diff --git a/hypertrace-graphql-platform/build.gradle.kts b/hypertrace-graphql-platform/build.gradle.kts index 7d61c6c6..1a53c52b 100644 --- a/hypertrace-graphql-platform/build.gradle.kts +++ b/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.27") + api("org.hypertrace.config.service:span-processing-config-service-api:0.1.34") } } diff --git a/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/dao/ConfigServiceSpanProcessingRequestConverter.java b/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/dao/ConfigServiceSpanProcessingRequestConverter.java index 4a43be38..16eda2c8 100644 --- a/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/dao/ConfigServiceSpanProcessingRequestConverter.java +++ b/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/dao/ConfigServiceSpanProcessingRequestConverter.java @@ -8,22 +8,32 @@ 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.request.mutation.IncludeSpanCreateRuleRequest; +import org.hypertrace.graphql.spanprocessing.request.mutation.IncludeSpanDeleteRuleRequest; +import org.hypertrace.graphql.spanprocessing.request.mutation.IncludeSpanUpdateRuleRequest; 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.mutation.IncludeSpanRuleCreate; +import org.hypertrace.graphql.spanprocessing.schema.mutation.IncludeSpanRuleUpdate; 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.CreateIncludeSpanRuleRequest; 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.DeleteIncludeSpanRuleRequest; import org.hypertrace.span.processing.config.service.v1.ExcludeSpanRuleInfo; +import org.hypertrace.span.processing.config.service.v1.IncludeSpanRuleInfo; 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; +import org.hypertrace.span.processing.config.service.v1.UpdateIncludeSpanRule; +import org.hypertrace.span.processing.config.service.v1.UpdateIncludeSpanRuleRequest; public class ConfigServiceSpanProcessingRequestConverter { @@ -67,6 +77,39 @@ DeleteExcludeSpanRuleRequest convert(ExcludeSpanDeleteRuleRequest request) { return DeleteExcludeSpanRuleRequest.newBuilder().setId(request.id()).build(); } + CreateIncludeSpanRuleRequest convert(IncludeSpanCreateRuleRequest request) { + return CreateIncludeSpanRuleRequest.newBuilder() + .setRuleInfo(convertInput(request.createInput())) + .build(); + } + + private IncludeSpanRuleInfo convertInput(IncludeSpanRuleCreate includeSpanRuleCreate) { + return IncludeSpanRuleInfo.newBuilder() + .setName(includeSpanRuleCreate.name()) + .setFilter(this.filterConverter.convert(includeSpanRuleCreate.spanFilter())) + .setDisabled(includeSpanRuleCreate.disabled()) + .build(); + } + + UpdateIncludeSpanRuleRequest convert(IncludeSpanUpdateRuleRequest request) { + return UpdateIncludeSpanRuleRequest.newBuilder() + .setRule(convertInput(request.updateInput())) + .build(); + } + + private UpdateIncludeSpanRule convertInput(IncludeSpanRuleUpdate includeSpanRuleUpdate) { + return UpdateIncludeSpanRule.newBuilder() + .setId(includeSpanRuleUpdate.id()) + .setName(includeSpanRuleUpdate.name()) + .setFilter(this.filterConverter.convert(includeSpanRuleUpdate.spanFilter())) + .setDisabled(includeSpanRuleUpdate.disabled()) + .build(); + } + + DeleteIncludeSpanRuleRequest convert(IncludeSpanDeleteRuleRequest request) { + return DeleteIncludeSpanRuleRequest.newBuilder().setId(request.id()).build(); + } + CreateApiNamingRuleRequest convert(ApiNamingCreateRuleRequest request) { return CreateApiNamingRuleRequest.newBuilder() .setRuleInfo(convertInput(request.createInput())) diff --git a/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/dao/ConfigServiceSpanProcessingResponseConverter.java b/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/dao/ConfigServiceSpanProcessingResponseConverter.java index 1e37f318..6d4d0415 100644 --- a/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/dao/ConfigServiceSpanProcessingResponseConverter.java +++ b/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/dao/ConfigServiceSpanProcessingResponseConverter.java @@ -11,16 +11,22 @@ 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.query.IncludeSpanRuleResultSet; import org.hypertrace.graphql.spanprocessing.schema.rule.ApiNamingRule; import org.hypertrace.graphql.spanprocessing.schema.rule.ExcludeSpanRule; +import org.hypertrace.graphql.spanprocessing.schema.rule.IncludeSpanRule; 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.CreateIncludeSpanRuleResponse; 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.DeleteIncludeSpanRuleResponse; 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.GetAllIncludeSpanRulesResponse; import org.hypertrace.span.processing.config.service.v1.UpdateApiNamingRuleResponse; import org.hypertrace.span.processing.config.service.v1.UpdateExcludeSpanRuleResponse; +import org.hypertrace.span.processing.config.service.v1.UpdateIncludeSpanRuleResponse; @Slf4j public class ConfigServiceSpanProcessingResponseConverter { @@ -37,6 +43,10 @@ Single convert(GetAllExcludeSpanRulesResponse response return this.convertExcludeSpanRuleResultSet(response.getRuleDetailsList()); } + Single convert(GetAllIncludeSpanRulesResponse response) { + return this.convertIncludeSpanRuleResultSet(response.getRuleDetailsList()); + } + Single convert(GetAllApiNamingRulesResponse response) { return this.convertApiNamingRuleResultSet(response.getRuleDetailsList()); } @@ -49,11 +59,19 @@ private Maybe convertOrDrop( .onErrorComplete(); } + private Maybe convertOrDrop( + org.hypertrace.span.processing.config.service.v1.IncludeSpanRuleDetails ruleDetails) { + return this.ruleConverter + .convert(ruleDetails) + .doOnError(error -> log.error("Error converting IncludeSpanRule", error)) + .onErrorComplete(); + } + private Maybe convertOrDrop( org.hypertrace.span.processing.config.service.v1.ApiNamingRuleDetails ruleDetails) { return this.ruleConverter .convert(ruleDetails) - .doOnError(error -> log.error("Error converting ExcludeSpanRule", error)) + .doOnError(error -> log.error("Error converting ApiNamingRule", error)) .onErrorComplete(); } @@ -65,6 +83,14 @@ private Single convertExcludeSpanRuleResultSet( .map(ConvertedExcludeSpanRuleResultSet::new); } + private Single convertIncludeSpanRuleResultSet( + List ruleDetails) { + return Observable.fromIterable(ruleDetails) + .concatMapMaybe(this::convertOrDrop) + .toList() + .map(ConvertedIncludeSpanRuleResultSet::new); + } + private Single convertApiNamingRuleResultSet( List ruleDetails) { return Observable.fromIterable(ruleDetails) @@ -85,6 +111,18 @@ Single convert(DeleteExcludeSpanRuleResponse r return Single.just(new DefaultDeleteSpanProcessingRuleResponse(true)); } + Single convert(CreateIncludeSpanRuleResponse response) { + return this.ruleConverter.convert(response.getRuleDetails()); + } + + Single convert(UpdateIncludeSpanRuleResponse response) { + return this.ruleConverter.convert(response.getRuleDetails()); + } + + Single convert(DeleteIncludeSpanRuleResponse response) { + return Single.just(new DefaultDeleteSpanProcessingRuleResponse(true)); + } + Single convert(CreateApiNamingRuleResponse response) { return this.ruleConverter.convert(response.getRuleDetails()); } @@ -118,6 +156,20 @@ private ConvertedExcludeSpanRuleResultSet(List results) { } } + @Value + @Accessors(fluent = true) + private static class ConvertedIncludeSpanRuleResultSet implements IncludeSpanRuleResultSet { + List results; + long total; + long count; + + private ConvertedIncludeSpanRuleResultSet(List results) { + this.results = results; + this.count = results.size(); + this.total = results.size(); + } + } + @Value @Accessors(fluent = true) private static class ConvertedApiNamingRuleResultSet implements ApiNamingRuleResultSet { diff --git a/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/dao/ConfigServiceSpanProcessingRuleConverter.java b/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/dao/ConfigServiceSpanProcessingRuleConverter.java index 0e1de001..8387b63c 100644 --- a/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/dao/ConfigServiceSpanProcessingRuleConverter.java +++ b/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/dao/ConfigServiceSpanProcessingRuleConverter.java @@ -5,12 +5,14 @@ import java.util.List; import java.util.NoSuchElementException; import javax.inject.Inject; +import lombok.Builder; 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.IncludeSpanRule; 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; @@ -44,6 +46,28 @@ public Single convert( ruleDetails.getMetadata().getLastUpdatedTimestamp().getNanos()))); } + public Single convert( + org.hypertrace.span.processing.config.service.v1.IncludeSpanRuleDetails ruleDetails) { + return this.filterConverter + .convert(ruleDetails.getRule().getRuleInfo().getFilter()) + .map( + spanProcessingRuleFilter -> + ConvertedIncludeSpanRule.builder() + .id(ruleDetails.getRule().getId()) + .name(ruleDetails.getRule().getRuleInfo().getName()) + .spanFilter(spanProcessingRuleFilter) + .disabled(ruleDetails.getRule().getRuleInfo().getDisabled()) + .creationTime( + Instant.ofEpochSecond( + ruleDetails.getMetadata().getCreationTimestamp().getSeconds(), + ruleDetails.getMetadata().getCreationTimestamp().getNanos())) + .lastUpdatedTime( + Instant.ofEpochSecond( + ruleDetails.getMetadata().getLastUpdatedTimestamp().getSeconds(), + ruleDetails.getMetadata().getLastUpdatedTimestamp().getNanos())) + .build()); + } + public Single convert(ApiNamingRuleDetails ruleDetails) { return this.filterConverter .convert(ruleDetails.getRule().getRuleInfo().getFilter()) @@ -90,6 +114,18 @@ private static class ConvertedExcludeSpanRule implements ExcludeSpanRule { Instant lastUpdatedTime; } + @Value + @Builder + @Accessors(fluent = true) + private static class ConvertedIncludeSpanRule implements IncludeSpanRule { + String id; + String name; + SpanProcessingRuleFilter spanFilter; + boolean disabled; + Instant creationTime; + Instant lastUpdatedTime; + } + @Value @Accessors(fluent = true) private static class ConvertedApiNamingRule implements ApiNamingRule { diff --git a/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/dao/ConfigServiceSpanProcessingRuleDao.java b/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/dao/ConfigServiceSpanProcessingRuleDao.java index d11e51fd..a22ca780 100644 --- a/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/dao/ConfigServiceSpanProcessingRuleDao.java +++ b/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/dao/ConfigServiceSpanProcessingRuleDao.java @@ -15,13 +15,19 @@ 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.request.mutation.IncludeSpanCreateRuleRequest; +import org.hypertrace.graphql.spanprocessing.request.mutation.IncludeSpanDeleteRuleRequest; +import org.hypertrace.graphql.spanprocessing.request.mutation.IncludeSpanUpdateRuleRequest; 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.query.IncludeSpanRuleResultSet; import org.hypertrace.graphql.spanprocessing.schema.rule.ApiNamingRule; import org.hypertrace.graphql.spanprocessing.schema.rule.ExcludeSpanRule; +import org.hypertrace.graphql.spanprocessing.schema.rule.IncludeSpanRule; 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.GetAllIncludeSpanRulesRequest; import org.hypertrace.span.processing.config.service.v1.SpanProcessingConfigServiceGrpc; public class ConfigServiceSpanProcessingRuleDao implements SpanProcessingRuleDao { @@ -109,6 +115,64 @@ public Single deleteExcludeSpanRule( .flatMap(this.responseConverter::convert); } + @Override + public Single getIncludeSpanRules(ContextualRequest request) { + return Single.fromFuture( + this.grpcContextBuilder + .build(request.context()) + .call( + () -> + this.configStub + .withDeadlineAfter( + serviceConfig.getConfigServiceTimeout().toMillis(), MILLISECONDS) + .getAllIncludeSpanRules( + GetAllIncludeSpanRulesRequest.getDefaultInstance()))) + .flatMap(this.responseConverter::convert); + } + + @Override + public Single createIncludeSpanRule(IncludeSpanCreateRuleRequest request) { + return Single.fromFuture( + this.grpcContextBuilder + .build(request.context()) + .call( + () -> + this.configStub + .withDeadlineAfter( + serviceConfig.getConfigServiceTimeout().toMillis(), MILLISECONDS) + .createIncludeSpanRule(this.requestConverter.convert(request)))) + .flatMap(this.responseConverter::convert); + } + + @Override + public Single updateIncludeSpanRule(IncludeSpanUpdateRuleRequest request) { + return Single.fromFuture( + this.grpcContextBuilder + .build(request.context()) + .call( + () -> + this.configStub + .withDeadlineAfter( + serviceConfig.getConfigServiceTimeout().toMillis(), MILLISECONDS) + .updateIncludeSpanRule(this.requestConverter.convert(request)))) + .flatMap(this.responseConverter::convert); + } + + @Override + public Single deleteIncludeSpanRule( + IncludeSpanDeleteRuleRequest request) { + return Single.fromFuture( + this.grpcContextBuilder + .build(request.context()) + .call( + () -> + this.configStub + .withDeadlineAfter( + serviceConfig.getConfigServiceTimeout().toMillis(), MILLISECONDS) + .deleteIncludeSpanRule(this.requestConverter.convert(request)))) + .flatMap(this.responseConverter::convert); + } + @Override public Single getApiNamingRules(ContextualRequest request) { return Single.fromFuture( diff --git a/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/dao/SpanProcessingRuleDao.java b/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/dao/SpanProcessingRuleDao.java index f55015c3..75ad10ae 100644 --- a/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/dao/SpanProcessingRuleDao.java +++ b/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/dao/SpanProcessingRuleDao.java @@ -8,11 +8,16 @@ 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.request.mutation.IncludeSpanCreateRuleRequest; +import org.hypertrace.graphql.spanprocessing.request.mutation.IncludeSpanDeleteRuleRequest; +import org.hypertrace.graphql.spanprocessing.request.mutation.IncludeSpanUpdateRuleRequest; 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.query.IncludeSpanRuleResultSet; import org.hypertrace.graphql.spanprocessing.schema.rule.ApiNamingRule; import org.hypertrace.graphql.spanprocessing.schema.rule.ExcludeSpanRule; +import org.hypertrace.graphql.spanprocessing.schema.rule.IncludeSpanRule; public interface SpanProcessingRuleDao { Single getExcludeSpanRules(ContextualRequest request); @@ -24,6 +29,15 @@ public interface SpanProcessingRuleDao { Single deleteExcludeSpanRule( ExcludeSpanDeleteRuleRequest request); + Single getIncludeSpanRules(ContextualRequest request); + + Single createIncludeSpanRule(IncludeSpanCreateRuleRequest request); + + Single updateIncludeSpanRule(IncludeSpanUpdateRuleRequest request); + + Single deleteIncludeSpanRule( + IncludeSpanDeleteRuleRequest request); + Single getApiNamingRules(ContextualRequest request); Single createApiNamingRule(ApiNamingCreateRuleRequest request); diff --git a/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/deserialization/IncludeSpanCreateInputDeserializationConfig.java b/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/deserialization/IncludeSpanCreateInputDeserializationConfig.java new file mode 100644 index 00000000..c37c677d --- /dev/null +++ b/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/deserialization/IncludeSpanCreateInputDeserializationConfig.java @@ -0,0 +1,49 @@ +package org.hypertrace.graphql.spanprocessing.deserialization; + +import com.fasterxml.jackson.databind.Module; +import com.fasterxml.jackson.databind.module.SimpleModule; +import java.util.List; +import lombok.Builder; +import lombok.Value; +import lombok.experimental.Accessors; +import lombok.extern.jackson.Jacksonized; +import org.hypertrace.core.graphql.deserialization.ArgumentDeserializationConfig; +import org.hypertrace.graphql.spanprocessing.schema.mutation.IncludeSpanRuleCreate; +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; + +public class IncludeSpanCreateInputDeserializationConfig implements ArgumentDeserializationConfig { + @Override + public String getArgumentKey() { + return IncludeSpanRuleCreate.ARGUMENT_NAME; + } + + @Override + public Class getArgumentSchema() { + return IncludeSpanRuleCreate.class; + } + + @Override + public List jacksonModules() { + return List.of( + new SimpleModule() + .addAbstractTypeMapping(IncludeSpanRuleCreate.class, DefaultIncludeSpanRuleCreate.class) + .addAbstractTypeMapping( + SpanProcessingRuleFilter.class, DefaultSpanProcessingRuleFilter.class) + .addAbstractTypeMapping( + SpanProcessingRelationalFilter.class, DefaultSpanProcessingRelationalFilter.class) + .addAbstractTypeMapping( + SpanProcessingLogicalFilter.class, DefaultSpanProcessingLogicalFilter.class)); + } + + @Value + @Accessors(fluent = true) + @Jacksonized + @Builder + private static class DefaultIncludeSpanRuleCreate implements IncludeSpanRuleCreate { + String name; + SpanProcessingRuleFilter spanFilter; + boolean disabled; + } +} diff --git a/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/deserialization/IncludeSpanDeleteInputDeserializationConfig.java b/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/deserialization/IncludeSpanDeleteInputDeserializationConfig.java new file mode 100644 index 00000000..09971cb9 --- /dev/null +++ b/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/deserialization/IncludeSpanDeleteInputDeserializationConfig.java @@ -0,0 +1,39 @@ +package org.hypertrace.graphql.spanprocessing.deserialization; + +import com.fasterxml.jackson.databind.Module; +import com.fasterxml.jackson.databind.module.SimpleModule; +import java.util.List; +import lombok.Builder; +import lombok.Value; +import lombok.experimental.Accessors; +import lombok.extern.jackson.Jacksonized; +import org.hypertrace.core.graphql.deserialization.ArgumentDeserializationConfig; +import org.hypertrace.graphql.spanprocessing.schema.mutation.IncludeSpanRuleDelete; + +public class IncludeSpanDeleteInputDeserializationConfig implements ArgumentDeserializationConfig { + @Override + public String getArgumentKey() { + return IncludeSpanRuleDelete.ARGUMENT_NAME; + } + + @Override + public Class getArgumentSchema() { + return IncludeSpanRuleDelete.class; + } + + @Override + public List jacksonModules() { + return List.of( + new SimpleModule() + .addAbstractTypeMapping( + IncludeSpanRuleDelete.class, DefaultIncludeSpanRuleDelete.class)); + } + + @Value + @Accessors(fluent = true) + @Jacksonized + @Builder + private static class DefaultIncludeSpanRuleDelete implements IncludeSpanRuleDelete { + String id; + } +} diff --git a/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/deserialization/IncludeSpanUpdateInputDeserializationConfig.java b/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/deserialization/IncludeSpanUpdateInputDeserializationConfig.java new file mode 100644 index 00000000..12cf85f3 --- /dev/null +++ b/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/deserialization/IncludeSpanUpdateInputDeserializationConfig.java @@ -0,0 +1,50 @@ +package org.hypertrace.graphql.spanprocessing.deserialization; + +import com.fasterxml.jackson.databind.Module; +import com.fasterxml.jackson.databind.module.SimpleModule; +import java.util.List; +import lombok.Builder; +import lombok.Value; +import lombok.experimental.Accessors; +import lombok.extern.jackson.Jacksonized; +import org.hypertrace.core.graphql.deserialization.ArgumentDeserializationConfig; +import org.hypertrace.graphql.spanprocessing.schema.mutation.IncludeSpanRuleUpdate; +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; + +public class IncludeSpanUpdateInputDeserializationConfig implements ArgumentDeserializationConfig { + @Override + public String getArgumentKey() { + return IncludeSpanRuleUpdate.ARGUMENT_NAME; + } + + @Override + public Class getArgumentSchema() { + return IncludeSpanRuleUpdate.class; + } + + @Override + public List jacksonModules() { + return List.of( + new SimpleModule() + .addAbstractTypeMapping(IncludeSpanRuleUpdate.class, DefaultIncludeSpanRuleUpdate.class) + .addAbstractTypeMapping( + SpanProcessingRuleFilter.class, DefaultSpanProcessingRuleFilter.class) + .addAbstractTypeMapping( + SpanProcessingRelationalFilter.class, DefaultSpanProcessingRelationalFilter.class) + .addAbstractTypeMapping( + SpanProcessingLogicalFilter.class, DefaultSpanProcessingLogicalFilter.class)); + } + + @Value + @Accessors(fluent = true) + @Jacksonized + @Builder + private static class DefaultIncludeSpanRuleUpdate implements IncludeSpanRuleUpdate { + String id; + String name; + SpanProcessingRuleFilter spanFilter; + boolean disabled; + } +} diff --git a/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/deserialization/SpanProcessingDeserializationModule.java b/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/deserialization/SpanProcessingDeserializationModule.java index 52b4ff01..ad1f441f 100644 --- a/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/deserialization/SpanProcessingDeserializationModule.java +++ b/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/deserialization/SpanProcessingDeserializationModule.java @@ -14,6 +14,10 @@ protected void configure() { multibinder.addBinding().to(ExcludeSpanUpdateInputDeserializationConfig.class); multibinder.addBinding().to(ExcludeSpanDeleteInputDeserializationConfig.class); + multibinder.addBinding().to(IncludeSpanCreateInputDeserializationConfig.class); + multibinder.addBinding().to(IncludeSpanUpdateInputDeserializationConfig.class); + multibinder.addBinding().to(IncludeSpanDeleteInputDeserializationConfig.class); + multibinder.addBinding().to(ApiNamingCreateInputDeserializationConfig.class); multibinder.addBinding().to(ApiNamingUpdateInputDeserializationConfig.class); multibinder.addBinding().to(ApiNamingDeleteInputDeserializationConfig.class); diff --git a/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/fetcher/mutation/IncludeSpanCreateRuleMutator.java b/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/fetcher/mutation/IncludeSpanCreateRuleMutator.java new file mode 100644 index 00000000..d05de682 --- /dev/null +++ b/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/fetcher/mutation/IncludeSpanCreateRuleMutator.java @@ -0,0 +1,40 @@ +package org.hypertrace.graphql.spanprocessing.fetcher.mutation; + +import graphql.schema.DataFetcher; +import graphql.schema.DataFetchingEnvironment; +import java.util.concurrent.CompletableFuture; +import javax.inject.Inject; +import org.hypertrace.core.graphql.common.fetcher.InjectableDataFetcher; +import org.hypertrace.graphql.spanprocessing.dao.SpanProcessingRuleDao; +import org.hypertrace.graphql.spanprocessing.request.mutation.IncludeSpanCreateRuleRequestBuilder; +import org.hypertrace.graphql.spanprocessing.schema.rule.IncludeSpanRule; + +public class IncludeSpanCreateRuleMutator extends InjectableDataFetcher { + + public IncludeSpanCreateRuleMutator() { + super(IncludeSpanCreateRuleMutatorImpl.class); + } + + static final class IncludeSpanCreateRuleMutatorImpl + implements DataFetcher> { + private final SpanProcessingRuleDao spanProcessingRuleDao; + private final IncludeSpanCreateRuleRequestBuilder requestBuilder; + + @Inject + IncludeSpanCreateRuleMutatorImpl( + IncludeSpanCreateRuleRequestBuilder requestBuilder, + SpanProcessingRuleDao spanProcessingRuleDao) { + this.requestBuilder = requestBuilder; + this.spanProcessingRuleDao = spanProcessingRuleDao; + } + + @Override + public CompletableFuture get(DataFetchingEnvironment environment) { + return this.requestBuilder + .build(environment.getContext(), environment.getArguments()) + .flatMap(this.spanProcessingRuleDao::createIncludeSpanRule) + .toCompletionStage() + .toCompletableFuture(); + } + } +} diff --git a/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/fetcher/mutation/IncludeSpanDeleteRuleMutator.java b/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/fetcher/mutation/IncludeSpanDeleteRuleMutator.java new file mode 100644 index 00000000..4fc73ff1 --- /dev/null +++ b/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/fetcher/mutation/IncludeSpanDeleteRuleMutator.java @@ -0,0 +1,42 @@ +package org.hypertrace.graphql.spanprocessing.fetcher.mutation; + +import graphql.schema.DataFetcher; +import graphql.schema.DataFetchingEnvironment; +import java.util.concurrent.CompletableFuture; +import javax.inject.Inject; +import org.hypertrace.core.graphql.common.fetcher.InjectableDataFetcher; +import org.hypertrace.graphql.spanprocessing.dao.SpanProcessingRuleDao; +import org.hypertrace.graphql.spanprocessing.request.mutation.IncludeSpanDeleteRuleRequestBuilder; +import org.hypertrace.graphql.spanprocessing.schema.mutation.DeleteSpanProcessingRuleResponse; + +public class IncludeSpanDeleteRuleMutator + extends InjectableDataFetcher { + + public IncludeSpanDeleteRuleMutator() { + super(IncludeSpanDeleteRuleMutatorImpl.class); + } + + static final class IncludeSpanDeleteRuleMutatorImpl + implements DataFetcher> { + private final SpanProcessingRuleDao spanProcessingRuleDao; + private final IncludeSpanDeleteRuleRequestBuilder requestBuilder; + + @Inject + IncludeSpanDeleteRuleMutatorImpl( + IncludeSpanDeleteRuleRequestBuilder requestBuilder, + SpanProcessingRuleDao spanProcessingRuleDao) { + this.requestBuilder = requestBuilder; + this.spanProcessingRuleDao = spanProcessingRuleDao; + } + + @Override + public CompletableFuture get( + DataFetchingEnvironment environment) { + return this.requestBuilder + .build(environment.getContext(), environment.getArguments()) + .flatMap(this.spanProcessingRuleDao::deleteIncludeSpanRule) + .toCompletionStage() + .toCompletableFuture(); + } + } +} diff --git a/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/fetcher/mutation/IncludeSpanUpdateRuleMutator.java b/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/fetcher/mutation/IncludeSpanUpdateRuleMutator.java new file mode 100644 index 00000000..b6a1eb00 --- /dev/null +++ b/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/fetcher/mutation/IncludeSpanUpdateRuleMutator.java @@ -0,0 +1,40 @@ +package org.hypertrace.graphql.spanprocessing.fetcher.mutation; + +import graphql.schema.DataFetcher; +import graphql.schema.DataFetchingEnvironment; +import java.util.concurrent.CompletableFuture; +import javax.inject.Inject; +import org.hypertrace.core.graphql.common.fetcher.InjectableDataFetcher; +import org.hypertrace.graphql.spanprocessing.dao.SpanProcessingRuleDao; +import org.hypertrace.graphql.spanprocessing.request.mutation.IncludeSpanUpdateRuleRequestBuilder; +import org.hypertrace.graphql.spanprocessing.schema.rule.IncludeSpanRule; + +public class IncludeSpanUpdateRuleMutator extends InjectableDataFetcher { + + public IncludeSpanUpdateRuleMutator() { + super(IncludeSpanUpdateRuleMutatorImpl.class); + } + + static final class IncludeSpanUpdateRuleMutatorImpl + implements DataFetcher> { + private final SpanProcessingRuleDao spanProcessingRuleDao; + private final IncludeSpanUpdateRuleRequestBuilder requestBuilder; + + @Inject + IncludeSpanUpdateRuleMutatorImpl( + IncludeSpanUpdateRuleRequestBuilder requestBuilder, + SpanProcessingRuleDao spanProcessingRuleDao) { + this.requestBuilder = requestBuilder; + this.spanProcessingRuleDao = spanProcessingRuleDao; + } + + @Override + public CompletableFuture get(DataFetchingEnvironment environment) { + return this.requestBuilder + .build(environment.getContext(), environment.getArguments()) + .flatMap(this.spanProcessingRuleDao::updateIncludeSpanRule) + .toCompletionStage() + .toCompletableFuture(); + } + } +} diff --git a/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/fetcher/query/IncludeSpanRulesFetcher.java b/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/fetcher/query/IncludeSpanRulesFetcher.java new file mode 100644 index 00000000..daae429f --- /dev/null +++ b/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/fetcher/query/IncludeSpanRulesFetcher.java @@ -0,0 +1,38 @@ +package org.hypertrace.graphql.spanprocessing.fetcher.query; + +import graphql.schema.DataFetcher; +import graphql.schema.DataFetchingEnvironment; +import java.util.concurrent.CompletableFuture; +import javax.inject.Inject; +import org.hypertrace.core.graphql.common.fetcher.InjectableDataFetcher; +import org.hypertrace.core.graphql.common.request.ContextualRequestBuilder; +import org.hypertrace.graphql.spanprocessing.dao.SpanProcessingRuleDao; +import org.hypertrace.graphql.spanprocessing.schema.query.IncludeSpanRuleResultSet; + +public class IncludeSpanRulesFetcher extends InjectableDataFetcher { + + public IncludeSpanRulesFetcher() { + super(IncludeSpanRulesFetcherImpl.class); + } + + static final class IncludeSpanRulesFetcherImpl + implements DataFetcher> { + private final SpanProcessingRuleDao spanProcessingRuleDao; + private final ContextualRequestBuilder requestBuilder; + + @Inject + IncludeSpanRulesFetcherImpl( + ContextualRequestBuilder requestBuilder, SpanProcessingRuleDao spanProcessingRuleDao) { + this.requestBuilder = requestBuilder; + this.spanProcessingRuleDao = spanProcessingRuleDao; + } + + @Override + public CompletableFuture get(DataFetchingEnvironment environment) { + return this.spanProcessingRuleDao + .getIncludeSpanRules(this.requestBuilder.build(environment.getContext())) + .toCompletionStage() + .toCompletableFuture(); + } + } +} diff --git a/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/request/mutation/DefaultIncludeSpanCreateRuleRequestBuilder.java b/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/request/mutation/DefaultIncludeSpanCreateRuleRequestBuilder.java new file mode 100644 index 00000000..f8b1c9d1 --- /dev/null +++ b/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/request/mutation/DefaultIncludeSpanCreateRuleRequestBuilder.java @@ -0,0 +1,39 @@ +package org.hypertrace.graphql.spanprocessing.request.mutation; + +import io.reactivex.rxjava3.core.Single; +import java.util.Map; +import javax.inject.Inject; +import lombok.Value; +import lombok.experimental.Accessors; +import org.hypertrace.core.graphql.context.GraphQlRequestContext; +import org.hypertrace.core.graphql.deserialization.ArgumentDeserializer; +import org.hypertrace.graphql.spanprocessing.schema.mutation.IncludeSpanRuleCreate; + +public class DefaultIncludeSpanCreateRuleRequestBuilder + implements IncludeSpanCreateRuleRequestBuilder { + + private final ArgumentDeserializer argumentDeserializer; + + @Inject + DefaultIncludeSpanCreateRuleRequestBuilder(ArgumentDeserializer argumentDeserializer) { + this.argumentDeserializer = argumentDeserializer; + } + + @Override + public Single build( + GraphQlRequestContext context, Map arguments) { + IncludeSpanRuleCreate includeSpanRuleCreateInput = + this.argumentDeserializer + .deserializeObject(arguments, IncludeSpanRuleCreate.class) + .orElseThrow(); + return Single.just( + new DefaultIncludeSpanCreateRuleRequest(context, includeSpanRuleCreateInput)); + } + + @Value + @Accessors(fluent = true) + private static class DefaultIncludeSpanCreateRuleRequest implements IncludeSpanCreateRuleRequest { + GraphQlRequestContext context; + IncludeSpanRuleCreate createInput; + } +} diff --git a/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/request/mutation/DefaultIncludeSpanDeleteRuleRequestBuilder.java b/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/request/mutation/DefaultIncludeSpanDeleteRuleRequestBuilder.java new file mode 100644 index 00000000..b90cb257 --- /dev/null +++ b/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/request/mutation/DefaultIncludeSpanDeleteRuleRequestBuilder.java @@ -0,0 +1,39 @@ +package org.hypertrace.graphql.spanprocessing.request.mutation; + +import io.reactivex.rxjava3.core.Single; +import java.util.Map; +import javax.inject.Inject; +import lombok.Value; +import lombok.experimental.Accessors; +import org.hypertrace.core.graphql.context.GraphQlRequestContext; +import org.hypertrace.core.graphql.deserialization.ArgumentDeserializer; +import org.hypertrace.graphql.spanprocessing.schema.mutation.IncludeSpanRuleDelete; + +public class DefaultIncludeSpanDeleteRuleRequestBuilder + implements IncludeSpanDeleteRuleRequestBuilder { + + private final ArgumentDeserializer argumentDeserializer; + + @Inject + DefaultIncludeSpanDeleteRuleRequestBuilder(ArgumentDeserializer argumentDeserializer) { + this.argumentDeserializer = argumentDeserializer; + } + + @Override + public Single build( + GraphQlRequestContext context, Map arguments) { + String idToDelete = + this.argumentDeserializer + .deserializeObject(arguments, IncludeSpanRuleDelete.class) + .map(IncludeSpanRuleDelete::id) + .orElseThrow(); + return Single.just(new DefaultIncludeSpanDeleteRuleRequest(context, idToDelete)); + } + + @Value + @Accessors(fluent = true) + private static class DefaultIncludeSpanDeleteRuleRequest implements IncludeSpanDeleteRuleRequest { + GraphQlRequestContext context; + String id; + } +} diff --git a/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/request/mutation/DefaultIncludeSpanUpdateRuleRequestBuilder.java b/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/request/mutation/DefaultIncludeSpanUpdateRuleRequestBuilder.java new file mode 100644 index 00000000..e0d6cc23 --- /dev/null +++ b/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/request/mutation/DefaultIncludeSpanUpdateRuleRequestBuilder.java @@ -0,0 +1,39 @@ +package org.hypertrace.graphql.spanprocessing.request.mutation; + +import io.reactivex.rxjava3.core.Single; +import java.util.Map; +import javax.inject.Inject; +import lombok.Value; +import lombok.experimental.Accessors; +import org.hypertrace.core.graphql.context.GraphQlRequestContext; +import org.hypertrace.core.graphql.deserialization.ArgumentDeserializer; +import org.hypertrace.graphql.spanprocessing.schema.mutation.IncludeSpanRuleUpdate; + +public class DefaultIncludeSpanUpdateRuleRequestBuilder + implements IncludeSpanUpdateRuleRequestBuilder { + + private final ArgumentDeserializer argumentDeserializer; + + @Inject + DefaultIncludeSpanUpdateRuleRequestBuilder(ArgumentDeserializer argumentDeserializer) { + this.argumentDeserializer = argumentDeserializer; + } + + @Override + public Single build( + GraphQlRequestContext context, Map arguments) { + IncludeSpanRuleUpdate includeSpanRuleUpdateInput = + this.argumentDeserializer + .deserializeObject(arguments, IncludeSpanRuleUpdate.class) + .orElseThrow(); + return Single.just( + new DefaultIncludeSpanUpdateRuleRequest(context, includeSpanRuleUpdateInput)); + } + + @Value + @Accessors(fluent = true) + private static class DefaultIncludeSpanUpdateRuleRequest implements IncludeSpanUpdateRuleRequest { + GraphQlRequestContext context; + IncludeSpanRuleUpdate updateInput; + } +} diff --git a/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/request/mutation/IncludeSpanCreateRuleRequest.java b/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/request/mutation/IncludeSpanCreateRuleRequest.java new file mode 100644 index 00000000..68668d0f --- /dev/null +++ b/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/request/mutation/IncludeSpanCreateRuleRequest.java @@ -0,0 +1,10 @@ +package org.hypertrace.graphql.spanprocessing.request.mutation; + +import org.hypertrace.core.graphql.context.GraphQlRequestContext; +import org.hypertrace.graphql.spanprocessing.schema.mutation.IncludeSpanRuleCreate; + +public interface IncludeSpanCreateRuleRequest { + GraphQlRequestContext context(); + + IncludeSpanRuleCreate createInput(); +} diff --git a/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/request/mutation/IncludeSpanCreateRuleRequestBuilder.java b/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/request/mutation/IncludeSpanCreateRuleRequestBuilder.java new file mode 100644 index 00000000..a12a7aa4 --- /dev/null +++ b/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/request/mutation/IncludeSpanCreateRuleRequestBuilder.java @@ -0,0 +1,10 @@ +package org.hypertrace.graphql.spanprocessing.request.mutation; + +import io.reactivex.rxjava3.core.Single; +import java.util.Map; +import org.hypertrace.core.graphql.context.GraphQlRequestContext; + +public interface IncludeSpanCreateRuleRequestBuilder { + Single build( + GraphQlRequestContext context, Map arguments); +} diff --git a/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/request/mutation/IncludeSpanDeleteRuleRequest.java b/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/request/mutation/IncludeSpanDeleteRuleRequest.java new file mode 100644 index 00000000..b907f27b --- /dev/null +++ b/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/request/mutation/IncludeSpanDeleteRuleRequest.java @@ -0,0 +1,9 @@ +package org.hypertrace.graphql.spanprocessing.request.mutation; + +import org.hypertrace.core.graphql.context.GraphQlRequestContext; + +public interface IncludeSpanDeleteRuleRequest { + GraphQlRequestContext context(); + + String id(); +} diff --git a/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/request/mutation/IncludeSpanDeleteRuleRequestBuilder.java b/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/request/mutation/IncludeSpanDeleteRuleRequestBuilder.java new file mode 100644 index 00000000..d0d3e0fb --- /dev/null +++ b/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/request/mutation/IncludeSpanDeleteRuleRequestBuilder.java @@ -0,0 +1,10 @@ +package org.hypertrace.graphql.spanprocessing.request.mutation; + +import io.reactivex.rxjava3.core.Single; +import java.util.Map; +import org.hypertrace.core.graphql.context.GraphQlRequestContext; + +public interface IncludeSpanDeleteRuleRequestBuilder { + Single build( + GraphQlRequestContext context, Map arguments); +} diff --git a/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/request/mutation/IncludeSpanUpdateRuleRequest.java b/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/request/mutation/IncludeSpanUpdateRuleRequest.java new file mode 100644 index 00000000..c6e4c3a9 --- /dev/null +++ b/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/request/mutation/IncludeSpanUpdateRuleRequest.java @@ -0,0 +1,10 @@ +package org.hypertrace.graphql.spanprocessing.request.mutation; + +import org.hypertrace.core.graphql.context.GraphQlRequestContext; +import org.hypertrace.graphql.spanprocessing.schema.mutation.IncludeSpanRuleUpdate; + +public interface IncludeSpanUpdateRuleRequest { + GraphQlRequestContext context(); + + IncludeSpanRuleUpdate updateInput(); +} diff --git a/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/request/mutation/IncludeSpanUpdateRuleRequestBuilder.java b/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/request/mutation/IncludeSpanUpdateRuleRequestBuilder.java new file mode 100644 index 00000000..ab20a8f4 --- /dev/null +++ b/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/request/mutation/IncludeSpanUpdateRuleRequestBuilder.java @@ -0,0 +1,10 @@ +package org.hypertrace.graphql.spanprocessing.request.mutation; + +import io.reactivex.rxjava3.core.Single; +import java.util.Map; +import org.hypertrace.core.graphql.context.GraphQlRequestContext; + +public interface IncludeSpanUpdateRuleRequestBuilder { + Single build( + GraphQlRequestContext context, Map arguments); +} diff --git a/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/request/mutation/SpanProcessingMutationRequestModule.java b/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/request/mutation/SpanProcessingMutationRequestModule.java index 46222433..7ae24424 100644 --- a/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/request/mutation/SpanProcessingMutationRequestModule.java +++ b/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/request/mutation/SpanProcessingMutationRequestModule.java @@ -14,6 +14,13 @@ protected void configure() { bind(ExcludeSpanDeleteRuleRequestBuilder.class) .to(DefaultExcludeSpanDeleteRuleRequestBuilder.class); + bind(IncludeSpanCreateRuleRequestBuilder.class) + .to(DefaultIncludeSpanCreateRuleRequestBuilder.class); + bind(IncludeSpanUpdateRuleRequestBuilder.class) + .to(DefaultIncludeSpanUpdateRuleRequestBuilder.class); + bind(IncludeSpanDeleteRuleRequestBuilder.class) + .to(DefaultIncludeSpanDeleteRuleRequestBuilder.class); + bind(ApiNamingCreateRuleRequestBuilder.class) .to(DefaultApiNamingCreateRuleRequestBuilder.class); bind(ApiNamingUpdateRuleRequestBuilder.class) diff --git a/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/schema/mutation/IncludeSpanRuleCreate.java b/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/schema/mutation/IncludeSpanRuleCreate.java new file mode 100644 index 00000000..08d628bd --- /dev/null +++ b/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/schema/mutation/IncludeSpanRuleCreate.java @@ -0,0 +1,10 @@ +package org.hypertrace.graphql.spanprocessing.schema.mutation; + +import graphql.annotations.annotationTypes.GraphQLName; +import org.hypertrace.graphql.spanprocessing.schema.rule.IncludeSpanRuleInfo; + +@GraphQLName(IncludeSpanRuleCreate.TYPE_NAME) +public interface IncludeSpanRuleCreate extends IncludeSpanRuleInfo { + String TYPE_NAME = "IncludeSpanRuleCreate"; + String ARGUMENT_NAME = "input"; +} diff --git a/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/schema/mutation/IncludeSpanRuleDelete.java b/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/schema/mutation/IncludeSpanRuleDelete.java new file mode 100644 index 00000000..f175e862 --- /dev/null +++ b/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/schema/mutation/IncludeSpanRuleDelete.java @@ -0,0 +1,10 @@ +package org.hypertrace.graphql.spanprocessing.schema.mutation; + +import graphql.annotations.annotationTypes.GraphQLName; +import org.hypertrace.core.graphql.common.schema.id.Identifiable; + +@GraphQLName(IncludeSpanRuleDelete.TYPE_NAME) +public interface IncludeSpanRuleDelete extends Identifiable { + String TYPE_NAME = "IncludeSpanRuleDelete"; + String ARGUMENT_NAME = "input"; +} diff --git a/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/schema/mutation/IncludeSpanRuleUpdate.java b/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/schema/mutation/IncludeSpanRuleUpdate.java new file mode 100644 index 00000000..9a4351fa --- /dev/null +++ b/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/schema/mutation/IncludeSpanRuleUpdate.java @@ -0,0 +1,32 @@ +package org.hypertrace.graphql.spanprocessing.schema.mutation; + +import graphql.annotations.annotationTypes.GraphQLField; +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.filter.SpanProcessingRuleFilter; + +@GraphQLName(IncludeSpanRuleUpdate.TYPE_NAME) +public interface IncludeSpanRuleUpdate extends Identifiable { + String TYPE_NAME = "IncludeSpanRuleUpdate"; + String ARGUMENT_NAME = "input"; + + String NAME_KEY = "name"; + String SPAN_PROCESSING_FILTER_KEY = "spanFilter"; + String DISABLED_KEY = "disabled"; + + @GraphQLField + @GraphQLName(NAME_KEY) + @GraphQLNonNull + String name(); + + @GraphQLField + @GraphQLName(SPAN_PROCESSING_FILTER_KEY) + @GraphQLNonNull + SpanProcessingRuleFilter spanFilter(); + + @GraphQLField + @GraphQLName(DISABLED_KEY) + @GraphQLNonNull + boolean disabled(); +} diff --git a/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/schema/mutation/SpanProcessingMutationSchema.java b/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/schema/mutation/SpanProcessingMutationSchema.java index ba9eea2a..2fd06aa9 100644 --- a/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/schema/mutation/SpanProcessingMutationSchema.java +++ b/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/schema/mutation/SpanProcessingMutationSchema.java @@ -10,13 +10,20 @@ import org.hypertrace.graphql.spanprocessing.fetcher.mutation.ExcludeSpanCreateRuleMutator; import org.hypertrace.graphql.spanprocessing.fetcher.mutation.ExcludeSpanDeleteRuleMutator; import org.hypertrace.graphql.spanprocessing.fetcher.mutation.ExcludeSpanUpdateRuleMutator; +import org.hypertrace.graphql.spanprocessing.fetcher.mutation.IncludeSpanCreateRuleMutator; +import org.hypertrace.graphql.spanprocessing.fetcher.mutation.IncludeSpanDeleteRuleMutator; +import org.hypertrace.graphql.spanprocessing.fetcher.mutation.IncludeSpanUpdateRuleMutator; import org.hypertrace.graphql.spanprocessing.schema.rule.ApiNamingRule; import org.hypertrace.graphql.spanprocessing.schema.rule.ExcludeSpanRule; +import org.hypertrace.graphql.spanprocessing.schema.rule.IncludeSpanRule; public interface SpanProcessingMutationSchema { String CREATE_EXCLUDE_SPAN_RULE_MUTATION_NAME = "createExcludeSpanRule"; String UPDATE_EXCLUDE_SPAN_RULE_MUTATION_NAME = "updateExcludeSpanRule"; String DELETE_EXCLUDE_SPAN_RULE_MUTATION_NAME = "deleteExcludeSpanRule"; + String CREATE_INCLUDE_SPAN_RULE_MUTATION_NAME = "createIncludeSpanRule"; + String UPDATE_INCLUDE_SPAN_RULE_MUTATION_NAME = "updateIncludeSpanRule"; + String DELETE_INCLUDE_SPAN_RULE_MUTATION_NAME = "deleteIncludeSpanRule"; String CREATE_API_NAMING_RULE_MUTATION_NAME = "createApiNamingRule"; String UPDATE_API_NAMING_RULE_MUTATION_NAME = "updateApiNamingRule"; String DELETE_API_NAMING_RULE_MUTATION_NAME = "deleteApiNamingRule"; @@ -45,6 +52,30 @@ DeleteSpanProcessingRuleResponse deleteExcludeSpanRule( @GraphQLName(ExcludeSpanRuleDelete.ARGUMENT_NAME) @GraphQLNonNull ExcludeSpanRuleDelete input); + @GraphQLField + @GraphQLName(CREATE_INCLUDE_SPAN_RULE_MUTATION_NAME) + @GraphQLNonNull + @GraphQLDataFetcher(IncludeSpanCreateRuleMutator.class) + IncludeSpanRule createIncludeSpanRule( + @GraphQLName(IncludeSpanRuleCreate.ARGUMENT_NAME) @GraphQLNonNull + IncludeSpanRuleCreate input); + + @GraphQLField + @GraphQLName(UPDATE_INCLUDE_SPAN_RULE_MUTATION_NAME) + @GraphQLNonNull + @GraphQLDataFetcher(IncludeSpanUpdateRuleMutator.class) + IncludeSpanRule updateIncludeSpanRule( + @GraphQLName(IncludeSpanRuleUpdate.ARGUMENT_NAME) @GraphQLNonNull + IncludeSpanRuleUpdate input); + + @GraphQLField + @GraphQLName(DELETE_INCLUDE_SPAN_RULE_MUTATION_NAME) + @GraphQLNonNull + @GraphQLDataFetcher(IncludeSpanDeleteRuleMutator.class) + DeleteSpanProcessingRuleResponse deleteIncludeSpanRule( + @GraphQLName(IncludeSpanRuleDelete.ARGUMENT_NAME) @GraphQLNonNull + IncludeSpanRuleDelete input); + @GraphQLField @GraphQLName(CREATE_API_NAMING_RULE_MUTATION_NAME) @GraphQLNonNull diff --git a/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/schema/query/IncludeSpanRuleResultSet.java b/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/schema/query/IncludeSpanRuleResultSet.java new file mode 100644 index 00000000..3a43af08 --- /dev/null +++ b/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/schema/query/IncludeSpanRuleResultSet.java @@ -0,0 +1,19 @@ +package org.hypertrace.graphql.spanprocessing.schema.query; + +import graphql.annotations.annotationTypes.GraphQLField; +import graphql.annotations.annotationTypes.GraphQLName; +import graphql.annotations.annotationTypes.GraphQLNonNull; +import java.util.List; +import org.hypertrace.core.graphql.common.schema.results.ResultSet; +import org.hypertrace.graphql.spanprocessing.schema.rule.IncludeSpanRule; + +@GraphQLName(IncludeSpanRuleResultSet.TYPE_NAME) +public interface IncludeSpanRuleResultSet extends ResultSet { + String TYPE_NAME = "IncludeSpanRuleResultSet"; + + @Override + @GraphQLField + @GraphQLNonNull + @GraphQLName(RESULT_SET_RESULTS_NAME) + List results(); +} diff --git a/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/schema/query/SpanProcessingQuerySchema.java b/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/schema/query/SpanProcessingQuerySchema.java index 5163ff51..ec042df9 100644 --- a/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/schema/query/SpanProcessingQuerySchema.java +++ b/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/schema/query/SpanProcessingQuerySchema.java @@ -6,9 +6,11 @@ import graphql.annotations.annotationTypes.GraphQLNonNull; import org.hypertrace.graphql.spanprocessing.fetcher.query.ApiNamingRulesFetcher; import org.hypertrace.graphql.spanprocessing.fetcher.query.ExcludeSpanRulesFetcher; +import org.hypertrace.graphql.spanprocessing.fetcher.query.IncludeSpanRulesFetcher; public interface SpanProcessingQuerySchema { String EXCLUDE_SPAN_RULES_QUERY_NAME = "excludeSpanRules"; + String INCLUDE_SPAN_RULES_QUERY_NAME = "includeSpanRules"; String API_NAMING_RULES_QUERY_NAME = "apiNamingRules"; @GraphQLField @@ -17,6 +19,12 @@ public interface SpanProcessingQuerySchema { @GraphQLDataFetcher(ExcludeSpanRulesFetcher.class) ExcludeSpanRuleResultSet excludeSpanRules(); + @GraphQLField + @GraphQLNonNull + @GraphQLName(INCLUDE_SPAN_RULES_QUERY_NAME) + @GraphQLDataFetcher(IncludeSpanRulesFetcher.class) + IncludeSpanRuleResultSet includeSpanRules(); + @GraphQLField @GraphQLNonNull @GraphQLName(API_NAMING_RULES_QUERY_NAME) diff --git a/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/schema/rule/IncludeSpanRule.java b/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/schema/rule/IncludeSpanRule.java new file mode 100644 index 00000000..0045fcbf --- /dev/null +++ b/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/schema/rule/IncludeSpanRule.java @@ -0,0 +1,25 @@ +package org.hypertrace.graphql.spanprocessing.schema.rule; + +import graphql.annotations.annotationTypes.GraphQLField; +import graphql.annotations.annotationTypes.GraphQLName; +import graphql.annotations.annotationTypes.GraphQLNonNull; +import java.time.Instant; +import org.hypertrace.core.graphql.common.schema.id.Identifiable; + +@GraphQLName(IncludeSpanRule.TYPE_NAME) +public interface IncludeSpanRule extends Identifiable, IncludeSpanRuleInfo { + String TYPE_NAME = "IncludeSpanRule"; + + String CREATION_TIME_KEY = "creationTime"; + String LAST_UPDATED_TIME_KEY = "lastUpdatedTime"; + + @GraphQLField + @GraphQLName(CREATION_TIME_KEY) + @GraphQLNonNull + Instant creationTime(); + + @GraphQLField + @GraphQLName(LAST_UPDATED_TIME_KEY) + @GraphQLNonNull + Instant lastUpdatedTime(); +} diff --git a/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/schema/rule/IncludeSpanRuleInfo.java b/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/schema/rule/IncludeSpanRuleInfo.java new file mode 100644 index 00000000..e1c6c916 --- /dev/null +++ b/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/schema/rule/IncludeSpanRuleInfo.java @@ -0,0 +1,30 @@ +package org.hypertrace.graphql.spanprocessing.schema.rule; + +import graphql.annotations.annotationTypes.GraphQLField; +import graphql.annotations.annotationTypes.GraphQLName; +import graphql.annotations.annotationTypes.GraphQLNonNull; +import org.hypertrace.graphql.spanprocessing.schema.rule.filter.SpanProcessingRuleFilter; + +@GraphQLName(IncludeSpanRuleInfo.TYPE_NAME) +public interface IncludeSpanRuleInfo { + String TYPE_NAME = "IncludeSpanRuleInfo"; + + String NAME_KEY = "name"; + String SPAN_FILTER_KEY = "spanFilter"; + String DISABLED_KEY = "disabled"; + + @GraphQLField + @GraphQLName(NAME_KEY) + @GraphQLNonNull + String name(); + + @GraphQLField + @GraphQLName(SPAN_FILTER_KEY) + @GraphQLNonNull + SpanProcessingRuleFilter spanFilter(); + + @GraphQLField + @GraphQLName(DISABLED_KEY) + @GraphQLNonNull + boolean disabled(); +}