@depup/sentry__node 10.44.0-depup.0

package/build/cjs/integrations/tracing/knex.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"knex.js","sources":["../../../../src/integrations/tracing/knex.ts"],"sourcesContent":["import { KnexInstrumentation } from '@opentelemetry/instrumentation-knex';\nimport type { IntegrationFn } from '@sentry/core';\nimport { defineIntegration, SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN, spanToJSON } from '@sentry/core';\nimport { generateInstrumentOnce, instrumentWhenWrapped } from '@sentry/node-core';\n\nconst INTEGRATION_NAME = 'Knex';\n\nexport const instrumentKnex = generateInstrumentOnce(\n  INTEGRATION_NAME,\n  () => new KnexInstrumentation({ requireParentSpan: true }),\n);\n\nconst _knexIntegration = (() => {\n  let instrumentationWrappedCallback: undefined | ((callback: () => void) => void);\n\n  return {\n    name: INTEGRATION_NAME,\n    setupOnce() {\n      const instrumentation = instrumentKnex();\n      instrumentationWrappedCallback = instrumentWhenWrapped(instrumentation);\n    },\n\n    setup(client) {\n      instrumentationWrappedCallback?.(() =>\n        client.on('spanStart', span => {\n          const { data } = spanToJSON(span);\n          // knex.version is always set in the span data\n          // https://github.com/open-telemetry/opentelemetry-js-contrib/blob/0309caeafc44ac9cb13a3345b790b01b76d0497d/plugins/node/opentelemetry-instrumentation-knex/src/instrumentation.ts#L138\n          if ('knex.version' in data) {\n            span.setAttribute(SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN, 'auto.db.otel.knex');\n          }\n        }),\n      );\n    },\n  };\n}) satisfies IntegrationFn;\n\n/**\n * Knex integration\n *\n * Capture tracing data for [Knex](https://knexjs.org/).\n *\n * @example\n * ```javascript\n * import * as Sentry from '@sentry/node';\n *\n * Sentry.init({\n *  integrations: [Sentry.knexIntegration()],\n * });\n * ```\n */\nexport const knexIntegration = defineIntegration(_knexIntegration);\n"],"names":["generateInstrumentOnce","KnexInstrumentation","instrumentWhenWrapped","spanToJSON","SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN","defineIntegration"],"mappings":";;;;;;AAKA,MAAM,gBAAA,GAAmB,MAAM;;AAExB,MAAM,cAAA,GAAiBA,+BAAsB;AACpD,EAAE,gBAAgB;AAClB,EAAE,MAAM,IAAIC,uCAAmB,CAAC,EAAE,iBAAiB,EAAE,IAAA,EAAM,CAAC;AAC5D;;AAEA,MAAM,gBAAA,IAAoB,MAAM;AAChC,EAAE,IAAI,8BAA8B;;AAEpC,EAAE,OAAO;AACT,IAAI,IAAI,EAAE,gBAAgB;AAC1B,IAAI,SAAS,GAAG;AAChB,MAAM,MAAM,eAAA,GAAkB,cAAc,EAAE;AAC9C,MAAM,8BAAA,GAAiCC,8BAAqB,CAAC,eAAe,CAAC;AAC7E,IAAI,CAAC;;AAEL,IAAI,KAAK,CAAC,MAAM,EAAE;AAClB,MAAM,8BAA8B,GAAG;AACvC,QAAQ,MAAM,CAAC,EAAE,CAAC,WAAW,EAAE,QAAQ;AACvC,UAAU,MAAM,EAAE,IAAA,EAAK,GAAIC,eAAU,CAAC,IAAI,CAAC;AAC3C;AACA;AACA,UAAU,IAAI,cAAA,IAAkB,IAAI,EAAE;AACtC,YAAY,IAAI,CAAC,YAAY,CAACC,qCAAgC,EAAE,mBAAmB,CAAC;AACpF,UAAU;AACV,QAAQ,CAAC,CAAC;AACV,OAAO;AACP,IAAI,CAAC;AACL,GAAG;AACH,CAAC,CAAA;;AAED;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;MACa,eAAA,GAAkBC,sBAAiB,CAAC,gBAAgB;;;;;"}

