diff --git a/hypertrace-graphql-platform/build.gradle.kts b/hypertrace-graphql-platform/build.gradle.kts index cfd18881..3d8c9fe0 100644 --- a/hypertrace-graphql-platform/build.gradle.kts +++ b/hypertrace-graphql-platform/build.gradle.kts @@ -13,5 +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.23") } } diff --git a/hypertrace-graphql-span-processing-schema/build.gradle.kts b/hypertrace-graphql-span-processing-schema/build.gradle.kts new file mode 100644 index 00000000..32bc3414 --- /dev/null +++ b/hypertrace-graphql-span-processing-schema/build.gradle.kts @@ -0,0 +1,24 @@ +plugins { + `java-library` + jacoco + id("org.hypertrace.jacoco-report-plugin") +} + +dependencies { + api("com.google.inject:guice") + api("com.graphql-java:graphql-java") + api("org.hypertrace.core.graphql:hypertrace-core-graphql-common-schema") + api("org.hypertrace.core.graphql:hypertrace-core-graphql-spi") + api("io.github.graphql-java:graphql-java-annotations") + + annotationProcessor("org.projectlombok:lombok") + compileOnly("org.projectlombok:lombok") + + implementation(project(":hypertrace-graphql-service-config")) + implementation("org.hypertrace.config.service:span-processing-config-service-api") + implementation("org.hypertrace.core.graphql:hypertrace-core-graphql-context") + implementation("org.hypertrace.core.graphql:hypertrace-core-graphql-grpc-utils") + implementation("org.hypertrace.core.graphql:hypertrace-core-graphql-deserialization") + implementation("org.slf4j:slf4j-api") + implementation("io.reactivex.rxjava3:rxjava") +} diff --git a/hypertrace-graphql-span-processing-schema/src/main/java/SpanProcessingSchemaFragment.java b/hypertrace-graphql-span-processing-schema/src/main/java/SpanProcessingSchemaFragment.java new file mode 100644 index 00000000..e73b5d0e --- /dev/null +++ b/hypertrace-graphql-span-processing-schema/src/main/java/SpanProcessingSchemaFragment.java @@ -0,0 +1,23 @@ +import javax.annotation.Nullable; +import org.hypertrace.core.graphql.spi.schema.GraphQlSchemaFragment; +import org.hypertrace.graphql.spanprocessing.schema.mutation.SpanProcessingMutationSchema; +import org.hypertrace.graphql.spanprocessing.schema.query.SpanProcessingQuerySchema; + +public class SpanProcessingSchemaFragment implements GraphQlSchemaFragment { + + @Override + public String fragmentName() { + return "Span Processing schema"; + } + + @Override + public Class annotatedQueryClass() { + return SpanProcessingQuerySchema.class; + } + + @Nullable + @Override + public Class annotatedMutationClass() { + return SpanProcessingMutationSchema.class; + } +} diff --git a/hypertrace-graphql-span-processing-schema/src/main/java/SpanProcessingSchemaModule.java b/hypertrace-graphql-span-processing-schema/src/main/java/SpanProcessingSchemaModule.java new file mode 100644 index 00000000..14229b73 --- /dev/null +++ b/hypertrace-graphql-span-processing-schema/src/main/java/SpanProcessingSchemaModule.java @@ -0,0 +1,19 @@ +import com.google.inject.AbstractModule; +import com.google.inject.multibindings.Multibinder; +import org.hypertrace.core.graphql.spi.schema.GraphQlSchemaFragment; +import org.hypertrace.graphql.spanprocessing.dao.SpanProcessingDaoModule; +import org.hypertrace.graphql.spanprocessing.deserialization.SpanProcessingDeserializationModule; +import org.hypertrace.graphql.spanprocessing.request.mutation.SpanProcessingMutationRequestModule; + +public class SpanProcessingSchemaModule extends AbstractModule { + @Override + protected void configure() { + Multibinder.newSetBinder(binder(), GraphQlSchemaFragment.class) + .addBinding() + .to(SpanProcessingSchemaFragment.class); + + install(new SpanProcessingMutationRequestModule()); + install(new SpanProcessingDaoModule()); + install(new SpanProcessingDeserializationModule()); + } +} diff --git a/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/dao/ConfigServiceSpanFilterConverter.java b/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/dao/ConfigServiceSpanFilterConverter.java new file mode 100644 index 00000000..aabfabb6 --- /dev/null +++ b/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/dao/ConfigServiceSpanFilterConverter.java @@ -0,0 +1,210 @@ +package org.hypertrace.graphql.spanprocessing.dao; + +import com.google.common.collect.ImmutableBiMap; +import io.reactivex.rxjava3.core.Single; +import java.util.List; +import java.util.NoSuchElementException; +import java.util.Objects; +import java.util.stream.Collectors; +import lombok.Value; +import lombok.experimental.Accessors; +import org.hypertrace.graphql.spanprocessing.schema.rule.filter.SpanProcessingFilterField; +import org.hypertrace.graphql.spanprocessing.schema.rule.filter.SpanProcessingLogicalFilter; +import org.hypertrace.graphql.spanprocessing.schema.rule.filter.SpanProcessingLogicalOperator; +import org.hypertrace.graphql.spanprocessing.schema.rule.filter.SpanProcessingRelationalFilter; +import org.hypertrace.graphql.spanprocessing.schema.rule.filter.SpanProcessingRelationalOperator; +import org.hypertrace.graphql.spanprocessing.schema.rule.filter.SpanProcessingRuleFilter; +import org.hypertrace.span.processing.config.service.v1.Field; +import org.hypertrace.span.processing.config.service.v1.LogicalOperator; +import org.hypertrace.span.processing.config.service.v1.LogicalSpanFilterExpression; +import org.hypertrace.span.processing.config.service.v1.RelationalOperator; +import org.hypertrace.span.processing.config.service.v1.RelationalSpanFilterExpression; +import org.hypertrace.span.processing.config.service.v1.SpanFilter; +import org.hypertrace.span.processing.config.service.v1.SpanFilterValue; + +public class ConfigServiceSpanFilterConverter { + + private static final ImmutableBiMap + LOGICAL_OPERATOR_OPERATOR_BI_MAP = + ImmutableBiMap.of( + LogicalOperator.LOGICAL_OPERATOR_AND, + SpanProcessingLogicalOperator.AND, + LogicalOperator.LOGICAL_OPERATOR_OR, + SpanProcessingLogicalOperator.OR); + + private static final ImmutableBiMap + OPERATOR_LOGICAL_OPERATOR_IMMUTABLE_BI_MAP = LOGICAL_OPERATOR_OPERATOR_BI_MAP.inverse(); + + private static final ImmutableBiMap + RELATIONAL_OPERATOR_OPERATOR_BI_MAP = + ImmutableBiMap.builder() + .put( + RelationalOperator.RELATIONAL_OPERATOR_CONTAINS, + SpanProcessingRelationalOperator.CONTAINS) + .put( + RelationalOperator.RELATIONAL_OPERATOR_EQUALS, + SpanProcessingRelationalOperator.EQUALS) + .put( + RelationalOperator.RELATIONAL_OPERATOR_NOT_EQUALS, + SpanProcessingRelationalOperator.NOT_EQUALS) + .put( + RelationalOperator.RELATIONAL_OPERATOR_STARTS_WITH, + SpanProcessingRelationalOperator.STARTS_WITH) + .put( + RelationalOperator.RELATIONAL_OPERATOR_ENDS_WITH, + SpanProcessingRelationalOperator.ENDS_WITH) + .put( + RelationalOperator.RELATIONAL_OPERATOR_REGEX_MATCH, + SpanProcessingRelationalOperator.REGEX_MATCH) + .build(); + + private static final ImmutableBiMap + OPERATOR_RELATIONAL_OPERATOR_IMMUTABLE_BI_MAP = RELATIONAL_OPERATOR_OPERATOR_BI_MAP.inverse(); + + private static final ImmutableBiMap + FIELD_FILTER_FIELD_IMMUTABLE_BI_MAP = + ImmutableBiMap.builder() + .put(Field.FIELD_URL, SpanProcessingFilterField.URL) + .put(Field.FIELD_SERVICE_NAME, SpanProcessingFilterField.SERVICE_NAME) + .put(Field.FIELD_ENVIRONMENT_NAME, SpanProcessingFilterField.ENVIRONMENT_NAME) + .build(); + + private static final ImmutableBiMap + FILTER_FIELD_FIELD_IMMUTABLE_BI_MAP = FIELD_FILTER_FIELD_IMMUTABLE_BI_MAP.inverse(); + + public Single convert(SpanFilter filter) { + return Single.just(Objects.requireNonNull(convertFilter(filter))); + } + + public SpanFilter convert(SpanProcessingRuleFilter filter) { + if (filter == null) { + return null; + } + SpanFilter.Builder spanFilterBuilder = SpanFilter.newBuilder(); + if (filter.logicalSpanFilter() != null) { + spanFilterBuilder = + spanFilterBuilder.setLogicalSpanFilter(convertLogicalFilter(filter.logicalSpanFilter())); + } else if (filter.relationalSpanFilter() != null) { + spanFilterBuilder = + spanFilterBuilder.setRelationalSpanFilter( + convertRelationalFilter(filter.relationalSpanFilter())); + } + return spanFilterBuilder.build(); + } + + private SpanProcessingRuleFilter convertFilter(SpanFilter filter) { + if (filter.equals(SpanFilter.getDefaultInstance())) { + return null; + } + return new ConvertedSpanProcessingRuleFilter( + this.convertLogicalFilter(filter.getLogicalSpanFilter()), + this.convertRelationalFilter(filter.getRelationalSpanFilter())); + } + + private SpanProcessingLogicalFilter convertLogicalFilter( + LogicalSpanFilterExpression logicalSpanFilterExpression) { + if (logicalSpanFilterExpression.equals(LogicalSpanFilterExpression.getDefaultInstance())) { + return null; + } + return new ConvertedSpanProcessingLogicalFilter( + LOGICAL_OPERATOR_OPERATOR_BI_MAP.get(logicalSpanFilterExpression.getOperator()), + logicalSpanFilterExpression.getOperandsList().stream() + .map(this::convertFilter) + .collect(Collectors.toUnmodifiableList())); + } + + private LogicalSpanFilterExpression convertLogicalFilter( + SpanProcessingLogicalFilter spanProcessingLogicalFilter) { + return LogicalSpanFilterExpression.newBuilder() + .setOperator( + Objects.requireNonNull( + OPERATOR_LOGICAL_OPERATOR_IMMUTABLE_BI_MAP.get( + spanProcessingLogicalFilter.logicalOperator()))) + .addAllOperands( + spanProcessingLogicalFilter.spanFilters().stream() + .map(this::convert) + .collect(Collectors.toUnmodifiableList())) + .build(); + } + + private SpanProcessingRelationalFilter convertRelationalFilter( + RelationalSpanFilterExpression relationalSpanFilterExpression) { + if (relationalSpanFilterExpression.equals( + RelationalSpanFilterExpression.getDefaultInstance())) { + return null; + } + return new ConvertedSpanProcessingRelationalFilter( + RELATIONAL_OPERATOR_OPERATOR_BI_MAP.get(relationalSpanFilterExpression.getOperator()), + relationalSpanFilterExpression.hasSpanAttributeKey() + ? relationalSpanFilterExpression.getSpanAttributeKey() + : null, + relationalSpanFilterExpression.hasField() + ? FIELD_FILTER_FIELD_IMMUTABLE_BI_MAP.get(relationalSpanFilterExpression.getField()) + : null, + convertSpanFilterValue(relationalSpanFilterExpression.getRightOperand())); + } + + private Object convertSpanFilterValue(SpanFilterValue spanFilterValue) { + switch (spanFilterValue.getValueCase()) { + case STRING_VALUE: + return spanFilterValue.getStringValue(); + default: + throw new NoSuchElementException("Unsupported right operand type"); + } + } + + private RelationalSpanFilterExpression convertRelationalFilter( + SpanProcessingRelationalFilter spanProcessingRelationalFilter) { + RelationalSpanFilterExpression.Builder relationalSpanFilterExpressionBuilder = + RelationalSpanFilterExpression.newBuilder() + .setOperator( + Objects.requireNonNull( + OPERATOR_RELATIONAL_OPERATOR_IMMUTABLE_BI_MAP.get( + spanProcessingRelationalFilter.relationalOperator()))) + .setRightOperand(convertToSpanFilterValue(spanProcessingRelationalFilter.value())); + + if (spanProcessingRelationalFilter.key() != null) { + relationalSpanFilterExpressionBuilder = + relationalSpanFilterExpressionBuilder.setSpanAttributeKey( + spanProcessingRelationalFilter.key()); + } else { + relationalSpanFilterExpressionBuilder = + relationalSpanFilterExpressionBuilder.setField( + Objects.requireNonNull( + FILTER_FIELD_FIELD_IMMUTABLE_BI_MAP.get(spanProcessingRelationalFilter.field()))); + } + return relationalSpanFilterExpressionBuilder.build(); + } + + private SpanFilterValue convertToSpanFilterValue(Object value) { + SpanFilterValue.Builder spanFilterValueBuilder = SpanFilterValue.newBuilder(); + if (String.class.equals(value.getClass())) { + spanFilterValueBuilder = spanFilterValueBuilder.setStringValue(value.toString()); + } + return spanFilterValueBuilder.build(); + } + + @Value + @Accessors(fluent = true) + private static class ConvertedSpanProcessingRelationalFilter + implements SpanProcessingRelationalFilter { + SpanProcessingRelationalOperator relationalOperator; + String key; + SpanProcessingFilterField field; + Object value; + } + + @Value + @Accessors(fluent = true) + private static class ConvertedSpanProcessingLogicalFilter implements SpanProcessingLogicalFilter { + SpanProcessingLogicalOperator logicalOperator; + List spanFilters; + } + + @Value + @Accessors(fluent = true) + private static class ConvertedSpanProcessingRuleFilter implements SpanProcessingRuleFilter { + SpanProcessingLogicalFilter logicalSpanFilter; + SpanProcessingRelationalFilter relationalSpanFilter; + } +} 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 new file mode 100644 index 00000000..556e7517 --- /dev/null +++ b/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/dao/ConfigServiceSpanProcessingRequestConverter.java @@ -0,0 +1,64 @@ +package org.hypertrace.graphql.spanprocessing.dao; + +import javax.inject.Inject; +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.ExcludeSpanRuleCreate; +import org.hypertrace.graphql.spanprocessing.schema.mutation.ExcludeSpanRuleUpdate; +import org.hypertrace.graphql.spanprocessing.schema.rule.filter.SpanProcessingRuleFilter; +import org.hypertrace.span.processing.config.service.v1.CreateExcludeSpanRuleRequest; +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.UpdateExcludeSpanRule; +import org.hypertrace.span.processing.config.service.v1.UpdateExcludeSpanRuleRequest; + +public class ConfigServiceSpanProcessingRequestConverter { + + private final ConfigServiceSpanFilterConverter filterConverter; + + @Inject + ConfigServiceSpanProcessingRequestConverter(ConfigServiceSpanFilterConverter filterConverter) { + this.filterConverter = filterConverter; + } + + CreateExcludeSpanRuleRequest convert(ExcludeSpanCreateRuleRequest request) { + return CreateExcludeSpanRuleRequest.newBuilder() + .setRuleInfo(convertInput(request.createInput())) + .build(); + } + + private ExcludeSpanRuleInfo convertInput(ExcludeSpanRuleCreate excludeSpanRuleCreate) { + return ExcludeSpanRuleInfo.newBuilder() + .setName(excludeSpanRuleCreate.name()) + .setFilter(this.filterConverter.convert(excludeSpanRuleCreate.spanFilter())) + .build(); + } + + UpdateExcludeSpanRuleRequest convert(ExcludeSpanUpdateRuleRequest request) { + return UpdateExcludeSpanRuleRequest.newBuilder() + .setRule(convertInput(request.updateInput())) + .build(); + } + + private UpdateExcludeSpanRule convertInput(ExcludeSpanRuleUpdate excludeSpanRuleUpdate) { + UpdateExcludeSpanRule.Builder updateExcludeSpanRuleBuilder = + UpdateExcludeSpanRule.newBuilder().setId(excludeSpanRuleUpdate.id()); + String name = excludeSpanRuleUpdate.name(); + SpanProcessingRuleFilter filter = excludeSpanRuleUpdate.spanFilter(); + if (name != null) { + updateExcludeSpanRuleBuilder = + updateExcludeSpanRuleBuilder.setName(excludeSpanRuleUpdate.name()); + } + if (filter != null) { + updateExcludeSpanRuleBuilder = + updateExcludeSpanRuleBuilder.setFilter( + this.filterConverter.convert(excludeSpanRuleUpdate.spanFilter())); + } + return updateExcludeSpanRuleBuilder.build(); + } + + DeleteExcludeSpanRuleRequest convert(ExcludeSpanDeleteRuleRequest request) { + return DeleteExcludeSpanRuleRequest.newBuilder().setId(request.id()).build(); + } +} 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 new file mode 100644 index 00000000..c86f1d4f --- /dev/null +++ b/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/dao/ConfigServiceSpanProcessingResponseConverter.java @@ -0,0 +1,82 @@ +package org.hypertrace.graphql.spanprocessing.dao; + +import io.reactivex.rxjava3.core.Maybe; +import io.reactivex.rxjava3.core.Observable; +import io.reactivex.rxjava3.core.Single; +import java.util.List; +import javax.inject.Inject; +import lombok.Value; +import lombok.experimental.Accessors; +import lombok.extern.slf4j.Slf4j; +import org.hypertrace.graphql.spanprocessing.schema.mutation.DeleteSpanProcessingRuleResponse; +import org.hypertrace.graphql.spanprocessing.schema.query.ExcludeSpanRuleResultSet; +import org.hypertrace.graphql.spanprocessing.schema.rule.ExcludeSpanRule; +import org.hypertrace.span.processing.config.service.v1.CreateExcludeSpanRuleResponse; +import org.hypertrace.span.processing.config.service.v1.DeleteExcludeSpanRuleResponse; +import org.hypertrace.span.processing.config.service.v1.GetAllExcludeSpanRulesResponse; +import org.hypertrace.span.processing.config.service.v1.UpdateExcludeSpanRuleResponse; + +@Slf4j +public class ConfigServiceSpanProcessingResponseConverter { + + private final ConfigServiceSpanProcessingRuleConverter ruleConverter; + + @Inject + ConfigServiceSpanProcessingResponseConverter( + ConfigServiceSpanProcessingRuleConverter ruleConverter) { + this.ruleConverter = ruleConverter; + } + + Single convert(GetAllExcludeSpanRulesResponse response) { + return this.convertResultSet(response.getRulesList()); + } + + private Maybe convertOrDrop( + org.hypertrace.span.processing.config.service.v1.ExcludeSpanRule rule) { + return this.ruleConverter + .convert(rule) + .doOnError(error -> log.error("Error converting ExcludeSpanRule", error)) + .onErrorComplete(); + } + + private Single convertResultSet( + List rules) { + return Observable.fromIterable(rules) + .concatMapMaybe(this::convertOrDrop) + .toList() + .map(ConvertedExcludeSpanRuleResultSet::new); + } + + Single convert(CreateExcludeSpanRuleResponse response) { + return this.ruleConverter.convert(response.getRule()); + } + + Single convert(UpdateExcludeSpanRuleResponse response) { + return this.ruleConverter.convert(response.getRule()); + } + + Single convert(DeleteExcludeSpanRuleResponse response) { + return Single.just(new DefaultDeleteSpanProcessingRuleResponse(true)); + } + + @Value + @Accessors(fluent = true) + private static class DefaultDeleteSpanProcessingRuleResponse + implements DeleteSpanProcessingRuleResponse { + boolean success; + } + + @Value + @Accessors(fluent = true) + private static class ConvertedExcludeSpanRuleResultSet implements ExcludeSpanRuleResultSet { + List results; + long total; + long count; + + private ConvertedExcludeSpanRuleResultSet(List results) { + this.results = results; + this.count = results.size(); + this.total = results.size(); + } + } +} 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 new file mode 100644 index 00000000..2ad85db8 --- /dev/null +++ b/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/dao/ConfigServiceSpanProcessingRuleConverter.java @@ -0,0 +1,40 @@ +package org.hypertrace.graphql.spanprocessing.dao; + +import io.reactivex.rxjava3.core.Single; +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.ExcludeSpanRule; +import org.hypertrace.graphql.spanprocessing.schema.rule.filter.SpanProcessingRuleFilter; + +class ConfigServiceSpanProcessingRuleConverter + implements Converter< + org.hypertrace.span.processing.config.service.v1.ExcludeSpanRule, ExcludeSpanRule> { + + private final ConfigServiceSpanFilterConverter filterConverter; + + @Inject + ConfigServiceSpanProcessingRuleConverter(ConfigServiceSpanFilterConverter filterConverter) { + this.filterConverter = filterConverter; + } + + @Override + public Single convert( + org.hypertrace.span.processing.config.service.v1.ExcludeSpanRule rule) { + return this.filterConverter + .convert(rule.getRuleInfo().getFilter()) + .map( + spanProcessingRuleFilter -> + new ConvertedExcludeSpanRule( + rule.getId(), rule.getRuleInfo().getName(), spanProcessingRuleFilter)); + } + + @Value + @Accessors(fluent = true) + private static class ConvertedExcludeSpanRule implements ExcludeSpanRule { + String id; + String name; + SpanProcessingRuleFilter spanFilter; + } +} 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 new file mode 100644 index 00000000..6da5e3d2 --- /dev/null +++ b/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/dao/ConfigServiceSpanProcessingRuleDao.java @@ -0,0 +1,104 @@ +package org.hypertrace.graphql.spanprocessing.dao; + +import static java.util.concurrent.TimeUnit.MILLISECONDS; + +import io.grpc.CallCredentials; +import io.reactivex.rxjava3.core.Single; +import javax.inject.Inject; +import org.hypertrace.core.graphql.common.request.ContextualRequest; +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.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.ExcludeSpanRuleResultSet; +import org.hypertrace.graphql.spanprocessing.schema.rule.ExcludeSpanRule; +import org.hypertrace.span.processing.config.service.v1.GetAllExcludeSpanRulesRequest; +import org.hypertrace.span.processing.config.service.v1.SpanProcessingConfigServiceGrpc; + +public class ConfigServiceSpanProcessingRuleDao implements SpanProcessingRuleDao { + private final HypertraceGraphQlServiceConfig serviceConfig; + private final GrpcContextBuilder grpcContextBuilder; + private final ConfigServiceSpanProcessingResponseConverter responseConverter; + private final ConfigServiceSpanProcessingRequestConverter requestConverter; + private final SpanProcessingConfigServiceGrpc.SpanProcessingConfigServiceFutureStub configStub; + + @Inject + ConfigServiceSpanProcessingRuleDao( + HypertraceGraphQlServiceConfig serviceConfig, + CallCredentials credentials, + GrpcContextBuilder grpcContextBuilder, + GrpcChannelRegistry channelRegistry, + ConfigServiceSpanProcessingResponseConverter responseConverter, + ConfigServiceSpanProcessingRequestConverter requestConverter) { + this.serviceConfig = serviceConfig; + this.grpcContextBuilder = grpcContextBuilder; + this.responseConverter = responseConverter; + this.requestConverter = requestConverter; + + this.configStub = + SpanProcessingConfigServiceGrpc.newFutureStub( + channelRegistry.forAddress( + serviceConfig.getConfigServiceHost(), serviceConfig.getConfigServicePort())) + .withCallCredentials(credentials); + } + + @Override + public Single getRules(ContextualRequest request) { + return Single.fromFuture( + this.grpcContextBuilder + .build(request.context()) + .call( + () -> + this.configStub + .withDeadlineAfter( + serviceConfig.getConfigServiceTimeout().toMillis(), MILLISECONDS) + .getAllExcludeSpanRules( + GetAllExcludeSpanRulesRequest.getDefaultInstance()))) + .flatMap(this.responseConverter::convert); + } + + @Override + public Single createRule(ExcludeSpanCreateRuleRequest request) { + return Single.fromFuture( + this.grpcContextBuilder + .build(request.context()) + .call( + () -> + this.configStub + .withDeadlineAfter( + serviceConfig.getConfigServiceTimeout().toMillis(), MILLISECONDS) + .createExcludeSpanRule(this.requestConverter.convert(request)))) + .flatMap(this.responseConverter::convert); + } + + @Override + public Single updateRule(ExcludeSpanUpdateRuleRequest request) { + return Single.fromFuture( + this.grpcContextBuilder + .build(request.context()) + .call( + () -> + this.configStub + .withDeadlineAfter( + serviceConfig.getConfigServiceTimeout().toMillis(), MILLISECONDS) + .updateExcludeSpanRule(this.requestConverter.convert(request)))) + .flatMap(this.responseConverter::convert); + } + + @Override + public Single deleteRule(ExcludeSpanDeleteRuleRequest request) { + return Single.fromFuture( + this.grpcContextBuilder + .build(request.context()) + .call( + () -> + this.configStub + .withDeadlineAfter( + serviceConfig.getConfigServiceTimeout().toMillis(), MILLISECONDS) + .deleteExcludeSpanRule(this.requestConverter.convert(request)))) + .flatMap(this.responseConverter::convert); + } +} diff --git a/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/dao/SpanProcessingDaoModule.java b/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/dao/SpanProcessingDaoModule.java new file mode 100644 index 00000000..51d27381 --- /dev/null +++ b/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/dao/SpanProcessingDaoModule.java @@ -0,0 +1,20 @@ +package org.hypertrace.graphql.spanprocessing.dao; + +import com.google.inject.AbstractModule; +import io.grpc.CallCredentials; +import org.hypertrace.core.graphql.utils.grpc.GrpcChannelRegistry; +import org.hypertrace.core.graphql.utils.grpc.GrpcContextBuilder; +import org.hypertrace.graphql.config.HypertraceGraphQlServiceConfig; + +public class SpanProcessingDaoModule extends AbstractModule { + + @Override + protected void configure() { + bind(SpanProcessingRuleDao.class).to(ConfigServiceSpanProcessingRuleDao.class); + + requireBinding(HypertraceGraphQlServiceConfig.class); + requireBinding(CallCredentials.class); + requireBinding(GrpcContextBuilder.class); + requireBinding(GrpcChannelRegistry.class); + } +} 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 new file mode 100644 index 00000000..8117614e --- /dev/null +++ b/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/dao/SpanProcessingRuleDao.java @@ -0,0 +1,20 @@ +package org.hypertrace.graphql.spanprocessing.dao; + +import io.reactivex.rxjava3.core.Single; +import org.hypertrace.core.graphql.common.request.ContextualRequest; +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.ExcludeSpanRuleResultSet; +import org.hypertrace.graphql.spanprocessing.schema.rule.ExcludeSpanRule; + +public interface SpanProcessingRuleDao { + Single getRules(ContextualRequest request); + + Single createRule(ExcludeSpanCreateRuleRequest request); + + Single updateRule(ExcludeSpanUpdateRuleRequest request); + + Single deleteRule(ExcludeSpanDeleteRuleRequest request); +} diff --git a/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/deserialization/ExcludeSpanCreateInputDeserializationConfig.java b/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/deserialization/ExcludeSpanCreateInputDeserializationConfig.java new file mode 100644 index 00000000..45fecd86 --- /dev/null +++ b/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/deserialization/ExcludeSpanCreateInputDeserializationConfig.java @@ -0,0 +1,81 @@ +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.ExcludeSpanRuleCreate; +import org.hypertrace.graphql.spanprocessing.schema.rule.filter.SpanProcessingFilterField; +import org.hypertrace.graphql.spanprocessing.schema.rule.filter.SpanProcessingLogicalFilter; +import org.hypertrace.graphql.spanprocessing.schema.rule.filter.SpanProcessingLogicalOperator; +import org.hypertrace.graphql.spanprocessing.schema.rule.filter.SpanProcessingRelationalFilter; +import org.hypertrace.graphql.spanprocessing.schema.rule.filter.SpanProcessingRelationalOperator; +import org.hypertrace.graphql.spanprocessing.schema.rule.filter.SpanProcessingRuleFilter; + +public class ExcludeSpanCreateInputDeserializationConfig implements ArgumentDeserializationConfig { + @Override + public String getArgumentKey() { + return ExcludeSpanRuleCreate.ARGUMENT_NAME; + } + + @Override + public Class getArgumentSchema() { + return ExcludeSpanRuleCreate.class; + } + + @Override + public List jacksonModules() { + return List.of( + new SimpleModule() + .addAbstractTypeMapping(ExcludeSpanRuleCreate.class, DefaultExcludeSpanRuleCreate.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 DefaultExcludeSpanRuleCreate implements ExcludeSpanRuleCreate { + String name; + SpanProcessingRuleFilter spanFilter; + } + + @Value + @Accessors(fluent = true) + @Jacksonized + @Builder + private static class DefaultSpanProcessingRuleFilter implements SpanProcessingRuleFilter { + SpanProcessingLogicalFilter logicalSpanFilter; + SpanProcessingRelationalFilter relationalSpanFilter; + } + + @Value + @Accessors(fluent = true) + @Jacksonized + @Builder + private static class DefaultSpanProcessingLogicalFilter implements SpanProcessingLogicalFilter { + SpanProcessingLogicalOperator logicalOperator; + List spanFilters; + } + + @Value + @Accessors(fluent = true) + @Jacksonized + @Builder + private static class DefaultSpanProcessingRelationalFilter + implements SpanProcessingRelationalFilter { + String key; + SpanProcessingFilterField field; + SpanProcessingRelationalOperator relationalOperator; + Object value; + } +} diff --git a/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/deserialization/ExcludeSpanDeleteInputDeserializationConfig.java b/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/deserialization/ExcludeSpanDeleteInputDeserializationConfig.java new file mode 100644 index 00000000..7c8c72fa --- /dev/null +++ b/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/deserialization/ExcludeSpanDeleteInputDeserializationConfig.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.ExcludeSpanRuleDelete; + +public class ExcludeSpanDeleteInputDeserializationConfig implements ArgumentDeserializationConfig { + @Override + public String getArgumentKey() { + return ExcludeSpanRuleDelete.ARGUMENT_NAME; + } + + @Override + public Class getArgumentSchema() { + return ExcludeSpanRuleDelete.class; + } + + @Override + public List jacksonModules() { + return List.of( + new SimpleModule() + .addAbstractTypeMapping( + ExcludeSpanRuleDelete.class, DefaultExcludeSpanRuleDelete.class)); + } + + @Value + @Accessors(fluent = true) + @Jacksonized + @Builder + private static class DefaultExcludeSpanRuleDelete implements ExcludeSpanRuleDelete { + String id; + } +} diff --git a/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/deserialization/ExcludeSpanUpdateInputDeserializationConfig.java b/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/deserialization/ExcludeSpanUpdateInputDeserializationConfig.java new file mode 100644 index 00000000..a93197ca --- /dev/null +++ b/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/deserialization/ExcludeSpanUpdateInputDeserializationConfig.java @@ -0,0 +1,82 @@ +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.ExcludeSpanRuleUpdate; +import org.hypertrace.graphql.spanprocessing.schema.rule.filter.SpanProcessingFilterField; +import org.hypertrace.graphql.spanprocessing.schema.rule.filter.SpanProcessingLogicalFilter; +import org.hypertrace.graphql.spanprocessing.schema.rule.filter.SpanProcessingLogicalOperator; +import org.hypertrace.graphql.spanprocessing.schema.rule.filter.SpanProcessingRelationalFilter; +import org.hypertrace.graphql.spanprocessing.schema.rule.filter.SpanProcessingRelationalOperator; +import org.hypertrace.graphql.spanprocessing.schema.rule.filter.SpanProcessingRuleFilter; + +public class ExcludeSpanUpdateInputDeserializationConfig implements ArgumentDeserializationConfig { + @Override + public String getArgumentKey() { + return ExcludeSpanRuleUpdate.ARGUMENT_NAME; + } + + @Override + public Class getArgumentSchema() { + return ExcludeSpanRuleUpdate.class; + } + + @Override + public List jacksonModules() { + return List.of( + new SimpleModule() + .addAbstractTypeMapping(ExcludeSpanRuleUpdate.class, DefaultExcludeSpanRuleUpdate.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 DefaultExcludeSpanRuleUpdate implements ExcludeSpanRuleUpdate { + String id; + String name; + SpanProcessingRuleFilter spanFilter; + } + + @Value + @Accessors(fluent = true) + @Jacksonized + @Builder + private static class DefaultSpanProcessingRuleFilter implements SpanProcessingRuleFilter { + SpanProcessingLogicalFilter logicalSpanFilter; + SpanProcessingRelationalFilter relationalSpanFilter; + } + + @Value + @Accessors(fluent = true) + @Jacksonized + @Builder + private static class DefaultSpanProcessingLogicalFilter implements SpanProcessingLogicalFilter { + SpanProcessingLogicalOperator logicalOperator; + List spanFilters; + } + + @Value + @Accessors(fluent = true) + @Jacksonized + @Builder + private static class DefaultSpanProcessingRelationalFilter + implements SpanProcessingRelationalFilter { + String key; + SpanProcessingFilterField field; + SpanProcessingRelationalOperator relationalOperator; + Object value; + } +} 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 new file mode 100644 index 00000000..5ab927a2 --- /dev/null +++ b/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/deserialization/SpanProcessingDeserializationModule.java @@ -0,0 +1,17 @@ +package org.hypertrace.graphql.spanprocessing.deserialization; + +import com.google.inject.AbstractModule; +import com.google.inject.multibindings.Multibinder; +import org.hypertrace.core.graphql.deserialization.ArgumentDeserializationConfig; + +public class SpanProcessingDeserializationModule extends AbstractModule { + @Override + protected void configure() { + Multibinder multibinder = + Multibinder.newSetBinder(binder(), ArgumentDeserializationConfig.class); + + multibinder.addBinding().to(ExcludeSpanCreateInputDeserializationConfig.class); + multibinder.addBinding().to(ExcludeSpanUpdateInputDeserializationConfig.class); + multibinder.addBinding().to(ExcludeSpanDeleteInputDeserializationConfig.class); + } +} diff --git a/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/fetcher/mutation/ExcludeSpanCreateRuleMutator.java b/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/fetcher/mutation/ExcludeSpanCreateRuleMutator.java new file mode 100644 index 00000000..8d749cbb --- /dev/null +++ b/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/fetcher/mutation/ExcludeSpanCreateRuleMutator.java @@ -0,0 +1,41 @@ +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.ExcludeSpanCreateRuleRequestBuilder; +import org.hypertrace.graphql.spanprocessing.schema.rule.ExcludeSpanRule; + +public class ExcludeSpanCreateRuleMutator extends InjectableDataFetcher { + + public ExcludeSpanCreateRuleMutator() { + super(SpanProcessingCreateRuleMutatorImpl.class); + } + + static final class SpanProcessingCreateRuleMutatorImpl + implements DataFetcher> { + private final SpanProcessingRuleDao spanProcessingRuleDao; + private final ExcludeSpanCreateRuleRequestBuilder requestBuilder; + + @Inject + SpanProcessingCreateRuleMutatorImpl( + ExcludeSpanCreateRuleRequestBuilder 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::createRule) + .toCompletionStage() + .toCompletableFuture(); + } + } +} diff --git a/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/fetcher/mutation/ExcludeSpanDeleteRuleMutator.java b/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/fetcher/mutation/ExcludeSpanDeleteRuleMutator.java new file mode 100644 index 00000000..607768b0 --- /dev/null +++ b/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/fetcher/mutation/ExcludeSpanDeleteRuleMutator.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.ExcludeSpanDeleteRuleRequestBuilder; +import org.hypertrace.graphql.spanprocessing.schema.mutation.DeleteSpanProcessingRuleResponse; + +public class ExcludeSpanDeleteRuleMutator + extends InjectableDataFetcher { + + public ExcludeSpanDeleteRuleMutator() { + super(SpanProcessingDeleteRuleMutatorImpl.class); + } + + static final class SpanProcessingDeleteRuleMutatorImpl + implements DataFetcher> { + private final SpanProcessingRuleDao spanProcessingRuleDao; + private final ExcludeSpanDeleteRuleRequestBuilder requestBuilder; + + @Inject + SpanProcessingDeleteRuleMutatorImpl( + ExcludeSpanDeleteRuleRequestBuilder 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::deleteRule) + .toCompletionStage() + .toCompletableFuture(); + } + } +} diff --git a/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/fetcher/mutation/ExcludeSpanUpdateRuleMutator.java b/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/fetcher/mutation/ExcludeSpanUpdateRuleMutator.java new file mode 100644 index 00000000..1022eeda --- /dev/null +++ b/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/fetcher/mutation/ExcludeSpanUpdateRuleMutator.java @@ -0,0 +1,41 @@ +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.ExcludeSpanUpdateRuleRequestBuilder; +import org.hypertrace.graphql.spanprocessing.schema.rule.ExcludeSpanRule; + +public class ExcludeSpanUpdateRuleMutator extends InjectableDataFetcher { + + public ExcludeSpanUpdateRuleMutator() { + super(SpanProcessingUpdateRuleMutatorImpl.class); + } + + static final class SpanProcessingUpdateRuleMutatorImpl + implements DataFetcher> { + private final SpanProcessingRuleDao spanProcessingRuleDao; + private final ExcludeSpanUpdateRuleRequestBuilder requestBuilder; + + @Inject + SpanProcessingUpdateRuleMutatorImpl( + ExcludeSpanUpdateRuleRequestBuilder 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::updateRule) + .toCompletionStage() + .toCompletableFuture(); + } + } +} diff --git a/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/fetcher/query/ExcludeSpanRulesFetcher.java b/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/fetcher/query/ExcludeSpanRulesFetcher.java new file mode 100644 index 00000000..896b29c5 --- /dev/null +++ b/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/fetcher/query/ExcludeSpanRulesFetcher.java @@ -0,0 +1,39 @@ +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.ExcludeSpanRuleResultSet; + +public class ExcludeSpanRulesFetcher extends InjectableDataFetcher { + + public ExcludeSpanRulesFetcher() { + super(SpanProcessingRulesFetcherImpl.class); + } + + static final class SpanProcessingRulesFetcherImpl + implements DataFetcher> { + private final SpanProcessingRuleDao spanProcessingRuleDao; + private final ContextualRequestBuilder requestBuilder; + + @Inject + SpanProcessingRulesFetcherImpl( + ContextualRequestBuilder requestBuilder, SpanProcessingRuleDao spanProcessingRuleDao) { + this.requestBuilder = requestBuilder; + this.spanProcessingRuleDao = spanProcessingRuleDao; + } + + @Override + public CompletableFuture get(DataFetchingEnvironment environment) { + + return this.spanProcessingRuleDao + .getRules(this.requestBuilder.build(environment.getContext())) + .toCompletionStage() + .toCompletableFuture(); + } + } +} diff --git a/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/request/mutation/DefaultExcludeSpanCreateRuleRequestBuilder.java b/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/request/mutation/DefaultExcludeSpanCreateRuleRequestBuilder.java new file mode 100644 index 00000000..b7da782f --- /dev/null +++ b/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/request/mutation/DefaultExcludeSpanCreateRuleRequestBuilder.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.ExcludeSpanRuleCreate; + +public class DefaultExcludeSpanCreateRuleRequestBuilder + implements ExcludeSpanCreateRuleRequestBuilder { + + private final ArgumentDeserializer argumentDeserializer; + + @Inject + DefaultExcludeSpanCreateRuleRequestBuilder(ArgumentDeserializer argumentDeserializer) { + this.argumentDeserializer = argumentDeserializer; + } + + @Override + public Single build( + GraphQlRequestContext context, Map arguments) { + ExcludeSpanRuleCreate excludeSpanRuleCreateInput = + this.argumentDeserializer + .deserializeObject(arguments, ExcludeSpanRuleCreate.class) + .orElseThrow(); + return Single.just( + new DefaultExcludeSpanCreateRuleRequest(context, excludeSpanRuleCreateInput)); + } + + @Value + @Accessors(fluent = true) + private static class DefaultExcludeSpanCreateRuleRequest implements ExcludeSpanCreateRuleRequest { + GraphQlRequestContext context; + ExcludeSpanRuleCreate createInput; + } +} diff --git a/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/request/mutation/DefaultExcludeSpanDeleteRuleRequestBuilder.java b/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/request/mutation/DefaultExcludeSpanDeleteRuleRequestBuilder.java new file mode 100644 index 00000000..04d9c10d --- /dev/null +++ b/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/request/mutation/DefaultExcludeSpanDeleteRuleRequestBuilder.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.ExcludeSpanRuleDelete; + +public class DefaultExcludeSpanDeleteRuleRequestBuilder + implements ExcludeSpanDeleteRuleRequestBuilder { + + private final ArgumentDeserializer argumentDeserializer; + + @Inject + DefaultExcludeSpanDeleteRuleRequestBuilder(ArgumentDeserializer argumentDeserializer) { + this.argumentDeserializer = argumentDeserializer; + } + + @Override + public Single build( + GraphQlRequestContext context, Map arguments) { + String idToDelete = + this.argumentDeserializer + .deserializeObject(arguments, ExcludeSpanRuleDelete.class) + .map(ExcludeSpanRuleDelete::id) + .orElseThrow(); + return Single.just(new DefaultExcludeSpanDeleteRuleRequest(context, idToDelete)); + } + + @Value + @Accessors(fluent = true) + private static class DefaultExcludeSpanDeleteRuleRequest implements ExcludeSpanDeleteRuleRequest { + GraphQlRequestContext context; + String id; + } +} diff --git a/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/request/mutation/DefaultExcludeSpanUpdateRuleRequestBuilder.java b/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/request/mutation/DefaultExcludeSpanUpdateRuleRequestBuilder.java new file mode 100644 index 00000000..25d7eb41 --- /dev/null +++ b/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/request/mutation/DefaultExcludeSpanUpdateRuleRequestBuilder.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.ExcludeSpanRuleUpdate; + +public class DefaultExcludeSpanUpdateRuleRequestBuilder + implements ExcludeSpanUpdateRuleRequestBuilder { + + private final ArgumentDeserializer argumentDeserializer; + + @Inject + DefaultExcludeSpanUpdateRuleRequestBuilder(ArgumentDeserializer argumentDeserializer) { + this.argumentDeserializer = argumentDeserializer; + } + + @Override + public Single build( + GraphQlRequestContext context, Map arguments) { + ExcludeSpanRuleUpdate excludeSpanRuleUpdateInput = + this.argumentDeserializer + .deserializeObject(arguments, ExcludeSpanRuleUpdate.class) + .orElseThrow(); + return Single.just( + new DefaultExcludeSpanUpdateRuleRequest(context, excludeSpanRuleUpdateInput)); + } + + @Value + @Accessors(fluent = true) + private static class DefaultExcludeSpanUpdateRuleRequest implements ExcludeSpanUpdateRuleRequest { + GraphQlRequestContext context; + ExcludeSpanRuleUpdate updateInput; + } +} diff --git a/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/request/mutation/ExcludeSpanCreateRuleRequest.java b/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/request/mutation/ExcludeSpanCreateRuleRequest.java new file mode 100644 index 00000000..8832d798 --- /dev/null +++ b/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/request/mutation/ExcludeSpanCreateRuleRequest.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.ExcludeSpanRuleCreate; + +public interface ExcludeSpanCreateRuleRequest { + GraphQlRequestContext context(); + + ExcludeSpanRuleCreate createInput(); +} diff --git a/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/request/mutation/ExcludeSpanCreateRuleRequestBuilder.java b/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/request/mutation/ExcludeSpanCreateRuleRequestBuilder.java new file mode 100644 index 00000000..5adcf676 --- /dev/null +++ b/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/request/mutation/ExcludeSpanCreateRuleRequestBuilder.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 ExcludeSpanCreateRuleRequestBuilder { + Single build( + GraphQlRequestContext context, Map arguments); +} diff --git a/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/request/mutation/ExcludeSpanDeleteRuleRequest.java b/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/request/mutation/ExcludeSpanDeleteRuleRequest.java new file mode 100644 index 00000000..9635b1bf --- /dev/null +++ b/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/request/mutation/ExcludeSpanDeleteRuleRequest.java @@ -0,0 +1,9 @@ +package org.hypertrace.graphql.spanprocessing.request.mutation; + +import org.hypertrace.core.graphql.context.GraphQlRequestContext; + +public interface ExcludeSpanDeleteRuleRequest { + GraphQlRequestContext context(); + + String id(); +} diff --git a/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/request/mutation/ExcludeSpanDeleteRuleRequestBuilder.java b/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/request/mutation/ExcludeSpanDeleteRuleRequestBuilder.java new file mode 100644 index 00000000..87099493 --- /dev/null +++ b/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/request/mutation/ExcludeSpanDeleteRuleRequestBuilder.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 ExcludeSpanDeleteRuleRequestBuilder { + Single build( + GraphQlRequestContext context, Map arguments); +} diff --git a/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/request/mutation/ExcludeSpanUpdateRuleRequest.java b/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/request/mutation/ExcludeSpanUpdateRuleRequest.java new file mode 100644 index 00000000..c6632163 --- /dev/null +++ b/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/request/mutation/ExcludeSpanUpdateRuleRequest.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.ExcludeSpanRuleUpdate; + +public interface ExcludeSpanUpdateRuleRequest { + GraphQlRequestContext context(); + + ExcludeSpanRuleUpdate updateInput(); +} diff --git a/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/request/mutation/ExcludeSpanUpdateRuleRequestBuilder.java b/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/request/mutation/ExcludeSpanUpdateRuleRequestBuilder.java new file mode 100644 index 00000000..068ffa8c --- /dev/null +++ b/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/request/mutation/ExcludeSpanUpdateRuleRequestBuilder.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 ExcludeSpanUpdateRuleRequestBuilder { + 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 new file mode 100644 index 00000000..46b4d7ea --- /dev/null +++ b/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/request/mutation/SpanProcessingMutationRequestModule.java @@ -0,0 +1,19 @@ +package org.hypertrace.graphql.spanprocessing.request.mutation; + +import com.google.inject.AbstractModule; +import org.hypertrace.core.graphql.deserialization.ArgumentDeserializer; + +public class SpanProcessingMutationRequestModule extends AbstractModule { + + @Override + protected void configure() { + bind(ExcludeSpanCreateRuleRequestBuilder.class) + .to(DefaultExcludeSpanCreateRuleRequestBuilder.class); + bind(ExcludeSpanUpdateRuleRequestBuilder.class) + .to(DefaultExcludeSpanUpdateRuleRequestBuilder.class); + bind(ExcludeSpanDeleteRuleRequestBuilder.class) + .to(DefaultExcludeSpanDeleteRuleRequestBuilder.class); + + requireBinding(ArgumentDeserializer.class); + } +} diff --git a/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/schema/mutation/DeleteSpanProcessingRuleResponse.java b/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/schema/mutation/DeleteSpanProcessingRuleResponse.java new file mode 100644 index 00000000..c66d830f --- /dev/null +++ b/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/schema/mutation/DeleteSpanProcessingRuleResponse.java @@ -0,0 +1,16 @@ +package org.hypertrace.graphql.spanprocessing.schema.mutation; + +import graphql.annotations.annotationTypes.GraphQLField; +import graphql.annotations.annotationTypes.GraphQLName; +import graphql.annotations.annotationTypes.GraphQLNonNull; + +@GraphQLName(DeleteSpanProcessingRuleResponse.TYPE_NAME) +public interface DeleteSpanProcessingRuleResponse { + String TYPE_NAME = "DeleteSpanProcessingRuleResponse"; + String DELETE_SPAN_PROCESSING_RULE_RESPONSE_SUCCESS = "success"; + + @GraphQLField + @GraphQLNonNull + @GraphQLName(DELETE_SPAN_PROCESSING_RULE_RESPONSE_SUCCESS) + boolean success(); +} diff --git a/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/schema/mutation/ExcludeSpanRuleCreate.java b/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/schema/mutation/ExcludeSpanRuleCreate.java new file mode 100644 index 00000000..b7d1d18a --- /dev/null +++ b/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/schema/mutation/ExcludeSpanRuleCreate.java @@ -0,0 +1,10 @@ +package org.hypertrace.graphql.spanprocessing.schema.mutation; + +import graphql.annotations.annotationTypes.GraphQLName; +import org.hypertrace.graphql.spanprocessing.schema.rule.ExcludeSpanRuleInfo; + +@GraphQLName(ExcludeSpanRuleCreate.TYPE_NAME) +public interface ExcludeSpanRuleCreate extends ExcludeSpanRuleInfo { + String TYPE_NAME = "ExcludeSpanRuleCreate"; + String ARGUMENT_NAME = "input"; +} diff --git a/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/schema/mutation/ExcludeSpanRuleDelete.java b/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/schema/mutation/ExcludeSpanRuleDelete.java new file mode 100644 index 00000000..63a1e883 --- /dev/null +++ b/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/schema/mutation/ExcludeSpanRuleDelete.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(ExcludeSpanRuleDelete.TYPE_NAME) +public interface ExcludeSpanRuleDelete extends Identifiable { + String TYPE_NAME = "ExcludeSpanRuleDelete"; + String ARGUMENT_NAME = "input"; +} diff --git a/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/schema/mutation/ExcludeSpanRuleUpdate.java b/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/schema/mutation/ExcludeSpanRuleUpdate.java new file mode 100644 index 00000000..e4ad1299 --- /dev/null +++ b/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/schema/mutation/ExcludeSpanRuleUpdate.java @@ -0,0 +1,23 @@ +package org.hypertrace.graphql.spanprocessing.schema.mutation; + +import graphql.annotations.annotationTypes.GraphQLField; +import graphql.annotations.annotationTypes.GraphQLName; +import org.hypertrace.core.graphql.common.schema.id.Identifiable; +import org.hypertrace.graphql.spanprocessing.schema.rule.filter.SpanProcessingRuleFilter; + +@GraphQLName(ExcludeSpanRuleUpdate.TYPE_NAME) +public interface ExcludeSpanRuleUpdate extends Identifiable { + String TYPE_NAME = "ExcludeSpanRuleUpdate"; + String ARGUMENT_NAME = "input"; + + String NAME_KEY = "name"; + String SPAN_PROCESSING_FILTER_KEY = "spanFilter"; + + @GraphQLField + @GraphQLName(NAME_KEY) + String name(); + + @GraphQLField + @GraphQLName(SPAN_PROCESSING_FILTER_KEY) + SpanProcessingRuleFilter spanFilter(); +} 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 new file mode 100644 index 00000000..7fc0f980 --- /dev/null +++ b/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/schema/mutation/SpanProcessingMutationSchema.java @@ -0,0 +1,40 @@ +package org.hypertrace.graphql.spanprocessing.schema.mutation; + +import graphql.annotations.annotationTypes.GraphQLDataFetcher; +import graphql.annotations.annotationTypes.GraphQLField; +import graphql.annotations.annotationTypes.GraphQLName; +import graphql.annotations.annotationTypes.GraphQLNonNull; +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.schema.rule.ExcludeSpanRule; + +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"; + + @GraphQLField + @GraphQLName(CREATE_EXCLUDE_SPAN_RULE_MUTATION_NAME) + @GraphQLNonNull + @GraphQLDataFetcher(ExcludeSpanCreateRuleMutator.class) + ExcludeSpanRule createExcludeSpanRule( + @GraphQLName(ExcludeSpanRuleCreate.ARGUMENT_NAME) @GraphQLNonNull + ExcludeSpanRuleCreate input); + + @GraphQLField + @GraphQLName(UPDATE_EXCLUDE_SPAN_RULE_MUTATION_NAME) + @GraphQLNonNull + @GraphQLDataFetcher(ExcludeSpanUpdateRuleMutator.class) + ExcludeSpanRule updateExcludeSpanRule( + @GraphQLName(ExcludeSpanRuleUpdate.ARGUMENT_NAME) @GraphQLNonNull + ExcludeSpanRuleUpdate input); + + @GraphQLField + @GraphQLName(DELETE_EXCLUDE_SPAN_RULE_MUTATION_NAME) + @GraphQLNonNull + @GraphQLDataFetcher(ExcludeSpanDeleteRuleMutator.class) + DeleteSpanProcessingRuleResponse deleteSpanProcessingRule( + @GraphQLName(ExcludeSpanRuleDelete.ARGUMENT_NAME) @GraphQLNonNull + ExcludeSpanRuleDelete input); +} diff --git a/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/schema/query/ExcludeSpanRuleResultSet.java b/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/schema/query/ExcludeSpanRuleResultSet.java new file mode 100644 index 00000000..7bb6607d --- /dev/null +++ b/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/schema/query/ExcludeSpanRuleResultSet.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.ExcludeSpanRule; + +@GraphQLName(ExcludeSpanRuleResultSet.TYPE_NAME) +public interface ExcludeSpanRuleResultSet extends ResultSet { + String TYPE_NAME = "ExcludeSpanRuleResultSet"; + + @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 new file mode 100644 index 00000000..60aa3e52 --- /dev/null +++ b/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/schema/query/SpanProcessingQuerySchema.java @@ -0,0 +1,17 @@ +package org.hypertrace.graphql.spanprocessing.schema.query; + +import graphql.annotations.annotationTypes.GraphQLDataFetcher; +import graphql.annotations.annotationTypes.GraphQLField; +import graphql.annotations.annotationTypes.GraphQLName; +import graphql.annotations.annotationTypes.GraphQLNonNull; +import org.hypertrace.graphql.spanprocessing.fetcher.query.ExcludeSpanRulesFetcher; + +public interface SpanProcessingQuerySchema { + String EXCLUDE_SPAN_RULES_QUERY_NAME = "excludeSpanRules"; + + @GraphQLField + @GraphQLNonNull + @GraphQLName(EXCLUDE_SPAN_RULES_QUERY_NAME) + @GraphQLDataFetcher(ExcludeSpanRulesFetcher.class) + ExcludeSpanRuleResultSet excludeSpanRules(); +} diff --git a/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/schema/rule/ExcludeSpanRule.java b/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/schema/rule/ExcludeSpanRule.java new file mode 100644 index 00000000..01dc080e --- /dev/null +++ b/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/schema/rule/ExcludeSpanRule.java @@ -0,0 +1,9 @@ +package org.hypertrace.graphql.spanprocessing.schema.rule; + +import graphql.annotations.annotationTypes.GraphQLName; +import org.hypertrace.core.graphql.common.schema.id.Identifiable; + +@GraphQLName(ExcludeSpanRule.TYPE_NAME) +public interface ExcludeSpanRule extends Identifiable, ExcludeSpanRuleInfo { + String TYPE_NAME = "ExcludeSpanRule"; +} diff --git a/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/schema/rule/ExcludeSpanRuleInfo.java b/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/schema/rule/ExcludeSpanRuleInfo.java new file mode 100644 index 00000000..5ee6c50b --- /dev/null +++ b/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/schema/rule/ExcludeSpanRuleInfo.java @@ -0,0 +1,24 @@ +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(ExcludeSpanRuleInfo.TYPE_NAME) +public interface ExcludeSpanRuleInfo { + String TYPE_NAME = "ExcludeSpanRuleInfo"; + + String NAME_KEY = "name"; + String SPAN_FILTER_KEY = "spanFilter"; + + @GraphQLField + @GraphQLName(NAME_KEY) + @GraphQLNonNull + String name(); + + @GraphQLField + @GraphQLName(SPAN_FILTER_KEY) + @GraphQLNonNull + SpanProcessingRuleFilter spanFilter(); +} diff --git a/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/schema/rule/filter/SpanProcessingFilterField.java b/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/schema/rule/filter/SpanProcessingFilterField.java new file mode 100644 index 00000000..6e6ec705 --- /dev/null +++ b/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/schema/rule/filter/SpanProcessingFilterField.java @@ -0,0 +1,11 @@ +package org.hypertrace.graphql.spanprocessing.schema.rule.filter; + +import graphql.annotations.annotationTypes.GraphQLName; + +@GraphQLName(SpanProcessingFilterField.TYPE_NAME) +public enum SpanProcessingFilterField { + URL, + SERVICE_NAME, + ENVIRONMENT_NAME; + static final String TYPE_NAME = "SpanProcessingFilterField"; +} diff --git a/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/schema/rule/filter/SpanProcessingLogicalFilter.java b/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/schema/rule/filter/SpanProcessingLogicalFilter.java new file mode 100644 index 00000000..260a9368 --- /dev/null +++ b/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/schema/rule/filter/SpanProcessingLogicalFilter.java @@ -0,0 +1,24 @@ +package org.hypertrace.graphql.spanprocessing.schema.rule.filter; + +import graphql.annotations.annotationTypes.GraphQLField; +import graphql.annotations.annotationTypes.GraphQLName; +import graphql.annotations.annotationTypes.GraphQLNonNull; +import java.util.List; + +@GraphQLName(SpanProcessingLogicalFilter.TYPE_NAME) +public interface SpanProcessingLogicalFilter { + String TYPE_NAME = "SpanProcessingLogicalFilter"; + + String SPAN_PROCESSING_FILTERS_KEY = "spanFilters"; + String SPAN_PROCESSING_LOGICAL_OPERATOR_KEY = "logicalOperator"; + + @GraphQLField + @GraphQLName(SPAN_PROCESSING_LOGICAL_OPERATOR_KEY) + @GraphQLNonNull + SpanProcessingLogicalOperator logicalOperator(); + + @GraphQLField + @GraphQLName(SPAN_PROCESSING_FILTERS_KEY) + @GraphQLNonNull + List spanFilters(); +} diff --git a/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/schema/rule/filter/SpanProcessingLogicalOperator.java b/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/schema/rule/filter/SpanProcessingLogicalOperator.java new file mode 100644 index 00000000..45d646f2 --- /dev/null +++ b/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/schema/rule/filter/SpanProcessingLogicalOperator.java @@ -0,0 +1,10 @@ +package org.hypertrace.graphql.spanprocessing.schema.rule.filter; + +import graphql.annotations.annotationTypes.GraphQLName; + +@GraphQLName(SpanProcessingLogicalOperator.TYPE_NAME) +public enum SpanProcessingLogicalOperator { + AND, + OR; + static final String TYPE_NAME = "SpanProcessingLogicalOperator"; +} diff --git a/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/schema/rule/filter/SpanProcessingRelationalFilter.java b/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/schema/rule/filter/SpanProcessingRelationalFilter.java new file mode 100644 index 00000000..ca3b8e50 --- /dev/null +++ b/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/schema/rule/filter/SpanProcessingRelationalFilter.java @@ -0,0 +1,34 @@ +package org.hypertrace.graphql.spanprocessing.schema.rule.filter; + +import static org.hypertrace.core.graphql.common.schema.results.arguments.filter.FilterArgument.FILTER_ARGUMENT_VALUE; + +import graphql.annotations.annotationTypes.GraphQLField; +import graphql.annotations.annotationTypes.GraphQLName; +import graphql.annotations.annotationTypes.GraphQLNonNull; + +@GraphQLName(SpanProcessingRelationalFilter.TYPE_NAME) +public interface SpanProcessingRelationalFilter { + String TYPE_NAME = "SpanProcessingRelationalFilter"; + + String RELATION_OPERATOR_KEY = "relationalOperator"; + String SPAN_PROCESSING_FILTER_FIELD_KEY = "field"; + String SPAN_PROCESSING_FILTER_KEY_KEY = "key"; + + @GraphQLField + @GraphQLName(SPAN_PROCESSING_FILTER_KEY_KEY) + String key(); + + @GraphQLField + @GraphQLName(SPAN_PROCESSING_FILTER_FIELD_KEY) + SpanProcessingFilterField field(); + + @GraphQLField + @GraphQLName(RELATION_OPERATOR_KEY) + @GraphQLNonNull + SpanProcessingRelationalOperator relationalOperator(); + + @GraphQLField + @GraphQLName(FILTER_ARGUMENT_VALUE) + @GraphQLNonNull + Object value(); +} diff --git a/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/schema/rule/filter/SpanProcessingRelationalOperator.java b/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/schema/rule/filter/SpanProcessingRelationalOperator.java new file mode 100644 index 00000000..81499e02 --- /dev/null +++ b/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/schema/rule/filter/SpanProcessingRelationalOperator.java @@ -0,0 +1,14 @@ +package org.hypertrace.graphql.spanprocessing.schema.rule.filter; + +import graphql.annotations.annotationTypes.GraphQLName; + +@GraphQLName(SpanProcessingRelationalOperator.TYPE_NAME) +public enum SpanProcessingRelationalOperator { + EQUALS, + NOT_EQUALS, + CONTAINS, + STARTS_WITH, + ENDS_WITH, + REGEX_MATCH; + static final String TYPE_NAME = "SpanProcessingRelationalOperator"; +} diff --git a/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/schema/rule/filter/SpanProcessingRuleFilter.java b/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/schema/rule/filter/SpanProcessingRuleFilter.java new file mode 100644 index 00000000..87f3b603 --- /dev/null +++ b/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/schema/rule/filter/SpanProcessingRuleFilter.java @@ -0,0 +1,20 @@ +package org.hypertrace.graphql.spanprocessing.schema.rule.filter; + +import graphql.annotations.annotationTypes.GraphQLField; +import graphql.annotations.annotationTypes.GraphQLName; + +@GraphQLName(SpanProcessingRuleFilter.TYPE_NAME) +public interface SpanProcessingRuleFilter { + String TYPE_NAME = "SpanProcessingRuleFilter"; + + String SPAN_PROCESSING_LOGICAL_FILTER_KEY = "logicalSpanFilter"; + String SPAN_PROCESSING_RELATIONAL_FILTER_KEY = "relationalSpanFilter"; + + @GraphQLField + @GraphQLName(SPAN_PROCESSING_LOGICAL_FILTER_KEY) + SpanProcessingLogicalFilter logicalSpanFilter(); + + @GraphQLField + @GraphQLName(SPAN_PROCESSING_RELATIONAL_FILTER_KEY) + SpanProcessingRelationalFilter relationalSpanFilter(); +} diff --git a/settings.gradle.kts b/settings.gradle.kts index b32a7d46..01779588 100644 --- a/settings.gradle.kts +++ b/settings.gradle.kts @@ -27,3 +27,4 @@ include(":hypertrace-graphql-platform") include(":hypertrace-graphql-spaces-schema") include(":hypertrace-graphql-labels-schema-api") include(":hypertrace-graphql-labels-schema-impl") +include(":hypertrace-graphql-span-processing-schema")