Converge sync and async resources (#5350)

Author: dyladan

CHANGELOG.md

@@ -52,6 +52,11 @@ For semantic convention package changes, see the [semconv CHANGELOG](packages/se
   * (user-facing): deprecated `AlwaysOffSampler` has moved to `@opentelemetry/sdk-trace-base`
   * (user-facing): deprecated `TraceIdRatioSampler` has moved to `@opentelemetry/sdk-trace-base`
   * (user-facing): deprecated `TraceIdRatioSampler` has moved to  `@opentelemetry/sdk-trace-base`
+* feat(resource): Merge sync and async resource interfaces into a single interface [#5350](https://github.com/open-telemetry/opentelemetry-js/pull/5350) @dyladan
+  * Resource constructor now takes a single argument which contains an optional `attributes` object
+  * Detected resource attribute values may be a promise or a synchronous value
+  * Resources are now merged by the order in which their detectors are configured instead of async attributes being last
+  * Resource detectors now return `DetectedResource` plain objects instead of `new Resource()`
 * feat(sdk-trace-base)!: drop ability to instantiate propagators beyond defaults [#5355](https://github.com/open-telemetry/opentelemetry-js/pull/5355) @pichlermarc
   * (user-facing): only a non-env-var based default is now used on `BasicTracerProvider#register()`.
     * propagators can now not be configured via `OTEL_PROPAGATORS` or `window.OTEL_PROPAGATORS` anymore, please pass the propagator to `NodeTracerProvider#register()` instead.

experimental/packages/opentelemetry-browser-detector/src/BrowserDetector.ts

@@ -16,8 +16,8 @@
 
 import { Attributes, diag } from '@opentelemetry/api';
 import {
-  Detector,
-  IResource,
+  DetectedResource,
+  ResourceDetector,
   Resource,
   ResourceDetectionConfig,
 } from '@opentelemetry/resources';
@@ -26,11 +26,11 @@ import { BROWSER_ATTRIBUTES, UserAgentData } from './types';
 /**
  * BrowserDetector will be used to detect the resources related to browser.
  */
-class BrowserDetector implements Detector {
-  async detect(config?: ResourceDetectionConfig): Promise<IResource> {
+class BrowserDetector implements ResourceDetector {
+  detect(config?: ResourceDetectionConfig): DetectedResource {
     const isBrowser = typeof navigator !== 'undefined';
     if (!isBrowser) {
-      return Resource.empty();
+      return Resource.EMPTY;
     }
     const browserResource: Attributes = getBrowserAttributes();
     return this._getResourceAttributes(browserResource, config);
@@ -45,17 +45,17 @@ class BrowserDetector implements Detector {
   private _getResourceAttributes(
     browserResource: Attributes,
     _config?: ResourceDetectionConfig
-  ) {
+  ): DetectedResource {
     if (
       !browserResource[BROWSER_ATTRIBUTES.USER_AGENT] &&
       !browserResource[BROWSER_ATTRIBUTES.PLATFORM]
     ) {
       diag.debug(
         'BrowserDetector failed: Unable to find required browser resources. '
       );
-      return Resource.empty();
+      return Resource.EMPTY;
     } else {
-      return new Resource(browserResource);
+      return { attributes: browserResource };
     }
   }
 }

experimental/packages/opentelemetry-browser-detector/test/BrowserDetector.test.ts

@@ -14,9 +14,8 @@
  * limitations under the License.
  */
 import * as sinon from 'sinon';
-import { IResource } from '@opentelemetry/resources';
 import { browserDetector } from '../src/BrowserDetector';
-import { describeBrowser, assertResource, assertEmptyResource } from './util';
+import { assertEmptyResource, assertResource, describeBrowser } from './util';
 
 describeBrowser('browserDetector()', () => {
   afterEach(() => {
@@ -47,7 +46,7 @@ describeBrowser('browserDetector()', () => {
       },
     });
 
-    const resource: IResource = await browserDetector.detect();
+    const resource = browserDetector.detect();
     assertResource(resource, {
       platform: 'platform',
       brands: ['Chromium 106', 'Google Chrome 106', 'Not;A=Brand 99'],
@@ -63,7 +62,7 @@ describeBrowser('browserDetector()', () => {
       userAgentData: undefined,
     });
 
-    const resource: IResource = await browserDetector.detect();
+    const resource = browserDetector.detect();
     assertResource(resource, {
       language: 'en-US',
       user_agent: 'dddd',
@@ -74,7 +73,7 @@ describeBrowser('browserDetector()', () => {
     sinon.stub(globalThis, 'navigator').value({
       userAgent: '',
     });
-    const resource: IResource = await browserDetector.detect();
+    const resource = browserDetector.detect();
     assertEmptyResource(resource);
   });
 });

experimental/packages/opentelemetry-browser-detector/test/util.ts

@@ -16,7 +16,7 @@
 import { Suite } from 'mocha';
 import * as assert from 'assert';
 import { BROWSER_ATTRIBUTES } from '../src/types';
-import { IResource } from '@opentelemetry/resources';
+import { DetectedResource } from '@opentelemetry/resources';
 
 export function describeBrowser(title: string, fn: (this: Suite) => void) {
   title = `Browser: ${title}`;
@@ -27,7 +27,7 @@ export function describeBrowser(title: string, fn: (this: Suite) => void) {
 }
 
 export const assertResource = (
-  resource: IResource,
+  resource: DetectedResource,
   validations: {
     platform?: string;
     brands?: string[];
@@ -38,32 +38,32 @@ export const assertResource = (
 ) => {
   if (validations.platform) {
     assert.strictEqual(
-      resource.attributes[BROWSER_ATTRIBUTES.PLATFORM],
+      resource.attributes?.[BROWSER_ATTRIBUTES.PLATFORM],
       validations.platform
     );
   }
   if (validations.brands) {
-    assert.ok(Array.isArray(resource.attributes[BROWSER_ATTRIBUTES.BRANDS]));
+    assert.ok(Array.isArray(resource.attributes?.[BROWSER_ATTRIBUTES.BRANDS]));
     assert.deepStrictEqual(
-      resource.attributes[BROWSER_ATTRIBUTES.BRANDS] as string[],
+      resource.attributes?.[BROWSER_ATTRIBUTES.BRANDS] as string[],
       validations.brands
     );
   }
   if (validations.mobile) {
     assert.strictEqual(
-      resource.attributes[BROWSER_ATTRIBUTES.MOBILE],
+      resource.attributes?.[BROWSER_ATTRIBUTES.MOBILE],
       validations.mobile
     );
   }
   if (validations.language) {
     assert.strictEqual(
-      resource.attributes[BROWSER_ATTRIBUTES.LANGUAGE],
+      resource.attributes?.[BROWSER_ATTRIBUTES.LANGUAGE],
       validations.language
     );
   }
   if (validations.user_agent) {
     assert.strictEqual(
-      resource.attributes[BROWSER_ATTRIBUTES.USER_AGENT],
+      resource.attributes?.[BROWSER_ATTRIBUTES.USER_AGENT],
       validations.user_agent
     );
   }
@@ -74,6 +74,6 @@ export const assertResource = (
  *
  * @param resource the Resource to validate
  */
-export const assertEmptyResource = (resource: IResource) => {
-  assert.strictEqual(Object.keys(resource.attributes).length, 0);
+export const assertEmptyResource = (resource: DetectedResource) => {
+  assert.strictEqual(Object.keys(resource.attributes ?? {}).length, 0);
 };

experimental/packages/opentelemetry-exporter-prometheus/test/PrometheusSerializer.test.ts

@@ -704,11 +704,13 @@ describe('PrometheusSerializer', () => {
       const serializer = new PrometheusSerializer(undefined, true);
       const result = serializer['_serializeResource'](
         new Resource({
-          env: 'prod',
-          hostname: 'myhost',
-          datacenter: 'sdc',
-          region: 'europe',
-          owner: 'frontend',
+          attributes: {
+            env: 'prod',
+            hostname: 'myhost',
+            datacenter: 'sdc',
+            region: 'europe',
+            owner: 'frontend',
+          },
         })
       );
 

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

@@ -27,15 +27,14 @@ import {
   registerInstrumentations,
 } from '@opentelemetry/instrumentation';
 import {
-  Detector,
-  DetectorSync,
-  detectResourcesSync,
+  detectResources,
   envDetector,
   hostDetector,
   IResource,
   processDetector,
   Resource,
   ResourceDetectionConfig,
+  ResourceDetector,
 } from '@opentelemetry/resources';
 import {
   LogRecordProcessor,
@@ -210,7 +209,7 @@ export class NodeSDK {
   private _instrumentations: Instrumentation[];
 
   private _resource: IResource;
-  private _resourceDetectors: Array<Detector | DetectorSync>;
+  private _resourceDetectors: Array<ResourceDetector>;
 
   private _autoDetectResources: boolean;
 
@@ -346,17 +345,17 @@ export class NodeSDK {
         detectors: this._resourceDetectors,
       };
 
-      this._resource = this._resource.merge(
-        detectResourcesSync(internalConfig)
-      );
+      this._resource = this._resource.merge(detectResources(internalConfig));
     }
 
     this._resource =
       this._serviceName === undefined
         ? this._resource
         : this._resource.merge(
             new Resource({
-              [ATTR_SERVICE_NAME]: this._serviceName,
+              attributes: {
+                [ATTR_SERVICE_NAME]: this._serviceName,
+              },
             })
           );
 

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

@@ -17,7 +17,7 @@
 import type { ContextManager } from '@opentelemetry/api';
 import { TextMapPropagator } from '@opentelemetry/api';
 import { Instrumentation } from '@opentelemetry/instrumentation';
-import { Detector, DetectorSync, IResource } from '@opentelemetry/resources';
+import { IResource, ResourceDetector } from '@opentelemetry/resources';
 import { LogRecordProcessor } from '@opentelemetry/sdk-logs';
 import { IMetricReader, ViewOptions } from '@opentelemetry/sdk-metrics';
 import {
@@ -39,7 +39,7 @@ export interface NodeSDKConfiguration {
   views: ViewOptions[];
   instrumentations: (Instrumentation | Instrumentation[])[];
   resource: IResource;
-  resourceDetectors: Array<Detector | DetectorSync>;
+  resourceDetectors: Array<ResourceDetector>;
   sampler: Sampler;
   serviceName?: string;
   /** @deprecated use spanProcessors instead*/

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

@@ -26,12 +26,12 @@ import { OTLPTraceExporter as OTLPHttpTraceExporter } from '@opentelemetry/expor
 import { OTLPTraceExporter as OTLPGrpcTraceExporter } from '@opentelemetry/exporter-trace-otlp-grpc';
 import { ZipkinExporter } from '@opentelemetry/exporter-zipkin';
 import {
-  DetectorSync,
-  envDetectorSync,
-  hostDetectorSync,
-  osDetectorSync,
-  processDetectorSync,
-  serviceInstanceIdDetectorSync,
+  envDetector,
+  hostDetector,
+  osDetector,
+  processDetector,
+  ResourceDetector,
+  serviceInstanceIdDetector,
 } from '@opentelemetry/resources';
 import {
   BatchSpanProcessor,
@@ -49,14 +49,14 @@ const RESOURCE_DETECTOR_OS = 'os';
 const RESOURCE_DETECTOR_PROCESS = 'process';
 const RESOURCE_DETECTOR_SERVICE_INSTANCE_ID = 'serviceinstance';
 
-export function getResourceDetectorsFromEnv(): Array<DetectorSync> {
+export function getResourceDetectorsFromEnv(): Array<ResourceDetector> {
   // When updating this list, make sure to also update the section `resourceDetectors` on README.
-  const resourceDetectors = new Map<string, DetectorSync>([
-    [RESOURCE_DETECTOR_ENVIRONMENT, envDetectorSync],
-    [RESOURCE_DETECTOR_HOST, hostDetectorSync],
-    [RESOURCE_DETECTOR_OS, osDetectorSync],
-    [RESOURCE_DETECTOR_SERVICE_INSTANCE_ID, serviceInstanceIdDetectorSync],
-    [RESOURCE_DETECTOR_PROCESS, processDetectorSync],
+  const resourceDetectors = new Map<string, ResourceDetector>([
+    [RESOURCE_DETECTOR_ENVIRONMENT, envDetector],
+    [RESOURCE_DETECTOR_HOST, hostDetector],
+    [RESOURCE_DETECTOR_OS, osDetector],
+    [RESOURCE_DETECTOR_SERVICE_INSTANCE_ID, serviceInstanceIdDetector],
+    [RESOURCE_DETECTOR_PROCESS, processDetector],
   ]);
 
   const resourceDetectorsFromEnv =

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

@@ -62,11 +62,11 @@ import { NodeSDK } from '../src';
 import { env } from 'process';
 import {
   envDetector,
-  envDetectorSync,
   processDetector,
   hostDetector,
   Resource,
-  serviceInstanceIdDetectorSync,
+  serviceInstanceIdDetector,
+  DetectedResource,
 } from '@opentelemetry/resources';
 import { OTLPTraceExporter } from '@opentelemetry/exporter-trace-otlp-http';
 import { logs, ProxyLoggerProvider } from '@opentelemetry/api-logs';
@@ -540,8 +540,10 @@ describe('Node SDK', () => {
           resourceDetectors: [
             processDetector,
             {
-              async detect(): Promise<Resource> {
-                return new Resource({ customAttr: 'someValue' });
+              detect(): DetectedResource {
+                return {
+                  attributes: { customAttr: 'someValue' },
+                };
               },
             },
             envDetector,
@@ -705,7 +707,7 @@ describe('Node SDK', () => {
           await sdk1.shutdown();
 
           const sdk2 = new NodeSDK({
-            resourceDetectors: [envDetectorSync],
+            resourceDetectors: [envDetector],
           });
           sdk2.start();
           await sdk2.shutdown();
@@ -870,7 +872,7 @@ describe('Node SDK', () => {
           processDetector,
           envDetector,
           hostDetector,
-          serviceInstanceIdDetectorSync,
+          serviceInstanceIdDetector,
         ],
       });
 
@@ -940,8 +942,10 @@ describe('Node SDK', () => {
           resourceDetectors: [
             processDetector,
             {
-              async detect(): Promise<Resource> {
-                return new Resource({ customAttr: 'someValue' });
+              detect(): DetectedResource {
+                return {
+                  attributes: { customAttr: 'someValue' },
+                };
               },
             },
             envDetector,

experimental/packages/opentelemetry-sdk-node/test/util/resource-assertions.ts

@@ -362,7 +362,7 @@ const assertHasOneLabel = (prefix: string, resource: Resource): void => {
   );
 };
 
-export const assertServiceInstanceIdIsUUID = (resource: Resource): void => {
+export const assertServiceInstanceIdIsUUID = (resource: IResource): void => {
   const UUID_REGEX =
     /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
   assert.equal(