[connector/signaltometrics]Drop get OTTL func in favor of OTTL's ParseValueExpression (#38101)

<!--Ex. Fixing a bug - Describe the bug and how this fixes the issue.
Ex. Adding a feature - Explain what this achieves.-->
#### Description

The component was using an internal `get` OTTL function as a stop gap
measure to extract value from OTTL expressions due to lack of such
function from the core OTTL library. With
#35621,
support for data extraction using OTTL value expressions was introduced.
This PR uses the `ParseValueExpression` method and drops the `get` OTTL
function. The function was documented in README as internal function and
strictly advised not to be used in configurations so I don't expect any
issues.

<!-- Issue number (e.g. #1234) or full URL to issue, if applicable. -->
#### Link to tracking issue
Fixes
#38098

<!--Describe what testing was performed and which tests were added.-->
#### Testing

Unit tests are passing

<!--Describe the documentation added.-->
#### Documentation

README is updated

<!--Please delete paragraphs that you did not use before submitting.-->

---------

Co-authored-by: Andrzej Stencel <[email protected]>

Author: lahsivjar

.chloggen/signaltometrics-use-ottl-valueexpression.yaml

@@ -0,0 +1,27 @@
+# Use this changelog template to create an entry for release notes.
+
+# One of 'breaking', 'deprecation', 'new_component', 'enhancement', 'bug_fix'
+change_type: breaking
+
+# The name of the component, or a single word describing the area of concern, (e.g. filelogreceiver)
+component: signaltometricsconnector
+
+# A brief description of the change.  Surround your text with quotes ("") if it needs to start with a backtick (`).
+note: "`get` OTTL function is removed and expressions are now parsed using `ParseValueExpression`"
+
+# Mandatory: One or more tracking issues related to the change. You can use the PR number here if no issue exists.
+issues: [38098]
+
+# (Optional) One or more lines of additional information to render under the primary note.
+# These lines will be padded with 2 spaces and then inserted directly into the document.
+# Use pipe (|) for multiline entries.
+subtext:
+
+# If your change doesn't affect end users or the exported elements of any package,
+# you should instead start your pull request title with [chore] or use the "Skip Changelog" label.
+# Optional: The change log or logs in which this entry should be included.
+# e.g. '[user]' or '[user, api]'
+# Include 'user' if the change is relevant to end users.
+# Include 'api' if there is a change to a library API.
+# Default: '[user]'
+change_logs: [user]

connector/signaltometricsconnector/README.md

@@ -229,9 +229,6 @@ signaltometrics.service.instance.id: <service_instance_id_of_the_otel_collector>
 
 ### Custom OTTL functions
 
-The component implements a couple of custom OTTL functions:
+The component implements the following custom OTTL functions:
 
 1. `AdjustedCount`: a converter capable of calculating [adjusted count for a span](https://github.com/open-telemetry/oteps/blob/main/text/trace/0235-sampling-threshold-in-trace-state.md).
-2. `get`: a temporary solution to parse OTTL expressions with only values. This is
-only for internal usage and MUST NOT be used explicitly as it is a stopgap measure
-([see this for more details](https://github.com/open-telemetry/opentelemetry-collector-contrib/issues/35621)).

connector/signaltometricsconnector/config/config.go

@@ -239,38 +239,42 @@ func validateMetricInfo[K any](mi MetricInfo, parser ottl.Parser[K]) error {
 		return fmt.Errorf("sum validation failed: %w", err)
 	}
 
-	// Exactly one metric should be defined
-	var (
-		metricsDefinedCount int
-		statements          []string
-	)
+	// Exactly one metric should be defined. Also, validate OTTL expressions,
+	// note that, here we only evaluate if statements are valid. Check for
+	// required statements are left to the other validations.
+	var metricsDefinedCount int
 	if mi.Histogram != nil {
 		metricsDefinedCount++
 		if mi.Histogram.Count != "" {
-			statements = append(statements, customottl.ConvertToStatement(mi.Histogram.Count))
+			if _, err := parser.ParseValueExpression(mi.Histogram.Count); err != nil {
+				return fmt.Errorf("failed to parse count OTTL expression for explicit histogram: %w", err)
+			}
+		}
+		if _, err := parser.ParseValueExpression(mi.Histogram.Value); err != nil {
+			return fmt.Errorf("failed to parse value OTTL expression for explicit histogram: %w", err)
 		}
-		statements = append(statements, customottl.ConvertToStatement(mi.Histogram.Value))
 	}
 	if mi.ExponentialHistogram != nil {
 		metricsDefinedCount++
 		if mi.ExponentialHistogram.Count != "" {
-			statements = append(statements, customottl.ConvertToStatement(mi.ExponentialHistogram.Count))
+			if _, err := parser.ParseValueExpression(mi.ExponentialHistogram.Count); err != nil {
+				return fmt.Errorf("failed to parse count OTTL expression for exponential histogram: %w", err)
+			}
+		}
+		if _, err := parser.ParseValueExpression(mi.ExponentialHistogram.Value); err != nil {
+			return fmt.Errorf("failed to parse value OTTL expression for exponential histogram: %w", err)
 		}
-		statements = append(statements, customottl.ConvertToStatement(mi.ExponentialHistogram.Value))
 	}
 	if mi.Sum != nil {
 		metricsDefinedCount++
-		statements = append(statements, customottl.ConvertToStatement(mi.Sum.Value))
+		if _, err := parser.ParseValueExpression(mi.Sum.Value); err != nil {
+			return fmt.Errorf("failed to parse value OTTL expression for summary: %w", err)
+		}
 	}
 	if metricsDefinedCount != 1 {
 		return fmt.Errorf("exactly one of the metrics must be defined, %d found", metricsDefinedCount)
 	}
 
-	// validate OTTL statements, note that, here we only evaluate if statements
-	// are valid. Check for required statements is left to the other validations.
-	if _, err := parser.ParseStatements(statements); err != nil {
-		return fmt.Errorf("failed to parse OTTL statements: %w", err)
-	}
 	// validate OTTL conditions
 	if _, err := parser.ParseConditions(mi.Conditions); err != nil {
 		return fmt.Errorf("failed to parse OTTL conditions: %w", err)

connector/signaltometricsconnector/config/config_test.go

@@ -84,11 +84,11 @@ func TestConfig(t *testing.T) {
 			},
 		},
 		{
-			path: "invalid_ottl_statements",
+			path: "invalid_ottl_value_expression",
 			errorMsgs: []string{
-				fullErrorForSignal(t, "spans", "failed to parse OTTL statements"),
-				fullErrorForSignal(t, "datapoints", "failed to parse OTTL statements"),
-				fullErrorForSignal(t, "logs", "failed to parse OTTL statements"),
+				fullErrorForSignal(t, "spans", "failed to parse value OTTL expression"),
+				fullErrorForSignal(t, "datapoints", "failed to parse value OTTL expression"),
+				fullErrorForSignal(t, "logs", "failed to parse value OTTL expression"),
 			},
 		},
 		{

connector/signaltometricsconnector/internal/aggregator/aggregator.go

@@ -72,7 +72,7 @@ func (a *Aggregator[K]) Aggregate(
 		}
 		return a.aggregateValueCount(md, resAttrs, srcAttrs, val, count)
 	case md.Sum != nil:
-		raw, _, err := md.Sum.Value.Execute(ctx, tCtx)
+		raw, err := md.Sum.Value.Eval(ctx, tCtx)
 		if err != nil {
 			return fmt.Errorf("failed to execute OTTL value for sum: %w", err)
 		}
@@ -237,7 +237,7 @@ func (a *Aggregator[K]) getResourceID(resourceAttrs pcommon.Map) [16]byte {
 // value is missing.
 func getValueCount[K any](
 	ctx context.Context, tCtx K,
-	valueExpr, countExpr *ottl.Statement[K],
+	valueExpr, countExpr *ottl.ValueExpression[K],
 	defaultCount int64,
 ) (float64, int64, error) {
 	val, err := getDoubleFromOTTL(ctx, tCtx, valueExpr)
@@ -257,12 +257,12 @@ func getValueCount[K any](
 func getIntFromOTTL[K any](
 	ctx context.Context,
 	tCtx K,
-	s *ottl.Statement[K],
+	s *ottl.ValueExpression[K],
 ) (int64, error) {
 	if s == nil {
 		return 0, nil
 	}
-	raw, _, err := s.Execute(ctx, tCtx)
+	raw, err := s.Eval(ctx, tCtx)
 	if err != nil {
 		return 0, err
 	}
@@ -282,12 +282,12 @@ func getIntFromOTTL[K any](
 func getDoubleFromOTTL[K any](
 	ctx context.Context,
 	tCtx K,
-	s *ottl.Statement[K],
+	s *ottl.ValueExpression[K],
 ) (float64, error) {
 	if s == nil {
 		return 0, nil
 	}
-	raw, _, err := s.Execute(ctx, tCtx)
+	raw, err := s.Eval(ctx, tCtx)
 	if err != nil {
 		return 0, err
 	}

connector/signaltometricsconnector/internal/customottl/funcs.go

@@ -27,8 +27,5 @@ func LogFuncs() map[string]ottl.Factory[ottllog.TransformContext] {
 }
 
 func commonFuncs[K any]() map[string]ottl.Factory[K] {
-	getFactory := NewGetFactory[K]()
-	standard := ottlfuncs.StandardFuncs[K]()
-	standard[getFactory.Name()] = getFactory
-	return standard
+	return ottlfuncs.StandardFuncs[K]()
 }

connector/signaltometricsconnector/internal/customottl/get.go

@@ -11,7 +11,6 @@ import (
 	"go.opentelemetry.io/collector/pdata/pcommon"
 
 	"github.com/open-telemetry/opentelemetry-collector-contrib/connector/signaltometricsconnector/config"
-	"github.com/open-telemetry/opentelemetry-collector-contrib/connector/signaltometricsconnector/internal/customottl"
 	"github.com/open-telemetry/opentelemetry-collector-contrib/pkg/ottl"
 )
 
@@ -27,8 +26,8 @@ type MetricKey struct {
 
 type ExplicitHistogram[K any] struct {
 	Buckets []float64
-	Count   *ottl.Statement[K]
-	Value   *ottl.Statement[K]
+	Count   *ottl.ValueExpression[K]
+	Value   *ottl.ValueExpression[K]
 }
 
 func (h *ExplicitHistogram[K]) fromConfig(
@@ -42,12 +41,12 @@ func (h *ExplicitHistogram[K]) fromConfig(
 	var err error
 	h.Buckets = mi.Buckets
 	if mi.Count != "" {
-		h.Count, err = parser.ParseStatement(customottl.ConvertToStatement(mi.Count))
+		h.Count, err = parser.ParseValueExpression(mi.Count)
 		if err != nil {
-			return fmt.Errorf("failed to parse count statement for explicit histogram: %w", err)
+			return fmt.Errorf("failed to parse count OTTL expression for explicit histogram: %w", err)
 		}
 	}
-	h.Value, err = parser.ParseStatement(customottl.ConvertToStatement(mi.Value))
+	h.Value, err = parser.ParseValueExpression(mi.Value)
 	if err != nil {
 		return fmt.Errorf("failed to parse value statement for explicit histogram: %w", err)
 	}
@@ -56,8 +55,8 @@ func (h *ExplicitHistogram[K]) fromConfig(
 
 type ExponentialHistogram[K any] struct {
 	MaxSize int32
-	Count   *ottl.Statement[K]
-	Value   *ottl.Statement[K]
+	Count   *ottl.ValueExpression[K]
+	Value   *ottl.ValueExpression[K]
 }
 
 func (h *ExponentialHistogram[K]) fromConfig(
@@ -71,20 +70,20 @@ func (h *ExponentialHistogram[K]) fromConfig(
 	var err error
 	h.MaxSize = mi.MaxSize
 	if mi.Count != "" {
-		h.Count, err = parser.ParseStatement(customottl.ConvertToStatement(mi.Count))
+		h.Count, err = parser.ParseValueExpression(mi.Count)
 		if err != nil {
-			return fmt.Errorf("failed to parse count statement for exponential histogram: %w", err)
+			return fmt.Errorf("failed to parse count OTTL expression for exponential histogram: %w", err)
 		}
 	}
-	h.Value, err = parser.ParseStatement(customottl.ConvertToStatement(mi.Value))
+	h.Value, err = parser.ParseValueExpression(mi.Value)
 	if err != nil {
-		return fmt.Errorf("failed to parse value statement for exponential histogram: %w", err)
+		return fmt.Errorf("failed to parse value OTTL expression for exponential histogram: %w", err)
 	}
 	return nil
 }
 
 type Sum[K any] struct {
-	Value *ottl.Statement[K]
+	Value *ottl.ValueExpression[K]
 }
 
 func (s *Sum[K]) fromConfig(
@@ -96,9 +95,9 @@ func (s *Sum[K]) fromConfig(
 	}
 
 	var err error
-	s.Value, err = parser.ParseStatement(customottl.ConvertToStatement(mi.Value))
+	s.Value, err = parser.ParseValueExpression(mi.Value)
 	if err != nil {
-		return fmt.Errorf("failed to parse value statement for sum: %w", err)
+		return fmt.Errorf("failed to parse value OTTL expression for sum: %w", err)
 	}
 	return nil
 }