add attribute projections

.gitignore

@@ -16,11 +16,7 @@ test-output
 *.patch
 *.log.gz
 *.code-workspace
-.idea/*.xml
-.idea/libraries/
-.idea/dictionaries/
-.idea/codeStyles/
-.idea/.name
+.idea
 # Local config to handle using Java 8 vs java 11.
 .java-version
 *.tgz

attribute-projection-functions/build.gradle.kts

@@ -0,0 +1,17 @@
+plugins {
+  `java-library`
+  jacoco
+  id("org.hypertrace.jacoco-report-plugin")
+  id("org.hypertrace.publish-plugin")
+}
+
+dependencies {
+  api("com.google.code.findbugs:jsr305:3.0.2")
+  implementation("com.github.f4b6a3:uuid-creator:2.7.7")
+
+  testImplementation("org.junit.jupiter:junit-jupiter:5.6.2")
+}
+
+tasks.test {
+  useJUnitPlatform()
+}

attribute-projection-functions/src/main/java/org/hypertrace/core/attribute/service/projection/functions/Concatenate.java

@@ -0,0 +1,18 @@
+package org.hypertrace.core.attribute.service.projection.functions;
+
+import static java.util.Objects.isNull;
+import static java.util.Objects.requireNonNullElse;
+
+import javax.annotation.Nullable;
+
+public class Concatenate {
+  private static final String DEFAULT_STRING = "";
+
+  @Nullable
+  public static String concatenate(@Nullable String first, @Nullable String second) {
+    if (isNull(first) && isNull(second)) {
+      return null;
+    }
+    return requireNonNullElse(first, DEFAULT_STRING) + requireNonNullElse(second, DEFAULT_STRING);
+  }
+}

attribute-projection-functions/src/main/java/org/hypertrace/core/attribute/service/projection/functions/DefaultValue.java

@@ -0,0 +1,13 @@
+package org.hypertrace.core.attribute.service.projection.functions;
+
+import static java.util.Objects.nonNull;
+
+import javax.annotation.Nullable;
+
+public class DefaultValue {
+
+  @Nullable
+  public static String defaultString(@Nullable String value, @Nullable String defaultValue) {
+    return nonNull(value) && !value.isEmpty() ? value : defaultValue;
+  }
+}

attribute-projection-functions/src/main/java/org/hypertrace/core/attribute/service/projection/functions/Hash.java

@@ -0,0 +1,25 @@
+package org.hypertrace.core.attribute.service.projection.functions;
+
+import static java.util.Objects.nonNull;
+
+import com.github.f4b6a3.uuid.UuidCreator;
+import com.github.f4b6a3.uuid.creator.rfc4122.NameBasedSha1UuidCreator;
+import java.util.UUID;
+import javax.annotation.Nullable;
+
+public class Hash {
+
+  /**
+   * Unique, randomly generated namespace that should never be used directly. Changing this value
+   * would change any existing projections containing a hash and orphan any data persisted against
+   * that such as stored entities.
+   */
+  private static final NameBasedSha1UuidCreator HASHER =
+      UuidCreator.getNameBasedSha1Creator()
+          .withNamespace(UUID.fromString("5088c92d-5e9c-43f4-a35b-2589474d5642"));
+
+  @Nullable
+  public static String hash(@Nullable String value) {
+    return nonNull(value) ? HASHER.create(value).toString() : null;
+  }
+}

attribute-projection-functions/src/test/java/org/hypertrace/core/attribute/service/projection/functions/ConcatenateTest.java

@@ -0,0 +1,23 @@
+package org.hypertrace.core.attribute.service.projection.functions;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNull;
+
+import org.junit.jupiter.api.Test;
+
+class ConcatenateTest {
+
+  @Test
+  void concatenatesNormalStrings() {
+    assertEquals("foobar", Concatenate.concatenate("foo", "bar"));
+    assertEquals("foo", Concatenate.concatenate("foo", ""));
+    assertEquals("bar", Concatenate.concatenate("", "bar"));
+  }
+
+  @Test
+  void concatenatesNullStrings() {
+    assertEquals("foo", Concatenate.concatenate("foo", null));
+    assertEquals("bar", Concatenate.concatenate(null, "bar"));
+    assertNull(Concatenate.concatenate(null, null));
+  }
+}

attribute-projection-functions/src/test/java/org/hypertrace/core/attribute/service/projection/functions/DefaultValueTest.java

