diff --git a/hypertrace-graphql-platform/build.gradle.kts b/hypertrace-graphql-platform/build.gradle.kts index c2734516..7d61c6c6 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.26") + api("org.hypertrace.config.service:span-processing-config-service-api:0.1.27") } } 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 index aabfabb6..7a9d837f 100644 --- 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 @@ -2,6 +2,7 @@ import com.google.common.collect.ImmutableBiMap; import io.reactivex.rxjava3.core.Single; +import java.util.ArrayList; import java.util.List; import java.util.NoSuchElementException; import java.util.Objects; @@ -15,6 +16,7 @@ import org.hypertrace.graphql.spanprocessing.schema.rule.filter.SpanProcessingRelationalOperator; import org.hypertrace.graphql.spanprocessing.schema.rule.filter.SpanProcessingRuleFilter; import org.hypertrace.span.processing.config.service.v1.Field; +import org.hypertrace.span.processing.config.service.v1.ListValue; import org.hypertrace.span.processing.config.service.v1.LogicalOperator; import org.hypertrace.span.processing.config.service.v1.LogicalSpanFilterExpression; import org.hypertrace.span.processing.config.service.v1.RelationalOperator; @@ -56,6 +58,7 @@ public class ConfigServiceSpanFilterConverter { .put( RelationalOperator.RELATIONAL_OPERATOR_REGEX_MATCH, SpanProcessingRelationalOperator.REGEX_MATCH) + .put(RelationalOperator.RELATIONAL_OPERATOR_IN, SpanProcessingRelationalOperator.IN) .build(); private static final ImmutableBiMap @@ -148,11 +151,19 @@ private Object convertSpanFilterValue(SpanFilterValue spanFilterValue) { switch (spanFilterValue.getValueCase()) { case STRING_VALUE: return spanFilterValue.getStringValue(); + case LIST_VALUE: + return convertListSpanFilterValue(spanFilterValue.getListValue()); default: throw new NoSuchElementException("Unsupported right operand type"); } } + private Object convertListSpanFilterValue(ListValue value) { + return value.getValuesList().stream() + .map(this::convertSpanFilterValue) + .collect(Collectors.toUnmodifiableList()); + } + private RelationalSpanFilterExpression convertRelationalFilter( SpanProcessingRelationalFilter spanProcessingRelationalFilter) { RelationalSpanFilterExpression.Builder relationalSpanFilterExpressionBuilder = @@ -180,10 +191,22 @@ private SpanFilterValue convertToSpanFilterValue(Object value) { SpanFilterValue.Builder spanFilterValueBuilder = SpanFilterValue.newBuilder(); if (String.class.equals(value.getClass())) { spanFilterValueBuilder = spanFilterValueBuilder.setStringValue(value.toString()); + } else if (ArrayList.class.equals(value.getClass())) { + spanFilterValueBuilder.setListValue(convertToListSpanFilterValue(value)); } return spanFilterValueBuilder.build(); } + private ListValue convertToListSpanFilterValue(Object value) { + List objectList = (List) value; + return ListValue.newBuilder() + .addAllValues( + objectList.stream() + .map(this::convertToSpanFilterValue) + .collect(Collectors.toUnmodifiableList())) + .build(); + } + @Value @Accessors(fluent = true) private static class ConvertedSpanProcessingRelationalFilter 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 4a46403d..4a43be38 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 @@ -1,5 +1,6 @@ package org.hypertrace.graphql.spanprocessing.dao; +import java.util.NoSuchElementException; import javax.inject.Inject; import org.hypertrace.graphql.spanprocessing.request.mutation.ApiNamingCreateRuleRequest; import org.hypertrace.graphql.spanprocessing.request.mutation.ApiNamingDeleteRuleRequest; @@ -18,6 +19,7 @@ import org.hypertrace.span.processing.config.service.v1.DeleteApiNamingRuleRequest; import org.hypertrace.span.processing.config.service.v1.DeleteExcludeSpanRuleRequest; import org.hypertrace.span.processing.config.service.v1.ExcludeSpanRuleInfo; +import org.hypertrace.span.processing.config.service.v1.SegmentMatchingBasedConfig; import org.hypertrace.span.processing.config.service.v1.UpdateApiNamingRule; import org.hypertrace.span.processing.config.service.v1.UpdateApiNamingRuleRequest; import org.hypertrace.span.processing.config.service.v1.UpdateExcludeSpanRule; @@ -77,14 +79,27 @@ private org.hypertrace.span.processing.config.service.v1.ApiNamingRuleInfo conve .setName(apiNamingRuleCreate.name()) .setFilter(this.filterConverter.convert(apiNamingRuleCreate.spanFilter())) .setDisabled(apiNamingRuleCreate.disabled()) - .setRuleConfig( - ApiNamingRuleConfig.newBuilder() - .setRegex(apiNamingRuleCreate.regex()) - .setValue(apiNamingRuleCreate.value()) - .build()) + .setRuleConfig(convertRuleConfig(apiNamingRuleCreate.apiNamingRuleConfig())) .build(); } + private ApiNamingRuleConfig convertRuleConfig( + org.hypertrace.graphql.spanprocessing.schema.rule.ApiNamingRuleConfig apiNamingRuleConfig) { + switch (apiNamingRuleConfig.apiNamingRuleConfigType()) { + case SEGMENT_MATCHING: + return ApiNamingRuleConfig.newBuilder() + .setSegmentMatchingBasedConfig( + SegmentMatchingBasedConfig.newBuilder() + .addAllRegexes(apiNamingRuleConfig.segmentMatchingBasedRuleConfig().regexes()) + .addAllValues(apiNamingRuleConfig.segmentMatchingBasedRuleConfig().values()) + .build()) + .build(); + default: + throw new NoSuchElementException( + "Unsupported api naming rule config type: " + apiNamingRuleConfig); + } + } + UpdateApiNamingRuleRequest convert(ApiNamingUpdateRuleRequest request) { return UpdateApiNamingRuleRequest.newBuilder() .setRule(convertInput(request.updateInput())) @@ -97,11 +112,7 @@ private UpdateApiNamingRule convertInput(ApiNamingRuleUpdate apiNamingRuleUpdate .setName(apiNamingRuleUpdate.name()) .setFilter(this.filterConverter.convert(apiNamingRuleUpdate.spanFilter())) .setDisabled(apiNamingRuleUpdate.disabled()) - .setRuleConfig( - ApiNamingRuleConfig.newBuilder() - .setRegex(apiNamingRuleUpdate.regex()) - .setValue(apiNamingRuleUpdate.value()) - .build()) + .setRuleConfig(convertRuleConfig(apiNamingRuleUpdate.apiNamingRuleConfig())) .build(); } 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 d83e5532..0e1de001 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 @@ -2,13 +2,19 @@ import io.reactivex.rxjava3.core.Single; import java.time.Instant; +import java.util.List; +import java.util.NoSuchElementException; import javax.inject.Inject; import lombok.Value; import lombok.experimental.Accessors; import org.hypertrace.graphql.spanprocessing.schema.rule.ApiNamingRule; +import org.hypertrace.graphql.spanprocessing.schema.rule.ApiNamingRuleConfig; +import org.hypertrace.graphql.spanprocessing.schema.rule.ApiNamingRuleConfigType; import org.hypertrace.graphql.spanprocessing.schema.rule.ExcludeSpanRule; +import org.hypertrace.graphql.spanprocessing.schema.rule.SegmentMatchingBasedRuleConfig; import org.hypertrace.graphql.spanprocessing.schema.rule.filter.SpanProcessingRuleFilter; import org.hypertrace.span.processing.config.service.v1.ApiNamingRuleDetails; +import org.hypertrace.span.processing.config.service.v1.SegmentMatchingBasedConfig; class ConfigServiceSpanProcessingRuleConverter { @@ -48,8 +54,7 @@ public Single convert(ApiNamingRuleDetails ruleDetails) { ruleDetails.getRule().getRuleInfo().getName(), spanProcessingRuleFilter, ruleDetails.getRule().getRuleInfo().getDisabled(), - ruleDetails.getRule().getRuleInfo().getRuleConfig().getRegex(), - ruleDetails.getRule().getRuleInfo().getRuleConfig().getValue(), + convertApiNamingRuleConfig(ruleDetails.getRule().getRuleInfo().getRuleConfig()), Instant.ofEpochSecond( ruleDetails.getMetadata().getCreationTimestamp().getSeconds(), ruleDetails.getMetadata().getCreationTimestamp().getNanos()), @@ -58,6 +63,22 @@ public Single convert(ApiNamingRuleDetails ruleDetails) { ruleDetails.getMetadata().getLastUpdatedTimestamp().getNanos()))); } + private ApiNamingRuleConfig convertApiNamingRuleConfig( + org.hypertrace.span.processing.config.service.v1.ApiNamingRuleConfig apiNamingRuleConfig) { + switch (apiNamingRuleConfig.getRuleConfigCase()) { + case SEGMENT_MATCHING_BASED_CONFIG: + SegmentMatchingBasedConfig segmentMatchingBasedConfig = + apiNamingRuleConfig.getSegmentMatchingBasedConfig(); + return new ConvertedApiNamingRuleConfig( + ApiNamingRuleConfigType.SEGMENT_MATCHING, + new ConvertedSegmentMatchingBasedRuleConfig( + segmentMatchingBasedConfig.getRegexesList(), + segmentMatchingBasedConfig.getValuesList())); + default: + throw new NoSuchElementException("Unsupported Rule config type: " + apiNamingRuleConfig); + } + } + @Value @Accessors(fluent = true) private static class ConvertedExcludeSpanRule implements ExcludeSpanRule { @@ -76,9 +97,23 @@ private static class ConvertedApiNamingRule implements ApiNamingRule { String name; SpanProcessingRuleFilter spanFilter; boolean disabled; - String regex; - String value; + ApiNamingRuleConfig apiNamingRuleConfig; Instant creationTime; Instant lastUpdatedTime; } + + @Value + @Accessors(fluent = true) + private static class ConvertedApiNamingRuleConfig implements ApiNamingRuleConfig { + ApiNamingRuleConfigType apiNamingRuleConfigType; + SegmentMatchingBasedRuleConfig segmentMatchingBasedRuleConfig; + } + + @Value + @Accessors(fluent = true) + private static class ConvertedSegmentMatchingBasedRuleConfig + implements SegmentMatchingBasedRuleConfig { + List regexes; + List values; + } } diff --git a/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/deserialization/ApiNamingCreateInputDeserializationConfig.java b/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/deserialization/ApiNamingCreateInputDeserializationConfig.java index 503aad40..22d9ef50 100644 --- a/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/deserialization/ApiNamingCreateInputDeserializationConfig.java +++ b/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/deserialization/ApiNamingCreateInputDeserializationConfig.java @@ -9,6 +9,8 @@ import lombok.extern.jackson.Jacksonized; import org.hypertrace.core.graphql.deserialization.ArgumentDeserializationConfig; import org.hypertrace.graphql.spanprocessing.schema.mutation.ApiNamingRuleCreate; +import org.hypertrace.graphql.spanprocessing.schema.rule.ApiNamingRuleConfig; +import org.hypertrace.graphql.spanprocessing.schema.rule.SegmentMatchingBasedRuleConfig; import org.hypertrace.graphql.spanprocessing.schema.rule.filter.SpanProcessingLogicalFilter; import org.hypertrace.graphql.spanprocessing.schema.rule.filter.SpanProcessingRelationalFilter; import org.hypertrace.graphql.spanprocessing.schema.rule.filter.SpanProcessingRuleFilter; @@ -29,6 +31,9 @@ public List jacksonModules() { return List.of( new SimpleModule() .addAbstractTypeMapping(ApiNamingRuleCreate.class, DefaultApiNamingRuleCreate.class) + .addAbstractTypeMapping(ApiNamingRuleConfig.class, DefaultApiNamingRuleConfig.class) + .addAbstractTypeMapping( + SegmentMatchingBasedRuleConfig.class, DefaultSegmentMatchingBasedRuleConfig.class) .addAbstractTypeMapping( SpanProcessingRuleFilter.class, DefaultSpanProcessingRuleFilter.class) .addAbstractTypeMapping( @@ -44,8 +49,7 @@ public List jacksonModules() { private static class DefaultApiNamingRuleCreate implements ApiNamingRuleCreate { String name; SpanProcessingRuleFilter spanFilter; - String regex; - String value; + ApiNamingRuleConfig apiNamingRuleConfig; boolean disabled; } } diff --git a/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/deserialization/ApiNamingUpdateInputDeserializationConfig.java b/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/deserialization/ApiNamingUpdateInputDeserializationConfig.java index 0152c780..333f226d 100644 --- a/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/deserialization/ApiNamingUpdateInputDeserializationConfig.java +++ b/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/deserialization/ApiNamingUpdateInputDeserializationConfig.java @@ -9,6 +9,8 @@ import lombok.extern.jackson.Jacksonized; import org.hypertrace.core.graphql.deserialization.ArgumentDeserializationConfig; import org.hypertrace.graphql.spanprocessing.schema.mutation.ApiNamingRuleUpdate; +import org.hypertrace.graphql.spanprocessing.schema.rule.ApiNamingRuleConfig; +import org.hypertrace.graphql.spanprocessing.schema.rule.SegmentMatchingBasedRuleConfig; import org.hypertrace.graphql.spanprocessing.schema.rule.filter.SpanProcessingLogicalFilter; import org.hypertrace.graphql.spanprocessing.schema.rule.filter.SpanProcessingRelationalFilter; import org.hypertrace.graphql.spanprocessing.schema.rule.filter.SpanProcessingRuleFilter; @@ -29,6 +31,9 @@ public List jacksonModules() { return List.of( new SimpleModule() .addAbstractTypeMapping(ApiNamingRuleUpdate.class, DefaultApiNamingRuleUpdate.class) + .addAbstractTypeMapping(ApiNamingRuleConfig.class, DefaultApiNamingRuleConfig.class) + .addAbstractTypeMapping( + SegmentMatchingBasedRuleConfig.class, DefaultSegmentMatchingBasedRuleConfig.class) .addAbstractTypeMapping( SpanProcessingRuleFilter.class, DefaultSpanProcessingRuleFilter.class) .addAbstractTypeMapping( @@ -46,7 +51,6 @@ private static class DefaultApiNamingRuleUpdate implements ApiNamingRuleUpdate { String name; SpanProcessingRuleFilter spanFilter; boolean disabled; - String regex; - String value; + ApiNamingRuleConfig apiNamingRuleConfig; } } diff --git a/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/deserialization/DefaultApiNamingRuleConfig.java b/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/deserialization/DefaultApiNamingRuleConfig.java new file mode 100644 index 00000000..d7e1a747 --- /dev/null +++ b/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/deserialization/DefaultApiNamingRuleConfig.java @@ -0,0 +1,18 @@ +package org.hypertrace.graphql.spanprocessing.deserialization; + +import lombok.Builder; +import lombok.Value; +import lombok.experimental.Accessors; +import lombok.extern.jackson.Jacksonized; +import org.hypertrace.graphql.spanprocessing.schema.rule.ApiNamingRuleConfig; +import org.hypertrace.graphql.spanprocessing.schema.rule.ApiNamingRuleConfigType; +import org.hypertrace.graphql.spanprocessing.schema.rule.SegmentMatchingBasedRuleConfig; + +@Value +@Accessors(fluent = true) +@Jacksonized +@Builder +public class DefaultApiNamingRuleConfig implements ApiNamingRuleConfig { + ApiNamingRuleConfigType apiNamingRuleConfigType; + SegmentMatchingBasedRuleConfig segmentMatchingBasedRuleConfig; +} diff --git a/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/deserialization/DefaultSegmentMatchingBasedRuleConfig.java b/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/deserialization/DefaultSegmentMatchingBasedRuleConfig.java new file mode 100644 index 00000000..7079e640 --- /dev/null +++ b/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/deserialization/DefaultSegmentMatchingBasedRuleConfig.java @@ -0,0 +1,17 @@ +package org.hypertrace.graphql.spanprocessing.deserialization; + +import java.util.List; +import lombok.Builder; +import lombok.Value; +import lombok.experimental.Accessors; +import lombok.extern.jackson.Jacksonized; +import org.hypertrace.graphql.spanprocessing.schema.rule.SegmentMatchingBasedRuleConfig; + +@Value +@Accessors(fluent = true) +@Jacksonized +@Builder +public class DefaultSegmentMatchingBasedRuleConfig implements SegmentMatchingBasedRuleConfig { + List regexes; + List values; +} diff --git a/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/schema/mutation/ApiNamingRuleUpdate.java b/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/schema/mutation/ApiNamingRuleUpdate.java index aa11d98f..f5d1ed7d 100644 --- a/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/schema/mutation/ApiNamingRuleUpdate.java +++ b/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/schema/mutation/ApiNamingRuleUpdate.java @@ -4,6 +4,7 @@ import graphql.annotations.annotationTypes.GraphQLName; import graphql.annotations.annotationTypes.GraphQLNonNull; import org.hypertrace.core.graphql.common.schema.id.Identifiable; +import org.hypertrace.graphql.spanprocessing.schema.rule.ApiNamingRuleConfig; import org.hypertrace.graphql.spanprocessing.schema.rule.filter.SpanProcessingRuleFilter; @GraphQLName(ApiNamingRuleUpdate.TYPE_NAME) @@ -14,8 +15,7 @@ public interface ApiNamingRuleUpdate extends Identifiable { String NAME_KEY = "name"; String SPAN_PROCESSING_FILTER_KEY = "spanFilter"; String DISABLED_KEY = "disabled"; - String REGEX_KEY = "regex"; - String VALUE_KEY = "value"; + String API_NAMING_RULE_CONFIG_KEY = "apiNamingRuleConfig"; @GraphQLField @GraphQLName(NAME_KEY) @@ -33,12 +33,7 @@ public interface ApiNamingRuleUpdate extends Identifiable { boolean disabled(); @GraphQLField - @GraphQLName(REGEX_KEY) + @GraphQLName(API_NAMING_RULE_CONFIG_KEY) @GraphQLNonNull - String regex(); - - @GraphQLField - @GraphQLName(VALUE_KEY) - @GraphQLNonNull - String value(); + ApiNamingRuleConfig apiNamingRuleConfig(); } diff --git a/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/schema/rule/ApiNamingRuleConfig.java b/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/schema/rule/ApiNamingRuleConfig.java new file mode 100644 index 00000000..7ddebd27 --- /dev/null +++ b/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/schema/rule/ApiNamingRuleConfig.java @@ -0,0 +1,22 @@ +package org.hypertrace.graphql.spanprocessing.schema.rule; + +import graphql.annotations.annotationTypes.GraphQLField; +import graphql.annotations.annotationTypes.GraphQLName; +import graphql.annotations.annotationTypes.GraphQLNonNull; + +@GraphQLName(ApiNamingRuleConfig.TYPE_NAME) +public interface ApiNamingRuleConfig { + String TYPE_NAME = "ApiNamingRuleConfig"; + + String API_NAMING_RULE_CONFIG_TYPE = "apiNamingRuleConfigType"; + String SEGMENT_MATCHING_BASED_RULE_CONFIG_TYPE = "segmentMatchingBasedRuleConfig"; + + @GraphQLField + @GraphQLName(API_NAMING_RULE_CONFIG_TYPE) + @GraphQLNonNull + ApiNamingRuleConfigType apiNamingRuleConfigType(); + + @GraphQLField + @GraphQLName(SEGMENT_MATCHING_BASED_RULE_CONFIG_TYPE) + SegmentMatchingBasedRuleConfig segmentMatchingBasedRuleConfig(); +} diff --git a/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/schema/rule/ApiNamingRuleConfigType.java b/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/schema/rule/ApiNamingRuleConfigType.java new file mode 100644 index 00000000..7e21b66c --- /dev/null +++ b/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/schema/rule/ApiNamingRuleConfigType.java @@ -0,0 +1,9 @@ +package org.hypertrace.graphql.spanprocessing.schema.rule; + +import graphql.annotations.annotationTypes.GraphQLName; + +@GraphQLName(ApiNamingRuleConfigType.TYPE_NAME) +public enum ApiNamingRuleConfigType { + SEGMENT_MATCHING; + static final String TYPE_NAME = "ApiNamingRuleConfigType"; +} diff --git a/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/schema/rule/ApiNamingRuleInfo.java b/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/schema/rule/ApiNamingRuleInfo.java index 18e8b157..c4a4e3b8 100644 --- a/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/schema/rule/ApiNamingRuleInfo.java +++ b/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/schema/rule/ApiNamingRuleInfo.java @@ -5,15 +5,14 @@ import graphql.annotations.annotationTypes.GraphQLNonNull; import org.hypertrace.graphql.spanprocessing.schema.rule.filter.SpanProcessingRuleFilter; -@GraphQLName(ExcludeSpanRuleInfo.TYPE_NAME) +@GraphQLName(ApiNamingRuleInfo.TYPE_NAME) public interface ApiNamingRuleInfo { String TYPE_NAME = "ApiNamingRuleInfo"; String NAME_KEY = "name"; String SPAN_FILTER_KEY = "spanFilter"; String DISABLED_KEY = "disabled"; - String REGEX_KEY = "regex"; - String VALUE_KEY = "value"; + String API_NAMING_RULE_CONFIG_KEY = "apiNamingRuleConfig"; @GraphQLField @GraphQLName(NAME_KEY) @@ -26,14 +25,9 @@ public interface ApiNamingRuleInfo { SpanProcessingRuleFilter spanFilter(); @GraphQLField - @GraphQLName(REGEX_KEY) + @GraphQLName(API_NAMING_RULE_CONFIG_KEY) @GraphQLNonNull - String regex(); - - @GraphQLField - @GraphQLName(VALUE_KEY) - @GraphQLNonNull - String value(); + ApiNamingRuleConfig apiNamingRuleConfig(); @GraphQLField @GraphQLName(DISABLED_KEY) diff --git a/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/schema/rule/SegmentMatchingBasedRuleConfig.java b/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/schema/rule/SegmentMatchingBasedRuleConfig.java new file mode 100644 index 00000000..be790856 --- /dev/null +++ b/hypertrace-graphql-span-processing-schema/src/main/java/org/hypertrace/graphql/spanprocessing/schema/rule/SegmentMatchingBasedRuleConfig.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 java.util.List; + +@GraphQLName(SegmentMatchingBasedRuleConfig.TYPE_NAME) +public interface SegmentMatchingBasedRuleConfig { + String TYPE_NAME = "SegmentMatchingBasedRuleConfig"; + + String REGEXES_KEY = "regexes"; + String VALUES_KEY = "values"; + + @GraphQLField + @GraphQLName(REGEXES_KEY) + @GraphQLNonNull + List regexes(); + + @GraphQLField + @GraphQLName(VALUES_KEY) + @GraphQLNonNull + List values(); +} 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 index 81499e02..a56fd19a 100644 --- 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 @@ -9,6 +9,7 @@ public enum SpanProcessingRelationalOperator { CONTAINS, STARTS_WITH, ENDS_WITH, - REGEX_MATCH; + REGEX_MATCH, + IN; static final String TYPE_NAME = "SpanProcessingRelationalOperator"; }