chore: server side improvements

1. increase dataset fields limit to 1000
2. add hostname to manifest file path
3. update hostname handling
4. list alerts to be sorted on state and then on severity

Author: nikhilsinhaparseable

src/cli.rs

@@ -35,7 +35,7 @@ use crate::{
 pub const DEFAULT_USERNAME: &str = "admin";
 pub const DEFAULT_PASSWORD: &str = "admin";
 
-pub const DATASET_FIELD_COUNT_LIMIT: usize = 250;
+pub const DATASET_FIELD_COUNT_LIMIT: usize = 1000;
 #[derive(Parser)]
 #[command(
     name = "parseable",

src/handlers/http/alerts.rs

@@ -61,10 +61,42 @@ pub async fn list(req: HttpRequest) -> Result<impl Responder, AlertError> {
     };
 
     let alerts = alerts.list_alerts_for_user(session_key, tags_list).await?;
-    let alerts_summary = alerts
+    let mut alerts_summary = alerts
         .iter()
         .map(|alert| alert.to_summary())
         .collect::<Vec<_>>();
+
+    // Sort by state priority (Triggered > Silenced > Resolved) then by severity (Critical > High > Medium > Low)
+    alerts_summary.sort_by(|a, b| {
+        // Helper function to convert state to priority number (lower number = higher priority)
+        let state_priority = |state: &str| match state {
+            "Triggered" => 0,
+            "Silenced" => 1,
+            "Resolved" => 2,
+            _ => 3, // Unknown state gets lowest priority
+        };
+
+        // Helper function to convert severity to priority number (lower number = higher priority)
+        let severity_priority = |severity: &str| match severity {
+            "Critical" => 0,
+            "High" => 1,
+            "Medium" => 2,
+            "Low" => 3,
+            _ => 4, // Unknown severity gets lowest priority
+        };
+
+        let state_a = a.get("state").and_then(|v| v.as_str()).unwrap_or("");
+        let state_b = b.get("state").and_then(|v| v.as_str()).unwrap_or("");
+
+        let severity_a = a.get("severity").and_then(|v| v.as_str()).unwrap_or("");
+        let severity_b = b.get("severity").and_then(|v| v.as_str()).unwrap_or("");
+
+        // First sort by state, then by severity
+        state_priority(state_a)
+            .cmp(&state_priority(state_b))
+            .then_with(|| severity_priority(severity_a).cmp(&severity_priority(severity_b)))
+    });
+
     Ok(web::Json(alerts_summary))
 }
 

src/parseable/streams.rs

@@ -41,6 +41,7 @@ use parquet::{
 use relative_path::RelativePathBuf;
 use tokio::task::JoinSet;
 use tracing::{error, info, trace, warn};
+use ulid::Ulid;
 
 use crate::{
     LOCK_EXPECT, OBJECT_STORE_DATA_GRANULARITY,
@@ -185,7 +186,15 @@ impl Stream {
         parsed_timestamp: NaiveDateTime,
         custom_partition_values: &HashMap<String, String>,
     ) -> String {
-        let mut hostname = hostname::get().unwrap().into_string().unwrap();
+        let mut hostname = hostname::get()
+            .unwrap_or_else(|_| std::ffi::OsString::from(&Ulid::new().to_string()))
+            .into_string()
+            .unwrap_or_else(|_| Ulid::new().to_string())
+            .chars()
+            .filter(|c| c.is_alphanumeric() || *c == '-' || *c == '_')
+            .collect::<String>()
+            .chars()
+            .collect::<String>();
         if let Some(id) = &self.ingestor_id {
             hostname.push_str(id);
         }

src/storage/object_storage.rs

@@ -1011,15 +1011,29 @@ pub fn target_json_path(target_id: &Ulid) -> RelativePathBuf {
 
 #[inline(always)]
 pub fn manifest_path(prefix: &str) -> RelativePathBuf {
+    let hostname = hostname::get()
+        .unwrap_or_else(|_| std::ffi::OsString::from(&Ulid::new().to_string()))
+        .into_string()
+        .unwrap_or_else(|_| Ulid::new().to_string())
+        .chars()
+        .filter(|c| c.is_alphanumeric() || *c == '-' || *c == '_')
+        .collect::<String>()
+        .chars()
+        .collect::<String>();
+
     match &PARSEABLE.options.mode {
         Mode::Ingest => {
             let id = INGESTOR_META
                 .get()
                 .unwrap_or_else(|| panic!("{}", INGESTOR_EXPECT))
                 .get_node_id();
-            let manifest_file_name = format!("ingestor.{id}.{MANIFEST_FILE}");
+
+            let manifest_file_name = format!("ingestor.{hostname}.{id}.{MANIFEST_FILE}");
+            RelativePathBuf::from_iter([prefix, &manifest_file_name])
+        }
+        _ => {
+            let manifest_file_name = format!("{hostname}.{MANIFEST_FILE}");
             RelativePathBuf::from_iter([prefix, &manifest_file_name])
         }
-        _ => RelativePathBuf::from_iter([prefix, MANIFEST_FILE]),
     }
 }