Add conditional recipients to notification rule

.generator/schemas/v2/openapi.yaml

@@ -29565,6 +29565,8 @@ components:
       additionalProperties: false
       description: Attributes of the monitor notification rule.
       properties:
+        conditional_recipients:
+          $ref: '#/components/schemas/MonitorNotificationRuleConditionalRecipients'
         filter:
           $ref: '#/components/schemas/MonitorNotificationRuleFilter'
         name:
@@ -29573,8 +29575,36 @@ components:
           $ref: '#/components/schemas/MonitorNotificationRuleRecipients'
       required:
       - name
+      type: object
+    MonitorNotificationRuleCondition:
+      description: Conditions for `conditional_recipients`.
+      properties:
+        recipients:
+          $ref: '#/components/schemas/MonitorNotificationRuleRecipients'
+        scope:
+          $ref: '#/components/schemas/MonitorNotificationRuleScope'
+      required:
+      - scope
       - recipients
       type: object
+    MonitorNotificationRuleConditionalRecipients:
+      description: Use conditional recipients to define different recipients for different
+        situations.
+      properties:
+        conditions:
+          description: Conditions of the notification rule.
+          items:
+            $ref: '#/components/schemas/MonitorNotificationRuleCondition'
+          maxItems: 10
+          minItems: 1
+          type: array
+        fallback_recipients:
+          $ref: '#/components/schemas/MonitorNotificationRuleRecipients'
+          description: If none of the `conditions` applied, `fallback_recipients`
+            will get notified.
+      required:
+      - conditions
+      type: object
     MonitorNotificationRuleCreateRequest:
       description: Request for creating a monitor notification rule.
       properties:
@@ -29714,6 +29744,8 @@ components:
       additionalProperties: {}
       description: Attributes of the monitor notification rule.
       properties:
+        conditional_recipients:
+          $ref: '#/components/schemas/MonitorNotificationRuleConditionalRecipients'
         created:
           description: Creation time of the monitor notification rule.
           example: 2020-01-02 03:04:00+00:00
@@ -29735,6 +29767,12 @@ components:
       description: An object related to a monitor notification rule.
       oneOf:
       - $ref: '#/components/schemas/User'
+    MonitorNotificationRuleScope:
+      description: The scope to which the monitor applied.
+      example: transition_type:alert
+      maxLength: 3000
+      minLength: 1
+      type: string
     MonitorNotificationRuleUpdateRequest:
       description: Request for updating a monitor notification rule.
       properties:

LICENSE-3rdparty.csv

@@ -129,6 +129,7 @@ serde_json,https://github.com/serde-rs/json,MIT OR Apache-2.0,"Erick Tryzelaar <
 serde_urlencoded,https://github.com/nox/serde_urlencoded,MIT OR Apache-2.0,Anthony Ramine <[email protected]>
 serde_with,https://github.com/jonasbb/serde_with,MIT OR Apache-2.0,"Jonas Bushart, Marcin Kaźmierczak"
 serde_with_macros,https://github.com/jonasbb/serde_with,MIT OR Apache-2.0,Jonas Bushart
+simd-adler32,https://github.com/mcountryman/simd-adler32,MIT,Marvin Countryman <[email protected]>
 slab,https://github.com/tokio-rs/slab,MIT,Carl Lerche <[email protected]>
 smallvec,https://github.com/servo/rust-smallvec,MIT OR Apache-2.0,The Servo Project Developers
 socket2,https://github.com/rust-lang/socket2,MIT OR Apache-2.0,"Alex Crichton <[email protected]>, Thomas de Zeeuw <[email protected]>"

examples/v2_monitors_CreateMonitorNotificationRule.rs

