feat(server-utils): Migrate Anthropic integration to orchestrion

Adds an orchestrion based Anthropic integration to server-utils, covering all
the APIs (messages, completions, models, beta messages) and both streaming and
non-streaming mode. Leaves the core integration intact and only exports the
necessary utils that are needed for the orchestrion integration.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: nicohrubec

dev-packages/node-integration-tests/suites/tracing/anthropic/orchestrion/instrument-orchestrion-with-pii.mjs

@@ -0,0 +1,18 @@
+import * as Sentry from '@sentry/node';
+import { loggingTransport } from '@sentry-internal/node-integration-tests';
+
+Sentry.experimentalUseDiagnosticsChannelInjection();
+
+Sentry.init({
+  dsn: 'https://public@dsn.ingest.sentry.io/1337',
+  release: '1.0',
+  tracesSampleRate: 1.0,
+  dataCollection: { genAI: { inputs: true, outputs: true } },
+  transport: loggingTransport,
+  beforeSendTransaction: event => {
+    if (event.transaction.includes('/anthropic/v1/')) {
+      return null;
+    }
+    return event;
+  },
+});

dev-packages/node-integration-tests/suites/tracing/anthropic/orchestrion/instrument-orchestrion.mjs

@@ -0,0 +1,18 @@
+import * as Sentry from '@sentry/node';
+import { loggingTransport } from '@sentry-internal/node-integration-tests';
+
+Sentry.experimentalUseDiagnosticsChannelInjection();
+
+Sentry.init({
+  dsn: 'https://public@dsn.ingest.sentry.io/1337',
+  release: '1.0',
+  tracesSampleRate: 1.0,
+  dataCollection: { genAI: { inputs: false, outputs: false } },
+  transport: loggingTransport,
+  beforeSendTransaction: event => {
+    if (event.transaction.includes('/anthropic/v1/')) {
+      return null;
+    }
+    return event;
+  },
+});

dev-packages/node-integration-tests/suites/tracing/anthropic/orchestrion/test.ts