@@ -0,0 +1,21 @@
+package org.hypertrace.core.attribute.service.projection.functions;
+
+import static org.hypertrace.core.attribute.service.projection.functions.DefaultValue.defaultString;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNull;
+
+import org.junit.jupiter.api.Test;
+
+public class DefaultValueTest {
+  @Test
+  void givesDefaultIfStringValueNullOrEmpty() {
+    assertEquals("default", defaultString(null, "default"));
+    assertEquals("default", defaultString("", "default"));
+    assertEquals("foo", defaultString("foo", "default"));
+  }
+
+  @Test
+  void returnsNullIfNullDefaultGiven() {
+    assertNull(defaultString(null, null));
+  }
+}

attribute-projection-functions/src/test/java/org/hypertrace/core/attribute/service/projection/functions/HashTest.java

@@ -0,0 +1,21 @@
+package org.hypertrace.core.attribute.service.projection.functions;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotEquals;
+import static org.junit.jupiter.api.Assertions.assertNull;
+
+import org.junit.jupiter.api.Test;
+
+class HashTest {
+
+  @Test
+  void createsMatchingHashesForMatchingInputs() {
+    assertEquals(Hash.hash("foo"), Hash.hash("foo"));
+    assertNotEquals(Hash.hash("foo"), Hash.hash("bar"));
+  }
+
+  @Test
+  void hashesNullToNull() {
+    assertNull(Hash.hash(null));
+  }
+}

attribute-projection-registry/build.gradle.kts

@@ -0,0 +1,17 @@
+plugins {
+  `java-library`
+  jacoco
+  id("org.hypertrace.jacoco-report-plugin")
+  id("org.hypertrace.publish-plugin")
+}
+
+dependencies {
+  api(project(":attribute-service-api"))
+  implementation(project(":attribute-projection-functions"))
+  implementation("com.google.guava:guava:29.0-jre")
+  testImplementation("org.junit.jupiter:junit-jupiter:5.6.2")
+}
+
+tasks.test {
+  useJUnitPlatform()
+}

attribute-projection-registry/src/main/java/org/hypertrace/core/attribute/service/projection/AbstractAttributeProjection.java

@@ -0,0 +1,50 @@
+package org.hypertrace.core.attribute.service.projection;
+
+import com.google.common.base.Preconditions;
+import java.util.ArrayList;
+import java.util.List;
+import org.hypertrace.core.attribute.service.v1.AttributeKind;
+import org.hypertrace.core.attribute.service.v1.LiteralValue;
+
+abstract class AbstractAttributeProjection<R> implements AttributeProjection {
+
+  private final AttributeKind resultKind;
+  private final List<AttributeKind> argumentKinds;
+
+  protected AbstractAttributeProjection(
+      AttributeKind resultKind, List<AttributeKind> argumentKinds) {
+    this.resultKind = resultKind;
+    this.argumentKinds = argumentKinds;
+  }
+
+  @Override
+  public LiteralValue project(List<LiteralValue> arguments) {
+    Preconditions.checkArgument(arguments.size() == argumentKinds.size());
+    List<Object> unwrappedArguments = new ArrayList<>(argumentKinds.size());
+    for (int index = 0; index < arguments.size(); index++) {
+      int argumentIndex = index;
+      LiteralValue argumentLiteral = arguments.get(argumentIndex);
+      AttributeKind attributeKind = this.argumentKinds.get(argumentIndex);
+      Object unwrappedArgument =
+          ValueCoercer.fromLiteral(argumentLiteral, attributeKind)
+              .orElseThrow(
+                  () ->
+                      new IllegalArgumentException(
+                          String.format(
+                              "Projection argument %s at index %d could not be converted to expected type %s",
+                              argumentLiteral, argumentIndex, attributeKind)));
+
+      unwrappedArguments.add(argumentIndex, unwrappedArgument);
+    }
+    Object unwrappedResult = this.doUnwrappedProjection(unwrappedArguments);
+    return ValueCoercer.toLiteral(unwrappedResult, this.resultKind)
+        .orElseThrow(
+            () ->
+                new UnsupportedOperationException(
+                    String.format(
+                        "Projection result %s could not be converted to expected type %s",
+                        unwrappedResult, this.resultKind)));
+  }
+
+  protected abstract R doUnwrappedProjection(List<Object> arguments);
+}

attribute-projection-registry/src/main/java/org/hypertrace/core/attribute/service/projection/AttributeProjection.java

