style: reformat code with cargo fmt

Author: MinecraftFuns

src/analytics/aggregator.rs

@@ -158,7 +158,11 @@ impl AnalyticsAggregator {
     pub fn record_event(&self, event: AnalyticsEvent) {
         // Send to actor channel (lock-free, non-blocking)
         // If channel is full, log warning and drop event
-        if self.actor_tx.try_send(ActorMessage::RecordEvent(event)).is_err() {
+        if self
+            .actor_tx
+            .try_send(ActorMessage::RecordEvent(event))
+            .is_err()
+        {
             warn!("Analytics event buffer full, dropping event");
         }
     }

src/analytics/ip_extractor.rs

@@ -137,13 +137,14 @@ fn apply_trust_chain_validation(ips: &[IpAddr], config: &AnalyticsConfig) -> Opt
         let trusted_ranges: Vec<IpNet> = config
             .trusted_proxies
             .iter()
-            .filter_map(|cidr_str| {
-                match IpNet::from_str(cidr_str) {
-                    Ok(net) => Some(net),
-                    Err(e) => {
-                        warn!("Invalid CIDR range '{}' in trusted_proxies: {}", cidr_str, e);
-                        None
-                    }
+            .filter_map(|cidr_str| match IpNet::from_str(cidr_str) {
+                Ok(net) => Some(net),
+                Err(e) => {
+                    warn!(
+                        "Invalid CIDR range '{}' in trusted_proxies: {}",
+                        cidr_str, e
+                    );
+                    None
                 }
             })
             .collect();

src/main.rs

@@ -126,7 +126,7 @@ enum UserCommands {
 #[derive(Subcommand)]
 enum AnalyticsCommands {
     /// Prune old analytics data by aggregating and dropping dimensions
-    /// 
+    ///
     /// Note: time_bucket is always set to the cutoff_time (start of the hour) for pruned entries.
     /// This ensures aggregated data is not immediately deleted and simplifies retention logic.
     Prune {

src/storage/sqlite.rs

@@ -1991,19 +1991,22 @@ mod tests {
         storage.upsert_analytics_batch(records).await.unwrap();
 
         // Prune (time_bucket is always set to cutoff_time now)
-        let (deleted, inserted) = storage
-            .prune_analytics(30, &[])
-            .await
-            .unwrap();
+        let (deleted, inserted) = storage.prune_analytics(30, &[]).await.unwrap();
 
         assert_eq!(deleted, 3, "Should have deleted 3 old entries");
-        assert_eq!(inserted, 1, "Should have created 1 aggregated entry with all data");
-        
+        assert_eq!(
+            inserted, 1,
+            "Should have created 1 aggregated entry with all data"
+        );
+
         // Verify the aggregated entry has time_bucket set to cutoff_time
-        let analytics = storage.get_analytics("test", None, None, 100).await.unwrap();
+        let analytics = storage
+            .get_analytics("test", None, None, 100)
+            .await
+            .unwrap();
         assert_eq!(analytics.len(), 1);
         assert_eq!(analytics[0].visit_count, 10); // 5 + 3 + 2
-        
+
         // The time_bucket should be at the cutoff_time (rounded to hour start)
         let raw_cutoff = chrono::Utc::now().timestamp() - (30 * 86400);
         let expected_cutoff = (raw_cutoff / 3600) * 3600;

tests/analytics_stress_test.rs

@@ -20,9 +20,9 @@ async fn create_test_storage() -> Arc<dyn Storage> {
 async fn test_concurrent_event_recording() {
     // Test that concurrent event recording doesn't lose data
     let agg = Arc::new(AnalyticsAggregator::new());
-    
+
     let mut handles = vec![];
-    
+
     // Spawn 10 concurrent tasks that each record 100 events
     for task_id in 0..10 {
         let agg_clone = Arc::clone(&agg);
@@ -38,15 +38,15 @@ async fn test_concurrent_event_recording() {
         });
         handles.push(handle);
     }
-    
+
     // Wait for all tasks to complete
     for handle in handles {
         handle.await.unwrap();
     }
-    
+
     // Wait a bit for events to be processed
     sleep(Duration::from_millis(500)).await;
-    
+
     // Drain events and verify count
     let events = agg.drain_events();
     assert_eq!(events.len(), 1000, "Should have all 1000 events");
@@ -57,7 +57,7 @@ async fn test_rapid_flush_cycles() {
     // Test that rapid flush cycles don't corrupt data
     let storage = create_test_storage().await;
     let agg = Arc::new(AnalyticsAggregator::new());
-    
+
     // Record initial data
     for i in 0..100 {
         let rec = AnalyticsRecord {
@@ -76,7 +76,7 @@ async fn test_rapid_flush_cycles() {
         };
         agg.record(rec);
     }
-    
+
     // Perform rapid flushes
     for _ in 0..10 {
         let entries = agg.drain();
@@ -95,11 +95,11 @@ async fn test_rapid_flush_cycles() {
                 )
             })
             .collect();
-        
+
         if !records.is_empty() {
             storage.upsert_analytics_batch(records).await.unwrap();
         }
-        
+
         // Record more data between flushes
         for i in 0..10 {
             let rec = AnalyticsRecord {
@@ -119,7 +119,7 @@ async fn test_rapid_flush_cycles() {
             agg.record(rec);
         }
     }
-    
+
     // Final flush
     let entries = agg.drain();
     if !entries.is_empty() {
@@ -140,48 +140,51 @@ async fn test_rapid_flush_cycles() {
             .collect();
         storage.upsert_analytics_batch(records).await.unwrap();
     }
-    
+
     // Verify all data was saved
     let analytics = storage
         .get_analytics("rapid", None, None, 1000)
         .await
         .unwrap();
-    
+
     let total: i64 = analytics.iter().map(|a| a.visit_count).sum();
-    assert_eq!(total, 200, "Should have all 200 visits (100 initial + 100 incremental)");
+    assert_eq!(
+        total, 200,
+        "Should have all 200 visits (100 initial + 100 incremental)"
+    );
 }
 
 #[tokio::test]
 async fn test_prune_preserves_data_consistency() {
     // Test that pruning maintains data consistency and doesn't lose visit counts
     let storage = create_test_storage().await;
-    
+
     // Create a short code
     storage
         .create_with_code("prune_test", "https://example.com", Some("user1"))
         .await
         .unwrap();
-    
+
     // Insert old data with various dimensions
     let old_time = chrono::Utc::now().timestamp() - (60 * 86400); // 60 days ago
     let mut records = vec![];
-    
+
     // Create 100 entries with different dimensions
     for i in 0..100 {
         records.push((
             "prune_test".to_string(),
-            old_time + (i * 3600), // Different hours
-            Some(format!("C{}", i % 5)),  // 5 different countries
-            Some(format!("R{}", i % 10)), // 10 different regions
+            old_time + (i * 3600),           // Different hours
+            Some(format!("C{}", i % 5)),     // 5 different countries
+            Some(format!("R{}", i % 10)),    // 10 different regions
             Some(format!("City{}", i % 20)), // 20 different cities
-            Some(15169 + (i % 3)), // 3 different ASNs
+            Some(15169 + (i % 3)),           // 3 different ASNs
             4,
             1,
         ));
     }
-    
+
     storage.upsert_analytics_batch(records).await.unwrap();
-    
+
     // Verify we have 100 entries
     let before_prune = storage
         .get_analytics("prune_test", None, None, 200)
@@ -190,24 +193,24 @@ async fn test_prune_preserves_data_consistency() {
     assert_eq!(before_prune.len(), 100);
     let total_before: i64 = before_prune.iter().map(|a| a.visit_count).sum();
     assert_eq!(total_before, 100);
-    
+
     // Prune with dropping city and region
     let (deleted, inserted) = storage
         .prune_analytics(30, &["city".to_string(), "region".to_string()])
         .await
         .unwrap();
-    
+
     assert_eq!(deleted, 100, "Should have deleted all old entries");
     assert!(inserted > 0, "Should have created aggregated entries");
-    
+
     // Verify all visits are preserved
     let after_prune = storage
         .get_analytics("prune_test", None, None, 200)
         .await
         .unwrap();
     let total_after: i64 = after_prune.iter().map(|a| a.visit_count).sum();
     assert_eq!(total_after, 100, "Total visit count should be preserved");
-    
+
     // Verify dimensions were dropped
     let has_dropped_city = after_prune
         .iter()
@@ -219,14 +222,14 @@ async fn test_prune_preserves_data_consistency() {
 async fn test_aggregation_consistency_with_multiple_upserts() {
     // Test that multiple upserts maintain consistency
     let storage = create_test_storage().await;
-    
+
     storage
         .create_with_code("multi_upsert", "https://example.com", Some("user1"))
         .await
         .unwrap();
-    
+
     let time_bucket = 1698768000;
-    
+
     // First batch
     let records1 = vec![(
         "multi_upsert".to_string(),
@@ -239,7 +242,7 @@ async fn test_aggregation_consistency_with_multiple_upserts() {
         10,
     )];
     storage.upsert_analytics_batch(records1).await.unwrap();
-    
+
     // Second batch (same key, should increment)
     let records2 = vec![(
         "multi_upsert".to_string(),
@@ -252,7 +255,7 @@ async fn test_aggregation_consistency_with_multiple_upserts() {
         5,
     )];
     storage.upsert_analytics_batch(records2).await.unwrap();
-    
+
     // Third batch (same key, should increment again)
     let records3 = vec![(
         "multi_upsert".to_string(),
@@ -265,13 +268,13 @@ async fn test_aggregation_consistency_with_multiple_upserts() {
         3,
     )];
     storage.upsert_analytics_batch(records3).await.unwrap();
-    
+
     // Verify total is correct
     let analytics = storage
         .get_analytics("multi_upsert", None, None, 100)
         .await
         .unwrap();
-    
+
     assert_eq!(analytics.len(), 1, "Should have exactly one entry");
     assert_eq!(analytics[0].visit_count, 18, "Should have 10+5+3=18 visits");
 }
@@ -280,12 +283,12 @@ async fn test_aggregation_consistency_with_multiple_upserts() {
 async fn test_time_range_filtering_edge_cases() {
     // Test edge cases in time range filtering
     let storage = create_test_storage().await;
-    
+
     storage
         .create_with_code("time_test", "https://example.com", Some("user1"))
         .await
         .unwrap();
-    
+
     // Insert records at specific timestamps
     let records = vec![
         (
@@ -320,23 +323,23 @@ async fn test_time_range_filtering_edge_cases() {
         ),
     ];
     storage.upsert_analytics_batch(records).await.unwrap();
-    
+
     // Test exact boundary: start_time = 2000
     let result = storage
         .get_analytics("time_test", Some(2000), None, 100)
         .await
         .unwrap();
     let total: i64 = result.iter().map(|a| a.visit_count).sum();
     assert_eq!(total, 5, "Should include entries at and after 2000");
-    
+
     // Test exact boundary: end_time = 2000
     let result = storage
         .get_analytics("time_test", None, Some(2000), 100)
         .await
         .unwrap();
     let total: i64 = result.iter().map(|a| a.visit_count).sum();
     assert_eq!(total, 3, "Should include entries at and before 2000");
-    
+
     // Test exact match
     let result = storage
         .get_analytics("time_test", Some(2000), Some(2000), 100)
@@ -350,12 +353,12 @@ async fn test_time_range_filtering_edge_cases() {
 async fn test_aggregation_with_null_dimensions() {
     // Test that aggregation correctly handles NULL dimensions
     let storage = create_test_storage().await;
-    
+
     storage
         .create_with_code("null_test", "https://example.com", Some("user1"))
         .await
         .unwrap();
-    
+
     let time_bucket = 1698768000;
     let records = vec![
         // Entry with all dimensions
@@ -392,24 +395,27 @@ async fn test_aggregation_with_null_dimensions() {
             2,
         ),
     ];
-    
+
     storage.upsert_analytics_batch(records).await.unwrap();
-    
+
     // Aggregate by country (should combine all)
     let country_agg = storage
         .get_analytics_aggregate("null_test", None, None, "country", 10)
         .await
         .unwrap();
     assert_eq!(country_agg.len(), 1);
     assert_eq!(country_agg[0].visit_count, 10);
-    
+
     // Aggregate by region (should handle NULLs correctly)
     let region_agg = storage
         .get_analytics_aggregate("null_test", None, None, "region", 10)
         .await
         .unwrap();
-    assert!(region_agg.len() >= 2, "Should have at least 2 regions (CA and Unknown)");
-    
+    assert!(
+        region_agg.len() >= 2,
+        "Should have at least 2 regions (CA and Unknown)"
+    );
+
     // Aggregate by ASN (should handle NULLs)
     let asn_agg = storage
         .get_analytics_aggregate("null_test", None, None, "asn", 10)