Merge branch 'main' into fix-pg-instr

Author: aryamohanan

package-lock.json

@@ -44,8 +44,8 @@
   "author": "OpenTelemetry Authors",
   "license": "Apache-2.0",
   "devDependencies": {
-    "@babel/core": "7.28.4",
-    "@babel/preset-env": "7.28.3",
+    "@babel/core": "7.28.5",
+    "@babel/preset-env": "7.28.5",
     "@eslint/js": "9.34.0",
     "@nx/eslint": "20.8.2",
     "@types/mocha": "10.0.10",
@@ -74,23 +74,23 @@
     "lerna": "9.0.0",
     "markdownlint-cli2": "0.17.2",
     "minimatch": "9.0.5",
-    "mocha": "11.7.4",
+    "mocha": "11.7.5",
     "nock": "14.0.10",
     "nx": "20.8.2",
     "nyc": "17.1.0",
     "prettier": "3.6.2",
     "process": "0.11.10",
     "rimraf": "5.0.10",
     "safe-stable-stringify": "2.5.0",
-    "semver": "7.7.2",
+    "semver": "7.7.3",
     "sinon": "15.2.0",
     "test-all-versions": "6.2.0",
     "ts-loader": "9.5.4",
     "ts-node": "10.9.2",
     "typescript": "5.0.4",
     "typescript-eslint": "8.41.0",
     "util": "0.12.5",
-    "webpack": "5.102.0",
+    "webpack": "5.102.1",
     "webpack-cli": "6.0.1",
     "webpack-merge": "6.0.1"
   },

package.json

@@ -0,0 +1,12 @@
+knex:
+  jobs:
+    - versions:
+        include: ">=1.0.0 <2"
+        mode: max-3
+      peerDependencies: "@vscode/sqlite3@^5.0.7"
+      commands: npm run test
+    - versions:
+        include: ">=2.0.0 <4"
+        exclude: '3.0.0' # broken release
+        mode: max-3
+      commands: npm run test

packages/instrumentation-knex/.tav.yml

@@ -17,7 +17,7 @@
     "prepublishOnly": "npm run compile",
     "tdd": "npm run test -- --watch-extensions ts --watch",
     "test": "nyc mocha 'test/**/*.ts'",
-    "//todo": "echo \"add test-all-versions\"",
+    "test-all-versions": "tav",
     "version:update": "node ../../scripts/version-update.js",
     "watch": "tsc -w"
   },

packages/instrumentation-knex/package.json

@@ -145,7 +145,15 @@ export class RedisInstrumentationV4_V5 extends InstrumentationBase<RedisInstrume
         this._wrap(
           redisClientMultiCommandPrototype,
           'exec',
-          this._getPatchMultiCommandsExec()
+          this._getPatchMultiCommandsExec(false)
+        );
+        if (isWrapped(redisClientMultiCommandPrototype?.execAsPipeline)) {
+          this._unwrap(redisClientMultiCommandPrototype, 'execAsPipeline');
+        }
+        this._wrap(
+          redisClientMultiCommandPrototype,
+          'execAsPipeline',
+          this._getPatchMultiCommandsExec(true)
         );
 
         if (isWrapped(redisClientMultiCommandPrototype?.addCommand)) {
@@ -277,36 +285,36 @@ export class RedisInstrumentationV4_V5 extends InstrumentationBase<RedisInstrume
     };
   }
 
