feat(core): Instrument LangChain AI (#17955)

This PR adds automatic instrumentation for LangChain chat clients in
Node SDK, we cover most used providers mentioned in
https://python.langchain.com/docs/integrations/chat/.

**What's added?**

TLDR; a [LangChain Callback Handler
](https://js.langchain.com/docs/concepts/callbacks/) that:

- Creates a stateful callback handler that tracks LangChain lifecycle
events
-  Handles LLM/Chat Model events (start, end, error, streaming)
-  Handles Chain events (start, end, error)
- Handles Tool events (start, end, error)
- Extracts and normalizes request/respo


**How it works?**
1. **Module Patching**: When a LangChain provider package is loaded
(e.g., `@langchain/anthropic`), the instrumentation:
   - Finds the chat model class (e.g., `ChatAnthropic`)
   - Wraps the `invoke`, `stream`, and `batch` methods on the prototype
   - Uses a Proxy to intercept method calls

2. **Callback Injection**: When a LangChain method is called:
   - The wrapper intercepts the call
- Augments the `options.callbacks` array with Sentry's callback handler
   - Calls the original method with the augmented callbacks
   
   
The integration is **enabled by default** when you initialize Sentry in
Node.js:

```javascript
import * as Sentry from '@sentry/node';
import { ChatAnthropic } from '@langchain/anthropic';

Sentry.init({
  dsn: 'your-dsn',
  tracesSampleRate: 1.0,
  sendDefaultPii: true, // Enable to record inputs/outputs
});

// LangChain calls are automatically instrumented
const model = new ChatAnthropic({
  model: 'claude-3-5-sonnet-20241022',
});

await model.invoke('What is the capital of France?');
```

You can configure what data is recorded:

```javascript
Sentry.init({
  integrations: [
    Sentry.langChainIntegration({
      recordInputs: true,  // Record prompts/messages
      recordOutputs: true, // Record responses
    })
  ],
});
```

Note: We need to disable integrations for AI providers that LangChain
use to avoid duplicate spans, this will be handled in a follow up PR.

Author: RulaKhaled

.size-limit.js

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

dev-packages/node-integration-tests/package.json

@@ -27,6 +27,8 @@
     "@aws-sdk/client-s3": "^3.552.0",
     "@google/genai": "^1.20.0",
     "@growthbook/growthbook": "^1.6.1",
+    "@langchain/anthropic": "^0.3.10",
+    "@langchain/core": "^0.3.28",
     "@hapi/hapi": "^21.3.10",
     "@hono/node-server": "^1.19.4",
     "@nestjs/common": "^11",

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

@@ -0,0 +1,19 @@
+import * as Sentry from '@sentry/node';
+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,
+  // Filter out Anthropic integration to avoid duplicate spans with LangChain
+  integrations: integrations => integrations.filter(integration => integration.name !== 'Anthropic_AI'),
+  beforeSendTransaction: event => {
+    // Filter out mock express server transactions
+    if (event.transaction.includes('/v1/messages')) {
+      return null;
+    }
+    return event;
+  },
+});

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

@@ -0,0 +1,19 @@
+import * as Sentry from '@sentry/node';
+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,
+  // Filter out Anthropic integration to avoid duplicate spans with LangChain
+  integrations: integrations => integrations.filter(integration => integration.name !== 'Anthropic_AI'),
+  beforeSendTransaction: event => {
+    // Filter out mock express server transactions
+    if (event.transaction.includes('/v1/messages')) {
+      return null;
+    }
+    return event;
+  },
+});

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

