chore: lint fix

blumamir · blumamir · commit b8f799ef00b5 · 2025-05-29T07:11:26.000+07:00
diff --git a/plugins/node/opentelemetry-instrumentation-redis/src/instrumentation.ts b/plugins/node/opentelemetry-instrumentation-redis/src/instrumentation.ts
@@ -21,7 +21,7 @@ import {
   safeExecuteInTheMiddle,
 } from '@opentelemetry/instrumentation';
 import {
-    endSpan,
+  endSpan,
   getTracedCreateClient,
   getTracedCreateStreamTrace,
 } from './utils';
@@ -31,15 +31,15 @@ import { PACKAGE_NAME, PACKAGE_VERSION } from './version';
 import { RedisPluginClientTypes } from './internal-types';
 import { SpanKind, context, trace } from '@opentelemetry/api';
 import {
-    DBSYSTEMVALUES_REDIS,
-    SEMATTRS_DB_CONNECTION_STRING,
-    SEMATTRS_DB_STATEMENT,
-    SEMATTRS_DB_SYSTEM,
-    SEMATTRS_NET_PEER_NAME,
-    SEMATTRS_NET_PEER_PORT,
-  } from '@opentelemetry/semantic-conventions';
+  DBSYSTEMVALUES_REDIS,
+  SEMATTRS_DB_CONNECTION_STRING,
+  SEMATTRS_DB_STATEMENT,
+  SEMATTRS_DB_SYSTEM,
+  SEMATTRS_NET_PEER_NAME,
+  SEMATTRS_NET_PEER_PORT,
+} from '@opentelemetry/semantic-conventions';
 import { defaultDbStatementSerializer } from '@opentelemetry/redis-common';
-  
+
 const DEFAULT_CONFIG: RedisInstrumentationConfig = {
   requireParentSpan: false,
 };
