@depup/sentry__node 10.44.0-depup.0

package/build/cjs/integrations/tracing/anthropic-ai/instrumentation.js

@@ -0,0 +1,95 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const instrumentation = require('@opentelemetry/instrumentation');
+const core = require('@sentry/core');
+
+const supportedVersions = ['>=0.19.2 <1.0.0'];
+
+/**
+ * Sentry Anthropic AI instrumentation using OpenTelemetry.
+ */
+class SentryAnthropicAiInstrumentation extends instrumentation.InstrumentationBase {
+   constructor(config = {}) {
+    super('@sentry/instrumentation-anthropic-ai', core.SDK_VERSION, config);
+  }
+
+  /**
+   * Initializes the instrumentation by defining the modules to be patched.
+   */
+   init() {
+    const module = new instrumentation.InstrumentationNodeModuleDefinition(
+      '@anthropic-ai/sdk',
+      supportedVersions,
+      this._patch.bind(this),
+    );
+    return module;
+  }
+
+  /**
+   * Core patch logic applying instrumentation to the Anthropic AI client constructor.
+   */
+   _patch(exports$1) {
+    const Original = exports$1.Anthropic;
+
+    const config = this.getConfig();
+
+    const WrappedAnthropic = function ( ...args) {
+      // Check if wrapping should be skipped (e.g., when LangChain is handling instrumentation)
+      if (core._INTERNAL_shouldSkipAiProviderWrapping(core.ANTHROPIC_AI_INTEGRATION_NAME)) {
+        return Reflect.construct(Original, args) ;
+      }
+
+      const instance = Reflect.construct(Original, args);
+
+      return core.instrumentAnthropicAiClient(instance , config);
+    } ;
+
+    // Preserve static and prototype chains
+    Object.setPrototypeOf(WrappedAnthropic, Original);
+    Object.setPrototypeOf(WrappedAnthropic.prototype, Original.prototype);
+
+    for (const key of Object.getOwnPropertyNames(Original)) {
+      if (!['length', 'name', 'prototype'].includes(key)) {
+        const descriptor = Object.getOwnPropertyDescriptor(Original, key);
+        if (descriptor) {
+          Object.defineProperty(WrappedAnthropic, key, descriptor);
+        }
+      }
+    }
+
+    // Constructor replacement - handle read-only properties
+    // The Anthropic property might have only a getter, so use defineProperty
+    try {
+      exports$1.Anthropic = WrappedAnthropic;
+    } catch {
+      // If direct assignment fails, override the property descriptor
+      Object.defineProperty(exports$1, 'Anthropic', {
+        value: WrappedAnthropic,
+        writable: true,
+        configurable: true,
+        enumerable: true,
+      });
+    }
+
+    // Wrap the default export if it points to the original constructor
+    // Constructor replacement - handle read-only properties
+    // The Anthropic property might have only a getter, so use defineProperty
+    if (exports$1.default === Original) {
+      try {
+        exports$1.default = WrappedAnthropic;
+      } catch {
+        // If direct assignment fails, override the property descriptor
+        Object.defineProperty(exports$1, 'default', {
+          value: WrappedAnthropic,
+          writable: true,
+          configurable: true,
+          enumerable: true,
+        });
+      }
+    }
+    return exports$1;
+  }
+}
+
+exports.SentryAnthropicAiInstrumentation = SentryAnthropicAiInstrumentation;
+//# sourceMappingURL=instrumentation.js.map

