formatting

Author: fordN

Cargo.lock

@@ -2,7 +2,7 @@ use async_trait::async_trait;
 use reqwest::Client;
 use serde::Deserialize;
 use serde_json::json;
-use slog::{warn, Logger};
+use slog::{Logger, warn};
 use std::collections::HashMap;
 use std::time::Duration;
 

graph/src/components/log_store/elasticsearch.rs

@@ -1,6 +1,6 @@
 use async_trait::async_trait;
 use serde::{Deserialize, Serialize};
-use slog::{warn, Logger};
+use slog::{Logger, warn};
 use std::cmp::Reverse;
 use std::collections::BinaryHeap;
 use std::fs::File;
@@ -30,17 +30,17 @@ impl FileLogStore {
         };
 
         // Run cleanup on startup for all existing log files
-        if retention_hours > 0 {
-            if let Ok(entries) = std::fs::read_dir(&store.directory) {
-                for entry in entries.filter_map(Result::ok) {
-                    let path = entry.path();
-
-                    // Only process .jsonl files
-                    if path.extension().and_then(|s| s.to_str()) == Some("jsonl") {
-                        // Run cleanup, but don't fail initialization if cleanup fails
-                        if let Err(e) = store.cleanup_old_logs(&path) {
-                            eprintln!("Warning: Failed to cleanup old logs for {:?}: {}", path, e);
-                        }
+        if retention_hours > 0
+            && let Ok(entries) = std::fs::read_dir(&store.directory)
+        {
+            for entry in entries.filter_map(Result::ok) {
+                let path = entry.path();
+
+                // Only process .jsonl files
+                if path.extension().and_then(|s| s.to_str()) == Some("jsonl") {
+                    // Run cleanup, but don't fail initialization if cleanup fails
+                    if let Err(e) = store.cleanup_old_logs(&path) {
+                        eprintln!("Warning: Failed to cleanup old logs for {:?}: {}", path, e);
                     }
                 }
             }
@@ -98,30 +98,30 @@ impl FileLogStore {
     /// Check if an entry matches the query filters
     fn matches_filters(&self, entry: &LogEntry, query: &LogQuery) -> bool {
         // Level filter
-        if let Some(level) = query.level {
-            if entry.level != level {
-                return false;
-            }
+        if let Some(level) = query.level
+            && entry.level != level
+        {
+            return false;
         }
 
         // Time range filters
-        if let Some(ref from) = query.from {
-            if entry.timestamp < *from {
-                return false;
-            }
+        if let Some(ref from) = query.from
+            && entry.timestamp < *from
+        {
+            return false;
         }
 
-        if let Some(ref to) = query.to {
-            if entry.timestamp > *to {
-                return false;
-            }
+        if let Some(ref to) = query.to
+            && entry.timestamp > *to
+        {
+            return false;
         }
 
         // Text search (case-insensitive)
-        if let Some(ref search) = query.search {
-            if !entry.text.to_lowercase().contains(&search.to_lowercase()) {
-                return false;
-            }
+        if let Some(ref search) = query.search
+            && !entry.text.to_lowercase().contains(&search.to_lowercase())
+        {
+            return false;
         }
 
         true

graph/src/components/log_store/file.rs

@@ -1,7 +1,7 @@
 use async_trait::async_trait;
 use reqwest::Client;
 use serde::Deserialize;
-use slog::{warn, Logger};
+use slog::{Logger, warn};
 use std::collections::HashMap;
 use std::time::Duration;
 
@@ -52,13 +52,11 @@ impl LokiLogStore {
         let selector = format!("{{{}}}", selectors.join(","));
 
         // Add line filter for text search if specified
-        let query_str = if let Some(search) = &query.search {
+        if let Some(search) = &query.search {
             format!("{} |~ \"(?i){}\"", selector, regex::escape(search))
         } else {
             selector
-        };
-
-        query_str
+        }
     }
 
     async fn execute_query(

graph/src/components/log_store/loki.rs

@@ -1,8 +1,8 @@
 use std::collections::HashMap;
 use std::fmt;
 
-use serde::ser::Serializer as SerdeSerializer;
 use serde::Serialize;
+use serde::ser::Serializer as SerdeSerializer;
 use slog::*;
 
 /// Serializer for concatenating key-value arguments into a string

graph/src/log/common.rs

@@ -10,13 +10,12 @@ use prometheus::Counter;
 use reqwest;
 use reqwest::Client;
 use serde::Serialize;
-use serde::ser::Serializer as SerdeSerializer;
 use serde_json::json;
 use slog::*;
 
 use crate::util::futures::retry;
 
-use super::common::{create_async_logger, LogEntryBuilder, LogMeta};
+use super::common::{LogEntryBuilder, LogMeta, create_async_logger};
 
 /// General configuration parameters for Elasticsearch logging.
 #[derive(Clone, Debug)]

graph/src/log/elastic.rs

@@ -8,8 +8,8 @@ use crate::components::log_store::LogStoreConfig;
 use crate::components::metrics::MetricsRegistry;
 use crate::components::store::DeploymentLocator;
 use crate::log::elastic::*;
-use crate::log::file::{file_logger, FileDrainConfig};
-use crate::log::loki::{loki_logger, LokiDrainConfig};
+use crate::log::file::{FileDrainConfig, file_logger};
+use crate::log::loki::{LokiDrainConfig, loki_logger};
 use crate::log::split::*;
 use crate::prelude::ENV_VARS;
 

graph/src/log/factory.rs

@@ -7,7 +7,7 @@ use chrono::prelude::{SecondsFormat, Utc};
 use serde::Serialize;
 use slog::*;
 
-use super::common::{create_async_logger, LogEntryBuilder, LogMeta};
+use super::common::{LogEntryBuilder, LogMeta, create_async_logger};
 
 /// Configuration for `FileDrain`.
 #[derive(Clone, Debug)]

graph/src/log/file.rs

@@ -8,7 +8,7 @@ use serde::Serialize;
 use serde_json::json;
 use slog::*;
 
-use super::common::{create_async_logger, LogEntryBuilder, LogMeta};
+use super::common::{LogEntryBuilder, LogMeta, create_async_logger};
 
 /// Configuration for `LokiDrain`.
 #[derive(Clone, Debug)]

graph/src/log/loki.rs

@@ -351,7 +351,7 @@ pub(crate) async fn execute_root_selection_set_uncached(
             _ => {
                 return Err(vec![QueryExecutionError::AbstractTypeError(
                     "_Log_ is not an object type".to_string(),
-                )])
+                )]);
             }
         };