update: add other fields to alert request, config and response

also exclude alert state from loading alerts

Author: nikhilsinhaparseable

src/alerts/alert_structs.rs

@@ -19,7 +19,8 @@
 use std::{collections::HashMap, time::Duration};
 
 use chrono::{DateTime, Utc};
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize};
+use serde_json::Value;
 use tokio::sync::{RwLock, mpsc};
 use ulid::Ulid;
 
@@ -38,6 +39,52 @@ use crate::{
     storage::object_storage::{alert_json_path, alert_state_json_path},
 };
 
+/// Custom deserializer for DateTime<Utc> that handles legacy empty strings
+///
+/// This is a compatibility layer for migrating old alerts that stored empty strings
+/// instead of valid timestamps. In production, this should log warnings to help
+/// identify data quality issues.
+///
+/// # Migration Path
+/// - Empty strings → Default to current time with a warning
+/// - Missing fields → Default to current time
+/// - Valid timestamps → Parse normally
+pub(crate) fn deserialize_datetime_with_empty_string_fallback<'de, D>(
+    deserializer: D,
+) -> Result<DateTime<Utc>, D::Error>
+where
+    D: Deserializer<'de>,
+{
+    #[derive(Deserialize)]
+    #[serde(untagged)]
+    enum DateTimeOrString {
+        DateTime(DateTime<Utc>),
+        String(String),
+    }
+
+    match DateTimeOrString::deserialize(deserializer)? {
+        DateTimeOrString::DateTime(dt) => Ok(dt),
+        DateTimeOrString::String(s) => {
+            if s.is_empty() {
+                // Log warning about data quality issue
+                tracing::warn!(
+                    "Alert has empty 'created' field - this indicates a data quality issue. \
+                     Defaulting to current timestamp. Please investigate and fix the data source."
+                );
+                Ok(Utc::now())
+            } else {
+                s.parse::<DateTime<Utc>>().map_err(serde::de::Error::custom)
+            }
+        }
+    }
+}
+
+/// Default function for created timestamp - returns current time
+/// This handles the case where created field is missing in deserialization
+pub(crate) fn default_created_time() -> DateTime<Utc> {
+    Utc::now()
+}
+
 /// Helper struct for basic alert fields during migration
 pub struct BasicAlertFields {
     pub id: Ulid,
@@ -253,6 +300,8 @@ pub struct AlertRequest {
     pub eval_config: EvalConfig,
     pub targets: Vec<Ulid>,
     pub tags: Option<Vec<String>>,
+    #[serde(flatten)]
+    pub other_fields: Option<serde_json::Map<String, Value>>,
 }
 
 impl AlertRequest {
@@ -309,6 +358,7 @@ impl AlertRequest {
             created: Utc::now(),
             tags: self.tags,
             last_triggered_at: None,
+            other_fields: self.other_fields,
         };
         Ok(config)
     }
@@ -333,9 +383,15 @@ pub struct AlertConfig {
     pub state: AlertState,
     pub notification_state: NotificationState,
     pub notification_config: NotificationConfig,
+    #[serde(
+        default = "default_created_time",
+        deserialize_with = "deserialize_datetime_with_empty_string_fallback"
+    )]
     pub created: DateTime<Utc>,
     pub tags: Option<Vec<String>>,
     pub last_triggered_at: Option<DateTime<Utc>>,
+    #[serde(flatten)]
+    pub other_fields: Option<serde_json::Map<String, Value>>,
 }
 
 #[derive(Debug, serde::Serialize, serde::Deserialize, Clone)]
@@ -359,9 +415,15 @@ pub struct AlertConfigResponse {
     pub state: AlertState,
     pub notification_state: NotificationState,
     pub notification_config: NotificationConfig,
+    #[serde(
+        default = "default_created_time",
+        deserialize_with = "deserialize_datetime_with_empty_string_fallback"
+    )]
     pub created: DateTime<Utc>,
     pub tags: Option<Vec<String>>,
     pub last_triggered_at: Option<DateTime<Utc>>,
+    #[serde(flatten)]
+    pub other_fields: Option<serde_json::Map<String, Value>>,
 }
 
 impl AlertConfig {
@@ -401,6 +463,7 @@ impl AlertConfig {
             created: self.created,
             tags: self.tags,
             last_triggered_at: self.last_triggered_at,
+            other_fields: self.other_fields,
         }
     }
 }

src/alerts/alert_types.rs

@@ -19,6 +19,7 @@
 use std::{str::FromStr, time::Duration};
 
 use chrono::{DateTime, Utc};
+use serde_json::Value;
 use tonic::async_trait;
 use tracing::{info, trace, warn};
 use ulid::Ulid;
