@depup/sentry__node 10.44.0-depup.0

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

@@ -0,0 +1,218 @@
+import { InstrumentationBase, InstrumentationNodeModuleDefinition, InstrumentationNodeModuleFile } from '@opentelemetry/instrumentation';
+import { SDK_VERSION, _INTERNAL_skipAiProviderWrapping, OPENAI_INTEGRATION_NAME, ANTHROPIC_AI_INTEGRATION_NAME, GOOGLE_GENAI_INTEGRATION_NAME, createLangChainCallbackHandler } 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,
+) {
+  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 InstrumentationBase {
+   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
+   *
+   * 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 InstrumentationNodeModuleDefinition(
+          packageName,
+          supportedVersions,
+          this._patch.bind(this),
+          exports$1 => exports$1,
+          [
+            new 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 InstrumentationNodeModuleDefinition(
+        'langchain',
+        supportedVersions,
+        this._patch.bind(this),
+        exports$1 => exports$1,
+        [
+          // To catch the CJS build that contains ConfigurableModel / initChatModel for v1
+          new 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
+    _INTERNAL_skipAiProviderWrapping([
+      OPENAI_INTEGRATION_NAME,
+      ANTHROPIC_AI_INTEGRATION_NAME,
+      GOOGLE_GENAI_INTEGRATION_NAME,
+    ]);
+
+    // Create a shared handler instance
+    const sentryHandler = 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);
+      }
+    }
+  }
+}
+
+export { SentryLangChainInstrumentation };
+//# sourceMappingURL=instrumentation.js.map

package/build/esm/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":["exports"],"mappings":"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"}

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

@@ -0,0 +1,90 @@
+import { LANGGRAPH_INTEGRATION_NAME, defineIntegration } from '@sentry/core';
+import { generateInstrumentOnce } from '@sentry/node-core';
+import { SentryLangGraphInstrumentation } from './instrumentation.js';
+
+const instrumentLangGraph = generateInstrumentOnce(
+  LANGGRAPH_INTEGRATION_NAME,
+  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 };
+//# sourceMappingURL=index.js.map

package/build/esm/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":[],"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;MACa,oBAAA,GAAuB,iBAAiB,CAAC,qBAAqB;;;;"}

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

@@ -0,0 +1,58 @@
+import { InstrumentationBase, InstrumentationNodeModuleDefinition, InstrumentationNodeModuleFile } from '@opentelemetry/instrumentation';
+import { SDK_VERSION, instrumentLangGraph } from '@sentry/core';
+
+const supportedVersions = ['>=0.0.0 <2.0.0'];
+
+/**
+ * Sentry LangGraph instrumentation using OpenTelemetry.
+ */
+class SentryLangGraphInstrumentation extends InstrumentationBase {
+   constructor(config = {}) {
+    super('@sentry/instrumentation-langgraph', SDK_VERSION, config);
+  }
+
+  /**
+   * Initializes the instrumentation by defining the modules to be patched.
+   */
+   init() {
+    const module = new InstrumentationNodeModuleDefinition(
+      '@langchain/langgraph',
+      supportedVersions,
+      this._patch.bind(this),
+      exports$1 => exports$1,
+      [
+        new InstrumentationNodeModuleFile(
+          /**
+           * In CJS, LangGraph 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
+           */
+          '@langchain/langgraph/dist/index.cjs',
+          supportedVersions,
+          this._patch.bind(this),
+          exports$1 => exports$1,
+        ),
+      ],
+    );
+    return module;
+  }
+
+  /**
+   * Core patch logic applying instrumentation to the LangGraph module.
+   */
+   _patch(exports$1) {
+    // Patch StateGraph.compile to instrument both compile() and invoke()
+    if (exports$1.StateGraph && typeof exports$1.StateGraph === 'function') {
+      instrumentLangGraph(
+        exports$1.StateGraph.prototype ,
+        this.getConfig(),
+      );
+    }
+
+    return exports$1;
+  }
+}
+
+export { SentryLangGraphInstrumentation };
+//# sourceMappingURL=instrumentation.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"instrumentation.js","sources":["../../../../../src/integrations/tracing/langgraph/instrumentation.ts"],"sourcesContent":["import {\n  InstrumentationBase,\n  type InstrumentationConfig,\n  type InstrumentationModuleDefinition,\n  InstrumentationNodeModuleDefinition,\n  InstrumentationNodeModuleFile,\n} from '@opentelemetry/instrumentation';\nimport type { LangGraphOptions } from '@sentry/core';\nimport { instrumentLangGraph, SDK_VERSION } from '@sentry/core';\n\nconst supportedVersions = ['>=0.0.0 <2.0.0'];\n\ntype LangGraphInstrumentationOptions = InstrumentationConfig & LangGraphOptions;\n\n/**\n * Represents the patched shape of the LangGraph module export.\n */\ninterface PatchedModuleExports {\n  [key: string]: unknown;\n  StateGraph?: abstract new (...args: unknown[]) => unknown;\n}\n\n/**\n * Sentry LangGraph instrumentation using OpenTelemetry.\n */\nexport class SentryLangGraphInstrumentation extends InstrumentationBase<LangGraphInstrumentationOptions> {\n  public constructor(config: LangGraphInstrumentationOptions = {}) {\n    super('@sentry/instrumentation-langgraph', SDK_VERSION, config);\n  }\n\n  /**\n   * Initializes the instrumentation by defining the modules to be patched.\n   */\n  public init(): InstrumentationModuleDefinition {\n    const module = new InstrumentationNodeModuleDefinition(\n      '@langchain/langgraph',\n      supportedVersions,\n      this._patch.bind(this),\n      exports => exports,\n      [\n        new InstrumentationNodeModuleFile(\n          /**\n           * In CJS, LangGraph 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           */\n          '@langchain/langgraph/dist/index.cjs',\n          supportedVersions,\n          this._patch.bind(this),\n          exports => exports,\n        ),\n      ],\n    );\n    return module;\n  }\n\n  /**\n   * Core patch logic applying instrumentation to the LangGraph module.\n   */\n  private _patch(exports: PatchedModuleExports): PatchedModuleExports | void {\n    // Patch StateGraph.compile to instrument both compile() and invoke()\n    if (exports.StateGraph && typeof exports.StateGraph === 'function') {\n      instrumentLangGraph(\n        exports.StateGraph.prototype as { compile: (...args: unknown[]) => unknown },\n        this.getConfig(),\n      );\n    }\n\n    return exports;\n  }\n}\n"],"names":["exports"],"mappings":";;;AAUA,MAAM,iBAAA,GAAoB,CAAC,gBAAgB,CAAC;;AAY5C;AACA;AACA;AACO,MAAM,8BAAA,SAAuC,mBAAmB,CAAkC;AACzG,GAAS,WAAW,CAAC,MAAM,GAAoC,EAAE,EAAE;AACnE,IAAI,KAAK,CAAC,mCAAmC,EAAE,WAAW,EAAE,MAAM,CAAC;AACnE,EAAE;;AAEF;AACA;AACA;AACA,GAAS,IAAI,GAAoC;AACjD,IAAI,MAAM,MAAA,GAAS,IAAI,mCAAmC;AAC1D,MAAM,sBAAsB;AAC5B,MAAM,iBAAiB;AACvB,MAAM,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC;AAC5B,MAAMA,SAAA,IAAWA,SAAO;AACxB,MAAM;AACN,QAAQ,IAAI,6BAA6B;AACzC;AACA;AACA;AACA;AACA;AACA;AACA,UAAU,qCAAqC;AAC/C,UAAU,iBAAiB;AAC3B,UAAU,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC;AAChC,UAAUA,SAAA,IAAWA,SAAO;AAC5B,SAAS;AACT,OAAO;AACP,KAAK;AACL,IAAI,OAAO,MAAM;AACjB,EAAE;;AAEF;AACA;AACA;AACA,GAAU,MAAM,CAACA,SAAO,EAAqD;AAC7E;AACA,IAAI,IAAIA,SAAO,CAAC,UAAA,IAAc,OAAOA,SAAO,CAAC,UAAA,KAAe,UAAU,EAAE;AACxE,MAAM,mBAAmB;AACzB,QAAQA,SAAO,CAAC,UAAU,CAAC,SAAA;AAC3B,QAAQ,IAAI,CAAC,SAAS,EAAE;AACxB,OAAO;AACP,IAAI;;AAEJ,IAAI,OAAOA,SAAO;AAClB,EAAE;AACF;;;;"}

package/build/esm/integrations/tracing/lrumemoizer.js

@@ -0,0 +1,34 @@
+import { LruMemoizerInstrumentation } from '@opentelemetry/instrumentation-lru-memoizer';
+import { defineIntegration } from '@sentry/core';
+import { generateInstrumentOnce } from '@sentry/node-core';
+
+const INTEGRATION_NAME = 'LruMemoizer';
+
+const instrumentLruMemoizer = generateInstrumentOnce(INTEGRATION_NAME, () => new LruMemoizerInstrumentation());
+
+const _lruMemoizerIntegration = (() => {
+  return {
+    name: INTEGRATION_NAME,
+    setupOnce() {
+      instrumentLruMemoizer();
+    },
+  };
+}) ;
+
+/**
+ * Adds Sentry tracing instrumentation for the [lru-memoizer](https://www.npmjs.com/package/lru-memoizer) library.
+ *
+ * For more information, see the [`lruMemoizerIntegration` documentation](https://docs.sentry.io/platforms/javascript/guides/node/configuration/integrations/lrumemoizer/).
+ *
+ * @example
+ * ```javascript
+ * const Sentry = require('@sentry/node');
+ *
+ * Sentry.init({
+ *  integrations: [Sentry.lruMemoizerIntegration()],
+ * });
+ */
+const lruMemoizerIntegration = defineIntegration(_lruMemoizerIntegration);
+
+export { instrumentLruMemoizer, lruMemoizerIntegration };
+//# sourceMappingURL=lrumemoizer.js.map

package/build/esm/integrations/tracing/lrumemoizer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"lrumemoizer.js","sources":["../../../../src/integrations/tracing/lrumemoizer.ts"],"sourcesContent":["import { LruMemoizerInstrumentation } from '@opentelemetry/instrumentation-lru-memoizer';\nimport type { IntegrationFn } from '@sentry/core';\nimport { defineIntegration } from '@sentry/core';\nimport { generateInstrumentOnce } from '@sentry/node-core';\n\nconst INTEGRATION_NAME = 'LruMemoizer';\n\nexport const instrumentLruMemoizer = generateInstrumentOnce(INTEGRATION_NAME, () => new LruMemoizerInstrumentation());\n\nconst _lruMemoizerIntegration = (() => {\n  return {\n    name: INTEGRATION_NAME,\n    setupOnce() {\n      instrumentLruMemoizer();\n    },\n  };\n}) satisfies IntegrationFn;\n\n/**\n * Adds Sentry tracing instrumentation for the [lru-memoizer](https://www.npmjs.com/package/lru-memoizer) library.\n *\n * For more information, see the [`lruMemoizerIntegration` documentation](https://docs.sentry.io/platforms/javascript/guides/node/configuration/integrations/lrumemoizer/).\n *\n * @example\n * ```javascript\n * const Sentry = require('@sentry/node');\n *\n * Sentry.init({\n *  integrations: [Sentry.lruMemoizerIntegration()],\n * });\n */\nexport const lruMemoizerIntegration = defineIntegration(_lruMemoizerIntegration);\n"],"names":[],"mappings":";;;;AAKA,MAAM,gBAAA,GAAmB,aAAa;;AAE/B,MAAM,qBAAA,GAAwB,sBAAsB,CAAC,gBAAgB,EAAE,MAAM,IAAI,0BAA0B,EAAE;;AAEpH,MAAM,uBAAA,IAA2B,MAAM;AACvC,EAAE,OAAO;AACT,IAAI,IAAI,EAAE,gBAAgB;AAC1B,IAAI,SAAS,GAAG;AAChB,MAAM,qBAAqB,EAAE;AAC7B,IAAI,CAAC;AACL,GAAG;AACH,CAAC,CAAA;;AAED;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;MACa,sBAAA,GAAyB,iBAAiB,CAAC,uBAAuB;;;;"}

