Add more merge helper methods and tests

Author: jsuereth

sdk/common/src/main/java/io/opentelemetry/sdk/resources/internal/Entity.java

@@ -32,21 +32,21 @@ public interface Entity {
    *
    * @return the entity type.
    */
-  public abstract String getType();
+  String getType();
 
   /**
    * Returns a map of attributes that identify the entity.
    *
    * @return a map of attributes.
    */
-  public abstract Attributes getId();
+  Attributes getId();
 
   /**
    * Returns a map of attributes that describe the entity.
    *
    * @return a map of attributes.
    */
-  public abstract Attributes getDescription();
+  Attributes getDescription();
 
   /**
    * Returns the URL of the OpenTelemetry schema used by this resource. May be null if this entity
@@ -56,7 +56,7 @@ public interface Entity {
    * @since 1.4.0
    */
   @Nullable
-  public abstract String getSchemaUrl();
+  String getSchemaUrl();
 
   /**
    * Returns a new {@link EntityBuilder} instance populated with the data of this {@link Entity}.

sdk/common/src/main/java/io/opentelemetry/sdk/resources/internal/EntityUtil.java

@@ -5,10 +5,17 @@
 
 package io.opentelemetry.sdk.resources.internal;
 
+import io.opentelemetry.api.common.AttributeKey;
+import io.opentelemetry.api.common.Attributes;
+import io.opentelemetry.api.common.AttributesBuilder;
+import java.util.ArrayList;
 import java.util.Collection;
 import java.util.HashMap;
 import java.util.Map;
+import java.util.Set;
 import java.util.logging.Logger;
+import java.util.stream.Collectors;
+import javax.annotation.Nullable;
 
 /**
  * Helper class for dealing with Entities.
@@ -21,6 +28,88 @@ public final class EntityUtil {
 
   private EntityUtil() {}
 
+  /** Returns true if any entity in the collection has the attribute key, in id or description. */
+  static final <T> boolean hasAttributeKey(Collection<Entity> entities, AttributeKey<T> key) {
+    return entities.stream()
+        .anyMatch(
+            e -> e.getId().asMap().containsKey(key) || e.getDescription().asMap().containsKey(key));
+  }
+
+  /** Decides on a final SchemaURL for OTLP Resource based on entities chosen. */
+  @Nullable
+  static final String mergeResourceSchemaUrl(
+      Collection<Entity> entities, @Nullable String baseUrl, @Nullable String nextUrl) {
+    // Check if entities all share the same URL.
+    Set<String> entitySchemas =
+        entities.stream().map(Entity::getSchemaUrl).collect(Collectors.toSet());
+    // If we have no entities, we preserve previous schema url behavior.
+    String result = baseUrl;
+    if (entitySchemas.size() == 1) {
+      // Updated Entities use same schema, we can preserve it.
+      result = entitySchemas.iterator().next();
+    } else if (entitySchemas.size() > 1) {
+      // Entities use different schemas, resource must treat this as no schema_url.
+      result = null;
+    }
+
+    // If schema url of merging resource is null, we use our current result.
+    if (nextUrl == null) {
+      return result;
+    }
+    // When there are no entities, we use old schema url merge behavior
+    if (result == null && entities.isEmpty()) {
+      return nextUrl;
+    }
+    if (!nextUrl.equals(result)) {
+      logger.info(
+          "Attempting to merge Resources with different schemaUrls. "
+              + "The resulting Resource will have no schemaUrl assigned. Schema 1: "
+              + baseUrl
+              + " Schema 2: "
+              + nextUrl);
+      return null;
+    }
+    return result;
+  }
+
+  /**
+   * Merges "loose" attributes on resource, removing those which conflict with the set of entities.
+   *
+   * @param base loose attributes from base resource
+   * @param additional additional attributes to add to the resource.
+   * @param entities the set of entites on the resource.
+   * @return the new set of raw attributes for Resource and the set of conflicting entities that
+   *     MUST NOT be reported on OTLP resource.
+   */
+  @SuppressWarnings("unchecked")
+  static final RawAttributeMergeResult mergeRawAttributes(
+      Attributes base, Attributes additional, Collection<Entity> entities) {
+    AttributesBuilder result = base.toBuilder();
+    // We know attribute conflicts were handled perviously on the resource, so
+    // This needs to account for entity merge of new entities, and remove raw
+    // attributes that would have been removed with new entities.
+    result.removeIf(key -> hasAttributeKey(entities, key));
+    // For every "raw" attribute on the other resource, we merge into the
+    // resource, but check for entity conflicts from previous entities.
+    ArrayList<Entity> conflicts = new ArrayList<>();
+    if (!additional.isEmpty()) {
+      additional.forEach(
+          (key, value) -> {
+            for (Entity e : entities) {
+              if (e.getId().asMap().keySet().contains(key)
+                  || e.getDescription().asMap().keySet().contains(key)) {
+                // Remove the entity and push all attributes as raw,
+                // we have an override.
+                conflicts.add(e);
+                result.putAll(e.getId()).putAll(e.getDescription());
+              }
+            }
+            result.put((AttributeKey<Object>) key, value);
+          });
+    }
+    return RawAttributeMergeResult.create(result.build(), conflicts);
+  }
+
   /**
    * Merges entities according to specification rules.
    *

sdk/common/src/main/java/io/opentelemetry/sdk/resources/internal/RawAttributeMergeResult.java

@@ -0,0 +1,32 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package io.opentelemetry.sdk.resources.internal;
+
+import com.google.auto.value.AutoValue;
+import io.opentelemetry.api.common.Attributes;
+import java.util.Collection;
+import javax.annotation.concurrent.Immutable;
+
+/**
+ * This class is internal and is hence not for public use. Its APIs are unstable and can change at
+ * any time.
+ */
+@Immutable
+@AutoValue
+abstract class RawAttributeMergeResult {
+  /** Merged raw attributes. */
+  abstract Attributes getAttributes();
+
+  /**
+   * Entities in conflict that should be removed from resource to avoid reporting invalid attribute
+   * sets in OTLP resource.
+   */
+  abstract Collection<Entity> getConflicts();
+
+  static final RawAttributeMergeResult create(Attributes attributes, Collection<Entity> conflicts) {
+    return new AutoValue_RawAttributeMergeResult(attributes, conflicts);
+  }
+}

sdk/common/src/main/java/io/opentelemetry/sdk/resources/internal/ResourceWithEntity.java

@@ -0,0 +1,62 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package io.opentelemetry.sdk.resources.internal;
+
+import io.opentelemetry.api.common.Attributes;
+import io.opentelemetry.sdk.resources.ResourceBuilder;
+import java.util.Collection;
+import javax.annotation.Nullable;
+import javax.annotation.concurrent.Immutable;
+
+/**
+ * {@link Resource} represents a resource, which capture identifying information about the entities
+ * for which signals (stats or traces) are reported.
+ *
+ * <p>This class is internal and is hence not for public use. Its APIs are unstable and can change
+ * at any time.
+ */
+@Immutable
+public interface ResourceWithEntity {
+  /**
+   * Returns the URL of the OpenTelemetry schema used by this resource. May be null.
+   *
+   * @return An OpenTelemetry schema URL.
+   * @since 1.4.0
+   */
+  @Nullable
+  String getSchemaUrl();
+
+  /**
+   * Returns a map of attributes that describe the resource, not associated with an entity.
+   *
+   * @return a map of attributes.
+   */
+  Attributes getRawAttributes();
+
+  /**
+   * Returns a collectoion of associated entities.
+   *
+   * @return a collection of entities.
+   */
+  Collection<Entity> getEntities();
+
+  /**
+   * Returns a map of attributes that describe the resource.
+   *
+   * <p>Note: this includes all entity attribtues and raw attributes.
+   *
+   * @return a map of attributes.
+   */
+  Attributes getAttributes();
+
+  /**
+   * Returns a new {@link ResourceBuilder} instance populated with the data of this {@link
+   * Resource}.
+   */
+  ResourceWithEntityBuilder toBuilder();
+
+  // TODO - Merge
+}

sdk/common/src/main/java/io/opentelemetry/sdk/resources/internal/ResourceWithEntityBuilder.java

@@ -0,0 +1,28 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package io.opentelemetry.sdk.resources.internal;
+
+import io.opentelemetry.api.common.Attributes;
+import java.util.Collection;
+
+/**
+ * A builder of {@link ResourceWithEntity} that allows to add key-value pairs and copy attributes
+ * from other {@link Attributes} or {@link ResourceWithEntity}.
+ *
+ * <p>This class is internal and is hence not for public use. Its APIs are unstable and can change
+ * at any time.
+ */
+public interface ResourceWithEntityBuilder {
+  // TODO - Raw Attributes.
+  /** Appends a new entity on to the end of the list of entities. */
+  ResourceWithEntityBuilder add(Entity e);
+
+  /** Appends a new collection of entities on to the end of the list of entities. */
+  ResourceWithEntityBuilder addAll(Collection<Entity> entities);
+
+  /** Create the {@link ResourceWithEntity} from this. */
+  ResourceWithEntity build();
+}

sdk/common/src/test/java/io/opentelemetry/sdk/resources/internal/EntityUtilTest.java

@@ -10,6 +10,7 @@
 
 import java.util.Arrays;
 import java.util.Collection;
+import java.util.Collections;
 import org.junit.jupiter.api.Test;
 
 /** Unit tests for {@link EntityUtil} */
@@ -160,4 +161,55 @@ void testMerge_entities_separate_types_and_schema() {
         .satisfiesExactlyInAnyOrder(
             a -> assertThat(a).hasType("a"), b -> assertThat(b).hasType("b"));
   }
+
+  @Test
+  void testSchemaUrlMerge_no_entities_differentUrls() {
+    // If the we find conflicting schema URLs in resource we must drop schema url (set to null).
+    String result = EntityUtil.mergeResourceSchemaUrl(Collections.emptyList(), "one", "two");
+    assertThat(result).isNull();
+  }
+
+  @Test
+  void testSchemaUrlMerge_no_entities_base_null() {
+    // If the our resource had no schema url it abides by, we use the incoming schema url.
+    String result = EntityUtil.mergeResourceSchemaUrl(Collections.emptyList(), null, "two");
+    assertThat(result).isEqualTo("two");
+  }
+
+  @Test
+  void testSchemaUrlMerge_no_entities_next_null() {
+    // If the new resource had no schema url it abides by, we preserve ours.
+    // NOTE: this is by specification, but seems problematic if conflicts in merge
+    // cause violation of SchemaURL.
+    String result = EntityUtil.mergeResourceSchemaUrl(Collections.emptyList(), "one", null);
+    assertThat(result).isEqualTo("one");
+  }
+
+  @Test
+  void testSchemaUrlMerge_entities_same_url() {
+    // If the new resource had no schema url it abides by, we preserve ours.
+    // NOTE: this is by specification, but seems problematic if conflicts in merge
+    // cause violation of SchemaURL.
+    String result =
+        EntityUtil.mergeResourceSchemaUrl(
+            Arrays.asList(
+                Entity.builder("t").setSchemaUrl("one").withId(id -> id.put("id", 1)).build()),
+            "one",
+            null);
+    assertThat(result).isEqualTo("one");
+  }
+
+  @Test
+  void testSchemaUrlMerge_entities_different_url() {
+    // When entities have conflciting schema urls, we cannot fill out resource schema url,
+    // no matter what.
+    String result =
+        EntityUtil.mergeResourceSchemaUrl(
+            Arrays.asList(
+                Entity.builder("t").setSchemaUrl("one").withId(id -> id.put("id", 1)).build(),
+                Entity.builder("t2").setSchemaUrl("two").withId(id -> id.put("id2", 1)).build()),
+            "one",
+            "one");
+    assertThat(result).isEqualTo(null);
+  }
 }