synapsecns/sanguine

package metrics

import (
    "context"
    "fmt"
    "net/http"
    "os"
    "strings"

    "github.com/gin-gonic/gin"
    "github.com/synapsecns/sanguine/core/config"
    experimentalLogger "github.com/synapsecns/sanguine/core/metrics/logger"
    "go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp"
    "go.opentelemetry.io/otel/metric"
    "go.opentelemetry.io/otel/propagation"
    "go.opentelemetry.io/otel/trace"
    "gorm.io/gorm"
)

// Handler collects metrics.
type Handler interface {
    Start(ctx context.Context) error
    // Gin gets all gin middlewares for tracing.
    Gin() []gin.HandlerFunc
    // ConfigureHTTPClient configures tracing on an http client
    ConfigureHTTPClient(client *http.Client, opts ...otelhttp.Option)
    // AddGormCallbacks adds gorm callbacks for tracing.
    AddGormCallbacks(db *gorm.DB)
    // GetTracerProvider returns the tracer provider.
    GetTracerProvider() trace.TracerProvider
    // Tracer returns the tracer provider.
    Tracer() trace.Tracer
    // Propagator returns the propagator.
    Propagator() propagation.TextMapPropagator
    // Type returns the handler type.
    Type() HandlerType
    // Metrics returns a metric provider
    // Deprecated: Will be removed in a future version please use meter.
    Metrics() Meter
    // Meter returns a metric provider
    Meter(name string, options ...metric.MeterOption) metric.Meter
    // Handler returns the http handler for the metrics endpoint.
    // right now, this supports only a single route
    Handler() http.Handler
    // ExperimentalLogger returns an experimental logger.
    ExperimentalLogger() experimentalLogger.ExperimentalLogger
}

// HandlerType is the handler type to use
//
//go:generate go run golang.org/x/tools/cmd/stringer -type=HandlerType -linecomment
type HandlerType uint8

// AllHandlerTypes is a list of all contract types. Since we use stringer and this is a testing library, instead
// of manually copying all these out we pull the names out of stringer. In order to make sure stringer is updated, we panic on
// any method called where the index is higher than the stringer array length.
var AllHandlerTypes []HandlerType

func init() {
    for i := 0; i < len(_HandlerType_index); i++ {
        contractType := HandlerType(i)
        AllHandlerTypes = append(AllHandlerTypes, contractType)
    }
}

const (
    // OTLP is the otlp driver.
    OTLP HandlerType = iota + 1 // OTLP
    // Jaeger is the jaeger driver.
    Jaeger // Jaeger
    // Null is a null data type handler.
    Null // Null
)

// Lower gets the lowercase version of the handler type. Useful for comparison
// in switch.
func (i HandlerType) Lower() string {
    return strings.ToLower(i.String())
}

// HandlerEnv is the driver to use for metrics.
const HandlerEnv = "METRICS_HANDLER"

// NewFromEnv sets up a metrics handler from environment variable.
// this will not set the global and generally, SetupFromEnv should be used instead.
func NewFromEnv(ctx context.Context, buildInfo config.BuildInfo) (handler Handler, err error) {
    metricsHandler := strings.ToLower(os.Getenv(HandlerEnv))
    var ht HandlerType
    //nolint: gocritic
    switch metricsHandler {
    case OTLP.Lower():
        ht = OTLP
    case Jaeger.Lower():
        ht = Jaeger
    case Null.Lower():
        ht = Null
    default:
        ht = Null
    }

    return NewByType(ctx, buildInfo, ht)
}

// NewByType sets up a metrics handler by type.
func NewByType(ctx context.Context, buildInfo config.BuildInfo, ht HandlerType) (handler Handler, err error) {
    //nolint: gocritic
    switch ht {
    case OTLP:
        handler = NewOTLPMetricsHandler(buildInfo)
    case Jaeger:
        handler = NewJaegerHandler(buildInfo)
    case Null:
        handler = NewNullHandler()
    default:
        handler = NewNullHandler()
    }

    if handler != nil {
        err = handler.Start(ctx)
        if err != nil {
            return nil, fmt.Errorf("could not start handler: %w", err)
        }
    }

    return handler, nil
}