reduce verbosity a bit

Signed-off-by: Pedro Tanaka <[email protected]>

Author: pedro-stanaka

execution/execution.go

@@ -59,79 +59,44 @@ func New(ctx context.Context, expr logicalplan.Node, storage storage.Scanners, o
 }
 
 func newOperator(ctx context.Context, expr logicalplan.Node, storage storage.Scanners, opts *query.Options, hints promstorage.SelectHints) (model.VectorOperator, error) {
-	span, ctx := tracing.StartSpanFromContext(ctx, "execution.newOperator")
-	defer span.Finish()
-	span.SetTag("expr_type", parser.DocumentedType(expr.ReturnType()))
-	span.SetTag("expr", expr.String())
-
 	switch e := expr.(type) {
 	case *logicalplan.NumberLiteral:
-		span.SetTag("operator_type", "number_literal")
 		return scan.NewNumberLiteralSelector(model.NewVectorPool(opts.StepsBatch), opts, e.Val), nil
 	case *logicalplan.VectorSelector:
-		span.SetTag("operator_type", "vector_selector")
 		return newVectorSelector(ctx, e, storage, opts, hints)
 	case *logicalplan.FunctionCall:
-		span.SetTag("operator_type", "function_call")
-		span.SetTag("function_name", e.Func.Name)
 		return newCall(ctx, e, storage, opts, hints)
 	case *logicalplan.Aggregation:
-		span.SetTag("operator_type", "aggregation")
-		span.SetTag("aggregation_op", e.Op.String())
 		return newAggregateExpression(ctx, e, storage, opts, hints)
 	case *logicalplan.Binary:
-		span.SetTag("operator_type", "binary")
-		span.SetTag("binary_op", e.Op.String())
 		return newBinaryExpression(ctx, e, storage, opts, hints)
 	case *logicalplan.Parens:
-		span.SetTag("operator_type", "parens")
 		return newOperator(ctx, e.Expr, storage, opts, hints)
 	case *logicalplan.Unary:
-		span.SetTag("operator_type", "unary")
-		span.SetTag("unary_op", e.Op.String())
 		return newUnaryExpression(ctx, e, storage, opts, hints)
 	case *logicalplan.StepInvariantExpr:
-		span.SetTag("operator_type", "step_invariant")
 		return newStepInvariantExpression(ctx, e, storage, opts, hints)
 	case logicalplan.Deduplicate:
-		span.SetTag("operator_type", "deduplicate")
 		return newDeduplication(ctx, e, storage, opts, hints)
 	case logicalplan.RemoteExecution:
-		span.SetTag("operator_type", "remote_execution")
 		return newRemoteExecution(ctx, e, opts, hints)
 	case *logicalplan.CheckDuplicateLabels:
-		span.SetTag("operator_type", "check_duplicate_labels")
 		return newDuplicateLabelCheck(ctx, e, storage, opts, hints)
 	case logicalplan.Noop:
-		span.SetTag("operator_type", "noop")
 		return noop.NewOperator(opts), nil
 	case logicalplan.UserDefinedExpr:
-		span.SetTag("operator_type", "user_defined")
 		return e.MakeExecutionOperator(ctx, model.NewVectorPool(opts.StepsBatch), opts, hints)
 	default:
-		err := errors.Wrapf(parse.ErrNotSupportedExpr, "got: %s (%T)", e, e)
-		tracing.LogError(span, err)
-		return nil, err
+		return nil, errors.Wrapf(parse.ErrNotSupportedExpr, "got: %s (%T)", e, e)
 	}
 }
 
 func newVectorSelector(ctx context.Context, e *logicalplan.VectorSelector, scanners storage.Scanners, opts *query.Options, hints promstorage.SelectHints) (model.VectorOperator, error) {
-	span, ctx := tracing.StartSpanFromContext(ctx, "execution.newVectorSelector")
-	defer span.Finish()
-	span.SetTag("vector_selector", e.String())
-
 	start, end := getTimeRangesForVectorSelector(e, opts, 0)
 	hints.Start = start
 	hints.End = end
 
-	span.SetTag("start_time", start)
-	span.SetTag("end_time", end)
-
-	op, err := scanners.NewVectorSelector(ctx, opts, hints, *e)
-	if err != nil {
-		tracing.LogError(span, err)
-	}
-	return op, err
+	return scanners.NewVectorSelector(ctx, opts, hints, *e)
 }
 
 func newCall(ctx context.Context, e *logicalplan.FunctionCall, scanners storage.Scanners, opts *query.Options, hints promstorage.SelectHints) (model.VectorOperator, error) {