package/build/esm/integrations/tracing/mongo.js

@@ -0,0 +1,89 @@
+import { MongoDBInstrumentation } from '@opentelemetry/instrumentation-mongodb';
+import { defineIntegration } from '@sentry/core';
+import { generateInstrumentOnce, addOriginToSpan } from '@sentry/node-core';
+
+const INTEGRATION_NAME = 'Mongo';
+
+const instrumentMongo = generateInstrumentOnce(
+  INTEGRATION_NAME,
+  () =>
+    new MongoDBInstrumentation({
+      dbStatementSerializer: _defaultDbStatementSerializer,
+      responseHook(span) {
+        addOriginToSpan(span, 'auto.db.otel.mongo');
+      },
+    }),
+);
+
+/**
+ * Replaces values in document with '?', hiding PII and helping grouping.
+ */
+function _defaultDbStatementSerializer(commandObj) {
+  const resultObj = _scrubStatement(commandObj);
+  return JSON.stringify(resultObj);
+}
+
+function _scrubStatement(value) {
+  if (Array.isArray(value)) {
+    return value.map(element => _scrubStatement(element));
+  }
+
+  if (isCommandObj(value)) {
+    const initial = {};
+    return Object.entries(value)
+      .map(([key, element]) => [key, _scrubStatement(element)])
+      .reduce((prev, current) => {
+        if (isCommandEntry(current)) {
+          prev[current[0]] = current[1];
+        }
+        return prev;
+      }, initial);
+  }
+
+  // A value like string or number, possible contains PII, scrub it
+  return '?';
+}
+
+function isCommandObj(value) {
+  return typeof value === 'object' && value !== null && !isBuffer(value);
+}
+
+function isBuffer(value) {
+  let isBuffer = false;
+  if (typeof Buffer !== 'undefined') {
+    isBuffer = Buffer.isBuffer(value);
+  }
+  return isBuffer;
+}
+
+function isCommandEntry(value) {
+  return Array.isArray(value);
+}
+
+const _mongoIntegration = (() => {
+  return {
+    name: INTEGRATION_NAME,
+    setupOnce() {
+      instrumentMongo();
+    },
+  };
+}) ;
+
+/**
+ * Adds Sentry tracing instrumentation for the [mongodb](https://www.npmjs.com/package/mongodb) library.
+ *
+ * For more information, see the [`mongoIntegration` documentation](https://docs.sentry.io/platforms/javascript/guides/node/configuration/integrations/mongo/).
+ *
+ * @example
+ * ```javascript
+ * const Sentry = require('@sentry/node');
+ *
+ * Sentry.init({
+ *  integrations: [Sentry.mongoIntegration()],
+ * });
+ * ```
+ */
+const mongoIntegration = defineIntegration(_mongoIntegration);
+
+export { _defaultDbStatementSerializer, instrumentMongo, mongoIntegration };
+//# sourceMappingURL=mongo.js.map