@@ -0,0 +1,90 @@
+import { ChatAnthropic } from '@langchain/anthropic';
+import * as Sentry from '@sentry/node';
+import express from 'express';
+
+function startMockAnthropicServer() {
+  const app = express();
+  app.use(express.json());
+
+  app.post('/v1/messages', (req, res) => {
+    const model = req.body.model;
+
+    // Simulate tool call response
+    res.json({
+      id: 'msg_tool_test_123',
+      type: 'message',
+      role: 'assistant',
+      model: model,
+      content: [
+        {
+          type: 'text',
+          text: 'Let me check the weather for you.',
+        },
+        {
+          type: 'tool_use',
+          id: 'toolu_01A09q90qw90lq917835lq9',
+          name: 'get_weather',
+          input: { location: 'San Francisco, CA' },
+        },
+        {
+          type: 'text',
+          text: 'The weather looks great!',
+        },
+      ],
+      stop_reason: 'tool_use',
+      stop_sequence: null,
+      usage: {
+        input_tokens: 20,
+        output_tokens: 30,
+      },
+    });
+  });
+
+  return new Promise(resolve => {
+    const server = app.listen(0, () => {
+      resolve(server);
+    });
+  });
+}
+
+async function run() {
+  const server = await startMockAnthropicServer();
+  const baseUrl = `http://localhost:${server.address().port}`;
+
+  await Sentry.startSpan({ op: 'function', name: 'main' }, async () => {
+    const model = new ChatAnthropic({
+      model: 'claude-3-5-sonnet-20241022',
+      temperature: 0.7,
+      maxTokens: 150,
+      apiKey: 'mock-api-key',
+      clientOptions: {
+        baseURL: baseUrl,
+      },
+    });
+
+    await model.invoke('What is the weather in San Francisco?', {
+      tools: [
+        {
+          name: 'get_weather',
+          description: 'Get the current weather in a given location',
+          input_schema: {
+            type: 'object',
+            properties: {
+              location: {
+                type: 'string',
+                description: 'The city and state, e.g. San Francisco, CA',
+              },
+            },
+            required: ['location'],
+          },
+        },
+      ],
+    });
+  });
+
+  await Sentry.flush(2000);
+
+  server.close();
+}
+
+run();

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

@@ -0,0 +1,110 @@
+import { ChatAnthropic } from '@langchain/anthropic';
+import * as Sentry from '@sentry/node';
+import express from 'express';
+
+function startMockAnthropicServer() {
+  const app = express();
+  app.use(express.json());
+
+  app.post('/v1/messages', (req, res) => {
+    const model = req.body.model;
+
+    if (model === 'error-model') {
+      res
+        .status(400)
+        .set('request-id', 'mock-request-123')
+        .json({
+          type: 'error',
+          error: {
+            type: 'invalid_request_error',
+            message: 'Model not found',
+          },
+        });
+      return;
+    }
+
+    // Simulate basic response
+    res.json({
+      id: 'msg_test123',
+      type: 'message',
+      role: 'assistant',
+      content: [
+        {
+          type: 'text',
+          text: 'Mock response from Anthropic!',
+        },
+      ],
+      model: model,
+      stop_reason: 'end_turn',
+      stop_sequence: null,
+      usage: {
+        input_tokens: 10,
+        output_tokens: 15,
+      },
+    });
+  });
+
+  return new Promise(resolve => {
+    const server = app.listen(0, () => {
+      resolve(server);
+    });
+  });
+}
+
+async function run() {
+  const server = await startMockAnthropicServer();
+  const baseUrl = `http://localhost:${server.address().port}`;
+
+  await Sentry.startSpan({ op: 'function', name: 'main' }, async () => {
+    // Test 1: Basic chat model invocation
+    const model1 = new ChatAnthropic({
+      model: 'claude-3-5-sonnet-20241022',
+      temperature: 0.7,
+      maxTokens: 100,
+      apiKey: 'mock-api-key',
+      clientOptions: {
+        baseURL: baseUrl,
+      },
+    });
+
+    await model1.invoke('Tell me a joke');
+
+    // Test 2: Chat with different model
+    const model2 = new ChatAnthropic({
+      model: 'claude-3-opus-20240229',
+      temperature: 0.9,
+      topP: 0.95,
+      maxTokens: 200,
+      apiKey: 'mock-api-key',
+      clientOptions: {
+        baseURL: baseUrl,
+      },
+    });
+
+    await model2.invoke([
+      { role: 'system', content: 'You are a helpful assistant' },
+      { role: 'user', content: 'What is the capital of France?' },
+    ]);
+
+    // Test 3: Error handling
+    const errorModel = new ChatAnthropic({
+      model: 'error-model',
+      apiKey: 'mock-api-key',
+      clientOptions: {
+        baseURL: baseUrl,
+      },
+    });
+
+    try {
+      await errorModel.invoke('This will fail');
+    } catch {
+      // Expected error
+    }
+  });
+
+  await Sentry.flush(2000);
+
+  server.close();
+}
+
+run();