[chore] unexport structs in cumulativetodeltaprocessor

This commit unexports internal structs that are not part of the public API
or configuration in the cumulativetodeltaprocessor component.

Unexported structs:
- State -> state (internal tracking state)
- DeltaValue -> deltaValue (internal delta calculation)
- ValuePoint -> valuePoint (internal value storage)
- HistogramPoint -> histogramPoint (internal histogram data)
- MetricPoint -> metricPoint (internal metric data)

Added constructor functions and getter/setter methods to maintain
functionality while keeping the structs unexported.

Fixes #40641

Author: NoNickeD

processor/cumulativetodeltaprocessor/internal/tracking/identity.go

@@ -73,3 +73,53 @@ func (mi *MetricIdentity) IsFloatVal() bool {
 func (mi *MetricIdentity) IsSupportedMetricType() bool {
 	return mi.MetricType == pmetric.MetricTypeSum || mi.MetricType == pmetric.MetricTypeHistogram
 }
+
+// NewMetricIdentity creates a new MetricIdentity
+func NewMetricIdentity() MetricIdentity {
+	return MetricIdentity{}
+}
+
+// SetResource sets the Resource field
+func (mi *MetricIdentity) SetResource(resource pcommon.Resource) {
+	mi.Resource = resource
+}
+
+// SetInstrumentationLibrary sets the InstrumentationLibrary field  
+func (mi *MetricIdentity) SetInstrumentationLibrary(scope pcommon.InstrumentationScope) {
+	mi.InstrumentationLibrary = scope
+}
+
+// SetMetricType sets the MetricType field
+func (mi *MetricIdentity) SetMetricType(metricType pmetric.MetricType) {
+	mi.MetricType = metricType
+}
+
+// SetMetricName sets the MetricName field
+func (mi *MetricIdentity) SetMetricName(name string) {
+	mi.MetricName = name
+}
+
+// SetMetricUnit sets the MetricUnit field
+func (mi *MetricIdentity) SetMetricUnit(unit string) {
+	mi.MetricUnit = unit
+}
+
+// SetMetricIsMonotonic sets the MetricIsMonotonic field
+func (mi *MetricIdentity) SetMetricIsMonotonic(monotonic bool) {
+	mi.MetricIsMonotonic = monotonic
+}
+
+// SetMetricValueType sets the MetricValueType field
+func (mi *MetricIdentity) SetMetricValueType(valueType pmetric.NumberDataPointValueType) {
+	mi.MetricValueType = valueType
+}
+
+// SetStartTimestamp sets the StartTimestamp field
+func (mi *MetricIdentity) SetStartTimestamp(timestamp pcommon.Timestamp) {
+	mi.StartTimestamp = timestamp
+}
+
+// SetAttributes sets the Attributes field
+func (mi *MetricIdentity) SetAttributes(attributes pcommon.Map) {
+	mi.Attributes = attributes
+}

processor/cumulativetodeltaprocessor/internal/tracking/metric.go

@@ -3,7 +3,15 @@
 
 package tracking // import "github.com/open-telemetry/opentelemetry-collector-contrib/processor/cumulativetodeltaprocessor/internal/tracking"
 
-type MetricPoint struct {
+type metricPoint struct {
 	Identity MetricIdentity
-	Value    ValuePoint
+	Value    valuePoint
+}
+
+// NewMetricPoint creates a new metricPoint
+func NewMetricPoint(identity MetricIdentity, value valuePoint) metricPoint {
+	return metricPoint{
+		Identity: identity,
+		Value:    value,
+	}
 }

processor/cumulativetodeltaprocessor/internal/tracking/tracker.go

@@ -59,16 +59,16 @@ var identityBufferPool = sync.Pool{
 	},
 }
 
-type State struct {
+type state struct {
 	sync.Mutex
-	PrevPoint ValuePoint
+	prevPoint valuePoint
 }
 
-type DeltaValue struct {
+type deltaValue struct {
 	StartTimestamp pcommon.Timestamp
 	FloatValue     float64
 	IntValue       int64
-	HistogramValue *HistogramPoint
+	HistogramValue *histogramPoint
 }
 
 func NewMetricTracker(ctx context.Context, logger *zap.Logger, maxStaleness time.Duration, initalValue InitialValue) *MetricTracker {
@@ -92,7 +92,7 @@ type MetricTracker struct {
 	startTime    pcommon.Timestamp
 }
 
-func (t *MetricTracker) Convert(in MetricPoint) (out DeltaValue, valid bool) {
+func (t *MetricTracker) Convert(in metricPoint) (out deltaValue, valid bool) {
 	metricID := in.Identity
 	metricPoint := in.Value
 	if !metricID.IsSupportedMetricType() {
@@ -112,8 +112,8 @@ func (t *MetricTracker) Convert(in MetricPoint) (out DeltaValue, valid bool) {
 	hashableID := b.String()
 	identityBufferPool.Put(b)
 
-	s, ok := t.states.LoadOrStore(hashableID, &State{
-		PrevPoint: metricPoint,
+	s, ok := t.states.LoadOrStore(hashableID, &state{
+		prevPoint: metricPoint,
 	})
 	if !ok {
 		switch metricID.MetricType {
@@ -141,16 +141,16 @@ func (t *MetricTracker) Convert(in MetricPoint) (out DeltaValue, valid bool) {
 
 	valid = true
 
-	state := s.(*State)
+	state := s.(*state)
 	state.Lock()
 	defer state.Unlock()
 
-	out.StartTimestamp = state.PrevPoint.ObservedTimestamp
+	out.StartTimestamp = state.prevPoint.ObservedTimestamp
 
 	switch metricID.MetricType {
 	case pmetric.MetricTypeHistogram:
 		value := metricPoint.HistogramValue
-		prevValue := state.PrevPoint.HistogramValue
+		prevValue := state.prevPoint.HistogramValue
 		if math.IsNaN(value.Sum) {
 			value.Sum = prevValue.Sum
 		}
@@ -174,7 +174,7 @@ func (t *MetricTracker) Convert(in MetricPoint) (out DeltaValue, valid bool) {
 	case pmetric.MetricTypeSum:
 		if metricID.IsFloatVal() {
 			value := metricPoint.FloatValue
-			prevValue := state.PrevPoint.FloatValue
+			prevValue := state.prevPoint.FloatValue
 			delta := value - prevValue
 
 			// Detect reset (non-monotonic sums are not converted)
@@ -185,7 +185,7 @@ func (t *MetricTracker) Convert(in MetricPoint) (out DeltaValue, valid bool) {
 			out.FloatValue = delta
 		} else {
 			value := metricPoint.IntValue
-			prevValue := state.PrevPoint.IntValue
+			prevValue := state.prevPoint.IntValue
 			delta := value - prevValue
 
 			// Detect reset (non-monotonic sums are not converted)
@@ -198,13 +198,13 @@ func (t *MetricTracker) Convert(in MetricPoint) (out DeltaValue, valid bool) {
 	case pmetric.MetricTypeEmpty, pmetric.MetricTypeGauge, pmetric.MetricTypeExponentialHistogram, pmetric.MetricTypeSummary:
 	}
 
-	state.PrevPoint = metricPoint
+	state.prevPoint = metricPoint
 	return
 }
 
 func (t *MetricTracker) removeStale(staleBefore pcommon.Timestamp) {
 	t.states.Range(func(key, value any) bool {
-		s := value.(*State)
+		s := value.(*state)
 
 		// There is a known race condition here.
 		// Because the state may be in the process of updating at the
@@ -220,7 +220,7 @@ func (t *MetricTracker) removeStale(staleBefore pcommon.Timestamp) {
 		//	  not be persisted. The next update will load an entirely
 		//	  new state.
 		s.Lock()
-		lastObserved := s.PrevPoint.ObservedTimestamp
+		lastObserved := s.prevPoint.ObservedTimestamp
 		s.Unlock()
 		if lastObserved < staleBefore {
 			t.logger.Debug("removing stale state key", zap.String("key", key.(string)))
@@ -243,3 +243,38 @@ func (t *MetricTracker) sweeper(ctx context.Context, remove func(pcommon.Timesta
 		}
 	}
 }
+
+// GetStartTimestamp returns the StartTimestamp field of deltaValue
+func (dv *deltaValue) GetStartTimestamp() pcommon.Timestamp {
+	return dv.StartTimestamp
+}
+
+// GetFloatValue returns the FloatValue field of deltaValue
+func (dv *deltaValue) GetFloatValue() float64 {
+	return dv.FloatValue
+}
+
+// GetIntValue returns the IntValue field of deltaValue
+func (dv *deltaValue) GetIntValue() int64 {
+	return dv.IntValue
+}
+
+// GetHistogramValue returns the HistogramValue field of deltaValue
+func (dv *deltaValue) GetHistogramValue() *histogramPoint {
+	return dv.HistogramValue
+}
+
+// GetCount returns the Count field of histogramPoint
+func (hp *histogramPoint) GetCount() uint64 {
+	return hp.Count
+}
+
+// GetSum returns the Sum field of histogramPoint
+func (hp *histogramPoint) GetSum() float64 {
+	return hp.Sum
+}
+
+// GetBuckets returns the Buckets field of histogramPoint
+func (hp *histogramPoint) GetBuckets() []uint64 {
+	return hp.Buckets
+}