diff --git a/cmd/ateapi/internal/controlapi/crash_test.go b/cmd/ateapi/internal/controlapi/crash_test.go index 3abef4e87..6ea13272b 100644 --- a/cmd/ateapi/internal/controlapi/crash_test.go +++ b/cmd/ateapi/internal/controlapi/crash_test.go @@ -32,6 +32,7 @@ import ( "github.com/agent-substrate/substrate/internal/resources" "github.com/agent-substrate/substrate/pkg/proto/ateapipb" "github.com/google/go-cmp/cmp" + "go.opentelemetry.io/otel/attribute" otellog "go.opentelemetry.io/otel/log" "go.opentelemetry.io/otel/log/global" sdklog "go.opentelemetry.io/otel/sdk/log" @@ -633,8 +634,8 @@ func (otlpSinkExporter) Export(_ context.Context, records []sdklog.Record) error timestamp: r.Timestamp(), attrs: map[string]string{}, } - r.WalkAttributes(func(kv otellog.KeyValue) bool { - e.attrs[kv.Key] = kv.Value.String() + r.WalkAttributes(func(kv attribute.KeyValue) bool { + e.attrs[string(kv.Key)] = kv.Value.String() return true }) otlpSink = append(otlpSink, e) diff --git a/go.mod b/go.mod index aa51c953b..d5699f40d 100644 --- a/go.mod +++ b/go.mod @@ -50,14 +50,14 @@ require ( go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.70.0 go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.70.0 go.opentelemetry.io/otel v1.45.0 - go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc v0.20.0 + go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc v0.21.0 go.opentelemetry.io/otel/exporters/otlp/otlpmetric/otlpmetricgrpc v1.43.0 go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc v1.45.0 go.opentelemetry.io/otel/exporters/prometheus v0.65.0 - go.opentelemetry.io/otel/log v0.20.0 + go.opentelemetry.io/otel/log v0.21.0 go.opentelemetry.io/otel/metric v1.45.0 go.opentelemetry.io/otel/sdk v1.45.0 - go.opentelemetry.io/otel/sdk/log v0.20.0 + go.opentelemetry.io/otel/sdk/log v0.21.0 go.opentelemetry.io/otel/sdk/metric v1.45.0 go.opentelemetry.io/otel/trace v1.45.0 go.opentelemetry.io/proto/otlp v1.11.0 diff --git a/go.sum b/go.sum index ded045e84..b1aa56df1 100644 --- a/go.sum +++ b/go.sum @@ -520,8 +520,8 @@ go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.70.0 h1:LMuyCAy go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.70.0/go.mod h1:085m8qbm4hgc8rZWGDEa4vmyyo2c3nPxUslYUKUIU04= go.opentelemetry.io/otel v1.45.0 h1:pdrWmLHofpubmArBv1LgFSv1Z0Ie/ppdZzu+kUN5EeU= go.opentelemetry.io/otel v1.45.0/go.mod h1:XZxIqPapzEYnhNSScF5DIqXhm/rYi0FzCe2XddAwZfQ= -go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc v0.20.0 h1:rydZ9sxbcFdm/oWrVyfLTjHIygMgv0bEeMd+3B/BvoM= -go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc v0.20.0/go.mod h1:earQ25dooT0Hhspq59DZ8YCC50jWfOlFEeWoxy/P444= +go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc v0.21.0 h1:WseeVYf5dJZTsyPiyW5L14k5qsSibqXAMTSiFEDiWr0= +go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc v0.21.0/go.mod h1:SiLZnQS6Qk2eCpvr2CH/XMAOa64TWGXxEZJZCpD2Lmc= go.opentelemetry.io/otel/exporters/otlp/otlpmetric/otlpmetricgrpc v1.43.0 h1:8UQVDcZxOJLtX6gxtDt3vY2WTgvZqMQRzjsqiIHQdkc= go.opentelemetry.io/otel/exporters/otlp/otlpmetric/otlpmetricgrpc v1.43.0/go.mod h1:2lmweYCiHYpEjQ/lSJBYhj9jP1zvCvQW4BqL9dnT7FQ= go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.45.0 h1:QRefszxJmfPdjXUUm3j6iDzY03mTPXMjqErFqQ67vUg= @@ -532,18 +532,18 @@ go.opentelemetry.io/otel/exporters/prometheus v0.65.0 h1:jOveH/b4lU9HT7y+Gfamf18 go.opentelemetry.io/otel/exporters/prometheus v0.65.0/go.mod h1:i1P8pcumauPtUI4YNopea1dhzEMuEqWP1xoUZDylLHo= go.opentelemetry.io/otel/exporters/stdout/stdoutmetric v1.43.0 h1:TC+BewnDpeiAmcscXbGMfxkO+mwYUwE/VySwvw88PfA= go.opentelemetry.io/otel/exporters/stdout/stdoutmetric v1.43.0/go.mod h1:J/ZyF4vfPwsSr9xJSPyQ4LqtcTPULFR64KwTikGLe+A= -go.opentelemetry.io/otel/log v0.20.0 h1:/5i0vuHxCLWUfChWG41K9wkM0jafruPw9NU1/RCJirs= -go.opentelemetry.io/otel/log v0.20.0/go.mod h1:wOcMcjsZpG8x7Bak7IhSi/lg8wscV2C1VdrKCLPlt0E= +go.opentelemetry.io/otel/log v0.21.0 h1:SLsVDGmtyBrdw8/a2Z0bOIxou/+bN4z56GebH7T0LvA= +go.opentelemetry.io/otel/log v0.21.0/go.mod h1:iReetQrZL9Wyg84cCkOoCmqDHS5RCFfyxC7J+r8fn8g= go.opentelemetry.io/otel/metric v1.45.0 h1:7Eg1uH7CJ5cXv9is6tnBe1FI6rj1nwUdbFypRm3br/M= go.opentelemetry.io/otel/metric v1.45.0/go.mod h1:HAPbm1nd3p1PmFH7v2dR+6BjXxw+Lq4a2+pndMAm08s= go.opentelemetry.io/otel/metric/x v0.67.0 h1:PcicCNZFkZ4bXfSooXdo3WN7RBOVOtjVdo1wD358Uns= go.opentelemetry.io/otel/metric/x v0.67.0/go.mod h1:FBjCWZe6wgcqxcMtjdGiClDKXb2YxxXii0CXftE4QtI= go.opentelemetry.io/otel/sdk v1.45.0 h1:4VVSMgQ83dUgW2aoX5f6JgLvHwIvzcuLnF9lUdCSpCw= go.opentelemetry.io/otel/sdk v1.45.0/go.mod h1:Sr40LgXV7DsKMMJMKOhUWOgMWTfAaqvm2kF0g7ilwuA= -go.opentelemetry.io/otel/sdk/log v0.20.0 h1:vM3xI7TQgKPiSghe6urZtAkyFY7SodrSpC83CffDFuY= -go.opentelemetry.io/otel/sdk/log v0.20.0/go.mod h1:Knej2nmsTUzN79T2eeXdRsjjPcoxoq2pUyUHz9TFyyU= -go.opentelemetry.io/otel/sdk/log/logtest v0.20.0 h1:OqdRZ1guyzamK3M6LlRsmGqRrjkHWw6WZOKKli5ELpg= -go.opentelemetry.io/otel/sdk/log/logtest v0.20.0/go.mod h1:PuMIlm7zAt7c3z8zfOI5ox4iT1Z87We+PF6YoINux/M= +go.opentelemetry.io/otel/sdk/log v0.21.0 h1:QsE7XSR0ktQdKmRKGnR+f1ObGF32WG+7MER/P9KgmYc= +go.opentelemetry.io/otel/sdk/log v0.21.0/go.mod h1:m9mApjCoD2/1QuKCAptjv+BrG9WKOvQLVdNx+iBldTo= +go.opentelemetry.io/otel/sdk/log/logtest v0.21.0 h1:X+JBBgKlswCGYsmgL0CnoUUtlE//VB345c84jYAYkdQ= +go.opentelemetry.io/otel/sdk/log/logtest v0.21.0/go.mod h1:HD1575K8e6sIFBBDd5tZB3t9DlMytWXq9FuR+Y4rfjE= go.opentelemetry.io/otel/sdk/metric v1.45.0 h1:oVFszMfyj1Am6s24Vtc7wBb8BKLcwepJjNEYILuiE3o= go.opentelemetry.io/otel/sdk/metric v1.45.0/go.mod h1:vUWUxDZvu1WVRj8JA8S0AdhsPrZoDpA2DdZauIh4mDA= go.opentelemetry.io/otel/trace v1.45.0 h1:l/mP6Uv7oNO7/TblbhpbgMidxhq1uO/rPsikOyVhxag= diff --git a/internal/actorevent/actorevent.go b/internal/actorevent/actorevent.go index 83b029bd6..2d914c71d 100644 --- a/internal/actorevent/actorevent.go +++ b/internal/actorevent/actorevent.go @@ -33,6 +33,7 @@ import ( "sync" "time" + "go.opentelemetry.io/otel/attribute" "go.opentelemetry.io/otel/log" "go.opentelemetry.io/otel/log/global" @@ -142,40 +143,40 @@ func BuildRecord(ev Event, t time.Time, attrs []slog.Attr) log.Record { rec.SetEventName(ev.Name) rec.SetTimestamp(t) rec.SetSeverity(ev.Severity) - rec.SetBody(log.StringValue(ev.Body)) + rec.SetBody(attribute.StringValue(ev.Body)) - kvs := make([]log.KeyValue, 0, len(attrs)) + kvs := make([]attribute.KeyValue, 0, len(attrs)) for _, a := range attrs { - kvs = append(kvs, log.KeyValue{Key: a.Key, Value: logValue(a.Value)}) + kvs = append(kvs, attribute.KeyValue{Key: attribute.Key(a.Key), Value: logValue(a.Value)}) } rec.AddAttributes(kvs...) return rec } // logValue keeps the kind slog's JSON handler writes, so the two copies match. -func logValue(v slog.Value) log.Value { +func logValue(v slog.Value) attribute.Value { switch v.Kind() { case slog.KindString: - return log.StringValue(v.String()) + return attribute.StringValue(v.String()) case slog.KindInt64: - return log.Int64Value(v.Int64()) + return attribute.Int64Value(v.Int64()) case slog.KindUint64: // OTel has no unsigned kind. Clamp rather than wrap, as the metric // side does in addSat. u := v.Uint64() if u > math.MaxInt64 { - return log.Int64Value(math.MaxInt64) + return attribute.Int64Value(math.MaxInt64) } - return log.Int64Value(int64(u)) + return attribute.Int64Value(int64(u)) case slog.KindFloat64: - return log.Float64Value(v.Float64()) + return attribute.Float64Value(v.Float64()) case slog.KindBool: - return log.BoolValue(v.Bool()) + return attribute.BoolValue(v.Bool()) case slog.KindDuration: // nanoseconds, not "1.5s" - return log.Int64Value(int64(v.Duration())) + return attribute.Int64Value(int64(v.Duration())) default: - return log.StringValue(v.String()) + return attribute.StringValue(v.String()) } } diff --git a/internal/actorevent/actorevent_test.go b/internal/actorevent/actorevent_test.go index e82a77c07..6516db166 100644 --- a/internal/actorevent/actorevent_test.go +++ b/internal/actorevent/actorevent_test.go @@ -23,6 +23,7 @@ import ( "testing" "time" + "go.opentelemetry.io/otel/attribute" "go.opentelemetry.io/otel/log" sdklog "go.opentelemetry.io/otel/sdk/log" sdktrace "go.opentelemetry.io/otel/sdk/trace" @@ -90,8 +91,8 @@ func usagePendingAttrs() []slog.Attr { func recordAttrs(rec log.Record) map[string]string { got := make(map[string]string, rec.AttributesLen()) - rec.WalkAttributes(func(kv log.KeyValue) bool { - got[kv.Key] = kv.Value.String() + rec.WalkAttributes(func(kv attribute.KeyValue) bool { + got[string(kv.Key)] = kv.Value.String() return true }) return got @@ -346,8 +347,8 @@ func TestLogWritesBothCopies(t *testing.T) { return true }) otlpAttrs := map[string]string{} - otlpRec.WalkAttributes(func(kv log.KeyValue) bool { - otlpAttrs[kv.Key] = kv.Value.String() + otlpRec.WalkAttributes(func(kv attribute.KeyValue) bool { + otlpAttrs[string(kv.Key)] = kv.Value.String() return true }) if !maps.Equal(stdoutAttrs, otlpAttrs) { @@ -387,7 +388,7 @@ func TestEmitCarriesTraceContext(t *testing.T) { // Trace context belongs on the record's own fields. The stdout copy carries // it as attributes; the OTLP copy must not, or it is there twice. - rec.WalkAttributes(func(kv log.KeyValue) bool { + rec.WalkAttributes(func(kv attribute.KeyValue) bool { switch kv.Key { case ateattr.LogTraceIDField, ateattr.LogSpanIDField, ateattr.LogTraceFlagsField: t.Errorf("record carries trace context as the attribute %q", kv.Key) @@ -414,16 +415,16 @@ func TestBuildRecordKeepsValueKinds(t *testing.T) { tests := []struct { name string attr slog.Attr - want log.Value + want attribute.Value }{ - {"string", slog.String("k", "v"), log.StringValue("v")}, - {"int", slog.Int64("k", 7), log.Int64Value(7)}, - {"uint", slog.Uint64("k", 7), log.Int64Value(7)}, - {"uint above int64 clamps", slog.Uint64("k", math.MaxUint64), log.Int64Value(math.MaxInt64)}, - {"float", slog.Float64("k", 1.5), log.Float64Value(1.5)}, - {"bool", slog.Bool("k", true), log.BoolValue(true)}, - {"duration is nanoseconds, as in the stdout copy", slog.Duration("k", 1500*time.Millisecond), log.Int64Value(1_500_000_000)}, - {"anything else falls back to its string form", slog.Any("k", struct{}{}), log.StringValue("{}")}, + {"string", slog.String("k", "v"), attribute.StringValue("v")}, + {"int", slog.Int64("k", 7), attribute.Int64Value(7)}, + {"uint", slog.Uint64("k", 7), attribute.Int64Value(7)}, + {"uint above int64 clamps", slog.Uint64("k", math.MaxUint64), attribute.Int64Value(math.MaxInt64)}, + {"float", slog.Float64("k", 1.5), attribute.Float64Value(1.5)}, + {"bool", slog.Bool("k", true), attribute.BoolValue(true)}, + {"duration is nanoseconds, as in the stdout copy", slog.Duration("k", 1500*time.Millisecond), attribute.Int64Value(1_500_000_000)}, + {"anything else falls back to its string form", slog.Any("k", struct{}{}), attribute.StringValue("{}")}, } for _, tt := range tests { @@ -431,13 +432,13 @@ func TestBuildRecordKeepsValueKinds(t *testing.T) { t.Parallel() rec := BuildRecord(StateChanged, time.Now(), []slog.Attr{tt.attr}) - var got log.Value - rec.WalkAttributes(func(kv log.KeyValue) bool { + var got attribute.Value + rec.WalkAttributes(func(kv attribute.KeyValue) bool { got = kv.Value return false }) - if got.Kind() != tt.want.Kind() { - t.Fatalf("kind = %v, want %v", got.Kind(), tt.want.Kind()) + if got.Type() != tt.want.Type() { + t.Fatalf("type = %v, want %v", got.Type(), tt.want.Type()) } if got.String() != tt.want.String() { t.Errorf("value = %v, want %v", got, tt.want) diff --git a/vendor/go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc/client.go b/vendor/go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc/client.go index 5488a4c62..8a88b802e 100644 --- a/vendor/go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc/client.go +++ b/vendor/go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc/client.go @@ -1,7 +1,7 @@ // Copyright The OpenTelemetry Authors // SPDX-License-Identifier: Apache-2.0 -package otlploggrpc // import "go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc" +package otlploggrpc import ( "context" @@ -103,10 +103,12 @@ func newGRPCDialOptions(cfg config) []grpc.DialOption { if cfg.serviceConfig.Value != "" { dialOpts = append(dialOpts, grpc.WithDefaultServiceConfig(cfg.serviceConfig.Value)) } - // Prioritize GRPCCredentials over Insecure (passing both is an error). + // Prioritize configured credentials over Insecure (passing both is an error). switch { case cfg.gRPCCredentials.Value != nil: dialOpts = append(dialOpts, grpc.WithTransportCredentials(cfg.gRPCCredentials.Value)) + case cfg.tlsCfg.Value != nil: + dialOpts = append(dialOpts, grpc.WithTransportCredentials(credentials.NewTLS(cfg.tlsCfg.Value))) case cfg.insecure.Value: dialOpts = append(dialOpts, grpc.WithTransportCredentials(insecure.NewCredentials())) default: diff --git a/vendor/go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc/config.go b/vendor/go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc/config.go index 6f8a0f9d1..a872d7b35 100644 --- a/vendor/go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc/config.go +++ b/vendor/go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc/config.go @@ -1,7 +1,7 @@ // Copyright The OpenTelemetry Authors // SPDX-License-Identifier: Apache-2.0 -package otlploggrpc // import "go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc" +package otlploggrpc import ( "crypto/tls" diff --git a/vendor/go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc/doc.go b/vendor/go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc/doc.go index 67cb81434..a159ad304 100644 --- a/vendor/go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc/doc.go +++ b/vendor/go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc/doc.go @@ -60,4 +60,4 @@ The configuration can be overridden by [WithTLSCredentials], [WithGRPCConn] opti [W3C Baggage HTTP Header Content Format]: https://www.w3.org/TR/baggage/#header-content */ -package otlploggrpc // import "go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc" +package otlploggrpc diff --git a/vendor/go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc/exporter.go b/vendor/go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc/exporter.go index 898eecf77..63ef9252a 100644 --- a/vendor/go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc/exporter.go +++ b/vendor/go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc/exporter.go @@ -1,7 +1,7 @@ // Copyright The OpenTelemetry Authors // SPDX-License-Identifier: Apache-2.0 -package otlploggrpc // import "go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc" +package otlploggrpc import ( "context" diff --git a/vendor/go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc/internal/gen.go b/vendor/go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc/internal/gen.go index 797bfc95c..40627daab 100644 --- a/vendor/go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc/internal/gen.go +++ b/vendor/go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc/internal/gen.go @@ -3,9 +3,9 @@ // Package internal provides internal functionality for the otlploggrpc // package. -package internal // import "go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc/internal" +package internal -//go:generate gotmpl --body=../../../../../internal/shared/otlp/observ/target.go.tmpl "--data={ \"pkg\": \"observ\", \"pkg_path\": \"go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc/internal/observ\" }" --out=observ/target.go +//go:generate gotmpl --body=../../../../../internal/shared/otlp/observ/target.go.tmpl "--data={ \"pkg\": \"observ\" }" --out=observ/target.go //go:generate gotmpl --body=../../../../../internal/shared/otlp/observ/target_test.go.tmpl "--data={ \"pkg\": \"observ\" }" --out=observ/target_test.go //go:generate gotmpl --body=../../../../../internal/shared/x/x.go.tmpl "--data={ \"pkg\": \"go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc\" }" --out=x/x.go diff --git a/vendor/go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc/internal/observ/instrumentation.go b/vendor/go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc/internal/observ/instrumentation.go index 7f2ecab71..2058f51c4 100644 --- a/vendor/go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc/internal/observ/instrumentation.go +++ b/vendor/go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc/internal/observ/instrumentation.go @@ -3,7 +3,7 @@ // Package observ provides observability metrics for OTLP log exporters. // This is an experimental feature controlled by the x.Observability feature flag. -package observ // import "go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc/internal/observ" +package observ import ( "context" @@ -21,8 +21,8 @@ import ( "go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc/internal/x" "go.opentelemetry.io/otel/internal/global" "go.opentelemetry.io/otel/metric" - semconv "go.opentelemetry.io/otel/semconv/v1.41.0" - "go.opentelemetry.io/otel/semconv/v1.41.0/otelconv" + semconv "go.opentelemetry.io/otel/semconv/v1.43.0" + "go.opentelemetry.io/otel/semconv/v1.43.0/otelconv" ) const ( diff --git a/vendor/go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc/internal/observ/target.go b/vendor/go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc/internal/observ/target.go index 186f00e52..4d0665894 100644 --- a/vendor/go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc/internal/observ/target.go +++ b/vendor/go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc/internal/observ/target.go @@ -1,10 +1,10 @@ -// Code generated by gotmpl. DO NOT MODIFY. -// source: internal/shared/otlp/observ/target.go.tmpl - // Copyright The OpenTelemetry Authors // SPDX-License-Identifier: Apache-2.0 -package observ // import "go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc/internal/observ" +// DO NOT MODIFY. Generated by gotmpl. +// source: internal/shared/otlp/observ/target.go.tmpl + +package observ import ( "errors" @@ -41,11 +41,10 @@ func ParseCanonicalTarget(target string) (string, int, error) { const sep = "://" // Find scheme. Do not allocate the string by using url.Parse. - idx := strings.Index(target, sep) - if idx == -1 { + scheme, endpoint, found := strings.Cut(target, sep) + if !found { return "", -1, fmt.Errorf("invalid target %q: missing scheme", target) } - scheme, endpoint := target[:idx], target[idx+len(sep):] // Check for unix schemes. if scheme == schemeUnix || scheme == schemeUnixAbstract { diff --git a/vendor/go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc/internal/partialsuccess.go b/vendor/go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc/internal/partialsuccess.go index 076f05fcf..455df0e0d 100644 --- a/vendor/go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc/internal/partialsuccess.go +++ b/vendor/go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc/internal/partialsuccess.go @@ -1,7 +1,7 @@ // Copyright The OpenTelemetry Authors // SPDX-License-Identifier: Apache-2.0 -package internal // import "go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc/internal" +package internal import "fmt" diff --git a/vendor/go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc/internal/retry/retry.go b/vendor/go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc/internal/retry/retry.go index 1a5684d6e..1883d0600 100644 --- a/vendor/go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc/internal/retry/retry.go +++ b/vendor/go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc/internal/retry/retry.go @@ -1,13 +1,13 @@ -// Code generated by gotmpl. DO NOT MODIFY. -// source: internal/shared/otlp/retry/retry.go.tmpl - // Copyright The OpenTelemetry Authors // SPDX-License-Identifier: Apache-2.0 +// DO NOT MODIFY. Generated by gotmpl. +// source: internal/shared/otlp/retry/retry.go.tmpl + // Package retry provides request retry functionality that can perform // configurable exponential backoff for transient errors and honor any // explicit throttle responses received. -package retry // import "go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc/internal/retry" +package retry import ( "context" diff --git a/vendor/go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc/internal/transform/log.go b/vendor/go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc/internal/transform/log.go index aa6eb510b..721e4eb3b 100644 --- a/vendor/go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc/internal/transform/log.go +++ b/vendor/go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc/internal/transform/log.go @@ -1,12 +1,12 @@ -// Code generated by gotmpl. DO NOT MODIFY. -// source: internal/shared/otlp/otlplog/transform/log.go.tmpl - // Copyright The OpenTelemetry Authors // SPDX-License-Identifier: Apache-2.0 +// DO NOT MODIFY. Generated by gotmpl. +// source: internal/shared/otlp/otlplog/transform/log.go.tmpl + // Package transform provides transformation functionality from the // sdk/log data-types into OTLP data-types. -package transform // import "go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc/internal/transform" +package transform import ( "time" @@ -94,13 +94,13 @@ func LogRecord(record log.Record) *lpb.LogRecord { EventName: record.EventName(), SeverityNumber: SeverityNumber(record.Severity()), SeverityText: record.SeverityText(), - Body: LogAttrValue(record.Body()), + Body: AttrValue(record.Body()), Attributes: make([]*cpb.KeyValue, 0, record.AttributesLen()), Flags: uint32(record.TraceFlags()), // TODO: DroppedAttributesCount: /* ... */, } - record.WalkAttributes(func(kv api.KeyValue) bool { - r.Attributes = append(r.Attributes, LogAttr(kv)) + record.WalkAttributes(func(kv attribute.KeyValue) bool { + r.Attributes = append(r.Attributes, Attr(kv)) return true }) if tID := record.TraceID(); tID.IsValid() { @@ -205,6 +205,12 @@ func AttrValue(v attribute.Value) *cpb.AnyValue { Values: attrValues(v.AsSlice()), }, } + case attribute.MAP: + av.Value = &cpb.AnyValue_KvlistValue{ + KvlistValue: &cpb.KeyValueList{ + Values: Attrs(v.AsMap()), + }, + } case attribute.STRINGSLICE: av.Value = &cpb.AnyValue_ArrayValue{ ArrayValue: &cpb.ArrayValue{ @@ -276,85 +282,6 @@ func attrValues(vals []attribute.Value) []*cpb.AnyValue { return converted } -// LogAttrs transforms a slice of [api.KeyValue] into OTLP key-values. -func LogAttrs(attrs []api.KeyValue) []*cpb.KeyValue { - if len(attrs) == 0 { - return nil - } - - out := make([]*cpb.KeyValue, 0, len(attrs)) - for _, kv := range attrs { - out = append(out, LogAttr(kv)) - } - return out -} - -// LogAttr transforms an [api.KeyValue] into an OTLP key-value. -func LogAttr(attr api.KeyValue) *cpb.KeyValue { - return &cpb.KeyValue{ - Key: attr.Key, - Value: LogAttrValue(attr.Value), - } -} - -// LogAttrValues transforms a slice of [api.Value] into an OTLP []AnyValue. -func LogAttrValues(vals []api.Value) []*cpb.AnyValue { - if len(vals) == 0 { - return nil - } - - out := make([]*cpb.AnyValue, 0, len(vals)) - for _, v := range vals { - out = append(out, LogAttrValue(v)) - } - return out -} - -// LogAttrValue transforms an [api.Value] into an OTLP AnyValue. -func LogAttrValue(v api.Value) *cpb.AnyValue { - av := new(cpb.AnyValue) - switch v.Kind() { - case api.KindBool: - av.Value = &cpb.AnyValue_BoolValue{ - BoolValue: v.AsBool(), - } - case api.KindInt64: - av.Value = &cpb.AnyValue_IntValue{ - IntValue: v.AsInt64(), - } - case api.KindFloat64: - av.Value = &cpb.AnyValue_DoubleValue{ - DoubleValue: v.AsFloat64(), - } - case api.KindString: - av.Value = &cpb.AnyValue_StringValue{ - StringValue: v.AsString(), - } - case api.KindBytes: - av.Value = &cpb.AnyValue_BytesValue{ - BytesValue: v.AsBytes(), - } - case api.KindSlice: - av.Value = &cpb.AnyValue_ArrayValue{ - ArrayValue: &cpb.ArrayValue{ - Values: LogAttrValues(v.AsSlice()), - }, - } - case api.KindMap: - av.Value = &cpb.AnyValue_KvlistValue{ - KvlistValue: &cpb.KeyValueList{ - Values: LogAttrs(v.AsMap()), - }, - } - case api.KindEmpty: - default: - av.Value = &cpb.AnyValue_StringValue{ - StringValue: "INVALID", - } - } - return av -} - // SeverityNumber transforms a [log.Severity] into an OTLP SeverityNumber. func SeverityNumber(s api.Severity) lpb.SeverityNumber { switch s { diff --git a/vendor/go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc/internal/version.go b/vendor/go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc/internal/version.go index 9dffad62c..8741594f3 100644 --- a/vendor/go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc/internal/version.go +++ b/vendor/go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc/internal/version.go @@ -1,8 +1,8 @@ // Copyright The OpenTelemetry Authors // SPDX-License-Identifier: Apache-2.0 -package internal // import "go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc/internal" +package internal // Version is the current release version of the OpenTelemetry otlploggrpc // exporter in use. -const Version = "0.20.0" +const Version = "0.21.0" diff --git a/vendor/go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc/internal/x/features.go b/vendor/go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc/internal/x/features.go index 0ed1c81aa..7b66b367c 100644 --- a/vendor/go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc/internal/x/features.go +++ b/vendor/go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc/internal/x/features.go @@ -2,7 +2,7 @@ // SPDX-License-Identifier: Apache-2.0 // Package x documents experimental features for [go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc]. -package x // import "go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc/internal/x" +package x import "strings" diff --git a/vendor/go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc/internal/x/x.go b/vendor/go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc/internal/x/x.go index e2d50cede..7b6363673 100644 --- a/vendor/go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc/internal/x/x.go +++ b/vendor/go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc/internal/x/x.go @@ -1,11 +1,11 @@ -// Code generated by gotmpl. DO NOT MODIFY. -// source: internal/shared/x/x.go.tmpl - // Copyright The OpenTelemetry Authors // SPDX-License-Identifier: Apache-2.0 +// DO NOT MODIFY. Generated by gotmpl. +// source: internal/shared/x/x.go.tmpl + // Package x documents experimental features for [go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc]. -package x // import "go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc/internal/x" +package x import ( "os" diff --git a/vendor/go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc/version.go b/vendor/go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc/version.go index 818ecf9e9..6aff6b221 100644 --- a/vendor/go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc/version.go +++ b/vendor/go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc/version.go @@ -1,7 +1,7 @@ // Copyright The OpenTelemetry Authors // SPDX-License-Identifier: Apache-2.0 -package otlploggrpc // import "go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc" +package otlploggrpc // Version is the current release version of the OpenTelemetry OTLP over gRPC logs exporter in use. func Version() string { diff --git a/vendor/go.opentelemetry.io/otel/log/DESIGN.md b/vendor/go.opentelemetry.io/otel/log/DESIGN.md index 47d39d34b..d36c96773 100644 --- a/vendor/go.opentelemetry.io/otel/log/DESIGN.md +++ b/vendor/go.opentelemetry.io/otel/log/DESIGN.md @@ -62,10 +62,10 @@ Implementation requirements: - The [specification requires](https://opentelemetry.io/docs/specs/otel/logs/api/#concurrency-requirements) the method to be safe to be called concurrently. -- The method should use some default name if the passed name is empty - in order to meet the [specification's SDK requirement](https://opentelemetry.io/docs/specs/otel/logs/sdk/#logger-creation) - to return a working logger when an invalid name is passed - as well as to resemble the behavior of getting tracers and meters. +- If the passed name is empty, this should be reported as invalid as specified + by the [Logs SDK specification](https://opentelemetry.io/docs/specs/otel/logs/sdk/#logger-creation). + The method should still use it as the instrumentation scope name and return + a working logger. `Logger` can be extended by adding new `LoggerOption` options and adding new exported fields to the `LoggerConfig` struct. @@ -148,16 +148,16 @@ func (r *Record) SetSeverityText(s string) is accessed using following methods: ```go -func (r *Record) Body() Value -func (r *Record) SetBody(v Value) +func (r *Record) Body() attribute.Value +func (r *Record) SetBody(v attribute.Value) ``` [Log record attributes](https://opentelemetry.io/docs/specs/otel/logs/data-model/#field-attributes) are accessed using following methods: ```go -func (r *Record) WalkAttributes(f func(KeyValue) bool) -func (r *Record) AddAttributes(attrs ...KeyValue) +func (r *Record) WalkAttributes(f func(attribute.KeyValue) bool) +func (r *Record) AddAttributes(attrs ...attribute.KeyValue) ``` `Record` has a `AttributesLen` method that returns @@ -175,49 +175,20 @@ while keeping the API user friendly. It relieves the user from making his own improvements for reducing the number of allocations when passing attributes. -The abstractions described in -[the specification](https://opentelemetry.io/docs/specs/otel/logs/#new-first-party-application-logs) -are defined in [keyvalue.go](keyvalue.go). +Log body and attributes use the common +[`attribute.Value`](https://pkg.go.dev/go.opentelemetry.io/otel/attribute#Value) +and +[`attribute.KeyValue`](https://pkg.go.dev/go.opentelemetry.io/otel/attribute#KeyValue) +types. +These types cover the Logs Data Model `any` value shape, including empty +values, byte slices, generic slices, and maps. +Reusing the attribute package keeps the API consistent across signals and +avoids maintaining a second value model with conversion helpers. -`Value` is representing `any`. -`KeyValue` is representing a key(string)-value(`any`) pair. - -`Kind` is an enumeration used for specifying the underlying value type. -`KindEmpty` is used for an empty (zero) value. -`KindBool` is used for boolean value. -`KindFloat64` is used for a double precision floating point (IEEE 754-1985) value. -`KindInt64` is used for a signed integer value. -`KindString` is used for a string value. -`KindBytes` is used for a slice of bytes (in spec: A byte array). -`KindSlice` is used for a slice of values (in spec: an array (a list) of any values). -`KindMap` is used for a slice of key-value pairs (in spec: `map`). - -These types are defined in `go.opentelemetry.io/otel/log` package -as they are tightly coupled with the API and different from common attributes. - -The internal implementation of `Value` is based on -[`slog.Value`](https://pkg.go.dev/log/slog#Value) -and the API is mostly inspired by -[`attribute.Value`](https://pkg.go.dev/go.opentelemetry.io/otel/attribute#Value). -The benchmarks[^1] show that the implementation is more performant than -[`attribute.Value`](https://pkg.go.dev/go.opentelemetry.io/otel/attribute#Value). - -The value accessors (`func (v Value) As[Kind]` methods) must not panic, -as it would violate the [specification](https://opentelemetry.io/docs/specs/otel/error-handling/): - -> API methods MUST NOT throw unhandled exceptions when used incorrectly by end -> users. The API and SDK SHOULD provide safe defaults for missing or invalid -> arguments. [...] Whenever the library suppresses an error that would otherwise -> have been exposed to the user, the library SHOULD log the error using -> language-specific conventions. - -Therefore, the value accessors should return a zero value -and log an error when a bad accessor is called. - -The `Severity`, `Kind`, `Value`, `KeyValue` may implement -the [`fmt.Stringer`](https://pkg.go.dev/fmt#Stringer) interface. -However, it is not needed for the first stable release -and the `String` methods can be added later. +The zero value of `attribute.Value` represents an empty body. +Log maps use `attribute.MAP`, which may contain duplicate keys when callers +construct one that way. Duplicate-key normalization is an SDK policy, not an +API behavior. The caller must not subsequently mutate the record passed to `Emit`. This would allow the implementation to not clone the record, @@ -252,12 +223,11 @@ Rejected alternatives: - [Passing record as pointer to Logger.Emit](#passing-record-as-pointer-to-loggeremit) - [Logger.WithAttributes](#loggerwithattributes) - [Record attributes as slice](#record-attributes-as-slice) -- [Use any instead of defining Value](#use-any-instead-of-defining-value) +- [Use any instead of attribute.Value](#use-any-instead-of-attributevalue) - [Severity type encapsulating number and text](#severity-type-encapsulating-number-and-text) -- [Reuse attribute package](#reuse-attribute-package) +- [Define log-specific value types](#define-log-specific-value-types) - [Mix receiver types for Record](#mix-receiver-types-for-record) - [Add XYZ method to Logger](#add-xyz-method-to-logger) -- [Rename KeyValue to Attr](#rename-keyvalue-to-attr) ### Logger.Enabled @@ -476,30 +446,21 @@ less user friendly (users and bridges would use e.g. a `sync.Pool` to reduce the number of heap allocation), less safe (more prone to use after free bugs and race conditions), and the benchmark differences were not significant. -### Use any instead of defining Value +### Use any instead of attribute.Value [Logs Data Model](https://opentelemetry.io/docs/specs/otel/logs/data-model/#field-body) defines Body to be `any`. One could propose to define `Body` (and attribute values) as `any` -instead of a defining a new type (`Value`). +instead of using `attribute.Value`. First of all, [`any` type defined in the specification](https://opentelemetry.io/docs/specs/otel/logs/data-model/#type-any) is not the same as `any` (`interface{}`) in Go. Moreover, using `any` as a field would decrease the performance.[^7] -Notice it will be still possible to add following kind and factories -in a backwards compatible way: - -```go -const KindMap Kind - -func AnyValue(value any) KeyValue - -func Any(key string, value any) KeyValue -``` - -However, currently, it would not be specification compliant. +Using `attribute.Value` preserves a typed, allocation-conscious representation +of the Logs Data Model `any` values while avoiding unconstrained `interface{}` +handling in bridge implementations. ### Severity type encapsulating number and text @@ -518,20 +479,22 @@ It should be more user friendly to have them separated. Especially when having getter and setter methods, setting one value when the other is already set would be unpleasant. -### Reuse attribute package +### Define log-specific value types -It was tempting to reuse the existing -[https://pkg.go.dev/go.opentelemetry.io/otel/attribute] package -for defining log attributes and body. +The original design defined `Kind`, `Value`, and `KeyValue` in +`go.opentelemetry.io/otel/log`. +That avoided coupling log bodies to the common attribute package while logs were +still exploring structured value support. -However, this would be wrong because [the log attribute definition](https://opentelemetry.io/docs/specs/otel/logs/data-model/#field-attributes) -is different from [the common attribute definition](https://opentelemetry.io/docs/specs/otel/common/#attribute). +The Logs Data Model and common attribute value model now share the structured +`any` shapes needed by Go: empty, bool, int64, float64, string, byte slice, +homogeneous slices, generic slices, and maps. +The specification direction is to reuse these value shapes across signals. +Keeping log-specific types would duplicate API surface, require conversion +helpers, and make bridge code choose between two equivalent value models. -Moreover, it there is nothing telling that [the body definition](https://opentelemetry.io/docs/specs/otel/logs/data-model/#field-body) -has anything in common with a common attribute value. - -Therefore, we define new types representing the abstract types defined -in the [Logs Data Model](https://opentelemetry.io/docs/specs/otel/logs/data-model/#definitions-used-in-this-document). +Therefore log records now use `attribute.Value` for body values and +`attribute.KeyValue` for attributes and map entries. ### Mix receiver types for Record @@ -591,36 +554,6 @@ The `Logger` does not have methods like `SetSeverity`, etc. as the Logs API needs to follow (be compliant with) the [specification](https://opentelemetry.io/docs/specs/otel/logs/api/) -### Rename KeyValue to Attr - -There was a proposal to rename `KeyValue` to `Attr` (or `Attribute`).[^11] -New developers may not intuitively know that `log.KeyValue` is an attribute in -the OpenTelemetry parlance. - -During the discussion we agreed to keep the `KeyValue` name. - -The type is used in multiple semantics: - -- as a log attribute, -- as a map item, -- as a log record Body. - -As for map item semantics, this type is a key-value pair, not an attribute. -Naming the type as `Attr` would convey semantical meaning -that would not be correct for a map. - -We expect that most of the Logs API users will be OpenTelemetry contributors. -We plan to implement bridges for the most popular logging libraries ourselves. -Given we will all have the context needed to disambiguate these overlapping -names, developers' confusion should not be an issue. - -For bridges not developed by us, -developers will likely look at our existing bridges for inspiration. -Our correct use of these types will be a reference to them. - -At last, we provide `ValueFromAttribute` and `KeyValueFromAttribute` -to offer reuse of `attribute.Value` and `attribute.KeyValue`. - [^1]: [Handle structured body and attributes](https://github.com/pellared/opentelemetry-go/pull/7) [^2]: Jonathan Amsterdam, [The Go Blog: Structured Logging with slog](https://go.dev/blog/slog) [^3]: Jonathan Amsterdam, [GopherCon Europe 2023: A Fast Structured Logging Package](https://www.youtube.com/watch?v=tC4Jt3i62ns) @@ -631,4 +564,3 @@ to offer reuse of `attribute.Value` and `attribute.KeyValue`. [^8]: [log/slog: structured, leveled logging](https://github.com/golang/go/issues/56345#issuecomment-1302563756) [^9]: [Record with pointer receivers only](https://github.com/pellared/opentelemetry-go/pull/8) [^10]: [Go FAQ: Stack or heap](https://go.dev/doc/faq#stack_or_heap) -[^11]: [Rename KeyValue to Attr discussion](https://github.com/open-telemetry/opentelemetry-go/pull/4809#discussion_r1476080093) diff --git a/vendor/go.opentelemetry.io/otel/log/doc.go b/vendor/go.opentelemetry.io/otel/log/doc.go index b7a085c63..c6f956269 100644 --- a/vendor/go.opentelemetry.io/otel/log/doc.go +++ b/vendor/go.opentelemetry.io/otel/log/doc.go @@ -82,4 +82,4 @@ implement all the API interfaces when a user updates their API. [registry]: https://opentelemetry.io/ecosystem/registry/?language=go&component=log-bridge */ -package log // import "go.opentelemetry.io/otel/log" +package log diff --git a/vendor/go.opentelemetry.io/otel/log/embedded/embedded.go b/vendor/go.opentelemetry.io/otel/log/embedded/embedded.go index 9b401b2b1..70bab2312 100644 --- a/vendor/go.opentelemetry.io/otel/log/embedded/embedded.go +++ b/vendor/go.opentelemetry.io/otel/log/embedded/embedded.go @@ -11,7 +11,7 @@ // bump of the API package). // // [OpenTelemetry Logs API]: https://pkg.go.dev/go.opentelemetry.io/otel/log -package embedded // import "go.opentelemetry.io/otel/log/embedded" +package embedded // LoggerProvider is embedded in the [Logs API LoggerProvider]. // diff --git a/vendor/go.opentelemetry.io/otel/log/global/log.go b/vendor/go.opentelemetry.io/otel/log/global/log.go index bfdb18479..ac9957c3f 100644 --- a/vendor/go.opentelemetry.io/otel/log/global/log.go +++ b/vendor/go.opentelemetry.io/otel/log/global/log.go @@ -9,7 +9,7 @@ This package is experimental. It will be deprecated and removed when the [log] package becomes stable. Its functionality will be migrated to go.opentelemetry.io/otel. */ -package global // import "go.opentelemetry.io/otel/log/global" +package global import ( "go.opentelemetry.io/otel/log" diff --git a/vendor/go.opentelemetry.io/otel/log/internal/global/log.go b/vendor/go.opentelemetry.io/otel/log/internal/global/log.go index e463acbf1..14eadf2e3 100644 --- a/vendor/go.opentelemetry.io/otel/log/internal/global/log.go +++ b/vendor/go.opentelemetry.io/otel/log/internal/global/log.go @@ -3,7 +3,7 @@ // Package global is the internal implementation of the OpenTelemetry global // Logs API. -package global // import "go.opentelemetry.io/otel/log/internal/global" +package global import ( "context" diff --git a/vendor/go.opentelemetry.io/otel/log/internal/global/state.go b/vendor/go.opentelemetry.io/otel/log/internal/global/state.go index dbe1c2fbf..e872cc2a8 100644 --- a/vendor/go.opentelemetry.io/otel/log/internal/global/state.go +++ b/vendor/go.opentelemetry.io/otel/log/internal/global/state.go @@ -1,7 +1,7 @@ // Copyright The OpenTelemetry Authors // SPDX-License-Identifier: Apache-2.0 -package global // import "go.opentelemetry.io/otel/log/internal/global" +package global import ( "errors" diff --git a/vendor/go.opentelemetry.io/otel/log/keyvalue.go b/vendor/go.opentelemetry.io/otel/log/keyvalue.go deleted file mode 100644 index ebf4fcbee..000000000 --- a/vendor/go.opentelemetry.io/otel/log/keyvalue.go +++ /dev/null @@ -1,453 +0,0 @@ -// Copyright The OpenTelemetry Authors -// SPDX-License-Identifier: Apache-2.0 - -//go:generate stringer -type=Kind -trimprefix=Kind - -package log // import "go.opentelemetry.io/otel/log" - -import ( - "bytes" - "cmp" - "errors" - "fmt" - "math" - "slices" - "strconv" - "unsafe" - - "go.opentelemetry.io/otel/attribute" - "go.opentelemetry.io/otel/internal/global" -) - -// errKind is logged when a Value is decoded to an incompatible type. -var errKind = errors.New("invalid Kind") - -// Kind is the kind of a [Value]. -type Kind int - -// Kind values. -const ( - KindEmpty Kind = iota - KindBool - KindFloat64 - KindInt64 - KindString - KindBytes - KindSlice - KindMap -) - -// A Value represents a structured log value. -// A zero value is valid and represents an empty value. -type Value struct { - // Ensure forward compatibility by explicitly making this not comparable. - noCmp [0]func() //nolint: unused // This is indeed used. - - // num holds the value for Int64, Float64, and Bool. It holds the length - // for String, Bytes, Slice, Map. - num uint64 - // any holds either the KindBool, KindInt64, KindFloat64, stringptr, - // bytesptr, sliceptr, or mapptr. If KindBool, KindInt64, or KindFloat64 - // then the value of Value is in num as described above. Otherwise, it - // contains the value wrapped in the appropriate type. - any any -} - -type ( - // sliceptr represents a value in Value.any for KindString Values. - stringptr *byte - // bytesptr represents a value in Value.any for KindBytes Values. - bytesptr *byte - // sliceptr represents a value in Value.any for KindSlice Values. - sliceptr *Value - // mapptr represents a value in Value.any for KindMap Values. - mapptr *KeyValue -) - -// StringValue returns a new [Value] for a string. -func StringValue(v string) Value { - return Value{ - num: uint64(len(v)), - any: stringptr(unsafe.StringData(v)), - } -} - -// IntValue returns a [Value] for an int. -func IntValue(v int) Value { return Int64Value(int64(v)) } - -// Int64Value returns a [Value] for an int64. -func Int64Value(v int64) Value { - // This can be later converted back to int64 (overflow not checked). - return Value{num: uint64(v), any: KindInt64} // nolint:gosec -} - -// Float64Value returns a [Value] for a float64. -func Float64Value(v float64) Value { - return Value{num: math.Float64bits(v), any: KindFloat64} -} - -// BoolValue returns a [Value] for a bool. -func BoolValue(v bool) Value { //nolint:revive // Not a control flag. - var n uint64 - if v { - n = 1 - } - return Value{num: n, any: KindBool} -} - -// BytesValue returns a [Value] for a byte slice. The passed slice must not be -// changed after it is passed. -func BytesValue(v []byte) Value { - return Value{ - num: uint64(len(v)), - any: bytesptr(unsafe.SliceData(v)), - } -} - -// SliceValue returns a [Value] for a slice of [Value]. The passed slice must -// not be changed after it is passed. -func SliceValue(vs ...Value) Value { - return Value{ - num: uint64(len(vs)), - any: sliceptr(unsafe.SliceData(vs)), - } -} - -// MapValue returns a new [Value] for a slice of key-value pairs. The passed -// slice must not be changed after it is passed. -func MapValue(kvs ...KeyValue) Value { - return Value{ - num: uint64(len(kvs)), - any: mapptr(unsafe.SliceData(kvs)), - } -} - -// AsString returns the value held by v as a string. -func (v Value) AsString() string { - if sp, ok := v.any.(stringptr); ok { - return unsafe.String(sp, v.num) - } - global.Error(errKind, "AsString", "Kind", v.Kind()) - return "" -} - -// asString returns the value held by v as a string. It will panic if the Value -// is not KindString. -func (v Value) asString() string { - return unsafe.String(v.any.(stringptr), v.num) -} - -// AsInt64 returns the value held by v as an int64. -func (v Value) AsInt64() int64 { - if v.Kind() != KindInt64 { - global.Error(errKind, "AsInt64", "Kind", v.Kind()) - return 0 - } - return v.asInt64() -} - -// asInt64 returns the value held by v as an int64. If v is not of KindInt64, -// this will return garbage. -func (v Value) asInt64() int64 { - // Assumes v.num was a valid int64 (overflow not checked). - return int64(v.num) // nolint: gosec -} - -// AsBool returns the value held by v as a bool. -func (v Value) AsBool() bool { - if v.Kind() != KindBool { - global.Error(errKind, "AsBool", "Kind", v.Kind()) - return false - } - return v.asBool() -} - -// asBool returns the value held by v as a bool. If v is not of KindBool, this -// will return garbage. -func (v Value) asBool() bool { return v.num == 1 } - -// AsFloat64 returns the value held by v as a float64. -func (v Value) AsFloat64() float64 { - if v.Kind() != KindFloat64 { - global.Error(errKind, "AsFloat64", "Kind", v.Kind()) - return 0 - } - return v.asFloat64() -} - -// asFloat64 returns the value held by v as a float64. If v is not of -// KindFloat64, this will return garbage. -func (v Value) asFloat64() float64 { return math.Float64frombits(v.num) } - -// AsBytes returns the value held by v as a []byte. -func (v Value) AsBytes() []byte { - if sp, ok := v.any.(bytesptr); ok { - return unsafe.Slice((*byte)(sp), v.num) - } - global.Error(errKind, "AsBytes", "Kind", v.Kind()) - return nil -} - -// asBytes returns the value held by v as a []byte. It will panic if the Value -// is not KindBytes. -func (v Value) asBytes() []byte { - return unsafe.Slice((*byte)(v.any.(bytesptr)), v.num) -} - -// AsSlice returns the value held by v as a []Value. -func (v Value) AsSlice() []Value { - if sp, ok := v.any.(sliceptr); ok { - return unsafe.Slice((*Value)(sp), v.num) - } - global.Error(errKind, "AsSlice", "Kind", v.Kind()) - return nil -} - -// asSlice returns the value held by v as a []Value. It will panic if the Value -// is not KindSlice. -func (v Value) asSlice() []Value { - return unsafe.Slice((*Value)(v.any.(sliceptr)), v.num) -} - -// AsMap returns the value held by v as a []KeyValue. -func (v Value) AsMap() []KeyValue { - if sp, ok := v.any.(mapptr); ok { - return unsafe.Slice((*KeyValue)(sp), v.num) - } - global.Error(errKind, "AsMap", "Kind", v.Kind()) - return nil -} - -// asMap returns the value held by v as a []KeyValue. It will panic if the -// Value is not KindMap. -func (v Value) asMap() []KeyValue { - return unsafe.Slice((*KeyValue)(v.any.(mapptr)), v.num) -} - -// Kind returns the Kind of v. -func (v Value) Kind() Kind { - switch x := v.any.(type) { - case Kind: - return x - case stringptr: - return KindString - case bytesptr: - return KindBytes - case sliceptr: - return KindSlice - case mapptr: - return KindMap - default: - return KindEmpty - } -} - -// Empty reports whether v does not hold any value. -func (v Value) Empty() bool { return v.Kind() == KindEmpty } - -// Equal reports whether v is equal to w. -func (v Value) Equal(w Value) bool { - k1 := v.Kind() - k2 := w.Kind() - if k1 != k2 { - return false - } - switch k1 { - case KindInt64, KindBool: - return v.num == w.num - case KindString: - return v.asString() == w.asString() - case KindFloat64: - return v.asFloat64() == w.asFloat64() - case KindSlice: - return slices.EqualFunc(v.asSlice(), w.asSlice(), Value.Equal) - case KindMap: - sv := sortMap(v.asMap()) - sw := sortMap(w.asMap()) - return slices.EqualFunc(sv, sw, KeyValue.Equal) - case KindBytes: - return bytes.Equal(v.asBytes(), w.asBytes()) - case KindEmpty: - return true - default: - global.Error(errKind, "Equal", "Kind", k1) - return false - } -} - -func sortMap(m []KeyValue) []KeyValue { - sm := make([]KeyValue, len(m)) - copy(sm, m) - slices.SortFunc(sm, func(a, b KeyValue) int { - return cmp.Compare(a.Key, b.Key) - }) - - return sm -} - -// String returns Value's value as a string, formatted like [fmt.Sprint]. -// -// The returned string is meant for debugging; -// the string representation is not stable. -func (v Value) String() string { - switch v.Kind() { - case KindString: - return v.asString() - case KindInt64: - // Assumes v.num was a valid int64 (overflow not checked). - return strconv.FormatInt(int64(v.num), 10) // nolint: gosec - case KindFloat64: - return strconv.FormatFloat(v.asFloat64(), 'g', -1, 64) - case KindBool: - return strconv.FormatBool(v.asBool()) - case KindBytes: - return fmt.Sprint(v.asBytes()) // nolint:staticcheck // Use fmt.Sprint to encode as slice. - case KindMap: - return fmt.Sprint(v.asMap()) - case KindSlice: - return fmt.Sprint(v.asSlice()) - case KindEmpty: - return "" - default: - // Try to handle this as gracefully as possible. - // - // Don't panic here. The goal here is to have developers find this - // first if a slog.Kind is is not handled. It is - // preferable to have user's open issue asking why their attributes - // have a "unhandled: " prefix than say that their code is panicking. - return fmt.Sprintf("", v.Kind()) - } -} - -// A KeyValue is a key-value pair used to represent a log attribute (a -// superset of [go.opentelemetry.io/otel/attribute.KeyValue]) and map item. -type KeyValue struct { - Key string - Value Value -} - -// Equal reports whether a is equal to b. -func (a KeyValue) Equal(b KeyValue) bool { - return a.Key == b.Key && a.Value.Equal(b.Value) -} - -// String returns a KeyValue for a string value. -func String(key, value string) KeyValue { - return KeyValue{key, StringValue(value)} -} - -// Int64 returns a KeyValue for an int64 value. -func Int64(key string, value int64) KeyValue { - return KeyValue{key, Int64Value(value)} -} - -// Int returns a KeyValue for an int value. -func Int(key string, value int) KeyValue { - return KeyValue{key, IntValue(value)} -} - -// Float64 returns a KeyValue for a float64 value. -func Float64(key string, value float64) KeyValue { - return KeyValue{key, Float64Value(value)} -} - -// Bool returns a KeyValue for a bool value. -func Bool(key string, value bool) KeyValue { - return KeyValue{key, BoolValue(value)} -} - -// Bytes returns a KeyValue for a []byte value. -// The passed slice must not be changed after it is passed. -func Bytes(key string, value []byte) KeyValue { - return KeyValue{key, BytesValue(value)} -} - -// Slice returns a KeyValue for a []Value value. -// The passed slice must not be changed after it is passed. -func Slice(key string, value ...Value) KeyValue { - return KeyValue{key, SliceValue(value...)} -} - -// Map returns a KeyValue for a map value. -// The passed slice must not be changed after it is passed. -func Map(key string, value ...KeyValue) KeyValue { - return KeyValue{key, MapValue(value...)} -} - -// Empty returns a KeyValue with an empty value. -func Empty(key string) KeyValue { - return KeyValue{key, Value{}} -} - -// String returns key-value pair as a string, formatted like "key:value". -// -// The returned string is meant for debugging; -// the string representation is not stable. -func (a KeyValue) String() string { - return fmt.Sprintf("%s:%s", a.Key, a.Value) -} - -// ValueFromAttribute converts [attribute.Value] to [Value]. -func ValueFromAttribute(value attribute.Value) Value { - switch value.Type() { - case attribute.EMPTY: - return Value{} - case attribute.BOOL: - return BoolValue(value.AsBool()) - case attribute.BOOLSLICE: - val := value.AsBoolSlice() - res := make([]Value, 0, len(val)) - for _, v := range val { - res = append(res, BoolValue(v)) - } - return SliceValue(res...) - case attribute.INT64: - return Int64Value(value.AsInt64()) - case attribute.INT64SLICE: - val := value.AsInt64Slice() - res := make([]Value, 0, len(val)) - for _, v := range val { - res = append(res, Int64Value(v)) - } - return SliceValue(res...) - case attribute.FLOAT64: - return Float64Value(value.AsFloat64()) - case attribute.FLOAT64SLICE: - val := value.AsFloat64Slice() - res := make([]Value, 0, len(val)) - for _, v := range val { - res = append(res, Float64Value(v)) - } - return SliceValue(res...) - case attribute.STRING: - return StringValue(value.AsString()) - case attribute.STRINGSLICE: - val := value.AsStringSlice() - res := make([]Value, 0, len(val)) - for _, v := range val { - res = append(res, StringValue(v)) - } - return SliceValue(res...) - case attribute.BYTESLICE: - val := value.AsByteSlice() - return BytesValue(val) - case attribute.SLICE: - val := value.AsSlice() - res := make([]Value, 0, len(val)) - for _, v := range val { - res = append(res, ValueFromAttribute(v)) - } - return SliceValue(res...) - } - // This code should never be reached - // as log attributes are a superset of standard attributes. - panic("unknown attribute type") -} - -// KeyValueFromAttribute converts [attribute.KeyValue] to [KeyValue]. -func KeyValueFromAttribute(kv attribute.KeyValue) KeyValue { - return KeyValue{ - Key: string(kv.Key), - Value: ValueFromAttribute(kv.Value), - } -} diff --git a/vendor/go.opentelemetry.io/otel/log/kind_string.go b/vendor/go.opentelemetry.io/otel/log/kind_string.go deleted file mode 100644 index b4f9e5335..000000000 --- a/vendor/go.opentelemetry.io/otel/log/kind_string.go +++ /dev/null @@ -1,31 +0,0 @@ -// Code generated by "stringer -type=Kind -trimprefix=Kind"; DO NOT EDIT. - -package log - -import "strconv" - -func _() { - // An "invalid array index" compiler error signifies that the constant values have changed. - // Re-run the stringer command to generate them again. - var x [1]struct{} - _ = x[KindEmpty-0] - _ = x[KindBool-1] - _ = x[KindFloat64-2] - _ = x[KindInt64-3] - _ = x[KindString-4] - _ = x[KindBytes-5] - _ = x[KindSlice-6] - _ = x[KindMap-7] -} - -const _Kind_name = "EmptyBoolFloat64Int64StringBytesSliceMap" - -var _Kind_index = [...]uint8{0, 5, 9, 16, 21, 27, 32, 37, 40} - -func (i Kind) String() string { - idx := int(i) - 0 - if i < 0 || idx >= len(_Kind_index)-1 { - return "Kind(" + strconv.FormatInt(int64(i), 10) + ")" - } - return _Kind_name[_Kind_index[idx]:_Kind_index[idx+1]] -} diff --git a/vendor/go.opentelemetry.io/otel/log/logger.go b/vendor/go.opentelemetry.io/otel/log/logger.go index 014161969..178e6be26 100644 --- a/vendor/go.opentelemetry.io/otel/log/logger.go +++ b/vendor/go.opentelemetry.io/otel/log/logger.go @@ -1,7 +1,7 @@ // Copyright The OpenTelemetry Authors // SPDX-License-Identifier: Apache-2.0 -package log // import "go.opentelemetry.io/otel/log" +package log import ( "context" @@ -36,7 +36,8 @@ type Logger interface { // // This is useful for users that want to know if a [Record] // will be processed or dropped before they perform complex operations to - // construct the [Record]. + // construct the [Record]. Callers should invoke Enabled before each call + // to [Logger.Emit] because the enabled state may change over time. // // The passed param is likely to be a partial record information being // provided (e.g a param with only the Severity set). diff --git a/vendor/go.opentelemetry.io/otel/log/noop/noop.go b/vendor/go.opentelemetry.io/otel/log/noop/noop.go index d779e5d80..082eb887b 100644 --- a/vendor/go.opentelemetry.io/otel/log/noop/noop.go +++ b/vendor/go.opentelemetry.io/otel/log/noop/noop.go @@ -12,7 +12,7 @@ // defaults to no operation for methods it does not implement. // // [OpenTelemetry Logs API]: https://pkg.go.dev/go.opentelemetry.io/otel/log -package noop // import "go.opentelemetry.io/otel/log/noop" +package noop import ( "context" diff --git a/vendor/go.opentelemetry.io/otel/log/provider.go b/vendor/go.opentelemetry.io/otel/log/provider.go index 5c8ca328f..62b7d73fc 100644 --- a/vendor/go.opentelemetry.io/otel/log/provider.go +++ b/vendor/go.opentelemetry.io/otel/log/provider.go @@ -1,7 +1,7 @@ // Copyright The OpenTelemetry Authors // SPDX-License-Identifier: Apache-2.0 -package log // import "go.opentelemetry.io/otel/log" +package log import "go.opentelemetry.io/otel/log/embedded" @@ -24,7 +24,8 @@ type LoggerProvider interface { // commonly, this means a bridge will need to accept this value from its // users. // - // If name is empty, implementations need to provide a default name. + // An empty name is invalid. Implementations should retain the empty value as the + // instrumentation scope name, return a working Logger, and report the invalid value. // // The version of the packages using a bridge can be critical information // to include when logging. The bridge should accept this version diff --git a/vendor/go.opentelemetry.io/otel/log/record.go b/vendor/go.opentelemetry.io/otel/log/record.go index cf62deb9e..9e4e4d80b 100644 --- a/vendor/go.opentelemetry.io/otel/log/record.go +++ b/vendor/go.opentelemetry.io/otel/log/record.go @@ -1,11 +1,13 @@ // Copyright The OpenTelemetry Authors // SPDX-License-Identifier: Apache-2.0 -package log // import "go.opentelemetry.io/otel/log" +package log import ( "slices" "time" + + "go.opentelemetry.io/otel/attribute" ) // attributesInlineCount is the number of attributes that are efficiently @@ -25,7 +27,7 @@ type Record struct { observedTimestamp time.Time severity Severity severityText string - body Value + body attribute.Value err error // The fields below are for optimizing the implementation of Attributes and @@ -35,7 +37,7 @@ type Record struct { // Allocation optimization: an inline array sized to hold // the majority of log calls (based on examination of open-source // code). It holds the start of the list of attributes. - front [attributesInlineCount]KeyValue + front [attributesInlineCount]attribute.KeyValue // The number of attributes in front. nFront int @@ -44,7 +46,7 @@ type Record struct { // Invariants: // - len(back) > 0 if nFront == len(front) // - Unused array elements are zero-ed. Used to detect mistakes. - back []KeyValue + back []attribute.KeyValue } // EventName returns the event name. @@ -55,6 +57,7 @@ func (r *Record) EventName() string { // SetEventName sets the event name. // A log record with non-empty event name is interpreted as an event record. +// Event names should uniquely identify the event's attribute and body structure. func (r *Record) SetEventName(s string) { r.eventName = s } @@ -102,12 +105,12 @@ func (r *Record) SetSeverityText(text string) { } // Body returns the body of the log record. -func (r *Record) Body() Value { +func (r *Record) Body() attribute.Value { return r.body } // SetBody sets the body of the log record. -func (r *Record) SetBody(v Value) { +func (r *Record) SetBody(v attribute.Value) { r.body = v } @@ -122,8 +125,8 @@ func (r *Record) SetErr(err error) { } // WalkAttributes walks all attributes the log record holds by calling f for -// each on each [KeyValue] in the [Record]. Iteration stops if f returns false. -func (r *Record) WalkAttributes(f func(KeyValue) bool) { +// each on each [attribute.KeyValue] in the [Record]. Iteration stops if f returns false. +func (r *Record) WalkAttributes(f func(attribute.KeyValue) bool) { for i := 0; i < r.nFront; i++ { if !f(r.front[i]) { return @@ -137,7 +140,7 @@ func (r *Record) WalkAttributes(f func(KeyValue) bool) { } // AddAttributes adds attributes to the log record. -func (r *Record) AddAttributes(attrs ...KeyValue) { +func (r *Record) AddAttributes(attrs ...attribute.KeyValue) { var i int for i = 0; i < len(attrs) && r.nFront < len(r.front); i++ { a := attrs[i] diff --git a/vendor/go.opentelemetry.io/otel/log/severity.go b/vendor/go.opentelemetry.io/otel/log/severity.go index 0240fd5ac..29aed675d 100644 --- a/vendor/go.opentelemetry.io/otel/log/severity.go +++ b/vendor/go.opentelemetry.io/otel/log/severity.go @@ -3,7 +3,7 @@ //go:generate stringer -type=Severity -linecomment -package log // import "go.opentelemetry.io/otel/log" +package log // Severity represents a log record severity (also known as log level). Smaller // numerical values correspond to less severe log records (such as debug diff --git a/vendor/go.opentelemetry.io/otel/sdk/log/DESIGN.md b/vendor/go.opentelemetry.io/otel/sdk/log/DESIGN.md index 2e0fb15e2..3858b85e6 100644 --- a/vendor/go.opentelemetry.io/otel/sdk/log/DESIGN.md +++ b/vendor/go.opentelemetry.io/otel/sdk/log/DESIGN.md @@ -80,7 +80,25 @@ is implemented as `SimpleProcessor` struct in [simple.go](simple.go). The [Batching processor](https://opentelemetry.io/docs/specs/otel/logs/sdk/#batching-processor) is implemented as `BatchProcessor` struct in [batch.go](batch.go). -The `Batcher` can be also configured using the `OTEL_BLRP_*` environment variables as +`OnEmit` clones accepted records into a bounded, drop-oldest queue. Once the +queue reaches the batch size, it attempts a non-blocking, coalesced worker +notification. It may briefly contend on the queue lock but never waits for +exporter I/O. A single worker goroutine owns dequeueing, scheduled exports, and +all exporter lifecycle calls, so exporter backpressure blocks the worker +instead of causing repeated polling. + +`ForceFlush` is serialized through the worker. When the worker accepts a +request, it drains the records then queued in batches no larger than the +configured maximum and calls the exporter's `ForceFlush` while the request +context remains valid. `Shutdown` first closes queue admission, drains accepted +records, calls `ForceFlush` while its context remains valid, and always invokes +the exporter's `Shutdown`. Cancellation stops additional drain chunks subject +to the exporter honoring its context. + +`WithMaxQueueSize` bounds the pending-record queue; the worker additionally +retains bounded batch scratch space and records currently being exported. + +The `BatchProcessor` can also be configured using the `OTEL_BLRP_*` environment variables as [defined by the specification](https://opentelemetry.io/docs/specs/otel/configuration/sdk-environment-variables/#batch-logrecord-processor). ### Exporter @@ -106,8 +124,18 @@ is defined as `Record` struct in [record.go](record.go). The `Record` is designed similarly to [`log.Record`](https://pkg.go.dev/go.opentelemetry.io/otel/log#Record) in order to reduce the number of heap allocations when processing attributes. +The log body and attributes use `attribute.Value` and `attribute.KeyValue` +from `go.opentelemetry.io/otel/attribute`, matching the API representation and +avoiding an SDK-specific value tree. -The SDK does not have have an additional definition of +Top-level duplicate attributes are handled with last-value-wins semantics +unless `WithAllowKeyDuplication` is configured. Nested `attribute.MAP` values +use the same semantics for duplicate map keys, including the body value, so +exporters receive a canonical attribute tree by default. The attribute value +length limit recursively truncates string, string slice, byte slice, slice, and +map attribute values. The body is deduplicated but not truncated. + +The SDK does not have an additional definition of [ReadableLogRecord](https://opentelemetry.io/docs/specs/otel/logs/sdk/#readablelogrecord) as the specification does not say that the exporters must not be able to modify the log records. It simply requires them to be able to read the log records. diff --git a/vendor/go.opentelemetry.io/otel/sdk/log/batch.go b/vendor/go.opentelemetry.io/otel/sdk/log/batch.go index a03248eba..c3c8237d8 100644 --- a/vendor/go.opentelemetry.io/otel/sdk/log/batch.go +++ b/vendor/go.opentelemetry.io/otel/sdk/log/batch.go @@ -1,17 +1,20 @@ // Copyright The OpenTelemetry Authors // SPDX-License-Identifier: Apache-2.0 -package log // import "go.opentelemetry.io/otel/sdk/log" +package log import ( "context" "errors" - "slices" + "math" "sync" "sync/atomic" "time" + "go.opentelemetry.io/otel" "go.opentelemetry.io/otel/internal/global" + "go.opentelemetry.io/otel/sdk/log/internal/counter" + "go.opentelemetry.io/otel/sdk/log/internal/observ" ) const ( @@ -19,7 +22,6 @@ const ( dfltExpInterval = time.Second dfltExpTimeout = 30 * time.Second dfltExpMaxBatchSize = 512 - dfltExpBufferSize = 1 envarMaxQSize = "OTEL_BLRP_MAX_QUEUE_SIZE" envarExpInterval = "OTEL_BLRP_SCHEDULE_DELAY" @@ -35,82 +37,83 @@ var _ Processor = (*BatchProcessor)(nil) // Use [NewBatchProcessor] to create a BatchProcessor. An empty BatchProcessor // is shut down by default, no records will be batched or exported. type BatchProcessor struct { - // The BatchProcessor is designed to provide the highest throughput of - // log records possible while being compatible with OpenTelemetry. The - // entry point of log records is the OnEmit method. This method is designed - // to receive records as fast as possible while still honoring shutdown - // commands. All records received are enqueued to queue. - // - // In order to block OnEmit as little as possible, a separate "poll" - // goroutine is spawned at the creation of a BatchProcessor. This - // goroutine is responsible for batching the queue at regular polled - // intervals, or when it is directly signaled to. - // - // To keep the polling goroutine from backing up, all batches it makes are - // exported with a bufferedExporter. This exporter allows the poll - // goroutine to enqueue an export payload that will be handled in a - // separate goroutine dedicated to the export. This asynchronous behavior - // allows the poll goroutine to maintain accurate interval polling. - // - // ___BatchProcessor____ __Poll Goroutine__ __Export Goroutine__ - // || || || || || || - // || ********** || || || || ********** || - // || Records=>* OnEmit * || || | - ticker || || * export * || - // || ********** || || | - trigger || || ********** || - // || || || || | || || || || - // || || || || | || || || || - // || __________\/___ || || |*********** || || ______/\_______ || - // || (____queue______)>=||=||===|* batch *===||=||=>[_export_buffer_] || - // || || || |*********** || || || - // ||_____________________|| ||__________________|| ||____________________|| - // - // - // The "release valve" in this processing is the record queue. This queue - // is a ring buffer. It will overwrite the oldest records first when writes - // to OnEmit are made faster than the queue can be flushed. If batches - // cannot be flushed to the export buffer, the records will remain in the - // queue. - - // exporter is the bufferedExporter all batches are exported with. - exporter *bufferExporter + // A single goroutine owns dequeueing and all exporter calls. OnEmit only + // writes to the bounded queue and signals that goroutine. Consequently, + // exporter backpressure blocks the exporter goroutine instead of causing + // another goroutine to retry without making progress. + exporter Exporter // q is the active queue of records that have not yet been exported. q *queue - // batchSize is the minimum number of records needed before an export is - // triggered (unless the interval expires). + // batchSize is the maximum number of records in a scheduled export. batchSize int - // pollTrigger triggers the poll goroutine to flush a batch from the queue. - // This is sent to when it is known that the queue contains at least one - // complete batch. - // - // When a send is made to the channel, the poll loop will be reset after - // the flush. If there is still enough records in the queue for another - // batch the reset of the poll loop will automatically re-trigger itself. - // There is no need for the original sender to monitor and resend. - pollTrigger chan struct{} - // pollKill kills the poll goroutine. This is only expected to be closed - // once by the Shutdown method. - pollKill chan struct{} - // pollDone signals the poll goroutine has completed. - pollDone chan struct{} + // exportTrigger is a coalesced signal that records are ready to export. + exportTrigger chan struct{} + // flush serializes ForceFlush requests through the worker. + flush chan batchProcessorRequest + // shutdown accepts the single Shutdown request. It is separate from flush + // so shutdown cannot be blocked behind concurrent ForceFlush callers. + shutdown chan batchProcessorRequest + // done is closed by the exporter goroutine after exporter shutdown. + done chan struct{} // stopped holds the stopped state of the BatchProcessor. stopped atomic.Bool + // inst is the instrumentation for observability (nil when disabled). + inst *observ.BLP + noCmp [0]func() //nolint: unused // This is indeed used. } +type batchProcessorRequest struct { + ctx context.Context + resp chan<- error +} + +func (r batchProcessorRequest) respond(err error) { + r.resp <- err +} + // NewBatchProcessor decorates the provided exporter // so that the log records are batched before exporting. // -// All of the exporter's methods are called synchronously. +// Calls to the exporter's Export, ForceFlush, and Shutdown methods are +// synchronized and never invoked concurrently. func NewBatchProcessor(exporter Exporter, opts ...BatchProcessorOption) *BatchProcessor { cfg := newBatchConfig(opts) if exporter == nil { // Do not panic on nil export. exporter = defaultNoopExporter } + + b := &BatchProcessor{ + q: newQueue(cfg.maxQSize.Value), + batchSize: cfg.expMaxBatchSize.Value, + exportTrigger: make(chan struct{}, 1), + flush: make(chan batchProcessorRequest), + shutdown: make(chan batchProcessorRequest, 1), + done: make(chan struct{}), + } + + var err error + b.inst, err = observ.NewBLP( + counter.NextExporterID(), + func() int64 { return int64(b.q.Len()) }, + int64(cfg.maxQSize.Value), + ) + if err != nil { + otel.Handle(err) + } + + // Wrap exporter with metrics recording if observability is enabled. + // This must be the innermost wrapper (closest to user exporter) to record + // metrics just before calling the actual exporter. + if b.inst != nil { + exporter = newMetricsExporter(exporter, b.inst) + } + // Order is important here. Wrap the timeoutExporter with the chunkExporter // to ensure each export completes in timeout (instead of all chunked // exports). @@ -119,69 +122,144 @@ func NewBatchProcessor(exporter Exporter, opts ...BatchProcessorOption) *BatchPr // appropriately on export. exporter = newChunkExporter(exporter, cfg.expMaxBatchSize.Value) - b := &BatchProcessor{ - exporter: newBufferExporter(exporter, cfg.expBufferSize.Value), - - q: newQueue(cfg.maxQSize.Value), - batchSize: cfg.expMaxBatchSize.Value, - pollTrigger: make(chan struct{}, 1), - pollKill: make(chan struct{}), - } - b.pollDone = b.poll(cfg.expInterval.Value) + b.exporter = exporter + b.process(cfg.expInterval.Value) return b } -// poll spawns a goroutine to handle interval polling and batch exporting. The -// returned done chan is closed when the spawned goroutine completes. -func (b *BatchProcessor) poll(interval time.Duration) (done chan struct{}) { - done = make(chan struct{}) - - ticker := time.NewTicker(interval) - // TODO: investigate using a sync.Pool instead of cloning. - buf := make([]Record, b.batchSize) +// process starts the goroutine that owns dequeueing and all exporter calls. +func (b *BatchProcessor) process(interval time.Duration) { go func() { - defer close(done) - defer ticker.Stop() + timer := time.NewTimer(interval) + defer timer.Stop() + // The worker owns and reuses buf. Exporters must not retain the slice + // passed to them, so it is safe to refill after Export returns. + buf := make([]Record, b.batchSize) for { + // Probe shutdown by itself first. This makes an already queued terminal + // request win over every other ready case. Closing done before replying + // also means a successful Shutdown response observes a stopped worker. select { - case <-ticker.C: - case <-b.pollTrigger: - ticker.Reset(interval) - case <-b.pollKill: + case req := <-b.shutdown: + err := b.shutdownExporter(req.ctx) + close(b.done) + req.respond(err) return + default: } - if d := b.q.Dropped(); d > 0 { - global.Warn("dropped log records", "dropped", d) + // With no queued shutdown, service a waiting ForceFlush before ordinary + // export wakes. The default keeps this priority check non-blocking. + // Shutdown remains selectable in case it arrived after the first probe. + select { + case req := <-b.shutdown: + err := b.shutdownExporter(req.ctx) + close(b.done) + req.respond(err) + return + case req := <-b.flush: + err := b.flushExporter(req.ctx) + req.respond(err) + continue + default: } - var qLen int - // Don't copy data from queue unless exporter can accept more, it is very expensive. - if b.exporter.Ready() { - qLen = b.q.TryDequeue(buf, func(r []Record) bool { - ok := b.exporter.EnqueueExport(r) - if ok { - buf = slices.Clone(buf) - } - return ok - }) - } else { - qLen = b.q.Len() - } - - if qLen >= b.batchSize { - // There is another full batch ready. Immediately trigger - // another export attempt. - select { - case b.pollTrigger <- struct{}{}: - default: - // Another flush signal already received. - } + // No lifecycle request was waiting, so block on the complete event set. + // Both timer and size-triggered exports start a new interval window. + select { + case req := <-b.shutdown: + err := b.shutdownExporter(req.ctx) + close(b.done) + req.respond(err) + return + case req := <-b.flush: + err := b.flushExporter(req.ctx) + req.respond(err) + case <-timer.C: + resetTimer(timer, interval) + b.exportBatch(buf) + case <-b.exportTrigger: + resetTimer(timer, interval) + b.exportBatch(buf) } } }() - return done +} + +func resetTimer(timer *time.Timer, interval time.Duration) { + // Handle both GODEBUG=asynctimerchan=[0|1] properly. + if !timer.Stop() { + select { + case <-timer.C: + default: + } + } + timer.Reset(interval) +} + +func (b *BatchProcessor) exportBatch(buf []Record) { + b.logDroppedRecords() + n, remaining := b.q.Dequeue(buf) + if n == 0 { + return + } + + err := b.exporter.Export(context.Background(), buf[:n]) + clear(buf[:n]) + if err != nil { + otel.Handle(err) + } + if remaining >= b.batchSize { + b.triggerExport() + } +} + +func (b *BatchProcessor) flushExporter(ctx context.Context) error { + if err := ctx.Err(); err != nil { + return err + } + b.logDroppedRecords() + records := b.q.Flush() + err := b.exporter.Export(ctx, records) + clear(records) + if ctxErr := ctx.Err(); ctxErr != nil { + return errors.Join(err, ctxErr) + } + return errors.Join(err, b.exporter.ForceFlush(ctx)) +} + +func (b *BatchProcessor) shutdownExporter(ctx context.Context) error { + b.logDroppedRecords() + records := b.q.Flush() + err := b.exporter.Export(ctx, records) + clear(records) + if ctxErr := ctx.Err(); ctxErr != nil { + err = errors.Join(err, ctxErr) + } else { + err = errors.Join(err, b.exporter.ForceFlush(ctx)) + } + err = errors.Join(err, b.exporter.Shutdown(ctx)) + if b.inst != nil { + err = errors.Join(err, b.inst.Shutdown()) + } + return err +} + +func (b *BatchProcessor) logDroppedRecords() { + if d := b.q.Dropped(); d > 0 { + if b.inst != nil { + b.inst.ProcessedQueueFull(context.Background(), int64(min(math.MaxInt64, d))) // nolint:gosec + } + global.Warn("dropped log records", "dropped", d) + } +} + +func (b *BatchProcessor) triggerExport() { + select { + case b.exportTrigger <- struct{}{}: + default: + } } // Enabled returns true, indicating this Processor will process all records. @@ -196,43 +274,31 @@ func (b *BatchProcessor) OnEmit(_ context.Context, r *Record) error { } // The record is cloned so that changes done by subsequent processors // are not going to lead to a data race. - if n := b.q.Enqueue(r.Clone()); n >= b.batchSize { - select { - case b.pollTrigger <- struct{}{}: - default: - // Flush chan full. The poll goroutine will handle this by - // re-sending any trigger until the queue has less than batchSize - // records. - } + if n, accepted := b.q.Enqueue(r.Clone()); accepted && n >= b.batchSize { + b.triggerExport() } return nil } -// Shutdown flushes queued log records and shuts down the decorated exporter. +// Shutdown flushes queued log records and the decorated exporter before +// shutting it down. func (b *BatchProcessor) Shutdown(ctx context.Context) error { if b.stopped.Swap(true) || b.q == nil { return nil } - // Stop the poll goroutine. - close(b.pollKill) + b.q.Close() + resp := make(chan error, 1) + b.shutdown <- batchProcessorRequest{ctx: ctx, resp: resp} + if err := ctx.Err(); err != nil { + return err + } select { - case <-b.pollDone: + case err := <-resp: + return err case <-ctx.Done(): - // Out of time. - return errors.Join(ctx.Err(), b.exporter.Shutdown(ctx)) + return ctx.Err() } - - // Flush remaining queued before exporter shutdown. - err := b.exporter.Export(ctx, b.q.Flush()) - return errors.Join(err, b.exporter.Shutdown(ctx)) -} - -var errPartialFlush = errors.New("partial flush: export buffer full") - -// Used for testing. -var ctxErr = func(ctx context.Context) error { - return ctx.Err() } // ForceFlush flushes queued log records and flushes the decorated exporter. @@ -240,27 +306,26 @@ func (b *BatchProcessor) ForceFlush(ctx context.Context) error { if b.stopped.Load() || b.q == nil { return nil } + if err := ctx.Err(); err != nil { + return err + } - buf := make([]Record, b.q.cap) - notFlushed := func() bool { - var flushed bool - _ = b.q.TryDequeue(buf, func(r []Record) bool { - flushed = b.exporter.EnqueueExport(r) - return flushed - }) - return !flushed + resp := make(chan error, 1) + req := batchProcessorRequest{ctx: ctx, resp: resp} + select { + case b.flush <- req: + case <-b.done: + return nil + case <-ctx.Done(): + return ctx.Err() } - var err error - // For as long as ctx allows, try to make a single flush of the queue. - for notFlushed() { - // Use ctxErr instead of calling ctx.Err directly so we can test - // the partial error return. - if e := ctxErr(ctx); e != nil { - err = errors.Join(e, errPartialFlush) - break - } + + select { + case err := <-resp: + return err + case <-ctx.Done(): + return ctx.Err() } - return errors.Join(err, b.exporter.ForceFlush(ctx)) } // queue holds a queue of logging records. @@ -273,6 +338,7 @@ type queue struct { dropped atomic.Uint64 cap, len int read, write *ring + closed bool } func newQueue(size int) *queue { @@ -302,10 +368,14 @@ func (q *queue) Dropped() uint64 { // // If enqueueing r will exceed the capacity of q, the oldest Record held in q // will be dropped and r retained. -func (q *queue) Enqueue(r Record) int { +func (q *queue) Enqueue(r Record) (int, bool) { q.Lock() defer q.Unlock() + if q.closed { + return q.len, false + } + q.write.Value = r q.write = q.write.Next() @@ -316,35 +386,23 @@ func (q *queue) Enqueue(r Record) int { q.read = q.read.Next() q.dropped.Add(1) } - return q.len + return q.len, true } -// TryDequeue attempts to dequeue up to len(buf) Records. The available Records -// will be assigned into buf and passed to write. If write fails, returning -// false, the Records will not be removed from the queue. If write succeeds, -// returning true, the dequeued Records are removed from the queue. The number -// of Records remaining in the queue are returned. -// -// When write is called the lock of q is held. The write function must not call -// other methods of this q that acquire the lock. -func (q *queue) TryDequeue(buf []Record, write func([]Record) bool) int { +// Dequeue removes up to len(buf) records from the queue and copies them into +// buf. The number copied and the number remaining are returned. +func (q *queue) Dequeue(buf []Record) (int, int) { q.Lock() defer q.Unlock() - origRead := q.read - n := min(len(buf), q.len) for i := range n { buf[i] = q.read.Value // nolint:gosec // n is bounded by len(buf) + q.read.Value = Record{} q.read = q.read.Next() } - - if write(buf[:n]) { - q.len -= n - } else { - q.read = origRead - } - return q.len + q.len -= n + return n, q.len } // Flush returns all the Records held in the queue and resets it to be @@ -353,9 +411,22 @@ func (q *queue) Flush() []Record { q.Lock() defer q.Unlock() + return q.flush() +} + +// Close stops the queue from accepting records. +func (q *queue) Close() { + q.Lock() + defer q.Unlock() + + q.closed = true +} + +func (q *queue) flush() []Record { out := make([]Record, q.len) for i := range out { out[i] = q.read.Value + q.read.Value = Record{} q.read = q.read.Next() } q.len = 0 @@ -368,7 +439,6 @@ type batchConfig struct { expInterval setting[time.Duration] expTimeout setting[time.Duration] expMaxBatchSize setting[int] - expBufferSize setting[int] } func newBatchConfig(options []BatchProcessorOption) batchConfig { @@ -399,14 +469,9 @@ func newBatchConfig(options []BatchProcessorOption) batchConfig { clearLessThanOne[int](), getenv[int](envarExpMaxBatchSize), clearLessThanOne[int](), // nolint:gocritic // the function argument is duplicated on purpose - clampMax[int](c.maxQSize.Value), fallback[int](dfltExpMaxBatchSize), + clampMax[int](c.maxQSize.Value), ) - c.expBufferSize = c.expBufferSize.Resolve( - clearLessThanOne[int](), - fallback[int](dfltExpBufferSize), - ) - return c } @@ -474,8 +539,9 @@ func WithExportTimeout(d time.Duration) BatchProcessorOption { // and this option is not passed, that variable value will be used. // // By default, if an environment variable is not set, and this option is not -// passed, 512 will be used. +// passed, 512 or the maximum queue size, if smaller, will be used. // The default value is also used when the provided value is less than one. +// The effective batch size will not exceed the configured maximum queue size. func WithExportMaxBatchSize(size int) BatchProcessorOption { return batchOptionFunc(func(cfg batchConfig) batchConfig { cfg.expMaxBatchSize = newSetting(size) @@ -483,14 +549,13 @@ func WithExportMaxBatchSize(size int) BatchProcessorOption { }) } -// WithExportBufferSize sets the batch buffer size. -// Batches will be temporarily kept in a memory buffer until they are exported. +// WithExportBufferSize is retained for source compatibility and has no effect. +// The processor no longer maintains a separately configurable export-request +// buffer. [WithMaxQueueSize] bounds the pending-record queue. // -// By default, a value of 1 will be used. -// The default value is also used when the provided value is less than one. -func WithExportBufferSize(size int) BatchProcessorOption { +// Deprecated: This option is no longer used. +func WithExportBufferSize(_ int) BatchProcessorOption { return batchOptionFunc(func(cfg batchConfig) batchConfig { - cfg.expBufferSize = newSetting(size) return cfg }) } diff --git a/vendor/go.opentelemetry.io/otel/sdk/log/doc.go b/vendor/go.opentelemetry.io/otel/sdk/log/doc.go index a27834a5b..5153a0e55 100644 --- a/vendor/go.opentelemetry.io/otel/sdk/log/doc.go +++ b/vendor/go.opentelemetry.io/otel/sdk/log/doc.go @@ -36,4 +36,4 @@ the experimental features. See [go.opentelemetry.io/otel/log] for more information about the OpenTelemetry Logs API. */ -package log // import "go.opentelemetry.io/otel/sdk/log" +package log diff --git a/vendor/go.opentelemetry.io/otel/sdk/log/exporter.go b/vendor/go.opentelemetry.io/otel/sdk/log/exporter.go index a9d3c439b..973ff91d7 100644 --- a/vendor/go.opentelemetry.io/otel/sdk/log/exporter.go +++ b/vendor/go.opentelemetry.io/otel/sdk/log/exporter.go @@ -1,17 +1,14 @@ // Copyright The OpenTelemetry Authors // SPDX-License-Identifier: Apache-2.0 -package log // import "go.opentelemetry.io/otel/sdk/log" +package log import ( "context" "errors" - "fmt" - "sync" - "sync/atomic" "time" - "go.opentelemetry.io/otel" + "go.opentelemetry.io/otel/sdk/log/internal/observ" ) // Exporter handles the delivery of log records to external receivers. @@ -67,6 +64,11 @@ func (noopExporter) Shutdown(context.Context) error { return nil } func (noopExporter) ForceFlush(context.Context) error { return nil } +func shutdownExporter(ctx context.Context, exporter Exporter) error { + err := exporter.ForceFlush(ctx) + return errors.Join(err, exporter.Shutdown(ctx)) +} + // chunkExporter wraps an Exporter's Export method so it is called with // appropriately sized export payloads. Any payload larger than a defined size // is chunked into smaller payloads and exported sequentially. @@ -90,12 +92,19 @@ func newChunkExporter(exporter Exporter, size int) Exporter { // Export exports records in chunks no larger than c.size. func (c chunkExporter) Export(ctx context.Context, records []Record) error { n := len(records) + var errs []error for i, j := 0, min(c.size, n); i < n; i, j = i+c.size, min(j+c.size, n) { + if ctxErr := ctx.Err(); ctxErr != nil { + return errors.Join(append(errs, ctxErr)...) + } if err := c.Exporter.Export(ctx, records[i:j]); err != nil { - return err + errs = append(errs, err) + } + if ctxErr := ctx.Err(); ctxErr != nil { + return errors.Join(append(errs, ctxErr)...) } } - return nil + return errors.Join(errs...) } // timeoutExporter wraps an Exporter and ensures any call to Export will have a @@ -126,201 +135,27 @@ func (e *timeoutExporter) Export(ctx context.Context, records []Record) error { return e.Exporter.Export(ctx, records) } -// exportSync exports all data from input using exporter in a spawned -// goroutine. The returned chan will be closed when the spawned goroutine -// completes. -func exportSync(input <-chan exportData, exporter Exporter) (done chan struct{}) { - done = make(chan struct{}) - go func() { - defer close(done) - for data := range input { - data.DoExport(exporter.Export) - } - }() - return done -} - -// exportData is data related to an export. -type exportData struct { - ctx context.Context - records []Record - - // respCh is the channel any error returned from the export will be sent - // on. If this is nil, and the export error is non-nil, the error will - // passed to the OTel error handler. - respCh chan<- error -} - -// DoExport calls exportFn with the data contained in e. The error response -// will be returned on e's respCh if not nil. The error will be handled by the -// default OTel error handle if it is not nil and respCh is nil or full. -func (e exportData) DoExport(exportFn func(context.Context, []Record) error) { - if len(e.records) == 0 { - e.respond(nil) - return - } - - e.respond(exportFn(e.ctx, e.records)) -} - -func (e exportData) respond(err error) { - select { - case e.respCh <- err: - default: - // e.respCh is nil or busy, default to otel.Handler. - if err != nil { - otel.Handle(err) - } - } -} - -// bufferExporter provides asynchronous and synchronous export functionality by -// buffering export requests. -type bufferExporter struct { +// metricsExporter wraps an Exporter to record log processing metrics +// just before calling the wrapped exporter. +type metricsExporter struct { Exporter - - input chan exportData - inputMu sync.Mutex - - done chan struct{} - stopped atomic.Bool + inst *observ.BLP } -// newBufferExporter returns a new bufferExporter that wraps exporter. The -// returned bufferExporter will buffer at most size number of export requests. -// If size is less than 1, 1 will be used. -func newBufferExporter(exporter Exporter, size int) *bufferExporter { - if size < 1 { - size = 1 - } - input := make(chan exportData, size) - return &bufferExporter{ +// newMetricsExporter creates a metricsExporter that wraps the given exporter. +func newMetricsExporter(exporter Exporter, inst *observ.BLP) Exporter { + return &metricsExporter{ Exporter: exporter, - - input: input, - done: exportSync(input, exporter), + inst: inst, } } -func (e *bufferExporter) Ready() bool { - return len(e.input) != cap(e.input) -} - -var errStopped = errors.New("exporter stopped") - -func (e *bufferExporter) enqueue(ctx context.Context, records []Record, rCh chan<- error) error { - data := exportData{ctx, records, rCh} - - e.inputMu.Lock() - defer e.inputMu.Unlock() - - // Check stopped before enqueueing now that e.inputMu is held. This - // prevents sends on a closed chan when Shutdown is called concurrently. - if e.stopped.Load() { - return errStopped - } - - select { - case e.input <- data: - case <-ctx.Done(): - return ctx.Err() - } - return nil -} - -// EnqueueExport enqueues an export of records in the context of ctx to be -// performed asynchronously. This will return true if the records are -// successfully enqueued (or the bufferExporter is shut down), false otherwise. -// -// The passed records are held after this call returns. -func (e *bufferExporter) EnqueueExport(records []Record) bool { - if len(records) == 0 { - // Nothing to enqueue, do not waste input space. - return true - } - - data := exportData{ctx: context.Background(), records: records} - - e.inputMu.Lock() - defer e.inputMu.Unlock() - - // Check stopped before enqueueing now that e.inputMu is held. This - // prevents sends on a closed chan when Shutdown is called concurrently. - if e.stopped.Load() { - return true - } - - select { - case e.input <- data: - return true - default: - return false - } -} - -// Export synchronously exports records in the context of ctx. This will not -// return until the export has been completed. -func (e *bufferExporter) Export(ctx context.Context, records []Record) error { - if len(records) == 0 { - return nil - } - - resp := make(chan error, 1) - err := e.enqueue(ctx, records, resp) - if err != nil { - if errors.Is(err, errStopped) { - return nil - } - return fmt.Errorf("%w: dropping %d records", err, len(records)) - } - - select { - case err := <-resp: - return err - case <-ctx.Done(): - return ctx.Err() - } -} - -// ForceFlush flushes buffered exports. Any existing exports that is buffered -// is flushed before this returns. -func (e *bufferExporter) ForceFlush(ctx context.Context) error { - resp := make(chan error, 1) - err := e.enqueue(ctx, nil, resp) - if err != nil { - if errors.Is(err, errStopped) { - return nil - } - return err - } - - select { - case <-resp: - case <-ctx.Done(): - return ctx.Err() - } - return e.Exporter.ForceFlush(ctx) -} - -// Shutdown shuts down e. -// -// Any buffered exports are flushed before this returns. -// -// All calls to EnqueueExport or Exporter will return nil without any export -// after this is called. -func (e *bufferExporter) Shutdown(ctx context.Context) error { - if e.stopped.Swap(true) { - return nil - } - e.inputMu.Lock() - defer e.inputMu.Unlock() - - // No more sends will be made. - close(e.input) - select { - case <-e.done: - case <-ctx.Done(): - return errors.Join(ctx.Err(), e.Exporter.Shutdown(ctx)) - } - return e.Exporter.Shutdown(ctx) +// Export records the number of log records as a metric then forwards +// them to the wrapped Exporter. Error returned from wrapped exporter +// is not considered as per specification (to be measured by exporter). +func (e *metricsExporter) Export(ctx context.Context, records []Record) error { + if e.inst != nil { + e.inst.Processed(ctx, int64(len(records))) + } + return e.Exporter.Export(ctx, records) } diff --git a/vendor/go.opentelemetry.io/otel/sdk/log/instrumentation.go b/vendor/go.opentelemetry.io/otel/sdk/log/instrumentation.go index 5e496f7e2..b6eec35b2 100644 --- a/vendor/go.opentelemetry.io/otel/sdk/log/instrumentation.go +++ b/vendor/go.opentelemetry.io/otel/sdk/log/instrumentation.go @@ -1,7 +1,7 @@ // Copyright The OpenTelemetry Authors // SPDX-License-Identifier: Apache-2.0 -package log // import "go.opentelemetry.io/otel/sdk/log" +package log import ( "context" @@ -11,8 +11,8 @@ import ( "go.opentelemetry.io/otel/metric" "go.opentelemetry.io/otel/sdk" "go.opentelemetry.io/otel/sdk/log/internal/x" - semconv "go.opentelemetry.io/otel/semconv/v1.41.0" - "go.opentelemetry.io/otel/semconv/v1.41.0/otelconv" + semconv "go.opentelemetry.io/otel/semconv/v1.43.0" + "go.opentelemetry.io/otel/semconv/v1.43.0/otelconv" ) // newRecordCounterIncr returns a function that increments the log record diff --git a/vendor/go.opentelemetry.io/otel/sdk/log/internal/attrnorm/dedup.go b/vendor/go.opentelemetry.io/otel/sdk/log/internal/attrnorm/dedup.go new file mode 100644 index 000000000..fe9ddc96d --- /dev/null +++ b/vendor/go.opentelemetry.io/otel/sdk/log/internal/attrnorm/dedup.go @@ -0,0 +1,300 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +// DO NOT MODIFY. Generated by gotmpl. +// source: internal/shared/attrnorm/dedup.go.tmpl + +// Package attrnorm normalizes attribute values. +package attrnorm + +import ( + "reflect" + "unsafe" + + "go.opentelemetry.io/otel/attribute" +) + +var ( + keyValueType = reflect.TypeFor[attribute.KeyValue]() + valueType = reflect.TypeFor[attribute.Value]() +) + +// rawValue mirrors attribute.Value. It is used only to read immutable slice +// storage without calling AsMap or AsSlice on no-op paths. +type rawValue struct { + vtype attribute.Type + numeric uint64 + stringly string + slice any +} + +// Value returns value with all map values deduplicated and whether it changed. +// +// Duplicate map keys are resolved using last-value-wins semantics. +func Value(value attribute.Value) (attribute.Value, bool) { + switch value.Type() { + case attribute.SLICE: + return deduplicateSliceValue(value) + case attribute.MAP: + return deduplicateMapValue(value) + default: + return value, false + } +} + +// KeyValue returns kv with all map values deduplicated and whether it changed. +func KeyValue(kv attribute.KeyValue) (attribute.KeyValue, bool) { + value, changed := Value(kv.Value) + if changed { + kv.Value = value + } + return kv, changed +} + +// KeyValues returns kvs with all map values deduplicated and whether they changed. +// +// The returned slice is the original kvs slice if no value needs +// deduplication. Top-level keys in kvs are not deduplicated. +func KeyValues(kvs []attribute.KeyValue) ([]attribute.KeyValue, bool) { + // Preserve the caller's slice on the common no-op path. Once a changed + // value is found, copy the prior values exactly once and fill the rest in + // place as the scan continues. + var normalized []attribute.KeyValue + for i, kv := range kvs { + kv, changed := KeyValue(kv) + if normalized != nil { + normalized[i] = kv + continue + } + if !changed { + continue + } + + normalized = make([]attribute.KeyValue, len(kvs)) + copy(normalized, kvs[:i]) + normalized[i] = kv + } + if normalized == nil { + return kvs, false + } + return normalized, true +} + +// Set returns set with all map values deduplicated and whether it changed. +// +// The returned Set is the original set if no value needs deduplication. +// Top-level key uniqueness remains attribute.Set's responsibility; this only +// normalizes map attribute values. +func Set(set attribute.Set) (attribute.Set, bool) { + if set.Len() == 0 { + return set, false + } + + // Most attribute sets contain no duplicate map keys. Delay allocation until + // the first changed value so the no-op path returns the original Set. + var normalized []attribute.KeyValue + for i := range set.Len() { + kv, _ := set.Get(i) + kv, changed := KeyValue(kv) + if normalized != nil { + normalized = append(normalized, kv) + continue + } + if !changed { + continue + } + + normalized = make([]attribute.KeyValue, 0, set.Len()) + for j := range i { + prior, _ := set.Get(j) + normalized = append(normalized, prior) + } + normalized = append(normalized, kv) + } + if normalized == nil { + return set, false + } + + return attribute.NewSet(normalized...), true +} + +func deduplicateSliceValue(value attribute.Value) (attribute.Value, bool) { + storage := valueStorage(value) + length := valueLen(storage) + + // Slice values can contain map values, so recurse into each element while + // keeping the original attribute.Value when no element changes. + var normalized []attribute.Value + for i := range length { + elem := valueAt(storage, i) + elem, changed := Value(elem) + if normalized != nil { + normalized[i] = elem + continue + } + if !changed { + continue + } + + normalized = make([]attribute.Value, length) + for j := range i { + normalized[j] = valueAt(storage, j) + } + normalized[i] = elem + } + if normalized == nil { + return value, false + } + return attribute.SliceValue(normalized...), true +} + +func deduplicateMapValue(value attribute.Value) (attribute.Value, bool) { + storage := valueStorage(value) + length := keyValueLen(storage) + if length <= 1 { + // A single map entry cannot duplicate its own key, but its value might + // contain a map or slice that needs recursive normalization. + if length == 1 { + kv, changed := KeyValue(keyValueAt(storage, 0)) + if changed { + return attribute.MapValue(kv), true + } + } + return value, false + } + + var normalized []attribute.KeyValue + for i := 0; i < length; { + // attribute.MapValue stores key-values sorted by key using a stable + // sort. Equal keys therefore form a contiguous run, and the last + // element in that run is the last value provided by the caller. + first := keyValueAt(storage, i) + j := i + 1 + for j < length && keyValueAt(storage, j).Key == first.Key { + j++ + } + + kv, nestedChanged := KeyValue(keyValueAt(storage, j-1)) + // j-i > 1 means the current key run contained duplicates. + changed := nestedChanged || j-i > 1 + if normalized != nil { + normalized = append(normalized, kv) + } else if changed { + normalized = make([]attribute.KeyValue, 0, length) + for k := range i { + normalized = append(normalized, keyValueAt(storage, k)) + } + normalized = append(normalized, kv) + } + i = j + } + if normalized == nil { + return value, false + } + return attribute.MapValue(normalized...), true +} + +func valueStorage(value attribute.Value) any { + // attribute.Value does not expose allocation-free map/slice iteration. + // The raw mirror lets us read the immutable backing array directly and + // reserve AsMap/AsSlice-style allocation for paths that actually change. + return (*rawValue)( + unsafe.Pointer(&value), + ).slice //nolint:gosec // Read-only mirror of attribute.Value for allocation-free iteration. +} + +func valueLen(storage any) int { + // attribute.Value stores small slices in fixed-size array values. Handle + // the common sizes directly and fall back to reflection for larger arrays. + switch storage.(type) { + case [0]attribute.Value: + return 0 + case [1]attribute.Value: + return 1 + case [2]attribute.Value: + return 2 + case [3]attribute.Value: + return 3 + case [4]attribute.Value: + return 4 + case [5]attribute.Value: + return 5 + default: + return arrayLen(storage, valueType) + } +} + +func valueAt(storage any, i int) attribute.Value { + switch values := storage.(type) { + case [1]attribute.Value: + return values[i] + case [2]attribute.Value: + return values[i] + case [3]attribute.Value: + return values[i] + case [4]attribute.Value: + return values[i] + case [5]attribute.Value: + return values[i] + default: + return arrayAt[attribute.Value](storage, valueType, i) + } +} + +func keyValueLen(storage any) int { + // attribute.Value stores small maps in fixed-size key-value arrays. Handle + // the common sizes directly and fall back to reflection for larger arrays. + switch storage.(type) { + case [0]attribute.KeyValue: + return 0 + case [1]attribute.KeyValue: + return 1 + case [2]attribute.KeyValue: + return 2 + case [3]attribute.KeyValue: + return 3 + case [4]attribute.KeyValue: + return 4 + case [5]attribute.KeyValue: + return 5 + default: + return arrayLen(storage, keyValueType) + } +} + +func keyValueAt(storage any, i int) attribute.KeyValue { + switch kvs := storage.(type) { + case [1]attribute.KeyValue: + return kvs[i] + case [2]attribute.KeyValue: + return kvs[i] + case [3]attribute.KeyValue: + return kvs[i] + case [4]attribute.KeyValue: + return kvs[i] + case [5]attribute.KeyValue: + return kvs[i] + default: + return arrayAt[attribute.KeyValue](storage, keyValueType, i) + } +} + +func arrayLen(storage any, elem reflect.Type) int { + // Be defensive around invalid or unexpected Value storage. Returning zero + // makes malformed storage a no-op instead of panicking in telemetry paths. + array := reflect.ValueOf(storage) + if array.Kind() != reflect.Array || array.Type().Elem() != elem { + return 0 + } + return array.Len() +} + +func arrayAt[T any](storage any, elem reflect.Type, i int) T { + // Match arrayLen's fail-closed behavior for unexpected storage. + array := reflect.ValueOf(storage) + if array.Kind() != reflect.Array || array.Type().Elem() != elem || i < 0 || i >= array.Len() { + var zero T + return zero + } + return array.Index(i).Interface().(T) +} diff --git a/vendor/go.opentelemetry.io/otel/sdk/log/internal/attrnorm/truncate.go b/vendor/go.opentelemetry.io/otel/sdk/log/internal/attrnorm/truncate.go new file mode 100644 index 000000000..9955e9072 --- /dev/null +++ b/vendor/go.opentelemetry.io/otel/sdk/log/internal/attrnorm/truncate.go @@ -0,0 +1,232 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +// DO NOT MODIFY. Generated by gotmpl. +// source: internal/shared/attrnorm/truncate.go.tmpl + +package attrnorm + +import ( + "slices" + "strings" + "unicode/utf8" + + "go.opentelemetry.io/otel/attribute" +) + +// Truncate returns a truncated version of attr. Only string, string slice, +// byte slice, slice, and map attribute values are truncated. String values are +// truncated to at most a length of limit. Each string slice value is truncated +// in this fashion (the slice length itself is unaffected), and byte slice +// values are truncated to at most limit bytes. For slice and map attribute +// values, the limit is applied recursively to contained values. +// +// No truncation is performed for a negative limit. +func Truncate(limit int, attr attribute.KeyValue) attribute.KeyValue { + if limit < 0 { + return attr + } + switch attr.Value.Type() { + case attribute.STRING: + v := attr.Value.AsString() + return attr.Key.String(truncate(limit, v)) + case attribute.STRINGSLICE: + v := attr.Value.AsStringSlice() + for i := range v { + v[i] = truncate(limit, v[i]) + } + return attr.Key.StringSlice(v) + case attribute.BYTESLICE: + v := attr.Value.AsString() + if len(v) > limit { + return attr.Key.ByteSlice([]byte(v[:limit])) + } + return attr + case attribute.SLICE: + v := attr.Value.AsSlice() + if !slices.ContainsFunc(v, func(e attribute.Value) bool { return needsTruncation(limit, e) }) { + return attr + } + newV := make([]attribute.Value, len(v)) + for i, elem := range v { + newV[i] = TruncateValue(limit, elem) + } + return attr.Key.Slice(newV...) + case attribute.MAP: + v := attr.Value.AsMap() + if !slices.ContainsFunc(v, func(kv attribute.KeyValue) bool { return needsTruncation(limit, kv.Value) }) { + return attr + } + newV := make([]attribute.KeyValue, len(v)) + for i, elem := range v { + elem.Value = TruncateValue(limit, elem.Value) + newV[i] = elem + } + return attr.Key.Map(newV...) + } + return attr +} + +// TruncateValue returns a truncated version of v. Only string, string +// slice, byte slice, and (recursively) slice and map values are modified. +// +// No truncation is performed for a negative limit. +func TruncateValue(limit int, v attribute.Value) attribute.Value { + if limit < 0 { + return v + } + + switch v.Type() { + case attribute.STRING: + return attribute.StringValue(truncate(limit, v.AsString())) + case attribute.STRINGSLICE: + ss := v.AsStringSlice() + for i := range ss { + ss[i] = truncate(limit, ss[i]) + } + return attribute.StringSliceValue(ss) + case attribute.BYTESLICE: + // len(v.AsString()) is identical to len(v.AsByteSlice()) but + // avoids allocating the full slice before truncation. + s := v.AsString() + if limit >= 0 && len(s) > limit { + return attribute.ByteSliceValue([]byte(s[:limit])) + } + case attribute.SLICE: + sl := v.AsSlice() + if !slices.ContainsFunc(sl, func(e attribute.Value) bool { return needsTruncation(limit, e) }) { + return v + } + newSl := make([]attribute.Value, len(sl)) + for i, elem := range sl { + newSl[i] = TruncateValue(limit, elem) + } + return attribute.SliceValue(newSl...) + case attribute.MAP: + m := v.AsMap() + if !slices.ContainsFunc(m, func(kv attribute.KeyValue) bool { return needsTruncation(limit, kv.Value) }) { + return v + } + newM := make([]attribute.KeyValue, len(m)) + for i, elem := range m { + elem.Value = TruncateValue(limit, elem.Value) + newM[i] = elem + } + return attribute.MapValue(newM...) + } + return v +} + +// stringNeedsTruncation reports whether s would be modified by truncate for the +// given limit. +func stringNeedsTruncation(limit int, s string) bool { + if limit < 0 || len(s) <= limit { + return false + } + return utf8.RuneCountInString(s) > limit || !utf8.ValidString(s) +} + +// needsTruncation reports whether v would be modified by TruncateValue for the +// given limit. +func needsTruncation(limit int, v attribute.Value) bool { + switch v.Type() { + case attribute.STRING: + return stringNeedsTruncation(limit, v.AsString()) + case attribute.BYTESLICE: + // len(v.AsString()) is identical to len(v.AsByteSlice()) but + // avoids memory allocation. + if limit >= 0 && len(v.AsString()) > limit { + return true + } + case attribute.STRINGSLICE: + for _, s := range v.AsStringSlice() { + if stringNeedsTruncation(limit, s) { + return true + } + } + case attribute.SLICE: + return slices.ContainsFunc(v.AsSlice(), func(e attribute.Value) bool { return needsTruncation(limit, e) }) + case attribute.MAP: + return slices.ContainsFunc( + v.AsMap(), + func(kv attribute.KeyValue) bool { return needsTruncation(limit, kv.Value) }, + ) + } + return false +} + +// 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. +// +// If limit is negative, it returns the original string. +// +// UTF-8 is supported. When truncating, all invalid characters are dropped +// before applying truncation. +// +// If s already contains less than the limit number of bytes, it is returned +// unchanged. No invalid characters are removed. +func truncate(limit int, s string) string { + // This prioritize performance in the following order based on the most + // common expected use-cases. + // + // - Short values less than the default limit (128). + // - Strings with valid encodings that exceed the limit. + // - No limit. + // - Strings with invalid encodings that exceed the limit. + if limit < 0 || len(s) <= limit { + return s + } + + // Optimistically, assume all valid UTF-8. + var b strings.Builder + count := 0 + for i, c := range s { + if c != utf8.RuneError { + count++ + if count > limit { + return s[:i] + } + continue + } + + _, size := utf8.DecodeRuneInString(s[i:]) + if size == 1 { + // Invalid encoding. + b.Grow(len(s) - 1) + _, _ = b.WriteString(s[:i]) + s = s[i:] + break + } + } + + // Fast-path, no invalid input. + if b.Cap() == 0 { + return s + } + + // Truncate while validating UTF-8. + for i := 0; i < len(s) && count < limit; { + c := s[i] + if c < utf8.RuneSelf { + // Optimization for single byte runes (common case). + _ = b.WriteByte(c) + i++ + count++ + continue + } + + _, size := utf8.DecodeRuneInString(s[i:]) + if size == 1 { + // We checked for all 1-byte runes above, this is a RuneError. + i++ + continue + } + + _, _ = b.WriteString(s[i : i+size]) + i += size + count++ + } + + return b.String() +} diff --git a/vendor/go.opentelemetry.io/otel/sdk/log/internal/counter/counter.go b/vendor/go.opentelemetry.io/otel/sdk/log/internal/counter/counter.go new file mode 100644 index 000000000..57c6acb78 --- /dev/null +++ b/vendor/go.opentelemetry.io/otel/sdk/log/internal/counter/counter.go @@ -0,0 +1,31 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +// DO NOT MODIFY. Generated by gotmpl. +// source: internal/shared/counter/counter.go.tmpl + +// Package counter provides a simple counter for generating unique IDs. +// +// This package is used to generate unique IDs while allowing testing packages +// to reset the counter. +package counter + +import "sync/atomic" + +// exporterN is a global 0-based count of the number of exporters created. +var exporterN atomic.Int64 + +// NextExporterID returns the next unique ID for an exporter. +func NextExporterID() int64 { + const inc = 1 + return exporterN.Add(inc) - inc +} + +// SetExporterID sets the exporter ID counter to v and returns the previous +// value. +// +// This function is useful for testing purposes, allowing you to reset the +// counter. It should not be used in production code. +func SetExporterID(v int64) int64 { + return exporterN.Swap(v) +} diff --git a/vendor/go.opentelemetry.io/otel/sdk/log/internal/observ/batch_log_processor.go b/vendor/go.opentelemetry.io/otel/sdk/log/internal/observ/batch_log_processor.go new file mode 100644 index 000000000..e6c6d6074 --- /dev/null +++ b/vendor/go.opentelemetry.io/otel/sdk/log/internal/observ/batch_log_processor.go @@ -0,0 +1,127 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +package observ + +import ( + "context" + "errors" + "fmt" + + "go.opentelemetry.io/otel" + "go.opentelemetry.io/otel/attribute" + "go.opentelemetry.io/otel/metric" + "go.opentelemetry.io/otel/sdk" + "go.opentelemetry.io/otel/sdk/log/internal/x" + semconv "go.opentelemetry.io/otel/semconv/v1.43.0" + "go.opentelemetry.io/otel/semconv/v1.43.0/otelconv" +) + +const ( + // SchemaURL is the schema URL of the instrumentation. + SchemaURL = semconv.SchemaURL +) + +// ErrQueueFull is the attribute value for the "queue_full" error type. +var ErrQueueFull = otelconv.SDKProcessorLogProcessed{}.AttrErrorType("queue_full") + +// BLPComponentName returns the component name attribute for a +// BatchLogProcessor with the given ID. +func BLPComponentName(id int64) attribute.KeyValue { + t := otelconv.ComponentTypeBatchingLogProcessor + name := fmt.Sprintf("%s/%d", t, id) + return semconv.OTelComponentName(name) +} + +// BLP is the instrumentation for an OTel SDK BatchLogProcessor. +type BLP struct { + reg metric.Registration + + processed metric.Int64Counter + processedOpts []metric.AddOption + processedQueueFullOpts []metric.AddOption +} + +// NewBLP creates a new BatchLogProcessor instrumentation. +// Returns nil if observability is not enabled. +func NewBLP(id int64, qLen func() int64, qMax int64) (*BLP, error) { + if !x.Observability.Enabled() { + return nil, nil + } + if qLen == nil { + return nil, errors.New("BLP qLen must not be nil") + } + + meter := otel.GetMeterProvider().Meter( + ScopeName, + metric.WithInstrumentationVersion(sdk.Version()), + metric.WithSchemaURL(SchemaURL), + ) + + qCap, err := otelconv.NewSDKProcessorLogQueueCapacity(meter) + if err != nil { + return nil, fmt.Errorf("failed to create BLP queue capacity metric: %w", err) + } + qCapInst := qCap.Inst() + + qSize, err := otelconv.NewSDKProcessorLogQueueSize(meter) + if err != nil { + return nil, fmt.Errorf("failed to create BLP queue size metric: %w", err) + } + qSizeInst := qSize.Inst() + + cmpntT := semconv.OTelComponentTypeBatchingLogProcessor + cmpnt := BLPComponentName(id) + set := attribute.NewSet(cmpnt, cmpntT) + + // Register callback for async metrics + obsOpts := []metric.ObserveOption{metric.WithAttributeSet(set)} + reg, err := meter.RegisterCallback( + func(_ context.Context, o metric.Observer) error { + o.ObserveInt64(qSizeInst, qLen(), obsOpts...) + o.ObserveInt64(qCapInst, qMax, obsOpts...) + return nil + }, + qSizeInst, + qCapInst, + ) + if err != nil { + return nil, fmt.Errorf("failed to register BLP queue size/capacity callback: %w", err) + } + + processed, err := otelconv.NewSDKProcessorLogProcessed(meter) + if err != nil { + _ = reg.Unregister() + return nil, fmt.Errorf("failed to create BLP processed logs metric: %w", err) + } + + processedOpts := []metric.AddOption{metric.WithAttributeSet(set)} + setWithError := attribute.NewSet(cmpnt, cmpntT, ErrQueueFull) + processedQueueFullOpts := []metric.AddOption{metric.WithAttributeSet(setWithError)} + + return &BLP{ + reg: reg, + processed: processed.Inst(), + processedOpts: processedOpts, + processedQueueFullOpts: processedQueueFullOpts, + }, nil +} + +func (b *BLP) Shutdown() error { + if b == nil || b.reg == nil { + return nil + } + return b.reg.Unregister() +} + +func (b *BLP) Processed(ctx context.Context, n int64) { + if b.processed.Enabled(ctx) { + b.processed.Add(ctx, n, b.processedOpts...) + } +} + +func (b *BLP) ProcessedQueueFull(ctx context.Context, n int64) { + if b.processed.Enabled(ctx) { + b.processed.Add(ctx, n, b.processedQueueFullOpts...) + } +} diff --git a/vendor/go.opentelemetry.io/otel/sdk/log/internal/observ/doc.go b/vendor/go.opentelemetry.io/otel/sdk/log/internal/observ/doc.go index 6879567cb..1c52a93e3 100644 --- a/vendor/go.opentelemetry.io/otel/sdk/log/internal/observ/doc.go +++ b/vendor/go.opentelemetry.io/otel/sdk/log/internal/observ/doc.go @@ -3,4 +3,4 @@ // Package observ provides observability instrumentation for the OTel log SDK // package. -package observ // import "go.opentelemetry.io/otel/sdk/log/internal/observ" +package observ diff --git a/vendor/go.opentelemetry.io/otel/sdk/log/internal/observ/simple_log_processor.go b/vendor/go.opentelemetry.io/otel/sdk/log/internal/observ/simple_log_processor.go index 916bdc67e..9f19320ad 100644 --- a/vendor/go.opentelemetry.io/otel/sdk/log/internal/observ/simple_log_processor.go +++ b/vendor/go.opentelemetry.io/otel/sdk/log/internal/observ/simple_log_processor.go @@ -1,7 +1,7 @@ // Copyright The OpenTelemetry Authors // SPDX-License-Identifier: Apache-2.0 -package observ // import "go.opentelemetry.io/otel/sdk/log/internal/observ" +package observ import ( "context" @@ -14,8 +14,8 @@ import ( "go.opentelemetry.io/otel/metric" "go.opentelemetry.io/otel/sdk" "go.opentelemetry.io/otel/sdk/log/internal/x" - semconv "go.opentelemetry.io/otel/semconv/v1.41.0" - "go.opentelemetry.io/otel/semconv/v1.41.0/otelconv" + semconv "go.opentelemetry.io/otel/semconv/v1.43.0" + "go.opentelemetry.io/otel/semconv/v1.43.0/otelconv" ) const ( diff --git a/vendor/go.opentelemetry.io/otel/sdk/log/internal/x/README.md b/vendor/go.opentelemetry.io/otel/sdk/log/internal/x/README.md index 33176f78e..5c06e2723 100644 --- a/vendor/go.opentelemetry.io/otel/sdk/log/internal/x/README.md +++ b/vendor/go.opentelemetry.io/otel/sdk/log/internal/x/README.md @@ -19,6 +19,9 @@ To opt-in, set the environment variable `OTEL_GO_X_OBSERVABILITY` to `true`. When enabled, the SDK will create the following metrics using the global `MeterProvider`: - `otel.sdk.log.created` +- `otel.sdk.processor.log.queue.capacity` +- `otel.sdk.processor.log.queue.size` +- `otel.sdk.processor.log.processed` Please see the [Semantic conventions for OpenTelemetry SDK metrics] documentation for more details on these metrics. diff --git a/vendor/go.opentelemetry.io/otel/sdk/log/internal/x/features.go b/vendor/go.opentelemetry.io/otel/sdk/log/internal/x/features.go index e0ac88a42..76e1bf7e2 100644 --- a/vendor/go.opentelemetry.io/otel/sdk/log/internal/x/features.go +++ b/vendor/go.opentelemetry.io/otel/sdk/log/internal/x/features.go @@ -2,7 +2,7 @@ // SPDX-License-Identifier: Apache-2.0 // Package x documents experimental features for [go.opentelemetry.io/otel/sdk/log]. -package x // import "go.opentelemetry.io/otel/sdk/log/internal/x" +package x import "strings" diff --git a/vendor/go.opentelemetry.io/otel/sdk/log/internal/x/x.go b/vendor/go.opentelemetry.io/otel/sdk/log/internal/x/x.go index e597efb10..90a1660bc 100644 --- a/vendor/go.opentelemetry.io/otel/sdk/log/internal/x/x.go +++ b/vendor/go.opentelemetry.io/otel/sdk/log/internal/x/x.go @@ -1,11 +1,11 @@ -// Code generated by gotmpl. DO NOT MODIFY. -// source: internal/shared/x/x.go.tmpl - // Copyright The OpenTelemetry Authors // SPDX-License-Identifier: Apache-2.0 +// DO NOT MODIFY. Generated by gotmpl. +// source: internal/shared/x/x.go.tmpl + // Package x documents experimental features for [go.opentelemetry.io/otel/sdk/log]. -package x // import "go.opentelemetry.io/otel/sdk/log/internal/x" +package x import ( "os" diff --git a/vendor/go.opentelemetry.io/otel/sdk/log/logger.go b/vendor/go.opentelemetry.io/otel/sdk/log/logger.go index ce63f4e30..7f8adcf66 100644 --- a/vendor/go.opentelemetry.io/otel/sdk/log/logger.go +++ b/vendor/go.opentelemetry.io/otel/sdk/log/logger.go @@ -1,7 +1,7 @@ // Copyright The OpenTelemetry Authors // SPDX-License-Identifier: Apache-2.0 -package log // import "go.opentelemetry.io/otel/sdk/log" +package log import ( "context" @@ -11,19 +11,19 @@ import ( "time" "go.opentelemetry.io/otel" + "go.opentelemetry.io/otel/attribute" "go.opentelemetry.io/otel/log" "go.opentelemetry.io/otel/log/embedded" "go.opentelemetry.io/otel/sdk/instrumentation" - semconv "go.opentelemetry.io/otel/semconv/v1.41.0" + semconv "go.opentelemetry.io/otel/semconv/v1.43.0" "go.opentelemetry.io/otel/trace" ) var now = time.Now const ( - exceptionTypeKey = string(semconv.ExceptionTypeKey) - exceptionMessageKey = string(semconv.ExceptionMessageKey) - exceptionStacktraceKey = string(semconv.ExceptionStacktraceKey) + exceptionTypeKey = semconv.ExceptionTypeKey + exceptionMessageKey = semconv.ExceptionMessageKey ) // Compile-time check logger implements log.Logger. @@ -55,17 +55,50 @@ func newLogger(p *LoggerProvider, scope instrumentation.Scope) *logger { } func (l *logger) Emit(ctx context.Context, r log.Record) { - newRecord := l.newRecord(ctx, r) - for _, p := range l.provider.processors { - if err := p.OnEmit(ctx, &newRecord); err != nil { - otel.Handle(err) + processors := l.provider.processors + if len(processors) == 0 { + if l.provider.stopped.Load() { + return } + // Emit remains observable without processors, but no lifecycle + // admission or SDK record construction is needed. + l.recordCreated(ctx) + return + } + + for _, err := range l.emit(ctx, r, processors) { + otel.Handle(err) + } +} + +func (l *logger) emit(ctx context.Context, r log.Record, processors []Processor) []error { + if !l.provider.beginProcessorOperation() { + return nil + } + defer l.provider.endProcessorOperation() + + l.recordCreated(ctx) + newRecord := l.newRecord(ctx, r) + var errs []error + for _, processor := range processors { + if err := processor.OnEmit(ctx, &newRecord); err != nil { + errs = append(errs, err) + } + } + return errs +} + +func (l *logger) recordCreated(ctx context.Context) { + if l.recCntIncr != nil { + l.recCntIncr(ctx) } } // Enabled returns true if at least one Processor held by the LoggerProvider // that created the logger will process for the provided context and param. // +// Enabled returns false after the LoggerProvider that created l starts shutdown. +// // If it is not possible to definitively determine the record will be // processed, true will be returned by default. A value of false will only be // returned if it can be positively verified that no Processor will process. @@ -76,7 +109,13 @@ func (l *logger) Enabled(ctx context.Context, param log.EnabledParameters) bool EventName: param.EventName, } - for _, processor := range l.provider.processors { + processors := l.provider.processors + if len(processors) == 0 || !l.provider.beginProcessorOperation() { + return false + } + defer l.provider.endProcessorOperation() + + for _, processor := range processors { if processor.Enabled(ctx, p) { // At least one Processor will process the Record. return true @@ -106,10 +145,6 @@ func (l *logger) newRecord(ctx context.Context, r log.Record) Record { attributeCountLimit: l.provider.attributeCountLimit, allowDupKeys: l.provider.allowDupKeys, } - if l.recCntIncr != nil { - l.recCntIncr(ctx) - } - // This ensures we deduplicate key-value collections in the log body newRecord.SetBody(r.Body()) @@ -118,47 +153,65 @@ func (l *logger) newRecord(ctx context.Context, r log.Record) Record { newRecord.observedTimestamp = now() } - hasExceptionAttr := false - r.WalkAttributes(func(kv log.KeyValue) bool { + // User-provided exception attributes MUST take precedence. Track message + // and type independently so a supplied value suppresses only its own + // derivation. + var hasExceptionMessage, hasExceptionType bool + r.WalkAttributes(func(kv attribute.KeyValue) bool { switch kv.Key { - case exceptionTypeKey, exceptionMessageKey, exceptionStacktraceKey: - hasExceptionAttr = true + case exceptionMessageKey: + hasExceptionMessage = true + case exceptionTypeKey: + hasExceptionType = true } newRecord.AddAttributes(kv) return true }) - if err := r.Err(); err != nil && !hasExceptionAttr { - addExceptionAttrs(&newRecord, err) + // Avoid inspecting the error for attributes when the caller has + // already supplied the attributes. + if err := r.Err(); err != nil && (!hasExceptionMessage || !hasExceptionType) { + // Derive missing exception attributes by default, as required by the + // Logs SDK specification. Attribute limits may constrain generation, + // so stop once there is no capacity for another attribute. + var attrs [2]attribute.KeyValue + n := 0 + + // Derived attributes are buffered until flush, so the current attribute + // count stays unchanged while missing values are prepared. + hasLimit := newRecord.hasAttributeCountLimit() + var remaining int + if hasLimit { + remaining = newRecord.attributeCountLimit - newRecord.AttributesLen() + } + if !hasExceptionMessage { + if msg := err.Error(); msg != "" { + if hasLimit && remaining <= n { + goto flush + } + attrs[n] = exceptionMessageKey.String(msg) + n++ + } + } + if !hasExceptionType { + if errType := errorType(err); errType != "" { + if hasLimit && remaining <= n { + goto flush + } + attrs[n] = exceptionTypeKey.String(errType) + n++ + } + } + + flush: + if n > 0 { + newRecord.addAttrs(attrs[:n]) + } } return newRecord } -func addExceptionAttrs(r *Record, err error) { - var attrs [2]log.KeyValue - n := 0 - if msg := err.Error(); msg != "" { - if r.attributeCountLimit > 0 && r.attributeCountLimit-r.AttributesLen() < n+1 { - goto flush - } - attrs[n] = log.String(exceptionMessageKey, msg) - n++ - } - if errType := errorType(err); errType != "" { - if r.attributeCountLimit > 0 && r.attributeCountLimit-r.AttributesLen() < n+1 { - goto flush - } - attrs[n] = log.String(exceptionTypeKey, errType) - n++ - } - -flush: - if n > 0 { - r.addAttrs(attrs[:n]) - } -} - func errorType(err error) string { if et, ok := err.(interface{ ErrorType() string }); ok { if s := et.ErrorType(); s != "" { diff --git a/vendor/go.opentelemetry.io/otel/sdk/log/processor.go b/vendor/go.opentelemetry.io/otel/sdk/log/processor.go index ba6319c09..31cd72c20 100644 --- a/vendor/go.opentelemetry.io/otel/sdk/log/processor.go +++ b/vendor/go.opentelemetry.io/otel/sdk/log/processor.go @@ -1,7 +1,7 @@ // Copyright The OpenTelemetry Authors // SPDX-License-Identifier: Apache-2.0 -package log // import "go.opentelemetry.io/otel/sdk/log" +package log import ( "context" @@ -12,13 +12,23 @@ import ( // Processor handles the processing of log records. // -// Any of the Processor's methods may be called concurrently with itself -// or with other methods. It is the responsibility of the Processor to manage -// this concurrency. +// Enabled, OnEmit, and ForceFlush may be called concurrently with themselves +// or each other. It is the responsibility of the Processor to manage this +// concurrency. +// +// A Processor must be registered only once and with a single +// [LoggerProvider]. Registering the same Processor with multiple providers or +// multiple times with the same provider is not supported. +// +// A [LoggerProvider] stops admitting new operations that invoke Enabled, +// OnEmit, or ForceFlush when shutdown starts. Callers that use a Processor +// directly are responsible for coordinating those calls with Shutdown. type Processor interface { // Enabled reports whether the Processor will process for the given context // and param. // + // Enabled is called synchronously and should not block. + // // The param contains a subset of the information that will be available // in the Record passed to OnEmit, as defined by EnabledParameters. // A field being unset in param does not imply the corresponding field @@ -42,12 +52,12 @@ type Processor interface { // The SDK's Logger.Enabled returns false if all the registered processors // return false. Otherwise, it returns true. // - // Implementations of this method need to be safe for a user to call - // concurrently. Enabled(ctx context.Context, param EnabledParameters) bool // OnEmit is called when a Record is emitted. // + // OnEmit is called synchronously and should not block. + // // OnEmit will be called independent of Enabled. Implementations need to // validate the arguments themselves before processing. // @@ -73,6 +83,13 @@ type Processor interface { // resources held by the Processor (and any underlying Exporter) should be // done in this call. // + // A LoggerProvider calls Shutdown at most once. Before calling it, the + // LoggerProvider waits for all Enabled, OnEmit, and ForceFlush calls it + // admitted to complete. If the LoggerProvider's Shutdown context is canceled + // while waiting, Shutdown is not called. + // + // Shutdown must include the effects of ForceFlush. + // // The deadline or cancellation of the passed context must be honored. An // appropriate error should be returned in these situations. // diff --git a/vendor/go.opentelemetry.io/otel/sdk/log/provider.go b/vendor/go.opentelemetry.io/otel/sdk/log/provider.go index 4ac799bfd..cf5472c0d 100644 --- a/vendor/go.opentelemetry.io/otel/sdk/log/provider.go +++ b/vendor/go.opentelemetry.io/otel/sdk/log/provider.go @@ -1,7 +1,7 @@ // Copyright The OpenTelemetry Authors // SPDX-License-Identifier: Apache-2.0 -package log // import "go.opentelemetry.io/otel/sdk/log" +package log import ( "context" @@ -15,6 +15,7 @@ import ( "go.opentelemetry.io/otel/log/embedded" "go.opentelemetry.io/otel/log/noop" "go.opentelemetry.io/otel/sdk/instrumentation" + "go.opentelemetry.io/otel/sdk/log/internal/attrnorm" "go.opentelemetry.io/otel/sdk/resource" ) @@ -65,7 +66,11 @@ func newProviderConfig(opts []LoggerProviderOption) providerConfig { } // LoggerProvider handles the creation and coordination of Loggers. All Loggers -// created by a LoggerProvider will be associated with the same Resource. +// it creates are associated with the same Resource. +// +// After [LoggerProvider.Shutdown] starts, calls to [log.Logger.Enabled] on +// Loggers created by the LoggerProvider return false, and calls to +// [log.Logger.Emit] perform no operation. type LoggerProvider struct { embedded.LoggerProvider @@ -78,7 +83,10 @@ type LoggerProvider struct { loggersMu sync.Mutex loggers map[instrumentation.Scope]*logger - stopped atomic.Bool + stopped atomic.Bool + processorOperationsMu sync.Mutex + processorOperationsActive int + processorOperationsDone chan struct{} noCmp [0]func() //nolint: unused // This is indeed used. } @@ -105,7 +113,7 @@ func NewLoggerProvider(opts ...LoggerProviderOption) *LoggerProvider { // Logger returns a new [log.Logger] with the provided name and configuration. // -// If p is shut down, a [noop.Logger] instance is returned. +// Calls made after [LoggerProvider.Shutdown] starts return a [noop.Logger]. // // This method can be called concurrently. func (p *LoggerProvider) Logger(name string, opts ...log.LoggerOption) log.Logger { @@ -118,11 +126,15 @@ func (p *LoggerProvider) Logger(name string, opts ...log.LoggerOption) log.Logge } cfg := log.NewLoggerConfig(opts...) + attrs := cfg.InstrumentationAttributes() + if !p.allowDupKeys { + attrs, _ = attrnorm.Set(attrs) + } scope := instrumentation.Scope{ Name: name, Version: cfg.InstrumentationVersion(), SchemaURL: cfg.SchemaURL(), - Attributes: cfg.InstrumentationAttributes(), + Attributes: attrs, } p.loggersMu.Lock() @@ -143,14 +155,40 @@ func (p *LoggerProvider) Logger(name string, opts ...log.LoggerOption) log.Logge return l } -// Shutdown shuts down the provider and all processors. +// Shutdown shuts down the provider and all processors in the order they were +// registered. +// +// The first call stops admitting new operations that invoke processor Enabled, +// OnEmit, or ForceFlush methods. It waits for operations already admitted to +// complete before synchronously invoking each processor's Shutdown method. If +// ctx is canceled before the admitted operations complete, Shutdown returns +// ctx.Err() without invoking processor Shutdown. +// +// Concurrent or subsequent Shutdown calls return nil without invoking +// processor Shutdown. +// +// Shutdown must not be called directly or indirectly from a Processor method. // // This method can be called concurrently. func (p *LoggerProvider) Shutdown(ctx context.Context) error { - stopped := p.stopped.Swap(true) - if stopped { + p.processorOperationsMu.Lock() + if p.stopped.Load() { + p.processorOperationsMu.Unlock() return nil } + p.processorOperationsDone = make(chan struct{}) + p.stopped.Store(true) + if p.processorOperationsActive == 0 { + close(p.processorOperationsDone) + } + p.processorOperationsMu.Unlock() + + // All count updates happen while processorOperationsMu is held. Therefore, + // either Shutdown observes zero operations and closes the channel above, or + // the final operation observes stopped and closes it synchronously. + if err := p.waitForProcessorOperations(ctx); err != nil { + return err + } var err error for _, p := range p.processors { @@ -161,11 +199,14 @@ func (p *LoggerProvider) Shutdown(ctx context.Context) error { // ForceFlush flushes all processors. // +// Once Shutdown starts, ForceFlush performs no operation and returns nil. +// // This method can be called concurrently. func (p *LoggerProvider) ForceFlush(ctx context.Context) error { - if p.stopped.Load() { + if len(p.processors) == 0 || !p.beginProcessorOperation() { return nil } + defer p.endProcessorOperation() var err error for _, p := range p.processors { @@ -174,6 +215,47 @@ func (p *LoggerProvider) ForceFlush(ctx context.Context) error { return err } +func (p *LoggerProvider) beginProcessorOperation() bool { + p.processorOperationsMu.Lock() + defer p.processorOperationsMu.Unlock() + if p.stopped.Load() { + return false + } + p.processorOperationsActive++ + return true +} + +func (p *LoggerProvider) endProcessorOperation() { + p.processorOperationsMu.Lock() + defer p.processorOperationsMu.Unlock() + p.processorOperationsActive-- + if p.processorOperationsActive == 0 && p.stopped.Load() { + close(p.processorOperationsDone) + } +} + +func (p *LoggerProvider) waitForProcessorOperations(ctx context.Context) error { + if err := ctx.Err(); err != nil { + return err + } + + return waitForProcessorOperationsCompletion(ctx, p.processorOperationsDone) +} + +func waitForProcessorOperationsCompletion(ctx context.Context, done <-chan struct{}) error { + select { + case <-done: + case <-ctx.Done(): + // Prefer a completed drain when it races with cancellation. + select { + case <-done: + default: + return ctx.Err() + } + } + return nil +} + // LoggerProviderOption applies a configuration option value to a LoggerProvider. type LoggerProviderOption interface { apply(providerConfig) providerConfig @@ -257,17 +339,23 @@ func WithAttributeValueLengthLimit(limit int) LoggerProviderOption { }) } -// WithAllowKeyDuplication sets whether deduplication is skipped for log attributes or other key-value collections. +// WithAllowKeyDuplication sets whether deduplication is skipped for log record +// and instrumentation scope key-value collections. // -// By default, the key-value collections within a log record are deduplicated to comply with the OpenTelemetry Specification. -// Deduplication means that if multiple key–value pairs with the same key are present, only a single pair -// is retained and others are discarded. +// By default, the key-value collections within a log record and +// instrumentation scope are deduplicated to comply with the OpenTelemetry +// Specification. +// Deduplication means that if multiple key-value pairs with the same key are +// present, only a single pair is retained and others are discarded. Resource +// attributes are always deduplicated by go.opentelemetry.io/otel/sdk/resource. // -// Disabling deduplication with this option can improve performance e.g. of adding attributes to the log record. +// Disabling deduplication with this option can improve performance e.g. of +// adding attributes to the log record. // -// Note that if you disable deduplication, you are responsible for ensuring that duplicate -// key-value pairs within in a single collection are not emitted, -// or that the telemetry receiver can handle such duplicates. +// Receivers may handle duplicate keys unpredictably. If you disable +// deduplication, you are responsible for ensuring that duplicate keys within a +// single collection are not emitted, or that the telemetry receiver can handle +// such duplicates. func WithAllowKeyDuplication() LoggerProviderOption { return loggerProviderOptionFunc(func(cfg providerConfig) providerConfig { cfg.allowDupKeys = newSetting(true) diff --git a/vendor/go.opentelemetry.io/otel/sdk/log/record.go b/vendor/go.opentelemetry.io/otel/sdk/log/record.go index 80b8bfa1e..6f64e04e3 100644 --- a/vendor/go.opentelemetry.io/otel/sdk/log/record.go +++ b/vendor/go.opentelemetry.io/otel/sdk/log/record.go @@ -1,18 +1,18 @@ // Copyright The OpenTelemetry Authors // SPDX-License-Identifier: Apache-2.0 -package log // import "go.opentelemetry.io/otel/sdk/log" +package log import ( "slices" - "strings" "sync" "time" - "unicode/utf8" + "go.opentelemetry.io/otel/attribute" "go.opentelemetry.io/otel/internal/global" "go.opentelemetry.io/otel/log" "go.opentelemetry.io/otel/sdk/instrumentation" + "go.opentelemetry.io/otel/sdk/log/internal/attrnorm" "go.opentelemetry.io/otel/sdk/resource" "go.opentelemetry.io/otel/trace" ) @@ -37,14 +37,14 @@ var logKeyValuePairDropped = sync.OnceFunc(func() { // uniquePool is a pool of unique attributes used for attributes de-duplication. var uniquePool = sync.Pool{ - New: func() any { return new([]log.KeyValue) }, + New: func() any { return new([]attribute.KeyValue) }, } -func getUnique() *[]log.KeyValue { - return uniquePool.Get().(*[]log.KeyValue) +func getUnique() *[]attribute.KeyValue { + return uniquePool.Get().(*[]attribute.KeyValue) } -func putUnique(v *[]log.KeyValue) { +func putUnique(v *[]attribute.KeyValue) { if cap(*v) <= maxUniqueSize { clear(*v) *v = (*v)[:0] @@ -54,32 +54,18 @@ func putUnique(v *[]log.KeyValue) { // indexPool is a pool of index maps used for attributes de-duplication. var indexPool = sync.Pool{ - New: func() any { return make(map[string]int) }, + New: func() any { return make(map[attribute.Key]int) }, } -func getIndex() map[string]int { - return indexPool.Get().(map[string]int) +func getIndex() map[attribute.Key]int { + return indexPool.Get().(map[attribute.Key]int) } -func putIndex(index map[string]int) { +func putIndex(index map[attribute.Key]int) { clear(index) indexPool.Put(index) } -// seenPool is a pool of seen keys used for maps de-duplication. -var seenPool = sync.Pool{ - New: func() any { return make(map[string]struct{}) }, -} - -func getSeen() map[string]struct{} { - return seenPool.Get().(map[string]struct{}) -} - -func putSeen(seen map[string]struct{}) { - clear(seen) - seenPool.Put(seen) -} - // Record is a log record emitted by the Logger. // A log record with non-empty event name is interpreted as an event record. // @@ -95,7 +81,7 @@ type Record struct { observedTimestamp time.Time severity log.Severity severityText string - body log.Value + body attribute.Value // The fields below are for optimizing the implementation of Attributes and // AddAttributes. This design is borrowed from the slog Record type: @@ -104,7 +90,7 @@ type Record struct { // Allocation optimization: an inline array sized to hold // the majority of log calls (based on examination of open-source // code). It holds the start of the list of attributes. - front [attributesInlineCount]log.KeyValue + front [attributesInlineCount]attribute.KeyValue // The number of attributes in front. nFront int @@ -113,7 +99,7 @@ type Record struct { // Invariants: // - len(back) > 0 if nFront == len(front) // - Unused array elements are zero-ed. Used to detect mistakes. - back []log.KeyValue + back []attribute.KeyValue // dropped is the count of attributes that have been dropped when limits // were reached. @@ -200,22 +186,22 @@ func (r *Record) SetSeverityText(text string) { } // Body returns the body of the log record. -func (r *Record) Body() log.Value { +func (r *Record) Body() attribute.Value { return r.body } // SetBody sets the body of the log record. -func (r *Record) SetBody(v log.Value) { +func (r *Record) SetBody(v attribute.Value) { if !r.allowDupKeys { - r.body = r.dedupeBodyCollections(v) + r.body, _ = attrnorm.Value(v) } else { r.body = v } } // WalkAttributes walks all attributes the log record holds by calling f for -// each on each [log.KeyValue] in the [Record]. Iteration stops if f returns false. -func (r *Record) WalkAttributes(f func(log.KeyValue) bool) { +// each on each [attribute.KeyValue] in the [Record]. Iteration stops if f returns false. +func (r *Record) WalkAttributes(f func(attribute.KeyValue) bool) { for i := 0; i < r.nFront; i++ { if !f(r.front[i]) { return @@ -230,7 +216,7 @@ func (r *Record) WalkAttributes(f func(log.KeyValue) bool) { // AddAttributes adds attributes to the log record. // Attributes in attrs will overwrite any attribute already added to r with the same key. -func (r *Record) AddAttributes(attrs ...log.KeyValue) { +func (r *Record) AddAttributes(attrs ...attribute.KeyValue) { n := r.AttributesLen() if n == 0 { // Avoid the more complex duplicate map lookups below. @@ -242,7 +228,7 @@ func (r *Record) AddAttributes(attrs ...log.KeyValue) { } } - attrs, drop := head(attrs, r.attributeCountLimit) + attrs, drop := r.head(attrs) r.addDropped(drop) r.addAttrs(attrs) @@ -295,12 +281,12 @@ func (r *Record) AddAttributes(attrs ...log.KeyValue) { } if dropped > 0 { - attrs = make([]log.KeyValue, len(*unique)) + attrs = make([]attribute.KeyValue, len(*unique)) copy(attrs, *unique) } } - if r.attributeCountLimit > 0 && n+len(attrs) > r.attributeCountLimit { + if r.hasAttributeCountLimit() && n+len(attrs) > r.attributeCountLimit { // Truncate the now unique attributes to comply with limit. // // Do not use head(attrs, r.attributeCountLimit - n) here. If @@ -320,7 +306,7 @@ func (r *Record) AddAttributes(attrs ...log.KeyValue) { // // The returned index is taken from the indexPool. It is the callers // responsibility to return the index to that pool (putIndex) when done. -func (r *Record) attrIndex() map[string]int { +func (r *Record) attrIndex() map[attribute.Key]int { index := getIndex() for i := 0; i < r.nFront; i++ { key := r.front[i].Key @@ -336,7 +322,7 @@ func (r *Record) attrIndex() map[string]int { // addAttrs adds attrs to the Record r. This does not validate any limits or // duplication of attributes, these tasks are left to the caller to handle // prior to calling. -func (r *Record) addAttrs(attrs []log.KeyValue) { +func (r *Record) addAttrs(attrs []attribute.KeyValue) { var i int for i = 0; i < len(attrs) && r.nFront < len(r.front); i++ { a := attrs[i] @@ -354,7 +340,7 @@ func (r *Record) addAttrs(attrs []log.KeyValue) { } // SetAttributes sets (and overrides) attributes to the log record. -func (r *Record) SetAttributes(attrs ...log.KeyValue) { +func (r *Record) SetAttributes(attrs ...attribute.KeyValue) { var drop int r.dropped = 0 if !r.allowDupKeys { @@ -364,7 +350,7 @@ func (r *Record) SetAttributes(attrs ...log.KeyValue) { } } - attrs, drop = head(attrs, r.attributeCountLimit) + attrs, drop = r.head(attrs) r.addDropped(drop) r.nFront = 0 @@ -381,17 +367,23 @@ func (r *Record) SetAttributes(attrs ...log.KeyValue) { } } -// head returns the first n values of kvs along with the number of elements -// dropped. If n is less than or equal to zero, kvs is returned with 0. -func head(kvs []log.KeyValue, n int) (out []log.KeyValue, dropped int) { - if n > 0 && len(kvs) > n { - return kvs[:n], len(kvs) - n +// head returns the attributes r can retain along with the number dropped. +func (r *Record) head(kvs []attribute.KeyValue) (out []attribute.KeyValue, dropped int) { + if r.attributeCountLimit < 0 || len(kvs) <= r.attributeCountLimit { + return kvs, 0 } - return kvs, 0 + if r.attributeCountLimit == 0 { + return nil, len(kvs) + } + return kvs[:r.attributeCountLimit], len(kvs) - r.attributeCountLimit +} + +func (r *Record) hasAttributeCountLimit() bool { + return r.attributeCountLimit >= 0 } // dedup deduplicates kvs front-to-back with the last value saved. -func dedup(kvs []log.KeyValue) (unique []log.KeyValue, dropped int) { +func dedup(kvs []attribute.KeyValue) (unique []attribute.KeyValue, dropped int) { if len(kvs) <= 1 { return kvs, 0 // No deduplication needed. } @@ -415,7 +407,7 @@ func dedup(kvs []log.KeyValue) (unique []log.KeyValue, dropped int) { return kvs, 0 } - unique = make([]log.KeyValue, len(*u)) + unique = make([]attribute.KeyValue, len(*u)) copy(unique, *u) return unique, dropped } @@ -482,275 +474,14 @@ func (r *Record) Clone() Record { return res } -func (r *Record) applyAttrLimitsAndDedup(attr log.KeyValue) log.KeyValue { - attr.Value = r.applyValueLimitsAndDedup(attr.Value) +func (r *Record) applyAttrLimitsAndDedup(attr attribute.KeyValue) attribute.KeyValue { + if !r.allowDupKeys { + var changed bool + attr, changed = attrnorm.KeyValue(attr) + if changed { + logKeyValuePairDropped() + } + } + attr.Value = attrnorm.TruncateValue(r.attributeValueLengthLimit, attr.Value) return attr } - -func (r *Record) applyValueLimitsAndDedup(val log.Value) log.Value { - switch val.Kind() { - case log.KindString: - s := val.AsString() - if r.attributeValueLengthLimit >= 0 && len(s) > r.attributeValueLengthLimit { - val = log.StringValue(truncate(r.attributeValueLengthLimit, s)) - } - case log.KindSlice: - sl := val.AsSlice() - - // First check if any limits need to be applied. - if slices.ContainsFunc(sl, r.needsValueLimitsOrDedup) { - // Create a new slice to avoid modifying the original. - newSl := make([]log.Value, len(sl)) - for i, item := range sl { - newSl[i] = r.applyValueLimitsAndDedup(item) - } - val = log.SliceValue(newSl...) - } - case log.KindBytes: - bs := val.AsBytes() - if r.attributeValueLengthLimit >= 0 && len(bs) > r.attributeValueLengthLimit { - val = log.BytesValue(bs[:r.attributeValueLengthLimit]) - } - case log.KindMap: - kvs := val.AsMap() - var newKvs []log.KeyValue - var dropped int - - if !r.allowDupKeys { - // Deduplicate then truncate. - // Do not do at the same time to avoid wasted truncation operations. - newKvs, dropped = dedup(kvs) - if dropped > 0 { - logKeyValuePairDropped() - } - } else { - newKvs = kvs - } - - // Check if any attribute limits need to be applied. - needsChange := false - if dropped > 0 { - needsChange = true // Already changed by dedup. - } else { - for _, kv := range newKvs { - if r.needsValueLimitsOrDedup(kv.Value) { - needsChange = true - break - } - } - } - - if needsChange { - // Only create new slice if changes are needed. - if dropped == 0 { - // Make a copy to avoid modifying the original. - newKvs = make([]log.KeyValue, len(kvs)) - copy(newKvs, kvs) - } - - for i := range newKvs { - newKvs[i] = r.applyAttrLimitsAndDedup(newKvs[i]) - } - val = log.MapValue(newKvs...) - } - } - return val -} - -// needsValueLimitsOrDedup checks if a value would be modified by applyValueLimitsAndDedup. -func (r *Record) needsValueLimitsOrDedup(val log.Value) bool { - switch val.Kind() { - case log.KindString: - return r.attributeValueLengthLimit >= 0 && len(val.AsString()) > r.attributeValueLengthLimit - case log.KindSlice: - if slices.ContainsFunc(val.AsSlice(), r.needsValueLimitsOrDedup) { - return true - } - case log.KindBytes: - bs := val.AsBytes() - if r.attributeValueLengthLimit >= 0 && len(bs) > r.attributeValueLengthLimit { - return true - } - case log.KindMap: - kvs := val.AsMap() - if !r.allowDupKeys && len(kvs) > 1 { - // Check for duplicates. - hasDuplicates := func() bool { - seen := getSeen() - defer putSeen(seen) - for _, kv := range kvs { - if _, ok := seen[kv.Key]; ok { - return true - } - seen[kv.Key] = struct{}{} - } - return false - }() - if hasDuplicates { - return true - } - } - for _, kv := range kvs { - if r.needsValueLimitsOrDedup(kv.Value) { - return true - } - } - } - return false -} - -func (r *Record) dedupeBodyCollections(val log.Value) log.Value { - switch val.Kind() { - case log.KindSlice: - sl := val.AsSlice() - - // Check if any nested values need deduplication. - if slices.ContainsFunc(sl, r.needsBodyDedup) { - // Create a new slice to avoid modifying the original. - newSl := make([]log.Value, len(sl)) - for i, item := range sl { - newSl[i] = r.dedupeBodyCollections(item) - } - val = log.SliceValue(newSl...) - } - - case log.KindMap: - kvs := val.AsMap() - newKvs, dropped := dedup(kvs) - - // Check if any nested values need deduplication. - needsValueChange := false - for _, kv := range newKvs { - if r.needsBodyDedup(kv.Value) { - needsValueChange = true - break - } - } - - if dropped > 0 || needsValueChange { - // Only create new value if changes are needed. - if dropped == 0 { - // Make a copy to avoid modifying the original. - newKvs = make([]log.KeyValue, len(kvs)) - copy(newKvs, kvs) - } - - for i := range newKvs { - newKvs[i].Value = r.dedupeBodyCollections(newKvs[i].Value) - } - val = log.MapValue(newKvs...) - } - } - return val -} - -// needsBodyDedup checks if a value would be modified by dedupeBodyCollections. -func (r *Record) needsBodyDedup(val log.Value) bool { - switch val.Kind() { - case log.KindSlice: - if slices.ContainsFunc(val.AsSlice(), r.needsBodyDedup) { - return true - } - case log.KindMap: - kvs := val.AsMap() - if len(kvs) > 1 { - // Check for duplicates. - hasDuplicates := func() bool { - seen := getSeen() - defer putSeen(seen) - for _, kv := range kvs { - if _, ok := seen[kv.Key]; ok { - return true - } - seen[kv.Key] = struct{}{} - } - return false - }() - if hasDuplicates { - return true - } - } - for _, kv := range kvs { - if r.needsBodyDedup(kv.Value) { - return true - } - } - } - return false -} - -// 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. -// -// If limit is negative, it returns the original string. -// -// UTF-8 is supported. When truncating, all invalid characters are dropped -// before applying truncation. -// -// If s already contains less than the limit number of bytes, it is returned -// unchanged. No invalid characters are removed. -func truncate(limit int, s string) string { - // This prioritize performance in the following order based on the most - // common expected use-cases. - // - // - Short values less than the default limit (128). - // - Strings with valid encodings that exceed the limit. - // - No limit. - // - Strings with invalid encodings that exceed the limit. - if limit < 0 || len(s) <= limit { - return s - } - - // Optimistically, assume all valid UTF-8. - var b strings.Builder - count := 0 - for i, c := range s { - if c != utf8.RuneError { - count++ - if count > limit { - return s[:i] - } - continue - } - - _, size := utf8.DecodeRuneInString(s[i:]) - if size == 1 { - // Invalid encoding. - b.Grow(len(s) - 1) - _, _ = b.WriteString(s[:i]) - s = s[i:] - break - } - } - - // Fast-path, no invalid input. - if b.Cap() == 0 { - return s - } - - // Truncate while validating UTF-8. - for i := 0; i < len(s) && count < limit; { - c := s[i] - if c < utf8.RuneSelf { - // Optimization for single byte runes (common case). - _ = b.WriteByte(c) - i++ - count++ - continue - } - - _, size := utf8.DecodeRuneInString(s[i:]) - if size == 1 { - // We checked for all 1-byte runes above, this is a RuneError. - i++ - continue - } - - _, _ = b.WriteString(s[i : i+size]) - i += size - count++ - } - - return b.String() -} diff --git a/vendor/go.opentelemetry.io/otel/sdk/log/ring.go b/vendor/go.opentelemetry.io/otel/sdk/log/ring.go index 5e84cb164..95da3816c 100644 --- a/vendor/go.opentelemetry.io/otel/sdk/log/ring.go +++ b/vendor/go.opentelemetry.io/otel/sdk/log/ring.go @@ -5,7 +5,7 @@ // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. -package log // import "go.opentelemetry.io/otel/sdk/log" +package log // A ring is an element of a circular list, or ring. Rings do not have a // beginning or end; a pointer to any ring element serves as reference to the diff --git a/vendor/go.opentelemetry.io/otel/sdk/log/setting.go b/vendor/go.opentelemetry.io/otel/sdk/log/setting.go index 72107a9e5..eb232bcb2 100644 --- a/vendor/go.opentelemetry.io/otel/sdk/log/setting.go +++ b/vendor/go.opentelemetry.io/otel/sdk/log/setting.go @@ -1,7 +1,7 @@ // Copyright The OpenTelemetry Authors // SPDX-License-Identifier: Apache-2.0 -package log // import "go.opentelemetry.io/otel/sdk/log" +package log import ( "fmt" diff --git a/vendor/go.opentelemetry.io/otel/sdk/log/simple.go b/vendor/go.opentelemetry.io/otel/sdk/log/simple.go index 9772e0c5e..ab83f19a2 100644 --- a/vendor/go.opentelemetry.io/otel/sdk/log/simple.go +++ b/vendor/go.opentelemetry.io/otel/sdk/log/simple.go @@ -1,7 +1,7 @@ // Copyright The OpenTelemetry Authors // SPDX-License-Identifier: Apache-2.0 -package log // import "go.opentelemetry.io/otel/sdk/log" +package log import ( "context" @@ -80,13 +80,13 @@ func (s *SimpleProcessor) OnEmit(ctx context.Context, r *Record) (err error) { return s.exporter.Export(ctx, *records) } -// Shutdown shuts down the exporter. +// Shutdown flushes the exporter before shutting it down. func (s *SimpleProcessor) Shutdown(ctx context.Context) error { if s.exporter == nil { return nil } - return s.exporter.Shutdown(ctx) + return shutdownExporter(ctx, s.exporter) } // ForceFlush flushes the exporter. diff --git a/vendor/go.opentelemetry.io/otel/semconv/v1.41.0/otelconv/metric.go b/vendor/go.opentelemetry.io/otel/semconv/v1.41.0/otelconv/metric.go deleted file mode 100644 index 367b58760..000000000 --- a/vendor/go.opentelemetry.io/otel/semconv/v1.41.0/otelconv/metric.go +++ /dev/null @@ -1,3125 +0,0 @@ -// Code generated from semantic convention specification. DO NOT EDIT. - -// Copyright The OpenTelemetry Authors -// SPDX-License-Identifier: Apache-2.0 - -// Package otelconv provides types and functionality for OpenTelemetry semantic -// conventions in the "otel" namespace. -package otelconv - -import ( - "context" - - "go.opentelemetry.io/otel/attribute" - "go.opentelemetry.io/otel/metric" - "go.opentelemetry.io/otel/metric/noop" - "go.opentelemetry.io/otel/semconv/internal/metricpool" -) - -// ErrorTypeAttr is an attribute conforming to the error.type semantic -// conventions. It represents the describes a class of error the operation ended -// with. -type ErrorTypeAttr string - -var ( - // ErrorTypeOther is a fallback error value to be used when the instrumentation - // doesn't define a custom value. - ErrorTypeOther ErrorTypeAttr = "_OTHER" -) - -// ComponentTypeAttr is an attribute conforming to the otel.component.type -// semantic conventions. It represents a name identifying the type of the -// OpenTelemetry component. -type ComponentTypeAttr string - -var ( - // ComponentTypeBatchingSpanProcessor is the builtin SDK batching span - // processor. - ComponentTypeBatchingSpanProcessor ComponentTypeAttr = "batching_span_processor" - // ComponentTypeSimpleSpanProcessor is the builtin SDK simple span processor. - ComponentTypeSimpleSpanProcessor ComponentTypeAttr = "simple_span_processor" - // ComponentTypeBatchingLogProcessor is the builtin SDK batching log record - // processor. - ComponentTypeBatchingLogProcessor ComponentTypeAttr = "batching_log_processor" - // ComponentTypeSimpleLogProcessor is the builtin SDK simple log record - // processor. - ComponentTypeSimpleLogProcessor ComponentTypeAttr = "simple_log_processor" - // ComponentTypeOtlpGRPCSpanExporter is the OTLP span exporter over gRPC with - // protobuf serialization. - ComponentTypeOtlpGRPCSpanExporter ComponentTypeAttr = "otlp_grpc_span_exporter" - // ComponentTypeOtlpHTTPSpanExporter is the OTLP span exporter over HTTP with - // protobuf serialization. - ComponentTypeOtlpHTTPSpanExporter ComponentTypeAttr = "otlp_http_span_exporter" - // ComponentTypeOtlpHTTPJSONSpanExporter is the OTLP span exporter over HTTP - // with JSON serialization. - ComponentTypeOtlpHTTPJSONSpanExporter ComponentTypeAttr = "otlp_http_json_span_exporter" - // ComponentTypeZipkinHTTPSpanExporter is the zipkin span exporter over HTTP. - ComponentTypeZipkinHTTPSpanExporter ComponentTypeAttr = "zipkin_http_span_exporter" - // ComponentTypeOtlpGRPCLogExporter is the OTLP log record exporter over gRPC - // with protobuf serialization. - ComponentTypeOtlpGRPCLogExporter ComponentTypeAttr = "otlp_grpc_log_exporter" - // ComponentTypeOtlpHTTPLogExporter is the OTLP log record exporter over HTTP - // with protobuf serialization. - ComponentTypeOtlpHTTPLogExporter ComponentTypeAttr = "otlp_http_log_exporter" - // ComponentTypeOtlpHTTPJSONLogExporter is the OTLP log record exporter over - // HTTP with JSON serialization. - ComponentTypeOtlpHTTPJSONLogExporter ComponentTypeAttr = "otlp_http_json_log_exporter" - // ComponentTypePeriodicMetricReader is the builtin SDK periodically exporting - // metric reader. - ComponentTypePeriodicMetricReader ComponentTypeAttr = "periodic_metric_reader" - // ComponentTypeOtlpGRPCMetricExporter is the OTLP metric exporter over gRPC - // with protobuf serialization. - ComponentTypeOtlpGRPCMetricExporter ComponentTypeAttr = "otlp_grpc_metric_exporter" - // ComponentTypeOtlpHTTPMetricExporter is the OTLP metric exporter over HTTP - // with protobuf serialization. - ComponentTypeOtlpHTTPMetricExporter ComponentTypeAttr = "otlp_http_metric_exporter" - // ComponentTypeOtlpHTTPJSONMetricExporter is the OTLP metric exporter over HTTP - // with JSON serialization. - ComponentTypeOtlpHTTPJSONMetricExporter ComponentTypeAttr = "otlp_http_json_metric_exporter" - // ComponentTypePrometheusHTTPTextMetricExporter is the prometheus metric - // exporter over HTTP with the default text-based format. - ComponentTypePrometheusHTTPTextMetricExporter ComponentTypeAttr = "prometheus_http_text_metric_exporter" -) - -// SpanParentOriginAttr is an attribute conforming to the otel.span.parent.origin -// semantic conventions. It represents the determines whether the span has a -// parent span, and if so, [whether it is a remote parent]. -// -// [whether it is a remote parent]: https://opentelemetry.io/docs/specs/otel/trace/api/#isremote -type SpanParentOriginAttr string - -var ( - // SpanParentOriginNone is the span does not have a parent, it is a root span. - SpanParentOriginNone SpanParentOriginAttr = "none" - // SpanParentOriginLocal is the span has a parent and the parent's span context - // [isRemote()] is false. - // - // [isRemote()]: https://opentelemetry.io/docs/specs/otel/trace/api/#isremote - SpanParentOriginLocal SpanParentOriginAttr = "local" - // SpanParentOriginRemote is the span has a parent and the parent's span context - // [isRemote()] is true. - // - // [isRemote()]: https://opentelemetry.io/docs/specs/otel/trace/api/#isremote - SpanParentOriginRemote SpanParentOriginAttr = "remote" -) - -// SpanSamplingResultAttr is an attribute conforming to the -// otel.span.sampling_result semantic conventions. It represents the result value -// of the sampler for this span. -type SpanSamplingResultAttr string - -var ( - // SpanSamplingResultDrop is the span is not sampled and not recording. - SpanSamplingResultDrop SpanSamplingResultAttr = "DROP" - // SpanSamplingResultRecordOnly is the span is not sampled, but recording. - SpanSamplingResultRecordOnly SpanSamplingResultAttr = "RECORD_ONLY" - // SpanSamplingResultRecordAndSample is the span is sampled and recording. - SpanSamplingResultRecordAndSample SpanSamplingResultAttr = "RECORD_AND_SAMPLE" -) - -// SDKExporterLogExported is an instrument used to record metric values -// conforming to the "otel.sdk.exporter.log.exported" semantic conventions. It -// represents the number of log records for which the export has finished, either -// successful or failed. -type SDKExporterLogExported struct { - metric.Int64Counter -} - -var newSDKExporterLogExportedOpts = []metric.Int64CounterOption{ - metric.WithDescription("The number of log records for which the export has finished, either successful or failed."), - metric.WithUnit("{log_record}"), -} - -// NewSDKExporterLogExported returns a new SDKExporterLogExported instrument. -func NewSDKExporterLogExported( - m metric.Meter, - opt ...metric.Int64CounterOption, -) (SDKExporterLogExported, error) { - // Check if the meter is nil. - if m == nil { - return SDKExporterLogExported{noop.Int64Counter{}}, nil - } - - if len(opt) == 0 { - opt = newSDKExporterLogExportedOpts - } else { - opt = append(opt, newSDKExporterLogExportedOpts...) - } - - i, err := m.Int64Counter( - "otel.sdk.exporter.log.exported", - opt..., - ) - if err != nil { - return SDKExporterLogExported{noop.Int64Counter{}}, err - } - return SDKExporterLogExported{i}, nil -} - -// Inst returns the underlying metric instrument. -func (m SDKExporterLogExported) Inst() metric.Int64Counter { - return m.Int64Counter -} - -// Name returns the semantic convention name of the instrument. -func (SDKExporterLogExported) Name() string { - return "otel.sdk.exporter.log.exported" -} - -// Unit returns the semantic convention unit of the instrument -func (SDKExporterLogExported) Unit() string { - return "{log_record}" -} - -// Description returns the semantic convention description of the instrument -func (SDKExporterLogExported) Description() string { - return "The number of log records for which the export has finished, either successful or failed." -} - -// Add adds incr to the existing count for attrs. -// -// All additional attrs passed are included in the recorded value. -// -// For successful exports, `error.type` MUST NOT be set. For failed exports, -// `error.type` MUST contain the failure cause. -// For exporters with partial success semantics (e.g. OTLP with -// `rejected_log_records`), rejected log records MUST count as failed and only -// non-rejected log records count as success. -// If no rejection reason is available, `rejected` SHOULD be used as value for -// `error.type`. -func (m SDKExporterLogExported) Add( - ctx context.Context, - incr int64, - attrs ...attribute.KeyValue, -) { - if !m.Int64Counter.Enabled(ctx) { - return - } - if len(attrs) == 0 { - m.Int64Counter.Add(ctx, incr) - return - } - - o := metricpool.AddOptions() - defer metricpool.PutAddOptions(o) - - *o = append( - *o, - metric.WithAttributes( - attrs..., - ), - ) - - m.Int64Counter.Add(ctx, incr, *o...) -} - -// AddSet adds incr to the existing count for set. -// -// For successful exports, `error.type` MUST NOT be set. For failed exports, -// `error.type` MUST contain the failure cause. -// For exporters with partial success semantics (e.g. OTLP with -// `rejected_log_records`), rejected log records MUST count as failed and only -// non-rejected log records count as success. -// If no rejection reason is available, `rejected` SHOULD be used as value for -// `error.type`. -func (m SDKExporterLogExported) AddSet(ctx context.Context, incr int64, set attribute.Set) { - if !m.Int64Counter.Enabled(ctx) { - return - } - if set.Len() == 0 { - m.Int64Counter.Add(ctx, incr) - return - } - - o := metricpool.AddOptions() - defer metricpool.PutAddOptions(o) - - *o = append(*o, metric.WithAttributeSet(set)) - m.Int64Counter.Add(ctx, incr, *o...) -} - -// AttrErrorType returns an optional attribute for the "error.type" semantic -// convention. It represents the describes a class of error the operation ended -// with. -func (SDKExporterLogExported) AttrErrorType(val ErrorTypeAttr) attribute.KeyValue { - return attribute.String("error.type", string(val)) -} - -// AttrComponentName returns an optional attribute for the "otel.component.name" -// semantic convention. It represents a name uniquely identifying the instance of -// the OpenTelemetry component within its containing SDK instance. -func (SDKExporterLogExported) AttrComponentName(val string) attribute.KeyValue { - return attribute.String("otel.component.name", val) -} - -// AttrComponentType returns an optional attribute for the "otel.component.type" -// semantic convention. It represents a name identifying the type of the -// OpenTelemetry component. -func (SDKExporterLogExported) AttrComponentType(val ComponentTypeAttr) attribute.KeyValue { - return attribute.String("otel.component.type", string(val)) -} - -// AttrServerAddress returns an optional attribute for the "server.address" -// semantic convention. It represents the server domain name if available without -// reverse DNS lookup; otherwise, IP address or Unix domain socket name. -func (SDKExporterLogExported) AttrServerAddress(val string) attribute.KeyValue { - return attribute.String("server.address", val) -} - -// AttrServerPort returns an optional attribute for the "server.port" semantic -// convention. It represents the server port number. -func (SDKExporterLogExported) AttrServerPort(val int) attribute.KeyValue { - return attribute.Int("server.port", val) -} - -// SDKExporterLogExportedObservable is an instrument used to record metric values -// conforming to the "otel.sdk.exporter.log.exported" semantic conventions. It -// represents the number of log records for which the export has finished, either -// successful or failed. -type SDKExporterLogExportedObservable struct { - metric.Int64ObservableCounter -} - -var newSDKExporterLogExportedObservableOpts = []metric.Int64ObservableCounterOption{ - metric.WithDescription("The number of log records for which the export has finished, either successful or failed."), - metric.WithUnit("{log_record}"), -} - -// NewSDKExporterLogExportedObservable returns a new -// SDKExporterLogExportedObservable instrument. -func NewSDKExporterLogExportedObservable( - m metric.Meter, - opt ...metric.Int64ObservableCounterOption, -) (SDKExporterLogExportedObservable, error) { - // Check if the meter is nil. - if m == nil { - return SDKExporterLogExportedObservable{noop.Int64ObservableCounter{}}, nil - } - - if len(opt) == 0 { - opt = newSDKExporterLogExportedObservableOpts - } else { - opt = append(opt, newSDKExporterLogExportedObservableOpts...) - } - - i, err := m.Int64ObservableCounter( - "otel.sdk.exporter.log.exported", - opt..., - ) - if err != nil { - return SDKExporterLogExportedObservable{noop.Int64ObservableCounter{}}, err - } - return SDKExporterLogExportedObservable{i}, nil -} - -// Inst returns the underlying metric instrument. -func (m SDKExporterLogExportedObservable) Inst() metric.Int64ObservableCounter { - return m.Int64ObservableCounter -} - -// Name returns the semantic convention name of the instrument. -func (SDKExporterLogExportedObservable) Name() string { - return "otel.sdk.exporter.log.exported" -} - -// Unit returns the semantic convention unit of the instrument -func (SDKExporterLogExportedObservable) Unit() string { - return "{log_record}" -} - -// Description returns the semantic convention description of the instrument -func (SDKExporterLogExportedObservable) Description() string { - return "The number of log records for which the export has finished, either successful or failed." -} - -// AttrErrorType returns an optional attribute for the "error.type" semantic -// convention. It represents the describes a class of error the operation ended -// with. -func (SDKExporterLogExportedObservable) AttrErrorType(val ErrorTypeAttr) attribute.KeyValue { - return attribute.String("error.type", string(val)) -} - -// AttrComponentName returns an optional attribute for the "otel.component.name" -// semantic convention. It represents a name uniquely identifying the instance of -// the OpenTelemetry component within its containing SDK instance. -func (SDKExporterLogExportedObservable) AttrComponentName(val string) attribute.KeyValue { - return attribute.String("otel.component.name", val) -} - -// AttrComponentType returns an optional attribute for the "otel.component.type" -// semantic convention. It represents a name identifying the type of the -// OpenTelemetry component. -func (SDKExporterLogExportedObservable) AttrComponentType(val ComponentTypeAttr) attribute.KeyValue { - return attribute.String("otel.component.type", string(val)) -} - -// AttrServerAddress returns an optional attribute for the "server.address" -// semantic convention. It represents the server domain name if available without -// reverse DNS lookup; otherwise, IP address or Unix domain socket name. -func (SDKExporterLogExportedObservable) AttrServerAddress(val string) attribute.KeyValue { - return attribute.String("server.address", val) -} - -// AttrServerPort returns an optional attribute for the "server.port" semantic -// convention. It represents the server port number. -func (SDKExporterLogExportedObservable) AttrServerPort(val int) attribute.KeyValue { - return attribute.Int("server.port", val) -} - -// SDKExporterLogInflight is an instrument used to record metric values -// conforming to the "otel.sdk.exporter.log.inflight" semantic conventions. It -// represents the number of log records which were passed to the exporter, but -// that have not been exported yet (neither successful, nor failed). -type SDKExporterLogInflight struct { - metric.Int64UpDownCounter -} - -var newSDKExporterLogInflightOpts = []metric.Int64UpDownCounterOption{ - metric.WithDescription("The number of log records which were passed to the exporter, but that have not been exported yet (neither successful, nor failed)."), - metric.WithUnit("{log_record}"), -} - -// NewSDKExporterLogInflight returns a new SDKExporterLogInflight instrument. -func NewSDKExporterLogInflight( - m metric.Meter, - opt ...metric.Int64UpDownCounterOption, -) (SDKExporterLogInflight, error) { - // Check if the meter is nil. - if m == nil { - return SDKExporterLogInflight{noop.Int64UpDownCounter{}}, nil - } - - if len(opt) == 0 { - opt = newSDKExporterLogInflightOpts - } else { - opt = append(opt, newSDKExporterLogInflightOpts...) - } - - i, err := m.Int64UpDownCounter( - "otel.sdk.exporter.log.inflight", - opt..., - ) - if err != nil { - return SDKExporterLogInflight{noop.Int64UpDownCounter{}}, err - } - return SDKExporterLogInflight{i}, nil -} - -// Inst returns the underlying metric instrument. -func (m SDKExporterLogInflight) Inst() metric.Int64UpDownCounter { - return m.Int64UpDownCounter -} - -// Name returns the semantic convention name of the instrument. -func (SDKExporterLogInflight) Name() string { - return "otel.sdk.exporter.log.inflight" -} - -// Unit returns the semantic convention unit of the instrument -func (SDKExporterLogInflight) Unit() string { - return "{log_record}" -} - -// Description returns the semantic convention description of the instrument -func (SDKExporterLogInflight) Description() string { - return "The number of log records which were passed to the exporter, but that have not been exported yet (neither successful, nor failed)." -} - -// Add adds incr to the existing count for attrs. -// -// All additional attrs passed are included in the recorded value. -// -// For successful exports, `error.type` MUST NOT be set. For failed exports, -// `error.type` MUST contain the failure cause. -func (m SDKExporterLogInflight) Add( - ctx context.Context, - incr int64, - attrs ...attribute.KeyValue, -) { - if !m.Int64UpDownCounter.Enabled(ctx) { - return - } - if len(attrs) == 0 { - m.Int64UpDownCounter.Add(ctx, incr) - return - } - - o := metricpool.AddOptions() - defer metricpool.PutAddOptions(o) - - *o = append( - *o, - metric.WithAttributes( - attrs..., - ), - ) - - m.Int64UpDownCounter.Add(ctx, incr, *o...) -} - -// AddSet adds incr to the existing count for set. -// -// For successful exports, `error.type` MUST NOT be set. For failed exports, -// `error.type` MUST contain the failure cause. -func (m SDKExporterLogInflight) AddSet(ctx context.Context, incr int64, set attribute.Set) { - if !m.Int64UpDownCounter.Enabled(ctx) { - return - } - if set.Len() == 0 { - m.Int64UpDownCounter.Add(ctx, incr) - return - } - - o := metricpool.AddOptions() - defer metricpool.PutAddOptions(o) - - *o = append(*o, metric.WithAttributeSet(set)) - m.Int64UpDownCounter.Add(ctx, incr, *o...) -} - -// AttrComponentName returns an optional attribute for the "otel.component.name" -// semantic convention. It represents a name uniquely identifying the instance of -// the OpenTelemetry component within its containing SDK instance. -func (SDKExporterLogInflight) AttrComponentName(val string) attribute.KeyValue { - return attribute.String("otel.component.name", val) -} - -// AttrComponentType returns an optional attribute for the "otel.component.type" -// semantic convention. It represents a name identifying the type of the -// OpenTelemetry component. -func (SDKExporterLogInflight) AttrComponentType(val ComponentTypeAttr) attribute.KeyValue { - return attribute.String("otel.component.type", string(val)) -} - -// AttrServerAddress returns an optional attribute for the "server.address" -// semantic convention. It represents the server domain name if available without -// reverse DNS lookup; otherwise, IP address or Unix domain socket name. -func (SDKExporterLogInflight) AttrServerAddress(val string) attribute.KeyValue { - return attribute.String("server.address", val) -} - -// AttrServerPort returns an optional attribute for the "server.port" semantic -// convention. It represents the server port number. -func (SDKExporterLogInflight) AttrServerPort(val int) attribute.KeyValue { - return attribute.Int("server.port", val) -} - -// SDKExporterLogInflightObservable is an instrument used to record metric values -// conforming to the "otel.sdk.exporter.log.inflight" semantic conventions. It -// represents the number of log records which were passed to the exporter, but -// that have not been exported yet (neither successful, nor failed). -type SDKExporterLogInflightObservable struct { - metric.Int64ObservableUpDownCounter -} - -var newSDKExporterLogInflightObservableOpts = []metric.Int64ObservableUpDownCounterOption{ - metric.WithDescription("The number of log records which were passed to the exporter, but that have not been exported yet (neither successful, nor failed)."), - metric.WithUnit("{log_record}"), -} - -// NewSDKExporterLogInflightObservable returns a new -// SDKExporterLogInflightObservable instrument. -func NewSDKExporterLogInflightObservable( - m metric.Meter, - opt ...metric.Int64ObservableUpDownCounterOption, -) (SDKExporterLogInflightObservable, error) { - // Check if the meter is nil. - if m == nil { - return SDKExporterLogInflightObservable{noop.Int64ObservableUpDownCounter{}}, nil - } - - if len(opt) == 0 { - opt = newSDKExporterLogInflightObservableOpts - } else { - opt = append(opt, newSDKExporterLogInflightObservableOpts...) - } - - i, err := m.Int64ObservableUpDownCounter( - "otel.sdk.exporter.log.inflight", - opt..., - ) - if err != nil { - return SDKExporterLogInflightObservable{noop.Int64ObservableUpDownCounter{}}, err - } - return SDKExporterLogInflightObservable{i}, nil -} - -// Inst returns the underlying metric instrument. -func (m SDKExporterLogInflightObservable) Inst() metric.Int64ObservableUpDownCounter { - return m.Int64ObservableUpDownCounter -} - -// Name returns the semantic convention name of the instrument. -func (SDKExporterLogInflightObservable) Name() string { - return "otel.sdk.exporter.log.inflight" -} - -// Unit returns the semantic convention unit of the instrument -func (SDKExporterLogInflightObservable) Unit() string { - return "{log_record}" -} - -// Description returns the semantic convention description of the instrument -func (SDKExporterLogInflightObservable) Description() string { - return "The number of log records which were passed to the exporter, but that have not been exported yet (neither successful, nor failed)." -} - -// AttrComponentName returns an optional attribute for the "otel.component.name" -// semantic convention. It represents a name uniquely identifying the instance of -// the OpenTelemetry component within its containing SDK instance. -func (SDKExporterLogInflightObservable) AttrComponentName(val string) attribute.KeyValue { - return attribute.String("otel.component.name", val) -} - -// AttrComponentType returns an optional attribute for the "otel.component.type" -// semantic convention. It represents a name identifying the type of the -// OpenTelemetry component. -func (SDKExporterLogInflightObservable) AttrComponentType(val ComponentTypeAttr) attribute.KeyValue { - return attribute.String("otel.component.type", string(val)) -} - -// AttrServerAddress returns an optional attribute for the "server.address" -// semantic convention. It represents the server domain name if available without -// reverse DNS lookup; otherwise, IP address or Unix domain socket name. -func (SDKExporterLogInflightObservable) AttrServerAddress(val string) attribute.KeyValue { - return attribute.String("server.address", val) -} - -// AttrServerPort returns an optional attribute for the "server.port" semantic -// convention. It represents the server port number. -func (SDKExporterLogInflightObservable) AttrServerPort(val int) attribute.KeyValue { - return attribute.Int("server.port", val) -} - -// SDKExporterMetricDataPointExported is an instrument used to record metric -// values conforming to the "otel.sdk.exporter.metric_data_point.exported" -// semantic conventions. It represents the number of metric data points for which -// the export has finished, either successful or failed. -type SDKExporterMetricDataPointExported struct { - metric.Int64Counter -} - -var newSDKExporterMetricDataPointExportedOpts = []metric.Int64CounterOption{ - metric.WithDescription("The number of metric data points for which the export has finished, either successful or failed."), - metric.WithUnit("{data_point}"), -} - -// NewSDKExporterMetricDataPointExported returns a new -// SDKExporterMetricDataPointExported instrument. -func NewSDKExporterMetricDataPointExported( - m metric.Meter, - opt ...metric.Int64CounterOption, -) (SDKExporterMetricDataPointExported, error) { - // Check if the meter is nil. - if m == nil { - return SDKExporterMetricDataPointExported{noop.Int64Counter{}}, nil - } - - if len(opt) == 0 { - opt = newSDKExporterMetricDataPointExportedOpts - } else { - opt = append(opt, newSDKExporterMetricDataPointExportedOpts...) - } - - i, err := m.Int64Counter( - "otel.sdk.exporter.metric_data_point.exported", - opt..., - ) - if err != nil { - return SDKExporterMetricDataPointExported{noop.Int64Counter{}}, err - } - return SDKExporterMetricDataPointExported{i}, nil -} - -// Inst returns the underlying metric instrument. -func (m SDKExporterMetricDataPointExported) Inst() metric.Int64Counter { - return m.Int64Counter -} - -// Name returns the semantic convention name of the instrument. -func (SDKExporterMetricDataPointExported) Name() string { - return "otel.sdk.exporter.metric_data_point.exported" -} - -// Unit returns the semantic convention unit of the instrument -func (SDKExporterMetricDataPointExported) Unit() string { - return "{data_point}" -} - -// Description returns the semantic convention description of the instrument -func (SDKExporterMetricDataPointExported) Description() string { - return "The number of metric data points for which the export has finished, either successful or failed." -} - -// Add adds incr to the existing count for attrs. -// -// All additional attrs passed are included in the recorded value. -// -// For successful exports, `error.type` MUST NOT be set. For failed exports, -// `error.type` MUST contain the failure cause. -// For exporters with partial success semantics (e.g. OTLP with -// `rejected_data_points`), rejected data points MUST count as failed and only -// non-rejected data points count as success. -// If no rejection reason is available, `rejected` SHOULD be used as value for -// `error.type`. -func (m SDKExporterMetricDataPointExported) Add( - ctx context.Context, - incr int64, - attrs ...attribute.KeyValue, -) { - if !m.Int64Counter.Enabled(ctx) { - return - } - if len(attrs) == 0 { - m.Int64Counter.Add(ctx, incr) - return - } - - o := metricpool.AddOptions() - defer metricpool.PutAddOptions(o) - - *o = append( - *o, - metric.WithAttributes( - attrs..., - ), - ) - - m.Int64Counter.Add(ctx, incr, *o...) -} - -// AddSet adds incr to the existing count for set. -// -// For successful exports, `error.type` MUST NOT be set. For failed exports, -// `error.type` MUST contain the failure cause. -// For exporters with partial success semantics (e.g. OTLP with -// `rejected_data_points`), rejected data points MUST count as failed and only -// non-rejected data points count as success. -// If no rejection reason is available, `rejected` SHOULD be used as value for -// `error.type`. -func (m SDKExporterMetricDataPointExported) AddSet(ctx context.Context, incr int64, set attribute.Set) { - if !m.Int64Counter.Enabled(ctx) { - return - } - if set.Len() == 0 { - m.Int64Counter.Add(ctx, incr) - return - } - - o := metricpool.AddOptions() - defer metricpool.PutAddOptions(o) - - *o = append(*o, metric.WithAttributeSet(set)) - m.Int64Counter.Add(ctx, incr, *o...) -} - -// AttrErrorType returns an optional attribute for the "error.type" semantic -// convention. It represents the describes a class of error the operation ended -// with. -func (SDKExporterMetricDataPointExported) AttrErrorType(val ErrorTypeAttr) attribute.KeyValue { - return attribute.String("error.type", string(val)) -} - -// AttrComponentName returns an optional attribute for the "otel.component.name" -// semantic convention. It represents a name uniquely identifying the instance of -// the OpenTelemetry component within its containing SDK instance. -func (SDKExporterMetricDataPointExported) AttrComponentName(val string) attribute.KeyValue { - return attribute.String("otel.component.name", val) -} - -// AttrComponentType returns an optional attribute for the "otel.component.type" -// semantic convention. It represents a name identifying the type of the -// OpenTelemetry component. -func (SDKExporterMetricDataPointExported) AttrComponentType(val ComponentTypeAttr) attribute.KeyValue { - return attribute.String("otel.component.type", string(val)) -} - -// AttrServerAddress returns an optional attribute for the "server.address" -// semantic convention. It represents the server domain name if available without -// reverse DNS lookup; otherwise, IP address or Unix domain socket name. -func (SDKExporterMetricDataPointExported) AttrServerAddress(val string) attribute.KeyValue { - return attribute.String("server.address", val) -} - -// AttrServerPort returns an optional attribute for the "server.port" semantic -// convention. It represents the server port number. -func (SDKExporterMetricDataPointExported) AttrServerPort(val int) attribute.KeyValue { - return attribute.Int("server.port", val) -} - -// SDKExporterMetricDataPointExportedObservable is an instrument used to record -// metric values conforming to the "otel.sdk.exporter.metric_data_point.exported" -// semantic conventions. It represents the number of metric data points for which -// the export has finished, either successful or failed. -type SDKExporterMetricDataPointExportedObservable struct { - metric.Int64ObservableCounter -} - -var newSDKExporterMetricDataPointExportedObservableOpts = []metric.Int64ObservableCounterOption{ - metric.WithDescription("The number of metric data points for which the export has finished, either successful or failed."), - metric.WithUnit("{data_point}"), -} - -// NewSDKExporterMetricDataPointExportedObservable returns a new -// SDKExporterMetricDataPointExportedObservable instrument. -func NewSDKExporterMetricDataPointExportedObservable( - m metric.Meter, - opt ...metric.Int64ObservableCounterOption, -) (SDKExporterMetricDataPointExportedObservable, error) { - // Check if the meter is nil. - if m == nil { - return SDKExporterMetricDataPointExportedObservable{noop.Int64ObservableCounter{}}, nil - } - - if len(opt) == 0 { - opt = newSDKExporterMetricDataPointExportedObservableOpts - } else { - opt = append(opt, newSDKExporterMetricDataPointExportedObservableOpts...) - } - - i, err := m.Int64ObservableCounter( - "otel.sdk.exporter.metric_data_point.exported", - opt..., - ) - if err != nil { - return SDKExporterMetricDataPointExportedObservable{noop.Int64ObservableCounter{}}, err - } - return SDKExporterMetricDataPointExportedObservable{i}, nil -} - -// Inst returns the underlying metric instrument. -func (m SDKExporterMetricDataPointExportedObservable) Inst() metric.Int64ObservableCounter { - return m.Int64ObservableCounter -} - -// Name returns the semantic convention name of the instrument. -func (SDKExporterMetricDataPointExportedObservable) Name() string { - return "otel.sdk.exporter.metric_data_point.exported" -} - -// Unit returns the semantic convention unit of the instrument -func (SDKExporterMetricDataPointExportedObservable) Unit() string { - return "{data_point}" -} - -// Description returns the semantic convention description of the instrument -func (SDKExporterMetricDataPointExportedObservable) Description() string { - return "The number of metric data points for which the export has finished, either successful or failed." -} - -// AttrErrorType returns an optional attribute for the "error.type" semantic -// convention. It represents the describes a class of error the operation ended -// with. -func (SDKExporterMetricDataPointExportedObservable) AttrErrorType(val ErrorTypeAttr) attribute.KeyValue { - return attribute.String("error.type", string(val)) -} - -// AttrComponentName returns an optional attribute for the "otel.component.name" -// semantic convention. It represents a name uniquely identifying the instance of -// the OpenTelemetry component within its containing SDK instance. -func (SDKExporterMetricDataPointExportedObservable) AttrComponentName(val string) attribute.KeyValue { - return attribute.String("otel.component.name", val) -} - -// AttrComponentType returns an optional attribute for the "otel.component.type" -// semantic convention. It represents a name identifying the type of the -// OpenTelemetry component. -func (SDKExporterMetricDataPointExportedObservable) AttrComponentType(val ComponentTypeAttr) attribute.KeyValue { - return attribute.String("otel.component.type", string(val)) -} - -// AttrServerAddress returns an optional attribute for the "server.address" -// semantic convention. It represents the server domain name if available without -// reverse DNS lookup; otherwise, IP address or Unix domain socket name. -func (SDKExporterMetricDataPointExportedObservable) AttrServerAddress(val string) attribute.KeyValue { - return attribute.String("server.address", val) -} - -// AttrServerPort returns an optional attribute for the "server.port" semantic -// convention. It represents the server port number. -func (SDKExporterMetricDataPointExportedObservable) AttrServerPort(val int) attribute.KeyValue { - return attribute.Int("server.port", val) -} - -// SDKExporterMetricDataPointInflight is an instrument used to record metric -// values conforming to the "otel.sdk.exporter.metric_data_point.inflight" -// semantic conventions. It represents the number of metric data points which -// were passed to the exporter, but that have not been exported yet (neither -// successful, nor failed). -type SDKExporterMetricDataPointInflight struct { - metric.Int64UpDownCounter -} - -var newSDKExporterMetricDataPointInflightOpts = []metric.Int64UpDownCounterOption{ - metric.WithDescription("The number of metric data points which were passed to the exporter, but that have not been exported yet (neither successful, nor failed)."), - metric.WithUnit("{data_point}"), -} - -// NewSDKExporterMetricDataPointInflight returns a new -// SDKExporterMetricDataPointInflight instrument. -func NewSDKExporterMetricDataPointInflight( - m metric.Meter, - opt ...metric.Int64UpDownCounterOption, -) (SDKExporterMetricDataPointInflight, error) { - // Check if the meter is nil. - if m == nil { - return SDKExporterMetricDataPointInflight{noop.Int64UpDownCounter{}}, nil - } - - if len(opt) == 0 { - opt = newSDKExporterMetricDataPointInflightOpts - } else { - opt = append(opt, newSDKExporterMetricDataPointInflightOpts...) - } - - i, err := m.Int64UpDownCounter( - "otel.sdk.exporter.metric_data_point.inflight", - opt..., - ) - if err != nil { - return SDKExporterMetricDataPointInflight{noop.Int64UpDownCounter{}}, err - } - return SDKExporterMetricDataPointInflight{i}, nil -} - -// Inst returns the underlying metric instrument. -func (m SDKExporterMetricDataPointInflight) Inst() metric.Int64UpDownCounter { - return m.Int64UpDownCounter -} - -// Name returns the semantic convention name of the instrument. -func (SDKExporterMetricDataPointInflight) Name() string { - return "otel.sdk.exporter.metric_data_point.inflight" -} - -// Unit returns the semantic convention unit of the instrument -func (SDKExporterMetricDataPointInflight) Unit() string { - return "{data_point}" -} - -// Description returns the semantic convention description of the instrument -func (SDKExporterMetricDataPointInflight) Description() string { - return "The number of metric data points which were passed to the exporter, but that have not been exported yet (neither successful, nor failed)." -} - -// Add adds incr to the existing count for attrs. -// -// All additional attrs passed are included in the recorded value. -// -// For successful exports, `error.type` MUST NOT be set. For failed exports, -// `error.type` MUST contain the failure cause. -func (m SDKExporterMetricDataPointInflight) Add( - ctx context.Context, - incr int64, - attrs ...attribute.KeyValue, -) { - if !m.Int64UpDownCounter.Enabled(ctx) { - return - } - if len(attrs) == 0 { - m.Int64UpDownCounter.Add(ctx, incr) - return - } - - o := metricpool.AddOptions() - defer metricpool.PutAddOptions(o) - - *o = append( - *o, - metric.WithAttributes( - attrs..., - ), - ) - - m.Int64UpDownCounter.Add(ctx, incr, *o...) -} - -// AddSet adds incr to the existing count for set. -// -// For successful exports, `error.type` MUST NOT be set. For failed exports, -// `error.type` MUST contain the failure cause. -func (m SDKExporterMetricDataPointInflight) AddSet(ctx context.Context, incr int64, set attribute.Set) { - if !m.Int64UpDownCounter.Enabled(ctx) { - return - } - if set.Len() == 0 { - m.Int64UpDownCounter.Add(ctx, incr) - return - } - - o := metricpool.AddOptions() - defer metricpool.PutAddOptions(o) - - *o = append(*o, metric.WithAttributeSet(set)) - m.Int64UpDownCounter.Add(ctx, incr, *o...) -} - -// AttrComponentName returns an optional attribute for the "otel.component.name" -// semantic convention. It represents a name uniquely identifying the instance of -// the OpenTelemetry component within its containing SDK instance. -func (SDKExporterMetricDataPointInflight) AttrComponentName(val string) attribute.KeyValue { - return attribute.String("otel.component.name", val) -} - -// AttrComponentType returns an optional attribute for the "otel.component.type" -// semantic convention. It represents a name identifying the type of the -// OpenTelemetry component. -func (SDKExporterMetricDataPointInflight) AttrComponentType(val ComponentTypeAttr) attribute.KeyValue { - return attribute.String("otel.component.type", string(val)) -} - -// AttrServerAddress returns an optional attribute for the "server.address" -// semantic convention. It represents the server domain name if available without -// reverse DNS lookup; otherwise, IP address or Unix domain socket name. -func (SDKExporterMetricDataPointInflight) AttrServerAddress(val string) attribute.KeyValue { - return attribute.String("server.address", val) -} - -// AttrServerPort returns an optional attribute for the "server.port" semantic -// convention. It represents the server port number. -func (SDKExporterMetricDataPointInflight) AttrServerPort(val int) attribute.KeyValue { - return attribute.Int("server.port", val) -} - -// SDKExporterMetricDataPointInflightObservable is an instrument used to record -// metric values conforming to the "otel.sdk.exporter.metric_data_point.inflight" -// semantic conventions. It represents the number of metric data points which -// were passed to the exporter, but that have not been exported yet (neither -// successful, nor failed). -type SDKExporterMetricDataPointInflightObservable struct { - metric.Int64ObservableUpDownCounter -} - -var newSDKExporterMetricDataPointInflightObservableOpts = []metric.Int64ObservableUpDownCounterOption{ - metric.WithDescription("The number of metric data points which were passed to the exporter, but that have not been exported yet (neither successful, nor failed)."), - metric.WithUnit("{data_point}"), -} - -// NewSDKExporterMetricDataPointInflightObservable returns a new -// SDKExporterMetricDataPointInflightObservable instrument. -func NewSDKExporterMetricDataPointInflightObservable( - m metric.Meter, - opt ...metric.Int64ObservableUpDownCounterOption, -) (SDKExporterMetricDataPointInflightObservable, error) { - // Check if the meter is nil. - if m == nil { - return SDKExporterMetricDataPointInflightObservable{noop.Int64ObservableUpDownCounter{}}, nil - } - - if len(opt) == 0 { - opt = newSDKExporterMetricDataPointInflightObservableOpts - } else { - opt = append(opt, newSDKExporterMetricDataPointInflightObservableOpts...) - } - - i, err := m.Int64ObservableUpDownCounter( - "otel.sdk.exporter.metric_data_point.inflight", - opt..., - ) - if err != nil { - return SDKExporterMetricDataPointInflightObservable{noop.Int64ObservableUpDownCounter{}}, err - } - return SDKExporterMetricDataPointInflightObservable{i}, nil -} - -// Inst returns the underlying metric instrument. -func (m SDKExporterMetricDataPointInflightObservable) Inst() metric.Int64ObservableUpDownCounter { - return m.Int64ObservableUpDownCounter -} - -// Name returns the semantic convention name of the instrument. -func (SDKExporterMetricDataPointInflightObservable) Name() string { - return "otel.sdk.exporter.metric_data_point.inflight" -} - -// Unit returns the semantic convention unit of the instrument -func (SDKExporterMetricDataPointInflightObservable) Unit() string { - return "{data_point}" -} - -// Description returns the semantic convention description of the instrument -func (SDKExporterMetricDataPointInflightObservable) Description() string { - return "The number of metric data points which were passed to the exporter, but that have not been exported yet (neither successful, nor failed)." -} - -// AttrComponentName returns an optional attribute for the "otel.component.name" -// semantic convention. It represents a name uniquely identifying the instance of -// the OpenTelemetry component within its containing SDK instance. -func (SDKExporterMetricDataPointInflightObservable) AttrComponentName(val string) attribute.KeyValue { - return attribute.String("otel.component.name", val) -} - -// AttrComponentType returns an optional attribute for the "otel.component.type" -// semantic convention. It represents a name identifying the type of the -// OpenTelemetry component. -func (SDKExporterMetricDataPointInflightObservable) AttrComponentType(val ComponentTypeAttr) attribute.KeyValue { - return attribute.String("otel.component.type", string(val)) -} - -// AttrServerAddress returns an optional attribute for the "server.address" -// semantic convention. It represents the server domain name if available without -// reverse DNS lookup; otherwise, IP address or Unix domain socket name. -func (SDKExporterMetricDataPointInflightObservable) AttrServerAddress(val string) attribute.KeyValue { - return attribute.String("server.address", val) -} - -// AttrServerPort returns an optional attribute for the "server.port" semantic -// convention. It represents the server port number. -func (SDKExporterMetricDataPointInflightObservable) AttrServerPort(val int) attribute.KeyValue { - return attribute.Int("server.port", val) -} - -// SDKExporterOperationDuration is an instrument used to record metric values -// conforming to the "otel.sdk.exporter.operation.duration" semantic conventions. -// It represents the duration of exporting a batch of telemetry records. -type SDKExporterOperationDuration struct { - metric.Float64Histogram -} - -var newSDKExporterOperationDurationOpts = []metric.Float64HistogramOption{ - metric.WithDescription("The duration of exporting a batch of telemetry records."), - metric.WithUnit("s"), -} - -// NewSDKExporterOperationDuration returns a new SDKExporterOperationDuration -// instrument. -func NewSDKExporterOperationDuration( - m metric.Meter, - opt ...metric.Float64HistogramOption, -) (SDKExporterOperationDuration, error) { - // Check if the meter is nil. - if m == nil { - return SDKExporterOperationDuration{noop.Float64Histogram{}}, nil - } - - if len(opt) == 0 { - opt = newSDKExporterOperationDurationOpts - } else { - opt = append(opt, newSDKExporterOperationDurationOpts...) - } - - i, err := m.Float64Histogram( - "otel.sdk.exporter.operation.duration", - opt..., - ) - if err != nil { - return SDKExporterOperationDuration{noop.Float64Histogram{}}, err - } - return SDKExporterOperationDuration{i}, nil -} - -// Inst returns the underlying metric instrument. -func (m SDKExporterOperationDuration) Inst() metric.Float64Histogram { - return m.Float64Histogram -} - -// Name returns the semantic convention name of the instrument. -func (SDKExporterOperationDuration) Name() string { - return "otel.sdk.exporter.operation.duration" -} - -// Unit returns the semantic convention unit of the instrument -func (SDKExporterOperationDuration) Unit() string { - return "s" -} - -// Description returns the semantic convention description of the instrument -func (SDKExporterOperationDuration) Description() string { - return "The duration of exporting a batch of telemetry records." -} - -// Record records val to the current distribution for attrs. -// -// All additional attrs passed are included in the recorded value. -// -// This metric defines successful operations using the full success definitions -// for [http] -// and [grpc]. Anything else is defined as an unsuccessful operation. For -// successful -// operations, `error.type` MUST NOT be set. For unsuccessful export operations, -// `error.type` MUST contain a relevant failure cause. -// -// [http]: https://github.com/open-telemetry/opentelemetry-proto/blob/v1.5.0/docs/specification.md#full-success-1 -// [grpc]: https://github.com/open-telemetry/opentelemetry-proto/blob/v1.5.0/docs/specification.md#full-success -func (m SDKExporterOperationDuration) Record( - ctx context.Context, - val float64, - attrs ...attribute.KeyValue, -) { - if !m.Float64Histogram.Enabled(ctx) { - return - } - if len(attrs) == 0 { - m.Float64Histogram.Record(ctx, val) - return - } - - o := metricpool.RecordOptions() - defer metricpool.PutRecordOptions(o) - - *o = append( - *o, - metric.WithAttributes( - attrs..., - ), - ) - - m.Float64Histogram.Record(ctx, val, *o...) -} - -// RecordSet records val to the current distribution for set. -// -// This metric defines successful operations using the full success definitions -// for [http] -// and [grpc]. Anything else is defined as an unsuccessful operation. For -// successful -// operations, `error.type` MUST NOT be set. For unsuccessful export operations, -// `error.type` MUST contain a relevant failure cause. -// -// [http]: https://github.com/open-telemetry/opentelemetry-proto/blob/v1.5.0/docs/specification.md#full-success-1 -// [grpc]: https://github.com/open-telemetry/opentelemetry-proto/blob/v1.5.0/docs/specification.md#full-success -func (m SDKExporterOperationDuration) RecordSet(ctx context.Context, val float64, set attribute.Set) { - if !m.Float64Histogram.Enabled(ctx) { - return - } - if set.Len() == 0 { - m.Float64Histogram.Record(ctx, val) - return - } - - o := metricpool.RecordOptions() - defer metricpool.PutRecordOptions(o) - - *o = append(*o, metric.WithAttributeSet(set)) - m.Float64Histogram.Record(ctx, val, *o...) -} - -// AttrErrorType returns an optional attribute for the "error.type" semantic -// convention. It represents the describes a class of error the operation ended -// with. -func (SDKExporterOperationDuration) AttrErrorType(val ErrorTypeAttr) attribute.KeyValue { - return attribute.String("error.type", string(val)) -} - -// AttrHTTPResponseStatusCode returns an optional attribute for the -// "http.response.status_code" semantic convention. It represents the HTTP status -// code of the last HTTP request performed in scope of this export call. -func (SDKExporterOperationDuration) AttrHTTPResponseStatusCode(val int) attribute.KeyValue { - return attribute.Int("http.response.status_code", val) -} - -// AttrComponentName returns an optional attribute for the "otel.component.name" -// semantic convention. It represents a name uniquely identifying the instance of -// the OpenTelemetry component within its containing SDK instance. -func (SDKExporterOperationDuration) AttrComponentName(val string) attribute.KeyValue { - return attribute.String("otel.component.name", val) -} - -// AttrComponentType returns an optional attribute for the "otel.component.type" -// semantic convention. It represents a name identifying the type of the -// OpenTelemetry component. -func (SDKExporterOperationDuration) AttrComponentType(val ComponentTypeAttr) attribute.KeyValue { - return attribute.String("otel.component.type", string(val)) -} - -// AttrRPCResponseStatusCode returns an optional attribute for the -// "rpc.response.status_code" semantic convention. It represents the gRPC status -// code of the last gRPC request performed in scope of this export call. -func (SDKExporterOperationDuration) AttrRPCResponseStatusCode(val string) attribute.KeyValue { - return attribute.String("rpc.response.status_code", val) -} - -// AttrServerAddress returns an optional attribute for the "server.address" -// semantic convention. It represents the server domain name if available without -// reverse DNS lookup; otherwise, IP address or Unix domain socket name. -func (SDKExporterOperationDuration) AttrServerAddress(val string) attribute.KeyValue { - return attribute.String("server.address", val) -} - -// AttrServerPort returns an optional attribute for the "server.port" semantic -// convention. It represents the server port number. -func (SDKExporterOperationDuration) AttrServerPort(val int) attribute.KeyValue { - return attribute.Int("server.port", val) -} - -// SDKExporterSpanExported is an instrument used to record metric values -// conforming to the "otel.sdk.exporter.span.exported" semantic conventions. It -// represents the number of spans for which the export has finished, either -// successful or failed. -type SDKExporterSpanExported struct { - metric.Int64Counter -} - -var newSDKExporterSpanExportedOpts = []metric.Int64CounterOption{ - metric.WithDescription("The number of spans for which the export has finished, either successful or failed."), - metric.WithUnit("{span}"), -} - -// NewSDKExporterSpanExported returns a new SDKExporterSpanExported instrument. -func NewSDKExporterSpanExported( - m metric.Meter, - opt ...metric.Int64CounterOption, -) (SDKExporterSpanExported, error) { - // Check if the meter is nil. - if m == nil { - return SDKExporterSpanExported{noop.Int64Counter{}}, nil - } - - if len(opt) == 0 { - opt = newSDKExporterSpanExportedOpts - } else { - opt = append(opt, newSDKExporterSpanExportedOpts...) - } - - i, err := m.Int64Counter( - "otel.sdk.exporter.span.exported", - opt..., - ) - if err != nil { - return SDKExporterSpanExported{noop.Int64Counter{}}, err - } - return SDKExporterSpanExported{i}, nil -} - -// Inst returns the underlying metric instrument. -func (m SDKExporterSpanExported) Inst() metric.Int64Counter { - return m.Int64Counter -} - -// Name returns the semantic convention name of the instrument. -func (SDKExporterSpanExported) Name() string { - return "otel.sdk.exporter.span.exported" -} - -// Unit returns the semantic convention unit of the instrument -func (SDKExporterSpanExported) Unit() string { - return "{span}" -} - -// Description returns the semantic convention description of the instrument -func (SDKExporterSpanExported) Description() string { - return "The number of spans for which the export has finished, either successful or failed." -} - -// Add adds incr to the existing count for attrs. -// -// All additional attrs passed are included in the recorded value. -// -// For successful exports, `error.type` MUST NOT be set. For failed exports, -// `error.type` MUST contain the failure cause. -// For exporters with partial success semantics (e.g. OTLP with `rejected_spans` -// ), rejected spans MUST count as failed and only non-rejected spans count as -// success. -// If no rejection reason is available, `rejected` SHOULD be used as value for -// `error.type`. -func (m SDKExporterSpanExported) Add( - ctx context.Context, - incr int64, - attrs ...attribute.KeyValue, -) { - if !m.Int64Counter.Enabled(ctx) { - return - } - if len(attrs) == 0 { - m.Int64Counter.Add(ctx, incr) - return - } - - o := metricpool.AddOptions() - defer metricpool.PutAddOptions(o) - - *o = append( - *o, - metric.WithAttributes( - attrs..., - ), - ) - - m.Int64Counter.Add(ctx, incr, *o...) -} - -// AddSet adds incr to the existing count for set. -// -// For successful exports, `error.type` MUST NOT be set. For failed exports, -// `error.type` MUST contain the failure cause. -// For exporters with partial success semantics (e.g. OTLP with `rejected_spans` -// ), rejected spans MUST count as failed and only non-rejected spans count as -// success. -// If no rejection reason is available, `rejected` SHOULD be used as value for -// `error.type`. -func (m SDKExporterSpanExported) AddSet(ctx context.Context, incr int64, set attribute.Set) { - if !m.Int64Counter.Enabled(ctx) { - return - } - if set.Len() == 0 { - m.Int64Counter.Add(ctx, incr) - return - } - - o := metricpool.AddOptions() - defer metricpool.PutAddOptions(o) - - *o = append(*o, metric.WithAttributeSet(set)) - m.Int64Counter.Add(ctx, incr, *o...) -} - -// AttrErrorType returns an optional attribute for the "error.type" semantic -// convention. It represents the describes a class of error the operation ended -// with. -func (SDKExporterSpanExported) AttrErrorType(val ErrorTypeAttr) attribute.KeyValue { - return attribute.String("error.type", string(val)) -} - -// AttrComponentName returns an optional attribute for the "otel.component.name" -// semantic convention. It represents a name uniquely identifying the instance of -// the OpenTelemetry component within its containing SDK instance. -func (SDKExporterSpanExported) AttrComponentName(val string) attribute.KeyValue { - return attribute.String("otel.component.name", val) -} - -// AttrComponentType returns an optional attribute for the "otel.component.type" -// semantic convention. It represents a name identifying the type of the -// OpenTelemetry component. -func (SDKExporterSpanExported) AttrComponentType(val ComponentTypeAttr) attribute.KeyValue { - return attribute.String("otel.component.type", string(val)) -} - -// AttrServerAddress returns an optional attribute for the "server.address" -// semantic convention. It represents the server domain name if available without -// reverse DNS lookup; otherwise, IP address or Unix domain socket name. -func (SDKExporterSpanExported) AttrServerAddress(val string) attribute.KeyValue { - return attribute.String("server.address", val) -} - -// AttrServerPort returns an optional attribute for the "server.port" semantic -// convention. It represents the server port number. -func (SDKExporterSpanExported) AttrServerPort(val int) attribute.KeyValue { - return attribute.Int("server.port", val) -} - -// SDKExporterSpanExportedObservable is an instrument used to record metric -// values conforming to the "otel.sdk.exporter.span.exported" semantic -// conventions. It represents the number of spans for which the export has -// finished, either successful or failed. -type SDKExporterSpanExportedObservable struct { - metric.Int64ObservableCounter -} - -var newSDKExporterSpanExportedObservableOpts = []metric.Int64ObservableCounterOption{ - metric.WithDescription("The number of spans for which the export has finished, either successful or failed."), - metric.WithUnit("{span}"), -} - -// NewSDKExporterSpanExportedObservable returns a new -// SDKExporterSpanExportedObservable instrument. -func NewSDKExporterSpanExportedObservable( - m metric.Meter, - opt ...metric.Int64ObservableCounterOption, -) (SDKExporterSpanExportedObservable, error) { - // Check if the meter is nil. - if m == nil { - return SDKExporterSpanExportedObservable{noop.Int64ObservableCounter{}}, nil - } - - if len(opt) == 0 { - opt = newSDKExporterSpanExportedObservableOpts - } else { - opt = append(opt, newSDKExporterSpanExportedObservableOpts...) - } - - i, err := m.Int64ObservableCounter( - "otel.sdk.exporter.span.exported", - opt..., - ) - if err != nil { - return SDKExporterSpanExportedObservable{noop.Int64ObservableCounter{}}, err - } - return SDKExporterSpanExportedObservable{i}, nil -} - -// Inst returns the underlying metric instrument. -func (m SDKExporterSpanExportedObservable) Inst() metric.Int64ObservableCounter { - return m.Int64ObservableCounter -} - -// Name returns the semantic convention name of the instrument. -func (SDKExporterSpanExportedObservable) Name() string { - return "otel.sdk.exporter.span.exported" -} - -// Unit returns the semantic convention unit of the instrument -func (SDKExporterSpanExportedObservable) Unit() string { - return "{span}" -} - -// Description returns the semantic convention description of the instrument -func (SDKExporterSpanExportedObservable) Description() string { - return "The number of spans for which the export has finished, either successful or failed." -} - -// AttrErrorType returns an optional attribute for the "error.type" semantic -// convention. It represents the describes a class of error the operation ended -// with. -func (SDKExporterSpanExportedObservable) AttrErrorType(val ErrorTypeAttr) attribute.KeyValue { - return attribute.String("error.type", string(val)) -} - -// AttrComponentName returns an optional attribute for the "otel.component.name" -// semantic convention. It represents a name uniquely identifying the instance of -// the OpenTelemetry component within its containing SDK instance. -func (SDKExporterSpanExportedObservable) AttrComponentName(val string) attribute.KeyValue { - return attribute.String("otel.component.name", val) -} - -// AttrComponentType returns an optional attribute for the "otel.component.type" -// semantic convention. It represents a name identifying the type of the -// OpenTelemetry component. -func (SDKExporterSpanExportedObservable) AttrComponentType(val ComponentTypeAttr) attribute.KeyValue { - return attribute.String("otel.component.type", string(val)) -} - -// AttrServerAddress returns an optional attribute for the "server.address" -// semantic convention. It represents the server domain name if available without -// reverse DNS lookup; otherwise, IP address or Unix domain socket name. -func (SDKExporterSpanExportedObservable) AttrServerAddress(val string) attribute.KeyValue { - return attribute.String("server.address", val) -} - -// AttrServerPort returns an optional attribute for the "server.port" semantic -// convention. It represents the server port number. -func (SDKExporterSpanExportedObservable) AttrServerPort(val int) attribute.KeyValue { - return attribute.Int("server.port", val) -} - -// SDKExporterSpanInflight is an instrument used to record metric values -// conforming to the "otel.sdk.exporter.span.inflight" semantic conventions. It -// represents the number of spans which were passed to the exporter, but that -// have not been exported yet (neither successful, nor failed). -type SDKExporterSpanInflight struct { - metric.Int64UpDownCounter -} - -var newSDKExporterSpanInflightOpts = []metric.Int64UpDownCounterOption{ - metric.WithDescription("The number of spans which were passed to the exporter, but that have not been exported yet (neither successful, nor failed)."), - metric.WithUnit("{span}"), -} - -// NewSDKExporterSpanInflight returns a new SDKExporterSpanInflight instrument. -func NewSDKExporterSpanInflight( - m metric.Meter, - opt ...metric.Int64UpDownCounterOption, -) (SDKExporterSpanInflight, error) { - // Check if the meter is nil. - if m == nil { - return SDKExporterSpanInflight{noop.Int64UpDownCounter{}}, nil - } - - if len(opt) == 0 { - opt = newSDKExporterSpanInflightOpts - } else { - opt = append(opt, newSDKExporterSpanInflightOpts...) - } - - i, err := m.Int64UpDownCounter( - "otel.sdk.exporter.span.inflight", - opt..., - ) - if err != nil { - return SDKExporterSpanInflight{noop.Int64UpDownCounter{}}, err - } - return SDKExporterSpanInflight{i}, nil -} - -// Inst returns the underlying metric instrument. -func (m SDKExporterSpanInflight) Inst() metric.Int64UpDownCounter { - return m.Int64UpDownCounter -} - -// Name returns the semantic convention name of the instrument. -func (SDKExporterSpanInflight) Name() string { - return "otel.sdk.exporter.span.inflight" -} - -// Unit returns the semantic convention unit of the instrument -func (SDKExporterSpanInflight) Unit() string { - return "{span}" -} - -// Description returns the semantic convention description of the instrument -func (SDKExporterSpanInflight) Description() string { - return "The number of spans which were passed to the exporter, but that have not been exported yet (neither successful, nor failed)." -} - -// Add adds incr to the existing count for attrs. -// -// All additional attrs passed are included in the recorded value. -// -// For successful exports, `error.type` MUST NOT be set. For failed exports, -// `error.type` MUST contain the failure cause. -func (m SDKExporterSpanInflight) Add( - ctx context.Context, - incr int64, - attrs ...attribute.KeyValue, -) { - if !m.Int64UpDownCounter.Enabled(ctx) { - return - } - if len(attrs) == 0 { - m.Int64UpDownCounter.Add(ctx, incr) - return - } - - o := metricpool.AddOptions() - defer metricpool.PutAddOptions(o) - - *o = append( - *o, - metric.WithAttributes( - attrs..., - ), - ) - - m.Int64UpDownCounter.Add(ctx, incr, *o...) -} - -// AddSet adds incr to the existing count for set. -// -// For successful exports, `error.type` MUST NOT be set. For failed exports, -// `error.type` MUST contain the failure cause. -func (m SDKExporterSpanInflight) AddSet(ctx context.Context, incr int64, set attribute.Set) { - if !m.Int64UpDownCounter.Enabled(ctx) { - return - } - if set.Len() == 0 { - m.Int64UpDownCounter.Add(ctx, incr) - return - } - - o := metricpool.AddOptions() - defer metricpool.PutAddOptions(o) - - *o = append(*o, metric.WithAttributeSet(set)) - m.Int64UpDownCounter.Add(ctx, incr, *o...) -} - -// AttrComponentName returns an optional attribute for the "otel.component.name" -// semantic convention. It represents a name uniquely identifying the instance of -// the OpenTelemetry component within its containing SDK instance. -func (SDKExporterSpanInflight) AttrComponentName(val string) attribute.KeyValue { - return attribute.String("otel.component.name", val) -} - -// AttrComponentType returns an optional attribute for the "otel.component.type" -// semantic convention. It represents a name identifying the type of the -// OpenTelemetry component. -func (SDKExporterSpanInflight) AttrComponentType(val ComponentTypeAttr) attribute.KeyValue { - return attribute.String("otel.component.type", string(val)) -} - -// AttrServerAddress returns an optional attribute for the "server.address" -// semantic convention. It represents the server domain name if available without -// reverse DNS lookup; otherwise, IP address or Unix domain socket name. -func (SDKExporterSpanInflight) AttrServerAddress(val string) attribute.KeyValue { - return attribute.String("server.address", val) -} - -// AttrServerPort returns an optional attribute for the "server.port" semantic -// convention. It represents the server port number. -func (SDKExporterSpanInflight) AttrServerPort(val int) attribute.KeyValue { - return attribute.Int("server.port", val) -} - -// SDKExporterSpanInflightObservable is an instrument used to record metric -// values conforming to the "otel.sdk.exporter.span.inflight" semantic -// conventions. It represents the number of spans which were passed to the -// exporter, but that have not been exported yet (neither successful, nor -// failed). -type SDKExporterSpanInflightObservable struct { - metric.Int64ObservableUpDownCounter -} - -var newSDKExporterSpanInflightObservableOpts = []metric.Int64ObservableUpDownCounterOption{ - metric.WithDescription("The number of spans which were passed to the exporter, but that have not been exported yet (neither successful, nor failed)."), - metric.WithUnit("{span}"), -} - -// NewSDKExporterSpanInflightObservable returns a new -// SDKExporterSpanInflightObservable instrument. -func NewSDKExporterSpanInflightObservable( - m metric.Meter, - opt ...metric.Int64ObservableUpDownCounterOption, -) (SDKExporterSpanInflightObservable, error) { - // Check if the meter is nil. - if m == nil { - return SDKExporterSpanInflightObservable{noop.Int64ObservableUpDownCounter{}}, nil - } - - if len(opt) == 0 { - opt = newSDKExporterSpanInflightObservableOpts - } else { - opt = append(opt, newSDKExporterSpanInflightObservableOpts...) - } - - i, err := m.Int64ObservableUpDownCounter( - "otel.sdk.exporter.span.inflight", - opt..., - ) - if err != nil { - return SDKExporterSpanInflightObservable{noop.Int64ObservableUpDownCounter{}}, err - } - return SDKExporterSpanInflightObservable{i}, nil -} - -// Inst returns the underlying metric instrument. -func (m SDKExporterSpanInflightObservable) Inst() metric.Int64ObservableUpDownCounter { - return m.Int64ObservableUpDownCounter -} - -// Name returns the semantic convention name of the instrument. -func (SDKExporterSpanInflightObservable) Name() string { - return "otel.sdk.exporter.span.inflight" -} - -// Unit returns the semantic convention unit of the instrument -func (SDKExporterSpanInflightObservable) Unit() string { - return "{span}" -} - -// Description returns the semantic convention description of the instrument -func (SDKExporterSpanInflightObservable) Description() string { - return "The number of spans which were passed to the exporter, but that have not been exported yet (neither successful, nor failed)." -} - -// AttrComponentName returns an optional attribute for the "otel.component.name" -// semantic convention. It represents a name uniquely identifying the instance of -// the OpenTelemetry component within its containing SDK instance. -func (SDKExporterSpanInflightObservable) AttrComponentName(val string) attribute.KeyValue { - return attribute.String("otel.component.name", val) -} - -// AttrComponentType returns an optional attribute for the "otel.component.type" -// semantic convention. It represents a name identifying the type of the -// OpenTelemetry component. -func (SDKExporterSpanInflightObservable) AttrComponentType(val ComponentTypeAttr) attribute.KeyValue { - return attribute.String("otel.component.type", string(val)) -} - -// AttrServerAddress returns an optional attribute for the "server.address" -// semantic convention. It represents the server domain name if available without -// reverse DNS lookup; otherwise, IP address or Unix domain socket name. -func (SDKExporterSpanInflightObservable) AttrServerAddress(val string) attribute.KeyValue { - return attribute.String("server.address", val) -} - -// AttrServerPort returns an optional attribute for the "server.port" semantic -// convention. It represents the server port number. -func (SDKExporterSpanInflightObservable) AttrServerPort(val int) attribute.KeyValue { - return attribute.Int("server.port", val) -} - -// SDKLogCreated is an instrument used to record metric values conforming to the -// "otel.sdk.log.created" semantic conventions. It represents the number of logs -// submitted to enabled SDK Loggers. -type SDKLogCreated struct { - metric.Int64Counter -} - -var newSDKLogCreatedOpts = []metric.Int64CounterOption{ - metric.WithDescription("The number of logs submitted to enabled SDK Loggers."), - metric.WithUnit("{log_record}"), -} - -// NewSDKLogCreated returns a new SDKLogCreated instrument. -func NewSDKLogCreated( - m metric.Meter, - opt ...metric.Int64CounterOption, -) (SDKLogCreated, error) { - // Check if the meter is nil. - if m == nil { - return SDKLogCreated{noop.Int64Counter{}}, nil - } - - if len(opt) == 0 { - opt = newSDKLogCreatedOpts - } else { - opt = append(opt, newSDKLogCreatedOpts...) - } - - i, err := m.Int64Counter( - "otel.sdk.log.created", - opt..., - ) - if err != nil { - return SDKLogCreated{noop.Int64Counter{}}, err - } - return SDKLogCreated{i}, nil -} - -// Inst returns the underlying metric instrument. -func (m SDKLogCreated) Inst() metric.Int64Counter { - return m.Int64Counter -} - -// Name returns the semantic convention name of the instrument. -func (SDKLogCreated) Name() string { - return "otel.sdk.log.created" -} - -// Unit returns the semantic convention unit of the instrument -func (SDKLogCreated) Unit() string { - return "{log_record}" -} - -// Description returns the semantic convention description of the instrument -func (SDKLogCreated) Description() string { - return "The number of logs submitted to enabled SDK Loggers." -} - -// Add adds incr to the existing count for attrs. -func (m SDKLogCreated) Add(ctx context.Context, incr int64, attrs ...attribute.KeyValue) { - if !m.Int64Counter.Enabled(ctx) { - return - } - if len(attrs) == 0 { - m.Int64Counter.Add(ctx, incr) - return - } - - o := metricpool.AddOptions() - defer metricpool.PutAddOptions(o) - - *o = append(*o, metric.WithAttributes(attrs...)) - m.Int64Counter.Add(ctx, incr, *o...) -} - -// AddSet adds incr to the existing count for set. -func (m SDKLogCreated) AddSet(ctx context.Context, incr int64, set attribute.Set) { - if !m.Int64Counter.Enabled(ctx) { - return - } - if set.Len() == 0 { - m.Int64Counter.Add(ctx, incr) - return - } - - o := metricpool.AddOptions() - defer metricpool.PutAddOptions(o) - - *o = append(*o, metric.WithAttributeSet(set)) - m.Int64Counter.Add(ctx, incr, *o...) -} - -// SDKLogCreatedObservable is an instrument used to record metric values -// conforming to the "otel.sdk.log.created" semantic conventions. It represents -// the number of logs submitted to enabled SDK Loggers. -type SDKLogCreatedObservable struct { - metric.Int64ObservableCounter -} - -var newSDKLogCreatedObservableOpts = []metric.Int64ObservableCounterOption{ - metric.WithDescription("The number of logs submitted to enabled SDK Loggers."), - metric.WithUnit("{log_record}"), -} - -// NewSDKLogCreatedObservable returns a new SDKLogCreatedObservable instrument. -func NewSDKLogCreatedObservable( - m metric.Meter, - opt ...metric.Int64ObservableCounterOption, -) (SDKLogCreatedObservable, error) { - // Check if the meter is nil. - if m == nil { - return SDKLogCreatedObservable{noop.Int64ObservableCounter{}}, nil - } - - if len(opt) == 0 { - opt = newSDKLogCreatedObservableOpts - } else { - opt = append(opt, newSDKLogCreatedObservableOpts...) - } - - i, err := m.Int64ObservableCounter( - "otel.sdk.log.created", - opt..., - ) - if err != nil { - return SDKLogCreatedObservable{noop.Int64ObservableCounter{}}, err - } - return SDKLogCreatedObservable{i}, nil -} - -// Inst returns the underlying metric instrument. -func (m SDKLogCreatedObservable) Inst() metric.Int64ObservableCounter { - return m.Int64ObservableCounter -} - -// Name returns the semantic convention name of the instrument. -func (SDKLogCreatedObservable) Name() string { - return "otel.sdk.log.created" -} - -// Unit returns the semantic convention unit of the instrument -func (SDKLogCreatedObservable) Unit() string { - return "{log_record}" -} - -// Description returns the semantic convention description of the instrument -func (SDKLogCreatedObservable) Description() string { - return "The number of logs submitted to enabled SDK Loggers." -} - -// SDKMetricReaderCollectionDuration is an instrument used to record metric -// values conforming to the "otel.sdk.metric_reader.collection.duration" semantic -// conventions. It represents the duration of the collect operation of the metric -// reader. -type SDKMetricReaderCollectionDuration struct { - metric.Float64Histogram -} - -var newSDKMetricReaderCollectionDurationOpts = []metric.Float64HistogramOption{ - metric.WithDescription("The duration of the collect operation of the metric reader."), - metric.WithUnit("s"), -} - -// NewSDKMetricReaderCollectionDuration returns a new -// SDKMetricReaderCollectionDuration instrument. -func NewSDKMetricReaderCollectionDuration( - m metric.Meter, - opt ...metric.Float64HistogramOption, -) (SDKMetricReaderCollectionDuration, error) { - // Check if the meter is nil. - if m == nil { - return SDKMetricReaderCollectionDuration{noop.Float64Histogram{}}, nil - } - - if len(opt) == 0 { - opt = newSDKMetricReaderCollectionDurationOpts - } else { - opt = append(opt, newSDKMetricReaderCollectionDurationOpts...) - } - - i, err := m.Float64Histogram( - "otel.sdk.metric_reader.collection.duration", - opt..., - ) - if err != nil { - return SDKMetricReaderCollectionDuration{noop.Float64Histogram{}}, err - } - return SDKMetricReaderCollectionDuration{i}, nil -} - -// Inst returns the underlying metric instrument. -func (m SDKMetricReaderCollectionDuration) Inst() metric.Float64Histogram { - return m.Float64Histogram -} - -// Name returns the semantic convention name of the instrument. -func (SDKMetricReaderCollectionDuration) Name() string { - return "otel.sdk.metric_reader.collection.duration" -} - -// Unit returns the semantic convention unit of the instrument -func (SDKMetricReaderCollectionDuration) Unit() string { - return "s" -} - -// Description returns the semantic convention description of the instrument -func (SDKMetricReaderCollectionDuration) Description() string { - return "The duration of the collect operation of the metric reader." -} - -// Record records val to the current distribution for attrs. -// -// All additional attrs passed are included in the recorded value. -// -// For successful collections, `error.type` MUST NOT be set. For failed -// collections, `error.type` SHOULD contain the failure cause. -// It can happen that metrics collection is successful for some MetricProducers, -// while others fail. In that case `error.type` SHOULD be set to any of the -// failure causes. -func (m SDKMetricReaderCollectionDuration) Record( - ctx context.Context, - val float64, - attrs ...attribute.KeyValue, -) { - if !m.Float64Histogram.Enabled(ctx) { - return - } - if len(attrs) == 0 { - m.Float64Histogram.Record(ctx, val) - return - } - - o := metricpool.RecordOptions() - defer metricpool.PutRecordOptions(o) - - *o = append( - *o, - metric.WithAttributes( - attrs..., - ), - ) - - m.Float64Histogram.Record(ctx, val, *o...) -} - -// RecordSet records val to the current distribution for set. -// -// For successful collections, `error.type` MUST NOT be set. For failed -// collections, `error.type` SHOULD contain the failure cause. -// It can happen that metrics collection is successful for some MetricProducers, -// while others fail. In that case `error.type` SHOULD be set to any of the -// failure causes. -func (m SDKMetricReaderCollectionDuration) RecordSet(ctx context.Context, val float64, set attribute.Set) { - if !m.Float64Histogram.Enabled(ctx) { - return - } - if set.Len() == 0 { - m.Float64Histogram.Record(ctx, val) - return - } - - o := metricpool.RecordOptions() - defer metricpool.PutRecordOptions(o) - - *o = append(*o, metric.WithAttributeSet(set)) - m.Float64Histogram.Record(ctx, val, *o...) -} - -// AttrErrorType returns an optional attribute for the "error.type" semantic -// convention. It represents the describes a class of error the operation ended -// with. -func (SDKMetricReaderCollectionDuration) AttrErrorType(val ErrorTypeAttr) attribute.KeyValue { - return attribute.String("error.type", string(val)) -} - -// AttrComponentName returns an optional attribute for the "otel.component.name" -// semantic convention. It represents a name uniquely identifying the instance of -// the OpenTelemetry component within its containing SDK instance. -func (SDKMetricReaderCollectionDuration) AttrComponentName(val string) attribute.KeyValue { - return attribute.String("otel.component.name", val) -} - -// AttrComponentType returns an optional attribute for the "otel.component.type" -// semantic convention. It represents a name identifying the type of the -// OpenTelemetry component. -func (SDKMetricReaderCollectionDuration) AttrComponentType(val ComponentTypeAttr) attribute.KeyValue { - return attribute.String("otel.component.type", string(val)) -} - -// SDKProcessorLogProcessed is an instrument used to record metric values -// conforming to the "otel.sdk.processor.log.processed" semantic conventions. It -// represents the number of log records for which the processing has finished, -// either successful or failed. -type SDKProcessorLogProcessed struct { - metric.Int64Counter -} - -var newSDKProcessorLogProcessedOpts = []metric.Int64CounterOption{ - metric.WithDescription("The number of log records for which the processing has finished, either successful or failed."), - metric.WithUnit("{log_record}"), -} - -// NewSDKProcessorLogProcessed returns a new SDKProcessorLogProcessed instrument. -func NewSDKProcessorLogProcessed( - m metric.Meter, - opt ...metric.Int64CounterOption, -) (SDKProcessorLogProcessed, error) { - // Check if the meter is nil. - if m == nil { - return SDKProcessorLogProcessed{noop.Int64Counter{}}, nil - } - - if len(opt) == 0 { - opt = newSDKProcessorLogProcessedOpts - } else { - opt = append(opt, newSDKProcessorLogProcessedOpts...) - } - - i, err := m.Int64Counter( - "otel.sdk.processor.log.processed", - opt..., - ) - if err != nil { - return SDKProcessorLogProcessed{noop.Int64Counter{}}, err - } - return SDKProcessorLogProcessed{i}, nil -} - -// Inst returns the underlying metric instrument. -func (m SDKProcessorLogProcessed) Inst() metric.Int64Counter { - return m.Int64Counter -} - -// Name returns the semantic convention name of the instrument. -func (SDKProcessorLogProcessed) Name() string { - return "otel.sdk.processor.log.processed" -} - -// Unit returns the semantic convention unit of the instrument -func (SDKProcessorLogProcessed) Unit() string { - return "{log_record}" -} - -// Description returns the semantic convention description of the instrument -func (SDKProcessorLogProcessed) Description() string { - return "The number of log records for which the processing has finished, either successful or failed." -} - -// Add adds incr to the existing count for attrs. -// -// All additional attrs passed are included in the recorded value. -// -// For successful processing, `error.type` MUST NOT be set. For failed -// processing, `error.type` MUST contain the failure cause. -// For the SDK Simple and Batching Log Record Processor a log record is -// considered to be processed already when it has been submitted to the exporter, -// not when the corresponding export call has finished. -func (m SDKProcessorLogProcessed) Add( - ctx context.Context, - incr int64, - attrs ...attribute.KeyValue, -) { - if !m.Int64Counter.Enabled(ctx) { - return - } - if len(attrs) == 0 { - m.Int64Counter.Add(ctx, incr) - return - } - - o := metricpool.AddOptions() - defer metricpool.PutAddOptions(o) - - *o = append( - *o, - metric.WithAttributes( - attrs..., - ), - ) - - m.Int64Counter.Add(ctx, incr, *o...) -} - -// AddSet adds incr to the existing count for set. -// -// For successful processing, `error.type` MUST NOT be set. For failed -// processing, `error.type` MUST contain the failure cause. -// For the SDK Simple and Batching Log Record Processor a log record is -// considered to be processed already when it has been submitted to the exporter, -// not when the corresponding export call has finished. -func (m SDKProcessorLogProcessed) AddSet(ctx context.Context, incr int64, set attribute.Set) { - if !m.Int64Counter.Enabled(ctx) { - return - } - if set.Len() == 0 { - m.Int64Counter.Add(ctx, incr) - return - } - - o := metricpool.AddOptions() - defer metricpool.PutAddOptions(o) - - *o = append(*o, metric.WithAttributeSet(set)) - m.Int64Counter.Add(ctx, incr, *o...) -} - -// AttrErrorType returns an optional attribute for the "error.type" semantic -// convention. It represents a low-cardinality description of the failure reason. -// SDK Batching Log Record Processors MUST use `queue_full` for log records -// dropped due to a full queue. -func (SDKProcessorLogProcessed) AttrErrorType(val ErrorTypeAttr) attribute.KeyValue { - return attribute.String("error.type", string(val)) -} - -// AttrComponentName returns an optional attribute for the "otel.component.name" -// semantic convention. It represents a name uniquely identifying the instance of -// the OpenTelemetry component within its containing SDK instance. -func (SDKProcessorLogProcessed) AttrComponentName(val string) attribute.KeyValue { - return attribute.String("otel.component.name", val) -} - -// AttrComponentType returns an optional attribute for the "otel.component.type" -// semantic convention. It represents a name identifying the type of the -// OpenTelemetry component. -func (SDKProcessorLogProcessed) AttrComponentType(val ComponentTypeAttr) attribute.KeyValue { - return attribute.String("otel.component.type", string(val)) -} - -// SDKProcessorLogProcessedObservable is an instrument used to record metric -// values conforming to the "otel.sdk.processor.log.processed" semantic -// conventions. It represents the number of log records for which the processing -// has finished, either successful or failed. -type SDKProcessorLogProcessedObservable struct { - metric.Int64ObservableCounter -} - -var newSDKProcessorLogProcessedObservableOpts = []metric.Int64ObservableCounterOption{ - metric.WithDescription("The number of log records for which the processing has finished, either successful or failed."), - metric.WithUnit("{log_record}"), -} - -// NewSDKProcessorLogProcessedObservable returns a new -// SDKProcessorLogProcessedObservable instrument. -func NewSDKProcessorLogProcessedObservable( - m metric.Meter, - opt ...metric.Int64ObservableCounterOption, -) (SDKProcessorLogProcessedObservable, error) { - // Check if the meter is nil. - if m == nil { - return SDKProcessorLogProcessedObservable{noop.Int64ObservableCounter{}}, nil - } - - if len(opt) == 0 { - opt = newSDKProcessorLogProcessedObservableOpts - } else { - opt = append(opt, newSDKProcessorLogProcessedObservableOpts...) - } - - i, err := m.Int64ObservableCounter( - "otel.sdk.processor.log.processed", - opt..., - ) - if err != nil { - return SDKProcessorLogProcessedObservable{noop.Int64ObservableCounter{}}, err - } - return SDKProcessorLogProcessedObservable{i}, nil -} - -// Inst returns the underlying metric instrument. -func (m SDKProcessorLogProcessedObservable) Inst() metric.Int64ObservableCounter { - return m.Int64ObservableCounter -} - -// Name returns the semantic convention name of the instrument. -func (SDKProcessorLogProcessedObservable) Name() string { - return "otel.sdk.processor.log.processed" -} - -// Unit returns the semantic convention unit of the instrument -func (SDKProcessorLogProcessedObservable) Unit() string { - return "{log_record}" -} - -// Description returns the semantic convention description of the instrument -func (SDKProcessorLogProcessedObservable) Description() string { - return "The number of log records for which the processing has finished, either successful or failed." -} - -// AttrErrorType returns an optional attribute for the "error.type" semantic -// convention. It represents a low-cardinality description of the failure reason. -// SDK Batching Log Record Processors MUST use `queue_full` for log records -// dropped due to a full queue. -func (SDKProcessorLogProcessedObservable) AttrErrorType(val ErrorTypeAttr) attribute.KeyValue { - return attribute.String("error.type", string(val)) -} - -// AttrComponentName returns an optional attribute for the "otel.component.name" -// semantic convention. It represents a name uniquely identifying the instance of -// the OpenTelemetry component within its containing SDK instance. -func (SDKProcessorLogProcessedObservable) AttrComponentName(val string) attribute.KeyValue { - return attribute.String("otel.component.name", val) -} - -// AttrComponentType returns an optional attribute for the "otel.component.type" -// semantic convention. It represents a name identifying the type of the -// OpenTelemetry component. -func (SDKProcessorLogProcessedObservable) AttrComponentType(val ComponentTypeAttr) attribute.KeyValue { - return attribute.String("otel.component.type", string(val)) -} - -// SDKProcessorLogQueueCapacity is an instrument used to record metric values -// conforming to the "otel.sdk.processor.log.queue.capacity" semantic -// conventions. It represents the maximum number of log records the queue of a -// given instance of an SDK Log Record processor can hold. -type SDKProcessorLogQueueCapacity struct { - metric.Int64ObservableUpDownCounter -} - -var newSDKProcessorLogQueueCapacityOpts = []metric.Int64ObservableUpDownCounterOption{ - metric.WithDescription("The maximum number of log records the queue of a given instance of an SDK Log Record processor can hold."), - metric.WithUnit("{log_record}"), -} - -// NewSDKProcessorLogQueueCapacity returns a new SDKProcessorLogQueueCapacity -// instrument. -func NewSDKProcessorLogQueueCapacity( - m metric.Meter, - opt ...metric.Int64ObservableUpDownCounterOption, -) (SDKProcessorLogQueueCapacity, error) { - // Check if the meter is nil. - if m == nil { - return SDKProcessorLogQueueCapacity{noop.Int64ObservableUpDownCounter{}}, nil - } - - if len(opt) == 0 { - opt = newSDKProcessorLogQueueCapacityOpts - } else { - opt = append(opt, newSDKProcessorLogQueueCapacityOpts...) - } - - i, err := m.Int64ObservableUpDownCounter( - "otel.sdk.processor.log.queue.capacity", - opt..., - ) - if err != nil { - return SDKProcessorLogQueueCapacity{noop.Int64ObservableUpDownCounter{}}, err - } - return SDKProcessorLogQueueCapacity{i}, nil -} - -// Inst returns the underlying metric instrument. -func (m SDKProcessorLogQueueCapacity) Inst() metric.Int64ObservableUpDownCounter { - return m.Int64ObservableUpDownCounter -} - -// Name returns the semantic convention name of the instrument. -func (SDKProcessorLogQueueCapacity) Name() string { - return "otel.sdk.processor.log.queue.capacity" -} - -// Unit returns the semantic convention unit of the instrument -func (SDKProcessorLogQueueCapacity) Unit() string { - return "{log_record}" -} - -// Description returns the semantic convention description of the instrument -func (SDKProcessorLogQueueCapacity) Description() string { - return "The maximum number of log records the queue of a given instance of an SDK Log Record processor can hold." -} - -// AttrComponentName returns an optional attribute for the "otel.component.name" -// semantic convention. It represents a name uniquely identifying the instance of -// the OpenTelemetry component within its containing SDK instance. -func (SDKProcessorLogQueueCapacity) AttrComponentName(val string) attribute.KeyValue { - return attribute.String("otel.component.name", val) -} - -// AttrComponentType returns an optional attribute for the "otel.component.type" -// semantic convention. It represents a name identifying the type of the -// OpenTelemetry component. -func (SDKProcessorLogQueueCapacity) AttrComponentType(val ComponentTypeAttr) attribute.KeyValue { - return attribute.String("otel.component.type", string(val)) -} - -// SDKProcessorLogQueueSize is an instrument used to record metric values -// conforming to the "otel.sdk.processor.log.queue.size" semantic conventions. It -// represents the number of log records in the queue of a given instance of an -// SDK log processor. -type SDKProcessorLogQueueSize struct { - metric.Int64ObservableUpDownCounter -} - -var newSDKProcessorLogQueueSizeOpts = []metric.Int64ObservableUpDownCounterOption{ - metric.WithDescription("The number of log records in the queue of a given instance of an SDK log processor."), - metric.WithUnit("{log_record}"), -} - -// NewSDKProcessorLogQueueSize returns a new SDKProcessorLogQueueSize instrument. -func NewSDKProcessorLogQueueSize( - m metric.Meter, - opt ...metric.Int64ObservableUpDownCounterOption, -) (SDKProcessorLogQueueSize, error) { - // Check if the meter is nil. - if m == nil { - return SDKProcessorLogQueueSize{noop.Int64ObservableUpDownCounter{}}, nil - } - - if len(opt) == 0 { - opt = newSDKProcessorLogQueueSizeOpts - } else { - opt = append(opt, newSDKProcessorLogQueueSizeOpts...) - } - - i, err := m.Int64ObservableUpDownCounter( - "otel.sdk.processor.log.queue.size", - opt..., - ) - if err != nil { - return SDKProcessorLogQueueSize{noop.Int64ObservableUpDownCounter{}}, err - } - return SDKProcessorLogQueueSize{i}, nil -} - -// Inst returns the underlying metric instrument. -func (m SDKProcessorLogQueueSize) Inst() metric.Int64ObservableUpDownCounter { - return m.Int64ObservableUpDownCounter -} - -// Name returns the semantic convention name of the instrument. -func (SDKProcessorLogQueueSize) Name() string { - return "otel.sdk.processor.log.queue.size" -} - -// Unit returns the semantic convention unit of the instrument -func (SDKProcessorLogQueueSize) Unit() string { - return "{log_record}" -} - -// Description returns the semantic convention description of the instrument -func (SDKProcessorLogQueueSize) Description() string { - return "The number of log records in the queue of a given instance of an SDK log processor." -} - -// AttrComponentName returns an optional attribute for the "otel.component.name" -// semantic convention. It represents a name uniquely identifying the instance of -// the OpenTelemetry component within its containing SDK instance. -func (SDKProcessorLogQueueSize) AttrComponentName(val string) attribute.KeyValue { - return attribute.String("otel.component.name", val) -} - -// AttrComponentType returns an optional attribute for the "otel.component.type" -// semantic convention. It represents a name identifying the type of the -// OpenTelemetry component. -func (SDKProcessorLogQueueSize) AttrComponentType(val ComponentTypeAttr) attribute.KeyValue { - return attribute.String("otel.component.type", string(val)) -} - -// SDKProcessorSpanProcessed is an instrument used to record metric values -// conforming to the "otel.sdk.processor.span.processed" semantic conventions. It -// represents the number of spans for which the processing has finished, either -// successful or failed. -type SDKProcessorSpanProcessed struct { - metric.Int64Counter -} - -var newSDKProcessorSpanProcessedOpts = []metric.Int64CounterOption{ - metric.WithDescription("The number of spans for which the processing has finished, either successful or failed."), - metric.WithUnit("{span}"), -} - -// NewSDKProcessorSpanProcessed returns a new SDKProcessorSpanProcessed -// instrument. -func NewSDKProcessorSpanProcessed( - m metric.Meter, - opt ...metric.Int64CounterOption, -) (SDKProcessorSpanProcessed, error) { - // Check if the meter is nil. - if m == nil { - return SDKProcessorSpanProcessed{noop.Int64Counter{}}, nil - } - - if len(opt) == 0 { - opt = newSDKProcessorSpanProcessedOpts - } else { - opt = append(opt, newSDKProcessorSpanProcessedOpts...) - } - - i, err := m.Int64Counter( - "otel.sdk.processor.span.processed", - opt..., - ) - if err != nil { - return SDKProcessorSpanProcessed{noop.Int64Counter{}}, err - } - return SDKProcessorSpanProcessed{i}, nil -} - -// Inst returns the underlying metric instrument. -func (m SDKProcessorSpanProcessed) Inst() metric.Int64Counter { - return m.Int64Counter -} - -// Name returns the semantic convention name of the instrument. -func (SDKProcessorSpanProcessed) Name() string { - return "otel.sdk.processor.span.processed" -} - -// Unit returns the semantic convention unit of the instrument -func (SDKProcessorSpanProcessed) Unit() string { - return "{span}" -} - -// Description returns the semantic convention description of the instrument -func (SDKProcessorSpanProcessed) Description() string { - return "The number of spans for which the processing has finished, either successful or failed." -} - -// Add adds incr to the existing count for attrs. -// -// All additional attrs passed are included in the recorded value. -// -// For successful processing, `error.type` MUST NOT be set. For failed -// processing, `error.type` MUST contain the failure cause. -// For the SDK Simple and Batching Span Processor a span is considered to be -// processed already when it has been submitted to the exporter, not when the -// corresponding export call has finished. -func (m SDKProcessorSpanProcessed) Add( - ctx context.Context, - incr int64, - attrs ...attribute.KeyValue, -) { - if !m.Int64Counter.Enabled(ctx) { - return - } - if len(attrs) == 0 { - m.Int64Counter.Add(ctx, incr) - return - } - - o := metricpool.AddOptions() - defer metricpool.PutAddOptions(o) - - *o = append( - *o, - metric.WithAttributes( - attrs..., - ), - ) - - m.Int64Counter.Add(ctx, incr, *o...) -} - -// AddSet adds incr to the existing count for set. -// -// For successful processing, `error.type` MUST NOT be set. For failed -// processing, `error.type` MUST contain the failure cause. -// For the SDK Simple and Batching Span Processor a span is considered to be -// processed already when it has been submitted to the exporter, not when the -// corresponding export call has finished. -func (m SDKProcessorSpanProcessed) AddSet(ctx context.Context, incr int64, set attribute.Set) { - if !m.Int64Counter.Enabled(ctx) { - return - } - if set.Len() == 0 { - m.Int64Counter.Add(ctx, incr) - return - } - - o := metricpool.AddOptions() - defer metricpool.PutAddOptions(o) - - *o = append(*o, metric.WithAttributeSet(set)) - m.Int64Counter.Add(ctx, incr, *o...) -} - -// AttrErrorType returns an optional attribute for the "error.type" semantic -// convention. It represents a low-cardinality description of the failure reason. -// SDK Batching Span Processors MUST use `queue_full` for spans dropped due to a -// full queue. -func (SDKProcessorSpanProcessed) AttrErrorType(val ErrorTypeAttr) attribute.KeyValue { - return attribute.String("error.type", string(val)) -} - -// AttrComponentName returns an optional attribute for the "otel.component.name" -// semantic convention. It represents a name uniquely identifying the instance of -// the OpenTelemetry component within its containing SDK instance. -func (SDKProcessorSpanProcessed) AttrComponentName(val string) attribute.KeyValue { - return attribute.String("otel.component.name", val) -} - -// AttrComponentType returns an optional attribute for the "otel.component.type" -// semantic convention. It represents a name identifying the type of the -// OpenTelemetry component. -func (SDKProcessorSpanProcessed) AttrComponentType(val ComponentTypeAttr) attribute.KeyValue { - return attribute.String("otel.component.type", string(val)) -} - -// SDKProcessorSpanProcessedObservable is an instrument used to record metric -// values conforming to the "otel.sdk.processor.span.processed" semantic -// conventions. It represents the number of spans for which the processing has -// finished, either successful or failed. -type SDKProcessorSpanProcessedObservable struct { - metric.Int64ObservableCounter -} - -var newSDKProcessorSpanProcessedObservableOpts = []metric.Int64ObservableCounterOption{ - metric.WithDescription("The number of spans for which the processing has finished, either successful or failed."), - metric.WithUnit("{span}"), -} - -// NewSDKProcessorSpanProcessedObservable returns a new -// SDKProcessorSpanProcessedObservable instrument. -func NewSDKProcessorSpanProcessedObservable( - m metric.Meter, - opt ...metric.Int64ObservableCounterOption, -) (SDKProcessorSpanProcessedObservable, error) { - // Check if the meter is nil. - if m == nil { - return SDKProcessorSpanProcessedObservable{noop.Int64ObservableCounter{}}, nil - } - - if len(opt) == 0 { - opt = newSDKProcessorSpanProcessedObservableOpts - } else { - opt = append(opt, newSDKProcessorSpanProcessedObservableOpts...) - } - - i, err := m.Int64ObservableCounter( - "otel.sdk.processor.span.processed", - opt..., - ) - if err != nil { - return SDKProcessorSpanProcessedObservable{noop.Int64ObservableCounter{}}, err - } - return SDKProcessorSpanProcessedObservable{i}, nil -} - -// Inst returns the underlying metric instrument. -func (m SDKProcessorSpanProcessedObservable) Inst() metric.Int64ObservableCounter { - return m.Int64ObservableCounter -} - -// Name returns the semantic convention name of the instrument. -func (SDKProcessorSpanProcessedObservable) Name() string { - return "otel.sdk.processor.span.processed" -} - -// Unit returns the semantic convention unit of the instrument -func (SDKProcessorSpanProcessedObservable) Unit() string { - return "{span}" -} - -// Description returns the semantic convention description of the instrument -func (SDKProcessorSpanProcessedObservable) Description() string { - return "The number of spans for which the processing has finished, either successful or failed." -} - -// AttrErrorType returns an optional attribute for the "error.type" semantic -// convention. It represents a low-cardinality description of the failure reason. -// SDK Batching Span Processors MUST use `queue_full` for spans dropped due to a -// full queue. -func (SDKProcessorSpanProcessedObservable) AttrErrorType(val ErrorTypeAttr) attribute.KeyValue { - return attribute.String("error.type", string(val)) -} - -// AttrComponentName returns an optional attribute for the "otel.component.name" -// semantic convention. It represents a name uniquely identifying the instance of -// the OpenTelemetry component within its containing SDK instance. -func (SDKProcessorSpanProcessedObservable) AttrComponentName(val string) attribute.KeyValue { - return attribute.String("otel.component.name", val) -} - -// AttrComponentType returns an optional attribute for the "otel.component.type" -// semantic convention. It represents a name identifying the type of the -// OpenTelemetry component. -func (SDKProcessorSpanProcessedObservable) AttrComponentType(val ComponentTypeAttr) attribute.KeyValue { - return attribute.String("otel.component.type", string(val)) -} - -// SDKProcessorSpanQueueCapacity is an instrument used to record metric values -// conforming to the "otel.sdk.processor.span.queue.capacity" semantic -// conventions. It represents the maximum number of spans the queue of a given -// instance of an SDK span processor can hold. -type SDKProcessorSpanQueueCapacity struct { - metric.Int64ObservableUpDownCounter -} - -var newSDKProcessorSpanQueueCapacityOpts = []metric.Int64ObservableUpDownCounterOption{ - metric.WithDescription("The maximum number of spans the queue of a given instance of an SDK span processor can hold."), - metric.WithUnit("{span}"), -} - -// NewSDKProcessorSpanQueueCapacity returns a new SDKProcessorSpanQueueCapacity -// instrument. -func NewSDKProcessorSpanQueueCapacity( - m metric.Meter, - opt ...metric.Int64ObservableUpDownCounterOption, -) (SDKProcessorSpanQueueCapacity, error) { - // Check if the meter is nil. - if m == nil { - return SDKProcessorSpanQueueCapacity{noop.Int64ObservableUpDownCounter{}}, nil - } - - if len(opt) == 0 { - opt = newSDKProcessorSpanQueueCapacityOpts - } else { - opt = append(opt, newSDKProcessorSpanQueueCapacityOpts...) - } - - i, err := m.Int64ObservableUpDownCounter( - "otel.sdk.processor.span.queue.capacity", - opt..., - ) - if err != nil { - return SDKProcessorSpanQueueCapacity{noop.Int64ObservableUpDownCounter{}}, err - } - return SDKProcessorSpanQueueCapacity{i}, nil -} - -// Inst returns the underlying metric instrument. -func (m SDKProcessorSpanQueueCapacity) Inst() metric.Int64ObservableUpDownCounter { - return m.Int64ObservableUpDownCounter -} - -// Name returns the semantic convention name of the instrument. -func (SDKProcessorSpanQueueCapacity) Name() string { - return "otel.sdk.processor.span.queue.capacity" -} - -// Unit returns the semantic convention unit of the instrument -func (SDKProcessorSpanQueueCapacity) Unit() string { - return "{span}" -} - -// Description returns the semantic convention description of the instrument -func (SDKProcessorSpanQueueCapacity) Description() string { - return "The maximum number of spans the queue of a given instance of an SDK span processor can hold." -} - -// AttrComponentName returns an optional attribute for the "otel.component.name" -// semantic convention. It represents a name uniquely identifying the instance of -// the OpenTelemetry component within its containing SDK instance. -func (SDKProcessorSpanQueueCapacity) AttrComponentName(val string) attribute.KeyValue { - return attribute.String("otel.component.name", val) -} - -// AttrComponentType returns an optional attribute for the "otel.component.type" -// semantic convention. It represents a name identifying the type of the -// OpenTelemetry component. -func (SDKProcessorSpanQueueCapacity) AttrComponentType(val ComponentTypeAttr) attribute.KeyValue { - return attribute.String("otel.component.type", string(val)) -} - -// SDKProcessorSpanQueueSize is an instrument used to record metric values -// conforming to the "otel.sdk.processor.span.queue.size" semantic conventions. -// It represents the number of spans in the queue of a given instance of an SDK -// span processor. -type SDKProcessorSpanQueueSize struct { - metric.Int64ObservableUpDownCounter -} - -var newSDKProcessorSpanQueueSizeOpts = []metric.Int64ObservableUpDownCounterOption{ - metric.WithDescription("The number of spans in the queue of a given instance of an SDK span processor."), - metric.WithUnit("{span}"), -} - -// NewSDKProcessorSpanQueueSize returns a new SDKProcessorSpanQueueSize -// instrument. -func NewSDKProcessorSpanQueueSize( - m metric.Meter, - opt ...metric.Int64ObservableUpDownCounterOption, -) (SDKProcessorSpanQueueSize, error) { - // Check if the meter is nil. - if m == nil { - return SDKProcessorSpanQueueSize{noop.Int64ObservableUpDownCounter{}}, nil - } - - if len(opt) == 0 { - opt = newSDKProcessorSpanQueueSizeOpts - } else { - opt = append(opt, newSDKProcessorSpanQueueSizeOpts...) - } - - i, err := m.Int64ObservableUpDownCounter( - "otel.sdk.processor.span.queue.size", - opt..., - ) - if err != nil { - return SDKProcessorSpanQueueSize{noop.Int64ObservableUpDownCounter{}}, err - } - return SDKProcessorSpanQueueSize{i}, nil -} - -// Inst returns the underlying metric instrument. -func (m SDKProcessorSpanQueueSize) Inst() metric.Int64ObservableUpDownCounter { - return m.Int64ObservableUpDownCounter -} - -// Name returns the semantic convention name of the instrument. -func (SDKProcessorSpanQueueSize) Name() string { - return "otel.sdk.processor.span.queue.size" -} - -// Unit returns the semantic convention unit of the instrument -func (SDKProcessorSpanQueueSize) Unit() string { - return "{span}" -} - -// Description returns the semantic convention description of the instrument -func (SDKProcessorSpanQueueSize) Description() string { - return "The number of spans in the queue of a given instance of an SDK span processor." -} - -// AttrComponentName returns an optional attribute for the "otel.component.name" -// semantic convention. It represents a name uniquely identifying the instance of -// the OpenTelemetry component within its containing SDK instance. -func (SDKProcessorSpanQueueSize) AttrComponentName(val string) attribute.KeyValue { - return attribute.String("otel.component.name", val) -} - -// AttrComponentType returns an optional attribute for the "otel.component.type" -// semantic convention. It represents a name identifying the type of the -// OpenTelemetry component. -func (SDKProcessorSpanQueueSize) AttrComponentType(val ComponentTypeAttr) attribute.KeyValue { - return attribute.String("otel.component.type", string(val)) -} - -// SDKSpanLive is an instrument used to record metric values conforming to the -// "otel.sdk.span.live" semantic conventions. It represents the number of created -// spans with `recording=true` for which the end operation has not been called -// yet. -type SDKSpanLive struct { - metric.Int64UpDownCounter -} - -var newSDKSpanLiveOpts = []metric.Int64UpDownCounterOption{ - metric.WithDescription("The number of created spans with `recording=true` for which the end operation has not been called yet."), - metric.WithUnit("{span}"), -} - -// NewSDKSpanLive returns a new SDKSpanLive instrument. -func NewSDKSpanLive( - m metric.Meter, - opt ...metric.Int64UpDownCounterOption, -) (SDKSpanLive, error) { - // Check if the meter is nil. - if m == nil { - return SDKSpanLive{noop.Int64UpDownCounter{}}, nil - } - - if len(opt) == 0 { - opt = newSDKSpanLiveOpts - } else { - opt = append(opt, newSDKSpanLiveOpts...) - } - - i, err := m.Int64UpDownCounter( - "otel.sdk.span.live", - opt..., - ) - if err != nil { - return SDKSpanLive{noop.Int64UpDownCounter{}}, err - } - return SDKSpanLive{i}, nil -} - -// Inst returns the underlying metric instrument. -func (m SDKSpanLive) Inst() metric.Int64UpDownCounter { - return m.Int64UpDownCounter -} - -// Name returns the semantic convention name of the instrument. -func (SDKSpanLive) Name() string { - return "otel.sdk.span.live" -} - -// Unit returns the semantic convention unit of the instrument -func (SDKSpanLive) Unit() string { - return "{span}" -} - -// Description returns the semantic convention description of the instrument -func (SDKSpanLive) Description() string { - return "The number of created spans with `recording=true` for which the end operation has not been called yet." -} - -// Add adds incr to the existing count for attrs. -// -// All additional attrs passed are included in the recorded value. -func (m SDKSpanLive) Add( - ctx context.Context, - incr int64, - attrs ...attribute.KeyValue, -) { - if !m.Int64UpDownCounter.Enabled(ctx) { - return - } - if len(attrs) == 0 { - m.Int64UpDownCounter.Add(ctx, incr) - return - } - - o := metricpool.AddOptions() - defer metricpool.PutAddOptions(o) - - *o = append( - *o, - metric.WithAttributes( - attrs..., - ), - ) - - m.Int64UpDownCounter.Add(ctx, incr, *o...) -} - -// AddSet adds incr to the existing count for set. -func (m SDKSpanLive) AddSet(ctx context.Context, incr int64, set attribute.Set) { - if !m.Int64UpDownCounter.Enabled(ctx) { - return - } - if set.Len() == 0 { - m.Int64UpDownCounter.Add(ctx, incr) - return - } - - o := metricpool.AddOptions() - defer metricpool.PutAddOptions(o) - - *o = append(*o, metric.WithAttributeSet(set)) - m.Int64UpDownCounter.Add(ctx, incr, *o...) -} - -// AttrSpanSamplingResult returns an optional attribute for the -// "otel.span.sampling_result" semantic convention. It represents the result -// value of the sampler for this span. -func (SDKSpanLive) AttrSpanSamplingResult(val SpanSamplingResultAttr) attribute.KeyValue { - return attribute.String("otel.span.sampling_result", string(val)) -} - -// SDKSpanLiveObservable is an instrument used to record metric values conforming -// to the "otel.sdk.span.live" semantic conventions. It represents the number of -// created spans with `recording=true` for which the end operation has not been -// called yet. -type SDKSpanLiveObservable struct { - metric.Int64ObservableUpDownCounter -} - -var newSDKSpanLiveObservableOpts = []metric.Int64ObservableUpDownCounterOption{ - metric.WithDescription("The number of created spans with `recording=true` for which the end operation has not been called yet."), - metric.WithUnit("{span}"), -} - -// NewSDKSpanLiveObservable returns a new SDKSpanLiveObservable instrument. -func NewSDKSpanLiveObservable( - m metric.Meter, - opt ...metric.Int64ObservableUpDownCounterOption, -) (SDKSpanLiveObservable, error) { - // Check if the meter is nil. - if m == nil { - return SDKSpanLiveObservable{noop.Int64ObservableUpDownCounter{}}, nil - } - - if len(opt) == 0 { - opt = newSDKSpanLiveObservableOpts - } else { - opt = append(opt, newSDKSpanLiveObservableOpts...) - } - - i, err := m.Int64ObservableUpDownCounter( - "otel.sdk.span.live", - opt..., - ) - if err != nil { - return SDKSpanLiveObservable{noop.Int64ObservableUpDownCounter{}}, err - } - return SDKSpanLiveObservable{i}, nil -} - -// Inst returns the underlying metric instrument. -func (m SDKSpanLiveObservable) Inst() metric.Int64ObservableUpDownCounter { - return m.Int64ObservableUpDownCounter -} - -// Name returns the semantic convention name of the instrument. -func (SDKSpanLiveObservable) Name() string { - return "otel.sdk.span.live" -} - -// Unit returns the semantic convention unit of the instrument -func (SDKSpanLiveObservable) Unit() string { - return "{span}" -} - -// Description returns the semantic convention description of the instrument -func (SDKSpanLiveObservable) Description() string { - return "The number of created spans with `recording=true` for which the end operation has not been called yet." -} - -// AttrSpanSamplingResult returns an optional attribute for the -// "otel.span.sampling_result" semantic convention. It represents the result -// value of the sampler for this span. -func (SDKSpanLiveObservable) AttrSpanSamplingResult(val SpanSamplingResultAttr) attribute.KeyValue { - return attribute.String("otel.span.sampling_result", string(val)) -} - -// SDKSpanStarted is an instrument used to record metric values conforming to the -// "otel.sdk.span.started" semantic conventions. It represents the number of -// created spans. -type SDKSpanStarted struct { - metric.Int64Counter -} - -var newSDKSpanStartedOpts = []metric.Int64CounterOption{ - metric.WithDescription("The number of created spans."), - metric.WithUnit("{span}"), -} - -// NewSDKSpanStarted returns a new SDKSpanStarted instrument. -func NewSDKSpanStarted( - m metric.Meter, - opt ...metric.Int64CounterOption, -) (SDKSpanStarted, error) { - // Check if the meter is nil. - if m == nil { - return SDKSpanStarted{noop.Int64Counter{}}, nil - } - - if len(opt) == 0 { - opt = newSDKSpanStartedOpts - } else { - opt = append(opt, newSDKSpanStartedOpts...) - } - - i, err := m.Int64Counter( - "otel.sdk.span.started", - opt..., - ) - if err != nil { - return SDKSpanStarted{noop.Int64Counter{}}, err - } - return SDKSpanStarted{i}, nil -} - -// Inst returns the underlying metric instrument. -func (m SDKSpanStarted) Inst() metric.Int64Counter { - return m.Int64Counter -} - -// Name returns the semantic convention name of the instrument. -func (SDKSpanStarted) Name() string { - return "otel.sdk.span.started" -} - -// Unit returns the semantic convention unit of the instrument -func (SDKSpanStarted) Unit() string { - return "{span}" -} - -// Description returns the semantic convention description of the instrument -func (SDKSpanStarted) Description() string { - return "The number of created spans." -} - -// Add adds incr to the existing count for attrs. -// -// All additional attrs passed are included in the recorded value. -// -// Implementations MUST record this metric for all spans, even for non-recording -// ones. -func (m SDKSpanStarted) Add( - ctx context.Context, - incr int64, - attrs ...attribute.KeyValue, -) { - if !m.Int64Counter.Enabled(ctx) { - return - } - if len(attrs) == 0 { - m.Int64Counter.Add(ctx, incr) - return - } - - o := metricpool.AddOptions() - defer metricpool.PutAddOptions(o) - - *o = append( - *o, - metric.WithAttributes( - attrs..., - ), - ) - - m.Int64Counter.Add(ctx, incr, *o...) -} - -// AddSet adds incr to the existing count for set. -// -// Implementations MUST record this metric for all spans, even for non-recording -// ones. -func (m SDKSpanStarted) AddSet(ctx context.Context, incr int64, set attribute.Set) { - if !m.Int64Counter.Enabled(ctx) { - return - } - if set.Len() == 0 { - m.Int64Counter.Add(ctx, incr) - return - } - - o := metricpool.AddOptions() - defer metricpool.PutAddOptions(o) - - *o = append(*o, metric.WithAttributeSet(set)) - m.Int64Counter.Add(ctx, incr, *o...) -} - -// AttrSpanParentOrigin returns an optional attribute for the -// "otel.span.parent.origin" semantic convention. It represents the determines -// whether the span has a parent span, and if so, [whether it is a remote parent] -// . -// -// [whether it is a remote parent]: https://opentelemetry.io/docs/specs/otel/trace/api/#isremote -func (SDKSpanStarted) AttrSpanParentOrigin(val SpanParentOriginAttr) attribute.KeyValue { - return attribute.String("otel.span.parent.origin", string(val)) -} - -// AttrSpanSamplingResult returns an optional attribute for the -// "otel.span.sampling_result" semantic convention. It represents the result -// value of the sampler for this span. -func (SDKSpanStarted) AttrSpanSamplingResult(val SpanSamplingResultAttr) attribute.KeyValue { - return attribute.String("otel.span.sampling_result", string(val)) -} - -// SDKSpanStartedObservable is an instrument used to record metric values -// conforming to the "otel.sdk.span.started" semantic conventions. It represents -// the number of created spans. -type SDKSpanStartedObservable struct { - metric.Int64ObservableCounter -} - -var newSDKSpanStartedObservableOpts = []metric.Int64ObservableCounterOption{ - metric.WithDescription("The number of created spans."), - metric.WithUnit("{span}"), -} - -// NewSDKSpanStartedObservable returns a new SDKSpanStartedObservable instrument. -func NewSDKSpanStartedObservable( - m metric.Meter, - opt ...metric.Int64ObservableCounterOption, -) (SDKSpanStartedObservable, error) { - // Check if the meter is nil. - if m == nil { - return SDKSpanStartedObservable{noop.Int64ObservableCounter{}}, nil - } - - if len(opt) == 0 { - opt = newSDKSpanStartedObservableOpts - } else { - opt = append(opt, newSDKSpanStartedObservableOpts...) - } - - i, err := m.Int64ObservableCounter( - "otel.sdk.span.started", - opt..., - ) - if err != nil { - return SDKSpanStartedObservable{noop.Int64ObservableCounter{}}, err - } - return SDKSpanStartedObservable{i}, nil -} - -// Inst returns the underlying metric instrument. -func (m SDKSpanStartedObservable) Inst() metric.Int64ObservableCounter { - return m.Int64ObservableCounter -} - -// Name returns the semantic convention name of the instrument. -func (SDKSpanStartedObservable) Name() string { - return "otel.sdk.span.started" -} - -// Unit returns the semantic convention unit of the instrument -func (SDKSpanStartedObservable) Unit() string { - return "{span}" -} - -// Description returns the semantic convention description of the instrument -func (SDKSpanStartedObservable) Description() string { - return "The number of created spans." -} - -// AttrSpanParentOrigin returns an optional attribute for the -// "otel.span.parent.origin" semantic convention. It represents the determines -// whether the span has a parent span, and if so, [whether it is a remote parent] -// . -// -// [whether it is a remote parent]: https://opentelemetry.io/docs/specs/otel/trace/api/#isremote -func (SDKSpanStartedObservable) AttrSpanParentOrigin(val SpanParentOriginAttr) attribute.KeyValue { - return attribute.String("otel.span.parent.origin", string(val)) -} - -// AttrSpanSamplingResult returns an optional attribute for the -// "otel.span.sampling_result" semantic convention. It represents the result -// value of the sampler for this span. -func (SDKSpanStartedObservable) AttrSpanSamplingResult(val SpanSamplingResultAttr) attribute.KeyValue { - return attribute.String("otel.span.sampling_result", string(val)) -} diff --git a/vendor/modules.txt b/vendor/modules.txt index 493a39144..0fc313969 100644 --- a/vendor/modules.txt +++ b/vendor/modules.txt @@ -1131,12 +1131,11 @@ go.opentelemetry.io/otel/semconv/v1.37.0/rpcconv go.opentelemetry.io/otel/semconv/v1.40.0 go.opentelemetry.io/otel/semconv/v1.40.0/otelconv go.opentelemetry.io/otel/semconv/v1.41.0 -go.opentelemetry.io/otel/semconv/v1.41.0/otelconv go.opentelemetry.io/otel/semconv/v1.43.0 go.opentelemetry.io/otel/semconv/v1.43.0/httpconv go.opentelemetry.io/otel/semconv/v1.43.0/otelconv go.opentelemetry.io/otel/semconv/v1.43.0/rpcconv -# go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc v0.20.0 +# go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc v0.21.0 ## explicit; go 1.25.0 go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc/internal @@ -1173,7 +1172,7 @@ go.opentelemetry.io/otel/exporters/prometheus/internal go.opentelemetry.io/otel/exporters/prometheus/internal/counter go.opentelemetry.io/otel/exporters/prometheus/internal/observ go.opentelemetry.io/otel/exporters/prometheus/internal/x -# go.opentelemetry.io/otel/log v0.20.0 +# go.opentelemetry.io/otel/log v0.21.0 ## explicit; go 1.25.0 go.opentelemetry.io/otel/log go.opentelemetry.io/otel/log/embedded @@ -1196,9 +1195,11 @@ go.opentelemetry.io/otel/sdk/trace go.opentelemetry.io/otel/sdk/trace/internal/env go.opentelemetry.io/otel/sdk/trace/internal/observ go.opentelemetry.io/otel/sdk/trace/tracetest -# go.opentelemetry.io/otel/sdk/log v0.20.0 +# go.opentelemetry.io/otel/sdk/log v0.21.0 ## explicit; go 1.25.0 go.opentelemetry.io/otel/sdk/log +go.opentelemetry.io/otel/sdk/log/internal/attrnorm +go.opentelemetry.io/otel/sdk/log/internal/counter go.opentelemetry.io/otel/sdk/log/internal/observ go.opentelemetry.io/otel/sdk/log/internal/x # go.opentelemetry.io/otel/sdk/metric v1.45.0