fix: prevent duplicate trace events for offline-queued commands

When a command was queued offline, traceCommand wrapped command.promise
at queue time. When the connection became ready and the command was
re-sent via sendCommand, it was wrapped again — producing duplicate
start/end/error trace events and inflated latency in the first span.

Move tracing to the write path only so offline-queued commands are
traced once when actually sent to Redis.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: logaretm

lib/Redis.ts

@@ -568,7 +568,14 @@ class Redis extends Commander implements DataHandledable {
       }
     }
 
-    // Wrap command promise with tracing (zero-cost when no subscribers)
+    if (!writable) {
+      // Offline-queued: skip tracing here. The command will be re-sent via
+      // sendCommand when the connection is ready, and traced at that point.
+      return command.promise;
+    }
+
+    // Trace on the write path only, so offline-queued commands that get
+    // re-sent aren't traced twice.
     return traceCommand(
       () => command.promise as Promise<unknown>,
       () => this._buildCommandContext(command)

test/functional/tracing.ts

@@ -205,6 +205,37 @@ describeOrSkip("tracing", function () {
       redis.disconnect();
     });
 
+    it("should not produce duplicate trace events for offline-queued commands", async function () {
+      const events: any[] = [];
+      const subscriber = {
+        start(message: any) { events.push(message); },
+        end() {},
+        asyncStart() {},
+        asyncEnd() {},
+        error() {},
+      };
+
+      const channel = dc.tracingChannel("ioredis:command");
+      channel.subscribe(subscriber);
+
+      try {
+        const redis = new Redis({ lazyConnect: true });
+        // Start connecting but don't await — puts Redis in "connecting" state
+        const connectPromise = redis.connect();
+        // Issue command while still connecting — it goes to the offline queue
+        const setPromise = redis.set("offline-key", "offline-value");
+        await connectPromise;
+        await setPromise;
+        redis.disconnect();
+
+        const setEvents = events.filter((e) => e.command === "set");
+        // Should trace exactly once, not twice
+        expect(setEvents.length).to.eql(1);
+      } finally {
+        channel.unsubscribe(subscriber);
+      }
+    });
+
     it("should trace errors on failed commands", async function () {
       const errorEvents: any[] = [];
       const subscriber = {