chore: update deps, switch to upstream duckdb

Signed-off-by: Henry Gressmann <[email protected]>

Author: explodingcamera

Cargo.lock

@@ -18,7 +18,7 @@ path="src/main.rs"
 # async/concurrency
 tokio={version="1.44", default-features=false, features=["macros", "rt-multi-thread", "signal"]}
 tokio-util={version="0.7", features=["io"]}
-futures-lite="2.6"
+futures-lite={version="2.6", default-features=false, features=["alloc"]}
 crossbeam-utils="0.8"
 crossbeam-channel="0.5"
 quick_cache="0.6"
@@ -35,10 +35,10 @@ sha3={version="0.10"}
 argon2={version="0.5"}
 
 # general
-argh={version="0.1"}
+argh={version="0.1", default-features=false, features=["help"]}
 eyre={version="0.6"}
-rand={version="0.9"}
-time={version="0.3"}
+rand={version="0.9", default-features=false, features=["std", "thread_rng"]}
+chrono={version="0.4"}
 colored={version="3.0"}
 figment={version="0.10", features=["toml", "env"]}
 tracing={version="0.1", default-features=false, features=["std"]}
@@ -51,11 +51,10 @@ poem={version="3.1", default-features=false, features=[
     "compression",
     "tower-compat",
 ]}
-poem-openapi={version="5.1", default-features=false, features=["time"]}
+poem-openapi={version="5.1", default-features=false, features=["chrono"]}
 tower={version="0.5", default-features=false, features=["limit"]}
 uaparser="0.6"
