Add api naming rules

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.25")
+    api("org.hypertrace.config.service:span-processing-config-service-api:0.1.26")
   }
 }

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

@@ -1,14 +1,25 @@
 package org.hypertrace.graphql.spanprocessing.dao;
 
 import javax.inject.Inject;
+import org.hypertrace.graphql.spanprocessing.request.mutation.ApiNamingCreateRuleRequest;
+import org.hypertrace.graphql.spanprocessing.request.mutation.ApiNamingDeleteRuleRequest;
+import org.hypertrace.graphql.spanprocessing.request.mutation.ApiNamingUpdateRuleRequest;
 import org.hypertrace.graphql.spanprocessing.request.mutation.ExcludeSpanCreateRuleRequest;
 import org.hypertrace.graphql.spanprocessing.request.mutation.ExcludeSpanDeleteRuleRequest;
 import org.hypertrace.graphql.spanprocessing.request.mutation.ExcludeSpanUpdateRuleRequest;
+import org.hypertrace.graphql.spanprocessing.schema.mutation.ApiNamingRuleCreate;
+import org.hypertrace.graphql.spanprocessing.schema.mutation.ApiNamingRuleUpdate;
 import org.hypertrace.graphql.spanprocessing.schema.mutation.ExcludeSpanRuleCreate;
 import org.hypertrace.graphql.spanprocessing.schema.mutation.ExcludeSpanRuleUpdate;
+import org.hypertrace.span.processing.config.service.v1.ApiNamingRuleConfig;
+import org.hypertrace.span.processing.config.service.v1.ApiNamingRuleInfo;
+import org.hypertrace.span.processing.config.service.v1.CreateApiNamingRuleRequest;
 import org.hypertrace.span.processing.config.service.v1.CreateExcludeSpanRuleRequest;
+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.UpdateApiNamingRule;
+import org.hypertrace.span.processing.config.service.v1.UpdateApiNamingRuleRequest;
 import org.hypertrace.span.processing.config.service.v1.UpdateExcludeSpanRule;
 import org.hypertrace.span.processing.config.service.v1.UpdateExcludeSpanRuleRequest;
 
@@ -53,4 +64,48 @@ private UpdateExcludeSpanRule convertInput(ExcludeSpanRuleUpdate excludeSpanRule
   DeleteExcludeSpanRuleRequest convert(ExcludeSpanDeleteRuleRequest request) {
     return DeleteExcludeSpanRuleRequest.newBuilder().setId(request.id()).build();
   }
+
+  CreateApiNamingRuleRequest convert(ApiNamingCreateRuleRequest request) {
+    return CreateApiNamingRuleRequest.newBuilder()
+        .setRuleInfo(convertInput(request.createInput()))
+        .build();
+  }
+
+  private org.hypertrace.span.processing.config.service.v1.ApiNamingRuleInfo convertInput(
+      ApiNamingRuleCreate apiNamingRuleCreate) {
+    return ApiNamingRuleInfo.newBuilder()
+        .setName(apiNamingRuleCreate.name())
+        .setFilter(this.filterConverter.convert(apiNamingRuleCreate.spanFilter()))
+        .setDisabled(apiNamingRuleCreate.disabled())
+        .setRuleConfig(
+            ApiNamingRuleConfig.newBuilder()
+                .setRegex(apiNamingRuleCreate.regex())
+                .setValue(apiNamingRuleCreate.value())
+                .build())
+        .build();
+  }
+
+  UpdateApiNamingRuleRequest convert(ApiNamingUpdateRuleRequest request) {
+    return UpdateApiNamingRuleRequest.newBuilder()
+        .setRule(convertInput(request.updateInput()))
+        .build();
+  }
+
+  private UpdateApiNamingRule convertInput(ApiNamingRuleUpdate apiNamingRuleUpdate) {
+    return UpdateApiNamingRule.newBuilder()
+        .setId(apiNamingRuleUpdate.id())
+        .setName(apiNamingRuleUpdate.name())
+        .setFilter(this.filterConverter.convert(apiNamingRuleUpdate.spanFilter()))
+        .setDisabled(apiNamingRuleUpdate.disabled())
+        .setRuleConfig(
+            ApiNamingRuleConfig.newBuilder()
+                .setRegex(apiNamingRuleUpdate.regex())
+                .setValue(apiNamingRuleUpdate.value())
+                .build())
+        .build();
+  }
+
+  DeleteApiNamingRuleRequest convert(ApiNamingDeleteRuleRequest request) {
+    return DeleteApiNamingRuleRequest.newBuilder().setId(request.id()).build();
+  }
 }

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