@@ -115,91 +115,97 @@ export class RedisInstrumentation extends InstrumentationBase<RedisInstrumentati
   private _getPatchInternalSendCommand() {
     const instrumentation = this;
     return function internal_send_command(original: Function) {
-        return function internal_send_command_trace(
-            this: RedisPluginClientTypes,
-            cmd?: RedisCommand
-          ) {
-            // Versions of redis (2.4+) use a single options object
-            // instead of named arguments
-            if (arguments.length !== 1 || typeof cmd !== 'object') {
-              // We don't know how to trace this call, so don't start/stop a span
-              return original.apply(this, arguments);
-            }
+      return function internal_send_command_trace(
+        this: RedisPluginClientTypes,
+        cmd?: RedisCommand
+      ) {
+        // Versions of redis (2.4+) use a single options object
+        // instead of named arguments
+        if (arguments.length !== 1 || typeof cmd !== 'object') {
+          // We don't know how to trace this call, so don't start/stop a span
+          return original.apply(this, arguments);
+        }
 
-            const config = instrumentation.getConfig();
-        
-            const hasNoParentSpan = trace.getSpan(context.active()) === undefined;
-            if (config.requireParentSpan === true && hasNoParentSpan) {
-              return original.apply(this, arguments);
-            }
-        
-            const dbStatementSerializer =
-              config?.dbStatementSerializer || defaultDbStatementSerializer;
-            const span = instrumentation.tracer.startSpan(
-              `${RedisInstrumentation.COMPONENT}-${cmd.command}`,
-              {
-                kind: SpanKind.CLIENT,
-                attributes: {
-                  [SEMATTRS_DB_SYSTEM]: DBSYSTEMVALUES_REDIS,
-                  [SEMATTRS_DB_STATEMENT]: dbStatementSerializer(cmd.command, cmd.args),
+        const config = instrumentation.getConfig();
+
+        const hasNoParentSpan = trace.getSpan(context.active()) === undefined;
+        if (config.requireParentSpan === true && hasNoParentSpan) {
+          return original.apply(this, arguments);
+        }
+
+        const dbStatementSerializer =
+          config?.dbStatementSerializer || defaultDbStatementSerializer;
+        const span = instrumentation.tracer.startSpan(
+          `${RedisInstrumentation.COMPONENT}-${cmd.command}`,
+          {
+            kind: SpanKind.CLIENT,
+            attributes: {
+              [SEMATTRS_DB_SYSTEM]: DBSYSTEMVALUES_REDIS,
+              [SEMATTRS_DB_STATEMENT]: dbStatementSerializer(
+                cmd.command,
+                cmd.args
+              ),
+            },
+          }
+        );
+
+        // Set attributes for not explicitly typed RedisPluginClientTypes
+        if (this.connection_options) {
+          span.setAttributes({
+            [SEMATTRS_NET_PEER_NAME]: this.connection_options.host,
+            [SEMATTRS_NET_PEER_PORT]: this.connection_options.port,
+          });
+        }
+        if (this.address) {
+          span.setAttribute(
+            SEMATTRS_DB_CONNECTION_STRING,
+            `redis://${this.address}`
+          );
+        }
+
+        const originalCallback = arguments[0].callback;
+        if (originalCallback) {
+          const originalContext = context.active();
+          (arguments[0] as RedisCommand).callback = function callback<T>(
+            this: unknown,
+            err: Error | null,
+            reply: T
+          ) {
+            if (config?.responseHook) {
+              const responseHook = config.responseHook;
+              safeExecuteInTheMiddle(
+                () => {
+                  responseHook(span, cmd.command, cmd.args, reply);
                 },
-              }
-            );
-        
-            // Set attributes for not explicitly typed RedisPluginClientTypes
-            if (this.connection_options) {
-              span.setAttributes({
-                [SEMATTRS_NET_PEER_NAME]: this.connection_options.host,
-                [SEMATTRS_NET_PEER_PORT]: this.connection_options.port,
-              });
-            }
-            if (this.address) {
-              span.setAttribute(
-                SEMATTRS_DB_CONNECTION_STRING,
-                `redis://${this.address}`
+                err => {
+                  if (err) {
+                    instrumentation._diag.error(
+                      'Error executing responseHook',
+                      err
+                    );
+                  }
+                },
+                true
               );
             }
-        
-            const originalCallback = arguments[0].callback;
-            if (originalCallback) {
-              const originalContext = context.active();
-              (arguments[0] as RedisCommand).callback = function callback<T>(
-                this: unknown,
-                err: Error | null,
-                reply: T
-              ) {
-                if (config?.responseHook) {
-                  const responseHook = config.responseHook;
-                  safeExecuteInTheMiddle(
-                    () => {
-                      responseHook(span, cmd.command, cmd.args, reply);
-                    },
-                    err => {
-                      if (err) {
-                        instrumentation._diag.error('Error executing responseHook', err);
-                      }
-                    },
-                    true
-                  );
-                }
-        
-                endSpan(span, err);
-                return context.with(
-                  originalContext,
-                  originalCallback,
-                  this,
-                  ...arguments
-                );
-              };
-            }
-            try {
-              // Span will be ended in callback
-              return original.apply(this, arguments);
-            } catch (rethrow: any) {
-              endSpan(span, rethrow);
-              throw rethrow; // rethrow after ending span
-            }
+
+            endSpan(span, err);
+            return context.with(
+              originalContext,
+              originalCallback,
+              this,
+              ...arguments
+            );
           };
+        }
+        try {
+          // Span will be ended in callback
+          return original.apply(this, arguments);
+        } catch (rethrow: any) {
+          endSpan(span, rethrow);
+          throw rethrow; // rethrow after ending span
+        }
+      };
     };
   }
 
diff --git a/plugins/node/opentelemetry-instrumentation-redis/src/utils.ts b/plugins/node/opentelemetry-instrumentation-redis/src/utils.ts
@@ -15,11 +15,7 @@
  */
 
 import type * as redisTypes from 'redis';
-import {
-  context,
-  Span,
-  SpanStatusCode,
-} from '@opentelemetry/api';
+import { context, Span, SpanStatusCode } from '@opentelemetry/api';
 import { EventEmitter } from 'events';
 
 export const endSpan = (span: Span, err?: Error | null) => {
@@ -39,9 +35,7 @@ export const getTracedCreateClient = (original: Function) => {
   };
 };
 
-export const getTracedCreateStreamTrace = (
-  original: Function
-) => {
+export const getTracedCreateStreamTrace = (original: Function) => {
   return function create_stream_trace(this: redisTypes.RedisClient) {
     if (!Object.prototype.hasOwnProperty.call(this, 'stream')) {
       Object.defineProperty(this, 'stream', {
diff --git a/plugins/node/opentelemetry-instrumentation-redis/test/redis.test.ts b/plugins/node/opentelemetry-instrumentation-redis/test/redis.test.ts
@@ -144,30 +144,30 @@ describe('redis@2.x', () => {
       expectedDbStatement: string;
       method: (cb: redisTypes.Callback<unknown>) => unknown;
     }> = [
-        {
-          description: 'insert',
-          command: 'hset',
-          args: ['hash', 'random', 'random'],
-          expectedDbStatement: 'hash random [1 other arguments]',
-          method: (cb: redisTypes.Callback<number>) =>
-            client.hset('hash', 'random', 'random', cb),
-        },
-        {
-          description: 'get',
-          command: 'get',
-          args: ['test'],
-          expectedDbStatement: 'test',
-          method: (cb: redisTypes.Callback<string | null>) =>
-            client.get('test', cb),
-        },
-        {
-          description: 'delete',
-          command: 'del',
-          args: ['test'],
-          expectedDbStatement: 'test',
-          method: (cb: redisTypes.Callback<number>) => client.del('test', cb),
-        },
-      ];
+      {
+        description: 'insert',
+        command: 'hset',
+        args: ['hash', 'random', 'random'],
+        expectedDbStatement: 'hash random [1 other arguments]',
+        method: (cb: redisTypes.Callback<number>) =>
+          client.hset('hash', 'random', 'random', cb),
+      },
+      {
+        description: 'get',
+        command: 'get',
+        args: ['test'],
+        expectedDbStatement: 'test',
+        method: (cb: redisTypes.Callback<string | null>) =>
+          client.get('test', cb),
+      },
+      {
+        description: 'delete',
+        command: 'del',
+        args: ['test'],
+        expectedDbStatement: 'test',
+        method: (cb: redisTypes.Callback<number>) => client.del('test', cb),
+      },
+    ];
 
     before(done => {
       client = redis.createClient(URL);
@@ -402,7 +402,9 @@ describe('redis@2.x', () => {
 
       it('should use new tracer provider after setTracerProvider is called', done => {
         const testSpecificMemoryExporter = new InMemorySpanExporter();
-        const spanProcessor = new SimpleSpanProcessor(testSpecificMemoryExporter);
+        const spanProcessor = new SimpleSpanProcessor(
+          testSpecificMemoryExporter
+        );
         const tracerProvider = new NodeTracerProvider({
           spanProcessors: [spanProcessor],
         });
@@ -411,14 +413,14 @@ describe('redis@2.x', () => {
         // new spans use it.
         instrumentation.setTracerProvider(tracerProvider);
 
-        client.set('foo', 'bar-value-from-test', (err) => {
+        client.set('test', 'value-with-new-tracer-provider', err => {
           assert.ifError(err);
           // assert that the span was exported by the new tracer provider
           // which is using the test specific span processor
           const spans = testSpecificMemoryExporter.getFinishedSpans();
           assert.strictEqual(spans.length, 1);
           done();
-        })
+        });
       });
     });
   });