-mime_guess={version="2.0"}
-rust-embed={version="8.7"}
+rust-embed={version="8.7", features=["mime-guess"]}
 reqwest={version="0.12", default-features=false, features=[
     "json",
     "stream",
@@ -65,18 +64,13 @@ reqwest={version="0.12", default-features=false, features=[
 rustls={version="0.23", features=["aws_lc_rs"]}
 
 # database
-duckdb={git="https://github.com/explodingcamera-contrib/duckdb-rs", features=[
-    "buildtime_bindgen",
-    "bundled",
-    "time",
-    "r2d2",
-]}
-rusqlite={version="0.35", features=["bundled", "modern_sqlite", "time"]}
-r2d2={version="0.8"}
-r2d2_sqlite="0.28"
+duckdb={version="1.3", features=["buildtime_bindgen", "bundled", "chrono", "r2d2"]}
+rusqlite={version="0.36", features=["bundled", "modern_sqlite", "chrono"]}
+r2d2={version="0.8", default-features=false}
+r2d2_sqlite="0.30"
 refinery={version="0.8", default-features=false}
 refinery-core={version="0.8", default-features=false}
-maxminddb={version="0.26", optional=true}
+maxminddb={version="0.26", optional=true, features=["simdutf8"]}
 ahash="0.8"
 
 [target.'cfg(not(target_env = "msvc"))'.dependencies]

Cargo.toml

@@ -1,9 +1,9 @@
 use std::sync::Arc;
 
+use chrono::{DateTime, Utc};
 use crossbeam_channel::Receiver;
 use crossbeam_utils::sync::ShardedLock;
 use eyre::{Result, bail};
-use time::OffsetDateTime;
 
 use crate::app::models::{Event, event_params};
 use crate::app::{DuckDBPool, EVENT_BATCH_INTERVAL, SqlitePool};
@@ -13,12 +13,12 @@ use crate::utils::hash::generate_salt;
 pub struct LiwanEvents {
     duckdb: DuckDBPool,
     sqlite: SqlitePool,
-    daily_salt: Arc<ShardedLock<(String, OffsetDateTime)>>,
+    daily_salt: Arc<ShardedLock<(String, DateTime<Utc>)>>,
 }
 
 impl LiwanEvents {
     pub fn try_new(duckdb: DuckDBPool, sqlite: SqlitePool) -> Result<Self> {
-        let daily_salt: (String, OffsetDateTime) = {
+        let daily_salt: (String, DateTime<Utc>) = {
             tracing::debug!("Loading daily salt");
             sqlite.get()?.query_row("select salt, updated_at from salts where id = 1", [], |row| {
                 Ok((row.get(0)?, row.get(1)?))
@@ -35,10 +35,10 @@ impl LiwanEvents {
         };
 
         // if the salt is older than 24 hours, replace it with a new one (utils::generate_salt)
-        if (OffsetDateTime::now_utc() - updated_at) > time::Duration::hours(24) {
+        if (Utc::now() - updated_at) > chrono::Duration::hours(24) {
             tracing::debug!("Daily salt expired, generating a new one");
             let new_salt = generate_salt();
-            let now = OffsetDateTime::now_utc();
+            let now = Utc::now();
             let conn = self.sqlite.get()?;
             conn.execute("update salts set salt = ?, updated_at = ? where id = 1", rusqlite::params![&new_salt, now])?;
 
@@ -56,7 +56,7 @@ impl LiwanEvents {
     pub fn append(&self, events: impl Iterator<Item = Event>) -> Result<()> {
         let conn = self.duckdb.get()?;
         let mut appender = conn.appender("events")?;
-        let mut first_event_time = OffsetDateTime::now_utc();
+        let mut first_event_time = Utc::now();
         for event in events {
             appender.append_row(event_params![event])?;
             if first_event_time > event.created_at {
@@ -105,7 +105,7 @@ impl LiwanEvents {
 
 use duckdb::{Connection, Result as DuckResult, params};
 
-pub fn update_event_times(conn: &Connection, from_time: OffsetDateTime) -> DuckResult<()> {
+pub fn update_event_times(conn: &Connection, from_time: DateTime<Utc>) -> DuckResult<()> {
     // this can probably be simplified, sadly the where clause can't contain window functions
     let sql = "--sql
         with

data/licenses-cargo.json

@@ -3,6 +3,7 @@ use std::fmt::{Debug, Display};
 
 use crate::app::DuckDBConn;
 use crate::utils::duckdb::{ParamVec, repeat_vars};
+use chrono::{DateTime, Utc};
 use duckdb::params_from_iter;
 use eyre::{Result, bail};
 use poem_openapi::{Enum, Object};
@@ -11,8 +12,8 @@ pub use super::reports_cached::*;
 
 #[derive(Object, Debug, Clone, Hash, PartialEq, Eq)]
 pub struct DateRange {
-    pub start: time::OffsetDateTime,
-    pub end: time::OffsetDateTime,
+    pub start: DateTime<Utc>,
+    pub end: DateTime<Utc>,
 }
 
 impl DateRange {
@@ -22,10 +23,10 @@ impl DateRange {
     }
 
     pub fn ends_in_future(&self) -> bool {
-        self.end > time::OffsetDateTime::now_utc()
+        self.end > Utc::now()
     }
 
-    pub fn duration(&self) -> time::Duration {
+    pub fn duration(&self) -> chrono::Duration {
         self.end - self.start
     }
 }
@@ -218,7 +219,7 @@ fn metric_sql(metric: Metric) -> String {
     .to_owned()
 }
 
-pub fn earliest_timestamp(conn: &DuckDBConn, entities: &[String]) -> Result<Option<time::OffsetDateTime>> {
+pub fn earliest_timestamp(conn: &DuckDBConn, entities: &[String]) -> Result<Option<DateTime<Utc>>> {
     if entities.is_empty() {
         return Ok(None);
     }
@@ -233,7 +234,7 @@ pub fn earliest_timestamp(conn: &DuckDBConn, entities: &[String]) -> Result<Opti
 
     let mut stmt = conn.prepare_cached(&query)?;
     let rows = stmt.query_map(params_from_iter(entities), |row| row.get(0))?;
-    let earliest_timestamp = rows.collect::<Result<Vec<Option<time::OffsetDateTime>>, duckdb::Error>>()?;
+    let earliest_timestamp = rows.collect::<Result<Vec<Option<DateTime<Utc>>>, duckdb::Error>>()?;
     Ok(earliest_timestamp[0])
 }
 

data/licenses-npm.json

@@ -2,6 +2,7 @@ use super::reports::{DateRange, Dimension, DimensionFilter, Metric, ReportGraph,
 use super::reports::{dimension_report, overall_report, overall_stats};
 
 use crate::{app::DuckDBConn, utils::to_sorted};
+use chrono::{DateTime, Utc};
 use eyre::Result;
 use quick_cache::sync::Cache;
 use std::sync::LazyLock;
@@ -50,13 +51,13 @@ type DimensionCacheKey = (
     Metric,
 );
 
-static OVERALL_REPORT_CACHE: LazyLock<Cache<OverallReportCacheKey, (time::OffsetDateTime, ReportGraph)>> =
+static OVERALL_REPORT_CACHE: LazyLock<Cache<OverallReportCacheKey, (DateTime<Utc>, ReportGraph)>> =
     LazyLock::new(|| Cache::new(1024));
 
-static OVERALL_STATS_CACHE: LazyLock<Cache<OverallStatsCacheKey, (time::OffsetDateTime, ReportStats)>> =
+static OVERALL_STATS_CACHE: LazyLock<Cache<OverallStatsCacheKey, (DateTime<Utc>, ReportStats)>> =
     LazyLock::new(|| Cache::new(1024));
 
-static DIMENSION_CACHE: LazyLock<Cache<DimensionCacheKey, (time::OffsetDateTime, ReportTable)>> =
+static DIMENSION_CACHE: LazyLock<Cache<DimensionCacheKey, (DateTime<Utc>, ReportTable)>> =
     LazyLock::new(|| Cache::new(1024));
 
 /// [super::reports::overall_report] with caching
@@ -121,19 +122,19 @@ pub fn dimension_report_cached(
 }
 
 /// Check if a cache entry should be invalidated
-fn should_invalidate(range: &DateRange, last_update: time::OffsetDateTime) -> bool {
+fn should_invalidate(range: &DateRange, last_update: DateTime<Utc>) -> bool {
     if !range.ends_in_future() {
         return false;
     }
 
-    let now = time::OffsetDateTime::now_utc();
+    let now = Utc::now();
     let diff = now - last_update;
 
-    match range.duration().whole_days() {
-        0..=6 => diff.whole_minutes() >= 1,
-        7..=31 => diff.whole_minutes() > 5,
-        32..=365 => diff.whole_minutes() > 30,
-        _ => diff.whole_hours() > 1,
+    match range.duration().num_days() {
+        0..=6 => diff.num_minutes() >= 1,
+        7..=31 => diff.num_minutes() > 5,
+        32..=365 => diff.num_minutes() > 30,
+        _ => diff.num_hours() > 1,
     }
 }
 
@@ -142,7 +143,7 @@ fn should_invalidate(range: &DateRange, last_update: time::OffsetDateTime) -> bo
 /// Like quick_cache::sync::Cache::get_or_insert_with, but with a timeout for the guard
 /// and invalidation logic to recompute when the data might be stale
 fn get_or_compute<T, K, F>(
-    cache: &LazyLock<Cache<K, (time::OffsetDateTime, T)>>,
+    cache: &LazyLock<Cache<K, (DateTime<Utc>, T)>>,
     cache_key: K,
     compute: F,
     range: &DateRange,
@@ -169,10 +170,10 @@ where
 
     match guard {
         Some(guard) => {
-            let _ = guard.insert((time::OffsetDateTime::now_utc(), result.clone()));
+            let _ = guard.insert((Utc::now(), result.clone()));
         }
         None => {
-            cache.insert(cache_key, (time::OffsetDateTime::now_utc(), result.clone()));
+            cache.insert(cache_key, (Utc::now(), result.clone()));
         }
     }
 

src/app/core/events.rs

@@ -1,7 +1,7 @@
 use crate::app::{SqlitePool, models};
+use chrono::{DateTime, Utc};
 use eyre::Result;
 use rusqlite::params;
-use time::OffsetDateTime;
 
 #[derive(Clone)]
 pub struct LiwanSessions {
@@ -14,7 +14,7 @@ impl LiwanSessions {
     }
 
     /// Create a new session
-    pub fn create(&self, session_id: &str, username: &str, expires_at: OffsetDateTime) -> Result<()> {
+    pub fn create(&self, session_id: &str, username: &str, expires_at: DateTime<Utc>) -> Result<()> {
         let conn = self.pool.get()?;
         let mut stmt = conn.prepare_cached("insert into sessions (id, username, expires_at) values (?, ?, ?)")?;
         stmt.execute(rusqlite::params![session_id, username, expires_at])?;
@@ -38,7 +38,7 @@ impl LiwanSessions {
         "#,
         )?;
 
-        let user = stmt.query_row(params![session_id, time::OffsetDateTime::now_utc()], |row| {
+        let user = stmt.query_row(params![session_id, Utc::now()], |row| {
             Ok(models::User {
                 username: row.get("username")?,
                 role: row.get::<_, String>("role")?.try_into().unwrap_or_default(),
@@ -62,7 +62,7 @@ impl LiwanSessions {
     pub fn delete(&self, session_id: &str) -> Result<()> {
         let conn = self.pool.get()?;
         let mut stmt = conn.prepare_cached("update sessions set expires_at = ? where id = ?")?;
-        stmt.execute(rusqlite::params![OffsetDateTime::now_utc(), session_id])?;
+        stmt.execute(rusqlite::params![Utc::now(), session_id])?;
         Ok(())
     }
 }

src/app/core/reports.rs

@@ -112,8 +112,8 @@ impl Liwan {
 #[cfg(any(debug_assertions, test, feature = "_enable_seeding"))]
 impl Liwan {
     pub fn seed_database(&self, count_per_entity: usize) -> Result<()> {
+        use chrono::{Days, Utc};
         use models::UserRole;
-        use time::OffsetDateTime;
 
         let entities = vec![
             ("entity-1", "Entity 1", "example.com", vec!["public-project".to_string(), "private-project".to_string()]),
@@ -139,8 +139,8 @@ impl Liwan {
             )?;
         }
 
-        let start = OffsetDateTime::now_utc().checked_sub(time::Duration::days(365)).unwrap();
-        let end = OffsetDateTime::now_utc();
+        let start = Utc::now().checked_sub_days(Days::new(365)).unwrap();
+        let end = Utc::now();
         for (entity_id, display_name, fqdn, project_ids) in entities {
             self.entities.create(
                 &models::Entity { id: entity_id.to_string(), display_name: display_name.to_string() },

src/app/core/reports_cached.rs

@@ -3,7 +3,7 @@ pub struct Event {
     pub entity_id: String,
     pub visitor_id: String,
     pub event: String,
-    pub created_at: OffsetDateTime,
+    pub created_at: DateTime<Utc>,
     pub fqdn: Option<String>,
     pub path: Option<String>,
     pub referrer: Option<String>,
@@ -99,7 +99,7 @@ macro_rules! event_params {
     };
 }
 
+use chrono::{DateTime, Utc};
 pub use event_params;
 use poem_openapi::Enum;
 use serde::{Deserialize, Serialize};
-use time::OffsetDateTime;