@@ -0,0 +1,230 @@
+import { SEMANTIC_ATTRIBUTE_SENTRY_OP, SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN } from '@sentry/core';
+import { afterAll, describe, expect } from 'vitest';
+import {
+  GEN_AI_INPUT_MESSAGES_ATTRIBUTE,
+  GEN_AI_OPERATION_NAME_ATTRIBUTE,
+  GEN_AI_REQUEST_MODEL_ATTRIBUTE,
+  GEN_AI_REQUEST_STREAM_ATTRIBUTE,
+  GEN_AI_RESPONSE_ID_ATTRIBUTE,
+  GEN_AI_RESPONSE_STREAMING_ATTRIBUTE,
+  GEN_AI_RESPONSE_TEXT_ATTRIBUTE,
+  GEN_AI_SYSTEM_ATTRIBUTE,
+  GEN_AI_USAGE_INPUT_TOKENS_ATTRIBUTE,
+  GEN_AI_USAGE_OUTPUT_TOKENS_ATTRIBUTE,
+  GEN_AI_USAGE_TOTAL_TOKENS_ATTRIBUTE,
+} from '../../../../../../packages/core/src/tracing/ai/gen-ai-attributes';
+import { cleanupChildProcesses, createEsmAndCjsTests } from '../../../../utils/runner';
+
+// The origin distinguishes the orchestrion (diagnostics-channel) path from the
+// OTel/proxy one (`auto.ai.anthropic`).
+const ORCHESTRION_ORIGIN = 'auto.ai.orchestrion.anthropic';
+
+describe('Anthropic integration (orchestrion)', () => {
+  afterAll(() => {
+    cleanupChildProcesses();
+  });
+
+  createEsmAndCjsTests(__dirname, '../scenario.mjs', 'instrument-orchestrion.mjs', (createRunner, test) => {
+    test('creates anthropic spans via the diagnostics-channel path', async () => {
+      await createRunner()
+        .ignore('event')
+        .expect({ transaction: { transaction: 'main' } })
+        .expect({
+          span: container => {
+            const completionSpan = container.items.find(
+              span => span.attributes[GEN_AI_RESPONSE_ID_ATTRIBUTE]?.value === 'msg_mock123',
+            );
+            expect(completionSpan).toBeDefined();
+            expect(completionSpan!.name).toBe('chat claude-3-haiku-20240307');
+            expect(completionSpan!.status).toBe('ok');
+            expect(completionSpan!.attributes[SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]).toEqual({
+              type: 'string',
+              value: ORCHESTRION_ORIGIN,
+            });
+            expect(completionSpan!.attributes[SEMANTIC_ATTRIBUTE_SENTRY_OP]).toEqual({
+              type: 'string',
+              value: 'gen_ai.chat',
+            });
+            expect(completionSpan!.attributes[GEN_AI_OPERATION_NAME_ATTRIBUTE]).toEqual({
+              type: 'string',
+              value: 'chat',
+            });
+            expect(completionSpan!.attributes[GEN_AI_SYSTEM_ATTRIBUTE]).toEqual({ type: 'string', value: 'anthropic' });
+            expect(completionSpan!.attributes[GEN_AI_REQUEST_MODEL_ATTRIBUTE]).toEqual({
+              type: 'string',
+              value: 'claude-3-haiku-20240307',
+            });
+            expect(completionSpan!.attributes[GEN_AI_USAGE_INPUT_TOKENS_ATTRIBUTE]).toEqual({
+              type: 'integer',
+              value: 10,
+            });
+            expect(completionSpan!.attributes[GEN_AI_USAGE_OUTPUT_TOKENS_ATTRIBUTE]).toEqual({
+              type: 'integer',
+              value: 15,
+            });
+            expect(completionSpan!.attributes[GEN_AI_USAGE_TOTAL_TOKENS_ATTRIBUTE]).toEqual({
+              type: 'integer',
+              value: 25,
+            });
+            // Recording disabled: no inputs/outputs captured.
+            expect(completionSpan!.attributes[GEN_AI_INPUT_MESSAGES_ATTRIBUTE]).toBeUndefined();
+            expect(completionSpan!.attributes[GEN_AI_RESPONSE_TEXT_ATTRIBUTE]).toBeUndefined();
+
+            const errorSpan = container.items.find(span => span.name === 'chat error-model');
+            expect(errorSpan).toBeDefined();
+            expect(errorSpan!.status).not.toBe('ok');
+            expect(errorSpan!.attributes[SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]).toEqual({
+              type: 'string',
+              value: ORCHESTRION_ORIGIN,
+            });
+
+            const tokenCountingSpan = container.items.find(
+              span =>
+                span.attributes[SEMANTIC_ATTRIBUTE_SENTRY_OP]?.value === 'gen_ai.chat' &&
+                span.status === 'ok' &&
+                span.attributes[GEN_AI_RESPONSE_ID_ATTRIBUTE] === undefined,
+            );
+            expect(tokenCountingSpan).toBeDefined();
+            expect(tokenCountingSpan!.name).toBe('chat claude-3-haiku-20240307');
+
+            const modelsSpan = container.items.find(span => span.name === 'models claude-3-haiku-20240307');
+            expect(modelsSpan).toBeDefined();
+            expect(modelsSpan!.status).toBe('ok');
+            expect(modelsSpan!.attributes[SEMANTIC_ATTRIBUTE_SENTRY_OP]).toEqual({
+              type: 'string',
+              value: 'gen_ai.models',
+            });
+            expect(modelsSpan!.attributes[SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]).toEqual({
+              type: 'string',
+              value: ORCHESTRION_ORIGIN,
+            });
+
+            // messages.create({ stream: true }) — the async-iterable `Stream` (`stream: true` in the request).
+            const streamingCreateSpan = container.items.find(
+              span =>
+                span.attributes[GEN_AI_RESPONSE_ID_ATTRIBUTE]?.value === 'msg_stream123' &&
+                span.attributes[GEN_AI_REQUEST_STREAM_ATTRIBUTE]?.value === true,
+            );
+            expect(streamingCreateSpan).toBeDefined();
+            expect(streamingCreateSpan!.status).toBe('ok');
+            expect(streamingCreateSpan!.attributes[SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]).toEqual({
+              type: 'string',
+              value: ORCHESTRION_ORIGIN,
+            });
+            expect(streamingCreateSpan!.attributes[GEN_AI_RESPONSE_STREAMING_ATTRIBUTE]).toEqual({
+              type: 'boolean',
+              value: true,
+            });
+            expect(streamingCreateSpan!.attributes[GEN_AI_USAGE_INPUT_TOKENS_ATTRIBUTE]).toEqual({
+              type: 'integer',
+              value: 10,
+            });
+            expect(streamingCreateSpan!.attributes[GEN_AI_USAGE_OUTPUT_TOKENS_ATTRIBUTE]).toEqual({
+              type: 'integer',
+              value: 15,
+            });
+            expect(streamingCreateSpan!.attributes[GEN_AI_USAGE_TOTAL_TOKENS_ATTRIBUTE]).toEqual({
+              type: 'integer',
+              value: 25,
+            });
+          },
+        })
+        .start()
+        .completed();
+    });
+  });
+
+  createEsmAndCjsTests(__dirname, '../scenario.mjs', 'instrument-orchestrion-with-pii.mjs', (createRunner, test) => {
+    test('records inputs and outputs when PII is enabled', async () => {
+      await createRunner()
+        .ignore('event')
+        .expect({ transaction: { transaction: 'main' } })
+        .expect({
+          span: container => {
+            const completionSpan = container.items.find(
+              span => span.attributes[GEN_AI_RESPONSE_ID_ATTRIBUTE]?.value === 'msg_mock123',
+            );
+            expect(completionSpan).toBeDefined();
+            expect(completionSpan!.attributes[SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]).toEqual({
+              type: 'string',
+              value: ORCHESTRION_ORIGIN,
+            });
+            expect(completionSpan!.attributes[GEN_AI_INPUT_MESSAGES_ATTRIBUTE]).toEqual({
+              type: 'string',
+              value: '[{"role":"user","content":"What is the capital of France?"}]',
+            });
+            expect(completionSpan!.attributes[GEN_AI_RESPONSE_TEXT_ATTRIBUTE]).toEqual({
+              type: 'string',
+              value: 'Hello from Anthropic mock!',
+            });
+
+            const streamingCreateSpan = container.items.find(
+              span =>
+                span.attributes[GEN_AI_RESPONSE_ID_ATTRIBUTE]?.value === 'msg_stream123' &&
+                span.attributes[GEN_AI_REQUEST_STREAM_ATTRIBUTE]?.value === true,
+            );
+            expect(streamingCreateSpan).toBeDefined();
+            expect(streamingCreateSpan!.attributes[GEN_AI_RESPONSE_TEXT_ATTRIBUTE]).toEqual({
+              type: 'string',
+              value: 'Hello from stream!',
+            });
+          },
+        })
+        .start()
+        .completed();
+    });
+  });
+
+  createEsmAndCjsTests(
+    __dirname,
+    '../scenario-stream.mjs',
+    'instrument-orchestrion-with-pii.mjs',
+    (createRunner, test) => {
+      test('creates a span for the messages.stream() emitter path', async () => {
+        await createRunner()
+          .ignore('event')
+          .expect({ transaction: { transaction: 'main' } })
+          .expect({
+            span: container => {
+              // The emitter span from `stream()` itself carries no `stream` request param, unlike
+              // `messages.create({ stream: true })`.
+              const messageStreamSpan = container.items.find(
+                span =>
+                  span.attributes[GEN_AI_RESPONSE_ID_ATTRIBUTE]?.value === 'msg_stream_1' &&
+                  span.attributes[GEN_AI_REQUEST_STREAM_ATTRIBUTE] === undefined,
+              );
+              expect(messageStreamSpan).toBeDefined();
+              expect(messageStreamSpan!.name).toBe('chat claude-3-haiku-20240307');
+              expect(messageStreamSpan!.status).toBe('ok');
+              expect(messageStreamSpan!.attributes[SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]).toEqual({
+                type: 'string',
+                value: ORCHESTRION_ORIGIN,
+              });
+              expect(messageStreamSpan!.attributes[SEMANTIC_ATTRIBUTE_SENTRY_OP]).toEqual({
+                type: 'string',
+                value: 'gen_ai.chat',
+              });
+              expect(messageStreamSpan!.attributes[GEN_AI_RESPONSE_STREAMING_ATTRIBUTE]).toEqual({
+                type: 'boolean',
+                value: true,
+              });
+              expect(messageStreamSpan!.attributes[GEN_AI_USAGE_INPUT_TOKENS_ATTRIBUTE]).toEqual({
+                type: 'integer',
+                value: 10,
+              });
+              expect(messageStreamSpan!.attributes[GEN_AI_USAGE_OUTPUT_TOKENS_ATTRIBUTE]).toEqual({
+                type: 'integer',
+                value: 15,
+              });
+              expect(messageStreamSpan!.attributes[GEN_AI_RESPONSE_TEXT_ATTRIBUTE]).toEqual({
+                type: 'string',
+                value: 'Hello from stream!',
+              });
+            },
+          })
+          .start()
+          .completed();
+      });
+    },
+  );
+});

