@sentry/node 10.53.1 → 10.54.0

package/build/esm/integrations/tracing/koa/vendored/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sources":["../../../../../../src/integrations/tracing/koa/vendored/types.ts"],"sourcesContent":["/*\n * Copyright The OpenTelemetry Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *      https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n *\n * NOTICE from the Sentry authors:\n * - Vendored from: https://github.com/open-telemetry/opentelemetry-js-contrib/tree/15ef7506553f631ea4181391e0c5725a56f0d082/packages/instrumentation-koa\n * - Upstream version: @opentelemetry/instrumentation-koa@0.66.0\n */\n/* eslint-disable */\n\nimport { Span } from '@opentelemetry/api';\nimport { InstrumentationConfig } from '@opentelemetry/instrumentation';\n\nexport enum KoaLayerType {\n  ROUTER = 'router',\n  MIDDLEWARE = 'middleware',\n}\n\n/**\n * Information about the current Koa middleware layer\n * The middleware layer type is any by default.\n * One can install koa types packages `@types/koa` and `@types/koa__router`\n * with compatible versions to the koa version used in the project\n * to get more specific types for the middleware layer property.\n *\n * Example use in a custom attribute function:\n * ```ts\n * import type { Middleware, ParameterizedContext, DefaultState } from 'koa';\n * import type { RouterParamContext } from '@koa/router';\n *\n * type KoaContext = ParameterizedContext<DefaultState, RouterParamContext>;\n * type KoaMiddleware = Middleware<DefaultState, KoaContext>;\n *\n * const koaConfig: KoaInstrumentationConfig<KoaContext, KoaMiddleware> = {\n *  requestHook: (span: Span, info: KoaRequestInfo<KoaContext, KoaMiddleware>) => {\n *   // custom typescript code that can access the typed into.middlewareLayer and info.context\n * }\n *\n */\nexport type KoaRequestInfo<KoaContextType = any, KoaMiddlewareType = any> = {\n  context: KoaContextType;\n  middlewareLayer: KoaMiddlewareType;\n  layerType: KoaLayerType;\n};\n\n/**\n * Function that can be used to add custom attributes to the current span\n * @param span - The Express middleware layer span.\n * @param context - The current KoaContext.\n */\nexport interface KoaRequestCustomAttributeFunction<KoaContextType = any, KoaMiddlewareType = any> {\n  (span: Span, info: KoaRequestInfo<KoaContextType, KoaMiddlewareType>): void;\n}\n\n/**\n * Options available for the Koa Instrumentation (see [documentation](https://github.com/open-telemetry/opentelemetry-js/tree/main/packages/opentelemetry-Instrumentation-koa#koa-Instrumentation-options))\n */\nexport interface KoaInstrumentationConfig<KoaContextType = any, KoaMiddlewareType = any> extends InstrumentationConfig {\n  /** Ignore specific layers based on their type */\n  ignoreLayersType?: KoaLayerType[];\n  /** Function for adding custom attributes to each middleware layer span */\n  requestHook?: KoaRequestCustomAttributeFunction<KoaContextType, KoaMiddlewareType>;\n}\n"],"names":["KoaLayerType"],"mappings":"AAwBO,IAAK,YAAA,qBAAAA,aAAAA,KAAL;AACL,EAAAA,cAAA,QAAA,CAAA,GAAS,QAAA;AACT,EAAAA,cAAA,YAAA,CAAA,GAAa,YAAA;AAFH,EAAA,OAAAA,aAAAA;AAAA,CAAA,EAAA,YAAA,IAAA,EAAA;;;;"}

package/build/esm/integrations/tracing/koa/vendored/utils.js

@@ -0,0 +1,30 @@
+import { KoaLayerType } from './types.js';
+import { AttributeNames } from './enums/AttributeNames.js';
+import { ATTR_HTTP_ROUTE } from '@opentelemetry/semantic-conventions';
+
+const getMiddlewareMetadata = (context, layer, isRouter, layerPath) => {
+  if (isRouter) {
+    return {
+      attributes: {
+        [AttributeNames.KOA_NAME]: layerPath?.toString(),
+        [AttributeNames.KOA_TYPE]: KoaLayerType.ROUTER,
+        [ATTR_HTTP_ROUTE]: layerPath?.toString()
+      },
+      name: context._matchedRouteName || `router - ${layerPath}`
+    };
+  } else {
+    return {
+      attributes: {
+        [AttributeNames.KOA_NAME]: layer.name ?? "middleware",
+        [AttributeNames.KOA_TYPE]: KoaLayerType.MIDDLEWARE
+      },
+      name: `middleware - ${layer.name}`
+    };
+  }
+};
+const isLayerIgnored = (type, config) => {
+  return !!(Array.isArray(config?.ignoreLayersType) && config?.ignoreLayersType?.includes(type));
+};
+
+export { getMiddlewareMetadata, isLayerIgnored };
+//# sourceMappingURL=utils.js.map

