fix: remove api naming rule apis

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

@@ -2,28 +2,16 @@
 
 import java.util.NoSuchElementException;
 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.graphql.spanprocessing.schema.rule.ExcludeSpanRuleRuleType;
-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.RuleType;
-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;
 import org.hypertrace.span.processing.config.service.v1.UpdateExcludeSpanRuleRequest;
 
@@ -70,59 +58,6 @@ 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(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()))
-        .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(convertRuleConfig(apiNamingRuleUpdate.apiNamingRuleConfig()))
-        .build();
-  }
-
-  DeleteApiNamingRuleRequest convert(ApiNamingDeleteRuleRequest request) {
-    return DeleteApiNamingRuleRequest.newBuilder().setId(request.id()).build();
-  }
-
   RuleType convertExcludeSpanRuleRuleType(ExcludeSpanRuleRuleType ruleType) {
     // TODO: remove this check after making this field non-nullable
     if (ruleType == null) {

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

@@ -1,7 +1,5 @@
 package org.hypertrace.graphql.spanprocessing.dao;
 
-import static org.hypertrace.span.processing.config.service.v1.ApiNamingRuleConfig.RuleConfigCase.API_SPEC_BASED_CONFIG;
-
 import io.reactivex.rxjava3.core.Maybe;
 import io.reactivex.rxjava3.core.Observable;
 import io.reactivex.rxjava3.core.Single;
@@ -11,17 +9,11 @@
 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
@@ -39,10 +31,6 @@ Single<ExcludeSpanRuleResultSet> convert(GetAllExcludeSpanRulesResponse response
     return this.convertExcludeSpanRuleResultSet(response.getRuleDetailsList());
   }
 
-  Single<ApiNamingRuleResultSet> convert(GetAllApiNamingRulesResponse response) {
-    return this.convertApiNamingRuleResultSet(response.getRuleDetailsList());
-  }
-
   private Maybe<ExcludeSpanRule> convertOrDrop(
       org.hypertrace.span.processing.config.service.v1.ExcludeSpanRuleDetails ruleDetails) {
     return this.ruleConverter
@@ -51,20 +39,6 @@ private Maybe<ExcludeSpanRule> convertOrDrop(
         .onErrorComplete();
   }
 
-  private Maybe<ApiNamingRule> convertOrDrop(
-      org.hypertrace.span.processing.config.service.v1.ApiNamingRuleDetails ruleDetails) {
-    // drop api spec based rules
-    if (API_SPEC_BASED_CONFIG.equals(
-        ruleDetails.getRule().getRuleInfo().getRuleConfig().getRuleConfigCase())) {
-      return Maybe.empty();
-    }
-
-    return this.ruleConverter
-        .convert(ruleDetails)
-        .doOnError(error -> log.error("Error converting ApiNamingRule", error))
-        .onErrorComplete();
-  }
-
   private Single<ExcludeSpanRuleResultSet> convertExcludeSpanRuleResultSet(
       List<org.hypertrace.span.processing.config.service.v1.ExcludeSpanRuleDetails> ruleDetails) {
     return Observable.fromIterable(ruleDetails)
@@ -73,14 +47,6 @@ private Single<ExcludeSpanRuleResultSet> convertExcludeSpanRuleResultSet(
         .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());
   }
@@ -93,18 +59,6 @@ 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
@@ -125,18 +79,4 @@ 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

@@ -2,21 +2,14 @@
 
 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.ExcludeSpanRuleRuleType;
-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.RuleType;
-import org.hypertrace.span.processing.config.service.v1.SegmentMatchingBasedConfig;
 
 class ConfigServiceSpanProcessingRuleConverter {
 
@@ -47,41 +40,6 @@ 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(),
-                    convertApiNamingRuleConfig(ruleDetails.getRule().getRuleInfo().getRuleConfig()),
-                    Instant.ofEpochSecond(
-                        ruleDetails.getMetadata().getCreationTimestamp().getSeconds(),
-                        ruleDetails.getMetadata().getCreationTimestamp().getNanos()),
-                    Instant.ofEpochSecond(
-                        ruleDetails.getMetadata().getLastUpdatedTimestamp().getSeconds(),
-                        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);
-    }
-  }
-
   private ExcludeSpanRuleRuleType convertExcludeSpanRuleRuleType(RuleType ruleType) {
     switch (ruleType) {
       case RULE_TYPE_UNSPECIFIED: // required to cater for the older user configs(as they didn't
@@ -106,31 +64,4 @@ 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;
-    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/dao/ConfigServiceSpanProcessingRuleDao.java

@@ -9,18 +9,12 @@
 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;
 
@@ -108,62 +102,4 @@ public Single<DeleteSpanProcessingRuleResponse> deleteExcludeSpanRule(
                             .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);
-  }
 }