packages/core/src/shared-exports.ts

@@ -177,16 +177,23 @@ export * as metrics from './metrics/public-api';
 export type { MetricOptions } from './metrics/public-api';
 export { createConsolaReporter } from './integrations/consola';
 export { addVercelAiProcessors, getProviderMetadataAttributes } from './tracing/vercel-ai';
-export { getTruncatedJsonString, shouldEnableTruncation } from './tracing/ai/utils';
+export { getTruncatedJsonString, shouldEnableTruncation, resolveAIRecordingOptions } from './tracing/ai/utils';
 export {
   GEN_AI_INPUT_MESSAGES_ORIGINAL_LENGTH_ATTRIBUTE,
+  GEN_AI_REQUEST_MODEL_ATTRIBUTE,
   GEN_AI_SYSTEM_INSTRUCTIONS_ATTRIBUTE,
 } from './tracing/ai/gen-ai-attributes';
 export { _INTERNAL_getSpanContextForToolCallId, _INTERNAL_cleanupToolCallSpanContext } from './tracing/vercel-ai/utils';
 export { toolCallSpanContextMap as _INTERNAL_toolCallSpanContextMap } from './tracing/vercel-ai/constants';
 export { instrumentOpenAiClient } from './tracing/openai';
 export { OPENAI_INTEGRATION_NAME } from './tracing/openai/constants';
