synapsecns/sanguine

package slackertrace

import (
    "context"
    "github.com/hedzr/log"
    "github.com/slack-io/slacker"
    "go.opentelemetry.io/otel"
    "go.opentelemetry.io/otel/attribute"
    "go.opentelemetry.io/otel/metric"
    "time"
)

const (
    instrumentationName    = "github.com/synapsecns/sanguine/core/metrics/instrumentation/slcakertracer"
    instrumentationVersion = "0.1.0"
)

// assumes method is only called once.
type otelRecorder struct {
    attemptsCounter       metric.Int64UpDownCounter
    totalDuration         metric.Int64Histogram
    activeRequestsCounter metric.Int64UpDownCounter
}

func newOtelRecorder() otelRecorder {
    otr := otelRecorder{}
    meter := otel.Meter(instrumentationName, metric.WithInstrumentationVersion(instrumentationVersion))

    // todo: make an option
    metricName := func(metricName string) string {
        return metricName
    }

    var err error
    otr.attemptsCounter, err = meter.Int64UpDownCounter(metricName("slacker.request_count"), metric.WithDescription("Number of Requests"), metric.WithUnit("Count"))
    if err != nil {
        log.Warnf("failed to create counter: %v", err)
    }
    otr.totalDuration, err = meter.Int64Histogram(metricName("slacker.duration"), metric.WithDescription("Time Taken by request"), metric.WithUnit("Milliseconds"))
    if err != nil {
        log.Warnf("failed to create histogram: %v", err)
    }

    otr.activeRequestsCounter, err = meter.Int64UpDownCounter("slacker.active_requests")
    if err != nil {
        log.Warnf("failed to create histogram: %v", err)
    }

    return otr
}

// AddRequests increments the number of requests being processed.
func (r *otelRecorder) AddRequests(ctx context.Context, quantity int64, attributes []attribute.KeyValue) {
    r.attemptsCounter.Add(ctx, quantity, metric.WithAttributes(attributes...))
}

// AddInflightRequests increments and decrements the number of inflight request being processed.
func (r *otelRecorder) AddInflightRequests(ctx context.Context, quantity int64, attributes []attribute.KeyValue) {
    r.activeRequestsCounter.Add(ctx, quantity, metric.WithAttributes(attributes...))
}

// ObserverCommandDuration measures the duration of an HTTP request.
func (r *otelRecorder) ObserverCommandDuration(ctx context.Context, duration time.Duration, attributes []attribute.KeyValue) {
    r.totalDuration.Record(ctx, int64(duration/time.Millisecond), metric.WithAttributes(attributes...))
}

// MetricsMiddleware returns a slacker middleware that records metrics for each command.
func MetricsMiddleware() slacker.CommandMiddlewareHandler {
    // assumes method is only called once.
    otr := newOtelRecorder()

    return func(next slacker.CommandHandler) slacker.CommandHandler {
        return func(cmdCtx *slacker.CommandContext) {
            attributes := []attribute.KeyValue{
                attribute.String("command", cmdCtx.Definition().Command),
            }
            start := time.Now()
            otr.AddInflightRequests(cmdCtx.Context(), 1, attributes)
            otr.AddRequests(cmdCtx.Context(), 1, attributes)
            defer func() {
                otr.AddInflightRequests(cmdCtx.Context(), -1, attributes)
            }()
            next(cmdCtx)
            otr.ObserverCommandDuration(cmdCtx.Context(), time.Since(start), attributes)
        }
    }
}