Use pointer when passing TransformContext around or calling into (open-telemetry#44541)

This PR changes only the `ottlspan.TransformContext`, if gets approved
will file separate PRs for all contexts.
* In OTTL Expr and Getter/Setter the TransformContext is no longer pass
as value avoiding a copy of 12 words (96B) every time an
Expr/Getter/Setter of even simple Get* on the context itself funcs are
called.
* Avoid allocating a new pcommon.Map every time, very costly when is not
needed.

Comparing existing benchmarks:

**Before:**
```
BenchmarkTwoSpans
BenchmarkTwoSpans/no_processing
BenchmarkTwoSpans/no_processing-12         	  841123	      1327 ns/op	    2592 B/op	      46 allocs/op
BenchmarkTwoSpans/set_attribute
BenchmarkTwoSpans/set_attribute-12         	  743674	      1600 ns/op	    2640 B/op	      49 allocs/op
BenchmarkTwoSpans/keep_keys_attribute
BenchmarkTwoSpans/keep_keys_attribute-12   	  715513	      1685 ns/op	    2656 B/op	      50 allocs/op
BenchmarkTwoSpans/no_match
BenchmarkTwoSpans/no_match-12              	  702061	      1554 ns/op	    2624 B/op	      48 allocs/op
BenchmarkTwoSpans/inner_field
BenchmarkTwoSpans/inner_field-12           	  721738	      1621 ns/op	    2624 B/op	      48 allocs/op
BenchmarkTwoSpans/inner_field_both_spans
BenchmarkTwoSpans/inner_field_both_spans-12         	  716055	      1713 ns/op	    2656 B/op	      50 allocs/op
```

**After:**
```
BenchmarkTwoSpans
BenchmarkTwoSpans/no_processing
BenchmarkTwoSpans/no_processing-12         	 1000000	      1244 ns/op	    2337 B/op	      40 allocs/op
BenchmarkTwoSpans/set_attribute
BenchmarkTwoSpans/set_attribute-12         	  885855	      1369 ns/op	    2385 B/op	      43 allocs/op
BenchmarkTwoSpans/keep_keys_attribute
BenchmarkTwoSpans/keep_keys_attribute-12   	  812374	      1448 ns/op	    2401 B/op	      44 allocs/op
BenchmarkTwoSpans/no_match
BenchmarkTwoSpans/no_match-12              	  886906	      1331 ns/op	    2369 B/op	      42 allocs/op
BenchmarkTwoSpans/inner_field
BenchmarkTwoSpans/inner_field-12           	  871096	      1374 ns/op	    2369 B/op	      42 allocs/op
BenchmarkTwoSpans/inner_field_both_spans
BenchmarkTwoSpans/inner_field_both_spans-12         	  866323	      1417 ns/op	    2401 B/op	      44 allocs/op
```

Comparing benchmarks that do not need to allocate the data again every
iteration and does not change the data to measure only the OTTL
overhead:

**Before:**
```
BenchmarkSetName
BenchmarkSetName-12    	 9204532	       122.0 ns/op	      32 B/op	       2 allocs/op
```

**After:**
```
BenchmarkSetName
BenchmarkSetName-12    	 3745602	       305.7 ns/op	     288 B/op	       8 allocs/op
```

For the current performance benchmarks which are not allocating new
TransformContext, here only benefit is because of the object copy part:

**Before:**
```
BenchmarkStatementSequenceExecuteSpans
BenchmarkStatementSequenceExecuteSpans/small
BenchmarkStatementSequenceExecuteSpans/small-12         	 1000000	      1004 ns/op	     264 B/op	      16 allocs/op
BenchmarkStatementSequenceExecuteSpans/medium
BenchmarkStatementSequenceExecuteSpans/medium-12        	  189889	      6194 ns/op	    1464 B/op	      86 allocs/op
BenchmarkStatementSequenceExecuteSpans/large
BenchmarkStatementSequenceExecuteSpans/large-12         	   29114	     39433 ns/op	    6000 B/op	     350 allocs/op
```

**After:**
```
BenchmarkStatementSequenceExecuteSpans
BenchmarkStatementSequenceExecuteSpans/small
BenchmarkStatementSequenceExecuteSpans/small-12         	 1915495	       603.9 ns/op	     264 B/op	      16 allocs/op
BenchmarkStatementSequenceExecuteSpans/medium
BenchmarkStatementSequenceExecuteSpans/medium-12        	  279411	      4292 ns/op	    1464 B/op	      86 allocs/op
BenchmarkStatementSequenceExecuteSpans/large
BenchmarkStatementSequenceExecuteSpans/large-12         	   34627	     34848 ns/op	    6000 B/op	     350 allocs/op
```

Signed-off-by: Bogdan Drutu <[email protected]>

Author: bogdandrutu

.chloggen/use-pointer-for-context.yaml

@@ -0,0 +1,35 @@
+# Use this changelog template to create an entry for release notes.
+
+# One of 'breaking', 'deprecation', 'new_component', 'enhancement', 'bug_fix'
+change_type: deprecation
+
+# The name of the component, or a single word describing the area of concern, (e.g. receiver/filelog)
+component: pkg/ottl
+
+# A brief description of the change.  Surround your text with quotes ("") if it needs to start with a backtick (`).
+note: Use pointer when passing TransformContext around or calling into.
+
+# Mandatory: One or more tracking issues related to the change. You can use the PR number here if no issue exists.
+issues: [44541]
+
+# (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: |
+  Change Expr/Parser/Getter/Setter and all ottl related funcs to accept pointers to avoid unnecessary copy of a large
+  TransformContext(96B). Avoid allocating a new pcommon.Map every time a new context is created by using a Borrow/Return
+  pattern and reuse objects between calls. Deprecated funcs are:
+  - `ottlspan.NewTransformContext` in favor of `ottlspan.BorrowContext`;
+  - `filtermprocessor.DefaultSpanFunctions` in favor of `filtermprocessor.DefaultSpanFunctionsNew`
+  - `filtermprocessor.WithSpanFunctions` in favor of `filtermprocessor.WithSpanFunctionsNew`
+  - `transformprocessor.DefaultSpanFunctions` in favor of `transformprocessor.DefaultSpanFunctionsNew`
+  - `transformprocessor.WithSpanFunctions` in favor of `transformprocessor.WithSpanFunctionsNew`
+
+# 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: [api]

connector/countconnector/connector.go

@@ -32,7 +32,7 @@ type count struct {
 	component.StartFunc
 	component.ShutdownFunc
 
-	spansMetricDefs      map[string]metricDef[ottlspan.TransformContext]
+	spansMetricDefs      map[string]metricDef[*ottlspan.TransformContext]
 	spanEventsMetricDefs map[string]metricDef[ottlspanevent.TransformContext]
 	metricsMetricDefs    map[string]metricDef[ottlmetric.TransformContext]
 	dataPointsMetricDefs map[string]metricDef[ottldatapoint.TransformContext]
@@ -51,7 +51,7 @@ func (c *count) ConsumeTraces(ctx context.Context, td ptrace.Traces) error {
 	for i := 0; i < td.ResourceSpans().Len(); i++ {
 		resourceSpan := td.ResourceSpans().At(i)
 		resourceAttrs := resourceSpan.Resource().Attributes()
-		spansCounter := newCounter[ottlspan.TransformContext](c.spansMetricDefs)
+		spansCounter := newCounter[*ottlspan.TransformContext](c.spansMetricDefs)
 		spanEventsCounter := newCounter[ottlspanevent.TransformContext](c.spanEventsMetricDefs)
 
 		for j := 0; j < resourceSpan.ScopeSpans().Len(); j++ {
@@ -62,8 +62,9 @@ func (c *count) ConsumeTraces(ctx context.Context, td ptrace.Traces) error {
 				span := scopeSpan.Spans().At(k)
 				spansCounter.updateTimestamp(span.StartTimestamp())
 				spansCounter.updateTimestamp(span.EndTimestamp())
-				sCtx := ottlspan.NewTransformContext(span, scopeSpan.Scope(), resourceSpan.Resource(), scopeSpan, resourceSpan)
+				sCtx := ottlspan.NewTransformContextPtr(span, scopeSpan.Scope(), resourceSpan.Resource(), scopeSpan, resourceSpan)
 				multiError = errors.Join(multiError, spansCounter.update(ctx, span.Attributes(), scopeAttrs, resourceAttrs, sCtx))
+				sCtx.Close()
 
 				for l := 0; l < span.Events().Len(); l++ {
 					event := span.Events().At(l)

connector/countconnector/counter_test.go

@@ -14,8 +14,8 @@ import (
 )
 
 func Test_update_attribute_inheritance(t *testing.T) {
-	spanMetricDefs := make(map[string]metricDef[ottlspan.TransformContext])
-	spanMetricDefs[defaultMetricNameSpans] = metricDef[ottlspan.TransformContext]{
+	spanMetricDefs := make(map[string]metricDef[*ottlspan.TransformContext])
+	spanMetricDefs[defaultMetricNameSpans] = metricDef[*ottlspan.TransformContext]{
 		desc: defaultMetricDescSpans,
 		attrs: []AttributeConfig{
 			{
@@ -129,8 +129,8 @@ func Test_update_attribute_inheritance(t *testing.T) {
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			spansCounter := newCounter[ottlspan.TransformContext](spanMetricDefs)
-			err := spansCounter.update(t.Context(), tt.spanAttr, tt.scopeAttr, tt.resourceAttr, ottlspan.TransformContext{})
+			spansCounter := newCounter[*ottlspan.TransformContext](spanMetricDefs)
+			err := spansCounter.update(t.Context(), tt.spanAttr, tt.scopeAttr, tt.resourceAttr, &ottlspan.TransformContext{})
 			require.NoError(t, err)
 			require.NotNil(t, spansCounter)
 			m := spansCounter.counts[defaultMetricNameSpans]
@@ -215,15 +215,15 @@ func Test_update_attributes_types(t *testing.T) {
 	}
 
 	for _, tt := range tests {
-		spanMetricDefs := make(map[string]metricDef[ottlspan.TransformContext])
-		spanMetricDefs[defaultMetricNameSpans] = metricDef[ottlspan.TransformContext]{
+		spanMetricDefs := make(map[string]metricDef[*ottlspan.TransformContext])
+		spanMetricDefs[defaultMetricNameSpans] = metricDef[*ottlspan.TransformContext]{
 			desc:  defaultMetricDescSpans,
 			attrs: tt.config,
 		}
 
 		t.Run(tt.name, func(t *testing.T) {
 			spansCounter := newCounter(spanMetricDefs)
-			err := spansCounter.update(t.Context(), pcommon.NewMap(), pcommon.NewMap(), tt.inputAttr, ottlspan.TransformContext{})
+			err := spansCounter.update(t.Context(), pcommon.NewMap(), pcommon.NewMap(), tt.inputAttr, &ottlspan.TransformContext{})
 			require.NoError(t, err)
 			require.NotNil(t, spansCounter)
 			m := spansCounter.counts[defaultMetricNameSpans]

connector/countconnector/factory.go

@@ -50,9 +50,9 @@ func createTracesToMetrics(
 ) (connector.Traces, error) {
 	c := cfg.(*Config)
 
-	spanMetricDefs := make(map[string]metricDef[ottlspan.TransformContext], len(c.Spans))
+	spanMetricDefs := make(map[string]metricDef[*ottlspan.TransformContext], len(c.Spans))
 	for name, info := range c.Spans {
-		md := metricDef[ottlspan.TransformContext]{
+		md := metricDef[*ottlspan.TransformContext]{
 			desc:  info.Description,
 			attrs: info.Attributes,
 		}

connector/routingconnector/functions.go

@@ -33,10 +33,10 @@ func standardFunctions[K any]() map[string]ottl.Factory[K] {
 	return funcs
 }
 
-func spanFunctions() map[string]ottl.Factory[ottlspan.TransformContext] {
-	funcs := standardFunctions[ottlspan.TransformContext]()
+func spanFunctions() map[string]ottl.Factory[*ottlspan.TransformContext] {
+	funcs := standardFunctions[*ottlspan.TransformContext]()
 
-	isRootSpan := ottlfuncs.NewIsRootSpanFactory()
+	isRootSpan := ottlfuncs.NewIsRootSpanFactoryNew()
 	funcs[isRootSpan.Name()] = isRootSpan
 
 	return funcs

connector/routingconnector/functions_test.go

@@ -22,7 +22,7 @@ func TestSpanFunctions(t *testing.T) {
 	funcs := spanFunctions()
 	assertStandardFunctions(t, funcs)
 
-	isRouteFuncName := ottlfuncs.NewIsRootSpanFactory().Name()
+	isRouteFuncName := ottlfuncs.NewIsRootSpanFactoryNew().Name()
 	val, ok := funcs[isRouteFuncName]
 
 	require.True(t, ok)

connector/routingconnector/router.go

@@ -32,7 +32,7 @@ type consumerProvider[C any] func(...pipeline.ID) (C, error)
 // consumer.Logs.
 type router[C any] struct {
 	resourceParser   ottl.Parser[ottlresource.TransformContext]
-	spanParser       ottl.Parser[ottlspan.TransformContext]
+	spanParser       ottl.Parser[*ottlspan.TransformContext]
 	metricParser     ottl.Parser[ottlmetric.TransformContext]
 	dataPointParser  ottl.Parser[ottldatapoint.TransformContext]
 	logParser        ottl.Parser[ottllog.TransformContext]
@@ -74,7 +74,7 @@ type routingItem[C any] struct {
 	consumer           C
 	requestCondition   *requestCondition
 	resourceStatement  *ottl.Statement[ottlresource.TransformContext]
-	spanStatement      *ottl.Statement[ottlspan.TransformContext]
+	spanStatement      *ottl.Statement[*ottlspan.TransformContext]
 	metricStatement    *ottl.Statement[ottlmetric.TransformContext]
 	dataPointStatement *ottl.Statement[ottldatapoint.TransformContext]
 	logStatement       *ottl.Statement[ottllog.TransformContext]

connector/routingconnector/traces.go

@@ -87,7 +87,8 @@ func (c *tracesConnector) ConsumeTraces(ctx context.Context, td ptrace.Traces) e
 		case "span":
 			ptraceutil.MoveSpansWithContextIf(td, matched,
 				func(rs ptrace.ResourceSpans, ss ptrace.ScopeSpans, s ptrace.Span) bool {
-					mtx := ottlspan.NewTransformContext(s, ss.Scope(), rs.Resource(), ss, rs)
+					mtx := ottlspan.NewTransformContextPtr(s, ss.Scope(), rs.Resource(), ss, rs)
+					defer mtx.Close()
 					_, isMatch, err := route.spanStatement.Execute(ctx, mtx)
 					// If error during statement evaluation consider it as not a match.
 					if err != nil {

connector/signaltometricsconnector/connector.go

@@ -29,7 +29,7 @@ type signalToMetrics struct {
 	collectorInstanceInfo model.CollectorInstanceInfo
 	logger                *zap.Logger
 
-	spanMetricDefs    []model.MetricDef[ottlspan.TransformContext]
+	spanMetricDefs    []model.MetricDef[*ottlspan.TransformContext]
 	dpMetricDefs      []model.MetricDef[ottldatapoint.TransformContext]
 	logMetricDefs     []model.MetricDef[ottllog.TransformContext]
 	profileMetricDefs []model.MetricDef[ottlprofile.TransformContext]
@@ -49,7 +49,7 @@ func (sm *signalToMetrics) ConsumeTraces(ctx context.Context, td ptrace.Traces)
 
 	processedMetrics := pmetric.NewMetrics()
 	processedMetrics.ResourceMetrics().EnsureCapacity(td.ResourceSpans().Len())
-	aggregator := aggregator.NewAggregator[ottlspan.TransformContext](processedMetrics)
+	aggregator := aggregator.NewAggregator[*ottlspan.TransformContext](processedMetrics)
 
 	for i := 0; i < td.ResourceSpans().Len(); i++ {
 		resourceSpan := td.ResourceSpans().At(i)
@@ -67,20 +67,24 @@ func (sm *signalToMetrics) ConsumeTraces(ctx context.Context, td ptrace.Traces)
 
 					// The transform context is created from original attributes so that the
 					// OTTL expressions are also applied on the original attributes.
-					tCtx := ottlspan.NewTransformContext(span, scopeSpan.Scope(), resourceSpan.Resource(), scopeSpan, resourceSpan)
+					tCtx := ottlspan.NewTransformContextPtr(span, scopeSpan.Scope(), resourceSpan.Resource(), scopeSpan, resourceSpan)
 					if md.Conditions != nil {
 						match, err := md.Conditions.Eval(ctx, tCtx)
 						if err != nil {
+							tCtx.Close()
 							return fmt.Errorf("failed to evaluate conditions: %w", err)
 						}
 						if !match {
+							tCtx.Close()
 							sm.logger.Debug("condition not matched, skipping", zap.String("name", md.Key.Name))
 							continue
 						}
 					}
 
 					filteredResAttrs := md.FilterResourceAttributes(resourceAttrs, sm.collectorInstanceInfo)
-					if err := aggregator.Aggregate(ctx, tCtx, md, filteredResAttrs, filteredSpanAttrs, 1); err != nil {
+					err := aggregator.Aggregate(ctx, tCtx, md, filteredResAttrs, filteredSpanAttrs, 1)
+					tCtx.Close()
+					if err != nil {
 						return err
 					}
 				}

connector/signaltometricsconnector/factory.go

@@ -50,10 +50,10 @@ func createTracesToMetrics(
 		return nil, fmt.Errorf("failed to create OTTL statement parser for spans: %w", err)
 	}
 
-	metricDefs := make([]model.MetricDef[ottlspan.TransformContext], 0, len(c.Spans))
+	metricDefs := make([]model.MetricDef[*ottlspan.TransformContext], 0, len(c.Spans))
 	for i := range c.Spans {
 		info := c.Spans[i]
-		var md model.MetricDef[ottlspan.TransformContext]
+		var md model.MetricDef[*ottlspan.TransformContext]
 		if err := md.FromMetricInfo(info, parser, set.TelemetrySettings); err != nil {
 			return nil, fmt.Errorf("failed to parse provided metric information; %w", err)
 		}