obs-pipelines Update tag cardinality limit processor schema

.generator/schemas/v2/openapi.yaml

@@ -70300,6 +70300,8 @@ components:
             $ref: "#/components/schemas/ObservabilityPipelineTagCardinalityLimitProcessorPerMetricLimit"
           maxItems: 100
           type: array
+        tracking_mode:
+          $ref: "#/components/schemas/ObservabilityPipelineTagCardinalityLimitProcessorTrackingMode"
         type:
           $ref: "#/components/schemas/ObservabilityPipelineTagCardinalityLimitProcessorType"
         value_limit:
@@ -70314,6 +70316,7 @@ components:
         - type
         - include
         - limit_exceeded_action
+        - tracking_mode
         - value_limit
         - enabled
       type: object
@@ -70328,6 +70331,16 @@ components:
       x-enum-varnames:
         - DROP_TAG
         - DROP_EVENT
+    ObservabilityPipelineTagCardinalityLimitProcessorOverrideType:
+      description: How the override is applied. `limit_override` enforces a custom limit; `excluded` omits the metric or tag from cardinality tracking.
+      enum:
+        - limit_override
+        - excluded
+      example: limit_override
+      type: string
+      x-enum-varnames:
+        - LIMIT_OVERRIDE
+        - EXCLUDED
     ObservabilityPipelineTagCardinalityLimitProcessorPerMetricLimit:
       description: A cardinality override applied to a specific metric.
       properties:
@@ -70337,65 +70350,63 @@ components:
           description: The name of the metric this override applies to.
           example: "system.cpu.user"
           type: string
-        mode:
-          $ref: "#/components/schemas/ObservabilityPipelineTagCardinalityLimitProcessorPerMetricMode"
+        override_type:
+          $ref: "#/components/schemas/ObservabilityPipelineTagCardinalityLimitProcessorOverrideType"
         per_tag_limits:
-          description: A list of per-tag cardinality overrides that apply within this metric. Must be omitted when `mode` is `excluded`.
+          description: A list of per-tag cardinality overrides that apply within this metric. Must be omitted when `override_type` is `excluded`.
           items:
             $ref: "#/components/schemas/ObservabilityPipelineTagCardinalityLimitProcessorPerTagLimit"
           maxItems: 50
           type: array
         value_limit:
-          description: The maximum number of distinct tag value combinations allowed for this metric. Required when `mode` is `tracked`. Must be omitted when `mode` is `excluded`.
+          description: The maximum number of distinct tag value combinations allowed for this metric. Required when `override_type` is `limit_override`. Must be omitted when `override_type` is `excluded`.
           example: 10000
           format: int64
           maximum: 1000000
           minimum: 0
           type: integer
       required:
         - metric_name
-        - mode
+        - override_type
       type: object
-    ObservabilityPipelineTagCardinalityLimitProcessorPerMetricMode:
-      description: How the per-metric override is applied. `tracked` enforces a custom limit; `excluded` skips the metric entirely.
-      enum:
-        - tracked
-        - excluded
-      example: tracked
-      type: string
-      x-enum-varnames:
-        - TRACKED
-        - EXCLUDED
     ObservabilityPipelineTagCardinalityLimitProcessorPerTagLimit:
       description: A cardinality override for a specific tag key within a per-metric limit.
       properties:
-        mode:
-          $ref: "#/components/schemas/ObservabilityPipelineTagCardinalityLimitProcessorPerTagMode"
+        override_type:
+          $ref: "#/components/schemas/ObservabilityPipelineTagCardinalityLimitProcessorOverrideType"
         tag_key:
           description: The tag key this override applies to.
           example: "host"
           type: string
         value_limit:
-          description: The maximum number of distinct values allowed for this tag. Required when `mode` is `limit_override`. Must be omitted when `mode` is `excluded`.
+          description: The maximum number of distinct values allowed for this tag. Required when `override_type` is `limit_override`. Must be omitted when `override_type` is `excluded`.
           example: 5000
           format: int64
           maximum: 1000000
           minimum: 0
           type: integer
       required:
         - tag_key
+        - override_type
+      type: object
+    ObservabilityPipelineTagCardinalityLimitProcessorTrackingMode:
+      description: Controls whether the processor uses exact or probabilistic tag tracking.
+      properties:
+        mode:
+          $ref: "#/components/schemas/ObservabilityPipelineTagCardinalityLimitProcessorTrackingModeMode"
+      required:
         - mode
       type: object
-    ObservabilityPipelineTagCardinalityLimitProcessorPerTagMode:
-      description: How the per-tag override is applied. `limit_override` enforces a custom limit on the tag; `excluded` skips the tag from cardinality tracking.
+    ObservabilityPipelineTagCardinalityLimitProcessorTrackingModeMode:
+      description: The cardinality tracking algorithm to use.
       enum:
-        - limit_override
-        - excluded
-      example: limit_override
+        - exact_fingerprint
+        - probabilistic
+      example: exact_fingerprint
       type: string
       x-enum-varnames:
-        - LIMIT_OVERRIDE
-        - EXCLUDED
+        - EXACT_FINGERPRINT
+        - PROBABILISTIC
     ObservabilityPipelineTagCardinalityLimitProcessorType:
       default: tag_cardinality_limit
       description: The processor type. The value must be `tag_cardinality_limit`.

src/datadogV2/model/mod.rs

@@ -7630,12 +7630,14 @@ pub mod model_observability_pipeline_tag_cardinality_limit_processor_action;
 pub use self::model_observability_pipeline_tag_cardinality_limit_processor_action::ObservabilityPipelineTagCardinalityLimitProcessorAction;
 pub mod model_observability_pipeline_tag_cardinality_limit_processor_per_metric_limit;
 pub use self::model_observability_pipeline_tag_cardinality_limit_processor_per_metric_limit::ObservabilityPipelineTagCardinalityLimitProcessorPerMetricLimit;
-pub mod model_observability_pipeline_tag_cardinality_limit_processor_per_metric_mode;
-pub use self::model_observability_pipeline_tag_cardinality_limit_processor_per_metric_mode::ObservabilityPipelineTagCardinalityLimitProcessorPerMetricMode;
+pub mod model_observability_pipeline_tag_cardinality_limit_processor_override_type;
+pub use self::model_observability_pipeline_tag_cardinality_limit_processor_override_type::ObservabilityPipelineTagCardinalityLimitProcessorOverrideType;
 pub mod model_observability_pipeline_tag_cardinality_limit_processor_per_tag_limit;
 pub use self::model_observability_pipeline_tag_cardinality_limit_processor_per_tag_limit::ObservabilityPipelineTagCardinalityLimitProcessorPerTagLimit;
-pub mod model_observability_pipeline_tag_cardinality_limit_processor_per_tag_mode;
-pub use self::model_observability_pipeline_tag_cardinality_limit_processor_per_tag_mode::ObservabilityPipelineTagCardinalityLimitProcessorPerTagMode;
+pub mod model_observability_pipeline_tag_cardinality_limit_processor_tracking_mode;
+pub use self::model_observability_pipeline_tag_cardinality_limit_processor_tracking_mode::ObservabilityPipelineTagCardinalityLimitProcessorTrackingMode;
+pub mod model_observability_pipeline_tag_cardinality_limit_processor_tracking_mode_mode;
+pub use self::model_observability_pipeline_tag_cardinality_limit_processor_tracking_mode_mode::ObservabilityPipelineTagCardinalityLimitProcessorTrackingModeMode;
 pub mod model_observability_pipeline_tag_cardinality_limit_processor_type;
 pub use self::model_observability_pipeline_tag_cardinality_limit_processor_type::ObservabilityPipelineTagCardinalityLimitProcessorType;
 pub mod model_observability_pipeline_config_processor_item;

src/datadogV2/model/model_observability_pipeline_tag_cardinality_limit_processor.rs