@@ -9,11 +9,17 @@
 import lombok.experimental.Accessors;
 import lombok.extern.slf4j.Slf4j;
 import org.hypertrace.graphql.spanprocessing.schema.mutation.DeleteSpanProcessingRuleResponse;
+import org.hypertrace.graphql.spanprocessing.schema.query.ApiNamingRuleResultSet;
 import org.hypertrace.graphql.spanprocessing.schema.query.ExcludeSpanRuleResultSet;
+import org.hypertrace.graphql.spanprocessing.schema.rule.ApiNamingRule;
 import org.hypertrace.graphql.spanprocessing.schema.rule.ExcludeSpanRule;
+import org.hypertrace.span.processing.config.service.v1.CreateApiNamingRuleResponse;
 import org.hypertrace.span.processing.config.service.v1.CreateExcludeSpanRuleResponse;
+import org.hypertrace.span.processing.config.service.v1.DeleteApiNamingRuleResponse;
 import org.hypertrace.span.processing.config.service.v1.DeleteExcludeSpanRuleResponse;
+import org.hypertrace.span.processing.config.service.v1.GetAllApiNamingRulesResponse;
 import org.hypertrace.span.processing.config.service.v1.GetAllExcludeSpanRulesResponse;
+import org.hypertrace.span.processing.config.service.v1.UpdateApiNamingRuleResponse;
 import org.hypertrace.span.processing.config.service.v1.UpdateExcludeSpanRuleResponse;
 
 @Slf4j
