Add sampling fields to SDS spec (#693)

Co-authored-by: ci.datadog-api-spec <[email protected]>

Author: api-clients-generation-pipeline[bot]

.apigentools-info

@@ -4,13 +4,13 @@
     "spec_versions": {
         "v1": {
             "apigentools_version": "1.6.6",
-            "regenerated": "2025-06-17 14:56:00.539225",
-            "spec_repo_commit": "b359fdcc"
+            "regenerated": "2025-06-17 18:21:57.470118",
+            "spec_repo_commit": "b1a1c000"
         },
         "v2": {
             "apigentools_version": "1.6.6",
-            "regenerated": "2025-06-17 14:56:00.555372",
-            "spec_repo_commit": "b359fdcc"
+            "regenerated": "2025-06-17 18:21:57.486359",
+            "spec_repo_commit": "b1a1c000"
         }
     }
 }

.generator/schemas/v2/openapi.yaml

@@ -35002,6 +35002,11 @@ components:
           items:
             $ref: '#/components/schemas/SensitiveDataScannerProduct'
           type: array
+        samplings:
+          description: List of sampling rates per product type.
+          items:
+            $ref: '#/components/schemas/SensitiveDataScannerSamplings'
+          type: array
       type: object
     SensitiveDataScannerGroupCreate:
       description: Data related to the creation of a group.
@@ -35433,6 +35438,19 @@ components:
         meta:
           $ref: '#/components/schemas/SensitiveDataScannerMetaVersionOnly'
       type: object
+    SensitiveDataScannerSamplings:
+      description: Sampling configurations for the Scanning Group.
+      properties:
+        product:
+          $ref: '#/components/schemas/SensitiveDataScannerProduct'
+        rate:
+          description: Rate at which data in product type will be scanned, as a percentage.
+          example: 100.0
+          format: double
+          maximum: 100.0
+          minimum: 0.0
+          type: number
+      type: object
     SensitiveDataScannerStandardPattern:
       description: Data containing the standard pattern id.
       properties:

src/datadogV2/model/mod.rs

@@ -4332,6 +4332,8 @@ pub mod model_sensitive_data_scanner_filter;
 pub use self::model_sensitive_data_scanner_filter::SensitiveDataScannerFilter;
 pub mod model_sensitive_data_scanner_product;
 pub use self::model_sensitive_data_scanner_product::SensitiveDataScannerProduct;
+pub mod model_sensitive_data_scanner_samplings;
+pub use self::model_sensitive_data_scanner_samplings::SensitiveDataScannerSamplings;
 pub mod model_sensitive_data_scanner_group_relationships;
 pub use self::model_sensitive_data_scanner_group_relationships::SensitiveDataScannerGroupRelationships;
 pub mod model_sensitive_data_scanner_configuration_data;

src/datadogV2/model/model_sensitive_data_scanner_group_attributes.rs

