feat(sdk-*)!: align merge resource behavior with spec

CHANGELOG_NEXT.md

@@ -16,6 +16,7 @@
 * refactor(sdk-trace-base)!: remove `new Span` constructor in favor of `Tracer.startSpan` API [#5048](https://github.com/open-telemetry/opentelemetry-js/pull/5048) @david-luna
 * refactor(sdk-trace-base)!: remove `BasicTracerProvider.addSpanProcessor` API in favor of constructor options. [#5134](https://github.com/open-telemetry/opentelemetry-js/pull/5134) @david-luna
 * refactor(sdk-trace-base)!: make `resource` property private in `BasicTracerProvider` and remove `getActiveSpanProcessor` API. [#5192](https://github.com/open-telemetry/opentelemetry-js/pull/5192) @david-luna
+* refactor!: align merge resource behavior with spec in all SDKs. [#5219](https://github.com/open-telemetry/opentelemetry-js/pull/5219) @david-luna
 
 ### :rocket: (Enhancement)
 

experimental/packages/opentelemetry-exporter-metrics-otlp-grpc/test/OTLPMetricExporter.test.ts

@@ -53,14 +53,15 @@ const udsAddr = 'unix:///tmp/otlp-metrics.sock';
 type TestParams = {
   address?: string;
   useTLS?: boolean;
+  useDefaultResource?: boolean;
   metadata?: grpc.Metadata;
 };
 
 const metadata = new grpc.Metadata();
 metadata.set('k', 'v');
 
 const testOTLPMetricExporter = (params: TestParams) => {
-  const { address = httpAddr, useTLS, metadata } = params;
+  const { address = httpAddr, useTLS, metadata, useDefaultResource } = params;
   return describe(`OTLPMetricExporter - node ${
     useTLS ? 'with' : 'without'
   } TLS, ${metadata ? 'with' : 'without'} metadata, target ${address}`, () => {
@@ -143,7 +144,7 @@ const testOTLPMetricExporter = (params: TestParams) => {
         temporalityPreference: AggregationTemporalityPreference.CUMULATIVE,
       });
 
-      setUp();
+      setUp(!!useDefaultResource);
 
       const counter = mockCounter();
       mockObservableGauge(observableResult => {
@@ -290,7 +291,7 @@ const testOTLPMetricExporter = (params: TestParams) => {
             ['0', '2', '0']
           );
           assert.ok(typeof resource !== 'undefined', "resource doesn't exist");
-          ensureResourceIsCorrect(resource);
+          ensureResourceIsCorrect(resource, !!useDefaultResource);
 
           ensureMetadataIsCorrect(reqMetadata, metadata);
 
@@ -304,5 +305,6 @@ const testOTLPMetricExporter = (params: TestParams) => {
 testOTLPMetricExporter({ useTLS: true });
 testOTLPMetricExporter({ useTLS: false });
 testOTLPMetricExporter({ metadata });
+testOTLPMetricExporter({ useDefaultResource: true });
 // skip UDS tests on windows
 process.platform !== 'win32' && testOTLPMetricExporter({ address: udsAddr });

experimental/packages/opentelemetry-exporter-metrics-otlp-grpc/test/metricsHelper.ts

@@ -66,10 +66,10 @@ export async function collect() {
   return (await reader.collect())!;
 }
 
-export function setUp() {
+export function setUp(useDefaultResource: boolean) {
   reader = new TestMetricReader();
   meterProvider = new MeterProvider({
-    resource: testResource,
+    resource: useDefaultResource ? undefined : testResource,
     views: [
       {
         aggregation: {
@@ -211,61 +211,72 @@ export function ensureExportedHistogramIsCorrect(
   assert.deepStrictEqual(dp.explicitBounds, explicitBounds);
 }
 
-export function ensureResourceIsCorrect(resource: IResource) {
-  assert.deepStrictEqual(resource, {
-    attributes: [
-      {
-        key: 'service.name',
-        value: {
-          stringValue: `unknown_service:${process.argv0}`,
-          value: 'stringValue',
+export function ensureResourceIsCorrect(
+  resource: IResource,
+  checkDefault: boolean
+) {
+  if (checkDefault) {
+    assert.deepStrictEqual(resource, {
+      attributes: [
+        {
+          key: 'service.name',
+          value: {
+            stringValue: `unknown_service:${process.argv0}`,
+            value: 'stringValue',
+          },
         },
-      },
-      {
-        key: 'telemetry.sdk.language',
-        value: {
-          stringValue: 'nodejs',
-          value: 'stringValue',
+        {
+          key: 'telemetry.sdk.language',
+          value: {
+            stringValue: 'nodejs',
+            value: 'stringValue',
+          },
         },
-      },
-      {
-        key: 'telemetry.sdk.name',
-        value: {
-          stringValue: 'opentelemetry',
-          value: 'stringValue',
+        {
+          key: 'telemetry.sdk.name',
+          value: {
+            stringValue: 'opentelemetry',
+            value: 'stringValue',
+          },
         },
-      },
-      {
-        key: 'telemetry.sdk.version',
-        value: {
-          stringValue: VERSION,
-          value: 'stringValue',
+        {
+          key: 'telemetry.sdk.version',
+          value: {
+            stringValue: VERSION,
+            value: 'stringValue',
+          },
         },
-      },
-      {
-        key: 'service',
-        value: {
-          stringValue: 'ui',
-          value: 'stringValue',
+      ],
+      droppedAttributesCount: 0,
+    });
+  } else {
+    assert.deepStrictEqual(resource, {
+      attributes: [
+        {
+          key: 'service',
+          value: {
+            stringValue: 'ui',
+            value: 'stringValue',
+          },
         },
-      },
-      {
-        key: 'version',
-        value: {
-          intValue: '1',
-          value: 'intValue',
+        {
+          key: 'version',
+          value: {
+            intValue: '1',
+            value: 'intValue',
+          },
         },
-      },
-      {
-        key: 'cost',
-        value: {
-          doubleValue: 112.12,
-          value: 'doubleValue',
+        {
+          key: 'cost',
+          value: {
+            doubleValue: 112.12,
+            value: 'doubleValue',
+          },
         },
-      },
-    ],
-    droppedAttributesCount: 0,
-  });
+      ],
+      droppedAttributesCount: 0,
+    });
+  }
 }
 
 export function ensureMetadataIsCorrect(

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

@@ -103,7 +103,6 @@ export class NodeSDK {
 
   private _resource: IResource;
   private _resourceDetectors: Array<Detector | DetectorSync>;
-  private _mergeResourceWithDefaults: boolean;
 
   private _autoDetectResources: boolean;
 
@@ -139,8 +138,6 @@ 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 = [];
@@ -263,7 +260,6 @@ export class NodeSDK {
     this._tracerProvider = new NodeTracerProvider({
       ...this._configuration,
       resource: this._resource,
-      mergeResourceWithDefaults: this._mergeResourceWithDefaults,
       spanProcessors,
     });
 
@@ -281,7 +277,6 @@ export class NodeSDK {
     if (this._loggerProviderConfig) {
       const loggerProvider = new LoggerProvider({
         resource: this._resource,
-        mergeResourceWithDefaults: this._mergeResourceWithDefaults,
       });
 
       for (const logRecordProcessor of this._loggerProviderConfig
@@ -303,7 +298,6 @@ 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,7 +40,6 @@ 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,28 +28,13 @@ 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 = prepareResource(
-      mergedConfig.mergeResourceWithDefaults,
-      config.resource
-    );
+    const resource = config.resource ?? Resource.default();
     this._sharedState = new LoggerProviderSharedState(
       resource,
       mergedConfig.forceFlushTimeoutMillis,

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

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

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

@@ -28,12 +28,6 @@ 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

@@ -63,39 +63,15 @@ describe('LoggerProvider', () => {
         assert.deepStrictEqual(resource, Resource.default());
       });
 
-      it('should fallback to default resource attrs', () => {
-        const passedInResource = new Resource({ foo: 'bar' });
-        const provider = new LoggerProvider({ resource: passedInResource });
-        const { resource } = provider['_sharedState'];
-        assert.deepStrictEqual(
-          resource,
-          Resource.default().merge(passedInResource)
-        );
-      });
-
-      it('should not merge with default resource attrs when flag is set to false', function () {
+      it('should not have default resource if passed', 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

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

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

@@ -54,7 +54,6 @@ 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

@@ -35,12 +35,6 @@ 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

@@ -932,25 +932,12 @@ describe('BasicTracerProvider', () => {
       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 () {
+    it('should use not use the default if resource passed', function () {
       const providedResource = new Resource({ foo: 'bar' });
       const tracerProvider = new BasicTracerProvider({
-        mergeResourceWithDefaults: true,
         resource: providedResource,
       });
-      assert.deepStrictEqual(
-        tracerProvider['_resource'],
-        Resource.default().merge(providedResource)
-      );
+      assert.deepStrictEqual(tracerProvider['_resource'], providedResource);
     });
   });