Implement span live and ended metrics

Author: JonasKunz

sdk/common/src/main/java/io/opentelemetry/sdk/internal/SemConvAttributes.java

@@ -25,6 +25,9 @@ private SemConvAttributes() {}
       AttributeKey.stringKey("otel.component.name");
   public static final AttributeKey<String> ERROR_TYPE = AttributeKey.stringKey("error.type");
 
+  public static final AttributeKey<String> OTEL_SPAN_SAMPLING_RESULT =
+      AttributeKey.stringKey("otel.span.sampling_result");
+
   public static final AttributeKey<String> SERVER_ADDRESS =
       AttributeKey.stringKey("server.address");
   public static final AttributeKey<Long> SERVER_PORT = AttributeKey.longKey("server.port");

sdk/common/src/test/java/io/opentelemetry/sdk/internal/SemConvAttributesTest.java

@@ -22,6 +22,8 @@ void testAttributeKeys() {
         .isEqualTo(OtelIncubatingAttributes.OTEL_COMPONENT_NAME);
     assertThat(SemConvAttributes.OTEL_COMPONENT_TYPE)
         .isEqualTo(OtelIncubatingAttributes.OTEL_COMPONENT_TYPE);
+    assertThat(SemConvAttributes.OTEL_SPAN_SAMPLING_RESULT)
+        .isEqualTo(OtelIncubatingAttributes.OTEL_SPAN_SAMPLING_RESULT);
 
     assertThat(SemConvAttributes.ERROR_TYPE).isEqualTo(ErrorAttributes.ERROR_TYPE);
 

sdk/trace/build.gradle.kts

@@ -32,6 +32,7 @@ dependencies {
   testImplementation(project(":sdk:testing"))
   testImplementation("com.google.guava:guava")
   testImplementation("com.google.guava:guava-testlib")
+  testImplementation("io.opentelemetry.semconv:opentelemetry-semconv-incubating")
 
   jmh(project(":sdk:metrics"))
   jmh(project(":sdk:testing")) {

sdk/trace/src/main/java/io/opentelemetry/sdk/trace/NonRecordingSpan.java

@@ -0,0 +1,133 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package io.opentelemetry.sdk.trace;
+
+import io.opentelemetry.api.common.AttributeKey;
+import io.opentelemetry.api.common.Attributes;
+import io.opentelemetry.api.trace.Span;
+import io.opentelemetry.api.trace.SpanContext;
+import io.opentelemetry.api.trace.StatusCode;
+import io.opentelemetry.sdk.trace.internal.metrics.SpanMetrics;
+import java.util.concurrent.TimeUnit;
+import javax.annotation.Nullable;
+import javax.annotation.concurrent.Immutable;
+
+/**
+ * Span implementation used from {@link io.opentelemetry.sdk.trace.SdkTracer} when starting a span
+ * which is not recording. All operations are noop, except for {@link #end()}, which ensures health
+ * metrics are still collected.
+ */
+@Immutable
+final class NonRecordingSpan implements Span {
+
+  private final SpanContext spanContext;
+  private final SpanMetrics.Recording metricRecording;
+
+  NonRecordingSpan(SpanContext spanContext, SpanMetrics.Recording metricRecording) {
+    this.spanContext = spanContext;
+    this.metricRecording = metricRecording;
+  }
+
+  @Override
+  public Span setAttribute(String key, @Nullable String value) {
+    return this;
+  }
+
+  @Override
+  public Span setAttribute(String key, long value) {
+    return this;
+  }
+
+  @Override
+  public Span setAttribute(String key, double value) {
+    return this;
+  }
+
+  @Override
+  public Span setAttribute(String key, boolean value) {
+    return this;
+  }
+
+  @Override
+  public <T> Span setAttribute(AttributeKey<T> key, @Nullable T value) {
+    return this;
+  }
+
+  @Override
+  public Span setAllAttributes(Attributes attributes) {
+    return this;
+  }
+
+  @Override
+  public Span addEvent(String name) {
+    return this;
+  }
+
+  @Override
+  public Span addEvent(String name, long timestamp, TimeUnit unit) {
+    return this;
+  }
+
+  @Override
+  public Span addEvent(String name, Attributes attributes) {
+    return this;
+  }
+
+  @Override
+  public Span addEvent(String name, Attributes attributes, long timestamp, TimeUnit unit) {
+    return this;
+  }
+
+  @Override
+  public Span setStatus(StatusCode statusCode) {
+    return this;
+  }
+
+  @Override
+  public Span setStatus(StatusCode statusCode, String description) {
+    return this;
+  }
+
+  @Override
+  public Span recordException(Throwable exception) {
+    return this;
+  }
+
+  @Override
+  public Span recordException(Throwable exception, Attributes additionalAttributes) {
+    return this;
+  }
+
+  @Override
+  public Span updateName(String name) {
+    return this;
+  }
+
+  @Override
+  public void end() {
+    metricRecording.recordSpanEnd();
+  }
+
+  @Override
+  public void end(long timestamp, TimeUnit unit) {
+    end();
+  }
+
+  @Override
+  public SpanContext getSpanContext() {
+    return spanContext;
+  }
+
+  @Override
+  public boolean isRecording() {
+    return false;
+  }
+
+  @Override
+  public String toString() {
+    return "NonRecordingSpan{" + spanContext + '}';
+  }
+}

sdk/trace/src/main/java/io/opentelemetry/sdk/trace/SdkSpan.java

@@ -26,6 +26,7 @@
 import io.opentelemetry.sdk.trace.data.SpanData;
 import io.opentelemetry.sdk.trace.data.StatusData;
 import io.opentelemetry.sdk.trace.internal.ExtendedSpanProcessor;
+import io.opentelemetry.sdk.trace.internal.metrics.SpanMetrics;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
@@ -99,6 +100,8 @@ final class SdkSpan implements ReadWriteSpan {
   @GuardedBy("lock")
   private long endEpochNanos;
 
+  private final SpanMetrics.Recording metricRecording;
+
   private enum EndState {
     NOT_ENDED,
     ENDING,
@@ -132,7 +135,8 @@ private SdkSpan(
       @Nullable AttributesMap attributes,
       @Nullable List<LinkData> links,
       int totalRecordedLinks,
-      long startEpochNanos) {
+      long startEpochNanos,
+      SpanMetrics.Recording metricRecording) {
     this.context = context;
     this.instrumentationScopeInfo = instrumentationScopeInfo;
     this.parentSpanContext = parentSpanContext;
@@ -143,6 +147,7 @@ private SdkSpan(
     this.spanProcessor = spanProcessor;
     this.exceptionAttributeResolver = exceptionAttributeResolver;
     this.resource = resource;
+    this.metricRecording = metricRecording;
     this.hasEnded = EndState.NOT_ENDED;
     this.clock = clock;
     this.startEpochNanos = startEpochNanos;
@@ -180,7 +185,8 @@ static SdkSpan startSpan(
       @Nullable AttributesMap attributes,
       @Nullable List<LinkData> links,
       int totalRecordedLinks,
-      long userStartEpochNanos) {
+      long userStartEpochNanos,
+      SpanMetrics.Recording metricsRecording) {
     boolean createdAnchoredClock;
     AnchoredClock clock;
     if (parentSpan instanceof SdkSpan) {
@@ -219,7 +225,8 @@ static SdkSpan startSpan(
             attributes,
             links,
             totalRecordedLinks,
-            startEpochNanos);
+            startEpochNanos,
+            metricsRecording);
     // Call onStart here instead of calling in the constructor to make sure the span is completely
     // initialized.
     if (spanProcessor.isStartRequired()) {
@@ -557,6 +564,7 @@ private void endInternal(long endEpochNanos) {
       spanEndingThread = Thread.currentThread();
       hasEnded = EndState.ENDING;
     }
+    metricRecording.recordSpanEnd();
     if (spanProcessor instanceof ExtendedSpanProcessor) {
       ExtendedSpanProcessor extendedSpanProcessor = (ExtendedSpanProcessor) spanProcessor;
       if (extendedSpanProcessor.isOnEndingRequired()) {

sdk/trace/src/main/java/io/opentelemetry/sdk/trace/SdkSpanBuilder.java

@@ -24,6 +24,7 @@
 import io.opentelemetry.sdk.internal.AttributeUtil;
 import io.opentelemetry.sdk.internal.AttributesMap;
 import io.opentelemetry.sdk.trace.data.LinkData;
+import io.opentelemetry.sdk.trace.internal.metrics.SpanMetrics;
 import io.opentelemetry.sdk.trace.samplers.SamplingDecision;
 import io.opentelemetry.sdk.trace.samplers.SamplingResult;
 import java.util.ArrayList;
@@ -204,8 +205,10 @@ public Span startSpan() {
             /* remote= */ false,
             tracerSharedState.isIdGeneratorSafeToSkipIdValidation());
 
+    SpanMetrics.Recording metricsRecording =
+        tracerSharedState.getSpanMetrics().recordSpanStart(samplingResult);
     if (!isRecording(samplingDecision)) {
-      return Span.wrap(spanContext);
+      return new NonRecordingSpan(spanContext, metricsRecording);
     }
     Attributes samplingAttributes = samplingResult.getAttributes();
     if (!samplingAttributes.isEmpty()) {
@@ -232,7 +235,8 @@ public Span startSpan() {
         recordedAttributes,
         currentLinks,
         totalNumberOfLinksAdded,
-        startEpochNanos);
+        startEpochNanos,
+        metricsRecording);
   }
 
   private AttributesMap attributes() {

sdk/trace/src/main/java/io/opentelemetry/sdk/trace/SdkTracerProvider.java

@@ -5,18 +5,22 @@
 
 package io.opentelemetry.sdk.trace;
 
+import io.opentelemetry.api.metrics.MeterProvider;
 import io.opentelemetry.api.trace.Tracer;
 import io.opentelemetry.api.trace.TracerBuilder;
 import io.opentelemetry.api.trace.TracerProvider;
 import io.opentelemetry.sdk.common.Clock;
 import io.opentelemetry.sdk.common.CompletableResultCode;
 import io.opentelemetry.sdk.common.InstrumentationScopeInfo;
+import io.opentelemetry.sdk.common.InternalTelemetryVersion;
 import io.opentelemetry.sdk.internal.ComponentRegistry;
 import io.opentelemetry.sdk.internal.ExceptionAttributeResolver;
 import io.opentelemetry.sdk.internal.ScopeConfigurator;
 import io.opentelemetry.sdk.resources.Resource;
 import io.opentelemetry.sdk.trace.internal.SdkTracerProviderUtil;
 import io.opentelemetry.sdk.trace.internal.TracerConfig;
+import io.opentelemetry.sdk.trace.internal.metrics.SemConvSpanMetrics;
+import io.opentelemetry.sdk.trace.internal.metrics.SpanMetrics;
 import io.opentelemetry.sdk.trace.samplers.Sampler;
 import java.io.Closeable;
 import java.util.List;
@@ -54,7 +58,9 @@ public static SdkTracerProviderBuilder builder() {
       Sampler sampler,
       List<SpanProcessor> spanProcessors,
       ScopeConfigurator<TracerConfig> tracerConfigurator,
-      ExceptionAttributeResolver exceptionAttributeResolver) {
+      ExceptionAttributeResolver exceptionAttributeResolver,
+      InternalTelemetryVersion internalTelemetryVersion,
+      Supplier<MeterProvider> meterProviderSupplier) {
     this.sharedState =
         new TracerSharedState(
             clock,
@@ -63,7 +69,8 @@ public static SdkTracerProviderBuilder builder() {
             spanLimitsSupplier,
             sampler,
             spanProcessors,
-            exceptionAttributeResolver);
+            exceptionAttributeResolver,
+            createSpanMetrics(internalTelemetryVersion, meterProviderSupplier));
     this.tracerSdkComponentRegistry =
         new ComponentRegistry<>(
             instrumentationScopeInfo ->
@@ -74,6 +81,21 @@ public static SdkTracerProviderBuilder builder() {
     this.tracerConfigurator = tracerConfigurator;
   }
 
+  private static SpanMetrics createSpanMetrics(
+      InternalTelemetryVersion internalTelemetryVersion,
+      Supplier<MeterProvider> meterProviderSupplier) {
+    switch (internalTelemetryVersion) {
+      case LEGACY:
+      case DISABLED:
+        return SpanMetrics.noop();
+      case V1_33:
+      case LATEST:
+        return new SemConvSpanMetrics(meterProviderSupplier);
+    }
+    throw new IllegalStateException(
+        "Unhandled telemetry schema version: " + internalTelemetryVersion);
+  }
+
   private TracerConfig getTracerConfig(InstrumentationScopeInfo instrumentationScopeInfo) {
     TracerConfig tracerConfig = tracerConfigurator.apply(instrumentationScopeInfo);
     return tracerConfig == null ? TracerConfig.defaultConfig() : tracerConfig;

sdk/trace/src/main/java/io/opentelemetry/sdk/trace/SdkTracerProviderBuilder.java

@@ -7,11 +7,14 @@
 
 import static java.util.Objects.requireNonNull;
 
+import io.opentelemetry.api.GlobalOpenTelemetry;
+import io.opentelemetry.api.metrics.MeterProvider;
 import io.opentelemetry.api.trace.Span;
 import io.opentelemetry.sdk.common.Clock;
 import io.opentelemetry.sdk.common.InstrumentationScopeInfo;
 import io.opentelemetry.sdk.internal.DefaultExceptionAttributeResolver;
 import io.opentelemetry.sdk.internal.ExceptionAttributeResolver;
+import io.opentelemetry.sdk.common.InternalTelemetryVersion;
 import io.opentelemetry.sdk.internal.ScopeConfigurator;
 import io.opentelemetry.sdk.internal.ScopeConfiguratorBuilder;
 import io.opentelemetry.sdk.resources.Resource;
@@ -35,6 +38,9 @@ public final class SdkTracerProviderBuilder {
   private Resource resource = Resource.getDefault();
   private Supplier<SpanLimits> spanLimitsSupplier = SpanLimits::getDefault;
   private Sampler sampler = DEFAULT_SAMPLER;
+  private Supplier<MeterProvider> meterProviderSupplier = GlobalOpenTelemetry::getMeterProvider;
+  private InternalTelemetryVersion internalTelemetryVersion =
+      InternalTelemetryVersion.DISABLED;
   private ScopeConfiguratorBuilder<TracerConfig> tracerConfiguratorBuilder =
       TracerConfig.configuratorBuilder();
   private ExceptionAttributeResolver exceptionAttributeResolver =
@@ -177,6 +183,27 @@ public SdkTracerProviderBuilder addSpanProcessorFirst(SpanProcessor spanProcesso
     return this;
   }
 
+  /**
+   * Sets the {@link MeterProvider} supplier used to collect self-monitoring metrics. If not set,
+   * uses {@link GlobalOpenTelemetry#getMeterProvider()}.
+   */
+  public SdkTracerProviderBuilder setMeterProvider(Supplier<MeterProvider> meterProviderSupplier) {
+    requireNonNull(meterProviderSupplier, "meterProviderSupplier");
+    this.meterProviderSupplier = meterProviderSupplier;
+    return this;
+  }
+
+  /**
+   * Sets the {@link InternalTelemetryVersion} defining which self-monitoring metrics the
+   * tracers originating from this provider collect.
+   */
+  public SdkTracerProviderBuilder setInternalTelemetry(
+      InternalTelemetryVersion internalTelemetryVersion) {
+    requireNonNull(internalTelemetryVersion, "internalTelemetryVersion");
+    this.internalTelemetryVersion = internalTelemetryVersion;
+    return this;
+  }
+
   /**
    * Set the tracer configurator, which computes {@link TracerConfig} for each {@link
    * InstrumentationScopeInfo}.
@@ -247,7 +274,9 @@ public SdkTracerProvider build() {
         sampler,
         spanProcessors,
         tracerConfiguratorBuilder.build(),
-        exceptionAttributeResolver);
+        exceptionAttributeResolver,
+        internalTelemetryVersion,
+        meterProviderSupplier);
   }
 
   SdkTracerProviderBuilder() {}