@@ -12,17 +12,18 @@ use datadog_api_client::datadogV2::model::MonitorNotificationRuleResourceType;
 async fn main() {
     let body = MonitorNotificationRuleCreateRequest::new(
         MonitorNotificationRuleCreateRequestData::new(
-            MonitorNotificationRuleAttributes::new(
-                "test rule".to_string(),
-                vec!["slack-test-channel".to_string(), "jira-test".to_string()],
-            )
-            .filter(
-                MonitorNotificationRuleFilter::MonitorNotificationRuleFilterTags(Box::new(
-                    MonitorNotificationRuleFilterTags::new(
-                        vec!["test:example-monitor".to_string()],
-                    ),
-                )),
-            ),
+            MonitorNotificationRuleAttributes::new("test rule".to_string())
+                .filter(
+                    MonitorNotificationRuleFilter::MonitorNotificationRuleFilterTags(Box::new(
+                        MonitorNotificationRuleFilterTags::new(vec![
+                            "test:example-monitor".to_string()
+                        ]),
+                    )),
+                )
+                .recipients(vec![
+                    "slack-test-channel".to_string(),
+                    "jira-test".to_string(),
+                ]),
         )
         .type_(MonitorNotificationRuleResourceType::MONITOR_NOTIFICATION_RULE),
     );

examples/v2_monitors_CreateMonitorNotificationRule_1181818787.rs

@@ -0,0 +1,43 @@
+// Create a monitor notification rule with conditional recipients returns "OK"
+// response
+use datadog_api_client::datadog;
+use datadog_api_client::datadogV2::api_monitors::MonitorsAPI;
+use datadog_api_client::datadogV2::model::MonitorNotificationRuleAttributes;
+use datadog_api_client::datadogV2::model::MonitorNotificationRuleCondition;
+use datadog_api_client::datadogV2::model::MonitorNotificationRuleConditionalRecipients;
+use datadog_api_client::datadogV2::model::MonitorNotificationRuleCreateRequest;
+use datadog_api_client::datadogV2::model::MonitorNotificationRuleCreateRequestData;
+use datadog_api_client::datadogV2::model::MonitorNotificationRuleFilter;
+use datadog_api_client::datadogV2::model::MonitorNotificationRuleFilterTags;
+use datadog_api_client::datadogV2::model::MonitorNotificationRuleResourceType;
+
+#[tokio::main]
+async fn main() {
+    let body = MonitorNotificationRuleCreateRequest::new(
+        MonitorNotificationRuleCreateRequestData::new(
+            MonitorNotificationRuleAttributes::new("test rule".to_string())
+                .conditional_recipients(MonitorNotificationRuleConditionalRecipients::new(vec![
+                    MonitorNotificationRuleCondition::new(
+                        vec!["slack-test-channel".to_string(), "jira-test".to_string()],
+                        "transition_type:is_alert".to_string(),
+                    ),
+                ]))
+                .filter(
+                    MonitorNotificationRuleFilter::MonitorNotificationRuleFilterTags(Box::new(
+                        MonitorNotificationRuleFilterTags::new(vec![
+                            "test:example-monitor".to_string()
+                        ]),
+                    )),
+                ),
+        )
+        .type_(MonitorNotificationRuleResourceType::MONITOR_NOTIFICATION_RULE),
+    );
+    let configuration = datadog::Configuration::new();
+    let api = MonitorsAPI::with_config(configuration);
+    let resp = api.create_monitor_notification_rule(body).await;
+    if let Ok(value) = resp {
+        println!("{:#?}", value);
+    } else {
+        println!("{:#?}", resp.unwrap_err());
+    }
+}

examples/v2_monitors_UpdateMonitorNotificationRule.rs

@@ -15,18 +15,16 @@ async fn main() {
         std::env::var("MONITOR_NOTIFICATION_RULE_DATA_ID").unwrap();
     let body = MonitorNotificationRuleUpdateRequest::new(
         MonitorNotificationRuleUpdateRequestData::new(
-            MonitorNotificationRuleAttributes::new(
-                "updated rule".to_string(),
-                vec!["slack-test-channel".to_string()],
-            )
-            .filter(
-                MonitorNotificationRuleFilter::MonitorNotificationRuleFilterTags(Box::new(
-                    MonitorNotificationRuleFilterTags::new(vec![
-                        "test:example-monitor".to_string(),
-                        "host:abc".to_string(),
-                    ]),
-                )),
-            ),
+            MonitorNotificationRuleAttributes::new("updated rule".to_string())
+                .filter(
+                    MonitorNotificationRuleFilter::MonitorNotificationRuleFilterTags(Box::new(
+                        MonitorNotificationRuleFilterTags::new(vec![
+                            "test:example-monitor".to_string(),
+                            "host:abc".to_string(),
+                        ]),
+                    )),
+                )
+                .recipients(vec!["slack-test-channel".to_string()]),
             monitor_notification_rule_data_id.clone(),
         )
         .type_(MonitorNotificationRuleResourceType::MONITOR_NOTIFICATION_RULE),

examples/v2_monitors_UpdateMonitorNotificationRule_1400905713.rs

@@ -0,0 +1,50 @@
+// Update a monitor notification rule with conditional_recipients returns "OK"
+// response
+use datadog_api_client::datadog;
+use datadog_api_client::datadogV2::api_monitors::MonitorsAPI;
+use datadog_api_client::datadogV2::model::MonitorNotificationRuleAttributes;
+use datadog_api_client::datadogV2::model::MonitorNotificationRuleCondition;
+use datadog_api_client::datadogV2::model::MonitorNotificationRuleConditionalRecipients;
+use datadog_api_client::datadogV2::model::MonitorNotificationRuleFilter;
+use datadog_api_client::datadogV2::model::MonitorNotificationRuleFilterTags;
+use datadog_api_client::datadogV2::model::MonitorNotificationRuleResourceType;
+use datadog_api_client::datadogV2::model::MonitorNotificationRuleUpdateRequest;
+use datadog_api_client::datadogV2::model::MonitorNotificationRuleUpdateRequestData;
+
+#[tokio::main]
+async fn main() {
+    // there is a valid "monitor_notification_rule" in the system
+    let monitor_notification_rule_data_id =
+        std::env::var("MONITOR_NOTIFICATION_RULE_DATA_ID").unwrap();
+    let body = MonitorNotificationRuleUpdateRequest::new(
+        MonitorNotificationRuleUpdateRequestData::new(
+            MonitorNotificationRuleAttributes::new("updated rule".to_string())
+                .conditional_recipients(MonitorNotificationRuleConditionalRecipients::new(vec![
+                    MonitorNotificationRuleCondition::new(
+                        vec!["slack-test-channel".to_string(), "jira-test".to_string()],
+                        "transition_type:is_alert".to_string(),
+                    ),
+                ]))
+                .filter(
+                    MonitorNotificationRuleFilter::MonitorNotificationRuleFilterTags(Box::new(
+                        MonitorNotificationRuleFilterTags::new(vec![
+                            "test:example-monitor".to_string(),
+                            "host:abc".to_string(),
+                        ]),
+                    )),
+                ),
+            monitor_notification_rule_data_id.clone(),
+        )
+        .type_(MonitorNotificationRuleResourceType::MONITOR_NOTIFICATION_RULE),
+    );
+    let configuration = datadog::Configuration::new();
+    let api = MonitorsAPI::with_config(configuration);
+    let resp = api
+        .update_monitor_notification_rule(monitor_notification_rule_data_id.clone(), body)
+        .await;
+    if let Ok(value) = resp {
+        println!("{:#?}", value);
+    } else {
+        println!("{:#?}", resp.unwrap_err());
+    }
+}

src/datadogV2/model/mod.rs

@@ -3428,6 +3428,10 @@ pub mod model_monitor_notification_rule_data;
 pub use self::model_monitor_notification_rule_data::MonitorNotificationRuleData;
 pub mod model_monitor_notification_rule_response_attributes;
 pub use self::model_monitor_notification_rule_response_attributes::MonitorNotificationRuleResponseAttributes;
+pub mod model_monitor_notification_rule_conditional_recipients;
+pub use self::model_monitor_notification_rule_conditional_recipients::MonitorNotificationRuleConditionalRecipients;
+pub mod model_monitor_notification_rule_condition;
+pub use self::model_monitor_notification_rule_condition::MonitorNotificationRuleCondition;
 pub mod model_monitor_notification_rule_filter_tags;
 pub use self::model_monitor_notification_rule_filter_tags::MonitorNotificationRuleFilterTags;
 pub mod model_monitor_notification_rule_filter;

src/datadogV2/model/model_monitor_notification_rule_attributes.rs

@@ -11,6 +11,10 @@ use std::fmt::{self, Formatter};
 #[skip_serializing_none]
 #[derive(Clone, Debug, PartialEq, Serialize)]
 pub struct MonitorNotificationRuleAttributes {
+    /// Use conditional recipients to define different recipients for different situations.
+    #[serde(rename = "conditional_recipients")]
+    pub conditional_recipients:
+        Option<crate::datadogV2::model::MonitorNotificationRuleConditionalRecipients>,
     /// Filter used to associate the notification rule with monitors.
     #[serde(rename = "filter")]
     pub filter: Option<crate::datadogV2::model::MonitorNotificationRuleFilter>,
@@ -19,26 +23,40 @@ pub struct MonitorNotificationRuleAttributes {
     pub name: String,
     /// A list of recipients to notify. Uses the same format as the monitor `message` field. Must not start with an '@'.
     #[serde(rename = "recipients")]
-    pub recipients: Vec<String>,
+    pub recipients: Option<Vec<String>>,
     #[serde(skip)]
     #[serde(default)]
     pub(crate) _unparsed: bool,
 }
 
 impl MonitorNotificationRuleAttributes {
-    pub fn new(name: String, recipients: Vec<String>) -> MonitorNotificationRuleAttributes {
+    pub fn new(name: String) -> MonitorNotificationRuleAttributes {
         MonitorNotificationRuleAttributes {
+            conditional_recipients: None,
             filter: None,
             name,
-            recipients,
+            recipients: None,
             _unparsed: false,
         }
     }
 
+    pub fn conditional_recipients(
+        mut self,
+        value: crate::datadogV2::model::MonitorNotificationRuleConditionalRecipients,
+    ) -> Self {
+        self.conditional_recipients = Some(value);
+        self
+    }
+
     pub fn filter(mut self, value: crate::datadogV2::model::MonitorNotificationRuleFilter) -> Self {
         self.filter = Some(value);
         self
     }
+
+    pub fn recipients(mut self, value: Vec<String>) -> Self {
+        self.recipients = Some(value);
+        self
+    }
 }
 
 impl<'de> Deserialize<'de> for MonitorNotificationRuleAttributes {
@@ -58,6 +76,9 @@ impl<'de> Deserialize<'de> for MonitorNotificationRuleAttributes {
             where
                 M: MapAccess<'a>,
             {
+                let mut conditional_recipients: Option<
+                    crate::datadogV2::model::MonitorNotificationRuleConditionalRecipients,
+                > = None;
                 let mut filter: Option<crate::datadogV2::model::MonitorNotificationRuleFilter> =
                     None;
                 let mut name: Option<String> = None;
@@ -66,6 +87,13 @@ impl<'de> Deserialize<'de> for MonitorNotificationRuleAttributes {
 
                 while let Some((k, v)) = map.next_entry::<String, serde_json::Value>()? {
                     match k.as_str() {
+                        "conditional_recipients" => {
+                            if v.is_null() {
+                                continue;
+                            }
+                            conditional_recipients =
+                                Some(serde_json::from_value(v).map_err(M::Error::custom)?);
+                        }
                         "filter" => {
                             if v.is_null() {
                                 continue;
@@ -84,6 +112,9 @@ impl<'de> Deserialize<'de> for MonitorNotificationRuleAttributes {
                             name = Some(serde_json::from_value(v).map_err(M::Error::custom)?);
                         }
                         "recipients" => {
+                            if v.is_null() {
+                                continue;
+                            }
                             recipients = Some(serde_json::from_value(v).map_err(M::Error::custom)?);
                         }
                         &_ => {
@@ -94,9 +125,9 @@ impl<'de> Deserialize<'de> for MonitorNotificationRuleAttributes {
                     }
                 }
                 let name = name.ok_or_else(|| M::Error::missing_field("name"))?;
-                let recipients = recipients.ok_or_else(|| M::Error::missing_field("recipients"))?;
 
                 let content = MonitorNotificationRuleAttributes {
+                    conditional_recipients,
                     filter,
                     name,
                     recipients,