@@ -28,7 +34,11 @@ public class ConfigServiceSpanProcessingResponseConverter {
   }
 
   Single<ExcludeSpanRuleResultSet> convert(GetAllExcludeSpanRulesResponse response) {
-    return this.convertResultSet(response.getRuleDetailsList());
+    return this.convertExcludeSpanRuleResultSet(response.getRuleDetailsList());
+  }
+
+  Single<ApiNamingRuleResultSet> convert(GetAllApiNamingRulesResponse response) {
+    return this.convertApiNamingRuleResultSet(response.getRuleDetailsList());
   }
 
   private Maybe<ExcludeSpanRule> convertOrDrop(
@@ -39,14 +49,30 @@ private Maybe<ExcludeSpanRule> convertOrDrop(
         .onErrorComplete();
   }
 
-  private Single<ExcludeSpanRuleResultSet> convertResultSet(
+  private Maybe<ApiNamingRule> convertOrDrop(
+      org.hypertrace.span.processing.config.service.v1.ApiNamingRuleDetails ruleDetails) {
+    return this.ruleConverter
+        .convert(ruleDetails)
+        .doOnError(error -> log.error("Error converting ExcludeSpanRule", error))
+        .onErrorComplete();
+  }
+
+  private Single<ExcludeSpanRuleResultSet> convertExcludeSpanRuleResultSet(
       List<org.hypertrace.span.processing.config.service.v1.ExcludeSpanRuleDetails> ruleDetails) {
     return Observable.fromIterable(ruleDetails)
         .concatMapMaybe(this::convertOrDrop)
         .toList()
         .map(ConvertedExcludeSpanRuleResultSet::new);
   }
 
+  private Single<ApiNamingRuleResultSet> convertApiNamingRuleResultSet(
+      List<org.hypertrace.span.processing.config.service.v1.ApiNamingRuleDetails> ruleDetails) {
+    return Observable.fromIterable(ruleDetails)
+        .concatMapMaybe(this::convertOrDrop)
+        .toList()
+        .map(ConvertedApiNamingRuleResultSet::new);
+  }
+
   Single<ExcludeSpanRule> convert(CreateExcludeSpanRuleResponse response) {
     return this.ruleConverter.convert(response.getRuleDetails());
   }
@@ -59,6 +85,18 @@ Single<DeleteSpanProcessingRuleResponse> convert(DeleteExcludeSpanRuleResponse r
     return Single.just(new DefaultDeleteSpanProcessingRuleResponse(true));
   }
 
+  Single<ApiNamingRule> convert(CreateApiNamingRuleResponse response) {
+    return this.ruleConverter.convert(response.getRuleDetails());
+  }
+
+  Single<ApiNamingRule> convert(UpdateApiNamingRuleResponse response) {
+    return this.ruleConverter.convert(response.getRuleDetails());
+  }
+
+  Single<DeleteSpanProcessingRuleResponse> convert(DeleteApiNamingRuleResponse response) {
+    return Single.just(new DefaultDeleteSpanProcessingRuleResponse(true));
+  }
+
   @Value
   @Accessors(fluent = true)
   private static class DefaultDeleteSpanProcessingRuleResponse
@@ -79,4 +117,18 @@ private ConvertedExcludeSpanRuleResultSet(List<ExcludeSpanRule> results) {
       this.total = results.size();
     }
   }
+
+  @Value
+  @Accessors(fluent = true)
+  private static class ConvertedApiNamingRuleResultSet implements ApiNamingRuleResultSet {
+    List<ApiNamingRule> results;
+    long total;
+    long count;
+
+    private ConvertedApiNamingRuleResultSet(List<ApiNamingRule> results) {
+      this.results = results;
+      this.count = results.size();
+      this.total = results.size();
+    }
+  }
 }

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

@@ -5,13 +5,12 @@
 import javax.inject.Inject;
 import lombok.Value;
 import lombok.experimental.Accessors;
-import org.hypertrace.core.graphql.common.utils.Converter;
+import org.hypertrace.graphql.spanprocessing.schema.rule.ApiNamingRule;
 import org.hypertrace.graphql.spanprocessing.schema.rule.ExcludeSpanRule;
 import org.hypertrace.graphql.spanprocessing.schema.rule.filter.SpanProcessingRuleFilter;
+import org.hypertrace.span.processing.config.service.v1.ApiNamingRuleDetails;
 
-class ConfigServiceSpanProcessingRuleConverter
-    implements Converter<
-        org.hypertrace.span.processing.config.service.v1.ExcludeSpanRuleDetails, ExcludeSpanRule> {
+class ConfigServiceSpanProcessingRuleConverter {
 
   private final ConfigServiceSpanFilterConverter filterConverter;
 
@@ -20,7 +19,6 @@ class ConfigServiceSpanProcessingRuleConverter
     this.filterConverter = filterConverter;
   }
 
-  @Override
   public Single<ExcludeSpanRule> convert(
       org.hypertrace.span.processing.config.service.v1.ExcludeSpanRuleDetails ruleDetails) {
     return this.filterConverter
@@ -40,6 +38,26 @@ public Single<ExcludeSpanRule> convert(
                         ruleDetails.getMetadata().getLastUpdatedTimestamp().getNanos())));
   }
 