package/build/esm/integrations/tracing/koa/vendored/utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.js","sources":["../../../../../../src/integrations/tracing/koa/vendored/utils.ts"],"sourcesContent":["/*\n * Copyright The OpenTelemetry Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *      https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n *\n * NOTICE from the Sentry authors:\n * - Vendored from: https://github.com/open-telemetry/opentelemetry-js-contrib/tree/15ef7506553f631ea4181391e0c5725a56f0d082/packages/instrumentation-koa\n * - Upstream version: @opentelemetry/instrumentation-koa@0.66.0\n */\n/* eslint-disable */\n\nimport { KoaLayerType, KoaInstrumentationConfig } from './types';\nimport { KoaContext, KoaMiddleware } from './internal-types';\nimport { AttributeNames } from './enums/AttributeNames';\nimport { Attributes } from '@opentelemetry/api';\nimport { ATTR_HTTP_ROUTE } from '@opentelemetry/semantic-conventions';\n\nexport const getMiddlewareMetadata = (\n  context: KoaContext,\n  layer: KoaMiddleware,\n  isRouter: boolean,\n  layerPath?: string | RegExp,\n): {\n  attributes: Attributes;\n  name: string;\n} => {\n  if (isRouter) {\n    return {\n      attributes: {\n        [AttributeNames.KOA_NAME]: layerPath?.toString(),\n        [AttributeNames.KOA_TYPE]: KoaLayerType.ROUTER,\n        [ATTR_HTTP_ROUTE]: layerPath?.toString(),\n      },\n      name: context._matchedRouteName || `router - ${layerPath}`,\n    };\n  } else {\n    return {\n      attributes: {\n        [AttributeNames.KOA_NAME]: layer.name ?? 'middleware',\n        [AttributeNames.KOA_TYPE]: KoaLayerType.MIDDLEWARE,\n      },\n      name: `middleware - ${layer.name}`,\n    };\n  }\n};\n\n/**\n * Check whether the given request is ignored by configuration\n * @param [list] List of ignore patterns\n * @param [onException] callback for doing something when an exception has\n *     occurred\n */\nexport const isLayerIgnored = (type: KoaLayerType, config?: KoaInstrumentationConfig): boolean => {\n  return !!(Array.isArray(config?.ignoreLayersType) && config?.ignoreLayersType?.includes(type));\n};\n"],"names":[],"mappings":";;;;AA2BO,MAAM,qBAAA,GAAwB,CACnC,OAAA,EACA,KAAA,EACA,UACA,SAAA,KAIG;AACH,EAAA,IAAI,QAAA,EAAU;AACZ,IAAA,OAAO;AAAA,MACL,UAAA,EAAY;AAAA,QACV,CAAC,cAAA,CAAe,QAAQ,GAAG,WAAW,QAAA,EAAS;AAAA,QAC/C,CAAC,cAAA,CAAe,QAAQ,GAAG,YAAA,CAAa,MAAA;AAAA,QACxC,CAAC,eAAe,GAAG,SAAA,EAAW,QAAA;AAAS,OACzC;AAAA,MACA,IAAA,EAAM,OAAA,CAAQ,iBAAA,IAAqB,CAAA,SAAA,EAAY,SAAS,CAAA;AAAA,KAC1D;AAAA,EACF,CAAA,MAAO;AACL,IAAA,OAAO;AAAA,MACL,UAAA,EAAY;AAAA,QACV,CAAC,cAAA,CAAe,QAAQ,GAAG,MAAM,IAAA,IAAQ,YAAA;AAAA,QACzC,CAAC,cAAA,CAAe,QAAQ,GAAG,YAAA,CAAa;AAAA,OAC1C;AAAA,MACA,IAAA,EAAM,CAAA,aAAA,EAAgB,KAAA,CAAM,IAAI,CAAA;AAAA,KAClC;AAAA,EACF;AACF;AAQO,MAAM,cAAA,GAAiB,CAAC,IAAA,EAAoB,MAAA,KAA+C;AAChG,EAAA,OAAO,CAAC,EAAE,KAAA,CAAM,OAAA,CAAQ,MAAA,EAAQ,gBAAgB,CAAA,IAAK,MAAA,EAAQ,gBAAA,EAAkB,QAAA,CAAS,IAAI,CAAA,CAAA;AAC9F;;;;"}

package/build/esm/integrations/tracing/langchain/index.js

@@ -4,110 +4,16 @@ import { SentryLangChainInstrumentation } from './instrumentation.js';
 
 const instrumentLangChain = generateInstrumentOnce(
   LANGCHAIN_INTEGRATION_NAME,
-  options => new SentryLangChainInstrumentation(options),
+  (options) => new SentryLangChainInstrumentation(options)
 );
-
 const _langChainIntegration = ((options = {}) => {
   return {
     name: LANGCHAIN_INTEGRATION_NAME,
     setupOnce() {
       instrumentLangChain(options);
-    },
+    }
   };
-}) ;
-
-/**
- * Adds Sentry tracing instrumentation for LangChain.
- *
- * This integration is enabled by default.
- *
- * When configured, this integration automatically instruments LangChain runnable instances
- * to capture telemetry data by injecting Sentry callback handlers into all LangChain calls.
- *
- * **Important:** This integration automatically skips wrapping the OpenAI, Anthropic, and Google GenAI
- * providers to prevent duplicate spans when using LangChain with these AI providers.
- * LangChain handles the instrumentation for all underlying AI providers.
- *
- * @example
- * ```javascript
- * import * as Sentry from '@sentry/node';
- * import { ChatOpenAI } from '@langchain/openai';
- *
- * Sentry.init({
- *   integrations: [Sentry.langChainIntegration()],
- *   sendDefaultPii: true, // Enable to record inputs/outputs
- * });
- *
- * // LangChain calls are automatically instrumented
- * const model = new ChatOpenAI();
- * await model.invoke("What is the capital of France?");
- * ```
- *
- * ## Manual Callback Handler
- *
- * You can also manually add the Sentry callback handler alongside other callbacks:
- *
- * @example
- * ```javascript
- * import * as Sentry from '@sentry/node';
- * import { ChatOpenAI } from '@langchain/openai';
- *
- * const sentryHandler = Sentry.createLangChainCallbackHandler({
- *   recordInputs: true,
- *   recordOutputs: true
- * });
- *
- * const model = new ChatOpenAI();
- * await model.invoke(
- *   "What is the capital of France?",
- *   { callbacks: [sentryHandler, myOtherCallback] }
- * );
- * ```
- *
- * ## Options
- *
- * - `recordInputs`: Whether to record input messages/prompts (default: respects `sendDefaultPii` client option)
- * - `recordOutputs`: Whether to record response text (default: respects `sendDefaultPii` client option)
- *
- * ### Default Behavior
- *
- * By default, the integration will:
- * - Record inputs and outputs ONLY if `sendDefaultPii` is set to `true` in your Sentry client options
- * - Otherwise, inputs and outputs are NOT recorded unless explicitly enabled
- *
- * @example
- * ```javascript
- * // Record inputs and outputs when sendDefaultPii is false
- * Sentry.init({
- *   integrations: [
- *     Sentry.langChainIntegration({
- *       recordInputs: true,
- *       recordOutputs: true
- *     })
- *   ],
- * });
- *
- * // Never record inputs/outputs regardless of sendDefaultPii
- * Sentry.init({
- *   sendDefaultPii: true,
- *   integrations: [
- *     Sentry.langChainIntegration({
- *       recordInputs: false,
- *       recordOutputs: false
- *     })
- *   ],
- * });
- * ```
- *
- * ## Supported Events
- *
- * The integration captures the following LangChain lifecycle events:
- * - LLM/Chat Model: start, end, error (via callbacks)
- * - Chain: start, end, error (via callbacks)
- * - Tool: start, end, error (via callbacks)
- * - Embeddings: embedQuery, embedDocuments (via direct method wrapping)
- *
- */
+});
 const langChainIntegration = defineIntegration(_langChainIntegration);
 
 export { instrumentLangChain, langChainIntegration };

