diff --git a/.generator/schemas/v2/openapi.yaml b/.generator/schemas/v2/openapi.yaml index c2aa6fb686..1d90d8e909 100644 --- a/.generator/schemas/v2/openapi.yaml +++ b/.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,16 +70350,16 @@ 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 @@ -70354,29 +70367,19 @@ components: 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 @@ -70384,18 +70387,26 @@ components: 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`. diff --git a/src/datadogV2/model/mod.rs b/src/datadogV2/model/mod.rs index b041c1f299..8d582c0d89 100644 --- a/src/datadogV2/model/mod.rs +++ b/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; diff --git a/src/datadogV2/model/model_observability_pipeline_tag_cardinality_limit_processor.rs b/src/datadogV2/model/model_observability_pipeline_tag_cardinality_limit_processor.rs index 233b7b31a7..d2aa9a4f71 100644 --- a/src/datadogV2/model/model_observability_pipeline_tag_cardinality_limit_processor.rs +++ b/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>, + /// 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 = None; let mut limit_exceeded_action: Option = None; let mut per_metric_limits: Option> = None; + let mut tracking_mode: Option = 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, diff --git a/src/datadogV2/model/model_observability_pipeline_tag_cardinality_limit_processor_per_tag_mode.rs b/src/datadogV2/model/model_observability_pipeline_tag_cardinality_limit_processor_override_type.rs similarity index 92% rename from src/datadogV2/model/model_observability_pipeline_tag_cardinality_limit_processor_per_tag_mode.rs rename to src/datadogV2/model/model_observability_pipeline_tag_cardinality_limit_processor_override_type.rs index 7569b6a927..9376554f7b 100644 --- a/src/datadogV2/model/model_observability_pipeline_tag_cardinality_limit_processor_per_tag_mode.rs +++ b/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(&self, serializer: S) -> Result 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(deserializer: D) -> Result where D: Deserializer<'de>, diff --git a/src/datadogV2/model/model_observability_pipeline_tag_cardinality_limit_processor_per_metric_limit.rs b/src/datadogV2/model/model_observability_pipeline_tag_cardinality_limit_processor_per_metric_limit.rs index 5ccdc6de0c..4fe124a371 100644 --- a/src/datadogV2/model/model_observability_pipeline_tag_cardinality_limit_processor_per_metric_limit.rs +++ b/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, >, - /// 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, #[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 = None; let mut metric_name: Option = None; - let mut mode: Option = None; + let mut override_type: Option = None; let mut per_tag_limits: Option> = None; let mut value_limit: Option = 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, diff --git a/src/datadogV2/model/model_observability_pipeline_tag_cardinality_limit_processor_per_tag_limit.rs b/src/datadogV2/model/model_observability_pipeline_tag_cardinality_limit_processor_per_tag_limit.rs index 18255f0aa4..22d142feb3 100644 --- a/src/datadogV2/model/model_observability_pipeline_tag_cardinality_limit_processor_per_tag_limit.rs +++ b/src/datadogV2/model/model_observability_pipeline_tag_cardinality_limit_processor_per_tag_limit.rs @@ -11,13 +11,14 @@ use std::fmt::{self, Formatter}; #[skip_serializing_none] #[derive(Clone, Debug, PartialEq, Serialize)] pub struct ObservabilityPipelineTagCardinalityLimitProcessorPerTagLimit { - /// How the per-tag override is applied. `limit_override` enforces a custom limit on the tag; `excluded` skips the tag from cardinality tracking. - #[serde(rename = "mode")] - pub mode: crate::datadogV2::model::ObservabilityPipelineTagCardinalityLimitProcessorPerTagMode, + /// 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, /// The tag key this override applies to. #[serde(rename = "tag_key")] pub tag_key: String, - /// The maximum number of distinct values allowed for this tag. Required when `mode` is `limit_override`. Must be omitted when `mode` is `excluded`. + /// 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`. #[serde(rename = "value_limit")] pub value_limit: Option, #[serde(flatten)] @@ -29,11 +30,11 @@ pub struct ObservabilityPipelineTagCardinalityLimitProcessorPerTagLimit { impl ObservabilityPipelineTagCardinalityLimitProcessorPerTagLimit { pub fn new( - mode: crate::datadogV2::model::ObservabilityPipelineTagCardinalityLimitProcessorPerTagMode, + override_type: crate::datadogV2::model::ObservabilityPipelineTagCardinalityLimitProcessorOverrideType, tag_key: String, ) -> ObservabilityPipelineTagCardinalityLimitProcessorPerTagLimit { ObservabilityPipelineTagCardinalityLimitProcessorPerTagLimit { - mode, + override_type, tag_key, value_limit: None, additional_properties: std::collections::BTreeMap::new(), @@ -72,7 +73,7 @@ impl<'de> Deserialize<'de> for ObservabilityPipelineTagCardinalityLimitProcessor where M: MapAccess<'a>, { - let mut mode: Option = None; + let mut override_type: Option = None; let mut tag_key: Option = None; let mut value_limit: Option = None; let mut additional_properties: std::collections::BTreeMap< @@ -83,11 +84,12 @@ impl<'de> Deserialize<'de> for ObservabilityPipelineTagCardinalityLimitProcessor while let Some((k, v)) = map.next_entry::()? { match k.as_str() { - "mode" => { - mode = Some(serde_json::from_value(v).map_err(M::Error::custom)?); - if let Some(ref _mode) = mode { - match _mode { - crate::datadogV2::model::ObservabilityPipelineTagCardinalityLimitProcessorPerTagMode::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; }, _ => {} @@ -111,11 +113,12 @@ impl<'de> Deserialize<'de> for ObservabilityPipelineTagCardinalityLimitProcessor } } } - 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 tag_key = tag_key.ok_or_else(|| M::Error::missing_field("tag_key"))?; let content = ObservabilityPipelineTagCardinalityLimitProcessorPerTagLimit { - mode, + override_type, tag_key, value_limit, additional_properties, diff --git a/src/datadogV2/model/model_observability_pipeline_tag_cardinality_limit_processor_tracking_mode.rs b/src/datadogV2/model/model_observability_pipeline_tag_cardinality_limit_processor_tracking_mode.rs new file mode 100644 index 0000000000..0630fcc389 --- /dev/null +++ b/src/datadogV2/model/model_observability_pipeline_tag_cardinality_limit_processor_tracking_mode.rs @@ -0,0 +1,104 @@ +// 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}; + +/// Controls whether the processor uses exact or probabilistic tag tracking. +#[non_exhaustive] +#[skip_serializing_none] +#[derive(Clone, Debug, PartialEq, Serialize)] +pub struct ObservabilityPipelineTagCardinalityLimitProcessorTrackingMode { + /// The cardinality tracking algorithm to use. + #[serde(rename = "mode")] + pub mode: + crate::datadogV2::model::ObservabilityPipelineTagCardinalityLimitProcessorTrackingModeMode, + #[serde(flatten)] + pub additional_properties: std::collections::BTreeMap, + #[serde(skip)] + #[serde(default)] + pub(crate) _unparsed: bool, +} + +impl ObservabilityPipelineTagCardinalityLimitProcessorTrackingMode { + pub fn new( + mode: crate::datadogV2::model::ObservabilityPipelineTagCardinalityLimitProcessorTrackingModeMode, + ) -> ObservabilityPipelineTagCardinalityLimitProcessorTrackingMode { + ObservabilityPipelineTagCardinalityLimitProcessorTrackingMode { + mode, + 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 ObservabilityPipelineTagCardinalityLimitProcessorTrackingMode { + fn deserialize(deserializer: D) -> Result + where + D: Deserializer<'de>, + { + struct ObservabilityPipelineTagCardinalityLimitProcessorTrackingModeVisitor; + impl<'a> Visitor<'a> for ObservabilityPipelineTagCardinalityLimitProcessorTrackingModeVisitor { + type Value = ObservabilityPipelineTagCardinalityLimitProcessorTrackingMode; + + 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 mode: Option = 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() { + "mode" => { + mode = Some(serde_json::from_value(v).map_err(M::Error::custom)?); + if let Some(ref _mode) = mode { + match _mode { + crate::datadogV2::model::ObservabilityPipelineTagCardinalityLimitProcessorTrackingModeMode::UnparsedObject(_mode) => { + _unparsed = true; + }, + _ => {} + } + } + } + &_ => { + if let Ok(value) = serde_json::from_value(v.clone()) { + additional_properties.insert(k, value); + } + } + } + } + let mode = mode.ok_or_else(|| M::Error::missing_field("mode"))?; + + let content = ObservabilityPipelineTagCardinalityLimitProcessorTrackingMode { + mode, + additional_properties, + _unparsed, + }; + + Ok(content) + } + } + + deserializer + .deserialize_any(ObservabilityPipelineTagCardinalityLimitProcessorTrackingModeVisitor) + } +} diff --git a/src/datadogV2/model/model_observability_pipeline_tag_cardinality_limit_processor_per_metric_mode.rs b/src/datadogV2/model/model_observability_pipeline_tag_cardinality_limit_processor_tracking_mode_mode.rs similarity index 75% rename from src/datadogV2/model/model_observability_pipeline_tag_cardinality_limit_processor_per_metric_mode.rs rename to src/datadogV2/model/model_observability_pipeline_tag_cardinality_limit_processor_tracking_mode_mode.rs index 7b75bb138e..0ca902235f 100644 --- a/src/datadogV2/model/model_observability_pipeline_tag_cardinality_limit_processor_per_metric_mode.rs +++ b/src/datadogV2/model/model_observability_pipeline_tag_cardinality_limit_processor_tracking_mode_mode.rs @@ -6,23 +6,23 @@ use serde::{Deserialize, Deserializer, Serialize, Serializer}; #[non_exhaustive] #[derive(Clone, Debug, Eq, PartialEq)] -pub enum ObservabilityPipelineTagCardinalityLimitProcessorPerMetricMode { - TRACKED, - EXCLUDED, +pub enum ObservabilityPipelineTagCardinalityLimitProcessorTrackingModeMode { + EXACT_FINGERPRINT, + PROBABILISTIC, UnparsedObject(crate::datadog::UnparsedObject), } -impl ToString for ObservabilityPipelineTagCardinalityLimitProcessorPerMetricMode { +impl ToString for ObservabilityPipelineTagCardinalityLimitProcessorTrackingModeMode { fn to_string(&self) -> String { match self { - Self::TRACKED => String::from("tracked"), - Self::EXCLUDED => String::from("excluded"), + Self::EXACT_FINGERPRINT => String::from("exact_fingerprint"), + Self::PROBABILISTIC => String::from("probabilistic"), Self::UnparsedObject(v) => v.value.to_string(), } } } -impl Serialize for ObservabilityPipelineTagCardinalityLimitProcessorPerMetricMode { +impl Serialize for ObservabilityPipelineTagCardinalityLimitProcessorTrackingModeMode { fn serialize(&self, serializer: S) -> Result where S: Serializer, @@ -34,15 +34,15 @@ impl Serialize for ObservabilityPipelineTagCardinalityLimitProcessorPerMetricMod } } -impl<'de> Deserialize<'de> for ObservabilityPipelineTagCardinalityLimitProcessorPerMetricMode { +impl<'de> Deserialize<'de> for ObservabilityPipelineTagCardinalityLimitProcessorTrackingModeMode { fn deserialize(deserializer: D) -> Result where D: Deserializer<'de>, { let s: String = String::deserialize(deserializer)?; Ok(match s.as_str() { - "tracked" => Self::TRACKED, - "excluded" => Self::EXCLUDED, + "exact_fingerprint" => Self::EXACT_FINGERPRINT, + "probabilistic" => Self::PROBABILISTIC, _ => Self::UnparsedObject(crate::datadog::UnparsedObject { value: serde_json::Value::String(s.into()), }),