Files
mtusi2026lab6/app/internal/telemetry/database.go
T

99 lines
3.0 KiB
Go

package telemetry
import (
"context"
"os"
"runtime"
"strconv"
"strings"
"sync/atomic"
"syscall"
"github.com/jackc/pgx/v5"
"github.com/jackc/pgx/v5/pgxpool"
"go.opentelemetry.io/otel"
"go.opentelemetry.io/otel/attribute"
"go.opentelemetry.io/otel/codes"
"go.opentelemetry.io/otel/metric"
"go.opentelemetry.io/otel/trace"
)
// No SQL, parameters, DSN or exception messages are recorded.
type DBTracer struct{ Waiting atomic.Int64 }
func (t *DBTracer) TraceQueryStart(ctx context.Context, _ *pgx.Conn, d pgx.TraceQueryStartData) context.Context {
op := "query"
fields := strings.Fields(d.SQL)
if len(fields) > 0 {
switch strings.ToUpper(fields[0]) {
case "SELECT", "INSERT", "UPDATE", "DELETE", "BEGIN", "COMMIT", "ROLLBACK":
op = strings.ToUpper(fields[0])
}
}
ctx, _ = otel.Tracer("messenger").Start(ctx, "db."+op, trace.WithSpanKind(trace.SpanKindClient), trace.WithAttributes(attribute.String("db.system.name", "postgresql")))
return ctx
}
func (t *DBTracer) TraceQueryEnd(ctx context.Context, _ *pgx.Conn, d pgx.TraceQueryEndData) {
s := trace.SpanFromContext(ctx)
defer s.End()
if d.Err != nil && d.Err != pgx.ErrNoRows {
s.SetStatus(codes.Error, "database query failed")
s.SetAttributes(attribute.String("error.type", "database_error"))
}
}
func (t *DBTracer) TraceAcquireStart(ctx context.Context, _ *pgxpool.Pool, _ pgxpool.TraceAcquireStartData) context.Context {
t.Waiting.Add(1)
return ctx
}
func (t *DBTracer) TraceAcquireEnd(_ context.Context, _ *pgxpool.Pool, _ pgxpool.TraceAcquireEndData) {
t.Waiting.Add(-1)
}
func WatchPool(pool *pgxpool.Pool, tracer *DBTracer) error {
meter := otel.Meter("messenger")
used, err := meter.Int64ObservableGauge("db_pool_used")
if err != nil {
return err
}
waiting, err := meter.Int64ObservableGauge("db_pool_waiting")
if err != nil {
return err
}
capacity, err := meter.Int64ObservableGauge("db_pool_capacity")
if err != nil {
return err
}
cpu, err := meter.Float64ObservableCounter("process_cpu", metric.WithUnit("s"))
if err != nil {
return err
}
ram, err := meter.Int64ObservableGauge("process_memory", metric.WithUnit("By"))
if err != nil {
return err
}
_, err = meter.RegisterCallback(func(_ context.Context, o metric.Observer) error {
st := pool.Stat()
o.ObserveInt64(used, int64(st.AcquiredConns()))
o.ObserveInt64(waiting, tracer.Waiting.Load())
o.ObserveInt64(capacity, int64(st.MaxConns()))
var usage syscall.Rusage
if syscall.Getrusage(syscall.RUSAGE_SELF, &usage) == nil {
o.ObserveFloat64(cpu, float64(usage.Utime.Sec+usage.Stime.Sec)+float64(usage.Utime.Usec+usage.Stime.Usec)/1e6)
}
var mem runtime.MemStats
runtime.ReadMemStats(&mem)
rss := int64(mem.Sys)
if data, e := os.ReadFile("/proc/self/statm"); e == nil {
f := strings.Fields(string(data))
if len(f) > 1 {
if pages, e := strconv.ParseInt(f[1], 10, 64); e == nil {
rss = pages * int64(os.Getpagesize())
}
}
}
o.ObserveInt64(ram, rss)
return nil
}, used, waiting, capacity, cpu, ram)
return err
}