feat: merge user supplied and default plugin configs

packages/opentelemetry-node/src/NodeTracerProvider.ts

@@ -20,7 +20,7 @@ import {
   SDKRegistrationConfig,
 } from '@opentelemetry/tracing';
 import { DEFAULT_INSTRUMENTATION_PLUGINS, NodeTracerConfig } from './config';
-import { PluginLoader } from './instrumentation/PluginLoader';
+import { PluginLoader, Plugins } from './instrumentation/PluginLoader';
 
 /**
  * Register this TracerProvider for use with the OpenTelemetry API.
@@ -39,7 +39,12 @@ export class NodeTracerProvider extends BasicTracerProvider {
     super(config);
 
     this._pluginLoader = new PluginLoader(this, this.logger);
-    this._pluginLoader.load(config.plugins || DEFAULT_INSTRUMENTATION_PLUGINS);
+
+    config.plugins
+      ? this._pluginLoader.load(
+          mergePlugins(DEFAULT_INSTRUMENTATION_PLUGINS, config.plugins)
+        )
+      : this._pluginLoader.load(DEFAULT_INSTRUMENTATION_PLUGINS);
   }
 
   stop() {
@@ -55,3 +60,32 @@ export class NodeTracerProvider extends BasicTracerProvider {
     super.register(config);
   }
 }
+
+/**
+ * Two layer merge.
+ * First, for user supplied config of plugin(s) that are loaded by default,
+ * merge the user supplied and default configs of said plugin(s).
+ * Then merge the results with the default plugins.
+ * @returns 2-layer deep merge of default and user supplied plugins.
+ */
+export function mergePlugins(
+  defaultPlugins: Plugins,
+  userSuppliedPlugins: Plugins
+): Plugins {
+  let mergedUserSuppliedPlugins: Plugins = {};
+
+  for (const pluginName in userSuppliedPlugins) {
+    mergedUserSuppliedPlugins[pluginName] = {
+      // Any user-supplied non-default plugin should be enabled by default
+      ...(DEFAULT_INSTRUMENTATION_PLUGINS[pluginName] || { enabled: true }),
+      ...userSuppliedPlugins[pluginName],
+    };
+  }
+
+  const mergedPlugins: Plugins = {
+    ...defaultPlugins,
+    ...mergedUserSuppliedPlugins,
+  };
+
+  return mergedPlugins;
+}

packages/opentelemetry-node/test/NodeTracerProvider.test.ts

@@ -28,7 +28,7 @@ import { Resource, TELEMETRY_SDK_RESOURCE } from '@opentelemetry/resources';
 import * as assert from 'assert';
 import * as path from 'path';
 import { ContextManager } from '@opentelemetry/context-base';
-import { NodeTracerProvider } from '../src/NodeTracerProvider';
+import { NodeTracerProvider, mergePlugins } from '../src/NodeTracerProvider';
 
 const sleep = (time: number) =>
   new Promise(resolve => {
@@ -81,29 +81,38 @@ describe('NodeTracerProvider', () => {
       assert.ok(provider instanceof NodeTracerProvider);
     });
 
-    it('should load user configured plugins', () => {
+    it('should load a merge of user configured and default plugins and implictly enable non-default plugins', () => {
       provider = new NodeTracerProvider({
         logger: new NoopLogger(),
         plugins: {
           'simple-module': {
-            enabled: true,
             path: '@opentelemetry/plugin-simple-module',
           },
           'supported-module': {
-            enabled: true,
             path: '@opentelemetry/plugin-supported-module',
             enhancedDatabaseReporting: false,
             ignoreMethods: [],
             ignoreUrls: [],
           },
+          'random-module': {
+            enabled: false,
+            path: '@opentelemetry/random-module',
+          },
+          http: {
+            path: '@opentelemetry/plugin-http-module',
+          },
         },
       });
-      const pluginLoader = provider['_pluginLoader'];
-      assert.strictEqual(pluginLoader['_plugins'].length, 0);
+      const plugins = provider['_pluginLoader']['_plugins'];
+      assert.strictEqual(plugins.length, 0);
       require('simple-module');
-      assert.strictEqual(pluginLoader['_plugins'].length, 1);
+      assert.strictEqual(plugins.length, 1);
       require('supported-module');
-      assert.strictEqual(pluginLoader['_plugins'].length, 2);
+      assert.strictEqual(plugins.length, 2);
+      require('random-module');
+      assert.strictEqual(plugins.length, 2);
+      require('http');
+      assert.strictEqual(plugins.length, 3);
     });
 
     it('should construct an instance with default attributes', () => {
@@ -269,3 +278,50 @@ describe('NodeTracerProvider', () => {
     });
   });
 });
+
+describe('mergePlugins', () => {
+  const defaultPlugins = {
+    module1: {
+      enabled: true,
+      path: 'testpath',
+    },
+    module2: {
+      enabled: true,
+      path: 'testpath2',
+    },
+    module3: {
+      enabled: true,
+      path: 'testpath3',
+    },
+  };
+
+  const userPlugins = {
+    module2: {
+      path: 'userpath',
+    },
+    module3: {
+      enabled: false,
+    },
+    nonDefaultModule: {
+      path: 'userpath2',
+    },
+  };
+
+  const mergedPlugins = mergePlugins(defaultPlugins, userPlugins);
+
+  it('should merge user and default configs', () => {
+    assert.equal(mergedPlugins.module1.enabled, true);
+    assert.equal(mergedPlugins.module1.path, 'testpath');
+    assert.equal(mergedPlugins.module2.enabled, true);
+    assert.equal(mergedPlugins.module2.path, 'userpath');
+    assert.equal(mergedPlugins.module3.enabled, false);
+    assert.equal(mergedPlugins.nonDefaultModule.enabled, true);
+    assert.equal(mergedPlugins.nonDefaultModule.path, 'userpath2');
+  });
+
+  it('should should not mangle default config', () => {
+    assert.equal(defaultPlugins.module2.path, 'testpath2');
+    assert.equal(defaultPlugins.module3.enabled, true);
+    assert.equal(defaultPlugins.module3.path, 'testpath3');
+  });
+});