[pkg/telemetryquerylanguage] Unexport unnessessary functions and types (

open-telemetry#13737)

This PR unexports several functions and types that do not need to be exposed

pkg/telemetryquerylanguage/functions/tqlcommon/func_set_test.go

@@ -42,15 +42,23 @@ func Test_set(t *testing.T) {
  {
  name: "set name",
  setter: target,
- getter: tql.Literal{Value: "new name"},
+ getter: tql.StandardGetSetter{
+ Getter: func(ctx tql.TransformContext) interface{} {
+ return "new name"
+ },
+ },
  want: func(expectedValue pcommon.Value) {
  expectedValue.SetStringVal("new name")
  },
  },
  {
  name: "set nil value",
  setter: target,
- getter: tql.Literal{Value: nil},
+ getter: tql.StandardGetSetter{
+ Getter: func(ctx tql.TransformContext) interface{} {
+ return nil
+ },
+ },
  want: func(expectedValue pcommon.Value) {
  expectedValue.SetStringVal("original name")
  },

pkg/telemetryquerylanguage/tql/boolean_value.go

@@ -18,8 +18,8 @@ import (
  "fmt"
 )
 
-// BoolExpressionEvaluator is a function that returns the result.
-type BoolExpressionEvaluator = func(ctx TransformContext) bool
+// boolExpressionEvaluator is a function that returns the result.
+type boolExpressionEvaluator = func(ctx TransformContext) bool
 
 var alwaysTrue = func(ctx TransformContext) bool {
  return true
@@ -30,8 +30,8 @@ var alwaysFalse = func(ctx TransformContext) bool {
 }
 
 // builds a function that returns a short-circuited result of ANDing
-// BoolExpressionEvaluator funcs
-func andFuncs(funcs []BoolExpressionEvaluator) BoolExpressionEvaluator {
+// boolExpressionEvaluator funcs
+func andFuncs(funcs []boolExpressionEvaluator) boolExpressionEvaluator {
  return func(ctx TransformContext) bool {
  for _, f := range funcs {
  if !f(ctx) {
@@ -43,8 +43,8 @@ func andFuncs(funcs []BoolExpressionEvaluator) BoolExpressionEvaluator {
 }
 
 // builds a function that returns a short-circuited result of ORing
-// BoolExpressionEvaluator funcs
-func orFuncs(funcs []BoolExpressionEvaluator) BoolExpressionEvaluator {
+// boolExpressionEvaluator funcs
+func orFuncs(funcs []boolExpressionEvaluator) boolExpressionEvaluator {
  return func(ctx TransformContext) bool {
  for _, f := range funcs {
  if f(ctx) {
@@ -55,15 +55,15 @@ func orFuncs(funcs []BoolExpressionEvaluator) BoolExpressionEvaluator {
  }
 }
 
-func (p *Parser) newComparisonEvaluator(comparison *Comparison) (BoolExpressionEvaluator, error) {
+func (p *Parser) newComparisonEvaluator(comparison *Comparison) (boolExpressionEvaluator, error) {
  if comparison == nil {
  return alwaysTrue, nil
  }
- left, err := p.NewGetter(comparison.Left)
+ left, err := p.newGetter(comparison.Left)
  if err != nil {
  return nil, err
  }
- right, err := p.NewGetter(comparison.Right)
+ right, err := p.newGetter(comparison.Right)
  if err != nil {
  return nil, err
  }
@@ -77,15 +77,15 @@ func (p *Parser) newComparisonEvaluator(comparison *Comparison) (BoolExpressionE
 
 }
 
-func (p *Parser) newBooleanExpressionEvaluator(expr *BooleanExpression) (BoolExpressionEvaluator, error) {
+func (p *Parser) newBooleanExpressionEvaluator(expr *BooleanExpression) (boolExpressionEvaluator, error) {
  if expr == nil {
  return alwaysTrue, nil
  }
  f, err := p.newBooleanTermEvaluator(expr.Left)
  if err != nil {
  return nil, err
  }
- funcs := []BoolExpressionEvaluator{f}
+ funcs := []boolExpressionEvaluator{f}
  for _, rhs := range expr.Right {
  f, err := p.newBooleanTermEvaluator(rhs.Term)
  if err != nil {
@@ -97,15 +97,15 @@ func (p *Parser) newBooleanExpressionEvaluator(expr *BooleanExpression) (BoolExp
  return orFuncs(funcs), nil
 }
 
-func (p *Parser) newBooleanTermEvaluator(term *Term) (BoolExpressionEvaluator, error) {
+func (p *Parser) newBooleanTermEvaluator(term *Term) (boolExpressionEvaluator, error) {
  if term == nil {
  return alwaysTrue, nil
  }
  f, err := p.newBooleanValueEvaluator(term.Left)
  if err != nil {
  return nil, err
  }
- funcs := []BoolExpressionEvaluator{f}
+ funcs := []boolExpressionEvaluator{f}
  for _, rhs := range term.Right {
  f, err := p.newBooleanValueEvaluator(rhs.Value)
  if err != nil {
@@ -117,7 +117,7 @@ func (p *Parser) newBooleanTermEvaluator(term *Term) (BoolExpressionEvaluator, e
  return andFuncs(funcs), nil
 }
 
-func (p *Parser) newBooleanValueEvaluator(value *BooleanValue) (BoolExpressionEvaluator, error) {
+func (p *Parser) newBooleanValueEvaluator(value *BooleanValue) (boolExpressionEvaluator, error) {
  if value == nil {
  return alwaysTrue, nil
  }

pkg/telemetryquerylanguage/tql/boolean_value_test.go

@@ -77,7 +77,7 @@ func comparison(left any, right any, op string) *Comparison {
 
 func Test_newComparisonEvaluator(t *testing.T) {
  p := NewParser(
- DefaultFunctionsForTests(),
+ defaultFunctionsForTests(),
  testParsePath,
  testParseEnum,
  NoOpLogger{},
@@ -128,7 +128,7 @@ func Test_newComparisonEvaluator(t *testing.T) {
 
 func Test_newConditionEvaluator_invalid(t *testing.T) {
  p := NewParser(
- DefaultFunctionsForTests(),
+ defaultFunctionsForTests(),
  testParsePath,
  testParseEnum,
  NoOpLogger{},
@@ -161,7 +161,7 @@ func Test_newConditionEvaluator_invalid(t *testing.T) {
 
 func Test_newBooleanExpressionEvaluator(t *testing.T) {
  p := NewParser(
- DefaultFunctionsForTests(),
+ defaultFunctionsForTests(),
  testParsePath,
  testParseEnum,
  NoOpLogger{},

pkg/telemetryquerylanguage/tql/expression.go

@@ -28,8 +28,6 @@ type TransformContext interface {
 
 type ExprFunc func(ctx TransformContext) interface{}
 
-type Enum int64
-
 type Getter interface {
  Get(ctx TransformContext) interface{}
 }
@@ -56,12 +54,12 @@ func (path StandardGetSetter) Set(ctx TransformContext, val interface{}) {
  path.Setter(ctx, val)
 }
 
-type Literal struct {
- Value interface{}
+type literal struct {
+ value interface{}
 }
 
-func (l Literal) Get(ctx TransformContext) interface{} {
- return l.Value
+func (l literal) Get(ctx TransformContext) interface{} {
+ return l.value
 }
 
 type exprGetter struct {
@@ -72,33 +70,33 @@ func (g exprGetter) Get(ctx TransformContext) interface{} {
  return g.expr(ctx)
 }
 
-func (p *Parser) NewGetter(val Value) (Getter, error) {
+func (p *Parser) newGetter(val Value) (Getter, error) {
  if val.IsNil != nil && *val.IsNil {
- return &Literal{Value: nil}, nil
+ return &literal{value: nil}, nil
  }
 
  if s := val.String; s != nil {
- return &Literal{Value: *s}, nil
+ return &literal{value: *s}, nil
  }
  if f := val.Float; f != nil {
- return &Literal{Value: *f}, nil
+ return &literal{value: *f}, nil
  }
  if i := val.Int; i != nil {
- return &Literal{Value: *i}, nil
+ return &literal{value: *i}, nil
  }
  if b := val.Bool; b != nil {
- return &Literal{Value: bool(*b)}, nil
+ return &literal{value: bool(*b)}, nil
  }
  if b := val.Bytes; b != nil {
- return &Literal{Value: ([]byte)(*b)}, nil
+ return &literal{value: ([]byte)(*b)}, nil
  }
 
  if val.Enum != nil {
  enum, err := p.enumParser(val.Enum)
  if err != nil {
  return nil, err
  }
- return &Literal{Value: int64(*enum)}, nil
+ return &literal{value: int64(*enum)}, nil
  }
 
  if val.Path != nil {
@@ -109,7 +107,7 @@ func (p *Parser) NewGetter(val Value) (Getter, error) {
  // In practice, can't happen since the DSL grammar guarantees one is set
  return nil, fmt.Errorf("no value field set. This is a bug in the Telemetry Query Language")
  }
- call, err := p.NewFunctionCall(*val.Invocation)
+ call, err := p.newFunctionCall(*val.Invocation)
  if err != nil {
  return nil, err
  }

pkg/telemetryquerylanguage/tql/expression_test.go

@@ -118,7 +118,7 @@ func Test_newGetter(t *testing.T) {
 
  for _, tt := range tests {
  t.Run(tt.name, func(t *testing.T) {
- reader, err := p.NewGetter(tt.val)
+ reader, err := p.newGetter(tt.val)
  assert.NoError(t, err)
  val := reader.Get(tqltest.TestTransformContext{
  Item: tt.want,
@@ -128,7 +128,7 @@ func Test_newGetter(t *testing.T) {
  }
 
  t.Run("empty value", func(t *testing.T) {
- _, err := p.NewGetter(Value{})
+ _, err := p.newGetter(Value{})
  assert.Error(t, err)
  })
 }

pkg/telemetryquerylanguage/tql/functions.go

@@ -23,8 +23,9 @@ type PathExpressionParser func(*Path) (GetSetter, error)
 
 type EnumParser func(*EnumSymbol) (*Enum, error)
 
-// NewFunctionCall Visible for testing
-func (p *Parser) NewFunctionCall(inv Invocation) (ExprFunc, error) {
+type Enum int64
+
+func (p *Parser) newFunctionCall(inv Invocation) (ExprFunc, error) {
  if f, ok := p.functions[inv.Function]; ok {
  args, err := p.buildArgs(inv, reflect.TypeOf(f))
  if err != nil {
@@ -126,7 +127,7 @@ func (p *Parser) buildSliceArg(inv Invocation, argType reflect.Type, startingInd
  case "Getter":
  var arg []Getter
  for j := startingIndex; j < len(inv.Arguments); j++ {
- val, err := p.NewGetter(inv.Arguments[j])
+ val, err := p.newGetter(inv.Arguments[j])
  if err != nil {
  return err
  }
@@ -151,7 +152,7 @@ func (p *Parser) buildArg(argDef Value, argType reflect.Type, index int, args *[
  }
  *args = append(*args, reflect.ValueOf(arg))
  case "Getter":
- arg, err := p.NewGetter(argDef)
+ arg, err := p.newGetter(argDef)
  if err != nil {
  return fmt.Errorf("invalid argument at position %v %w", index, err)
  }

pkg/telemetryquerylanguage/tql/functions_test.go

@@ -202,15 +202,15 @@ func Test_NewFunctionCall_invalid(t *testing.T) {
 
  for _, tt := range tests {
  t.Run(tt.name, func(t *testing.T) {
- _, err := p.NewFunctionCall(tt.inv)
+ _, err := p.newFunctionCall(tt.inv)
  assert.Error(t, err)
  })
  }
 }
 
 func Test_NewFunctionCall(t *testing.T) {
  p := NewParser(
- DefaultFunctionsForTests(),
+ defaultFunctionsForTests(),
  testParsePath,
  testParseEnum,
  NoOpLogger{},
@@ -533,7 +533,7 @@ func Test_NewFunctionCall(t *testing.T) {
  }
  for _, tt := range tests {
  t.Run(tt.name, func(t *testing.T) {
- _, err := p.NewFunctionCall(tt.inv)
+ _, err := p.newFunctionCall(tt.inv)
  assert.NoError(t, err)
  })
  }
@@ -648,7 +648,7 @@ func functionWithLoggerLast(_ string, _ string, _ int64, _ Logger) (ExprFunc, er
  }, nil
 }
 
-func DefaultFunctionsForTests() map[string]interface{} {
+func defaultFunctionsForTests() map[string]interface{} {
  functions := make(map[string]interface{})
  functions["testing_string_slice"] = functionWithStringSlice
  functions["testing_float_slice"] = functionWithFloatSlice

pkg/telemetryquerylanguage/tql/parser.go

@@ -158,7 +158,7 @@ type Field struct {
 // invocation and the expression to match telemetry for invoking the function.
 type Query struct {
  Function ExprFunc
- Condition BoolExpressionEvaluator
+ Condition boolExpressionEvaluator
 }
 
 // Bytes type for capturing byte arrays
@@ -218,7 +218,7 @@ func (p *Parser) ParseQueries(statements []string) ([]Query, error) {
  errors = multierr.Append(errors, err)
  continue
  }
- function, err := p.NewFunctionCall(parsed.Invocation)
+ function, err := p.newFunctionCall(parsed.Invocation)
  if err != nil {
  errors = multierr.Append(errors, err)
  continue