+  public Single<ApiNamingRule> convert(ApiNamingRuleDetails ruleDetails) {
+    return this.filterConverter
+        .convert(ruleDetails.getRule().getRuleInfo().getFilter())
+        .map(
+            spanProcessingRuleFilter ->
+                new ConvertedApiNamingRule(
+                    ruleDetails.getRule().getId(),
+                    ruleDetails.getRule().getRuleInfo().getName(),
+                    spanProcessingRuleFilter,
+                    ruleDetails.getRule().getRuleInfo().getDisabled(),
+                    ruleDetails.getRule().getRuleInfo().getRuleConfig().getRegex(),
+                    ruleDetails.getRule().getRuleInfo().getRuleConfig().getValue(),
+                    Instant.ofEpochSecond(
+                        ruleDetails.getMetadata().getCreationTimestamp().getSeconds(),
+                        ruleDetails.getMetadata().getCreationTimestamp().getNanos()),
+                    Instant.ofEpochSecond(
+                        ruleDetails.getMetadata().getLastUpdatedTimestamp().getSeconds(),
+                        ruleDetails.getMetadata().getLastUpdatedTimestamp().getNanos())));
+  }
+
   @Value
   @Accessors(fluent = true)
   private static class ConvertedExcludeSpanRule implements ExcludeSpanRule {
@@ -50,4 +68,17 @@ private static class ConvertedExcludeSpanRule implements ExcludeSpanRule {
     Instant creationTime;
     Instant lastUpdatedTime;
   }
+
+  @Value
+  @Accessors(fluent = true)
+  private static class ConvertedApiNamingRule implements ApiNamingRule {
+    String id;
+    String name;
+    SpanProcessingRuleFilter spanFilter;
+    boolean disabled;
+    String regex;
+    String value;
+    Instant creationTime;
+    Instant lastUpdatedTime;
+  }
 }

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

@@ -9,12 +9,18 @@
 import org.hypertrace.core.graphql.utils.grpc.GrpcChannelRegistry;
 import org.hypertrace.core.graphql.utils.grpc.GrpcContextBuilder;
 import org.hypertrace.graphql.config.HypertraceGraphQlServiceConfig;
+import org.hypertrace.graphql.spanprocessing.request.mutation.ApiNamingCreateRuleRequest;
+import org.hypertrace.graphql.spanprocessing.request.mutation.ApiNamingDeleteRuleRequest;
+import org.hypertrace.graphql.spanprocessing.request.mutation.ApiNamingUpdateRuleRequest;
 import org.hypertrace.graphql.spanprocessing.request.mutation.ExcludeSpanCreateRuleRequest;
 import org.hypertrace.graphql.spanprocessing.request.mutation.ExcludeSpanDeleteRuleRequest;
 import org.hypertrace.graphql.spanprocessing.request.mutation.ExcludeSpanUpdateRuleRequest;
 import org.hypertrace.graphql.spanprocessing.schema.mutation.DeleteSpanProcessingRuleResponse;
+import org.hypertrace.graphql.spanprocessing.schema.query.ApiNamingRuleResultSet;
 import org.hypertrace.graphql.spanprocessing.schema.query.ExcludeSpanRuleResultSet;
+import org.hypertrace.graphql.spanprocessing.schema.rule.ApiNamingRule;
 import org.hypertrace.graphql.spanprocessing.schema.rule.ExcludeSpanRule;
+import org.hypertrace.span.processing.config.service.v1.GetAllApiNamingRulesRequest;
 import org.hypertrace.span.processing.config.service.v1.GetAllExcludeSpanRulesRequest;
 import org.hypertrace.span.processing.config.service.v1.SpanProcessingConfigServiceGrpc;
 
@@ -46,7 +52,7 @@ public class ConfigServiceSpanProcessingRuleDao implements SpanProcessingRuleDao
   }
 
   @Override