package/build/cjs/integrations/tracing/anthropic-ai/instrumentation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"instrumentation.js","sources":["../../../../../src/integrations/tracing/anthropic-ai/instrumentation.ts"],"sourcesContent":["import {\n  InstrumentationBase,\n  type InstrumentationConfig,\n  type InstrumentationModuleDefinition,\n  InstrumentationNodeModuleDefinition,\n} from '@opentelemetry/instrumentation';\nimport type { AnthropicAiClient, AnthropicAiOptions } from '@sentry/core';\nimport {\n  _INTERNAL_shouldSkipAiProviderWrapping,\n  ANTHROPIC_AI_INTEGRATION_NAME,\n  instrumentAnthropicAiClient,\n  SDK_VERSION,\n} from '@sentry/core';\n\nconst supportedVersions = ['>=0.19.2 <1.0.0'];\n\ntype AnthropicAiInstrumentationOptions = InstrumentationConfig & AnthropicAiOptions;\n\n/**\n * Represents the patched shape of the Anthropic AI module export.\n */\ninterface PatchedModuleExports {\n  [key: string]: unknown;\n  Anthropic: abstract new (...args: unknown[]) => AnthropicAiClient;\n}\n\n/**\n * Sentry Anthropic AI instrumentation using OpenTelemetry.\n */\nexport class SentryAnthropicAiInstrumentation extends InstrumentationBase<AnthropicAiInstrumentationOptions> {\n  public constructor(config: AnthropicAiInstrumentationOptions = {}) {\n    super('@sentry/instrumentation-anthropic-ai', 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      '@anthropic-ai/sdk',\n      supportedVersions,\n      this._patch.bind(this),\n    );\n    return module;\n  }\n\n  /**\n   * Core patch logic applying instrumentation to the Anthropic AI client constructor.\n   */\n  private _patch(exports: PatchedModuleExports): PatchedModuleExports | void {\n    const Original = exports.Anthropic;\n\n    const config = this.getConfig();\n\n    const WrappedAnthropic = function (this: unknown, ...args: unknown[]) {\n      // Check if wrapping should be skipped (e.g., when LangChain is handling instrumentation)\n      if (_INTERNAL_shouldSkipAiProviderWrapping(ANTHROPIC_AI_INTEGRATION_NAME)) {\n        return Reflect.construct(Original, args) as AnthropicAiClient;\n      }\n\n      const instance = Reflect.construct(Original, args);\n\n      return instrumentAnthropicAiClient(instance as AnthropicAiClient, config);\n    } as unknown as abstract new (...args: unknown[]) => AnthropicAiClient;\n\n    // Preserve static and prototype chains\n    Object.setPrototypeOf(WrappedAnthropic, Original);\n    Object.setPrototypeOf(WrappedAnthropic.prototype, Original.prototype);\n\n    for (const key of Object.getOwnPropertyNames(Original)) {\n      if (!['length', 'name', 'prototype'].includes(key)) {\n        const descriptor = Object.getOwnPropertyDescriptor(Original, key);\n        if (descriptor) {\n          Object.defineProperty(WrappedAnthropic, key, descriptor);\n        }\n      }\n    }\n\n    // Constructor replacement - handle read-only properties\n    // The Anthropic property might have only a getter, so use defineProperty\n    try {\n      exports.Anthropic = WrappedAnthropic;\n    } catch {\n      // If direct assignment fails, override the property descriptor\n      Object.defineProperty(exports, 'Anthropic', {\n        value: WrappedAnthropic,\n        writable: true,\n        configurable: true,\n        enumerable: true,\n      });\n    }\n\n    // Wrap the default export if it points to the original constructor\n    // Constructor replacement - handle read-only properties\n    // The Anthropic property might have only a getter, so use defineProperty\n    if (exports.default === Original) {\n      try {\n        exports.default = WrappedAnthropic;\n      } catch {\n        // If direct assignment fails, override the property descriptor\n        Object.defineProperty(exports, 'default', {\n          value: WrappedAnthropic,\n          writable: true,\n          configurable: true,\n          enumerable: true,\n        });\n      }\n    }\n    return exports;\n  }\n}\n"],"names":["InstrumentationBase","SDK_VERSION","InstrumentationNodeModuleDefinition","exports","_INTERNAL_shouldSkipAiProviderWrapping","ANTHROPIC_AI_INTEGRATION_NAME","instrumentAnthropicAiClient"],"mappings":";;;;;AAcA,MAAM,iBAAA,GAAoB,CAAC,iBAAiB,CAAC;;AAY7C;AACA;AACA;AACO,MAAM,gCAAA,SAAyCA,mCAAmB,CAAoC;AAC7G,GAAS,WAAW,CAAC,MAAM,GAAsC,EAAE,EAAE;AACrE,IAAI,KAAK,CAAC,sCAAsC,EAAEC,gBAAW,EAAE,MAAM,CAAC;AACtE,EAAE;;AAEF;AACA;AACA;AACA,GAAS,IAAI,GAAoC;AACjD,IAAI,MAAM,MAAA,GAAS,IAAIC,mDAAmC;AAC1D,MAAM,mBAAmB;AACzB,MAAM,iBAAiB;AACvB,MAAM,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC;AAC5B,KAAK;AACL,IAAI,OAAO,MAAM;AACjB,EAAE;;AAEF;AACA;AACA;AACA,GAAU,MAAM,CAACC,SAAO,EAAqD;AAC7E,IAAI,MAAM,QAAA,GAAWA,SAAO,CAAC,SAAS;;AAEtC,IAAI,MAAM,MAAA,GAAS,IAAI,CAAC,SAAS,EAAE;;AAEnC,IAAI,MAAM,mBAAmB,WAAyB,GAAG,IAAI,EAAa;AAC1E;AACA,MAAM,IAAIC,2CAAsC,CAACC,kCAA6B,CAAC,EAAE;AACjF,QAAQ,OAAO,OAAO,CAAC,SAAS,CAAC,QAAQ,EAAE,IAAI,CAAA;AAC/C,MAAM;;AAEN,MAAM,MAAM,QAAA,GAAW,OAAO,CAAC,SAAS,CAAC,QAAQ,EAAE,IAAI,CAAC;;AAExD,MAAM,OAAOC,gCAA2B,CAAC,QAAA,GAA+B,MAAM,CAAC;AAC/E,IAAI,CAAA;;AAEJ;AACA,IAAI,MAAM,CAAC,cAAc,CAAC,gBAAgB,EAAE,QAAQ,CAAC;AACrD,IAAI,MAAM,CAAC,cAAc,CAAC,gBAAgB,CAAC,SAAS,EAAE,QAAQ,CAAC,SAAS,CAAC;;AAEzE,IAAI,KAAK,MAAM,GAAA,IAAO,MAAM,CAAC,mBAAmB,CAAC,QAAQ,CAAC,EAAE;AAC5D,MAAM,IAAI,CAAC,CAAC,QAAQ,EAAE,MAAM,EAAE,WAAW,CAAC,CAAC,QAAQ,CAAC,GAAG,CAAC,EAAE;AAC1D,QAAQ,MAAM,UAAA,GAAa,MAAM,CAAC,wBAAwB,CAAC,QAAQ,EAAE,GAAG,CAAC;AACzE,QAAQ,IAAI,UAAU,EAAE;AACxB,UAAU,MAAM,CAAC,cAAc,CAAC,gBAAgB,EAAE,GAAG,EAAE,UAAU,CAAC;AAClE,QAAQ;AACR,MAAM;AACN,IAAI;;AAEJ;AACA;AACA,IAAI,IAAI;AACR,MAAMH,SAAO,CAAC,SAAA,GAAY,gBAAgB;AAC1C,IAAI,EAAE,MAAM;AACZ;AACA,MAAM,MAAM,CAAC,cAAc,CAACA,SAAO,EAAE,WAAW,EAAE;AAClD,QAAQ,KAAK,EAAE,gBAAgB;AAC/B,QAAQ,QAAQ,EAAE,IAAI;AACtB,QAAQ,YAAY,EAAE,IAAI;AAC1B,QAAQ,UAAU,EAAE,IAAI;AACxB,OAAO,CAAC;AACR,IAAI;;AAEJ;AACA;AACA;AACA,IAAI,IAAIA,SAAO,CAAC,OAAA,KAAY,QAAQ,EAAE;AACtC,MAAM,IAAI;AACV,QAAQA,SAAO,CAAC,OAAA,GAAU,gBAAgB;AAC1C,MAAM,EAAE,MAAM;AACd;AACA,QAAQ,MAAM,CAAC,cAAc,CAACA,SAAO,EAAE,SAAS,EAAE;AAClD,UAAU,KAAK,EAAE,gBAAgB;AACjC,UAAU,QAAQ,EAAE,IAAI;AACxB,UAAU,YAAY,EAAE,IAAI;AAC5B,UAAU,UAAU,EAAE,IAAI;AAC1B,SAAS,CAAC;AACV,MAAM;AACN,IAAI;AACJ,IAAI,OAAOA,SAAO;AAClB,EAAE;AACF;;;;"}

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

