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 }