add tracerprovider instrumentation

Author: dashpole

sdk/trace/provider.go

@@ -10,8 +10,12 @@ import (
 	"sync/atomic"
 
 	"go.opentelemetry.io/otel"
+	"go.opentelemetry.io/otel/attribute"
 	"go.opentelemetry.io/otel/internal/global"
+	"go.opentelemetry.io/otel/metric"
+	metricnoop "go.opentelemetry.io/otel/metric/noop"
 	"go.opentelemetry.io/otel/sdk/instrumentation"
+	"go.opentelemetry.io/otel/sdk/internal/x"
 	"go.opentelemetry.io/otel/sdk/resource"
 	"go.opentelemetry.io/otel/trace"
 	"go.opentelemetry.io/otel/trace/embedded"
@@ -79,6 +83,12 @@ type TracerProvider struct {
 	idGenerator IDGenerator
 	spanLimits  SpanLimits
 	resource    *resource.Resource
+
+	spanCreatedCount     metric.Int64Counter
+	spanEndedCount       metric.Int64Counter
+	spanLiveCount        metric.Int64UpDownCounter
+	sampledAttributes    metric.MeasurementOption
+	notSampledAttributes metric.MeasurementOption
 }
 
 var _ trace.TracerProvider = &TracerProvider{}
@@ -120,9 +130,55 @@ func NewTracerProvider(opts ...TracerProviderOption) *TracerProvider {
 	}
 	tp.spanProcessors.Store(&spss)
 
+	tp.configureSelfObservability()
+
 	return tp
 }
 
+var providerID atomic.Uint64
+
+// nextProviderID returns an identifier for this tracerprovider,
+// starting with 0 and incrementing by 1 each time it is called.
+func nextProviderID() int64 {
+	return int64(providerID.Add(1) - 1)
+}
+
+func (p *TracerProvider) configureSelfObservability() {
+	mp := otel.GetMeterProvider()
+	if !x.SelfObservability.Enabled() {
+		mp = metric.MeterProvider(metricnoop.NewMeterProvider())
+	}
+	meter := mp.Meter(
+		selfObsScopeName,
+		metric.WithInstrumentationVersion(version()),
+	)
+	componentNameAttr := attribute.String("otel.sdk.component.name", fmt.Sprintf("tracer_provider/%d", nextProviderID()))
+	p.sampledAttributes = metric.WithAttributes(componentNameAttr, attribute.String("otel.span.is_sampled", "true"))
+	p.notSampledAttributes = metric.WithAttributes(componentNameAttr, attribute.String("otel.span.is_sampled", "false"))
+	var err error
+	p.spanCreatedCount, err = meter.Int64Counter("otel.sdk.span.created_count",
+		metric.WithUnit("{span}"),
+		metric.WithDescription("The number of spans which have been created."),
+	)
+	if err != nil {
+		otel.Handle(err)
+	}
+	p.spanEndedCount, err = meter.Int64Counter("otel.sdk.span.ended_count",
+		metric.WithUnit("{span}"),
+		metric.WithDescription("The number of created spans for which the end operation was called."),
+	)
+	if err != nil {
+		otel.Handle(err)
+	}
+	p.spanLiveCount, err = meter.Int64UpDownCounter("otel.sdk.span.live_count",
+		metric.WithUnit("{span}"),
+		metric.WithDescription("The number of created spans for which the end operation has not been called yet."),
+	)
+	if err != nil {
+		otel.Handle(err)
+	}
+}
+
 // Tracer returns a Tracer with the given name and options. If a Tracer for
 // the given name and options does not exist it is created, otherwise the
 // existing Tracer is returned.

sdk/trace/span.go

@@ -495,6 +495,14 @@ func (s *recordingSpan) End(options ...trace.SpanEndOption) {
 	}
 	s.mu.Unlock()
 
+	if s.spanContext.IsSampled() {
+		s.tracer.provider.spanLiveCount.Add(context.Background(), -1, s.tracer.provider.sampledAttributes)
+		s.tracer.provider.spanEndedCount.Add(context.Background(), 1, s.tracer.provider.sampledAttributes)
+	} else {
+		s.tracer.provider.spanLiveCount.Add(context.Background(), -1, s.tracer.provider.notSampledAttributes)
+		s.tracer.provider.spanEndedCount.Add(context.Background(), 1, s.tracer.provider.notSampledAttributes)
+	}
+
 	sps := s.tracer.provider.getSpanProcessors()
 	if len(sps) == 0 {
 		return
@@ -901,7 +909,11 @@ func (nonRecordingSpan) SetError(bool) {}
 func (nonRecordingSpan) SetAttributes(...attribute.KeyValue) {}
 
 // End does nothing.
-func (nonRecordingSpan) End(...trace.SpanEndOption) {}
+func (s nonRecordingSpan) End(...trace.SpanEndOption) {
+	// TODO: does adding instrumentation to non-recording spans have performance implications?
+	s.tracer.provider.spanEndedCount.Add(context.Background(), 1, s.tracer.provider.notSampledAttributes)
+	s.tracer.provider.spanLiveCount.Add(context.Background(), -1, s.tracer.provider.notSampledAttributes)
+}
 
 // RecordError does nothing.
 func (nonRecordingSpan) RecordError(error, ...trace.EventOption) {}

sdk/trace/tracer.go

@@ -100,8 +100,12 @@ func (tr *tracer) newSpan(ctx context.Context, name string, config *trace.SpanCo
 	}
 	if isSampled(samplingResult) {
 		scc.TraceFlags = psc.TraceFlags() | trace.FlagsSampled
+		tr.provider.spanLiveCount.Add(ctx, 1, tr.provider.sampledAttributes)
+		tr.provider.spanCreatedCount.Add(ctx, 1, tr.provider.sampledAttributes)
 	} else {
 		scc.TraceFlags = psc.TraceFlags() &^ trace.FlagsSampled
+		tr.provider.spanLiveCount.Add(ctx, 1, tr.provider.notSampledAttributes)
+		tr.provider.spanCreatedCount.Add(ctx, 1, tr.provider.notSampledAttributes)
 	}
 	sc := trace.NewSpanContext(scc)