@depup/sentry__node 10.47.0-depup.1 → 10.67.0-depup.0

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

@@ -0,0 +1,43 @@
+import { defineIntegration, extendIntegration } from '@sentry/core';
+import * as dc from 'node:diagnostics_channel';
+import { redisIntegration as redisIntegration$1 } from '@sentry/server-utils';
+import { generateInstrumentOnce } from '@sentry/node-core';
+import { isDiagnosticsChannelInjectionEnabled } from '../../../sdk/diagnosticsChannelInjection.js';
+import { cacheResponseHook, setRedisOptions } from './cache.js';
+export { _redisOptions } from './cache.js';
+import { IORedisInstrumentation } from './vendored/ioredis-instrumentation.js';
+import { RedisInstrumentation } from './vendored/redis-instrumentation.js';
+
+const INTEGRATION_NAME = "Redis";
+const instrumentIORedis = generateInstrumentOnce(`${INTEGRATION_NAME}.IORedis`, () => {
+  return new IORedisInstrumentation({
+    responseHook: cacheResponseHook
+  });
+});
+const instrumentRedisModule = generateInstrumentOnce(`${INTEGRATION_NAME}.Redis`, () => {
+  return new RedisInstrumentation({
+    responseHook: cacheResponseHook
+  });
+});
+const instrumentRedis = Object.assign(
+  () => {
+    if (!isDiagnosticsChannelInjectionEnabled() || !dc.tracingChannel) {
+      instrumentIORedis();
+      instrumentRedisModule();
+    }
+  },
+  { id: INTEGRATION_NAME }
+);
+const _redisIntegration = ((options = {}) => {
+  return extendIntegration(redisIntegration$1({ responseHook: cacheResponseHook }), {
+    name: INTEGRATION_NAME,
+    setupOnce() {
+      setRedisOptions(options);
+      instrumentRedis();
+    }
+  });
+});
+const redisIntegration = defineIntegration(_redisIntegration);
+
+export { cacheResponseHook, instrumentRedis, redisIntegration };
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +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":["redisChannelIntegration"],"mappings":";;;;;;;;;;AAeA,MAAM,gBAAA,GAAmB,OAAA;AAEzB,MAAM,iBAAA,GAAoB,sBAAA,CAAuB,CAAA,EAAG,gBAAgB,YAAY,MAAM;AACpF,EAAA,OAAO,IAAI,sBAAA,CAAuB;AAAA,IAChC,YAAA,EAAc;AAAA,GACf,CAAA;AACH,CAAC,CAAA;AAED,MAAM,qBAAA,GAAwB,sBAAA,CAAuB,CAAA,EAAG,gBAAgB,UAAU,MAAM;AACtF,EAAA,OAAO,IAAI,oBAAA,CAAqB;AAAA,IAC9B,YAAA,EAAc;AAAA,GACf,CAAA;AACH,CAAC,CAAA;AAMM,MAAM,kBAAkB,MAAA,CAAO,MAAA;AAAA,EACpC,MAAY;AAKV,IAAA,IAAI,CAAC,oCAAA,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,OAAO,kBAAkBA,kBAAA,CAAwB,EAAE,YAAA,EAAc,iBAAA,EAAmB,CAAA,EAAG;AAAA,IACrF,IAAA,EAAM,gBAAA;AAAA,IACN,SAAA,GAAY;AACV,MAAA,eAAA,CAAgB,OAAO,CAAA;AACvB,MAAA,eAAA,EAAgB;AAAA,IAClB;AAAA,GACD,CAAA;AACH,CAAA,CAAA;AAiBO,MAAM,gBAAA,GAAmB,kBAAkB,iBAAiB;;;;"}

package/build/esm/integrations/tracing/redis/vendored/ioredis-instrumentation.js

