Bump Rust Version

bumped edition to 2024
bumped version to 1.88.0

Author: parmesant

Cargo.toml

@@ -2,8 +2,8 @@
 name = "parseable"
 version = "2.3.5"
 authors = ["Parseable Team <[email protected]>"]
-edition = "2021"
-rust-version = "1.83.0"
+edition = "2024"
+rust-version = "1.88.0"
 categories = ["logs", "observability", "metrics", "traces"]
 build = "build.rs"
 

build.rs

@@ -38,7 +38,7 @@ pub fn main() -> Result<()> {
 
 mod ui {
 
-    use std::fs::{self, create_dir_all, OpenOptions};
+    use std::fs::{self, OpenOptions, create_dir_all};
     use std::io::{self, Cursor, Read, Write};
     use std::path::{Path, PathBuf};
     use std::{env, panic};

src/alerts/alerts_utils.rs

@@ -27,7 +27,7 @@ use datafusion::{
         sum::sum,
     },
     logical_expr::{BinaryExpr, Literal, Operator},
-    prelude::{col, lit, DataFrame, Expr},
+    prelude::{DataFrame, Expr, col, lit},
 };
 use tracing::trace;
 
@@ -40,8 +40,8 @@ use crate::{
 };
 
 use super::{
-    AggregateConfig, AggregateFunction, AggregateResult, Aggregates, AlertConfig, AlertError,
-    AlertOperator, AlertState, ConditionConfig, Conditions, WhereConfigOperator, ALERTS,
+    ALERTS, AggregateConfig, AggregateFunction, AggregateResult, Aggregates, AlertConfig,
+    AlertError, AlertOperator, AlertState, ConditionConfig, Conditions, WhereConfigOperator,
 };
 
 /// accept the alert
@@ -497,15 +497,19 @@ fn match_alert_operator(expr: &ConditionConfig) -> Expr {
                 Operator::RegexNotIMatch,
                 Box::new(lit(format!("{string_value}$"))),
             )),
-            _ => unreachable!("value must not be null for operators other than `is null` and `is not null`. Should've been caught in validation")
+            _ => unreachable!(
+                "value must not be null for operators other than `is null` and `is not null`. Should've been caught in validation"
+            ),
         }
     } else {
         // for maintaining column case
         let column = format!(r#""{}""#, expr.column);
         match expr.operator {
             WhereConfigOperator::IsNull => col(column).is_null(),
             WhereConfigOperator::IsNotNull => col(column).is_not_null(),
-            _ => unreachable!("value must be null for `is null` and `is not null`. Should've been caught in validation")
+            _ => unreachable!(
+                "value must be null for `is null` and `is not null`. Should've been caught in validation"
+            ),
         }
     }
 }

src/alerts/mod.rs

@@ -22,6 +22,7 @@ use chrono::Utc;
 use datafusion::sql::sqlparser::parser::ParserError;
 use derive_more::derive::FromStr;
 use derive_more::FromStrError;
+use derive_more::derive::FromStr;
 use http::StatusCode;
 use once_cell::sync::Lazy;
 use serde::Serialize;
@@ -31,7 +32,7 @@ use std::fmt::{self, Display};
 use std::thread;
 use std::time::Duration;
 use tokio::sync::oneshot::{Receiver, Sender};
-use tokio::sync::{mpsc, RwLock};
+use tokio::sync::{RwLock, mpsc};
 use tokio::task::JoinHandle;
 use tracing::{error, trace, warn};
 use ulid::Ulid;
@@ -40,7 +41,7 @@ pub mod alerts_utils;
 pub mod target;
 
 use crate::alerts::target::TARGETS;
-use crate::parseable::{StreamNotFound, PARSEABLE};
+use crate::parseable::{PARSEABLE, StreamNotFound};
 use crate::rbac::map::SessionKey;
 use crate::storage;
 use crate::storage::ObjectStorageError;

src/alerts/target.rs

@@ -26,11 +26,11 @@ use async_trait::async_trait;
 use base64::Engine;
 use bytes::Bytes;
 use chrono::Utc;
-use http::{header::AUTHORIZATION, HeaderMap, HeaderValue};
+use http::{HeaderMap, HeaderValue, header::AUTHORIZATION};
 use itertools::Itertools;
 use once_cell::sync::Lazy;
 use reqwest::ClientBuilder;
-use serde_json::{json, Value};
+use serde_json::{Value, json};
 use tokio::sync::RwLock;
 use tracing::{error, trace, warn};
 use ulid::Ulid;
@@ -288,7 +288,9 @@ impl Target {
                         state
                     } else {
                         *state.lock().unwrap() = TimeoutState::default();
-                        warn!("Unable to fetch state for given alert_id- {alert_id}, stopping target notifs");
+                        warn!(
+                            "Unable to fetch state for given alert_id- {alert_id}, stopping target notifs"
+                        );
                         return;
                     };
 
