Merge pull request #20 from AstroHQ/jfro/eng-5091

jfro · web-flow · commit af392df7f2d9 · 2026-04-02T16:30:51.000-04:00
fix: upgrade to Rust 2024 edition (ENG-5091)
diff --git a/Cargo.toml b/Cargo.toml
@@ -1,11 +1,12 @@
 [package]
 name = "metrics-sqlite"
-version = "0.5.3"
+version = "0.6.0"
 authors = ["Jeremy Knope <jeremy@astropad.com>"]
 description = "Library for providing SQLite backend for metrics"
 keywords = ["metrics", "sqlite"]
 categories = ["development-tools::debugging"]
-edition = "2018"
+edition = "2024"
+rust-version = "1.85"
 license = "MIT OR Apache-2.0"
 readme = "README.md"
 documentation = "https://docs.rs/metrics-sqlite"
diff --git a/examples/import_csv.rs b/examples/import_csv.rs
@@ -1,5 +1,5 @@
 use metrics_sqlite::MetricsDb;
-use tracing_subscriber::{fmt, layer::SubscriberExt, util::SubscriberInitExt, EnvFilter};
+use tracing_subscriber::{EnvFilter, fmt, layer::SubscriberExt, util::SubscriberInitExt};
 
 fn main() {
     let fmt_layer = fmt::layer();
diff --git a/examples/large-file.rs b/examples/large-file.rs
@@ -2,7 +2,7 @@ use metrics::{counter, gauge};
 use metrics_sqlite::SqliteExporter;
 use std::time::Duration;
 use tracing_subscriber::prelude::*;
-use tracing_subscriber::{fmt, EnvFilter};
+use tracing_subscriber::{EnvFilter, fmt};
 
 fn setup_metrics() {
     let exporter = SqliteExporter::new(
diff --git a/examples/simple.rs b/examples/simple.rs
@@ -1,7 +1,7 @@
 use metrics::{counter, gauge};
 use metrics_sqlite::SqliteExporter;
 use std::time::Duration;
-use tracing_subscriber::{fmt, layer::SubscriberExt, util::SubscriberInitExt, EnvFilter};
+use tracing_subscriber::{EnvFilter, fmt, layer::SubscriberExt, util::SubscriberInitExt};
 
 fn setup_metrics() {
     let exporter = SqliteExporter::new(
diff --git a/examples/summary.rs b/examples/summary.rs
@@ -3,7 +3,7 @@ use std::time::Duration;
 use chrono::{DateTime, Local, TimeZone};
 use clap::Parser;
 use metrics_sqlite::MetricsDb;
-use tracing_subscriber::{fmt, layer::SubscriberExt, util::SubscriberInitExt, EnvFilter};
+use tracing_subscriber::{EnvFilter, fmt, layer::SubscriberExt, util::SubscriberInitExt};
 
 #[derive(Parser)]
 struct Args {
diff --git a/src/lib.rs b/src/lib.rs
@@ -352,18 +352,20 @@ fn run_worker(
                 // Check if we need to flush based on elapsed time
                 let time_based_flush = state.last_flush.elapsed() >= flush_duration;
 
-                let (should_flush, should_exit) = match receiver.recv_timeout(flush_duration) {
+                let mut should_flush = false;
+                let mut should_exit = false;
+                match receiver.recv_timeout(flush_duration) {
                     Ok(Event::Stop) => {
                         info!("Stopping SQLiteExporter worker, flushing & exiting");
-                        (true, true)
+                        should_flush = true;
+                        should_exit = true;
                     }
                     Ok(Event::SetHousekeeping {
                         retention_period,
                         housekeeping_period,
                         record_limit,
                     }) => {
                         state.set_housekeeping(retention_period, housekeeping_period, record_limit);
-                        (false, false)
                     }
                     Ok(Event::DescribeKey(_key_type, key, unit, desc)) => {
                         info!("Describing key {:?}", key);
@@ -375,11 +377,9 @@ fn run_worker(
                         ) {
                             error!("Failed to create key entry: {:?}", e);
                         }
-                        (false, false)
                     }
                     Ok(Event::RegisterKey(_key_type, _key, _handle)) => {
                         // we currently don't do anything with register...
-                        (false, false)
                     }
                     Ok(Event::IncrementCounter(timestamp, key, value)) => {
                         let key_name = key.name();
@@ -391,16 +391,15 @@ fn run_worker(
                         if let Err(e) = state.queue_metric(timestamp, key_name, value as _) {
                             error!("Error queueing metric: {:?}", e);
                         }
-
-                        (state.should_flush(), false)
+                        should_flush = state.should_flush();
                     }
                     Ok(Event::AbsoluteCounter(timestamp, key, value)) => {
                         let key_name = key.name();
                         state.counters.insert(key.clone(), value);
                         if let Err(e) = state.queue_metric(timestamp, key_name, value as _) {
                             error!("Error queueing metric: {:?}", e);
                         }
-                        (state.should_flush(), false)
+                        should_flush = state.should_flush();
                     }
                     Ok(Event::UpdateGauge(timestamp, key, value)) => {
                         let key_name = key.name();
@@ -422,15 +421,14 @@ fn run_worker(
                         if let Err(e) = state.queue_metric(timestamp, key_name, value) {
                             error!("Error queueing metric: {:?}", e);
                         }
-                        (state.should_flush(), false)
+                        should_flush = state.should_flush();
                     }
                     Ok(Event::UpdateHistogram(timestamp, key, value)) => {
                         let key_name = key.name();
                         if let Err(e) = state.queue_metric(timestamp, key_name, value) {
                             error!("Error queueing metric: {:?}", e);
                         }
-
-                        (state.should_flush(), false)
+                        should_flush = state.should_flush();
                     }
                     Ok(Event::RequestSummaryFromSignpost {
                         signpost_key,
@@ -468,16 +466,16 @@ fn run_worker(
                                 }
                             }
                         }
-                        (false, false)
                     }
                     Err(RecvTimeoutError::Timeout) => {
-                        (true, false)
+                        should_flush = true;
                     }
                     Err(RecvTimeoutError::Disconnected) => {
                         warn!("SQLiteExporter channel disconnected, exiting worker");
-                        (true, true)
+                        should_flush = true;
+                        should_exit = true;
                     }
-                };
+                }
 
                 // Flush if time-based flush is triggered OR if event-based flush is triggered
                 if time_based_flush || should_flush {
@@ -587,11 +585,11 @@ impl SqliteExporter {
                         let excess = records - record_limit + (record_limit / 4); // delete excess + 25% of limit
                         trace!(
                             "Exceeded limit! {} > {}, deleting {} oldest",
-                            records,
-                            record_limit,
-                            excess
+                            records, record_limit, excess
+                        );
+                        let query = format!(
+                            "DELETE FROM metrics WHERE id IN (SELECT id FROM metrics ORDER BY timestamp ASC LIMIT {excess});"
                         );
-                        let query = format!("DELETE FROM metrics WHERE id IN (SELECT id FROM metrics ORDER BY timestamp ASC LIMIT {excess});");
                         if let Err(e) = sql_query(query).execute(db) {
                             error!("Failed to delete excessive records: {:?}", e);
                         }
diff --git a/src/metrics_db.rs b/src/metrics_db.rs
@@ -1,7 +1,8 @@
 //! Metrics DB, to use/query/etc metrics SQLite databases
 use super::{
+    MetricsError, Result,
     models::{Metric, MetricKey},
-    setup_db, MetricsError, Result,
+    setup_db,
 };
 use diesel::prelude::*;
 #[cfg(feature = "import_csv")]
@@ -205,7 +206,7 @@ impl MetricsDb {
                     error!("Skipping record due to error reading CSV record: {:?}", e);
                 }
             }
-            if flush_counter.is_multiple_of(200) {
+            if flush_counter % 200 == 0 {
                 trace!("Flushing");
                 inner.flush()?;
             }
diff --git a/src/recorder.rs b/src/recorder.rs
@@ -4,7 +4,7 @@ use metrics::{
     Recorder, SharedString, Unit,
 };
 use std::{
-    sync::{mpsc::SyncSender, Arc},
+    sync::{Arc, mpsc::SyncSender},
     time::SystemTime,
 };
 use tracing::error;

Original file line number	Diff line number	Diff line change
`@@ -352,18 +352,20 @@ fn run_worker(`
`352`	`352`	`// Check if we need to flush based on elapsed time`
`353`	`353`	`let time_based_flush = state.last_flush.elapsed() >= flush_duration;`
`354`	`354`
`355`		`- let (should_flush, should_exit) = match receiver.recv_timeout(flush_duration) {`
	`355`	`+ let mut should_flush = false;`
	`356`	`+ let mut should_exit = false;`
	`357`	`+ match receiver.recv_timeout(flush_duration) {`
`356`	`358`	`Ok(Event::Stop) => {`
`357`	`359`	`info!("Stopping SQLiteExporter worker, flushing & exiting");`
`358`		`- (true, true)`
	`360`	`+ should_flush = true;`
	`361`	`+ should_exit = true;`
`359`	`362`	`}`
`360`	`363`	`Ok(Event::SetHousekeeping {`
`361`	`364`	`retention_period,`
`362`	`365`	`housekeeping_period,`
`363`	`366`	`record_limit,`
`364`	`367`	`}) => {`
`365`	`368`	`state.set_housekeeping(retention_period, housekeeping_period, record_limit);`
`366`		`- (false, false)`
`367`	`369`	`}`
`368`	`370`	`Ok(Event::DescribeKey(_key_type, key, unit, desc)) => {`
`369`	`371`	`info!("Describing key {:?}", key);`
`@@ -375,11 +377,9 @@ fn run_worker(`
`375`	`377`	`) {`
`376`	`378`	`error!("Failed to create key entry: {:?}", e);`
`377`	`379`	`}`
`378`		`- (false, false)`
`379`	`380`	`}`
`380`	`381`	`Ok(Event::RegisterKey(_key_type, _key, _handle)) => {`
`381`	`382`	`// we currently don't do anything with register...`
`382`		`- (false, false)`
`383`	`383`	`}`
`384`	`384`	`Ok(Event::IncrementCounter(timestamp, key, value)) => {`
`385`	`385`	`let key_name = key.name();`
`@@ -391,16 +391,15 @@ fn run_worker(`
`391`	`391`	`if let Err(e) = state.queue_metric(timestamp, key_name, value as _) {`
`392`	`392`	`error!("Error queueing metric: {:?}", e);`
`393`	`393`	`}`
`394`		`-`
`395`		`- (state.should_flush(), false)`
	`394`	`+ should_flush = state.should_flush();`
`396`	`395`	`}`
`397`	`396`	`Ok(Event::AbsoluteCounter(timestamp, key, value)) => {`
`398`	`397`	`let key_name = key.name();`
`399`	`398`	`state.counters.insert(key.clone(), value);`
`400`	`399`	`if let Err(e) = state.queue_metric(timestamp, key_name, value as _) {`
`401`	`400`	`error!("Error queueing metric: {:?}", e);`
`402`	`401`	`}`
`403`		`- (state.should_flush(), false)`
	`402`	`+ should_flush = state.should_flush();`
`404`	`403`	`}`
`405`	`404`	`Ok(Event::UpdateGauge(timestamp, key, value)) => {`
`406`	`405`	`let key_name = key.name();`
`@@ -422,15 +421,14 @@ fn run_worker(`
`422`	`421`	`if let Err(e) = state.queue_metric(timestamp, key_name, value) {`
`423`	`422`	`error!("Error queueing metric: {:?}", e);`
`424`	`423`	`}`
`425`		`- (state.should_flush(), false)`
	`424`	`+ should_flush = state.should_flush();`
`426`	`425`	`}`
`427`	`426`	`Ok(Event::UpdateHistogram(timestamp, key, value)) => {`
`428`	`427`	`let key_name = key.name();`
`429`	`428`	`if let Err(e) = state.queue_metric(timestamp, key_name, value) {`
`430`	`429`	`error!("Error queueing metric: {:?}", e);`
`431`	`430`	`}`
`432`		`-`
`433`		`- (state.should_flush(), false)`
	`431`	`+ should_flush = state.should_flush();`
`434`	`432`	`}`
`435`	`433`	`Ok(Event::RequestSummaryFromSignpost {`
`436`	`434`	`signpost_key,`
`@@ -468,16 +466,16 @@ fn run_worker(`
`468`	`466`	`}`
`469`	`467`	`}`
`470`	`468`	`}`
`471`		`- (false, false)`
`472`	`469`	`}`
`473`	`470`	`Err(RecvTimeoutError::Timeout) => {`
`474`		`- (true, false)`
	`471`	`+ should_flush = true;`
`475`	`472`	`}`
`476`	`473`	`Err(RecvTimeoutError::Disconnected) => {`
`477`	`474`	`warn!("SQLiteExporter channel disconnected, exiting worker");`
`478`		`- (true, true)`
	`475`	`+ should_flush = true;`
	`476`	`+ should_exit = true;`
`479`	`477`	`}`
`480`		`- };`
	`478`	`+ }`
`481`	`479`
`482`	`480`	`// Flush if time-based flush is triggered OR if event-based flush is triggered`
`483`	`481`	`if time_based_flush \|\| should_flush {`
`@@ -587,11 +585,11 @@ impl SqliteExporter {`
`587`	`585`	`let excess = records - record_limit + (record_limit / 4); // delete excess + 25% of limit`
`588`	`586`	`trace!(`
`589`	`587`	`"Exceeded limit! {} > {}, deleting {} oldest",`
`590`		`- records,`
`591`		`- record_limit,`
`592`		`- excess`
	`588`	`+ records, record_limit, excess`
	`589`	`+ );`
	`590`	`+ let query = format!(`
	`591`	`+ "DELETE FROM metrics WHERE id IN (SELECT id FROM metrics ORDER BY timestamp ASC LIMIT {excess});"`
`593`	`592`	`);`
`594`		`- let query = format!("DELETE FROM metrics WHERE id IN (SELECT id FROM metrics ORDER BY timestamp ASC LIMIT {excess});");`
`595`	`593`	`if let Err(e) = sql_query(query).execute(db) {`
`596`	`594`	`error!("Failed to delete excessive records: {:?}", e);`
`597`	`595`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,7 +1,8 @@`
`1`	`1`	`//! Metrics DB, to use/query/etc metrics SQLite databases`
`2`	`2`	`use super::{`
	`3`	`+ MetricsError, Result,`
`3`	`4`	`models::{Metric, MetricKey},`
`4`		`- setup_db, MetricsError, Result,`
	`5`	`+ setup_db,`
`5`	`6`	`};`
`6`	`7`	`use diesel::prelude::*;`
`7`	`8`	`#[cfg(feature = "import_csv")]`
`@@ -205,7 +206,7 @@ impl MetricsDb {`
`205`	`206`	`error!("Skipping record due to error reading CSV record: {:?}", e);`
`206`	`207`	`}`
`207`	`208`	`}`
`208`		`- if flush_counter.is_multiple_of(200) {`
	`209`	`+ if flush_counter % 200 == 0 {`
`209`	`210`	`trace!("Flushing");`
`210`	`211`	`inner.flush()?;`
`211`	`212`	`}`