Add in operator and segment based matching config

hypertrace-graphql-platform/build.gradle.kts

@@ -13,6 +13,6 @@ dependencies {
     api("org.hypertrace.config.service:spaces-config-service-api:0.1.1")
     api("org.hypertrace.config.service:labels-config-service-api:0.1.15")
     api("org.hypertrace.config.service:label-application-rule-config-service-api:0.1.16")
-    api("org.hypertrace.config.service:span-processing-config-service-api:0.1.26")
+    api("org.hypertrace.config.service:span-processing-config-service-api:0.1.27")
   }
 }

hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/dao/ConfigServiceSpanFilterConverter.java

@@ -2,6 +2,7 @@
 
 import com.google.common.collect.ImmutableBiMap;
 import io.reactivex.rxjava3.core.Single;
+import java.util.ArrayList;
 import java.util.List;
 import java.util.NoSuchElementException;
 import java.util.Objects;
@@ -15,6 +16,7 @@
 import org.hypertrace.graphql.spanprocessing.schema.rule.filter.SpanProcessingRelationalOperator;
 import org.hypertrace.graphql.spanprocessing.schema.rule.filter.SpanProcessingRuleFilter;
 import org.hypertrace.span.processing.config.service.v1.Field;
+import org.hypertrace.span.processing.config.service.v1.ListValue;
 import org.hypertrace.span.processing.config.service.v1.LogicalOperator;
 import org.hypertrace.span.processing.config.service.v1.LogicalSpanFilterExpression;
 import org.hypertrace.span.processing.config.service.v1.RelationalOperator;
