move scale function to transformprocessor

Signed-off-by: Florian Bacher <[email protected]>

Author: bacherfl

pkg/ottl/ottlfuncs/README.md

@@ -59,7 +59,6 @@ Available Editors:
 - [replace_pattern](#replace_pattern)
 - [set](#set)
 - [truncate_all](#truncate_all)
-- [scale_metric](#scale_metric)
 
 ### append
 
@@ -403,22 +402,6 @@ Examples:
 
 - `truncate_all(resource.attributes, 50)`
 
-### scale_metric
-
-`scale_metric(factor)`
-
-The `scale_metric` function multiplies the values in the data points in the metric by the `factor`.
-The supported data types are:
-
-- `data_points` - Supported metric types are `Gauge`, `Sum` and `Histogram`.
-  To scale a metric of these types, the `data_points` property of the respective metric needs to be passed to the function,
-  as indicated in the examples below.
-
-Examples:
-
-- `scale_metric(10.0, 0.1)`: Trivial example
-- `scale_metric(data_points, 10.0)`: Modifies the metric's `data_points` by multiplying them with the factor `10.0`.
-
 ## Converters
 
 Converters are pure functions that take OTTL values as input and output a single value for use within a statement.

pkg/ottl/ottlfuncs/functions.go

@@ -23,7 +23,6 @@ func StandardFuncs[K any]() map[string]ottl.Factory[K] {
 		NewReplacePatternFactory[K](),
 		NewSetFactory[K](),
 		NewTruncateAllFactory[K](),
-		NewScaleFactory[K](),
 	}
 	f = append(f, converters[K]()...)
 

processor/transformprocessor/README.md

@@ -212,6 +212,7 @@ In addition to OTTL functions, the processor defines its own functions to help w
 - [convert_summary_count_val_to_sum](#convert_summary_count_val_to_sum)
 - [convert_summary_sum_val_to_sum](#convert_summary_sum_val_to_sum)
 - [copy_metric](#copy_metric)
+- [scale_metric](#scale_metric)
 
 ### convert_sum_to_gauge
 
@@ -347,6 +348,21 @@ Examples:
 
 - `copy_metric(desc="new desc") where description == "old desc"`
 
+### scale_metric
+
+`scale_metric(factor,unit)`
+
+The `scale_metric` function multiplies the values in the data points in the metric by the `factor`.
+If set to a non-empty string, the metric's unit will be set to `unit`.
+The supported data types are:
+
+Supported metric types are `Gauge`, `Sum` and `Histogram`.
+
+Examples:
+
+- `scale_metric(0.1,"")`: Scale the metric by a factor of `0.1`. The unit of the metric will not be modified.
+- `scale_metric(10.0, "kWh")`: Scale the metric by a factor of `10.0` and sets the unit to `kWh`.
+
 ## Examples
 
 ### Perform transformation if field does not exist

pkg/ottl/ottlfuncs/func_scale.go renamed to processor/transformprocessor/internal/metrics/func_scale.go

@@ -1,7 +1,7 @@
 // Copyright The OpenTelemetry Authors
 // SPDX-License-Identifier: Apache-2.0
 
-package ottlfuncs // import "github.com/open-telemetry/opentelemetry-collector-contrib/pkg/ottl/ottlfuncs"
+package metrics // import "github.com/open-telemetry/opentelemetry-collector-contrib/pkg/ottl/ottlfuncs"
 
 import (
 	"context"
@@ -11,60 +11,52 @@ import (
 	"go.opentelemetry.io/collector/pdata/pmetric"
 
 	"github.com/open-telemetry/opentelemetry-collector-contrib/pkg/ottl"
+	"github.com/open-telemetry/opentelemetry-collector-contrib/pkg/ottl/contexts/ottlmetric"
 )
 
-type ScaleArguments[K any] struct {
-	Value      ottl.GetSetter[K]
+type ScaleArguments struct {
 	Multiplier float64
+	Unit       string
 }
 
-func NewScaleFactory[K any]() ottl.Factory[K] {
-	return ottl.NewFactory("scale_metric", &ScaleArguments[K]{}, createScaleFunction[K])
+func newScaleMetricFactory() ottl.Factory[ottlmetric.TransformContext] {
+	return ottl.NewFactory("scale_metric", &ScaleArguments{}, createScaleFunction)
 }
 
-func createScaleFunction[K any](_ ottl.FunctionContext, oArgs ottl.Arguments) (ottl.ExprFunc[K], error) {
-	args, ok := oArgs.(*ScaleArguments[K])
+func createScaleFunction(_ ottl.FunctionContext, oArgs ottl.Arguments) (ottl.ExprFunc[ottlmetric.TransformContext], error) {
+	args, ok := oArgs.(*ScaleArguments)
 
 	if !ok {
 		return nil, fmt.Errorf("ScaleFactory args must be of type *ScaleArguments[K]")
 	}
 
-	return Scale(args.Value, args.Multiplier)
+	return Scale(*args)
 }
 
-func Scale[K any](getSetter ottl.GetSetter[K], multiplier float64) (ottl.ExprFunc[K], error) {
-	return func(ctx context.Context, tCtx K) (any, error) {
-		got, err := getSetter.Get(ctx, tCtx)
-		if err != nil {
-			return nil, err
-		}
-
-		switch value := got.(type) {
-		case pmetric.NumberDataPointSlice:
-			scaleMetric(value, multiplier)
-			return nil, nil
-		case pmetric.HistogramDataPointSlice:
-			scaleHistogram(value, multiplier)
-			return nil, nil
-		case pmetric.SummaryDataPointValueAtQuantileSlice:
-			scaleSummaryDataPointValueAtQuantileSlice(value, multiplier)
-			return nil, nil
-		case pmetric.ExemplarSlice:
-			scaleExemplarSlice(value, multiplier)
-			return nil, nil
-		case pmetric.ExponentialHistogramDataPointSlice:
+func Scale(args ScaleArguments) (ottl.ExprFunc[ottlmetric.TransformContext], error) {
+	return func(ctx context.Context, tCtx ottlmetric.TransformContext) (any, error) {
+		metric := tCtx.GetMetric()
+
+		switch metric.Type() {
+		case pmetric.MetricTypeGauge:
+			scaleMetric(metric.Gauge().DataPoints(), args.Multiplier)
+		case pmetric.MetricTypeHistogram:
+			scaleHistogram(metric.Histogram().DataPoints(), args.Multiplier)
+		case pmetric.MetricTypeSummary:
+			scaleSummarySlice(metric.Summary().DataPoints(), args.Multiplier)
+		case pmetric.MetricTypeSum:
+			scaleMetric(metric.Sum().DataPoints(), args.Multiplier)
+		case pmetric.MetricTypeExponentialHistogram:
 			return nil, errors.New("exponential histograms are not supported by the 'scale_metric' function")
 		default:
-			return nil, fmt.Errorf("unsupported data type: '%T'", value)
+			return nil, fmt.Errorf("unsupported metric type: '%v'", metric.Type())
 		}
-	}, nil
-}
 
-func scaleExemplarSlice(values pmetric.ExemplarSlice, multiplier float64) {
-	for i := 0; i < values.Len(); i++ {
-		ex := values.At(i)
-		scaleExemplar(&ex, multiplier)
-	}
+		if args.Unit != "" {
+			metric.SetUnit(args.Unit)
+		}
+		return nil, nil
+	}, nil
 }
 
 func scaleExemplar(ex *pmetric.Exemplar, multiplier float64) {
@@ -76,11 +68,16 @@ func scaleExemplar(ex *pmetric.Exemplar, multiplier float64) {
 	}
 }
 
-func scaleSummaryDataPointValueAtQuantileSlice(values pmetric.SummaryDataPointValueAtQuantileSlice, multiplier float64) {
+func scaleSummarySlice(values pmetric.SummaryDataPointSlice, multiplier float64) {
 	for i := 0; i < values.Len(); i++ {
 		dp := values.At(i)
 
-		dp.SetValue(dp.Value() * multiplier)
+		dp.SetSum(dp.Sum() * multiplier)
+
+		for i := 0; i < dp.QuantileValues().Len(); i++ {
+			qv := dp.QuantileValues().At(i)
+			qv.SetValue(qv.Value() * multiplier)
+		}
 	}
 }