Add suppressions to SensitiveDataScannerRule resource

.generator/schemas/v2/openapi.yaml

@@ -50351,6 +50351,8 @@ components:
           maximum: 5
           minimum: 1
           type: integer
+        suppressions:
+          $ref: '#/components/schemas/SensitiveDataScannerSuppressions'
         tags:
           description: List of tags.
           items:
@@ -50572,6 +50574,32 @@ components:
         type:
           $ref: '#/components/schemas/SensitiveDataScannerStandardPatternType'
       type: object
+    SensitiveDataScannerSuppressions:
+      description: 'Object describing the suppressions for a rule. There are three
+        types of suppressions, `starts_with`, `ends_with`, and `exact_match`.
+
+        Suppressed matches are not obfuscated, counted in metrics, or displayed in
+        the Findings page.'
+      properties:
+        ends_with:
+          description: List of strings to use for suppression of matches ending with
+            these strings.
+          items:
+            type: string
+          type: array
+        exact_match:
+          description: List of strings to use for suppression of matches exactly matching
+            these strings.
+          items:
+            type: string
+          type: array
+        starts_with:
+          description: List of strings to use for suppression of matches starting
+            with these strings.
+          items:
+            type: string
+          type: array
+      type: object
     SensitiveDataScannerTextReplacement:
       description: Object describing how the scanned event will be replaced.
       properties:

src/datadogV2/model/mod.rs

@@ -6296,6 +6296,8 @@ pub mod model_sensitive_data_scanner_rule_attributes;
 pub use self::model_sensitive_data_scanner_rule_attributes::SensitiveDataScannerRuleAttributes;
 pub mod model_sensitive_data_scanner_included_keyword_configuration;
 pub use self::model_sensitive_data_scanner_included_keyword_configuration::SensitiveDataScannerIncludedKeywordConfiguration;
+pub mod model_sensitive_data_scanner_suppressions;
+pub use self::model_sensitive_data_scanner_suppressions::SensitiveDataScannerSuppressions;
 pub mod model_sensitive_data_scanner_text_replacement;
 pub use self::model_sensitive_data_scanner_text_replacement::SensitiveDataScannerTextReplacement;
 pub mod model_sensitive_data_scanner_text_replacement_type;

src/datadogV2/model/model_sensitive_data_scanner_rule_attributes.rs