@@ -26,6 +26,9 @@ pub struct SensitiveDataScannerGroupAttributes {
     /// List of products the scanning group applies.
     #[serde(rename = "product_list")]
     pub product_list: Option<Vec<crate::datadogV2::model::SensitiveDataScannerProduct>>,
+    /// List of sampling rates per product type.
+    #[serde(rename = "samplings")]
+    pub samplings: Option<Vec<crate::datadogV2::model::SensitiveDataScannerSamplings>>,
     #[serde(flatten)]
     pub additional_properties: std::collections::BTreeMap<String, serde_json::Value>,
     #[serde(skip)]
@@ -41,6 +44,7 @@ impl SensitiveDataScannerGroupAttributes {
             is_enabled: None,
             name: None,
             product_list: None,
+            samplings: None,
             additional_properties: std::collections::BTreeMap::new(),
             _unparsed: false,
         }
@@ -74,6 +78,14 @@ impl SensitiveDataScannerGroupAttributes {
         self
     }
 
+    pub fn samplings(
+        mut self,
+        value: Vec<crate::datadogV2::model::SensitiveDataScannerSamplings>,
+    ) -> Self {
+        self.samplings = Some(value);
+        self
+    }
+
     pub fn additional_properties(
         mut self,
         value: std::collections::BTreeMap<String, serde_json::Value>,
@@ -113,6 +125,9 @@ impl<'de> Deserialize<'de> for SensitiveDataScannerGroupAttributes {
                 let mut product_list: Option<
                     Vec<crate::datadogV2::model::SensitiveDataScannerProduct>,
                 > = None;
+                let mut samplings: Option<
+                    Vec<crate::datadogV2::model::SensitiveDataScannerSamplings>,
+                > = None;
                 let mut additional_properties: std::collections::BTreeMap<
                     String,
                     serde_json::Value,
@@ -153,6 +168,12 @@ impl<'de> Deserialize<'de> for SensitiveDataScannerGroupAttributes {
                             product_list =
                                 Some(serde_json::from_value(v).map_err(M::Error::custom)?);
                         }
+                        "samplings" => {
+                            if v.is_null() {
+                                continue;
+                            }
+                            samplings = 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);
@@ -167,6 +188,7 @@ impl<'de> Deserialize<'de> for SensitiveDataScannerGroupAttributes {
                     is_enabled,
                     name,
                     product_list,
+                    samplings,
                     additional_properties,
                     _unparsed,
                 };

src/datadogV2/model/model_sensitive_data_scanner_samplings.rs

@@ -0,0 +1,131 @@
+// 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};
+
+/// Sampling configurations for the Scanning Group.
+#[non_exhaustive]
+#[skip_serializing_none]
+#[derive(Clone, Debug, PartialEq, Serialize)]
+pub struct SensitiveDataScannerSamplings {
+    /// Datadog product onto which Sensitive Data Scanner can be activated.
+    #[serde(rename = "product")]
+    pub product: Option<crate::datadogV2::model::SensitiveDataScannerProduct>,
+    /// Rate at which data in product type will be scanned, as a percentage.
+    #[serde(rename = "rate")]
+    pub rate: Option<f64>,
+    #[serde(flatten)]
+    pub additional_properties: std::collections::BTreeMap<String, serde_json::Value>,
+    #[serde(skip)]
+    #[serde(default)]
+    pub(crate) _unparsed: bool,
+}
+
+impl SensitiveDataScannerSamplings {
+    pub fn new() -> SensitiveDataScannerSamplings {
+        SensitiveDataScannerSamplings {
+            product: None,
+            rate: None,
+            additional_properties: std::collections::BTreeMap::new(),
+            _unparsed: false,
+        }
+    }
+
+    pub fn product(mut self, value: crate::datadogV2::model::SensitiveDataScannerProduct) -> Self {
+        self.product = Some(value);
+        self
+    }
+
+    pub fn rate(mut self, value: f64) -> Self {
+        self.rate = Some(value);
+        self
+    }
+
+    pub fn additional_properties(
+        mut self,
+        value: std::collections::BTreeMap<String, serde_json::Value>,
+    ) -> Self {
+        self.additional_properties = value;
+        self
+    }
+}
+
+impl Default for SensitiveDataScannerSamplings {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl<'de> Deserialize<'de> for SensitiveDataScannerSamplings {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        struct SensitiveDataScannerSamplingsVisitor;
+        impl<'a> Visitor<'a> for SensitiveDataScannerSamplingsVisitor {
+            type Value = SensitiveDataScannerSamplings;
+
+            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 product: Option<crate::datadogV2::model::SensitiveDataScannerProduct> =
+                    None;
+                let mut rate: Option<f64> = 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() {
+                        "product" => {
+                            if v.is_null() {
+                                continue;
+                            }
+                            product = Some(serde_json::from_value(v).map_err(M::Error::custom)?);
+                            if let Some(ref _product) = product {
+                                match _product {
+                                    crate::datadogV2::model::SensitiveDataScannerProduct::UnparsedObject(_product) => {
+                                        _unparsed = true;
+                                    },
+                                    _ => {}
+                                }
+                            }
+                        }
+                        "rate" => {
+                            if v.is_null() {
+                                continue;
+                            }
+                            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 = SensitiveDataScannerSamplings {
+                    product,
+                    rate,
+                    additional_properties,
+                    _unparsed,
+                };
+
+                Ok(content)
+            }
+        }
+
+        deserializer.deserialize_any(SensitiveDataScannerSamplingsVisitor)
+    }
+}

tests/scenarios/cassettes/v2/sensitive_data_scanner/Create-Scanning-Rule-returns-Bad-Request-response.frozen

@@ -1 +1 @@
-2022-12-15T14:50:52.745Z
+2025-05-30T17:17:05.785Z

tests/scenarios/cassettes/v2/sensitive_data_scanner/Create-Scanning-Rule-returns-Bad-Request-response.json

@@ -1 +1 @@
-2024-01-04T13:51:03.802Z
+2025-05-30T17:17:07.743Z

tests/scenarios/cassettes/v2/sensitive_data_scanner/Create-Scanning-Rule-returns-OK-response.frozen

@@ -1 +1 @@
-2022-12-09T09:52:52.562Z
+2025-05-30T17:17:09.412Z