Change to not expose the context inferrer and removed the ignoreUnknownContext option

Author: edmocosta

pkg/ottl/context_inferrer.go

@@ -18,18 +18,17 @@ var (
 	}
 )
 
-// ContextInferrer is an interface used to infer the OTTL context from statements paths.
-type ContextInferrer interface {
-	// Infer returns the OTTL context inferred from the given statements paths.
-	Infer(statements []string) (string, error)
+// contextInferrer is an interface used to infer the OTTL context from statements paths.
+type contextInferrer interface {
+	// infer returns the OTTL context inferred from the given statements paths.
+	infer(statements []string) (string, error)
 }
 
 type priorityContextInferrer struct {
-	contextPriority      map[string]int
-	ignoreUnknownContext bool
+	contextPriority map[string]int
 }
 
-func (s *priorityContextInferrer) Infer(statements []string) (string, error) {
+func (s *priorityContextInferrer) infer(statements []string) (string, error) {
 	var inferredContext string
 	var inferredContextPriority int
 
@@ -42,10 +41,6 @@ func (s *priorityContextInferrer) Infer(statements []string) (string, error) {
 		for _, p := range getParsedStatementPaths(parsed) {
 			pathContextPriority, ok := s.contextPriority[p.Context]
 			if !ok {
-				if s.ignoreUnknownContext {
-					continue
-				}
-
 				// Lowest priority
 				pathContextPriority = math.MaxInt
 			}
@@ -60,26 +55,25 @@ func (s *priorityContextInferrer) Infer(statements []string) (string, error) {
 	return inferredContext, nil
 }
 
-// DefaultPriorityContextInferrer is like NewPriorityContextInferrer, but using the default
+// defaultPriorityContextInferrer is like newPriorityContextInferrer, but using the default
 // context priorities and ignoring unknown/non-prioritized contexts.
-func DefaultPriorityContextInferrer() ContextInferrer {
-	return NewPriorityContextInferrer(defaultContextInferPriority, false)
+func defaultPriorityContextInferrer() contextInferrer {
+	return newPriorityContextInferrer(defaultContextInferPriority)
 }
 
-// NewPriorityContextInferrer creates a new priority-based context inferrer.
+// newPriorityContextInferrer creates a new priority-based context inferrer.
 // To infer the context, it compares all [ottl.Path.Context] values, prioritizing them based
 // on the provide contextsPriority argument, the lower the context position is in the array,
 // the more priority it will have over other items.
 // If unknown/non-prioritized contexts are found on the statements, they can be either ignored
 // or considered when no other prioritized context is found. To skip unknown contexts, the
 // ignoreUnknownContext argument must be set to false.
-func NewPriorityContextInferrer(contextsPriority []string, ignoreUnknownContext bool) ContextInferrer {
+func newPriorityContextInferrer(contextsPriority []string) contextInferrer {
 	contextPriority := make(map[string]int, len(contextsPriority))
 	for i, ctx := range contextsPriority {
 		contextPriority[ctx] = i
 	}
 	return &priorityContextInferrer{
-		contextPriority:      contextPriority,
-		ignoreUnknownContext: ignoreUnknownContext,
+		contextPriority: contextPriority,
 	}
 }

pkg/ottl/context_inferrer_test.go

@@ -12,11 +12,10 @@ import (
 
 func Test_NewPriorityContextInferrer_Infer(t *testing.T) {
 	tests := []struct {
-		name          string
-		priority      []string
-		ignoreUnknown bool
-		statements    []string
-		expected      string
+		name       string
+		priority   []string
+		statements []string
+		expected   string
 	}{
 		{
 			name:       "with priority and contexts",
@@ -45,42 +44,27 @@ func Test_NewPriorityContextInferrer_Infer(t *testing.T) {
 			expected:   "foo",
 		},
 		{
-			name:          "with ignore unknown false",
-			priority:      []string{"foo", "bar"},
-			ignoreUnknown: false,
-			statements:    []string{"set(span.foo, true) where span.bar == true"},
-			expected:      "span",
-		},
-		{
-			name:          "with ignore unknown true",
-			priority:      []string{"foo", "bar"},
-			ignoreUnknown: true,
-			statements:    []string{"set(span.foo, true) where span.bar == true"},
-			expected:      "",
-		},
-		{
-			name:          "with ignore unknown true and mixed statement contexts",
-			priority:      []string{"foo", "span"},
-			ignoreUnknown: true,
-			statements:    []string{"set(bar.foo, true) where span.bar == true"},
-			expected:      "span",
+			name:       "with unknown context",
+			priority:   []string{"foo", "bar"},
+			statements: []string{"set(span.foo, true) where span.bar == true"},
+			expected:   "span",
 		},
 	}
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			inferrer := NewPriorityContextInferrer(tt.priority, tt.ignoreUnknown)
-			inferredContext, err := inferrer.Infer(tt.statements)
+			inferrer := newPriorityContextInferrer(tt.priority)
+			inferredContext, err := inferrer.infer(tt.statements)
 			require.NoError(t, err)
 			assert.Equal(t, tt.expected, inferredContext)
 		})
 	}
 }
 
 func Test_NewPriorityContextInferrer_InvalidStatement(t *testing.T) {
-	inferrer := NewPriorityContextInferrer([]string{"foo"}, false)
+	inferrer := newPriorityContextInferrer([]string{"foo"})
 	statements := []string{"set(foo.field,"}
-	_, err := inferrer.Infer(statements)
+	_, err := inferrer.infer(statements)
 	require.ErrorContains(t, err, "unexpected token")
 }
 
@@ -96,9 +80,8 @@ func Test_DefaultPriorityContextInferrer(t *testing.T) {
 		"instrumentation_scope",
 	}
 
-	inferrer := DefaultPriorityContextInferrer().(*priorityContextInferrer)
+	inferrer := defaultPriorityContextInferrer().(*priorityContextInferrer)
 	require.NotNil(t, inferrer)
-	require.False(t, inferrer.ignoreUnknownContext)
 
 	for pri, ctx := range expectedPriority {
 		require.Equal(t, pri, inferrer.contextPriority[ctx])