@sentry/node 10.70.0 → 11.0.0-alpha.1

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

@@ -1,63 +1,11 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 
-const instrumentation = require('@opentelemetry/instrumentation');
-const nodeCore = require('@sentry/node-core');
 const core = require('@sentry/core');
-const debugBuild = require('../../debug-build.js');
-const setHttpServerSpanRouteAttribute = require('../../utils/setHttpServerSpanRouteAttribute.js');
 
-const INTEGRATION_NAME = "Express";
-const SUPPORTED_VERSIONS = [">=4.0.0 <6"];
 function setupExpressErrorHandler(app, options) {
   core.setupExpressErrorHandler(app, options);
-  nodeCore.ensureIsWrapped(app.use, "express");
 }
-const instrumentExpress = nodeCore.generateInstrumentOnce(
-  INTEGRATION_NAME,
-  (options) => new ExpressInstrumentation(options)
-);
-class ExpressInstrumentation extends instrumentation.InstrumentationBase {
-  constructor(config = {}) {
-    super("sentry-express", core.SDK_VERSION, config);
-  }
-  init() {
-    const module = new instrumentation.InstrumentationNodeModuleDefinition(
-      "express",
-      SUPPORTED_VERSIONS,
-      (express) => {
-        try {
-          core.patchExpressModule(express, () => ({
-            ...this.getConfig(),
-            onRouteResolved(route) {
-              if (route) {
-                setHttpServerSpanRouteAttribute.setHttpServerSpanRouteAttribute(route);
-              }
-            }
-          }));
-        } catch (e) {
-          debugBuild.DEBUG_BUILD && core.debug.error("Failed to patch express module:", e);
-        }
-        return express;
-      },
-      // we do not ever actually unpatch in our SDKs
-      (express) => express
-    );
-    return module;
-  }
-}
-const _expressIntegration = ((options) => {
-  return {
-    name: INTEGRATION_NAME,
-    setupOnce() {
-      instrumentExpress(options);
-    }
-  };
-});
-const expressIntegration = core.defineIntegration(_expressIntegration);
 
 exports.expressErrorHandler = core.expressErrorHandler;
-exports.ExpressInstrumentation = ExpressInstrumentation;
-exports.expressIntegration = expressIntegration;
-exports.instrumentExpress = instrumentExpress;
 exports.setupExpressErrorHandler = setupExpressErrorHandler;
 //# sourceMappingURL=express.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"express.js","sources":["../../../../src/integrations/tracing/express.ts"],"sourcesContent":["// Automatic istrumentation for Express using OTel\nimport type { InstrumentationConfig } from '@opentelemetry/instrumentation';\nimport { InstrumentationBase, InstrumentationNodeModuleDefinition } from '@opentelemetry/instrumentation';\n\nimport { ensureIsWrapped, generateInstrumentOnce } from '@sentry/node-core';\nimport {\n  type ExpressIntegrationOptions,\n  type IntegrationFn,\n  debug,\n  patchExpressModule,\n  SDK_VERSION,\n  defineIntegration,\n  setupExpressErrorHandler as coreSetupExpressErrorHandler,\n  type ExpressHandlerOptions,\n} from '@sentry/core';\nexport { expressErrorHandler } from '@sentry/core';\nimport { DEBUG_BUILD } from '../../debug-build';\nimport { setHttpServerSpanRouteAttribute } from '../../utils/setHttpServerSpanRouteAttribute';\n\nconst INTEGRATION_NAME = 'Express' as const;\nconst SUPPORTED_VERSIONS = ['>=4.0.0 <6'];\n\nexport function setupExpressErrorHandler(\n  //oxlint-disable-next-line no-explicit-any\n  app: { use: (middleware: any) => unknown },\n  options?: ExpressHandlerOptions,\n): void {\n  coreSetupExpressErrorHandler(app, options);\n  ensureIsWrapped(app.use, 'express');\n}\n\nexport type ExpressInstrumentationConfig = InstrumentationConfig &\n  Omit<ExpressIntegrationOptions, 'express' | 'onRouteResolved'>;\n\nexport const instrumentExpress = generateInstrumentOnce(\n  INTEGRATION_NAME,\n  (options?: ExpressInstrumentationConfig) => new ExpressInstrumentation(options),\n);\n\nexport class ExpressInstrumentation extends InstrumentationBase<ExpressInstrumentationConfig> {\n  public constructor(config: ExpressInstrumentationConfig = {}) {\n    super('sentry-express', SDK_VERSION, config);\n  }\n  public init(): InstrumentationNodeModuleDefinition {\n    const module = new InstrumentationNodeModuleDefinition(\n      'express',\n      SUPPORTED_VERSIONS,\n      express => {\n        try {\n          patchExpressModule(express, () => ({\n            ...this.getConfig(),\n            onRouteResolved(route) {\n              if (route) {\n                setHttpServerSpanRouteAttribute(route);\n              }\n            },\n          }));\n        } catch (e) {\n          DEBUG_BUILD && debug.error('Failed to patch express module:', e);\n        }\n        return express;\n      },\n      // we do not ever actually unpatch in our SDKs\n      express => express,\n    );\n    return module;\n  }\n}\nconst _expressIntegration = ((options?: ExpressInstrumentationConfig) => {\n  return {\n    name: INTEGRATION_NAME,\n    setupOnce() {\n      instrumentExpress(options);\n    },\n  };\n}) satisfies IntegrationFn;\n\nexport const expressIntegration = defineIntegration(_expressIntegration);\n"],"names":["coreSetupExpressErrorHandler","ensureIsWrapped","generateInstrumentOnce","InstrumentationBase","SDK_VERSION","InstrumentationNodeModuleDefinition","patchExpressModule","setHttpServerSpanRouteAttribute","DEBUG_BUILD","debug","defineIntegration"],"mappings":";;;;;;;;AAmBA,MAAM,gBAAA,GAAmB,SAAA;AACzB,MAAM,kBAAA,GAAqB,CAAC,YAAY,CAAA;AAEjC,SAAS,wBAAA,CAEd,KACA,OAAA,EACM;AACN,EAAAA,6BAAA,CAA6B,KAAK,OAAO,CAAA;AACzC,EAAAC,wBAAA,CAAgB,GAAA,CAAI,KAAK,SAAS,CAAA;AACpC;AAKO,MAAM,iBAAA,GAAoBC,+BAAA;AAAA,EAC/B,gBAAA;AAAA,EACA,CAAC,OAAA,KAA2C,IAAI,sBAAA,CAAuB,OAAO;AAChF;AAEO,MAAM,+BAA+BC,mCAAA,CAAkD;AAAA,EACrF,WAAA,CAAY,MAAA,GAAuC,EAAC,EAAG;AAC5D,IAAA,KAAA,CAAM,gBAAA,EAAkBC,kBAAa,MAAM,CAAA;AAAA,EAC7C;AAAA,EACO,IAAA,GAA4C;AACjD,IAAA,MAAM,SAAS,IAAIC,mDAAA;AAAA,MACjB,SAAA;AAAA,MACA,kBAAA;AAAA,MACA,CAAA,OAAA,KAAW;AACT,QAAA,IAAI;AACF,UAAAC,uBAAA,CAAmB,SAAS,OAAO;AAAA,YACjC,GAAG,KAAK,SAAA,EAAU;AAAA,YAClB,gBAAgB,KAAA,EAAO;AACrB,cAAA,IAAI,KAAA,EAAO;AACT,gBAAAC,+DAAA,CAAgC,KAAK,CAAA;AAAA,cACvC;AAAA,YACF;AAAA,WACF,CAAE,CAAA;AAAA,QACJ,SAAS,CAAA,EAAG;AACV,UAAAC,sBAAA,IAAeC,UAAA,CAAM,KAAA,CAAM,iCAAA,EAAmC,CAAC,CAAA;AAAA,QACjE;AACA,QAAA,OAAO,OAAA;AAAA,MACT,CAAA;AAAA;AAAA,MAEA,CAAA,OAAA,KAAW;AAAA,KACb;AACA,IAAA,OAAO,MAAA;AAAA,EACT;AACF;AACA,MAAM,mBAAA,IAAuB,CAAC,OAAA,KAA2C;AACvE,EAAA,OAAO;AAAA,IACL,IAAA,EAAM,gBAAA;AAAA,IACN,SAAA,GAAY;AACV,MAAA,iBAAA,CAAkB,OAAO,CAAA;AAAA,IAC3B;AAAA,GACF;AACF,CAAA,CAAA;AAEO,MAAM,kBAAA,GAAqBC,uBAAkB,mBAAmB;;;;;;;;"}
+{"version":3,"file":"express.js","sources":["../../../../src/integrations/tracing/express.ts"],"sourcesContent":["import { setupExpressErrorHandler as coreSetupExpressErrorHandler, type ExpressHandlerOptions } from '@sentry/core';\nexport { expressErrorHandler } from '@sentry/core';\n\nexport function setupExpressErrorHandler(\n  //oxlint-disable-next-line no-explicit-any\n  app: { use: (middleware: any) => unknown },\n  options?: ExpressHandlerOptions,\n): void {\n  coreSetupExpressErrorHandler(app, options);\n}\n"],"names":["coreSetupExpressErrorHandler"],"mappings":";;;;AAGO,SAAS,wBAAA,CAEd,KACA,OAAA,EACM;AACN,EAAAA,6BAAA,CAA6B,KAAK,OAAO,CAAA;AAC3C;;;;;"}

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

@@ -1,15 +1,9 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 
 const core = require('@sentry/core');
-const nodeCore = require('@sentry/node-core');
-const instrumentation = require('./v3/instrumentation.js');
 const serverUtils = require('@sentry/server-utils');
 
 const INTEGRATION_NAME = "Fastify";