package/build/esm/integrations/tracing/langchain/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sources":["../../../../../src/integrations/tracing/langchain/index.ts"],"sourcesContent":["import type { IntegrationFn, LangChainOptions } from '@sentry/core';\nimport { defineIntegration, LANGCHAIN_INTEGRATION_NAME } from '@sentry/core';\nimport { generateInstrumentOnce } from '@sentry/node-core';\nimport { SentryLangChainInstrumentation } from './instrumentation';\n\nexport const instrumentLangChain = generateInstrumentOnce<LangChainOptions>(\n  LANGCHAIN_INTEGRATION_NAME,\n  options => new SentryLangChainInstrumentation(options),\n);\n\nconst _langChainIntegration = ((options: LangChainOptions = {}) => {\n  return {\n    name: LANGCHAIN_INTEGRATION_NAME,\n    setupOnce() {\n      instrumentLangChain(options);\n    },\n  };\n}) satisfies IntegrationFn;\n\n/**\n * Adds Sentry tracing instrumentation for LangChain.\n *\n * This integration is enabled by default.\n *\n * When configured, this integration automatically instruments LangChain runnable instances\n * to capture telemetry data by injecting Sentry callback handlers into all LangChain calls.\n *\n * **Important:** This integration automatically skips wrapping the OpenAI, Anthropic, and Google GenAI\n * providers to prevent duplicate spans when using LangChain with these AI providers.\n * LangChain handles the instrumentation for all underlying AI providers.\n *\n * @example\n * ```javascript\n * import * as Sentry from '@sentry/node';\n * import { ChatOpenAI } from '@langchain/openai';\n *\n * Sentry.init({\n *   integrations: [Sentry.langChainIntegration()],\n *   sendDefaultPii: true, // Enable to record inputs/outputs\n * });\n *\n * // LangChain calls are automatically instrumented\n * const model = new ChatOpenAI();\n * await model.invoke(\"What is the capital of France?\");\n * ```\n *\n * ## Manual Callback Handler\n *\n * You can also manually add the Sentry callback handler alongside other callbacks:\n *\n * @example\n * ```javascript\n * import * as Sentry from '@sentry/node';\n * import { ChatOpenAI } from '@langchain/openai';\n *\n * const sentryHandler = Sentry.createLangChainCallbackHandler({\n *   recordInputs: true,\n *   recordOutputs: true\n * });\n *\n * const model = new ChatOpenAI();\n * await model.invoke(\n *   \"What is the capital of France?\",\n *   { callbacks: [sentryHandler, myOtherCallback] }\n * );\n * ```\n *\n * ## Options\n *\n * - `recordInputs`: Whether to record input messages/prompts (default: respects `sendDefaultPii` client option)\n * - `recordOutputs`: Whether to record response text (default: respects `sendDefaultPii` client option)\n *\n * ### Default Behavior\n *\n * By default, the integration will:\n * - Record inputs and outputs ONLY if `sendDefaultPii` is set to `true` in your Sentry client options\n * - Otherwise, inputs and outputs are NOT recorded unless explicitly enabled\n *\n * @example\n * ```javascript\n * // Record inputs and outputs when sendDefaultPii is false\n * Sentry.init({\n *   integrations: [\n *     Sentry.langChainIntegration({\n *       recordInputs: true,\n *       recordOutputs: true\n *     })\n *   ],\n * });\n *\n * // Never record inputs/outputs regardless of sendDefaultPii\n * Sentry.init({\n *   sendDefaultPii: true,\n *   integrations: [\n *     Sentry.langChainIntegration({\n *       recordInputs: false,\n *       recordOutputs: false\n *     })\n *   ],\n * });\n * ```\n *\n * ## Supported Events\n *\n * The integration captures the following LangChain lifecycle events:\n * - LLM/Chat Model: start, end, error (via callbacks)\n * - Chain: start, end, error (via callbacks)\n * - Tool: start, end, error (via callbacks)\n * - Embeddings: embedQuery, embedDocuments (via direct method wrapping)\n *\n */\nexport const langChainIntegration = defineIntegration(_langChainIntegration);\n"],"names":[],"mappings":";;;;AAKO,MAAM,mBAAA,GAAsB,sBAAsB;AACzD,EAAE,0BAA0B;AAC5B,EAAE,WAAW,IAAI,8BAA8B,CAAC,OAAO,CAAC;AACxD;;AAEA,MAAM,qBAAA,IAAyB,CAAC,OAAO,GAAqB,EAAE,KAAK;AACnE,EAAE,OAAO;AACT,IAAI,IAAI,EAAE,0BAA0B;AACpC,IAAI,SAAS,GAAG;AAChB,MAAM,mBAAmB,CAAC,OAAO,CAAC;AAClC,IAAI,CAAC;AACL,GAAG;AACH,CAAC,CAAA;;AAED;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;MACa,oBAAA,GAAuB,iBAAiB,CAAC,qBAAqB;;;;"}
+{"version":3,"file":"index.js","sources":["../../../../../src/integrations/tracing/langchain/index.ts"],"sourcesContent":["import type { IntegrationFn, LangChainOptions } from '@sentry/core';\nimport { defineIntegration, LANGCHAIN_INTEGRATION_NAME } from '@sentry/core';\nimport { generateInstrumentOnce } from '@sentry/node-core';\nimport { SentryLangChainInstrumentation } from './instrumentation';\n\nexport const instrumentLangChain = generateInstrumentOnce<LangChainOptions>(\n  LANGCHAIN_INTEGRATION_NAME,\n  options => new SentryLangChainInstrumentation(options),\n);\n\nconst _langChainIntegration = ((options: LangChainOptions = {}) => {\n  return {\n    name: LANGCHAIN_INTEGRATION_NAME,\n    setupOnce() {\n      instrumentLangChain(options);\n    },\n  };\n}) satisfies IntegrationFn;\n\n/**\n * Adds Sentry tracing instrumentation for LangChain.\n *\n * This integration is enabled by default.\n *\n * When configured, this integration automatically instruments LangChain runnable instances\n * to capture telemetry data by injecting Sentry callback handlers into all LangChain calls.\n *\n * **Important:** This integration automatically skips wrapping the OpenAI, Anthropic, and Google GenAI\n * providers to prevent duplicate spans when using LangChain with these AI providers.\n * LangChain handles the instrumentation for all underlying AI providers.\n *\n * @example\n * ```javascript\n * import * as Sentry from '@sentry/node';\n * import { ChatOpenAI } from '@langchain/openai';\n *\n * Sentry.init({\n *   integrations: [Sentry.langChainIntegration()],\n *   sendDefaultPii: true, // Enable to record inputs/outputs\n * });\n *\n * // LangChain calls are automatically instrumented\n * const model = new ChatOpenAI();\n * await model.invoke(\"What is the capital of France?\");\n * ```\n *\n * ## Manual Callback Handler\n *\n * You can also manually add the Sentry callback handler alongside other callbacks:\n *\n * @example\n * ```javascript\n * import * as Sentry from '@sentry/node';\n * import { ChatOpenAI } from '@langchain/openai';\n *\n * const sentryHandler = Sentry.createLangChainCallbackHandler({\n *   recordInputs: true,\n *   recordOutputs: true\n * });\n *\n * const model = new ChatOpenAI();\n * await model.invoke(\n *   \"What is the capital of France?\",\n *   { callbacks: [sentryHandler, myOtherCallback] }\n * );\n * ```\n *\n * ## Options\n *\n * - `recordInputs`: Whether to record input messages/prompts (default: respects `sendDefaultPii` client option)\n * - `recordOutputs`: Whether to record response text (default: respects `sendDefaultPii` client option)\n *\n * ### Default Behavior\n *\n * By default, the integration will:\n * - Record inputs and outputs ONLY if `sendDefaultPii` is set to `true` in your Sentry client options\n * - Otherwise, inputs and outputs are NOT recorded unless explicitly enabled\n *\n * @example\n * ```javascript\n * // Record inputs and outputs when sendDefaultPii is false\n * Sentry.init({\n *   integrations: [\n *     Sentry.langChainIntegration({\n *       recordInputs: true,\n *       recordOutputs: true\n *     })\n *   ],\n * });\n *\n * // Never record inputs/outputs regardless of sendDefaultPii\n * Sentry.init({\n *   sendDefaultPii: true,\n *   integrations: [\n *     Sentry.langChainIntegration({\n *       recordInputs: false,\n *       recordOutputs: false\n *     })\n *   ],\n * });\n * ```\n *\n * ## Supported Events\n *\n * The integration captures the following LangChain lifecycle events:\n * - LLM/Chat Model: start, end, error (via callbacks)\n * - Chain: start, end, error (via callbacks)\n * - Tool: start, end, error (via callbacks)\n * - Embeddings: embedQuery, embedDocuments (via direct method wrapping)\n *\n */\nexport const langChainIntegration = defineIntegration(_langChainIntegration);\n"],"names":[],"mappings":";;;;AAKO,MAAM,mBAAA,GAAsB,sBAAA;AAAA,EACjC,0BAAA;AAAA,EACA,CAAA,OAAA,KAAW,IAAI,8BAAA,CAA+B,OAAO;AACvD;AAEA,MAAM,qBAAA,IAAyB,CAAC,OAAA,GAA4B,EAAC,KAAM;AACjE,EAAA,OAAO;AAAA,IACL,IAAA,EAAM,0BAAA;AAAA,IACN,SAAA,GAAY;AACV,MAAA,mBAAA,CAAoB,OAAO,CAAA;AAAA,IAC7B;AAAA,GACF;AACF,CAAA,CAAA;AA8FO,MAAM,oBAAA,GAAuB,kBAAkB,qBAAqB;;;;"}