@@ -0,0 +1,145 @@
+import { InstrumentationBase, InstrumentationNodeModuleDefinition, isWrapped } from '@opentelemetry/instrumentation';
+import { SDK_VERSION, getActiveSpan, startInactiveSpan, SPAN_KIND, SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN, SPAN_STATUS_ERROR } from '@sentry/core';
+import { DB_STATEMENT, NET_PEER_PORT, NET_PEER_NAME, DB_SYSTEM } from '@sentry/conventions/attributes';
+import { defaultDbStatementSerializer } from '@sentry/server-utils';
+import { DB_SYSTEM_VALUE_REDIS, ATTR_DB_CONNECTION_STRING } from './semconv.js';
+
+const PACKAGE_NAME = "@sentry/instrumentation-ioredis";
+const ORIGIN = "auto.db.otel.redis";
+const SUPPORTED_VERSIONS = [">=2.0.0 <5.11.0"];
+function endSpan(span, err) {
+  if (err) {
+    span.setStatus({ code: SPAN_STATUS_ERROR, message: err.message });
+  }
+  span.end();
+}
+class IORedisInstrumentation extends InstrumentationBase {
+  constructor(config = {}) {
+    super(PACKAGE_NAME, SDK_VERSION, config);
+  }
+  init() {
+    return [
+      new InstrumentationNodeModuleDefinition(
+        "ioredis",
+        SUPPORTED_VERSIONS,
+        (module) => {
+          const moduleExports = module[Symbol.toStringTag] === "Module" && module.default ? module.default : module;
+          if (isWrapped(moduleExports.prototype.sendCommand)) {
+            this._unwrap(moduleExports.prototype, "sendCommand");
+          }
+          this._wrap(moduleExports.prototype, "sendCommand", this._patchSendCommand());
+          if (isWrapped(moduleExports.prototype.connect)) {
+            this._unwrap(moduleExports.prototype, "connect");
+          }
+          this._wrap(moduleExports.prototype, "connect", this._patchConnection());
+          return module;
+        },
+        (module) => {
+          if (module === void 0) return;
+          const moduleExports = module[Symbol.toStringTag] === "Module" && module.default ? module.default : module;
+          this._unwrap(moduleExports.prototype, "sendCommand");
+          this._unwrap(moduleExports.prototype, "connect");
+        }
+      )
+    ];
+  }
+  _patchSendCommand() {
+    const instrumentation = this;
+    return (original) => {
+      return function(...args) {
+        const cmd = args[0];
+        if (args.length < 1 || typeof cmd !== "object" || !getActiveSpan()) {
+          return original.apply(this, args);
+        }
+        const { host, port } = this.options;
+        const attributes = {
+          // oxlint-disable-next-line typescript/no-deprecated
+          [DB_SYSTEM]: DB_SYSTEM_VALUE_REDIS,
+          // oxlint-disable-next-line typescript/no-deprecated
+          [DB_STATEMENT]: defaultDbStatementSerializer(cmd.name, cmd.args),
+          [ATTR_DB_CONNECTION_STRING]: `redis://${host}:${port}`,
+          // oxlint-disable-next-line typescript/no-deprecated
+          [NET_PEER_NAME]: host,
+          // oxlint-disable-next-line typescript/no-deprecated
+          [NET_PEER_PORT]: port,
+          [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: ORIGIN
+        };
+        const span = startInactiveSpan({ name: cmd.name, kind: SPAN_KIND.CLIENT, attributes });
+        try {
+          const result = original.apply(this, args);
+          const origResolve = cmd.resolve;
+          cmd.resolve = function(response) {
+            instrumentation._callResponseHook(span, cmd, response);
+            endSpan(span, null);
+            origResolve(response);
+          };
+          const origReject = cmd.reject;
+          cmd.reject = function(err) {
+            endSpan(span, err);
+            origReject(err);
+          };
+          return result;
+        } catch (error) {
+          endSpan(span, error);
+          throw error;
+        }
+      };
+    };
+  }
+  _patchConnection() {
+    return (original) => {
+      return function(...args) {
+        if (!getActiveSpan()) {
+          return original.apply(this, args);
+        }
+        const { host, port } = this.options;
+        const attributes = {
+          // oxlint-disable-next-line typescript/no-deprecated
+          [DB_SYSTEM]: DB_SYSTEM_VALUE_REDIS,
+          // oxlint-disable-next-line typescript/no-deprecated
+          [DB_STATEMENT]: "connect",
+          [ATTR_DB_CONNECTION_STRING]: `redis://${host}:${port}`,
+          // oxlint-disable-next-line typescript/no-deprecated
+          [NET_PEER_NAME]: host,
+          // oxlint-disable-next-line typescript/no-deprecated
+          [NET_PEER_PORT]: port,
+          [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: ORIGIN
+        };
+        const span = startInactiveSpan({ name: "connect", kind: SPAN_KIND.CLIENT, attributes });
+        try {
+          const result = original.apply(this, args);
+          if (result instanceof Promise) {
+            return result.then(
+              (value) => {
+                endSpan(span, null);
+                return value;
+              },
+              (error) => {
+                endSpan(span, error);
+                return Promise.reject(error);
+              }
+            );
+          }
+          endSpan(span, null);
+          return result;
+        } catch (error) {
+          endSpan(span, error);
+          throw error;
+        }
+      };
+    };
+  }
+  _callResponseHook(span, cmd, response) {
+    const { responseHook } = this.getConfig();
+    if (!responseHook) {
+      return;
+    }
+    try {
+      responseHook(span, cmd.name, cmd.args, response);
+    } catch {
+    }
+  }
+}
+
+export { IORedisInstrumentation };
+//# sourceMappingURL=ioredis-instrumentation.js.map

package/build/esm/integrations/tracing/redis/vendored/ioredis-instrumentation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ioredis-instrumentation.js","sources":["../../../../../../src/integrations/tracing/redis/vendored/ioredis-instrumentation.ts"],"sourcesContent":["/*\n * Copyright The OpenTelemetry Authors\n * SPDX-License-Identifier: Apache-2.0\n *\n * NOTICE from the Sentry authors:\n * - Vendored from: https://github.com/open-telemetry/opentelemetry-js-contrib/tree/instrumentation-ioredis-v0.62.0/packages/instrumentation-ioredis\n * - Upstream version: @opentelemetry/instrumentation-ioredis@0.62.0\n * - Minor TypeScript adjustments for this repository's compiler settings\n * - Refactored to use Sentry's span APIs instead of OpenTelemetry tracing APIs\n */\n\nimport { InstrumentationBase, InstrumentationNodeModuleDefinition, isWrapped } from '@opentelemetry/instrumentation';\nimport type { Span, SpanAttributes } from '@sentry/core';\nimport {\n  getActiveSpan,\n  SDK_VERSION,\n  SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN,\n  SPAN_KIND,\n  SPAN_STATUS_ERROR,\n  startInactiveSpan,\n} from '@sentry/core';\nimport { DB_STATEMENT, DB_SYSTEM, NET_PEER_NAME, NET_PEER_PORT } from '@sentry/conventions/attributes';\nimport { defaultDbStatementSerializer } from '@sentry/server-utils';\nimport { ATTR_DB_CONNECTION_STRING, DB_SYSTEM_VALUE_REDIS } from './semconv';\nimport type { IORedisInstrumentationConfig } from './types';\n\nconst PACKAGE_NAME = '@sentry/instrumentation-ioredis';\nconst ORIGIN = 'auto.db.otel.redis';\n\n// ioredis >= 5.11.0 publishes via diagnostics_channel, which Sentry subscribes\n// to separately, so this monkey-patching instrumentation only covers < 5.11.0.\nconst SUPPORTED_VERSIONS = ['>=2.0.0 <5.11.0'];\n\n// The raw imported `ioredis` module is either the CommonJS export or an ESM\n// namespace wrapping it on `.default`. Typed shallowly since it is only used\n// internally to reach the `Redis` prototype that holds the methods we patch.\ntype IORedisModule = {\n  default?: { prototype: RedisPrototype };\n  prototype: RedisPrototype;\n  [Symbol.toStringTag]?: string;\n};\n\ninterface RedisPrototype {\n  sendCommand: (...args: unknown[]) => unknown;\n  connect: (...args: unknown[]) => unknown;\n}\n\n// The `this` of the patched methods is a Redis client instance exposing its\n// connection options.\ninterface RedisClient {\n  options: { host?: string; port?: number };\n}\n\n// The in-flight command object ioredis passes to `sendCommand`. We swap its\n// `resolve`/`reject` so the span ends when the command settles.\ninterface RedisCommand {\n  name: string;\n  args: Array<string | Buffer>;\n  resolve: (result: unknown) => void;\n  reject: (err: Error) => void;\n}\n\nfunction endSpan(span: Span, err: Error | null | undefined): void {\n  if (err) {\n    span.setStatus({ code: SPAN_STATUS_ERROR, message: err.message });\n  }\n  span.end();\n}\n\nexport class IORedisInstrumentation extends InstrumentationBase<IORedisInstrumentationConfig> {\n  public constructor(config: IORedisInstrumentationConfig = {}) {\n    super(PACKAGE_NAME, SDK_VERSION, config);\n  }\n\n  protected init(): InstrumentationNodeModuleDefinition[] {\n    return [\n      new InstrumentationNodeModuleDefinition(\n        'ioredis',\n        SUPPORTED_VERSIONS,\n        (module: IORedisModule) => {\n          const moduleExports = module[Symbol.toStringTag] === 'Module' && module.default ? module.default : module;\n          if (isWrapped(moduleExports.prototype.sendCommand)) {\n            this._unwrap(moduleExports.prototype, 'sendCommand');\n          }\n          this._wrap(moduleExports.prototype, 'sendCommand', this._patchSendCommand());\n          if (isWrapped(moduleExports.prototype.connect)) {\n            this._unwrap(moduleExports.prototype, 'connect');\n          }\n          this._wrap(moduleExports.prototype, 'connect', this._patchConnection());\n          return module;\n        },\n        (module: IORedisModule | undefined) => {\n          if (module === undefined) return;\n          const moduleExports = module[Symbol.toStringTag] === 'Module' && module.default ? module.default : module;\n          this._unwrap(moduleExports.prototype, 'sendCommand');\n          this._unwrap(moduleExports.prototype, 'connect');\n        },\n      ),\n    ];\n  }\n\n  private _patchSendCommand() {\n    const instrumentation = this;\n    return (original: (...args: unknown[]) => unknown) => {\n      return function (this: RedisClient, ...args: unknown[]): unknown {\n        const cmd = args[0] as RedisCommand | undefined;\n        // ioredis only creates a span when there is an active parent span\n        // (the upstream `requireParentSpan` default, which Sentry never overrides).\n        if (args.length < 1 || typeof cmd !== 'object' || !getActiveSpan()) {\n          return original.apply(this, args);\n        }\n\n        const { host, port } = this.options;\n        const attributes: SpanAttributes = {\n          // oxlint-disable-next-line typescript/no-deprecated\n          [DB_SYSTEM]: DB_SYSTEM_VALUE_REDIS,\n          // oxlint-disable-next-line typescript/no-deprecated\n          [DB_STATEMENT]: defaultDbStatementSerializer(cmd.name, cmd.args),\n          [ATTR_DB_CONNECTION_STRING]: `redis://${host}:${port}`,\n          // oxlint-disable-next-line typescript/no-deprecated\n          [NET_PEER_NAME]: host,\n          // oxlint-disable-next-line typescript/no-deprecated\n          [NET_PEER_PORT]: port,\n          [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: ORIGIN,\n        };\n\n        const span = startInactiveSpan({ name: cmd.name, kind: SPAN_KIND.CLIENT, attributes });\n\n        try {\n          const result = original.apply(this, args);\n          const origResolve = cmd.resolve;\n          cmd.resolve = function (response: unknown): void {\n            instrumentation._callResponseHook(span, cmd, response);\n            endSpan(span, null);\n            origResolve(response);\n          };\n          const origReject = cmd.reject;\n          cmd.reject = function (err: Error): void {\n            endSpan(span, err);\n            origReject(err);\n          };\n          return result;\n        } catch (error) {\n          endSpan(span, error as Error);\n          throw error;\n        }\n      };\n    };\n  }\n\n  private _patchConnection() {\n    return (original: (...args: unknown[]) => unknown) => {\n      return function (this: RedisClient, ...args: unknown[]): unknown {\n        if (!getActiveSpan()) {\n          return original.apply(this, args);\n        }\n\n        const { host, port } = this.options;\n        const attributes: SpanAttributes = {\n          // oxlint-disable-next-line typescript/no-deprecated\n          [DB_SYSTEM]: DB_SYSTEM_VALUE_REDIS,\n          // oxlint-disable-next-line typescript/no-deprecated\n          [DB_STATEMENT]: 'connect',\n          [ATTR_DB_CONNECTION_STRING]: `redis://${host}:${port}`,\n          // oxlint-disable-next-line typescript/no-deprecated\n          [NET_PEER_NAME]: host,\n          // oxlint-disable-next-line typescript/no-deprecated\n          [NET_PEER_PORT]: port,\n          [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: ORIGIN,\n        };\n\n        const span = startInactiveSpan({ name: 'connect', kind: SPAN_KIND.CLIENT, attributes });\n\n        try {\n          const result = original.apply(this, args) as Promise<unknown> | undefined;\n          if (result instanceof Promise) {\n            return result.then(\n              (value: unknown) => {\n                endSpan(span, null);\n                return value;\n              },\n              (error: Error) => {\n                endSpan(span, error);\n                return Promise.reject(error);\n              },\n            );\n          }\n          endSpan(span, null);\n          return result;\n        } catch (error) {\n          endSpan(span, error as Error);\n          throw error;\n        }\n      };\n    };\n  }\n\n  private _callResponseHook(span: Span, cmd: RedisCommand, response: unknown): void {\n    const { responseHook } = this.getConfig();\n    if (!responseHook) {\n      return;\n    }\n    try {\n      responseHook(span, cmd.name, cmd.args, response);\n    } catch {\n      // ignore errors thrown from the user-provided response hook\n    }\n  }\n}\n"],"names":[],"mappings":"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"}

package/build/esm/integrations/tracing/redis/vendored/redis-instrumentation.js

@@ -0,0 +1,443 @@
+import { InstrumentationBase, InstrumentationNodeModuleDefinition, isWrapped } from '@opentelemetry/instrumentation';
+import { SDK_VERSION, startInactiveSpan, SPAN_KIND, getActiveSpan, withActiveSpan, debug, SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN, SPAN_STATUS_ERROR } from '@sentry/core';
+import { DB_STATEMENT, DB_SYSTEM, NET_PEER_NAME, NET_PEER_PORT } from '@sentry/conventions/attributes';
+import { defaultDbStatementSerializer } from '@sentry/server-utils';
+import { DEBUG_BUILD } from '../../../../debug-build.js';
+import { InstrumentationNodeModuleFile } from '../../InstrumentationNodeModuleFile.js';
+import { DB_SYSTEM_VALUE_REDIS, ATTR_DB_CONNECTION_STRING } from './semconv.js';
+
+const PACKAGE_NAME = "@sentry/instrumentation-redis";
+const ORIGIN = "auto.db.otel.redis";
+const OTEL_OPEN_SPANS = /* @__PURE__ */ Symbol("opentelemetry.instrumentation.redis.open_spans");
+const MULTI_COMMAND_OPTIONS = /* @__PURE__ */ Symbol("opentelemetry.instrumentation.redis.multi_command_options");
+function endSpan(span, err) {
+  if (err) {
+    span.setStatus({ code: SPAN_STATUS_ERROR, message: err.message });
+  }
+  span.end();
+}
+function runResponseHook(responseHook, span, commandName, commandArgs, response) {
+  if (!responseHook) {
+    return;
+  }
+  try {
+    responseHook(span, commandName, commandArgs, response);
+  } catch {
+  }
+}
+function removeCredentialsFromDBConnectionStringAttribute(url) {
+  if (typeof url !== "string" || !url) {
+    return void 0;
+  }
+  try {
+    const u = new URL(url);
+    u.searchParams.delete("user_pwd");
+    u.username = "";
+    u.password = "";
+    return u.href;
+  } catch (err) {
+    DEBUG_BUILD && debug.error("failed to sanitize redis connection url", err);
+  }
+  return void 0;
+}
+function getClientAttributes(options) {
+  return {
+    // oxlint-disable-next-line typescript/no-deprecated
+    [DB_SYSTEM]: DB_SYSTEM_VALUE_REDIS,
+    // oxlint-disable-next-line typescript/no-deprecated
+    [NET_PEER_NAME]: options?.socket?.host,
+    // oxlint-disable-next-line typescript/no-deprecated
+    [NET_PEER_PORT]: options?.socket?.port,
+    [ATTR_DB_CONNECTION_STRING]: removeCredentialsFromDBConnectionStringAttribute(options?.url),
+    [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: ORIGIN
+  };
+}
+const _RedisInstrumentationV2_V3 = class _RedisInstrumentationV2_V3 extends InstrumentationBase {
+  constructor(config = {}) {
+    super(PACKAGE_NAME, SDK_VERSION, config);
+  }
+  init() {
+    return [
+      new InstrumentationNodeModuleDefinition(
+        "redis",
+        [">=2.6.0 <4"],
+        (moduleExports) => {
+          if (isWrapped(moduleExports.RedisClient.prototype["internal_send_command"])) {
+            this._unwrap(moduleExports.RedisClient.prototype, "internal_send_command");
+          }
+          this._wrap(moduleExports.RedisClient.prototype, "internal_send_command", this._getPatchInternalSendCommand());
+          return moduleExports;
+        },
+        (moduleExports) => {
+          if (moduleExports === void 0) return;
+          this._unwrap(moduleExports.RedisClient.prototype, "internal_send_command");
+        }
+      )
+    ];
+  }
+  _getPatchInternalSendCommand() {
+    const instrumentation = this;
+    return function internal_send_command(original) {
+      return function internal_send_command_trace(cmd) {
+        if (arguments.length !== 1 || typeof cmd !== "object") {
+          return original.apply(this, arguments);
+        }
+        const attributes = {
+          // oxlint-disable-next-line typescript/no-deprecated
+          [DB_SYSTEM]: DB_SYSTEM_VALUE_REDIS,
+          // oxlint-disable-next-line typescript/no-deprecated
+          [DB_STATEMENT]: defaultDbStatementSerializer(cmd.command, cmd.args),
+          [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: ORIGIN
+        };
+        if (this.connection_options) {
+          attributes[NET_PEER_NAME] = this.connection_options.host;
+          attributes[NET_PEER_PORT] = this.connection_options.port;
+        }
+        if (this.address) {
+          attributes[ATTR_DB_CONNECTION_STRING] = `redis://${this.address}`;
+        }
+        const span = startInactiveSpan({
+          name: `${_RedisInstrumentationV2_V3.COMPONENT}-${cmd.command}`,
+          kind: SPAN_KIND.CLIENT,
+          attributes
+        });
+        const originalCallback = arguments[0].callback;
+        if (originalCallback) {
+          const parentSpan = getActiveSpan();
+          arguments[0].callback = function callback(err, reply) {
+            runResponseHook(instrumentation.getConfig().responseHook, span, cmd.command, cmd.args, reply);
+            endSpan(span, err);
+            return withActiveSpan(parentSpan ?? null, () => originalCallback.apply(this, arguments));
+          };
+        }
+        try {
+          return original.apply(this, arguments);
+        } catch (rethrow) {
+          endSpan(span, rethrow);
+          throw rethrow;
+        }
+      };
+    };
+  }
+};
+_RedisInstrumentationV2_V3.COMPONENT = "redis";
+let RedisInstrumentationV2_V3 = _RedisInstrumentationV2_V3;
+const _RedisInstrumentationV4_V5 = class _RedisInstrumentationV4_V5 extends InstrumentationBase {
+  constructor(config = {}) {
+    super(PACKAGE_NAME, SDK_VERSION, config);
+  }
+  init() {
+    return [
+      this._getInstrumentationNodeModuleDefinition("@redis/client"),
+      this._getInstrumentationNodeModuleDefinition("@node-redis/client")
+    ];
+  }
+  _getInstrumentationNodeModuleDefinition(basePackageName) {
+    const commanderModuleFile = new InstrumentationNodeModuleFile(
+      `${basePackageName}/dist/lib/commander.js`,
+      ["^1.0.0"],
+      (moduleExports, moduleVersion) => {
+        const transformCommandArguments = moduleExports.transformCommandArguments;
+        if (!transformCommandArguments) {
+          DEBUG_BUILD && debug.error("internal instrumentation error, missing transformCommandArguments function");
+          return moduleExports;
+        }
+        const functionToPatch = moduleVersion?.startsWith("1.0.") ? "extendWithCommands" : "attachCommands";
+        if (isWrapped(moduleExports?.[functionToPatch])) {
+          this._unwrap(moduleExports, functionToPatch);
+        }
+        this._wrap(moduleExports, functionToPatch, this._getPatchExtendWithCommands(transformCommandArguments));
+        return moduleExports;
+      },
+      (moduleExports) => {
+        if (isWrapped(moduleExports?.extendWithCommands)) {
+          this._unwrap(moduleExports, "extendWithCommands");
+        }
+        if (isWrapped(moduleExports?.attachCommands)) {
+          this._unwrap(moduleExports, "attachCommands");
+        }
+      }
+    );
+    const multiCommanderModule = new InstrumentationNodeModuleFile(
+      `${basePackageName}/dist/lib/client/multi-command.js`,
+      ["^1.0.0", ">=5.0.0 <5.12.0"],
+      (moduleExports) => {
+        const redisClientMultiCommandPrototype = moduleExports?.default?.prototype;
+        if (isWrapped(redisClientMultiCommandPrototype?.exec)) {
+          this._unwrap(redisClientMultiCommandPrototype, "exec");
+        }
+        this._wrap(redisClientMultiCommandPrototype, "exec", this._getPatchMultiCommandsExec());
+        if (isWrapped(redisClientMultiCommandPrototype?.execAsPipeline)) {
+          this._unwrap(redisClientMultiCommandPrototype, "execAsPipeline");
+        }
+        this._wrap(redisClientMultiCommandPrototype, "execAsPipeline", this._getPatchMultiCommandsExec());
+        if (isWrapped(redisClientMultiCommandPrototype?.addCommand)) {
+          this._unwrap(redisClientMultiCommandPrototype, "addCommand");
+        }
+        this._wrap(redisClientMultiCommandPrototype, "addCommand", this._getPatchMultiCommandsAddCommand());
+        return moduleExports;
+      },
+      (moduleExports) => {
+        const redisClientMultiCommandPrototype = moduleExports?.default?.prototype;
+        if (isWrapped(redisClientMultiCommandPrototype?.exec)) {
+          this._unwrap(redisClientMultiCommandPrototype, "exec");
+        }
+        if (isWrapped(redisClientMultiCommandPrototype?.execAsPipeline)) {
+          this._unwrap(redisClientMultiCommandPrototype, "execAsPipeline");
+        }
+        if (isWrapped(redisClientMultiCommandPrototype?.addCommand)) {
+          this._unwrap(redisClientMultiCommandPrototype, "addCommand");
+        }
+      }
+    );
+    const clientIndexModule = new InstrumentationNodeModuleFile(
+      `${basePackageName}/dist/lib/client/index.js`,
+      ["^1.0.0", ">=5.0.0 <5.12.0"],
+      (moduleExports) => {
+        const redisClientPrototype = moduleExports?.default?.prototype;
+        if (redisClientPrototype?.multi) {
+          if (isWrapped(redisClientPrototype?.multi)) {
+            this._unwrap(redisClientPrototype, "multi");
+          }
+          this._wrap(redisClientPrototype, "multi", this._getPatchRedisClientMulti());
+        }
+        if (redisClientPrototype?.MULTI) {
+          if (isWrapped(redisClientPrototype?.MULTI)) {
+            this._unwrap(redisClientPrototype, "MULTI");
+          }
+          this._wrap(redisClientPrototype, "MULTI", this._getPatchRedisClientMulti());
+        }
+        if (isWrapped(redisClientPrototype?.sendCommand)) {
+          this._unwrap(redisClientPrototype, "sendCommand");
+        }
+        this._wrap(redisClientPrototype, "sendCommand", this._getPatchRedisClientSendCommand());
+        if (isWrapped(redisClientPrototype?.connect)) {
+          this._unwrap(redisClientPrototype, "connect");
+        }
+        this._wrap(redisClientPrototype, "connect", this._getPatchedClientConnect());
+        return moduleExports;
+      },
+      (moduleExports) => {
+        const redisClientPrototype = moduleExports?.default?.prototype;
+        if (isWrapped(redisClientPrototype?.multi)) {
+          this._unwrap(redisClientPrototype, "multi");
+        }
+        if (isWrapped(redisClientPrototype?.MULTI)) {
+          this._unwrap(redisClientPrototype, "MULTI");
+        }
+        if (isWrapped(redisClientPrototype?.sendCommand)) {
+          this._unwrap(redisClientPrototype, "sendCommand");
+        }
+        if (isWrapped(redisClientPrototype?.connect)) {
+          this._unwrap(redisClientPrototype, "connect");
+        }
+      }
+    );
+    return new InstrumentationNodeModuleDefinition(
+      basePackageName,
+      ["^1.0.0", ">=5.0.0 <5.12.0"],
+      (moduleExports) => moduleExports,
+      () => {
+      },
+      [commanderModuleFile, multiCommanderModule, clientIndexModule]
+    );
+  }
+  _getPatchExtendWithCommands(transformCommandArguments) {
+    const plugin = this;
+    return function extendWithCommandsPatchWrapper(original) {
+      return function extendWithCommandsPatch(config) {
+        if (config?.BaseClass?.name !== "RedisClient") {
+          return original.apply(this, arguments);
+        }
+        const origExecutor = config.executor;
+        config.executor = function(command, args) {
+          const redisCommandArguments = transformCommandArguments(command, args).args;
+          return plugin._traceClientCommand(origExecutor, this, arguments, redisCommandArguments);
+        };
+        return original.apply(this, arguments);
+      };
+    };
+  }
+  _getPatchMultiCommandsExec() {
+    const plugin = this;
+    return function execPatchWrapper(original) {
+      return function execPatch() {
+        const execRes = original.apply(this, arguments);
+        if (typeof execRes?.then !== "function") {
+          DEBUG_BUILD && debug.error("non-promise result when patching exec/execAsPipeline");
+          return execRes;
+        }
+        return execRes.then((redisRes) => {
+          const openSpans = this[OTEL_OPEN_SPANS];
+          plugin._endSpansWithRedisReplies(openSpans, redisRes);
+          return redisRes;
+        }).catch((err) => {
+          const openSpans = this[OTEL_OPEN_SPANS];
+          if (!openSpans) {
+            DEBUG_BUILD && debug.error("cannot find open spans to end for multi/pipeline");
+          } else {
+            const replies = err.constructor.name === "MultiErrorReply" ? err.replies : new Array(openSpans.length).fill(err);
+            plugin._endSpansWithRedisReplies(openSpans, replies);
+          }
+          return Promise.reject(err);
+        });
+      };
+    };
+  }
+  _getPatchMultiCommandsAddCommand() {
+    const plugin = this;
+    return function addCommandWrapper(original) {
+      return function addCommandPatch(args) {
+        return plugin._traceClientCommand(original, this, arguments, args);
+      };
+    };
+  }
+  _getPatchRedisClientMulti() {
+    return function multiPatchWrapper(original) {
+      return function multiPatch() {
+        const multiRes = original.apply(this, arguments);
+        multiRes[MULTI_COMMAND_OPTIONS] = this.options;
+        return multiRes;
+      };
+    };
+  }
+  _getPatchRedisClientSendCommand() {
+    const plugin = this;
+    return function sendCommandWrapper(original) {
+      return function sendCommandPatch(args) {
+        return plugin._traceClientCommand(original, this, arguments, args);
+      };
+    };
+  }
+  _getPatchedClientConnect() {
+    return function connectWrapper(original) {
+      return function patchedConnect() {
+        const attributes = getClientAttributes(this.options);
+        const span = startInactiveSpan({
+          name: `${_RedisInstrumentationV4_V5.COMPONENT}-connect`,
+          kind: SPAN_KIND.CLIENT,
+          attributes
+        });
+        const res = withActiveSpan(span, () => original.apply(this));
+        return res.then(
+          (result) => {
+            span.end();
+            return result;
+          },
+          (error) => {
+            endSpan(span, error);
+            return Promise.reject(error);
+          }
+        );
+      };
+    };
+  }
+  _traceClientCommand(origFunction, origThis, origArguments, redisCommandArguments) {
+    const clientOptions = origThis.options || origThis[MULTI_COMMAND_OPTIONS];
+    const commandName = redisCommandArguments[0];
+    const commandArgs = redisCommandArguments.slice(1);
+    const attributes = getClientAttributes(clientOptions);
+    const dbStatement = defaultDbStatementSerializer(commandName, commandArgs);
+    if (dbStatement != null) {
+      attributes[DB_STATEMENT] = dbStatement;
+    }
+    const span = startInactiveSpan({
+      name: `${_RedisInstrumentationV4_V5.COMPONENT}-${commandName}`,
+      kind: SPAN_KIND.CLIENT,
+      attributes
+    });
+    const res = withActiveSpan(span, () => origFunction.apply(origThis, origArguments));
+    if (res instanceof Promise) {
+      res.then(
+        (redisRes) => {
+          this._endSpanWithResponse(span, commandName, commandArgs, redisRes, void 0);
+        },
+        (err) => {
+          this._endSpanWithResponse(span, commandName, commandArgs, null, err);
+        }
+      );
+    } else {
+      const redisClientMultiCommand = res;
+      redisClientMultiCommand[OTEL_OPEN_SPANS] = redisClientMultiCommand[OTEL_OPEN_SPANS] || [];
+      redisClientMultiCommand[OTEL_OPEN_SPANS].push({
+        span,
+        commandName,
+        commandArgs
+      });
+    }
+    return res;
+  }
+  _endSpansWithRedisReplies(openSpans, replies) {
+    if (!openSpans) {
+      DEBUG_BUILD && debug.error("cannot find open spans to end for redis multi/pipeline");
+      return;
+    }
+    if (replies.length !== openSpans.length) {
+      DEBUG_BUILD && debug.error("number of multi command spans does not match response from redis");
+      return;
+    }
+    for (let i = 0; i < openSpans.length; i++) {
+      const { span, commandName, commandArgs } = openSpans[i];
+      const currCommandRes = replies[i];
+      const [res, err] = currCommandRes instanceof Error ? [null, currCommandRes] : [currCommandRes, void 0];
+      this._endSpanWithResponse(span, commandName, commandArgs, res, err);
+    }
+  }
+  _endSpanWithResponse(span, commandName, commandArgs, response, error) {
+    if (!error) {
+      runResponseHook(this.getConfig().responseHook, span, commandName, commandArgs, response);
+    }
+    endSpan(span, error);
+  }
+};
+_RedisInstrumentationV4_V5.COMPONENT = "redis";
+let RedisInstrumentationV4_V5 = _RedisInstrumentationV4_V5;
+class RedisInstrumentation extends InstrumentationBase {
+  constructor(config = {}) {
+    super(PACKAGE_NAME, SDK_VERSION, config);
+    this.initialized = false;
+    this.instrumentationV2_V3 = new RedisInstrumentationV2_V3(this.getConfig());
+    this.instrumentationV4_V5 = new RedisInstrumentationV4_V5(this.getConfig());
+    this.initialized = true;
+  }
+  setConfig(config = {}) {
+    super.setConfig(config);
+    if (!this.initialized) {
+      return;
+    }
+    this.instrumentationV2_V3.setConfig(config);
+    this.instrumentationV4_V5.setConfig(config);
+  }
+  init() {
+  }
+  getModuleDefinitions() {
+    return [...this.instrumentationV2_V3.getModuleDefinitions(), ...this.instrumentationV4_V5.getModuleDefinitions()];
+  }
+  setTracerProvider(tracerProvider) {
+    super.setTracerProvider(tracerProvider);
+    if (!this.initialized) {
+      return;
+    }
+    this.instrumentationV2_V3.setTracerProvider(tracerProvider);
+    this.instrumentationV4_V5.setTracerProvider(tracerProvider);
+  }
+  enable() {
+    super.enable();
+    if (!this.initialized) {
+      return;
+    }
+    this.instrumentationV2_V3.enable();
+    this.instrumentationV4_V5.enable();
+  }
+  disable() {
+    super.disable();
+    if (!this.initialized) {
+      return;
+    }
+    this.instrumentationV2_V3.disable();
+    this.instrumentationV4_V5.disable();
+  }
+}
+
+export { RedisInstrumentation };
+//# sourceMappingURL=redis-instrumentation.js.map