updates:

- separated `NotificationConfig` from target config

Author: parmesant

src/alerts/alert_structs.rs

@@ -13,7 +13,7 @@ use crate::{
             LogicalOperator, NotificationState, Severity, WhereConfigOperator,
         },
         alert_traits::AlertTrait,
-        target::TARGETS,
+        target::{NotificationConfig, TARGETS},
     },
     query::resolve_stream_names,
 };
@@ -36,14 +36,21 @@ pub struct Context {
     pub alert_info: AlertInfo,
     pub deployment_info: DeploymentInfo,
     pub message: String,
+    pub notification_config: NotificationConfig,
 }
 
 impl Context {
-    pub fn new(alert_info: AlertInfo, deployment_info: DeploymentInfo, message: String) -> Self {
+    pub fn new(
+        alert_info: AlertInfo,
+        deployment_info: DeploymentInfo,
+        notification_config: NotificationConfig,
+        message: String,
+    ) -> Self {
         Self {
             alert_info,
             deployment_info,
             message,
+            notification_config,
         }
     }
 
@@ -226,6 +233,7 @@ pub struct AlertRequest {
     pub query: String,
     pub alert_type: AlertType,
     pub threshold_config: ThresholdConfig,
+    pub notification_config: NotificationConfig,
     pub eval_config: EvalConfig,
     pub targets: Vec<Ulid>,
     pub tags: Option<Vec<String>>,
@@ -251,6 +259,7 @@ impl AlertRequest {
             targets: self.targets,
             state: AlertState::default(),
             notification_state: NotificationState::Notify,
+            notification_config: self.notification_config,
             created: Utc::now(),
             tags: self.tags,
         };
@@ -276,6 +285,7 @@ pub struct AlertConfig {
     #[serde(default)]
     pub state: AlertState,
     pub notification_state: NotificationState,
+    pub notification_config: NotificationConfig,
     pub created: DateTime<Utc>,
     pub tags: Option<Vec<String>>,
 }

src/alerts/alert_types.rs

@@ -31,7 +31,7 @@ use crate::{
         alert_traits::{AlertTrait, MessageCreation},
         alerts_utils::{evaluate_condition, execute_alert_query, extract_time_range},
         is_query_aggregate,
-        target::{self, TARGETS},
+        target::{self, NotificationConfig},
     },
     handlers::http::query::create_streams_for_distributed,
     option::Mode,
@@ -58,6 +58,7 @@ pub struct ThresholdAlert {
     #[serde(default)]
     pub state: AlertState,
     pub notification_state: NotificationState,
+    pub notification_config: NotificationConfig,
     pub created: DateTime<Utc>,
     pub tags: Option<Vec<String>>,
     pub datasets: Vec<String>,
@@ -105,19 +106,15 @@ impl AlertTrait for ThresholdAlert {
         };
 
         // validate that target repeat notifs !> eval_frequency
-        for target_id in &self.targets {
-            let target = TARGETS.get_target_by_id(target_id).await?;
-            match &target.notification_config.times {
-                target::Retry::Infinite => {}
-                target::Retry::Finite(repeat) => {
-                    let notif_duration =
-                        Duration::from_secs(60 * target.notification_config.interval)
-                            * *repeat as u32;
-                    if (notif_duration.as_secs_f64()).gt(&((eval_frequency * 60) as f64)) {
-                        return Err(AlertError::Metadata(
-                            "evalFrequency should be greater than target repetition  interval",
-                        ));
-                    }
+        match &self.notification_config.times {
+            target::Retry::Infinite => {}
+            target::Retry::Finite(repeat) => {
+                let notif_duration =
+                    Duration::from_secs(60 * self.notification_config.interval) * *repeat as u32;
+                if (notif_duration.as_secs_f64()).gt(&((eval_frequency * 60) as f64)) {
+                    return Err(AlertError::Metadata(
+                        "evalFrequency should be greater than target repetition  interval",
+                    ));
                 }
             }
         }
@@ -329,6 +326,7 @@ impl From<AlertConfig> for ThresholdAlert {
             targets: value.targets,
             state: value.state,
             notification_state: value.notification_state,
+            notification_config: value.notification_config,
             created: value.created,
             tags: value.tags,
             datasets: value.datasets,
@@ -350,6 +348,7 @@ impl From<ThresholdAlert> for AlertConfig {
             targets: val.targets,
             state: val.state,
             notification_state: val.notification_state,
+            notification_config: val.notification_config,
             created: val.created,
             tags: val.tags,
             datasets: val.datasets,

src/alerts/mod.rs

@@ -53,7 +53,7 @@ pub use crate::alerts::alert_structs::{
 };
 use crate::alerts::alert_traits::{AlertManagerTrait, AlertTrait};
 use crate::alerts::alert_types::ThresholdAlert;
-use crate::alerts::target::TARGETS;
+use crate::alerts::target::{NotificationConfig, TARGETS};
 use crate::handlers::http::fetch_schema;
 use crate::handlers::http::query::create_streams_for_distributed;
 use crate::option::Mode;
@@ -130,6 +130,7 @@ impl AlertConfig {
             targets,
             state,
             notification_state: NotificationState::Notify,
+            notification_config: NotificationConfig::default(),
             created: Utc::now(),
             tags: None,
         };
@@ -603,19 +604,15 @@ impl AlertConfig {
         };
 
         // validate that target repeat notifs !> eval_frequency
-        for target_id in &self.targets {
-            let target = TARGETS.get_target_by_id(target_id).await?;
-            match &target.notification_config.times {
-                target::Retry::Infinite => {}
-                target::Retry::Finite(repeat) => {
-                    let notif_duration =
-                        Duration::from_secs(60 * target.notification_config.interval)
-                            * *repeat as u32;
-                    if (notif_duration.as_secs_f64()).gt(&((eval_frequency * 60) as f64)) {
-                        return Err(AlertError::Metadata(
-                            "evalFrequency should be greater than target repetition  interval",
-                        ));
-                    }
+        match &self.notification_config.times {
+            target::Retry::Infinite => {}
+            target::Retry::Finite(repeat) => {
+                let notif_duration =
+                    Duration::from_secs(60 * self.notification_config.interval) * *repeat as u32;
+                if (notif_duration.as_secs_f64()).gt(&((eval_frequency * 60) as f64)) {
+                    return Err(AlertError::Metadata(
+                        "evalFrequency should be greater than target repetition  interval",
+                    ));
                 }
             }
         }
@@ -675,6 +672,7 @@ impl AlertConfig {
                 self.severity.clone().to_string(),
             ),
             DeploymentInfo::new(deployment_instance, deployment_id, deployment_mode),
+            self.notification_config.clone(),
             String::default(),
         )
     }

src/alerts/target.rs

@@ -151,7 +151,6 @@ pub struct Target {
     pub name: String,
     #[serde(flatten)]
     pub target: TargetType,
-    pub notification_config: Timeout,
     #[serde(default = "Ulid::new")]
     pub id: Ulid,
 }
@@ -170,7 +169,6 @@ impl Target {
                    "name":self.name,
                    "type":"slack",
                    "endpoint":masked_endpoint,
-                   "notificationConfig":self.notification_config,
                    "id":self.id
                 })
             }
@@ -187,7 +185,6 @@ impl Target {
                     "endpoint":masked_endpoint,
                     "headers":other_web_hook.headers,
                     "skipTlsCheck":other_web_hook.skip_tls_check,
-                    "notificationConfig":self.notification_config,
                     "id":self.id
                 })
             }
@@ -207,7 +204,6 @@ impl Target {
                         "username":auth.username,
                         "password":password,
                         "skipTlsCheck":alert_manager.skip_tls_check,
-                        "notificationConfig":self.notification_config,
                         "id":self.id
                     })
                 } else {
@@ -218,7 +214,6 @@ impl Target {
                         "username":Value::Null,
                         "password":Value::Null,
                         "skipTlsCheck":alert_manager.skip_tls_check,
-                        "notificationConfig":self.notification_config,
                         "id":self.id
                     })
                 }
@@ -228,7 +223,7 @@ impl Target {
 
     pub fn call(&self, context: Context) {
         trace!("target.call context- {context:?}");
-        let timeout = &self.notification_config;
+        let timeout = context.notification_config.clone();
         let resolves = context.alert_info.alert_state;
         let mut state = timeout.state.lock().unwrap();
         trace!("target.call state- {state:?}");
@@ -245,7 +240,7 @@ impl Target {
                     state.timed_out = true;
                     state.awaiting_resolve = true;
                     drop(state);
-                    self.spawn_timeout_task(timeout, context.clone());
+                    self.spawn_timeout_task(&timeout, context.clone());
                 }
             }
             alert_state @ AlertState::NotTriggered => {
@@ -268,7 +263,7 @@ impl Target {
         }
     }
 
-    fn spawn_timeout_task(&self, target_timeout: &Timeout, alert_context: Context) {
+    fn spawn_timeout_task(&self, target_timeout: &NotificationConfig, alert_context: Context) {
         trace!("repeat-\n{target_timeout:?}");
         let state = Arc::clone(&target_timeout.state);
         let retry = target_timeout.times;
@@ -383,7 +378,7 @@ impl TryFrom<TargetVerifier> for Target {
     type Error = String;
 
     fn try_from(value: TargetVerifier) -> Result<Self, Self::Error> {
-        let mut timeout = Timeout::default();
+        let mut timeout = NotificationConfig::default();
 
         // Default is Infinite in case of alertmanager
         if matches!(value.target, TargetType::AlertManager(_)) {
@@ -405,7 +400,6 @@ impl TryFrom<TargetVerifier> for Target {
         Ok(Target {
             name: value.name,
             target: value.target,
-            notification_config: timeout,
             id: value.id,
         })
     }
@@ -599,15 +593,15 @@ impl CallableTarget for AlertManager {
 }
 
 #[derive(Debug, serde::Serialize, serde::Deserialize, Clone)]
-pub struct Timeout {
+pub struct NotificationConfig {
     pub interval: u64,
     #[serde(default = "Retry::default")]
     pub times: Retry,
     #[serde(skip)]
     pub state: Arc<Mutex<TimeoutState>>,
 }
 
-impl Default for Timeout {
+impl Default for NotificationConfig {
     fn default() -> Self {
         Self {
             interval: 1,