diff --git a/.generator/schemas/v2/openapi.yaml b/.generator/schemas/v2/openapi.yaml index c2aa6fb6864..1d90d8e9090 100644 --- a/.generator/schemas/v2/openapi.yaml +++ b/.generator/schemas/v2/openapi.yaml @@ -70300,6 +70300,8 @@ components: $ref: "#/components/schemas/ObservabilityPipelineTagCardinalityLimitProcessorPerMetricLimit" maxItems: 100 type: array + tracking_mode: + $ref: "#/components/schemas/ObservabilityPipelineTagCardinalityLimitProcessorTrackingMode" type: $ref: "#/components/schemas/ObservabilityPipelineTagCardinalityLimitProcessorType" value_limit: @@ -70314,6 +70316,7 @@ components: - type - include - limit_exceeded_action + - tracking_mode - value_limit - enabled type: object @@ -70328,6 +70331,16 @@ components: x-enum-varnames: - DROP_TAG - DROP_EVENT + ObservabilityPipelineTagCardinalityLimitProcessorOverrideType: + description: How the override is applied. `limit_override` enforces a custom limit; `excluded` omits the metric or tag from cardinality tracking. + enum: + - limit_override + - excluded + example: limit_override + type: string + x-enum-varnames: + - LIMIT_OVERRIDE + - EXCLUDED ObservabilityPipelineTagCardinalityLimitProcessorPerMetricLimit: description: A cardinality override applied to a specific metric. properties: @@ -70337,16 +70350,16 @@ components: description: The name of the metric this override applies to. example: "system.cpu.user" type: string - mode: - $ref: "#/components/schemas/ObservabilityPipelineTagCardinalityLimitProcessorPerMetricMode" + override_type: + $ref: "#/components/schemas/ObservabilityPipelineTagCardinalityLimitProcessorOverrideType" per_tag_limits: - description: A list of per-tag cardinality overrides that apply within this metric. Must be omitted when `mode` is `excluded`. + description: A list of per-tag cardinality overrides that apply within this metric. Must be omitted when `override_type` is `excluded`. items: $ref: "#/components/schemas/ObservabilityPipelineTagCardinalityLimitProcessorPerTagLimit" maxItems: 50 type: array value_limit: - description: The maximum number of distinct tag value combinations allowed for this metric. Required when `mode` is `tracked`. Must be omitted when `mode` is `excluded`. + description: The maximum number of distinct tag value combinations allowed for this metric. Required when `override_type` is `limit_override`. Must be omitted when `override_type` is `excluded`. example: 10000 format: int64 maximum: 1000000 @@ -70354,29 +70367,19 @@ components: type: integer required: - metric_name - - mode + - override_type type: object - ObservabilityPipelineTagCardinalityLimitProcessorPerMetricMode: - description: How the per-metric override is applied. `tracked` enforces a custom limit; `excluded` skips the metric entirely. - enum: - - tracked - - excluded - example: tracked - type: string - x-enum-varnames: - - TRACKED - - EXCLUDED ObservabilityPipelineTagCardinalityLimitProcessorPerTagLimit: description: A cardinality override for a specific tag key within a per-metric limit. properties: - mode: - $ref: "#/components/schemas/ObservabilityPipelineTagCardinalityLimitProcessorPerTagMode" + override_type: + $ref: "#/components/schemas/ObservabilityPipelineTagCardinalityLimitProcessorOverrideType" tag_key: description: The tag key this override applies to. example: "host" type: string value_limit: - description: The maximum number of distinct values allowed for this tag. Required when `mode` is `limit_override`. Must be omitted when `mode` is `excluded`. + description: The maximum number of distinct values allowed for this tag. Required when `override_type` is `limit_override`. Must be omitted when `override_type` is `excluded`. example: 5000 format: int64 maximum: 1000000 @@ -70384,18 +70387,26 @@ components: type: integer required: - tag_key + - override_type + type: object + ObservabilityPipelineTagCardinalityLimitProcessorTrackingMode: + description: Controls whether the processor uses exact or probabilistic tag tracking. + properties: + mode: + $ref: "#/components/schemas/ObservabilityPipelineTagCardinalityLimitProcessorTrackingModeMode" + required: - mode type: object - ObservabilityPipelineTagCardinalityLimitProcessorPerTagMode: - description: How the per-tag override is applied. `limit_override` enforces a custom limit on the tag; `excluded` skips the tag from cardinality tracking. + ObservabilityPipelineTagCardinalityLimitProcessorTrackingModeMode: + description: The cardinality tracking algorithm to use. enum: - - limit_override - - excluded - example: limit_override + - exact_fingerprint + - probabilistic + example: exact_fingerprint type: string x-enum-varnames: - - LIMIT_OVERRIDE - - EXCLUDED + - EXACT_FINGERPRINT + - PROBABILISTIC ObservabilityPipelineTagCardinalityLimitProcessorType: default: tag_cardinality_limit description: The processor type. The value must be `tag_cardinality_limit`. diff --git a/src/main/java/com/datadog/api/client/v2/model/ObservabilityPipelineTagCardinalityLimitProcessor.java b/src/main/java/com/datadog/api/client/v2/model/ObservabilityPipelineTagCardinalityLimitProcessor.java index 18f6e5f55c5..b96afe55b96 100644 --- a/src/main/java/com/datadog/api/client/v2/model/ObservabilityPipelineTagCardinalityLimitProcessor.java +++ b/src/main/java/com/datadog/api/client/v2/model/ObservabilityPipelineTagCardinalityLimitProcessor.java @@ -32,6 +32,7 @@ ObservabilityPipelineTagCardinalityLimitProcessor.JSON_PROPERTY_INCLUDE, ObservabilityPipelineTagCardinalityLimitProcessor.JSON_PROPERTY_LIMIT_EXCEEDED_ACTION, ObservabilityPipelineTagCardinalityLimitProcessor.JSON_PROPERTY_PER_METRIC_LIMITS, + ObservabilityPipelineTagCardinalityLimitProcessor.JSON_PROPERTY_TRACKING_MODE, ObservabilityPipelineTagCardinalityLimitProcessor.JSON_PROPERTY_TYPE, ObservabilityPipelineTagCardinalityLimitProcessor.JSON_PROPERTY_VALUE_LIMIT }) @@ -58,6 +59,9 @@ public class ObservabilityPipelineTagCardinalityLimitProcessor { private List perMetricLimits = null; + public static final String JSON_PROPERTY_TRACKING_MODE = "tracking_mode"; + private ObservabilityPipelineTagCardinalityLimitProcessorTrackingMode trackingMode; + public static final String JSON_PROPERTY_TYPE = "type"; private ObservabilityPipelineTagCardinalityLimitProcessorType type = ObservabilityPipelineTagCardinalityLimitProcessorType.TAG_CARDINALITY_LIMIT; @@ -74,6 +78,8 @@ public ObservabilityPipelineTagCardinalityLimitProcessor( @JsonProperty(required = true, value = JSON_PROPERTY_INCLUDE) String include, @JsonProperty(required = true, value = JSON_PROPERTY_LIMIT_EXCEEDED_ACTION) ObservabilityPipelineTagCardinalityLimitProcessorAction limitExceededAction, + @JsonProperty(required = true, value = JSON_PROPERTY_TRACKING_MODE) + ObservabilityPipelineTagCardinalityLimitProcessorTrackingMode trackingMode, @JsonProperty(required = true, value = JSON_PROPERTY_TYPE) ObservabilityPipelineTagCardinalityLimitProcessorType type, @JsonProperty(required = true, value = JSON_PROPERTY_VALUE_LIMIT) Long valueLimit) { @@ -82,6 +88,8 @@ public ObservabilityPipelineTagCardinalityLimitProcessor( this.include = include; this.limitExceededAction = limitExceededAction; this.unparsed |= !limitExceededAction.isValid(); + this.trackingMode = trackingMode; + this.unparsed |= trackingMode.unparsed; this.type = type; this.unparsed |= !type.isValid(); this.valueLimit = valueLimit; @@ -233,6 +241,29 @@ public void setPerMetricLimits( this.perMetricLimits = perMetricLimits; } + public ObservabilityPipelineTagCardinalityLimitProcessor trackingMode( + ObservabilityPipelineTagCardinalityLimitProcessorTrackingMode trackingMode) { + this.trackingMode = trackingMode; + this.unparsed |= trackingMode.unparsed; + return this; + } + + /** + * Controls whether the processor uses exact or probabilistic tag tracking. + * + * @return trackingMode + */ + @JsonProperty(JSON_PROPERTY_TRACKING_MODE) + @JsonInclude(value = JsonInclude.Include.ALWAYS) + public ObservabilityPipelineTagCardinalityLimitProcessorTrackingMode getTrackingMode() { + return trackingMode; + } + + public void setTrackingMode( + ObservabilityPipelineTagCardinalityLimitProcessorTrackingMode trackingMode) { + this.trackingMode = trackingMode; + } + public ObservabilityPipelineTagCardinalityLimitProcessor type( ObservabilityPipelineTagCardinalityLimitProcessorType type) { this.type = type; @@ -348,6 +379,8 @@ public boolean equals(Object o) { observabilityPipelineTagCardinalityLimitProcessor.limitExceededAction) && Objects.equals( this.perMetricLimits, observabilityPipelineTagCardinalityLimitProcessor.perMetricLimits) + && Objects.equals( + this.trackingMode, observabilityPipelineTagCardinalityLimitProcessor.trackingMode) && Objects.equals(this.type, observabilityPipelineTagCardinalityLimitProcessor.type) && Objects.equals( this.valueLimit, observabilityPipelineTagCardinalityLimitProcessor.valueLimit) @@ -365,6 +398,7 @@ public int hashCode() { include, limitExceededAction, perMetricLimits, + trackingMode, type, valueLimit, additionalProperties); @@ -382,6 +416,7 @@ public String toString() { .append(toIndentedString(limitExceededAction)) .append("\n"); sb.append(" perMetricLimits: ").append(toIndentedString(perMetricLimits)).append("\n"); + sb.append(" trackingMode: ").append(toIndentedString(trackingMode)).append("\n"); sb.append(" type: ").append(toIndentedString(type)).append("\n"); sb.append(" valueLimit: ").append(toIndentedString(valueLimit)).append("\n"); sb.append(" additionalProperties: ") diff --git a/src/main/java/com/datadog/api/client/v2/model/ObservabilityPipelineTagCardinalityLimitProcessorPerTagMode.java b/src/main/java/com/datadog/api/client/v2/model/ObservabilityPipelineTagCardinalityLimitProcessorOverrideType.java similarity index 58% rename from src/main/java/com/datadog/api/client/v2/model/ObservabilityPipelineTagCardinalityLimitProcessorPerTagMode.java rename to src/main/java/com/datadog/api/client/v2/model/ObservabilityPipelineTagCardinalityLimitProcessorOverrideType.java index 6ea8b34f1f9..91a42170d11 100644 --- a/src/main/java/com/datadog/api/client/v2/model/ObservabilityPipelineTagCardinalityLimitProcessorPerTagMode.java +++ b/src/main/java/com/datadog/api/client/v2/model/ObservabilityPipelineTagCardinalityLimitProcessorOverrideType.java @@ -19,41 +19,42 @@ import java.util.Set; /** - * How the per-tag override is applied. limit_override enforces a custom limit on the - * tag; excluded skips the tag from cardinality tracking. + * How the override is applied. limit_override enforces a custom limit; excluded + * omits the metric or tag from cardinality tracking. */ @JsonSerialize( using = - ObservabilityPipelineTagCardinalityLimitProcessorPerTagMode - .ObservabilityPipelineTagCardinalityLimitProcessorPerTagModeSerializer.class) -public class ObservabilityPipelineTagCardinalityLimitProcessorPerTagMode extends ModelEnum { + ObservabilityPipelineTagCardinalityLimitProcessorOverrideType + .ObservabilityPipelineTagCardinalityLimitProcessorOverrideTypeSerializer.class) +public class ObservabilityPipelineTagCardinalityLimitProcessorOverrideType + extends ModelEnum { private static final Set allowedValues = new HashSet(Arrays.asList("limit_override", "excluded")); - public static final ObservabilityPipelineTagCardinalityLimitProcessorPerTagMode LIMIT_OVERRIDE = - new ObservabilityPipelineTagCardinalityLimitProcessorPerTagMode("limit_override"); - public static final ObservabilityPipelineTagCardinalityLimitProcessorPerTagMode EXCLUDED = - new ObservabilityPipelineTagCardinalityLimitProcessorPerTagMode("excluded"); + public static final ObservabilityPipelineTagCardinalityLimitProcessorOverrideType LIMIT_OVERRIDE = + new ObservabilityPipelineTagCardinalityLimitProcessorOverrideType("limit_override"); + public static final ObservabilityPipelineTagCardinalityLimitProcessorOverrideType EXCLUDED = + new ObservabilityPipelineTagCardinalityLimitProcessorOverrideType("excluded"); - ObservabilityPipelineTagCardinalityLimitProcessorPerTagMode(String value) { + ObservabilityPipelineTagCardinalityLimitProcessorOverrideType(String value) { super(value, allowedValues); } - public static class ObservabilityPipelineTagCardinalityLimitProcessorPerTagModeSerializer - extends StdSerializer { - public ObservabilityPipelineTagCardinalityLimitProcessorPerTagModeSerializer( - Class t) { + public static class ObservabilityPipelineTagCardinalityLimitProcessorOverrideTypeSerializer + extends StdSerializer { + public ObservabilityPipelineTagCardinalityLimitProcessorOverrideTypeSerializer( + Class t) { super(t); } - public ObservabilityPipelineTagCardinalityLimitProcessorPerTagModeSerializer() { + public ObservabilityPipelineTagCardinalityLimitProcessorOverrideTypeSerializer() { this(null); } @Override public void serialize( - ObservabilityPipelineTagCardinalityLimitProcessorPerTagMode value, + ObservabilityPipelineTagCardinalityLimitProcessorOverrideType value, JsonGenerator jgen, SerializerProvider provider) throws IOException, JsonProcessingException { @@ -62,8 +63,8 @@ public void serialize( } @JsonCreator - public static ObservabilityPipelineTagCardinalityLimitProcessorPerTagMode fromValue( + public static ObservabilityPipelineTagCardinalityLimitProcessorOverrideType fromValue( String value) { - return new ObservabilityPipelineTagCardinalityLimitProcessorPerTagMode(value); + return new ObservabilityPipelineTagCardinalityLimitProcessorOverrideType(value); } } diff --git a/src/main/java/com/datadog/api/client/v2/model/ObservabilityPipelineTagCardinalityLimitProcessorPerMetricLimit.java b/src/main/java/com/datadog/api/client/v2/model/ObservabilityPipelineTagCardinalityLimitProcessorPerMetricLimit.java index b3bea91a9de..f7ee517c365 100644 --- a/src/main/java/com/datadog/api/client/v2/model/ObservabilityPipelineTagCardinalityLimitProcessorPerMetricLimit.java +++ b/src/main/java/com/datadog/api/client/v2/model/ObservabilityPipelineTagCardinalityLimitProcessorPerMetricLimit.java @@ -24,7 +24,7 @@ ObservabilityPipelineTagCardinalityLimitProcessorPerMetricLimit .JSON_PROPERTY_LIMIT_EXCEEDED_ACTION, ObservabilityPipelineTagCardinalityLimitProcessorPerMetricLimit.JSON_PROPERTY_METRIC_NAME, - ObservabilityPipelineTagCardinalityLimitProcessorPerMetricLimit.JSON_PROPERTY_MODE, + ObservabilityPipelineTagCardinalityLimitProcessorPerMetricLimit.JSON_PROPERTY_OVERRIDE_TYPE, ObservabilityPipelineTagCardinalityLimitProcessorPerMetricLimit.JSON_PROPERTY_PER_TAG_LIMITS, ObservabilityPipelineTagCardinalityLimitProcessorPerMetricLimit.JSON_PROPERTY_VALUE_LIMIT }) @@ -38,8 +38,8 @@ public class ObservabilityPipelineTagCardinalityLimitProcessorPerMetricLimit { public static final String JSON_PROPERTY_METRIC_NAME = "metric_name"; private String metricName; - public static final String JSON_PROPERTY_MODE = "mode"; - private ObservabilityPipelineTagCardinalityLimitProcessorPerMetricMode mode; + public static final String JSON_PROPERTY_OVERRIDE_TYPE = "override_type"; + private ObservabilityPipelineTagCardinalityLimitProcessorOverrideType overrideType; public static final String JSON_PROPERTY_PER_TAG_LIMITS = "per_tag_limits"; private List perTagLimits = null; @@ -52,11 +52,11 @@ public ObservabilityPipelineTagCardinalityLimitProcessorPerMetricLimit() {} @JsonCreator public ObservabilityPipelineTagCardinalityLimitProcessorPerMetricLimit( @JsonProperty(required = true, value = JSON_PROPERTY_METRIC_NAME) String metricName, - @JsonProperty(required = true, value = JSON_PROPERTY_MODE) - ObservabilityPipelineTagCardinalityLimitProcessorPerMetricMode mode) { + @JsonProperty(required = true, value = JSON_PROPERTY_OVERRIDE_TYPE) + ObservabilityPipelineTagCardinalityLimitProcessorOverrideType overrideType) { this.metricName = metricName; - this.mode = mode; - this.unparsed |= !mode.isValid(); + this.overrideType = overrideType; + this.unparsed |= !overrideType.isValid(); } public ObservabilityPipelineTagCardinalityLimitProcessorPerMetricLimit limitExceededAction( @@ -107,30 +107,31 @@ public void setMetricName(String metricName) { this.metricName = metricName; } - public ObservabilityPipelineTagCardinalityLimitProcessorPerMetricLimit mode( - ObservabilityPipelineTagCardinalityLimitProcessorPerMetricMode mode) { - this.mode = mode; - this.unparsed |= !mode.isValid(); + public ObservabilityPipelineTagCardinalityLimitProcessorPerMetricLimit overrideType( + ObservabilityPipelineTagCardinalityLimitProcessorOverrideType overrideType) { + this.overrideType = overrideType; + this.unparsed |= !overrideType.isValid(); return this; } /** - * How the per-metric override is applied. tracked enforces a custom limit; - * excluded skips the metric entirely. + * How the override is applied. limit_override enforces a custom limit; + * excluded omits the metric or tag from cardinality tracking. * - * @return mode + * @return overrideType */ - @JsonProperty(JSON_PROPERTY_MODE) + @JsonProperty(JSON_PROPERTY_OVERRIDE_TYPE) @JsonInclude(value = JsonInclude.Include.ALWAYS) - public ObservabilityPipelineTagCardinalityLimitProcessorPerMetricMode getMode() { - return mode; + public ObservabilityPipelineTagCardinalityLimitProcessorOverrideType getOverrideType() { + return overrideType; } - public void setMode(ObservabilityPipelineTagCardinalityLimitProcessorPerMetricMode mode) { - if (!mode.isValid()) { + public void setOverrideType( + ObservabilityPipelineTagCardinalityLimitProcessorOverrideType overrideType) { + if (!overrideType.isValid()) { this.unparsed = true; } - this.mode = mode; + this.overrideType = overrideType; } public ObservabilityPipelineTagCardinalityLimitProcessorPerMetricLimit perTagLimits( @@ -154,7 +155,7 @@ public ObservabilityPipelineTagCardinalityLimitProcessorPerMetricLimit addPerTag /** * A list of per-tag cardinality overrides that apply within this metric. Must be omitted when - * mode is excluded. + * override_type is excluded. * * @return perTagLimits */ @@ -178,8 +179,8 @@ public ObservabilityPipelineTagCardinalityLimitProcessorPerMetricLimit valueLimi /** * The maximum number of distinct tag value combinations allowed for this metric. Required when - * mode is tracked. Must be omitted when mode is - * excluded. minimum: 0 maximum: 1000000 + * override_type is limit_override. Must be omitted when + * override_type is excluded. minimum: 0 maximum: 1000000 * * @return valueLimit */ @@ -263,7 +264,8 @@ public boolean equals(Object o) { this.metricName, observabilityPipelineTagCardinalityLimitProcessorPerMetricLimit.metricName) && Objects.equals( - this.mode, observabilityPipelineTagCardinalityLimitProcessorPerMetricLimit.mode) + this.overrideType, + observabilityPipelineTagCardinalityLimitProcessorPerMetricLimit.overrideType) && Objects.equals( this.perTagLimits, observabilityPipelineTagCardinalityLimitProcessorPerMetricLimit.perTagLimits) @@ -278,7 +280,12 @@ public boolean equals(Object o) { @Override public int hashCode() { return Objects.hash( - limitExceededAction, metricName, mode, perTagLimits, valueLimit, additionalProperties); + limitExceededAction, + metricName, + overrideType, + perTagLimits, + valueLimit, + additionalProperties); } @Override @@ -289,7 +296,7 @@ public String toString() { .append(toIndentedString(limitExceededAction)) .append("\n"); sb.append(" metricName: ").append(toIndentedString(metricName)).append("\n"); - sb.append(" mode: ").append(toIndentedString(mode)).append("\n"); + sb.append(" overrideType: ").append(toIndentedString(overrideType)).append("\n"); sb.append(" perTagLimits: ").append(toIndentedString(perTagLimits)).append("\n"); sb.append(" valueLimit: ").append(toIndentedString(valueLimit)).append("\n"); sb.append(" additionalProperties: ") diff --git a/src/main/java/com/datadog/api/client/v2/model/ObservabilityPipelineTagCardinalityLimitProcessorPerTagLimit.java b/src/main/java/com/datadog/api/client/v2/model/ObservabilityPipelineTagCardinalityLimitProcessorPerTagLimit.java index e068e8b5256..d4085e44396 100644 --- a/src/main/java/com/datadog/api/client/v2/model/ObservabilityPipelineTagCardinalityLimitProcessorPerTagLimit.java +++ b/src/main/java/com/datadog/api/client/v2/model/ObservabilityPipelineTagCardinalityLimitProcessorPerTagLimit.java @@ -19,7 +19,7 @@ /** A cardinality override for a specific tag key within a per-metric limit. */ @JsonPropertyOrder({ - ObservabilityPipelineTagCardinalityLimitProcessorPerTagLimit.JSON_PROPERTY_MODE, + ObservabilityPipelineTagCardinalityLimitProcessorPerTagLimit.JSON_PROPERTY_OVERRIDE_TYPE, ObservabilityPipelineTagCardinalityLimitProcessorPerTagLimit.JSON_PROPERTY_TAG_KEY, ObservabilityPipelineTagCardinalityLimitProcessorPerTagLimit.JSON_PROPERTY_VALUE_LIMIT }) @@ -27,8 +27,8 @@ value = "https://github.com/DataDog/datadog-api-client-java/blob/master/.generator") public class ObservabilityPipelineTagCardinalityLimitProcessorPerTagLimit { @JsonIgnore public boolean unparsed = false; - public static final String JSON_PROPERTY_MODE = "mode"; - private ObservabilityPipelineTagCardinalityLimitProcessorPerTagMode mode; + public static final String JSON_PROPERTY_OVERRIDE_TYPE = "override_type"; + private ObservabilityPipelineTagCardinalityLimitProcessorOverrideType overrideType; public static final String JSON_PROPERTY_TAG_KEY = "tag_key"; private String tagKey; @@ -40,38 +40,39 @@ public ObservabilityPipelineTagCardinalityLimitProcessorPerTagLimit() {} @JsonCreator public ObservabilityPipelineTagCardinalityLimitProcessorPerTagLimit( - @JsonProperty(required = true, value = JSON_PROPERTY_MODE) - ObservabilityPipelineTagCardinalityLimitProcessorPerTagMode mode, + @JsonProperty(required = true, value = JSON_PROPERTY_OVERRIDE_TYPE) + ObservabilityPipelineTagCardinalityLimitProcessorOverrideType overrideType, @JsonProperty(required = true, value = JSON_PROPERTY_TAG_KEY) String tagKey) { - this.mode = mode; - this.unparsed |= !mode.isValid(); + this.overrideType = overrideType; + this.unparsed |= !overrideType.isValid(); this.tagKey = tagKey; } - public ObservabilityPipelineTagCardinalityLimitProcessorPerTagLimit mode( - ObservabilityPipelineTagCardinalityLimitProcessorPerTagMode mode) { - this.mode = mode; - this.unparsed |= !mode.isValid(); + public ObservabilityPipelineTagCardinalityLimitProcessorPerTagLimit overrideType( + ObservabilityPipelineTagCardinalityLimitProcessorOverrideType overrideType) { + this.overrideType = overrideType; + this.unparsed |= !overrideType.isValid(); return this; } /** - * How the per-tag override is applied. limit_override enforces a custom limit on the - * tag; excluded skips the tag from cardinality tracking. + * How the override is applied. limit_override enforces a custom limit; + * excluded omits the metric or tag from cardinality tracking. * - * @return mode + * @return overrideType */ - @JsonProperty(JSON_PROPERTY_MODE) + @JsonProperty(JSON_PROPERTY_OVERRIDE_TYPE) @JsonInclude(value = JsonInclude.Include.ALWAYS) - public ObservabilityPipelineTagCardinalityLimitProcessorPerTagMode getMode() { - return mode; + public ObservabilityPipelineTagCardinalityLimitProcessorOverrideType getOverrideType() { + return overrideType; } - public void setMode(ObservabilityPipelineTagCardinalityLimitProcessorPerTagMode mode) { - if (!mode.isValid()) { + public void setOverrideType( + ObservabilityPipelineTagCardinalityLimitProcessorOverrideType overrideType) { + if (!overrideType.isValid()) { this.unparsed = true; } - this.mode = mode; + this.overrideType = overrideType; } public ObservabilityPipelineTagCardinalityLimitProcessorPerTagLimit tagKey(String tagKey) { @@ -100,9 +101,9 @@ public ObservabilityPipelineTagCardinalityLimitProcessorPerTagLimit valueLimit(L } /** - * The maximum number of distinct values allowed for this tag. Required when mode is - * limit_override. Must be omitted when mode is excluded. - * minimum: 0 maximum: 1000000 + * The maximum number of distinct values allowed for this tag. Required when override_type + * is limit_override. Must be omitted when override_type is + * excluded. minimum: 0 maximum: 1000000 * * @return valueLimit */ @@ -180,7 +181,8 @@ public boolean equals(Object o) { observabilityPipelineTagCardinalityLimitProcessorPerTagLimit = (ObservabilityPipelineTagCardinalityLimitProcessorPerTagLimit) o; return Objects.equals( - this.mode, observabilityPipelineTagCardinalityLimitProcessorPerTagLimit.mode) + this.overrideType, + observabilityPipelineTagCardinalityLimitProcessorPerTagLimit.overrideType) && Objects.equals( this.tagKey, observabilityPipelineTagCardinalityLimitProcessorPerTagLimit.tagKey) && Objects.equals( @@ -193,14 +195,14 @@ public boolean equals(Object o) { @Override public int hashCode() { - return Objects.hash(mode, tagKey, valueLimit, additionalProperties); + return Objects.hash(overrideType, tagKey, valueLimit, additionalProperties); } @Override public String toString() { StringBuilder sb = new StringBuilder(); sb.append("class ObservabilityPipelineTagCardinalityLimitProcessorPerTagLimit {\n"); - sb.append(" mode: ").append(toIndentedString(mode)).append("\n"); + sb.append(" overrideType: ").append(toIndentedString(overrideType)).append("\n"); sb.append(" tagKey: ").append(toIndentedString(tagKey)).append("\n"); sb.append(" valueLimit: ").append(toIndentedString(valueLimit)).append("\n"); sb.append(" additionalProperties: ") diff --git a/src/main/java/com/datadog/api/client/v2/model/ObservabilityPipelineTagCardinalityLimitProcessorTrackingMode.java b/src/main/java/com/datadog/api/client/v2/model/ObservabilityPipelineTagCardinalityLimitProcessorTrackingMode.java new file mode 100644 index 00000000000..11953173d74 --- /dev/null +++ b/src/main/java/com/datadog/api/client/v2/model/ObservabilityPipelineTagCardinalityLimitProcessorTrackingMode.java @@ -0,0 +1,161 @@ +/* + * Unless explicitly stated otherwise all files in this repository are licensed under the Apache-2.0 License. + * This product includes software developed at Datadog (https://www.datadoghq.com/). + * Copyright 2019-Present Datadog, Inc. + */ + +package com.datadog.api.client.v2.model; + +import com.fasterxml.jackson.annotation.JsonAnyGetter; +import com.fasterxml.jackson.annotation.JsonAnySetter; +import com.fasterxml.jackson.annotation.JsonCreator; +import com.fasterxml.jackson.annotation.JsonIgnore; +import com.fasterxml.jackson.annotation.JsonInclude; +import com.fasterxml.jackson.annotation.JsonProperty; +import com.fasterxml.jackson.annotation.JsonPropertyOrder; +import java.util.HashMap; +import java.util.Map; +import java.util.Objects; + +/** Controls whether the processor uses exact or probabilistic tag tracking. */ +@JsonPropertyOrder({ + ObservabilityPipelineTagCardinalityLimitProcessorTrackingMode.JSON_PROPERTY_MODE +}) +@jakarta.annotation.Generated( + value = "https://github.com/DataDog/datadog-api-client-java/blob/master/.generator") +public class ObservabilityPipelineTagCardinalityLimitProcessorTrackingMode { + @JsonIgnore public boolean unparsed = false; + public static final String JSON_PROPERTY_MODE = "mode"; + private ObservabilityPipelineTagCardinalityLimitProcessorTrackingModeMode mode; + + public ObservabilityPipelineTagCardinalityLimitProcessorTrackingMode() {} + + @JsonCreator + public ObservabilityPipelineTagCardinalityLimitProcessorTrackingMode( + @JsonProperty(required = true, value = JSON_PROPERTY_MODE) + ObservabilityPipelineTagCardinalityLimitProcessorTrackingModeMode mode) { + this.mode = mode; + this.unparsed |= !mode.isValid(); + } + + public ObservabilityPipelineTagCardinalityLimitProcessorTrackingMode mode( + ObservabilityPipelineTagCardinalityLimitProcessorTrackingModeMode mode) { + this.mode = mode; + this.unparsed |= !mode.isValid(); + return this; + } + + /** + * The cardinality tracking algorithm to use. + * + * @return mode + */ + @JsonProperty(JSON_PROPERTY_MODE) + @JsonInclude(value = JsonInclude.Include.ALWAYS) + public ObservabilityPipelineTagCardinalityLimitProcessorTrackingModeMode getMode() { + return mode; + } + + public void setMode(ObservabilityPipelineTagCardinalityLimitProcessorTrackingModeMode mode) { + if (!mode.isValid()) { + this.unparsed = true; + } + this.mode = mode; + } + + /** + * A container for additional, undeclared properties. This is a holder for any undeclared + * properties as specified with the 'additionalProperties' keyword in the OAS document. + */ + private Map additionalProperties; + + /** + * Set the additional (undeclared) property with the specified name and value. If the property + * does not already exist, create it otherwise replace it. + * + * @param key The arbitrary key to set + * @param value The associated value + * @return ObservabilityPipelineTagCardinalityLimitProcessorTrackingMode + */ + @JsonAnySetter + public ObservabilityPipelineTagCardinalityLimitProcessorTrackingMode putAdditionalProperty( + String key, Object value) { + if (this.additionalProperties == null) { + this.additionalProperties = new HashMap(); + } + this.additionalProperties.put(key, value); + return this; + } + + /** + * Return the additional (undeclared) property. + * + * @return The additional properties + */ + @JsonAnyGetter + public Map getAdditionalProperties() { + return additionalProperties; + } + + /** + * Return the additional (undeclared) property with the specified name. + * + * @param key The arbitrary key to get + * @return The specific additional property for the given key + */ + public Object getAdditionalProperty(String key) { + if (this.additionalProperties == null) { + return null; + } + return this.additionalProperties.get(key); + } + + /** + * Return true if this ObservabilityPipelineTagCardinalityLimitProcessorTrackingMode object is + * equal to o. + */ + @Override + public boolean equals(Object o) { + if (this == o) { + return true; + } + if (o == null || getClass() != o.getClass()) { + return false; + } + ObservabilityPipelineTagCardinalityLimitProcessorTrackingMode + observabilityPipelineTagCardinalityLimitProcessorTrackingMode = + (ObservabilityPipelineTagCardinalityLimitProcessorTrackingMode) o; + return Objects.equals( + this.mode, observabilityPipelineTagCardinalityLimitProcessorTrackingMode.mode) + && Objects.equals( + this.additionalProperties, + observabilityPipelineTagCardinalityLimitProcessorTrackingMode.additionalProperties); + } + + @Override + public int hashCode() { + return Objects.hash(mode, additionalProperties); + } + + @Override + public String toString() { + StringBuilder sb = new StringBuilder(); + sb.append("class ObservabilityPipelineTagCardinalityLimitProcessorTrackingMode {\n"); + sb.append(" mode: ").append(toIndentedString(mode)).append("\n"); + sb.append(" additionalProperties: ") + .append(toIndentedString(additionalProperties)) + .append("\n"); + sb.append('}'); + return sb.toString(); + } + + /** + * Convert the given object to string with each line indented by 4 spaces (except the first line). + */ + private String toIndentedString(Object o) { + if (o == null) { + return "null"; + } + return o.toString().replace("\n", "\n "); + } +} diff --git a/src/main/java/com/datadog/api/client/v2/model/ObservabilityPipelineTagCardinalityLimitProcessorPerMetricMode.java b/src/main/java/com/datadog/api/client/v2/model/ObservabilityPipelineTagCardinalityLimitProcessorTrackingModeMode.java similarity index 56% rename from src/main/java/com/datadog/api/client/v2/model/ObservabilityPipelineTagCardinalityLimitProcessorPerMetricMode.java rename to src/main/java/com/datadog/api/client/v2/model/ObservabilityPipelineTagCardinalityLimitProcessorTrackingModeMode.java index 494fce07c65..7dadc6f0507 100644 --- a/src/main/java/com/datadog/api/client/v2/model/ObservabilityPipelineTagCardinalityLimitProcessorPerMetricMode.java +++ b/src/main/java/com/datadog/api/client/v2/model/ObservabilityPipelineTagCardinalityLimitProcessorTrackingModeMode.java @@ -18,43 +18,43 @@ import java.util.HashSet; import java.util.Set; -/** - * How the per-metric override is applied. tracked enforces a custom limit; - * excluded skips the metric entirely. - */ +/** The cardinality tracking algorithm to use. */ @JsonSerialize( using = - ObservabilityPipelineTagCardinalityLimitProcessorPerMetricMode - .ObservabilityPipelineTagCardinalityLimitProcessorPerMetricModeSerializer.class) -public class ObservabilityPipelineTagCardinalityLimitProcessorPerMetricMode + ObservabilityPipelineTagCardinalityLimitProcessorTrackingModeMode + .ObservabilityPipelineTagCardinalityLimitProcessorTrackingModeModeSerializer.class) +public class ObservabilityPipelineTagCardinalityLimitProcessorTrackingModeMode extends ModelEnum { private static final Set allowedValues = - new HashSet(Arrays.asList("tracked", "excluded")); + new HashSet(Arrays.asList("exact_fingerprint", "probabilistic")); - public static final ObservabilityPipelineTagCardinalityLimitProcessorPerMetricMode TRACKED = - new ObservabilityPipelineTagCardinalityLimitProcessorPerMetricMode("tracked"); - public static final ObservabilityPipelineTagCardinalityLimitProcessorPerMetricMode EXCLUDED = - new ObservabilityPipelineTagCardinalityLimitProcessorPerMetricMode("excluded"); + public static final ObservabilityPipelineTagCardinalityLimitProcessorTrackingModeMode + EXACT_FINGERPRINT = + new ObservabilityPipelineTagCardinalityLimitProcessorTrackingModeMode( + "exact_fingerprint"); + public static final ObservabilityPipelineTagCardinalityLimitProcessorTrackingModeMode + PROBABILISTIC = + new ObservabilityPipelineTagCardinalityLimitProcessorTrackingModeMode("probabilistic"); - ObservabilityPipelineTagCardinalityLimitProcessorPerMetricMode(String value) { + ObservabilityPipelineTagCardinalityLimitProcessorTrackingModeMode(String value) { super(value, allowedValues); } - public static class ObservabilityPipelineTagCardinalityLimitProcessorPerMetricModeSerializer - extends StdSerializer { - public ObservabilityPipelineTagCardinalityLimitProcessorPerMetricModeSerializer( - Class t) { + public static class ObservabilityPipelineTagCardinalityLimitProcessorTrackingModeModeSerializer + extends StdSerializer { + public ObservabilityPipelineTagCardinalityLimitProcessorTrackingModeModeSerializer( + Class t) { super(t); } - public ObservabilityPipelineTagCardinalityLimitProcessorPerMetricModeSerializer() { + public ObservabilityPipelineTagCardinalityLimitProcessorTrackingModeModeSerializer() { this(null); } @Override public void serialize( - ObservabilityPipelineTagCardinalityLimitProcessorPerMetricMode value, + ObservabilityPipelineTagCardinalityLimitProcessorTrackingModeMode value, JsonGenerator jgen, SerializerProvider provider) throws IOException, JsonProcessingException { @@ -63,8 +63,8 @@ public void serialize( } @JsonCreator - public static ObservabilityPipelineTagCardinalityLimitProcessorPerMetricMode fromValue( + public static ObservabilityPipelineTagCardinalityLimitProcessorTrackingModeMode fromValue( String value) { - return new ObservabilityPipelineTagCardinalityLimitProcessorPerMetricMode(value); + return new ObservabilityPipelineTagCardinalityLimitProcessorTrackingModeMode(value); } }