@@ -0,0 +1,110 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const instrumentationConnect = require('@opentelemetry/instrumentation-connect');
+const core = require('@sentry/core');
+const nodeCore = require('@sentry/node-core');
+
+const INTEGRATION_NAME = 'Connect';
+
+const instrumentConnect = nodeCore.generateInstrumentOnce(INTEGRATION_NAME, () => new instrumentationConnect.ConnectInstrumentation());
+
+const _connectIntegration = (() => {
+  return {
+    name: INTEGRATION_NAME,
+    setupOnce() {
+      instrumentConnect();
+    },
+  };
+}) ;
+
+/**
+ * Adds Sentry tracing instrumentation for [Connect](https://github.com/senchalabs/connect/).
+ *
+ * If you also want to capture errors, you need to call `setupConnectErrorHandler(app)` after you initialize your connect app.
+ *
+ * For more information, see the [connect documentation](https://docs.sentry.io/platforms/javascript/guides/connect/).
+ *
+ * @example
+ * ```javascript
+ * const Sentry = require('@sentry/node');
+ *
+ * Sentry.init({
+ *   integrations: [Sentry.connectIntegration()],
+ * })
+ * ```
+ */
+const connectIntegration = core.defineIntegration(_connectIntegration);
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function connectErrorMiddleware(err, req, res, next) {
+  core.captureException(err, {
+    mechanism: {
+      handled: false,
+      type: 'auto.middleware.connect',
+    },
+  });
+  next(err);
+}
+
+/**
+ * Add a Connect middleware to capture errors to Sentry.
+ *
+ * @param app The Connect app to attach the error handler to
+ *
+ * @example
+ * ```javascript
+ * const Sentry = require('@sentry/node');
+ * const connect = require("connect");
+ *
+ * const app = connect();
+ *
+ * Sentry.setupConnectErrorHandler(app);
+ *
+ * // Add you connect routes here
+ *
+ * app.listen(3000);
+ * ```
+ */
+const setupConnectErrorHandler = (app) => {
+  app.use(connectErrorMiddleware);
+
+  // Sadly, ConnectInstrumentation has no requestHook, so we need to add the attributes here
+  // We register this hook in this method, because if we register it in the integration `setup`,
+  // it would always run even for users that are not even using connect
+  const client = core.getClient();
+  if (client) {
+    client.on('spanStart', span => {
+      addConnectSpanAttributes(span);
+    });
+  }
+
+  nodeCore.ensureIsWrapped(app.use, 'connect');
+};
+
+function addConnectSpanAttributes(span) {
+  const attributes = core.spanToJSON(span).data;
+
+  // this is one of: middleware, request_handler
+  const type = attributes['connect.type'];
+
+  // If this is already set, or we have no connect span, no need to process again...
+  if (attributes[core.SEMANTIC_ATTRIBUTE_SENTRY_OP] || !type) {
+    return;
+  }
+
+  span.setAttributes({
+    [core.SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto.http.otel.connect',
+    [core.SEMANTIC_ATTRIBUTE_SENTRY_OP]: `${type}.connect`,
+  });
+
+  // Also update the name, we don't need the "middleware - " prefix
+  const name = attributes['connect.name'];
+  if (typeof name === 'string') {
+    span.updateName(name);
+  }
+}
+
+exports.connectIntegration = connectIntegration;
+exports.instrumentConnect = instrumentConnect;
+exports.setupConnectErrorHandler = setupConnectErrorHandler;
+//# sourceMappingURL=connect.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"connect.js","sources":["../../../../src/integrations/tracing/connect.ts"],"sourcesContent":["import { ConnectInstrumentation } from '@opentelemetry/instrumentation-connect';\nimport type { IntegrationFn, Span } from '@sentry/core';\nimport {\n  captureException,\n  defineIntegration,\n  getClient,\n  SEMANTIC_ATTRIBUTE_SENTRY_OP,\n  SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN,\n  spanToJSON,\n} from '@sentry/core';\nimport { ensureIsWrapped, generateInstrumentOnce } from '@sentry/node-core';\n\ntype ConnectApp = {\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  use: (middleware: any) => void;\n};\n\nconst INTEGRATION_NAME = 'Connect';\n\nexport const instrumentConnect = generateInstrumentOnce(INTEGRATION_NAME, () => new ConnectInstrumentation());\n\nconst _connectIntegration = (() => {\n  return {\n    name: INTEGRATION_NAME,\n    setupOnce() {\n      instrumentConnect();\n    },\n  };\n}) satisfies IntegrationFn;\n\n/**\n * Adds Sentry tracing instrumentation for [Connect](https://github.com/senchalabs/connect/).\n *\n * If you also want to capture errors, you need to call `setupConnectErrorHandler(app)` after you initialize your connect app.\n *\n * For more information, see the [connect documentation](https://docs.sentry.io/platforms/javascript/guides/connect/).\n *\n * @example\n * ```javascript\n * const Sentry = require('@sentry/node');\n *\n * Sentry.init({\n *   integrations: [Sentry.connectIntegration()],\n * })\n * ```\n */\nexport const connectIntegration = defineIntegration(_connectIntegration);\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nfunction connectErrorMiddleware(err: any, req: any, res: any, next: any): void {\n  captureException(err, {\n    mechanism: {\n      handled: false,\n      type: 'auto.middleware.connect',\n    },\n  });\n  next(err);\n}\n\n/**\n * Add a Connect middleware to capture errors to Sentry.\n *\n * @param app The Connect app to attach the error handler to\n *\n * @example\n * ```javascript\n * const Sentry = require('@sentry/node');\n * const connect = require(\"connect\");\n *\n * const app = connect();\n *\n * Sentry.setupConnectErrorHandler(app);\n *\n * // Add you connect routes here\n *\n * app.listen(3000);\n * ```\n */\nexport const setupConnectErrorHandler = (app: ConnectApp): void => {\n  app.use(connectErrorMiddleware);\n\n  // Sadly, ConnectInstrumentation has no requestHook, so we need to add the attributes here\n  // We register this hook in this method, because if we register it in the integration `setup`,\n  // it would always run even for users that are not even using connect\n  const client = getClient();\n  if (client) {\n    client.on('spanStart', span => {\n      addConnectSpanAttributes(span);\n    });\n  }\n\n  ensureIsWrapped(app.use, 'connect');\n};\n\nfunction addConnectSpanAttributes(span: Span): void {\n  const attributes = spanToJSON(span).data;\n\n  // this is one of: middleware, request_handler\n  const type = attributes['connect.type'];\n\n  // If this is already set, or we have no connect span, no need to process again...\n  if (attributes[SEMANTIC_ATTRIBUTE_SENTRY_OP] || !type) {\n    return;\n  }\n\n  span.setAttributes({\n    [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto.http.otel.connect',\n    [SEMANTIC_ATTRIBUTE_SENTRY_OP]: `${type}.connect`,\n  });\n\n  // Also update the name, we don't need the \"middleware - \" prefix\n  const name = attributes['connect.name'];\n  if (typeof name === 'string') {\n    span.updateName(name);\n  }\n}\n"],"names":["generateInstrumentOnce","ConnectInstrumentation","defineIntegration","captureException","getClient","ensureIsWrapped","spanToJSON","SEMANTIC_ATTRIBUTE_SENTRY_OP","SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN"],"mappings":";;;;;;AAiBA,MAAM,gBAAA,GAAmB,SAAS;;AAE3B,MAAM,iBAAA,GAAoBA,+BAAsB,CAAC,gBAAgB,EAAE,MAAM,IAAIC,6CAAsB,EAAE;;AAE5G,MAAM,mBAAA,IAAuB,MAAM;AACnC,EAAE,OAAO;AACT,IAAI,IAAI,EAAE,gBAAgB;AAC1B,IAAI,SAAS,GAAG;AAChB,MAAM,iBAAiB,EAAE;AACzB,IAAI,CAAC;AACL,GAAG;AACH,CAAC,CAAA;;AAED;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;MACa,kBAAA,GAAqBC,sBAAiB,CAAC,mBAAmB;;AAEvE;AACA,SAAS,sBAAsB,CAAC,GAAG,EAAO,GAAG,EAAO,GAAG,EAAO,IAAI,EAAa;AAC/E,EAAEC,qBAAgB,CAAC,GAAG,EAAE;AACxB,IAAI,SAAS,EAAE;AACf,MAAM,OAAO,EAAE,KAAK;AACpB,MAAM,IAAI,EAAE,yBAAyB;AACrC,KAAK;AACL,GAAG,CAAC;AACJ,EAAE,IAAI,CAAC,GAAG,CAAC;AACX;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,MAAM,wBAAA,GAA2B,CAAC,GAAG,KAAuB;AACnE,EAAE,GAAG,CAAC,GAAG,CAAC,sBAAsB,CAAC;;AAEjC;AACA;AACA;AACA,EAAE,MAAM,MAAA,GAASC,cAAS,EAAE;AAC5B,EAAE,IAAI,MAAM,EAAE;AACd,IAAI,MAAM,CAAC,EAAE,CAAC,WAAW,EAAE,QAAQ;AACnC,MAAM,wBAAwB,CAAC,IAAI,CAAC;AACpC,IAAI,CAAC,CAAC;AACN,EAAE;;AAEF,EAAEC,wBAAe,CAAC,GAAG,CAAC,GAAG,EAAE,SAAS,CAAC;AACrC;;AAEA,SAAS,wBAAwB,CAAC,IAAI,EAAc;AACpD,EAAE,MAAM,aAAaC,eAAU,CAAC,IAAI,CAAC,CAAC,IAAI;;AAE1C;AACA,EAAE,MAAM,IAAA,GAAO,UAAU,CAAC,cAAc,CAAC;;AAEzC;AACA,EAAE,IAAI,UAAU,CAACC,iCAA4B,CAAA,IAAK,CAAC,IAAI,EAAE;AACzD,IAAI;AACJ,EAAE;;AAEF,EAAE,IAAI,CAAC,aAAa,CAAC;AACrB,IAAI,CAACC,qCAAgC,GAAG,wBAAwB;AAChE,IAAI,CAACD,iCAA4B,GAAG,CAAC,EAAA,IAAA,CAAA,QAAA,CAAA;AACA,GAAA,CAAA;;AAEA;AACA,EAAA,MAAA,IAAA,GAAA,UAAA,CAAA,cAAA,CAAA;AACA,EAAA,IAAA,OAAA,IAAA,KAAA,QAAA,EAAA;AACA,IAAA,IAAA,CAAA,UAAA,CAAA,IAAA,CAAA;AACA,EAAA;AACA;;;;;;"}

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

@@ -0,0 +1,72 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const instrumentationDataloader = require('@opentelemetry/instrumentation-dataloader');
+const core = require('@sentry/core');
+const nodeCore = require('@sentry/node-core');
+
+const INTEGRATION_NAME = 'Dataloader';
+
+const instrumentDataloader = nodeCore.generateInstrumentOnce(
+  INTEGRATION_NAME,
+  () =>
+    new instrumentationDataloader.DataloaderInstrumentation({
+      requireParentSpan: true,
+    }),
+);
+
+const _dataloaderIntegration = (() => {
+  let instrumentationWrappedCallback;
+
+  return {
+    name: INTEGRATION_NAME,
+    setupOnce() {
+      const instrumentation = instrumentDataloader();
+      instrumentationWrappedCallback = nodeCore.instrumentWhenWrapped(instrumentation);
+    },
+
+    setup(client) {
+      // This is called either immediately or when the instrumentation is wrapped
+      instrumentationWrappedCallback?.(() => {
+        client.on('spanStart', span => {
+          const spanJSON = core.spanToJSON(span);
+          if (spanJSON.description?.startsWith('dataloader')) {
+            span.setAttribute(core.SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN, 'auto.db.otel.dataloader');
+          }
+
+          // These are all possible dataloader span descriptions
+          // Still checking for the future versions
+          // in case they add support for `clear` and `prime`
+          if (
+            spanJSON.description === 'dataloader.load' ||
+            spanJSON.description === 'dataloader.loadMany' ||
+            spanJSON.description === 'dataloader.batch'
+          ) {
+            span.setAttribute(core.SEMANTIC_ATTRIBUTE_SENTRY_OP, 'cache.get');
+            // TODO: We can try adding `key` to the `data` attribute upstream.
+            // Or alternatively, we can add `requestHook` to the dataloader instrumentation.
+          }
+        });
+      });
+    },
+  };
+}) ;
+
+/**
+ * Adds Sentry tracing instrumentation for the [dataloader](https://www.npmjs.com/package/dataloader) library.
+ *
+ * For more information, see the [`dataloaderIntegration` documentation](https://docs.sentry.io/platforms/javascript/guides/node/configuration/integrations/dataloader/).
+ *
+ * @example
+ * ```javascript
+ * const Sentry = require('@sentry/node');
+ *
+ * Sentry.init({
+ *  integrations: [Sentry.dataloaderIntegration()],
+ * });
+ * ```
+ */
+const dataloaderIntegration = core.defineIntegration(_dataloaderIntegration);
+
+exports.dataloaderIntegration = dataloaderIntegration;
+exports.instrumentDataloader = instrumentDataloader;
+//# sourceMappingURL=dataloader.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"dataloader.js","sources":["../../../../src/integrations/tracing/dataloader.ts"],"sourcesContent":["import { DataloaderInstrumentation } from '@opentelemetry/instrumentation-dataloader';\nimport type { IntegrationFn } from '@sentry/core';\nimport {\n  defineIntegration,\n  SEMANTIC_ATTRIBUTE_SENTRY_OP,\n  SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN,\n  spanToJSON,\n} from '@sentry/core';\nimport { generateInstrumentOnce, instrumentWhenWrapped } from '@sentry/node-core';\n\nconst INTEGRATION_NAME = 'Dataloader';\n\nexport const instrumentDataloader = generateInstrumentOnce(\n  INTEGRATION_NAME,\n  () =>\n    new DataloaderInstrumentation({\n      requireParentSpan: true,\n    }),\n);\n\nconst _dataloaderIntegration = (() => {\n  let instrumentationWrappedCallback: undefined | ((callback: () => void) => void);\n\n  return {\n    name: INTEGRATION_NAME,\n    setupOnce() {\n      const instrumentation = instrumentDataloader();\n      instrumentationWrappedCallback = instrumentWhenWrapped(instrumentation);\n    },\n\n    setup(client) {\n      // This is called either immediately or when the instrumentation is wrapped\n      instrumentationWrappedCallback?.(() => {\n        client.on('spanStart', span => {\n          const spanJSON = spanToJSON(span);\n          if (spanJSON.description?.startsWith('dataloader')) {\n            span.setAttribute(SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN, 'auto.db.otel.dataloader');\n          }\n\n          // These are all possible dataloader span descriptions\n          // Still checking for the future versions\n          // in case they add support for `clear` and `prime`\n          if (\n            spanJSON.description === 'dataloader.load' ||\n            spanJSON.description === 'dataloader.loadMany' ||\n            spanJSON.description === 'dataloader.batch'\n          ) {\n            span.setAttribute(SEMANTIC_ATTRIBUTE_SENTRY_OP, 'cache.get');\n            // TODO: We can try adding `key` to the `data` attribute upstream.\n            // Or alternatively, we can add `requestHook` to the dataloader instrumentation.\n          }\n        });\n      });\n    },\n  };\n}) satisfies IntegrationFn;\n\n/**\n * Adds Sentry tracing instrumentation for the [dataloader](https://www.npmjs.com/package/dataloader) library.\n *\n * For more information, see the [`dataloaderIntegration` documentation](https://docs.sentry.io/platforms/javascript/guides/node/configuration/integrations/dataloader/).\n *\n * @example\n * ```javascript\n * const Sentry = require('@sentry/node');\n *\n * Sentry.init({\n *  integrations: [Sentry.dataloaderIntegration()],\n * });\n * ```\n */\nexport const dataloaderIntegration = defineIntegration(_dataloaderIntegration);\n"],"names":["generateInstrumentOnce","DataloaderInstrumentation","instrumentWhenWrapped","spanToJSON","SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN","SEMANTIC_ATTRIBUTE_SENTRY_OP","defineIntegration"],"mappings":";;;;;;AAUA,MAAM,gBAAA,GAAmB,YAAY;;AAE9B,MAAM,oBAAA,GAAuBA,+BAAsB;AAC1D,EAAE,gBAAgB;AAClB,EAAE;AACF,IAAI,IAAIC,mDAAyB,CAAC;AAClC,MAAM,iBAAiB,EAAE,IAAI;AAC7B,KAAK,CAAC;AACN;;AAEA,MAAM,sBAAA,IAA0B,MAAM;AACtC,EAAE,IAAI,8BAA8B;;AAEpC,EAAE,OAAO;AACT,IAAI,IAAI,EAAE,gBAAgB;AAC1B,IAAI,SAAS,GAAG;AAChB,MAAM,MAAM,eAAA,GAAkB,oBAAoB,EAAE;AACpD,MAAM,8BAAA,GAAiCC,8BAAqB,CAAC,eAAe,CAAC;AAC7E,IAAI,CAAC;;AAEL,IAAI,KAAK,CAAC,MAAM,EAAE;AAClB;AACA,MAAM,8BAA8B,GAAG,MAAM;AAC7C,QAAQ,MAAM,CAAC,EAAE,CAAC,WAAW,EAAE,QAAQ;AACvC,UAAU,MAAM,QAAA,GAAWC,eAAU,CAAC,IAAI,CAAC;AAC3C,UAAU,IAAI,QAAQ,CAAC,WAAW,EAAE,UAAU,CAAC,YAAY,CAAC,EAAE;AAC9D,YAAY,IAAI,CAAC,YAAY,CAACC,qCAAgC,EAAE,yBAAyB,CAAC;AAC1F,UAAU;;AAEV;AACA;AACA;AACA,UAAU;AACV,YAAY,QAAQ,CAAC,WAAA,KAAgB,iBAAA;AACrC,YAAY,QAAQ,CAAC,WAAA,KAAgB,qBAAA;AACrC,YAAY,QAAQ,CAAC,WAAA,KAAgB;AACrC,YAAY;AACZ,YAAY,IAAI,CAAC,YAAY,CAACC,iCAA4B,EAAE,WAAW,CAAC;AACxE;AACA;AACA,UAAU;AACV,QAAQ,CAAC,CAAC;AACV,MAAM,CAAC,CAAC;AACR,IAAI,CAAC;AACL,GAAG;AACH,CAAC,CAAA;;AAED;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;MACa,qBAAA,GAAwBC,sBAAiB,CAAC,sBAAsB;;;;;"}

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

@@ -0,0 +1,166 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const instrumentationExpress = require('@opentelemetry/instrumentation-express');
+const core = require('@sentry/core');
+const nodeCore = require('@sentry/node-core');
+const debugBuild = require('../../debug-build.js');
+
+const INTEGRATION_NAME = 'Express';
+
+function requestHook(span) {
+  nodeCore.addOriginToSpan(span, 'auto.http.otel.express');
+
+  const attributes = core.spanToJSON(span).data;
+  // this is one of: middleware, request_handler, router
+  const type = attributes['express.type'];
+
+  if (type) {
+    span.setAttribute(core.SEMANTIC_ATTRIBUTE_SENTRY_OP, `${type}.express`);
+  }
+
+  // Also update the name, we don't need to "middleware - " prefix
+  const name = attributes['express.name'];
+  if (typeof name === 'string') {
+    span.updateName(name);
+  }
+}
+
+function spanNameHook(info, defaultName) {
+  if (core.getIsolationScope() === core.getDefaultIsolationScope()) {
+    debugBuild.DEBUG_BUILD && core.debug.warn('Isolation scope is still default isolation scope - skipping setting transactionName');
+    return defaultName;
+  }
+  if (info.layerType === 'request_handler') {
+    // type cast b/c Otel unfortunately types info.request as any :(
+    const req = info.request ;
+    const method = req.method ? req.method.toUpperCase() : 'GET';
+    core.getIsolationScope().setTransactionName(`${method} ${info.route}`);
+  }
+  return defaultName;
+}
+
+const instrumentExpress = nodeCore.generateInstrumentOnce(
+  INTEGRATION_NAME,
+  () =>
+    new instrumentationExpress.ExpressInstrumentation({
+      requestHook: span => requestHook(span),
+      spanNameHook: (info, defaultName) => spanNameHook(info, defaultName),
+    }),
+);
+
+const _expressIntegration = (() => {
+  return {
+    name: INTEGRATION_NAME,
+    setupOnce() {
+      instrumentExpress();
+    },
+  };
+}) ;
+
+/**
+ * Adds Sentry tracing instrumentation for [Express](https://expressjs.com/).
+ *
+ * If you also want to capture errors, you need to call `setupExpressErrorHandler(app)` after you set up your Express server.
+ *
+ * For more information, see the [express documentation](https://docs.sentry.io/platforms/javascript/guides/express/).
+ *
+ * @example
+ * ```javascript
+ * const Sentry = require('@sentry/node');
+ *
+ * Sentry.init({
+ *   integrations: [Sentry.expressIntegration()],
+ * })
+ * ```
+ */
+const expressIntegration = core.defineIntegration(_expressIntegration);
+
+/**
+ * An Express-compatible error handler.
+ */
+function expressErrorHandler(options) {
+  return function sentryErrorMiddleware(
+    error,
+    request,
+    res,
+    next,
+  ) {
+    const normalizedRequest = core.httpRequestToRequestData(request);
+    // Ensure we use the express-enhanced request here, instead of the plain HTTP one
+    // When an error happens, the `expressRequestHandler` middleware does not run, so we set it here too
+    core.getIsolationScope().setSDKProcessingMetadata({ normalizedRequest });
+
+    const shouldHandleError = options?.shouldHandleError || defaultShouldHandleError;
+
+    if (shouldHandleError(error)) {
+      const eventId = core.captureException(error, { mechanism: { type: 'auto.middleware.express', handled: false } });
+      (res ).sentry = eventId;
+    }
+
+    next(error);
+  };
+}
+
+function expressRequestHandler() {
+  return function sentryRequestMiddleware(
+    request,
+    _res,
+    next,
+  ) {
+    const normalizedRequest = core.httpRequestToRequestData(request);
+    // Ensure we use the express-enhanced request here, instead of the plain HTTP one
+    core.getIsolationScope().setSDKProcessingMetadata({ normalizedRequest });
+
+    next();
+  };
+}
+
+/**
+ * Add an Express 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 express = require("express");
+ *
+ * const app = express();
+ *
+ * // Add your routes, etc.
+ *
+ * // Add this after all routes,
+ * // but before any and other error-handling middlewares are defined
+ * Sentry.setupExpressErrorHandler(app);
+ *
+ * app.listen(3000);
+ * ```
+ */
+function setupExpressErrorHandler(
+  app,
+  options,
+) {
+  app.use(expressRequestHandler());
+  app.use(expressErrorHandler(options));
+  nodeCore.ensureIsWrapped(app.use, 'express');
+}
+
+function getStatusCodeFromResponse(error) {
+  const statusCode = error.status || error.statusCode || error.status_code || error.output?.statusCode;
+  return statusCode ? parseInt(statusCode , 10) : 500;
+}
+
+/** Returns true if response code is internal server error */
+function defaultShouldHandleError(error) {
+  const status = getStatusCodeFromResponse(error);
+  return status >= 500;
+}
+
+exports.expressErrorHandler = expressErrorHandler;
+exports.expressIntegration = expressIntegration;
+exports.instrumentExpress = instrumentExpress;
+exports.setupExpressErrorHandler = setupExpressErrorHandler;
+//# sourceMappingURL=express.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"express.js","sources":["../../../../src/integrations/tracing/express.ts"],"sourcesContent":["import type * as http from 'node:http';\nimport type { Span } from '@opentelemetry/api';\nimport type { ExpressRequestInfo } from '@opentelemetry/instrumentation-express';\nimport { ExpressInstrumentation } from '@opentelemetry/instrumentation-express';\nimport type { IntegrationFn } from '@sentry/core';\nimport {\n  captureException,\n  debug,\n  defineIntegration,\n  getDefaultIsolationScope,\n  getIsolationScope,\n  httpRequestToRequestData,\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\nconst INTEGRATION_NAME = 'Express';\n\nfunction requestHook(span: Span): void {\n  addOriginToSpan(span, 'auto.http.otel.express');\n\n  const attributes = spanToJSON(span).data;\n  // this is one of: middleware, request_handler, router\n  const type = attributes['express.type'];\n\n  if (type) {\n    span.setAttribute(SEMANTIC_ATTRIBUTE_SENTRY_OP, `${type}.express`);\n  }\n\n  // Also update the name, we don't need to \"middleware - \" prefix\n  const name = attributes['express.name'];\n  if (typeof name === 'string') {\n    span.updateName(name);\n  }\n}\n\nfunction spanNameHook(info: ExpressRequestInfo<unknown>, defaultName: string): string {\n  if (getIsolationScope() === getDefaultIsolationScope()) {\n    DEBUG_BUILD && debug.warn('Isolation scope is still default isolation scope - skipping setting transactionName');\n    return defaultName;\n  }\n  if (info.layerType === 'request_handler') {\n    // type cast b/c Otel unfortunately types info.request as any :(\n    const req = info.request as { method?: string };\n    const method = req.method ? req.method.toUpperCase() : 'GET';\n    getIsolationScope().setTransactionName(`${method} ${info.route}`);\n  }\n  return defaultName;\n}\n\nexport const instrumentExpress = generateInstrumentOnce(\n  INTEGRATION_NAME,\n  () =>\n    new ExpressInstrumentation({\n      requestHook: span => requestHook(span),\n      spanNameHook: (info, defaultName) => spanNameHook(info, defaultName),\n    }),\n);\n\nconst _expressIntegration = (() => {\n  return {\n    name: INTEGRATION_NAME,\n    setupOnce() {\n      instrumentExpress();\n    },\n  };\n}) satisfies IntegrationFn;\n\n/**\n * Adds Sentry tracing instrumentation for [Express](https://expressjs.com/).\n *\n * If you also want to capture errors, you need to call `setupExpressErrorHandler(app)` after you set up your Express server.\n *\n * For more information, see the [express documentation](https://docs.sentry.io/platforms/javascript/guides/express/).\n *\n * @example\n * ```javascript\n * const Sentry = require('@sentry/node');\n *\n * Sentry.init({\n *   integrations: [Sentry.expressIntegration()],\n * })\n * ```\n */\nexport const expressIntegration = defineIntegration(_expressIntegration);\n\ninterface MiddlewareError extends Error {\n  status?: number | string;\n  statusCode?: number | string;\n  status_code?: number | string;\n  output?: {\n    statusCode?: number | string;\n  };\n}\n\ntype ExpressMiddleware = (req: http.IncomingMessage, res: http.ServerResponse, next: () => void) => void;\n\ntype ExpressErrorMiddleware = (\n  error: MiddlewareError,\n  req: http.IncomingMessage,\n  res: http.ServerResponse,\n  next: (error: MiddlewareError) => void,\n) => void;\n\ninterface ExpressHandlerOptions {\n  /**\n   * Callback method deciding whether error should be captured and sent to Sentry\n   * @param error Captured middleware error\n   */\n  shouldHandleError?(this: void, error: MiddlewareError): boolean;\n}\n\n/**\n * An Express-compatible error handler.\n */\nexport function expressErrorHandler(options?: ExpressHandlerOptions): ExpressErrorMiddleware {\n  return function sentryErrorMiddleware(\n    error: MiddlewareError,\n    request: http.IncomingMessage,\n    res: http.ServerResponse,\n    next: (error: MiddlewareError) => void,\n  ): void {\n    const normalizedRequest = httpRequestToRequestData(request);\n    // Ensure we use the express-enhanced request here, instead of the plain HTTP one\n    // When an error happens, the `expressRequestHandler` middleware does not run, so we set it here too\n    getIsolationScope().setSDKProcessingMetadata({ normalizedRequest });\n\n    const shouldHandleError = options?.shouldHandleError || defaultShouldHandleError;\n\n    if (shouldHandleError(error)) {\n      const eventId = captureException(error, { mechanism: { type: 'auto.middleware.express', handled: false } });\n      (res as { sentry?: string }).sentry = eventId;\n    }\n\n    next(error);\n  };\n}\n\nfunction expressRequestHandler(): ExpressMiddleware {\n  return function sentryRequestMiddleware(\n    request: http.IncomingMessage,\n    _res: http.ServerResponse,\n    next: () => void,\n  ): void {\n    const normalizedRequest = httpRequestToRequestData(request);\n    // Ensure we use the express-enhanced request here, instead of the plain HTTP one\n    getIsolationScope().setSDKProcessingMetadata({ normalizedRequest });\n\n    next();\n  };\n}\n\n/**\n * Add an Express 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 express = require(\"express\");\n *\n * const app = express();\n *\n * // Add your routes, etc.\n *\n * // Add this after all routes,\n * // but before any and other error-handling middlewares are defined\n * Sentry.setupExpressErrorHandler(app);\n *\n * app.listen(3000);\n * ```\n */\nexport function setupExpressErrorHandler(\n  app: { use: (middleware: ExpressMiddleware | ExpressErrorMiddleware) => unknown },\n  options?: ExpressHandlerOptions,\n): void {\n  app.use(expressRequestHandler());\n  app.use(expressErrorHandler(options));\n  ensureIsWrapped(app.use, 'express');\n}\n\nfunction getStatusCodeFromResponse(error: MiddlewareError): number {\n  const statusCode = error.status || error.statusCode || error.status_code || error.output?.statusCode;\n  return statusCode ? parseInt(statusCode as string, 10) : 500;\n}\n\n/** Returns true if response code is internal server error */\nfunction defaultShouldHandleError(error: MiddlewareError): boolean {\n  const status = getStatusCodeFromResponse(error);\n  return status >= 500;\n}\n"],"names":["addOriginToSpan","spanToJSON","SEMANTIC_ATTRIBUTE_SENTRY_OP","getIsolationScope","getDefaultIsolationScope","DEBUG_BUILD","debug","generateInstrumentOnce","ExpressInstrumentation","defineIntegration","httpRequestToRequestData","captureException","ensureIsWrapped"],"mappings":"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"}