From dee9a716903e3f5241f049c0fac87e37c0793c87 Mon Sep 17 00:00:00 2001 From: "ci.datadog-api-spec" Date: Fri, 13 Feb 2026 15:28:32 +0000 Subject: [PATCH] Regenerate client from commit f2190ae of spec repo --- .generator/schemas/v2/openapi.yaml | 69 ++++++++++ src/datadogV2/model/mod.rs | 6 + .../model/model_rum_cross_product_sampling.rs | 127 ++++++++++++++++++ ...model_rum_cross_product_sampling_create.rs | 112 +++++++++++++++ ...model_rum_cross_product_sampling_update.rs | 124 +++++++++++++++++ .../model_rum_retention_filter_attributes.rs | 25 ++++ ..._rum_retention_filter_create_attributes.rs | 23 ++++ ..._rum_retention_filter_update_attributes.rs | 23 ++++ 8 files changed, 509 insertions(+) create mode 100644 src/datadogV2/model/model_rum_cross_product_sampling.rs create mode 100644 src/datadogV2/model/model_rum_cross_product_sampling_create.rs create mode 100644 src/datadogV2/model/model_rum_cross_product_sampling_update.rs diff --git a/.generator/schemas/v2/openapi.yaml b/.generator/schemas/v2/openapi.yaml index b8661d93f..39007848c 100644 --- a/.generator/schemas/v2/openapi.yaml +++ b/.generator/schemas/v2/openapi.yaml @@ -50374,6 +50374,69 @@ components: type: string x-enum-varnames: - RULESET + RumCrossProductSampling: + description: 'Configuration for additional APM Trace data retention for sessions + matching this retention filter. + + When a session matches the filter and is retained (based on sample_rate), + you can configure + + what percentage of retained sessions with ingested traces should have their + traces indexed.' + properties: + trace_enabled: + description: Whether Trace cross-product sampling is enabled. When false, + no traces are indexed regardless of trace_sample_rate. + example: true + type: boolean + trace_sample_rate: + description: 'The percentage (0-100) of retained sessions with ingested + traces for which traces are indexed. + + For example, 25.0 means 25% of retained sessions with ingested traces + will have their traces indexed.' + example: 25.0 + format: double + maximum: 100 + minimum: 0 + type: number + type: object + RumCrossProductSamplingCreate: + description: Configuration for cross-product sampling when creating a retention + filter. + properties: + trace_enabled: + description: Whether Trace cross-product sampling is enabled. + example: true + type: boolean + trace_sample_rate: + description: The percentage (0-100) of retained sessions with ingested traces + for which traces are indexed. + example: 25.0 + format: double + maximum: 100 + minimum: 0 + type: number + required: + - trace_sample_rate + type: object + RumCrossProductSamplingUpdate: + description: Configuration for cross-product sampling when updating a retention + filter. All fields are optional for partial updates. + properties: + trace_enabled: + description: Whether Trace cross-product sampling is enabled. + example: true + type: boolean + trace_sample_rate: + description: The percentage (0-100) of retained sessions with ingested traces + for which traces are indexed. + example: 25.0 + format: double + maximum: 100 + minimum: 0 + type: number + type: object RumMetricCompute: description: The compute rule to compute the rum-based metric. properties: @@ -50661,6 +50724,8 @@ components: RumRetentionFilterAttributes: description: The object describing attributes of a RUM retention filter. properties: + cross_product_sampling: + $ref: '#/components/schemas/RumCrossProductSampling' enabled: $ref: '#/components/schemas/RumRetentionFilterEnabled' event_type: @@ -50675,6 +50740,8 @@ components: RumRetentionFilterCreateAttributes: description: The object describing attributes of a RUM retention filter to create. properties: + cross_product_sampling: + $ref: '#/components/schemas/RumCrossProductSamplingCreate' enabled: $ref: '#/components/schemas/RumRetentionFilterEnabled' event_type: @@ -50776,6 +50843,8 @@ components: RumRetentionFilterUpdateAttributes: description: The object describing attributes of a RUM retention filter to update. properties: + cross_product_sampling: + $ref: '#/components/schemas/RumCrossProductSamplingUpdate' enabled: $ref: '#/components/schemas/RumRetentionFilterEnabled' event_type: diff --git a/src/datadogV2/model/mod.rs b/src/datadogV2/model/mod.rs index bd048f077..3c836384f 100644 --- a/src/datadogV2/model/mod.rs +++ b/src/datadogV2/model/mod.rs @@ -6136,6 +6136,8 @@ pub mod model_rum_retention_filter_data; pub use self::model_rum_retention_filter_data::RumRetentionFilterData; pub mod model_rum_retention_filter_attributes; pub use self::model_rum_retention_filter_attributes::RumRetentionFilterAttributes; +pub mod model_rum_cross_product_sampling; +pub use self::model_rum_cross_product_sampling::RumCrossProductSampling; pub mod model_rum_retention_filter_event_type; pub use self::model_rum_retention_filter_event_type::RumRetentionFilterEventType; pub mod model_rum_retention_filter_create_request; @@ -6144,6 +6146,8 @@ pub mod model_rum_retention_filter_create_data; pub use self::model_rum_retention_filter_create_data::RumRetentionFilterCreateData; pub mod model_rum_retention_filter_create_attributes; pub use self::model_rum_retention_filter_create_attributes::RumRetentionFilterCreateAttributes; +pub mod model_rum_cross_product_sampling_create; +pub use self::model_rum_cross_product_sampling_create::RumCrossProductSamplingCreate; pub mod model_rum_retention_filter_response; pub use self::model_rum_retention_filter_response::RumRetentionFilterResponse; pub mod model_rum_retention_filter_update_request; @@ -6152,6 +6156,8 @@ pub mod model_rum_retention_filter_update_data; pub use self::model_rum_retention_filter_update_data::RumRetentionFilterUpdateData; pub mod model_rum_retention_filter_update_attributes; pub use self::model_rum_retention_filter_update_attributes::RumRetentionFilterUpdateAttributes; +pub mod model_rum_cross_product_sampling_update; +pub use self::model_rum_cross_product_sampling_update::RumCrossProductSamplingUpdate; pub mod model_rum_application_update_request; pub use self::model_rum_application_update_request::RUMApplicationUpdateRequest; pub mod model_rum_application_update; diff --git a/src/datadogV2/model/model_rum_cross_product_sampling.rs b/src/datadogV2/model/model_rum_cross_product_sampling.rs new file mode 100644 index 000000000..e8715b238 --- /dev/null +++ b/src/datadogV2/model/model_rum_cross_product_sampling.rs @@ -0,0 +1,127 @@ +// 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}; + +/// Configuration for additional APM Trace data retention for sessions matching this retention filter. +/// When a session matches the filter and is retained (based on sample_rate), you can configure +/// what percentage of retained sessions with ingested traces should have their traces indexed. +#[non_exhaustive] +#[skip_serializing_none] +#[derive(Clone, Debug, PartialEq, Serialize)] +pub struct RumCrossProductSampling { + /// Whether Trace cross-product sampling is enabled. When false, no traces are indexed regardless of trace_sample_rate. + #[serde(rename = "trace_enabled")] + pub trace_enabled: Option, + /// The percentage (0-100) of retained sessions with ingested traces for which traces are indexed. + /// For example, 25.0 means 25% of retained sessions with ingested traces will have their traces indexed. + #[serde(rename = "trace_sample_rate")] + pub trace_sample_rate: Option, + #[serde(flatten)] + pub additional_properties: std::collections::BTreeMap, + #[serde(skip)] + #[serde(default)] + pub(crate) _unparsed: bool, +} + +impl RumCrossProductSampling { + pub fn new() -> RumCrossProductSampling { + RumCrossProductSampling { + trace_enabled: None, + trace_sample_rate: None, + additional_properties: std::collections::BTreeMap::new(), + _unparsed: false, + } + } + + pub fn trace_enabled(mut self, value: bool) -> Self { + self.trace_enabled = Some(value); + self + } + + pub fn trace_sample_rate(mut self, value: f64) -> Self { + self.trace_sample_rate = Some(value); + self + } + + pub fn additional_properties( + mut self, + value: std::collections::BTreeMap, + ) -> Self { + self.additional_properties = value; + self + } +} + +impl Default for RumCrossProductSampling { + fn default() -> Self { + Self::new() + } +} + +impl<'de> Deserialize<'de> for RumCrossProductSampling { + fn deserialize(deserializer: D) -> Result + where + D: Deserializer<'de>, + { + struct RumCrossProductSamplingVisitor; + impl<'a> Visitor<'a> for RumCrossProductSamplingVisitor { + type Value = RumCrossProductSampling; + + 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 trace_enabled: Option = None; + let mut trace_sample_rate: 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() { + "trace_enabled" => { + if v.is_null() { + continue; + } + trace_enabled = + Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + "trace_sample_rate" => { + if v.is_null() { + continue; + } + trace_sample_rate = + Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + &_ => { + if let Ok(value) = serde_json::from_value(v.clone()) { + additional_properties.insert(k, value); + } + } + } + } + + let content = RumCrossProductSampling { + trace_enabled, + trace_sample_rate, + additional_properties, + _unparsed, + }; + + Ok(content) + } + } + + deserializer.deserialize_any(RumCrossProductSamplingVisitor) + } +} diff --git a/src/datadogV2/model/model_rum_cross_product_sampling_create.rs b/src/datadogV2/model/model_rum_cross_product_sampling_create.rs new file mode 100644 index 000000000..0e25481f5 --- /dev/null +++ b/src/datadogV2/model/model_rum_cross_product_sampling_create.rs @@ -0,0 +1,112 @@ +// 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}; + +/// Configuration for cross-product sampling when creating a retention filter. +#[non_exhaustive] +#[skip_serializing_none] +#[derive(Clone, Debug, PartialEq, Serialize)] +pub struct RumCrossProductSamplingCreate { + /// Whether Trace cross-product sampling is enabled. + #[serde(rename = "trace_enabled")] + pub trace_enabled: Option, + /// The percentage (0-100) of retained sessions with ingested traces for which traces are indexed. + #[serde(rename = "trace_sample_rate")] + pub trace_sample_rate: f64, + #[serde(flatten)] + pub additional_properties: std::collections::BTreeMap, + #[serde(skip)] + #[serde(default)] + pub(crate) _unparsed: bool, +} + +impl RumCrossProductSamplingCreate { + pub fn new(trace_sample_rate: f64) -> RumCrossProductSamplingCreate { + RumCrossProductSamplingCreate { + trace_enabled: None, + trace_sample_rate, + additional_properties: std::collections::BTreeMap::new(), + _unparsed: false, + } + } + + pub fn trace_enabled(mut self, value: bool) -> Self { + self.trace_enabled = Some(value); + self + } + + pub fn additional_properties( + mut self, + value: std::collections::BTreeMap, + ) -> Self { + self.additional_properties = value; + self + } +} + +impl<'de> Deserialize<'de> for RumCrossProductSamplingCreate { + fn deserialize(deserializer: D) -> Result + where + D: Deserializer<'de>, + { + struct RumCrossProductSamplingCreateVisitor; + impl<'a> Visitor<'a> for RumCrossProductSamplingCreateVisitor { + type Value = RumCrossProductSamplingCreate; + + 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 trace_enabled: Option = None; + let mut trace_sample_rate: 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() { + "trace_enabled" => { + if v.is_null() { + continue; + } + trace_enabled = + Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + "trace_sample_rate" => { + trace_sample_rate = + Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + &_ => { + if let Ok(value) = serde_json::from_value(v.clone()) { + additional_properties.insert(k, value); + } + } + } + } + let trace_sample_rate = trace_sample_rate + .ok_or_else(|| M::Error::missing_field("trace_sample_rate"))?; + + let content = RumCrossProductSamplingCreate { + trace_enabled, + trace_sample_rate, + additional_properties, + _unparsed, + }; + + Ok(content) + } + } + + deserializer.deserialize_any(RumCrossProductSamplingCreateVisitor) + } +} diff --git a/src/datadogV2/model/model_rum_cross_product_sampling_update.rs b/src/datadogV2/model/model_rum_cross_product_sampling_update.rs new file mode 100644 index 000000000..7275681f1 --- /dev/null +++ b/src/datadogV2/model/model_rum_cross_product_sampling_update.rs @@ -0,0 +1,124 @@ +// 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}; + +/// Configuration for cross-product sampling when updating a retention filter. All fields are optional for partial updates. +#[non_exhaustive] +#[skip_serializing_none] +#[derive(Clone, Debug, PartialEq, Serialize)] +pub struct RumCrossProductSamplingUpdate { + /// Whether Trace cross-product sampling is enabled. + #[serde(rename = "trace_enabled")] + pub trace_enabled: Option, + /// The percentage (0-100) of retained sessions with ingested traces for which traces are indexed. + #[serde(rename = "trace_sample_rate")] + pub trace_sample_rate: Option, + #[serde(flatten)] + pub additional_properties: std::collections::BTreeMap, + #[serde(skip)] + #[serde(default)] + pub(crate) _unparsed: bool, +} + +impl RumCrossProductSamplingUpdate { + pub fn new() -> RumCrossProductSamplingUpdate { + RumCrossProductSamplingUpdate { + trace_enabled: None, + trace_sample_rate: None, + additional_properties: std::collections::BTreeMap::new(), + _unparsed: false, + } + } + + pub fn trace_enabled(mut self, value: bool) -> Self { + self.trace_enabled = Some(value); + self + } + + pub fn trace_sample_rate(mut self, value: f64) -> Self { + self.trace_sample_rate = Some(value); + self + } + + pub fn additional_properties( + mut self, + value: std::collections::BTreeMap, + ) -> Self { + self.additional_properties = value; + self + } +} + +impl Default for RumCrossProductSamplingUpdate { + fn default() -> Self { + Self::new() + } +} + +impl<'de> Deserialize<'de> for RumCrossProductSamplingUpdate { + fn deserialize(deserializer: D) -> Result + where + D: Deserializer<'de>, + { + struct RumCrossProductSamplingUpdateVisitor; + impl<'a> Visitor<'a> for RumCrossProductSamplingUpdateVisitor { + type Value = RumCrossProductSamplingUpdate; + + 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 trace_enabled: Option = None; + let mut trace_sample_rate: 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() { + "trace_enabled" => { + if v.is_null() { + continue; + } + trace_enabled = + Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + "trace_sample_rate" => { + if v.is_null() { + continue; + } + trace_sample_rate = + Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + &_ => { + if let Ok(value) = serde_json::from_value(v.clone()) { + additional_properties.insert(k, value); + } + } + } + } + + let content = RumCrossProductSamplingUpdate { + trace_enabled, + trace_sample_rate, + additional_properties, + _unparsed, + }; + + Ok(content) + } + } + + deserializer.deserialize_any(RumCrossProductSamplingUpdateVisitor) + } +} diff --git a/src/datadogV2/model/model_rum_retention_filter_attributes.rs b/src/datadogV2/model/model_rum_retention_filter_attributes.rs index 517667bc0..a9cf94e99 100644 --- a/src/datadogV2/model/model_rum_retention_filter_attributes.rs +++ b/src/datadogV2/model/model_rum_retention_filter_attributes.rs @@ -11,6 +11,11 @@ use std::fmt::{self, Formatter}; #[skip_serializing_none] #[derive(Clone, Debug, PartialEq, Serialize)] pub struct RumRetentionFilterAttributes { + /// Configuration for additional APM Trace data retention for sessions matching this retention filter. + /// When a session matches the filter and is retained (based on sample_rate), you can configure + /// what percentage of retained sessions with ingested traces should have their traces indexed. + #[serde(rename = "cross_product_sampling")] + pub cross_product_sampling: Option, /// Whether the retention filter is enabled. #[serde(rename = "enabled")] pub enabled: Option, @@ -36,6 +41,7 @@ pub struct RumRetentionFilterAttributes { impl RumRetentionFilterAttributes { pub fn new() -> RumRetentionFilterAttributes { RumRetentionFilterAttributes { + cross_product_sampling: None, enabled: None, event_type: None, name: None, @@ -46,6 +52,14 @@ impl RumRetentionFilterAttributes { } } + pub fn cross_product_sampling( + mut self, + value: crate::datadogV2::model::RumCrossProductSampling, + ) -> Self { + self.cross_product_sampling = Some(value); + self + } + pub fn enabled(mut self, value: bool) -> Self { self.enabled = Some(value); self @@ -106,6 +120,9 @@ impl<'de> Deserialize<'de> for RumRetentionFilterAttributes { where M: MapAccess<'a>, { + let mut cross_product_sampling: Option< + crate::datadogV2::model::RumCrossProductSampling, + > = None; let mut enabled: Option = None; let mut event_type: Option = None; @@ -120,6 +137,13 @@ impl<'de> Deserialize<'de> for RumRetentionFilterAttributes { while let Some((k, v)) = map.next_entry::()? { match k.as_str() { + "cross_product_sampling" => { + if v.is_null() { + continue; + } + cross_product_sampling = + Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } "enabled" => { if v.is_null() { continue; @@ -168,6 +192,7 @@ impl<'de> Deserialize<'de> for RumRetentionFilterAttributes { } let content = RumRetentionFilterAttributes { + cross_product_sampling, enabled, event_type, name, diff --git a/src/datadogV2/model/model_rum_retention_filter_create_attributes.rs b/src/datadogV2/model/model_rum_retention_filter_create_attributes.rs index b1876d209..494b5c5b4 100644 --- a/src/datadogV2/model/model_rum_retention_filter_create_attributes.rs +++ b/src/datadogV2/model/model_rum_retention_filter_create_attributes.rs @@ -11,6 +11,9 @@ use std::fmt::{self, Formatter}; #[skip_serializing_none] #[derive(Clone, Debug, PartialEq, Serialize)] pub struct RumRetentionFilterCreateAttributes { + /// Configuration for cross-product sampling when creating a retention filter. + #[serde(rename = "cross_product_sampling")] + pub cross_product_sampling: Option, /// Whether the retention filter is enabled. #[serde(rename = "enabled")] pub enabled: Option, @@ -40,6 +43,7 @@ impl RumRetentionFilterCreateAttributes { sample_rate: f64, ) -> RumRetentionFilterCreateAttributes { RumRetentionFilterCreateAttributes { + cross_product_sampling: None, enabled: None, event_type, name, @@ -50,6 +54,14 @@ impl RumRetentionFilterCreateAttributes { } } + pub fn cross_product_sampling( + mut self, + value: crate::datadogV2::model::RumCrossProductSamplingCreate, + ) -> Self { + self.cross_product_sampling = Some(value); + self + } + pub fn enabled(mut self, value: bool) -> Self { self.enabled = Some(value); self @@ -86,6 +98,9 @@ impl<'de> Deserialize<'de> for RumRetentionFilterCreateAttributes { where M: MapAccess<'a>, { + let mut cross_product_sampling: Option< + crate::datadogV2::model::RumCrossProductSamplingCreate, + > = None; let mut enabled: Option = None; let mut event_type: Option = None; @@ -100,6 +115,13 @@ impl<'de> Deserialize<'de> for RumRetentionFilterCreateAttributes { while let Some((k, v)) = map.next_entry::()? { match k.as_str() { + "cross_product_sampling" => { + if v.is_null() { + continue; + } + cross_product_sampling = + Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } "enabled" => { if v.is_null() { continue; @@ -143,6 +165,7 @@ impl<'de> Deserialize<'de> for RumRetentionFilterCreateAttributes { sample_rate.ok_or_else(|| M::Error::missing_field("sample_rate"))?; let content = RumRetentionFilterCreateAttributes { + cross_product_sampling, enabled, event_type, name, diff --git a/src/datadogV2/model/model_rum_retention_filter_update_attributes.rs b/src/datadogV2/model/model_rum_retention_filter_update_attributes.rs index 58416cb32..a4226b070 100644 --- a/src/datadogV2/model/model_rum_retention_filter_update_attributes.rs +++ b/src/datadogV2/model/model_rum_retention_filter_update_attributes.rs @@ -11,6 +11,9 @@ use std::fmt::{self, Formatter}; #[skip_serializing_none] #[derive(Clone, Debug, PartialEq, Serialize)] pub struct RumRetentionFilterUpdateAttributes { + /// Configuration for cross-product sampling when updating a retention filter. All fields are optional for partial updates. + #[serde(rename = "cross_product_sampling")] + pub cross_product_sampling: Option, /// Whether the retention filter is enabled. #[serde(rename = "enabled")] pub enabled: Option, @@ -36,6 +39,7 @@ pub struct RumRetentionFilterUpdateAttributes { impl RumRetentionFilterUpdateAttributes { pub fn new() -> RumRetentionFilterUpdateAttributes { RumRetentionFilterUpdateAttributes { + cross_product_sampling: None, enabled: None, event_type: None, name: None, @@ -46,6 +50,14 @@ impl RumRetentionFilterUpdateAttributes { } } + pub fn cross_product_sampling( + mut self, + value: crate::datadogV2::model::RumCrossProductSamplingUpdate, + ) -> Self { + self.cross_product_sampling = Some(value); + self + } + pub fn enabled(mut self, value: bool) -> Self { self.enabled = Some(value); self @@ -106,6 +118,9 @@ impl<'de> Deserialize<'de> for RumRetentionFilterUpdateAttributes { where M: MapAccess<'a>, { + let mut cross_product_sampling: Option< + crate::datadogV2::model::RumCrossProductSamplingUpdate, + > = None; let mut enabled: Option = None; let mut event_type: Option = None; @@ -120,6 +135,13 @@ impl<'de> Deserialize<'de> for RumRetentionFilterUpdateAttributes { while let Some((k, v)) = map.next_entry::()? { match k.as_str() { + "cross_product_sampling" => { + if v.is_null() { + continue; + } + cross_product_sampling = + Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } "enabled" => { if v.is_null() { continue; @@ -168,6 +190,7 @@ impl<'de> Deserialize<'de> for RumRetentionFilterUpdateAttributes { } let content = RumRetentionFilterUpdateAttributes { + cross_product_sampling, enabled, event_type, name,