synapsecns/sanguine

package metrics

import (
    "context"
    "github.com/gin-gonic/gin"
    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/metric/noop"
    "go.opentelemetry.io/otel/propagation"
    "go.opentelemetry.io/otel/trace"
    "gorm.io/gorm"
    "net/http"
)

// nullHandler is a metrics handler that does nothing.
// it is used to allow metrics collection to be skipped.
type nullHandler struct {
    tracer     trace.Tracer
    propagator nullPropogator
    meter      Meter
}

func (n nullHandler) ExperimentalLogger() experimentalLogger.ExperimentalLogger {
    return experimentalLogger.NewNullLogger()
}

func (n nullHandler) Meter(name string, options ...metric.MeterOption) metric.Meter {
    return noop.Meter{}
}

func (n nullHandler) Handler() http.Handler {
    return noopHandler{}
}

func (n nullHandler) Type() HandlerType {
    return Null
}

func (n nullHandler) Propagator() propagation.TextMapPropagator {
    return n.propagator
}

func (n nullHandler) GetTracerProvider() trace.TracerProvider {
    return trace.NewNoopTracerProvider()
}

func (n nullHandler) Tracer() trace.Tracer {
    return n.tracer
}

func (n nullHandler) AddGormCallbacks(db *gorm.DB) {
    // Do nothing
}

func (n nullHandler) ConfigureHTTPClient(client *http.Client, opts ...otelhttp.Option) {
    // Do nothing
}

func (n nullHandler) Gin() []gin.HandlerFunc {
    return []gin.HandlerFunc{}
}

func (n nullHandler) Start(_ context.Context) error {
    return nil
}
func (n nullHandler) Metrics() Meter {
    return n.meter
}

// NewNullHandler creates a new null transaction handler.
func NewNullHandler() Handler {
    return &nullHandler{
        tracer:     trace.NewNoopTracerProvider().Tracer(""),
        propagator: nullPropogator{},
        meter:      &NullMeterImpl{},
    }
}

var _ Handler = &nullHandler{}

// nullPropogator is a metrics propagator that does nothing.
type nullPropogator struct{}

func (n nullPropogator) Inject(ctx context.Context, carrier propagation.TextMapCarrier) {
}

func (n nullPropogator) Extract(ctx context.Context, _ propagation.TextMapCarrier) context.Context {
    return ctx
}

func (n nullPropogator) Fields() []string {
    return []string{}
}

var _ propagation.TextMapPropagator = &nullPropogator{}

// noopHandler is an http handler that does nothing.
type noopHandler struct{}

func (n noopHandler) ServeHTTP(_ http.ResponseWriter, _ *http.Request) {
    // Do nothing
}

var _ http.Handler = noopHandler{}