[pkg/ottl] Add Decode function

.chloggen/add-decode-function.yaml

@@ -0,0 +1,27 @@
+# Use this changelog template to create an entry for release notes.
+
+# One of 'breaking', 'deprecation', 'new_component', 'enhancement', 'bug_fix'
+change_type: enhancement
+
+# The name of the component, or a single word describing the area of concern, (e.g. filelogreceiver)
+component: pkg/ottl
+
+# A brief description of the change.  Surround your text with quotes ("") if it needs to start with a backtick (`).
+note: Added Decode() converter function
+
+# Mandatory: One or more tracking issues related to the change. You can use the PR number here if no issue exists.
+issues: [32493]
+
+# (Optional) One or more lines of additional information to render under the primary note.
+# These lines will be padded with 2 spaces and then inserted directly into the document.
+# Use pipe (|) for multiline entries.
+subtext:
+
+# If your change doesn't affect end users or the exported elements of any package,
+# you should instead start your pull request title with [chore] or use the "Skip Changelog" label.
+# Optional: The change log or logs in which this entry should be included.
+# e.g. '[user]' or '[user, api]'
+# Include 'user' if the change is relevant to end users.
+# Include 'api' if there is a change to a library API.
+# Default: '[user]'
+change_logs: []

pkg/ottl/e2e/e2e_test.go

@@ -311,6 +311,12 @@ func Test_e2e_converters(t *testing.T) {
 				tCtx.GetLogRecord().Attributes().PutStr("test", "pass")
 			},
 		},
