feat: make metrics build specific

instrumentation/opentelemetry/internal/metrics/metrics.go

@@ -0,0 +1,67 @@
+package metrics
+
+import (
+	"context"
+	"fmt"
+	"go.opentelemetry.io/otel"
+	"go.opentelemetry.io/otel/metric"
+	"log"
+)
+
+const meterName = "goagent.hypertrace.org/metrics"
+
+type systemMetrics interface {
+	getMemory() (float64, error)
+	getCPU() (float64, error)
+	getCurrentMetrics() error
+}
+
+func InitializeSystemMetrics() {
+	meterProvider := otel.GetMeterProvider()
+	meter := meterProvider.Meter(meterName)
+	err := setUpMetricRecorder(meter)
+	if err != nil {
+		log.Printf("error initializing metrics, failed to setup metric recorder: %v\n", err)
+	}
+}
+
+func setUpMetricRecorder(meter metric.Meter) error {
+	if meter == nil {
+		return fmt.Errorf("error while setting up metric recorder: meter is nil")
+	}
+	cpuSeconds, err := meter.Float64ObservableCounter("hypertrace.agent.cpu.seconds.total", metric.WithDescription("Metric to monitor total CPU seconds"))
+	if err != nil {
+		return fmt.Errorf("error while setting up cpu seconds metric counter: %v", err)
+	}
+	memory, err := meter.Float64ObservableGauge("hypertrace.agent.memory", metric.WithDescription("Metric to monitor memory usage"))
+	if err != nil {
+		return fmt.Errorf("error while setting up memory metric counter: %v", err)
+	}
+	// Register the callback function for both cpu_seconds and memory observable gauges
+	_, err = meter.RegisterCallback(
+		func(ctx context.Context, result metric.Observer) error {
+			sysMetrics := newSystemMetrics()
+			err := sysMetrics.getCurrentMetrics()
+			if err != nil {
+				return err
+			}
+			cpus, err := sysMetrics.getCPU()
+			if err != nil {
+				return err
+			}
+			mem, err := sysMetrics.getMemory()
+			if err != nil {
+				return err
+			}
+			result.ObserveFloat64(cpuSeconds, cpus)
+			result.ObserveFloat64(memory, mem)
+			return nil
+		},
+		cpuSeconds, memory,
+	)
+	if err != nil {
+		log.Fatalf("failed to register callback: %v", err)
+		return err
+	}
+	return nil
+}

instrumentation/opentelemetry/internal/metrics/metricsImpl.go

@@ -0,0 +1,100 @@
+//go:build linux
+
+package metrics
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+	"strconv"
+	"strings"
+
+	"github.com/tklauser/go-sysconf"
+)
+
+const procStatArrayLength = 52
+
+var (
+	clkTck   = getClockTicks()
+	pageSize = float64(os.Getpagesize())
+)
+
+type processStats struct {
+	utime  float64
+	stime  float64
+	cutime float64
+	cstime float64
+	rss    float64
+}
+
+type linuxMetrics struct {
+	memory          float64
+	cpuSecondsTotal float64
+}
+
+func newSystemMetrics() systemMetrics {
+	return &linuxMetrics{}
+}
+
+func (lm *linuxMetrics) getCurrentMetrics() error {
+	stats, err := lm.processStatsFromPid(os.Getpid())
+	if err != nil {
+		return err
+	}
+	lm.memory = stats.rss * pageSize
+	lm.cpuSecondsTotal = (stats.stime + stats.utime + stats.cstime + stats.cutime) / clkTck
+	return nil
+}
+
+func (lm *linuxMetrics) getMemory() (float64, error) {
+	return lm.memory, nil
+}
+
+func (lm *linuxMetrics) getCPU() (float64, error) {
+	return lm.cpuSecondsTotal, nil
+}
+
+func (lm *linuxMetrics) processStatsFromPid(pid int) (*processStats, error) {
+	procFilepath := filepath.Join("/proc", strconv.Itoa(pid), "stat")
+	var err error
+	if procStatFileBytes, err := os.ReadFile(filepath.Clean(procFilepath)); err == nil {
+		if stat, err := lm.parseProcStatFile(procStatFileBytes, procFilepath); err == nil {
+			if err != nil {
+				return nil, err
+			}
+			return stat, nil
+		}
+		return nil, err
+	}
+	return nil, err
+}
+
+// ref: /proc/pid/stat section of https://man7.org/linux/man-pages/man5/proc.5.html
+func (lm *linuxMetrics) parseProcStatFile(bytesArr []byte, procFilepath string) (*processStats, error) {
+	infos := strings.Split(string(bytesArr), " ")
+	if len(infos) != procStatArrayLength {
+		return nil, fmt.Errorf("%s file could not be parsed", procFilepath)
+	}
+	return &processStats{
+		utime:  parseFloat(infos[13]),
+		stime:  parseFloat(infos[14]),
+		cutime: parseFloat(infos[15]),
+		cstime: parseFloat(infos[16]),
+		rss:    parseFloat(infos[23]),
+	}, nil
+}
+
+func parseFloat(val string) float64 {
+	floatVal, _ := strconv.ParseFloat(val, 64)
+	return floatVal
+}
+
+// sysconf for go. claims to work without cgo or external binaries
+// https://pkg.go.dev/github.com/tklauser/go-sysconf@v0.3.14#section-readme
+func getClockTicks() float64 {
+	clktck, err := sysconf.Sysconf(sysconf.SC_CLK_TCK)
+	if err != nil {
+		return float64(100)
+	}
+	return float64(clktck)
+}

instrumentation/opentelemetry/internal/metrics/metricsNoop.go

@@ -0,0 +1,21 @@
+//go:build !linux
+
+package metrics
+
+type noopMetrics struct{}
+
+func newSystemMetrics() systemMetrics {
+	return &noopMetrics{}
+}
+
+func (nm *noopMetrics) getMemory() (float64, error) {
+	return 0, nil
+}
+
+func (nm *noopMetrics) getCPU() (float64, error) {
+	return 0, nil
+}
+
+func (nm *noopMetrics) getCurrentMetrics() error {
+	return nil
+}