[pkg/ottl] Add parser utility to rewrite statements appending missing paths context

.chloggen/ottl-add-statement-context-append-utility.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: enhancement
+
+# The name of the component, or a single word describing the area of concern, (e.g. filelogreceiver)
+component: pkg/ottl
+
+# A brief description of the change.  Surround your text with quotes ("") if it needs to start with a backtick (`).
+note: Add OTTL parser utility to rewrite statements appending missing paths context
+
+# Mandatory: One or more tracking issues related to the change. You can use the PR number here if no issue exists.
+issues: [29017]
+
+# (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: "The `ottl.Parser[K]` has a new function `AppendStatementPathsContext`"
+
+# 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]

pkg/ottl/parser.go

@@ -7,6 +7,7 @@ import (
 	"context"
 	"errors"
 	"fmt"
+	"strings"
 
 	"github.com/alecthomas/participle/v2"
 	"go.opentelemetry.io/collector/component"
@@ -195,6 +196,33 @@ func (p *Parser[K]) ParseCondition(condition string) (*Condition[K], error) {
 	}, nil
 }
 
+// AppendStatementPathsContext changes the given OTTL statement adding the context name prefix
+// to all context-less paths. No modifications are performed for paths which [Path.Context]
+// value matches any WithPathContextNames value.
+// The context argument must be valid WithPathContextNames value, otherwise an error is returned.
+func (p *Parser[K]) AppendStatementPathsContext(context string, statement string) (string, error) {
+	if _, ok := p.pathContextNames[context]; !ok {
+		return statement, fmt.Errorf(`unknown context "%s" for parser %T, valid options are: %s`, context, p, p.buildPathContextNamesText(""))
+	}
+	parsed, err := parseStatement(statement)
+	if err != nil {
+		return "", err
+	}
+	paths := getParsedStatementPaths(parsed)
+	if len(paths) == 0 {
+		return statement, nil
+	}
+
+	var missingContextOffsets []int
+	for _, it := range paths {
+		if _, ok := p.pathContextNames[it.Context]; !ok {
+			missingContextOffsets = append(missingContextOffsets, it.Pos.Offset)
+		}
+	}
+
+	return writeStatementWithPathsContext(context, statement, missingContextOffsets), nil
+}
+
 var parser = newParser[parsedStatement]()
 var conditionParser = newParser[booleanExpression]()
 
@@ -226,6 +254,29 @@ func parseCondition(raw string) (*booleanExpression, error) {
 	return parsed, nil
 }
 
+func writeStatementWithPathsContext(context string, statement string, offsets []int) string {
+	if len(offsets) == 0 {
+		return statement
+	}
+
+	contextPrefix := context + "."
+	var sb strings.Builder
+	sb.Grow(len(statement) + (len(contextPrefix) * len(offsets)))
+
+	left := 0
+	for i, offset := range offsets {
+		sb.WriteString(statement[left:offset])
+		sb.WriteString(contextPrefix)
+		if i+1 >= len(offsets) {
+			sb.WriteString(statement[offset:])
+		} else {
+			left = offset
+		}
+	}
+
+	return sb.String()
+}
+
 // newParser returns a parser that can be used to read a string into a parsedStatement. An error will be returned if the string
 // is not formatted for the DSL.
 func newParser[G any]() *participle.Parser[G] {

pkg/ottl/parser_test.go

@@ -2714,3 +2714,141 @@ func Test_ConditionSequence_Eval_Error(t *testing.T) {
 		})
 	}
 }
