[prototype] feat(sdk-trace): add option to opt-out from merging the resource with Resource.default()

experimental/packages/opentelemetry-sdk-node/src/sdk.ts

@@ -96,6 +96,7 @@ export class NodeSDK {
 
   private _resource: IResource;
   private _resourceDetectors: Array<Detector | DetectorSync>;
+  private _mergeResourceWithDefaults: boolean;
 
   private _autoDetectResources: boolean;
 
@@ -131,6 +132,8 @@ export class NodeSDK {
     this._configuration = configuration;
 
     this._resource = configuration.resource ?? new Resource({});
+    this._mergeResourceWithDefaults =
+      configuration.mergeResourceWithDefaults ?? true;
     this._autoDetectResources = configuration.autoDetectResources ?? true;
     if (!this._autoDetectResources) {
       this._resourceDetectors = [];
@@ -254,6 +257,7 @@ export class NodeSDK {
     const tracerProvider = new Provider({
       ...this._configuration,
       resource: this._resource,
+      mergeResourceWithDefaults: this._mergeResourceWithDefaults,
     });
 
     this._tracerProvider = tracerProvider;
@@ -296,6 +300,7 @@ export class NodeSDK {
         resource: this._resource,
         views: this._meterProviderConfig?.views ?? [],
         readers: readers,
+        mergeResourceWithDefaults: this._mergeResourceWithDefaults,
       });
 
       this._meterProvider = meterProvider;

experimental/packages/opentelemetry-sdk-node/src/types.ts

@@ -40,6 +40,7 @@ export interface NodeSDKConfiguration {
   instrumentations: (Instrumentation | Instrumentation[])[];
   resource: IResource;
   resourceDetectors: Array<Detector | DetectorSync>;
+  mergeResourceWithDefaults: boolean;
   sampler: Sampler;
   serviceName?: string;
   /** @deprecated use spanProcessors instead*/

experimental/packages/sdk-logs/src/LoggerProvider.ts

@@ -28,14 +28,27 @@ import { LoggerProviderSharedState } from './internal/LoggerProviderSharedState'
 
 export const DEFAULT_LOGGER_NAME = 'unknown';
 
+function prepareResource(
+  mergeWithDefaults: boolean,
+  providedResource: Resource | undefined
+) {
+  const resource = providedResource ?? Resource.empty();
+
+  if (mergeWithDefaults) {
+    return Resource.default().merge(resource);
+  }
+  return resource;
+}
+
 export class LoggerProvider implements logsAPI.LoggerProvider {
   private _shutdownOnce: BindOnceFuture<void>;
   private readonly _sharedState: LoggerProviderSharedState;
 
   constructor(config: LoggerProviderConfig = {}) {
     const mergedConfig = merge({}, loadDefaultConfig(), config);
-    const resource = Resource.default().merge(
-      mergedConfig.resource ?? Resource.empty()
+    const resource = prepareResource(
+      mergedConfig.mergeResourceWithDefaults,
+      config.resource
     );
     this._sharedState = new LoggerProviderSharedState(
       resource,

experimental/packages/sdk-logs/src/config.ts

@@ -31,6 +31,7 @@ export function loadDefaultConfig() {
       attributeCountLimit: getEnv().OTEL_LOGRECORD_ATTRIBUTE_COUNT_LIMIT,
     },
     includeTraceContext: true,
+    mergeResourceWithDefaults: true,
   };
 }
 

experimental/packages/sdk-logs/src/types.ts

@@ -28,6 +28,12 @@ export interface LoggerProviderConfig {
 
   /** Log Record Limits*/
   logRecordLimits?: LogRecordLimits;
+
+  /**
+   * Merge resource with {@link Resource.default()}?
+   * Default: {@code true}
+   **/
+  mergeResourceWithDefaults?: boolean;
 }
 
 export interface LogRecordLimits {

experimental/packages/sdk-logs/test/common/LoggerProvider.test.ts

@@ -73,6 +73,29 @@ describe('LoggerProvider', () => {
         );
       });
 
+      it('should not merge with default resource attrs when flag is set to false', function () {
+        const passedInResource = new Resource({ foo: 'bar' });
+        const provider = new LoggerProvider({
+          resource: passedInResource,
+          mergeResourceWithDefaults: false,
+        });
+        const { resource } = provider['_sharedState'];
+        assert.deepStrictEqual(resource, passedInResource);
+      });
+
+      it('should merge with default resource attrs when flag is set to true', function () {
+        const passedInResource = new Resource({ foo: 'bar' });
+        const provider = new LoggerProvider({
+          resource: passedInResource,
+          mergeResourceWithDefaults: true,
+        });
+        const { resource } = provider['_sharedState'];
+        assert.deepStrictEqual(
+          resource,
+          Resource.default().merge(passedInResource)
+        );
+      });
+
       it('should have default forceFlushTimeoutMillis if not pass', () => {
         const provider = new LoggerProvider();
         const sharedState = provider['_sharedState'];

packages/opentelemetry-sdk-trace-base/src/BasicTracerProvider.ts

@@ -80,7 +80,11 @@ export class BasicTracerProvider implements TracerProvider {
       reconfigureLimits(config)
     );
     this.resource = mergedConfig.resource ?? Resource.empty();
-    this.resource = Resource.default().merge(this.resource);
+
+    if (mergedConfig.mergeResourceWithDefaults) {
+      this.resource = Resource.default().merge(this.resource);
+    }
+
     this._config = Object.assign({}, mergedConfig, {
       resource: this.resource,
     });

packages/opentelemetry-sdk-trace-base/src/config.ts

@@ -54,6 +54,7 @@ export function loadDefaultConfig() {
         _env.OTEL_SPAN_ATTRIBUTE_PER_EVENT_COUNT_LIMIT,
       attributePerLinkCountLimit: _env.OTEL_SPAN_ATTRIBUTE_PER_LINK_COUNT_LIMIT,
     },
+    mergeResourceWithDefaults: true,
   };
 }
 

packages/opentelemetry-sdk-trace-base/src/types.ts

@@ -34,6 +34,12 @@ export interface TracerConfig {
   /** Span Limits */
   spanLimits?: SpanLimits;
 
+  /**
+   * Merge resource with {@link Resource.default()}?
+   * Default: {@code true}
+   **/
+  mergeResourceWithDefaults?: boolean;
+
   /** Resource associated with trace telemetry  */
   resource?: IResource;
 

packages/opentelemetry-sdk-trace-base/test/common/BasicTracerProvider.test.ts

@@ -829,9 +829,30 @@ describe('BasicTracerProvider', () => {
   });
 
   describe('.resource', () => {
-    it('should return a Resource', () => {
+    it('should use the default resource when no resource is provided', function () {
       const tracerProvider = new BasicTracerProvider();
-      assert.ok(tracerProvider.resource instanceof Resource);
+      assert.deepStrictEqual(tracerProvider.resource, Resource.default());
+    });
+
+    it('should not merge with defaults when flag is set to false', function () {
+      const expectedResource = new Resource({ foo: 'bar' });
+      const tracerProvider = new BasicTracerProvider({
+        mergeResourceWithDefaults: false,
+        resource: expectedResource,
+      });
+      assert.deepStrictEqual(tracerProvider.resource, expectedResource);
+    });
+
+    it('should merge with defaults when flag is set to true', function () {
+      const providedResource = new Resource({ foo: 'bar' });
+      const tracerProvider = new BasicTracerProvider({
+        mergeResourceWithDefaults: true,
+        resource: providedResource,
+      });
+      assert.deepStrictEqual(
+        tracerProvider.resource,
+        Resource.default().merge(providedResource)
+      );
     });
   });
 

packages/sdk-metrics/src/MeterProvider.ts

@@ -36,6 +36,27 @@ export interface MeterProviderOptions {
   resource?: IResource;
   views?: View[];
   readers?: MetricReader[];
+  /**
+   * Merge resource with {@link Resource.default()}?
+   * Default: {@code true}
+   **/
+  mergeResourceWithDefaults?: boolean;
+}
+
+/**
+ * @param mergeWithDefaults
+ * @param providedResource
+ */
+function prepareResource(
+  mergeWithDefaults: boolean,
+  providedResource: Resource | undefined
+) {
+  const resource = providedResource ?? Resource.empty();
+
+  if (mergeWithDefaults) {
+    return Resource.default().merge(resource);
+  }
+  return resource;
 }
 
 /**
@@ -46,10 +67,12 @@ export class MeterProvider implements IMeterProvider {
   private _shutdown = false;
 
   constructor(options?: MeterProviderOptions) {
-    const resource = Resource.default().merge(
-      options?.resource ?? Resource.empty()
+    this._sharedState = new MeterProviderSharedState(
+      prepareResource(
+        options?.mergeResourceWithDefaults ?? true,
+        options?.resource
+      )
     );
-    this._sharedState = new MeterProviderSharedState(resource);
     if (options?.views != null && options.views.length > 0) {
       for (const view of options.views) {
         this._sharedState.viewRegistry.addView(view);

packages/sdk-metrics/test/MeterProvider.test.ts

@@ -32,6 +32,7 @@ import { TestMetricReader } from './export/TestMetricReader';
 import * as sinon from 'sinon';
 import { View } from '../src/view/View';
 import { Meter } from '../src/Meter';
+import { Resource } from '@opentelemetry/resources';
 
 describe('MeterProvider', () => {
   afterEach(() => {
@@ -48,6 +49,66 @@ describe('MeterProvider', () => {
       const meterProvider = new MeterProvider({ resource: defaultResource });
       assert(meterProvider instanceof MeterProvider);
     });
+
+    it('should use default resource when no resource is passed', async function () {
+      const reader = new TestMetricReader();
+
+      const meterProvider = new MeterProvider({
+        readers: [reader],
+      });
+
+      // Create meter and instrument, otherwise nothing will export
+      const myMeter = meterProvider.getMeter('meter1', 'v1.0.0');
+      const counter = myMeter.createCounter('non-renamed-instrument');
+      counter.add(1, { attrib1: 'attrib_value1', attrib2: 'attrib_value2' });
+
+      // Perform collection.
+      const { resourceMetrics } = await reader.collect();
+      assert.deepStrictEqual(resourceMetrics.resource, Resource.default());
+    });
+
+    it('should not merge with defaults when flag is set to false', async function () {
+      const reader = new TestMetricReader();
+      const expectedResource = new Resource({ foo: 'bar' });
+
+      const meterProvider = new MeterProvider({
+        readers: [reader],
+        resource: expectedResource,
+        mergeResourceWithDefaults: false,
+      });
+
+      // Create meter and instrument, otherwise nothing will export
+      const myMeter = meterProvider.getMeter('meter1', 'v1.0.0');
+      const counter = myMeter.createCounter('non-renamed-instrument');
+      counter.add(1, { attrib1: 'attrib_value1', attrib2: 'attrib_value2' });
+
+      // Perform collection.
+      const { resourceMetrics } = await reader.collect();
+      assert.deepStrictEqual(resourceMetrics.resource, expectedResource);
+    });
+
+    it('should merge with defaults when flag is set to true', async function () {
+      const reader = new TestMetricReader();
+      const providedResource = new Resource({ foo: 'bar' });
+
+      const meterProvider = new MeterProvider({
+        readers: [reader],
+        resource: providedResource,
+        mergeResourceWithDefaults: true,
+      });
+
+      // Create meter and instrument, otherwise nothing will export
+      const myMeter = meterProvider.getMeter('meter1', 'v1.0.0');
+      const counter = myMeter.createCounter('non-renamed-instrument');
+      counter.add(1, { attrib1: 'attrib_value1', attrib2: 'attrib_value2' });
+
+      // Perform collection.
+      const { resourceMetrics } = await reader.collect();
+      assert.deepStrictEqual(
+        resourceMetrics.resource,
+        Resource.default().merge(providedResource)
+      );
+    });
   });
 
   describe('getMeter', () => {