-  private _getPatchMultiCommandsExec() {
+  private _getPatchMultiCommandsExec(isPipeline: boolean) {
     const plugin = this;
     return function execPatchWrapper(original: Function) {
       return function execPatch(this: any) {
         const execRes = original.apply(this, arguments);
         if (typeof execRes?.then !== 'function') {
           plugin._diag.error(
-            'got non promise result when patching RedisClientMultiCommand.exec'
+            'non-promise result when patching exec/execAsPipeline'
           );
           return execRes;
         }
 
         return execRes
           .then((redisRes: unknown[]) => {
             const openSpans = this[OTEL_OPEN_SPANS];
-            plugin._endSpansWithRedisReplies(openSpans, redisRes);
+            plugin._endSpansWithRedisReplies(openSpans, redisRes, isPipeline);
             return redisRes;
           })
           .catch((err: Error) => {
             const openSpans = this[OTEL_OPEN_SPANS];
             if (!openSpans) {
               plugin._diag.error(
-                'cannot find open spans to end for redis multi command'
+                'cannot find open spans to end for multi/pipeline'
               );
             } else {
               const replies =
                 err.constructor.name === 'MultiErrorReply'
                   ? (err as MultiErrorReply).replies
                   : new Array(openSpans.length).fill(err);
-              plugin._endSpansWithRedisReplies(openSpans, replies);
+              plugin._endSpansWithRedisReplies(openSpans, replies, isPipeline);
             }
             return Promise.reject(err);
           });
@@ -472,27 +480,43 @@ export class RedisInstrumentationV4_V5 extends InstrumentationBase<RedisInstrume
 
   private _endSpansWithRedisReplies(
     openSpans: Array<MutliCommandInfo>,
-    replies: unknown[]
+    replies: unknown[],
+    isPipeline = false
   ) {
     if (!openSpans) {
       return this._diag.error(
-        'cannot find open spans to end for redis multi command'
+        'cannot find open spans to end for redis multi/pipeline'
       );
     }
     if (replies.length !== openSpans.length) {
       return this._diag.error(
         'number of multi command spans does not match response from redis'
       );
     }
+    // Determine a single operation name for the batch of commands.
+    // If all commands are identical, include the command name (e.g., "MULTI SET").
+    // Otherwise, use a generic "MULTI" or "PIPELINE" label for the span.
+    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, commandName, commandArgs } = openSpans[i];
+      const { span, commandArgs } = openSpans[i];
       const currCommandRes = replies[i];
       const [res, err] =
         currCommandRes instanceof Error
           ? [null, currCommandRes]
           : [currCommandRes, undefined];
-      this._endSpanWithResponse(span, commandName, commandArgs, res, err);
+
+      if (this._semconvStability & SemconvStability.STABLE) {
+        span.setAttribute(ATTR_DB_OPERATION_NAME, operationName);
+      }
+
+      this._endSpanWithResponse(span, allCommands[i], commandArgs, res, err);
     }
   }
 

packages/instrumentation-redis/src/v4-v5/instrumentation.ts

@@ -452,7 +452,7 @@ describe('redis v4-v5', () => {
       );
       assert.strictEqual(
         multiSetSpan?.attributes[ATTR_DB_OPERATION_NAME],
-        'SET'
+        'MULTI'
       );
 
       assert.ok(multiGetSpan);
@@ -487,7 +487,7 @@ describe('redis v4-v5', () => {
       );
       assert.strictEqual(
         multiGetSpan?.attributes[ATTR_DB_OPERATION_NAME],
-        'GET'
+        'MULTI'
       );
     });
 
@@ -530,7 +530,7 @@ describe('redis v4-v5', () => {
       );
       assert.strictEqual(
         multiSetSpan?.attributes[ATTR_DB_OPERATION_NAME],
-        'SET'
+        'MULTI SET'
       );
     });
 
@@ -824,4 +824,76 @@ describe('redis v4-v5', () => {
       );
     });
   });
