Try to instrument createReactAgent (doesn't work yet)

Author: nicohrubec

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, instrumentLangGraph } from './tracing/langgraph';
+export { instrumentStateGraphCompile, instrumentCreateReactAgent, 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

@@ -156,6 +156,51 @@ function instrumentCompiledGraphInvoke(
   }) as (...args: unknown[]) => Promise<unknown>;
 }
 
+/**
+ * Instruments createReactAgent to create spans for agent creation and invocation
+ *
+ * Creates a `gen_ai.create_agent` span when createReactAgent() is called
+ */
+export function instrumentCreateReactAgent(
+  originalCreateReactAgent: (...args: unknown[]) => CompiledGraph,
+  options: LangGraphOptions,
+): (...args: unknown[]) => CompiledGraph {
+  return new Proxy(originalCreateReactAgent, {
+    apply(target, thisArg, args: unknown[]): CompiledGraph {
+      return startSpan(
+        {
+          op: 'gen_ai.create_agent',
+          name: 'create_agent',
+          attributes: {
+            [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: LANGGRAPH_ORIGIN,
+            [SEMANTIC_ATTRIBUTE_SENTRY_OP]: 'gen_ai.create_agent',
+            [GEN_AI_OPERATION_NAME_ATTRIBUTE]: 'create_agent',
+          },
+        },
+        () => {
+          try {
+            const compiledGraph = Reflect.apply(target, thisArg, args);
+            const compiledOptions = args.length > 0 ? (args[0] as Record<string, unknown>) : {};
+            const originalInvoke = compiledGraph.invoke;
+            if (originalInvoke && typeof originalInvoke === 'function') {
+              compiledGraph.invoke = instrumentCompiledGraphInvoke(
+                originalInvoke.bind(compiledGraph) as (...args: unknown[]) => Promise<unknown>,
+                compiledGraph,
+                compiledOptions,
+                options,
+              ) as typeof originalInvoke;
+            }
+
+            return compiledGraph;
+          } catch (error) {
+            throw error;
+          }
+        },
+      );
+    },
+  }) as (...args: unknown[]) => CompiledGraph;
+}
+
 /**
  * Directly instruments a StateGraph instance to add tracing spans
  *

packages/node/src/integrations/tracing/langgraph/instrumentation.ts

@@ -6,7 +6,7 @@ import {
   InstrumentationNodeModuleFile,
 } from '@opentelemetry/instrumentation';
 import type { CompiledGraph, LangGraphOptions } from '@sentry/core';
-import { getClient, instrumentStateGraphCompile, SDK_VERSION } from '@sentry/core';
+import { getClient, instrumentStateGraphCompile, instrumentCreateReactAgent, SDK_VERSION } from '@sentry/core';
 
 const supportedVersions = ['>=0.0.0 <2.0.0'];
 
@@ -50,6 +50,16 @@ export class SentryLangGraphInstrumentation extends InstrumentationBase<LangGrap
           this._patch.bind(this),
           exports => exports,
         ),
+        new InstrumentationNodeModuleFile(
+          /**
+           * Patch the prebuilt subpath exports for CJS.
+           * The @langchain/langgraph/prebuilt entry point re-exports from dist/prebuilt/index.cjs
+           */
+          '@langchain/langgraph/dist/prebuilt/index.cjs',
+          supportedVersions,
+          this._patch.bind(this),
+          exports => exports,
+        ),
       ],
     );
     return module;
@@ -83,6 +93,26 @@ export class SentryLangGraphInstrumentation extends InstrumentationBase<LangGrap
       );
     }
 
+    // Patch createReactAgent to instrument the agent creation and invocation
+    if (exports.createReactAgent && typeof exports.createReactAgent === 'function') {
+      exports.createReactAgent = instrumentCreateReactAgent(
+        exports.createReactAgent as (...args: unknown[]) => CompiledGraph,
+        options,
+      );
+     /*
+      const originalCreateReactAgent = exports.createReactAgent;
+      Object.defineProperty(exports, 'createReactAgent', {
+        value: instrumentCreateReactAgent(
+          originalCreateReactAgent as (...args: unknown[]) => CompiledGraph,
+          options,
+        ),
+        writable: true,
+        enumerable: true,
+        configurable: true,
+      });
+      */
+    }
+
     return exports;
   }
 }