Merge pull request #23 from InjectiveLabs/f/v2

feat: v2 direction

Author: hmoragrega

client.go

@@ -39,6 +39,10 @@ var (
 	mixPanelClient          *mixpanel.ApiClient
 )
 
+func Tracer() trace.Tracer {
+	return tracer
+}
+
 type StatterConfig struct {
 	Addr                   string            // localhost:8125
 	Prefix                 string            // metrics prefix

go.mod

@@ -29,7 +29,7 @@ require (
 	cosmossdk.io/depinject v1.0.0-alpha.4 // indirect
 	cosmossdk.io/errors v1.0.1 // indirect
 	cosmossdk.io/log v1.3.1 // indirect
-	cosmossdk.io/math v1.3.0 // indirect
+	cosmossdk.io/math v1.5.3 // indirect
 	cosmossdk.io/store v1.1.0 // indirect
 	cosmossdk.io/x/tx v0.13.2 // indirect
 	github.com/DataDog/appsec-internal-go v1.5.0 // indirect

go.sum

@@ -10,8 +10,8 @@ cosmossdk.io/errors v1.0.1 h1:bzu+Kcr0kS/1DuPBtUFdWjzLqyUuCiyHjyJB6srBV/0=
 cosmossdk.io/errors v1.0.1/go.mod h1:MeelVSZThMi4bEakzhhhE/CKqVv3nOJDA25bIqRDu/U=
 cosmossdk.io/log v1.3.1 h1:UZx8nWIkfbbNEWusZqzAx3ZGvu54TZacWib3EzUYmGI=
 cosmossdk.io/log v1.3.1/go.mod h1:2/dIomt8mKdk6vl3OWJcPk2be3pGOS8OQaLUM/3/tCM=
-cosmossdk.io/math v1.3.0 h1:RC+jryuKeytIiictDslBP9i1fhkVm6ZDmZEoNP316zE=
-cosmossdk.io/math v1.3.0/go.mod h1:vnRTxewy+M7BtXBNFybkuhSH4WfedVAAnERHgVFhp3k=
+cosmossdk.io/math v1.5.3 h1:WH6tu6Z3AUCeHbeOSHg2mt9rnoiUWVWaQ2t6Gkll96U=
+cosmossdk.io/math v1.5.3/go.mod h1:uqcZv7vexnhMFJF+6zh9EWdm/+Ylyln34IvPnBauPCQ=
 cosmossdk.io/store v1.1.0 h1:LnKwgYMc9BInn9PhpTFEQVbL9UK475G2H911CGGnWHk=
 cosmossdk.io/store v1.1.0/go.mod h1:oZfW/4Fc/zYqu3JmQcQdUJ3fqu5vnYTn3LZFFy8P8ng=
 cosmossdk.io/x/tx v0.13.2 h1:Kh90UH30bhnnUdJH+CmWLyaH8IKdY6BBGY3EkdOk82o=

metrics.go

@@ -7,6 +7,7 @@ import (
 	"runtime"
 	"strconv"
 	"strings"
+	"sync/atomic"
 	"time"
 
 	log "github.com/InjectiveLabs/suplog"
@@ -165,26 +166,28 @@ func reportTiming(ctx context.Context, fn string, tags ...Tags) (context.Context
 	tagArray = append(tagArray, getSingleTag("func_name", fn))
 
 	doneC := make(chan struct{})
-	go func(name string, start time.Time) {
-		timeout := time.NewTimer(config.StuckFunctionTimeout)
-		defer timeout.Stop()
-
-		select {
-		case <-doneC:
-			return
-		case <-timeout.C:
-			clientMux.RLock()
-			defer clientMux.RUnlock()
-
-			err := fmt.Errorf("detected stuck function: %s stuck for %v", name, time.Since(start))
-			fmt.Println(err)
-			client.Incr("func.stuck", tagArray, 1)
-			if span != nil {
-				span.SetStatus(codes.Error, "stuck")
-				span.End()
+	if !disableStuckFuncReport.Load() {
+		go func(name string, start time.Time) {
+			timeout := time.NewTimer(config.StuckFunctionTimeout)
+			defer timeout.Stop()
+
+			select {
+			case <-doneC:
+				return
+			case <-timeout.C:
+				clientMux.RLock()
+				defer clientMux.RUnlock()
+
+				err := fmt.Errorf("detected stuck function: %s stuck for %v", name, time.Since(start))
+				fmt.Println(err)
+				client.Incr("func.stuck", tagArray, 1)
+				if span != nil {
+					span.SetStatus(codes.Error, "stuck")
+					span.End()
+				}
 			}
-		}
-	}(fn, t)
+		}(fn, t)
+	}
 
 	return spanCtx, func(stopTags ...Tags) {
 		d := time.Since(t)
@@ -212,21 +215,24 @@ func ReportClosureFuncTiming(name string, tags ...Tags) StopTimerFunc {
 	tagArray = append(tagArray, getSingleTag("func_name", name))
 
 	doneC := make(chan struct{})
-	go func(name string, start time.Time) {
-		timeout := time.NewTimer(config.StuckFunctionTimeout)
-		defer timeout.Stop()
-
-		select {
-		case <-doneC:
-			return
-		case <-timeout.C:
-			clientMux.RLock()
-			defer clientMux.RUnlock()
-
-			log.Warningf("detected stuck function: %s stuck for %v", name, time.Since(start))
-			client.Incr("func.stuck", tagArray, 1)
-		}
-	}(name, t)
+
+	if !disableStuckFuncReport.Load() {
+		go func(name string, start time.Time) {
+			timeout := time.NewTimer(config.StuckFunctionTimeout)
+			defer timeout.Stop()
+
+			select {
+			case <-doneC:
+				return
+			case <-timeout.C:
+				clientMux.RLock()
+				defer clientMux.RUnlock()
+
+				log.Warningf("detected stuck function: %s stuck for %v", name, time.Since(start))
+				client.Incr("func.stuck", tagArray, 1)
+			}
+		}(name, t)
+	}
 
 	return func(stopTags ...Tags) {
 		d := time.Since(t)
@@ -432,65 +438,108 @@ func ToString(i interface{}) (v string, ok bool) {
 	case float64:
 		v = strconv.FormatFloat(x, 'f', -1, 64)
 	case *string:
-		if x != nil {
+		if x == nil {
+			v = "nil"
+		} else {
 			v = *x
 		}
 	case *int:
-		if x != nil {
+		if x == nil {
+			v = "nil"
+		} else {
 			v = strconv.FormatInt(int64(*x), 10)
 		}
 	case *int8:
-		if x != nil {
+		if x == nil {
+			v = "nil"
+		} else {
 			v = strconv.FormatInt(int64(*x), 10)
 		}
 	case *int16:
-		if x != nil {
+		if x == nil {
+			v = "nil"
+		} else {
 			v = strconv.FormatInt(int64(*x), 10)
 		}
 	case *int32:
-		if x != nil {
+		if x == nil {
+			v = "nil"
+		} else {
 			v = strconv.FormatInt(int64(*x), 10)
 		}
 	case *int64:
-		if x != nil {
+		if x == nil {
+			v = "nil"
+		} else {
 			v = strconv.FormatInt(*x, 10)
 		}
 	case *uint:
-		if x != nil {
+		if x == nil {
+			v = "nil"
+		} else {
 			v = strconv.FormatUint(uint64(*x), 10)
 		}
 	case *uint8:
-		if x != nil {
+		if x == nil {
+			v = "nil"
+		} else {
 			v = strconv.FormatUint(uint64(*x), 10)
 		}
 	case *uint16:
-		if x != nil {
+		if x == nil {
+			v = "nil"
+		} else {
 			v = strconv.FormatUint(uint64(*x), 10)
 		}
 	case *uint32:
-		if x != nil {
+		if x == nil {
+			v = "nil"
+		} else {
 			v = strconv.FormatUint(uint64(*x), 10)
 		}
 	case *uint64:
-		if x != nil {
+		if x == nil {
+			v = "nil"
+		} else {
 			v = strconv.FormatUint(*x, 10)
 		}
 	case *float32:
-		if x != nil {
+		if x == nil {
+			v = "nil"
+		} else {
 			v = strconv.FormatFloat(float64(*x), 'f', -1, 32)
 		}
 	case *float64:
-		if x != nil {
+		if x == nil {
+			v = "nil"
+		} else {
 			v = strconv.FormatFloat(*x, 'f', -1, 64)
 		}
 	case bool:
 		v = strconv.FormatBool(x)
 	case *bool:
-		v = strconv.FormatBool(*x)
+		if x == nil {
+			v = "nil"
+		} else {
+			v = strconv.FormatBool(*x)
+		}
+	case fmt.Stringer:
+		rv := reflect.ValueOf(x)
+		if rv.Kind() == reflect.Ptr && rv.IsNil() {
+			v = "nil"
+		} else {
+			v = x.String()
+		}
 	case nil:
 		v = "nil"
 	default:
 		ok = false
 	}
 	return v, ok
 }
+
+var disableStuckFuncReport atomic.Bool
+
+func DisableStuckFuncReport() {
+	disableStuckFuncReport.Store(true)
+}

metrics_test.go

@@ -93,6 +93,10 @@ func TestToString(t *testing.T) {
 		{"*float32", func() *float32 { f := float32(42.42); return &f }(), "42.42", true},
 		{"*float64", func() *float64 { f := float64(42.42); return &f }(), "42.42", true},
 		{"*bool", func() *bool { b := true; return &b }(), "true", true},
+		{"nil *string", (*string)(nil), "nil", true},
+		{"nil *int", (*int)(nil), "nil", true},
+		{"nil *bool", (*bool)(nil), "nil", true},
+		{"stringer", stringerTag("custom"), "tag:custom", true},
 		{"nil", nil, "nil", true},
 		{"unsupported type", struct{}{}, "", false},
 	}
@@ -106,6 +110,12 @@ func TestToString(t *testing.T) {
 	}
 }
 
+type stringerTag string
+
+func (t stringerTag) String() string {
+	return "tag:" + string(t)
+}
+
 func record(t *testing.T) *statterRecorder {
 	t.Helper()
 	var rec statterRecorder

otel.go

@@ -5,6 +5,7 @@ import (
 	"fmt"
 	"strings"
 	"sync"
+	"sync/atomic"
 	"time"
 
 	"go.opentelemetry.io/otel"
@@ -17,11 +18,23 @@ import (
 	sdktrace "go.opentelemetry.io/otel/sdk/trace"
 )
 
+var (
+	useOTelCounters atomic.Bool
+)
+
+// ForceOTelCounters enables monotonic OTel counters for otelStatter instances
+// created after this call. Call it before creating statters to change the
+// global default.
+func ForceOTelCounters() {
+	useOTelCounters.Store(true)
+}
+
 type otelStatter struct {
-	meter         otelmetric.Meter
-	meterProvider *sdkmetric.MeterProvider
-	prefix        string
-	useCounters   bool
+	meter                    otelmetric.Meter
+	meterProvider            *sdkmetric.MeterProvider
+	prefix                   string
+	useCounters              bool
+	effectiveUseOTelCounters bool
 
 	mu             sync.RWMutex
 	counters       map[string]otelmetric.Int64Counter
@@ -30,6 +43,10 @@ type otelStatter struct {
 	histograms     map[string]otelmetric.Float64Histogram
 }
 
+func (s *otelStatter) shouldUseOTelCounters() bool {
+	return s.effectiveUseOTelCounters
+}
+
 func newOTELResource(baseTags []string) *resource.Resource {
 	attrs := []attribute.KeyValue{}
 	for _, tag := range baseTags {
@@ -70,14 +87,15 @@ func newOTELStatter(endpoint, prefix string, insecure bool, headers map[string]s
 	otel.SetMeterProvider(mp)
 
 	return &otelStatter{
-		meter:          mp.Meter(prefix),
-		meterProvider:  mp,
-		prefix:         prefix,
-		useCounters:    useCounters,
-		counters:       make(map[string]otelmetric.Int64Counter),
-		updownCounters: make(map[string]otelmetric.Int64UpDownCounter),
-		gauges:         make(map[string]otelmetric.Float64Gauge),
-		histograms:     make(map[string]otelmetric.Float64Histogram),
+		meter:                    mp.Meter(prefix),
+		meterProvider:            mp,
+		prefix:                   prefix,
+		useCounters:              useCounters,
+		effectiveUseOTelCounters: useCounters || useOTelCounters.Load(),
+		counters:                 make(map[string]otelmetric.Int64Counter),
+		updownCounters:           make(map[string]otelmetric.Int64UpDownCounter),
+		gauges:                   make(map[string]otelmetric.Float64Gauge),
+		histograms:               make(map[string]otelmetric.Float64Histogram),
 	}, nil
 }
 
@@ -204,7 +222,7 @@ func (s *otelStatter) getHistogram(name string) (otelmetric.Float64Histogram, er
 }
 
 func (s *otelStatter) Count(name string, value int64, tags []string, rate float64) error {
-	if s.useCounters {
+	if s.shouldUseOTelCounters() {
 		if value < 0 {
 			return fmt.Errorf("counter value must be non-negative")
 		}
@@ -224,7 +242,7 @@ func (s *otelStatter) Count(name string, value int64, tags []string, rate float6
 }
 
 func (s *otelStatter) Incr(name string, tags []string, rate float64) error {
-	if s.useCounters {
+	if s.shouldUseOTelCounters() {
 		c, err := s.getCounter(name)
 		if err != nil {
 			return err