95 lines
2.7 KiB
Go
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
|
|
}
|