feat(opentelemetry-resources): add schema url

CHANGELOG.md

@@ -9,6 +9,10 @@ For semantic convention package changes, see the [semconv CHANGELOG](packages/se
 
 ## Unreleased
 
+### :feature-request:sparkles: (Feature)
+
+* feat(opentelemetry-resources): add schema url [#5070](https://github.com/open-telemetry/opentelemetry-js/pull/5070) @taylorhelene
+
 ### :boom: Breaking Change
 
 ### :rocket: (Enhancement)

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

@@ -827,7 +827,7 @@ describe('Node SDK', () => {
       const resource = sdk['_resource'];
       await resource.waitForAsyncAttributes?.();
 
-      assertServiceInstanceIdIsUUID(resource);
+      assertServiceInstanceIdIsUUID(resource as Resource);
       delete process.env.OTEL_NODE_RESOURCE_DETECTORS;
       await sdk.shutdown();
     });
@@ -847,7 +847,7 @@ describe('Node SDK', () => {
       const resource = sdk['_resource'];
       await resource.waitForAsyncAttributes?.();
 
-      assertServiceInstanceIdIsUUID(resource);
+      assertServiceInstanceIdIsUUID(resource as Resource);
       await sdk.shutdown();
     });
   });

experimental/packages/otlp-transformer/src/resource/internal.ts

@@ -21,5 +21,6 @@ export function createResource(resource: ISdkResource): IResource {
   return {
     attributes: toAttributes(resource.attributes),
     droppedAttributesCount: 0,
+    schemaUrl: resource.getSchemaUrl ? resource.getSchemaUrl() : '',
   };
 }

experimental/packages/otlp-transformer/src/resource/types.ts

@@ -23,4 +23,7 @@ export interface IResource {
 
   /** Resource droppedAttributesCount */
   droppedAttributesCount: number;
+
+  /** Schema URL */
+  schemaUrl?: string;
 }

experimental/packages/sdk-logs/test/common/export/SimpleLogRecordProcessor.test.ts

@@ -165,7 +165,7 @@ describe('SimpleLogRecordProcessor', () => {
       const exporter = new InMemoryLogRecordExporter();
       const { processor, logRecord } = setup(
         exporter,
-        new Resource190({ fromold: 'fromold' })
+        new Resource190({ fromold: 'fromold' }) as any
       );
       assert.strictEqual(exporter.getFinishedLogRecords().length, 0);
       processor.onEmit(logRecord);

packages/opentelemetry-resources/src/IResource.ts

@@ -51,4 +51,9 @@ export interface IResource {
    * @returns the newly merged Resource.
    */
   merge(other: IResource | null): IResource;
+
+  /**
+   * Returns the schema URL of the resource.
+   */
+  getSchemaUrl(): string; // Add this line
 }

packages/opentelemetry-resources/src/Resource.ts

@@ -25,6 +25,7 @@ import { SDK_INFO } from '@opentelemetry/core';
 import { ResourceAttributes } from './types';
 import { defaultServiceName } from './platform';
 import { IResource } from './IResource';
+import { mergeSchemaUrls } from './schemaUrlUtils'; // Import the utility function
 
 /**
  * A Resource describes the entity for which a signals (metrics or trace) are
@@ -35,7 +36,7 @@ export class Resource implements IResource {
   private _syncAttributes?: ResourceAttributes;
   private _asyncAttributesPromise?: Promise<ResourceAttributes>;
   private _attributes?: ResourceAttributes;
-
+  private _schemaUrl?: string;
   /**
    * Check if async attributes have resolved. This is useful to avoid awaiting
    * waitForAsyncAttributes (which will introduce asynchronous behavior) when not necessary.
@@ -67,13 +68,9 @@ export class Resource implements IResource {
   }
 
   constructor(
-    /**
-     * A dictionary of attributes with string keys and values that provide
-     * information about the entity as numbers, strings or booleans
-     * TODO: Consider to add check/validation on attributes.
-     */
     attributes: ResourceAttributes,
-    asyncAttributesPromise?: Promise<ResourceAttributes>
+    asyncAttributesPromise?: Promise<ResourceAttributes>,
+    schemaUrl = ''
   ) {
     this._attributes = attributes;
     this.asyncAttributesPending = asyncAttributesPromise != null;
@@ -90,6 +87,7 @@ export class Resource implements IResource {
         return {};
       }
     );
+    this._schemaUrl = schemaUrl;
   }
 
   get attributes(): ResourceAttributes {
@@ -102,6 +100,13 @@ export class Resource implements IResource {
     return this._attributes ?? {};
   }
 
+  /**
+   * Returns the schema URL of the resource.
+   */
+  public getSchemaUrl(): string {
+    return this._schemaUrl || ''; // Return schema URL as string
+  }
+
   /**
    * Returns a promise that will never be rejected. Resolves when all async attributes have finished being added to
    * this Resource's attributes. This is useful in exporters to block until resource detection
@@ -127,15 +132,21 @@ export class Resource implements IResource {
     // SpanAttributes from other resource overwrite attributes from this resource.
     const mergedSyncAttributes = {
       ...this._syncAttributes,
-      //Support for old resource implementation where _syncAttributes is not defined
+      // Support for old resource implementation where _syncAttributes is not defined
       ...((other as Resource)._syncAttributes ?? other.attributes),
     };
 
+    // Merge schema URLs using the utility function
+    const mergedSchemaUrl = mergeSchemaUrls(
+      this._schemaUrl || '',
+      other.getSchemaUrl?.() || ''
+    );
+
     if (
       !this._asyncAttributesPromise &&
       !(other as Resource)._asyncAttributesPromise
     ) {
-      return new Resource(mergedSyncAttributes);
+      return new Resource(mergedSyncAttributes, undefined, mergedSchemaUrl);
     }
 
     const mergedAttributesPromise = Promise.all([
@@ -145,12 +156,16 @@ export class Resource implements IResource {
       return {
         ...this._syncAttributes,
         ...thisAsyncAttributes,
-        //Support for old resource implementation where _syncAttributes is not defined
+        // Support for old resource implementation where _syncAttributes is not defined
         ...((other as Resource)._syncAttributes ?? other.attributes),
         ...otherAsyncAttributes,
       };
     });
 
-    return new Resource(mergedSyncAttributes, mergedAttributesPromise);
+    return new Resource(
+      mergedSyncAttributes,
+      mergedAttributesPromise,
+      mergedSchemaUrl
+    );
   }
 }

packages/opentelemetry-resources/src/schemaUrlUtils.ts

@@ -0,0 +1,36 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { diag } from '@opentelemetry/api';
+
+/**
+ * Merges two schema URLs. If both schema URLs are present and differ,
+ * a warning is logged and the first schema URL is prioritized.
+ *
+ * @param schemaUrl1 - The first schema URL
+ * @param schemaUrl2 - The second schema URL
+ * @returns The prioritized schema URL
+ */
+
+export function mergeSchemaUrls(
+  schemaUrl1: string,
+  schemaUrl2: string
+): string {
+  if (schemaUrl1 !== schemaUrl2) {
+    diag.warn('Schema URLs differ. Using the original schema URL.');
+  }
+  return schemaUrl1 || schemaUrl2;
+}

packages/opentelemetry-resources/test/Resource.test.ts

@@ -330,7 +330,7 @@ describe('Resource', () => {
       const resource = Resource.EMPTY;
       const oldResource = new Resource190({ fromold: 'fromold' });
 
-      const mergedResource = resource.merge(oldResource);
+      const mergedResource = resource.merge(oldResource as any);
 
       assert.strictEqual(mergedResource.attributes['fromold'], 'fromold');
     });
@@ -342,11 +342,73 @@ describe('Resource', () => {
       );
       const oldResource = new Resource190({ fromold: 'fromold' });
 
-      const mergedResource = resource.merge(oldResource);
+      const mergedResource = resource.merge(oldResource as any);
       assert.strictEqual(mergedResource.attributes['fromold'], 'fromold');
 
       await mergedResource.waitForAsyncAttributes?.();
       assert.strictEqual(mergedResource.attributes['fromnew'], 'fromnew');
     });
   });