@@ -28,7 +29,10 @@ use crate::{
         AlertConfig, AlertError, AlertState, AlertType, AlertVersion, EvalConfig, Severity,
         ThresholdConfig,
         alert_enums::NotificationState,
-        alert_structs::{AlertStateEntry, GroupResult},
+        alert_structs::{
+            AlertStateEntry, GroupResult, default_created_time,
+            deserialize_datetime_with_empty_string_fallback,
+        },
         alert_traits::{AlertTrait, MessageCreation},
         alerts_utils::{evaluate_condition, execute_alert_query, extract_time_range},
         get_number_of_agg_exprs,
@@ -61,10 +65,16 @@ pub struct ThresholdAlert {
     pub state: AlertState,
     pub notification_state: NotificationState,
     pub notification_config: NotificationConfig,
+    #[serde(
+        default = "default_created_time",
+        deserialize_with = "deserialize_datetime_with_empty_string_fallback"
+    )]
     pub created: DateTime<Utc>,
     pub tags: Option<Vec<String>>,
     pub datasets: Vec<String>,
     pub last_triggered_at: Option<DateTime<Utc>>,
+    #[serde(flatten)]
+    pub other_fields: Option<serde_json::Map<String, Value>>,
 }
 
 impl MetastoreObject for ThresholdAlert {
@@ -408,6 +418,7 @@ impl From<AlertConfig> for ThresholdAlert {
             tags: value.tags,
             datasets: value.datasets,
             last_triggered_at: value.last_triggered_at,
+            other_fields: value.other_fields,
         }
     }
 }
@@ -431,6 +442,7 @@ impl From<ThresholdAlert> for AlertConfig {
             tags: val.tags,
             datasets: val.datasets,
             last_triggered_at: val.last_triggered_at,
+            other_fields: val.other_fields,
         }
     }
 }

src/alerts/mod.rs

@@ -134,6 +134,7 @@ impl AlertConfig {
             created: Utc::now(),
             tags: None,
             last_triggered_at: None,
+            other_fields: None,
         };
 
         // Save the migrated alert back to storage
@@ -682,6 +683,12 @@ impl AlertConfig {
             );
         }
 
+        if let Some(other_fields) = &self.other_fields {
+            for (key, value) in other_fields {
+                map.insert(key.clone(), value.clone());
+            }
+        }
+
         map
     }
 }

src/handlers/http/alerts.rs

@@ -51,6 +51,10 @@ pub async fn list(req: HttpRequest) -> Result<impl Responder, AlertError> {
     let mut limit = 100usize; // Default limit
     const MAX_LIMIT: usize = 1000; // Maximum allowed limit
 
+    // Reserved query parameter names that are not treated as other_fields filters
+    const RESERVED_PARAMS: [&str; 3] = ["tags", "offset", "limit"];
+    let mut other_fields_filters: HashMap<String, String> = HashMap::new();
+
     // Parse query parameters
     if !query_map.is_empty() {
         // Parse tags parameter
@@ -87,6 +91,13 @@ pub async fn list(req: HttpRequest) -> Result<impl Responder, AlertError> {
                 ));
             }
         }
+
+        // Collect all other query parameters as potential other_fields filters
+        for (key, value) in query_map.iter() {
+            if !RESERVED_PARAMS.contains(&key.as_str()) {
+                other_fields_filters.insert(key.clone(), value.clone());
+            }
+        }
     }
     let guard = ALERTS.read().await;
     let alerts = if let Some(alerts) = guard.as_ref() {
@@ -100,6 +111,23 @@ pub async fn list(req: HttpRequest) -> Result<impl Responder, AlertError> {
         .iter()
         .map(|alert| alert.to_summary())
         .collect::<Vec<_>>();
+
+    // Filter by other_fields if any filters are specified
+    if !other_fields_filters.is_empty() {
+        alerts_summary.retain(|alert_summary| {
+            // Check if all specified other_fields filters match
+            other_fields_filters
+                .iter()
+                .all(|(filter_key, filter_value)| {
+                    alert_summary
+                        .get(filter_key)
+                        .and_then(|v| v.as_str())
+                        .map(|alert_value| alert_value == filter_value)
+                        .unwrap_or(false)
+                })
+        });
+    }
+
     // Sort by state priority (Triggered > NotTriggered) then by severity (Critical > High > Medium > Low)
     alerts_summary.sort_by(|a, b| {
         // Parse state and severity from JSON values back to enums

src/metastore/metastores/object_store_metastore.rs

@@ -180,7 +180,9 @@ impl Metastore for ObjectStoreMetastore {
             .storage
             .get_objects(
                 Some(&alerts_path),
-                Box::new(|file_name| file_name.ends_with(".json")),
+                Box::new(|file_name| {
+                    !file_name.starts_with("alert_state_") && file_name.ends_with(".json")
+                }),
             )
             .await?;