feat(node): Add Anthropic AI integration (#17348)

This PR adds official support for instrumenting Anthropic AI SDK calls
in Node with Sentry tracing, following OpenTelemetry semantic
conventions for Generative AI.

We instrument the following Anthropic AI SDK methods:
-  messages.create
- messages.countTokens
 - models.get
 - models.retrieve
 - completions.create

Supported in:
- Node.js (ESM and CJS) 
- Will be added to cloudflare workers and vercel edge functions exports.

The anthropicAIIntegration() accepts the following options:

```
// The integration respects your sendDefaultPii client option
interface AnthropicAiOptions {
  recordInputs?: boolean;   // Whether to record prompt messages
  recordOutputs?: boolean;  // Whether to record response text
}
```

Author: RulaKhaled

.size-limit.js

@@ -233,7 +233,7 @@ module.exports = [
     import: createImport('init'),
     ignore: [...builtinModules, ...nodePrefixedBuiltinModules],
     gzip: true,
-    limit: '148 KB',
+    limit: '149 KB',
   },
   {
     name: '@sentry/node - without tracing',

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

@@ -0,0 +1,18 @@
+import * as Sentry from '@sentry/node';
+import { nodeContextIntegration } from '@sentry/node-core';
+import { loggingTransport } from '@sentry-internal/node-integration-tests';
+
+Sentry.init({
+  dsn: 'https://public@dsn.ingest.sentry.io/1337',
+  release: '1.0',
+  tracesSampleRate: 1.0,
+  sendDefaultPii: false,
+  transport: loggingTransport,
+  integrations: [
+    Sentry.anthropicAIIntegration({
+      recordInputs: true,
+      recordOutputs: true,
+    }),
+    nodeContextIntegration(),
+  ],
+});

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

@@ -0,0 +1,15 @@
+import * as Sentry from '@sentry/node';
+import { nodeContextIntegration } from '@sentry/node-core';
+import { loggingTransport } from '@sentry-internal/node-integration-tests';
+
+Sentry.init({
+  dsn: 'https://public@dsn.ingest.sentry.io/1337',
+  release: '1.0',
+  tracesSampleRate: 1.0,
+  sendDefaultPii: true,
+  transport: loggingTransport,
+  integrations: [
+    Sentry.anthropicAIIntegration(),
+    nodeContextIntegration(),
+  ],
+});

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

@@ -0,0 +1,16 @@
+import * as Sentry from '@sentry/node';
+import { nodeContextIntegration } from '@sentry/node-core';
+import { loggingTransport } from '@sentry-internal/node-integration-tests';
+
+Sentry.init({
+  dsn: 'https://public@dsn.ingest.sentry.io/1337',
+  release: '1.0',
+  tracesSampleRate: 1.0,
+  sendDefaultPii: false,
+  transport: loggingTransport,
+  // Force include the integration
+  integrations: [
+    Sentry.anthropicAIIntegration(),
+    nodeContextIntegration(),
+  ],
+});

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

@@ -0,0 +1,119 @@
+import { instrumentAnthropicAiClient } from '@sentry/core';
+import * as Sentry from '@sentry/node';
+
+class MockAnthropic {
+  constructor(config) {
+    this.apiKey = config.apiKey;
+
+    // Create messages object with create and countTokens methods
+    this.messages = {
+      create: this._messagesCreate.bind(this),
+      countTokens: this._messagesCountTokens.bind(this)
+    };
+
+    this.models = {
+      retrieve: this._modelsRetrieve.bind(this),
+    };
+  }
+
+  /**
+   * Create a mock message
+   */
+  async _messagesCreate(params) {
+    // Simulate processing time
+    await new Promise(resolve => setTimeout(resolve, 10));
+
+    if (params.model === 'error-model') {
+      const error = new Error('Model not found');
+      error.status = 404;
+      error.headers = { 'x-request-id': 'mock-request-123' };
+      throw error;
+    }
+
+    return {
+      id: 'msg_mock123',
+      type: 'message',
+      model: params.model,
+      role: 'assistant',
+      content: [
+        {
+          type: 'text',
+          text: 'Hello from Anthropic mock!',
+        },
+      ],
+      stop_reason: 'end_turn',
+      stop_sequence: null,
+      usage: {
+        input_tokens: 10,
+        output_tokens: 15,
+      },
+    };
+  }
+
+  async _messagesCountTokens() {
+    // Simulate processing time
+    await new Promise(resolve => setTimeout(resolve, 10));
+
+    // For countTokens, just return input_tokens
+    return {
+        input_tokens: 15
+      }
+  }
+
+  async _modelsRetrieve(modelId) {
+    // Simulate processing time
+    await new Promise(resolve => setTimeout(resolve, 10));
+
+    // Match what the actual implementation would return
+    return {
+      id: modelId,
+      name: modelId,
+      created_at: 1715145600,
+      model: modelId,  // Add model field to match the check in addResponseAttributes
+    };
+  }
+}
+
+async function run() {
+  await Sentry.startSpan({ op: 'function', name: 'main' }, async () => {
+    const mockClient = new MockAnthropic({
+      apiKey: 'mock-api-key',
+    });
+
+    const client = instrumentAnthropicAiClient(mockClient);
+
+    // First test: basic message completion
+    await client.messages.create({
+      model: 'claude-3-haiku-20240307',
+      system: 'You are a helpful assistant.',
+      messages: [
+        { role: 'user', content: 'What is the capital of France?' },
+      ],
+      temperature: 0.7,
+      max_tokens: 100,
+    });
+
+    // Second test: error handling
+    try {
+      await client.messages.create({
+        model: 'error-model',
+        messages: [{ role: 'user', content: 'This will fail' }],
+      });
+    } catch {
+      // Error is expected and handled
+    }
+
+    // Third test: count tokens with cached tokens
+    await client.messages.countTokens({
+      model: 'claude-3-haiku-20240307',
+      messages: [
+        { role: 'user', content: 'What is the capital of France?' },
+      ],
+    });
+
+    // Fourth test: models.retrieve
+    await client.models.retrieve('claude-3-haiku-20240307');
+  });
+}
+
+run();