feat(sdk-trace): implement span start/end metrics

api/CHANGELOG.md

@@ -11,6 +11,7 @@ All notable changes to this project will be documented in this file.
 
 * feat(api): improve isValidSpanId, isValidTraceId performance [#5714](https://github.com/open-telemetry/opentelemetry-js/pull/5714) @seemk
 * feat(diag): change types in `DiagComponentLogger` from `any` to `unknown`[#5478](https://github.com/open-telemetry/opentelemetry-js/pull/5478) @loganrosen
+* feat(sdk-trace): implement span start/end metrics  [#1851](https://github.com/open-telemetry/opentelemetry-js/pull/6213) @anuraaga
 
 ### :bug: (Bug Fix)
 

e2e-tests/verify.mjs

@@ -32,9 +32,14 @@ for (const line of lines) {
     verifiedSpan = true;
   }
   if (parsed.resourceMetrics) {
-    console.log('found metric');
-    verifyMetric(parsed.resourceMetrics[0].scopeMetrics[0].metrics[0]);
-    verifiedMetric = true;
+    const scopeMetrics = parsed.resourceMetrics[0].scopeMetrics.find(
+      sm => sm.scope.name === 'example-meter'
+    );
+    if (scopeMetrics) {
+      console.log('found metric');
+      verifyMetric(scopeMetrics.metrics[0]);
+      verifiedMetric = true;
+    }
   }
   if (parsed.resourceLogs) {
     console.log('found log');

packages/opentelemetry-sdk-trace-base/package.json

@@ -64,6 +64,7 @@
   },
   "devDependencies": {
     "@opentelemetry/api": ">=1.3.0 <1.10.0",
+    "@opentelemetry/sdk-metrics": "2.2.0",
     "@types/mocha": "10.0.10",
     "@types/node": "18.6.5",
     "@types/sinon": "17.0.4",

packages/opentelemetry-sdk-trace-base/src/Span.ts

@@ -73,6 +73,7 @@ interface SpanOptions {
   attributes?: Attributes;
   spanLimits: SpanLimits;
   spanProcessor: SpanProcessor;
+  recordEndMetrics?: () => void;
 }
 
 /**
@@ -105,6 +106,7 @@ export class SpanImpl implements Span {
   private readonly _spanProcessor: SpanProcessor;
   private readonly _spanLimits: SpanLimits;
   private readonly _attributeValueLengthLimit: number;
+  private readonly _recordEndMetrics?: () => void;
 
   private readonly _performanceStartTime: number;
   private readonly _performanceOffset: number;
@@ -133,6 +135,7 @@ export class SpanImpl implements Span {
     this.startTime = this._getTime(opts.startTime ?? now);
     this.resource = opts.resource;
     this.instrumentationScope = opts.scope;
+    this._recordEndMetrics = opts.recordEndMetrics;
 
     if (opts.attributes != null) {
       this.setAttributes(opts.attributes);
@@ -292,6 +295,7 @@ export class SpanImpl implements Span {
       this._spanProcessor.onEnding(this);
     }
 
+    this._recordEndMetrics?.();
     this._ended = true;
     this._spanProcessor.onEnd(this);
   }

packages/opentelemetry-sdk-trace-base/src/Tracer.ts

@@ -28,6 +28,7 @@ import { Sampler } from './Sampler';
 import { IdGenerator } from './IdGenerator';
 import { RandomIdGenerator } from './platform';
 import { Resource } from '@opentelemetry/resources';
+import { TracerMetrics } from './TracerMetrics';
 
 /**
  * This class represents a basic tracer.
@@ -41,6 +42,7 @@ export class Tracer implements api.Tracer {
 
   private readonly _resource: Resource;
   private readonly _spanProcessor: SpanProcessor;
+  private readonly _tracerMetrics: TracerMetrics;
 
   /**
    * Constructs a new Tracer instance.
@@ -58,6 +60,9 @@ export class Tracer implements api.Tracer {
     this._idGenerator = config.idGenerator || new RandomIdGenerator();
     this._resource = resource;
     this._spanProcessor = spanProcessor;
+    this._tracerMetrics = new TracerMetrics(
+      localConfig.meterProvider || api.metrics.getMeterProvider()
+    );
     this.instrumentationScope = instrumentationScope;
   }
 
@@ -120,6 +125,11 @@ export class Tracer implements api.Tracer {
       links
     );
 
+    const recordEndMetrics = this._tracerMetrics.startSpan(
+      parentSpanContext,
+      samplingResult.decision
+    );
+
     traceState = samplingResult.traceState ?? traceState;
 
     const traceFlags =
@@ -154,6 +164,7 @@ export class Tracer implements api.Tracer {
       startTime: options.startTime,
       spanProcessor: this._spanProcessor,
       spanLimits: this._spanLimits,
+      recordEndMetrics,
     });
     return span;
   }

packages/opentelemetry-sdk-trace-base/src/TracerMetrics.ts

@@ -0,0 +1,87 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import {
+  Counter,
+  MeterProvider,
+  SpanContext,
+  UpDownCounter,
+} from '@opentelemetry/api';
+import { SamplingDecision } from './Sampler';
+
+export class TracerMetrics {
+  private readonly startedSpans: Counter;
+  private readonly liveSpans: UpDownCounter;
+
+  constructor(meterProvider: MeterProvider) {
+    const meter = meterProvider.getMeter('@opentelemetry/sdk-trace');
+
+    this.startedSpans = meter.createCounter('otel.sdk.span.started', {
+      unit: '{span}',
+      description: 'The number of created spans.',
+    });
+
+    this.liveSpans = meter.createUpDownCounter('otel.sdk.span.live', {
+      unit: '{span}',
+      description: 'The number of currently live spans.',
+    });
+  }
+
+  startSpan(
+    parentSpanCtx: SpanContext | undefined,
+    samplingDecision: SamplingDecision
+  ): () => void {
+    const samplingDecisionStr = samplingDecisionToString(samplingDecision);
+    this.startedSpans.add(1, {
+      'otel.span.parent.origin': parentOrigin(parentSpanCtx),
+      'otel.span.sampling_result': samplingDecisionStr,
+    });
+
+    if (samplingDecision === SamplingDecision.NOT_RECORD) {
+      return () => {};
+    }
+
+    const liveSpanAttributes = {
+      'otel.span.sampling_result': samplingDecisionStr,
+    };
+    this.liveSpans.add(1, liveSpanAttributes);
+    return () => {
+      this.liveSpans.add(-1, liveSpanAttributes);
+    };
+  }
+}
+
+function parentOrigin(parentSpanContext: SpanContext | undefined): string {
+  if (!parentSpanContext) {
+    return 'none';
+  }
+  if (parentSpanContext.isRemote) {
+    return 'remote';
+  }
+  return 'local';
+}
+
+function samplingDecisionToString(decision: SamplingDecision): string {
+  switch (decision) {
+    case SamplingDecision.RECORD_AND_SAMPLED:
+      return 'RECORD_AND_SAMPLE';
+    case SamplingDecision.RECORD:
+      return 'RECORD_ONLY';
+    case SamplingDecision.NOT_RECORD:
+      return 'DROP';
+    default:
+      return 'unknown';
+  }
+}

packages/opentelemetry-sdk-trace-base/src/types.ts

@@ -14,7 +14,11 @@
  * limitations under the License.
  */
 
-import { ContextManager, TextMapPropagator } from '@opentelemetry/api';
+import {
+  ContextManager,
+  MeterProvider,
+  TextMapPropagator,
+} from '@opentelemetry/api';
 import { Resource } from '@opentelemetry/resources';
 import { IdGenerator } from './IdGenerator';
 import { Sampler } from './Sampler';
@@ -54,6 +58,9 @@ export interface TracerConfig {
    * List of SpanProcessor for the tracer
    */
   spanProcessors?: SpanProcessor[];
+
+  /** A meter provider to record trace SDK metrics to. */
+  meterProvider?: MeterProvider;
 }
 
 /**