Attribute expressions (#128)

* refactor: add support for attribute expressions

* chore: temp for testing

* chore: update new label code for attribute expressions

* chore: update submodule

* fix: remove debug logging

* style: spotless

* chore: rename attribute expression association

Author: aaron-steinfeld

.snyk

@@ -5,6 +5,6 @@ ignore:
   SNYK-JAVA-IONETTY-1042268:
     - '*':
         reason: No replacement available
-        expires: 2021-12-31T00:00:00.000Z
+        expires: 2022-03-31T00:00:00.000Z
 patch: {}
 

hypertrace-core-graphql

@@ -11,6 +11,7 @@
 import java.util.Set;
 import org.hypertrace.core.graphql.common.request.AttributeAssociation;
 import org.hypertrace.core.graphql.common.request.AttributeRequest;
+import org.hypertrace.core.graphql.common.schema.attributes.arguments.AttributeExpression;
 import org.hypertrace.core.graphql.common.schema.results.arguments.filter.FilterArgument;
 import org.hypertrace.core.graphql.common.utils.BiConverter;
 import org.hypertrace.core.graphql.common.utils.Converter;
@@ -81,19 +82,21 @@ protected void configure() {
                     Collection<MetricRequest>,
                     Entity,
                     BaselineEntity,
-                    Map<String, MetricContainer>>>() {}));
+                    Map<AttributeExpression, MetricContainer>>>() {}));
 
     requireBinding(
         Key.get(
             new TypeLiteral<
                 BiConverter<
-                    Collection<AttributeRequest>, Map<String, Value>, Map<String, Object>>>() {}));
+                    Collection<AttributeRequest>,
+                    Map<String, Value>,
+                    Map<AttributeExpression, Object>>>() {}));
     requireBinding(
         Key.get(
             new TypeLiteral<
                 BiConverter<
                     Collection<MetricAggregationRequest>,
                     Map<String, AggregatedMetricValue>,
-                    Map<String, BaselinedMetricAggregationContainer>>>() {}));
+                    Map<AttributeExpression, BaselinedMetricAggregationContainer>>>() {}));
   }
 }

hypertrace-graphql-entity-schema/src/main/java/org/hypertrace/graphql/entity/dao/EntityDaoModule.java

@@ -73,7 +73,7 @@ private Single<ImmutableSetMultimap<String, InteractionResponse>> mapInteraction
   private Single<Entry<String, InteractionResponse>> buildInteractionEntry(
       AttributeRequest neighborIdAttribute, InteractionResponse response) {
     return this.valueConverter
-        .convert(response.getInteraction().getAttributeMap().get(neighborIdAttribute.alias()))
+        .convert(response.getInteraction().getAttributeMap().get(neighborIdAttribute.asMapKey()))
         .map(String::valueOf)
         .map(id -> Map.entry(id, response));
   }

hypertrace-graphql-entity-schema/src/main/java/org/hypertrace/graphql/entity/dao/EntityNeighborMapFetcher.java

@@ -9,11 +9,13 @@
 import java.util.List;
 import java.util.Map;
 import java.util.Optional;
+import java.util.function.Function;
 import java.util.stream.Collectors;
 import javax.annotation.Nullable;
 import javax.inject.Inject;
 import lombok.experimental.Accessors;
 import org.hypertrace.core.graphql.common.request.AttributeRequest;
+import org.hypertrace.core.graphql.common.schema.attributes.arguments.AttributeExpression;
 import org.hypertrace.core.graphql.common.utils.BiConverter;
 import org.hypertrace.core.graphql.common.utils.TriConverter;
 import org.hypertrace.gateway.service.v1.baseline.BaselineEntitiesResponse;
