From 5f692f71dbcc5b6ceedbba1e5d2d84609bfc718b Mon Sep 17 00:00:00 2001 From: "ci.datadog-api-spec" Date: Wed, 16 Jul 2025 19:28:32 +0000 Subject: [PATCH] Regenerate client from commit 2945951 of spec repo --- .generated-info | 4 +- .generator/schemas/v2/openapi.yaml | 75 ++++ ...ervabilityPipelineConfigProcessorItem.java | 86 ++++- ...rvabilityPipelineDatadogTagsProcessor.java | 353 ++++++++++++++++++ ...ityPipelineDatadogTagsProcessorAction.java | 65 ++++ ...ilityPipelineDatadogTagsProcessorMode.java | 62 +++ ...ilityPipelineDatadogTagsProcessorType.java | 63 ++++ 7 files changed, 702 insertions(+), 6 deletions(-) create mode 100644 src/main/java/com/datadog/api/client/v2/model/ObservabilityPipelineDatadogTagsProcessor.java create mode 100644 src/main/java/com/datadog/api/client/v2/model/ObservabilityPipelineDatadogTagsProcessorAction.java create mode 100644 src/main/java/com/datadog/api/client/v2/model/ObservabilityPipelineDatadogTagsProcessorMode.java create mode 100644 src/main/java/com/datadog/api/client/v2/model/ObservabilityPipelineDatadogTagsProcessorType.java diff --git a/.generated-info b/.generated-info index 166b839d628..ecd5a7001d1 100644 --- a/.generated-info +++ b/.generated-info @@ -1,4 +1,4 @@ { - "spec_repo_commit": "2e1c8ca", - "generated": "2025-07-16 17:26:43.623" + "spec_repo_commit": "2945951", + "generated": "2025-07-16 19:28:32.502" } diff --git a/.generator/schemas/v2/openapi.yaml b/.generator/schemas/v2/openapi.yaml index a1a26e28473..e67a8572d48 100644 --- a/.generator/schemas/v2/openapi.yaml +++ b/.generator/schemas/v2/openapi.yaml @@ -25164,6 +25164,7 @@ components: - $ref: '#/components/schemas/ObservabilityPipelineEnrichmentTableProcessor' - $ref: '#/components/schemas/ObservabilityPipelineReduceProcessor' - $ref: '#/components/schemas/ObservabilityPipelineThrottleProcessor' + - $ref: '#/components/schemas/ObservabilityPipelineDatadogTagsProcessor' ObservabilityPipelineConfigSourceItem: description: A data source for the pipeline. oneOf: @@ -25273,6 +25274,80 @@ components: type: string x-enum-varnames: - DATADOG_LOGS + ObservabilityPipelineDatadogTagsProcessor: + description: The `datadog_tags` processor includes or excludes specific Datadog + tags in your logs. + properties: + action: + $ref: '#/components/schemas/ObservabilityPipelineDatadogTagsProcessorAction' + id: + description: The unique identifier for this component. Used to reference + this component in other parts of the pipeline (for example, as the `input` + to downstream components). + example: datadog-tags-processor + type: string + include: + description: A Datadog search query used to determine which logs this processor + targets. + example: service:my-service + type: string + inputs: + description: A list of component IDs whose output is used as the `input` + for this component. + example: + - datadog-agent-source + items: + type: string + type: array + keys: + description: A list of tag keys. + example: + - env + - service + - version + items: + type: string + type: array + mode: + $ref: '#/components/schemas/ObservabilityPipelineDatadogTagsProcessorMode' + type: + $ref: '#/components/schemas/ObservabilityPipelineDatadogTagsProcessorType' + required: + - id + - type + - include + - mode + - action + - keys + - inputs + type: object + ObservabilityPipelineDatadogTagsProcessorAction: + description: The action to take on tags with matching keys. + enum: + - include + - exclude + example: include + type: string + x-enum-varnames: + - INCLUDE + - EXCLUDE + ObservabilityPipelineDatadogTagsProcessorMode: + description: The processing mode. + enum: + - filter + example: filter + type: string + x-enum-varnames: + - FILTER + ObservabilityPipelineDatadogTagsProcessorType: + default: datadog_tags + description: The processor type. The value should always be `datadog_tags`. + enum: + - datadog_tags + example: datadog_tags + type: string + x-enum-varnames: + - DATADOG_TAGS ObservabilityPipelineDecoding: description: The decoding format used to interpret incoming logs. enum: diff --git a/src/main/java/com/datadog/api/client/v2/model/ObservabilityPipelineConfigProcessorItem.java b/src/main/java/com/datadog/api/client/v2/model/ObservabilityPipelineConfigProcessorItem.java index 18000ccfacd..8637d0951dc 100644 --- a/src/main/java/com/datadog/api/client/v2/model/ObservabilityPipelineConfigProcessorItem.java +++ b/src/main/java/com/datadog/api/client/v2/model/ObservabilityPipelineConfigProcessorItem.java @@ -902,6 +902,57 @@ public ObservabilityPipelineConfigProcessorItem deserialize( e); } + // deserialize ObservabilityPipelineDatadogTagsProcessor + try { + boolean attemptParsing = true; + // ensure that we respect type coercion as set on the client ObjectMapper + if (ObservabilityPipelineDatadogTagsProcessor.class.equals(Integer.class) + || ObservabilityPipelineDatadogTagsProcessor.class.equals(Long.class) + || ObservabilityPipelineDatadogTagsProcessor.class.equals(Float.class) + || ObservabilityPipelineDatadogTagsProcessor.class.equals(Double.class) + || ObservabilityPipelineDatadogTagsProcessor.class.equals(Boolean.class) + || ObservabilityPipelineDatadogTagsProcessor.class.equals(String.class)) { + attemptParsing = typeCoercion; + if (!attemptParsing) { + attemptParsing |= + ((ObservabilityPipelineDatadogTagsProcessor.class.equals(Integer.class) + || ObservabilityPipelineDatadogTagsProcessor.class.equals(Long.class)) + && token == JsonToken.VALUE_NUMBER_INT); + attemptParsing |= + ((ObservabilityPipelineDatadogTagsProcessor.class.equals(Float.class) + || ObservabilityPipelineDatadogTagsProcessor.class.equals(Double.class)) + && (token == JsonToken.VALUE_NUMBER_FLOAT + || token == JsonToken.VALUE_NUMBER_INT)); + attemptParsing |= + (ObservabilityPipelineDatadogTagsProcessor.class.equals(Boolean.class) + && (token == JsonToken.VALUE_FALSE || token == JsonToken.VALUE_TRUE)); + attemptParsing |= + (ObservabilityPipelineDatadogTagsProcessor.class.equals(String.class) + && token == JsonToken.VALUE_STRING); + } + } + if (attemptParsing) { + tmp = + tree.traverse(jp.getCodec()) + .readValueAs(ObservabilityPipelineDatadogTagsProcessor.class); + // TODO: there is no validation against JSON schema constraints + // (min, max, enum, pattern...), this does not perform a strict JSON + // validation, which means the 'match' count may be higher than it should be. + if (!((ObservabilityPipelineDatadogTagsProcessor) tmp).unparsed) { + deserialized = tmp; + match++; + } + log.log( + Level.FINER, "Input data matches schema 'ObservabilityPipelineDatadogTagsProcessor'"); + } + } catch (Exception e) { + // deserialization failed, continue + log.log( + Level.FINER, + "Input data does not match schema 'ObservabilityPipelineDatadogTagsProcessor'", + e); + } + ObservabilityPipelineConfigProcessorItem ret = new ObservabilityPipelineConfigProcessorItem(); if (match == 1) { ret.setActualInstance(deserialized); @@ -1013,6 +1064,11 @@ public ObservabilityPipelineConfigProcessorItem(ObservabilityPipelineThrottlePro setActualInstance(o); } + public ObservabilityPipelineConfigProcessorItem(ObservabilityPipelineDatadogTagsProcessor o) { + super("oneOf", Boolean.FALSE); + setActualInstance(o); + } + static { schemas.put( "ObservabilityPipelineFilterProcessor", @@ -1062,6 +1118,9 @@ public ObservabilityPipelineConfigProcessorItem(ObservabilityPipelineThrottlePro schemas.put( "ObservabilityPipelineThrottleProcessor", new GenericType() {}); + schemas.put( + "ObservabilityPipelineDatadogTagsProcessor", + new GenericType() {}); JSON.registerDescendants( ObservabilityPipelineConfigProcessorItem.class, Collections.unmodifiableMap(schemas)); } @@ -1081,7 +1140,7 @@ public Map getSchemas() { * ObservabilityPipelineSensitiveDataScannerProcessor, ObservabilityPipelineOcsfMapperProcessor, * ObservabilityPipelineAddEnvVarsProcessor, ObservabilityPipelineDedupeProcessor, * ObservabilityPipelineEnrichmentTableProcessor, ObservabilityPipelineReduceProcessor, - * ObservabilityPipelineThrottleProcessor + * ObservabilityPipelineThrottleProcessor, ObservabilityPipelineDatadogTagsProcessor * *

