forked from mtusi2026/mtusi2026lab6
99 lines
3.0 KiB
Go
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
|
|
}
|