feat(koa): Adds support to ignore a span by its layer name

MrFabio · MrFabio · commit 7576742ee98c · 2024-11-08T17:08:02.000Z
diff --git a/plugins/node/opentelemetry-instrumentation-koa/README.md b/plugins/node/opentelemetry-instrumentation-koa/README.md
@@ -54,7 +54,7 @@ Note that generator-based middleware are deprecated and won't be instrumented.
 | Options            | Type                                | Example              | Description                                                                                              |
 | ------------------ | ----------------------------------- | -------------------- | -------------------------------------------------------------------------------------------------------- |
 | `ignoreLayersType` | `KoaLayerType[]`                    | `['middleware']`     | Ignore layers of specified type.                                                                         |
-| `ignoreLayersName` | `string[]`                          | `['logger']`         | Ignore layers with specified names.                                                                      |
+| `ignoreLayers`     | `IgnoreMatcher[]`                   | `['logger', /router/]`         | Ignore layers with specified names.                                                                      |
 | `requestHook`      | `KoaRequestCustomAttributeFunction` | `(span, info) => {}` | Function for adding custom attributes to Koa middleware layers. Receives params: `Span, KoaRequestInfo`. |
 
 `ignoreLayersType` accepts an array of `KoaLayerType` which can take the following string values:
diff --git a/plugins/node/opentelemetry-instrumentation-koa/src/instrumentation.ts b/plugins/node/opentelemetry-instrumentation-koa/src/instrumentation.ts
@@ -29,7 +29,6 @@ import { PACKAGE_NAME, PACKAGE_VERSION } from './version';
 import {
   getMiddlewareMetadata,
   isLayerIgnored,
-  isLayerNameIgnored,
 } from './utils';
 import { getRPCMetadata, RPCType } from '@opentelemetry/core';
 import {
@@ -167,7 +166,7 @@ export class KoaInstrumentation extends InstrumentationBase<KoaInstrumentationCo
         layerPath
       );
 
-      if (isLayerNameIgnored(metadata.layerName, this.getConfig())) {
+      if (isLayerIgnored(layerType, this.getConfig(), metadata.name)) {
         return middlewareLayer(context, next);
       }
 
diff --git a/plugins/node/opentelemetry-instrumentation-koa/src/types.ts b/plugins/node/opentelemetry-instrumentation-koa/src/types.ts
@@ -70,10 +70,12 @@ export interface KoaInstrumentationConfig<
   /** Ignore specific layers based on their type */
   ignoreLayersType?: KoaLayerType[];
   /** Ignore specific layers based on their name */
-  ignoreLayersName?: string[];
+  ignoreLayers?: IgnoreMatcher[];
   /** Function for adding custom attributes to each middleware layer span */
   requestHook?: KoaRequestCustomAttributeFunction<
     KoaContextType,
     KoaMiddlewareType
   >;
 }
+
+export type IgnoreMatcher = string | RegExp | ((url: string) => boolean);
diff --git a/plugins/node/opentelemetry-instrumentation-koa/src/utils.ts b/plugins/node/opentelemetry-instrumentation-koa/src/utils.ts
@@ -13,7 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { KoaLayerType, KoaInstrumentationConfig } from './types';
+import { KoaLayerType, KoaInstrumentationConfig, IgnoreMatcher } from './types';
 import { KoaContext, KoaMiddleware } from './internal-types';
 import { AttributeNames } from './enums/AttributeNames';
 import { Attributes } from '@opentelemetry/api';
@@ -27,7 +27,6 @@ export const getMiddlewareMetadata = (
 ): {
   attributes: Attributes;
   name: string;
-  layerName: string;
 } => {
   if (isRouter) {
     return {
@@ -36,17 +35,15 @@ export const getMiddlewareMetadata = (
         [AttributeNames.KOA_TYPE]: KoaLayerType.ROUTER,
         [SEMATTRS_HTTP_ROUTE]: layerPath?.toString(),
       },
-      name: context._matchedRouteName || `router - ${layerPath}`,
-      layerName: context._matchedRouteName || layerPath?.toString() || '',
+      name: context._matchedRouteName || `router - ${layerPath}`
     };
   } else {
     return {
       attributes: {
         [AttributeNames.KOA_NAME]: layer.name ?? 'middleware',
         [AttributeNames.KOA_TYPE]: KoaLayerType.MIDDLEWARE,
       },
-      name: `middleware - ${layer.name}`,
-      layerName: layer.name,
+      name: `middleware - ${layer.name}`
     };
   }
 };
