Merge branch 'main' into bug-5717-obtain-xray-sampling-rules-silent-fail

.github/workflows/ci.yml

@@ -86,12 +86,11 @@ jobs:
         cp coverage.txt $TEST_RESULTS
         cp coverage.html $TEST_RESULTS
     - name: Upload coverage report
-      uses: codecov/codecov-action@v4.4.1
+      uses: codecov/codecov-action@v4.5.0
       env:
         CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}
       with:
         file: ./coverage.txt
-        fail_ci_if_error: true
         verbose: true
     - name: Store coverage test output
       uses: actions/upload-artifact@v4
@@ -160,7 +159,7 @@ jobs:
         find . -name 'coverage.html' > "${TEST_RESULTS}/coverage.lst"
         tar -n -cf - -T "${TEST_RESULTS}/coverage.lst" | tar -C "${TEST_RESULTS}" -xvf -
     - name: Upload coverage report
-      uses: codecov/codecov-action@v4.4.1
+      uses: codecov/codecov-action@v4.5.0
       if: hashFiles('coverage.out') != ''
       with:
         file: ./coverage.out

CHANGELOG.md

@@ -11,13 +11,17 @@ This project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.htm
 ### Added
 
 - The `go.opentelemetry.io/contrib/config` add support to configure periodic reader interval and timeout. (#5661)
+- Add the new `go.opentelemetry.io/contrib/detectors/azure/azurevm` package to provide a resource detector for Azure VMs. (#5422)
 - Add support to configure views when creating MeterProvider using the config package. (#5654)
+- Add log support for the autoexport package. (#5733)
+- Add support for disabling the old runtime metrics using the `OTEL_GO_X_DEPRECATED_RUNTIME_METRICS=false` environment variable. (#5747)
 
 ### Fixed
 
 - The superfluous `response.WriteHeader` call in `go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp` when the response writer is flushed. (#5634)
 - Custom attributes targeting metrics recorded by the `go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp` are not ignored anymore. (#5129)
 - Use `c.FullPath()` method to set `http.route` attribute in `go.opentelemetry.io/contrib/instrumentation/github.com/gin-gonic/gin/otelgin`. (#5734)
+- The double setup in `go.opentelemetry.io/contrib/instrumentation/net/http/httptrace/otelhttptrace/example` that caused duplicate traces. (#5564)
 - Non-200 HTTP status codes when retrieving sampling rules in `go.opentelemetry.io/contrib/samplers/aws/xray` now return an error. (#5718)
 
 ### Deprecated
@@ -38,8 +42,8 @@ This project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.htm
 
 ### Changed
 
-- Improve performance of `go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc` with the usage of `WithAttributeSet()` instead of `WithAttribute()`. (#5664) 
-- Improve performance of `go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp` with the usage of `WithAttributeSet()` instead of `WithAttribute()`. (#5664) 
+- Improve performance of `go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc` with the usage of `WithAttributeSet()` instead of `WithAttribute()`. (#5664)
+- Improve performance of `go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp` with the usage of `WithAttributeSet()` instead of `WithAttribute()`. (#5664)
 
 ## [1.27.0/0.52.0/0.21.0/0.7.0/0.2.0] - 2024-05-21
 
@@ -65,6 +69,7 @@ This project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.htm
 - The gRPC trace `Filter` for interceptor is renamed to `InterceptorFilter`. (#5196)
 - The gRPC trace filter functions `Any`, `All`, `None`, `Not`, `MethodName`, `MethodPrefix`, `FullMethodName`, `ServiceName`, `ServicePrefix` and `HealthCheck` for interceptor are moved to `go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc/filters/interceptor`.
   With this change, the filters in `go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc` are now working for stats handler. (#5196)
+- `NewSDK` in `go.opentelemetry.io/contrib/config` now returns a configured SDK with a valid `LoggerProvider`. (#5427)
 
 - `NewLogger` now accepts a `name` `string` as the first argument.
   This parameter is used as a replacement of `WithInstrumentationScope` to specify the name of the logger backing the underlying `Handler`. (#5588)

CODEOWNERS

@@ -36,6 +36,7 @@ detectors/aws/ec2                                                       @open-te
 detectors/aws/ecs                                                       @open-telemetry/go-approvers @pyohannes @akats7
 detectors/aws/eks                                                       @open-telemetry/go-approvers @pyohannes
 detectors/aws/lambda                                                    @open-telemetry/go-approvers @akats7
+detectors/azure/                                                        @open-telemetry/go-approvers @pyohannes
 detectors/gcp/                                                          @open-telemetry/go-approvers @dashpole
 
 exporters/autoexport                                                    @open-telemetry/go-approvers @MikeGoldsmith @pellared

CONTRIBUTING.md

@@ -125,8 +125,6 @@ See the [public meeting notes](https://docs.google.com/document/d/1E5e7Ld0NuU1iV
 
 Approvers:
 
-- [Evan Torrie](https://github.com/evantorrie), Verizon Media
-- [Josh MacDonald](https://github.com/jmacd), LightStep
 - [Sam Xie](https://github.com/XSAM), Cisco/AppDynamics
 - [Chester Cheung](https://github.com/hanyuancheung), Tencent
 - [Damien Mathieu](https://github.com/dmathieu), Elastic
@@ -141,7 +139,9 @@ Maintainers:
 Emeritus:
 
 - [Gustavo Silva Paiva](https://github.com/paivagustavo), LightStep
+- [Josh MacDonald](https://github.com/jmacd), LightStep
 - [Anthony Mirabella](https://github.com/Aneurysm9), Amazon
+- [Evan Torrie](https://github.com/evantorrie), Yahoo
 
 ### Become an Approver or a Maintainer
 

bridges/otelzap/core.go

@@ -183,7 +183,8 @@ func convertField(fields []zapcore.Field) (context.Context, []log.KeyValue) {
 		field.AddTo(enc)
 	}
 
-	return ctx, enc.kv
+	enc.calculate(enc.root)
+	return ctx, enc.root.attrs
 }
 
 func convertLevel(level zapcore.Level) log.Severity {

bridges/otelzap/encoder.go

@@ -18,47 +18,69 @@ var (
 	_ zapcore.ArrayEncoder  = (*arrayEncoder)(nil)
 )
 
+type namespace struct {
+	name  string
+	attrs []log.KeyValue
+	next  *namespace
+}
+
 // objectEncoder implements zapcore.ObjectEncoder.
 // It encodes given fields to OTel key-values.
 type objectEncoder struct {
-	kv []log.KeyValue
+	// root is a pointer to the default namespace
+	root *namespace
+	// cur is a pointer to the namespace we're currently writing to.
+	cur *namespace
 }
 
-// nolint:unused
 func newObjectEncoder(len int) *objectEncoder {
 	keyval := make([]log.KeyValue, 0, len)
-
+	m := &namespace{
+		attrs: keyval,
+	}
 	return &objectEncoder{
-		kv: keyval,
+		root: m,
+		cur:  m,
 	}
 }
 
+// It iterates to the end of the linked list and appends namespace data.
+// Run this function before accessing complete result.
+func (m *objectEncoder) calculate(o *namespace) {
+	if o.next == nil {
+		return
+	}
+	m.calculate(o.next)
+	o.attrs = append(o.attrs, log.Map(o.next.name, o.next.attrs...))
+}
+
 func (m *objectEncoder) AddArray(key string, v zapcore.ArrayMarshaler) error {
 	// TODO: Use arrayEncoder from a pool.
 	arr := &arrayEncoder{}
 	err := v.MarshalLogArray(arr)
-	m.kv = append(m.kv, log.Slice(key, arr.elems...))
+	m.cur.attrs = append(m.cur.attrs, log.Slice(key, arr.elems...))
 	return err
 }
 
 func (m *objectEncoder) AddObject(k string, v zapcore.ObjectMarshaler) error {
 	// TODO: Use objectEncoder from a pool.
 	newobj := newObjectEncoder(2)
 	err := v.MarshalLogObject(newobj)
-	m.kv = append(m.kv, log.Map(k, newobj.kv...))
+	newobj.calculate(newobj.root)
+	m.cur.attrs = append(m.cur.attrs, log.Map(k, newobj.root.attrs...))
 	return err
 }
 
 func (m *objectEncoder) AddBinary(k string, v []byte) {
-	m.kv = append(m.kv, log.Bytes(k, v))
+	m.cur.attrs = append(m.cur.attrs, log.Bytes(k, v))
 }
 
 func (m *objectEncoder) AddByteString(k string, v []byte) {
-	m.kv = append(m.kv, log.String(k, string(v)))
+	m.cur.attrs = append(m.cur.attrs, log.String(k, string(v)))
 }
 
 func (m *objectEncoder) AddBool(k string, v bool) {
-	m.kv = append(m.kv, log.Bool(k, v))
+	m.cur.attrs = append(m.cur.attrs, log.Bool(k, v))
 }
 
 func (m *objectEncoder) AddDuration(k string, v time.Duration) {
@@ -68,35 +90,35 @@ func (m *objectEncoder) AddDuration(k string, v time.Duration) {
 func (m *objectEncoder) AddComplex128(k string, v complex128) {
 	r := log.Float64("r", real(v))
 	i := log.Float64("i", imag(v))
-	m.kv = append(m.kv, log.Map(k, r, i))
+	m.cur.attrs = append(m.cur.attrs, log.Map(k, r, i))
 }
 
 func (m *objectEncoder) AddFloat64(k string, v float64) {
-	m.kv = append(m.kv, log.Float64(k, v))
+	m.cur.attrs = append(m.cur.attrs, log.Float64(k, v))
 }
 
 func (m *objectEncoder) AddInt64(k string, v int64) {
-	m.kv = append(m.kv, log.Int64(k, v))
+	m.cur.attrs = append(m.cur.attrs, log.Int64(k, v))
 }
 
 func (m *objectEncoder) AddInt(k string, v int) {
-	m.kv = append(m.kv, log.Int(k, v))
+	m.cur.attrs = append(m.cur.attrs, log.Int(k, v))
 }
 
 func (m *objectEncoder) AddString(k string, v string) {
-	m.kv = append(m.kv, log.String(k, v))
+	m.cur.attrs = append(m.cur.attrs, log.String(k, v))
 }
 
 func (m *objectEncoder) AddUint64(k string, v uint64) {
-	m.kv = append(m.kv,
+	m.cur.attrs = append(m.cur.attrs,
 		log.KeyValue{
 			Key:   k,
 			Value: assignUintValue(v),
 		})
 }
 
 func (m *objectEncoder) AddReflected(k string, v interface{}) error {
-	m.kv = append(m.kv,
+	m.cur.attrs = append(m.cur.attrs,
 		log.KeyValue{
 			Key:   k,
 			Value: convertValue(v),
@@ -107,7 +129,13 @@ func (m *objectEncoder) AddReflected(k string, v interface{}) error {
 // OpenNamespace opens an isolated namespace where all subsequent fields will
 // be added.
 func (m *objectEncoder) OpenNamespace(k string) {
-	// TODO
+	keyValue := make([]log.KeyValue, 0, 5)
+	s := &namespace{
+		name:  k,
+		attrs: keyValue,
+	}
+	m.cur.next = s
+	m.cur = s
 }
 
 func (m *objectEncoder) AddComplex64(k string, v complex64) {
@@ -179,7 +207,8 @@ func (a *arrayEncoder) AppendObject(v zapcore.ObjectMarshaler) error {
 	// TODO: Use objectEncoder from a pool.
 	m := newObjectEncoder(2)
 	err := v.MarshalLogObject(m)
-	a.elems = append(a.elems, log.MapValue(m.kv...))
+	m.calculate(m.root)
+	a.elems = append(a.elems, log.MapValue(m.root.attrs...))
 	return err
 }
 

bridges/otelzap/encoder_test.go

@@ -182,14 +182,52 @@ func TestObjectEncoder(t *testing.T) {
 			f:        func(e zapcore.ObjectEncoder) { e.AddComplex64("k", 1+2i) },
 			expected: map[string]interface{}{"i": float64(2), "r": float64(1)},
 		},
+		{
+			desc: "OpenNamespace",
+			f: func(e zapcore.ObjectEncoder) {
+				e.OpenNamespace("k")
+				e.AddInt("foo", 1)
+				e.OpenNamespace("middle")
+				e.AddInt("foo", 2)
+				e.OpenNamespace("inner")
+				e.AddInt("foo", 3)
+			},
+			expected: map[string]interface{}{
+				"foo": int64(1),
+				"middle": map[string]interface{}{
+					"foo": int64(2),
+					"inner": map[string]interface{}{
+						"foo": int64(3),
+					},
+				},
+			},
+		},
+		{
+			desc: "object (with nested namespace) then string",
+			f: func(e zapcore.ObjectEncoder) {
+				e.OpenNamespace("k")
+				assert.NoError(t, e.AddObject("obj", maybeNamespace{true}))
+				e.AddString("not-obj", "should-be-outside-obj")
+			},
+			expected: map[string]interface{}{
+				"obj": map[string]interface{}{
+					"obj-out": "obj-outside-namespace",
+					"obj-namespace": map[string]interface{}{
+						"obj-in": "obj-inside-namespace",
+					},
+				},
+				"not-obj": "should-be-outside-obj",
+			},
+		},
 	}
 
 	for _, tt := range tests {
 		t.Run(tt.desc, func(t *testing.T) {
 			enc := newObjectEncoder(1)
 			tt.f(enc)
-			require.Len(t, enc.kv, 1)
-			assert.Equal(t, tt.expected, value2Result((enc.kv[0].Value)), "Unexpected encoder output.")
+			enc.calculate(enc.root)
+			require.Len(t, enc.root.attrs, 1)
+			assert.Equal(t, tt.expected, value2Result((enc.root.attrs[0].Value)), "Unexpected encoder output.")
 		})
 	}
 }
@@ -221,6 +259,43 @@ func TestArrayEncoder(t *testing.T) {
 			},
 			expected: map[string]interface{}{"foo": int64(5)},
 		},
+		{
+			desc: "object (no nested namespace) then string",
+			f: func(e zapcore.ArrayEncoder) {
+				err := e.AppendArray(zapcore.ArrayMarshalerFunc(func(inner zapcore.ArrayEncoder) error {
+					err := inner.AppendObject(maybeNamespace{false})
+					inner.AppendString("should-be-outside-obj")
+					return err
+				}))
+				assert.NoError(t, err)
+			},
+			expected: []interface{}{
+				map[string]interface{}{
+					"obj-out": "obj-outside-namespace",
+				},
+				"should-be-outside-obj",
+			},
+		},
+		{
+			desc: "object (with nested namespace) then string",
+			f: func(e zapcore.ArrayEncoder) {
+				err := e.AppendArray(zapcore.ArrayMarshalerFunc(func(inner zapcore.ArrayEncoder) error {
+					err := inner.AppendObject(maybeNamespace{true})
+					inner.AppendString("should-be-outside-obj")
+					return err
+				}))
+				assert.NoError(t, err)
+			},
+			expected: []interface{}{
+				map[string]interface{}{
+					"obj-out": "obj-outside-namespace",
+					"obj-namespace": map[string]interface{}{
+						"obj-in": "obj-inside-namespace",
+					},
+				},
+				"should-be-outside-obj",
+			},
+		},
 		{"AppendBool", func(e zapcore.ArrayEncoder) { e.AppendBool(true) }, true},
 		{"AppendByteString", func(e zapcore.ArrayEncoder) { e.AppendByteString([]byte("foo")) }, "foo"},
 		{"AppendFloat64", func(e zapcore.ArrayEncoder) { e.AppendFloat64(3.14) }, 3.14},
@@ -252,8 +327,8 @@ func TestArrayEncoder(t *testing.T) {
 				tt.f(arr)
 				return nil
 			})), "Expected AddArray to succeed.")
-
-			assert.Equal(t, []interface{}{tt.expected, tt.expected}, value2Result(enc.kv[0].Value), "Unexpected encoder output.")
+			enc.calculate(enc.root)
+			assert.Equal(t, []interface{}{tt.expected, tt.expected}, value2Result(enc.root.attrs[0].Value), "Unexpected encoder output.")
 		})
 	}
 }
@@ -304,6 +379,18 @@ func (l loggable) MarshalLogArray(enc zapcore.ArrayEncoder) error {
 	return nil
 }
 
+// maybeNamespace is an ObjectMarshaler that sometimes opens a namespace.
+type maybeNamespace struct{ bool }
+
+func (m maybeNamespace) MarshalLogObject(enc zapcore.ObjectEncoder) error {
+	enc.AddString("obj-out", "obj-outside-namespace")
+	if m.bool {
+		enc.OpenNamespace("obj-namespace")
+		enc.AddString("obj-in", "obj-inside-namespace")
+	}
+	return nil
+}
+
 func value2Result(v log.Value) any {
 	switch v.Kind() {
 	case log.KindBool: