feat(core): Instrument LangGraph Agent

Author: RulaKhaled

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

@@ -13,7 +13,8 @@
     "test:watch": "yarn test --watch"
   },
   "dependencies": {
-    "@sentry/cloudflare": "10.25.0"
+    "@sentry/cloudflare": "10.25.0",
+    "@langchain/langgraph": "^1.0.1"
   },
   "devDependencies": {
     "@cloudflare/workers-types": "^4.20250922.0",

dev-packages/cloudflare-integration-tests/suites/tracing/langgraph/index.ts

@@ -0,0 +1,66 @@
+import { END, MessagesAnnotation, START, StateGraph } from '@langchain/langgraph';
+import * as Sentry from '@sentry/cloudflare';
+
+interface Env {
+  SENTRY_DSN: string;
+}
+
+export default Sentry.withSentry(
+  (env: Env) => ({
+    dsn: env.SENTRY_DSN,
+    tracesSampleRate: 1.0,
+    sendDefaultPii: true,
+  }),
+  {
+    async fetch(_request, _env, _ctx) {
+      // Define simple mock LLM function
+      const mockLlm = (): {
+        messages: {
+          role: string;
+          content: string;
+          response_metadata: {
+            model_name: string;
+            finish_reason: string;
+            tokenUsage: { promptTokens: number; completionTokens: number; totalTokens: number };
+          };
+          tool_calls: never[];
+        }[];
+      } => {
+        return {
+          messages: [
+            {
+              role: 'assistant',
+              content: 'Mock response from LangGraph agent',
+              response_metadata: {
+                model_name: 'mock-model',
+                finish_reason: 'stop',
+                tokenUsage: {
+                  promptTokens: 20,
+                  completionTokens: 10,
+                  totalTokens: 30,
+                },
+              },
+              tool_calls: [],
+            },
+          ],
+        };
+      };
+
+      // Create and instrument the graph
+      const graph = new StateGraph(MessagesAnnotation)
+        .addNode('agent', mockLlm)
+        .addEdge(START, 'agent')
+        .addEdge('agent', END);
+
+      Sentry.instrumentLangGraph(graph, { recordInputs: true, recordOutputs: true });
+
+      const compiled = graph.compile({ name: 'weather_assistant' });
+
+      await compiled.invoke({
+        messages: [{ role: 'user', content: 'What is the weather in SF?' }],
+      });
+
+      return new Response(JSON.stringify({ success: true }));
+    },
+  },
+);

dev-packages/cloudflare-integration-tests/suites/tracing/langgraph/test.ts

@@ -0,0 +1,59 @@
+import { expect, it } from 'vitest';
+import { createRunner } from '../../../runner';
+
+// These tests are not exhaustive because the instrumentation is
+// already tested in the node integration tests and we merely
+// want to test that the instrumentation does not break in our
+// cloudflare SDK.
+
+it('traces langgraph compile and invoke operations', async ({ signal }) => {
+  const runner = createRunner(__dirname)
+    .ignore('event')
+    .expect(envelope => {
+      const transactionEvent = envelope[1]?.[0]?.[1] as any;
+
+      expect(transactionEvent.transaction).toBe('GET /');
+
+      // Check create_agent span
+      const createAgentSpan = transactionEvent.spans.find((span: any) => span.op === 'gen_ai.create_agent');
+      expect(createAgentSpan).toMatchObject({
+        data: {
+          'gen_ai.operation.name': 'create_agent',
+          'sentry.op': 'gen_ai.create_agent',
+          'sentry.origin': 'auto.ai.langgraph',
+          'gen_ai.agent.name': 'weather_assistant',
+        },
+        description: 'create_agent weather_assistant',
+        op: 'gen_ai.create_agent',
+        origin: 'auto.ai.langgraph',
+      });
+
+      // Check invoke_agent span
+      const invokeAgentSpan = transactionEvent.spans.find((span: any) => span.op === 'gen_ai.invoke_agent');
+      expect(invokeAgentSpan).toMatchObject({
+        data: expect.objectContaining({
+          'gen_ai.operation.name': 'invoke_agent',
+          'sentry.op': 'gen_ai.invoke_agent',
+          'sentry.origin': 'auto.ai.langgraph',
+          'gen_ai.agent.name': 'weather_assistant',
+          'gen_ai.pipeline.name': 'weather_assistant',
+          'gen_ai.request.messages': '[{"role":"user","content":"What is the weather in SF?"}]',
+          'gen_ai.response.model': 'mock-model',
+          'gen_ai.usage.input_tokens': 20,
+          'gen_ai.usage.output_tokens': 10,
+          'gen_ai.usage.total_tokens': 30,
+        }),
+        description: 'invoke_agent weather_assistant',
+        op: 'gen_ai.invoke_agent',
+        origin: 'auto.ai.langgraph',
+      });
+
+      // Verify tools are captured
+      if (invokeAgentSpan.data['gen_ai.request.available_tools']) {
+        expect(invokeAgentSpan.data['gen_ai.request.available_tools']).toMatch(/get_weather/);
+      }
+    })
+    .start(signal);
+  await runner.makeRequest('get', '/');
+  await runner.completed();
+});

dev-packages/cloudflare-integration-tests/suites/tracing/langgraph/wrangler.jsonc

@@ -0,0 +1,6 @@
+{
+  "name": "worker-name",
+  "compatibility_date": "2025-06-17",
+  "main": "index.ts",
+  "compatibility_flags": ["nodejs_compat"],
+}

packages/cloudflare/src/index.ts

@@ -102,6 +102,7 @@ export {
   growthbookIntegration,
   logger,
   metrics,
+  instrumentLangGraph,
 } from '@sentry/core';
 
 export { withSentry } from './handler';

packages/core/src/index.ts

@@ -152,7 +152,7 @@ export type { GoogleGenAIResponse } from './tracing/google-genai/types';
 export { createLangChainCallbackHandler } from './tracing/langchain';
 export { LANGCHAIN_INTEGRATION_NAME } from './tracing/langchain/constants';
 export type { LangChainOptions, LangChainIntegration } from './tracing/langchain/types';
-export { instrumentStateGraphCompile } from './tracing/langgraph';
+export { instrumentStateGraphCompile, instrumentLangGraph } from './tracing/langgraph';
 export { LANGGRAPH_INTEGRATION_NAME } from './tracing/langgraph/constants';
 export type { LangGraphOptions, LangGraphIntegration, CompiledGraph } from './tracing/langgraph/types';
 export type { OpenAiClient, OpenAiOptions, InstrumentedMethod } from './tracing/openai/types';

packages/core/src/tracing/langgraph/index.ts

@@ -155,3 +155,38 @@ function instrumentCompiledGraphInvoke(
     },
   }) as (...args: unknown[]) => Promise<unknown>;
 }
+
+/**
+ * Directly instruments a StateGraph instance to add tracing spans
+ *
+ * This function can be used to manually instrument LangGraph StateGraph instances
+ * in environments where automatic instrumentation is not available or desired.
+ *
+ * @param stateGraph - The StateGraph instance to instrument
+ * @param options - Optional configuration for recording inputs/outputs
+ *
+ * @example
+ * ```typescript
+ * import { instrumentLangGraph } from '@sentry/cloudflare';
+ * import { StateGraph } from '@langchain/langgraph';
+ *
+ * const graph = new StateGraph(MessagesAnnotation)
+ *   .addNode('agent', mockLlm)
+ *   .addEdge(START, 'agent')
+ *   .addEdge('agent', END);
+ *
+ * instrumentLangGraph(graph, { recordInputs: true, recordOutputs: true });
+ * const compiled = graph.compile({ name: 'my_agent' });
+ * ```
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function instrumentLangGraph<T extends { compile: (...args: any[]) => any }>(
+  stateGraph: T,
+  options?: LangGraphOptions,
+): T {
+  const _options: LangGraphOptions = options || {};
+
+  stateGraph.compile = instrumentStateGraphCompile(stateGraph.compile.bind(stateGraph), _options);
+
+  return stateGraph;
+}

packages/vercel-edge/src/index.ts

@@ -71,6 +71,7 @@ export {
   // eslint-disable-next-line deprecation/deprecation
   inboundFiltersIntegration,
   instrumentOpenAiClient,
+  instrumentLangGraph,
   instrumentGoogleGenAIClient,
   instrumentAnthropicAiClient,
   eventFiltersIntegration,