Files
mtusi2026lab6/src/backend/telemetry/capacity.go
T

95 lines
2.7 KiB
Go

package telemetry
import (
"context"
"go.opentelemetry.io/otel/attribute"
"os"
"strconv"
"strings"
"syscall"
"time"
"github.com/jackc/pgx/v5/pgxpool"
"go.opentelemetry.io/otel/metric"
)
func (s *Signals) ObservePool(pool *pgxpool.Pool) error {
if s == nil {
return nil
}
used, err := s.meter.Int64ObservableGauge("messenger.db.pool.used")
if err != nil {
return err
}
capacity, err := s.meter.Int64ObservableGauge("messenger.db.pool.capacity")
if err != nil {
return err
}
waited, err := s.meter.Int64ObservableCounter("messenger.db.pool.waited")
if err != nil {
return err
}
_, err = s.meter.RegisterCallback(func(_ context.Context, observer metric.Observer) error {
stats := pool.Stat()
observer.ObserveInt64(used, int64(stats.AcquiredConns()))
observer.ObserveInt64(capacity, int64(stats.MaxConns()))
observer.ObserveInt64(waited, stats.EmptyAcquireCount())
return nil
}, used, capacity, waited)
return err
}
func (s *Signals) ObserveBacklog(read func(context.Context) (int64, float64, error)) error {
if s == nil {
return nil
}
depth, err := s.meter.Int64ObservableGauge("messenger.queue.depth")
if err != nil {
return err
}
age, err := s.meter.Float64ObservableGauge("messenger.queue.oldest", metric.WithUnit("s"))
if err != nil {
return err
}
_, err = s.meter.RegisterCallback(func(ctx context.Context, observer metric.Observer) error {
ctx, cancel := context.WithTimeout(ctx, time.Second)
defer cancel()
count, seconds, err := read(ctx)
if err == nil {
queue := metric.WithAttributes(attribute.String("queue.name", "attachments.v1"))
observer.ObserveInt64(depth, count, queue)
observer.ObserveFloat64(age, seconds, queue)
}
return nil
}, depth, age)
return err
}
// ObserveProcess exports Linux process CPU time and resident memory.
func (s *Signals) ObserveProcess() error {
cpu, err := s.meter.Float64ObservableCounter("messenger.process.cpu", metric.WithUnit("s"))
if err != nil {
return err
}
rss, err := s.meter.Int64ObservableGauge("messenger.process.rss", metric.WithUnit("By"))
if err != nil {
return err
}
_, err = s.meter.RegisterCallback(func(_ context.Context, observer metric.Observer) error {
var usage syscall.Rusage
if syscall.Getrusage(syscall.RUSAGE_SELF, &usage) == nil {
observer.ObserveFloat64(cpu, float64(usage.Utime.Nano()+usage.Stime.Nano())/float64(time.Second))
}
if data, err := os.ReadFile("/proc/self/statm"); err == nil {
fields := strings.Fields(string(data))
if len(fields) >= 2 {
if pages, err := strconv.ParseInt(fields[1], 10, 64); err == nil {
observer.ObserveInt64(rss, pages*int64(os.Getpagesize()))
}
}
}
return nil
}, cpu, rss)
return err
}