+
+  it('should initialize resource with schema URL', () => {
+    const schemaUrl = 'https://example.com/schema';
+    const resource = new Resource(
+      { 'k8s.io/container/name': 'c1' },
+      undefined,
+      schemaUrl
+    );
+    assert.strictEqual(resource.getSchemaUrl(), schemaUrl);
+  });
+
+  it('should merge resources with different schema URLs', () => {
+    const schemaUrl1 = 'https://example.com/schema1';
+    const schemaUrl2 = 'https://example.com/schema2';
+    const resource1 = new Resource({ attr1: 'value1' }, undefined, schemaUrl1);
+    const resource2 = new Resource({ attr2: 'value2' }, undefined, schemaUrl2);
+
+    const warnStub = sinon.spy(diag, 'warn');
+    const mergedResource = resource1.merge(resource2);
+
+    assert.strictEqual(mergedResource.getSchemaUrl(), schemaUrl1);
+    assert.ok(
+      warnStub.calledWithMatch(
+        'Schema URLs differ. Using the original schema URL.'
+      )
+    );
+  });
+
+  it('should retain the same schema URL when merging resources with identical URLs', () => {
+    const schemaUrl = 'https://example.com/schema';
+    const resource1 = new Resource({ attr1: 'value1' }, undefined, schemaUrl);
+    const resource2 = new Resource({ attr2: 'value2' }, undefined, schemaUrl);
+
+    const mergedResource = resource1.merge(resource2);
+
+    assert.strictEqual(mergedResource.getSchemaUrl(), schemaUrl);
+  });
+
+  it('should retain schema URL from the resource that has it when merging', () => {
+    const resource1 = new Resource({ attr1: 'value1' }, undefined, '');
+    const resource2 = new Resource(
+      { attr2: 'value2' },
+      undefined,
+      'https://example.com/schema'
+    );
+
+    const mergedResource = resource1.merge(resource2);
+
+    assert.strictEqual(
+      mergedResource.getSchemaUrl(),
+      'https://example.com/schema'
+    );
+  });
+
+  it('should have empty schema URL when merging resources with no schema URL', () => {
+    const resource1 = new Resource({ attr1: 'value1' }, undefined, '');
+    const resource2 = new Resource({ attr2: 'value2' }, undefined, '');
+
+    const mergedResource = resource1.merge(resource2);
+
+    assert.strictEqual(mergedResource.getSchemaUrl(), '');
+  });
 });

packages/opentelemetry-resources/test/regression/existing-detectors-1-9-1.test.ts

@@ -20,7 +20,7 @@ import * as assert from 'assert';
 // If compilation fails at this point then the changes made are breaking.
 class RegressionTestResourceDetector_1_9_1 implements Detector {
   async detect(_config?: ResourceDetectionConfig): Promise<Resource> {
-    return Resource.empty();
+    return Resource.empty() as any;
   }
 }