wip

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/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/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', () => {