+  describe('pipeline commands', () => {
+    it('should trace all commands in a pipeline with a mixed set of commands', async () => {
+      await client.set('another-key', 'another-value');
+
+      const [setKeyReply, otherKeyValue] = await client
+        .multi()
+        .set('key', 'value')
+        .get('another-key')
+        .execAsPipeline();
+
+      assert.strictEqual(setKeyReply, 'OK');
+      assert.strictEqual(otherKeyValue, 'another-value');
+
+      const [setSpan, pipelineSetSpan, pipelineGetSpan] = getTestSpans();
+
+      assert.ok(setSpan);
+
+      assert.ok(pipelineSetSpan);
+      assert.strictEqual(pipelineSetSpan.name, 'redis-SET');
+      assert.strictEqual(
+        pipelineSetSpan.attributes[ATTR_DB_STATEMENT],
+        'SET key [1 other arguments]'
+      );
+      assert.strictEqual(
+        pipelineSetSpan.attributes[ATTR_DB_QUERY_TEXT],
+        'SET key [1 other arguments]'
+      );
+      assert.strictEqual(
+        pipelineSetSpan.attributes[ATTR_DB_OPERATION_NAME],
+        'PIPELINE'
+      );
+
+      assert.ok(pipelineGetSpan);
+      assert.strictEqual(pipelineGetSpan.name, 'redis-GET');
+      assert.strictEqual(
+        pipelineGetSpan.attributes[ATTR_DB_STATEMENT],
+        'GET another-key'
+      );
+      assert.strictEqual(
+        pipelineGetSpan.attributes[ATTR_DB_QUERY_TEXT],
+        'GET another-key'
+      );
+      assert.strictEqual(
+        pipelineGetSpan.attributes[ATTR_DB_OPERATION_NAME],
+        'PIPELINE'
+      );
+    });
+
+    it('should trace all commands in a pipeline with a same set of commands', async () => {
+      const [setReply] = await client
+        .multi()
+        .addCommand(['SET', 'key', 'value'])
+        .execAsPipeline();
+
+      assert.strictEqual(setReply, 'OK');
+
+      const [pipelineSetSpan] = getTestSpans();
+      assert.ok(pipelineSetSpan);
+      assert.strictEqual(
+        pipelineSetSpan.attributes[ATTR_DB_STATEMENT],
+        'SET key [1 other arguments]'
+      );
+      assert.strictEqual(
+        pipelineSetSpan.attributes[ATTR_DB_QUERY_TEXT],
+        'SET key [1 other arguments]'
+      );
+      assert.strictEqual(
+        pipelineSetSpan.attributes[ATTR_DB_OPERATION_NAME],
+        'PIPELINE SET'
+      );
+    });
+  });
 });

packages/instrumentation-redis/test/v4-v5/redis.test.ts

@@ -24,6 +24,8 @@ import {
   ATTR_V8JS_HEAP_SPACE_NAME,
   METRIC_V8JS_MEMORY_HEAP_LIMIT,
   METRIC_V8JS_MEMORY_HEAP_USED,
+  METRIC_V8JS_MEMORY_HEAP_SPACE_AVAILABLE_SIZE,
+  METRIC_V8JS_MEMORY_HEAP_SPACE_PHYSICAL_SIZE,
 } from '../semconv';
 
 export class HeapSpacesSizeAndUsedCollector extends BaseCollector {
@@ -43,16 +45,14 @@ export class HeapSpacesSizeAndUsedCollector extends BaseCollector {
       }
     );
     const heapSpaceAvailable = meter.createObservableGauge(
-      // TODO: Use METRIC_V8JS_MEMORY_HEAP_SPACE_AVAILABLE_SIZE when available in semconv v1.38.0
-      'v8js.memory.heap.space.available_size',
+      METRIC_V8JS_MEMORY_HEAP_SPACE_AVAILABLE_SIZE,
       {
         description: 'Heap space available size.',
         unit: 'By',
       }
     );
     const heapSpacePhysical = meter.createObservableGauge(
-      // TODO: Use METRIC_V8JS_MEMORY_HEAP_SPACE_PHYSICAL_SIZE when available in semconv v1.38.0
-      'v8js.memory.heap.space.physical_size',
+      METRIC_V8JS_MEMORY_HEAP_SPACE_PHYSICAL_SIZE,
       {
         description: 'Committed size of a heap space.',
         unit: 'By',