Use pointer when passing TransformContext around or calling into

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

Author: bogdandrutu

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

@@ -0,0 +1,30 @@
+# 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. 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.s
+
+# 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.BorrowContext(span, scopeSpan.Scope(), resourceSpan.Resource(), scopeSpan, resourceSpan)
 				multiError = errors.Join(multiError, spansCounter.update(ctx, span.Attributes(), scopeAttrs, resourceAttrs, sCtx))
+				ottlspan.ReturnContext(sCtx)
 
 				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,8 +33,8 @@ 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()
 	funcs[isRootSpan.Name()] = isRootSpan

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.BorrowContext(s, ss.Scope(), rs.Resource(), ss, rs)
+					defer ottlspan.ReturnContext(mtx)
 					_, 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,22 +67,26 @@ 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.BorrowContext(span, scopeSpan.Scope(), resourceSpan.Resource(), scopeSpan, resourceSpan)
 					if md.Conditions != nil {
 						match, err := md.Conditions.Eval(ctx, tCtx)
 						if err != nil {
+							ottlspan.ReturnContext(tCtx)
 							return fmt.Errorf("failed to evaluate conditions: %w", err)
 						}
 						if !match {
+							ottlspan.ReturnContext(tCtx)
 							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 {
+						ottlspan.ReturnContext(tCtx)
 						return err
 					}
+					ottlspan.ReturnContext(tCtx)
 				}
 			}
 		}

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)
 		}

connector/signaltometricsconnector/internal/customottl/adjustedcount.go

@@ -12,16 +12,16 @@ import (
 	"github.com/open-telemetry/opentelemetry-collector-contrib/pkg/sampling"
 )
 
-func NewAdjustedCountFactory() ottl.Factory[ottlspan.TransformContext] {
+func NewAdjustedCountFactory() ottl.Factory[*ottlspan.TransformContext] {
 	return ottl.NewFactory("AdjustedCount", nil, createAdjustedCountFunction)
 }
 
-func createAdjustedCountFunction(ottl.FunctionContext, ottl.Arguments) (ottl.ExprFunc[ottlspan.TransformContext], error) {
+func createAdjustedCountFunction(ottl.FunctionContext, ottl.Arguments) (ottl.ExprFunc[*ottlspan.TransformContext], error) {
 	return adjustedCount()
 }
 
-func adjustedCount() (ottl.ExprFunc[ottlspan.TransformContext], error) {
-	return func(_ context.Context, tCtx ottlspan.TransformContext) (any, error) {
+func adjustedCount() (ottl.ExprFunc[*ottlspan.TransformContext], error) {
+	return func(_ context.Context, tCtx *ottlspan.TransformContext) (any, error) {
 		tracestate := tCtx.GetSpan().TraceState().AsRaw()
 		w3cTraceState, err := sampling.NewW3CTraceState(tracestate)
 		if err != nil {