-export { instrumentAnthropicAiClient } from './tracing/anthropic-ai';
+export {
+  instrumentAnthropicAiClient,
+  extractRequestAttributes as extractAnthropicRequestAttributes,
+  addPrivateRequestAttributes as addAnthropicRequestAttributes,
+  addResponseAttributes as addAnthropicResponseAttributes,
+} from './tracing/anthropic-ai';
+export { instrumentAsyncIterableStream, instrumentMessageStream } from './tracing/anthropic-ai/streaming';
 export { ANTHROPIC_AI_INTEGRATION_NAME } from './tracing/anthropic-ai/constants';
 export { instrumentGoogleGenAIClient } from './tracing/google-genai';
 export { GOOGLE_GENAI_INTEGRATION_NAME } from './tracing/google-genai/constants';

packages/core/src/tracing/anthropic-ai/index.ts

@@ -36,7 +36,11 @@ import { handleResponseError, messagesFromParams, setMessagesAttribute } from '.
 /**
  * Extract request attributes from method arguments
  */
-function extractRequestAttributes(args: unknown[], methodPath: string, operationName: string): Record<string, unknown> {
+export function extractRequestAttributes(
+  args: unknown[],
+  methodPath: string,
+  operationName: string,
+): Record<string, unknown> {
   const attributes: Record<string, unknown> = {
     [GEN_AI_SYSTEM_ATTRIBUTE]: 'anthropic',
     [GEN_AI_OPERATION_NAME_ATTRIBUTE]: operationName,
@@ -73,7 +77,11 @@ function extractRequestAttributes(args: unknown[], methodPath: string, operation
  * Add private request attributes to spans.
  * This is only recorded if recordInputs is true.
  */
-function addPrivateRequestAttributes(span: Span, params: Record<string, unknown>, enableTruncation: boolean): void {
+export function addPrivateRequestAttributes(
+  span: Span,
+  params: Record<string, unknown>,
+  enableTruncation: boolean,
+): void {
   const messages = messagesFromParams(params);
   setMessagesAttribute(span, messages, enableTruncation);
 
@@ -143,7 +151,7 @@ function addMetadataAttributes(span: Span, response: AnthropicAiResponse): void
 /**
  * Add response attributes to spans
  */
-function addResponseAttributes(span: Span, response: AnthropicAiResponse, recordOutputs?: boolean): void {
+export function addResponseAttributes(span: Span, response: AnthropicAiResponse, recordOutputs?: boolean): void {
   if (!response || typeof response !== 'object') return;
 
   // capture error, do not add attributes if error (they shouldn't exist)

packages/node/src/sdk/experimentalUseDiagnosticsChannelInjection.ts

@@ -1,6 +1,7 @@
 import {
   mysqlChannelIntegration,
   lruMemoizerChannelIntegration,
+  anthropicChannelIntegration,
   detectOrchestrionSetup,
 } from '@sentry/server-utils/orchestrion';
 import { registerDiagnosticsChannelInjection } from '@sentry/server-utils/orchestrion/register';
@@ -41,7 +42,11 @@ import { setDiagnosticsChannelInjectionLoader } from './diagnosticsChannelInject
  */
 export function experimentalUseDiagnosticsChannelInjection(): void {
   setDiagnosticsChannelInjectionLoader((): DiagnosticsChannelInjection => {
-    const integrations = [mysqlChannelIntegration(), lruMemoizerChannelIntegration()] as const;
+    const integrations = [
+      mysqlChannelIntegration(),
+      lruMemoizerChannelIntegration(),
+      anthropicChannelIntegration(),
+    ] as const;
     const replacedOtelIntegrationNames = integrations.map(i => i.name);
 
     return {