package/build/esm/integrations/tracing/mongo.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mongo.js","sources":["../../../../src/integrations/tracing/mongo.ts"],"sourcesContent":["import { MongoDBInstrumentation } from '@opentelemetry/instrumentation-mongodb';\nimport type { IntegrationFn } from '@sentry/core';\nimport { defineIntegration } from '@sentry/core';\nimport { addOriginToSpan, generateInstrumentOnce } from '@sentry/node-core';\n\nconst INTEGRATION_NAME = 'Mongo';\n\nexport const instrumentMongo = generateInstrumentOnce(\n  INTEGRATION_NAME,\n  () =>\n    new MongoDBInstrumentation({\n      dbStatementSerializer: _defaultDbStatementSerializer,\n      responseHook(span) {\n        addOriginToSpan(span, 'auto.db.otel.mongo');\n      },\n    }),\n);\n\n/**\n * Replaces values in document with '?', hiding PII and helping grouping.\n */\nexport function _defaultDbStatementSerializer(commandObj: Record<string, unknown>): string {\n  const resultObj = _scrubStatement(commandObj);\n  return JSON.stringify(resultObj);\n}\n\nfunction _scrubStatement(value: unknown): unknown {\n  if (Array.isArray(value)) {\n    return value.map(element => _scrubStatement(element));\n  }\n\n  if (isCommandObj(value)) {\n    const initial: Record<string, unknown> = {};\n    return Object.entries(value)\n      .map(([key, element]) => [key, _scrubStatement(element)])\n      .reduce((prev, current) => {\n        if (isCommandEntry(current)) {\n          prev[current[0]] = current[1];\n        }\n        return prev;\n      }, initial);\n  }\n\n  // A value like string or number, possible contains PII, scrub it\n  return '?';\n}\n\nfunction isCommandObj(value: Record<string, unknown> | unknown): value is Record<string, unknown> {\n  return typeof value === 'object' && value !== null && !isBuffer(value);\n}\n\nfunction isBuffer(value: unknown): boolean {\n  let isBuffer = false;\n  if (typeof Buffer !== 'undefined') {\n    isBuffer = Buffer.isBuffer(value);\n  }\n  return isBuffer;\n}\n\nfunction isCommandEntry(value: [string, unknown] | unknown): value is [string, unknown] {\n  return Array.isArray(value);\n}\n\nconst _mongoIntegration = (() => {\n  return {\n    name: INTEGRATION_NAME,\n    setupOnce() {\n      instrumentMongo();\n    },\n  };\n}) satisfies IntegrationFn;\n\n/**\n * Adds Sentry tracing instrumentation for the [mongodb](https://www.npmjs.com/package/mongodb) library.\n *\n * For more information, see the [`mongoIntegration` documentation](https://docs.sentry.io/platforms/javascript/guides/node/configuration/integrations/mongo/).\n *\n * @example\n * ```javascript\n * const Sentry = require('@sentry/node');\n *\n * Sentry.init({\n *  integrations: [Sentry.mongoIntegration()],\n * });\n * ```\n */\nexport const mongoIntegration = defineIntegration(_mongoIntegration);\n"],"names":[],"mappings":";;;;AAKA,MAAM,gBAAA,GAAmB,OAAO;;AAEzB,MAAM,eAAA,GAAkB,sBAAsB;AACrD,EAAE,gBAAgB;AAClB,EAAE;AACF,IAAI,IAAI,sBAAsB,CAAC;AAC/B,MAAM,qBAAqB,EAAE,6BAA6B;AAC1D,MAAM,YAAY,CAAC,IAAI,EAAE;AACzB,QAAQ,eAAe,CAAC,IAAI,EAAE,oBAAoB,CAAC;AACnD,MAAM,CAAC;AACP,KAAK,CAAC;AACN;;AAEA;AACA;AACA;AACO,SAAS,6BAA6B,CAAC,UAAU,EAAmC;AAC3F,EAAE,MAAM,SAAA,GAAY,eAAe,CAAC,UAAU,CAAC;AAC/C,EAAE,OAAO,IAAI,CAAC,SAAS,CAAC,SAAS,CAAC;AAClC;;AAEA,SAAS,eAAe,CAAC,KAAK,EAAoB;AAClD,EAAE,IAAI,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE;AAC5B,IAAI,OAAO,KAAK,CAAC,GAAG,CAAC,OAAA,IAAW,eAAe,CAAC,OAAO,CAAC,CAAC;AACzD,EAAE;;AAEF,EAAE,IAAI,YAAY,CAAC,KAAK,CAAC,EAAE;AAC3B,IAAI,MAAM,OAAO,GAA4B,EAAE;AAC/C,IAAI,OAAO,MAAM,CAAC,OAAO,CAAC,KAAK;AAC/B,OAAO,GAAG,CAAC,CAAC,CAAC,GAAG,EAAE,OAAO,CAAC,KAAK,CAAC,GAAG,EAAE,eAAe,CAAC,OAAO,CAAC,CAAC;AAC9D,OAAO,MAAM,CAAC,CAAC,IAAI,EAAE,OAAO,KAAK;AACjC,QAAQ,IAAI,cAAc,CAAC,OAAO,CAAC,EAAE;AACrC,UAAU,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,CAAA,GAAI,OAAO,CAAC,CAAC,CAAC;AACvC,QAAQ;AACR,QAAQ,OAAO,IAAI;AACnB,MAAM,CAAC,EAAE,OAAO,CAAC;AACjB,EAAE;;AAEF;AACA,EAAE,OAAO,GAAG;AACZ;;AAEA,SAAS,YAAY,CAAC,KAAK,EAAuE;AAClG,EAAE,OAAO,OAAO,KAAA,KAAU,YAAY,KAAA,KAAU,IAAA,IAAQ,CAAC,QAAQ,CAAC,KAAK,CAAC;AACxE;;AAEA,SAAS,QAAQ,CAAC,KAAK,EAAoB;AAC3C,EAAE,IAAI,QAAA,GAAW,KAAK;AACtB,EAAE,IAAI,OAAO,MAAA,KAAW,WAAW,EAAE;AACrC,IAAI,WAAW,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC;AACrC,EAAE;AACF,EAAE,OAAO,QAAQ;AACjB;;AAEA,SAAS,cAAc,CAAC,KAAK,EAA2D;AACxF,EAAE,OAAO,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC;AAC7B;;AAEA,MAAM,iBAAA,IAAqB,MAAM;AACjC,EAAE,OAAO;AACT,IAAI,IAAI,EAAE,gBAAgB;AAC1B,IAAI,SAAS,GAAG;AAChB,MAAM,eAAe,EAAE;AACvB,IAAI,CAAC;AACL,GAAG;AACH,CAAC,CAAA;;AAED;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;MACa,gBAAA,GAAmB,iBAAiB,CAAC,iBAAiB;;;;"}

package/build/esm/integrations/tracing/mongoose.js

@@ -0,0 +1,43 @@
+import { MongooseInstrumentation } from '@opentelemetry/instrumentation-mongoose';
+import { defineIntegration } from '@sentry/core';
+import { generateInstrumentOnce, addOriginToSpan } from '@sentry/node-core';
+
+const INTEGRATION_NAME = 'Mongoose';
+
+const instrumentMongoose = generateInstrumentOnce(
+  INTEGRATION_NAME,
+  () =>
+    new MongooseInstrumentation({
+      responseHook(span) {
+        addOriginToSpan(span, 'auto.db.otel.mongoose');
+      },
+    }),
+);
+
+const _mongooseIntegration = (() => {
+  return {
+    name: INTEGRATION_NAME,
+    setupOnce() {
+      instrumentMongoose();
+    },
+  };
+}) ;
+
+/**
+ * Adds Sentry tracing instrumentation for the [mongoose](https://www.npmjs.com/package/mongoose) library.
+ *
+ * For more information, see the [`mongooseIntegration` documentation](https://docs.sentry.io/platforms/javascript/guides/node/configuration/integrations/mongoose/).
+ *
+ * @example
+ * ```javascript
+ * const Sentry = require('@sentry/node');
+ *
+ * Sentry.init({
+ *  integrations: [Sentry.mongooseIntegration()],
+ * });
+ * ```
+ */
+const mongooseIntegration = defineIntegration(_mongooseIntegration);
+
+export { instrumentMongoose, mongooseIntegration };
+//# sourceMappingURL=mongoose.js.map

package/build/esm/integrations/tracing/mongoose.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mongoose.js","sources":["../../../../src/integrations/tracing/mongoose.ts"],"sourcesContent":["import { MongooseInstrumentation } from '@opentelemetry/instrumentation-mongoose';\nimport type { IntegrationFn } from '@sentry/core';\nimport { defineIntegration } from '@sentry/core';\nimport { addOriginToSpan, generateInstrumentOnce } from '@sentry/node-core';\n\nconst INTEGRATION_NAME = 'Mongoose';\n\nexport const instrumentMongoose = generateInstrumentOnce(\n  INTEGRATION_NAME,\n  () =>\n    new MongooseInstrumentation({\n      responseHook(span) {\n        addOriginToSpan(span, 'auto.db.otel.mongoose');\n      },\n    }),\n);\n\nconst _mongooseIntegration = (() => {\n  return {\n    name: INTEGRATION_NAME,\n    setupOnce() {\n      instrumentMongoose();\n    },\n  };\n}) satisfies IntegrationFn;\n\n/**\n * Adds Sentry tracing instrumentation for the [mongoose](https://www.npmjs.com/package/mongoose) library.\n *\n * For more information, see the [`mongooseIntegration` documentation](https://docs.sentry.io/platforms/javascript/guides/node/configuration/integrations/mongoose/).\n *\n * @example\n * ```javascript\n * const Sentry = require('@sentry/node');\n *\n * Sentry.init({\n *  integrations: [Sentry.mongooseIntegration()],\n * });\n * ```\n */\nexport const mongooseIntegration = defineIntegration(_mongooseIntegration);\n"],"names":[],"mappings":";;;;AAKA,MAAM,gBAAA,GAAmB,UAAU;;AAE5B,MAAM,kBAAA,GAAqB,sBAAsB;AACxD,EAAE,gBAAgB;AAClB,EAAE;AACF,IAAI,IAAI,uBAAuB,CAAC;AAChC,MAAM,YAAY,CAAC,IAAI,EAAE;AACzB,QAAQ,eAAe,CAAC,IAAI,EAAE,uBAAuB,CAAC;AACtD,MAAM,CAAC;AACP,KAAK,CAAC;AACN;;AAEA,MAAM,oBAAA,IAAwB,MAAM;AACpC,EAAE,OAAO;AACT,IAAI,IAAI,EAAE,gBAAgB;AAC1B,IAAI,SAAS,GAAG;AAChB,MAAM,kBAAkB,EAAE;AAC1B,IAAI,CAAC;AACL,GAAG;AACH,CAAC,CAAA;;AAED;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;MACa,mBAAA,GAAsB,iBAAiB,CAAC,oBAAoB;;;;"}

package/build/esm/integrations/tracing/mysql.js

@@ -0,0 +1,35 @@
+import { MySQLInstrumentation } from '@opentelemetry/instrumentation-mysql';
+import { defineIntegration } from '@sentry/core';
+import { generateInstrumentOnce } from '@sentry/node-core';
+
+const INTEGRATION_NAME = 'Mysql';
+
+const instrumentMysql = generateInstrumentOnce(INTEGRATION_NAME, () => new MySQLInstrumentation({}));
+
+const _mysqlIntegration = (() => {
+  return {
+    name: INTEGRATION_NAME,
+    setupOnce() {
+      instrumentMysql();
+    },
+  };
+}) ;
+
+/**
+ * Adds Sentry tracing instrumentation for the [mysql](https://www.npmjs.com/package/mysql) library.
+ *
+ * For more information, see the [`mysqlIntegration` documentation](https://docs.sentry.io/platforms/javascript/guides/node/configuration/integrations/mysql/).
+ *
+ * @example
+ * ```javascript
+ * const Sentry = require('@sentry/node');
+ *
+ * Sentry.init({
+ *  integrations: [Sentry.mysqlIntegration()],
+ * });
+ * ```
+ */
+const mysqlIntegration = defineIntegration(_mysqlIntegration);
+
+export { instrumentMysql, mysqlIntegration };
+//# sourceMappingURL=mysql.js.map

package/build/esm/integrations/tracing/mysql.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mysql.js","sources":["../../../../src/integrations/tracing/mysql.ts"],"sourcesContent":["import { MySQLInstrumentation } from '@opentelemetry/instrumentation-mysql';\nimport type { IntegrationFn } from '@sentry/core';\nimport { defineIntegration } from '@sentry/core';\nimport { generateInstrumentOnce } from '@sentry/node-core';\n\nconst INTEGRATION_NAME = 'Mysql';\n\nexport const instrumentMysql = generateInstrumentOnce(INTEGRATION_NAME, () => new MySQLInstrumentation({}));\n\nconst _mysqlIntegration = (() => {\n  return {\n    name: INTEGRATION_NAME,\n    setupOnce() {\n      instrumentMysql();\n    },\n  };\n}) satisfies IntegrationFn;\n\n/**\n * Adds Sentry tracing instrumentation for the [mysql](https://www.npmjs.com/package/mysql) library.\n *\n * For more information, see the [`mysqlIntegration` documentation](https://docs.sentry.io/platforms/javascript/guides/node/configuration/integrations/mysql/).\n *\n * @example\n * ```javascript\n * const Sentry = require('@sentry/node');\n *\n * Sentry.init({\n *  integrations: [Sentry.mysqlIntegration()],\n * });\n * ```\n */\nexport const mysqlIntegration = defineIntegration(_mysqlIntegration);\n"],"names":[],"mappings":";;;;AAKA,MAAM,gBAAA,GAAmB,OAAO;;MAEnB,eAAA,GAAkB,sBAAsB,CAAC,gBAAgB,EAAE,MAAM,IAAI,oBAAoB,CAAC,EAAE,CAAC;;AAE1G,MAAM,iBAAA,IAAqB,MAAM;AACjC,EAAE,OAAO;AACT,IAAI,IAAI,EAAE,gBAAgB;AAC1B,IAAI,SAAS,GAAG;AAChB,MAAM,eAAe,EAAE;AACvB,IAAI,CAAC;AACL,GAAG;AACH,CAAC,CAAA;;AAED;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;MACa,gBAAA,GAAmB,iBAAiB,CAAC,iBAAiB;;;;"}