github.com/wfusion/gofusion@v1.1.14/common/infra/metrics/sink.go

package metrics

import (
	"fmt"
	"net/url"

	"github.com/wfusion/gofusion/common/utils"
)

// The MetricSink interface is used to transmit metrics information
// to an external system
type MetricSink interface {
	// SetGauge A Gauge should retain the last value it is set to
	SetGauge(key []string, val float32, opts ...utils.OptionExtender)
	SetGaugeWithLabels(key []string, val float32, labels []Label, opts ...utils.OptionExtender)

	// EmitKey Should emit a Key/Value pair for each call
	EmitKey(key []string, val float32, opts ...utils.OptionExtender)

	// IncrCounter should accumulate values
	IncrCounter(key []string, val float32, opts ...utils.OptionExtender)
	IncrCounterWithLabels(key []string, val float32, labels []Label, opts ...utils.OptionExtender)

	// AddSample are for timing information, where quantiles are used
	AddSample(key []string, val float32, opts ...utils.OptionExtender)
	AddSampleWithLabels(key []string, val float32, labels []Label, opts ...utils.OptionExtender)
}

// PrecisionGaugeMetricSink interface is used to support 64 bit precisions for Sinks, if needed.
type PrecisionGaugeMetricSink interface {
	SetPrecisionGauge(key []string, val float64, opts ...utils.OptionExtender)
	SetPrecisionGaugeWithLabels(key []string, val float64, labels []Label, opts ...utils.OptionExtender)
}

// PrecisionSampleMetricSink interface is used to support 64 bit precisions for Sinks, if needed.
type PrecisionSampleMetricSink interface {
	AddPrecisionSample(key []string, val float64, opts ...utils.OptionExtender)
	AddPrecisionSampleWithLabels(key []string, val float64, labels []Label, opts ...utils.OptionExtender)
}

type ShutdownSink interface {
	MetricSink

	// Shutdown the metric sink, flush metrics to storage, and cleanup resources.
	// Called immediately prior to application exit. Implementations must block
	// until metrics are flushed to storage.
	Shutdown()
}

// BlackholeSink is used to just blackhole messages
type BlackholeSink struct{}

func (*BlackholeSink) SetGauge(key []string, val float32, opts ...utils.OptionExtender) {
}
func (*BlackholeSink) SetGaugeWithLabels(key []string, val float32, labels []Label, opts ...utils.OptionExtender) {
}
func (*BlackholeSink) SetPrecisionGauge(key []string, val float64, opts ...utils.OptionExtender) {
}
func (*BlackholeSink) SetPrecisionGaugeWithLabels(key []string, val float64, labels []Label,
	opts ...utils.OptionExtender) {
}
func (*BlackholeSink) EmitKey(key []string, val float32, opts ...utils.OptionExtender) {
}
func (*BlackholeSink) IncrCounter(key []string, val float32, opts ...utils.OptionExtender) {
}
func (*BlackholeSink) IncrCounterWithLabels(key []string, val float32, labels []Label, opts ...utils.OptionExtender) {
}
func (*BlackholeSink) AddSample(key []string, val float32, opts ...utils.OptionExtender) {
}
func (*BlackholeSink) AddSampleWithLabels(key []string, val float32, labels []Label, opts ...utils.OptionExtender) {
}

// FanoutSink is used to sink to fanout values to multiple sinks
type FanoutSink []MetricSink

func (fh FanoutSink) SetGauge(key []string, val float32, opts ...utils.OptionExtender) {
	fh.SetGaugeWithLabels(key, val, nil)
}

func (fh FanoutSink) SetGaugeWithLabels(key []string, val float32, labels []Label, opts ...utils.OptionExtender) {
	for _, s := range fh {
		s.SetGaugeWithLabels(key, val, labels)
	}
}

func (fh FanoutSink) SetPrecisionGauge(key []string, val float64, opts ...utils.OptionExtender) {
	fh.SetPrecisionGaugeWithLabels(key, val, nil)
}

func (fh FanoutSink) SetPrecisionGaugeWithLabels(key []string, val float64, labels []Label,
	opts ...utils.OptionExtender) {
	for _, s := range fh {
		// The Sink needs to implement PrecisionGaugeMetricSink,
		// in case it doesn't, the metric value won't be set and ignored instead
		if s64, ok := s.(PrecisionGaugeMetricSink); ok {
			s64.SetPrecisionGaugeWithLabels(key, val, labels)
		}
	}
}

func (fh FanoutSink) EmitKey(key []string, val float32, opts ...utils.OptionExtender) {
	for _, s := range fh {
		s.EmitKey(key, val)
	}
}

func (fh FanoutSink) IncrCounter(key []string, val float32, opts ...utils.OptionExtender) {
	fh.IncrCounterWithLabels(key, val, nil)
}

func (fh FanoutSink) IncrCounterWithLabels(key []string, val float32, labels []Label, opts ...utils.OptionExtender) {
	for _, s := range fh {
		s.IncrCounterWithLabels(key, val, labels)
	}
}

func (fh FanoutSink) AddSample(key []string, val float32, opts ...utils.OptionExtender) {
	fh.AddSampleWithLabels(key, val, nil)
}

func (fh FanoutSink) AddSampleWithLabels(key []string, val float32, labels []Label, opts ...utils.OptionExtender) {
	for _, s := range fh {
		s.AddSampleWithLabels(key, val, labels)
	}
}

func (fh FanoutSink) Shutdown() {
	for _, s := range fh {
		if ss, ok := s.(ShutdownSink); ok {
			ss.Shutdown()
		}
	}
}

// sinkURLFactoryFunc is a generic interface around the *SinkFromURL() function provided
// by each sink type
type sinkURLFactoryFunc func(*url.URL) (MetricSink, error)

// sinkRegistry supports the generic NewMetricSink function by mapping URL
// schemes to metric sink factory functions
var sinkRegistry = map[string]sinkURLFactoryFunc{
	"statsd":   NewStatsdSinkFromURL,
	"statsite": NewStatsiteSinkFromURL,
	"inmem":    NewInmemSinkFromURL,
}

// NewMetricSinkFromURL allows a generic URL input to configure any of the
// supported sinks. The scheme of the URL identifies the type of the sink, the
// and query parameters are used to set options.
//
// "statsd://" - Initializes a StatsdSink. The host and port are passed through
// as the "addr" of the sink
//
// "statsite://" - Initializes a StatsiteSink. The host and port become the
// "addr" of the sink
//
// "inmem://" - Initializes an InmemSink. The host and port are ignored. The
// "interval" and "duration" query parameters must be specified with valid
// durations, see NewInmemSink for details.
func NewMetricSinkFromURL(urlStr string) (MetricSink, error) {
	u, err := url.Parse(urlStr)
	if err != nil {
		return nil, err
	}

	sinkURLFactoryFunc := sinkRegistry[u.Scheme]
	if sinkURLFactoryFunc == nil {
		return nil, fmt.Errorf(
			"cannot create metric sink, unrecognized sink name: %q", u.Scheme)
	}

	return sinkURLFactoryFunc(u)
}

type Option struct {
	Buckets   []float64
	Precision bool
}

func Precision() utils.OptionFunc[Option] {
	return func(o *Option) {
		o.Precision = true
	}
}