From f363c22e9853fe5499559d8048c54de9e0258474 Mon Sep 17 00:00:00 2001 From: "ci.datadog-api-spec" Date: Fri, 16 Oct 2026 20:01:51 +0000 Subject: [PATCH] Regenerate client from commit 2a61112 of spec repo --- .generator/schemas/v2/openapi.yaml | 45 +++++++++ .../TagIndexingRuleExemptionAttributes.java | 95 ++++++++++++++++++- .../TagIndexingRuleExemptionVolumeStatus.java | 69 ++++++++++++++ 3 files changed, 207 insertions(+), 2 deletions(-) create mode 100644 src/main/java/com/datadog/api/client/v2/model/TagIndexingRuleExemptionVolumeStatus.java diff --git a/.generator/schemas/v2/openapi.yaml b/.generator/schemas/v2/openapi.yaml index 8e540e2cff5..c194a9c9f8b 100644 --- a/.generator/schemas/v2/openapi.yaml +++ b/.generator/schemas/v2/openapi.yaml @@ -129207,15 +129207,37 @@ components: example: user@datadoghq.com readOnly: true type: string + estimated_change_in_volume: + description: |- + Estimated change in indexed cardinality or points if the exemption is removed and the matching tag indexing + rule applies to the metric. A negative value indicates a reduction in indexed volume, a positive value + indicates an increase, and zero indicates no change. A `null` value indicates that the estimate is unavailable. + example: 45 + format: int64 + nullable: true + readOnly: true + type: integer kind: description: >- Discriminates between an explicit exemption (`exemption`) and a pre-existing legacy tag configuration acting as an implicit exclusion (`legacy_tag_configuration`). example: exemption type: string + missing_indexed_tags: + description: |- + Tag keys used to query this metric in monitors, dashboards, notebooks, and SLOs that the matching rule would + remove or not include if the exemption is removed. + example: + - service + items: + type: string + readOnly: true + type: array reason: description: The reason the metric is exempt from tag indexing rules. example: This metric has a pre-existing tag configuration. type: string + volume_status: + $ref: "#/components/schemas/TagIndexingRuleExemptionVolumeStatus" type: object TagIndexingRuleExemptionCreateAttributes: description: Attributes for creating a tag indexing rule exemption. @@ -129274,6 +129296,22 @@ components: type: string x-enum-varnames: - TAG_INDEXING_RULE_EXEMPTIONS + TagIndexingRuleExemptionVolumeStatus: + description: |- + Indicates whether `estimated_change_in_volume` is available and, if not, why. `ok` indicates a fresh estimate. + `unindexed_tags` indicates that the matching rule uses tags that are not indexed for the metric. + `unavailable` indicates that the estimate is stale, was not computed, or could not be retrieved. + enum: + - ok + - unindexed_tags + - unavailable + example: unavailable + readOnly: true + type: string + x-enum-varnames: + - OK + - UNINDEXED_TAGS + - UNAVAILABLE TagIndexingRuleMetricMatch: description: Criteria for matching metrics based on query state. properties: @@ -199163,8 +199201,12 @@ paths: attributes: created_at: "2024-01-15T12:00:00.000Z" created_by_handle: user@datadoghq.com + estimated_change_in_volume: 45 kind: exemption + missing_indexed_tags: + - service reason: This metric has a pre-existing tag configuration. + volume_status: ok id: dd.test.metric type: tag_indexing_rule_exemptions schema: @@ -199240,8 +199282,11 @@ paths: attributes: created_at: "2024-01-15T12:00:00.000Z" created_by_handle: user@datadoghq.com + estimated_change_in_volume: kind: exemption + missing_indexed_tags: [] reason: This metric has a pre-existing tag configuration. + volume_status: unavailable id: dd.test.metric type: tag_indexing_rule_exemptions schema: diff --git a/src/main/java/com/datadog/api/client/v2/model/TagIndexingRuleExemptionAttributes.java b/src/main/java/com/datadog/api/client/v2/model/TagIndexingRuleExemptionAttributes.java index e8aa59e7422..72ce39bdb7e 100644 --- a/src/main/java/com/datadog/api/client/v2/model/TagIndexingRuleExemptionAttributes.java +++ b/src/main/java/com/datadog/api/client/v2/model/TagIndexingRuleExemptionAttributes.java @@ -14,15 +14,20 @@ import com.fasterxml.jackson.annotation.JsonPropertyOrder; import java.time.OffsetDateTime; import java.util.HashMap; +import java.util.List; import java.util.Map; import java.util.Objects; +import org.openapitools.jackson.nullable.JsonNullable; /** Attributes of a tag indexing rule exemption. */ @JsonPropertyOrder({ TagIndexingRuleExemptionAttributes.JSON_PROPERTY_CREATED_AT, TagIndexingRuleExemptionAttributes.JSON_PROPERTY_CREATED_BY_HANDLE, + TagIndexingRuleExemptionAttributes.JSON_PROPERTY_ESTIMATED_CHANGE_IN_VOLUME, TagIndexingRuleExemptionAttributes.JSON_PROPERTY_KIND, - TagIndexingRuleExemptionAttributes.JSON_PROPERTY_REASON + TagIndexingRuleExemptionAttributes.JSON_PROPERTY_MISSING_INDEXED_TAGS, + TagIndexingRuleExemptionAttributes.JSON_PROPERTY_REASON, + TagIndexingRuleExemptionAttributes.JSON_PROPERTY_VOLUME_STATUS }) @jakarta.annotation.Generated( value = "https://github.com/DataDog/datadog-api-client-java/blob/master/.generator") @@ -34,12 +39,22 @@ public class TagIndexingRuleExemptionAttributes { public static final String JSON_PROPERTY_CREATED_BY_HANDLE = "created_by_handle"; private String createdByHandle; + public static final String JSON_PROPERTY_ESTIMATED_CHANGE_IN_VOLUME = + "estimated_change_in_volume"; + private JsonNullable estimatedChangeInVolume = JsonNullable.undefined(); + public static final String JSON_PROPERTY_KIND = "kind"; private String kind; + public static final String JSON_PROPERTY_MISSING_INDEXED_TAGS = "missing_indexed_tags"; + private List missingIndexedTags = null; + public static final String JSON_PROPERTY_REASON = "reason"; private String reason; + public static final String JSON_PROPERTY_VOLUME_STATUS = "volume_status"; + private TagIndexingRuleExemptionVolumeStatus volumeStatus; + /** * Timestamp when the exemption was created. * @@ -64,6 +79,35 @@ public String getCreatedByHandle() { return createdByHandle; } + /** + * Estimated change in indexed cardinality or points if the exemption is removed and the matching + * tag indexing rule applies to the metric. A negative value indicates a reduction in indexed + * volume, a positive value indicates an increase, and zero indicates no change. A null + * value indicates that the estimate is unavailable. + * + * @return estimatedChangeInVolume + */ + @jakarta.annotation.Nullable + @JsonIgnore + public Long getEstimatedChangeInVolume() { + + if (estimatedChangeInVolume == null) { + estimatedChangeInVolume = JsonNullable.undefined(); + } + return estimatedChangeInVolume.orElse(null); + } + + @JsonProperty(JSON_PROPERTY_ESTIMATED_CHANGE_IN_VOLUME) + @JsonInclude(value = JsonInclude.Include.USE_DEFAULTS) + public JsonNullable getEstimatedChangeInVolume_JsonNullable() { + return estimatedChangeInVolume; + } + + @JsonProperty(JSON_PROPERTY_ESTIMATED_CHANGE_IN_VOLUME) + private void setEstimatedChangeInVolume_JsonNullable(JsonNullable estimatedChangeInVolume) { + this.estimatedChangeInVolume = estimatedChangeInVolume; + } + public TagIndexingRuleExemptionAttributes kind(String kind) { this.kind = kind; return this; @@ -86,6 +130,19 @@ public void setKind(String kind) { this.kind = kind; } + /** + * Tag keys used to query this metric in monitors, dashboards, notebooks, and SLOs that the + * matching rule would remove or not include if the exemption is removed. + * + * @return missingIndexedTags + */ + @jakarta.annotation.Nullable + @JsonProperty(JSON_PROPERTY_MISSING_INDEXED_TAGS) + @JsonInclude(value = JsonInclude.Include.USE_DEFAULTS) + public List getMissingIndexedTags() { + return missingIndexedTags; + } + public TagIndexingRuleExemptionAttributes reason(String reason) { this.reason = reason; return this; @@ -107,6 +164,21 @@ public void setReason(String reason) { this.reason = reason; } + /** + * Indicates whether estimated_change_in_volume is available and, if not, why. + * ok indicates a fresh estimate. unindexed_tags indicates that the matching + * rule uses tags that are not indexed for the metric. unavailable indicates that the + * estimate is stale, was not computed, or could not be retrieved. + * + * @return volumeStatus + */ + @jakarta.annotation.Nullable + @JsonProperty(JSON_PROPERTY_VOLUME_STATUS) + @JsonInclude(value = JsonInclude.Include.USE_DEFAULTS) + public TagIndexingRuleExemptionVolumeStatus getVolumeStatus() { + return volumeStatus; + } + /** * A container for additional, undeclared properties. This is a holder for any undeclared * properties as specified with the 'additionalProperties' keyword in the OAS document. @@ -166,15 +238,29 @@ public boolean equals(Object o) { (TagIndexingRuleExemptionAttributes) o; return Objects.equals(this.createdAt, tagIndexingRuleExemptionAttributes.createdAt) && Objects.equals(this.createdByHandle, tagIndexingRuleExemptionAttributes.createdByHandle) + && Objects.equals( + this.estimatedChangeInVolume, + tagIndexingRuleExemptionAttributes.estimatedChangeInVolume) && Objects.equals(this.kind, tagIndexingRuleExemptionAttributes.kind) + && Objects.equals( + this.missingIndexedTags, tagIndexingRuleExemptionAttributes.missingIndexedTags) && Objects.equals(this.reason, tagIndexingRuleExemptionAttributes.reason) + && Objects.equals(this.volumeStatus, tagIndexingRuleExemptionAttributes.volumeStatus) && Objects.equals( this.additionalProperties, tagIndexingRuleExemptionAttributes.additionalProperties); } @Override public int hashCode() { - return Objects.hash(createdAt, createdByHandle, kind, reason, additionalProperties); + return Objects.hash( + createdAt, + createdByHandle, + estimatedChangeInVolume, + kind, + missingIndexedTags, + reason, + volumeStatus, + additionalProperties); } @Override @@ -183,8 +269,13 @@ public String toString() { sb.append("class TagIndexingRuleExemptionAttributes {\n"); sb.append(" createdAt: ").append(toIndentedString(createdAt)).append("\n"); sb.append(" createdByHandle: ").append(toIndentedString(createdByHandle)).append("\n"); + sb.append(" estimatedChangeInVolume: ") + .append(toIndentedString(estimatedChangeInVolume)) + .append("\n"); sb.append(" kind: ").append(toIndentedString(kind)).append("\n"); + sb.append(" missingIndexedTags: ").append(toIndentedString(missingIndexedTags)).append("\n"); sb.append(" reason: ").append(toIndentedString(reason)).append("\n"); + sb.append(" volumeStatus: ").append(toIndentedString(volumeStatus)).append("\n"); sb.append(" additionalProperties: ") .append(toIndentedString(additionalProperties)) .append("\n"); diff --git a/src/main/java/com/datadog/api/client/v2/model/TagIndexingRuleExemptionVolumeStatus.java b/src/main/java/com/datadog/api/client/v2/model/TagIndexingRuleExemptionVolumeStatus.java new file mode 100644 index 00000000000..eff668e8767 --- /dev/null +++ b/src/main/java/com/datadog/api/client/v2/model/TagIndexingRuleExemptionVolumeStatus.java @@ -0,0 +1,69 @@ +/* + * 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.datadog.api.client.ModelEnum; +import com.fasterxml.jackson.annotation.JsonCreator; +import com.fasterxml.jackson.core.JsonGenerator; +import com.fasterxml.jackson.core.JsonProcessingException; +import com.fasterxml.jackson.databind.SerializerProvider; +import com.fasterxml.jackson.databind.annotation.JsonSerialize; +import com.fasterxml.jackson.databind.ser.std.StdSerializer; +import java.io.IOException; +import java.util.Arrays; +import java.util.HashSet; +import java.util.Set; + +/** + * Indicates whether estimated_change_in_volume is available and, if not, why. ok + * indicates a fresh estimate. unindexed_tags indicates that the matching rule + * uses tags that are not indexed for the metric. unavailable indicates that the + * estimate is stale, was not computed, or could not be retrieved. + */ +@JsonSerialize( + using = + TagIndexingRuleExemptionVolumeStatus.TagIndexingRuleExemptionVolumeStatusSerializer.class) +public class TagIndexingRuleExemptionVolumeStatus extends ModelEnum { + + private static final Set allowedValues = + new HashSet(Arrays.asList("ok", "unindexed_tags", "unavailable")); + + public static final TagIndexingRuleExemptionVolumeStatus OK = + new TagIndexingRuleExemptionVolumeStatus("ok"); + public static final TagIndexingRuleExemptionVolumeStatus UNINDEXED_TAGS = + new TagIndexingRuleExemptionVolumeStatus("unindexed_tags"); + public static final TagIndexingRuleExemptionVolumeStatus UNAVAILABLE = + new TagIndexingRuleExemptionVolumeStatus("unavailable"); + + TagIndexingRuleExemptionVolumeStatus(String value) { + super(value, allowedValues); + } + + public static class TagIndexingRuleExemptionVolumeStatusSerializer + extends StdSerializer { + public TagIndexingRuleExemptionVolumeStatusSerializer( + Class t) { + super(t); + } + + public TagIndexingRuleExemptionVolumeStatusSerializer() { + this(null); + } + + @Override + public void serialize( + TagIndexingRuleExemptionVolumeStatus value, JsonGenerator jgen, SerializerProvider provider) + throws IOException, JsonProcessingException { + jgen.writeObject(value.value); + } + } + + @JsonCreator + public static TagIndexingRuleExemptionVolumeStatus fromValue(String value) { + return new TagIndexingRuleExemptionVolumeStatus(value); + } +}