package/build/cjs/integrations/tracing/koa.js

@@ -0,0 +1,138 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const instrumentationKoa = require('@opentelemetry/instrumentation-koa');
+const semanticConventions = require('@opentelemetry/semantic-conventions');
+const core = require('@sentry/core');
+const nodeCore = require('@sentry/node-core');
+const debugBuild = require('../../debug-build.js');
+
+const INTEGRATION_NAME = 'Koa';
+
+const instrumentKoa = nodeCore.generateInstrumentOnce(
+  INTEGRATION_NAME,
+  instrumentationKoa.KoaInstrumentation,
+  (options = {}) => {
+    return {
+      ignoreLayersType: options.ignoreLayersType ,
+      requestHook(span, info) {
+        nodeCore.addOriginToSpan(span, 'auto.http.otel.koa');
+
+        const attributes = core.spanToJSON(span).data;
+
+        // this is one of: middleware, router
+        const type = attributes['koa.type'];
+        if (type) {
+          span.setAttribute(core.SEMANTIC_ATTRIBUTE_SENTRY_OP, `${type}.koa`);
+        }
+
+        // Also update the name
+        const name = attributes['koa.name'];
+        if (typeof name === 'string') {
+          // Somehow, name is sometimes `''` for middleware spans
+          // See: https://github.com/open-telemetry/opentelemetry-js-contrib/issues/2220
+          span.updateName(name || '< unknown >');
+        }
+
+        if (core.getIsolationScope() === core.getDefaultIsolationScope()) {
+          debugBuild.DEBUG_BUILD && core.debug.warn('Isolation scope is default isolation scope - skipping setting transactionName');
+          return;
+        }
+        const route = attributes[semanticConventions.ATTR_HTTP_ROUTE];
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+        const method = info.context?.request?.method?.toUpperCase() || 'GET';
+        if (route) {
+          core.getIsolationScope().setTransactionName(`${method} ${route}`);
+        }
+      },
+    } ;
+  },
+);
+
+const _koaIntegration = ((options = {}) => {
+  return {
+    name: INTEGRATION_NAME,
+    setupOnce() {
+      instrumentKoa(options);
+    },
+  };
+}) ;
+
+/**
+ * Adds Sentry tracing instrumentation for [Koa](https://koajs.com/).
+ *
+ * If you also want to capture errors, you need to call `setupKoaErrorHandler(app)` after you set up your Koa server.
+ *
+ * For more information, see the [koa documentation](https://docs.sentry.io/platforms/javascript/guides/koa/).
+ *
+ * @param {KoaOptions} options Configuration options for the Koa integration.
+ *
+ * @example
+ * ```javascript
+ * const Sentry = require('@sentry/node');
+ *
+ * Sentry.init({
+ *   integrations: [Sentry.koaIntegration()],
+ * })
+ * ```
+ *
+ * @example
+ * ```javascript
+ * // To ignore middleware spans
+ * const Sentry = require('@sentry/node');
+ *
+ * Sentry.init({
+ *   integrations: [
+ *     Sentry.koaIntegration({
+ *       ignoreLayersType: ['middleware']
+ *     })
+ *   ],
+ * })
+ * ```
+ */
+const koaIntegration = core.defineIntegration(_koaIntegration);
+
+/**
+ * Add an Koa error handler to capture errors to Sentry.
+ *
+ * The error handler must be before any other middleware and after all controllers.
+ *
+ * @param app The Express instances
+ * @param options {ExpressHandlerOptions} Configuration options for the handler
+ *
+ * @example
+ * ```javascript
+ * const Sentry = require('@sentry/node');
+ * const Koa = require("koa");
+ *
+ * const app = new Koa();
+ *
+ * Sentry.setupKoaErrorHandler(app);
+ *
+ * // Add your routes, etc.
+ *
+ * app.listen(3000);
+ * ```
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+const setupKoaErrorHandler = (app) => {
+  app.use(async (ctx, next) => {
+    try {
+      await next();
+    } catch (error) {
+      core.captureException(error, {
+        mechanism: {
+          handled: false,
+          type: 'auto.middleware.koa',
+        },
+      });
+      throw error;
+    }
+  });
+
+  nodeCore.ensureIsWrapped(app.use, 'koa');
+};
+
+exports.instrumentKoa = instrumentKoa;
+exports.koaIntegration = koaIntegration;
+exports.setupKoaErrorHandler = setupKoaErrorHandler;
+//# sourceMappingURL=koa.js.map

package/build/cjs/integrations/tracing/koa.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"koa.js","sources":["../../../../src/integrations/tracing/koa.ts"],"sourcesContent":["import type { KoaInstrumentationConfig, KoaLayerType } from '@opentelemetry/instrumentation-koa';\nimport { KoaInstrumentation } from '@opentelemetry/instrumentation-koa';\nimport { ATTR_HTTP_ROUTE } from '@opentelemetry/semantic-conventions';\nimport type { IntegrationFn } from '@sentry/core';\nimport {\n  captureException,\n  debug,\n  defineIntegration,\n  getDefaultIsolationScope,\n  getIsolationScope,\n  SEMANTIC_ATTRIBUTE_SENTRY_OP,\n  spanToJSON,\n} from '@sentry/core';\nimport { addOriginToSpan, ensureIsWrapped, generateInstrumentOnce } from '@sentry/node-core';\nimport { DEBUG_BUILD } from '../../debug-build';\n\ninterface KoaOptions {\n  /**\n   * Ignore layers of specified types\n   */\n  ignoreLayersType?: Array<'middleware' | 'router'>;\n}\n\nconst INTEGRATION_NAME = 'Koa';\n\nexport const instrumentKoa = generateInstrumentOnce(\n  INTEGRATION_NAME,\n  KoaInstrumentation,\n  (options: KoaOptions = {}) => {\n    return {\n      ignoreLayersType: options.ignoreLayersType as KoaLayerType[],\n      requestHook(span, info) {\n        addOriginToSpan(span, 'auto.http.otel.koa');\n\n        const attributes = spanToJSON(span).data;\n\n        // this is one of: middleware, router\n        const type = attributes['koa.type'];\n        if (type) {\n          span.setAttribute(SEMANTIC_ATTRIBUTE_SENTRY_OP, `${type}.koa`);\n        }\n\n        // Also update the name\n        const name = attributes['koa.name'];\n        if (typeof name === 'string') {\n          // Somehow, name is sometimes `''` for middleware spans\n          // See: https://github.com/open-telemetry/opentelemetry-js-contrib/issues/2220\n          span.updateName(name || '< unknown >');\n        }\n\n        if (getIsolationScope() === getDefaultIsolationScope()) {\n          DEBUG_BUILD && debug.warn('Isolation scope is default isolation scope - skipping setting transactionName');\n          return;\n        }\n        const route = attributes[ATTR_HTTP_ROUTE];\n        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n        const method = info.context?.request?.method?.toUpperCase() || 'GET';\n        if (route) {\n          getIsolationScope().setTransactionName(`${method} ${route}`);\n        }\n      },\n    } satisfies KoaInstrumentationConfig;\n  },\n);\n\nconst _koaIntegration = ((options: KoaOptions = {}) => {\n  return {\n    name: INTEGRATION_NAME,\n    setupOnce() {\n      instrumentKoa(options);\n    },\n  };\n}) satisfies IntegrationFn;\n\n/**\n * Adds Sentry tracing instrumentation for [Koa](https://koajs.com/).\n *\n * If you also want to capture errors, you need to call `setupKoaErrorHandler(app)` after you set up your Koa server.\n *\n * For more information, see the [koa documentation](https://docs.sentry.io/platforms/javascript/guides/koa/).\n *\n * @param {KoaOptions} options Configuration options for the Koa integration.\n *\n * @example\n * ```javascript\n * const Sentry = require('@sentry/node');\n *\n * Sentry.init({\n *   integrations: [Sentry.koaIntegration()],\n * })\n * ```\n *\n * @example\n * ```javascript\n * // To ignore middleware spans\n * const Sentry = require('@sentry/node');\n *\n * Sentry.init({\n *   integrations: [\n *     Sentry.koaIntegration({\n *       ignoreLayersType: ['middleware']\n *     })\n *   ],\n * })\n * ```\n */\nexport const koaIntegration = defineIntegration(_koaIntegration);\n\n/**\n * Add an Koa error handler to capture errors to Sentry.\n *\n * The error handler must be before any other middleware and after all controllers.\n *\n * @param app The Express instances\n * @param options {ExpressHandlerOptions} Configuration options for the handler\n *\n * @example\n * ```javascript\n * const Sentry = require('@sentry/node');\n * const Koa = require(\"koa\");\n *\n * const app = new Koa();\n *\n * Sentry.setupKoaErrorHandler(app);\n *\n * // Add your routes, etc.\n *\n * app.listen(3000);\n * ```\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport const setupKoaErrorHandler = (app: { use: (arg0: (ctx: any, next: any) => Promise<void>) => void }): void => {\n  app.use(async (ctx, next) => {\n    try {\n      await next();\n    } catch (error) {\n      captureException(error, {\n        mechanism: {\n          handled: false,\n          type: 'auto.middleware.koa',\n        },\n      });\n      throw error;\n    }\n  });\n\n  ensureIsWrapped(app.use, 'koa');\n};\n"],"names":["generateInstrumentOnce","KoaInstrumentation","addOriginToSpan","spanToJSON","SEMANTIC_ATTRIBUTE_SENTRY_OP","getIsolationScope","getDefaultIsolationScope","DEBUG_BUILD","debug","ATTR_HTTP_ROUTE","defineIntegration","captureException","ensureIsWrapped"],"mappings":";;;;;;;;AAuBA,MAAM,gBAAA,GAAmB,KAAK;;AAEvB,MAAM,aAAA,GAAgBA,+BAAsB;AACnD,EAAE,gBAAgB;AAClB,EAAEC,qCAAkB;AACpB,EAAE,CAAC,OAAO,GAAe,EAAE,KAAK;AAChC,IAAI,OAAO;AACX,MAAM,gBAAgB,EAAE,OAAO,CAAC,gBAAA;AAChC,MAAM,WAAW,CAAC,IAAI,EAAE,IAAI,EAAE;AAC9B,QAAQC,wBAAe,CAAC,IAAI,EAAE,oBAAoB,CAAC;;AAEnD,QAAQ,MAAM,aAAaC,eAAU,CAAC,IAAI,CAAC,CAAC,IAAI;;AAEhD;AACA,QAAQ,MAAM,IAAA,GAAO,UAAU,CAAC,UAAU,CAAC;AAC3C,QAAQ,IAAI,IAAI,EAAE;AAClB,UAAU,IAAI,CAAC,YAAY,CAACC,iCAA4B,EAAE,CAAC,EAAA,IAAA,CAAA,IAAA,CAAA,CAAA;AACA,QAAA;;AAEA;AACA,QAAA,MAAA,IAAA,GAAA,UAAA,CAAA,UAAA,CAAA;AACA,QAAA,IAAA,OAAA,IAAA,KAAA,QAAA,EAAA;AACA;AACA;AACA,UAAA,IAAA,CAAA,UAAA,CAAA,IAAA,IAAA,aAAA,CAAA;AACA,QAAA;;AAEA,QAAA,IAAAC,sBAAA,EAAA,KAAAC,6BAAA,EAAA,EAAA;AACA,UAAAC,sBAAA,IAAAC,UAAA,CAAA,IAAA,CAAA,+EAAA,CAAA;AACA,UAAA;AACA,QAAA;AACA,QAAA,MAAA,KAAA,GAAA,UAAA,CAAAC,mCAAA,CAAA;AACA;AACA,QAAA,MAAA,MAAA,GAAA,IAAA,CAAA,OAAA,EAAA,OAAA,EAAA,MAAA,EAAA,WAAA,EAAA,IAAA,KAAA;AACA,QAAA,IAAA,KAAA,EAAA;AACA,UAAAJ,sBAAA,EAAA,CAAA,kBAAA,CAAA,CAAA,EAAA,MAAA,CAAA,CAAA,EAAA,KAAA,CAAA,CAAA,CAAA;AACA,QAAA;AACA,MAAA,CAAA;AACA,KAAA;AACA,EAAA,CAAA;AACA;;AAEA,MAAA,eAAA,IAAA,CAAA,OAAA,GAAA,EAAA,KAAA;AACA,EAAA,OAAA;AACA,IAAA,IAAA,EAAA,gBAAA;AACA,IAAA,SAAA,GAAA;AACA,MAAA,aAAA,CAAA,OAAA,CAAA;AACA,IAAA,CAAA;AACA,GAAA;AACA,CAAA,CAAA;;AAEA;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,MAAA,cAAA,GAAAK,sBAAA,CAAA,eAAA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAA,oBAAA,GAAA,CAAA,GAAA,KAAA;AACA,EAAA,GAAA,CAAA,GAAA,CAAA,OAAA,GAAA,EAAA,IAAA,KAAA;AACA,IAAA,IAAA;AACA,MAAA,MAAA,IAAA,EAAA;AACA,IAAA,CAAA,CAAA,OAAA,KAAA,EAAA;AACA,MAAAC,qBAAA,CAAA,KAAA,EAAA;AACA,QAAA,SAAA,EAAA;AACA,UAAA,OAAA,EAAA,KAAA;AACA,UAAA,IAAA,EAAA,qBAAA;AACA,SAAA;AACA,OAAA,CAAA;AACA,MAAA,MAAA,KAAA;AACA,IAAA;AACA,EAAA,CAAA,CAAA;;AAEA,EAAAC,wBAAA,CAAA,GAAA,CAAA,GAAA,EAAA,KAAA,CAAA;AACA;;;;;;"}

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

@@ -0,0 +1,116 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const core = require('@sentry/core');
+const nodeCore = require('@sentry/node-core');
+const instrumentation = require('./instrumentation.js');
+
+const instrumentLangChain = nodeCore.generateInstrumentOnce(
+  core.LANGCHAIN_INTEGRATION_NAME,
+  options => new instrumentation.SentryLangChainInstrumentation(options),
+);
+
+const _langChainIntegration = ((options = {}) => {
+  return {
+    name: core.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
+ * - Chain: start, end, error
+ * - Tool: start, end, error
+ *
+ */
+const langChainIntegration = core.defineIntegration(_langChainIntegration);
+
+exports.instrumentLangChain = instrumentLangChain;
+exports.langChainIntegration = langChainIntegration;
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +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\n * - Chain: start, end, error\n * - Tool: start, end, error\n *\n */\nexport const langChainIntegration = defineIntegration(_langChainIntegration);\n"],"names":["generateInstrumentOnce","LANGCHAIN_INTEGRATION_NAME","SentryLangChainInstrumentation","defineIntegration"],"mappings":";;;;;;AAKO,MAAM,mBAAA,GAAsBA,+BAAsB;AACzD,EAAEC,+BAA0B;AAC5B,EAAE,WAAW,IAAIC,8CAA8B,CAAC,OAAO,CAAC;AACxD;;AAEA,MAAM,qBAAA,IAAyB,CAAC,OAAO,GAAqB,EAAE,KAAK;AACnE,EAAE,OAAO;AACT,IAAI,IAAI,EAAED,+BAA0B;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;MACa,oBAAA,GAAuBE,sBAAiB,CAAC,qBAAqB;;;;;"}

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

@@ -0,0 +1,220 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const instrumentation = require('@opentelemetry/instrumentation');
+const core = require('@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,
+) {
+  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)) {
+        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
+      return Reflect.apply(target, thisArg, args);
+    },
+  }) ;
+}
+
+/**
+ * Sentry LangChain instrumentation using OpenTelemetry.
+ */
+class SentryLangChainInstrumentation extends instrumentation.InstrumentationBase {
+   constructor(config = {}) {
+    super('@sentry/instrumentation-langchain', core.SDK_VERSION, config);
+  }
+
+  /**
+   * Initializes the instrumentation by defining the modules to be patched.
+   * We patch the BaseChatModel class methods to inject callbacks
+   *
+   * We hook into provider packages (@langchain/anthropic, @langchain/openai, etc.)
+   * because @langchain/core is often bundled and not loaded as a separate module
+   */
+   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',
+    ];
+
+    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 instrumentation.InstrumentationNodeModuleDefinition(
+          packageName,
+          supportedVersions,
+          this._patch.bind(this),
+          exports$1 => exports$1,
+          [
+            new instrumentation.InstrumentationNodeModuleFile(
+              `${packageName}/dist/index.cjs`,
+              supportedVersions,
+              this._patch.bind(this),
+              exports$1 => exports$1,
+            ),
+          ],
+        ),
+      );
+    }
+
+    // Hook into main 'langchain' package to catch initChatModel (v1+)
+    modules.push(
+      new instrumentation.InstrumentationNodeModuleDefinition(
+        'langchain',
+        supportedVersions,
+        this._patch.bind(this),
+        exports$1 => exports$1,
+        [
+          // To catch the CJS build that contains ConfigurableModel / initChatModel for v1
+          new instrumentation.InstrumentationNodeModuleFile(
+            'langchain/dist/chat_models/universal.cjs',
+            supportedVersions,
+            this._patch.bind(this),
+            exports$1 => exports$1,
+          ),
+        ],
+      ),
+    );
+
+    return modules;
+  }
+
+  /**
+   * Core patch logic - patches chat model methods to inject Sentry callbacks
+   * This is called when a LangChain provider package is loaded
+   */
+   _patch(exports$1) {
+    // Skip AI provider wrapping now that LangChain is actually being used
+    // This prevents duplicate spans from Anthropic/OpenAI/GoogleGenAI standalone integrations
+    core._INTERNAL_skipAiProviderWrapping([
+      core.OPENAI_INTEGRATION_NAME,
+      core.ANTHROPIC_AI_INTEGRATION_NAME,
+      core.GOOGLE_GENAI_INTEGRATION_NAME,
+    ]);
+
+    // Create a shared handler instance
+    const sentryHandler = core.createLangChainCallbackHandler(this.getConfig());
+
+    // Patch Runnable methods to inject callbacks at request time
+    // This directly manipulates options.callbacks that LangChain uses
+    this._patchRunnableMethods(exports$1, sentryHandler);
+
+    return exports$1;
+  }
+
+  /**
+   * 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$1, sentryHandler) {
+    // Known chat model class names for each provider
+    const knownChatModelNames = [
+      'ChatAnthropic',
+      'ChatOpenAI',
+      'ChatGoogleGenerativeAI',
+      'ChatMistralAI',
+      'ChatVertexAI',
+      'ChatGroq',
+      'ConfigurableModel',
+    ];
+
+    const exportsToPatch = (exports$1.universal_exports ?? exports$1) ;
+
+    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)
+    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'] ;
+
+    for (const methodName of methodsToPatch) {
+      const method = targetProto[methodName];
+      if (typeof method === 'function') {
+        targetProto[methodName] = wrapRunnableMethod(
+          method ,
+          sentryHandler);
+      }
+    }
+  }
+}
+
+exports.SentryLangChainInstrumentation = SentryLangChainInstrumentation;
+//# sourceMappingURL=instrumentation.js.map

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

@@ -0,0 +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  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 methods to inject Sentry callbacks\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    // Create a shared handler instance\n    const sentryHandler = createLangChainCallbackHandler(this.getConfig());\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    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"],"names":["InstrumentationBase","SDK_VERSION","InstrumentationNodeModuleDefinition","exports","InstrumentationNodeModuleFile","_INTERNAL_skipAiProviderWrapping","OPENAI_INTEGRATION_NAME","ANTHROPIC_AI_INTEGRATION_NAME","GOOGLE_GENAI_INTEGRATION_NAME","createLangChainCallbackHandler"],"mappings":"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"}

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

@@ -0,0 +1,93 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const core = require('@sentry/core');
+const nodeCore = require('@sentry/node-core');
+const instrumentation = require('./instrumentation.js');
+
+const instrumentLangGraph = nodeCore.generateInstrumentOnce(
+  core.LANGGRAPH_INTEGRATION_NAME,
+  options => new instrumentation.SentryLangGraphInstrumentation(options),
+);
+
+const _langGraphIntegration = ((options = {}) => {
+  return {
+    name: core.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 = core.defineIntegration(_langGraphIntegration);
+
+exports.instrumentLangGraph = instrumentLangGraph;
+exports.langGraphIntegration = langGraphIntegration;
+//# sourceMappingURL=index.js.map

package/build/cjs/integrations/tracing/langgraph/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":["../../../../../src/integrations/tracing/langgraph/index.ts"],"sourcesContent":["import type { IntegrationFn, LangGraphOptions } from '@sentry/core';\nimport { defineIntegration, LANGGRAPH_INTEGRATION_NAME } from '@sentry/core';\nimport { generateInstrumentOnce } from '@sentry/node-core';\nimport { SentryLangGraphInstrumentation } from './instrumentation';\n\nexport const instrumentLangGraph = generateInstrumentOnce<LangGraphOptions>(\n  LANGGRAPH_INTEGRATION_NAME,\n  options => new SentryLangGraphInstrumentation(options),\n);\n\nconst _langGraphIntegration = ((options: LangGraphOptions = {}) => {\n  return {\n    name: LANGGRAPH_INTEGRATION_NAME,\n    setupOnce() {\n      instrumentLangGraph(options);\n    },\n  };\n}) satisfies IntegrationFn;\n\n/**\n * Adds Sentry tracing instrumentation for LangGraph.\n *\n * This integration is enabled by default.\n *\n * When configured, this integration automatically instruments LangGraph StateGraph and compiled graph instances\n * to capture telemetry data following OpenTelemetry Semantic Conventions for Generative AI.\n *\n * @example\n * ```javascript\n * import * as Sentry from '@sentry/node';\n *\n * Sentry.init({\n *   integrations: [Sentry.langGraphIntegration()],\n * });\n * ```\n *\n * ## Options\n *\n * - `recordInputs`: Whether to record input messages (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.langGraphIntegration({\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.langGraphIntegration({\n *       recordInputs: false,\n *       recordOutputs: false\n *     })\n *   ],\n * });\n * ```\n *\n * ## Captured Operations\n *\n * The integration captures the following LangGraph operations:\n * - **Agent Creation** (`StateGraph.compile()`) - Creates a `gen_ai.create_agent` span\n * - **Agent Invocation** (`CompiledGraph.invoke()`) - Creates a `gen_ai.invoke_agent` span\n *\n * ## Captured Data\n *\n * When `recordInputs` and `recordOutputs` are enabled, the integration captures:\n * - Input messages from the graph state\n * - Output messages and LLM responses\n * - Tool calls made during agent execution\n * - Agent and graph names\n * - Available tools configured in the graph\n *\n */\nexport const langGraphIntegration = defineIntegration(_langGraphIntegration);\n"],"names":["generateInstrumentOnce","LANGGRAPH_INTEGRATION_NAME","SentryLangGraphInstrumentation","defineIntegration"],"mappings":";;;;;;AAKO,MAAM,mBAAA,GAAsBA,+BAAsB;AACzD,EAAEC,+BAA0B;AAC5B,EAAE,WAAW,IAAIC,8CAA8B,CAAC,OAAO,CAAC;AACxD;;AAEA,MAAM,qBAAA,IAAyB,CAAC,OAAO,GAAqB,EAAE,KAAK;AACnE,EAAE,OAAO;AACT,IAAI,IAAI,EAAED,+BAA0B;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;MACa,oBAAA,GAAuBE,sBAAiB,CAAC,qBAAqB;;;;;"}