@@ -31,6 +31,9 @@ pub struct ObservabilityPipelineTagCardinalityLimitProcessor {
     /// A list of per-metric cardinality overrides that take precedence over the default `value_limit`.
     #[serde(rename = "per_metric_limits")]
     pub per_metric_limits: Option<Vec<crate::datadogV2::model::ObservabilityPipelineTagCardinalityLimitProcessorPerMetricLimit>>,
+    /// Controls whether the processor uses exact or probabilistic tag tracking.
+    #[serde(rename = "tracking_mode")]
+    pub tracking_mode: crate::datadogV2::model::ObservabilityPipelineTagCardinalityLimitProcessorTrackingMode,
     /// The processor type. The value must be `tag_cardinality_limit`.
     #[serde(rename = "type")]
     pub type_: crate::datadogV2::model::ObservabilityPipelineTagCardinalityLimitProcessorType,
@@ -50,6 +53,7 @@ impl ObservabilityPipelineTagCardinalityLimitProcessor {
         id: String,
         include: String,
         limit_exceeded_action: crate::datadogV2::model::ObservabilityPipelineTagCardinalityLimitProcessorAction,
+        tracking_mode: crate::datadogV2::model::ObservabilityPipelineTagCardinalityLimitProcessorTrackingMode,
         type_: crate::datadogV2::model::ObservabilityPipelineTagCardinalityLimitProcessorType,
         value_limit: i64,
     ) -> ObservabilityPipelineTagCardinalityLimitProcessor {
@@ -60,6 +64,7 @@ impl ObservabilityPipelineTagCardinalityLimitProcessor {
             include,
             limit_exceeded_action,
             per_metric_limits: None,
+            tracking_mode,
             type_,
             value_limit,
             additional_properties: std::collections::BTreeMap::new(),
@@ -112,6 +117,7 @@ impl<'de> Deserialize<'de> for ObservabilityPipelineTagCardinalityLimitProcessor
                 let mut include: Option<String> = None;
                 let mut limit_exceeded_action: Option<crate::datadogV2::model::ObservabilityPipelineTagCardinalityLimitProcessorAction> = None;
                 let mut per_metric_limits: Option<Vec<crate::datadogV2::model::ObservabilityPipelineTagCardinalityLimitProcessorPerMetricLimit>> = None;
+                let mut tracking_mode: Option<crate::datadogV2::model::ObservabilityPipelineTagCardinalityLimitProcessorTrackingMode> = None;
                 let mut type_: Option<
                     crate::datadogV2::model::ObservabilityPipelineTagCardinalityLimitProcessorType,
                 > = None;
@@ -159,6 +165,10 @@ impl<'de> Deserialize<'de> for ObservabilityPipelineTagCardinalityLimitProcessor
                             per_metric_limits =
                                 Some(serde_json::from_value(v).map_err(M::Error::custom)?);
                         }
+                        "tracking_mode" => {
+                            tracking_mode =
+                                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_ {
@@ -186,6 +196,8 @@ impl<'de> Deserialize<'de> for ObservabilityPipelineTagCardinalityLimitProcessor
                 let include = include.ok_or_else(|| M::Error::missing_field("include"))?;
                 let limit_exceeded_action = limit_exceeded_action
                     .ok_or_else(|| M::Error::missing_field("limit_exceeded_action"))?;
+                let tracking_mode =
+                    tracking_mode.ok_or_else(|| M::Error::missing_field("tracking_mode"))?;
                 let type_ = type_.ok_or_else(|| M::Error::missing_field("type_"))?;
                 let value_limit =
                     value_limit.ok_or_else(|| M::Error::missing_field("value_limit"))?;
@@ -197,6 +209,7 @@ impl<'de> Deserialize<'de> for ObservabilityPipelineTagCardinalityLimitProcessor
                     include,
                     limit_exceeded_action,
                     per_metric_limits,
+                    tracking_mode,
                     type_,
                     value_limit,
                     additional_properties,

src/datadogV2/model/model_observability_pipeline_tag_cardinality_limit_processor_per_tag_mode.rs → src/datadogV2/model/model_observability_pipeline_tag_cardinality_limit_processor_override_type.rs

@@ -6,13 +6,13 @@ use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[non_exhaustive]
 #[derive(Clone, Debug, Eq, PartialEq)]
-pub enum ObservabilityPipelineTagCardinalityLimitProcessorPerTagMode {
+pub enum ObservabilityPipelineTagCardinalityLimitProcessorOverrideType {
     LIMIT_OVERRIDE,
     EXCLUDED,
     UnparsedObject(crate::datadog::UnparsedObject),
 }
 
-impl ToString for ObservabilityPipelineTagCardinalityLimitProcessorPerTagMode {
+impl ToString for ObservabilityPipelineTagCardinalityLimitProcessorOverrideType {
     fn to_string(&self) -> String {
         match self {
             Self::LIMIT_OVERRIDE => String::from("limit_override"),
@@ -22,7 +22,7 @@ impl ToString for ObservabilityPipelineTagCardinalityLimitProcessorPerTagMode {
     }
 }
 
-impl Serialize for ObservabilityPipelineTagCardinalityLimitProcessorPerTagMode {
+impl Serialize for ObservabilityPipelineTagCardinalityLimitProcessorOverrideType {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where
         S: Serializer,
@@ -34,7 +34,7 @@ impl Serialize for ObservabilityPipelineTagCardinalityLimitProcessorPerTagMode {
     }
 }
 
-impl<'de> Deserialize<'de> for ObservabilityPipelineTagCardinalityLimitProcessorPerTagMode {
+impl<'de> Deserialize<'de> for ObservabilityPipelineTagCardinalityLimitProcessorOverrideType {
     fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
     where
         D: Deserializer<'de>,

src/datadogV2/model/model_observability_pipeline_tag_cardinality_limit_processor_per_metric_limit.rs

@@ -18,16 +18,16 @@ pub struct ObservabilityPipelineTagCardinalityLimitProcessorPerMetricLimit {
     /// The name of the metric this override applies to.
     #[serde(rename = "metric_name")]
     pub metric_name: String,
-    /// How the per-metric override is applied. `tracked` enforces a custom limit; `excluded` skips the metric entirely.
-    #[serde(rename = "mode")]
-    pub mode:
-        crate::datadogV2::model::ObservabilityPipelineTagCardinalityLimitProcessorPerMetricMode,
-    /// A list of per-tag cardinality overrides that apply within this metric. Must be omitted when `mode` is `excluded`.
+    /// How the override is applied. `limit_override` enforces a custom limit; `excluded` omits the metric or tag from cardinality tracking.
+    #[serde(rename = "override_type")]
+    pub override_type:
+        crate::datadogV2::model::ObservabilityPipelineTagCardinalityLimitProcessorOverrideType,
+    /// A list of per-tag cardinality overrides that apply within this metric. Must be omitted when `override_type` is `excluded`.
     #[serde(rename = "per_tag_limits")]
     pub per_tag_limits: Option<
         Vec<crate::datadogV2::model::ObservabilityPipelineTagCardinalityLimitProcessorPerTagLimit>,
     >,
-    /// The maximum number of distinct tag value combinations allowed for this metric. Required when `mode` is `tracked`. Must be omitted when `mode` is `excluded`.
+    /// The maximum number of distinct tag value combinations allowed for this metric. Required when `override_type` is `limit_override`. Must be omitted when `override_type` is `excluded`.
     #[serde(rename = "value_limit")]
     pub value_limit: Option<i64>,
     #[serde(flatten)]
@@ -40,12 +40,12 @@ pub struct ObservabilityPipelineTagCardinalityLimitProcessorPerMetricLimit {
 impl ObservabilityPipelineTagCardinalityLimitProcessorPerMetricLimit {
     pub fn new(
         metric_name: String,
-        mode: crate::datadogV2::model::ObservabilityPipelineTagCardinalityLimitProcessorPerMetricMode,
+        override_type: crate::datadogV2::model::ObservabilityPipelineTagCardinalityLimitProcessorOverrideType,
     ) -> ObservabilityPipelineTagCardinalityLimitProcessorPerMetricLimit {
         ObservabilityPipelineTagCardinalityLimitProcessorPerMetricLimit {
             limit_exceeded_action: None,
             metric_name,
-            mode,
+            override_type,
             per_tag_limits: None,
             value_limit: None,
             additional_properties: std::collections::BTreeMap::new(),
@@ -104,7 +104,7 @@ impl<'de> Deserialize<'de> for ObservabilityPipelineTagCardinalityLimitProcessor
             {
                 let mut limit_exceeded_action: Option<crate::datadogV2::model::ObservabilityPipelineTagCardinalityLimitProcessorAction> = None;
                 let mut metric_name: Option<String> = None;
-                let mut mode: Option<crate::datadogV2::model::ObservabilityPipelineTagCardinalityLimitProcessorPerMetricMode> = None;
+                let mut override_type: Option<crate::datadogV2::model::ObservabilityPipelineTagCardinalityLimitProcessorOverrideType> = None;
                 let mut per_tag_limits: Option<Vec<crate::datadogV2::model::ObservabilityPipelineTagCardinalityLimitProcessorPerTagLimit>> = None;
                 let mut value_limit: Option<i64> = None;
                 let mut additional_properties: std::collections::BTreeMap<
@@ -134,11 +134,12 @@ impl<'de> Deserialize<'de> for ObservabilityPipelineTagCardinalityLimitProcessor
                             metric_name =
                                 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::ObservabilityPipelineTagCardinalityLimitProcessorPerMetricMode::UnparsedObject(_mode) => {
+                        "override_type" => {
+                            override_type =
+                                Some(serde_json::from_value(v).map_err(M::Error::custom)?);
+                            if let Some(ref _override_type) = override_type {
+                                match _override_type {
+                                    crate::datadogV2::model::ObservabilityPipelineTagCardinalityLimitProcessorOverrideType::UnparsedObject(_override_type) => {
                                         _unparsed = true;
                                     },
                                     _ => {}
@@ -168,12 +169,13 @@ impl<'de> Deserialize<'de> for ObservabilityPipelineTagCardinalityLimitProcessor
                 }
                 let metric_name =
                     metric_name.ok_or_else(|| M::Error::missing_field("metric_name"))?;
-                let mode = mode.ok_or_else(|| M::Error::missing_field("mode"))?;
+                let override_type =
+                    override_type.ok_or_else(|| M::Error::missing_field("override_type"))?;
 
                 let content = ObservabilityPipelineTagCardinalityLimitProcessorPerMetricLimit {
                     limit_exceeded_action,
                     metric_name,
-                    mode,
+                    override_type,
                     per_tag_limits,
                     value_limit,
                     additional_properties,