@@ -31,26 +33,28 @@
 import org.hypertrace.graphql.metric.schema.MetricContainer;
 
 class GatewayServiceEntityConverter {
-  private final BiConverter<Collection<AttributeRequest>, Map<String, Value>, Map<String, Object>>
+  private final BiConverter<
+          Collection<AttributeRequest>, Map<String, Value>, Map<AttributeExpression, Object>>
       attributeMapConverter;
 
   private final TriConverter<
           Collection<MetricRequest>,
           org.hypertrace.gateway.service.v1.entity.Entity,
           BaselineEntity,
-          Map<String, MetricContainer>>
+          Map<AttributeExpression, MetricContainer>>
       metricContainerConverter;
   private final GatewayServiceEntityEdgeLookupConverter edgeLookupConverter;
 
   @Inject
   GatewayServiceEntityConverter(
-      BiConverter<Collection<AttributeRequest>, Map<String, Value>, Map<String, Object>>
+      BiConverter<
+              Collection<AttributeRequest>, Map<String, Value>, Map<AttributeExpression, Object>>
           attributeMapConverter,
       TriConverter<
               Collection<MetricRequest>,
               org.hypertrace.gateway.service.v1.entity.Entity,
               BaselineEntity,
-              Map<String, MetricContainer>>
+              Map<AttributeExpression, MetricContainer>>
           metricContainerConverter,
       GatewayServiceEntityEdgeLookupConverter edgeLookupConverter) {
     this.attributeMapConverter = attributeMapConverter;
@@ -103,7 +107,7 @@ private BaselineEntity getBaselineEntity(
   private Map<String, BaselineEntity> getBaselineEntityMap(
       BaselineEntitiesResponse baselineResponse) {
     return baselineResponse.getBaselineEntityList().stream()
-        .collect(Collectors.toMap(BaselineEntity::getId, entity -> entity));
+        .collect(Collectors.toMap(BaselineEntity::getId, Function.identity()));
   }
 
   private Single<Entity> convertEntity(
@@ -121,7 +125,12 @@ private Single<Entity> convertEntity(
         (attrMap, containerMap) ->
             new ConvertedEntity(
                 attrMap
-                    .get(entityRequest.resultSetRequest().idAttribute().attribute().key())
+                    .get(
+                        entityRequest
+                            .resultSetRequest()
+                            .idAttribute()
+                            .attributeExpressionAssociation()
+                            .value())
                     .toString(),
                 entityRequest.entityType(),
                 attrMap,
@@ -136,20 +145,19 @@ private Single<Entity> convertEntity(
   private static class ConvertedEntity implements Entity {
     String id;
     String type;
-    Map<String, Object> attributeValues;
-    Map<String, MetricContainer> metricContainers;
+    Map<AttributeExpression, Object> attributeValues;
+    Map<AttributeExpression, MetricContainer> metricContainers;
     Map<String, EdgeResultSet> incomingEdges;
     Map<String, EdgeResultSet> outgoingEdges;
     LabelResultSet labels;
 
-    @Override
-    public Object attribute(String key) {
-      return this.attributeValues.get(key);
+    public Object attribute(AttributeExpression attributeExpression) {
+      return this.attributeValues.get(attributeExpression);
     }
 
     @Override
-    public MetricContainer metric(String key) {
-      return this.metricContainers.get(key);
+    public MetricContainer metric(AttributeExpression attributeExpression) {
+      return this.metricContainers.get(attributeExpression);
     }
 
     @Override

hypertrace-graphql-entity-schema/src/main/java/org/hypertrace/graphql/entity/dao/GatewayServiceEntityConverter.java

@@ -11,6 +11,7 @@
 import javax.inject.Inject;
 import javax.inject.Singleton;
 import lombok.extern.slf4j.Slf4j;
+import org.hypertrace.core.graphql.common.request.AttributeRequest;
 import org.hypertrace.core.graphql.context.GraphQlRequestContext;
 import org.hypertrace.core.graphql.rx.BoundedIoScheduler;
 import org.hypertrace.core.graphql.spi.config.GraphQlServiceConfig;
@@ -23,6 +24,7 @@
 import org.hypertrace.gateway.service.v1.entity.EntitiesResponse;
 import org.hypertrace.gateway.service.v1.entity.Entity;
 import org.hypertrace.graphql.entity.health.BaselineDao;
+import org.hypertrace.graphql.entity.request.EntityLabelRequest;
 import org.hypertrace.graphql.entity.request.EntityRequest;
 import org.hypertrace.graphql.entity.schema.EntityResultSet;
 import org.hypertrace.graphql.label.joiner.LabelJoiner;
@@ -117,21 +119,22 @@ private Single<Map<Entity, LabelResultSet>> buildLabelResultSetMap(
         .flatMap(
             joiner ->
                 joiner.joinLabels(
-                    entitiesResponse.getEntityList(), getEntityLabelsGetter(request)));
-  }
-
-  private LabelJoiner.LabelIdGetter<Entity> getEntityLabelsGetter(EntityRequest request) {
-    return entity -> Single.just(getLabelAttributeValue(request, entity));
+                    entitiesResponse.getEntityList(),
+                    entity -> Single.just(getLabelAttributeValue(request, entity))));
   }
 
   private List<String> getLabelAttributeValue(EntityRequest request, Entity entity) {
-    Value labelAttributeValue =
-        entity.getAttributeOrDefault(
-            request.labelRequest().get().labelIdArrayAttributeRequest().attribute().id(), null);
-    if (labelAttributeValue == null) {
-      log.warn("Unable to fetch labels attribute for entity with id {}", entity.getId());
-      return Collections.emptyList();
-    }
-    return labelAttributeValue.getStringArrayList();
+    return request
+        .labelRequest()
+        .map(EntityLabelRequest::labelIdArrayAttributeRequest)
+        .map(AttributeRequest::asMapKey)
+        .filter(entity::containsAttribute)
+        .map(entity::getAttributeOrThrow)
+        .<List<String>>map(Value::getStringArrayList)
+        .orElseGet(
+            () -> {
+              log.warn("Unable to fetch labels attribute for entity with id {}", entity.getId());
+              return Collections.emptyList();
+            });
   }
 }

hypertrace-graphql-entity-schema/src/main/java/org/hypertrace/graphql/entity/dao/GatewayServiceEntityDao.java

@@ -14,6 +14,7 @@
 import javax.inject.Inject;
 import lombok.experimental.Accessors;
 import org.hypertrace.core.graphql.common.request.AttributeRequest;
+import org.hypertrace.core.graphql.common.schema.attributes.arguments.AttributeExpression;
 import org.hypertrace.core.graphql.common.utils.BiConverter;
 import org.hypertrace.core.graphql.common.utils.CollectorUtils;
 import org.hypertrace.gateway.service.v1.common.AggregatedMetricValue;
@@ -34,23 +35,25 @@ class GatewayServiceEntityEdgeFetcher {
 
   private final EntityNeighborMapFetcher neighborMapFetcher;
 
-  private final BiConverter<Collection<AttributeRequest>, Map<String, Value>, Map<String, Object>>
+  private final BiConverter<
+          Collection<AttributeRequest>, Map<String, Value>, Map<AttributeExpression, Object>>
       attributeMapConverter;
   private final BiConverter<
           Collection<MetricAggregationRequest>,
           Map<String, AggregatedMetricValue>,
-          Map<String, BaselinedMetricAggregationContainer>>
+          Map<AttributeExpression, BaselinedMetricAggregationContainer>>
       baselineMetricAggregationContainerMapConverter;
 
   @Inject
   GatewayServiceEntityEdgeFetcher(
       EntityNeighborMapFetcher neighborMapFetcher,
-      BiConverter<Collection<AttributeRequest>, Map<String, Value>, Map<String, Object>>
+      BiConverter<
+              Collection<AttributeRequest>, Map<String, Value>, Map<AttributeExpression, Object>>
           attributeMapConverter,
       BiConverter<
               Collection<MetricAggregationRequest>,
               Map<String, AggregatedMetricValue>,
-              Map<String, BaselinedMetricAggregationContainer>>
+              Map<AttributeExpression, BaselinedMetricAggregationContainer>>
           baselineMetricAggregationContainerMapConverter) {
     this.neighborMapFetcher = neighborMapFetcher;
     this.attributeMapConverter = attributeMapConverter;
@@ -127,17 +130,17 @@ private Maybe<Edge> buildEdge(
   @Accessors(fluent = true)
   private static class ConvertedEdge implements Edge {
     Entity neighbor;
-    Map<String, Object> attributeValues;
-    Map<String, BaselinedMetricAggregationContainer> metricContainers;
+    Map<AttributeExpression, Object> attributeValues;
+    Map<AttributeExpression, BaselinedMetricAggregationContainer> metricContainers;
 
     @Override
-    public Object attribute(String key) {
-      return this.attributeValues.get(key);
+    public Object attribute(AttributeExpression attributeExpression) {
+      return this.attributeValues.get(attributeExpression);
     }
 
     @Override
-    public BaselinedMetricAggregationContainer metric(String key) {
-      return this.metricContainers.get(key);
+    public BaselinedMetricAggregationContainer metric(AttributeExpression attributeExpressiony) {
+      return this.metricContainers.get(attributeExpressiony);
     }
   }
 

hypertrace-graphql-entity-schema/src/main/java/org/hypertrace/graphql/entity/dao/GatewayServiceEntityEdgeFetcher.java

@@ -59,7 +59,8 @@ private Single<Map<String, Collection<InteractionResponse>>> groupInteractionsBy
   private Single<Entry<String, InteractionResponse>> builtInteractionTypeEntry(
       InteractionResponse response, AttributeRequest neighborType) {
 
-    return this.getEntityType(response.getInteraction().getAttributeMap().get(neighborType.alias()))
+    return this.getEntityType(
+            response.getInteraction().getAttributeMap().get(neighborType.asMapKey()))
         .map(entityType -> Map.entry(entityType, response));
   }
 

hypertrace-graphql-entity-schema/src/main/java/org/hypertrace/graphql/entity/dao/GatewayServiceEntityEdgeTableConverter.java

@@ -13,6 +13,7 @@
 import org.hypertrace.core.graphql.common.request.AttributeAssociation;
 import org.hypertrace.core.graphql.common.request.AttributeRequest;
 import org.hypertrace.core.graphql.common.schema.attributes.AttributeScope;
+import org.hypertrace.core.graphql.common.schema.attributes.arguments.AttributeExpression;
 import org.hypertrace.core.graphql.common.schema.results.arguments.filter.FilterArgument;
 import org.hypertrace.core.graphql.common.schema.results.arguments.filter.FilterOperatorType;
 import org.hypertrace.core.graphql.common.schema.results.arguments.filter.FilterType;
@@ -71,17 +72,19 @@ private Single<Filter> buildEntityTypeFilter(EdgeSetGroupRequest request) {
         .map(
             entityTypes ->
                 AttributeAssociation.<FilterArgument>of(
-                    request.neighborTypeAttribute().attribute(),
+                    request.neighborTypeAttribute().attributeExpressionAssociation().attribute(),
                     new EntityNeighborTypeFilter(
-                        request.neighborTypeAttribute().attribute().key(), entityTypes)))
+                        request.neighborTypeAttribute().attributeExpressionAssociation().value(),
+                        entityTypes)))
         .flatMap(filterAssociation -> this.filterConverter.convert(Set.of(filterAssociation)));
   }
 
   @Value
   @Accessors(fluent = true)
   private static class EntityNeighborTypeFilter implements FilterArgument {
     FilterType type = FilterType.ATTRIBUTE;
-    String key;
+    String key = null;
+    AttributeExpression keyExpression;
     FilterOperatorType operator = FilterOperatorType.IN;
     Collection<String> value;
     AttributeScope idType = null;

hypertrace-graphql-entity-schema/src/main/java/org/hypertrace/graphql/entity/dao/GatewayServiceEntityInteractionRequestBuilder.java

@@ -41,6 +41,7 @@
 import org.hypertrace.core.graphql.common.request.ResultSetRequestBuilder;
 import org.hypertrace.core.graphql.common.schema.arguments.TimeRangeArgument;
 import org.hypertrace.core.graphql.common.schema.attributes.AttributeScope;
+import org.hypertrace.core.graphql.common.schema.attributes.arguments.AttributeExpression;
 import org.hypertrace.core.graphql.common.schema.results.arguments.filter.FilterArgument;
 import org.hypertrace.core.graphql.common.schema.results.arguments.filter.FilterOperatorType;
 import org.hypertrace.core.graphql.common.schema.results.arguments.filter.FilterType;
@@ -344,6 +345,7 @@ private static class InstantTimeRange implements TimeRangeArgument {
   private static class EntityIdFilter implements FilterArgument {
     FilterType type = FilterType.ID;
     String key = null;
+    AttributeExpression keyExpression = null;
     FilterOperatorType operator = FilterOperatorType.IN;
     Collection<String> value;
     AttributeScope idType = null;