updated message

Author: parmesant

src/alerts/alert_traits.rs

@@ -43,6 +43,7 @@ pub trait MessageCreation {
         forecasted_time: DateTime<Utc>,
         forecasted_value: f64,
     ) -> Result<String, AlertError>;
+    fn get_message_header(&self) -> Result<String, AlertError>;
 }
 
 #[async_trait]

src/alerts/alert_types.rs

@@ -303,15 +303,26 @@ impl AlertTrait for ThresholdAlert {
 }
 
 impl MessageCreation for ThresholdAlert {
+    fn get_message_header(&self) -> Result<String, AlertError> {
+        Ok(format!(
+            "Alert Name:         {}\nAlert Type:         Threshold alert\nSeverity:           {}\nTriggered at:       {}\nThreshold:          {}\nAlert ID:           {}\nEvaluation Window:  {}\nFrequency:          {}\n\nValues crossing the threshold:",
+            self.title,
+            self.severity,
+            Utc::now().to_rfc3339(),
+            format_args!(
+                "{} {}",
+                self.threshold_config.operator, self.threshold_config.value
+            ),
+            self.id,
+            self.get_eval_window(),
+            self.get_eval_frequency()
+        ))
+    }
     fn create_threshold_message(&self, actual_value: f64) -> Result<String, AlertError> {
+        let header = self.get_message_header()?;
         Ok(format!(
-            "Alert Triggered: {}\n\nThreshold: ({} {})\nCurrent Value: {}\nEvaluation Window: {} | Frequency: {}\n\nQuery:\n{}",
-            self.get_id(),
-            self.get_threshold_config().operator,
-            self.get_threshold_config().value,
+            "{header}\nValue: {}\n\nQuery:\n{}",
             actual_value,
-            self.get_eval_window(),
-            self.get_eval_frequency(),
             self.get_query()
         ))
     }
@@ -384,14 +395,8 @@ impl From<ThresholdAlert> for AlertConfig {
 
 impl ThresholdAlert {
     fn create_group_message(&self, breached_groups: &[GroupResult]) -> Result<String, AlertError> {
-        let mut message = format!(
-            "Alert Triggered: {}\n\nThreshold: ({} {})\nEvaluation Window: {} | Frequency: {}\n\n",
-            self.get_id(),
-            self.get_threshold_config().operator,
-            self.get_threshold_config().value,
-            self.get_eval_window(),
-            self.get_eval_frequency()
-        );
+        let header = self.get_message_header()?;
+        let mut message = format!("{header}\n");
 
         message.push_str(&format!(
             "Alerting Groups ({} total):\n",

src/alerts/mod.rs

@@ -869,31 +869,6 @@ fn is_likely_aggregate_column(column_name: &str) -> bool {
         || lower_name.contains("max(")
 }
 
-/// Alternative approach: Walk the entire plan and collect all expressions
-pub fn extract_aggregate_aliases_comprehensive(
-    plan: &LogicalPlan,
-) -> Vec<(String, Option<String>)> {
-    let mut aliases = Vec::new();
-    collect_all_expressions(plan, &mut aliases);
-    aliases.dedup(); // Remove duplicates
-    aliases
-}
-
-fn collect_all_expressions(plan: &LogicalPlan, aliases: &mut Vec<(String, Option<String>)>) {
-    // Collect expressions from current node
-    let expressions = plan.expressions();
-    for expr in expressions {
-        if let Some((agg_name, alias)) = extract_alias_from_expr(&expr) {
-            aliases.push((agg_name, alias));
-        }
-    }
-
-    // Recursively process child plans
-    for input in plan.inputs() {
-        collect_all_expressions(input, aliases);
-    }
-}
-
 /// Analyze a logical plan to determine if it represents an aggregate query
 ///
 /// Returns the number of aggregate expressions found in the plan