@sentry/node 10.58.0 → 10.60.0

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

@@ -1,18 +1,33 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 
 const api = require('@opentelemetry/api');
-const core = require('@sentry/core');
 const instrumentation = require('@opentelemetry/instrumentation');
+const core = require('@sentry/core');
+const debugBuild = require('../../../../debug-build.js');
 const InstrumentationNodeModuleFile = require('../../InstrumentationNodeModuleFile.js');
-const semanticConventions = require('@opentelemetry/semantic-conventions');
 const redisCommon = require('./redis-common.js');
 const semconv = require('./semconv.js');
 
-const PACKAGE_NAME = "@opentelemetry/instrumentation-redis";
-const PACKAGE_VERSION = "0.62.0";
+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 removeCredentialsFromDBConnectionStringAttribute(diagLogger, url) {
+function endSpan(span, err) {
+  if (err) {
+    span.setStatus({ code: core.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;
   }
@@ -23,68 +38,22 @@ function removeCredentialsFromDBConnectionStringAttribute(diagLogger, url) {
     u.password = "";
     return u.href;
   } catch (err) {
-    diagLogger.error("failed to sanitize redis connection url", err);
+    debugBuild.DEBUG_BUILD && core.debug.error("failed to sanitize redis connection url", err);
   }
   return void 0;
 }
-function getClientAttributes(diagLogger, options, semconvStability) {
-  const attributes = {};
-  if (semconvStability & instrumentation.SemconvStability.OLD) {
-    Object.assign(attributes, {
-      [semconv.ATTR_DB_SYSTEM]: semconv.DB_SYSTEM_VALUE_REDIS,
-      [semconv.ATTR_NET_PEER_NAME]: options?.socket?.host,
-      [semconv.ATTR_NET_PEER_PORT]: options?.socket?.port,
-      [semconv.ATTR_DB_CONNECTION_STRING]: removeCredentialsFromDBConnectionStringAttribute(diagLogger, options?.url)
-    });
-  }
-  if (semconvStability & instrumentation.SemconvStability.STABLE) {
-    Object.assign(attributes, {
-      [semanticConventions.ATTR_DB_SYSTEM_NAME]: semconv.DB_SYSTEM_NAME_VALUE_REDIS,
-      [semanticConventions.ATTR_SERVER_ADDRESS]: options?.socket?.host,
-      [semanticConventions.ATTR_SERVER_PORT]: options?.socket?.port
-    });
-  }
-  return attributes;
-}
-function endSpanV2(span, err) {
-  if (err) {
-    span.setStatus({
-      code: api.SpanStatusCode.ERROR,
-      message: err.message
-    });
-  }
-  span.end();
-}
-function getTracedCreateClient(original) {
-  return function createClientTrace() {
-    const client = original.apply(this, arguments);
-    return api.context.bind(api.context.active(), client);
-  };
-}
-function getTracedCreateStreamTrace(original) {
-  return function create_stream_trace() {
-    if (!Object.prototype.hasOwnProperty.call(this, "stream")) {
-      Object.defineProperty(this, "stream", {
-        get() {
-          return this._patched_redis_stream;
-        },
-        set(val) {
-          api.context.bind(api.context.active(), val);
-          this._patched_redis_stream = val;
-        }
-      });
-    }
-    return original.apply(this, arguments);
+function getClientAttributes(options) {
+  return {
+    [semconv.ATTR_DB_SYSTEM]: semconv.DB_SYSTEM_VALUE_REDIS,
+    [semconv.ATTR_NET_PEER_NAME]: options?.socket?.host,
+    [semconv.ATTR_NET_PEER_PORT]: options?.socket?.port,
+    [semconv.ATTR_DB_CONNECTION_STRING]: removeCredentialsFromDBConnectionStringAttribute(options?.url),
+    [core.SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: ORIGIN
   };
 }
 const _RedisInstrumentationV2_V3 = class _RedisInstrumentationV2_V3 extends instrumentation.InstrumentationBase {
   constructor(config = {}) {
-    super(PACKAGE_NAME, PACKAGE_VERSION, config);
-    this._semconvStability = config.semconvStability ? config.semconvStability : instrumentation.semconvStabilityFromStr("database", process.env["OTEL_SEMCONV_STABILITY_OPT_IN"]);
-  }
-  setConfig(config = {}) {
-    super.setConfig(config);
-    this._semconvStability = config.semconvStability ? config.semconvStability : instrumentation.semconvStabilityFromStr("database", process.env["OTEL_SEMCONV_STABILITY_OPT_IN"]);
+    super(PACKAGE_NAME, core.SDK_VERSION, config);
   }
   init() {
     return [
@@ -96,128 +65,63 @@ const _RedisInstrumentationV2_V3 = class _RedisInstrumentationV2_V3 extends inst
             this._unwrap(moduleExports.RedisClient.prototype, "internal_send_command");
           }
           this._wrap(moduleExports.RedisClient.prototype, "internal_send_command", this._getPatchInternalSendCommand());
-          if (instrumentation.isWrapped(moduleExports.RedisClient.prototype["create_stream"])) {
-            this._unwrap(moduleExports.RedisClient.prototype, "create_stream");
-          }
-          this._wrap(moduleExports.RedisClient.prototype, "create_stream", this._getPatchCreateStream());
-          if (instrumentation.isWrapped(moduleExports.createClient)) {
-            this._unwrap(moduleExports, "createClient");
-          }
-          this._wrap(moduleExports, "createClient", this._getPatchCreateClient());
           return moduleExports;
         },
         (moduleExports) => {
           if (moduleExports === void 0) return;
           this._unwrap(moduleExports.RedisClient.prototype, "internal_send_command");
-          this._unwrap(moduleExports.RedisClient.prototype, "create_stream");
-          this._unwrap(moduleExports, "createClient");
         }
       )
     ];
   }
   _getPatchInternalSendCommand() {
-    const instrumentation$1 = this;
+    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 config = instrumentation$1.getConfig();
-        const hasNoParentSpan = api.trace.getSpan(api.context.active()) === void 0;
-        if (config.requireParentSpan === true && hasNoParentSpan) {
-          return original.apply(this, arguments);
-        }
-        const dbStatementSerializer = config?.dbStatementSerializer || redisCommon.defaultDbStatementSerializer;
-        const attributes = {};
-        if (instrumentation$1._semconvStability & instrumentation.SemconvStability.OLD) {
-          Object.assign(attributes, {
-            [semconv.ATTR_DB_SYSTEM]: semconv.DB_SYSTEM_VALUE_REDIS,
-            [semconv.ATTR_DB_STATEMENT]: dbStatementSerializer(cmd.command, cmd.args)
-          });
+        const attributes = {
+          [semconv.ATTR_DB_SYSTEM]: semconv.DB_SYSTEM_VALUE_REDIS,
+          [semconv.ATTR_DB_STATEMENT]: redisCommon.defaultDbStatementSerializer(cmd.command, cmd.args),
+          [core.SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: ORIGIN
+        };
+        if (this.connection_options) {
+          attributes[semconv.ATTR_NET_PEER_NAME] = this.connection_options.host;
+          attributes[semconv.ATTR_NET_PEER_PORT] = this.connection_options.port;
         }
-        if (instrumentation$1._semconvStability & instrumentation.SemconvStability.STABLE) {
-          Object.assign(attributes, {
-            [semanticConventions.ATTR_DB_SYSTEM_NAME]: semconv.DB_SYSTEM_NAME_VALUE_REDIS,
-            [semanticConventions.ATTR_DB_OPERATION_NAME]: cmd.command,
-            [semanticConventions.ATTR_DB_QUERY_TEXT]: dbStatementSerializer(cmd.command, cmd.args)
-          });
+        if (this.address) {
+          attributes[semconv.ATTR_DB_CONNECTION_STRING] = `redis://${this.address}`;
         }
-        attributes[core.SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN] = "auto.db.otel.redis";
-        const span = instrumentation$1.tracer.startSpan(`${_RedisInstrumentationV2_V3.COMPONENT}-${cmd.command}`, {
+        const span = core.startInactiveSpan({
+          name: `${_RedisInstrumentationV2_V3.COMPONENT}-${cmd.command}`,
           kind: api.SpanKind.CLIENT,
           attributes
         });
-        if (this.connection_options) {
-          const connectionAttributes = {};
-          if (instrumentation$1._semconvStability & instrumentation.SemconvStability.OLD) {
-            Object.assign(connectionAttributes, {
-              [semconv.ATTR_NET_PEER_NAME]: this.connection_options.host,
-              [semconv.ATTR_NET_PEER_PORT]: this.connection_options.port
-            });
-          }
-          if (instrumentation$1._semconvStability & instrumentation.SemconvStability.STABLE) {
-            Object.assign(connectionAttributes, {
-              [semanticConventions.ATTR_SERVER_ADDRESS]: this.connection_options.host,
-              [semanticConventions.ATTR_SERVER_PORT]: this.connection_options.port
-            });
-          }
-          span.setAttributes(connectionAttributes);
-        }
-        if (this.address && instrumentation$1._semconvStability & instrumentation.SemconvStability.OLD) {
-          span.setAttribute(semconv.ATTR_DB_CONNECTION_STRING, `redis://${this.address}`);
-        }
         const originalCallback = arguments[0].callback;
         if (originalCallback) {
-          const originalContext = api.context.active();
+          const parentSpan = core.getActiveSpan();
           arguments[0].callback = function callback(err, reply) {
-            if (config?.responseHook) {
-              const responseHook = config.responseHook;
-              instrumentation.safeExecuteInTheMiddle(
-                () => {
-                  responseHook(span, cmd.command, cmd.args, reply);
-                },
-                (e) => {
-                  if (e) {
-                    instrumentation$1._diag.error("Error executing responseHook", e);
-                  }
-                },
-                true
-              );
-            }
-            endSpanV2(span, err);
-            return api.context.with(originalContext, originalCallback, this, ...arguments);
+            runResponseHook(instrumentation.getConfig().responseHook, span, cmd.command, cmd.args, reply);
+            endSpan(span, err);
+            return core.withActiveSpan(parentSpan ?? null, () => originalCallback.apply(this, arguments));
           };
         }
         try {
           return original.apply(this, arguments);
         } catch (rethrow) {
-          endSpanV2(span, rethrow);
+          endSpan(span, rethrow);
           throw rethrow;
         }
       };
     };
   }
-  _getPatchCreateClient() {
-    return function createClient(original) {
-      return getTracedCreateClient(original);
-    };
-  }
-  _getPatchCreateStream() {
-    return function createReadStream(original) {
-      return getTracedCreateStreamTrace(original);
-    };
-  }
 };
 _RedisInstrumentationV2_V3.COMPONENT = "redis";
 let RedisInstrumentationV2_V3 = _RedisInstrumentationV2_V3;
 const _RedisInstrumentationV4_V5 = class _RedisInstrumentationV4_V5 extends instrumentation.InstrumentationBase {
   constructor(config = {}) {
-    super(PACKAGE_NAME, PACKAGE_VERSION, config);
-    this._semconvStability = config.semconvStability ? config.semconvStability : instrumentation.semconvStabilityFromStr("database", process.env["OTEL_SEMCONV_STABILITY_OPT_IN"]);
-  }
-  setConfig(config = {}) {
-    super.setConfig(config);
-    this._semconvStability = config.semconvStability ? config.semconvStability : instrumentation.semconvStabilityFromStr("database", process.env["OTEL_SEMCONV_STABILITY_OPT_IN"]);
+    super(PACKAGE_NAME, core.SDK_VERSION, config);
   }
   init() {
     return [
@@ -232,7 +136,7 @@ const _RedisInstrumentationV4_V5 = class _RedisInstrumentationV4_V5 extends inst
       (moduleExports, moduleVersion) => {
         const transformCommandArguments = moduleExports.transformCommandArguments;
         if (!transformCommandArguments) {
-          this._diag.error("internal instrumentation error, missing transformCommandArguments function");
+          debugBuild.DEBUG_BUILD && core.debug.error("internal instrumentation error, missing transformCommandArguments function");
           return moduleExports;
         }
         const functionToPatch = moduleVersion?.startsWith("1.0.") ? "extendWithCommands" : "attachCommands";
@@ -259,11 +163,11 @@ const _RedisInstrumentationV4_V5 = class _RedisInstrumentationV4_V5 extends inst
         if (instrumentation.isWrapped(redisClientMultiCommandPrototype?.exec)) {
           this._unwrap(redisClientMultiCommandPrototype, "exec");
         }
-        this._wrap(redisClientMultiCommandPrototype, "exec", this._getPatchMultiCommandsExec(false));
+        this._wrap(redisClientMultiCommandPrototype, "exec", this._getPatchMultiCommandsExec());
         if (instrumentation.isWrapped(redisClientMultiCommandPrototype?.execAsPipeline)) {
           this._unwrap(redisClientMultiCommandPrototype, "execAsPipeline");
         }
-        this._wrap(redisClientMultiCommandPrototype, "execAsPipeline", this._getPatchMultiCommandsExec(true));
+        this._wrap(redisClientMultiCommandPrototype, "execAsPipeline", this._getPatchMultiCommandsExec());
         if (instrumentation.isWrapped(redisClientMultiCommandPrototype?.addCommand)) {
           this._unwrap(redisClientMultiCommandPrototype, "addCommand");
         }
@@ -351,26 +255,26 @@ const _RedisInstrumentationV4_V5 = class _RedisInstrumentationV4_V5 extends inst
       };
     };
   }
-  _getPatchMultiCommandsExec(isPipeline) {
+  _getPatchMultiCommandsExec() {
     const plugin = this;
     return function execPatchWrapper(original) {
       return function execPatch() {
         const execRes = original.apply(this, arguments);
         if (typeof execRes?.then !== "function") {
-          plugin._diag.error("non-promise result when patching exec/execAsPipeline");
+          debugBuild.DEBUG_BUILD && core.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, isPipeline);
+          plugin._endSpansWithRedisReplies(openSpans, redisRes);
           return redisRes;
         }).catch((err) => {
           const openSpans = this[OTEL_OPEN_SPANS];
           if (!openSpans) {
-            plugin._diag.error("cannot find open spans to end for multi/pipeline");
+            debugBuild.DEBUG_BUILD && core.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, isPipeline);
+            plugin._endSpansWithRedisReplies(openSpans, replies);
           }
           return Promise.reject(err);
         });
@@ -403,69 +307,44 @@ const _RedisInstrumentationV4_V5 = class _RedisInstrumentationV4_V5 extends inst
     };
   }
   _getPatchedClientConnect() {
-    const plugin = this;
     return function connectWrapper(original) {
       return function patchedConnect() {
-        const options = this.options;
-        const attributes = getClientAttributes(plugin._diag, options, plugin._semconvStability);
-        attributes[core.SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN] = "auto.db.otel.redis";
-        const span = plugin.tracer.startSpan(`${_RedisInstrumentationV4_V5.COMPONENT}-connect`, {
+        const attributes = getClientAttributes(this.options);
+        const span = core.startInactiveSpan({
+          name: `${_RedisInstrumentationV4_V5.COMPONENT}-connect`,
           kind: api.SpanKind.CLIENT,
           attributes
         });
-        const res = api.context.with(api.trace.setSpan(api.context.active(), span), () => {
-          return original.apply(this);
-        });
-        return res.then((result) => {
-          span.end();
-          return result;
-        }).catch((error) => {
-          span.recordException(error);
-          span.setStatus({
-            code: api.SpanStatusCode.ERROR,
-            message: error.message
-          });
-          span.end();
-          return Promise.reject(error);
-        });
+        const res = core.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 hasNoParentSpan = api.trace.getSpan(api.context.active()) === void 0;
-    if (hasNoParentSpan && this.getConfig().requireParentSpan) {
-      return origFunction.apply(origThis, origArguments);
-    }
     const clientOptions = origThis.options || origThis[MULTI_COMMAND_OPTIONS];
     const commandName = redisCommandArguments[0];
     const commandArgs = redisCommandArguments.slice(1);
-    const dbStatementSerializer = this.getConfig().dbStatementSerializer || redisCommon.defaultDbStatementSerializer;
-    const attributes = getClientAttributes(this._diag, clientOptions, this._semconvStability);
-    if (this._semconvStability & instrumentation.SemconvStability.STABLE) {
-      attributes[semanticConventions.ATTR_DB_OPERATION_NAME] = commandName;
-    }
-    try {
-      const dbStatement = dbStatementSerializer(commandName, commandArgs);
-      if (dbStatement != null) {
-        if (this._semconvStability & instrumentation.SemconvStability.OLD) {
-          attributes[semconv.ATTR_DB_STATEMENT] = dbStatement;
-        }
-        if (this._semconvStability & instrumentation.SemconvStability.STABLE) {
-          attributes[semanticConventions.ATTR_DB_QUERY_TEXT] = dbStatement;
-        }
-      }
-    } catch (e) {
-      this._diag.error("dbStatementSerializer throw an exception", e, { commandName });
+    const attributes = getClientAttributes(clientOptions);
+    const dbStatement = redisCommon.defaultDbStatementSerializer(commandName, commandArgs);
+    if (dbStatement != null) {
+      attributes[semconv.ATTR_DB_STATEMENT] = dbStatement;
     }
-    attributes[core.SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN] = "auto.db.otel.redis";
-    const span = this.tracer.startSpan(`${_RedisInstrumentationV4_V5.COMPONENT}-${commandName}`, {
+    const span = core.startInactiveSpan({
+      name: `${_RedisInstrumentationV4_V5.COMPONENT}-${commandName}`,
       kind: api.SpanKind.CLIENT,
       attributes
     });
-    const res = api.context.with(api.trace.setSpan(api.context.active(), span), () => {
-      return origFunction.apply(origThis, origArguments);
-    });
-    if (typeof res?.then === "function") {
+    const res = core.withActiveSpan(span, () => origFunction.apply(origThis, origArguments));
+    if (res instanceof Promise) {
       res.then(
         (redisRes) => {
           this._endSpanWithResponse(span, commandName, commandArgs, redisRes, void 0);
@@ -485,64 +364,46 @@ const _RedisInstrumentationV4_V5 = class _RedisInstrumentationV4_V5 extends inst
     }
     return res;
   }
-  _endSpansWithRedisReplies(openSpans, replies, isPipeline = false) {
+  _endSpansWithRedisReplies(openSpans, replies) {
     if (!openSpans) {
-      return this._diag.error("cannot find open spans to end for redis multi/pipeline");
+      debugBuild.DEBUG_BUILD && core.debug.error("cannot find open spans to end for redis multi/pipeline");
+      return;
     }
     if (replies.length !== openSpans.length) {
-      return this._diag.error("number of multi command spans does not match response from redis");
+      debugBuild.DEBUG_BUILD && core.debug.error("number of multi command spans does not match response from redis");
+      return;
     }
-    const allCommands = openSpans.map((s) => s.commandName);
-    const allSameCommand = allCommands.every((cmd) => cmd === allCommands[0]);
-    const operationName = allSameCommand ? (isPipeline ? "PIPELINE " : "MULTI ") + allCommands[0] : isPipeline ? "PIPELINE" : "MULTI";
     for (let i = 0; i < openSpans.length; i++) {
-      const { span, commandArgs } = openSpans[i];
+      const { span, commandName, commandArgs } = openSpans[i];
       const currCommandRes = replies[i];
       const [res, err] = currCommandRes instanceof Error ? [null, currCommandRes] : [currCommandRes, void 0];
-      if (this._semconvStability & instrumentation.SemconvStability.STABLE) {
-        span.setAttribute(semanticConventions.ATTR_DB_OPERATION_NAME, operationName);
-      }
-      this._endSpanWithResponse(span, allCommands[i], commandArgs, res, err);
+      this._endSpanWithResponse(span, commandName, commandArgs, res, err);
     }
   }
   _endSpanWithResponse(span, commandName, commandArgs, response, error) {
-    const { responseHook } = this.getConfig();
-    if (!error && responseHook) {
-      try {
-        responseHook(span, commandName, commandArgs, response);
-      } catch (err) {
-        this._diag.error("responseHook throw an exception", err);
-      }
-    }
-    if (error) {
-      span.recordException(error);
-      span.setStatus({ code: api.SpanStatusCode.ERROR, message: error?.message });
+    if (!error) {
+      runResponseHook(this.getConfig().responseHook, span, commandName, commandArgs, response);
     }
-    span.end();
+    endSpan(span, error);
   }
 };
 _RedisInstrumentationV4_V5.COMPONENT = "redis";
 let RedisInstrumentationV4_V5 = _RedisInstrumentationV4_V5;
-const DEFAULT_CONFIG = {
-  requireParentSpan: false
-};
 class RedisInstrumentation extends instrumentation.InstrumentationBase {
   constructor(config = {}) {
-    const resolvedConfig = { ...DEFAULT_CONFIG, ...config };
-    super(PACKAGE_NAME, PACKAGE_VERSION, resolvedConfig);
+    super(PACKAGE_NAME, core.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 = {}) {
-    const newConfig = { ...DEFAULT_CONFIG, ...config };
-    super.setConfig(newConfig);
+    super.setConfig(config);
     if (!this.initialized) {
       return;
     }
-    this.instrumentationV2_V3.setConfig(newConfig);
-    this.instrumentationV4_V5.setConfig(newConfig);
+    this.instrumentationV2_V3.setConfig(config);
+    this.instrumentationV4_V5.setConfig(config);
   }
   init() {
   }