@@ -304,7 +306,9 @@ impl Target {
                             state
                         } else {
                             *state.lock().unwrap() = TimeoutState::default();
-                            warn!("Unable to fetch state for given alert_id- {alert_id}, stopping target notifs");
+                            warn!(
+                                "Unable to fetch state for given alert_id- {alert_id}, stopping target notifs"
+                            );
                             return;
                         };
 

src/analytics.rs

@@ -16,7 +16,7 @@
  *
  *
  */
-use actix_web::{web, HttpRequest, Responder};
+use actix_web::{HttpRequest, Responder, web};
 use chrono::{DateTime, Utc};
 use clokwerk::{AsyncScheduler, Interval};
 use http::header;
@@ -31,19 +31,20 @@ use tracing::{error, info};
 use ulid::Ulid;
 
 use crate::{
+    HTTP_CLIENT, INTRA_CLUSTER_CLIENT,
     about::{current, platform},
     handlers::{
+        STREAM_NAME_HEADER_KEY,
         http::{
             base_path_without_preceding_slash,
             cluster::{self, utils::check_liveness},
             modal::{NodeMetadata, NodeType},
         },
-        STREAM_NAME_HEADER_KEY,
     },
     option::Mode,
     parseable::PARSEABLE,
     stats::{self, Stats},
-    storage, HTTP_CLIENT, INTRA_CLUSTER_CLIENT,
+    storage,
 };
 
 const ANALYTICS_SERVER_URL: &str = "https://analytics.parseable.io:80";
@@ -239,8 +240,8 @@ fn total_event_stats() -> (Stats, Stats, Stats) {
     )
 }
 
-async fn fetch_ingestors_metrics(
-) -> anyhow::Result<(u64, u64, usize, u64, u64, u64, u64, u64, u64, u64, u64, u64)> {
+async fn fetch_ingestors_metrics()
+-> anyhow::Result<(u64, u64, usize, u64, u64, u64, u64, u64, u64, u64, u64, u64)> {
     let event_stats = total_event_stats();
     let mut node_metrics = NodeMetrics::new(
         total_streams(),

src/audit.rs

@@ -21,12 +21,12 @@ use std::{
     fmt::{Debug, Display},
 };
 
-use crate::{about::current, parseable::PARSEABLE, storage::StorageMetadata, HTTP_CLIENT};
+use crate::{HTTP_CLIENT, about::current, parseable::PARSEABLE, storage::StorageMetadata};
 
 use chrono::{DateTime, Utc};
 use once_cell::sync::Lazy;
 use serde::Serialize;
-use serde_json::{json, Value};
+use serde_json::{Value, json};
 use tracing::error;
 
 use ulid::Ulid;

src/catalog/mod.rs

@@ -41,7 +41,7 @@ use crate::{
     query::PartialTimeFilter,
     stats::{event_labels_date, get_current_stats, storage_size_labels_date, update_deleted_stats},
     storage::{
-        object_storage::manifest_path, ObjectStorage, ObjectStorageError, ObjectStoreFormat,
+        ObjectStorage, ObjectStorageError, ObjectStoreFormat, object_storage::manifest_path,
     },
 };
 pub use manifest::create_from_parquet_file;

src/cli.rs

@@ -26,7 +26,7 @@ use crate::connectors::kafka::config::KafkaConfig;
 
 use crate::{
     oidc::{self, OpenidConfig},
-    option::{validation, Compression, Mode},
+    option::{Compression, Mode, validation},
     storage::{AzureBlobConfig, FSConfig, GcsConfig, S3Config},
 };
 

src/connectors/kafka/consumer.rs

@@ -16,20 +16,20 @@
  *
  */
 
-use crate::connectors::common::shutdown::Shutdown;
 use crate::connectors::common::ConnectorError;
+use crate::connectors::common::shutdown::Shutdown;
 use crate::connectors::kafka::partition_stream::{PartitionStreamReceiver, PartitionStreamSender};
 use crate::connectors::kafka::state::StreamState;
 use crate::connectors::kafka::{
-    partition_stream, ConsumerRecord, KafkaContext, StreamConsumer, TopicPartition,
+    ConsumerRecord, KafkaContext, StreamConsumer, TopicPartition, partition_stream,
 };
 use futures_util::FutureExt;
+use rdkafka::Statistics;
 use rdkafka::consumer::Consumer;
 use rdkafka::message::BorrowedMessage;
-use rdkafka::Statistics;
 use std::sync::Arc;
 use std::time::Duration;
-use tokio::sync::{mpsc, RwLock};
+use tokio::sync::{RwLock, mpsc};
 use tokio_stream::wrappers::ReceiverStream;
 use tracing::{error, info, warn};