+		{
+			statement: `set(attributes["test"], Decode("cGFzcw==", "base64"))`,
+			want: func(tCtx ottllog.TransformContext) {
+				tCtx.GetLogRecord().Attributes().PutStr("test", "pass")
+			},
+		},
 		{
 			statement: `set(attributes["test"], Concat(["A","B"], ":"))`,
 			want: func(tCtx ottllog.TransformContext) {

pkg/ottl/go.mod

@@ -21,6 +21,7 @@ require (
 	go.uber.org/zap v1.27.0
 	golang.org/x/exp v0.0.0-20240506185415-9bf2ced13842
 	golang.org/x/net v0.28.0
+	golang.org/x/text v0.17.0
 )
 
 require (
@@ -50,7 +51,6 @@ require (
 	go.opentelemetry.io/otel/sdk/metric v1.29.0 // indirect
 	go.uber.org/multierr v1.11.0 // indirect
 	golang.org/x/sys v0.24.0 // indirect
-	golang.org/x/text v0.17.0 // indirect
 	google.golang.org/genproto/googleapis/rpc v0.0.0-20240822170219-fc7c04adadcd // indirect
 	google.golang.org/grpc v1.66.0 // indirect
 	google.golang.org/protobuf v1.34.2 // indirect

pkg/ottl/ottlfuncs/README.md

@@ -410,6 +410,7 @@ Unlike functions, they do not modify any input telemetry and always return a val
 Available Converters:
 
 - [Base64Decode](#base64decode)
+- [Decode](#decode)
 - [Concat](#concat)
 - [ConvertCase](#convertcase)
 - [Day](#day)
@@ -465,7 +466,9 @@ Available Converters:
 - [UUID](#UUID)
 - [Year](#year)
 
-### Base64Decode
+### Base64Decode (Deprecated)
+
+*This function has been deprecated. Please use the [Decode](#decode) function instead.*
 
 `Base64Decode(value)`
 
@@ -480,6 +483,22 @@ Examples:
 
 - `Base64Decode(attributes["encoded field"])`
 
+### Decode
+
+`Decode(value, encoding)`
+
+The `Decode` Converter takes a string or byte array encoded with the specified encoding and returns the decoded string.
+
+`value` is a valid encoded string or byte array.
+`encoding` is a valid encoding name included in the [IANA encoding index](https://www.iana.org/assignments/character-sets/character-sets.xhtml).
+
+Examples:
+
+- `Decode("aGVsbG8gd29ybGQ=", "base64")`
+
+
+- `Decode(attributes["encoded field"], "us-ascii")`
+
 ### Concat
 
 `Concat(values[], delimiter)`

pkg/ottl/ottlfuncs/func_decode.go

@@ -0,0 +1,114 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+package ottlfuncs // import "github.com/open-telemetry/opentelemetry-collector-contrib/pkg/ottl/ottlfuncs"
+
+import (
+	"context"
+	"encoding/base64"
+	"fmt"
+	"strings"
+
+	"go.opentelemetry.io/collector/pdata/pcommon"
+	"golang.org/x/text/encoding"
+	"golang.org/x/text/encoding/ianaindex"
+	"golang.org/x/text/encoding/unicode"
+
+	"github.com/open-telemetry/opentelemetry-collector-contrib/pkg/ottl"
+)
+
+type DecodeArguments[K any] struct {
+	Target   ottl.Getter[K]
+	Encoding string
+}
+
+func NewDecodeFactory[K any]() ottl.Factory[K] {
+	return ottl.NewFactory("Decode", &DecodeArguments[K]{}, createDecodeFunction[K])
+}
+
+func createDecodeFunction[K any](_ ottl.FunctionContext, oArgs ottl.Arguments) (ottl.ExprFunc[K], error) {
+	args, ok := oArgs.(*DecodeArguments[K])
+	if !ok {
+		return nil, fmt.Errorf("DecodeFactory args must be of type *DecodeArguments[K]")
+	}
+
+	return Decode(args.Target, args.Encoding)
+}
+
+func Decode[K any](target ottl.Getter[K], encoding string) (ottl.ExprFunc[K], error) {
+	return func(ctx context.Context, tCtx K) (any, error) {
+		val, err := target.Get(ctx, tCtx)
+		if err != nil {
+			return nil, err
+		}
+		var stringValue string
+
+		switch v := val.(type) {
+		case []byte:
+			stringValue = string(v)
+		case *string:
+			stringValue = *v
+		case string:
+			stringValue = v
+		case pcommon.ByteSlice:
+			stringValue = string(v.AsRaw())
+		case *pcommon.ByteSlice:
+			stringValue = string(v.AsRaw())
+		case pcommon.Value:
+			stringValue = v.AsString()
+		case *pcommon.Value:
+			stringValue = v.AsString()
+		default:
+			return nil, fmt.Errorf("unsupported type provided to Decode function: %T", v)
+		}
+
+		switch encoding {
+		case "base64":
+			// base64 is not in IANA index, so we have to deal with this encoding separately
+			decodedBytes, err := base64.StdEncoding.DecodeString(stringValue)
+			if err != nil {
+				return nil, fmt.Errorf("could not decode: %w", err)
+			}
+			return string(decodedBytes), nil
+		default:
+			e, err := getEncoding(encoding)
+			if err != nil {
+				return nil, err
+			}
+
+			decodedString, err := e.NewDecoder().String(stringValue)
+			if err != nil {
+				return nil, fmt.Errorf("could not decode: %w", err)
+			}
+
+			return decodedString, nil
+		}
+	}, nil
+}
+
+func getEncoding(encoding string) (encoding.Encoding, error) {
+	if e, ok := encodingOverrides[strings.ToLower(encoding)]; ok {
+		return e, nil
+	}
+	e, err := ianaindex.IANA.Encoding(encoding)
+	if err != nil {
+		return nil, fmt.Errorf("could not get encoding for %s: %w", encoding, err)
+	}
+	if e == nil {
+		// for some encodings a nil error and a nil encoding is returned, so we need to double check
+		// if the encoding is actually set here
+		return nil, fmt.Errorf("no decoder available for encoding: %s", encoding)
+	}
+	return e, nil
+}
+
+var encodingOverrides = map[string]encoding.Encoding{
+	"":         unicode.UTF8,
+	"nop":      encoding.Nop,
+	"ascii":    unicode.UTF8,
+	"us-ascii": unicode.UTF8,
+	"utf8":     unicode.UTF8,
+	"utf-8":    unicode.UTF8,
+	"utf16":    unicode.UTF16(unicode.LittleEndian, unicode.IgnoreBOM),
+	"utf-16":   unicode.UTF16(unicode.LittleEndian, unicode.IgnoreBOM),
+}