From 05018420ae07340d002383fb7d939d373fd7ad5e Mon Sep 17 00:00:00 2001 From: "ci.datadog-api-spec" Date: Fri, 18 Jul 2025 21:28:10 +0000 Subject: [PATCH] Regenerate client from commit 5b64e98 of spec repo --- .generated-info | 4 +- .generator/schemas/v2/openapi.yaml | 75 +++++++ src/datadogV2/model/mod.rs | 8 + ...vability_pipeline_config_processor_item.rs | 11 + ...ability_pipeline_datadog_tags_processor.rs | 190 ++++++++++++++++++ ..._pipeline_datadog_tags_processor_action.rs | 51 +++++ ...ty_pipeline_datadog_tags_processor_mode.rs | 48 +++++ ...ty_pipeline_datadog_tags_processor_type.rs | 48 +++++ 8 files changed, 433 insertions(+), 2 deletions(-) create mode 100644 src/datadogV2/model/model_observability_pipeline_datadog_tags_processor.rs create mode 100644 src/datadogV2/model/model_observability_pipeline_datadog_tags_processor_action.rs create mode 100644 src/datadogV2/model/model_observability_pipeline_datadog_tags_processor_mode.rs create mode 100644 src/datadogV2/model/model_observability_pipeline_datadog_tags_processor_type.rs diff --git a/.generated-info b/.generated-info index aba212bec..a1850cc66 100644 --- a/.generated-info +++ b/.generated-info @@ -1,4 +1,4 @@ { - "spec_repo_commit": "0f24b8e", - "generated": "2025-07-18 16:58:06.791" + "spec_repo_commit": "5b64e98", + "generated": "2025-07-18 21:28:10.698" } diff --git a/.generator/schemas/v2/openapi.yaml b/.generator/schemas/v2/openapi.yaml index 5a4d2ba12..571011d49 100644 --- a/.generator/schemas/v2/openapi.yaml +++ b/.generator/schemas/v2/openapi.yaml @@ -25557,6 +25557,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: @@ -25666,6 +25667,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/datadogV2/model/mod.rs b/src/datadogV2/model/mod.rs index 37180685c..ffdc68b2a 100644 --- a/src/datadogV2/model/mod.rs +++ b/src/datadogV2/model/mod.rs @@ -3712,6 +3712,14 @@ pub mod model_observability_pipeline_throttle_processor; pub use self::model_observability_pipeline_throttle_processor::ObservabilityPipelineThrottleProcessor; pub mod model_observability_pipeline_throttle_processor_type; pub use self::model_observability_pipeline_throttle_processor_type::ObservabilityPipelineThrottleProcessorType; +pub mod model_observability_pipeline_datadog_tags_processor; +pub use self::model_observability_pipeline_datadog_tags_processor::ObservabilityPipelineDatadogTagsProcessor; +pub mod model_observability_pipeline_datadog_tags_processor_action; +pub use self::model_observability_pipeline_datadog_tags_processor_action::ObservabilityPipelineDatadogTagsProcessorAction; +pub mod model_observability_pipeline_datadog_tags_processor_mode; +pub use self::model_observability_pipeline_datadog_tags_processor_mode::ObservabilityPipelineDatadogTagsProcessorMode; +pub mod model_observability_pipeline_datadog_tags_processor_type; +pub use self::model_observability_pipeline_datadog_tags_processor_type::ObservabilityPipelineDatadogTagsProcessorType; pub mod model_observability_pipeline_config_processor_item; pub use self::model_observability_pipeline_config_processor_item::ObservabilityPipelineConfigProcessorItem; pub mod model_observability_pipeline_kafka_source; diff --git a/src/datadogV2/model/model_observability_pipeline_config_processor_item.rs b/src/datadogV2/model/model_observability_pipeline_config_processor_item.rs index 8bfae3f08..f3c7cc537 100644 --- a/src/datadogV2/model/model_observability_pipeline_config_processor_item.rs +++ b/src/datadogV2/model/model_observability_pipeline_config_processor_item.rs @@ -56,6 +56,9 @@ pub enum ObservabilityPipelineConfigProcessorItem { ObservabilityPipelineThrottleProcessor( Box, ), + ObservabilityPipelineDatadogTagsProcessor( + Box, + ), UnparsedObject(crate::datadog::UnparsedObject), } @@ -213,6 +216,14 @@ impl<'de> Deserialize<'de> for ObservabilityPipelineConfigProcessorItem { return Ok(ObservabilityPipelineConfigProcessorItem::ObservabilityPipelineThrottleProcessor(_v)); } } + if let Ok(_v) = serde_json::from_value::< + Box, + >(value.clone()) + { + if !_v._unparsed { + return Ok(ObservabilityPipelineConfigProcessorItem::ObservabilityPipelineDatadogTagsProcessor(_v)); + } + } return Ok(ObservabilityPipelineConfigProcessorItem::UnparsedObject( crate::datadog::UnparsedObject { value }, diff --git a/src/datadogV2/model/model_observability_pipeline_datadog_tags_processor.rs b/src/datadogV2/model/model_observability_pipeline_datadog_tags_processor.rs new file mode 100644 index 000000000..fd8da1208 --- /dev/null +++ b/src/datadogV2/model/model_observability_pipeline_datadog_tags_processor.rs @@ -0,0 +1,190 @@ +// 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. +use serde::de::{Error, MapAccess, Visitor}; +use serde::{Deserialize, Deserializer, Serialize}; +use serde_with::skip_serializing_none; +use std::fmt::{self, Formatter}; + +/// The `datadog_tags` processor includes or excludes specific Datadog tags in your logs. +#[non_exhaustive] +#[skip_serializing_none] +#[derive(Clone, Debug, PartialEq, Serialize)] +pub struct ObservabilityPipelineDatadogTagsProcessor { + /// The action to take on tags with matching keys. + #[serde(rename = "action")] + pub action: crate::datadogV2::model::ObservabilityPipelineDatadogTagsProcessorAction, + /// 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). + #[serde(rename = "id")] + pub id: String, + /// A Datadog search query used to determine which logs this processor targets. + #[serde(rename = "include")] + pub include: String, + /// A list of component IDs whose output is used as the `input` for this component. + #[serde(rename = "inputs")] + pub inputs: Vec, + /// A list of tag keys. + #[serde(rename = "keys")] + pub keys: Vec, + /// The processing mode. + #[serde(rename = "mode")] + pub mode: crate::datadogV2::model::ObservabilityPipelineDatadogTagsProcessorMode, + /// The processor type. The value should always be `datadog_tags`. + #[serde(rename = "type")] + pub type_: crate::datadogV2::model::ObservabilityPipelineDatadogTagsProcessorType, + #[serde(flatten)] + pub additional_properties: std::collections::BTreeMap, + #[serde(skip)] + #[serde(default)] + pub(crate) _unparsed: bool, +} + +impl ObservabilityPipelineDatadogTagsProcessor { + pub fn new( + action: crate::datadogV2::model::ObservabilityPipelineDatadogTagsProcessorAction, + id: String, + include: String, + inputs: Vec, + keys: Vec, + mode: crate::datadogV2::model::ObservabilityPipelineDatadogTagsProcessorMode, + type_: crate::datadogV2::model::ObservabilityPipelineDatadogTagsProcessorType, + ) -> ObservabilityPipelineDatadogTagsProcessor { + ObservabilityPipelineDatadogTagsProcessor { + action, + id, + include, + inputs, + keys, + mode, + type_, + additional_properties: std::collections::BTreeMap::new(), + _unparsed: false, + } + } + + pub fn additional_properties( + mut self, + value: std::collections::BTreeMap, + ) -> Self { + self.additional_properties = value; + self + } +} + +impl<'de> Deserialize<'de> for ObservabilityPipelineDatadogTagsProcessor { + fn deserialize(deserializer: D) -> Result + where + D: Deserializer<'de>, + { + struct ObservabilityPipelineDatadogTagsProcessorVisitor; + impl<'a> Visitor<'a> for ObservabilityPipelineDatadogTagsProcessorVisitor { + type Value = ObservabilityPipelineDatadogTagsProcessor; + + fn expecting(&self, f: &mut Formatter<'_>) -> fmt::Result { + f.write_str("a mapping") + } + + fn visit_map(self, mut map: M) -> Result + where + M: MapAccess<'a>, + { + let mut action: Option< + crate::datadogV2::model::ObservabilityPipelineDatadogTagsProcessorAction, + > = None; + let mut id: Option = None; + let mut include: Option = None; + let mut inputs: Option> = None; + let mut keys: Option> = None; + let mut mode: Option< + crate::datadogV2::model::ObservabilityPipelineDatadogTagsProcessorMode, + > = None; + let mut type_: Option< + crate::datadogV2::model::ObservabilityPipelineDatadogTagsProcessorType, + > = None; + let mut additional_properties: std::collections::BTreeMap< + String, + serde_json::Value, + > = std::collections::BTreeMap::new(); + let mut _unparsed = false; + + while let Some((k, v)) = map.next_entry::()? { + match k.as_str() { + "action" => { + action = Some(serde_json::from_value(v).map_err(M::Error::custom)?); + if let Some(ref _action) = action { + match _action { + crate::datadogV2::model::ObservabilityPipelineDatadogTagsProcessorAction::UnparsedObject(_action) => { + _unparsed = true; + }, + _ => {} + } + } + } + "id" => { + id = Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + "include" => { + include = Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + "inputs" => { + inputs = Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + "keys" => { + keys = Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + "mode" => { + mode = Some(serde_json::from_value(v).map_err(M::Error::custom)?); + if let Some(ref _mode) = mode { + match _mode { + crate::datadogV2::model::ObservabilityPipelineDatadogTagsProcessorMode::UnparsedObject(_mode) => { + _unparsed = true; + }, + _ => {} + } + } + } + "type" => { + type_ = Some(serde_json::from_value(v).map_err(M::Error::custom)?); + if let Some(ref _type_) = type_ { + match _type_ { + crate::datadogV2::model::ObservabilityPipelineDatadogTagsProcessorType::UnparsedObject(_type_) => { + _unparsed = true; + }, + _ => {} + } + } + } + &_ => { + if let Ok(value) = serde_json::from_value(v.clone()) { + additional_properties.insert(k, value); + } + } + } + } + let action = action.ok_or_else(|| M::Error::missing_field("action"))?; + let id = id.ok_or_else(|| M::Error::missing_field("id"))?; + let include = include.ok_or_else(|| M::Error::missing_field("include"))?; + let inputs = inputs.ok_or_else(|| M::Error::missing_field("inputs"))?; + let keys = keys.ok_or_else(|| M::Error::missing_field("keys"))?; + let mode = mode.ok_or_else(|| M::Error::missing_field("mode"))?; + let type_ = type_.ok_or_else(|| M::Error::missing_field("type_"))?; + + let content = ObservabilityPipelineDatadogTagsProcessor { + action, + id, + include, + inputs, + keys, + mode, + type_, + additional_properties, + _unparsed, + }; + + Ok(content) + } + } + + deserializer.deserialize_any(ObservabilityPipelineDatadogTagsProcessorVisitor) + } +} diff --git a/src/datadogV2/model/model_observability_pipeline_datadog_tags_processor_action.rs b/src/datadogV2/model/model_observability_pipeline_datadog_tags_processor_action.rs new file mode 100644 index 000000000..0519cc9d5 --- /dev/null +++ b/src/datadogV2/model/model_observability_pipeline_datadog_tags_processor_action.rs @@ -0,0 +1,51 @@ +// 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. + +use serde::{Deserialize, Deserializer, Serialize, Serializer}; + +#[non_exhaustive] +#[derive(Clone, Debug, Eq, PartialEq)] +pub enum ObservabilityPipelineDatadogTagsProcessorAction { + INCLUDE, + EXCLUDE, + UnparsedObject(crate::datadog::UnparsedObject), +} + +impl ToString for ObservabilityPipelineDatadogTagsProcessorAction { + fn to_string(&self) -> String { + match self { + Self::INCLUDE => String::from("include"), + Self::EXCLUDE => String::from("exclude"), + Self::UnparsedObject(v) => v.value.to_string(), + } + } +} + +impl Serialize for ObservabilityPipelineDatadogTagsProcessorAction { + fn serialize(&self, serializer: S) -> Result + where + S: Serializer, + { + match self { + Self::UnparsedObject(v) => v.serialize(serializer), + _ => serializer.serialize_str(self.to_string().as_str()), + } + } +} + +impl<'de> Deserialize<'de> for ObservabilityPipelineDatadogTagsProcessorAction { + fn deserialize(deserializer: D) -> Result + where + D: Deserializer<'de>, + { + let s: String = String::deserialize(deserializer)?; + Ok(match s.as_str() { + "include" => Self::INCLUDE, + "exclude" => Self::EXCLUDE, + _ => Self::UnparsedObject(crate::datadog::UnparsedObject { + value: serde_json::Value::String(s.into()), + }), + }) + } +} diff --git a/src/datadogV2/model/model_observability_pipeline_datadog_tags_processor_mode.rs b/src/datadogV2/model/model_observability_pipeline_datadog_tags_processor_mode.rs new file mode 100644 index 000000000..e8e030aee --- /dev/null +++ b/src/datadogV2/model/model_observability_pipeline_datadog_tags_processor_mode.rs @@ -0,0 +1,48 @@ +// 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. + +use serde::{Deserialize, Deserializer, Serialize, Serializer}; + +#[non_exhaustive] +#[derive(Clone, Debug, Eq, PartialEq)] +pub enum ObservabilityPipelineDatadogTagsProcessorMode { + FILTER, + UnparsedObject(crate::datadog::UnparsedObject), +} + +impl ToString for ObservabilityPipelineDatadogTagsProcessorMode { + fn to_string(&self) -> String { + match self { + Self::FILTER => String::from("filter"), + Self::UnparsedObject(v) => v.value.to_string(), + } + } +} + +impl Serialize for ObservabilityPipelineDatadogTagsProcessorMode { + fn serialize(&self, serializer: S) -> Result + where + S: Serializer, + { + match self { + Self::UnparsedObject(v) => v.serialize(serializer), + _ => serializer.serialize_str(self.to_string().as_str()), + } + } +} + +impl<'de> Deserialize<'de> for ObservabilityPipelineDatadogTagsProcessorMode { + fn deserialize(deserializer: D) -> Result + where + D: Deserializer<'de>, + { + let s: String = String::deserialize(deserializer)?; + Ok(match s.as_str() { + "filter" => Self::FILTER, + _ => Self::UnparsedObject(crate::datadog::UnparsedObject { + value: serde_json::Value::String(s.into()), + }), + }) + } +} diff --git a/src/datadogV2/model/model_observability_pipeline_datadog_tags_processor_type.rs b/src/datadogV2/model/model_observability_pipeline_datadog_tags_processor_type.rs new file mode 100644 index 000000000..0b685263a --- /dev/null +++ b/src/datadogV2/model/model_observability_pipeline_datadog_tags_processor_type.rs @@ -0,0 +1,48 @@ +// 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. + +use serde::{Deserialize, Deserializer, Serialize, Serializer}; + +#[non_exhaustive] +#[derive(Clone, Debug, Eq, PartialEq)] +pub enum ObservabilityPipelineDatadogTagsProcessorType { + DATADOG_TAGS, + UnparsedObject(crate::datadog::UnparsedObject), +} + +impl ToString for ObservabilityPipelineDatadogTagsProcessorType { + fn to_string(&self) -> String { + match self { + Self::DATADOG_TAGS => String::from("datadog_tags"), + Self::UnparsedObject(v) => v.value.to_string(), + } + } +} + +impl Serialize for ObservabilityPipelineDatadogTagsProcessorType { + fn serialize(&self, serializer: S) -> Result + where + S: Serializer, + { + match self { + Self::UnparsedObject(v) => v.serialize(serializer), + _ => serializer.serialize_str(self.to_string().as_str()), + } + } +} + +impl<'de> Deserialize<'de> for ObservabilityPipelineDatadogTagsProcessorType { + fn deserialize(deserializer: D) -> Result + where + D: Deserializer<'de>, + { + let s: String = String::deserialize(deserializer)?; + Ok(match s.as_str() { + "datadog_tags" => Self::DATADOG_TAGS, + _ => Self::UnparsedObject(crate::datadog::UnparsedObject { + value: serde_json::Value::String(s.into()), + }), + }) + } +}