fix(instrumentation): add back support for absolute paths via require-in-the-middle

experimental/CHANGELOG.md

@@ -16,6 +16,7 @@ All notable changes to experimental packages in this project will be documented
 
 * fix(instrumentation-xhr): http.url attribute should be absolute [#3200](https://github.com/open-telemetry/opentelemetry-js/pull/3200) @t2t2
 * fix(instrumentation-grpc): always set grpc semcov status code attribute with numeric value [#3076](https://github.com/open-telemetry/opentelemetry-js/pull/3076) @blumamir
+* fix(instrumentation): add back support for absolute paths via `require-in-the-middle` [#3457](https://github.com/open-telemetry/opentelemetry-js/pull/3457) @mhassan1
 
 ### :books: (Refine Doc)
 

experimental/packages/opentelemetry-instrumentation/src/platform/node/instrumentation.ts

@@ -21,6 +21,7 @@ import { InstrumentationAbstract } from '../../instrumentation';
 import { RequireInTheMiddleSingleton, Hooked } from './RequireInTheMiddleSingleton';
 import { InstrumentationModuleDefinition } from './types';
 import { diag } from '@opentelemetry/api';
+import * as RequireInTheMiddle from 'require-in-the-middle';
 
 /**
  * Base abstract class for instrumenting node plugins
@@ -29,7 +30,7 @@ export abstract class InstrumentationBase<T = any>
   extends InstrumentationAbstract
   implements types.Instrumentation {
   private _modules: InstrumentationModuleDefinition<T>[];
-  private _hooks: Hooked[] = [];
+  private _hooks: (Hooked | RequireInTheMiddle.Hooked)[] = [];
   private _requireInTheMiddleSingleton: RequireInTheMiddleSingleton = RequireInTheMiddleSingleton.getInstance();
   private _enabled = false;
 
@@ -160,21 +161,24 @@ export abstract class InstrumentationBase<T = any>
 
     this._warnOnPreloadedModules();
     for (const module of this._modules) {
-      this._hooks.push(
-        this._requireInTheMiddleSingleton.register(
-          module.name,
-          (exports, name, baseDir) => {
-            return this._onRequire<typeof exports>(
-              (module as unknown) as InstrumentationModuleDefinition<
-                typeof exports
-              >,
-              exports,
-              name,
-              baseDir
-            );
-          }
-        )
-      );
+      const onRequire: RequireInTheMiddle.OnRequireFn = (exports, name, baseDir) => {
+        return this._onRequire<typeof exports>(
+          (module as unknown) as InstrumentationModuleDefinition<
+            typeof exports
+          >,
+          exports,
+          name,
+          baseDir
+        );
+      };
+
+      // `RequireInTheMiddleSingleton` does not support absolute paths.
+      // For an absolute paths, we must create a separate instance of `RequireInTheMiddle`.
+      const hook = path.isAbsolute(module.name)
+        ? RequireInTheMiddle([module.name], { internals: true }, onRequire)
+        : this._requireInTheMiddleSingleton.register(module.name, onRequire);
+
+      this._hooks.push(hook);
     }
   }
 

experimental/packages/opentelemetry-instrumentation/test/node/InstrumentationBase.test.ts

@@ -16,7 +16,8 @@
 
 import * as assert from 'assert';
 import * as sinon from 'sinon';
-import { InstrumentationBase, InstrumentationModuleDefinition } from '../../src';
+import { InstrumentationBase, InstrumentationModuleDefinition, InstrumentationNodeModuleDefinition, InstrumentationNodeModuleFile } from '../../src';
+import * as path from 'path';
 
 const MODULE_NAME = 'test-module';
 const MODULE_FILE_NAME = 'test-module-file';
@@ -254,4 +255,93 @@ describe('InstrumentationBase', () => {
       });
     });
   });
+
+  describe('enable/disable', () => {
+    describe('AND a normal module name', () => {
+      type Exports = Record<string, unknown>;
+      type ExportsPatched = Exports & { __patched?: boolean };
+      const moduleName = 'net';
+      class TestInstrumentation extends InstrumentationBase<Exports> {
+        constructor() {
+          super('@opentelemetry/instrumentation-net-test', '0.0.0', { enabled: false });
+        }
+        init(): InstrumentationNodeModuleDefinition<Exports>[] {
+          return [
+            new InstrumentationNodeModuleDefinition<Exports>(
+              moduleName,
+              ['*'],
+              (exports: ExportsPatched) => {
+                exports.__patched = true;
+                return exports;
+              },
+              (exports: ExportsPatched) => {
+                exports.__patched = false;
+                return exports;
+              }
+            )
+          ];
+        }
+      }
+
+      const instrumentation = new TestInstrumentation();
+
+      it('should patch the module', () => {
+        instrumentation.enable();
+        const exportsPatched = require(moduleName);
+        assert.equal(exportsPatched.__patched, true, 'after enable');
+        instrumentation.disable();
+        assert.equal(exportsPatched.__patched, false, 'after disable');
+        instrumentation.enable();
+        assert.equal(exportsPatched.__patched, true, 'after re-enable');
+      });
+    });
+
+    describe('AND an absolute path module name', () => {
+      type Exports = Record<string, unknown>;
+      type ExportsPatched = Exports & { __patched?: boolean };
+      const moduleName = 'absolutePathTestFixture';
+      const fileName = path.join(__dirname, 'fixtures', `${moduleName}.js`);
+      class TestInstrumentation extends InstrumentationBase<Exports> {
+        constructor() {
+          super('@opentelemetry/instrumentation-absolute-path-test', '0.0.0', { enabled: false });
+        }
+        init(): InstrumentationNodeModuleDefinition<Exports>[] {
+          return [
+            new InstrumentationNodeModuleDefinition<Exports>(
+              fileName,
+              ['*'],
+              undefined,
+              undefined,
+              [
+                new InstrumentationNodeModuleFile(
+                  moduleName,
+                  ['*'],
+                  (exports: ExportsPatched) => {
+                    exports.__patched = true;
+                    return exports;
+                  },
+                  (exports?: ExportsPatched) => {
+                    if (exports) exports.__patched = false;
+                    return exports;
+                  }
+                )
+              ],
+            )
+          ];
+        }
+      }
+
+      const instrumentation = new TestInstrumentation();
+
+      it('should patch the module', () => {
+        instrumentation.enable();
+        const exportsPatched = require(fileName);
+        assert.equal(exportsPatched.__patched, true, 'after enable');
+        instrumentation.disable();
+        assert.equal(exportsPatched.__patched, false, 'after disable');
+        instrumentation.enable();
+        assert.equal(exportsPatched.__patched, true, 'after re-enable');
+      });
+    });
+  });
 });

experimental/packages/opentelemetry-instrumentation/test/node/fixtures/absolutePathTestFixture.js

@@ -0,0 +1,17 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+module.exports = {};