package/build/esm/integrations/tracing/langchain/instrumentation.js

@@ -1,81 +1,25 @@
 import { InstrumentationBase, InstrumentationNodeModuleDefinition, InstrumentationNodeModuleFile } from '@opentelemetry/instrumentation';
-import { SDK_VERSION, _INTERNAL_skipAiProviderWrapping, OPENAI_INTEGRATION_NAME, ANTHROPIC_AI_INTEGRATION_NAME, GOOGLE_GENAI_INTEGRATION_NAME, createLangChainCallbackHandler, instrumentLangChainEmbeddings } from '@sentry/core';
+import { SDK_VERSION, _INTERNAL_skipAiProviderWrapping, OPENAI_INTEGRATION_NAME, ANTHROPIC_AI_INTEGRATION_NAME, GOOGLE_GENAI_INTEGRATION_NAME, createLangChainCallbackHandler, instrumentLangChainEmbeddings, _INTERNAL_mergeLangChainCallbackHandler } from '@sentry/core';
 
-const supportedVersions = ['>=0.1.0 <2.0.0'];
-
-/**
- * Augments a callback handler list with Sentry's handler if not already present
- */
-function augmentCallbackHandlers(handlers, sentryHandler) {
-  // Handle null/undefined - return array with just our handler
-  if (!handlers) {
-    return [sentryHandler];
-  }
-
-  // If handlers is already an array
-  if (Array.isArray(handlers)) {
-    // Check if our handler is already in the list
-    if (handlers.includes(sentryHandler)) {
-      return handlers;
-    }
-    // Add our handler to the list
-    return [...handlers, sentryHandler];
-  }
-
-  // If it's a single handler object, convert to array
-  if (typeof handlers === 'object') {
-    return [handlers, sentryHandler];
-  }
-
-  // Unknown type - return original
-  return handlers;
-}
-
-/**
- * Wraps Runnable methods (invoke, stream, batch) to inject Sentry callbacks at request time
- * Uses a Proxy to intercept method calls and augment the options.callbacks
- */
-function wrapRunnableMethod(
-  originalMethod,
-  sentryHandler,
-  _methodName,
-) {
+const supportedVersions = [">=0.1.0 <2.0.0"];
+function wrapRunnableMethod(originalMethod, sentryHandler, _methodName) {
   return new Proxy(originalMethod, {
     apply(target, thisArg, args) {
-      // LangChain Runnable method signatures:
-      // invoke(input, options?) - options contains callbacks
-      // stream(input, options?) - options contains callbacks
-      // batch(inputs, options?) - options contains callbacks
-
-      // Options is typically the second argument
       const optionsIndex = 1;
-      let options = args[optionsIndex] ;
-
-      // If options don't exist or aren't an object, create them
-      if (!options || typeof options !== 'object' || Array.isArray(options)) {
+      let options = args[optionsIndex];
+      if (!options || typeof options !== "object" || Array.isArray(options)) {
         options = {};
         args[optionsIndex] = options;
       }
-
-      // Inject our callback handler into options.callbacks (request time callbacks)
-      const existingCallbacks = options.callbacks;
-      const augmentedCallbacks = augmentCallbackHandlers(existingCallbacks, sentryHandler);
-      options.callbacks = augmentedCallbacks;
-
-      // Call original method with augmented options
+      options.callbacks = _INTERNAL_mergeLangChainCallbackHandler(options.callbacks, sentryHandler);
       return Reflect.apply(target, thisArg, args);
-    },
-  }) ;
+    }
+  });
 }
-
-/**
- * Sentry LangChain instrumentation using OpenTelemetry.
- */
 class SentryLangChainInstrumentation extends InstrumentationBase {
-   constructor(config = {}) {
-    super('@sentry/instrumentation-langchain', SDK_VERSION, config);
+  constructor(config = {}) {
+    super("@sentry/instrumentation-langchain", SDK_VERSION, config);
   }
-
   /**
    * Initializes the instrumentation by defining the modules to be patched.
    * We patch the BaseChatModel class methods to inject callbacks
@@ -83,142 +27,105 @@ class SentryLangChainInstrumentation extends InstrumentationBase {
    * We hook into provider packages (@langchain/anthropic, @langchain/openai, etc.)
    * because @langchain/core is often bundled and not loaded as a separate module
    */
-   init() {
+  init() {
     const modules = [];
-
-    // Hook into common LangChain provider packages
     const providerPackages = [
-      '@langchain/anthropic',
-      '@langchain/openai',
-      '@langchain/google-genai',
-      '@langchain/mistralai',
-      '@langchain/google-vertexai',
-      '@langchain/groq',
+      "@langchain/anthropic",
+      "@langchain/openai",
+      "@langchain/google-genai",
+      "@langchain/mistralai",
+      "@langchain/google-vertexai",
+      "@langchain/groq"
     ];
-
     for (const packageName of providerPackages) {
-      // In CJS, LangChain packages re-export from dist/index.cjs files.
-      // Patching only the root module sometimes misses the real implementation or
-      // gets overwritten when that file is loaded. We add a file-level patch so that
-      // _patch runs again on the concrete implementation
       modules.push(
         new InstrumentationNodeModuleDefinition(
           packageName,
           supportedVersions,
           this._patch.bind(this),
-          exports => exports,
+          (exports) => exports,
           [
             new InstrumentationNodeModuleFile(
               `${packageName}/dist/index.cjs`,
               supportedVersions,
               this._patch.bind(this),
-              exports => exports,
-            ),
-          ],
-        ),
+              (exports) => exports
+            )
+          ]
+        )
       );
     }
-
-    // Hook into main 'langchain' package to catch initChatModel (v1+)
     modules.push(
       new InstrumentationNodeModuleDefinition(
-        'langchain',
+        "langchain",
         supportedVersions,
         this._patch.bind(this),
-        exports => exports,
+        (exports) => exports,
         [
           // To catch the CJS build that contains ConfigurableModel / initChatModel for v1
           new InstrumentationNodeModuleFile(
-            'langchain/dist/chat_models/universal.cjs',
+            "langchain/dist/chat_models/universal.cjs",
             supportedVersions,
             this._patch.bind(this),
-            exports => exports,
-          ),
-        ],
-      ),
+            (exports) => exports
+          )
+        ]
+      )
     );
