MM-34932: Bump dependencies (#17708)

https://mattermost.atlassian.net/browse/MM-34932

```release-note
NONE
```

vendor/github.com/splitio/go-split-commons/v3/synchronizer/local.go

@@ -1,10 +1,8 @@
 package synchronizer
 
 import (
-	"github.com/splitio/go-split-commons/v3/dtos"
-	"github.com/splitio/go-split-commons/v3/service"
+	"github.com/splitio/go-split-commons/v3/service/api"
 	"github.com/splitio/go-split-commons/v3/storage"
-	storageMock "github.com/splitio/go-split-commons/v3/storage/mocks"
 	"github.com/splitio/go-split-commons/v3/synchronizer/worker/split"
 	"github.com/splitio/go-split-commons/v3/tasks"
 	"github.com/splitio/go-toolkit/v4/logging"
@@ -12,30 +10,15 @@ import (
 
 // Local implements Local Synchronizer
 type Local struct {
-	splitTasks          SplitTasks
-	workers             Workers
-	logger              logging.LoggerInterface
-	inMememoryFullQueue chan string
+	splitTasks SplitTasks
+	workers    Workers
+	logger     logging.LoggerInterface
 }
 
 // NewLocal creates new Local
-func NewLocal(
-	period int,
-	splitAPI *service.SplitAPI,
-	splitStorage storage.SplitStorage,
-	logger logging.LoggerInterface,
-) Synchronizer {
-	metricStorageMock := storageMock.MockMetricStorage{
-		IncCounterCall:   func(key string) {},
-		IncLatencyCall:   func(metricName string, index int) {},
-		PopCountersCall:  func() []dtos.CounterDTO { return make([]dtos.CounterDTO, 0, 0) },
-		PopGaugesCall:    func() []dtos.GaugeDTO { return make([]dtos.GaugeDTO, 0, 0) },
-		PopLatenciesCall: func() []dtos.LatenciesDTO { return make([]dtos.LatenciesDTO, 0, 0) },
-		PutGaugeCall:     func(key string, gauge float64) {},
-	}
-	metricsWrapper := storage.NewMetricWrapper(metricStorageMock, nil, logger)
+func NewLocal(period int, splitAPI *api.SplitAPI, splitStorage storage.SplitStorage, logger logging.LoggerInterface, runtimeTelemetry storage.TelemetryRuntimeProducer) Synchronizer {
 	workers := Workers{
-		SplitFetcher: split.NewSplitFetcher(splitStorage, splitAPI.SplitFetcher, metricsWrapper, logger),
+		SplitFetcher: split.NewSplitFetcher(splitStorage, splitAPI.SplitFetcher, logger, runtimeTelemetry),
 	}
 	return &Local{
 		splitTasks: SplitTasks{

vendor/github.com/splitio/go-split-commons/v3/synchronizer/manager.go

@@ -6,9 +6,11 @@ import (
 	"time"
 
 	"github.com/splitio/go-split-commons/v3/conf"
+	"github.com/splitio/go-split-commons/v3/dtos"
 	"github.com/splitio/go-split-commons/v3/push"
 	"github.com/splitio/go-split-commons/v3/service"
 	"github.com/splitio/go-split-commons/v3/storage"
+	"github.com/splitio/go-split-commons/v3/telemetry"
 	"github.com/splitio/go-toolkit/v4/backoff"
 	"github.com/splitio/go-toolkit/v4/logging"
 	"github.com/splitio/go-toolkit/v4/struct/traits/lifecycle"
@@ -38,15 +40,16 @@ type Manager interface {
 
 // ManagerImpl struct
 type ManagerImpl struct {
-	synchronizer    Synchronizer
-	logger          logging.LoggerInterface
-	config          conf.AdvancedConfig
-	pushManager     push.Manager
-	managerStatus   chan int
-	streamingStatus chan int64
-	operationMode   int32
-	lifecycle       lifecycle.Manager
-	backoff         backoff.Interface
+	synchronizer     Synchronizer
+	logger           logging.LoggerInterface
+	config           conf.AdvancedConfig
+	pushManager      push.Manager
+	managerStatus    chan int
+	streamingStatus  chan int64
+	operationMode    int32
+	lifecycle        lifecycle.Manager
+	backoff          backoff.Interface
+	runtimeTelemetry storage.TelemetryRuntimeProducer
 }
 
 // NewSynchronizerManager creates new sync manager
@@ -57,22 +60,29 @@ func NewSynchronizerManager(
 	authClient service.AuthClient,
 	splitStorage storage.SplitStorage,
 	managerStatus chan int,
+	runtimeTelemetry storage.TelemetryRuntimeProducer,
+	metadata dtos.Metadata,
+	clientKey *string,
 ) (*ManagerImpl, error) {
 	if managerStatus == nil || cap(managerStatus) < 1 {
 		return nil, errors.New("Status channel cannot be nil nor having capacity")
 	}
 
 	manager := &ManagerImpl{
-		backoff:       backoff.New(),
-		synchronizer:  synchronizer,
-		logger:        logger,
-		config:        config,
-		managerStatus: managerStatus,
+		backoff:          backoff.New(),
+		synchronizer:     synchronizer,
+		logger:           logger,
+		config:           config,
+		managerStatus:    managerStatus,
+		runtimeTelemetry: runtimeTelemetry,
 	}
 	manager.lifecycle.Setup()
 	if config.StreamingEnabled {
 		streamingStatus := make(chan int64, 1000)
-		pushManager, err := push.NewManager(logger, synchronizer, &config, streamingStatus, authClient)
+		if clientKey != nil && len(*clientKey) != 4 {
+			return nil, errors.New("invalid ClientKey")
+		}
+		pushManager, err := push.NewManager(logger, synchronizer, &config, streamingStatus, authClient, runtimeTelemetry, metadata, clientKey)
 		if err != nil {
 			return nil, err
 		}
@@ -182,6 +192,8 @@ func (s *ManagerImpl) pushStatusWatcher() {
 				s.pushManager.Stop()
 				s.synchronizer.SyncAll(false)
 				s.startPolling()
+				// Tracking STREAMING_DISABLED
+				s.runtimeTelemetry.RecordStreamingEvent(telemetry.GetStreamingEvent(telemetry.EventTypeStreamingStatus, telemetry.StreamingDisabled))
 			}
 		}
 	}
@@ -190,6 +202,8 @@ func (s *ManagerImpl) pushStatusWatcher() {
 func (s *ManagerImpl) startPolling() {
 	atomic.StoreInt32(&s.operationMode, Polling)
 	s.synchronizer.StartPeriodicFetching()
+	// Tracking POLLING
+	s.runtimeTelemetry.RecordStreamingEvent(telemetry.GetStreamingEvent(telemetry.EventTypeSyncMode, telemetry.Polling))
 }
 
 func (s *ManagerImpl) stopPolling() {
@@ -198,10 +212,16 @@ func (s *ManagerImpl) stopPolling() {
 
 func (s *ManagerImpl) pauseStreaming() {
 	s.pushManager.StartWorkers()
+	// Tracking STREAMING_PAUSED
+	s.runtimeTelemetry.RecordStreamingEvent(telemetry.GetStreamingEvent(telemetry.EventTypeStreamingStatus, telemetry.StreamingPaused))
 }
 
 func (s *ManagerImpl) enableStreaming() {
 	s.pushManager.StartWorkers()
 	atomic.StoreInt32(&s.operationMode, Streaming)
 	s.backoff.Reset()
+	// Tracking STREAMING
+	s.runtimeTelemetry.RecordStreamingEvent(telemetry.GetStreamingEvent(telemetry.EventTypeSyncMode, telemetry.Streaming))
+	// Tracking STREAMING_ENABLED
+	s.runtimeTelemetry.RecordStreamingEvent(telemetry.GetStreamingEvent(telemetry.EventTypeStreamingStatus, telemetry.StreamingEnabled))
 }

vendor/github.com/splitio/go-split-commons/v3/synchronizer/synchronizer.go

@@ -5,10 +5,10 @@ import (
 	"github.com/splitio/go-split-commons/v3/synchronizer/worker/event"
 	"github.com/splitio/go-split-commons/v3/synchronizer/worker/impression"
 	"github.com/splitio/go-split-commons/v3/synchronizer/worker/impressionscount"
-	"github.com/splitio/go-split-commons/v3/synchronizer/worker/metric"
 	"github.com/splitio/go-split-commons/v3/synchronizer/worker/segment"
 	"github.com/splitio/go-split-commons/v3/synchronizer/worker/split"
 	"github.com/splitio/go-split-commons/v3/tasks"
+	"github.com/splitio/go-split-commons/v3/telemetry"
 	"github.com/splitio/go-toolkit/v4/asynctask"
 	"github.com/splitio/go-toolkit/v4/logging"
 )
@@ -27,7 +27,7 @@ type SplitTasks struct {
 type Workers struct {
 	SplitFetcher             split.Updater
 	SegmentFetcher           segment.Updater
-	TelemetryRecorder        metric.MetricRecorder
+	TelemetryRecorder        telemetry.TelemetrySynchronizer
 	ImpressionRecorder       impression.ImpressionRecorder
 	EventRecorder            event.EventRecorder
 	ImpressionsCountRecorder impressionscount.ImpressionsCountRecorder
@@ -62,7 +62,7 @@ func NewSynchronizer(
 }
 
 func (s *SynchronizerImpl) dataFlusher() {
-	for true {
+	for {
 		msg := <-s.inMememoryFullQueue
 		switch msg {
 		case "EVENTS_FULL":
@@ -71,7 +71,6 @@ func (s *SynchronizerImpl) dataFlusher() {
 			if err != nil {
 				s.logger.Error("Error flushing storage queue", err)
 			}
-			break
 		case "IMPRESSIONS_FULL":
 			s.logger.Debug("FLUSHING storage queue")
 			err := s.workers.ImpressionRecorder.SynchronizeImpressions(s.impressionBulkSize)
@@ -137,7 +136,7 @@ func (s *SynchronizerImpl) StopPeriodicDataRecording() {
 		s.splitTasks.ImpressionSyncTask.Stop(true)
 	}
 	if s.splitTasks.TelemetrySyncTask != nil {
-		s.splitTasks.TelemetrySyncTask.Stop(false)
+		s.splitTasks.TelemetrySyncTask.Stop(true)
 	}
 	if s.splitTasks.EventSyncTask != nil {
 		s.splitTasks.EventSyncTask.Stop(true)

vendor/github.com/splitio/go-split-commons/v3/synchronizer/worker/event/single.go

@@ -2,39 +2,38 @@ package event
 
 import (
 	"errors"
-	"strconv"
 	"time"
 
 	"github.com/splitio/go-split-commons/v3/dtos"
 	"github.com/splitio/go-split-commons/v3/service"
 	"github.com/splitio/go-split-commons/v3/storage"
-	"github.com/splitio/go-split-commons/v3/util"
+	"github.com/splitio/go-split-commons/v3/telemetry"
 	"github.com/splitio/go-toolkit/v4/logging"
 )
 
 // RecorderSingle struct for event sync
 type RecorderSingle struct {
-	eventStorage   storage.EventStorageConsumer
-	eventRecorder  service.EventsRecorder
-	metricsWrapper *storage.MetricWrapper
-	logger         logging.LoggerInterface
-	metadata       dtos.Metadata
+	eventStorage     storage.EventStorageConsumer
+	eventRecorder    service.EventsRecorder
+	logger           logging.LoggerInterface
+	metadata         dtos.Metadata
+	runtimeTelemetry storage.TelemetryRuntimeProducer
 }
 
 // NewEventRecorderSingle creates new event synchronizer for posting events
 func NewEventRecorderSingle(
 	eventStorage storage.EventStorageConsumer,
 	eventRecorder service.EventsRecorder,
-	metricsWrapper *storage.MetricWrapper,
 	logger logging.LoggerInterface,
 	metadata dtos.Metadata,
+	runtimeTelemetry storage.TelemetryRuntimeProducer,
 ) EventRecorder {
 	return &RecorderSingle{
-		eventStorage:   eventStorage,
-		eventRecorder:  eventRecorder,
-		metricsWrapper: metricsWrapper,
-		logger:         logger,
-		metadata:       metadata,
+		eventStorage:     eventStorage,
+		eventRecorder:    eventRecorder,
+		logger:           logger,
+		metadata:         metadata,
+		runtimeTelemetry: runtimeTelemetry,
 	}
 }
 
@@ -55,13 +54,12 @@ func (e *RecorderSingle) SynchronizeEvents(bulkSize int64) error {
 	err = e.eventRecorder.Record(queuedEvents, e.metadata)
 	if err != nil {
 		if httpError, ok := err.(*dtos.HTTPError); ok {
-			e.metricsWrapper.StoreCounters(storage.PostEventsCounter, strconv.Itoa(httpError.Code))
+			e.runtimeTelemetry.RecordSyncError(telemetry.EventSync, httpError.Code)
 		}
 		return err
 	}
-	bucket := util.Bucket(time.Now().Sub(before).Nanoseconds())
-	e.metricsWrapper.StoreLatencies(storage.PostEventsLatency, bucket)
-	e.metricsWrapper.StoreCounters(storage.PostEventsCounter, "ok")
+	e.runtimeTelemetry.RecordSyncLatency(telemetry.EventSync, time.Since(before).Nanoseconds())
+	e.runtimeTelemetry.RecordSuccessfulSync(telemetry.EventSync, time.Now().UTC().UnixNano()/int64(time.Millisecond))
 	return nil
 }
 

vendor/github.com/splitio/go-split-commons/v3/synchronizer/worker/impression/single.go

@@ -2,13 +2,13 @@ package impression
 
 import (
 	"errors"
-	"strconv"
 	"time"
 
 	"github.com/splitio/go-split-commons/v3/conf"
 	"github.com/splitio/go-split-commons/v3/dtos"
 	"github.com/splitio/go-split-commons/v3/service"
 	"github.com/splitio/go-split-commons/v3/storage"
+	"github.com/splitio/go-split-commons/v3/telemetry"
 	"github.com/splitio/go-split-commons/v3/util"
 	"github.com/splitio/go-toolkit/v4/logging"
 )
@@ -22,20 +22,20 @@ const (
 type RecorderSingle struct {
 	impressionStorage  storage.ImpressionStorageConsumer
 	impressionRecorder service.ImpressionsRecorder
-	metricsWrapper     *storage.MetricWrapper
 	logger             logging.LoggerInterface
 	metadata           dtos.Metadata
 	mode               string
+	runtimeTelemetry   storage.TelemetryRuntimeProducer
 }
 
 // NewRecorderSingle creates new impression synchronizer for posting impressions
 func NewRecorderSingle(
 	impressionStorage storage.ImpressionStorageConsumer,
 	impressionRecorder service.ImpressionsRecorder,
-	metricsWrapper *storage.MetricWrapper,
 	logger logging.LoggerInterface,
 	metadata dtos.Metadata,
 	managerConfig conf.ManagerConfig,
+	runtimeTelemetry storage.TelemetryRuntimeProducer,
 ) ImpressionRecorder {
 	mode := conf.ImpressionsModeOptimized
 	if !util.ShouldBeOptimized(managerConfig) {
@@ -44,10 +44,10 @@ func NewRecorderSingle(
 	return &RecorderSingle{
 		impressionStorage:  impressionStorage,
 		impressionRecorder: impressionRecorder,
-		metricsWrapper:     metricsWrapper,
 		logger:             logger,
 		metadata:           metadata,
 		mode:               mode,
+		runtimeTelemetry:   runtimeTelemetry,
 	}
 }
 
@@ -96,13 +96,12 @@ func (i *RecorderSingle) SynchronizeImpressions(bulkSize int64) error {
 	err = i.impressionRecorder.Record(bulkImpressions, i.metadata, map[string]string{splitSDKImpressionsMode: i.mode})
 	if err != nil {
 		if httpError, ok := err.(*dtos.HTTPError); ok {
-			i.metricsWrapper.StoreCounters(storage.TestImpressionsCounter, strconv.Itoa(httpError.Code))
+			i.runtimeTelemetry.RecordSyncError(telemetry.ImpressionSync, httpError.Code)
 		}
 		return err
 	}
-	bucket := util.Bucket(time.Now().Sub(before).Nanoseconds())
-	i.metricsWrapper.StoreLatencies(storage.TestImpressionsLatency, bucket)
-	i.metricsWrapper.StoreCounters(storage.TestImpressionsCounter, "ok")
+	i.runtimeTelemetry.RecordSyncLatency(telemetry.ImpressionSync, time.Since(before).Nanoseconds())
+	i.runtimeTelemetry.RecordSuccessfulSync(telemetry.ImpressionSync, time.Now().UTC().UnixNano()/int64(time.Millisecond))
 	return nil
 }
 

vendor/github.com/splitio/go-split-commons/v3/synchronizer/worker/impressionscount/single.go

@@ -1,9 +1,13 @@
 package impressionscount
 
 import (
+	"time"
+
 	"github.com/splitio/go-split-commons/v3/dtos"
 	"github.com/splitio/go-split-commons/v3/provisional"
 	"github.com/splitio/go-split-commons/v3/service"
+	"github.com/splitio/go-split-commons/v3/storage"
+	"github.com/splitio/go-split-commons/v3/telemetry"
 	"github.com/splitio/go-toolkit/v4/logging"
 )
 
@@ -13,6 +17,7 @@ type RecorderSingle struct {
 	impressionRecorder service.ImpressionsRecorder
 	metadata           dtos.Metadata
 	logger             logging.LoggerInterface
+	runtimeTelemetry   storage.TelemetryRuntimeProducer
 }
 
 // NewRecorderSingle creates new impressionsCount synchronizer for posting impressionsCount
@@ -21,12 +26,14 @@ func NewRecorderSingle(
 	impressionRecorder service.ImpressionsRecorder,
 	metadata dtos.Metadata,
 	logger logging.LoggerInterface,
+	runtimeTelemetry storage.TelemetryRuntimeProducer,
 ) ImpressionsCountRecorder {
 	return &RecorderSingle{
 		impressionsCounter: impressionsCounter,
 		impressionRecorder: impressionRecorder,
 		metadata:           metadata,
 		logger:             logger,
+		runtimeTelemetry:   runtimeTelemetry,
 	}
 }
 
@@ -47,5 +54,16 @@ func (m *RecorderSingle) SynchronizeImpressionsCount() error {
 	pf := dtos.ImpressionsCountDTO{
 		PerFeature: impressionsInTimeFrame,
 	}
-	return m.impressionRecorder.RecordImpressionsCount(pf, m.metadata)
+
+	before := time.Now()
+	err := m.impressionRecorder.RecordImpressionsCount(pf, m.metadata)
+	if err != nil {
+		if httpError, ok := err.(*dtos.HTTPError); ok {
+			m.runtimeTelemetry.RecordSyncError(telemetry.ImpressionCountSync, httpError.Code)
+		}
+		return err
+	}
+	m.runtimeTelemetry.RecordSyncLatency(telemetry.ImpressionCountSync, time.Since(before).Nanoseconds())
+	m.runtimeTelemetry.RecordSuccessfulSync(telemetry.ImpressionCountSync, time.Now().UTC().UnixNano()/int64(time.Millisecond))
+	return nil
 }

vendor/github.com/splitio/go-split-commons/v3/synchronizer/worker/metric/interface.go

@@ -1,6 +0,0 @@
-package metric
-
-// MetricRecorder interface
-type MetricRecorder interface {
-	SynchronizeTelemetry() error
-}

vendor/github.com/splitio/go-split-commons/v3/synchronizer/worker/metric/single.go

@@ -1,74 +0,0 @@
-package metric
-
-import (
-	"errors"
-
-	"github.com/splitio/go-split-commons/v3/dtos"
-	"github.com/splitio/go-split-commons/v3/service"
-	"github.com/splitio/go-split-commons/v3/storage"
-)
-
-// RecorderSingle struct for metric sync
-type RecorderSingle struct {
-	metricStorage  storage.MetricsStorageConsumer
-	metricRecorder service.MetricsRecorder
-	metadata       dtos.Metadata
-}
-
-// NewRecorderSingle creates new metric synchronizer for posting metrics
-func NewRecorderSingle(
-	metricStorage storage.MetricsStorageConsumer,
-	metricRecorder service.MetricsRecorder,
-	metadata dtos.Metadata,
-) MetricRecorder {
-	return &RecorderSingle{
-		metricStorage:  metricStorage,
-		metricRecorder: metricRecorder,
-		metadata:       metadata,
-	}
-}
-
-func (m *RecorderSingle) synchronizeLatencies() error {
-	latencies := m.metricStorage.PopLatencies()
-	if len(latencies) > 0 {
-		err := m.metricRecorder.RecordLatencies(latencies, m.metadata)
-		return err
-	}
-	return nil
-}
-
-func (m *RecorderSingle) synchronizeGauges() error {
-	var errs []error
-	for _, gauge := range m.metricStorage.PopGauges() {
-		err := m.metricRecorder.RecordGauge(gauge, m.metadata)
-		if err != nil {
-			errs = append(errs, err)
-		}
-	}
-	if len(errs) > 0 {
-		return errors.New("Some gauges could not be posted")
-	}
-	return nil
-}
-
-func (m *RecorderSingle) synchronizeCounters() error {
-	counters := m.metricStorage.PopCounters()
-	if len(counters) > 0 {
-		err := m.metricRecorder.RecordCounters(counters, m.metadata)
-		return err
-	}
-	return nil
-}
-
-// SynchronizeTelemetry syncs telemetry
-func (m *RecorderSingle) SynchronizeTelemetry() error {
-	err := m.synchronizeGauges()
-	if err != nil {
-		return err
-	}
-	err = m.synchronizeLatencies()
-	if err != nil {
-		return err
-	}
-	return m.synchronizeCounters()
-}

vendor/github.com/splitio/go-split-commons/v3/synchronizer/worker/segment/segment.go

@@ -2,25 +2,24 @@ package segment
 
 import (
 	"fmt"
-	"strconv"
 	"sync"
 	"time"
 
 	"github.com/splitio/go-split-commons/v3/dtos"
 	"github.com/splitio/go-split-commons/v3/service"
 	"github.com/splitio/go-split-commons/v3/storage"
-	"github.com/splitio/go-split-commons/v3/util"
+	"github.com/splitio/go-split-commons/v3/telemetry"
 	"github.com/splitio/go-toolkit/v4/datastructures/set"
 	"github.com/splitio/go-toolkit/v4/logging"
 )
 
 // UpdaterImpl struct for segment sync
 type UpdaterImpl struct {
-	splitStorage   storage.SplitStorageConsumer
-	segmentStorage storage.SegmentStorage
-	segmentFetcher service.SegmentFetcher
-	metricsWrapper *storage.MetricWrapper
-	logger         logging.LoggerInterface
+	splitStorage     storage.SplitStorageConsumer
+	segmentStorage   storage.SegmentStorage
+	segmentFetcher   service.SegmentFetcher
+	logger           logging.LoggerInterface
+	runtimeTelemetry storage.TelemetryRuntimeProducer
 }
 
 // NewSegmentFetcher creates new segment synchronizer for processing segment updates
@@ -28,15 +27,15 @@ func NewSegmentFetcher(
 	splitStorage storage.SplitStorage,
 	segmentStorage storage.SegmentStorage,
 	segmentFetcher service.SegmentFetcher,
-	metricsWrapper *storage.MetricWrapper,
 	logger logging.LoggerInterface,
+	runtimeTelemetry storage.TelemetryRuntimeProducer,
 ) Updater {
 	return &UpdaterImpl{
-		splitStorage:   splitStorage,
-		segmentStorage: segmentStorage,
-		segmentFetcher: segmentFetcher,
-		metricsWrapper: metricsWrapper,
-		logger:         logger,
+		splitStorage:     splitStorage,
+		segmentStorage:   segmentStorage,
+		segmentFetcher:   segmentFetcher,
+		logger:           logger,
+		runtimeTelemetry: runtimeTelemetry,
 	}
 }
 
@@ -83,16 +82,14 @@ func (s *UpdaterImpl) SynchronizeSegment(name string, till *int64, requestNoCach
 		segmentChanges, err := s.segmentFetcher.Fetch(name, changeNumber, requestNoCache)
 		if err != nil {
 			if httpError, ok := err.(*dtos.HTTPError); ok {
-				s.metricsWrapper.StoreCounters(storage.SegmentChangesCounter, strconv.Itoa(httpError.Code))
+				s.runtimeTelemetry.RecordSyncError(telemetry.SegmentSync, httpError.Code)
 			}
 			return err
 		}
-
+		s.runtimeTelemetry.RecordSyncLatency(telemetry.SegmentSync, time.Since(before).Nanoseconds())
 		s.processUpdate(segmentChanges)
-		bucket := util.Bucket(time.Now().Sub(before).Nanoseconds())
-		s.metricsWrapper.StoreLatencies(storage.SegmentChangesLatency, bucket)
-		s.metricsWrapper.StoreCounters(storage.SegmentChangesCounter, "ok")
 		if segmentChanges.Till == segmentChanges.Since || (till != nil && segmentChanges.Till >= *till) {
+			s.runtimeTelemetry.RecordSuccessfulSync(telemetry.SegmentSync, time.Now().UTC().UnixNano()/int64(time.Millisecond))
 			return nil
 		}
 	}

vendor/github.com/splitio/go-split-commons/v3/synchronizer/worker/split/split.go

@@ -1,13 +1,12 @@
 package split
 
 import (
-	"strconv"
 	"time"
 
 	"github.com/splitio/go-split-commons/v3/dtos"
 	"github.com/splitio/go-split-commons/v3/service"
 	"github.com/splitio/go-split-commons/v3/storage"
-	"github.com/splitio/go-split-commons/v3/util"
+	"github.com/splitio/go-split-commons/v3/telemetry"
 	"github.com/splitio/go-toolkit/v4/logging"
 )
 
@@ -17,24 +16,24 @@ const (
 
 // UpdaterImpl struct for split sync
 type UpdaterImpl struct {
-	splitStorage   storage.SplitStorage
-	splitFetcher   service.SplitFetcher
-	metricsWrapper *storage.MetricWrapper
-	logger         logging.LoggerInterface
+	splitStorage     storage.SplitStorage
+	splitFetcher     service.SplitFetcher
+	logger           logging.LoggerInterface
+	runtimeTelemetry storage.TelemetryRuntimeProducer
 }
 
 // NewSplitFetcher creates new split synchronizer for processing split updates
 func NewSplitFetcher(
 	splitStorage storage.SplitStorage,
 	splitFetcher service.SplitFetcher,
-	metricsWrapper *storage.MetricWrapper,
 	logger logging.LoggerInterface,
-) *UpdaterImpl {
+	runtimeTelemetry storage.TelemetryRuntimeProducer,
+) Updater {
 	return &UpdaterImpl{
-		splitStorage:   splitStorage,
-		splitFetcher:   splitFetcher,
-		metricsWrapper: metricsWrapper,
-		logger:         logger,
+		splitStorage:     splitStorage,
+		splitFetcher:     splitFetcher,
+		logger:           logger,
+		runtimeTelemetry: runtimeTelemetry,
 	}
 }
 
@@ -76,16 +75,15 @@ func (s *UpdaterImpl) SynchronizeSplits(till *int64, requestNoCache bool) ([]str
 		splits, err := s.splitFetcher.Fetch(changeNumber, requestNoCache)
 		if err != nil {
 			if httpError, ok := err.(*dtos.HTTPError); ok {
-				s.metricsWrapper.StoreCounters(storage.SplitChangesCounter, strconv.Itoa(httpError.Code))
+				s.runtimeTelemetry.RecordSyncError(telemetry.SplitSync, httpError.Code)
 			}
 			return segments, err
 		}
+		s.runtimeTelemetry.RecordSyncLatency(telemetry.SplitSync, time.Since(before).Nanoseconds())
 		s.processUpdate(splits)
 		segments = append(segments, extractSegments(splits)...)
-		bucket := util.Bucket(time.Now().Sub(before).Nanoseconds())
-		s.metricsWrapper.StoreCounters(storage.SplitChangesCounter, "ok")
-		s.metricsWrapper.StoreLatencies(storage.SplitChangesLatency, bucket)
 		if splits.Till == splits.Since || (till != nil && splits.Till >= *till) {
+			s.runtimeTelemetry.RecordSuccessfulSync(telemetry.SplitSync, time.Now().UTC().UnixNano()/int64(time.Millisecond))
 			return segments, nil
 		}
 	}