+
+func Test_AppendStatementPathsContext_InvalidStatement(t *testing.T) {
+	ps, err := NewParser(
+		CreateFactoryMap[any](),
+		testParsePath[any],
+		componenttest.NewNopTelemetrySettings(),
+		WithEnumParser[any](testParseEnum),
+		WithPathContextNames[any]([]string{"foo", "bar"}),
+	)
+	require.NoError(t, err)
+	_, err = ps.AppendStatementPathsContext("foo", "this is invalid")
+	require.ErrorContains(t, err, `statement has invalid syntax`)
+}
+
+func Test_AppendStatementPathsContext_InvalidContext(t *testing.T) {
+	ps, err := NewParser(
+		CreateFactoryMap[any](),
+		testParsePath[any],
+		componenttest.NewNopTelemetrySettings(),
+		WithEnumParser[any](testParseEnum),
+		WithPathContextNames[any]([]string{"foo", "bar"}),
+	)
+	require.NoError(t, err)
+	_, err = ps.AppendStatementPathsContext("foobar", "set(foo, 1)")
+	require.ErrorContains(t, err, `unknown context "foobar" for parser`)
+}
+
+func Test_AppendStatementPathsContext_Success(t *testing.T) {
+	type mockSetArguments[K any] struct {
+		Target Setter[K]
+		Value  Getter[K]
+	}
+
+	mockSetFactory := NewFactory("set", &mockSetArguments[any]{}, func(_ FunctionContext, _ Arguments) (ExprFunc[any], error) {
+		return func(_ context.Context, _ any) (any, error) {
+			return nil, nil
+		}, nil
+	})
+
+	tests := []struct {
+		name             string
+		statement        string
+		context          string
+		pathContextNames []string
+		expected         string
+	}{
+		{
+			name:      "no paths",
+			statement: `set("foo", 1)`,
+			context:   "bar",
+		},
+		{
+			name:      "single path with context",
+			statement: `set(span.value, 1)`,
+			context:   "span",
+		},
+		{
+			name:      "single path without context",
+			statement: "set(value, 1)",
+			expected:  "set(span.value, 1)",
+			context:   "span",
+		},
+		{
+			name:             "single path with context - multiple context names",
+			statement:        "set(span.value, 1)",
+			pathContextNames: []string{"spanevent", "span"},
+			context:          "spanevent",
+		},
+		{
+			name:             "multiple paths with the same context",
+			statement:        `set(span.value, 1) where span.attributes["foo"] == "foo" and span.id == 1`,
+			pathContextNames: []string{"another", "span"},
+			context:          "another",
+		},
+		{
+			name:             "multiple paths with different contexts",
+			statement:        `set(another.value, 1) where span.attributes["foo"] == "foo" and another.id == 1`,
+			pathContextNames: []string{"another", "span"},
+			context:          "another",
+		},
+		{
+			name:             "multiple paths with and without contexts",
+			statement:        `set(value, 1) where span.attributes["foo"] == "foo" and id == 1`,
+			expected:         `set(spanevent.value, 1) where span.attributes["foo"] == "foo" and spanevent.id == 1`,
+			pathContextNames: []string{"spanevent", "span"},
+			context:          "spanevent",
+		},
+		{
+			name:      "multiple paths without context",
+			statement: `set(value, 1) where name == attributes["foo.name"]`,
+			expected:  `set(span.value, 1) where span.name == span.attributes["foo.name"]`,
+			context:   "span",
+		},
+		{
+			name:      "function path parameter without context",
+			statement: `set(attributes["test"], "pass") where IsMatch(name, "operation[AC]")`,
+			context:   "log",
+			expected:  `set(log.attributes["test"], "pass") where IsMatch(log.name, "operation[AC]")`,
+		},
+		{
+			name:             "function path parameter with context",
+			statement:        `set(attributes["test"], "pass") where IsMatch(resource.name, "operation[AC]")`,
+			context:          "log",
+			pathContextNames: []string{"log", "resource"},
+			expected:         `set(log.attributes["test"], "pass") where IsMatch(resource.name, "operation[AC]")`,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if len(tt.pathContextNames) == 0 {
+				tt.pathContextNames = append(tt.pathContextNames, tt.context)
+			}
+
+			ps, err := NewParser(
+				CreateFactoryMap[any](mockSetFactory),
+				testParsePath[any],
+				componenttest.NewNopTelemetrySettings(),
+				WithEnumParser[any](testParseEnum),
+				WithPathContextNames[any](tt.pathContextNames),
+			)
+
+			require.NoError(t, err)
+			require.NotNil(t, ps)
+
+			var expected string
+			if tt.expected != "" {
+				expected = tt.expected
+			} else {
+				expected = tt.statement
+			}
+
+			result, err := ps.AppendStatementPathsContext(tt.context, tt.statement)
+			require.NoError(t, err)
+			assert.Equal(t, expected, result)
+		})
+	}
+}