From 14130e313b5d30558b9502ad2bda4c1076bf78be Mon Sep 17 00:00:00 2001 From: "ci.datadog-api-spec" Date: Tue, 9 Jun 2026 20:17:23 +0000 Subject: [PATCH] Regenerate client from commit b56a85b of spec repo --- .generator/schemas/v2/openapi.yaml | 45 +++++ src/datadogV2/model/mod.rs | 4 + ...vability_pipeline_config_processor_item.rs | 11 ++ ..._pipeline_generate_metrics_v2_processor.rs | 187 ++++++++++++++++++ ...line_generate_metrics_v2_processor_type.rs | 48 +++++ 5 files changed, 295 insertions(+) create mode 100644 src/datadogV2/model/model_observability_pipeline_generate_metrics_v2_processor.rs create mode 100644 src/datadogV2/model/model_observability_pipeline_generate_metrics_v2_processor_type.rs diff --git a/.generator/schemas/v2/openapi.yaml b/.generator/schemas/v2/openapi.yaml index 2d470c8f2f..2247ca8cc5 100644 --- a/.generator/schemas/v2/openapi.yaml +++ b/.generator/schemas/v2/openapi.yaml @@ -59823,6 +59823,7 @@ components: - $ref: "#/components/schemas/ObservabilityPipelineDedupeProcessor" - $ref: "#/components/schemas/ObservabilityPipelineEnrichmentTableProcessor" - $ref: "#/components/schemas/ObservabilityPipelineGenerateMetricsProcessor" + - $ref: "#/components/schemas/ObservabilityPipelineGenerateMetricsV2Processor" - $ref: "#/components/schemas/ObservabilityPipelineOcsfMapperProcessor" - $ref: "#/components/schemas/ObservabilityPipelineParseGrokProcessor" - $ref: "#/components/schemas/ObservabilityPipelineParseJSONProcessor" @@ -60962,6 +60963,50 @@ components: type: string x-enum-varnames: - GENERATE_DATADOG_METRICS + ObservabilityPipelineGenerateMetricsV2Processor: + description: |- + The `generate_metrics` processor creates custom metrics from logs. + Metrics can be counters, gauges, or distributions and optionally grouped by log fields. + The generated metrics must be routed to a metrics destination using the input `.metrics`. + + **Supported pipeline types:** logs + properties: + display_name: + $ref: "#/components/schemas/ObservabilityPipelineComponentDisplayName" + enabled: + description: Indicates whether the processor is enabled. + example: true + type: boolean + id: + description: The unique identifier for this component. Used to reference this component in other parts of the pipeline. + example: generate-metrics-processor + type: string + include: + description: A Datadog search query used to determine which logs this processor targets. + example: "service:my-service" + type: string + metrics: + description: Configuration for generating individual metrics. + items: + $ref: "#/components/schemas/ObservabilityPipelineGeneratedMetric" + type: array + type: + $ref: "#/components/schemas/ObservabilityPipelineGenerateMetricsV2ProcessorType" + required: + - id + - type + - enabled + type: object + x-pipeline-types: [logs] + ObservabilityPipelineGenerateMetricsV2ProcessorType: + default: generate_metrics + description: The processor type. Always `generate_metrics`. + enum: + - generate_metrics + example: generate_metrics + type: string + x-enum-varnames: + - GENERATE_METRICS ObservabilityPipelineGeneratedMetric: description: |- Defines a log-based custom metric, including its name, type, filter, value computation strategy, diff --git a/src/datadogV2/model/mod.rs b/src/datadogV2/model/mod.rs index dc9baf5f5c..89a9b18517 100644 --- a/src/datadogV2/model/mod.rs +++ b/src/datadogV2/model/mod.rs @@ -6872,6 +6872,10 @@ pub mod model_observability_pipeline_metric_value; pub use self::model_observability_pipeline_metric_value::ObservabilityPipelineMetricValue; pub mod model_observability_pipeline_generate_metrics_processor_type; pub use self::model_observability_pipeline_generate_metrics_processor_type::ObservabilityPipelineGenerateMetricsProcessorType; +pub mod model_observability_pipeline_generate_metrics_v2_processor; +pub use self::model_observability_pipeline_generate_metrics_v2_processor::ObservabilityPipelineGenerateMetricsV2Processor; +pub mod model_observability_pipeline_generate_metrics_v2_processor_type; +pub use self::model_observability_pipeline_generate_metrics_v2_processor_type::ObservabilityPipelineGenerateMetricsV2ProcessorType; pub mod model_observability_pipeline_ocsf_mapper_processor; pub use self::model_observability_pipeline_ocsf_mapper_processor::ObservabilityPipelineOcsfMapperProcessor; pub mod model_observability_pipeline_ocsf_mapper_processor_mapping; 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 1143f4197b..241bf1e121 100644 --- a/src/datadogV2/model/model_observability_pipeline_config_processor_item.rs +++ b/src/datadogV2/model/model_observability_pipeline_config_processor_item.rs @@ -35,6 +35,9 @@ pub enum ObservabilityPipelineConfigProcessorItem { ObservabilityPipelineGenerateMetricsProcessor( Box, ), + ObservabilityPipelineGenerateMetricsV2Processor( + Box, + ), ObservabilityPipelineOcsfMapperProcessor( Box, ), @@ -179,6 +182,14 @@ impl<'de> Deserialize<'de> for ObservabilityPipelineConfigProcessorItem { return Ok(ObservabilityPipelineConfigProcessorItem::ObservabilityPipelineGenerateMetricsProcessor(_v)); } } + if let Ok(_v) = serde_json::from_value::< + Box, + >(value.clone()) + { + if !_v._unparsed { + return Ok(ObservabilityPipelineConfigProcessorItem::ObservabilityPipelineGenerateMetricsV2Processor(_v)); + } + } if let Ok(_v) = serde_json::from_value::< Box, >(value.clone()) diff --git a/src/datadogV2/model/model_observability_pipeline_generate_metrics_v2_processor.rs b/src/datadogV2/model/model_observability_pipeline_generate_metrics_v2_processor.rs new file mode 100644 index 0000000000..963a351f26 --- /dev/null +++ b/src/datadogV2/model/model_observability_pipeline_generate_metrics_v2_processor.rs @@ -0,0 +1,187 @@ +// 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 `generate_metrics` processor creates custom metrics from logs. +/// Metrics can be counters, gauges, or distributions and optionally grouped by log fields. +/// The generated metrics must be routed to a metrics destination using the input `.metrics`. +/// +/// **Supported pipeline types:** logs +#[non_exhaustive] +#[skip_serializing_none] +#[derive(Clone, Debug, PartialEq, Serialize)] +pub struct ObservabilityPipelineGenerateMetricsV2Processor { + /// The display name for a component. + #[serde(rename = "display_name")] + pub display_name: Option, + /// Indicates whether the processor is enabled. + #[serde(rename = "enabled")] + pub enabled: bool, + /// The unique identifier for this component. Used to reference this component in other parts of the pipeline. + #[serde(rename = "id")] + pub id: String, + /// A Datadog search query used to determine which logs this processor targets. + #[serde(rename = "include")] + pub include: Option, + /// Configuration for generating individual metrics. + #[serde(rename = "metrics")] + pub metrics: Option>, + /// The processor type. Always `generate_metrics`. + #[serde(rename = "type")] + pub type_: crate::datadogV2::model::ObservabilityPipelineGenerateMetricsV2ProcessorType, + #[serde(flatten)] + pub additional_properties: std::collections::BTreeMap, + #[serde(skip)] + #[serde(default)] + pub(crate) _unparsed: bool, +} + +impl ObservabilityPipelineGenerateMetricsV2Processor { + pub fn new( + enabled: bool, + id: String, + type_: crate::datadogV2::model::ObservabilityPipelineGenerateMetricsV2ProcessorType, + ) -> ObservabilityPipelineGenerateMetricsV2Processor { + ObservabilityPipelineGenerateMetricsV2Processor { + display_name: None, + enabled, + id, + include: None, + metrics: None, + type_, + additional_properties: std::collections::BTreeMap::new(), + _unparsed: false, + } + } + + pub fn display_name(mut self, value: String) -> Self { + self.display_name = Some(value); + self + } + + pub fn include(mut self, value: String) -> Self { + self.include = Some(value); + self + } + + pub fn metrics( + mut self, + value: Vec, + ) -> Self { + self.metrics = Some(value); + self + } + + pub fn additional_properties( + mut self, + value: std::collections::BTreeMap, + ) -> Self { + self.additional_properties = value; + self + } +} + +impl<'de> Deserialize<'de> for ObservabilityPipelineGenerateMetricsV2Processor { + fn deserialize(deserializer: D) -> Result + where + D: Deserializer<'de>, + { + struct ObservabilityPipelineGenerateMetricsV2ProcessorVisitor; + impl<'a> Visitor<'a> for ObservabilityPipelineGenerateMetricsV2ProcessorVisitor { + type Value = ObservabilityPipelineGenerateMetricsV2Processor; + + 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 display_name: Option = None; + let mut enabled: Option = None; + let mut id: Option = None; + let mut include: Option = None; + let mut metrics: Option< + Vec, + > = None; + let mut type_: Option< + crate::datadogV2::model::ObservabilityPipelineGenerateMetricsV2ProcessorType, + > = 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() { + "display_name" => { + if v.is_null() { + continue; + } + display_name = + Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + "enabled" => { + enabled = Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + "id" => { + id = Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + "include" => { + if v.is_null() { + continue; + } + include = Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + "metrics" => { + if v.is_null() { + continue; + } + metrics = Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + "type" => { + type_ = Some(serde_json::from_value(v).map_err(M::Error::custom)?); + if let Some(ref _type_) = type_ { + match _type_ { + crate::datadogV2::model::ObservabilityPipelineGenerateMetricsV2ProcessorType::UnparsedObject(_type_) => { + _unparsed = true; + }, + _ => {} + } + } + } + &_ => { + if let Ok(value) = serde_json::from_value(v.clone()) { + additional_properties.insert(k, value); + } + } + } + } + let enabled = enabled.ok_or_else(|| M::Error::missing_field("enabled"))?; + let id = id.ok_or_else(|| M::Error::missing_field("id"))?; + let type_ = type_.ok_or_else(|| M::Error::missing_field("type_"))?; + + let content = ObservabilityPipelineGenerateMetricsV2Processor { + display_name, + enabled, + id, + include, + metrics, + type_, + additional_properties, + _unparsed, + }; + + Ok(content) + } + } + + deserializer.deserialize_any(ObservabilityPipelineGenerateMetricsV2ProcessorVisitor) + } +} diff --git a/src/datadogV2/model/model_observability_pipeline_generate_metrics_v2_processor_type.rs b/src/datadogV2/model/model_observability_pipeline_generate_metrics_v2_processor_type.rs new file mode 100644 index 0000000000..09b235ac45 --- /dev/null +++ b/src/datadogV2/model/model_observability_pipeline_generate_metrics_v2_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 ObservabilityPipelineGenerateMetricsV2ProcessorType { + GENERATE_METRICS, + UnparsedObject(crate::datadog::UnparsedObject), +} + +impl ToString for ObservabilityPipelineGenerateMetricsV2ProcessorType { + fn to_string(&self) -> String { + match self { + Self::GENERATE_METRICS => String::from("generate_metrics"), + Self::UnparsedObject(v) => v.value.to_string(), + } + } +} + +impl Serialize for ObservabilityPipelineGenerateMetricsV2ProcessorType { + 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 ObservabilityPipelineGenerateMetricsV2ProcessorType { + fn deserialize(deserializer: D) -> Result + where + D: Deserializer<'de>, + { + let s: String = String::deserialize(deserializer)?; + Ok(match s.as_str() { + "generate_metrics" => Self::GENERATE_METRICS, + _ => Self::UnparsedObject(crate::datadog::UnparsedObject { + value: serde_json::Value::String(s.into()), + }), + }) + } +}