@@ -56,6 +58,7 @@ public class ConfigServiceSpanFilterConverter {
               .put(
                   RelationalOperator.RELATIONAL_OPERATOR_REGEX_MATCH,
                   SpanProcessingRelationalOperator.REGEX_MATCH)
+              .put(RelationalOperator.RELATIONAL_OPERATOR_IN, SpanProcessingRelationalOperator.IN)
               .build();
 
   private static final ImmutableBiMap<SpanProcessingRelationalOperator, RelationalOperator>
@@ -148,11 +151,19 @@ private Object convertSpanFilterValue(SpanFilterValue spanFilterValue) {
     switch (spanFilterValue.getValueCase()) {
       case STRING_VALUE:
         return spanFilterValue.getStringValue();
+      case LIST_VALUE:
+        return convertListSpanFilterValue(spanFilterValue.getListValue());
       default:
         throw new NoSuchElementException("Unsupported right operand type");
     }
   }
 
+  private Object convertListSpanFilterValue(ListValue value) {
+    return value.getValuesList().stream()
+        .map(this::convertSpanFilterValue)
+        .collect(Collectors.toUnmodifiableList());
+  }
+
   private RelationalSpanFilterExpression convertRelationalFilter(
       SpanProcessingRelationalFilter spanProcessingRelationalFilter) {
     RelationalSpanFilterExpression.Builder relationalSpanFilterExpressionBuilder =
@@ -180,10 +191,22 @@ private SpanFilterValue convertToSpanFilterValue(Object value) {
     SpanFilterValue.Builder spanFilterValueBuilder = SpanFilterValue.newBuilder();
     if (String.class.equals(value.getClass())) {
       spanFilterValueBuilder = spanFilterValueBuilder.setStringValue(value.toString());
+    } else if (ArrayList.class.equals(value.getClass())) {
+      spanFilterValueBuilder.setListValue(convertToListSpanFilterValue(value));
     }
     return spanFilterValueBuilder.build();
   }
 
+  private ListValue convertToListSpanFilterValue(Object value) {
+    List<Object> objectList = (List<Object>) value;
+    return ListValue.newBuilder()
+        .addAllValues(
+            objectList.stream()
+                .map(this::convertToSpanFilterValue)
+                .collect(Collectors.toUnmodifiableList()))
+        .build();
+  }
+
   @Value
   @Accessors(fluent = true)
   private static class ConvertedSpanProcessingRelationalFilter

hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/dao/ConfigServiceSpanProcessingRequestConverter.java

@@ -1,5 +1,6 @@
 package org.hypertrace.graphql.spanprocessing.dao;
 
+import java.util.NoSuchElementException;
 import javax.inject.Inject;
 import org.hypertrace.graphql.spanprocessing.request.mutation.ApiNamingCreateRuleRequest;
 import org.hypertrace.graphql.spanprocessing.request.mutation.ApiNamingDeleteRuleRequest;
@@ -18,6 +19,7 @@
 import org.hypertrace.span.processing.config.service.v1.DeleteApiNamingRuleRequest;
 import org.hypertrace.span.processing.config.service.v1.DeleteExcludeSpanRuleRequest;
 import org.hypertrace.span.processing.config.service.v1.ExcludeSpanRuleInfo;
+import org.hypertrace.span.processing.config.service.v1.SegmentMatchingBasedConfig;
 import org.hypertrace.span.processing.config.service.v1.UpdateApiNamingRule;
 import org.hypertrace.span.processing.config.service.v1.UpdateApiNamingRuleRequest;
 import org.hypertrace.span.processing.config.service.v1.UpdateExcludeSpanRule;
@@ -77,14 +79,27 @@ private org.hypertrace.span.processing.config.service.v1.ApiNamingRuleInfo conve
         .setName(apiNamingRuleCreate.name())
         .setFilter(this.filterConverter.convert(apiNamingRuleCreate.spanFilter()))
         .setDisabled(apiNamingRuleCreate.disabled())
-        .setRuleConfig(
-            ApiNamingRuleConfig.newBuilder()
-                .setRegex(apiNamingRuleCreate.regex())
-                .setValue(apiNamingRuleCreate.value())
-                .build())
+        .setRuleConfig(convertRuleConfig(apiNamingRuleCreate.apiNamingRuleConfig()))
         .build();
   }
 
+  private ApiNamingRuleConfig convertRuleConfig(
+      org.hypertrace.graphql.spanprocessing.schema.rule.ApiNamingRuleConfig apiNamingRuleConfig) {
+    switch (apiNamingRuleConfig.apiNamingRuleConfigType()) {
+      case SEGMENT_MATCHING:
+        return ApiNamingRuleConfig.newBuilder()
+            .setSegmentMatchingBasedConfig(
+                SegmentMatchingBasedConfig.newBuilder()
+                    .addAllRegexes(apiNamingRuleConfig.segmentMatchingBasedRuleConfig().regexes())
+                    .addAllValues(apiNamingRuleConfig.segmentMatchingBasedRuleConfig().values())
+                    .build())
+            .build();
+      default:
+        throw new NoSuchElementException(
+            "Unsupported api naming rule config type: " + apiNamingRuleConfig);
+    }
+  }
+
   UpdateApiNamingRuleRequest convert(ApiNamingUpdateRuleRequest request) {
     return UpdateApiNamingRuleRequest.newBuilder()
         .setRule(convertInput(request.updateInput()))
@@ -97,11 +112,7 @@ private UpdateApiNamingRule convertInput(ApiNamingRuleUpdate apiNamingRuleUpdate
         .setName(apiNamingRuleUpdate.name())
         .setFilter(this.filterConverter.convert(apiNamingRuleUpdate.spanFilter()))
         .setDisabled(apiNamingRuleUpdate.disabled())
-        .setRuleConfig(
-            ApiNamingRuleConfig.newBuilder()
-                .setRegex(apiNamingRuleUpdate.regex())
-                .setValue(apiNamingRuleUpdate.value())
-                .build())
+        .setRuleConfig(convertRuleConfig(apiNamingRuleUpdate.apiNamingRuleConfig()))
         .build();
   }
 

hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/dao/ConfigServiceSpanProcessingRuleConverter.java

@@ -2,13 +2,19 @@
 
 import io.reactivex.rxjava3.core.Single;
 import java.time.Instant;
+import java.util.List;
+import java.util.NoSuchElementException;
 import javax.inject.Inject;
 import lombok.Value;
 import lombok.experimental.Accessors;
 import org.hypertrace.graphql.spanprocessing.schema.rule.ApiNamingRule;
+import org.hypertrace.graphql.spanprocessing.schema.rule.ApiNamingRuleConfig;
+import org.hypertrace.graphql.spanprocessing.schema.rule.ApiNamingRuleConfigType;
 import org.hypertrace.graphql.spanprocessing.schema.rule.ExcludeSpanRule;
+import org.hypertrace.graphql.spanprocessing.schema.rule.SegmentMatchingBasedRuleConfig;
 import org.hypertrace.graphql.spanprocessing.schema.rule.filter.SpanProcessingRuleFilter;
 import org.hypertrace.span.processing.config.service.v1.ApiNamingRuleDetails;
+import org.hypertrace.span.processing.config.service.v1.SegmentMatchingBasedConfig;
 
 class ConfigServiceSpanProcessingRuleConverter {
 
@@ -48,8 +54,7 @@ public Single<ApiNamingRule> convert(ApiNamingRuleDetails ruleDetails) {
                     ruleDetails.getRule().getRuleInfo().getName(),
                     spanProcessingRuleFilter,
                     ruleDetails.getRule().getRuleInfo().getDisabled(),
-                    ruleDetails.getRule().getRuleInfo().getRuleConfig().getRegex(),
-                    ruleDetails.getRule().getRuleInfo().getRuleConfig().getValue(),
+                    convertApiNamingRuleConfig(ruleDetails.getRule().getRuleInfo().getRuleConfig()),
                     Instant.ofEpochSecond(
                         ruleDetails.getMetadata().getCreationTimestamp().getSeconds(),
                         ruleDetails.getMetadata().getCreationTimestamp().getNanos()),
@@ -58,6 +63,22 @@ public Single<ApiNamingRule> convert(ApiNamingRuleDetails ruleDetails) {
                         ruleDetails.getMetadata().getLastUpdatedTimestamp().getNanos())));
   }
 
+  private ApiNamingRuleConfig convertApiNamingRuleConfig(
+      org.hypertrace.span.processing.config.service.v1.ApiNamingRuleConfig apiNamingRuleConfig) {
+    switch (apiNamingRuleConfig.getRuleConfigCase()) {
+      case SEGMENT_MATCHING_BASED_CONFIG:
+        SegmentMatchingBasedConfig segmentMatchingBasedConfig =
+            apiNamingRuleConfig.getSegmentMatchingBasedConfig();
+        return new ConvertedApiNamingRuleConfig(
+            ApiNamingRuleConfigType.SEGMENT_MATCHING,
+            new ConvertedSegmentMatchingBasedRuleConfig(
+                segmentMatchingBasedConfig.getRegexesList(),
+                segmentMatchingBasedConfig.getValuesList()));
+      default:
+        throw new NoSuchElementException("Unsupported Rule config type: " + apiNamingRuleConfig);
+    }
+  }
+
   @Value
   @Accessors(fluent = true)
   private static class ConvertedExcludeSpanRule implements ExcludeSpanRule {
@@ -76,9 +97,23 @@ private static class ConvertedApiNamingRule implements ApiNamingRule {
     String name;
     SpanProcessingRuleFilter spanFilter;
     boolean disabled;
-    String regex;
-    String value;
+    ApiNamingRuleConfig apiNamingRuleConfig;
     Instant creationTime;
     Instant lastUpdatedTime;
   }
+
+  @Value
+  @Accessors(fluent = true)
+  private static class ConvertedApiNamingRuleConfig implements ApiNamingRuleConfig {
+    ApiNamingRuleConfigType apiNamingRuleConfigType;
+    SegmentMatchingBasedRuleConfig segmentMatchingBasedRuleConfig;
+  }
+
+  @Value
+  @Accessors(fluent = true)
+  private static class ConvertedSegmentMatchingBasedRuleConfig
+      implements SegmentMatchingBasedRuleConfig {
+    List<String> regexes;
+    List<String> values;
+  }
 }

hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/deserialization/ApiNamingCreateInputDeserializationConfig.java

@@ -9,6 +9,8 @@
 import lombok.extern.jackson.Jacksonized;
 import org.hypertrace.core.graphql.deserialization.ArgumentDeserializationConfig;
 import org.hypertrace.graphql.spanprocessing.schema.mutation.ApiNamingRuleCreate;
+import org.hypertrace.graphql.spanprocessing.schema.rule.ApiNamingRuleConfig;
+import org.hypertrace.graphql.spanprocessing.schema.rule.SegmentMatchingBasedRuleConfig;
 import org.hypertrace.graphql.spanprocessing.schema.rule.filter.SpanProcessingLogicalFilter;
 import org.hypertrace.graphql.spanprocessing.schema.rule.filter.SpanProcessingRelationalFilter;
 import org.hypertrace.graphql.spanprocessing.schema.rule.filter.SpanProcessingRuleFilter;
@@ -29,6 +31,9 @@ public List<Module> jacksonModules() {
     return List.of(
         new SimpleModule()
             .addAbstractTypeMapping(ApiNamingRuleCreate.class, DefaultApiNamingRuleCreate.class)
+            .addAbstractTypeMapping(ApiNamingRuleConfig.class, DefaultApiNamingRuleConfig.class)
+            .addAbstractTypeMapping(
+                SegmentMatchingBasedRuleConfig.class, DefaultSegmentMatchingBasedRuleConfig.class)
             .addAbstractTypeMapping(
                 SpanProcessingRuleFilter.class, DefaultSpanProcessingRuleFilter.class)
             .addAbstractTypeMapping(
@@ -44,8 +49,7 @@ public List<Module> jacksonModules() {
   private static class DefaultApiNamingRuleCreate implements ApiNamingRuleCreate {
     String name;
     SpanProcessingRuleFilter spanFilter;
-    String regex;
-    String value;
+    ApiNamingRuleConfig apiNamingRuleConfig;
     boolean disabled;
   }
 }

hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/deserialization/ApiNamingUpdateInputDeserializationConfig.java

@@ -9,6 +9,8 @@
 import lombok.extern.jackson.Jacksonized;
 import org.hypertrace.core.graphql.deserialization.ArgumentDeserializationConfig;
 import org.hypertrace.graphql.spanprocessing.schema.mutation.ApiNamingRuleUpdate;
+import org.hypertrace.graphql.spanprocessing.schema.rule.ApiNamingRuleConfig;
+import org.hypertrace.graphql.spanprocessing.schema.rule.SegmentMatchingBasedRuleConfig;
 import org.hypertrace.graphql.spanprocessing.schema.rule.filter.SpanProcessingLogicalFilter;
 import org.hypertrace.graphql.spanprocessing.schema.rule.filter.SpanProcessingRelationalFilter;
 import org.hypertrace.graphql.spanprocessing.schema.rule.filter.SpanProcessingRuleFilter;
@@ -29,6 +31,9 @@ public List<Module> jacksonModules() {
     return List.of(
         new SimpleModule()
             .addAbstractTypeMapping(ApiNamingRuleUpdate.class, DefaultApiNamingRuleUpdate.class)
+            .addAbstractTypeMapping(ApiNamingRuleConfig.class, DefaultApiNamingRuleConfig.class)
+            .addAbstractTypeMapping(
+                SegmentMatchingBasedRuleConfig.class, DefaultSegmentMatchingBasedRuleConfig.class)
             .addAbstractTypeMapping(
                 SpanProcessingRuleFilter.class, DefaultSpanProcessingRuleFilter.class)
             .addAbstractTypeMapping(
@@ -46,7 +51,6 @@ private static class DefaultApiNamingRuleUpdate implements ApiNamingRuleUpdate {
     String name;
     SpanProcessingRuleFilter spanFilter;
     boolean disabled;
-    String regex;
-    String value;
+    ApiNamingRuleConfig apiNamingRuleConfig;
   }
 }

hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/deserialization/DefaultApiNamingRuleConfig.java

@@ -0,0 +1,18 @@
+package org.hypertrace.graphql.spanprocessing.deserialization;
+
+import lombok.Builder;
+import lombok.Value;
+import lombok.experimental.Accessors;
+import lombok.extern.jackson.Jacksonized;
+import org.hypertrace.graphql.spanprocessing.schema.rule.ApiNamingRuleConfig;
+import org.hypertrace.graphql.spanprocessing.schema.rule.ApiNamingRuleConfigType;
+import org.hypertrace.graphql.spanprocessing.schema.rule.SegmentMatchingBasedRuleConfig;
+
+@Value
+@Accessors(fluent = true)
+@Jacksonized
+@Builder
+public class DefaultApiNamingRuleConfig implements ApiNamingRuleConfig {
+  ApiNamingRuleConfigType apiNamingRuleConfigType;
+  SegmentMatchingBasedRuleConfig segmentMatchingBasedRuleConfig;
+}

hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/deserialization/DefaultSegmentMatchingBasedRuleConfig.java

@@ -0,0 +1,17 @@
+package org.hypertrace.graphql.spanprocessing.deserialization;
+
+import java.util.List;
+import lombok.Builder;
+import lombok.Value;
+import lombok.experimental.Accessors;
+import lombok.extern.jackson.Jacksonized;
+import org.hypertrace.graphql.spanprocessing.schema.rule.SegmentMatchingBasedRuleConfig;
+
+@Value
+@Accessors(fluent = true)
+@Jacksonized
+@Builder
+public class DefaultSegmentMatchingBasedRuleConfig implements SegmentMatchingBasedRuleConfig {
+  List<String> regexes;
+  List<String> values;
+}

hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/schema/mutation/ApiNamingRuleUpdate.java

@@ -4,6 +4,7 @@
 import graphql.annotations.annotationTypes.GraphQLName;
 import graphql.annotations.annotationTypes.GraphQLNonNull;
 import org.hypertrace.core.graphql.common.schema.id.Identifiable;
+import org.hypertrace.graphql.spanprocessing.schema.rule.ApiNamingRuleConfig;
 import org.hypertrace.graphql.spanprocessing.schema.rule.filter.SpanProcessingRuleFilter;
 
 @GraphQLName(ApiNamingRuleUpdate.TYPE_NAME)
@@ -14,8 +15,7 @@ public interface ApiNamingRuleUpdate extends Identifiable {
   String NAME_KEY = "name";
   String SPAN_PROCESSING_FILTER_KEY = "spanFilter";
   String DISABLED_KEY = "disabled";
-  String REGEX_KEY = "regex";
-  String VALUE_KEY = "value";
+  String API_NAMING_RULE_CONFIG_KEY = "apiNamingRuleConfig";
 
   @GraphQLField
   @GraphQLName(NAME_KEY)
@@ -33,12 +33,7 @@ public interface ApiNamingRuleUpdate extends Identifiable {
   boolean disabled();
 
   @GraphQLField
-  @GraphQLName(REGEX_KEY)
+  @GraphQLName(API_NAMING_RULE_CONFIG_KEY)
   @GraphQLNonNull
-  String regex();
-
-  @GraphQLField
-  @GraphQLName(VALUE_KEY)
-  @GraphQLNonNull
-  String value();
+  ApiNamingRuleConfig apiNamingRuleConfig();
 }

hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/schema/rule/ApiNamingRuleConfig.java

@@ -0,0 +1,22 @@
+package org.hypertrace.graphql.spanprocessing.schema.rule;
+
+import graphql.annotations.annotationTypes.GraphQLField;
+import graphql.annotations.annotationTypes.GraphQLName;
+import graphql.annotations.annotationTypes.GraphQLNonNull;
+
+@GraphQLName(ApiNamingRuleConfig.TYPE_NAME)
+public interface ApiNamingRuleConfig {
+  String TYPE_NAME = "ApiNamingRuleConfig";
+
+  String API_NAMING_RULE_CONFIG_TYPE = "apiNamingRuleConfigType";
+  String SEGMENT_MATCHING_BASED_RULE_CONFIG_TYPE = "segmentMatchingBasedRuleConfig";
+
+  @GraphQLField
+  @GraphQLName(API_NAMING_RULE_CONFIG_TYPE)
+  @GraphQLNonNull
+  ApiNamingRuleConfigType apiNamingRuleConfigType();
+
+  @GraphQLField
+  @GraphQLName(SEGMENT_MATCHING_BASED_RULE_CONFIG_TYPE)
+  SegmentMatchingBasedRuleConfig segmentMatchingBasedRuleConfig();
+}

hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/schema/rule/ApiNamingRuleConfigType.java

@@ -0,0 +1,9 @@
+package org.hypertrace.graphql.spanprocessing.schema.rule;
+
+import graphql.annotations.annotationTypes.GraphQLName;
+
+@GraphQLName(ApiNamingRuleConfigType.TYPE_NAME)
+public enum ApiNamingRuleConfigType {
+  SEGMENT_MATCHING;
+  static final String TYPE_NAME = "ApiNamingRuleConfigType";
+}