[pkg/ottl] Add ParseJSON factory function

.chloggen/ottl-parse-to-map.yaml

@@ -0,0 +1,16 @@
+# 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: Add new `ParseJSON` function that can convert a json string into `pcommon.Map`.
+
+# One or more tracking issues related to the change
+issues: [16444]
+
+# (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:

pkg/ottl/go.mod

@@ -6,6 +6,7 @@ require (
 	github.com/alecthomas/participle/v2 v2.0.0-beta.5
 	github.com/gobwas/glob v0.2.3
 	github.com/iancoleman/strcase v0.2.0
+	github.com/json-iterator/go v1.1.12
 	github.com/stretchr/testify v1.8.1
 	go.opentelemetry.io/collector/component v0.65.0
 	go.opentelemetry.io/collector/pdata v0.65.0
@@ -20,7 +21,6 @@ require (
 	github.com/fsnotify/fsnotify v1.6.0 // indirect
 	github.com/gogo/protobuf v1.3.2 // indirect
 	github.com/golang/protobuf v1.5.2 // indirect
-	github.com/json-iterator/go v1.1.12 // indirect
 	github.com/knadh/koanf v1.4.4 // indirect
 	github.com/kr/pretty v0.3.0 // indirect
 	github.com/mitchellh/copystructure v1.2.0 // indirect

pkg/ottl/ottlfuncs/README.md

@@ -37,6 +37,7 @@ List of available Factory Functions:
 - [ConvertCase](#convertcase)
 - [Int](#int)
 - [IsMatch](#ismatch)
+- [ParseJSON](#ParseJSON)
 - [SpanID](#spanid)
 - [Split](#split)
 - [TraceID](#traceid)
@@ -126,6 +127,36 @@ Examples:
 
 - `IsMatch("string", ".*ring")`
 
+### ParseJSON
+
+`ParseJSON(target)`
+
+The `ParseJSON` factory function returns a `pcommon.Map` struct that is a result of parsing the target string as JSON
+
+`target` is a Getter that returns a string. This string should be in json format.
+
+Unmarshalling is done using [jsoniter](https://github.com/json-iterator/go).
+Each JSON type is converted into a `pdata.Value` using the following map:
+
+```
+JSON boolean -> bool
+JSON number  -> float64
+JSON string  -> string
+JSON null    -> nil
+JSON arrays  -> pdata.SliceValue
+JSON objects -> map[string]any
+```
+
+Examples:
+
+- `ParseJSON("{\"attr\":true}")`
+
+
+- `ParseJSON(attributes["kubernetes"])`
+
+
+- `ParseJSON(body)`
+
 ### SpanID
 
 `SpanID(bytes)`

pkg/ottl/ottlfuncs/func_parse_json.go

@@ -0,0 +1,58 @@
+// Copyright The OpenTelemetry Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package ottlfuncs // import "github.com/open-telemetry/opentelemetry-collector-contrib/pkg/ottl/ottlfuncs"
+
+import (
+	"context"
+	jsoniter "github.com/json-iterator/go"
+	"go.opentelemetry.io/collector/pdata/pcommon"
+
+	"github.com/open-telemetry/opentelemetry-collector-contrib/pkg/ottl"
+)
+
+// ParseJSON factory function returns a `pcommon.Map` struct that is a result of parsing the target string as JSON
+// Each JSON type is converted into a `pdata.Value` using the following map:
+//
+//	JSON boolean -> bool
+//	JSON number  -> float64
+//	JSON string  -> string
+//	JSON null    -> nil
+//	JSON arrays  -> pdata.SliceValue
+//	JSON objects -> map[string]any
+func ParseJSON[K any](target ottl.Getter[K]) (ottl.ExprFunc[K], error) {
+	return func(ctx context.Context, tCtx K) (interface{}, error) {
+		targetVal, err := target.Get(ctx, tCtx)
+		if err != nil {
+			return nil, err
+		}
+		if jsonStr, ok := targetVal.(string); ok {
+			var parsedValue map[string]interface{}
+			err := jsoniter.UnmarshalFromString(jsonStr, &parsedValue)
+			if err != nil {
+				return pcommon.Map{}, err
+			}
+			result := pcommon.NewMap()
+			for k, v := range parsedValue {
+				attrVal := result.PutEmpty(k)
+				err = attrVal.FromRaw(v)
+				if err != nil {
+					return pcommon.Map{}, err
+				}
+			}
+			return result, nil
+		}
+		return nil, nil
+	}, nil
+}

pkg/ottl/ottlfuncs/func_parse_json_test.go

@@ -0,0 +1,173 @@
+// Copyright The OpenTelemetry Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package ottlfuncs // import "github.com/open-telemetry/opentelemetry-collector-contrib/pkg/ottl/ottlfuncs"
+
+import (
+	"context"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"go.opentelemetry.io/collector/pdata/pcommon"
+
+	"github.com/open-telemetry/opentelemetry-collector-contrib/pkg/ottl"
+)
+
+func Test_ParseJSON(t *testing.T) {
+	tests := []struct {
+		name   string
+		target ottl.Getter[any]
+		want   func(pcommon.Map)
+	}{
+		{
+			name: "handle string",
+			target: ottl.StandardGetSetter[any]{
+				Getter: func(ctx context.Context, tCtx any) (interface{}, error) {
+					return `{"test":"string value"}`, nil
+				},
+			},
+			want: func(expectedMap pcommon.Map) {
+				expectedMap.PutStr("test", "string value")
+			},
+		},
+		{
+			name: "handle bool",
+			target: ottl.StandardGetSetter[any]{
+				Getter: func(ctx context.Context, tCtx any) (interface{}, error) {
+					return `{"test":true}`, nil
+				},
+			},
+			want: func(expectedMap pcommon.Map) {
+				expectedMap.PutBool("test", true)
+			},
+		},
+		{
+			name: "handle int",
+			target: ottl.StandardGetSetter[any]{
+				Getter: func(ctx context.Context, tCtx any) (interface{}, error) {
+					return `{"test":1}`, nil
+				},
+			},
+			want: func(expectedMap pcommon.Map) {
+				expectedMap.PutDouble("test", 1)
+			},
+		},
+		{
+			name: "handle float",
+			target: ottl.StandardGetSetter[any]{
+				Getter: func(ctx context.Context, tCtx any) (interface{}, error) {
+					return `{"test":1.1}`, nil
+				},
+			},
+			want: func(expectedMap pcommon.Map) {
+				expectedMap.PutDouble("test", 1.1)
+			},
+		},
+		{
+			name: "handle nil",
+			target: ottl.StandardGetSetter[any]{
+				Getter: func(ctx context.Context, tCtx any) (interface{}, error) {
+					return `{"test":null}`, nil
+				},
+			},
+			want: func(expectedMap pcommon.Map) {
+				expectedMap.PutEmpty("test")
+			},
+		},
+		{
+			name: "handle array",
+			target: ottl.StandardGetSetter[any]{
+				Getter: func(ctx context.Context, tCtx any) (interface{}, error) {
+					return `{"test":["string","value"]}`, nil
+				},
+			},
+			want: func(expectedMap pcommon.Map) {
+				emptySlice := expectedMap.PutEmptySlice("test")
+				emptySlice.AppendEmpty().SetStr("string")
+				emptySlice.AppendEmpty().SetStr("value")
+			},
+		},
+		{
+			name: "handle nested object",
+			target: ottl.StandardGetSetter[any]{
+				Getter: func(ctx context.Context, tCtx any) (interface{}, error) {
+					return `{"test":{"nested":"true"}}`, nil
+				},
+			},
+			want: func(expectedMap pcommon.Map) {
+				newMap := expectedMap.PutEmptyMap("test")
+				newMap.PutStr("nested", "true")
+			},
+		},
+		{
+			name: "updates existing",
+			target: ottl.StandardGetSetter[any]{
+				Getter: func(ctx context.Context, tCtx any) (interface{}, error) {
+					return `{"existing":"pass"}`, nil
+				},
+			},
+			want: func(expectedMap pcommon.Map) {
+				expectedMap.PutStr("existing", "pass")
+			},
+		},
+		{
+			name: "complex",
+			target: ottl.StandardGetSetter[any]{
+				Getter: func(ctx context.Context, tCtx any) (interface{}, error) {
+					return `{"test1":{"nested":"true"},"test2":"string","test3":1,"test4":1.1,"test5":[[1], [2, 3],[]],"test6":null}`, nil
+				},
+			},
+			want: func(expectedMap pcommon.Map) {
+				newMap := expectedMap.PutEmptyMap("test1")
+				newMap.PutStr("nested", "true")
+				expectedMap.PutStr("test2", "string")
+				expectedMap.PutDouble("test3", 1)
+				expectedMap.PutDouble("test4", 1.1)
+				slice := expectedMap.PutEmptySlice("test5")
+				slice0 := slice.AppendEmpty().SetEmptySlice()
+				slice0.AppendEmpty().SetDouble(1)
+				slice1 := slice.AppendEmpty().SetEmptySlice()
+				slice1.AppendEmpty().SetDouble(2)
+				slice1.AppendEmpty().SetDouble(3)
+				slice.AppendEmpty().SetEmptySlice()
+				expectedMap.PutEmpty("test6")
+			},
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			exprFunc, err := ParseJSON(tt.target)
+			assert.NoError(t, err)
+
+			result, err := exprFunc(context.Background(), nil)
+			assert.NoError(t, err)
+
+			resultMap, ok := result.(pcommon.Map)
+			if !ok {
+				assert.Fail(t, "pcommon.Map not returned")
+			}
+
+			expected := pcommon.NewMap()
+			tt.want(expected)
+
+			assert.Equal(t, expected.Len(), resultMap.Len())
+			expected.Range(func(k string, v pcommon.Value) bool {
+				ev, _ := expected.Get(k)
+				av, _ := resultMap.Get(k)
+				assert.Equal(t, ev, av)
+				return true
+			})
+		})
+	}
+}