@@ -40,6 +40,10 @@ pub struct SensitiveDataScannerRuleAttributes {
     /// Integer from 1 (high) to 5 (low) indicating rule issue severity.
     #[serde(rename = "priority")]
     pub priority: Option<i64>,
+    /// Object describing the suppressions for a rule. There are three types of suppressions, `starts_with`, `ends_with`, and `exact_match`.
+    /// Suppressed matches are not obfuscated, counted in metrics, or displayed in the Findings page.
+    #[serde(rename = "suppressions")]
+    pub suppressions: Option<crate::datadogV2::model::SensitiveDataScannerSuppressions>,
     /// List of tags.
     #[serde(rename = "tags")]
     pub tags: Option<Vec<String>>,
@@ -64,6 +68,7 @@ impl SensitiveDataScannerRuleAttributes {
             namespaces: None,
             pattern: None,
             priority: None,
+            suppressions: None,
             tags: None,
             text_replacement: None,
             additional_properties: std::collections::BTreeMap::new(),
@@ -114,6 +119,14 @@ impl SensitiveDataScannerRuleAttributes {
         self
     }
 
+    pub fn suppressions(
+        mut self,
+        value: crate::datadogV2::model::SensitiveDataScannerSuppressions,
+    ) -> Self {
+        self.suppressions = Some(value);
+        self
+    }
+
     pub fn tags(mut self, value: Vec<String>) -> Self {
         self.tags = Some(value);
         self
@@ -169,6 +182,9 @@ impl<'de> Deserialize<'de> for SensitiveDataScannerRuleAttributes {
                 let mut namespaces: Option<Vec<String>> = None;
                 let mut pattern: Option<String> = None;
                 let mut priority: Option<i64> = None;
+                let mut suppressions: Option<
+                    crate::datadogV2::model::SensitiveDataScannerSuppressions,
+                > = None;
                 let mut tags: Option<Vec<String>> = None;
                 let mut text_replacement: Option<
                     crate::datadogV2::model::SensitiveDataScannerTextReplacement,
@@ -232,6 +248,13 @@ impl<'de> Deserialize<'de> for SensitiveDataScannerRuleAttributes {
                             }
                             priority = Some(serde_json::from_value(v).map_err(M::Error::custom)?);
                         }
+                        "suppressions" => {
+                            if v.is_null() {
+                                continue;
+                            }
+                            suppressions =
+                                Some(serde_json::from_value(v).map_err(M::Error::custom)?);
+                        }
                         "tags" => {
                             if v.is_null() {
                                 continue;
@@ -262,6 +285,7 @@ impl<'de> Deserialize<'de> for SensitiveDataScannerRuleAttributes {
                     namespaces,
                     pattern,
                     priority,
+                    suppressions,
                     tags,
                     text_replacement,
                     additional_properties,

src/datadogV2/model/model_sensitive_data_scanner_suppressions.rs

@@ -0,0 +1,142 @@
+// 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};
+
+/// Object describing the suppressions for a rule. There are three types of suppressions, `starts_with`, `ends_with`, and `exact_match`.
+/// Suppressed matches are not obfuscated, counted in metrics, or displayed in the Findings page.
+#[non_exhaustive]
+#[skip_serializing_none]
+#[derive(Clone, Debug, PartialEq, Serialize)]
+pub struct SensitiveDataScannerSuppressions {
+    /// List of strings to use for suppression of matches ending with these strings.
+    #[serde(rename = "ends_with")]
+    pub ends_with: Option<Vec<String>>,
+    /// List of strings to use for suppression of matches exactly matching these strings.
+    #[serde(rename = "exact_match")]
+    pub exact_match: Option<Vec<String>>,
+    /// List of strings to use for suppression of matches starting with these strings.
+    #[serde(rename = "starts_with")]
+    pub starts_with: Option<Vec<String>>,
+    #[serde(flatten)]
+    pub additional_properties: std::collections::BTreeMap<String, serde_json::Value>,
+    #[serde(skip)]
+    #[serde(default)]
+    pub(crate) _unparsed: bool,
+}
+
+impl SensitiveDataScannerSuppressions {
+    pub fn new() -> SensitiveDataScannerSuppressions {
+        SensitiveDataScannerSuppressions {
+            ends_with: None,
+            exact_match: None,
+            starts_with: None,
+            additional_properties: std::collections::BTreeMap::new(),
+            _unparsed: false,
+        }
+    }
+
+    pub fn ends_with(mut self, value: Vec<String>) -> Self {
+        self.ends_with = Some(value);
+        self
+    }
+
+    pub fn exact_match(mut self, value: Vec<String>) -> Self {
+        self.exact_match = Some(value);
+        self
+    }
+
+    pub fn starts_with(mut self, value: Vec<String>) -> Self {
+        self.starts_with = 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 SensitiveDataScannerSuppressions {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl<'de> Deserialize<'de> for SensitiveDataScannerSuppressions {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        struct SensitiveDataScannerSuppressionsVisitor;
+        impl<'a> Visitor<'a> for SensitiveDataScannerSuppressionsVisitor {
+            type Value = SensitiveDataScannerSuppressions;
+
+            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 ends_with: Option<Vec<String>> = None;
+                let mut exact_match: Option<Vec<String>> = None;
+                let mut starts_with: Option<Vec<String>> = 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() {
+                        "ends_with" => {
+                            if v.is_null() {
+                                continue;
+                            }
+                            ends_with = Some(serde_json::from_value(v).map_err(M::Error::custom)?);
+                        }
+                        "exact_match" => {
+                            if v.is_null() {
+                                continue;
+                            }
+                            exact_match =
+                                Some(serde_json::from_value(v).map_err(M::Error::custom)?);
+                        }
+                        "starts_with" => {
+                            if v.is_null() {
+                                continue;
+                            }
+                            starts_with =
+                                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 = SensitiveDataScannerSuppressions {
+                    ends_with,
+                    exact_match,
+                    starts_with,
+                    additional_properties,
+                    _unparsed,
+                };
+
+                Ok(content)
+            }
+        }
+
+        deserializer.deserialize_any(SensitiveDataScannerSuppressionsVisitor)
+    }
+}

tests/scenarios/features/v2/sensitive_data_scanner.feature

@@ -200,7 +200,7 @@ Feature: Sensitive Data Scanner
   Scenario: Update Scanning Rule returns "Not Found" response
     Given new "UpdateScanningRule" request
     And request contains "rule_id" parameter from "REPLACE.ME"
-    And body with value {"data": {"attributes": {"excluded_namespaces": ["admin.name"], "included_keyword_configuration": {"character_count": 30, "keywords": ["credit card", "cc"]}, "namespaces": ["admin"], "tags": [], "text_replacement": {"type": "none"}}, "relationships": {"group": {"data": {"type": "sensitive_data_scanner_group"}}, "standard_pattern": {"data": {"type": "sensitive_data_scanner_standard_pattern"}}}, "type": "sensitive_data_scanner_rule"}, "meta": {"version": 0}}
+    And body with value {"data": {"attributes": {"excluded_namespaces": ["admin.name"], "included_keyword_configuration": {"character_count": 30, "keywords": ["credit card", "cc"]}, "namespaces": ["admin"], "suppressions": {"ends_with": [], "exact_match": [], "starts_with": []}, "tags": [], "text_replacement": {"type": "none"}}, "relationships": {"group": {"data": {"type": "sensitive_data_scanner_group"}}, "standard_pattern": {"data": {"type": "sensitive_data_scanner_standard_pattern"}}}, "type": "sensitive_data_scanner_rule"}, "meta": {"version": 0}}
     When the request is sent
     Then the response status is 404 Not Found