@@ -0,0 +1,17 @@
+package org.hypertrace.core.attribute.service.projection;
+
+import java.util.List;
+import org.hypertrace.core.attribute.service.v1.LiteralValue;
+
+public interface AttributeProjection {
+  /**
+   * Performs the projection operation with the provided arguments.
+   *
+   * @param arguments to the projection
+   * @return the result of the projection
+   * @throws IllegalArgumentException if the provided arguments do not match the expected arity of
+   *     the projection, can not be converted to the expected input types or produce a result that
+   *     can't be converted to the expected output type.
+   */
+  LiteralValue project(List<LiteralValue> arguments);
+}

attribute-projection-registry/src/main/java/org/hypertrace/core/attribute/service/projection/AttributeProjectionRegistry.java

@@ -0,0 +1,30 @@
+package org.hypertrace.core.attribute.service.projection;
+
+import static org.hypertrace.core.attribute.service.v1.ProjectionOperator.PROJECTION_OPERATOR_CONCAT;
+import static org.hypertrace.core.attribute.service.v1.ProjectionOperator.PROJECTION_OPERATOR_HASH;
+
+import java.util.Map;
+import java.util.Optional;
+import org.hypertrace.core.attribute.service.projection.functions.Concatenate;
+import org.hypertrace.core.attribute.service.projection.functions.Hash;
+import org.hypertrace.core.attribute.service.v1.AttributeKind;
+import org.hypertrace.core.attribute.service.v1.ProjectionOperator;
+
+public class AttributeProjectionRegistry {
+
+  private static final Map<ProjectionOperator, AttributeProjection> PROJECTION_MAP =
+      Map.of(
+          PROJECTION_OPERATOR_CONCAT,
+          new BinaryAttributeProjection<>(
+              AttributeKind.TYPE_STRING,
+              AttributeKind.TYPE_STRING,
+              AttributeKind.TYPE_STRING,
+              Concatenate::concatenate),
+          PROJECTION_OPERATOR_HASH,
+          new UnaryAttributeProjection<>(
+              AttributeKind.TYPE_STRING, AttributeKind.TYPE_STRING, Hash::hash));
+
+  public Optional<AttributeProjection> getProjection(ProjectionOperator projectionOperator) {
+    return Optional.ofNullable(PROJECTION_MAP.get(projectionOperator));
+  }
+}

attribute-projection-registry/src/main/java/org/hypertrace/core/attribute/service/projection/BinaryAttributeProjection.java

@@ -0,0 +1,24 @@
+package org.hypertrace.core.attribute.service.projection;
+
+import java.util.List;
+import java.util.function.BiFunction;
+import org.hypertrace.core.attribute.service.v1.AttributeKind;
+
+class BinaryAttributeProjection<T, U, R> extends AbstractAttributeProjection<R> {
+  private final BiFunction<T, U, R> projectionImplementation;
+
+  BinaryAttributeProjection(
+      AttributeKind resultKind,
+      AttributeKind firstArgumentKind,
+      AttributeKind secondArgumentKind,
+      BiFunction<T, U, R> projectionImplementation) {
+    super(resultKind, List.of(firstArgumentKind, secondArgumentKind));
+    this.projectionImplementation = projectionImplementation;
+  }
+
+  @Override
+  @SuppressWarnings("unchecked")
+  protected R doUnwrappedProjection(List<Object> arguments) {
+    return this.projectionImplementation.apply((T) arguments.get(0), (U) arguments.get(1));
+  }
+}

attribute-projection-registry/src/main/java/org/hypertrace/core/attribute/service/projection/UnaryAttributeProjection.java

@@ -0,0 +1,23 @@
+package org.hypertrace.core.attribute.service.projection;
+
+import java.util.List;
+import java.util.function.Function;
+import org.hypertrace.core.attribute.service.v1.AttributeKind;
+
+class UnaryAttributeProjection<T, R> extends AbstractAttributeProjection<R> {
+  private final Function<T, R> projectionImplementation;
+
+  UnaryAttributeProjection(
+      AttributeKind resultKind,
+      AttributeKind argumentKind,
+      Function<T, R> projectionImplementation) {
+    super(resultKind, List.of(argumentKind));
+    this.projectionImplementation = projectionImplementation;
+  }
+
+  @Override
+  @SuppressWarnings("unchecked")
+  protected R doUnwrappedProjection(List<Object> arguments) {
+    return this.projectionImplementation.apply((T) arguments.get(0));
+  }
+}