It could be an instance of the 'oneOf' schemas. The oneOf child schemas may themselves be a * composed schema (allOf, anyOf, oneOf). @@ -1170,6 +1229,11 @@ public void setActualInstance(Object instance) { super.setActualInstance(instance); return; } + if (JSON.isInstanceOf( + ObservabilityPipelineDatadogTagsProcessor.class, instance, new HashSet>())) { + super.setActualInstance(instance); + return; + } if (JSON.isInstanceOf(UnparsedObject.class, instance, new HashSet>())) { super.setActualInstance(instance); @@ -1187,7 +1251,8 @@ public void setActualInstance(Object instance) { + " ObservabilityPipelineOcsfMapperProcessor, ObservabilityPipelineAddEnvVarsProcessor," + " ObservabilityPipelineDedupeProcessor," + " ObservabilityPipelineEnrichmentTableProcessor," - + " ObservabilityPipelineReduceProcessor, ObservabilityPipelineThrottleProcessor"); + + " ObservabilityPipelineReduceProcessor, ObservabilityPipelineThrottleProcessor," + + " ObservabilityPipelineDatadogTagsProcessor"); } /** @@ -1199,7 +1264,7 @@ public void setActualInstance(Object instance) { * ObservabilityPipelineSensitiveDataScannerProcessor, ObservabilityPipelineOcsfMapperProcessor, * ObservabilityPipelineAddEnvVarsProcessor, ObservabilityPipelineDedupeProcessor, * ObservabilityPipelineEnrichmentTableProcessor, ObservabilityPipelineReduceProcessor, - * ObservabilityPipelineThrottleProcessor + * ObservabilityPipelineThrottleProcessor, ObservabilityPipelineDatadogTagsProcessor * * @return The actual instance (ObservabilityPipelineFilterProcessor, * ObservabilityPipelineParseJSONProcessor, ObservabilityPipelineQuotaProcessor, @@ -1209,7 +1274,8 @@ public void setActualInstance(Object instance) { * ObservabilityPipelineSensitiveDataScannerProcessor, * ObservabilityPipelineOcsfMapperProcessor, ObservabilityPipelineAddEnvVarsProcessor, * ObservabilityPipelineDedupeProcessor, ObservabilityPipelineEnrichmentTableProcessor, - * ObservabilityPipelineReduceProcessor, ObservabilityPipelineThrottleProcessor) + * ObservabilityPipelineReduceProcessor, ObservabilityPipelineThrottleProcessor, + * ObservabilityPipelineDatadogTagsProcessor) */ @Override public Object getActualInstance() { @@ -1413,4 +1479,16 @@ public ObservabilityPipelineThrottleProcessor getObservabilityPipelineThrottlePr throws ClassCastException { return (ObservabilityPipelineThrottleProcessor) super.getActualInstance(); } + + /** + * Get the actual instance of `ObservabilityPipelineDatadogTagsProcessor`. If the actual instance + * is not `ObservabilityPipelineDatadogTagsProcessor`, the ClassCastException will be thrown. + * + * @return The actual instance of `ObservabilityPipelineDatadogTagsProcessor` + * @throws ClassCastException if the instance is not `ObservabilityPipelineDatadogTagsProcessor` + */ + public ObservabilityPipelineDatadogTagsProcessor getObservabilityPipelineDatadogTagsProcessor() + throws ClassCastException { + return (ObservabilityPipelineDatadogTagsProcessor) super.getActualInstance(); + } } diff --git a/src/main/java/com/datadog/api/client/v2/model/ObservabilityPipelineDatadogTagsProcessor.java b/src/main/java/com/datadog/api/client/v2/model/ObservabilityPipelineDatadogTagsProcessor.java new file mode 100644 index 00000000000..c38aacab4bf --- /dev/null +++ b/src/main/java/com/datadog/api/client/v2/model/ObservabilityPipelineDatadogTagsProcessor.java @@ -0,0 +1,353 @@ +/* + * 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.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.Objects; + +/** + * The datadog_tags processor includes or excludes specific Datadog tags in your logs. + */ +@JsonPropertyOrder({ + ObservabilityPipelineDatadogTagsProcessor.JSON_PROPERTY_ACTION, + ObservabilityPipelineDatadogTagsProcessor.JSON_PROPERTY_ID, + ObservabilityPipelineDatadogTagsProcessor.JSON_PROPERTY_INCLUDE, + ObservabilityPipelineDatadogTagsProcessor.JSON_PROPERTY_INPUTS, + ObservabilityPipelineDatadogTagsProcessor.JSON_PROPERTY_KEYS, + ObservabilityPipelineDatadogTagsProcessor.JSON_PROPERTY_MODE, + ObservabilityPipelineDatadogTagsProcessor.JSON_PROPERTY_TYPE +}) +@jakarta.annotation.Generated( + value = "https://github.com/DataDog/datadog-api-client-java/blob/master/.generator") +public class ObservabilityPipelineDatadogTagsProcessor { + @JsonIgnore public boolean unparsed = false; + public static final String JSON_PROPERTY_ACTION = "action"; + private ObservabilityPipelineDatadogTagsProcessorAction action; + + public static final String JSON_PROPERTY_ID = "id"; + private String id; + + public static final String JSON_PROPERTY_INCLUDE = "include"; + private String include; + + public static final String JSON_PROPERTY_INPUTS = "inputs"; + private List inputs = new ArrayList<>(); + + public static final String JSON_PROPERTY_KEYS = "keys"; + private List keys = new ArrayList<>(); + + public static final String JSON_PROPERTY_MODE = "mode"; + private ObservabilityPipelineDatadogTagsProcessorMode mode; + + public static final String JSON_PROPERTY_TYPE = "type"; + private ObservabilityPipelineDatadogTagsProcessorType type = + ObservabilityPipelineDatadogTagsProcessorType.DATADOG_TAGS; + + public ObservabilityPipelineDatadogTagsProcessor() {} + + @JsonCreator + public ObservabilityPipelineDatadogTagsProcessor( + @JsonProperty(required = true, value = JSON_PROPERTY_ACTION) + ObservabilityPipelineDatadogTagsProcessorAction action, + @JsonProperty(required = true, value = JSON_PROPERTY_ID) String id, + @JsonProperty(required = true, value = JSON_PROPERTY_INCLUDE) String include, + @JsonProperty(required = true, value = JSON_PROPERTY_INPUTS) List inputs, + @JsonProperty(required = true, value = JSON_PROPERTY_KEYS) List keys, + @JsonProperty(required = true, value = JSON_PROPERTY_MODE) + ObservabilityPipelineDatadogTagsProcessorMode mode, + @JsonProperty(required = true, value = JSON_PROPERTY_TYPE) + ObservabilityPipelineDatadogTagsProcessorType type) { + this.action = action; + this.unparsed |= !action.isValid(); + this.id = id; + this.include = include; + this.inputs = inputs; + this.keys = keys; + this.mode = mode; + this.unparsed |= !mode.isValid(); + this.type = type; + this.unparsed |= !type.isValid(); + } + + public ObservabilityPipelineDatadogTagsProcessor action( + ObservabilityPipelineDatadogTagsProcessorAction action) { + this.action = action; + this.unparsed |= !action.isValid(); + return this; + } + + /** + * The action to take on tags with matching keys. + * + * @return action + */ + @JsonProperty(JSON_PROPERTY_ACTION) + @JsonInclude(value = JsonInclude.Include.ALWAYS) + public ObservabilityPipelineDatadogTagsProcessorAction getAction() { + return action; + } + + public void setAction(ObservabilityPipelineDatadogTagsProcessorAction action) { + if (!action.isValid()) { + this.unparsed = true; + } + this.action = action; + } + + public ObservabilityPipelineDatadogTagsProcessor id(String id) { + this.id = id; + return this; + } + + /** + * The unique identifier for this component. Used to reference this component in other parts of + * the pipeline (for example, as the input to downstream components). + * + * @return id + */ + @JsonProperty(JSON_PROPERTY_ID) + @JsonInclude(value = JsonInclude.Include.ALWAYS) + public String getId() { + return id; + } + + public void setId(String id) { + this.id = id; + } + + public ObservabilityPipelineDatadogTagsProcessor include(String include) { + this.include = include; + return this; + } + + /** + * A Datadog search query used to determine which logs this processor targets. + * + * @return include + */ + @JsonProperty(JSON_PROPERTY_INCLUDE) + @JsonInclude(value = JsonInclude.Include.ALWAYS) + public String getInclude() { + return include; + } + + public void setInclude(String include) { + this.include = include; + } + + public ObservabilityPipelineDatadogTagsProcessor inputs(List inputs) { + this.inputs = inputs; + return this; + } + + public ObservabilityPipelineDatadogTagsProcessor addInputsItem(String inputsItem) { + this.inputs.add(inputsItem); + return this; + } + + /** + * A list of component IDs whose output is used as the input for this component. + * + * @return inputs + */ + @JsonProperty(JSON_PROPERTY_INPUTS) + @JsonInclude(value = JsonInclude.Include.ALWAYS) + public List getInputs() { + return inputs; + } + + public void setInputs(List inputs) { + this.inputs = inputs; + } + + public ObservabilityPipelineDatadogTagsProcessor keys(List keys) { + this.keys = keys; + return this; + } + + public ObservabilityPipelineDatadogTagsProcessor addKeysItem(String keysItem) { + this.keys.add(keysItem); + return this; + } + + /** + * A list of tag keys. + * + * @return keys + */ + @JsonProperty(JSON_PROPERTY_KEYS) + @JsonInclude(value = JsonInclude.Include.ALWAYS) + public List getKeys() { + return keys; + } + + public void setKeys(List keys) { + this.keys = keys; + } + + public ObservabilityPipelineDatadogTagsProcessor mode( + ObservabilityPipelineDatadogTagsProcessorMode mode) { + this.mode = mode; + this.unparsed |= !mode.isValid(); + return this; + } + + /** + * The processing mode. + * + * @return mode + */ + @JsonProperty(JSON_PROPERTY_MODE) + @JsonInclude(value = JsonInclude.Include.ALWAYS) + public ObservabilityPipelineDatadogTagsProcessorMode getMode() { + return mode; + } + + public void setMode(ObservabilityPipelineDatadogTagsProcessorMode mode) { + if (!mode.isValid()) { + this.unparsed = true; + } + this.mode = mode; + } + + public ObservabilityPipelineDatadogTagsProcessor type( + ObservabilityPipelineDatadogTagsProcessorType type) { + this.type = type; + this.unparsed |= !type.isValid(); + return this; + } + + /** + * The processor type. The value should always be datadog_tags. + * + * @return type + */ + @JsonProperty(JSON_PROPERTY_TYPE) + @JsonInclude(value = JsonInclude.Include.ALWAYS) + public ObservabilityPipelineDatadogTagsProcessorType getType() { + return type; + } + + public void setType(ObservabilityPipelineDatadogTagsProcessorType type) { + if (!type.isValid()) { + this.unparsed = true; + } + this.type = type; + } + + /** + * 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 ObservabilityPipelineDatadogTagsProcessor + */ + @JsonAnySetter + public ObservabilityPipelineDatadogTagsProcessor 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 ObservabilityPipelineDatadogTagsProcessor object is equal to o. */ + @Override + public boolean equals(Object o) { + if (this == o) { + return true; + } + if (o == null || getClass() != o.getClass()) { + return false; + } + ObservabilityPipelineDatadogTagsProcessor observabilityPipelineDatadogTagsProcessor = + (ObservabilityPipelineDatadogTagsProcessor) o; + return Objects.equals(this.action, observabilityPipelineDatadogTagsProcessor.action) + && Objects.equals(this.id, observabilityPipelineDatadogTagsProcessor.id) + && Objects.equals(this.include, observabilityPipelineDatadogTagsProcessor.include) + && Objects.equals(this.inputs, observabilityPipelineDatadogTagsProcessor.inputs) + && Objects.equals(this.keys, observabilityPipelineDatadogTagsProcessor.keys) + && Objects.equals(this.mode, observabilityPipelineDatadogTagsProcessor.mode) + && Objects.equals(this.type, observabilityPipelineDatadogTagsProcessor.type) + && Objects.equals( + this.additionalProperties, + observabilityPipelineDatadogTagsProcessor.additionalProperties); + } + + @Override + public int hashCode() { + return Objects.hash(action, id, include, inputs, keys, mode, type, additionalProperties); + } + + @Override + public String toString() { + StringBuilder sb = new StringBuilder(); + sb.append("class ObservabilityPipelineDatadogTagsProcessor {\n"); + sb.append(" action: ").append(toIndentedString(action)).append("\n"); + sb.append(" id: ").append(toIndentedString(id)).append("\n"); + sb.append(" include: ").append(toIndentedString(include)).append("\n"); + sb.append(" inputs: ").append(toIndentedString(inputs)).append("\n"); + sb.append(" keys: ").append(toIndentedString(keys)).append("\n"); + sb.append(" mode: ").append(toIndentedString(mode)).append("\n"); + sb.append(" type: ").append(toIndentedString(type)).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/ObservabilityPipelineDatadogTagsProcessorAction.java b/src/main/java/com/datadog/api/client/v2/model/ObservabilityPipelineDatadogTagsProcessorAction.java new file mode 100644 index 00000000000..8ef51d4614f --- /dev/null +++ b/src/main/java/com/datadog/api/client/v2/model/ObservabilityPipelineDatadogTagsProcessorAction.java @@ -0,0 +1,65 @@ +/* + * 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; + +/** The action to take on tags with matching keys. */ +@JsonSerialize( + using = + ObservabilityPipelineDatadogTagsProcessorAction + .ObservabilityPipelineDatadogTagsProcessorActionSerializer.class) +public class ObservabilityPipelineDatadogTagsProcessorAction extends ModelEnum { + + private static final Set allowedValues = + new HashSet(Arrays.asList("include", "exclude")); + + public static final ObservabilityPipelineDatadogTagsProcessorAction INCLUDE = + new ObservabilityPipelineDatadogTagsProcessorAction("include"); + public static final ObservabilityPipelineDatadogTagsProcessorAction EXCLUDE = + new ObservabilityPipelineDatadogTagsProcessorAction("exclude"); + + ObservabilityPipelineDatadogTagsProcessorAction(String value) { + super(value, allowedValues); + } + + public static class ObservabilityPipelineDatadogTagsProcessorActionSerializer + extends StdSerializer { + public ObservabilityPipelineDatadogTagsProcessorActionSerializer( + Class t) { + super(t); + } + + public ObservabilityPipelineDatadogTagsProcessorActionSerializer() { + this(null); + } + + @Override + public void serialize( + ObservabilityPipelineDatadogTagsProcessorAction value, + JsonGenerator jgen, + SerializerProvider provider) + throws IOException, JsonProcessingException { + jgen.writeObject(value.value); + } + } + + @JsonCreator + public static ObservabilityPipelineDatadogTagsProcessorAction fromValue(String value) { + return new ObservabilityPipelineDatadogTagsProcessorAction(value); + } +} diff --git a/src/main/java/com/datadog/api/client/v2/model/ObservabilityPipelineDatadogTagsProcessorMode.java b/src/main/java/com/datadog/api/client/v2/model/ObservabilityPipelineDatadogTagsProcessorMode.java new file mode 100644 index 00000000000..f0f737536ef --- /dev/null +++ b/src/main/java/com/datadog/api/client/v2/model/ObservabilityPipelineDatadogTagsProcessorMode.java @@ -0,0 +1,62 @@ +/* + * 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; + +/** The processing mode. */ +@JsonSerialize( + using = + ObservabilityPipelineDatadogTagsProcessorMode + .ObservabilityPipelineDatadogTagsProcessorModeSerializer.class) +public class ObservabilityPipelineDatadogTagsProcessorMode extends ModelEnum { + + private static final Set allowedValues = new HashSet(Arrays.asList("filter")); + + public static final ObservabilityPipelineDatadogTagsProcessorMode FILTER = + new ObservabilityPipelineDatadogTagsProcessorMode("filter"); + + ObservabilityPipelineDatadogTagsProcessorMode(String value) { + super(value, allowedValues); + } + + public static class ObservabilityPipelineDatadogTagsProcessorModeSerializer + extends StdSerializer { + public ObservabilityPipelineDatadogTagsProcessorModeSerializer( + Class t) { + super(t); + } + + public ObservabilityPipelineDatadogTagsProcessorModeSerializer() { + this(null); + } + + @Override + public void serialize( + ObservabilityPipelineDatadogTagsProcessorMode value, + JsonGenerator jgen, + SerializerProvider provider) + throws IOException, JsonProcessingException { + jgen.writeObject(value.value); + } + } + + @JsonCreator + public static ObservabilityPipelineDatadogTagsProcessorMode fromValue(String value) { + return new ObservabilityPipelineDatadogTagsProcessorMode(value); + } +} diff --git a/src/main/java/com/datadog/api/client/v2/model/ObservabilityPipelineDatadogTagsProcessorType.java b/src/main/java/com/datadog/api/client/v2/model/ObservabilityPipelineDatadogTagsProcessorType.java new file mode 100644 index 00000000000..02a83a8e94b --- /dev/null +++ b/src/main/java/com/datadog/api/client/v2/model/ObservabilityPipelineDatadogTagsProcessorType.java @@ -0,0 +1,63 @@ +/* + * 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; + +/** The processor type. The value should always be datadog_tags. */ +@JsonSerialize( + using = + ObservabilityPipelineDatadogTagsProcessorType + .ObservabilityPipelineDatadogTagsProcessorTypeSerializer.class) +public class ObservabilityPipelineDatadogTagsProcessorType extends ModelEnum { + + private static final Set allowedValues = + new HashSet(Arrays.asList("datadog_tags")); + + public static final ObservabilityPipelineDatadogTagsProcessorType DATADOG_TAGS = + new ObservabilityPipelineDatadogTagsProcessorType("datadog_tags"); + + ObservabilityPipelineDatadogTagsProcessorType(String value) { + super(value, allowedValues); + } + + public static class ObservabilityPipelineDatadogTagsProcessorTypeSerializer + extends StdSerializer { + public ObservabilityPipelineDatadogTagsProcessorTypeSerializer( + Class t) { + super(t); + } + + public ObservabilityPipelineDatadogTagsProcessorTypeSerializer() { + this(null); + } + + @Override + public void serialize( + ObservabilityPipelineDatadogTagsProcessorType value, + JsonGenerator jgen, + SerializerProvider provider) + throws IOException, JsonProcessingException { + jgen.writeObject(value.value); + } + } + + @JsonCreator + public static ObservabilityPipelineDatadogTagsProcessorType fromValue(String value) { + return new ObservabilityPipelineDatadogTagsProcessorType(value); + } +}