-
     return modules;
   }
-
   /**
    * Core patch logic - patches chat model and embedding methods
    * This is called when a LangChain provider package is loaded
    */
-   _patch(exports) {
-    // Skip AI provider wrapping now that LangChain is actually being used
-    // This prevents duplicate spans from Anthropic/OpenAI/GoogleGenAI standalone integrations
+  _patch(exports) {
     _INTERNAL_skipAiProviderWrapping([
       OPENAI_INTEGRATION_NAME,
       ANTHROPIC_AI_INTEGRATION_NAME,
-      GOOGLE_GENAI_INTEGRATION_NAME,
+      GOOGLE_GENAI_INTEGRATION_NAME
     ]);
-
     const config = this.getConfig();
-
-    // Create a shared handler instance for chat model callbacks
     const sentryHandler = createLangChainCallbackHandler(config);
-
-    // Patch Runnable methods to inject callbacks at request time
-    // This directly manipulates options.callbacks that LangChain uses
     this._patchRunnableMethods(exports, sentryHandler);
-
-    // Patch embedding methods to create spans directly
-    // Embeddings don't use the callback system, so we wrap the methods themselves
     this._patchEmbeddingsMethods(exports, config);
-
     return exports;
   }
-
   /**
    * Patches chat model methods (invoke, stream, batch) to inject Sentry callbacks
    * Finds a chat model class from the provider package exports and patches its prototype methods
    */
-   _patchRunnableMethods(exports, sentryHandler) {
-    // Known chat model class names for each provider
+  _patchRunnableMethods(exports, sentryHandler) {
     const knownChatModelNames = [
-      'ChatAnthropic',
-      'ChatOpenAI',
-      'ChatGoogleGenerativeAI',
-      'ChatMistralAI',
-      'ChatVertexAI',
-      'ChatGroq',
-      'ConfigurableModel',
+      "ChatAnthropic",
+      "ChatOpenAI",
+      "ChatGoogleGenerativeAI",
+      "ChatMistralAI",
+      "ChatVertexAI",
+      "ChatGroq",
+      "ConfigurableModel"
     ];
-
-    const exportsToPatch = (exports.universal_exports ?? exports) ;
-
-    const chatModelClass = Object.values(exportsToPatch).find(exp => {
-      return typeof exp === 'function' && knownChatModelNames.includes(exp.name);
-    }) ;
-
+    const exportsToPatch = exports.universal_exports ?? exports;
+    const chatModelClass = Object.values(exportsToPatch).find((exp) => {
+      return typeof exp === "function" && knownChatModelNames.includes(exp.name);
+    });
     if (!chatModelClass) {
       return;
     }
-
-    // Patch directly on chatModelClass.prototype
-    const targetProto = chatModelClass.prototype ;
-
-    // Skip if already patched (both file-level and module-level hooks resolve to the same prototype)
+    const targetProto = chatModelClass.prototype;
     if (targetProto.__sentry_patched__) {
       return;
     }
     targetProto.__sentry_patched__ = true;
-
-    // Patch the methods (invoke, stream, batch)
-    // All chat model instances will inherit these patched methods
-    const methodsToPatch = ['invoke', 'stream', 'batch'] ;
-
+    const methodsToPatch = ["invoke", "stream", "batch"];
     for (const methodName of methodsToPatch) {
       const method = targetProto[methodName];
-      if (typeof method === 'function') {
+      if (typeof method === "function") {
         targetProto[methodName] = wrapRunnableMethod(
-          method ,
+          method,
           sentryHandler);
       }
     }
   }
-
   /**
    * Patches embedding class methods (embedQuery, embedDocuments) to create Sentry spans.
    *
@@ -227,22 +134,20 @@ class SentryLangChainInstrumentation extends InstrumentationBase {
    *
    * Instruments any exported class whose prototype has both embedQuery and embedDocuments as functions.
    */
-   _patchEmbeddingsMethods(exports, options) {
-    const exportsToPatch = (exports.universal_exports ?? exports) ;
-
+  _patchEmbeddingsMethods(exports, options) {
+    const exportsToPatch = exports.universal_exports ?? exports;
     for (const exp of Object.values(exportsToPatch)) {
-      if (typeof exp !== 'function' || !exp.prototype) {
+      if (typeof exp !== "function" || !exp.prototype) {
         continue;
       }
-      const proto = exp.prototype ;
-      if (typeof proto.embedQuery !== 'function' || typeof proto.embedDocuments !== 'function') {
+      const proto = exp.prototype;
+      if (typeof proto.embedQuery !== "function" || typeof proto.embedDocuments !== "function") {
         continue;
       }
       if (proto.__sentry_patched__) {
         continue;
       }
       proto.__sentry_patched__ = true;
-
       instrumentLangChainEmbeddings(proto, options);
     }
   }

package/build/esm/integrations/tracing/langchain/instrumentation.js.map

@@ -1 +1 @@
-{"version":3,"file":"instrumentation.js","sources":["../../../../../src/integrations/tracing/langchain/instrumentation.ts"],"sourcesContent":["import {\n  InstrumentationBase,\n  type InstrumentationConfig,\n  type InstrumentationModuleDefinition,\n  InstrumentationNodeModuleDefinition,\n  InstrumentationNodeModuleFile,\n} from '@opentelemetry/instrumentation';\nimport type { LangChainOptions } from '@sentry/core';\nimport {\n  _INTERNAL_skipAiProviderWrapping,\n  ANTHROPIC_AI_INTEGRATION_NAME,\n  createLangChainCallbackHandler,\n  GOOGLE_GENAI_INTEGRATION_NAME,\n  instrumentLangChainEmbeddings,\n  OPENAI_INTEGRATION_NAME,\n  SDK_VERSION,\n} from '@sentry/core';\n\nconst supportedVersions = ['>=0.1.0 <2.0.0'];\n\ntype LangChainInstrumentationOptions = InstrumentationConfig & LangChainOptions;\n\n/**\n * Represents the patched shape of LangChain provider package exports\n */\ninterface PatchedLangChainExports {\n  [key: string]: unknown;\n}\n\n/**\n * Augments a callback handler list with Sentry's handler if not already present\n */\nfunction augmentCallbackHandlers(handlers: unknown, sentryHandler: unknown): unknown {\n  // Handle null/undefined - return array with just our handler\n  if (!handlers) {\n    return [sentryHandler];\n  }\n\n  // If handlers is already an array\n  if (Array.isArray(handlers)) {\n    // Check if our handler is already in the list\n    if (handlers.includes(sentryHandler)) {\n      return handlers;\n    }\n    // Add our handler to the list\n    return [...handlers, sentryHandler];\n  }\n\n  // If it's a single handler object, convert to array\n  if (typeof handlers === 'object') {\n    return [handlers, sentryHandler];\n  }\n\n  // Unknown type - return original\n  return handlers;\n}\n\n/**\n * Wraps Runnable methods (invoke, stream, batch) to inject Sentry callbacks at request time\n * Uses a Proxy to intercept method calls and augment the options.callbacks\n */\nfunction wrapRunnableMethod(\n  originalMethod: (...args: unknown[]) => unknown,\n  sentryHandler: unknown,\n  _methodName: string,\n): (...args: unknown[]) => unknown {\n  return new Proxy(originalMethod, {\n    apply(target, thisArg, args: unknown[]): unknown {\n      // LangChain Runnable method signatures:\n      // invoke(input, options?) - options contains callbacks\n      // stream(input, options?) - options contains callbacks\n      // batch(inputs, options?) - options contains callbacks\n\n      // Options is typically the second argument\n      const optionsIndex = 1;\n      let options = args[optionsIndex] as Record<string, unknown> | undefined;\n\n      // If options don't exist or aren't an object, create them\n      if (!options || typeof options !== 'object' || Array.isArray(options)) {\n        options = {};\n        args[optionsIndex] = options;\n      }\n\n      // Inject our callback handler into options.callbacks (request time callbacks)\n      const existingCallbacks = options.callbacks;\n      const augmentedCallbacks = augmentCallbackHandlers(existingCallbacks, sentryHandler);\n      options.callbacks = augmentedCallbacks;\n\n      // Call original method with augmented options\n      return Reflect.apply(target, thisArg, args);\n    },\n  }) as (...args: unknown[]) => unknown;\n}\n\n/**\n * Sentry LangChain instrumentation using OpenTelemetry.\n */\nexport class SentryLangChainInstrumentation extends InstrumentationBase<LangChainInstrumentationOptions> {\n  public constructor(config: LangChainInstrumentationOptions = {}) {\n    super('@sentry/instrumentation-langchain', SDK_VERSION, config);\n  }\n\n  /**\n   * Initializes the instrumentation by defining the modules to be patched.\n   * We patch the BaseChatModel class methods to inject callbacks\n   *\n   * We hook into provider packages (@langchain/anthropic, @langchain/openai, etc.)\n   * because @langchain/core is often bundled and not loaded as a separate module\n   */\n  public init(): InstrumentationModuleDefinition | InstrumentationModuleDefinition[] {\n    const modules: InstrumentationModuleDefinition[] = [];\n\n    // Hook into common LangChain provider packages\n    const providerPackages = [\n      '@langchain/anthropic',\n      '@langchain/openai',\n      '@langchain/google-genai',\n      '@langchain/mistralai',\n      '@langchain/google-vertexai',\n      '@langchain/groq',\n    ];\n\n    for (const packageName of providerPackages) {\n      // In CJS, LangChain packages re-export from dist/index.cjs files.\n      // Patching only the root module sometimes misses the real implementation or\n      // gets overwritten when that file is loaded. We add a file-level patch so that\n      // _patch runs again on the concrete implementation\n      modules.push(\n        new InstrumentationNodeModuleDefinition(\n          packageName,\n          supportedVersions,\n          this._patch.bind(this),\n          exports => exports,\n          [\n            new InstrumentationNodeModuleFile(\n              `${packageName}/dist/index.cjs`,\n              supportedVersions,\n              this._patch.bind(this),\n              exports => exports,\n            ),\n          ],\n        ),\n      );\n    }\n\n    // Hook into main 'langchain' package to catch initChatModel (v1+)\n    modules.push(\n      new InstrumentationNodeModuleDefinition(\n        'langchain',\n        supportedVersions,\n        this._patch.bind(this),\n        exports => exports,\n        [\n          // To catch the CJS build that contains ConfigurableModel / initChatModel for v1\n          new InstrumentationNodeModuleFile(\n            'langchain/dist/chat_models/universal.cjs',\n            supportedVersions,\n            this._patch.bind(this),\n            exports => exports,\n          ),\n        ],\n      ),\n    );\n\n    return modules;\n  }\n\n  /**\n   * Core patch logic - patches chat model and embedding methods\n   * This is called when a LangChain provider package is loaded\n   */\n  private _patch(exports: PatchedLangChainExports): PatchedLangChainExports | void {\n    // Skip AI provider wrapping now that LangChain is actually being used\n    // This prevents duplicate spans from Anthropic/OpenAI/GoogleGenAI standalone integrations\n    _INTERNAL_skipAiProviderWrapping([\n      OPENAI_INTEGRATION_NAME,\n      ANTHROPIC_AI_INTEGRATION_NAME,\n      GOOGLE_GENAI_INTEGRATION_NAME,\n    ]);\n\n    const config = this.getConfig();\n\n    // Create a shared handler instance for chat model callbacks\n    const sentryHandler = createLangChainCallbackHandler(config);\n\n    // Patch Runnable methods to inject callbacks at request time\n    // This directly manipulates options.callbacks that LangChain uses\n    this._patchRunnableMethods(exports, sentryHandler);\n\n    // Patch embedding methods to create spans directly\n    // Embeddings don't use the callback system, so we wrap the methods themselves\n    this._patchEmbeddingsMethods(exports, config);\n\n    return exports;\n  }\n\n  /**\n   * Patches chat model methods (invoke, stream, batch) to inject Sentry callbacks\n   * Finds a chat model class from the provider package exports and patches its prototype methods\n   */\n  private _patchRunnableMethods(exports: PatchedLangChainExports, sentryHandler: unknown): void {\n    // Known chat model class names for each provider\n    const knownChatModelNames = [\n      'ChatAnthropic',\n      'ChatOpenAI',\n      'ChatGoogleGenerativeAI',\n      'ChatMistralAI',\n      'ChatVertexAI',\n      'ChatGroq',\n      'ConfigurableModel',\n    ];\n\n    const exportsToPatch = (exports.universal_exports ?? exports) as Record<string, unknown>;\n\n    const chatModelClass = Object.values(exportsToPatch).find(exp => {\n      return typeof exp === 'function' && knownChatModelNames.includes(exp.name);\n    }) as { prototype: unknown; name: string } | undefined;\n\n    if (!chatModelClass) {\n      return;\n    }\n\n    // Patch directly on chatModelClass.prototype\n    const targetProto = chatModelClass.prototype as Record<string, unknown>;\n\n    // Skip if already patched (both file-level and module-level hooks resolve to the same prototype)\n    if (targetProto.__sentry_patched__) {\n      return;\n    }\n    targetProto.__sentry_patched__ = true;\n\n    // Patch the methods (invoke, stream, batch)\n    // All chat model instances will inherit these patched methods\n    const methodsToPatch = ['invoke', 'stream', 'batch'] as const;\n\n    for (const methodName of methodsToPatch) {\n      const method = targetProto[methodName];\n      if (typeof method === 'function') {\n        targetProto[methodName] = wrapRunnableMethod(\n          method as (...args: unknown[]) => unknown,\n          sentryHandler,\n          methodName,\n        );\n      }\n    }\n  }\n\n  /**\n   * Patches embedding class methods (embedQuery, embedDocuments) to create Sentry spans.\n   *\n   * Unlike chat models which use LangChain's callback system, the Embeddings base class\n   * has no callback support. We wrap the methods directly on the prototype.\n   *\n   * Instruments any exported class whose prototype has both embedQuery and embedDocuments as functions.\n   */\n  private _patchEmbeddingsMethods(exports: PatchedLangChainExports, options: LangChainOptions): void {\n    const exportsToPatch = (exports.universal_exports ?? exports) as Record<string, unknown>;\n\n    for (const exp of Object.values(exportsToPatch)) {\n      if (typeof exp !== 'function' || !exp.prototype) {\n        continue;\n      }\n      const proto = exp.prototype as Record<string, unknown>;\n      if (typeof proto.embedQuery !== 'function' || typeof proto.embedDocuments !== 'function') {\n        continue;\n      }\n      if (proto.__sentry_patched__) {\n        continue;\n      }\n      proto.__sentry_patched__ = true;\n\n      instrumentLangChainEmbeddings(proto, options);\n    }\n  }\n}\n"],"names":[],"mappings":"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"}
+{"version":3,"file":"instrumentation.js","sources":["../../../../../src/integrations/tracing/langchain/instrumentation.ts"],"sourcesContent":["import {\n  InstrumentationBase,\n  type InstrumentationConfig,\n  type InstrumentationModuleDefinition,\n  InstrumentationNodeModuleDefinition,\n  InstrumentationNodeModuleFile,\n} from '@opentelemetry/instrumentation';\nimport type { LangChainOptions } from '@sentry/core';\nimport {\n  _INTERNAL_mergeLangChainCallbackHandler,\n  _INTERNAL_skipAiProviderWrapping,\n  ANTHROPIC_AI_INTEGRATION_NAME,\n  createLangChainCallbackHandler,\n  GOOGLE_GENAI_INTEGRATION_NAME,\n  instrumentLangChainEmbeddings,\n  OPENAI_INTEGRATION_NAME,\n  SDK_VERSION,\n} from '@sentry/core';\n\nconst supportedVersions = ['>=0.1.0 <2.0.0'];\n\ntype LangChainInstrumentationOptions = InstrumentationConfig & LangChainOptions;\n\n/**\n * Represents the patched shape of LangChain provider package exports\n */\ninterface PatchedLangChainExports {\n  [key: string]: unknown;\n}\n\n/**\n * Wraps Runnable methods (invoke, stream, batch) to inject Sentry callbacks at request time\n * Uses a Proxy to intercept method calls and augment the options.callbacks\n */\nfunction wrapRunnableMethod(\n  originalMethod: (...args: unknown[]) => unknown,\n  sentryHandler: unknown,\n  _methodName: string,\n): (...args: unknown[]) => unknown {\n  return new Proxy(originalMethod, {\n    apply(target, thisArg, args: unknown[]): unknown {\n      // LangChain Runnable method signatures:\n      // invoke(input, options?) - options contains callbacks\n      // stream(input, options?) - options contains callbacks\n      // batch(inputs, options?) - options contains callbacks\n\n      // Options is typically the second argument\n      const optionsIndex = 1;\n      let options = args[optionsIndex] as Record<string, unknown> | undefined;\n\n      // If options don't exist or aren't an object, create them\n      if (!options || typeof options !== 'object' || Array.isArray(options)) {\n        options = {};\n        args[optionsIndex] = options;\n      }\n\n      // Inject our callback handler into options.callbacks (request time callbacks)\n      options.callbacks = _INTERNAL_mergeLangChainCallbackHandler(options.callbacks, sentryHandler);\n\n      // Call original method with augmented options\n      return Reflect.apply(target, thisArg, args);\n    },\n  }) as (...args: unknown[]) => unknown;\n}\n\n/**\n * Sentry LangChain instrumentation using OpenTelemetry.\n */\nexport class SentryLangChainInstrumentation extends InstrumentationBase<LangChainInstrumentationOptions> {\n  public constructor(config: LangChainInstrumentationOptions = {}) {\n    super('@sentry/instrumentation-langchain', SDK_VERSION, config);\n  }\n\n  /**\n   * Initializes the instrumentation by defining the modules to be patched.\n   * We patch the BaseChatModel class methods to inject callbacks\n   *\n   * We hook into provider packages (@langchain/anthropic, @langchain/openai, etc.)\n   * because @langchain/core is often bundled and not loaded as a separate module\n   */\n  public init(): InstrumentationModuleDefinition | InstrumentationModuleDefinition[] {\n    const modules: InstrumentationModuleDefinition[] = [];\n\n    // Hook into common LangChain provider packages\n    const providerPackages = [\n      '@langchain/anthropic',\n      '@langchain/openai',\n      '@langchain/google-genai',\n      '@langchain/mistralai',\n      '@langchain/google-vertexai',\n      '@langchain/groq',\n    ];\n\n    for (const packageName of providerPackages) {\n      // In CJS, LangChain packages re-export from dist/index.cjs files.\n      // Patching only the root module sometimes misses the real implementation or\n      // gets overwritten when that file is loaded. We add a file-level patch so that\n      // _patch runs again on the concrete implementation\n      modules.push(\n        new InstrumentationNodeModuleDefinition(\n          packageName,\n          supportedVersions,\n          this._patch.bind(this),\n          exports => exports,\n          [\n            new InstrumentationNodeModuleFile(\n              `${packageName}/dist/index.cjs`,\n              supportedVersions,\n              this._patch.bind(this),\n              exports => exports,\n            ),\n          ],\n        ),\n      );\n    }\n\n    // Hook into main 'langchain' package to catch initChatModel (v1+)\n    modules.push(\n      new InstrumentationNodeModuleDefinition(\n        'langchain',\n        supportedVersions,\n        this._patch.bind(this),\n        exports => exports,\n        [\n          // To catch the CJS build that contains ConfigurableModel / initChatModel for v1\n          new InstrumentationNodeModuleFile(\n            'langchain/dist/chat_models/universal.cjs',\n            supportedVersions,\n            this._patch.bind(this),\n            exports => exports,\n          ),\n        ],\n      ),\n    );\n\n    return modules;\n  }\n\n  /**\n   * Core patch logic - patches chat model and embedding methods\n   * This is called when a LangChain provider package is loaded\n   */\n  private _patch(exports: PatchedLangChainExports): PatchedLangChainExports | void {\n    // Skip AI provider wrapping now that LangChain is actually being used\n    // This prevents duplicate spans from Anthropic/OpenAI/GoogleGenAI standalone integrations\n    _INTERNAL_skipAiProviderWrapping([\n      OPENAI_INTEGRATION_NAME,\n      ANTHROPIC_AI_INTEGRATION_NAME,\n      GOOGLE_GENAI_INTEGRATION_NAME,\n    ]);\n\n    const config = this.getConfig();\n\n    // Create a shared handler instance for chat model callbacks\n    const sentryHandler = createLangChainCallbackHandler(config);\n\n    // Patch Runnable methods to inject callbacks at request time\n    // This directly manipulates options.callbacks that LangChain uses\n    this._patchRunnableMethods(exports, sentryHandler);\n\n    // Patch embedding methods to create spans directly\n    // Embeddings don't use the callback system, so we wrap the methods themselves\n    this._patchEmbeddingsMethods(exports, config);\n\n    return exports;\n  }\n\n  /**\n   * Patches chat model methods (invoke, stream, batch) to inject Sentry callbacks\n   * Finds a chat model class from the provider package exports and patches its prototype methods\n   */\n  private _patchRunnableMethods(exports: PatchedLangChainExports, sentryHandler: unknown): void {\n    // Known chat model class names for each provider\n    const knownChatModelNames = [\n      'ChatAnthropic',\n      'ChatOpenAI',\n      'ChatGoogleGenerativeAI',\n      'ChatMistralAI',\n      'ChatVertexAI',\n      'ChatGroq',\n      'ConfigurableModel',\n    ];\n\n    const exportsToPatch = (exports.universal_exports ?? exports) as Record<string, unknown>;\n\n    const chatModelClass = Object.values(exportsToPatch).find(exp => {\n      return typeof exp === 'function' && knownChatModelNames.includes(exp.name);\n    }) as { prototype: unknown; name: string } | undefined;\n\n    if (!chatModelClass) {\n      return;\n    }\n\n    // Patch directly on chatModelClass.prototype\n    const targetProto = chatModelClass.prototype as Record<string, unknown>;\n\n    // Skip if already patched (both file-level and module-level hooks resolve to the same prototype)\n    if (targetProto.__sentry_patched__) {\n      return;\n    }\n    targetProto.__sentry_patched__ = true;\n\n    // Patch the methods (invoke, stream, batch)\n    // All chat model instances will inherit these patched methods\n    const methodsToPatch = ['invoke', 'stream', 'batch'] as const;\n\n    for (const methodName of methodsToPatch) {\n      const method = targetProto[methodName];\n      if (typeof method === 'function') {\n        targetProto[methodName] = wrapRunnableMethod(\n          method as (...args: unknown[]) => unknown,\n          sentryHandler,\n          methodName,\n        );\n      }\n    }\n  }\n\n  /**\n   * Patches embedding class methods (embedQuery, embedDocuments) to create Sentry spans.\n   *\n   * Unlike chat models which use LangChain's callback system, the Embeddings base class\n   * has no callback support. We wrap the methods directly on the prototype.\n   *\n   * Instruments any exported class whose prototype has both embedQuery and embedDocuments as functions.\n   */\n  private _patchEmbeddingsMethods(exports: PatchedLangChainExports, options: LangChainOptions): void {\n    const exportsToPatch = (exports.universal_exports ?? exports) as Record<string, unknown>;\n\n    for (const exp of Object.values(exportsToPatch)) {\n      if (typeof exp !== 'function' || !exp.prototype) {\n        continue;\n      }\n      const proto = exp.prototype as Record<string, unknown>;\n      if (typeof proto.embedQuery !== 'function' || typeof proto.embedDocuments !== 'function') {\n        continue;\n      }\n      if (proto.__sentry_patched__) {\n        continue;\n      }\n      proto.__sentry_patched__ = true;\n\n      instrumentLangChainEmbeddings(proto, options);\n    }\n  }\n}\n"],"names":[],"mappings":"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"}

package/build/esm/integrations/tracing/langgraph/index.js

@@ -4,86 +4,16 @@ import { SentryLangGraphInstrumentation } from './instrumentation.js';
 
 const instrumentLangGraph = generateInstrumentOnce(
   LANGGRAPH_INTEGRATION_NAME,
-  options => new SentryLangGraphInstrumentation(options),
+  (options) => new SentryLangGraphInstrumentation(options)
 );
-
 const _langGraphIntegration = ((options = {}) => {
   return {
     name: LANGGRAPH_INTEGRATION_NAME,
     setupOnce() {
       instrumentLangGraph(options);
-    },
+    }
   };
-}) ;
-
-/**
- * Adds Sentry tracing instrumentation for LangGraph.
- *
- * This integration is enabled by default.
- *
- * When configured, this integration automatically instruments LangGraph StateGraph and compiled graph instances
- * to capture telemetry data following OpenTelemetry Semantic Conventions for Generative AI.
- *
- * @example
- * ```javascript
- * import * as Sentry from '@sentry/node';
- *
- * Sentry.init({
- *   integrations: [Sentry.langGraphIntegration()],
- * });
- * ```
- *
- * ## Options
- *
- * - `recordInputs`: Whether to record input messages (default: respects `sendDefaultPii` client option)
- * - `recordOutputs`: Whether to record response text (default: respects `sendDefaultPii` client option)
- *
- * ### Default Behavior
- *
- * By default, the integration will:
- * - Record inputs and outputs ONLY if `sendDefaultPii` is set to `true` in your Sentry client options
- * - Otherwise, inputs and outputs are NOT recorded unless explicitly enabled
- *
- * @example
- * ```javascript
- * // Record inputs and outputs when sendDefaultPii is false
- * Sentry.init({
- *   integrations: [
- *     Sentry.langGraphIntegration({
- *       recordInputs: true,
- *       recordOutputs: true
- *     })
- *   ],
- * });
- *
- * // Never record inputs/outputs regardless of sendDefaultPii
- * Sentry.init({
- *   sendDefaultPii: true,
- *   integrations: [
- *     Sentry.langGraphIntegration({
- *       recordInputs: false,
- *       recordOutputs: false
- *     })
- *   ],
- * });
- * ```
- *
- * ## Captured Operations
- *
- * The integration captures the following LangGraph operations:
- * - **Agent Creation** (`StateGraph.compile()`) - Creates a `gen_ai.create_agent` span
- * - **Agent Invocation** (`CompiledGraph.invoke()`) - Creates a `gen_ai.invoke_agent` span
- *
- * ## Captured Data
- *
- * When `recordInputs` and `recordOutputs` are enabled, the integration captures:
- * - Input messages from the graph state
- * - Output messages and LLM responses
- * - Tool calls made during agent execution
- * - Agent and graph names
- * - Available tools configured in the graph
- *
- */
+});
 const langGraphIntegration = defineIntegration(_langGraphIntegration);
 
 export { instrumentLangGraph, langGraphIntegration };