Hmm

Author: gorbak25

Cargo.lock

@@ -46,7 +46,6 @@ sqlite-pool = { path = "../sqlite-pool" }
 sqlite3-parser = { workspace = true }
 tempfile = { workspace = true }
 thiserror = { workspace = true }
-thread_local = "1.1"
 time = { workspace = true }
 tokio = { workspace = true }
 tokio-util = { workspace = true }

crates/corro-types/Cargo.toml

@@ -14,45 +14,35 @@ use rusqlite::{
 use sqlite_pool::{Committable, SqliteConn};
 use std::rc::Rc;
 use tempfile::TempDir;
-use thread_local::ThreadLocal;
 use tracing::{error, info, trace, warn};
 
 use crate::vtab::unnest::UnnestTab;
 
 pub type SqlitePool = sqlite_pool::Pool<CrConn>;
 pub type SqlitePoolError = sqlite_pool::PoolError;
+use lazy_static::lazy_static;
 
-// Global registry for thread-local query stats
-type QueryStatsMap = Mutex<HashMap<String, u128>>;
-static QUERY_STATS_REGISTRY: Lazy<Arc<ThreadLocal<QueryStatsMap>>> = 
-    Lazy::new(|| Arc::new(ThreadLocal::new()));
-
-pub fn print_aggregated_query_stats() {
-    print_aggregated_stats(&QUERY_STATS_REGISTRY);
+// Global registry for query stats - single shared HashMap
+lazy_static! {
+    static ref QUERY_STATS: Mutex<HashMap<String, u128>> = 
+        Mutex::new(HashMap::new());
 }
-
-fn print_aggregated_stats(registry: &Arc<ThreadLocal<QueryStatsMap>>) {
-    let mut aggregated: HashMap<String, u128> = HashMap::new();
-
-    // Collect and reset stats from all threads
-    for stats in registry.iter() {
-        let mut stats = stats.lock();
-        for (query, total_nanos) in stats.iter() {
-            *aggregated.entry(query.clone()).or_insert(0) += total_nanos;
-        }
-        stats.clear(); // Reset for next interval
-    }
-
-    if !aggregated.is_empty() {
+pub fn print_aggregated_query_stats() {
+    let mut stats = QUERY_STATS.lock();
+    
+    if !stats.is_empty() {
         info!("=== Query Statistics (last 10s) ===");
-        let mut sorted: Vec<_> = aggregated.iter().collect();
+        let mut sorted: Vec<_> = stats.iter().collect();
         sorted.sort_by(|a, b| b.1.cmp(a.1)); // Sort by total time descending
 
         for (query, total_nanos) in sorted.iter().take(10) {
             let total_ms = *total_nanos / 1_000_000;
             info!("  {total_ms}ms total: {query}");
         }
         info!("===================================");
+        
+        // Clear stats for next interval
+        stats.clear();
     }
 }
 
@@ -115,10 +105,10 @@ pub fn rusqlite_to_crsqlite(mut conn: rusqlite::Connection) -> rusqlite::Result<
             let dur = duration.as_nanos();
             let sql = stmt_ref.sql().to_string();
 
-            // Get or create thread-local stats
-            let stats = QUERY_STATS_REGISTRY.get_or(|| Mutex::new(HashMap::new()));
-            let mut stats = stats.lock();
+            // Update shared stats
+            let mut stats = QUERY_STATS.lock();
             *stats.entry(sql.clone()).or_insert(0) += dur;
+            drop(stats); // Release lock quickly
 
             if duration >= SLOW_THRESHOLD {
                 warn!("SLOW query {duration:?} => {}", sql);

crates/corro-types/src/sqlite.rs

@@ -1,22 +1,21 @@
 [db]
-path = "/var/lib/corrosion/state.db"
-schema_paths = ["/etc/corrosion/schemas"]
-    
+path = "/tmp/corrosion.db"
+schema_paths = ["/tmp/schema"]
+
 [gossip]
-# addr and bootstrap for Fly.io deployment example are written 
-# on startup by entrypoint script
-plaintext = true   # Cryptography and authz are handled by Fly.io private networking
-max_mtu = 1372     # For Fly.io private network
-disable_gso = true # For Fly.io private network
+addr = "[::]:8787"
+bootstrap = []
+plaintext = true
 
 [api]
-addr = "[::]:8080" # Must be available on IPv6 for Fly.io private network
+addr = "127.0.0.1:8080"
 
 [admin]
-path = "/app/admin.sock"
+path = "/tmp/corrosion-admin.sock"
 
 [telemetry]
-prometheus.addr = "0.0.0.0:9090"
+prometheus.addr = "127.0.0.1:9090"
 
 [log]
-colors = false
+format = "json"
+