@ai-sdk/otel 1.0.159 → 1.0.160

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-sdk/otel",
-  "version": "1.0.159",
+  "version": "1.0.160",
   "type": "module",
   "license": "Apache-2.0",
   "sideEffects": false,
@@ -28,10 +28,11 @@
   "dependencies": {
     "@ai-sdk/provider": "4.0.35",
     "@opentelemetry/api": "1.9.1",
-    "ai": "7.0.159"
+    "ai": "7.0.160"
   },
   "devDependencies": {
     "@ai-sdk/provider-utils": "5.0.72",
+    "@opentelemetry/sdk-metrics": "2.8.0",
     "@opentelemetry/sdk-trace-base": "2.7.1",
     "@types/node": "22.19.19",
     "@vercel/ai-tsconfig": "0.0.0",

package/src/open-telemetry.ts

@@ -1,5 +1,6 @@
 import {
   context,
+  metrics,
   SpanKind,
   SpanStatusCode,
   trace,
@@ -91,6 +92,11 @@ interface CallState {
   stepContext: OpenTelemetryContext | undefined;
   inferenceSpan: Span | undefined;
   inferenceContext: OpenTelemetryContext | undefined;
+  inferenceMetrics?: {
+    startTime: number;
+    provider: string;
+    modelId: string;
+  };
   inferenceToolDefinitions?: ReadonlyArray<Record<string, unknown>>;
   embedSpans: Map<string, { span: Span; context: OpenTelemetryContext }>;
   rerankSpan: { span: Span; context: OpenTelemetryContext } | undefined;
@@ -145,6 +151,52 @@ export class OpenTelemetry implements Telemetry {
     this.callStates.delete(callId);
   }
 
+  private recordInferenceDuration(
+    state: CallState,
+    {
+      responseTimeMs,
+      provider,
+      responseModelId,
+      errorType,
+    }: {
+      responseTimeMs?: number;
+      provider?: string;
+      responseModelId?: string;
+      errorType?: string;
+    } = {},
+  ): void {
+    const inference = state.inferenceMetrics;
+    if (inference == null) return;
+    state.inferenceMetrics = undefined;
+
+    // Resolve the meter when recording so a provider registered after this
+    // integration is constructed can still receive metrics.
+    const histogram = metrics
+      .getMeter('gen_ai')
+      .createHistogram('gen_ai.client.inference.duration', {
+        description: 'GenAI client inference operation duration.',
+        unit: 's',
+        advice: {
+          explicitBucketBoundaries: [
+            0.01, 0.02, 0.04, 0.08, 0.16, 0.32, 0.64, 1.28, 2.56, 5.12, 10.24,
+            20.48, 40.96, 81.92,
+          ],
+        },
+      });
+
+    histogram.record(
+      (responseTimeMs ?? performance.now() - inference.startTime) / 1000,
+      selectAttributes(state.telemetry, {
+        'gen_ai.operation.name': 'chat',
+        'gen_ai.provider.name': mapProviderName(provider ?? inference.provider),
+        'gen_ai.request.model': inference.modelId,
+        'gen_ai.response.model': responseModelId,
+        'error.type': errorType,
+      }),
+      state.inferenceContext,
+    );
+  }
+
   private getAgentSpanName({
     operationName,
     modelId,
@@ -859,9 +911,17 @@ export class OpenTelemetry implements Telemetry {
     const state = this.getCallState(event.callId);
     if (!state?.stepContext) return;
 
+    // A retried stream may start a new attempt without ending the failed one.
+    this.recordInferenceDuration(state, { errorType: '_OTHER' });
+
     const { telemetry } = state;
     const providerName = mapProviderName(event.provider);
     state.inferenceToolDefinitions = event.tools;
+    state.inferenceMetrics = {
+      startTime: performance.now(),
+      provider: event.provider,
+      modelId: event.modelId,
+    };
 
     const inferenceAttributes = selectAttributes(telemetry, {
       'gen_ai.operation.name': 'chat',
@@ -932,6 +992,13 @@ export class OpenTelemetry implements Telemetry {
     const state = this.getCallState(event.callId);
     if (!state?.inferenceSpan) return;
 
+    this.recordInferenceDuration(state, {
+      responseTimeMs: event.performance.responseTimeMs,
+      provider: event.provider,
+      responseModelId: event.modelId,
+      errorType: event.finishReason === 'error' ? '_OTHER' : undefined,
+    });
+
     if (event.finishReason === 'error') {
       state.inferenceSpan.setStatus({ code: SpanStatusCode.ERROR });
     }
@@ -1175,6 +1242,11 @@ export class OpenTelemetry implements Telemetry {
     const state = this.getCallState(event.callId);
     if (!state?.stepSpan) return;
 
+    // Streams can close after an error chunk without a model-call end event.
+    this.recordInferenceDuration(state, {
+      errorType: event.finishReason === 'error' ? '_OTHER' : undefined,
+    });
+
     if (event.finishReason === 'error') {
       state.stepSpan.setStatus({ code: SpanStatusCode.ERROR });
     }
@@ -1206,6 +1278,10 @@ export class OpenTelemetry implements Telemetry {
     const state = this.getCallState(event.callId);
     if (!state?.stepSpan) return;
 
+    this.recordInferenceDuration(state, {
+      errorType: event.error instanceof Error ? event.error.name : '_OTHER',
+    });
+
     if (state.inferenceSpan) {
       recordErrorOnSpan(state.inferenceSpan, event.error);
       state.inferenceSpan.end();
@@ -1907,6 +1983,8 @@ export class OpenTelemetry implements Telemetry {
     const state = this.getCallState(event.callId);
     if (!state?.rootSpan) return;
 
+    this.recordInferenceDuration(state, { errorType: 'AbortError' });
+
     for (const { span: toolSpan } of state.toolSpans.values()) {
       toolSpan.end();
     }
@@ -1952,6 +2030,10 @@ export class OpenTelemetry implements Telemetry {
 
     const actualError = event.error ?? error;
 
+    this.recordInferenceDuration(state, {
+      errorType: actualError instanceof Error ? actualError.name : '_OTHER',
+    });
+
     for (const { span: toolSpan } of state.toolSpans.values()) {
       recordErrorOnSpan(toolSpan, actualError);
       toolSpan.end();