Removed WithPathContextNameValidation option

Author: edmocosta

pkg/ottl/functions.go

@@ -78,28 +78,23 @@ func (p *Parser[K]) newPath(path *path) (*basePath[K], error) {
 }
 
 func (p *Parser[K]) parsePathContext(path *path) (string, []field, error) {
-	fields := path.Fields
-	var pathContext string
+	hasPathContextNames := len(p.pathContextNames) > 0
 	if path.Context != "" {
-		// nil or empty pathContextNames means the Parser isn't handling the grammar path's
-		// context yet, so it falls back to the previous behavior with the path.Context value
-		// as the first path's segment.
-		if p.pathContextNames == nil || len(p.pathContextNames) == 0 {
-			fields = append([]field{{Name: path.Context}}, fields...)
+		// no pathContextNames means the Parser isn't handling the grammar path's context yet,
+		// so it falls back to the previous behavior with the path.Context value as the first
+		// path's segment.
+		if !hasPathContextNames {
+			return "", append([]field{{Name: path.Context}}, path.Fields...), nil
 		} else if _, ok := p.pathContextNames[path.Context]; !ok {
-			if p.validatePathContextNames {
-				return "", nil, fmt.Errorf(`context "%s" from path "%s" is not valid, it must be replaced by one of: %s`, path.Context, buildOriginalText(path), p.buildPathContextNamesText(""))
-			}
-			fields = append([]field{{Name: path.Context}}, fields...)
-		} else {
-			pathContext = path.Context
+			return "", path.Fields, fmt.Errorf(`context "%s" from path "%s" is not valid, it must be replaced by one of: %s`, path.Context, buildOriginalText(path), p.buildPathContextNamesText(""))
 		}
-	} else if p.validatePathContextNames {
+		return path.Context, path.Fields, nil
+	} else if hasPathContextNames {
 		originalText := buildOriginalText(path)
 		return "", nil, fmt.Errorf(`missing context name for path "%s", valid options are: %s`, originalText, p.buildPathContextNamesText(originalText))
 	}
 
-	return pathContext, fields, nil
+	return "", path.Fields, nil
 }
 
 func (p *Parser[K]) buildPathContextNamesText(path string) string {

pkg/ottl/functions_test.go

@@ -2402,52 +2402,34 @@ func Test_newPath(t *testing.T) {
 
 func Test_newPath_WithPathContextNames(t *testing.T) {
 	tests := []struct {
-		name                 string
-		pathContext          string
-		pathContextNames     []string
-		validationEnabled    bool
-		contextParsedAsField bool
-		expectedError        bool
+		name             string
+		pathContext      string
+		pathContextNames []string
+		expectedError    string
 	}{
 		{
-			name:             "with no context",
+			name:             "with no path context",
 			pathContextNames: []string{"log"},
+			expectedError:    `missing context name for path "body.string[key]", valid options are: "log.body.string[key]"`,
 		},
 		{
-			name:             "with context",
+			name: "with no path context and configuration",
+		},
+		{
+			name:             "with valid path context",
 			pathContext:      "log",
 			pathContextNames: []string{"log"},
 		},
 		{
-			name:             "with multiple contexts",
+			name:             "with invalid path context",
 			pathContext:      "span",
-			pathContextNames: []string{"log", "span"},
-		},
-		{
-			name:                 "with invalid context and validation disabled",
-			pathContext:          "span",
-			pathContextNames:     []string{"log"},
-			validationEnabled:    false,
-			contextParsedAsField: true,
-		},
-		{
-			name:              "with invalid context and validation enabled",
-			pathContext:       "span",
-			pathContextNames:  []string{"log"},
-			validationEnabled: true,
-			expectedError:     true,
-		},
-		{
-			name:              "with valid context and validation enabled",
-			pathContext:       "spanevent",
-			pathContextNames:  []string{"spanevent"},
-			validationEnabled: true,
+			pathContextNames: []string{"log"},
+			expectedError:    `context "span" from path "span.body.string[key]" is not valid, it must be replaced by one of: "log"`,
 		},
 		{
-			name:              "with no context and validation enabled",
-			pathContextNames:  []string{"spanevent"},
-			validationEnabled: true,
-			expectedError:     true,
+			name:             "with multiple configured contexts",
+			pathContext:      "span",
+			pathContextNames: []string{"log", "span"},
 		},
 	}
 
@@ -2459,7 +2441,6 @@ func Test_newPath_WithPathContextNames(t *testing.T) {
 				componenttest.NewNopTelemetrySettings(),
 				WithEnumParser[any](testParseEnum),
 				WithPathContextNames[any](tt.pathContextNames),
-				WithPathContextNameValidation[any](tt.validationEnabled),
 			)
 
 			gp := &path{
@@ -2479,13 +2460,14 @@ func Test_newPath_WithPathContextNames(t *testing.T) {
 				}}
 
 			np, err := ps.newPath(gp)
-			if tt.expectedError {
-				assert.Error(t, err)
+			if tt.expectedError != "" {
+				assert.Error(t, err, tt.expectedError)
 				return
 			}
 			assert.NoError(t, err)
 			p := Path[any](np)
-			if tt.contextParsedAsField {
+			contextParsedAsField := len(tt.pathContextNames) == 0 && tt.pathContext != ""
+			if contextParsedAsField {
 				assert.Equal(t, tt.pathContext, p.Name())
 				assert.Equal(t, "", p.Context())
 				assert.Nil(t, p.Keys())
@@ -2500,13 +2482,13 @@ func Test_newPath_WithPathContextNames(t *testing.T) {
 			assert.Equal(t, "body", p.Name())
 			assert.Nil(t, p.Keys())
 			assert.Equal(t, bodyStringFuncValue, p.String())
-			if !tt.contextParsedAsField {
+			if !contextParsedAsField {
 				assert.Equal(t, tt.pathContext, p.Context())
 			}
 			p = p.Next()
 			assert.Equal(t, "string", p.Name())
 			assert.Equal(t, bodyStringFuncValue, p.String())
-			if !tt.contextParsedAsField {
+			if !contextParsedAsField {
 				assert.Equal(t, tt.pathContext, p.Context())
 			}
 			assert.Nil(t, p.Next())

pkg/ottl/parser.go

@@ -63,12 +63,11 @@ func (c *Condition[K]) Eval(ctx context.Context, tCtx K) (bool, error) {
 // Parser provides the means to parse OTTL StatementSequence and Conditions given a specific set of functions,
 // a PathExpressionParser, and an EnumParser.
 type Parser[K any] struct {
-	functions                map[string]Factory[K]
-	pathParser               PathExpressionParser[K]
-	enumParser               EnumParser
-	telemetrySettings        component.TelemetrySettings
-	pathContextNames         map[string]bool
-	validatePathContextNames bool
+	functions         map[string]Factory[K]
+	pathParser        PathExpressionParser[K]
+	enumParser        EnumParser
+	telemetrySettings component.TelemetrySettings
+	pathContextNames  map[string]bool
 }
 
 func NewParser[K any](
@@ -102,21 +101,11 @@ func WithEnumParser[K any](parser EnumParser) Option[K] {
 	}
 }
 
-// WithPathContextNameValidation turns the validation mode on/off for the Path's contexts.
-// When enabled, and WithPathContextNames is configured, it requires all Path's to be prefixed
-// with a valid context name, matching at least one configured WithPathContextNames value.
-func WithPathContextNameValidation[K any](enabled bool) Option[K] {
-	return func(p *Parser[K]) {
-		p.validatePathContextNames = enabled
-	}
-}
-
 // WithPathContextNames sets the context names to be considered when parsing a Path value.
 // When this option is empty or nil, all Path segments are considered fields, and the
 // Path.Context value is always empty.
-// When this option is configured, and the first path segment is not present in this context
-// names list, it either parses the whole Path as fields, without a Path.Context value,
-// or results into an error, depending on the WithPathContextNameValidation config.
+// When this option is configured, and the path's context is empty or is not present in
+// this context names list, it results into an error.
 func WithPathContextNames[K any](contexts []string) Option[K] {
 	return func(p *Parser[K]) {
 		pathContextNames := make(map[string]bool, len(contexts))