@@ -59,26 +56,48 @@ export const getMiddlewareMetadata = (
  */
 export const isLayerIgnored = (
   type: KoaLayerType,
-  config?: KoaInstrumentationConfig
+  config?: KoaInstrumentationConfig,
+  name?: string
 ): boolean => {
-  return !!(
+  if (
     Array.isArray(config?.ignoreLayersType) &&
     config?.ignoreLayersType?.includes(type)
-  );
+  ) {
+    return true;
+  }
+  if (Array.isArray(config?.ignoreLayers) === false || !config?.ignoreLayers ) return false;
+  try {
+    for (const pattern of config.ignoreLayers) {
+      if (satisfiesPattern(name!, pattern)) {
+        return true;
+      }
+    }
+  } catch (e) {
+    /* catch block*/
+  }
+
+  return false;
 };
 
 /**
- * Check whether the given request name is ignored by configuration
- * @param [list] List of ignore name patterns
- * @param [onException] callback for doing something when an exception has
- *     occurred
+ * Check whether the given obj match pattern
+ * @param constant e.g URL of request
+ * @param obj obj to inspect
+ * @param pattern Match pattern
  */
-export const isLayerNameIgnored = (
-  layerName: string,
-  config?: KoaInstrumentationConfig
+export const satisfiesPattern = (
+  constant: string,
+  pattern: IgnoreMatcher
 ): boolean => {
-  return !!(
-    Array.isArray(config?.ignoreLayersName) &&
-    config?.ignoreLayersName?.includes(layerName)
-  );
+  console.warn(`constant: ${constant}`);
+  console.warn(`pattern: ${pattern}`);
+  if (typeof pattern === 'string') {
+    return pattern === constant;
+  } else if (pattern instanceof RegExp) {
+    return pattern.test(constant);
+  } else if (typeof pattern === 'function') {
+    return pattern(constant);
+  } else {
+    throw new TypeError('Pattern is in unsupported datatype');
+  }
 };
diff --git a/plugins/node/opentelemetry-instrumentation-koa/test/utils.test.ts b/plugins/node/opentelemetry-instrumentation-koa/test/utils.test.ts
@@ -16,7 +16,7 @@
 
 import * as utils from '../src/utils';
 import * as assert from 'assert';
-import { KoaInstrumentationConfig, KoaLayerType } from '../src/types';
+import { IgnoreMatcher, KoaInstrumentationConfig, KoaLayerType } from '../src/types';
 
 describe('Utils', () => {
   describe('isLayerIgnored()', () => {
@@ -60,45 +60,115 @@ describe('Utils', () => {
   });
   describe('isLayerNameIgnored()', () => {
     it('should not fail with invalid config', () => {
-      assert.strictEqual(utils.isLayerNameIgnored(''), false);
+      assert.strictEqual(utils.isLayerIgnored(KoaLayerType.MIDDLEWARE, {}), false);
       assert.strictEqual(
-        utils.isLayerNameIgnored('', {} as KoaInstrumentationConfig),
+        utils.isLayerIgnored(KoaLayerType.MIDDLEWARE, {} as KoaInstrumentationConfig),
         false
       );
       assert.strictEqual(
-        utils.isLayerNameIgnored('', {
-          ignoreLayersName: {},
-        } as KoaInstrumentationConfig),
+        utils.isLayerIgnored(KoaLayerType.MIDDLEWARE, {
+          ignoreLayers: {},
+        } as KoaInstrumentationConfig, ''),
         false
       );
       assert.strictEqual(
-        utils.isLayerNameIgnored('logger', {
-          ignoreLayersName: {},
-        } as KoaInstrumentationConfig),
+        utils.isLayerIgnored(KoaLayerType.MIDDLEWARE, {
+          ignoreLayers: {},
+        } as KoaInstrumentationConfig, 'logger'),
         false
       );
-      assert.strictEqual(utils.isLayerNameIgnored('logger'), false);
+      assert.strictEqual(utils.isLayerIgnored(KoaLayerType.MIDDLEWARE, {}, 'logger'), false);
       assert.strictEqual(
-        utils.isLayerNameIgnored('', {
-          ignoreLayersName: [],
-        } as KoaInstrumentationConfig),
+        utils.isLayerIgnored(KoaLayerType.MIDDLEWARE, {
+          ignoreLayers: [],
+        } as KoaInstrumentationConfig, ''),
         false
       );
     });
 
-    it('should ignore based on type', () => {
+    it('should ignore based on name', () => {
       assert.strictEqual(
-        utils.isLayerNameIgnored('logger', {
-          ignoreLayersName: ['logger'],
-        }),
+        utils.isLayerIgnored(KoaLayerType.MIDDLEWARE, {
+          ignoreLayers: ['logger'],
+        }, 'logger'),
         true
       );
       assert.strictEqual(
-        utils.isLayerNameIgnored('', {
-          ignoreLayersName: ['logger'],
-        }),
+        utils.isLayerIgnored(KoaLayerType.MIDDLEWARE, {
+          ignoreLayers: ['logger'],
+        }, 'logger'),
+        true
+      );
+      assert.strictEqual(
+        utils.isLayerIgnored(KoaLayerType.MIDDLEWARE, {
+          ignoreLayers: ['logger'],
+        }, ''),
         false
       );
+      assert.strictEqual(
+        utils.isLayerIgnored(KoaLayerType.MIDDLEWARE, {
+          ignoreLayers: [/logger/],
+        }, 'logger - test'),
+        true
+      );
+      assert.strictEqual(
+        utils.isLayerIgnored(KoaLayerType.MIDDLEWARE, {
+          ignoreLayers: [/logger/],
+        }, 'router - test'),
+        false
+      );
+      assert.strictEqual(
+        utils.isLayerIgnored(KoaLayerType.MIDDLEWARE, {
+          ignoreLayers: [(name: string) => name === 'test'],
+        }, 'test'),
+        true
+      );
+      assert.strictEqual(
+        utils.isLayerIgnored(KoaLayerType.MIDDLEWARE, {
+          ignoreLayers: [(name: string) => name === 'router'],
+        }, 'test'),
+        false
+      );
+    });
+  });
+});
+
+describe('Utility', () => {
+  describe('satisfiesPattern()', () => {
+    it('string pattern', () => {
+      const answer1 = utils.satisfiesPattern('localhost', 'localhost');
+      assert.strictEqual(answer1, true);
+      const answer2 = utils.satisfiesPattern('hostname', 'localhost');
+      assert.strictEqual(answer2, false);
+    });
+
+    it('regex pattern', () => {
+      const answer1 = utils.satisfiesPattern('LocalHost', /localhost/i);
+      assert.strictEqual(answer1, true);
+      const answer2 = utils.satisfiesPattern('Montreal.ca', /montreal.ca/);
+      assert.strictEqual(answer2, false);
+    });
+
+    it('should throw if type is unknown', () => {
+      try {
+        utils.satisfiesPattern('google.com', true as unknown as IgnoreMatcher);
+        assert.fail();
+      } catch (error) {
+        assert.strictEqual(error instanceof TypeError, true);
+      }
+    });
+
+    it('function pattern', () => {
+      const answer1 = utils.satisfiesPattern(
+        'montreal.ca',
+        (url: string) => url === 'montreal.ca'
+      );
+      assert.strictEqual(answer1, true);
+      const answer2 = utils.satisfiesPattern(
+        'montreal.ca',
+        (url: string) => url !== 'montreal.ca'
+      );
+      assert.strictEqual(answer2, false);
     });
   });
 });
