sdk/log: Deduplicate key-value collections in Record.SetBody

CHANGELOG.md

@@ -49,6 +49,10 @@ This project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.htm
 <!-- Released section -->
 <!-- Don't change this section unless doing release -->
 
+### Fixes
+
+- sdk/log: Deduplicate key-value collections in log body in `go.opentelemetry.io/otel/sdk/log`, as per OTel spec. (#7002)
+
 ## [1.37.0/0.59.0/0.13.0] 2025-06-25
 
 ### Added

sdk/log/record.go

@@ -170,7 +170,11 @@ func (r *Record) Body() log.Value {
 
 // SetBody sets the body of the log record.
 func (r *Record) SetBody(v log.Value) {
-	r.body = v
+	if !r.allowDupKeys {
+		r.body = r.dedupeBodyCollections(v)
+	} else {
+		r.body = v
+	}
 }
 
 // WalkAttributes walks all attributes the log record holds by calling f for
@@ -452,6 +456,24 @@ func (r *Record) applyValueLimits(val log.Value) log.Value {
 	return val
 }
 
+func (r *Record) dedupeBodyCollections(val log.Value) log.Value {
+	switch val.Kind() {
+	case log.KindSlice:
+		sl := val.AsSlice()
+		for i := range sl {
+			sl[i] = r.applyValueLimits(sl[i])
+		}
+		val = log.SliceValue(sl...)
+	case log.KindMap:
+		kvs, _ := dedup(val.AsMap())
+		for i := range kvs {
+			kvs[i].Value = r.dedupeBodyCollections(kvs[i].Value)
+		}
+		val = log.MapValue(kvs...)
+	}
+	return val
+}
+
 // truncate returns a truncated version of s such that it contains less than
 // the limit number of characters. Truncation is applied by returning the limit
 // number of valid characters contained in s.

sdk/log/record_test.go

@@ -56,10 +56,81 @@ func TestRecordSeverityText(t *testing.T) {
 }
 
 func TestRecordBody(t *testing.T) {
-	v := log.BoolValue(true)
-	r := new(Record)
-	r.SetBody(v)
-	assert.True(t, v.Equal(r.Body()))
+	testcases := []struct {
+		name            string
+		body            log.Value
+		want            log.Value
+		allowDuplicates bool
+	}{
+		{
+			name: "Bool",
+			body: log.BoolValue(true),
+			want: log.BoolValue(true),
+		},
+		{
+			name: "slice",
+			body: log.SliceValue(log.BoolValue(true), log.BoolValue(false)),
+			want: log.SliceValue(log.BoolValue(true), log.BoolValue(false)),
+		},
+		{
+			name: "map",
+			body: log.MapValue(
+				log.Bool("0", true),
+				log.Int64("1", 2), // This should be removed
+				log.Float64("2", 3.0),
+				log.String("3", "forth"),
+				log.Slice("4", log.Int64Value(1)),
+				log.Map("5", log.Int("key", 2)),
+				log.Bytes("6", []byte("six")),
+				log.Int64("1", 3),
+			),
+			want: log.MapValue(
+				log.Bool("0", true),
+				log.Float64("2", 3.0),
+				log.String("3", "forth"),
+				log.Slice("4", log.Int64Value(1)),
+				log.Map("5", log.Int("key", 2)),
+				log.Bytes("6", []byte("six")),
+				log.Int64("1", 3),
+			),
+		},
+		{
+			name: "nestedMap",
+			body: log.MapValue(
+				log.Map("key",
+					log.Int64("key", 1),
+					log.Int64("key", 2),
+				),
+			),
+			want: log.MapValue(
+				log.Map("key",
+					log.Int64("key", 2),
+				),
+			),
+		},
+		{
+			name: "map - allow duplicates",
+			body: log.MapValue(
+				log.Int64("1", 2),
+				log.Int64("1", 3),
+			),
+			want: log.MapValue(
+				log.Int64("1", 2),
+				log.Int64("1", 3),
+			),
+			allowDuplicates: true,
+		},
+	}
+	for _, tc := range testcases {
+		t.Run(tc.name, func(t *testing.T) {
+			r := new(Record)
+			r.allowDupKeys = tc.allowDuplicates
+			r.SetBody(tc.body)
+			assert.True(t, tc.want.Equal(r.Body()), "body is not equal")
+			t.Logf("wanted %v", tc.want)
+			t.Logf("got %v", r.Body())
+		})
+	}
 }
 
 func TestRecordAttributes(t *testing.T) {