Add observability pipelines Generate metrics (generate_metrics) processor

.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 `<processor-id>.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,

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;

src/datadogV2/model/model_observability_pipeline_config_processor_item.rs

@@ -35,6 +35,9 @@ pub enum ObservabilityPipelineConfigProcessorItem {
     ObservabilityPipelineGenerateMetricsProcessor(
         Box<crate::datadogV2::model::ObservabilityPipelineGenerateMetricsProcessor>,
     ),
+    ObservabilityPipelineGenerateMetricsV2Processor(
+        Box<crate::datadogV2::model::ObservabilityPipelineGenerateMetricsV2Processor>,
+    ),
     ObservabilityPipelineOcsfMapperProcessor(
         Box<crate::datadogV2::model::ObservabilityPipelineOcsfMapperProcessor>,
     ),
@@ -179,6 +182,14 @@ impl<'de> Deserialize<'de> for ObservabilityPipelineConfigProcessorItem {
                 return Ok(ObservabilityPipelineConfigProcessorItem::ObservabilityPipelineGenerateMetricsProcessor(_v));
             }
         }
+        if let Ok(_v) = serde_json::from_value::<
+            Box<crate::datadogV2::model::ObservabilityPipelineGenerateMetricsV2Processor>,
+        >(value.clone())
+        {
+            if !_v._unparsed {
+                return Ok(ObservabilityPipelineConfigProcessorItem::ObservabilityPipelineGenerateMetricsV2Processor(_v));
+            }
+        }
         if let Ok(_v) = serde_json::from_value::<
             Box<crate::datadogV2::model::ObservabilityPipelineOcsfMapperProcessor>,
         >(value.clone())

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 `<processor-id>.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<String>,
+    /// 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<String>,
+    /// Configuration for generating individual metrics.
+    #[serde(rename = "metrics")]
+    pub metrics: Option<Vec<crate::datadogV2::model::ObservabilityPipelineGeneratedMetric>>,
+    /// The processor type. Always `generate_metrics`.
+    #[serde(rename = "type")]
+    pub type_: crate::datadogV2::model::ObservabilityPipelineGenerateMetricsV2ProcessorType,
+    #[serde(flatten)]
+    pub additional_properties: std::collections::BTreeMap<String, serde_json::Value>,
+    #[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<crate::datadogV2::model::ObservabilityPipelineGeneratedMetric>,
+    ) -> Self {
+        self.metrics = Some(value);
+        self
+    }
+
+    pub fn additional_properties(
+        mut self,
+        value: std::collections::BTreeMap<String, serde_json::Value>,
+    ) -> Self {
+        self.additional_properties = value;
+        self
+    }
+}
+
+impl<'de> Deserialize<'de> for ObservabilityPipelineGenerateMetricsV2Processor {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    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<M>(self, mut map: M) -> Result<Self::Value, M::Error>
+            where
+                M: MapAccess<'a>,
+            {
+                let mut display_name: Option<String> = None;
+                let mut enabled: Option<bool> = None;
+                let mut id: Option<String> = None;
+                let mut include: Option<String> = None;
+                let mut metrics: Option<
+                    Vec<crate::datadogV2::model::ObservabilityPipelineGeneratedMetric>,
+                > = 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::<String, serde_json::Value>()? {
+                    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)
+    }
+}

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<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    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<D>(deserializer: D) -> Result<Self, D::Error>
+    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()),
+            }),
+        })
+    }
+}