-  public Single<ExcludeSpanRuleResultSet> getRules(ContextualRequest request) {
+  public Single<ExcludeSpanRuleResultSet> getExcludeSpanRules(ContextualRequest request) {
     return Single.fromFuture(
             this.grpcContextBuilder
                 .build(request.context())
@@ -61,7 +67,7 @@ public Single<ExcludeSpanRuleResultSet> getRules(ContextualRequest request) {
   }
 
   @Override
-  public Single<ExcludeSpanRule> createRule(ExcludeSpanCreateRuleRequest request) {
+  public Single<ExcludeSpanRule> createExcludeSpanRule(ExcludeSpanCreateRuleRequest request) {
     return Single.fromFuture(
             this.grpcContextBuilder
                 .build(request.context())
@@ -75,7 +81,7 @@ public Single<ExcludeSpanRule> createRule(ExcludeSpanCreateRuleRequest request)
   }
 
   @Override
-  public Single<ExcludeSpanRule> updateRule(ExcludeSpanUpdateRuleRequest request) {
+  public Single<ExcludeSpanRule> updateExcludeSpanRule(ExcludeSpanUpdateRuleRequest request) {
     return Single.fromFuture(
             this.grpcContextBuilder
                 .build(request.context())
@@ -89,7 +95,8 @@ public Single<ExcludeSpanRule> updateRule(ExcludeSpanUpdateRuleRequest request)
   }
 
   @Override
-  public Single<DeleteSpanProcessingRuleResponse> deleteRule(ExcludeSpanDeleteRuleRequest request) {
+  public Single<DeleteSpanProcessingRuleResponse> deleteExcludeSpanRule(
+      ExcludeSpanDeleteRuleRequest request) {
     return Single.fromFuture(
             this.grpcContextBuilder
                 .build(request.context())
@@ -101,4 +108,62 @@ public Single<DeleteSpanProcessingRuleResponse> deleteRule(ExcludeSpanDeleteRule
                             .deleteExcludeSpanRule(this.requestConverter.convert(request))))
         .flatMap(this.responseConverter::convert);
   }
+
+  @Override
+  public Single<ApiNamingRuleResultSet> getApiNamingRules(ContextualRequest request) {
+    return Single.fromFuture(
+            this.grpcContextBuilder
+                .build(request.context())
+                .call(
+                    () ->
+                        this.configStub
+                            .withDeadlineAfter(
+                                serviceConfig.getConfigServiceTimeout().toMillis(), MILLISECONDS)
+                            .getAllApiNamingRules(
+                                GetAllApiNamingRulesRequest.getDefaultInstance())))
+        .flatMap(this.responseConverter::convert);
+  }
+
+  @Override
+  public Single<ApiNamingRule> createApiNamingRule(ApiNamingCreateRuleRequest request) {
+    return Single.fromFuture(
+            this.grpcContextBuilder
+                .build(request.context())
+                .call(
+                    () ->
+                        this.configStub
+                            .withDeadlineAfter(
+                                serviceConfig.getConfigServiceTimeout().toMillis(), MILLISECONDS)
+                            .createApiNamingRule(this.requestConverter.convert(request))))
+        .flatMap(this.responseConverter::convert);
+  }
+
+  @Override
+  public Single<ApiNamingRule> updateApiNamingRule(ApiNamingUpdateRuleRequest request) {
+    return Single.fromFuture(
+            this.grpcContextBuilder
+                .build(request.context())
+                .call(
+                    () ->
+                        this.configStub
+                            .withDeadlineAfter(
+                                serviceConfig.getConfigServiceTimeout().toMillis(), MILLISECONDS)
+                            .updateApiNamingRule(this.requestConverter.convert(request))))
+        .flatMap(this.responseConverter::convert);
+  }
+
+  @Override
+  public Single<DeleteSpanProcessingRuleResponse> deleteApiNamingRule(
+      ApiNamingDeleteRuleRequest request) {
+    return Single.fromFuture(
+            this.grpcContextBuilder
+                .build(request.context())
+                .call(
+                    () ->
+                        this.configStub
+                            .withDeadlineAfter(
+                                serviceConfig.getConfigServiceTimeout().toMillis(), MILLISECONDS)
+                            .deleteApiNamingRule(this.requestConverter.convert(request))))
+        .flatMap(this.responseConverter::convert);
+  }
 }