-const instrumentFastifyV3 = nodeCore.generateInstrumentOnce(
-  `${INTEGRATION_NAME}.v3`,
-  () => new instrumentation.FastifyInstrumentationV3()
-);
 function getFastifyIntegration() {
   const client = core.getClient();
   if (!client) {
@@ -18,16 +12,8 @@ function getFastifyIntegration() {
     return client.getIntegrationByName(INTEGRATION_NAME);
   }
 }
-const _fastifyIntegration = ((options) => {
-  const parentIntegration = serverUtils.fastifyIntegration(options);
-  return core.extendIntegration(parentIntegration, {
-    setupOnce() {
-      instrumentFastifyV3();
-    }
-  });
-});
 const fastifyIntegration = core.defineIntegration(
-  (options = {}) => _fastifyIntegration(options)
+  (options = {}) => serverUtils.fastifyIntegration(options)
 );
 function setupFastifyErrorHandler(fastify, options) {
   if (options?.shouldHandleError) {
@@ -50,6 +36,5 @@ function setupFastifyErrorHandler(fastify, options) {
 
 exports.instrumentFastify = serverUtils.instrumentFastify;
 exports.fastifyIntegration = fastifyIntegration;
-exports.instrumentFastifyV3 = instrumentFastifyV3;
 exports.setupFastifyErrorHandler = setupFastifyErrorHandler;
 //# sourceMappingURL=index.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.js","sources":["../../../../../src/integrations/tracing/fastify/index.ts"],"sourcesContent":["import type { Integration, IntegrationFn } from '@sentry/core';\nimport { defineIntegration, extendIntegration, getClient } from '@sentry/core';\nimport { generateInstrumentOnce } from '@sentry/node-core';\nimport type { FastifyInstance, FastifyMinimal, FastifyReply, FastifyRequest } from './types';\nimport { FastifyInstrumentationV3 } from './v3/instrumentation';\nimport {\n  fastifyIntegration as serverUtilsFastifyIntegration,\n  instrumentFastify,\n  handleFastifyError,\n} from '@sentry/server-utils';\n\ninterface FastifyIntegration extends Integration {\n  getShouldHandleError: () => (error: Error, request: FastifyRequest, reply: FastifyReply) => boolean;\n  // todo(v11): Remove this\n  setShouldHandleError: (\n    shouldHandleError: (error: Error, request: FastifyRequest, reply: FastifyReply) => boolean,\n  ) => void;\n}\n\n// oxlint-disable-next-line typescript/no-deprecated\nexport { instrumentFastify };\n\n/**\n * Options for the Fastify integration.\n *\n * `shouldHandleError` - Callback method deciding whether error should be captured and sent to Sentry\n * This is used on Fastify v5 where Sentry handles errors in the diagnostics channel.\n * Fastify v3 and v4 use `setupFastifyErrorHandler` instead.\n *\n * @example\n *\n * ```javascript\n * Sentry.init({\n *   integrations: [\n *     Sentry.fastifyIntegration({\n *       shouldHandleError(_error, _request, reply) {\n *         return reply.statusCode >= 500;\n *       },\n *     });\n *   },\n * });\n * ```\n *\n */\ninterface FastifyIntegrationOptions {\n  /**\n   * Callback method deciding whether error should be captured and sent to Sentry\n   * This is used on Fastify v5 where Sentry handles errors in the diagnostics channel.\n   * Fastify v3 and v4 use `setupFastifyErrorHandler` instead.\n   *\n   * @param error Captured Fastify error\n   * @param request Fastify request (or any object containing at least method, routeOptions.url, and routerPath)\n   * @param reply Fastify reply (or any object containing at least statusCode)\n   */\n  shouldHandleError: (error: Error, request: FastifyRequest, reply: FastifyReply) => boolean;\n}\n\ninterface FastifyHandlerOptions {\n  /**\n   * Callback method deciding whether error should be captured and sent to Sentry\n   *\n   * @param error Captured Fastify error\n   * @param request Fastify request (or any object containing at least method, routeOptions.url, and routerPath)\n   * @param reply Fastify reply (or any object containing at least statusCode)\n   *\n   * @example\n   *\n   *\n   * ```javascript\n   * setupFastifyErrorHandler(app, {\n   *   shouldHandleError(_error, _request, reply) {\n   *     return reply.statusCode >= 400;\n   *   },\n   * });\n   * ```\n   *\n   *\n   * If using TypeScript, you can cast the request and reply to get full type safety.\n   *\n   * ```typescript\n   * import type { FastifyRequest, FastifyReply } from 'fastify';\n   *\n   * setupFastifyErrorHandler(app, {\n   *   shouldHandleError(error, minimalRequest, minimalReply) {\n   *     const request = minimalRequest as FastifyRequest;\n   *     const reply = minimalReply as FastifyReply;\n   *     return reply.statusCode >= 500;\n   *   },\n   * });\n   * ```\n   */\n  shouldHandleError: (error: Error, request: FastifyRequest, reply: FastifyReply) => boolean;\n}\n\nconst INTEGRATION_NAME = 'Fastify' as const;\n\nexport const instrumentFastifyV3 = generateInstrumentOnce(\n  `${INTEGRATION_NAME}.v3`,\n  () => new FastifyInstrumentationV3(),\n);\n\nfunction getFastifyIntegration(): FastifyIntegration | undefined {\n  const client = getClient();\n  if (!client) {\n    return undefined;\n  } else {\n    return client.getIntegrationByName(INTEGRATION_NAME);\n  }\n}\n\nconst _fastifyIntegration = ((options: Partial<FastifyIntegrationOptions>) => {\n  const parentIntegration = serverUtilsFastifyIntegration(options) as FastifyIntegration;\n\n  return extendIntegration(parentIntegration, {\n    setupOnce() {\n      instrumentFastifyV3();\n    },\n  });\n}) satisfies IntegrationFn;\n\n/**\n * Adds Sentry tracing instrumentation for [Fastify](https://fastify.dev/).\n *\n * If you also want to capture errors, you need to call `setupFastifyErrorHandler(app)` after you set up your Fastify server.\n *\n * For more information, see the [fastify documentation](https://docs.sentry.io/platforms/javascript/guides/fastify/).\n *\n * @example\n * ```javascript\n * const Sentry = require('@sentry/node');\n *\n * Sentry.init({\n *   integrations: [Sentry.fastifyIntegration()],\n * })\n * ```\n */\nexport const fastifyIntegration = defineIntegration((options: Partial<FastifyIntegrationOptions> = {}) =>\n  _fastifyIntegration(options),\n);\n\n/**\n * Add an Fastify error handler to capture errors to Sentry.\n *\n * @param fastify The Fastify instance to which to add the error handler\n * @param options Configuration options for the handler\n *\n * @example\n * ```javascript\n * const Sentry = require('@sentry/node');\n * const Fastify = require(\"fastify\");\n *\n * const app = Fastify();\n *\n * Sentry.setupFastifyErrorHandler(app);\n *\n * // Add your routes, etc.\n *\n * app.listen({ port: 3000 });\n * ```\n */\nexport function setupFastifyErrorHandler(fastify: FastifyMinimal, options?: Partial<FastifyHandlerOptions>): void {\n  if (options?.shouldHandleError) {\n    getFastifyIntegration()?.setShouldHandleError(options.shouldHandleError);\n  }\n\n  const plugin = Object.assign(\n    function (fastify: FastifyInstance, _options: unknown, done: () => void): void {\n      fastify.addHook('onError', async (request, reply, error) => {\n        // oxlint-disable-next-line typescript/no-deprecated\n        handleFastifyError.call(handleFastifyError, error, request, reply, 'onError-hook');\n      });\n      done();\n    },\n    {\n      [Symbol.for('skip-override')]: true,\n      [Symbol.for('fastify.display-name')]: 'sentry-fastify-error-handler',\n    },\n  );\n\n  fastify.register(plugin);\n}\n"],"names":["generateInstrumentOnce","FastifyInstrumentationV3","getClient","serverUtilsFastifyIntegration","extendIntegration","defineIntegration","fastify","handleFastifyError"],"mappings":";;;;;;;AA8FA,MAAM,gBAAA,GAAmB,SAAA;AAElB,MAAM,mBAAA,GAAsBA,+BAAA;AAAA,EACjC,GAAG,gBAAgB,CAAA,GAAA,CAAA;AAAA,EACnB,MAAM,IAAIC,wCAAA;AACZ;AAEA,SAAS,qBAAA,GAAwD;AAC/D,EAAA,MAAM,SAASC,cAAA,EAAU;AACzB,EAAA,IAAI,CAAC,MAAA,EAAQ;AACX,IAAA,OAAO,MAAA;AAAA,EACT,CAAA,MAAO;AACL,IAAA,OAAO,MAAA,CAAO,qBAAqB,gBAAgB,CAAA;AAAA,EACrD;AACF;AAEA,MAAM,mBAAA,IAAuB,CAAC,OAAA,KAAgD;AAC5E,EAAA,MAAM,iBAAA,GAAoBC,+BAA8B,OAAO,CAAA;AAE/D,EAAA,OAAOC,uBAAkB,iBAAA,EAAmB;AAAA,IAC1C,SAAA,GAAY;AACV,MAAA,mBAAA,EAAoB;AAAA,IACtB;AAAA,GACD,CAAA;AACH,CAAA,CAAA;AAkBO,MAAM,kBAAA,GAAqBC,sBAAA;AAAA,EAAkB,CAAC,OAAA,GAA8C,EAAC,KAClG,oBAAoB,OAAO;AAC7B;AAsBO,SAAS,wBAAA,CAAyB,SAAyB,OAAA,EAAgD;AAChH,EAAA,IAAI,SAAS,iBAAA,EAAmB;AAC9B,IAAA,qBAAA,EAAsB,EAAG,oBAAA,CAAqB,OAAA,CAAQ,iBAAiB,CAAA;AAAA,EACzE;AAEA,EAAA,MAAM,SAAS,MAAA,CAAO,MAAA;AAAA,IACpB,SAAUC,QAAAA,EAA0B,QAAA,EAAmB,IAAA,EAAwB;AAC7E,MAAAA,SAAQ,OAAA,CAAQ,SAAA,EAAW,OAAO,OAAA,EAAS,OAAO,KAAA,KAAU;AAE1D,QAAAC,8BAAA,CAAmB,IAAA,CAAKA,8BAAA,EAAoB,KAAA,EAAO,OAAA,EAAS,OAAO,cAAc,CAAA;AAAA,MACnF,CAAC,CAAA;AACD,MAAA,IAAA,EAAK;AAAA,IACP,CAAA;AAAA,IACA;AAAA,MACE,iBAAC,MAAA,CAAO,GAAA,CAAI,eAAe,CAAC,GAAG,IAAA;AAAA,MAC/B,iBAAC,MAAA,CAAO,GAAA,CAAI,sBAAsB,CAAC,GAAG;AAAA;AACxC,GACF;AAEA,EAAA,OAAA,CAAQ,SAAS,MAAM,CAAA;AACzB;;;;;;;"}
+{"version":3,"file":"index.js","sources":["../../../../../src/integrations/tracing/fastify/index.ts"],"sourcesContent":["import type { Integration } from '@sentry/core';\nimport { defineIntegration, getClient } from '@sentry/core';\nimport type { FastifyInstance, FastifyMinimal, FastifyReply, FastifyRequest } from './types';\nimport {\n  fastifyIntegration as serverUtilsFastifyIntegration,\n  instrumentFastify,\n  handleFastifyError,\n} from '@sentry/server-utils';\n\ninterface FastifyIntegration extends Integration {\n  getShouldHandleError: () => (error: Error, request: FastifyRequest, reply: FastifyReply) => boolean;\n  // todo(v11): Remove this\n  setShouldHandleError: (\n    shouldHandleError: (error: Error, request: FastifyRequest, reply: FastifyReply) => boolean,\n  ) => void;\n}\n\n// oxlint-disable-next-line typescript/no-deprecated\nexport { instrumentFastify };\n\n/**\n * Options for the Fastify integration.\n *\n * `shouldHandleError` - Callback method deciding whether error should be captured and sent to Sentry\n * This is used on Fastify v5 where Sentry handles errors in the diagnostics channel.\n * Fastify v3 and v4 use `setupFastifyErrorHandler` instead.\n *\n * @example\n *\n * ```javascript\n * Sentry.init({\n *   integrations: [\n *     Sentry.fastifyIntegration({\n *       shouldHandleError(_error, _request, reply) {\n *         return reply.statusCode >= 500;\n *       },\n *     });\n *   },\n * });\n * ```\n *\n */\ninterface FastifyIntegrationOptions {\n  /**\n   * Callback method deciding whether error should be captured and sent to Sentry\n   * This is used on Fastify v5 where Sentry handles errors in the diagnostics channel.\n   * Fastify v3 and v4 use `setupFastifyErrorHandler` instead.\n   *\n   * @param error Captured Fastify error\n   * @param request Fastify request (or any object containing at least method, routeOptions.url, and routerPath)\n   * @param reply Fastify reply (or any object containing at least statusCode)\n   */\n  shouldHandleError: (error: Error, request: FastifyRequest, reply: FastifyReply) => boolean;\n}\n\ninterface FastifyHandlerOptions {\n  /**\n   * Callback method deciding whether error should be captured and sent to Sentry\n   *\n   * @param error Captured Fastify error\n   * @param request Fastify request (or any object containing at least method, routeOptions.url, and routerPath)\n   * @param reply Fastify reply (or any object containing at least statusCode)\n   *\n   * @example\n   *\n   *\n   * ```javascript\n   * setupFastifyErrorHandler(app, {\n   *   shouldHandleError(_error, _request, reply) {\n   *     return reply.statusCode >= 400;\n   *   },\n   * });\n   * ```\n   *\n   *\n   * If using TypeScript, you can cast the request and reply to get full type safety.\n   *\n   * ```typescript\n   * import type { FastifyRequest, FastifyReply } from 'fastify';\n   *\n   * setupFastifyErrorHandler(app, {\n   *   shouldHandleError(error, minimalRequest, minimalReply) {\n   *     const request = minimalRequest as FastifyRequest;\n   *     const reply = minimalReply as FastifyReply;\n   *     return reply.statusCode >= 500;\n   *   },\n   * });\n   * ```\n   */\n  shouldHandleError: (error: Error, request: FastifyRequest, reply: FastifyReply) => boolean;\n}\n\nconst INTEGRATION_NAME = 'Fastify' as const;\n\nfunction getFastifyIntegration(): FastifyIntegration | undefined {\n  const client = getClient();\n  if (!client) {\n    return undefined;\n  } else {\n    return client.getIntegrationByName(INTEGRATION_NAME);\n  }\n}\n\n/**\n * Adds Sentry tracing instrumentation for [Fastify](https://fastify.dev/).\n *\n * If you also want to capture errors, you need to call `setupFastifyErrorHandler(app)` after you set up your Fastify server.\n *\n * For more information, see the [fastify documentation](https://docs.sentry.io/platforms/javascript/guides/fastify/).\n *\n * @example\n * ```javascript\n * const Sentry = require('@sentry/node');\n *\n * Sentry.init({\n *   integrations: [Sentry.fastifyIntegration()],\n * })\n * ```\n */\nexport const fastifyIntegration = defineIntegration((options: Partial<FastifyIntegrationOptions> = {}) =>\n  serverUtilsFastifyIntegration(options),\n);\n\n/**\n * Add an Fastify error handler to capture errors to Sentry.\n *\n * @param fastify The Fastify instance to which to add the error handler\n * @param options Configuration options for the handler\n *\n * @example\n * ```javascript\n * const Sentry = require('@sentry/node');\n * const Fastify = require(\"fastify\");\n *\n * const app = Fastify();\n *\n * Sentry.setupFastifyErrorHandler(app);\n *\n * // Add your routes, etc.\n *\n * app.listen({ port: 3000 });\n * ```\n */\nexport function setupFastifyErrorHandler(fastify: FastifyMinimal, options?: Partial<FastifyHandlerOptions>): void {\n  if (options?.shouldHandleError) {\n    getFastifyIntegration()?.setShouldHandleError(options.shouldHandleError);\n  }\n\n  const plugin = Object.assign(\n    function (fastify: FastifyInstance, _options: unknown, done: () => void): void {\n      fastify.addHook('onError', async (request, reply, error) => {\n        // oxlint-disable-next-line typescript/no-deprecated\n        handleFastifyError.call(handleFastifyError, error, request, reply, 'onError-hook');\n      });\n      done();\n    },\n    {\n      [Symbol.for('skip-override')]: true,\n      [Symbol.for('fastify.display-name')]: 'sentry-fastify-error-handler',\n    },\n  );\n\n  fastify.register(plugin);\n}\n"],"names":["getClient","defineIntegration","serverUtilsFastifyIntegration","fastify","handleFastifyError"],"mappings":";;;;;AA4FA,MAAM,gBAAA,GAAmB,SAAA;AAEzB,SAAS,qBAAA,GAAwD;AAC/D,EAAA,MAAM,SAASA,cAAA,EAAU;AACzB,EAAA,IAAI,CAAC,MAAA,EAAQ;AACX,IAAA,OAAO,MAAA;AAAA,EACT,CAAA,MAAO;AACL,IAAA,OAAO,MAAA,CAAO,qBAAqB,gBAAgB,CAAA;AAAA,EACrD;AACF;AAkBO,MAAM,kBAAA,GAAqBC,sBAAA;AAAA,EAAkB,CAAC,OAAA,GAA8C,EAAC,KAClGC,+BAA8B,OAAO;AACvC;AAsBO,SAAS,wBAAA,CAAyB,SAAyB,OAAA,EAAgD;AAChH,EAAA,IAAI,SAAS,iBAAA,EAAmB;AAC9B,IAAA,qBAAA,EAAsB,EAAG,oBAAA,CAAqB,OAAA,CAAQ,iBAAiB,CAAA;AAAA,EACzE;AAEA,EAAA,MAAM,SAAS,MAAA,CAAO,MAAA;AAAA,IACpB,SAAUC,QAAAA,EAA0B,QAAA,EAAmB,IAAA,EAAwB;AAC7E,MAAAA,SAAQ,OAAA,CAAQ,SAAA,EAAW,OAAO,OAAA,EAAS,OAAO,KAAA,KAAU;AAE1D,QAAAC,8BAAA,CAAmB,IAAA,CAAKA,8BAAA,EAAoB,KAAA,EAAO,OAAA,EAAS,OAAO,cAAc,CAAA;AAAA,MACnF,CAAC,CAAA;AACD,MAAA,IAAA,EAAK;AAAA,IACP,CAAA;AAAA,IACA;AAAA,MACE,iBAAC,MAAA,CAAO,GAAA,CAAI,eAAe,CAAC,GAAG,IAAA;AAAA,MAC/B,iBAAC,MAAA,CAAO,GAAA,CAAI,sBAAsB,CAAC,GAAG;AAAA;AACxC,GACF;AAEA,EAAA,OAAA,CAAQ,SAAS,MAAM,CAAA;AACzB;;;;;;"}

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

@@ -1,21 +1,8 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 
-const instrumentation = require('./vendored/instrumentation.js');
 const core = require('@sentry/core');
-const nodeCore = require('@sentry/node-core');
 const debugBuild = require('../../../debug-build.js');
 
-const INTEGRATION_NAME = "Hapi";
-const instrumentHapi = nodeCore.generateInstrumentOnce(INTEGRATION_NAME, () => new instrumentation.HapiInstrumentation());
-const _hapiIntegration = (() => {
-  return {
-    name: INTEGRATION_NAME,
-    setupOnce() {
-      instrumentHapi();
-    }
-  };
-});
-const hapiIntegration = core.defineIntegration(_hapiIntegration);
 function isErrorEvent(event) {
   return !!(event && typeof event === "object" && "error" in event && event.error);
 }
@@ -50,11 +37,8 @@ const hapiErrorPlugin = {
 };
 async function setupHapiErrorHandler(server) {
   await server.register(hapiErrorPlugin);
-  nodeCore.ensureIsWrapped(server.register, "hapi");
 }
 
 exports.hapiErrorPlugin = hapiErrorPlugin;
-exports.hapiIntegration = hapiIntegration;
-exports.instrumentHapi = instrumentHapi;
 exports.setupHapiErrorHandler = setupHapiErrorHandler;
 //# sourceMappingURL=index.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.js","sources":["../../../../../src/integrations/tracing/hapi/index.ts"],"sourcesContent":["import { HapiInstrumentation } from './vendored/instrumentation';\nimport type { IntegrationFn } from '@sentry/core';\nimport {\n  captureException,\n  debug,\n  defineIntegration,\n  getDefaultIsolationScope,\n  getIsolationScope,\n  SDK_VERSION,\n} from '@sentry/core';\nimport { ensureIsWrapped, generateInstrumentOnce } from '@sentry/node-core';\nimport { DEBUG_BUILD } from '../../../debug-build';\nimport type { Request, RequestEvent, Server } from './types';\n\nconst INTEGRATION_NAME = 'Hapi' as const;\n\nexport const instrumentHapi = generateInstrumentOnce(INTEGRATION_NAME, () => new HapiInstrumentation());\n\nconst _hapiIntegration = (() => {\n  return {\n    name: INTEGRATION_NAME,\n    setupOnce() {\n      instrumentHapi();\n    },\n  };\n}) satisfies IntegrationFn;\n\n/**\n * Adds Sentry tracing instrumentation for [Hapi](https://hapi.dev/).\n *\n * If you also want to capture errors, you need to call `setupHapiErrorHandler(server)` after you set up your server.\n *\n * For more information, see the [hapi documentation](https://docs.sentry.io/platforms/javascript/guides/hapi/).\n *\n * @example\n * ```javascript\n * const Sentry = require('@sentry/node');\n *\n * Sentry.init({\n *   integrations: [Sentry.hapiIntegration()],\n * })\n * ```\n */\nexport const hapiIntegration = defineIntegration(_hapiIntegration);\n\nfunction isErrorEvent(event: unknown): event is RequestEvent {\n  return !!(event && typeof event === 'object' && 'error' in event && event.error);\n}\n\nfunction sendErrorToSentry(errorData: object): void {\n  captureException(errorData, {\n    mechanism: {\n      type: 'auto.function.hapi',\n      handled: false,\n    },\n  });\n}\n\nexport const hapiErrorPlugin = {\n  name: 'SentryHapiErrorPlugin',\n  version: SDK_VERSION,\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  register: async function (serverArg: Record<any, any>) {\n    const server = serverArg as unknown as Server;\n\n    server.events.on({ name: 'request', channels: ['error'] }, (request: Request, event: RequestEvent) => {\n      if (getIsolationScope() !== getDefaultIsolationScope()) {\n        const route = request.route;\n        if (route.path) {\n          getIsolationScope().setTransactionName(`${route.method.toUpperCase()} ${route.path}`);\n        }\n      } else {\n        DEBUG_BUILD &&\n          debug.warn('Isolation scope is still the default isolation scope - skipping setting transactionName');\n      }\n\n      if (isErrorEvent(event)) {\n        sendErrorToSentry(event.error);\n      }\n    });\n  },\n};\n\n/**\n * Add a Hapi plugin to capture errors to Sentry.\n *\n * @param server The Hapi server to attach the error handler to\n *\n * @example\n * ```javascript\n * const Sentry = require('@sentry/node');\n * const Hapi = require('@hapi/hapi');\n *\n * const init = async () => {\n *   const server = Hapi.server();\n *\n *   // all your routes here\n *\n *   await Sentry.setupHapiErrorHandler(server);\n *\n *   await server.start();\n * };\n * ```\n */\nexport async function setupHapiErrorHandler(server: Server): Promise<void> {\n  await server.register(hapiErrorPlugin);\n  ensureIsWrapped(server.register, 'hapi');\n}\n"],"names":["generateInstrumentOnce","HapiInstrumentation","defineIntegration","captureException","SDK_VERSION","getIsolationScope","getDefaultIsolationScope","DEBUG_BUILD","debug","ensureIsWrapped"],"mappings":";;;;;;;AAcA,MAAM,gBAAA,GAAmB,MAAA;AAElB,MAAM,iBAAiBA,+BAAA,CAAuB,gBAAA,EAAkB,MAAM,IAAIC,qCAAqB;AAEtG,MAAM,oBAAoB,MAAM;AAC9B,EAAA,OAAO;AAAA,IACL,IAAA,EAAM,gBAAA;AAAA,IACN,SAAA,GAAY;AACV,MAAA,cAAA,EAAe;AAAA,IACjB;AAAA,GACF;AACF,CAAA,CAAA;AAkBO,MAAM,eAAA,GAAkBC,uBAAkB,gBAAgB;AAEjE,SAAS,aAAa,KAAA,EAAuC;AAC3D,EAAA,OAAO,CAAC,EAAE,KAAA,IAAS,OAAO,UAAU,QAAA,IAAY,OAAA,IAAW,SAAS,KAAA,CAAM,KAAA,CAAA;AAC5E;AAEA,SAAS,kBAAkB,SAAA,EAAyB;AAClD,EAAAC,qBAAA,CAAiB,SAAA,EAAW;AAAA,IAC1B,SAAA,EAAW;AAAA,MACT,IAAA,EAAM,oBAAA;AAAA,MACN,OAAA,EAAS;AAAA;AACX,GACD,CAAA;AACH;AAEO,MAAM,eAAA,GAAkB;AAAA,EAC7B,IAAA,EAAM,uBAAA;AAAA,EACN,OAAA,EAASC,gBAAA;AAAA;AAAA,EAET,QAAA,EAAU,eAAgB,SAAA,EAA6B;AACrD,IAAA,MAAM,MAAA,GAAS,SAAA;AAEf,IAAA,MAAA,CAAO,MAAA,CAAO,EAAA,CAAG,EAAE,IAAA,EAAM,SAAA,EAAW,QAAA,EAAU,CAAC,OAAO,CAAA,EAAE,EAAG,CAAC,OAAA,EAAkB,KAAA,KAAwB;AACpG,MAAA,IAAIC,sBAAA,EAAkB,KAAMC,6BAAA,EAAyB,EAAG;AACtD,QAAA,MAAM,QAAQ,OAAA,CAAQ,KAAA;AACtB,QAAA,IAAI,MAAM,IAAA,EAAM;AACd,UAAAD,sBAAA,EAAkB,CAAE,kBAAA,CAAmB,CAAA,EAAG,KAAA,CAAM,MAAA,CAAO,aAAa,CAAA,CAAA,EAAI,KAAA,CAAM,IAAI,CAAA,CAAE,CAAA;AAAA,QACtF;AAAA,MACF,CAAA,MAAO;AACL,QAAAE,sBAAA,IACEC,UAAA,CAAM,KAAK,yFAAyF,CAAA;AAAA,MACxG;AAEA,MAAA,IAAI,YAAA,CAAa,KAAK,CAAA,EAAG;AACvB,QAAA,iBAAA,CAAkB,MAAM,KAAK,CAAA;AAAA,MAC/B;AAAA,IACF,CAAC,CAAA;AAAA,EACH;AACF;AAuBA,eAAsB,sBAAsB,MAAA,EAA+B;AACzE,EAAA,MAAM,MAAA,CAAO,SAAS,eAAe,CAAA;AACrC,EAAAC,wBAAA,CAAgB,MAAA,CAAO,UAAU,MAAM,CAAA;AACzC;;;;;;;"}
+{"version":3,"file":"index.js","sources":["../../../../../src/integrations/tracing/hapi/index.ts"],"sourcesContent":["import { captureException, debug, getDefaultIsolationScope, getIsolationScope, SDK_VERSION } from '@sentry/core';\nimport { DEBUG_BUILD } from '../../../debug-build';\nimport type { Request, RequestEvent, Server } from './types';\n\nfunction isErrorEvent(event: unknown): event is RequestEvent {\n  return !!(event && typeof event === 'object' && 'error' in event && event.error);\n}\n\nfunction sendErrorToSentry(errorData: object): void {\n  captureException(errorData, {\n    mechanism: {\n      type: 'auto.function.hapi',\n      handled: false,\n    },\n  });\n}\n\nexport const hapiErrorPlugin = {\n  name: 'SentryHapiErrorPlugin',\n  version: SDK_VERSION,\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  register: async function (serverArg: Record<any, any>) {\n    const server = serverArg as unknown as Server;\n\n    server.events.on({ name: 'request', channels: ['error'] }, (request: Request, event: RequestEvent) => {\n      if (getIsolationScope() !== getDefaultIsolationScope()) {\n        const route = request.route;\n        if (route.path) {\n          getIsolationScope().setTransactionName(`${route.method.toUpperCase()} ${route.path}`);\n        }\n      } else {\n        DEBUG_BUILD &&\n          debug.warn('Isolation scope is still the default isolation scope - skipping setting transactionName');\n      }\n\n      if (isErrorEvent(event)) {\n        sendErrorToSentry(event.error);\n      }\n    });\n  },\n};\n\n/**\n * Add a Hapi plugin to capture errors to Sentry.\n *\n * @param server The Hapi server to attach the error handler to\n *\n * @example\n * ```javascript\n * const Sentry = require('@sentry/node');\n * const Hapi = require('@hapi/hapi');\n *\n * const init = async () => {\n *   const server = Hapi.server();\n *\n *   // all your routes here\n *\n *   await Sentry.setupHapiErrorHandler(server);\n *\n *   await server.start();\n * };\n * ```\n */\nexport async function setupHapiErrorHandler(server: Server): Promise<void> {\n  await server.register(hapiErrorPlugin);\n}\n"],"names":["captureException","SDK_VERSION","getIsolationScope","getDefaultIsolationScope","DEBUG_BUILD","debug"],"mappings":";;;;;AAIA,SAAS,aAAa,KAAA,EAAuC;AAC3D,EAAA,OAAO,CAAC,EAAE,KAAA,IAAS,OAAO,UAAU,QAAA,IAAY,OAAA,IAAW,SAAS,KAAA,CAAM,KAAA,CAAA;AAC5E;AAEA,SAAS,kBAAkB,SAAA,EAAyB;AAClD,EAAAA,qBAAA,CAAiB,SAAA,EAAW;AAAA,IAC1B,SAAA,EAAW;AAAA,MACT,IAAA,EAAM,oBAAA;AAAA,MACN,OAAA,EAAS;AAAA;AACX,GACD,CAAA;AACH;AAEO,MAAM,eAAA,GAAkB;AAAA,EAC7B,IAAA,EAAM,uBAAA;AAAA,EACN,OAAA,EAASC,gBAAA;AAAA;AAAA,EAET,QAAA,EAAU,eAAgB,SAAA,EAA6B;AACrD,IAAA,MAAM,MAAA,GAAS,SAAA;AAEf,IAAA,MAAA,CAAO,MAAA,CAAO,EAAA,CAAG,EAAE,IAAA,EAAM,SAAA,EAAW,QAAA,EAAU,CAAC,OAAO,CAAA,EAAE,EAAG,CAAC,OAAA,EAAkB,KAAA,KAAwB;AACpG,MAAA,IAAIC,sBAAA,EAAkB,KAAMC,6BAAA,EAAyB,EAAG;AACtD,QAAA,MAAM,QAAQ,OAAA,CAAQ,KAAA;AACtB,QAAA,IAAI,MAAM,IAAA,EAAM;AACd,UAAAD,sBAAA,EAAkB,CAAE,kBAAA,CAAmB,CAAA,EAAG,KAAA,CAAM,MAAA,CAAO,aAAa,CAAA,CAAA,EAAI,KAAA,CAAM,IAAI,CAAA,CAAE,CAAA;AAAA,QACtF;AAAA,MACF,CAAA,MAAO;AACL,QAAAE,sBAAA,IACEC,UAAA,CAAM,KAAK,yFAAyF,CAAA;AAAA,MACxG;AAEA,MAAA,IAAI,YAAA,CAAa,KAAK,CAAA,EAAG;AACvB,QAAA,iBAAA,CAAkB,MAAM,KAAK,CAAA;AAAA,MAC/B;AAAA,IACF,CAAC,CAAA;AAAA,EACH;AACF;AAuBA,eAAsB,sBAAsB,MAAA,EAA+B;AACzE,EAAA,MAAM,MAAA,CAAO,SAAS,eAAe,CAAA;AACvC;;;;;"}

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

@@ -1,101 +1,43 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 
 const serverUtils = require('@sentry/server-utils');
-const http = require('../http.js');
-const index$g = require('./amqplib/index.js');
-const index$k = require('./anthropic-ai/index.js');
-const index = require('./connect/index.js');
-const express = require('./express.js');
-const index$1 = require('./fastify/index.js');
-const firebase = require('./firebase/firebase.js');
-const index$f = require('./genericPool/index.js');
-const index$l = require('./google-genai/index.js');
-const index$c = require('./graphql/index.js');
-const index$2 = require('./hapi/index.js');
-const index$3 = require('./hono/index.js');
-const index$4 = require('./kafka/index.js');
-const index$5 = require('./koa/index.js');
-const index$h = require('./langchain/index.js');
-const index$m = require('./langgraph/index.js');
-const index$6 = require('./lrumemoizer/index.js');
-const index$7 = require('./mongo/index.js');
-const index$8 = require('./mongoose/index.js');
-const index$9 = require('./mysql/index.js');
-const index$a = require('./mysql2/index.js');
-const index$j = require('./openai/index.js');
-const index$b = require('./postgres/index.js');
-const postgresjs = require('./postgresjs.js');
-const index$d = require('./redis/index.js');
-const index$e = require('./tedious/index.js');
-const index$i = require('./vercelai/index.js');
+const orchestrion = require('@sentry/server-utils/orchestrion');
+const index = require('./fastify/index.js');
+const index$1 = require('./redis/index.js');
 
 function getAutoPerformanceIntegrations() {
   return [
-    express.expressIntegration(),
-    index$1.fastifyIntegration(),
-    index$c.graphqlIntegration(),
-    // eslint-disable-next-line typescript/no-deprecated
-    index$3.honoIntegration(),
-    index$7.mongoIntegration(),
-    index$8.mongooseIntegration(),
-    index$9.mysqlIntegration(),
-    index$a.mysql2Integration(),
-    index$d.redisIntegration(),
-    index$b.postgresIntegration(),
+    orchestrion.expressIntegration(),
+    index.fastifyIntegration(),
+    orchestrion.graphqlDiagnosticsIntegration(),
+    orchestrion.mongodbIntegration(),
+    orchestrion.mongooseIntegration(),
+    orchestrion.mysqlIntegration(),
+    orchestrion.mysql2Integration(),
+    // Redis keeps the node wrapper: it wires the cache `responseHook` into the channel subscribers
+    // and covers all redis client versions (native diagnostics_channel + orchestrion fallbacks).
+    index$1.redisIntegration(),
+    orchestrion.postgresIntegration(),
     serverUtils.prismaIntegration(),
-    index$2.hapiIntegration(),
-    index$5.koaIntegration(),
-    index.connectIntegration(),
-    index$e.tediousIntegration(),
-    index$f.genericPoolIntegration(),
-    index$4.kafkaIntegration(),
-    index$g.amqplibIntegration(),
-    index$6.lruMemoizerIntegration(),
+    orchestrion.hapiIntegration(),
+    orchestrion.koaIntegration(),
+    orchestrion.tediousIntegration(),
+    orchestrion.genericPoolIntegration(),
+    orchestrion.kafkajsIntegration(),
+    orchestrion.amqplibIntegration(),
+    orchestrion.lruMemoizerIntegration(),
     // AI providers
     // LangChain must come first to disable AI provider integrations before they instrument
-    index$h.langChainIntegration(),
-    index$m.langGraphIntegration(),
-    index$i.vercelAIIntegration(),
-    index$j.openAIIntegration(),
-    index$k.anthropicAIIntegration(),
-    index$l.googleGenAIIntegration(),
-    postgresjs.postgresJsIntegration(),
-    firebase.firebaseIntegration()
-  ];
-}
-function getOpenTelemetryInstrumentationToPreload() {
-  return [
-    http.instrumentSentryHttp,
-    express.instrumentExpress,
-    index.instrumentConnect,
-    index$1.instrumentFastifyV3,
-    index$2.instrumentHapi,
-    index$3.instrumentHono,
-    index$4.instrumentKafka,
-    index$5.instrumentKoa,
-    index$6.instrumentLruMemoizer,
-    index$7.instrumentMongo,
-    index$8.instrumentMongoose,
-    index$9.instrumentMysql,
-    index$a.instrumentMysql2,
-    index$b.instrumentPostgres,
-    index$2.instrumentHapi,
-    index$c.instrumentGraphql,
-    index$d.instrumentRedis,
-    index$e.instrumentTedious,
-    index$f.instrumentGenericPool,
-    index$g.instrumentAmqplib,
-    index$h.instrumentLangChain,
-    index$i.instrumentVercelAi,
-    index$j.instrumentOpenAi,
-    postgresjs.instrumentPostgresJs,
-    firebase.instrumentFirebase,
-    index$k.instrumentAnthropicAi,
-    index$l.instrumentGoogleGenAI,
-    index$m.instrumentLangGraph
+    orchestrion.langChainIntegration(),
+    orchestrion.langGraphIntegration(),
+    orchestrion.vercelAiIntegration(),
+    orchestrion.openaiIntegration(),
+    orchestrion.anthropicIntegration(),
+    orchestrion.googleGenAIIntegration(),
+    orchestrion.postgresJsIntegration(),
+    orchestrion.firebaseIntegration()
   ];
 }
 
 exports.getAutoPerformanceIntegrations = getAutoPerformanceIntegrations;
-exports.getOpenTelemetryInstrumentationToPreload = getOpenTelemetryInstrumentationToPreload;
 //# sourceMappingURL=index.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.js","sources":["../../../../src/integrations/tracing/index.ts"],"sourcesContent":["import type { Integration } from '@sentry/core';\nimport { prismaIntegration } from '@sentry/server-utils';\nimport { instrumentSentryHttp } from '../http';\nimport { amqplibIntegration, instrumentAmqplib } from './amqplib';\nimport { anthropicAIIntegration, instrumentAnthropicAi } from './anthropic-ai';\nimport { connectIntegration, instrumentConnect } from './connect';\nimport { expressIntegration, instrumentExpress } from './express';\nimport { fastifyIntegration, instrumentFastifyV3 } from './fastify';\nimport { firebaseIntegration, instrumentFirebase } from './firebase';\nimport { genericPoolIntegration, instrumentGenericPool } from './genericPool';\nimport { googleGenAIIntegration, instrumentGoogleGenAI } from './google-genai';\nimport { graphqlIntegration, instrumentGraphql } from './graphql';\nimport { hapiIntegration, instrumentHapi } from './hapi';\nimport { honoIntegration, instrumentHono } from './hono';\nimport { instrumentKafka, kafkaIntegration } from './kafka';\nimport { instrumentKoa, koaIntegration } from './koa';\nimport { instrumentLangChain, langChainIntegration } from './langchain';\nimport { instrumentLangGraph, langGraphIntegration } from './langgraph';\nimport { instrumentLruMemoizer, lruMemoizerIntegration } from './lrumemoizer';\nimport { instrumentMongo, mongoIntegration } from './mongo';\nimport { instrumentMongoose, mongooseIntegration } from './mongoose';\nimport { instrumentMysql, mysqlIntegration } from './mysql';\nimport { instrumentMysql2, mysql2Integration } from './mysql2';\nimport { instrumentOpenAi, openAIIntegration } from './openai';\nimport { instrumentPostgres, postgresIntegration } from './postgres';\nimport { instrumentPostgresJs, postgresJsIntegration } from './postgresjs';\nimport { instrumentRedis, redisIntegration } from './redis';\nimport { instrumentTedious, tediousIntegration } from './tedious';\nimport { instrumentVercelAi, vercelAIIntegration } from './vercelai';\n\n/**\n * With OTEL, all performance integrations will be added, as OTEL only initializes them when the patched package is actually required.\n */\nexport function getAutoPerformanceIntegrations(): Integration[] {\n  return [\n    expressIntegration(),\n    fastifyIntegration(),\n    graphqlIntegration(),\n    // eslint-disable-next-line typescript/no-deprecated\n    honoIntegration(),\n    mongoIntegration(),\n    mongooseIntegration(),\n    mysqlIntegration(),\n    mysql2Integration(),\n    redisIntegration(),\n    postgresIntegration(),\n    prismaIntegration(),\n    hapiIntegration(),\n    koaIntegration(),\n    connectIntegration(),\n    tediousIntegration(),\n    genericPoolIntegration(),\n    kafkaIntegration(),\n    amqplibIntegration(),\n    lruMemoizerIntegration(),\n    // AI providers\n    // LangChain must come first to disable AI provider integrations before they instrument\n    langChainIntegration(),\n    langGraphIntegration(),\n    vercelAIIntegration(),\n    openAIIntegration(),\n    anthropicAIIntegration(),\n    googleGenAIIntegration(),\n    postgresJsIntegration(),\n    firebaseIntegration(),\n  ];\n}\n\n/**\n * Get a list of methods to instrument OTEL, when preload instrumentation.\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport function getOpenTelemetryInstrumentationToPreload(): (((options?: any) => void) & { id: string })[] {\n  return [\n    instrumentSentryHttp,\n    instrumentExpress,\n    instrumentConnect,\n    instrumentFastifyV3,\n    instrumentHapi,\n    instrumentHono,\n    instrumentKafka,\n    instrumentKoa,\n    instrumentLruMemoizer,\n    instrumentMongo,\n    instrumentMongoose,\n    instrumentMysql,\n    instrumentMysql2,\n    instrumentPostgres,\n    instrumentHapi,\n    instrumentGraphql,\n    instrumentRedis,\n    instrumentTedious,\n    instrumentGenericPool,\n    instrumentAmqplib,\n    instrumentLangChain,\n    instrumentVercelAi,\n    instrumentOpenAi,\n    instrumentPostgresJs,\n    instrumentFirebase,\n    instrumentAnthropicAi,\n    instrumentGoogleGenAI,\n    instrumentLangGraph,\n  ];\n}\n"],"names":["expressIntegration","fastifyIntegration","graphqlIntegration","honoIntegration","mongoIntegration","mongooseIntegration","mysqlIntegration","mysql2Integration","redisIntegration","postgresIntegration","prismaIntegration","hapiIntegration","koaIntegration","connectIntegration","tediousIntegration","genericPoolIntegration","kafkaIntegration","amqplibIntegration","lruMemoizerIntegration","langChainIntegration","langGraphIntegration","vercelAIIntegration","openAIIntegration","anthropicAIIntegration","googleGenAIIntegration","postgresJsIntegration","firebaseIntegration","instrumentSentryHttp","instrumentExpress","instrumentConnect","instrumentFastifyV3","instrumentHapi","instrumentHono","instrumentKafka","instrumentKoa","instrumentLruMemoizer","instrumentMongo","instrumentMongoose","instrumentMysql","instrumentMysql2","instrumentPostgres","instrumentGraphql","instrumentRedis","instrumentTedious","instrumentGenericPool","instrumentAmqplib","instrumentLangChain","instrumentVercelAi","instrumentOpenAi","instrumentPostgresJs","instrumentFirebase","instrumentAnthropicAi","instrumentGoogleGenAI","instrumentLangGraph"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiCO,SAAS,8BAAA,GAAgD;AAC9D,EAAA,OAAO;AAAA,IACLA,0BAAA,EAAmB;AAAA,IACnBC,0BAAA,EAAmB;AAAA,IACnBC,0BAAA,EAAmB;AAAA;AAAA,IAEnBC,uBAAA,EAAgB;AAAA,IAChBC,wBAAA,EAAiB;AAAA,IACjBC,2BAAA,EAAoB;AAAA,IACpBC,wBAAA,EAAiB;AAAA,IACjBC,yBAAA,EAAkB;AAAA,IAClBC,wBAAA,EAAiB;AAAA,IACjBC,2BAAA,EAAoB;AAAA,IACpBC,6BAAA,EAAkB;AAAA,IAClBC,uBAAA,EAAgB;AAAA,IAChBC,sBAAA,EAAe;AAAA,IACfC,wBAAA,EAAmB;AAAA,IACnBC,0BAAA,EAAmB;AAAA,IACnBC,8BAAA,EAAuB;AAAA,IACvBC,wBAAA,EAAiB;AAAA,IACjBC,0BAAA,EAAmB;AAAA,IACnBC,8BAAA,EAAuB;AAAA;AAAA;AAAA,IAGvBC,4BAAA,EAAqB;AAAA,IACrBC,4BAAA,EAAqB;AAAA,IACrBC,2BAAA,EAAoB;AAAA,IACpBC,yBAAA,EAAkB;AAAA,IAClBC,8BAAA,EAAuB;AAAA,IACvBC,8BAAA,EAAuB;AAAA,IACvBC,gCAAA,EAAsB;AAAA,IACtBC,4BAAA;AAAoB,GACtB;AACF;AAMO,SAAS,wCAAA,GAA2F;AACzG,EAAA,OAAO;AAAA,IACLC,yBAAA;AAAA,IACAC,yBAAA;AAAA,IACAC,uBAAA;AAAA,IACAC,2BAAA;AAAA,IACAC,sBAAA;AAAA,IACAC,sBAAA;AAAA,IACAC,uBAAA;AAAA,IACAC,qBAAA;AAAA,IACAC,6BAAA;AAAA,IACAC,uBAAA;AAAA,IACAC,0BAAA;AAAA,IACAC,uBAAA;AAAA,IACAC,wBAAA;AAAA,IACAC,0BAAA;AAAA,IACAT,sBAAA;AAAA,IACAU,yBAAA;AAAA,IACAC,uBAAA;AAAA,IACAC,yBAAA;AAAA,IACAC,6BAAA;AAAA,IACAC,yBAAA;AAAA,IACAC,2BAAA;AAAA,IACAC,0BAAA;AAAA,IACAC,wBAAA;AAAA,IACAC,+BAAA;AAAA,IACAC,2BAAA;AAAA,IACAC,6BAAA;AAAA,IACAC,6BAAA;AAAA,IACAC;AAAA,GACF;AACF;;;;;"}
+{"version":3,"file":"index.js","sources":["../../../../src/integrations/tracing/index.ts"],"sourcesContent":["import type { Integration } from '@sentry/core';\nimport { prismaIntegration } from '@sentry/server-utils';\nimport {\n  amqplibIntegration,\n  anthropicIntegration,\n  expressIntegration,\n  firebaseIntegration,\n  genericPoolIntegration,\n  googleGenAIIntegration,\n  graphqlDiagnosticsIntegration,\n  hapiIntegration,\n  kafkajsIntegration,\n  koaIntegration,\n  langChainIntegration,\n  langGraphIntegration,\n  lruMemoizerIntegration,\n  mongodbIntegration,\n  mongooseIntegration,\n  mysqlIntegration,\n  mysql2Integration,\n  openaiIntegration,\n  postgresIntegration,\n  postgresJsIntegration,\n  tediousIntegration,\n  vercelAiIntegration,\n} from '@sentry/server-utils/orchestrion';\nimport { fastifyIntegration } from './fastify';\nimport { redisIntegration } from './redis';\n\nexport function getAutoPerformanceIntegrations(): Integration[] {\n  return [\n    expressIntegration(),\n    fastifyIntegration(),\n    graphqlDiagnosticsIntegration(),\n    mongodbIntegration(),\n    mongooseIntegration(),\n    mysqlIntegration(),\n    mysql2Integration(),\n    // Redis keeps the node wrapper: it wires the cache `responseHook` into the channel subscribers\n    // and covers all redis client versions (native diagnostics_channel + orchestrion fallbacks).\n    redisIntegration(),\n    postgresIntegration(),\n    prismaIntegration(),\n    hapiIntegration(),\n    koaIntegration(),\n    tediousIntegration(),\n    genericPoolIntegration(),\n    kafkajsIntegration(),\n    amqplibIntegration(),\n    lruMemoizerIntegration(),\n    // AI providers\n    // LangChain must come first to disable AI provider integrations before they instrument\n    langChainIntegration(),\n    langGraphIntegration(),\n    vercelAiIntegration(),\n    openaiIntegration(),\n    anthropicIntegration(),\n    googleGenAIIntegration(),\n    postgresJsIntegration(),\n    firebaseIntegration(),\n  ];\n}\n"],"names":["expressIntegration","fastifyIntegration","graphqlDiagnosticsIntegration","mongodbIntegration","mongooseIntegration","mysqlIntegration","mysql2Integration","redisIntegration","postgresIntegration","prismaIntegration","hapiIntegration","koaIntegration","tediousIntegration","genericPoolIntegration","kafkajsIntegration","amqplibIntegration","lruMemoizerIntegration","langChainIntegration","langGraphIntegration","vercelAiIntegration","openaiIntegration","anthropicIntegration","googleGenAIIntegration","postgresJsIntegration","firebaseIntegration"],"mappings":";;;;;;;AA6BO,SAAS,8BAAA,GAAgD;AAC9D,EAAA,OAAO;AAAA,IACLA,8BAAA,EAAmB;AAAA,IACnBC,wBAAA,EAAmB;AAAA,IACnBC,yCAAA,EAA8B;AAAA,IAC9BC,8BAAA,EAAmB;AAAA,IACnBC,+BAAA,EAAoB;AAAA,IACpBC,4BAAA,EAAiB;AAAA,IACjBC,6BAAA,EAAkB;AAAA;AAAA;AAAA,IAGlBC,wBAAA,EAAiB;AAAA,IACjBC,+BAAA,EAAoB;AAAA,IACpBC,6BAAA,EAAkB;AAAA,IAClBC,2BAAA,EAAgB;AAAA,IAChBC,0BAAA,EAAe;AAAA,IACfC,8BAAA,EAAmB;AAAA,IACnBC,kCAAA,EAAuB;AAAA,IACvBC,8BAAA,EAAmB;AAAA,IACnBC,8BAAA,EAAmB;AAAA,IACnBC,kCAAA,EAAuB;AAAA;AAAA;AAAA,IAGvBC,gCAAA,EAAqB;AAAA,IACrBC,gCAAA,EAAqB;AAAA,IACrBC,+BAAA,EAAoB;AAAA,IACpBC,6BAAA,EAAkB;AAAA,IAClBC,gCAAA,EAAqB;AAAA,IACrBC,kCAAA,EAAuB;AAAA,IACvBC,iCAAA,EAAsB;AAAA,IACtBC,+BAAA;AAAoB,GACtB;AACF;;;;"}

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

@@ -1,28 +1,7 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 
-const instrumentation = require('./vendored/instrumentation.js');
 const core = require('@sentry/core');
-const nodeCore = require('@sentry/node-core');
 
-const INTEGRATION_NAME = "Koa";
-const instrumentKoa = nodeCore.generateInstrumentOnce(
-  INTEGRATION_NAME,
-  instrumentation.KoaInstrumentation,
-  (options = {}) => {
-    return {
-      ignoreLayersType: options.ignoreLayersType
-    };
-  }
-);
-const _koaIntegration = ((options = {}) => {
-  return {
-    name: INTEGRATION_NAME,
-    setupOnce() {
-      instrumentKoa(options);
-    }
-  };
-});
-const koaIntegration = core.defineIntegration(_koaIntegration);
 const setupKoaErrorHandler = (app) => {
   app.use(async (ctx, next) => {
     try {
@@ -37,10 +16,7 @@ const setupKoaErrorHandler = (app) => {
       throw error;
     }
   });
-  nodeCore.ensureIsWrapped(app.use, "koa");
 };
 
-exports.instrumentKoa = instrumentKoa;
-exports.koaIntegration = koaIntegration;
 exports.setupKoaErrorHandler = setupKoaErrorHandler;
 //# sourceMappingURL=index.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.js","sources":["../../../../../src/integrations/tracing/koa/index.ts"],"sourcesContent":["import type { KoaInstrumentationConfig, KoaLayerType } from './vendored/types';\nimport { KoaInstrumentation } from './vendored/instrumentation';\nimport type { IntegrationFn } from '@sentry/core';\nimport { captureException, defineIntegration } from '@sentry/core';\nimport { ensureIsWrapped, generateInstrumentOnce } from '@sentry/node-core';\n\ninterface KoaOptions {\n  /**\n   * Ignore layers of specified types\n   */\n  ignoreLayersType?: Array<'middleware' | 'router'>;\n}\n\nconst INTEGRATION_NAME = 'Koa' as const;\n\nexport const instrumentKoa = generateInstrumentOnce(\n  INTEGRATION_NAME,\n  KoaInstrumentation,\n  (options: KoaOptions = {}) => {\n    return {\n      ignoreLayersType: options.ignoreLayersType as KoaLayerType[],\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","defineIntegration","captureException","ensureIsWrapped"],"mappings":";;;;;;AAaA,MAAM,gBAAA,GAAmB,KAAA;AAElB,MAAM,aAAA,GAAgBA,+BAAA;AAAA,EAC3B,gBAAA;AAAA,EACAC,kCAAA;AAAA,EACA,CAAC,OAAA,GAAsB,EAAC,KAAM;AAC5B,IAAA,OAAO;AAAA,MACL,kBAAkB,OAAA,CAAQ;AAAA,KAC5B;AAAA,EACF;AACF;AAEA,MAAM,eAAA,IAAmB,CAAC,OAAA,GAAsB,EAAC,KAAM;AACrD,EAAA,OAAO;AAAA,IACL,IAAA,EAAM,gBAAA;AAAA,IACN,SAAA,GAAY;AACV,MAAA,aAAA,CAAc,OAAO,CAAA;AAAA,IACvB;AAAA,GACF;AACF,CAAA,CAAA;AAkCO,MAAM,cAAA,GAAiBC,uBAAkB,eAAe;AAyBxD,MAAM,oBAAA,GAAuB,CAAC,GAAA,KAA+E;AAClH,EAAA,GAAA,CAAI,GAAA,CAAI,OAAO,GAAA,EAAK,IAAA,KAAS;AAC3B,IAAA,IAAI;AACF,MAAA,MAAM,IAAA,EAAK;AAAA,IACb,SAAS,KAAA,EAAO;AACd,MAAAC,qBAAA,CAAiB,KAAA,EAAO;AAAA,QACtB,SAAA,EAAW;AAAA,UACT,OAAA,EAAS,KAAA;AAAA,UACT,IAAA,EAAM;AAAA;AACR,OACD,CAAA;AACD,MAAA,MAAM,KAAA;AAAA,IACR;AAAA,EACF,CAAC,CAAA;AAED,EAAAC,wBAAA,CAAgB,GAAA,CAAI,KAAK,KAAK,CAAA;AAChC;;;;;;"}
+{"version":3,"file":"index.js","sources":["../../../../../src/integrations/tracing/koa/index.ts"],"sourcesContent":["import { captureException } from '@sentry/core';\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"],"names":["captureException"],"mappings":";;;;AAyBO,MAAM,oBAAA,GAAuB,CAAC,GAAA,KAA+E;AAClH,EAAA,GAAA,CAAI,GAAA,CAAI,OAAO,GAAA,EAAK,IAAA,KAAS;AAC3B,IAAA,IAAI;AACF,MAAA,MAAM,IAAA,EAAK;AAAA,IACb,SAAS,KAAA,EAAO;AACd,MAAAA,qBAAA,CAAiB,KAAA,EAAO;AAAA,QACtB,SAAA,EAAW;AAAA,UACT,OAAA,EAAS,KAAA;AAAA,UACT,IAAA,EAAM;AAAA;AACR,OACD,CAAA;AACD,MAAA,MAAM,KAAA;AAAA,IACR;AAAA,EACF,CAAC,CAAA;AACH;;;;"}

package/build/cjs/integrations/tracing/redis/cache.js

@@ -2,6 +2,7 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 
 const core = require('@sentry/core');
 const redisCache = require('../../../utils/redisCache.js');
+const attributes = require('@sentry/conventions/attributes');
 
 exports._redisOptions = {};
 function setRedisOptions(options) {
@@ -13,11 +14,11 @@ const cacheResponseHook = (span, redisCommand, cmdArgs, response) => {
   if (!safeKey || !cacheOperation || !exports._redisOptions.cachePrefixes || !redisCache.shouldConsiderForCache(redisCommand, safeKey, exports._redisOptions.cachePrefixes)) {
     return;
   }
-  const spanData = core.spanToJSON(span).data;
-  const networkPeerAddress = spanData["net.peer.name"] ?? spanData["server.address"];
-  const networkPeerPort = spanData["net.peer.port"] ?? spanData["server.port"];
+  const attributes$1 = core.spanToJSON(span).attributes;
+  const networkPeerAddress = attributes$1[attributes.NET_PEER_NAME] ?? attributes$1[attributes.SERVER_ADDRESS];
+  const networkPeerPort = attributes$1[attributes.NET_PEER_PORT] ?? attributes$1[attributes.SERVER_PORT];
   if (networkPeerPort && networkPeerAddress) {
-    span.setAttributes({ "network.peer.address": networkPeerAddress, "network.peer.port": networkPeerPort });
+    span.setAttributes({ [attributes.NETWORK_PEER_ADDRESS]: networkPeerAddress, [attributes.NETWORK_PEER_PORT]: networkPeerPort });
   }
   const cacheItemSize = redisCache.isInCommands(redisCache.REMOVE_COMMANDS, redisCommand) ? void 0 : redisCache.calculateCacheItemSize(response);
   if (cacheItemSize) {
@@ -34,6 +35,7 @@ const cacheResponseHook = (span, redisCommand, cmdArgs, response) => {
   span.updateName(
     exports._redisOptions.maxCacheKeyLength ? core.truncate(spanDescription, exports._redisOptions.maxCacheKeyLength) : spanDescription
   );
+  span.setAttribute(core.SEMANTIC_ATTRIBUTE_SENTRY_SOURCE, void 0);
 };
 
 exports.cacheResponseHook = cacheResponseHook;

package/build/cjs/integrations/tracing/redis/cache.js.map

@@ -1 +1 @@
-{"version":3,"file":"cache.js","sources":["../../../../../src/integrations/tracing/redis/cache.ts"],"sourcesContent":["import type { Span } from '@sentry/core';\nimport {\n  SEMANTIC_ATTRIBUTE_CACHE_HIT,\n  SEMANTIC_ATTRIBUTE_CACHE_ITEM_SIZE,\n  SEMANTIC_ATTRIBUTE_CACHE_KEY,\n  SEMANTIC_ATTRIBUTE_SENTRY_OP,\n  spanToJSON,\n  truncate,\n} from '@sentry/core';\nimport type { IORedisCommandArgs } from '../../../utils/redisCache';\nimport {\n  calculateCacheItemSize,\n  GET_COMMANDS,\n  getCacheKeySafely,\n  getCacheOperation,\n  isInCommands,\n  REMOVE_COMMANDS,\n  shouldConsiderForCache,\n} from '../../../utils/redisCache';\nimport type { IORedisResponseCustomAttributeFunction } from './vendored/types';\n\n// This module deliberately does NOT import the vendored OTel `IORedisInstrumentation`/\n// `RedisInstrumentation`, so the orchestrion opt-in can pull `cacheResponseHook`\n// without dragging the OTel redis instrumentation into its module graph.\n\nexport interface RedisOptions {\n  /**\n   * Define cache prefixes for cache keys that should be captured as a cache span.\n   *\n   * Setting this to, for example, `['user:']` will capture cache keys that start with `user:`.\n   */\n  cachePrefixes?: string[];\n  /**\n   * Maximum length of the cache key added to the span description. If the key exceeds this length, it will be truncated.\n   *\n   * Passing `0` will use the full cache key without truncation.\n   *\n   * By default, the full cache key is used.\n   */\n  maxCacheKeyLength?: number;\n}\n\n/* Only exported for testing purposes */\nexport let _redisOptions: RedisOptions = {};\n\n/** Set the options consumed by {@link cacheResponseHook}. */\nexport function setRedisOptions(options: RedisOptions): void {\n  _redisOptions = options;\n}\n\n/* Only exported for testing purposes */\nexport const cacheResponseHook: IORedisResponseCustomAttributeFunction = (\n  span: Span,\n  redisCommand: string,\n  cmdArgs: IORedisCommandArgs,\n  response: unknown,\n) => {\n  const safeKey = getCacheKeySafely(redisCommand, cmdArgs);\n  const cacheOperation = getCacheOperation(redisCommand);\n\n  if (\n    !safeKey ||\n    !cacheOperation ||\n    !_redisOptions.cachePrefixes ||\n    !shouldConsiderForCache(redisCommand, safeKey, _redisOptions.cachePrefixes)\n  ) {\n    // not relevant for cache\n    return;\n  }\n\n  // otel/ioredis seems to be using the old standard, as there was a change to those params: https://github.com/open-telemetry/opentelemetry-specification/issues/3199\n  // We are using params based on the docs: https://opentelemetry.io/docs/specs/semconv/attributes-registry/network/\n  // Fall back to stable semconv attributes (server.address/server.port) when\n  // old-semconv ones are absent, eg OTEL_SEMCONV_STABILITY_OPT_IN=database\n  // set for node-redis v4/v5.\n  const spanData = spanToJSON(span).data;\n  const networkPeerAddress = spanData['net.peer.name'] ?? spanData['server.address'];\n  const networkPeerPort = spanData['net.peer.port'] ?? spanData['server.port'];\n  if (networkPeerPort && networkPeerAddress) {\n    span.setAttributes({ 'network.peer.address': networkPeerAddress, 'network.peer.port': networkPeerPort });\n  }\n\n  // A remove response is a delete-count, not a cached value, so its size is meaningless.\n  const cacheItemSize = isInCommands(REMOVE_COMMANDS, redisCommand) ? undefined : calculateCacheItemSize(response);\n\n  if (cacheItemSize) {\n    span.setAttribute(SEMANTIC_ATTRIBUTE_CACHE_ITEM_SIZE, cacheItemSize);\n  }\n\n  if (isInCommands(GET_COMMANDS, redisCommand) && cacheItemSize !== undefined) {\n    span.setAttribute(SEMANTIC_ATTRIBUTE_CACHE_HIT, cacheItemSize > 0);\n  }\n\n  span.setAttributes({\n    [SEMANTIC_ATTRIBUTE_SENTRY_OP]: cacheOperation,\n    [SEMANTIC_ATTRIBUTE_CACHE_KEY]: safeKey,\n  });\n\n  // todo: change to string[] once EAP supports it\n  const spanDescription = safeKey.join(', ');\n\n  span.updateName(\n    _redisOptions.maxCacheKeyLength ? truncate(spanDescription, _redisOptions.maxCacheKeyLength) : spanDescription,\n  );\n};\n"],"names":["_redisOptions","getCacheKeySafely","getCacheOperation","shouldConsiderForCache","spanToJSON","isInCommands","REMOVE_COMMANDS","calculateCacheItemSize","SEMANTIC_ATTRIBUTE_CACHE_ITEM_SIZE","GET_COMMANDS","SEMANTIC_ATTRIBUTE_CACHE_HIT","SEMANTIC_ATTRIBUTE_SENTRY_OP","SEMANTIC_ATTRIBUTE_CACHE_KEY","truncate"],"mappings":";;;;;AA2CWA,wBAA8B;AAGlC,SAAS,gBAAgB,OAAA,EAA6B;AAC3D,EAAAA,qBAAA,GAAgB,OAAA;AAClB;AAGO,MAAM,iBAAA,GAA4D,CACvE,IAAA,EACA,YAAA,EACA,SACA,QAAA,KACG;AACH,EAAA,MAAM,OAAA,GAAUC,4BAAA,CAAkB,YAAA,EAAc,OAAO,CAAA;AACvD,EAAA,MAAM,cAAA,GAAiBC,6BAAkB,YAAY,CAAA;AAErD,EAAA,IACE,CAAC,OAAA,IACD,CAAC,cAAA,IACD,CAACF,qBAAA,CAAc,aAAA,IACf,CAACG,iCAAA,CAAuB,YAAA,EAAc,OAAA,EAASH,qBAAA,CAAc,aAAa,CAAA,EAC1E;AAEA,IAAA;AAAA,EACF;AAOA,EAAA,MAAM,QAAA,GAAWI,eAAA,CAAW,IAAI,CAAA,CAAE,IAAA;AAClC,EAAA,MAAM,kBAAA,GAAqB,QAAA,CAAS,eAAe,CAAA,IAAK,SAAS,gBAAgB,CAAA;AACjF,EAAA,MAAM,eAAA,GAAkB,QAAA,CAAS,eAAe,CAAA,IAAK,SAAS,aAAa,CAAA;AAC3E,EAAA,IAAI,mBAAmB,kBAAA,EAAoB;AACzC,IAAA,IAAA,CAAK,cAAc,EAAE,sBAAA,EAAwB,kBAAA,EAAoB,mBAAA,EAAqB,iBAAiB,CAAA;AAAA,EACzG;AAGA,EAAA,MAAM,gBAAgBC,uBAAA,CAAaC,0BAAA,EAAiB,YAAY,CAAA,GAAI,MAAA,GAAYC,kCAAuB,QAAQ,CAAA;AAE/G,EAAA,IAAI,aAAA,EAAe;AACjB,IAAA,IAAA,CAAK,YAAA,CAAaC,yCAAoC,aAAa,CAAA;AAAA,EACrE;AAEA,EAAA,IAAIH,uBAAA,CAAaI,uBAAA,EAAc,YAAY,CAAA,IAAK,kBAAkB,MAAA,EAAW;AAC3E,IAAA,IAAA,CAAK,YAAA,CAAaC,iCAAA,EAA8B,aAAA,GAAgB,CAAC,CAAA;AAAA,EACnE;AAEA,EAAA,IAAA,CAAK,aAAA,CAAc;AAAA,IACjB,CAACC,iCAA4B,GAAG,cAAA;AAAA,IAChC,CAACC,iCAA4B,GAAG;AAAA,GACjC,CAAA;AAGD,EAAA,MAAM,eAAA,GAAkB,OAAA,CAAQ,IAAA,CAAK,IAAI,CAAA;AAEzC,EAAA,IAAA,CAAK,UAAA;AAAA,IACHZ,sBAAc,iBAAA,GAAoBa,aAAA,CAAS,eAAA,EAAiBb,qBAAA,CAAc,iBAAiB,CAAA,GAAI;AAAA,GACjG;AACF;;;;;"}
+{"version":3,"file":"cache.js","sources":["../../../../../src/integrations/tracing/redis/cache.ts"],"sourcesContent":["import type { Span } from '@sentry/core';\nimport {\n  SEMANTIC_ATTRIBUTE_CACHE_HIT,\n  SEMANTIC_ATTRIBUTE_CACHE_ITEM_SIZE,\n  SEMANTIC_ATTRIBUTE_CACHE_KEY,\n  SEMANTIC_ATTRIBUTE_SENTRY_OP,\n  SEMANTIC_ATTRIBUTE_SENTRY_SOURCE,\n  spanToJSON,\n  truncate,\n} from '@sentry/core';\nimport type { IORedisCommandArgs } from '../../../utils/redisCache';\nimport {\n  calculateCacheItemSize,\n  GET_COMMANDS,\n  getCacheKeySafely,\n  getCacheOperation,\n  isInCommands,\n  REMOVE_COMMANDS,\n  shouldConsiderForCache,\n} from '../../../utils/redisCache';\nimport type { IORedisResponseCustomAttributeFunction } from './vendored/types';\nimport {\n  NET_PEER_NAME,\n  NET_PEER_PORT,\n  NETWORK_PEER_ADDRESS,\n  NETWORK_PEER_PORT,\n  SERVER_ADDRESS,\n  SERVER_PORT,\n} from '@sentry/conventions/attributes';\n\n// This module deliberately does NOT import the vendored OTel `IORedisInstrumentation`/\n// `RedisInstrumentation`, so the orchestrion opt-in can pull `cacheResponseHook`\n// without dragging the OTel redis instrumentation into its module graph.\n\nexport interface RedisOptions {\n  /**\n   * Define cache prefixes for cache keys that should be captured as a cache span.\n   *\n   * Setting this to, for example, `['user:']` will capture cache keys that start with `user:`.\n   */\n  cachePrefixes?: string[];\n  /**\n   * Maximum length of the cache key added to the span description. If the key exceeds this length, it will be truncated.\n   *\n   * Passing `0` will use the full cache key without truncation.\n   *\n   * By default, the full cache key is used.\n   */\n  maxCacheKeyLength?: number;\n}\n\n/* Only exported for testing purposes */\nexport let _redisOptions: RedisOptions = {};\n\n/** Set the options consumed by {@link cacheResponseHook}. */\nexport function setRedisOptions(options: RedisOptions): void {\n  _redisOptions = options;\n}\n\n/* Only exported for testing purposes */\nexport const cacheResponseHook: IORedisResponseCustomAttributeFunction = (\n  span: Span,\n  redisCommand: string,\n  cmdArgs: IORedisCommandArgs,\n  response: unknown,\n) => {\n  const safeKey = getCacheKeySafely(redisCommand, cmdArgs);\n  const cacheOperation = getCacheOperation(redisCommand);\n\n  if (\n    !safeKey ||\n    !cacheOperation ||\n    !_redisOptions.cachePrefixes ||\n    !shouldConsiderForCache(redisCommand, safeKey, _redisOptions.cachePrefixes)\n  ) {\n    // not relevant for cache\n    return;\n  }\n\n  // otel/ioredis seems to be using the old standard, as there was a change to those params: https://github.com/open-telemetry/opentelemetry-specification/issues/3199\n  // We are using params based on the docs: https://opentelemetry.io/docs/specs/semconv/attributes-registry/network/\n  // Fall back to stable semconv attributes (server.address/server.port) when\n  // old-semconv ones are absent, eg OTEL_SEMCONV_STABILITY_OPT_IN=database\n  // set for node-redis v4/v5.\n  const attributes = spanToJSON(span).attributes;\n  // oxlint-disable-next-line typescript/no-deprecated\n  const networkPeerAddress = (attributes[NET_PEER_NAME] ?? attributes[SERVER_ADDRESS]) as string | undefined;\n  // oxlint-disable-next-line typescript/no-deprecated\n  const networkPeerPort = (attributes[NET_PEER_PORT] ?? attributes[SERVER_PORT]) as number | undefined;\n\n  if (networkPeerPort && networkPeerAddress) {\n    span.setAttributes({ [NETWORK_PEER_ADDRESS]: networkPeerAddress, [NETWORK_PEER_PORT]: networkPeerPort });\n  }\n\n  // A remove response is a delete-count, not a cached value, so its size is meaningless.\n  const cacheItemSize = isInCommands(REMOVE_COMMANDS, redisCommand) ? undefined : calculateCacheItemSize(response);\n\n  if (cacheItemSize) {\n    span.setAttribute(SEMANTIC_ATTRIBUTE_CACHE_ITEM_SIZE, cacheItemSize);\n  }\n\n  if (isInCommands(GET_COMMANDS, redisCommand) && cacheItemSize !== undefined) {\n    span.setAttribute(SEMANTIC_ATTRIBUTE_CACHE_HIT, cacheItemSize > 0);\n  }\n\n  span.setAttributes({\n    [SEMANTIC_ATTRIBUTE_SENTRY_OP]: cacheOperation,\n    [SEMANTIC_ATTRIBUTE_CACHE_KEY]: safeKey,\n  });\n\n  // todo: change to string[] once EAP supports it\n  const spanDescription = safeKey.join(', ');\n\n  span.updateName(\n    _redisOptions.maxCacheKeyLength ? truncate(spanDescription, _redisOptions.maxCacheKeyLength) : spanDescription,\n  );\n  span.setAttribute(SEMANTIC_ATTRIBUTE_SENTRY_SOURCE, undefined);\n};\n"],"names":["_redisOptions","getCacheKeySafely","getCacheOperation","shouldConsiderForCache","attributes","spanToJSON","NET_PEER_NAME","SERVER_ADDRESS","NET_PEER_PORT","SERVER_PORT","NETWORK_PEER_ADDRESS","NETWORK_PEER_PORT","isInCommands","REMOVE_COMMANDS","calculateCacheItemSize","SEMANTIC_ATTRIBUTE_CACHE_ITEM_SIZE","GET_COMMANDS","SEMANTIC_ATTRIBUTE_CACHE_HIT","SEMANTIC_ATTRIBUTE_SENTRY_OP","SEMANTIC_ATTRIBUTE_CACHE_KEY","truncate","SEMANTIC_ATTRIBUTE_SENTRY_SOURCE"],"mappings":";;;;;;AAoDWA,wBAA8B;AAGlC,SAAS,gBAAgB,OAAA,EAA6B;AAC3D,EAAAA,qBAAA,GAAgB,OAAA;AAClB;AAGO,MAAM,iBAAA,GAA4D,CACvE,IAAA,EACA,YAAA,EACA,SACA,QAAA,KACG;AACH,EAAA,MAAM,OAAA,GAAUC,4BAAA,CAAkB,YAAA,EAAc,OAAO,CAAA;AACvD,EAAA,MAAM,cAAA,GAAiBC,6BAAkB,YAAY,CAAA;AAErD,EAAA,IACE,CAAC,OAAA,IACD,CAAC,cAAA,IACD,CAACF,qBAAA,CAAc,aAAA,IACf,CAACG,iCAAA,CAAuB,YAAA,EAAc,OAAA,EAASH,qBAAA,CAAc,aAAa,CAAA,EAC1E;AAEA,IAAA;AAAA,EACF;AAOA,EAAA,MAAMI,YAAA,GAAaC,eAAA,CAAW,IAAI,CAAA,CAAE,UAAA;AAEpC,EAAA,MAAM,kBAAA,GAAsBD,YAAA,CAAWE,wBAAa,CAAA,IAAKF,aAAWG,yBAAc,CAAA;AAElF,EAAA,MAAM,eAAA,GAAmBH,YAAA,CAAWI,wBAAa,CAAA,IAAKJ,aAAWK,sBAAW,CAAA;AAE5E,EAAA,IAAI,mBAAmB,kBAAA,EAAoB;AACzC,IAAA,IAAA,CAAK,aAAA,CAAc,EAAE,CAACC,+BAAoB,GAAG,oBAAoB,CAACC,4BAAiB,GAAG,eAAA,EAAiB,CAAA;AAAA,EACzG;AAGA,EAAA,MAAM,gBAAgBC,uBAAA,CAAaC,0BAAA,EAAiB,YAAY,CAAA,GAAI,MAAA,GAAYC,kCAAuB,QAAQ,CAAA;AAE/G,EAAA,IAAI,aAAA,EAAe;AACjB,IAAA,IAAA,CAAK,YAAA,CAAaC,yCAAoC,aAAa,CAAA;AAAA,EACrE;AAEA,EAAA,IAAIH,uBAAA,CAAaI,uBAAA,EAAc,YAAY,CAAA,IAAK,kBAAkB,MAAA,EAAW;AAC3E,IAAA,IAAA,CAAK,YAAA,CAAaC,iCAAA,EAA8B,aAAA,GAAgB,CAAC,CAAA;AAAA,EACnE;AAEA,EAAA,IAAA,CAAK,aAAA,CAAc;AAAA,IACjB,CAACC,iCAA4B,GAAG,cAAA;AAAA,IAChC,CAACC,iCAA4B,GAAG;AAAA,GACjC,CAAA;AAGD,EAAA,MAAM,eAAA,GAAkB,OAAA,CAAQ,IAAA,CAAK,IAAI,CAAA;AAEzC,EAAA,IAAA,CAAK,UAAA;AAAA,IACHnB,sBAAc,iBAAA,GAAoBoB,aAAA,CAAS,eAAA,EAAiBpB,qBAAA,CAAc,iBAAiB,CAAA,GAAI;AAAA,GACjG;AACA,EAAA,IAAA,CAAK,YAAA,CAAaqB,uCAAkC,MAAS,CAAA;AAC/D;;;;;"}

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

@@ -1,40 +1,25 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 
 const core = require('@sentry/core');
-const dc = require('node:diagnostics_channel');
 const serverUtils = require('@sentry/server-utils');
-const nodeCore = require('@sentry/node-core');
-const diagnosticsChannelInjection = require('../../../sdk/diagnosticsChannelInjection.js');
+const orchestrion = require('@sentry/server-utils/orchestrion');
 const cache = require('./cache.js');
-const ioredisInstrumentation = require('./vendored/ioredis-instrumentation.js');
-const redisInstrumentation = require('./vendored/redis-instrumentation.js');
 
 const INTEGRATION_NAME = "Redis";
-const instrumentIORedis = nodeCore.generateInstrumentOnce(`${INTEGRATION_NAME}.IORedis`, () => {
-  return new ioredisInstrumentation.IORedisInstrumentation({
-    responseHook: cache.cacheResponseHook
-  });
-});
-const instrumentRedisModule = nodeCore.generateInstrumentOnce(`${INTEGRATION_NAME}.Redis`, () => {
-  return new redisInstrumentation.RedisInstrumentation({
-    responseHook: cache.cacheResponseHook
-  });
-});
-const instrumentRedis = Object.assign(
-  () => {
-    if (!diagnosticsChannelInjection.isDiagnosticsChannelInjectionEnabled() || !dc.tracingChannel) {
-      instrumentIORedis();
-      instrumentRedisModule();
-    }
-  },
-  { id: INTEGRATION_NAME }
-);
 const _redisIntegration = ((options = {}) => {
+  const orchestrionIntegrations = [
+    orchestrion.ioredisChannelIntegration({ responseHook: cache.cacheResponseHook }),
+    orchestrion.redisChannelIntegration({ responseHook: cache.cacheResponseHook })
+  ];
   return core.extendIntegration(serverUtils.redisIntegration({ responseHook: cache.cacheResponseHook }), {
     name: INTEGRATION_NAME,
     setupOnce() {
       cache.setRedisOptions(options);
-      instrumentRedis();
+    },
+    setup(client) {
+      for (const integration of orchestrionIntegrations) {
+        integration.setup?.(client);
+      }
     }
   });
 });
@@ -45,6 +30,5 @@ Object.defineProperty(exports, "_redisOptions", {
   get: () => cache._redisOptions
 });
 exports.cacheResponseHook = cache.cacheResponseHook;
-exports.instrumentRedis = instrumentRedis;
 exports.redisIntegration = redisIntegration;
 //# sourceMappingURL=index.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.js","sources":["../../../../../src/integrations/tracing/redis/index.ts"],"sourcesContent":["import type { IntegrationFn } from '@sentry/core';\nimport { defineIntegration, extendIntegration } from '@sentry/core';\nimport * as dc from 'node:diagnostics_channel';\nimport { redisIntegration as redisChannelIntegration } from '@sentry/server-utils';\nimport { generateInstrumentOnce } from '@sentry/node-core';\nimport { isDiagnosticsChannelInjectionEnabled } from '../../../sdk/diagnosticsChannelInjection';\nimport { cacheResponseHook, type RedisOptions, setRedisOptions } from './cache';\nimport { IORedisInstrumentation } from './vendored/ioredis-instrumentation';\nimport { RedisInstrumentation } from './vendored/redis-instrumentation';\n\n// `cacheResponseHook`/`_redisOptions` live in `./cache` (which has no OTel\n// instrumentation imports) so the orchestrion opt-in can pull the hook without\n// dragging the OTel redis instrumentation in. Re-exported here for tests.\nexport { _redisOptions, cacheResponseHook } from './cache';\n\nconst INTEGRATION_NAME = 'Redis' as const;\n\nconst instrumentIORedis = generateInstrumentOnce(`${INTEGRATION_NAME}.IORedis`, () => {\n  return new IORedisInstrumentation({\n    responseHook: cacheResponseHook,\n  });\n});\n\nconst instrumentRedisModule = generateInstrumentOnce(`${INTEGRATION_NAME}.Redis`, () => {\n  return new RedisInstrumentation({\n    responseHook: cacheResponseHook,\n  });\n});\n\n/**\n * To be able to preload all Redis OTel instrumentations with just one ID\n * (\"Redis\"), all the instrumentations are generated in this one function\n */\nexport const instrumentRedis = Object.assign(\n  (): void => {\n    // When diagnostics-channel injection is opted in, orchestrion fully owns the older\n    // ioredis (`<5.11.0`) and redis/node-redis (`<5.12.0`) ranges — commands, connect, and\n    // batches — so skip both OTel monkey-patches to avoid double instrumentation. On Node\n    // without `tracingChannel` (<18.19) orchestrion can't run, so keep the OTel patches there.\n    if (!isDiagnosticsChannelInjectionEnabled() || !dc.tracingChannel) {\n      instrumentIORedis();\n      instrumentRedisModule();\n    }\n\n    // todo: implement them gradually\n    // new LegacyRedisInstrumentation({}),\n  },\n  { id: INTEGRATION_NAME },\n);\n\nconst _redisIntegration = ((options: RedisOptions = {}) => {\n  // The diagnostics_channel subscription (node-redis >= 5.12.0, ioredis >= 5.11.0) lives in\n  // server-utils so it is shared across server runtimes; we extend it here to also run the vendored\n  // OTel patchers for older client versions. `cacheResponseHook` reads options set in the extension's\n  // `setupOnce` below, but it only runs at command time, by which point those options are set.\n  return extendIntegration(redisChannelIntegration({ responseHook: cacheResponseHook }), {\n    name: INTEGRATION_NAME,\n    setupOnce() {\n      setRedisOptions(options);\n      instrumentRedis();\n    },\n  });\n}) satisfies IntegrationFn;\n\n/**\n * Adds Sentry tracing instrumentation for the [redis](https://www.npmjs.com/package/redis) and\n * [ioredis](https://www.npmjs.com/package/ioredis) libraries.\n *\n * For more information, see the [`redisIntegration` documentation](https://docs.sentry.io/platforms/javascript/guides/node/configuration/integrations/redis/).\n *\n * @example\n * ```javascript\n * const Sentry = require('@sentry/node');\n *\n * Sentry.init({\n *  integrations: [Sentry.redisIntegration()],\n * });\n * ```\n */\nexport const redisIntegration = defineIntegration(_redisIntegration);\n"],"names":["generateInstrumentOnce","IORedisInstrumentation","cacheResponseHook","RedisInstrumentation","isDiagnosticsChannelInjectionEnabled","extendIntegration","redisChannelIntegration","setRedisOptions","defineIntegration"],"mappings":";;;;;;;;;;;AAeA,MAAM,gBAAA,GAAmB,OAAA;AAEzB,MAAM,iBAAA,GAAoBA,+BAAA,CAAuB,CAAA,EAAG,gBAAgB,YAAY,MAAM;AACpF,EAAA,OAAO,IAAIC,6CAAA,CAAuB;AAAA,IAChC,YAAA,EAAcC;AAAA,GACf,CAAA;AACH,CAAC,CAAA;AAED,MAAM,qBAAA,GAAwBF,+BAAA,CAAuB,CAAA,EAAG,gBAAgB,UAAU,MAAM;AACtF,EAAA,OAAO,IAAIG,yCAAA,CAAqB;AAAA,IAC9B,YAAA,EAAcD;AAAA,GACf,CAAA;AACH,CAAC,CAAA;AAMM,MAAM,kBAAkB,MAAA,CAAO,MAAA;AAAA,EACpC,MAAY;AAKV,IAAA,IAAI,CAACE,gEAAA,EAAqC,IAAK,CAAC,GAAG,cAAA,EAAgB;AACjE,MAAA,iBAAA,EAAkB;AAClB,MAAA,qBAAA,EAAsB;AAAA,IACxB;AAAA,EAIF,CAAA;AAAA,EACA,EAAE,IAAI,gBAAA;AACR;AAEA,MAAM,iBAAA,IAAqB,CAAC,OAAA,GAAwB,EAAC,KAAM;AAKzD,EAAA,OAAOC,uBAAkBC,4BAAA,CAAwB,EAAE,YAAA,EAAcJ,uBAAA,EAAmB,CAAA,EAAG;AAAA,IACrF,IAAA,EAAM,gBAAA;AAAA,IACN,SAAA,GAAY;AACV,MAAAK,qBAAA,CAAgB,OAAO,CAAA;AACvB,MAAA,eAAA,EAAgB;AAAA,IAClB;AAAA,GACD,CAAA;AACH,CAAA,CAAA;AAiBO,MAAM,gBAAA,GAAmBC,uBAAkB,iBAAiB;;;;;;;;;;"}
+{"version":3,"file":"index.js","sources":["../../../../../src/integrations/tracing/redis/index.ts"],"sourcesContent":["import type { IntegrationFn } from '@sentry/core';\nimport { defineIntegration, extendIntegration } from '@sentry/core';\nimport { redisIntegration as redisNativeChannelIntegration } from '@sentry/server-utils';\nimport { ioredisChannelIntegration, redisChannelIntegration } from '@sentry/server-utils/orchestrion';\nimport { cacheResponseHook, type RedisOptions, setRedisOptions } from './cache';\n\n// `cacheResponseHook`/`_redisOptions` live in `./cache` (which has no OTel\n// instrumentation imports) so the orchestrion opt-in can pull the hook without\n// dragging the OTel redis instrumentation in. Re-exported here for tests.\nexport { _redisOptions, cacheResponseHook } from './cache';\n\nconst INTEGRATION_NAME = 'Redis' as const;\n\nconst _redisIntegration = ((options: RedisOptions = {}) => {\n  // A single public `Redis` integration covers every redis client version. The native\n  // diagnostics_channel subscription (node-redis >= 5.12.0, ioredis >= 5.11.0, and batches) lives in\n  // server-utils so it is shared across server runtimes; the orchestrion channel integrations cover\n  // the older node-redis (`<5.12.0`) and ioredis (`<5.11.0`) ranges. We fold the orchestrion\n  // subscribers into this integration's `setup` so `Sentry.redisIntegration()` alone instruments\n  // all ranges, even with `defaultIntegrations: []`. All three share the node cache `responseHook`,\n  // which reads the options set below but only runs at command time, by which point they are set.\n  const orchestrionIntegrations = [\n    ioredisChannelIntegration({ responseHook: cacheResponseHook }),\n    redisChannelIntegration({ responseHook: cacheResponseHook }),\n  ];\n\n  return extendIntegration(redisNativeChannelIntegration({ responseHook: cacheResponseHook }), {\n    name: INTEGRATION_NAME,\n    setupOnce() {\n      setRedisOptions(options);\n    },\n    setup(client) {\n      for (const integration of orchestrionIntegrations) {\n        integration.setup?.(client);\n      }\n    },\n  });\n}) satisfies IntegrationFn;\n\n/**\n * Adds Sentry tracing instrumentation for the [redis](https://www.npmjs.com/package/redis) and\n * [ioredis](https://www.npmjs.com/package/ioredis) libraries.\n *\n * For more information, see the [`redisIntegration` documentation](https://docs.sentry.io/platforms/javascript/guides/node/configuration/integrations/redis/).\n *\n * @example\n * ```javascript\n * const Sentry = require('@sentry/node');\n *\n * Sentry.init({\n *  integrations: [Sentry.redisIntegration()],\n * });\n * ```\n */\nexport const redisIntegration = defineIntegration(_redisIntegration);\n"],"names":["ioredisChannelIntegration","cacheResponseHook","redisChannelIntegration","extendIntegration","redisNativeChannelIntegration","setRedisOptions","defineIntegration"],"mappings":";;;;;;;AAWA,MAAM,gBAAA,GAAmB,OAAA;AAEzB,MAAM,iBAAA,IAAqB,CAAC,OAAA,GAAwB,EAAC,KAAM;AAQzD,EAAA,MAAM,uBAAA,GAA0B;AAAA,IAC9BA,qCAAA,CAA0B,EAAE,YAAA,EAAcC,uBAAA,EAAmB,CAAA;AAAA,IAC7DC,mCAAA,CAAwB,EAAE,YAAA,EAAcD,uBAAA,EAAmB;AAAA,GAC7D;AAEA,EAAA,OAAOE,uBAAkBC,4BAAA,CAA8B,EAAE,YAAA,EAAcH,uBAAA,EAAmB,CAAA,EAAG;AAAA,IAC3F,IAAA,EAAM,gBAAA;AAAA,IACN,SAAA,GAAY;AACV,MAAAI,qBAAA,CAAgB,OAAO,CAAA;AAAA,IACzB,CAAA;AAAA,IACA,MAAM,MAAA,EAAQ;AACZ,MAAA,KAAA,MAAW,eAAe,uBAAA,EAAyB;AACjD,QAAA,WAAA,CAAY,QAAQ,MAAM,CAAA;AAAA,MAC5B;AAAA,IACF;AAAA,GACD,CAAA;AACH,CAAA,CAAA;AAiBO,MAAM,gBAAA,GAAmBC,uBAAkB,iBAAiB;;;;;;;;;"}