From 4f9e237802ad744dd03350835543f70b3a228113 Mon Sep 17 00:00:00 2001 From: Antoine Pultier <45740+fungiboletus@users.noreply.github.com> Date: Tue, 26 Aug 2025 10:43:09 +0200 Subject: [PATCH 01/39] =?UTF-8?q?feat:=20=F0=9F=8C=88=20rrdcached=20work?= =?UTF-8?q?=20in=20progress?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- Cargo.lock | 8 +- Cargo.toml | 2 +- Makefile.toml | 3 +- docs/RRDCACHED.md | 143 +++++++++ src/storage/rrdcached/mod.rs | 285 +++++++++++++++-- tests/common/mod.rs | 7 + tests/rrdcached_integration.rs | 570 +++++++++++++++++++++++++++++++++ 7 files changed, 994 insertions(+), 24 deletions(-) create mode 100644 docs/RRDCACHED.md create mode 100644 tests/rrdcached_integration.rs diff --git a/Cargo.lock b/Cargo.lock index d56aa4b..a4e25c3 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -4979,12 +4979,12 @@ dependencies = [ [[package]] name = "rrdcached-client" -version = "0.1.3" +version = "0.1.5" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f8320934d3dc3e2f1d236912fe45a381cad9648d21f3975181393ffe8f2eac4b" +checksum = "57dfd6f5a3094934b1f0813199b7571be5bde0bcc985005fe5a3c3d6a738d4cd" dependencies = [ - "nom 7.1.3", - "thiserror 1.0.69", + "nom 8.0.0", + "thiserror 2.0.15", "tokio", ] diff --git a/Cargo.toml b/Cargo.toml index d39cf2b..889e603 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -110,7 +110,7 @@ big-decimal-byte-string-encoder = { version = "0.1", optional = true } clru = "0.6" utoipa = { version = "5.4", features = ["axum_extras"] } utoipa-scalar = { version = "0.3", features = ["axum"] } -rrdcached-client = { version = "0.1", optional = true } +rrdcached-client = { version = "0.1.5", optional = true } clickhouse = { version = "0.13", features = ["lz4", "uuid", "time"], optional = true } rustls = "0.23" diff --git a/Makefile.toml b/Makefile.toml index 3db1279..d25f185 100644 --- a/Makefile.toml +++ b/Makefile.toml @@ -20,6 +20,7 @@ DATABASE_URL = { value = "postgres://${POSTGRES_USER}:${POSTGRES_PASSWORD}@${POS TEST_DATABASE_URL_POSTGRES = { value = "${DATABASE_URL}", condition = { env_not_set = ["TEST_DATABASE_URL_POSTGRES"] } } TEST_DATABASE_URL_SQLITE = { value = "sqlite://test.db", condition = { env_not_set = ["TEST_DATABASE_URL_SQLITE"] } } TEST_DATABASE_URL_CLICKHOUSE = { value = "clickhouse://default:password@localhost:8123/sensapp_test", condition = { env_not_set = ["TEST_DATABASE_URL_CLICKHOUSE"] } } +TEST_DATABASE_URL_RRDCACHED = { value = "rrdcached://127.0.0.1:42217?preset=hoarder", condition = { env_not_set = ["TEST_DATABASE_URL_RRDCACHED"] } } # Environment profiles [env.ci] @@ -319,7 +320,7 @@ env = { "CARGO_MAKE_TASK_FEATURE" = "rrdcached" } extend = "template-test" private = false description = "Test with RRDCached feature" -env = { "CARGO_MAKE_TASK_FEATURE" = "rrdcached" } +env = { "CARGO_MAKE_TASK_FEATURE" = "rrdcached", "TEST_DATABASE_URL" = "${TEST_DATABASE_URL_RRDCACHED}" } [tasks.clippy-rrdcached] extend = "template-clippy" diff --git a/docs/RRDCACHED.md b/docs/RRDCACHED.md new file mode 100644 index 0000000..a112f81 --- /dev/null +++ b/docs/RRDCACHED.md @@ -0,0 +1,143 @@ +# RRDCached Storage Backend + +## Overview + +RRDCached is an experimental storage backend for SensApp that uses [RRDtool's](https://oss.oetiker.ch/rrdtool/) caching daemon for time-series data storage. RRDtool is a mature, high-performance system originally designed for network monitoring that excels at storing and graphing time-series data with fixed-size storage requirements. + +## How it Works + +SensApp integrates with RRDCached through a TCP connection, allowing it to: +- Create Round Robin Database (RRD) files for each sensor +- Publish numeric sensor data points +- Query historical data using RRD's consolidation functions +- List available sensors based on RRD files + +### Connection String + +``` +rrdcached://host:port?preset= +``` + +Example: +``` +rrdcached://127.0.0.1:42217?preset=hoarder +``` + +### Available Presets + +- **munin**: Traditional Munin-style data retention (5-minute resolution) +- **hoarder**: High-resolution data retention for detailed analysis + +## Configuration + +To use RRDCached as a storage backend: + +1. Start an RRDCached daemon: +```bash +rrdcached -l 127.0.0.1:42217 -b /var/lib/rrdcached/db -j /var/lib/rrdcached/journal +``` + +2. Configure SensApp with the RRDCached connection string in `settings.toml`: +```toml +[database] +connection_string = "rrdcached://127.0.0.1:42217?preset=hoarder" +``` + +## Current Implementation Status + +### Supported Features + +✅ **Publishing numeric data** - Integer and Float sensor values +✅ **Creating RRD files** - Automatic RRD creation with configurable presets +✅ **Querying sensor data** - Fetch historical data with time ranges +✅ **Listing sensors** - Basic sensor enumeration based on RRD files + +### Limitations + +The RRDCached backend has significant limitations due to the fundamental design of RRDtool: + +#### Metadata Storage +RRDtool only stores numeric time-series data. It cannot store: +- **Sensor names** - Only UUIDs are used as RRD filenames +- **Sensor types** - All data is treated as numeric (Float) +- **Units** - No unit information is preserved +- **Labels/Tags** - Not supported by RRD format +- **Non-numeric types** - String, Boolean, Location, and JSON types cannot be stored + +#### Feature Limitations +- **Arrow format export/import** - Not supported due to missing metadata +- **Sensor search by name** - Names are not stored, only UUIDs +- **Type preservation** - Integer values become Floats in RRD +- **Round-trip data integrity** - Original sensor metadata cannot be reconstructed + +#### Query Limitations +- **Recent data** - RRD consolidation may return NaN for very recent data points +- **Exact timestamps** - RRD uses fixed time intervals, timestamps are rounded +- **Raw data access** - Only consolidated data is available after initial retention period + +## Testing + +Integration tests are available but **not enabled by default** due to the limitations described above. To run RRDCached-specific tests: + +```bash +# Ensure RRDCached is running on port 42217 +TEST_DATABASE_URL="rrdcached://127.0.0.1:42217?preset=hoarder" \ + cargo test --no-default-features --features rrdcached --test rrdcached_integration +``` + +Note: Generic storage tests that depend on full metadata support will fail. This includes: +- Arrow format import/export tests +- Tests requiring sensor name lookups +- Tests using non-numeric data types +- Round-trip data integrity tests + +## Use Cases + +RRDCached is suitable for: +- **Fixed-size storage** - RRD files don't grow over time +- **Network monitoring** - Traditional RRDtool use case +- **Simple numeric metrics** - Temperature, CPU usage, network traffic +- **Long-term trending** - Automatic data consolidation over time + +RRDCached is **not** suitable for: +- **Rich sensor metadata** - When names, units, or labels are important +- **Non-numeric data** - String, Boolean, or complex data types +- **Data export/interchange** - When Arrow or other formats are needed +- **Exact data retrieval** - When original resolution must be preserved + +## Future Plans + +The RRDCached backend is currently experimental. Future enhancements being considered include: + +- **External metadata store** - SQLite or JSON sidecar for sensor metadata +- **Hybrid storage** - RRD for numeric data, separate store for metadata +- **Improved query support** - Better handling of consolidation functions +- **Grafana integration** - Direct RRD graph generation + +These enhancements would address the current limitations but require significant architectural changes. Implementation timeline is to be determined based on user needs and project priorities. + +## Technical Details + +### RRD File Structure + +Each sensor creates an RRD file named `{uuid}.rrd` with: +- **Data Source (DS)**: Single gauge-type data source named "value" +- **Round Robin Archives (RRA)**: Multiple archives with different resolutions + - Munin preset: 5-minute, 30-minute, 2-hour, daily consolidations + - Hoarder preset: 1-second resolution with longer retention + +### Consolidation Functions + +When querying data, RRDCached uses consolidation functions: +- **AVERAGE**: Mean value over the consolidation period +- **MIN**: Minimum value +- **MAX**: Maximum value +- **LAST**: Most recent value + +### Implementation Notes + +The implementation uses: +- `rrdcached_client` crate for protocol communication +- Async/await pattern with Tokio runtime +- UUID v7 for time-ordered sensor identifiers +- In-memory tracking of created sensors per session \ No newline at end of file diff --git a/src/storage/rrdcached/mod.rs b/src/storage/rrdcached/mod.rs index ea4ad67..a88cd39 100644 --- a/src/storage/rrdcached/mod.rs +++ b/src/storage/rrdcached/mod.rs @@ -4,7 +4,7 @@ use crate::{ datamodel::{Sensor, SensorType, TypedSamples}, storage::{StorageInstance, common::sync_with_timeout}, }; -use anyhow::{Context, Result, anyhow, bail}; +use anyhow::{Context, Result, bail}; use async_trait::async_trait; use rrdcached_client::{ RRDCachedClient, @@ -14,8 +14,9 @@ use rrdcached_client::{ errors::RRDCachedClientError, }; use std::{collections::HashSet, sync::Arc}; +use smallvec::SmallVec; use tokio::sync::RwLock; -use tracing::{debug, error}; +use tracing::error; use url::Url; use uuid::Uuid; @@ -113,13 +114,90 @@ impl std::str::FromStr for Preset { #[derive(Debug)] pub struct RrdCachedStorage { - client: Arc>, - + client: Arc>>, created_sensors: Arc>>, - preset: Preset, } +// Trait to abstract over TCP and Unix socket clients +#[async_trait::async_trait] +trait RRDCachedClientTrait: Send + Sync + std::fmt::Debug { + async fn create(&mut self, args: rrdcached_client::create::CreateArguments) -> Result<(), rrdcached_client::errors::RRDCachedClientError>; + async fn batch(&mut self, batch_updates: Vec) -> Result<(), rrdcached_client::errors::RRDCachedClientError>; + async fn flush_all(&mut self) -> Result<(), rrdcached_client::errors::RRDCachedClientError>; + async fn list(&mut self, recursive: bool, path: Option<&str>) -> Result, rrdcached_client::errors::RRDCachedClientError>; + async fn fetch( + &mut self, + path: &str, + consolidation_function: ConsolidationFunction, + start: Option, + end: Option, + columns: Option>, + ) -> Result; +} + +// Implement the trait for TCP client +#[async_trait::async_trait] +impl RRDCachedClientTrait for RRDCachedClient { + async fn create(&mut self, args: rrdcached_client::create::CreateArguments) -> Result<(), rrdcached_client::errors::RRDCachedClientError> { + RRDCachedClient::create(self, args).await + } + + async fn batch(&mut self, batch_updates: Vec) -> Result<(), rrdcached_client::errors::RRDCachedClientError> { + RRDCachedClient::batch(self, batch_updates).await + } + + async fn flush_all(&mut self) -> Result<(), rrdcached_client::errors::RRDCachedClientError> { + RRDCachedClient::flush_all(self).await + } + + async fn list(&mut self, recursive: bool, path: Option<&str>) -> Result, rrdcached_client::errors::RRDCachedClientError> { + RRDCachedClient::list(self, recursive, path).await + } + + async fn fetch( + &mut self, + path: &str, + consolidation_function: ConsolidationFunction, + start: Option, + end: Option, + columns: Option>, + ) -> Result { + RRDCachedClient::fetch(self, path, consolidation_function, start, end, columns).await + } +} + +// Implement the trait for Unix socket client +#[async_trait::async_trait] +impl RRDCachedClientTrait for RRDCachedClient { + async fn create(&mut self, args: rrdcached_client::create::CreateArguments) -> Result<(), rrdcached_client::errors::RRDCachedClientError> { + RRDCachedClient::create(self, args).await + } + + async fn batch(&mut self, batch_updates: Vec) -> Result<(), rrdcached_client::errors::RRDCachedClientError> { + RRDCachedClient::batch(self, batch_updates).await + } + + async fn flush_all(&mut self) -> Result<(), rrdcached_client::errors::RRDCachedClientError> { + RRDCachedClient::flush_all(self).await + } + + async fn list(&mut self, recursive: bool, path: Option<&str>) -> Result, rrdcached_client::errors::RRDCachedClientError> { + RRDCachedClient::list(self, recursive, path).await + } + + async fn fetch( + &mut self, + path: &str, + consolidation_function: ConsolidationFunction, + start: Option, + end: Option, + columns: Option>, + ) -> Result { + RRDCachedClient::fetch(self, path, consolidation_function, start, end, columns).await + } +} + impl RrdCachedStorage { pub async fn connect(connection_string: &str) -> Result { let url = Url::parse(connection_string)?; @@ -136,25 +214,36 @@ impl RrdCachedStorage { "rrdcached" | "rrdcached+tcp" => { // extract host and port let host = url.host_str().ok_or_else(|| { - anyhow::Error::from(StorageError::configuration( - "RRDCached connection URL missing host", + anyhow::Error::from(StorageError::Configuration( + "RRDCached connection URL missing host".to_string(), )) })?; let port = url.port().ok_or_else(|| { - anyhow::Error::from(StorageError::configuration( - "RRDCached connection URL missing port", + anyhow::Error::from(StorageError::Configuration( + "RRDCached connection URL missing port".to_string(), )) })?; let client = RRDCachedClient::connect_tcp(&format!("{}:{}", host, port)).await?; Ok(Self { - client: Arc::new(RwLock::new(client)), + client: Arc::new(RwLock::new(Box::new(client))), created_sensors: Arc::new(RwLock::new(HashSet::new())), preset, }) } "rrdcached+unix" => { - unimplemented!() + // Extract Unix socket path from the URL + let socket_path = url.path(); + if socket_path.is_empty() { + bail!("RRDCached Unix socket connection URL missing socket path"); + } + + let client = RRDCachedClient::connect_unix(socket_path).await?; + Ok(Self { + client: Arc::new(RwLock::new(Box::new(client))), + created_sensors: Arc::new(RwLock::new(HashSet::new())), + preset, + }) } _ => bail!("Invalid scheme in connection string: {}", scheme), } @@ -333,18 +422,178 @@ impl StorageInstance for RrdCachedStorage { Ok(()) } - async fn list_series(&self) -> Result> { - unimplemented!(); + async fn list_series( + &self, + metric_filter: Option<&str>, + ) -> Result> { + // Use RRDcached's native LIST command to get available RRD files + let mut client = self.client.write().await; + + match client.list(true, None).await { + Ok(rrd_files) => { + let mut sensors = Vec::new(); + + for rrd_file in rrd_files { + // Trim whitespace from filename (RRDcached LIST returns names with trailing newlines) + let rrd_file = rrd_file.trim(); + + // Filter by metric name if provided + if let Some(filter) = metric_filter { + if !rrd_file.contains(filter) { + continue; + } + } + + // Extract UUID from filename (assuming format: ".rrd") + let filename = rrd_file.rsplit('/').next().unwrap_or(&rrd_file); + let uuid_str = filename.strip_suffix(".rrd").unwrap_or(filename); + + if let Ok(uuid) = uuid_str.parse::() { + // Create a basic sensor object from RRD file info + // Note: RRDcached doesn't store full sensor metadata, + // so we create minimal sensor objects with defaults + let sensor = crate::datamodel::Sensor { + uuid, + name: uuid.to_string(), // Use UUID as name + sensor_type: crate::datamodel::SensorType::Float, // Default type + unit: None, + labels: SmallVec::new(), + }; + sensors.push(sensor); + } else { + // If filename is not a valid UUID, create a sensor with a new UUID + let sensor = crate::datamodel::Sensor { + uuid: Uuid::new_v4(), + name: filename.to_string(), + sensor_type: crate::datamodel::SensorType::Float, + unit: None, + labels: SmallVec::new(), + }; + sensors.push(sensor); + } + } + + Ok(sensors) + } + Err(e) => { + error!("Failed to list RRD files: {:?}", e); + + // Fallback to tracking created sensors in this session + let created_sensors = self.created_sensors.read().await; + let mut sensors = Vec::new(); + + for uuid in created_sensors.iter() { + let sensor = crate::datamodel::Sensor { + uuid: *uuid, + name: uuid.to_string(), + sensor_type: crate::datamodel::SensorType::Float, + unit: None, + labels: SmallVec::new(), + }; + sensors.push(sensor); + } + + Ok(sensors) + } + } + } + + async fn list_metrics(&self) -> Result> { + // RRDcached doesn't support metric-level operations like PostgreSQL + // Return empty list for now, as RRDcached focuses on individual series + Ok(vec![]) } async fn query_sensor_data( &self, - _sensor_uuid: &str, - _start_time: Option, - _end_time: Option, - _limit: Option, + sensor_uuid: &str, + start_time: Option, + end_time: Option, + _limit: Option, // RRD doesn't support limiting results directly ) -> Result> { - unimplemented!("RRDCached sensor data querying not yet implemented"); + use crate::datamodel::{SensorData, SensorType, Sample, sensapp_datetime::SensAppDateTimeExt}; + use smallvec::SmallVec; + + // Check if sensor exists in our created_sensors set + let created_sensors = self.created_sensors.read().await; + let sensor_uuid_obj = sensor_uuid.parse::() + .map_err(|e| anyhow::anyhow!("Invalid sensor UUID: {}", e))?; + + drop(created_sensors); + + // Convert time parameters to Unix timestamps + let start_timestamp = start_time.map(|t| t.to_unix_seconds().floor() as i64); + let end_timestamp = end_time.map(|t| t.to_unix_seconds().floor() as i64); + + // Fetch data from RRDcached - first flush to ensure data is written + let mut client = self.client.write().await; + + // Force flush to ensure all pending data is written to RRD files + if let Err(e) = client.flush_all().await { + tracing::warn!("Failed to flush before query: {:?}", e); + } + let rrd_path = sensor_uuid; // RRD file path is just the UUID + + let fetch_response = match client.fetch( + &rrd_path, + ConsolidationFunction::Average, // Use AVERAGE consolidation by default + start_timestamp, + end_timestamp, + None, // columns - use default + ).await { + Ok(response) => { + tracing::info!("Fetch successful for sensor {}: {} data points", + sensor_uuid, response.data.len()); + response + }, + Err(e) => { + // If fetch fails, it might be because no data exists yet + tracing::info!("Failed to fetch data for sensor {}: {:?}", sensor_uuid, e); + return Ok(None); + } + }; + + // Convert RRD data to SensApp samples + let mut samples = SmallVec::new(); + + tracing::info!("Processing {} RRD data points", fetch_response.data.len()); + + // RRD returns data as Vec<(timestamp, Vec)> + // We use the first data source (index 0) since we create RRDs with one DS + for (timestamp, values) in fetch_response.data { + tracing::debug!("RRD data point: timestamp={}, values={:?}", timestamp, values); + if let Some(&value) = values.get(0) { + // Skip NaN values (RRD uses NaN for missing data) + if !value.is_nan() { + let datetime = crate::datamodel::SensAppDateTime::from_unix_seconds_i64(timestamp as i64); + samples.push(Sample { datetime, value }); + tracing::debug!("Added sample: time={:?}, value={}", datetime, value); + } else { + tracing::debug!("Skipped NaN value at timestamp {}", timestamp); + } + } + } + + tracing::info!("Converted {} valid samples from RRD data", samples.len()); + + if samples.is_empty() { + tracing::info!("No valid samples found, returning None"); + return Ok(None); + } + + // Create sensor metadata (we have to reconstruct it since RRD doesn't store it) + let sensor = crate::datamodel::Sensor { + uuid: sensor_uuid_obj, + name: sensor_uuid.to_string(), // Use UUID as name since we don't have the original + sensor_type: SensorType::Float, // Assume Float since RRD stores f64 values + unit: None, // We don't have unit information + labels: SmallVec::new(), // We don't have labels information + }; + + let typed_samples = TypedSamples::Float(samples); + let sensor_data = SensorData::new(sensor, typed_samples); + + Ok(Some(sensor_data)) } /// Clean up all test data from the database (RRDCached implementation) diff --git a/tests/common/mod.rs b/tests/common/mod.rs index 4f004e5..d7c18c6 100644 --- a/tests/common/mod.rs +++ b/tests/common/mod.rs @@ -12,6 +12,7 @@ pub enum DatabaseType { PostgreSQL, SQLite, ClickHouse, + RRDcached, } impl DatabaseType { @@ -26,6 +27,9 @@ impl DatabaseType { DatabaseType::ClickHouse => std::env::var("TEST_DATABASE_URL").unwrap_or_else(|_| { "clickhouse://default:password@localhost:9000/sensapp_test".to_string() }), + DatabaseType::RRDcached => std::env::var("TEST_DATABASE_URL").unwrap_or_else(|_| { + "rrdcached://127.0.0.1:42217?preset=hoarder".to_string() + }), } } @@ -35,6 +39,8 @@ impl DatabaseType { DatabaseType::SQLite } else if connection_string.starts_with("clickhouse://") { DatabaseType::ClickHouse + } else if connection_string.starts_with("rrdcached://") { + DatabaseType::RRDcached } else { // Default to PostgreSQL for postgres://, postgresql://, or any other prefix DatabaseType::PostgreSQL @@ -75,6 +81,7 @@ impl TestDb { DatabaseType::PostgreSQL => "sensapp".to_string(), DatabaseType::SQLite => "test.db".to_string(), DatabaseType::ClickHouse => "sensapp_test".to_string(), + DatabaseType::RRDcached => "rrdcached".to_string(), }; let connection_string = db_type.default_connection_string(); diff --git a/tests/rrdcached_integration.rs b/tests/rrdcached_integration.rs new file mode 100644 index 0000000..7e45fe8 --- /dev/null +++ b/tests/rrdcached_integration.rs @@ -0,0 +1,570 @@ +mod common; + +#[cfg(feature = "rrdcached")] +mod rrdcached_tests { + use crate::common::{DatabaseType, TestDb}; + use anyhow::Result; + use sensapp::config::load_configuration_for_tests; + use sensapp::datamodel::{ + batch::{Batch, SingleSensorBatch}, Sample, Sensor, SensorType, SensAppDateTime, TypedSamples, sensapp_vec::SensAppVec, + }; + use serial_test::serial; + use smallvec::SmallVec; + use std::sync::Arc; + use uuid::Uuid; + + // Ensure configuration is loaded once for all tests in this module + static INIT: std::sync::Once = std::sync::Once::new(); + fn ensure_config() { + INIT.call_once(|| { + load_configuration_for_tests().expect("Failed to load configuration for tests"); + }); + } + + /// Test basic RRDcached connection and database setup + #[tokio::test] + #[serial] + async fn test_rrdcached_connection() -> Result<()> { + ensure_config(); + // Given: An RRDcached test database + let test_db = TestDb::new_with_type(DatabaseType::RRDcached).await?; + let storage = test_db.storage(); + + // When: We try to migrate and list series + storage.create_or_migrate().await?; + + // Then: The operations should succeed (database is accessible) + let sensors = storage.list_series(None).await?; + + // Database should be empty initially (or may contain existing RRD files) + println!("Found {} sensors in RRDcached database", sensors.len()); + for sensor in &sensors { + println!(" - Sensor: UUID={}, Name={}", sensor.uuid, sensor.name); + } + + Ok(()) + } + + /// Test RRDcached list functionality with data + #[tokio::test] + #[serial] + async fn test_rrdcached_list_after_publishing() -> Result<()> { + ensure_config(); + let test_db = TestDb::new_with_type(DatabaseType::RRDcached).await?; + let storage = test_db.storage(); + + // Given: We publish some data first + let sensor = Sensor { + uuid: Uuid::new_v4(), + name: "test_sensor_for_listing".to_string(), + sensor_type: SensorType::Float, + unit: None, + labels: SmallVec::new(), + }; + + let base_time = 1704067200.0; // 2024-01-01 00:00:00 UTC + let samples = vec![Sample { + datetime: SensAppDateTime::from_unix_seconds(base_time), + value: 42.0, + }]; + + // Create and publish batch + let sensor_arc = Arc::new(sensor); + let single_sensor_batch = SingleSensorBatch::new(sensor_arc.clone(), TypedSamples::Float(samples.into())); + let mut sensors_vec = SensAppVec::new(); + sensors_vec.push(single_sensor_batch); + let batch = Arc::new(Batch::new(sensors_vec)); + + let (sync_sender, _sync_receiver) = async_broadcast::broadcast(10); + storage.publish(batch, sync_sender.clone()).await?; + + // When: We list the series + let sensors = storage.list_series(None).await?; + + // Then: We should find the sensor we just created + println!("Found {} sensors after publishing data", sensors.len()); + for sensor in &sensors { + println!(" - Sensor: UUID={}, Name={}", sensor.uuid, sensor.name); + } + + // Verify our sensor appears in the list (either by UUID match or by being present) + let found = sensors.iter().any(|s| s.uuid == sensor_arc.uuid); + if !found && sensors.is_empty() { + println!("Warning: No sensors found - this might be expected if RRDcached LIST command doesn't show recently created files"); + } + + Ok(()) + } + + /// Test metrics listing functionality + #[tokio::test] + #[serial] + async fn test_rrdcached_list_metrics() -> Result<()> { + ensure_config(); + let test_db = TestDb::new_with_type(DatabaseType::RRDcached).await?; + let storage = test_db.storage(); + + // When: We list metrics + let metrics = storage.list_metrics().await?; + + // Then: The operation should succeed + // RRDcached doesn't support metrics the same way as SQL databases + println!("Found {} metrics in RRDcached database", metrics.len()); + + Ok(()) + } + + /// Test basic data publishing to RRDcached + #[tokio::test] + #[serial] + async fn test_rrdcached_publish_float_data() -> Result<()> { + ensure_config(); + let test_db = TestDb::new_with_type(DatabaseType::RRDcached).await?; + let storage = test_db.storage(); + + // Given: A test sensor with float data + let sensor_uuid = Uuid::new_v4(); + let sensor = Sensor { + uuid: sensor_uuid, + name: "test_float_sensor".to_string(), + sensor_type: SensorType::Float, + unit: None, + labels: SmallVec::new(), + }; + + // Create some test float samples + let base_time = 1704067200.0; // 2024-01-01 00:00:00 UTC + let samples = vec![ + Sample { + datetime: SensAppDateTime::from_unix_seconds(base_time), + value: 23.5, + }, + Sample { + datetime: SensAppDateTime::from_unix_seconds(base_time + 1.0), + value: 24.1, + }, + Sample { + datetime: SensAppDateTime::from_unix_seconds(base_time + 2.0), + value: 22.8, + }, + ]; + + // Build batch manually + let sensor_arc = Arc::new(sensor); + let single_sensor_batch = SingleSensorBatch::new(sensor_arc, TypedSamples::Float(samples.into())); + let mut sensors = SensAppVec::new(); + sensors.push(single_sensor_batch); + let batch = Arc::new(Batch::new(sensors)); + + // When: We publish the batch + let (sync_sender, _sync_receiver) = async_broadcast::broadcast(10); + storage.publish(batch, sync_sender.clone()).await?; + + // Then: The data should be stored + // Note: RRDcached doesn't support querying data back easily, + // but we can at least verify the publish operation succeeded + println!("Successfully published float data to RRDcached"); + + // Verify the sensor appears in our created sensors list + let sensors = storage.list_series(None).await?; + assert!(!sensors.is_empty(), "Should have at least one sensor"); + + let found_sensor = sensors.iter().find(|s| s.uuid == sensor_uuid); + assert!(found_sensor.is_some(), "Published sensor should be in the list"); + + Ok(()) + } + + /// Test publishing different data types + #[tokio::test] + #[serial] + async fn test_rrdcached_publish_multiple_types() -> Result<()> { + ensure_config(); + let test_db = TestDb::new_with_type(DatabaseType::RRDcached).await?; + let storage = test_db.storage(); + + let base_time = 1704067200.0; // 2024-01-01 00:00:00 UTC + let (sync_sender, _sync_receiver) = async_broadcast::broadcast(10); + + // Test Integer data + let int_sensor = Sensor { + uuid: Uuid::new_v4(), + name: "test_integer_sensor".to_string(), + sensor_type: SensorType::Integer, + unit: None, + labels: SmallVec::new(), + }; + + let int_samples = vec![Sample { + datetime: SensAppDateTime::from_unix_seconds(base_time), + value: 42i64, + }]; + + let int_sensor_arc = Arc::new(int_sensor); + let single_sensor_batch = SingleSensorBatch::new(int_sensor_arc.clone(), TypedSamples::Integer(int_samples.into())); + let mut sensors = SensAppVec::new(); + sensors.push(single_sensor_batch); + let batch = Arc::new(Batch::new(sensors)); + + storage.publish(batch, sync_sender.clone()).await?; + println!("Successfully published integer data to RRDcached"); + + // Test Boolean data + let bool_sensor = Sensor { + uuid: Uuid::new_v4(), + name: "test_boolean_sensor".to_string(), + sensor_type: SensorType::Boolean, + unit: None, + labels: SmallVec::new(), + }; + + let bool_samples = vec![Sample { + datetime: SensAppDateTime::from_unix_seconds(base_time + 5.0), // Ensure different timestamp + value: true, + }]; + + let bool_sensor_arc = Arc::new(bool_sensor); + let single_sensor_batch = SingleSensorBatch::new(bool_sensor_arc.clone(), TypedSamples::Boolean(bool_samples.into())); + let mut sensors = SensAppVec::new(); + sensors.push(single_sensor_batch); + let batch = Arc::new(Batch::new(sensors)); + + storage.publish(batch, sync_sender.clone()).await?; + println!("Successfully published boolean data to RRDcached"); + + // Verify all sensors are tracked + let sensors = storage.list_series(None).await?; + assert!( + sensors.len() >= 2, + "Should have at least 2 sensors (integer and boolean)" + ); + + Ok(()) + } + + /// Test RRDcached vacuum operation + #[tokio::test] + #[serial] + async fn test_rrdcached_vacuum() -> Result<()> { + ensure_config(); + let test_db = TestDb::new_with_type(DatabaseType::RRDcached).await?; + let storage = test_db.storage(); + + // When: We call vacuum + storage.vacuum().await?; + + // Then: The operation should succeed (even though it's a no-op for RRDcached) + println!("RRDcached vacuum completed successfully"); + + Ok(()) + } + + /// Test that unsupported sensor types are handled gracefully + #[tokio::test] + #[serial] + async fn test_rrdcached_unsupported_types() -> Result<()> { + ensure_config(); + let test_db = TestDb::new_with_type(DatabaseType::RRDcached).await?; + let storage = test_db.storage(); + + // Given: A sensor with an unsupported type (String) + let string_sensor = Sensor { + uuid: Uuid::new_v4(), + name: "test_string_sensor".to_string(), + sensor_type: SensorType::String, + unit: None, + labels: SmallVec::new(), + }; + + let string_samples = vec![Sample { + datetime: SensAppDateTime::from_unix_seconds(1704067200.0), + value: "test_value".to_string(), + }]; + + let string_sensor_arc = Arc::new(string_sensor); + let single_sensor_batch = SingleSensorBatch::new(string_sensor_arc.clone(), TypedSamples::String(string_samples.into())); + let mut sensors = SensAppVec::new(); + sensors.push(single_sensor_batch); + let batch = Arc::new(Batch::new(sensors)); + + // When: We try to publish unsupported data + let (sync_sender, _sync_receiver) = async_broadcast::broadcast(10); + storage.publish(batch, sync_sender.clone()).await?; + + // Then: The operation should succeed but the sensor shouldn't be created + // (since unsupported types are filtered out in the create_sensors method) + let sensors = storage.list_series(None).await?; + let found_sensor = sensors.iter().find(|s| s.uuid == string_sensor_arc.uuid); + assert!(found_sensor.is_none(), "Unsupported sensor types should not be created"); + + Ok(()) + } + + /// Test querying data that was previously published + #[tokio::test] + #[serial] + async fn test_rrdcached_query_published_data() -> Result<()> { + ensure_config(); + let test_db = TestDb::new_with_type(DatabaseType::RRDcached).await?; + let storage = test_db.storage(); + + // Given: A sensor with known data + let sensor_uuid = Uuid::new_v4(); + let sensor = Sensor { + uuid: sensor_uuid, + name: "test_query_sensor".to_string(), + sensor_type: SensorType::Float, + unit: None, + labels: SmallVec::new(), + }; + + let base_time = 1704067200.0; // 2024-01-01 00:00:00 UTC + let test_values = vec![23.5, 24.1, 22.8]; + let samples: Vec> = test_values + .iter() + .enumerate() + .map(|(i, &value)| Sample { + datetime: SensAppDateTime::from_unix_seconds(base_time + i as f64), + value, + }) + .collect(); + + // Publish the data + let sensor_arc = Arc::new(sensor); + let single_sensor_batch = SingleSensorBatch::new(sensor_arc.clone(), TypedSamples::Float(samples.into())); + let mut sensors = SensAppVec::new(); + sensors.push(single_sensor_batch); + let batch = Arc::new(Batch::new(sensors)); + + let (sync_sender, _sync_receiver) = async_broadcast::broadcast(10); + storage.publish(batch, sync_sender.clone()).await?; + + // Give RRD time to process and consolidate the data + tokio::time::sleep(tokio::time::Duration::from_millis(1000)).await; + + // When: We query the data back with the specific time range + let start_time = Some(SensAppDateTime::from_unix_seconds(base_time - 10.0)); // Start before our data + let end_time = Some(SensAppDateTime::from_unix_seconds(base_time + 10.0)); // End after our data + let sensor_data = storage.query_sensor_data(&sensor_uuid.to_string(), start_time, end_time, None).await?; + + + // Then: We should get back the data we stored + assert!(sensor_data.is_some(), "Query should return data"); + let sensor_data = sensor_data.unwrap(); + + // Verify sensor metadata (reconstructed from UUID) + assert_eq!(sensor_data.sensor.uuid, sensor_uuid); + assert_eq!(sensor_data.sensor.sensor_type, SensorType::Float); + + // Verify samples (may not be exact due to RRD time alignment and consolidation) + if let TypedSamples::Float(returned_samples) = sensor_data.samples { + assert!(!returned_samples.is_empty(), "Should have returned some samples"); + + // We may not get exact values due to RRD consolidation, but let's check we get reasonable data + for sample in &returned_samples { + assert!(!sample.value.is_nan(), "Sample values should not be NaN"); + println!("Retrieved sample: time={:?}, value={}", sample.datetime, sample.value); + } + } else { + panic!("Expected Float samples, got: {:?}", sensor_data.samples); + } + + Ok(()) + } + + /// Test querying with time range + #[tokio::test] + #[serial] + async fn test_rrdcached_query_with_time_range() -> Result<()> { + ensure_config(); + let test_db = TestDb::new_with_type(DatabaseType::RRDcached).await?; + let storage = test_db.storage(); + + // Given: A sensor with data spread over time + let sensor_uuid = Uuid::new_v4(); + let sensor = Sensor { + uuid: sensor_uuid, + name: "test_time_range_sensor".to_string(), + sensor_type: SensorType::Float, + unit: None, + labels: SmallVec::new(), + }; + + let base_time = 1704067200.0; // 2024-01-01 00:00:00 UTC + let samples: Vec> = (0..10) + .map(|i| Sample { + datetime: SensAppDateTime::from_unix_seconds(base_time + i as f64 * 60.0), // Every minute + value: i as f64 * 10.0, + }) + .collect(); + + // Publish the data + let sensor_arc = Arc::new(sensor); + let single_sensor_batch = SingleSensorBatch::new(sensor_arc.clone(), TypedSamples::Float(samples.into())); + let mut sensors = SensAppVec::new(); + sensors.push(single_sensor_batch); + let batch = Arc::new(Batch::new(sensors)); + + let (sync_sender, _sync_receiver) = async_broadcast::broadcast(10); + storage.publish(batch, sync_sender.clone()).await?; + + // Give RRD time to process and consolidate the data + tokio::time::sleep(tokio::time::Duration::from_millis(1000)).await; + + // When: We query with a time range (first 5 minutes with buffer) + let start_time = Some(SensAppDateTime::from_unix_seconds(base_time - 60.0)); // Start 1 minute before + let end_time = Some(SensAppDateTime::from_unix_seconds(base_time + 360.0)); // End 6 minutes after start + + let sensor_data = storage.query_sensor_data( + &sensor_uuid.to_string(), + start_time, + end_time, + None + ).await?; + + // Then: We should get data within the time range + assert!(sensor_data.is_some(), "Query with time range should return data"); + let sensor_data = sensor_data.unwrap(); + + if let TypedSamples::Float(returned_samples) = sensor_data.samples { + assert!(!returned_samples.is_empty(), "Should have returned samples in time range"); + + for sample in &returned_samples { + let sample_time = sample.datetime.to_unix_seconds(); + println!("Sample in range: time={}, value={}", sample_time, sample.value); + // Note: RRD may return data slightly outside the range due to consolidation + } + } else { + panic!("Expected Float samples, got: {:?}", sensor_data.samples); + } + + Ok(()) + } + + /// Test querying non-existent sensor + #[tokio::test] + #[serial] + async fn test_rrdcached_query_nonexistent_sensor() -> Result<()> { + ensure_config(); + let test_db = TestDb::new_with_type(DatabaseType::RRDcached).await?; + let storage = test_db.storage(); + + // When: We query a sensor that doesn't exist + let non_existent_uuid = Uuid::new_v4(); + let sensor_data = storage.query_sensor_data(&non_existent_uuid.to_string(), None, None, None).await?; + + // Then: We should get None + assert!(sensor_data.is_none(), "Query for non-existent sensor should return None"); + + Ok(()) + } + + /// Test querying sensor with no data yet + #[tokio::test] + #[serial] + async fn test_rrdcached_query_sensor_no_data() -> Result<()> { + ensure_config(); + let test_db = TestDb::new_with_type(DatabaseType::RRDcached).await?; + let storage = test_db.storage(); + + // Given: A sensor that exists but has no data + let sensor_uuid = Uuid::new_v4(); + let sensor = Sensor { + uuid: sensor_uuid, + name: "test_empty_sensor".to_string(), + sensor_type: SensorType::Float, + unit: None, + labels: SmallVec::new(), + }; + + // Create the sensor without publishing any data + let sensor_arc = Arc::new(sensor); + let empty_samples: Vec> = vec![]; + let single_sensor_batch = SingleSensorBatch::new(sensor_arc.clone(), TypedSamples::Float(empty_samples.into())); + let mut sensors = SensAppVec::new(); + sensors.push(single_sensor_batch); + let batch = Arc::new(Batch::new(sensors)); + + let (sync_sender, _sync_receiver) = async_broadcast::broadcast(10); + storage.publish(batch, sync_sender.clone()).await?; + + // When: We query the sensor + let sensor_data = storage.query_sensor_data(&sensor_uuid.to_string(), None, None, None).await?; + + // Then: We should get None (no data available) + assert!(sensor_data.is_none(), "Query for sensor with no data should return None"); + + Ok(()) + } + + /// Test querying integer data (stored as float in RRD) + #[tokio::test] + #[serial] + async fn test_rrdcached_query_integer_data() -> Result<()> { + ensure_config(); + let test_db = TestDb::new_with_type(DatabaseType::RRDcached).await?; + let storage = test_db.storage(); + + // Given: A sensor with integer data + let sensor_uuid = Uuid::new_v4(); + let sensor = Sensor { + uuid: sensor_uuid, + name: "test_integer_query_sensor".to_string(), + sensor_type: SensorType::Integer, + unit: None, + labels: SmallVec::new(), + }; + + let base_time = 1704067200.0; // 2024-01-01 00:00:00 UTC + let int_samples = vec![ + Sample { + datetime: SensAppDateTime::from_unix_seconds(base_time), + value: 42i64, + }, + Sample { + datetime: SensAppDateTime::from_unix_seconds(base_time + 1.0), + value: 84i64, + }, + ]; + + // Publish the integer data + let sensor_arc = Arc::new(sensor); + let single_sensor_batch = SingleSensorBatch::new(sensor_arc.clone(), TypedSamples::Integer(int_samples.into())); + let mut sensors = SensAppVec::new(); + sensors.push(single_sensor_batch); + let batch = Arc::new(Batch::new(sensors)); + + let (sync_sender, _sync_receiver) = async_broadcast::broadcast(10); + storage.publish(batch, sync_sender.clone()).await?; + + // Give RRD time to process and consolidate the data + tokio::time::sleep(tokio::time::Duration::from_millis(1000)).await; + + // When: We query the data back with time range + let start_time = Some(SensAppDateTime::from_unix_seconds(base_time - 10.0)); // Start before our data + let end_time = Some(SensAppDateTime::from_unix_seconds(base_time + 10.0)); // End after our data + let sensor_data = storage.query_sensor_data(&sensor_uuid.to_string(), start_time, end_time, None).await?; + + // Then: We should get back Float data (since RRD stores everything as f64) + // Note: This shows a limitation - we lose the original type information + assert!(sensor_data.is_some(), "Query should return data"); + let sensor_data = sensor_data.unwrap(); + + // The sensor type will be reconstructed as Float since we don't store the original type + assert_eq!(sensor_data.sensor.sensor_type, SensorType::Float); + + if let TypedSamples::Float(returned_samples) = sensor_data.samples { + assert!(!returned_samples.is_empty(), "Should have returned some samples"); + + for sample in &returned_samples { + println!("Retrieved integer-as-float sample: time={:?}, value={}", sample.datetime, sample.value); + // Values should be close to the original integers (42.0, 84.0) + assert!(!sample.value.is_nan(), "Sample values should not be NaN"); + } + } else { + panic!("Expected Float samples, got: {:?}", sensor_data.samples); + } + + Ok(()) + } +} \ No newline at end of file From 323651192aa666230b52783e8af56613bd2afef1 Mon Sep 17 00:00:00 2001 From: Antoine Pultier <45740+fungiboletus@users.noreply.github.com> Date: Tue, 26 Aug 2025 10:43:52 +0200 Subject: [PATCH 02/39] =?UTF-8?q?style:=20=E2=9C=A8=20please=20the=20linte?= =?UTF-8?q?r?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/storage/rrdcached/mod.rs | 139 +++++++++++++++++++++++---------- tests/common/mod.rs | 5 +- tests/rrdcached_integration.rs | 136 +++++++++++++++++++++++--------- 3 files changed, 196 insertions(+), 84 deletions(-) diff --git a/src/storage/rrdcached/mod.rs b/src/storage/rrdcached/mod.rs index a88cd39..9274abf 100644 --- a/src/storage/rrdcached/mod.rs +++ b/src/storage/rrdcached/mod.rs @@ -13,8 +13,8 @@ use rrdcached_client::{ create::{CreateArguments, CreateDataSource, CreateDataSourceType, CreateRoundRobinArchive}, errors::RRDCachedClientError, }; -use std::{collections::HashSet, sync::Arc}; use smallvec::SmallVec; +use std::{collections::HashSet, sync::Arc}; use tokio::sync::RwLock; use tracing::error; use url::Url; @@ -122,10 +122,20 @@ pub struct RrdCachedStorage { // Trait to abstract over TCP and Unix socket clients #[async_trait::async_trait] trait RRDCachedClientTrait: Send + Sync + std::fmt::Debug { - async fn create(&mut self, args: rrdcached_client::create::CreateArguments) -> Result<(), rrdcached_client::errors::RRDCachedClientError>; - async fn batch(&mut self, batch_updates: Vec) -> Result<(), rrdcached_client::errors::RRDCachedClientError>; + async fn create( + &mut self, + args: rrdcached_client::create::CreateArguments, + ) -> Result<(), rrdcached_client::errors::RRDCachedClientError>; + async fn batch( + &mut self, + batch_updates: Vec, + ) -> Result<(), rrdcached_client::errors::RRDCachedClientError>; async fn flush_all(&mut self) -> Result<(), rrdcached_client::errors::RRDCachedClientError>; - async fn list(&mut self, recursive: bool, path: Option<&str>) -> Result, rrdcached_client::errors::RRDCachedClientError>; + async fn list( + &mut self, + recursive: bool, + path: Option<&str>, + ) -> Result, rrdcached_client::errors::RRDCachedClientError>; async fn fetch( &mut self, path: &str, @@ -133,17 +143,26 @@ trait RRDCachedClientTrait: Send + Sync + std::fmt::Debug { start: Option, end: Option, columns: Option>, - ) -> Result; + ) -> Result< + rrdcached_client::fetch::FetchResponse, + rrdcached_client::errors::RRDCachedClientError, + >; } // Implement the trait for TCP client #[async_trait::async_trait] impl RRDCachedClientTrait for RRDCachedClient { - async fn create(&mut self, args: rrdcached_client::create::CreateArguments) -> Result<(), rrdcached_client::errors::RRDCachedClientError> { + async fn create( + &mut self, + args: rrdcached_client::create::CreateArguments, + ) -> Result<(), rrdcached_client::errors::RRDCachedClientError> { RRDCachedClient::create(self, args).await } - async fn batch(&mut self, batch_updates: Vec) -> Result<(), rrdcached_client::errors::RRDCachedClientError> { + async fn batch( + &mut self, + batch_updates: Vec, + ) -> Result<(), rrdcached_client::errors::RRDCachedClientError> { RRDCachedClient::batch(self, batch_updates).await } @@ -151,7 +170,11 @@ impl RRDCachedClientTrait for RRDCachedClient { RRDCachedClient::flush_all(self).await } - async fn list(&mut self, recursive: bool, path: Option<&str>) -> Result, rrdcached_client::errors::RRDCachedClientError> { + async fn list( + &mut self, + recursive: bool, + path: Option<&str>, + ) -> Result, rrdcached_client::errors::RRDCachedClientError> { RRDCachedClient::list(self, recursive, path).await } @@ -162,7 +185,10 @@ impl RRDCachedClientTrait for RRDCachedClient { start: Option, end: Option, columns: Option>, - ) -> Result { + ) -> Result< + rrdcached_client::fetch::FetchResponse, + rrdcached_client::errors::RRDCachedClientError, + > { RRDCachedClient::fetch(self, path, consolidation_function, start, end, columns).await } } @@ -170,11 +196,17 @@ impl RRDCachedClientTrait for RRDCachedClient { // Implement the trait for Unix socket client #[async_trait::async_trait] impl RRDCachedClientTrait for RRDCachedClient { - async fn create(&mut self, args: rrdcached_client::create::CreateArguments) -> Result<(), rrdcached_client::errors::RRDCachedClientError> { + async fn create( + &mut self, + args: rrdcached_client::create::CreateArguments, + ) -> Result<(), rrdcached_client::errors::RRDCachedClientError> { RRDCachedClient::create(self, args).await } - async fn batch(&mut self, batch_updates: Vec) -> Result<(), rrdcached_client::errors::RRDCachedClientError> { + async fn batch( + &mut self, + batch_updates: Vec, + ) -> Result<(), rrdcached_client::errors::RRDCachedClientError> { RRDCachedClient::batch(self, batch_updates).await } @@ -182,7 +214,11 @@ impl RRDCachedClientTrait for RRDCachedClient { RRDCachedClient::flush_all(self).await } - async fn list(&mut self, recursive: bool, path: Option<&str>) -> Result, rrdcached_client::errors::RRDCachedClientError> { + async fn list( + &mut self, + recursive: bool, + path: Option<&str>, + ) -> Result, rrdcached_client::errors::RRDCachedClientError> { RRDCachedClient::list(self, recursive, path).await } @@ -193,7 +229,10 @@ impl RRDCachedClientTrait for RRDCachedClient { start: Option, end: Option, columns: Option>, - ) -> Result { + ) -> Result< + rrdcached_client::fetch::FetchResponse, + rrdcached_client::errors::RRDCachedClientError, + > { RRDCachedClient::fetch(self, path, consolidation_function, start, end, columns).await } } @@ -428,26 +467,26 @@ impl StorageInstance for RrdCachedStorage { ) -> Result> { // Use RRDcached's native LIST command to get available RRD files let mut client = self.client.write().await; - + match client.list(true, None).await { Ok(rrd_files) => { let mut sensors = Vec::new(); - + for rrd_file in rrd_files { // Trim whitespace from filename (RRDcached LIST returns names with trailing newlines) let rrd_file = rrd_file.trim(); - + // Filter by metric name if provided if let Some(filter) = metric_filter { if !rrd_file.contains(filter) { continue; } } - + // Extract UUID from filename (assuming format: ".rrd") let filename = rrd_file.rsplit('/').next().unwrap_or(&rrd_file); let uuid_str = filename.strip_suffix(".rrd").unwrap_or(filename); - + if let Ok(uuid) = uuid_str.parse::() { // Create a basic sensor object from RRD file info // Note: RRDcached doesn't store full sensor metadata, @@ -472,16 +511,16 @@ impl StorageInstance for RrdCachedStorage { sensors.push(sensor); } } - + Ok(sensors) } Err(e) => { error!("Failed to list RRD files: {:?}", e); - + // Fallback to tracking created sensors in this session let created_sensors = self.created_sensors.read().await; let mut sensors = Vec::new(); - + for uuid in created_sensors.iter() { let sensor = crate::datamodel::Sensor { uuid: *uuid, @@ -492,7 +531,7 @@ impl StorageInstance for RrdCachedStorage { }; sensors.push(sensor); } - + Ok(sensors) } } @@ -511,14 +550,17 @@ impl StorageInstance for RrdCachedStorage { end_time: Option, _limit: Option, // RRD doesn't support limiting results directly ) -> Result> { - use crate::datamodel::{SensorData, SensorType, Sample, sensapp_datetime::SensAppDateTimeExt}; + use crate::datamodel::{ + Sample, SensorData, SensorType, sensapp_datetime::SensAppDateTimeExt, + }; use smallvec::SmallVec; // Check if sensor exists in our created_sensors set let created_sensors = self.created_sensors.read().await; - let sensor_uuid_obj = sensor_uuid.parse::() + let sensor_uuid_obj = sensor_uuid + .parse::() .map_err(|e| anyhow::anyhow!("Invalid sensor UUID: {}", e))?; - + drop(created_sensors); // Convert time parameters to Unix timestamps @@ -527,25 +569,31 @@ impl StorageInstance for RrdCachedStorage { // Fetch data from RRDcached - first flush to ensure data is written let mut client = self.client.write().await; - + // Force flush to ensure all pending data is written to RRD files if let Err(e) = client.flush_all().await { tracing::warn!("Failed to flush before query: {:?}", e); } let rrd_path = sensor_uuid; // RRD file path is just the UUID - - let fetch_response = match client.fetch( - &rrd_path, - ConsolidationFunction::Average, // Use AVERAGE consolidation by default - start_timestamp, - end_timestamp, - None, // columns - use default - ).await { + + let fetch_response = match client + .fetch( + &rrd_path, + ConsolidationFunction::Average, // Use AVERAGE consolidation by default + start_timestamp, + end_timestamp, + None, // columns - use default + ) + .await + { Ok(response) => { - tracing::info!("Fetch successful for sensor {}: {} data points", - sensor_uuid, response.data.len()); + tracing::info!( + "Fetch successful for sensor {}: {} data points", + sensor_uuid, + response.data.len() + ); response - }, + } Err(e) => { // If fetch fails, it might be because no data exists yet tracing::info!("Failed to fetch data for sensor {}: {:?}", sensor_uuid, e); @@ -555,17 +603,22 @@ impl StorageInstance for RrdCachedStorage { // Convert RRD data to SensApp samples let mut samples = SmallVec::new(); - + tracing::info!("Processing {} RRD data points", fetch_response.data.len()); - + // RRD returns data as Vec<(timestamp, Vec)> // We use the first data source (index 0) since we create RRDs with one DS for (timestamp, values) in fetch_response.data { - tracing::debug!("RRD data point: timestamp={}, values={:?}", timestamp, values); + tracing::debug!( + "RRD data point: timestamp={}, values={:?}", + timestamp, + values + ); if let Some(&value) = values.get(0) { // Skip NaN values (RRD uses NaN for missing data) if !value.is_nan() { - let datetime = crate::datamodel::SensAppDateTime::from_unix_seconds_i64(timestamp as i64); + let datetime = + crate::datamodel::SensAppDateTime::from_unix_seconds_i64(timestamp as i64); samples.push(Sample { datetime, value }); tracing::debug!("Added sample: time={:?}, value={}", datetime, value); } else { @@ -586,8 +639,8 @@ impl StorageInstance for RrdCachedStorage { uuid: sensor_uuid_obj, name: sensor_uuid.to_string(), // Use UUID as name since we don't have the original sensor_type: SensorType::Float, // Assume Float since RRD stores f64 values - unit: None, // We don't have unit information - labels: SmallVec::new(), // We don't have labels information + unit: None, // We don't have unit information + labels: SmallVec::new(), // We don't have labels information }; let typed_samples = TypedSamples::Float(samples); diff --git a/tests/common/mod.rs b/tests/common/mod.rs index d7c18c6..ee3f023 100644 --- a/tests/common/mod.rs +++ b/tests/common/mod.rs @@ -27,9 +27,8 @@ impl DatabaseType { DatabaseType::ClickHouse => std::env::var("TEST_DATABASE_URL").unwrap_or_else(|_| { "clickhouse://default:password@localhost:9000/sensapp_test".to_string() }), - DatabaseType::RRDcached => std::env::var("TEST_DATABASE_URL").unwrap_or_else(|_| { - "rrdcached://127.0.0.1:42217?preset=hoarder".to_string() - }), + DatabaseType::RRDcached => std::env::var("TEST_DATABASE_URL") + .unwrap_or_else(|_| "rrdcached://127.0.0.1:42217?preset=hoarder".to_string()), } } diff --git a/tests/rrdcached_integration.rs b/tests/rrdcached_integration.rs index 7e45fe8..540601d 100644 --- a/tests/rrdcached_integration.rs +++ b/tests/rrdcached_integration.rs @@ -6,7 +6,9 @@ mod rrdcached_tests { use anyhow::Result; use sensapp::config::load_configuration_for_tests; use sensapp::datamodel::{ - batch::{Batch, SingleSensorBatch}, Sample, Sensor, SensorType, SensAppDateTime, TypedSamples, sensapp_vec::SensAppVec, + Sample, SensAppDateTime, Sensor, SensorType, TypedSamples, + batch::{Batch, SingleSensorBatch}, + sensapp_vec::SensAppVec, }; use serial_test::serial; use smallvec::SmallVec; @@ -70,7 +72,8 @@ mod rrdcached_tests { // Create and publish batch let sensor_arc = Arc::new(sensor); - let single_sensor_batch = SingleSensorBatch::new(sensor_arc.clone(), TypedSamples::Float(samples.into())); + let single_sensor_batch = + SingleSensorBatch::new(sensor_arc.clone(), TypedSamples::Float(samples.into())); let mut sensors_vec = SensAppVec::new(); sensors_vec.push(single_sensor_batch); let batch = Arc::new(Batch::new(sensors_vec)); @@ -90,7 +93,9 @@ mod rrdcached_tests { // Verify our sensor appears in the list (either by UUID match or by being present) let found = sensors.iter().any(|s| s.uuid == sensor_arc.uuid); if !found && sensors.is_empty() { - println!("Warning: No sensors found - this might be expected if RRDcached LIST command doesn't show recently created files"); + println!( + "Warning: No sensors found - this might be expected if RRDcached LIST command doesn't show recently created files" + ); } Ok(()) @@ -151,7 +156,8 @@ mod rrdcached_tests { // Build batch manually let sensor_arc = Arc::new(sensor); - let single_sensor_batch = SingleSensorBatch::new(sensor_arc, TypedSamples::Float(samples.into())); + let single_sensor_batch = + SingleSensorBatch::new(sensor_arc, TypedSamples::Float(samples.into())); let mut sensors = SensAppVec::new(); sensors.push(single_sensor_batch); let batch = Arc::new(Batch::new(sensors)); @@ -170,7 +176,10 @@ mod rrdcached_tests { assert!(!sensors.is_empty(), "Should have at least one sensor"); let found_sensor = sensors.iter().find(|s| s.uuid == sensor_uuid); - assert!(found_sensor.is_some(), "Published sensor should be in the list"); + assert!( + found_sensor.is_some(), + "Published sensor should be in the list" + ); Ok(()) } @@ -201,7 +210,10 @@ mod rrdcached_tests { }]; let int_sensor_arc = Arc::new(int_sensor); - let single_sensor_batch = SingleSensorBatch::new(int_sensor_arc.clone(), TypedSamples::Integer(int_samples.into())); + let single_sensor_batch = SingleSensorBatch::new( + int_sensor_arc.clone(), + TypedSamples::Integer(int_samples.into()), + ); let mut sensors = SensAppVec::new(); sensors.push(single_sensor_batch); let batch = Arc::new(Batch::new(sensors)); @@ -224,7 +236,10 @@ mod rrdcached_tests { }]; let bool_sensor_arc = Arc::new(bool_sensor); - let single_sensor_batch = SingleSensorBatch::new(bool_sensor_arc.clone(), TypedSamples::Boolean(bool_samples.into())); + let single_sensor_batch = SingleSensorBatch::new( + bool_sensor_arc.clone(), + TypedSamples::Boolean(bool_samples.into()), + ); let mut sensors = SensAppVec::new(); sensors.push(single_sensor_batch); let batch = Arc::new(Batch::new(sensors)); @@ -282,7 +297,10 @@ mod rrdcached_tests { }]; let string_sensor_arc = Arc::new(string_sensor); - let single_sensor_batch = SingleSensorBatch::new(string_sensor_arc.clone(), TypedSamples::String(string_samples.into())); + let single_sensor_batch = SingleSensorBatch::new( + string_sensor_arc.clone(), + TypedSamples::String(string_samples.into()), + ); let mut sensors = SensAppVec::new(); sensors.push(single_sensor_batch); let batch = Arc::new(Batch::new(sensors)); @@ -295,7 +313,10 @@ mod rrdcached_tests { // (since unsupported types are filtered out in the create_sensors method) let sensors = storage.list_series(None).await?; let found_sensor = sensors.iter().find(|s| s.uuid == string_sensor_arc.uuid); - assert!(found_sensor.is_none(), "Unsupported sensor types should not be created"); + assert!( + found_sensor.is_none(), + "Unsupported sensor types should not be created" + ); Ok(()) } @@ -331,7 +352,8 @@ mod rrdcached_tests { // Publish the data let sensor_arc = Arc::new(sensor); - let single_sensor_batch = SingleSensorBatch::new(sensor_arc.clone(), TypedSamples::Float(samples.into())); + let single_sensor_batch = + SingleSensorBatch::new(sensor_arc.clone(), TypedSamples::Float(samples.into())); let mut sensors = SensAppVec::new(); sensors.push(single_sensor_batch); let batch = Arc::new(Batch::new(sensors)); @@ -345,8 +367,9 @@ mod rrdcached_tests { // When: We query the data back with the specific time range let start_time = Some(SensAppDateTime::from_unix_seconds(base_time - 10.0)); // Start before our data let end_time = Some(SensAppDateTime::from_unix_seconds(base_time + 10.0)); // End after our data - let sensor_data = storage.query_sensor_data(&sensor_uuid.to_string(), start_time, end_time, None).await?; - + let sensor_data = storage + .query_sensor_data(&sensor_uuid.to_string(), start_time, end_time, None) + .await?; // Then: We should get back the data we stored assert!(sensor_data.is_some(), "Query should return data"); @@ -358,12 +381,18 @@ mod rrdcached_tests { // Verify samples (may not be exact due to RRD time alignment and consolidation) if let TypedSamples::Float(returned_samples) = sensor_data.samples { - assert!(!returned_samples.is_empty(), "Should have returned some samples"); - + assert!( + !returned_samples.is_empty(), + "Should have returned some samples" + ); + // We may not get exact values due to RRD consolidation, but let's check we get reasonable data for sample in &returned_samples { assert!(!sample.value.is_nan(), "Sample values should not be NaN"); - println!("Retrieved sample: time={:?}, value={}", sample.datetime, sample.value); + println!( + "Retrieved sample: time={:?}, value={}", + sample.datetime, sample.value + ); } } else { panic!("Expected Float samples, got: {:?}", sensor_data.samples); @@ -400,7 +429,8 @@ mod rrdcached_tests { // Publish the data let sensor_arc = Arc::new(sensor); - let single_sensor_batch = SingleSensorBatch::new(sensor_arc.clone(), TypedSamples::Float(samples.into())); + let single_sensor_batch = + SingleSensorBatch::new(sensor_arc.clone(), TypedSamples::Float(samples.into())); let mut sensors = SensAppVec::new(); sensors.push(single_sensor_batch); let batch = Arc::new(Batch::new(sensors)); @@ -414,24 +444,30 @@ mod rrdcached_tests { // When: We query with a time range (first 5 minutes with buffer) let start_time = Some(SensAppDateTime::from_unix_seconds(base_time - 60.0)); // Start 1 minute before let end_time = Some(SensAppDateTime::from_unix_seconds(base_time + 360.0)); // End 6 minutes after start - - let sensor_data = storage.query_sensor_data( - &sensor_uuid.to_string(), - start_time, - end_time, - None - ).await?; + + let sensor_data = storage + .query_sensor_data(&sensor_uuid.to_string(), start_time, end_time, None) + .await?; // Then: We should get data within the time range - assert!(sensor_data.is_some(), "Query with time range should return data"); + assert!( + sensor_data.is_some(), + "Query with time range should return data" + ); let sensor_data = sensor_data.unwrap(); if let TypedSamples::Float(returned_samples) = sensor_data.samples { - assert!(!returned_samples.is_empty(), "Should have returned samples in time range"); - + assert!( + !returned_samples.is_empty(), + "Should have returned samples in time range" + ); + for sample in &returned_samples { let sample_time = sample.datetime.to_unix_seconds(); - println!("Sample in range: time={}, value={}", sample_time, sample.value); + println!( + "Sample in range: time={}, value={}", + sample_time, sample.value + ); // Note: RRD may return data slightly outside the range due to consolidation } } else { @@ -451,10 +487,15 @@ mod rrdcached_tests { // When: We query a sensor that doesn't exist let non_existent_uuid = Uuid::new_v4(); - let sensor_data = storage.query_sensor_data(&non_existent_uuid.to_string(), None, None, None).await?; + let sensor_data = storage + .query_sensor_data(&non_existent_uuid.to_string(), None, None, None) + .await?; // Then: We should get None - assert!(sensor_data.is_none(), "Query for non-existent sensor should return None"); + assert!( + sensor_data.is_none(), + "Query for non-existent sensor should return None" + ); Ok(()) } @@ -480,7 +521,10 @@ mod rrdcached_tests { // Create the sensor without publishing any data let sensor_arc = Arc::new(sensor); let empty_samples: Vec> = vec![]; - let single_sensor_batch = SingleSensorBatch::new(sensor_arc.clone(), TypedSamples::Float(empty_samples.into())); + let single_sensor_batch = SingleSensorBatch::new( + sensor_arc.clone(), + TypedSamples::Float(empty_samples.into()), + ); let mut sensors = SensAppVec::new(); sensors.push(single_sensor_batch); let batch = Arc::new(Batch::new(sensors)); @@ -489,10 +533,15 @@ mod rrdcached_tests { storage.publish(batch, sync_sender.clone()).await?; // When: We query the sensor - let sensor_data = storage.query_sensor_data(&sensor_uuid.to_string(), None, None, None).await?; + let sensor_data = storage + .query_sensor_data(&sensor_uuid.to_string(), None, None, None) + .await?; // Then: We should get None (no data available) - assert!(sensor_data.is_none(), "Query for sensor with no data should return None"); + assert!( + sensor_data.is_none(), + "Query for sensor with no data should return None" + ); Ok(()) } @@ -529,7 +578,10 @@ mod rrdcached_tests { // Publish the integer data let sensor_arc = Arc::new(sensor); - let single_sensor_batch = SingleSensorBatch::new(sensor_arc.clone(), TypedSamples::Integer(int_samples.into())); + let single_sensor_batch = SingleSensorBatch::new( + sensor_arc.clone(), + TypedSamples::Integer(int_samples.into()), + ); let mut sensors = SensAppVec::new(); sensors.push(single_sensor_batch); let batch = Arc::new(Batch::new(sensors)); @@ -543,7 +595,9 @@ mod rrdcached_tests { // When: We query the data back with time range let start_time = Some(SensAppDateTime::from_unix_seconds(base_time - 10.0)); // Start before our data let end_time = Some(SensAppDateTime::from_unix_seconds(base_time + 10.0)); // End after our data - let sensor_data = storage.query_sensor_data(&sensor_uuid.to_string(), start_time, end_time, None).await?; + let sensor_data = storage + .query_sensor_data(&sensor_uuid.to_string(), start_time, end_time, None) + .await?; // Then: We should get back Float data (since RRD stores everything as f64) // Note: This shows a limitation - we lose the original type information @@ -554,10 +608,16 @@ mod rrdcached_tests { assert_eq!(sensor_data.sensor.sensor_type, SensorType::Float); if let TypedSamples::Float(returned_samples) = sensor_data.samples { - assert!(!returned_samples.is_empty(), "Should have returned some samples"); - + assert!( + !returned_samples.is_empty(), + "Should have returned some samples" + ); + for sample in &returned_samples { - println!("Retrieved integer-as-float sample: time={:?}, value={}", sample.datetime, sample.value); + println!( + "Retrieved integer-as-float sample: time={:?}, value={}", + sample.datetime, sample.value + ); // Values should be close to the original integers (42.0, 84.0) assert!(!sample.value.is_nan(), "Sample values should not be NaN"); } @@ -567,4 +627,4 @@ mod rrdcached_tests { Ok(()) } -} \ No newline at end of file +} From 8b90b29034dbb3703e06ca0274e07095257f428d Mon Sep 17 00:00:00 2001 From: Antoine Pultier <45740+fungiboletus@users.noreply.github.com> Date: Fri, 17 Oct 2025 16:34:05 +0200 Subject: [PATCH 03/39] =?UTF-8?q?feat:=20=E2=AC=86=EF=B8=8F=20Dependencies?= =?UTF-8?q?=20update?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- Cargo.lock | 2197 +++++++++++----------------------------------------- Cargo.toml | 84 +- README.md | 18 +- 3 files changed, 514 insertions(+), 1785 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index fe0dea7..a1a127f 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -8,7 +8,7 @@ version = "0.5.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "5f7b0a21988c1bf877cf4759ef5ddaac04c1c9fe808c9142ecb78ba97d97a28a" dependencies = [ - "bitflags 2.9.2", + "bitflags", "bytes", "futures-core", "futures-sink", @@ -30,7 +30,7 @@ dependencies = [ "actix-service", "actix-utils", "base64 0.22.1", - "bitflags 2.9.2", + "bitflags", "bytes", "bytestring", "derive_more", @@ -291,9 +291,9 @@ dependencies = [ [[package]] name = "anyhow" -version = "1.0.99" +version = "1.0.100" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b0674a1ddeecb70197781e945de4b3b8ffb61fa939a5597bcf48503737663100" +checksum = "a23eb6b1614318a8071c9b2521f36b424b2c83db5eb3a0fead4a6c0809af6e61" [[package]] name = "approx" @@ -304,21 +304,6 @@ dependencies = [ "num-traits", ] -[[package]] -name = "argminmax" -version = "0.6.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "70f13d10a41ac8d2ec79ee34178d61e6f47a29c2edfe7ef1721c7383b0359e65" -dependencies = [ - "num-traits", -] - -[[package]] -name = "array-init-cursor" -version = "0.2.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ed51fe0f224d1d4ea768be38c51f9f831dee9d05c163c11fba0b8c44387b1fc3" - [[package]] name = "arraydeque" version = "0.5.1" @@ -339,119 +324,60 @@ checksum = "7c02d123df017efcdfbd739ef81735b36c5ba83ec3c59c80a9d7ecc718f92e50" [[package]] name = "arrow" -version = "54.3.1" +version = "56.2.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b5ec52ba94edeed950e4a41f75d35376df196e8cb04437f7280a5aa49f20f796" +checksum = "6e833808ff2d94ed40d9379848a950d995043c7fb3e81a30b383f4c6033821cc" dependencies = [ - "arrow-arith 54.3.1", - "arrow-array 54.3.1", - "arrow-buffer 54.3.1", - "arrow-cast 54.3.1", + "arrow-arith", + "arrow-array", + "arrow-buffer", + "arrow-cast", "arrow-csv", - "arrow-data 54.3.1", + "arrow-data", "arrow-ipc", "arrow-json", - "arrow-ord 54.3.1", - "arrow-row 54.3.1", - "arrow-schema 54.3.1", - "arrow-select 54.3.1", - "arrow-string 54.3.1", -] - -[[package]] -name = "arrow" -version = "55.2.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f3f15b4c6b148206ff3a2b35002e08929c2462467b62b9c02036d9c34f9ef994" -dependencies = [ - "arrow-arith 55.2.0", - "arrow-array 55.2.0", - "arrow-buffer 55.2.0", - "arrow-cast 55.2.0", - "arrow-data 55.2.0", - "arrow-ord 55.2.0", - "arrow-row 55.2.0", - "arrow-schema 55.2.0", - "arrow-select 55.2.0", - "arrow-string 55.2.0", -] - -[[package]] -name = "arrow-arith" -version = "54.3.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8fc766fdacaf804cb10c7c70580254fcdb5d55cdfda2bc57b02baf5223a3af9e" -dependencies = [ - "arrow-array 54.3.1", - "arrow-buffer 54.3.1", - "arrow-data 54.3.1", - "arrow-schema 54.3.1", - "chrono", - "num", + "arrow-ord", + "arrow-row", + "arrow-schema", + "arrow-select", + "arrow-string", ] [[package]] name = "arrow-arith" -version = "55.2.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "30feb679425110209ae35c3fbf82404a39a4c0436bb3ec36164d8bffed2a4ce4" -dependencies = [ - "arrow-array 55.2.0", - "arrow-buffer 55.2.0", - "arrow-data 55.2.0", - "arrow-schema 55.2.0", - "chrono", - "num", -] - -[[package]] -name = "arrow-array" -version = "54.3.1" +version = "56.2.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a12fcdb3f1d03f69d3ec26ac67645a8fe3f878d77b5ebb0b15d64a116c212985" +checksum = "ad08897b81588f60ba983e3ca39bda2b179bdd84dced378e7df81a5313802ef8" dependencies = [ - "ahash 0.8.12", - "arrow-buffer 54.3.1", - "arrow-data 54.3.1", - "arrow-schema 54.3.1", + "arrow-array", + "arrow-buffer", + "arrow-data", + "arrow-schema", "chrono", - "half", - "hashbrown 0.15.5", "num", ] [[package]] name = "arrow-array" -version = "55.2.0" +version = "56.2.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "70732f04d285d49054a48b72c54f791bb3424abae92d27aafdf776c98af161c8" +checksum = "8548ca7c070d8db9ce7aa43f37393e4bfcf3f2d3681df278490772fd1673d08d" dependencies = [ "ahash 0.8.12", - "arrow-buffer 55.2.0", - "arrow-data 55.2.0", - "arrow-schema 55.2.0", + "arrow-buffer", + "arrow-data", + "arrow-schema", "chrono", "half", - "hashbrown 0.15.5", - "num", -] - -[[package]] -name = "arrow-buffer" -version = "54.3.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "263f4801ff1839ef53ebd06f99a56cecd1dbaf314ec893d93168e2e860e0291c" -dependencies = [ - "bytes", - "half", + "hashbrown 0.16.0", "num", ] [[package]] name = "arrow-buffer" -version = "55.2.0" +version = "56.2.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "169b1d5d6cb390dd92ce582b06b23815c7953e9dfaaea75556e89d890d19993d" +checksum = "e003216336f70446457e280807a73899dd822feaf02087d31febca1363e2fccc" dependencies = [ "bytes", "half", @@ -460,35 +386,15 @@ dependencies = [ [[package]] name = "arrow-cast" -version = "54.3.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ede6175fbc039dfc946a61c1b6d42fd682fcecf5ab5d148fbe7667705798cac9" -dependencies = [ - "arrow-array 54.3.1", - "arrow-buffer 54.3.1", - "arrow-data 54.3.1", - "arrow-schema 54.3.1", - "arrow-select 54.3.1", - "atoi", - "base64 0.22.1", - "chrono", - "half", - "lexical-core", - "num", - "ryu", -] - -[[package]] -name = "arrow-cast" -version = "55.2.0" +version = "56.2.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e4f12eccc3e1c05a766cafb31f6a60a46c2f8efec9b74c6e0648766d30686af8" +checksum = "919418a0681298d3a77d1a315f625916cb5678ad0d74b9c60108eb15fd083023" dependencies = [ - "arrow-array 55.2.0", - "arrow-buffer 55.2.0", - "arrow-data 55.2.0", - "arrow-schema 55.2.0", - "arrow-select 55.2.0", + "arrow-array", + "arrow-buffer", + "arrow-data", + "arrow-schema", + "arrow-select", "atoi", "base64 0.22.1", "chrono", @@ -501,71 +407,59 @@ dependencies = [ [[package]] name = "arrow-csv" -version = "54.3.1" +version = "56.2.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1644877d8bc9a0ef022d9153dc29375c2bda244c39aec05a91d0e87ccf77995f" +checksum = "bfa9bf02705b5cf762b6f764c65f04ae9082c7cfc4e96e0c33548ee3f67012eb" dependencies = [ - "arrow-array 54.3.1", - "arrow-cast 54.3.1", - "arrow-schema 54.3.1", + "arrow-array", + "arrow-cast", + "arrow-schema", "chrono", "csv", "csv-core", - "lazy_static", "regex", ] [[package]] name = "arrow-data" -version = "54.3.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "61cfdd7d99b4ff618f167e548b2411e5dd2c98c0ddebedd7df433d34c20a4429" -dependencies = [ - "arrow-buffer 54.3.1", - "arrow-schema 54.3.1", - "half", - "num", -] - -[[package]] -name = "arrow-data" -version = "55.2.0" +version = "56.2.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8de1ce212d803199684b658fc4ba55fb2d7e87b213de5af415308d2fee3619c2" +checksum = "a5c64fff1d142f833d78897a772f2e5b55b36cb3e6320376f0961ab0db7bd6d0" dependencies = [ - "arrow-buffer 55.2.0", - "arrow-schema 55.2.0", + "arrow-buffer", + "arrow-schema", "half", "num", ] [[package]] name = "arrow-ipc" -version = "54.3.1" +version = "56.2.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "62ff528658b521e33905334723b795ee56b393dbe9cf76c8b1f64b648c65a60c" +checksum = "1d3594dcddccc7f20fd069bc8e9828ce37220372680ff638c5e00dea427d88f5" dependencies = [ - "arrow-array 54.3.1", - "arrow-buffer 54.3.1", - "arrow-data 54.3.1", - "arrow-schema 54.3.1", + "arrow-array", + "arrow-buffer", + "arrow-data", + "arrow-schema", + "arrow-select", "flatbuffers", ] [[package]] name = "arrow-json" -version = "54.3.1" +version = "56.2.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0ee5b4ca98a7fb2efb9ab3309a5d1c88b5116997ff93f3147efdc1062a6158e9" +checksum = "88cf36502b64a127dc659e3b305f1d993a544eab0d48cce704424e62074dc04b" dependencies = [ - "arrow-array 54.3.1", - "arrow-buffer 54.3.1", - "arrow-cast 54.3.1", - "arrow-data 54.3.1", - "arrow-schema 54.3.1", + "arrow-array", + "arrow-buffer", + "arrow-cast", + "arrow-data", + "arrow-schema", "chrono", "half", - "indexmap 2.10.0", + "indexmap", "lexical-core", "memchr", "num", @@ -576,143 +470,68 @@ dependencies = [ [[package]] name = "arrow-ord" -version = "54.3.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f0a3334a743bd2a1479dbc635540617a3923b4b2f6870f37357339e6b5363c21" -dependencies = [ - "arrow-array 54.3.1", - "arrow-buffer 54.3.1", - "arrow-data 54.3.1", - "arrow-schema 54.3.1", - "arrow-select 54.3.1", -] - -[[package]] -name = "arrow-ord" -version = "55.2.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6506e3a059e3be23023f587f79c82ef0bcf6d293587e3272d20f2d30b969b5a7" -dependencies = [ - "arrow-array 55.2.0", - "arrow-buffer 55.2.0", - "arrow-data 55.2.0", - "arrow-schema 55.2.0", - "arrow-select 55.2.0", -] - -[[package]] -name = "arrow-row" -version = "54.3.1" +version = "56.2.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8d1d7a7291d2c5107e92140f75257a99343956871f3d3ab33a7b41532f79cb68" +checksum = "3c8f82583eb4f8d84d4ee55fd1cb306720cddead7596edce95b50ee418edf66f" dependencies = [ - "arrow-array 54.3.1", - "arrow-buffer 54.3.1", - "arrow-data 54.3.1", - "arrow-schema 54.3.1", - "half", + "arrow-array", + "arrow-buffer", + "arrow-data", + "arrow-schema", + "arrow-select", ] [[package]] name = "arrow-row" -version = "55.2.0" +version = "56.2.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "52bf7393166beaf79b4bed9bfdf19e97472af32ce5b6b48169d321518a08cae2" +checksum = "9d07ba24522229d9085031df6b94605e0f4b26e099fb7cdeec37abd941a73753" dependencies = [ - "arrow-array 55.2.0", - "arrow-buffer 55.2.0", - "arrow-data 55.2.0", - "arrow-schema 55.2.0", + "arrow-array", + "arrow-buffer", + "arrow-data", + "arrow-schema", "half", ] [[package]] name = "arrow-schema" -version = "54.3.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "39cfaf5e440be44db5413b75b72c2a87c1f8f0627117d110264048f2969b99e9" - -[[package]] -name = "arrow-schema" -version = "55.2.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "af7686986a3bf2254c9fb130c623cdcb2f8e1f15763e7c71c310f0834da3d292" -dependencies = [ - "bitflags 2.9.2", -] - -[[package]] -name = "arrow-select" -version = "54.3.1" +version = "56.2.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "69efcd706420e52cd44f5c4358d279801993846d1c2a8e52111853d61d55a619" +checksum = "b3aa9e59c611ebc291c28582077ef25c97f1975383f1479b12f3b9ffee2ffabe" dependencies = [ - "ahash 0.8.12", - "arrow-array 54.3.1", - "arrow-buffer 54.3.1", - "arrow-data 54.3.1", - "arrow-schema 54.3.1", - "num", + "bitflags", ] [[package]] name = "arrow-select" -version = "55.2.0" +version = "56.2.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "dd2b45757d6a2373faa3352d02ff5b54b098f5e21dccebc45a21806bc34501e5" +checksum = "8c41dbbd1e97bfcaee4fcb30e29105fb2c75e4d82ae4de70b792a5d3f66b2e7a" dependencies = [ "ahash 0.8.12", - "arrow-array 55.2.0", - "arrow-buffer 55.2.0", - "arrow-data 55.2.0", - "arrow-schema 55.2.0", - "num", -] - -[[package]] -name = "arrow-string" -version = "54.3.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a21546b337ab304a32cfc0770f671db7411787586b45b78b4593ae78e64e2b03" -dependencies = [ - "arrow-array 54.3.1", - "arrow-buffer 54.3.1", - "arrow-data 54.3.1", - "arrow-schema 54.3.1", - "arrow-select 54.3.1", - "memchr", + "arrow-array", + "arrow-buffer", + "arrow-data", + "arrow-schema", "num", - "regex", - "regex-syntax 0.8.5", ] [[package]] name = "arrow-string" -version = "55.2.0" +version = "56.2.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0377d532850babb4d927a06294314b316e23311503ed580ec6ce6a0158f49d40" +checksum = "53f5183c150fbc619eede22b861ea7c0eebed8eaac0333eaa7f6da5205fd504d" dependencies = [ - "arrow-array 55.2.0", - "arrow-buffer 55.2.0", - "arrow-data 55.2.0", - "arrow-schema 55.2.0", - "arrow-select 55.2.0", + "arrow-array", + "arrow-buffer", + "arrow-data", + "arrow-schema", + "arrow-select", "memchr", "num", "regex", - "regex-syntax 0.8.5", -] - -[[package]] -name = "async-channel" -version = "2.5.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "924ed96dd52d1b75e9c1a3e6275715fd320f5f9439fb5a4a11fa51f4221158d2" -dependencies = [ - "concurrent-queue", - "event-listener-strategy", - "futures-core", - "pin-project-lite", + "regex-syntax", ] [[package]] @@ -773,15 +592,6 @@ dependencies = [ "num-traits", ] -[[package]] -name = "atoi_simd" -version = "0.16.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c2a49e05797ca52e312a0c658938b7d00693ef037799ef7187678f212d7684cf" -dependencies = [ - "debug_unsafe", -] - [[package]] name = "atomic-waker" version = "1.1.2" @@ -796,9 +606,9 @@ checksum = "c08606f8c3cbf4ce6ec8e28fb0014a2c086708fe954eaa885384a6165172e7e8" [[package]] name = "aws-lc-rs" -version = "1.13.3" +version = "1.14.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5c953fe1ba023e6b7730c0d4b031d06f267f23a46167dcbd40316644b10a17ba" +checksum = "879b6c89592deb404ba4dc0ae6b58ffd1795c78991cbb5b8bc441c48a070440d" dependencies = [ "aws-lc-sys", "zeroize", @@ -806,9 +616,9 @@ dependencies = [ [[package]] name = "aws-lc-sys" -version = "0.30.0" +version = "0.32.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "dbfd150b5dbdb988bcc8fb1fe787eb6b7ee6180ca24da683b61ea5405f3d43ff" +checksum = "107a4e9d9cab9963e04e84bb8dee0e25f2a987f9a8bad5ed054abd439caa8f8c" dependencies = [ "bindgen", "cc", @@ -819,9 +629,9 @@ dependencies = [ [[package]] name = "axum" -version = "0.8.4" +version = "0.8.6" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "021e862c184ae977658b36c4500f7feac3221ca5da43e3f25bd04ab6c79a29b5" +checksum = "8a18ed336352031311f4e0b4dd2ff392d4fbb370777c9d18d7fc9d7359f73871" dependencies = [ "axum-core", "axum-macros", @@ -840,14 +650,13 @@ dependencies = [ "multer", "percent-encoding", "pin-project-lite", - "rustversion", - "serde", + "serde_core", "serde_json", "serde_path_to_error", "serde_urlencoded", "sync_wrapper", "tokio", - "tower 0.5.2", + "tower", "tower-layer", "tower-service", "tracing", @@ -855,9 +664,9 @@ dependencies = [ [[package]] name = "axum-core" -version = "0.5.2" +version = "0.5.5" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "68464cd0412f486726fb3373129ef5d2993f90c34bc2bc1c1e9943b2f4fc7ca6" +checksum = "59446ce19cd142f8833f856eb31f3eb097812d1479ab224f54d72428ca21ea22" dependencies = [ "bytes", "futures-core", @@ -866,7 +675,6 @@ dependencies = [ "http-body-util", "mime", "pin-project-lite", - "rustversion", "sync_wrapper", "tower-layer", "tower-service", @@ -942,60 +750,31 @@ dependencies = [ "num-traits", ] -[[package]] -name = "bincode" -version = "2.0.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "36eaf5d7b090263e8150820482d5d93cd964a81e4019913c972f4edcc6edb740" -dependencies = [ - "bincode_derive", - "serde", - "unty", -] - -[[package]] -name = "bincode_derive" -version = "2.0.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "bf95709a440f45e986983918d0e8a1f30a9b1df04918fc828670606804ac3c09" -dependencies = [ - "virtue", -] - [[package]] name = "bindgen" -version = "0.69.5" +version = "0.72.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "271383c67ccabffb7381723dea0672a673f292304fcb45c01cc648c7a8d58088" +checksum = "993776b509cfb49c750f11b8f07a46fa23e0a1386ffc01fb1e7d343efc387895" dependencies = [ - "bitflags 2.9.2", + "bitflags", "cexpr", "clang-sys", "itertools 0.12.1", - "lazy_static", - "lazycell", "log", "prettyplease", "proc-macro2", "quote", "regex", - "rustc-hash 1.1.0", + "rustc-hash", "shlex", "syn 2.0.106", - "which", ] [[package]] name = "bitflags" -version = "1.3.2" +version = "2.9.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a" - -[[package]] -name = "bitflags" -version = "2.9.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6a65b545ab31d687cff52899d4890855fec459eb6afe0da6417b8a18da87aa29" +checksum = "2261d10cca569e4643e526d8dc2e62e433cc8aba21ab764233731f8d369bf394" dependencies = [ "serde", ] @@ -1057,12 +836,6 @@ dependencies = [ "syn 2.0.106", ] -[[package]] -name = "boxcar" -version = "0.2.14" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "36f64beae40a84da1b4b26ff2761a5b895c12adc41dc25aaee1c4f2bbfe97a6e" - [[package]] name = "brotli" version = "8.0.2" @@ -1132,26 +905,6 @@ dependencies = [ "syn 1.0.109", ] -[[package]] -name = "bytemuck" -version = "1.23.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3995eaeebcdf32f91f980d360f78732ddc061097ab4e39991ae7a6ace9194677" -dependencies = [ - "bytemuck_derive", -] - -[[package]] -name = "bytemuck_derive" -version = "1.10.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4f154e572231cb6ba2bd1176980827e3d5dc04cc183a75dea38109fbdd672d29" -dependencies = [ - "proc-macro2", - "quote", - "syn 2.0.106", -] - [[package]] name = "byteorder" version = "1.5.0" @@ -1163,9 +916,6 @@ name = "bytes" version = "1.10.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "d71b6127be86fdcfddb610f7182ac57211d4b18a3e9c82eb2d17662f2227ad6a" -dependencies = [ - "serde", -] [[package]] name = "bytestring" @@ -1189,7 +939,7 @@ dependencies = [ "futures", "hashbrown 0.15.5", "once_cell", - "thiserror 2.0.15", + "thiserror 2.0.17", "tokio", "web-time", ] @@ -1218,15 +968,6 @@ version = "0.3.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "37b2a672a2cb129a2e41c10b1224bb368f9f37a2b16b612598138befd7b37eb5" -[[package]] -name = "castaway" -version = "0.2.4" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "dec551ab6e7578819132c713a93c022a05d60159dc86e7a7050223577484c55a" -dependencies = [ - "rustversion", -] - [[package]] name = "cc" version = "1.2.33" @@ -1271,17 +1012,7 @@ dependencies = [ "num-traits", "serde", "wasm-bindgen", - "windows-link", -] - -[[package]] -name = "chrono-tz" -version = "0.10.4" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a6139a8597ed92cf816dfb33f5dd6cf0bb93a6adc938f11039f371bc5bcd26c3" -dependencies = [ - "chrono", - "phf", + "windows-link 0.1.3", ] [[package]] @@ -1303,9 +1034,9 @@ dependencies = [ [[package]] name = "clap" -version = "4.5.45" +version = "4.5.49" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1fc0e74a703892159f5ae7d3aac52c8e6c392f5ae5f359c70b5881d60aaac318" +checksum = "f4512b90fa68d3a9932cea5184017c5d200f5921df706d45e853537dea51508f" dependencies = [ "clap_builder", "clap_derive", @@ -1313,9 +1044,9 @@ dependencies = [ [[package]] name = "clap_builder" -version = "4.5.44" +version = "4.5.49" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b3e7f4214277f3c7aa526a59dd3fbe306a370daee1f8b7b8c987069cd8e888a8" +checksum = "0025e98baa12e766c67ba13ff4695a887a1eba19569aad00a472546795bd6730" dependencies = [ "anstream", "anstyle", @@ -1325,9 +1056,9 @@ dependencies = [ [[package]] name = "clap_derive" -version = "4.5.45" +version = "4.5.49" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "14cb31bb0a7d536caef2639baa7fad459e15c3144efefa6dbd1c84562c4739f6" +checksum = "2a0b5487afeab2deb2ff4e03a807ad1a03ac532ff5a2cee5d86884440c7f7671" dependencies = [ "heck 0.5.0", "proc-macro2", @@ -1343,16 +1074,17 @@ checksum = "b94f61472cee1439c0b966b47e3aca9ae07e45d070759512cd390ea2bebc6675" [[package]] name = "clickhouse" -version = "0.13.3" +version = "0.14.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9a9a81a1dffadd762ee662635ce409232258ce9beebd7cc0fa227df0b5e7efc0" +checksum = "52d6ac02411e84914fdf4e0565bfe02fc4bebdf375bd1fc58168bad74b3707a2" dependencies = [ "bstr", "bytes", "cityhash-rs", - "clickhouse-derive", - "futures", + "clickhouse-macros", + "clickhouse-types", "futures-channel", + "futures-util", "http-body-util", "hyper", "hyper-util", @@ -1362,7 +1094,7 @@ dependencies = [ "sealed", "serde", "static_assertions", - "thiserror 1.0.69", + "thiserror 2.0.17", "time", "tokio", "url", @@ -1370,10 +1102,10 @@ dependencies = [ ] [[package]] -name = "clickhouse-derive" -version = "0.2.0" +name = "clickhouse-macros" +version = "0.3.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d70f3e2893f7d3e017eeacdc9a708fbc29a10488e3ebca21f9df6a5d2b616dbb" +checksum = "ff6669899e23cb87b43daf7996f0ea3b9c07d0fb933d745bb7b815b052515ae3" dependencies = [ "proc-macro2", "quote", @@ -1381,6 +1113,16 @@ dependencies = [ "syn 2.0.106", ] +[[package]] +name = "clickhouse-types" +version = "0.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "235f72141cfbe1d2d930d8156a34814c8a3d60491febb9af64cc52a203444764" +dependencies = [ + "bytes", + "thiserror 2.0.17", +] + [[package]] name = "clru" version = "0.6.2" @@ -1404,30 +1146,15 @@ checksum = "b05b61dc5112cbb17e4b6cd61790d9845d13888356391624cbe7e41efeac1e75" [[package]] name = "comfy-table" -version = "7.1.4" +version = "7.1.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4a65ebfec4fb190b6f90e944a817d60499ee0744e582530e2c9900a22e591d9a" +checksum = "e0d05af1e006a2407bedef5af410552494ce5be9090444dbbcb57258c1af3d56" dependencies = [ - "crossterm", - "unicode-segmentation", + "strum 0.26.3", + "strum_macros 0.26.4", "unicode-width", ] -[[package]] -name = "compact_str" -version = "0.9.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3fdb1325a1cece981e8a296ab8f0f9b63ae357bd0784a9faaf548cc7b480707a" -dependencies = [ - "castaway", - "cfg-if", - "itoa", - "rustversion", - "ryu", - "serde", - "static_assertions", -] - [[package]] name = "concurrent-queue" version = "2.5.0" @@ -1439,9 +1166,9 @@ dependencies = [ [[package]] name = "config" -version = "0.15.14" +version = "0.15.18" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "aa4092bf3922a966e2bd74640b80f36c73eaa7251a4fd0fbcda1f8a4de401352" +checksum = "180e549344080374f9b32ed41bf3b6b57885ff6a289367b3dbc10eea8acc1918" dependencies = [ "async-trait", "convert_case", @@ -1449,8 +1176,8 @@ dependencies = [ "pathdiff", "ron", "rust-ini", - "serde", "serde-untagged", + "serde_core", "serde_json", "toml", "winnow", @@ -1580,15 +1307,6 @@ dependencies = [ "cfg-if", ] -[[package]] -name = "crossbeam-channel" -version = "0.5.15" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "82b8f8f868b36967f9606790d1903570de9ceaf870a7bf9fbbd3016d636a2cb2" -dependencies = [ - "crossbeam-utils", -] - [[package]] name = "crossbeam-deque" version = "0.8.6" @@ -1623,28 +1341,6 @@ version = "0.8.21" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "d0a5c400df2834b80a4c3327b3aad3a4c4cd4de0629063962b03235697506a28" -[[package]] -name = "crossterm" -version = "0.28.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "829d955a0bb380ef178a640b91779e3987da38c9aea133b20614cfed8cdea9c6" -dependencies = [ - "bitflags 2.9.2", - "crossterm_winapi", - "parking_lot", - "rustix 0.38.44", - "winapi", -] - -[[package]] -name = "crossterm_winapi" -version = "0.9.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "acdd7c62a3665c7f6830a51635d9ac9b23ed385797f70a83bb8bafe9c572ab2b" -dependencies = [ - "winapi", -] - [[package]] name = "crunchy" version = "0.2.4" @@ -1732,10 +1428,22 @@ dependencies = [ ] [[package]] -name = "debug_unsafe" -version = "0.1.3" +name = "deadpool" +version = "0.12.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "85d3cef41d236720ed453e102153a53e4cc3d2fde848c0078a50cf249e8e3e5b" +checksum = "0be2b1d1d6ec8d846f05e137292d0b89133caf95ef33695424c09568bdd39b1b" +dependencies = [ + "deadpool-runtime", + "lazy_static", + "num_cpus", + "tokio", +] + +[[package]] +name = "deadpool-runtime" +version = "0.1.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "092966b41edc516079bdf31ec78a2e0588d1d0c08f78b91d8307215928642b2b" [[package]] name = "debugid" @@ -1760,12 +1468,12 @@ dependencies = [ [[package]] name = "deranged" -version = "0.4.0" +version = "0.5.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9c9e6a11ca8224451684bc0d7d5a7adbf8f2fd6887261a1cfc3c0432f9d4068e" +checksum = "a41953f86f8a05768a6cda24def994fd2f424b04ec5c719cf89989779f199071" dependencies = [ "powerfmt", - "serde", + "serde_core", ] [[package]] @@ -1835,11 +1543,11 @@ checksum = "1aaf95b3e5c8f23aa320147307562d361db0ae0d51242340f558153b4eb2439b" [[package]] name = "duckdb" -version = "1.3.2" +version = "1.4.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "07ab83a22530667ffc8cc0e31c0549bb07bea5dba3b957a8e315effc38923701" +checksum = "2a093eed1c714143b257b95fa323e38527fabf05fbf02bb0d5d2045275ffdaef" dependencies = [ - "arrow 55.2.0", + "arrow", "cast", "fallible-iterator", "fallible-streaming-iterator", @@ -1847,8 +1555,7 @@ dependencies = [ "libduckdb-sys", "num-integer", "rust_decimal", - "smallvec 1.15.1", - "strum", + "strum 0.27.2", ] [[package]] @@ -1928,12 +1635,6 @@ dependencies = [ "windows-sys 0.48.0", ] -[[package]] -name = "ethnum" -version = "1.5.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ca81e6b4777c89fd810c25a4be2b1bd93ea034fbe58e6a75216a34c6b82c539b" - [[package]] name = "event-listener" version = "5.4.1" @@ -1945,16 +1646,6 @@ dependencies = [ "pin-project-lite", ] -[[package]] -name = "event-listener-strategy" -version = "0.5.4" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8be9f3dfaaffdae2972880079a491a1a8bb7cbed0b8dd7a347f668b4150a3b93" -dependencies = [ - "event-listener", - "pin-project-lite", -] - [[package]] name = "fallible-iterator" version = "0.3.0" @@ -1967,12 +1658,6 @@ version = "0.1.9" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "7360491ce676a36bf9bb3c56c1aa791658183a54d2744120f27285738d90465a" -[[package]] -name = "fast-float2" -version = "0.2.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f8eb564c5c7423d25c886fb561d1e4ee69f72354d16918afa32c08811f6b6a55" - [[package]] name = "fastrand" version = "2.3.0" @@ -2011,19 +1696,19 @@ checksum = "1d674e81391d1e1ab681a28d99df07927c6d4aa5b027d7da16ba32d1d21ecd99" [[package]] name = "flatbuffers" -version = "24.12.23" +version = "25.9.23" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4f1baf0dbf96932ec9a3038d57900329c015b0bfb7b63d904f3bc27e2b02a096" +checksum = "09b6620799e7340ebd9968d2e0708eb82cf1971e9a16821e2091b6d6e475eed5" dependencies = [ - "bitflags 1.3.2", + "bitflags", "rustc_version", ] [[package]] name = "flate2" -version = "1.1.2" +version = "1.1.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4a3d7db9596fecd151c5f638c0ee5d5bd487b6e0ea232e5dc96d5250f6f94b1d" +checksum = "dc5a4e564e38c699f2880d3fda590bedc2e69f3f84cd48b457bd892ce61d0aa9" dependencies = [ "crc32fast", "miniz_oxide", @@ -2075,26 +1760,16 @@ checksum = "00b0228411908ca8685dba7fc2cdd70ec9990a6e753e89b6ac91a84c40fbaf4b" [[package]] name = "form_urlencoded" -version = "1.2.1" +version = "1.2.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e13624c2627564efccf4934284bdd98cbaa14e79b0b5a141218e507b3a823456" +checksum = "cb4cb245038516f5f85277875cdaa4f7d2c9a0fa0468de06ed190163b1581fcf" dependencies = [ "percent-encoding", ] [[package]] -name = "fs4" -version = "0.13.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8640e34b88f7652208ce9e88b1a37a2ae95227d84abec377ccd3c5cfeb141ed4" -dependencies = [ - "rustix 1.0.8", - "windows-sys 0.59.0", -] - -[[package]] -name = "fs_extra" -version = "1.3.0" +name = "fs_extra" +version = "1.3.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "42703706b716c37f96a77aea830392ad231f44c9e9a67872fa5548707e11b11c" @@ -2163,19 +1838,6 @@ version = "0.3.31" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "9e5c1b78ca4aae1ac06c48a526a655760685149f0d465d21f37abfe57ce075c6" -[[package]] -name = "futures-lite" -version = "2.6.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f78e10609fe0e0b3f4157ffab1876319b5b0db102a2c60dc4626306dc46b44ad" -dependencies = [ - "fastrand", - "futures-core", - "futures-io", - "parking", - "pin-project-lite", -] - [[package]] name = "futures-macro" version = "0.3.31" @@ -2219,28 +1881,33 @@ dependencies = [ [[package]] name = "gcp-bigquery-client" -version = "0.26.0" +version = "0.27.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2212aef5c38372fde142832f0aee14f7161e24acfc2af3811dc87af291db95f9" +checksum = "fb75ad03f4fffd15675c6fed7c37715176d7fc3f681b91c055a9f0a5cd34973d" dependencies = [ "async-stream", "async-trait", + "deadpool", "dyn-clone", "flate2", - "hyper", + "futures", "hyper-util", "log", - "prost 0.13.5", + "pin-project", + "prost", + "prost-build", "prost-types", "reqwest", "serde", "serde_json", - "thiserror 2.0.15", + "thiserror 2.0.17", "time", "tokio", "tokio-stream", - "tonic 0.12.3", + "tonic", "tonic-build", + "tonic-prost", + "tonic-prost-build", "url", "yup-oauth2", ] @@ -2257,9 +1924,9 @@ dependencies = [ [[package]] name = "geo" -version = "0.30.0" +version = "0.31.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4416397671d8997e9a3e7ad99714f4f00a22e9eaa9b966a5985d2194fc9e02e1" +checksum = "2fc1a1678e54befc9b4bcab6cd43b8e7f834ae8ea121118b0fd8c42747675b4a" dependencies = [ "earcutr", "float_next_after", @@ -2346,7 +2013,7 @@ dependencies = [ "futures-core", "futures-sink", "http 1.3.1", - "indexmap 2.10.0", + "indexmap", "slab", "tokio", "tokio-util", @@ -2397,10 +2064,14 @@ dependencies = [ "allocator-api2", "equivalent", "foldhash", - "rayon", - "serde", ] +[[package]] +name = "hashbrown" +version = "0.16.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5419bdc4f6a9207fbeba6d11b604d481addf78ecd10c11ad51e76c2f6482748d" + [[package]] name = "hashlink" version = "0.10.0" @@ -2442,6 +2113,12 @@ version = "0.5.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea" +[[package]] +name = "hermit-abi" +version = "0.5.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fc0fef456e4baa96da950455cd02c081ca953b141298e41db3fc7e36b1da849c" + [[package]] name = "hex" version = "0.4.3" @@ -2450,9 +2127,9 @@ checksum = "7f24254aa9a54b5c858eaee2f5bccdb46aaf0e486a595ed5fd8f86ba55232a70" [[package]] name = "hifitime" -version = "4.1.3" +version = "4.2.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f7252eb7d1bb00f11b26c5373ffa97ce45d9cd9e485a4beb7f547661a747c4e0" +checksum = "8ca4780c17998a6d7089dac984f76aa860324dbf7451f11cf915d7f199846bec" dependencies = [ "js-sys", "lexical-core", @@ -2500,7 +2177,7 @@ checksum = "a56f203cd1c76362b69e3863fd987520ac36cf70a8c92627449b2f64a8cf7d65" dependencies = [ "cfg-if", "libc", - "windows-link", + "windows-link 0.1.3", ] [[package]] @@ -2566,12 +2243,6 @@ version = "1.0.3" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "df3b46402a9d5adb4c86a0cf463f42e19994e3ee891101b1841f30a545cb49a9" -[[package]] -name = "humantime" -version = "2.2.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9b112acc8b3adf4b107a8ec20977da0273a8c386765a3ec0229bd500a1443f9f" - [[package]] name = "hybridmap" version = "0.1.2" @@ -2676,24 +2347,24 @@ dependencies = [ [[package]] name = "i_float" -version = "1.7.0" +version = "1.15.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "85df3a416829bb955fdc2416c7b73680c8dcea8d731f2c7aa23e1042fe1b8343" +checksum = "010025c2c532c8d82e42d0b8bb5184afa449fa6f06c709ea9adcb16c49ae405b" dependencies = [ - "serde", + "libm", ] [[package]] name = "i_key_sort" -version = "0.2.0" +version = "0.6.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "347c253b4748a1a28baf94c9ce133b6b166f08573157e05afe718812bc599fcd" +checksum = "9190f86706ca38ac8add223b2aed8b1330002b5cdbbce28fb58b10914d38fc27" [[package]] name = "i_overlay" -version = "2.0.5" +version = "4.0.6" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0542dfef184afdd42174a03dcc0625b6147fb73e1b974b1a08a2a42ac35cee49" +checksum = "0fcccbd4e4274e0f80697f5fbc6540fdac533cce02f2081b328e68629cce24f9" dependencies = [ "i_float", "i_key_sort", @@ -2704,19 +2375,18 @@ dependencies = [ [[package]] name = "i_shape" -version = "1.7.0" +version = "1.14.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0a38f5a42678726718ff924f6d4a0e79b129776aeed298f71de4ceedbd091bce" +checksum = "1ea154b742f7d43dae2897fcd5ead86bc7b5eefcedd305a7ebf9f69d44d61082" dependencies = [ "i_float", - "serde", ] [[package]] name = "i_tree" -version = "0.8.3" +version = "0.16.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "155181bc97d770181cf9477da51218a19ee92a8e5be642e796661aee2b601139" +checksum = "35e6d558e6d4c7b82bc51d9c771e7a927862a161a7d87bf2b0541450e0e20915" [[package]] name = "iana-time-zone" @@ -2836,9 +2506,9 @@ checksum = "b9e0384b61958566e926dc50660321d12159025e767c18e043daf26b70104c39" [[package]] name = "idna" -version = "1.0.3" +version = "1.1.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "686f825264d630750a544639377bae737628043f20d38bbc029e8f29ea968a7e" +checksum = "3b0875f23caa03898994f6ddc501886a45c7d3d62d04d2d90788d47be1b1e4de" dependencies = [ "idna_adapter", "smallvec 1.15.1", @@ -2863,23 +2533,14 @@ checksum = "e8a5a9a0ff0086c7a148acb942baaabeadf9504d10400b5a05645853729b9cd2" [[package]] name = "indexmap" -version = "1.9.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "bd070e393353796e801d209ad339e89596eb4c8d430d18ede6a1cced8fafbd99" -dependencies = [ - "autocfg", - "hashbrown 0.12.3", -] - -[[package]] -name = "indexmap" -version = "2.10.0" +version = "2.11.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "fe4cd85333e22411419a0bcae1297d25e58c9443848b11dc6a86fefe8c78a661" +checksum = "4b0f83760fb341a774ed326568e19f5a863af4a952def8c39f9ab92fd95b88e5" dependencies = [ "equivalent", - "hashbrown 0.15.5", + "hashbrown 0.16.0", "serde", + "serde_core", ] [[package]] @@ -2895,17 +2556,6 @@ dependencies = [ "snafu 0.7.5", ] -[[package]] -name = "io-uring" -version = "0.7.9" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d93587f37623a1a17d94ef2bc9ada592f5465fe7732084ab7beefabe5c77c0c4" -dependencies = [ - "bitflags 2.9.2", - "cfg-if", - "libc", -] - [[package]] name = "ipnet" version = "2.11.0" @@ -3016,12 +2666,6 @@ dependencies = [ "spin", ] -[[package]] -name = "lazycell" -version = "1.3.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "830d08ce1d1d941e6b30645f1a0eb5643013d835ce3779a5fc208261dbe10f55" - [[package]] name = "lexical-core" version = "1.0.5" @@ -3094,9 +2738,9 @@ checksum = "6a82ae493e598baaea5209805c49bbf2ea7de956d50d7da0da1164f9c6d28543" [[package]] name = "libduckdb-sys" -version = "1.3.2" +version = "1.4.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4e02f6069513efb67a0743aff3b846090de14763802b0e95c352ebc6e1bdc1da" +checksum = "4b93c3ff279601516f01531cadf2ccba50394fbb5f7bf685c6e6b9b07c8dca6f" dependencies = [ "cc", "flate2", @@ -3129,7 +2773,7 @@ version = "0.1.9" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "391290121bad3d37fbddad76d8f5d1c1c314cfc646d143d7e07a3086ddff0ce3" dependencies = [ - "bitflags 2.9.2", + "bitflags", "libc", "redox_syscall", ] @@ -3145,12 +2789,6 @@ dependencies = [ "vcpkg", ] -[[package]] -name = "linux-raw-sys" -version = "0.4.15" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d26c52dbd32dccf2d10cac7725f8eae5296885fb5703b261f7d0a0739ec807ab" - [[package]] name = "linux-raw-sys" version = "0.9.4" @@ -3192,9 +2830,9 @@ dependencies = [ [[package]] name = "log" -version = "0.4.27" +version = "0.4.28" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "13dc2df351e3202783a1fe0d44375f7295ffb4049267b0f3018346dc122a1d94" +checksum = "34080505efa8e45a4b816c349525ebe327ceaa8559756f0356cba97ef3bf7432" [[package]] name = "lru-slab" @@ -3202,25 +2840,6 @@ version = "0.1.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "112b39cec0b298b6c1999fee3e31427f74f676e4cb9879ed1a121b43661a4154" -[[package]] -name = "lz4" -version = "1.28.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a20b523e860d03443e98350ceaac5e71c6ba89aea7d960769ec3ce37f4de5af4" -dependencies = [ - "lz4-sys", -] - -[[package]] -name = "lz4-sys" -version = "1.11.1+lz4-1.10.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6bd8c0d6c6ed0cd30b3652886bb8711dc4bb01d637a68105a3d5158039b418e6" -dependencies = [ - "cc", - "libc", -] - [[package]] name = "lz4_flex" version = "0.11.5" @@ -3229,11 +2848,11 @@ checksum = "08ab2867e3eeeca90e844d1940eab391c9dc5228783db2ed999acbc0a9ed375a" [[package]] name = "matchers" -version = "0.1.0" +version = "0.2.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8263075bb86c5a1b1427b5ae862e8889656f126e9f77c484496e8b47cf5c5558" +checksum = "d1525a2a28c7f4fa0fc98bb91ae755d1e2d1505079e05539e35bc876b5d65ae9" dependencies = [ - "regex-automata 0.1.10", + "regex-automata", ] [[package]] @@ -3258,15 +2877,6 @@ version = "2.7.5" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "32a282da65faaf38286cf3be983213fcf1d2e2a58700e808f83f4ea9a4804bc0" -[[package]] -name = "memmap2" -version = "0.9.7" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "483758ad303d734cec05e5c12b41d7e93e6a6390c5e9dae6bdeb7c1259012d28" -dependencies = [ - "libc", -] - [[package]] name = "mime" version = "0.3.17" @@ -3296,6 +2906,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "1fa76a2c86f704bdb222d66965fb3d63269ce38518b83cb0575fca855ebb6316" dependencies = [ "adler2", + "simd-adler32", ] [[package]] @@ -3369,23 +2980,13 @@ dependencies = [ "memchr", ] -[[package]] -name = "now" -version = "0.1.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6d89e9874397a1f0a52fc1f197a8effd9735223cb2390e9dcc83ac6cd02923d0" -dependencies = [ - "chrono", -] - [[package]] name = "nu-ansi-term" -version = "0.46.0" +version = "0.50.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "77a8165726e8236064dbb45459242600304b42a5ea24ee2948e18e023bf7ba84" +checksum = "7957b9740744892f114936ab4a57b3f487491bbeafaf8083688b16841a4240e5" dependencies = [ - "overload", - "winapi", + "windows-sys 0.61.2", ] [[package]] @@ -3485,6 +3086,16 @@ dependencies = [ "libm", ] +[[package]] +name = "num_cpus" +version = "1.17.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "91df4bbde75afed763b708b7eee1e8e7651e02d97f6d5dd763e89367e957b23b" +dependencies = [ + "hermit-abi", + "libc", +] + [[package]] name = "num_threads" version = "0.1.7" @@ -3503,41 +3114,6 @@ dependencies = [ "memchr", ] -[[package]] -name = "object_store" -version = "0.12.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "efc4f07659e11cd45a341cd24d71e683e3be65d9ff1f8150061678fe60437496" -dependencies = [ - "async-trait", - "base64 0.22.1", - "bytes", - "chrono", - "form_urlencoded", - "futures", - "http 1.3.1", - "http-body-util", - "humantime", - "hyper", - "itertools 0.14.0", - "parking_lot", - "percent-encoding", - "quick-xml", - "rand 0.9.2", - "reqwest", - "ring", - "serde", - "serde_json", - "serde_urlencoded", - "thiserror 2.0.15", - "tokio", - "tracing", - "url", - "walkdir", - "wasm-bindgen-futures", - "web-time", -] - [[package]] name = "once_cell" version = "1.21.3" @@ -3556,7 +3132,7 @@ version = "0.10.73" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "8505734d46c8ab1e19a1dce3aef597ad87dcb4c37e7188231769bd6bd51cebf8" dependencies = [ - "bitflags 2.9.2", + "bitflags", "cfg-if", "foreign-types", "libc", @@ -3616,12 +3192,6 @@ dependencies = [ "windows-sys 0.52.0", ] -[[package]] -name = "overload" -version = "0.1.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b15813163c1d831bf4a13c3610c05c0d03b39feb07f7e09fa234dac9b15aaf39" - [[package]] name = "parking" version = "2.2.1" @@ -3651,12 +3221,6 @@ dependencies = [ "windows-targets 0.52.6", ] -[[package]] -name = "paste" -version = "1.0.15" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "57c0d7b74b563b49d38dae00a0c37d4d6de9b432382b2892f0574ddcae73fd0a" - [[package]] name = "pathdiff" version = "0.2.3" @@ -3674,9 +3238,9 @@ dependencies = [ [[package]] name = "percent-encoding" -version = "2.3.1" +version = "2.3.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e3148f5046208a5d56bcfc03053e3ca6334e51da8dfb19b6cdc8b306fae3283e" +checksum = "9b4f627cb1b25917193a259e49bdad08f671f8d9708acfd5fe0a8c1455d87220" [[package]] name = "pest" @@ -3685,7 +3249,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "1db05f56d34358a8b1066f67cbb203ee3e7ed2ba674a6263a1d5ec6db2204323" dependencies = [ "memchr", - "thiserror 2.0.15", + "thiserror 2.0.17", "ucd-trie", ] @@ -3729,25 +3293,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "3672b37090dbd86368a4145bc067582552b29c27377cad4e0a306c97f9bd7772" dependencies = [ "fixedbitset", - "indexmap 2.10.0", -] - -[[package]] -name = "phf" -version = "0.12.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "913273894cec178f401a31ec4b656318d95473527be05c0752cc41cdc32be8b7" -dependencies = [ - "phf_shared", -] - -[[package]] -name = "phf_shared" -version = "0.12.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "06005508882fb681fd97892ecff4b7fd0fee13ef1aa569f8695dae7ab9099981" -dependencies = [ - "siphasher", + "indexmap", ] [[package]] @@ -3809,16 +3355,6 @@ version = "0.3.32" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "7edddbd0b52d732b21ad9a5fab5c704c14cd949e5e9a1ec5929a24fded1b904c" -[[package]] -name = "planus" -version = "1.1.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3daf8e3d4b712abe1d690838f6e29fb76b76ea19589c4afa39ec30e12f62af71" -dependencies = [ - "array-init-cursor", - "hashbrown 0.15.5", -] - [[package]] name = "plist" version = "1.7.4" @@ -3826,515 +3362,12 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "3af6b589e163c5a788fab00ce0c0366f6efbb9959c2f9874b224936af7fce7e1" dependencies = [ "base64 0.22.1", - "indexmap 2.10.0", + "indexmap", "quick-xml", "serde", "time", ] -[[package]] -name = "polars" -version = "0.50.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "fde57577c2b4b823d85617c2c95c11fcdc649e68467030e321e573800524946c" -dependencies = [ - "getrandom 0.2.16", - "getrandom 0.3.3", - "polars-arrow", - "polars-core", - "polars-error", - "polars-io", - "polars-lazy", - "polars-ops", - "polars-parquet", - "polars-sql", - "polars-time", - "polars-utils", - "version_check", -] - -[[package]] -name = "polars-arrow" -version = "0.50.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "29f705dc037eb0a4213554a19320f13c02095c63bdd5e9e7f960817fa29b7b8d" -dependencies = [ - "atoi_simd", - "bitflags 2.9.2", - "bytemuck", - "chrono", - "chrono-tz", - "dyn-clone", - "either", - "ethnum", - "getrandom 0.2.16", - "getrandom 0.3.3", - "hashbrown 0.15.5", - "itoa", - "lz4", - "num-traits", - "polars-arrow-format", - "polars-error", - "polars-schema", - "polars-utils", - "serde", - "simdutf8", - "streaming-iterator", - "strum_macros", - "version_check", - "zstd", -] - -[[package]] -name = "polars-arrow-format" -version = "0.2.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "863c04c514be005eced7db7053e20d49f7e7a58048a282fa52dfea1fd5434e78" -dependencies = [ - "planus", - "serde", -] - -[[package]] -name = "polars-compute" -version = "0.50.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "896f4efdf1292121df34d6214fd32e634ce9aa5f3739519b3ccd9c11bda75d2a" -dependencies = [ - "atoi_simd", - "bytemuck", - "chrono", - "either", - "fast-float2", - "hashbrown 0.15.5", - "itoa", - "num-traits", - "polars-arrow", - "polars-error", - "polars-utils", - "rand 0.9.2", - "ryu", - "serde", - "skiplist", - "strength_reduce", - "strum_macros", - "version_check", -] - -[[package]] -name = "polars-core" -version = "0.50.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "11e2c54762ac17a039552033d81779b58619b832aa4f36ebc3395f9aa8bce083" -dependencies = [ - "bitflags 2.9.2", - "boxcar", - "bytemuck", - "chrono", - "chrono-tz", - "comfy-table", - "either", - "hashbrown 0.15.5", - "indexmap 2.10.0", - "itoa", - "num-traits", - "polars-arrow", - "polars-compute", - "polars-dtype", - "polars-error", - "polars-row", - "polars-schema", - "polars-utils", - "rand 0.9.2", - "rand_distr", - "rayon", - "regex", - "serde", - "serde_json", - "strum_macros", - "uuid", - "version_check", - "xxhash-rust", -] - -[[package]] -name = "polars-dtype" -version = "0.50.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6bdc47854d72f3df098a06b984de4105ca5030123445d3edef27502e6034019a" -dependencies = [ - "boxcar", - "hashbrown 0.15.5", - "polars-arrow", - "polars-error", - "polars-utils", - "serde", - "uuid", -] - -[[package]] -name = "polars-error" -version = "0.50.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "24d0fe86ef36dfa5c9e0b9833effd2e42cd64054b862fe40a243a635ecf62771" -dependencies = [ - "object_store", - "parking_lot", - "polars-arrow-format", - "regex", - "signal-hook", - "simdutf8", -] - -[[package]] -name = "polars-expr" -version = "0.50.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "98212e4899b5432f2b89f2f33c665240f8882cf757e7a5d18cf7b03ba80cdc1e" -dependencies = [ - "bitflags 2.9.2", - "hashbrown 0.15.5", - "num-traits", - "polars-arrow", - "polars-compute", - "polars-core", - "polars-io", - "polars-ops", - "polars-plan", - "polars-row", - "polars-time", - "polars-utils", - "rand 0.9.2", - "rayon", - "recursive", -] - -[[package]] -name = "polars-io" -version = "0.50.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "cba1a01ed61ec1ba3f3f7d1a7c4ad61cb7ece4bfd606d5d52bfa1384ce707109" -dependencies = [ - "async-trait", - "atoi_simd", - "blake3", - "bytes", - "chrono", - "fast-float2", - "fs4", - "futures", - "glob", - "hashbrown 0.15.5", - "home", - "itoa", - "memchr", - "memmap2", - "num-traits", - "object_store", - "percent-encoding", - "polars-arrow", - "polars-core", - "polars-error", - "polars-parquet", - "polars-schema", - "polars-time", - "polars-utils", - "rayon", - "regex", - "reqwest", - "ryu", - "serde", - "serde_json", - "simdutf8", - "tokio", - "tokio-util", - "url", -] - -[[package]] -name = "polars-lazy" -version = "0.50.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1aa4dbd41c7508735c3e8c2607aef39679d89298b53f1462710fc3f95b6c5cbd" -dependencies = [ - "bitflags 2.9.2", - "chrono", - "either", - "memchr", - "polars-arrow", - "polars-compute", - "polars-core", - "polars-expr", - "polars-io", - "polars-mem-engine", - "polars-ops", - "polars-plan", - "polars-stream", - "polars-time", - "polars-utils", - "rayon", - "version_check", -] - -[[package]] -name = "polars-mem-engine" -version = "0.50.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "712491f22624672d1c97a0f1faca93645ce749aa497c04dd67914738872474e1" -dependencies = [ - "memmap2", - "polars-arrow", - "polars-core", - "polars-error", - "polars-expr", - "polars-io", - "polars-ops", - "polars-plan", - "polars-time", - "polars-utils", - "rayon", - "recursive", -] - -[[package]] -name = "polars-ops" -version = "0.50.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7c433eb8eb4d5767504a6a145df286e503307d773dc92a085b9cabc6eaaafb01" -dependencies = [ - "argminmax", - "base64 0.22.1", - "bytemuck", - "chrono", - "chrono-tz", - "either", - "hashbrown 0.15.5", - "hex", - "indexmap 2.10.0", - "libm", - "memchr", - "num-traits", - "polars-arrow", - "polars-compute", - "polars-core", - "polars-error", - "polars-schema", - "polars-utils", - "rayon", - "regex", - "regex-syntax 0.8.5", - "strum_macros", - "unicode-normalization", - "unicode-reverse", - "version_check", -] - -[[package]] -name = "polars-parquet" -version = "0.50.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6efe8ffb9207c3d50d47ee9b5ee750beb889e7cffd2b61291766c74a020ee51d" -dependencies = [ - "async-stream", - "base64 0.22.1", - "bytemuck", - "ethnum", - "futures", - "hashbrown 0.15.5", - "num-traits", - "polars-arrow", - "polars-compute", - "polars-error", - "polars-parquet-format", - "polars-utils", - "serde", - "simdutf8", - "streaming-decompression", -] - -[[package]] -name = "polars-parquet-format" -version = "0.1.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c025243dcfe8dbc57e94d9f82eb3bef10b565ab180d5b99bed87fd8aea319ce1" -dependencies = [ - "async-trait", - "futures", -] - -[[package]] -name = "polars-plan" -version = "0.50.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2219ff36b304d0543185773cf182c49eca4f558403fb33c464b7688cd4f178d2" -dependencies = [ - "bitflags 2.9.2", - "bytemuck", - "bytes", - "chrono", - "chrono-tz", - "either", - "hashbrown 0.15.5", - "memmap2", - "num-traits", - "percent-encoding", - "polars-arrow", - "polars-compute", - "polars-core", - "polars-error", - "polars-io", - "polars-ops", - "polars-time", - "polars-utils", - "rayon", - "recursive", - "regex", - "sha2", - "strum_macros", - "version_check", -] - -[[package]] -name = "polars-row" -version = "0.50.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1eb03bbe6518a9a50fbe2f0d587f6634cf33f1e485657ef3db2bfab997fbc7a4" -dependencies = [ - "bitflags 2.9.2", - "bytemuck", - "polars-arrow", - "polars-compute", - "polars-dtype", - "polars-error", - "polars-utils", -] - -[[package]] -name = "polars-schema" -version = "0.50.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4b2daa5d628c4aa56deed967cc64fd24c9f62a919c8aaaf2b77b1457f8684f98" -dependencies = [ - "indexmap 2.10.0", - "polars-error", - "polars-utils", - "serde", - "version_check", -] - -[[package]] -name = "polars-sql" -version = "0.50.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f9021d46eb864c2bd944a51676c24c17eaa9e5fe755be464a50827179e6dcb8d" -dependencies = [ - "bitflags 2.9.2", - "hex", - "polars-core", - "polars-error", - "polars-lazy", - "polars-ops", - "polars-plan", - "polars-time", - "polars-utils", - "rand 0.9.2", - "regex", - "serde", - "sqlparser", -] - -[[package]] -name = "polars-stream" -version = "0.50.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "22323af55f0f2f9f9d64d65a5b0277b8dfa45300e4f6ba8d96e30817059c433e" -dependencies = [ - "async-channel", - "async-trait", - "atomic-waker", - "bitflags 2.9.2", - "crossbeam-channel", - "crossbeam-deque", - "crossbeam-queue", - "crossbeam-utils", - "futures", - "memmap2", - "parking_lot", - "percent-encoding", - "pin-project-lite", - "polars-arrow", - "polars-core", - "polars-error", - "polars-expr", - "polars-io", - "polars-mem-engine", - "polars-ops", - "polars-parquet", - "polars-plan", - "polars-utils", - "rand 0.9.2", - "rayon", - "recursive", - "slotmap", - "tokio", - "version_check", -] - -[[package]] -name = "polars-time" -version = "0.50.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "954b926cf121787c9fd2cf274b66ed85be46ab425405d0c5a1830c885c78b259" -dependencies = [ - "atoi_simd", - "bytemuck", - "chrono", - "chrono-tz", - "now", - "num-traits", - "polars-arrow", - "polars-compute", - "polars-core", - "polars-error", - "polars-ops", - "polars-utils", - "rayon", - "regex", - "strum_macros", -] - -[[package]] -name = "polars-utils" -version = "0.50.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "846a868e172550e4a3a465d7cdddee06377ccd0ea863cd49afd6f903078e0cff" -dependencies = [ - "bincode", - "bytemuck", - "bytes", - "compact_str", - "flate2", - "foldhash", - "hashbrown 0.15.5", - "indexmap 2.10.0", - "libc", - "memmap2", - "num-traits", - "polars-error", - "rand 0.9.2", - "raw-cpuid", - "rayon", - "regex", - "rmp-serde", - "serde", - "serde_json", - "serde_stacker", - "slotmap", - "stacker", - "uuid", - "version_check", -] - [[package]] name = "potential_utf" version = "0.1.2" @@ -4387,16 +3420,6 @@ dependencies = [ "unicode-ident", ] -[[package]] -name = "prost" -version = "0.13.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2796faa41db3ec313a31f7624d9286acf277b52de526150b7e69f3debf891ee5" -dependencies = [ - "bytes", - "prost-derive 0.13.5", -] - [[package]] name = "prost" version = "0.14.1" @@ -4404,14 +3427,14 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "7231bd9b3d3d33c86b58adbac74b5ec0ad9f496b19d22801d773636feaa95f3d" dependencies = [ "bytes", - "prost-derive 0.14.1", + "prost-derive", ] [[package]] name = "prost-build" -version = "0.13.5" +version = "0.14.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "be769465445e8c1474e9c5dac2018218498557af32d9ed057325ec9a41ae81bf" +checksum = "ac6c3320f9abac597dcbc668774ef006702672474aad53c6d596b62e487b40b1" dependencies = [ "heck 0.5.0", "itertools 0.14.0", @@ -4420,7 +3443,7 @@ dependencies = [ "once_cell", "petgraph", "prettyplease", - "prost 0.13.5", + "prost", "prost-types", "pulldown-cmark", "pulldown-cmark-to-cmark", @@ -4429,19 +3452,6 @@ dependencies = [ "tempfile", ] -[[package]] -name = "prost-derive" -version = "0.13.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8a56d757972c98b346a9b766e3f02746cde6dd1cd1d1d563472929fdd74bec4d" -dependencies = [ - "anyhow", - "itertools 0.14.0", - "proc-macro2", - "quote", - "syn 2.0.106", -] - [[package]] name = "prost-derive" version = "0.14.1" @@ -4457,20 +3467,11 @@ dependencies = [ [[package]] name = "prost-types" -version = "0.13.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "52c2c1bf36ddb1a1c396b3601a3cec27c2462e45f07c386894ec3ccf5332bd16" -dependencies = [ - "prost 0.13.5", -] - -[[package]] -name = "psm" -version = "0.1.26" +version = "0.14.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6e944464ec8536cd1beb0bbfd96987eb5e3b72f2ecdafdc5c769a37f1fa2ae1f" +checksum = "b9b4db3d6da204ed77bb26ba83b6122a73aeb2e87e25fbf7ad2e84c4ccbf8f72" dependencies = [ - "cc", + "prost", ] [[package]] @@ -4495,20 +3496,20 @@ dependencies = [ [[package]] name = "pulldown-cmark" -version = "0.12.2" +version = "0.13.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f86ba2052aebccc42cbbb3ed234b8b13ce76f75c3551a303cb2bcffcff12bb14" +checksum = "1e8bbe1a966bd2f362681a44f6edce3c2310ac21e4d5067a6e7ec396297a6ea0" dependencies = [ - "bitflags 2.9.2", + "bitflags", "memchr", "unicase", ] [[package]] name = "pulldown-cmark-to-cmark" -version = "20.0.1" +version = "21.0.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6c0f333311d2d8fda65bcf76af35054e9f38e253332a0289746156a59656988b" +checksum = "e5b6a0769a491a08b31ea5c62494a8f144ee0987d86d670a8af4df1e1b7cde75" dependencies = [ "pulldown-cmark", ] @@ -4535,7 +3536,6 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "9845d9dccf565065824e69f9f235fafba1587031eda353c1f1561cd6a6be78f4" dependencies = [ "memchr", - "serde", ] [[package]] @@ -4549,10 +3549,10 @@ dependencies = [ "pin-project-lite", "quinn-proto", "quinn-udp", - "rustc-hash 2.1.1", + "rustc-hash", "rustls", "socket2 0.5.10", - "thiserror 2.0.15", + "thiserror 2.0.17", "tokio", "tracing", "web-time", @@ -4569,11 +3569,11 @@ dependencies = [ "lru-slab", "rand 0.9.2", "ring", - "rustc-hash 2.1.1", + "rustc-hash", "rustls", "rustls-pki-types", "slab", - "thiserror 2.0.15", + "thiserror 2.0.17", "tinyvec", "tracing", "web-time", @@ -4673,23 +3673,13 @@ dependencies = [ "getrandom 0.3.3", ] -[[package]] -name = "rand_distr" -version = "0.5.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6a8615d50dcf34fa31f7ab52692afec947c4dd0ab803cc87cb3b0b4570ff7463" -dependencies = [ - "num-traits", - "rand 0.9.2", -] - [[package]] name = "raw-cpuid" version = "11.5.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "c6df7ab838ed27997ba19a4664507e6f82b41fe6e20be42929332156e5e85146" dependencies = [ - "bitflags 2.9.2", + "bitflags", ] [[package]] @@ -4712,65 +3702,36 @@ dependencies = [ "crossbeam-utils", ] -[[package]] -name = "recursive" -version = "0.1.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0786a43debb760f491b1bc0269fe5e84155353c67482b9e60d0cfb596054b43e" -dependencies = [ - "recursive-proc-macro-impl", - "stacker", -] - -[[package]] -name = "recursive-proc-macro-impl" -version = "0.1.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "76009fbe0614077fc1a2ce255e3a1881a2e3a3527097d5dc6d8212c585e7e38b" -dependencies = [ - "quote", - "syn 2.0.106", -] - [[package]] name = "redox_syscall" version = "0.5.17" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "5407465600fb0548f1442edf71dd20683c6ed326200ace4b1ef0763521bb3b77" dependencies = [ - "bitflags 2.9.2", + "bitflags", ] [[package]] name = "regex" -version = "1.11.1" +version = "1.12.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b544ef1b4eac5dc2db33ea63606ae9ffcfac26c1416a2806ae0bf5f56b201191" +checksum = "843bc0191f75f3e22651ae5f1e72939ab2f72a4bc30fa80a066bd66edefc24d4" dependencies = [ "aho-corasick", "memchr", - "regex-automata 0.4.9", - "regex-syntax 0.8.5", -] - -[[package]] -name = "regex-automata" -version = "0.1.10" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6c230d73fb8d8c1b9c0b3135c5142a8acee3a0558fb8db5cf1cb65f8d7862132" -dependencies = [ - "regex-syntax 0.6.29", + "regex-automata", + "regex-syntax", ] [[package]] name = "regex-automata" -version = "0.4.9" +version = "0.4.13" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "809e8dc61f6de73b46c85f4c96486310fe304c434cfa43669d7b40f711150908" +checksum = "5276caf25ac86c8d810222b3dbb938e512c55c6831a10f3e6ed1c93b84041f1c" dependencies = [ "aho-corasick", "memchr", - "regex-syntax 0.8.5", + "regex-syntax", ] [[package]] @@ -4779,12 +3740,6 @@ version = "0.1.6" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "53a49587ad06b26609c52e423de037e7f57f20d53535d66e08c695f347df952a" -[[package]] -name = "regex-syntax" -version = "0.6.29" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f162c6dd7b008981e4d40210aca20b4bd0f9b60ca9271061b07f78537722f2e1" - [[package]] name = "regex-syntax" version = "0.8.5" @@ -4817,7 +3772,6 @@ dependencies = [ "futures-channel", "futures-core", "futures-util", - "h2", "http 1.3.1", "http-body", "http-body-util", @@ -4832,7 +3786,6 @@ dependencies = [ "pin-project-lite", "quinn", "rustls", - "rustls-native-certs", "rustls-pki-types", "serde", "serde_json", @@ -4841,14 +3794,12 @@ dependencies = [ "tokio", "tokio-native-tls", "tokio-rustls", - "tokio-util", - "tower 0.5.2", + "tower", "tower-http", "tower-service", "url", "wasm-bindgen", "wasm-bindgen-futures", - "wasm-streams", "web-sys", "webpki-roots", ] @@ -4896,28 +3847,6 @@ dependencies = [ "syn 1.0.109", ] -[[package]] -name = "rmp" -version = "0.8.14" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "228ed7c16fa39782c3b3468e974aec2795e9089153cd08ee2e9aefb3613334c4" -dependencies = [ - "byteorder", - "num-traits", - "paste", -] - -[[package]] -name = "rmp-serde" -version = "1.3.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "52e599a477cf9840e92f2cde9a7189e67b42c57532749bf90aea6ec10facd4db" -dependencies = [ - "byteorder", - "rmp", - "serde", -] - [[package]] name = "robust" version = "1.2.0" @@ -4931,19 +3860,19 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "b91f7eff05f748767f183df4320a63d6936e9c6107d97c9e6bdd9784f4289c94" dependencies = [ "base64 0.21.7", - "bitflags 2.9.2", + "bitflags", "serde", "serde_derive", ] [[package]] name = "rrdcached-client" -version = "0.1.3" +version = "0.1.5" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f8320934d3dc3e2f1d236912fe45a381cad9648d21f3975181393ffe8f2eac4b" +checksum = "57dfd6f5a3094934b1f0813199b7571be5bde0bcc985005fe5a3c3d6a738d4cd" dependencies = [ - "nom 7.1.3", - "thiserror 1.0.69", + "nom 8.0.0", + "thiserror 2.0.17", "tokio", ] @@ -4980,20 +3909,19 @@ dependencies = [ [[package]] name = "rust-ini" -version = "0.21.1" +version = "0.21.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4e310ef0e1b6eeb79169a1171daf9abcb87a2e17c03bee2c4bb100b55c75409f" +checksum = "796e8d2b6696392a43bea58116b667fb4c29727dc5abd27d6acf338bb4f688c7" dependencies = [ "cfg-if", "ordered-multimap", - "trim-in-place", ] [[package]] name = "rust_decimal" -version = "1.37.2" +version = "1.39.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b203a6425500a03e0919c42d3c47caca51e79f1132046626d2c8871c5092035d" +checksum = "35affe401787a9bd846712274d97654355d21b2a2c092a3139aabe31e9022282" dependencies = [ "arrayvec", "borsh", @@ -5007,15 +3935,9 @@ dependencies = [ [[package]] name = "rustc-demangle" -version = "0.1.26" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "56f7d92ca342cea22a06f2121d944b4fd82af56988c270852495420f961d4ace" - -[[package]] -name = "rustc-hash" -version = "1.1.0" +version = "0.1.26" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "08d43f7aa6b08d49f382cde6a7982047c3426db949b1424bc4b7ec9ae12c6ce2" +checksum = "56f7d92ca342cea22a06f2121d944b4fd82af56988c270852495420f961d4ace" [[package]] name = "rustc-hash" @@ -5032,37 +3954,24 @@ dependencies = [ "semver", ] -[[package]] -name = "rustix" -version = "0.38.44" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "fdb5bc1ae2baa591800df16c9ca78619bf65c0488b41b96ccec5d11220d8c154" -dependencies = [ - "bitflags 2.9.2", - "errno", - "libc", - "linux-raw-sys 0.4.15", - "windows-sys 0.59.0", -] - [[package]] name = "rustix" version = "1.0.8" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "11181fbabf243db407ef8df94a6ce0b2f9a733bd8be4ad02b4eda9602296cac8" dependencies = [ - "bitflags 2.9.2", + "bitflags", "errno", "libc", - "linux-raw-sys 0.9.4", + "linux-raw-sys", "windows-sys 0.60.2", ] [[package]] name = "rustls" -version = "0.23.31" +version = "0.23.33" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c0ebcbd2f03de0fc1122ad9bb24b127a5a6cd51d72604a3f3c50ac459762b6cc" +checksum = "751e04a496ca00bb97a5e043158d23d66b5aabf2e1d5aa2a0aaebb1aafe6f82c" dependencies = [ "aws-lc-rs", "log", @@ -5107,9 +4016,9 @@ dependencies = [ [[package]] name = "rustls-webpki" -version = "0.103.4" +version = "0.103.7" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0a17884ae0c1b773f1ccd2bd4a8c72f16da897310a98b0e84bf349ad5ead92fc" +checksum = "e10b3f4191e8a80e6b43eebabfac91e5dcecebb27a71f04e820c47ec41d314bf" dependencies = [ "aws-lc-rs", "ring", @@ -5129,15 +4038,6 @@ version = "1.0.20" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "28d3b2b1366ec20994f1fd18c3c594f05c5dd4bc44d8bb0c1c632c8d6829481f" -[[package]] -name = "same-file" -version = "1.0.6" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "93fc1dc3aaa9bfed95e02e6eadabb4baf7e3078b0bd1b4d7b6b0b68378900502" -dependencies = [ - "winapi-util", -] - [[package]] name = "scc" version = "2.4.0" @@ -5191,7 +4091,7 @@ version = "2.11.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "897b2245f0b511c87893af39b033e5ca9cce68824c4d7e7630b5a1d339658d02" dependencies = [ - "bitflags 2.9.2", + "bitflags", "core-foundation 0.9.4", "core-foundation-sys", "libc", @@ -5204,7 +4104,7 @@ version = "3.3.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "80fb1d92c5028aa318b4b8bd7302a5bfcf48be96a37fc6fc790f806b0004ee0c" dependencies = [ - "bitflags 2.9.2", + "bitflags", "core-foundation 0.10.1", "core-foundation-sys", "libc", @@ -5232,10 +4132,10 @@ name = "sensapp" version = "0.3.0" dependencies = [ "anyhow", - "arrow 54.3.1", - "arrow-array 54.3.1", + "arrow", + "arrow-array", "arrow-ipc", - "arrow-schema 54.3.1", + "arrow-schema", "async-trait", "axum", "base64 0.22.1", @@ -5253,7 +4153,6 @@ dependencies = [ "duckdb", "flate2", "futures", - "futures-lite", "gcp-bigquery-client", "geo", "hex", @@ -5262,10 +4161,8 @@ dependencies = [ "influxdb-line-protocol", "iso8601", "nom 8.0.0", - "num-traits", "once_cell", - "polars", - "prost 0.14.1", + "prost", "regex", "rrdcached-client", "rust_decimal", @@ -5273,8 +4170,6 @@ dependencies = [ "sensapp", "sentry", "serde", - "serde-inline-default", - "serde_bytes", "serde_json", "serial_test", "sindit-senml", @@ -5283,13 +4178,13 @@ dependencies = [ "snap", "sqlx", "temp-env", - "thiserror 2.0.15", + "thiserror 2.0.17", "tokio", "tokio-stream", "tokio-test", "tokio-util", - "tonic 0.14.1", - "tower 0.5.2", + "tonic", + "tower", "tower-http", "tracing", "tracing-subscriber", @@ -5302,9 +4197,9 @@ dependencies = [ [[package]] name = "sentry" -version = "0.42.0" +version = "0.45.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "989425268ab5c011e06400187eed6c298272f8ef913e49fcadc3fda788b45030" +checksum = "48b85e25e8a1fc13928885e8bf13abe8a09e15c46993aed05d6405f7755d6e20" dependencies = [ "httpdate", "native-tls", @@ -5324,9 +4219,9 @@ dependencies = [ [[package]] name = "sentry-actix" -version = "0.42.0" +version = "0.45.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a5c675bdf6118764a8e265c3395c311b4d905d12866c92df52870c0223d2ffc1" +checksum = "cc694e6ffc8d5d7fdb2a33923b0358f6ad41c0b428ced034b349b9e2b08260bc" dependencies = [ "actix-http", "actix-web", @@ -5337,9 +4232,9 @@ dependencies = [ [[package]] name = "sentry-anyhow" -version = "0.42.0" +version = "0.45.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e1b4523c2595d6730bfbe401e95a6423fe9cb16dc3b6046f340551591cffe723" +checksum = "cfd12302213b0f449a065a68164e30dc02f5a4bc84843c2c5939b2c46b1513e8" dependencies = [ "anyhow", "sentry-backtrace", @@ -5348,9 +4243,9 @@ dependencies = [ [[package]] name = "sentry-backtrace" -version = "0.42.0" +version = "0.45.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "68e299dd3f7bcf676875eee852c9941e1d08278a743c32ca528e2debf846a653" +checksum = "f3253a495ab536f6de1746a58d5d7824b77d75e08e1a4b8ca6fb356839077ae0" dependencies = [ "backtrace", "regex", @@ -5359,9 +4254,9 @@ dependencies = [ [[package]] name = "sentry-contexts" -version = "0.42.0" +version = "0.45.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "fac0c5d6892cd4c414492fc957477b620026fb3411fca9fa12774831da561c88" +checksum = "027f81a728836e66b88c07666a10f5ed5a35e2695b04eb7aa0fcbed93f814900" dependencies = [ "hostname", "libc", @@ -5373,9 +4268,9 @@ dependencies = [ [[package]] name = "sentry-core" -version = "0.42.0" +version = "0.45.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "deaa38b94e70820ff3f1f9db3c8b0aef053b667be130f618e615e0ff2492cbcc" +checksum = "d3b6729c8e71ac968edbe9bf2dd4109c162e552b52bacd2b07e24ede1aba84a5" dependencies = [ "rand 0.9.2", "sentry-types", @@ -5386,9 +4281,9 @@ dependencies = [ [[package]] name = "sentry-debug-images" -version = "0.42.0" +version = "0.45.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "00950648aa0d371c7f57057434ad5671bd4c106390df7e7284739330786a01b6" +checksum = "dc85b59c1dfb19912bfba1af73a592e2e5548cae241a79ecb805afab3333d04c" dependencies = [ "findshlibs", "sentry-core", @@ -5396,9 +4291,9 @@ dependencies = [ [[package]] name = "sentry-panic" -version = "0.42.0" +version = "0.45.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2b7a23b13c004873de3ce7db86eb0f59fe4adfc655a31f7bbc17fd10bacc9bfe" +checksum = "1ac0471f04f8f97af0c17eeca2c516e23faa1c0271a55bc64371d9ce488c2d40" dependencies = [ "sentry-backtrace", "sentry-core", @@ -5406,9 +4301,9 @@ dependencies = [ [[package]] name = "sentry-tower" -version = "0.42.0" +version = "0.45.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4a303d0127d95ae928a937dcc0886931d28b4186e7338eea7d5786827b69b002" +checksum = "417bd48071863a65ca5f33d15af9aabd49a5cee7f97415d3f08ce8c90ed2c531" dependencies = [ "sentry-core", "tower-layer", @@ -5417,11 +4312,11 @@ dependencies = [ [[package]] name = "sentry-tracing" -version = "0.42.0" +version = "0.45.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "fac841c7050aa73fc2bec8f7d8e9cb1159af0b3095757b99820823f3e54e5080" +checksum = "428f780866a613142dcc81b7f8551ae4d1c056f4df22b6d7ddd9154a9974eb03" dependencies = [ - "bitflags 2.9.2", + "bitflags", "sentry-backtrace", "sentry-core", "tracing-core", @@ -5430,16 +4325,16 @@ dependencies = [ [[package]] name = "sentry-types" -version = "0.42.0" +version = "0.45.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e477f4d4db08ddb4ab553717a8d3a511bc9e81dde0c808c680feacbb8105c412" +checksum = "2c19d1d1967b55659c358886d0f1aa3076488d445f84c7d727d384c675adaec1" dependencies = [ "debugid", "hex", "rand 0.9.2", "serde", "serde_json", - "thiserror 2.0.15", + "thiserror 2.0.17", "time", "url", "uuid", @@ -5447,49 +4342,40 @@ dependencies = [ [[package]] name = "serde" -version = "1.0.219" +version = "1.0.228" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5f0e2c6ed6606019b4e29e69dbaba95b11854410e5347d525002456dbbb786b6" +checksum = "9a8e94ea7f378bd32cbbd37198a4a91436180c5bb472411e48b5ec2e2124ae9e" dependencies = [ + "serde_core", "serde_derive", ] -[[package]] -name = "serde-inline-default" -version = "0.2.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "59fb1bedd774187d304179493b0d3c41fbe97b04b14305363f68d2bdf5e47cb9" -dependencies = [ - "proc-macro2", - "quote", - "syn 2.0.106", -] - [[package]] name = "serde-untagged" -version = "0.1.8" +version = "0.1.9" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "34836a629bcbc6f1afdf0907a744870039b1e14c0561cb26094fa683b158eff3" +checksum = "f9faf48a4a2d2693be24c6289dbe26552776eb7737074e6722891fadbe6c5058" dependencies = [ "erased-serde", "serde", + "serde_core", "typeid", ] [[package]] -name = "serde_bytes" -version = "0.11.17" +name = "serde_core" +version = "1.0.228" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8437fd221bde2d4ca316d61b90e337e9e702b3820b87d63caa9ba6c02bd06d96" +checksum = "41d385c7d4ca58e59fc732af25c3983b67ac852c1a25000afe1175de458b67ad" dependencies = [ - "serde", + "serde_derive", ] [[package]] name = "serde_derive" -version = "1.0.219" +version = "1.0.228" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5b0276cf7f2c73365f7157c8123c21cd9a50fbbd844757af28ca1f5925fc2a00" +checksum = "d540f220d3187173da220f885ab66608367b6574e925011a9353e4badda91d79" dependencies = [ "proc-macro2", "quote", @@ -5509,14 +4395,15 @@ dependencies = [ [[package]] name = "serde_json" -version = "1.0.142" +version = "1.0.145" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "030fedb782600dcbd6f02d479bf0d817ac3bb40d644745b769d6a96bc3afc5a7" +checksum = "402a6f66d8c709116cf22f558eab210f5a50187f702eb4d7e5ef38d9a7f1c79c" dependencies = [ "itoa", "memchr", "ryu", "serde", + "serde_core", ] [[package]] @@ -5531,21 +4418,11 @@ dependencies = [ [[package]] name = "serde_spanned" -version = "1.0.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "40734c41988f7306bb04f0ecf60ec0f3f1caa34290e4e8ea471dcd3346483b83" -dependencies = [ - "serde", -] - -[[package]] -name = "serde_stacker" -version = "0.1.12" +version = "1.0.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "69c8defe6c780725cce4ec6ad3bd91e321baf6fa4e255df1f31e345d507ef01a" +checksum = "e24345aa0fe688594e73770a5f6d1b216508b4f93484c0026d521acd30134392" dependencies = [ - "serde", - "stacker", + "serde_core", ] [[package]] @@ -5622,16 +4499,6 @@ version = "1.3.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64" -[[package]] -name = "signal-hook" -version = "0.3.18" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d881a16cf4426aa584979d30bd82cb33429027e42122b169753d6ef1085ed6e2" -dependencies = [ - "libc", - "signal-hook-registry", -] - [[package]] name = "signal-hook-registry" version = "1.4.6" @@ -5651,6 +4518,12 @@ dependencies = [ "rand_core 0.6.4", ] +[[package]] +name = "simd-adler32" +version = "0.3.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d66dc143e6b11c1eddc06d5c423cfc97062865baf299914ab64caa38182078fe" + [[package]] name = "simdutf8" version = "0.1.5" @@ -5692,31 +4565,12 @@ version = "1.0.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "56199f7ddabf13fe5074ce809e7d3f42b42ae711800501b5b16ea82ad029c39d" -[[package]] -name = "skiplist" -version = "0.6.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f354fd282d3177c2951004953e2fdc4cb342fa159bbee8b829852b6a081c8ea1" -dependencies = [ - "rand 0.9.2", - "thiserror 2.0.15", -] - [[package]] name = "slab" version = "0.4.11" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "7a2ae44ef20feb57a68b23d846850f861394c2e02dc425a50098ae8c90267589" -[[package]] -name = "slotmap" -version = "1.0.7" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "dbff4acf519f630b3a3ddcfaea6c06b42174d9a44bc70c620e9ed1649d58b82a" -dependencies = [ - "version_check", -] - [[package]] name = "smallvec" version = "1.15.1" @@ -5833,15 +4687,6 @@ dependencies = [ "der", ] -[[package]] -name = "sqlparser" -version = "0.53.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "05a528114c392209b3264855ad491fcce534b94a38771b0a0b97a79379275ce8" -dependencies = [ - "log", -] - [[package]] name = "sqlx" version = "0.8.6" @@ -5873,7 +4718,7 @@ dependencies = [ "futures-util", "hashbrown 0.15.5", "hashlink", - "indexmap 2.10.0", + "indexmap", "log", "memchr", "once_cell", @@ -5883,7 +4728,7 @@ dependencies = [ "serde_json", "sha2", "smallvec 1.15.1", - "thiserror 2.0.15", + "thiserror 2.0.17", "time", "tokio", "tokio-stream", @@ -5938,7 +4783,7 @@ checksum = "aa003f0038df784eb8fecbbac13affe3da23b45194bd57dba231c8f48199c526" dependencies = [ "atoi", "base64 0.22.1", - "bitflags 2.9.2", + "bitflags", "byteorder", "bytes", "crc", @@ -5968,7 +4813,7 @@ dependencies = [ "smallvec 1.15.1", "sqlx-core", "stringprep", - "thiserror 2.0.15", + "thiserror 2.0.17", "time", "tracing", "uuid", @@ -5983,7 +4828,7 @@ checksum = "db58fcd5a53cf07c184b154801ff91347e4c30d17a3562a635ff028ad5deda46" dependencies = [ "atoi", "base64 0.22.1", - "bitflags 2.9.2", + "bitflags", "byteorder", "crc", "dotenvy", @@ -6008,7 +4853,7 @@ dependencies = [ "smallvec 1.15.1", "sqlx-core", "stringprep", - "thiserror 2.0.15", + "thiserror 2.0.17", "time", "tracing", "uuid", @@ -6034,7 +4879,7 @@ dependencies = [ "serde", "serde_urlencoded", "sqlx-core", - "thiserror 2.0.15", + "thiserror 2.0.17", "time", "tracing", "url", @@ -6047,46 +4892,12 @@ version = "1.2.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "a8f112729512f8e442d81f95a8a7ddf2b7c6b8a1a6f509a95864142b30cab2d3" -[[package]] -name = "stacker" -version = "0.1.21" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "cddb07e32ddb770749da91081d8d0ac3a16f1a569a18b20348cd371f5dead06b" -dependencies = [ - "cc", - "cfg-if", - "libc", - "psm", - "windows-sys 0.59.0", -] - [[package]] name = "static_assertions" version = "1.1.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "a2eb9349b6444b326872e140eb1cf5e7c522154d69e7a0ffb0fb81c06b37543f" -[[package]] -name = "streaming-decompression" -version = "0.1.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "bf6cc3b19bfb128a8ad11026086e31d3ce9ad23f8ea37354b31383a187c44cf3" -dependencies = [ - "fallible-streaming-iterator", -] - -[[package]] -name = "streaming-iterator" -version = "0.1.9" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2b2231b7c3057d5e4ad0156fb3dc807d900806020c5ffa3ee6ff2c8c76fb8520" - -[[package]] -name = "strength_reduce" -version = "0.2.4" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "fe895eb47f22e2ddd4dabc02bce419d2e643c8e3b585c78158b349195bc24d82" - [[package]] name = "stringprep" version = "0.1.5" @@ -6104,13 +4915,32 @@ version = "0.11.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "7da8b5736845d9f2fcb837ea5d9e2628564b3b043a70948a3f0b778838c5fb4f" +[[package]] +name = "strum" +version = "0.26.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8fec0f0aef304996cf250b31b5a10dee7980c85da9d759361292b8bca5a18f06" + [[package]] name = "strum" version = "0.27.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "af23d6f6c1a224baef9d3f61e287d2761385a5b88fdab4eb4c6f11aeb54c4bcf" dependencies = [ - "strum_macros", + "strum_macros 0.27.2", +] + +[[package]] +name = "strum_macros" +version = "0.26.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4c6bee85a5a24955dc440386795aa378cd9cf82acd5f764469152d2270e581be" +dependencies = [ + "heck 0.5.0", + "proc-macro2", + "quote", + "rustversion", + "syn 2.0.106", ] [[package]] @@ -6208,7 +5038,7 @@ dependencies = [ "fastrand", "getrandom 0.3.3", "once_cell", - "rustix 1.0.8", + "rustix", "windows-sys 0.59.0", ] @@ -6223,11 +5053,11 @@ dependencies = [ [[package]] name = "thiserror" -version = "2.0.15" +version = "2.0.17" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "80d76d3f064b981389ecb4b6b7f45a0bf9fdac1d5b9204c7bd6714fecc302850" +checksum = "f63587ca0f12b72a0600bcba1d40081f830876000bb46dd2337a3051618f4fc8" dependencies = [ - "thiserror-impl 2.0.15", + "thiserror-impl 2.0.17", ] [[package]] @@ -6243,9 +5073,9 @@ dependencies = [ [[package]] name = "thiserror-impl" -version = "2.0.15" +version = "2.0.17" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "44d29feb33e986b6ea906bd9c3559a856983f92371b3eaa5e83782a351623de0" +checksum = "3ff15c8ecd7de3849db632e14d18d2571fa09dfc5ed93479bc4485c7a517c913" dependencies = [ "proc-macro2", "quote", @@ -6263,9 +5093,9 @@ dependencies = [ [[package]] name = "time" -version = "0.3.41" +version = "0.3.44" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8a7619e19bc266e0f9c5e6686659d394bc57973859340060a69221e57dbc0c40" +checksum = "91e7d9e3bb61134e77bde20dd4825b97c010155709965fedf0f49bb138e52a9d" dependencies = [ "deranged", "itoa", @@ -6280,15 +5110,15 @@ dependencies = [ [[package]] name = "time-core" -version = "0.1.4" +version = "0.1.6" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c9e9a38711f559d9e3ce1cdb06dd7c5b8ea546bc90052da6d06bb76da74bb07c" +checksum = "40868e7c1d2f0b8d73e4a8c7f0ff63af4f6d19be117e90bd73eb1d62cf831c6b" [[package]] name = "time-macros" -version = "0.2.22" +version = "0.2.24" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3526739392ec93fd8b359c8e98514cb3e8e021beb4e5f597b00a0221f8ed8a49" +checksum = "30cfb0125f12d9c277f35663a0a33f8c30190f4e4574868a330595412d34ebf3" dependencies = [ "num-conv", "time-core", @@ -6330,29 +5160,26 @@ checksum = "1f3ccbac311fea05f86f61904b462b55fb3df8837a366dfc601a0161d0532f20" [[package]] name = "tokio" -version = "1.47.1" +version = "1.48.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "89e49afdadebb872d3145a5638b59eb0691ea23e46ca484037cfab3b76b95038" +checksum = "ff360e02eab121e0bc37a2d3b4d4dc622e6eda3a8e5253d5435ecf5bd4c68408" dependencies = [ - "backtrace", "bytes", - "io-uring", "libc", "mio", "parking_lot", "pin-project-lite", "signal-hook-registry", - "slab", "socket2 0.6.0", "tokio-macros", - "windows-sys 0.59.0", + "windows-sys 0.61.2", ] [[package]] name = "tokio-macros" -version = "2.5.0" +version = "2.6.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6e06d43f1345a3bcd39f6a56dbb7dcab2ba47e68e8ac134855e7e2bdbaf8cab8" +checksum = "af407857209536a95c8e56f8231ef2c2e2aff839b22e07a1ffcbc617e9db9fa5" dependencies = [ "proc-macro2", "quote", @@ -6418,14 +5245,14 @@ dependencies = [ [[package]] name = "toml" -version = "0.9.5" +version = "0.9.8" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "75129e1dc5000bfbaa9fee9d1b21f974f9fbad9daec557a521ee6e080825f6e8" +checksum = "f0dc8b1fb61449e27716ec0e1bdf0f6b8f3e8f6b05391e8497b8b6d7804ea6d8" dependencies = [ - "indexmap 2.10.0", - "serde", + "indexmap", + "serde_core", "serde_spanned", - "toml_datetime 0.7.0", + "toml_datetime 0.7.3", "toml_parser", "toml_writer", "winnow", @@ -6439,11 +5266,11 @@ checksum = "22cddaf88f4fbc13c51aebbf5f8eceb5c7c5a9da2ac40a13519eb5b0a0e8f11c" [[package]] name = "toml_datetime" -version = "0.7.0" +version = "0.7.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "bade1c3e902f58d73d3f294cd7f20391c1cb2fbcb643b73566bc773971df91e3" +checksum = "f2cdb639ebbc97961c51720f858597f7f24c4fc295327923af55b74c3c724533" dependencies = [ - "serde", + "serde_core", ] [[package]] @@ -6452,65 +5279,37 @@ version = "0.22.27" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "41fe8c660ae4257887cf66394862d21dbca4a6ddd26f04a3560410406a2f819a" dependencies = [ - "indexmap 2.10.0", + "indexmap", "toml_datetime 0.6.11", "winnow", ] [[package]] name = "toml_parser" -version = "1.0.2" +version = "1.0.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b551886f449aa90d4fe2bdaa9f4a2577ad2dde302c61ecf262d80b116db95c10" +checksum = "c0cbe268d35bdb4bb5a56a2de88d0ad0eb70af5384a99d648cd4b3d04039800e" dependencies = [ "winnow", ] [[package]] name = "toml_writer" -version = "1.0.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "fcc842091f2def52017664b53082ecbbeb5c7731092bad69d2c63050401dfd64" - -[[package]] -name = "tonic" -version = "0.12.3" +version = "1.0.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "877c5b330756d856ffcc4553ab34a5684481ade925ecc54bcd1bf02b1d0d4d52" -dependencies = [ - "async-trait", - "base64 0.22.1", - "bytes", - "http 1.3.1", - "http-body", - "http-body-util", - "hyper", - "hyper-timeout", - "hyper-util", - "percent-encoding", - "pin-project", - "prost 0.13.5", - "rustls-native-certs", - "rustls-pemfile", - "tokio", - "tokio-rustls", - "tokio-stream", - "tower 0.4.13", - "tower-layer", - "tower-service", - "tracing", -] +checksum = "df8b2b54733674ad286d16267dcfc7a71ed5c776e4ac7aa3c3e2561f7c637bf2" [[package]] name = "tonic" -version = "0.14.1" +version = "0.14.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "67ac5a8627ada0968acec063a4746bf79588aa03ccb66db2f75d7dce26722a40" +checksum = "eb7613188ce9f7df5bfe185db26c5814347d110db17920415cf2fbcad85e7203" dependencies = [ "async-trait", "axum", "base64 0.22.1", "bytes", + "flate2", "h2", "http 1.3.1", "http-body", @@ -6520,48 +5319,56 @@ dependencies = [ "hyper-util", "percent-encoding", "pin-project", + "rustls-native-certs", "socket2 0.6.0", "sync_wrapper", "tokio", + "tokio-rustls", "tokio-stream", - "tower 0.5.2", + "tower", "tower-layer", "tower-service", "tracing", + "zstd", ] [[package]] name = "tonic-build" -version = "0.12.3" +version = "0.14.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9557ce109ea773b399c9b9e5dca39294110b74f1f342cb347a80d1fce8c26a11" +checksum = "4c40aaccc9f9eccf2cd82ebc111adc13030d23e887244bc9cfa5d1d636049de3" dependencies = [ "prettyplease", "proc-macro2", - "prost-build", - "prost-types", "quote", "syn 2.0.106", ] [[package]] -name = "tower" -version = "0.4.13" +name = "tonic-prost" +version = "0.14.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b8fa9be0de6cf49e536ce1851f987bd21a43b771b09473c3549a6c853db37c1c" +checksum = "66bd50ad6ce1252d87ef024b3d64fe4c3cf54a86fb9ef4c631fdd0ded7aeaa67" dependencies = [ - "futures-core", - "futures-util", - "indexmap 1.9.3", - "pin-project", - "pin-project-lite", - "rand 0.8.5", - "slab", - "tokio", - "tokio-util", - "tower-layer", - "tower-service", - "tracing", + "bytes", + "prost", + "tonic", +] + +[[package]] +name = "tonic-prost-build" +version = "0.14.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b4a16cba4043dc3ff43fcb3f96b4c5c154c64cbd18ca8dce2ab2c6a451d058a2" +dependencies = [ + "prettyplease", + "proc-macro2", + "prost-build", + "prost-types", + "quote", + "syn 2.0.106", + "tempfile", + "tonic-build", ] [[package]] @@ -6573,7 +5380,7 @@ dependencies = [ "futures-core", "futures-util", "hdrhistogram", - "indexmap 2.10.0", + "indexmap", "pin-project-lite", "slab", "sync_wrapper", @@ -6592,7 +5399,7 @@ checksum = "adc82fd73de2a9722ac5da747f12383d2bfdb93591ee6c58486e0097890f05f2" dependencies = [ "async-compression", "base64 0.22.1", - "bitflags 2.9.2", + "bitflags", "bytes", "futures-core", "futures-util", @@ -6608,7 +5415,7 @@ dependencies = [ "pin-project-lite", "tokio", "tokio-util", - "tower 0.5.2", + "tower", "tower-layer", "tower-service", "tracing", @@ -6673,14 +5480,14 @@ dependencies = [ [[package]] name = "tracing-subscriber" -version = "0.3.19" +version = "0.3.20" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e8189decb5ac0fa7bc8b96b7cb9b2701d60d48805aca84a238004d665fcc4008" +checksum = "2054a14f5307d601f88daf0553e1cbf472acc4f2c51afab632431cdcd72124d5" dependencies = [ "matchers", "nu-ansi-term", "once_cell", - "regex", + "regex-automata", "sharded-slab", "smallvec 1.15.1", "thread_local", @@ -6689,12 +5496,6 @@ dependencies = [ "tracing-log", ] -[[package]] -name = "trim-in-place" -version = "0.1.7" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "343e926fc669bc8cde4fa3129ab681c63671bae288b1f1081ceee6d9d37904fc" - [[package]] name = "try-lock" version = "0.2.5" @@ -6761,15 +5562,6 @@ version = "0.1.3" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "e70f2a8b45122e719eb623c01822704c4e0907e7e426a05927e1a1cfff5b75d0" -[[package]] -name = "unicode-reverse" -version = "1.0.9" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4b6f4888ebc23094adfb574fdca9fdc891826287a6397d2cd28802ffd6f20c76" -dependencies = [ - "unicode-segmentation", -] - [[package]] name = "unicode-segmentation" version = "1.12.0" @@ -6794,12 +5586,6 @@ version = "0.9.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "8ecb6da28b8a351d773b68d5825ac39017e680750f980f3a1a85cd8dd28a47c1" -[[package]] -name = "unty" -version = "0.0.4" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6d49784317cd0d1ee7ec5c716dd598ec5b4483ea832a2dced265471cc0f690ae" - [[package]] name = "ureq" version = "3.1.0" @@ -6832,9 +5618,9 @@ dependencies = [ [[package]] name = "url" -version = "2.5.4" +version = "2.5.7" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "32f8b686cadd1473f4bd0117a5d28d36b1ade384ea9b5069a1c40aefed7fda60" +checksum = "08bc136a29a3d1758e07a9cca267be308aeebf5cfd5a10f3f67ab2097683ef5b" dependencies = [ "form_urlencoded", "idna", @@ -6878,7 +5664,7 @@ version = "5.4.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "2fcc29c80c21c31608227e0912b2d7fddba57ad76b606890627ba8ee7964e993" dependencies = [ - "indexmap 2.10.0", + "indexmap", "serde", "serde_json", "utoipa-gen", @@ -6910,9 +5696,9 @@ dependencies = [ [[package]] name = "uuid" -version = "1.18.0" +version = "1.18.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f33196643e165781c20a5ead5582283a7dacbb87855d867fbc2df3f81eddc1be" +checksum = "2f87b8aa10b915a06587d0dec516c282ff295b475d94abf425d62b57710070a2" dependencies = [ "getrandom 0.3.3", "js-sys", @@ -6938,22 +5724,6 @@ version = "0.9.5" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a" -[[package]] -name = "virtue" -version = "0.0.18" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "051eb1abcf10076295e815102942cc58f9d5e3b4560e46e53c21e8ff6f3af7b1" - -[[package]] -name = "walkdir" -version = "2.5.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "29790946404f91d9c5d06f9874efddea1dc06c5efe94541a7d6863108e3a5e4b" -dependencies = [ - "same-file", - "winapi-util", -] - [[package]] name = "want" version = "0.3.1" @@ -7055,19 +5825,6 @@ dependencies = [ "unicode-ident", ] -[[package]] -name = "wasm-streams" -version = "0.4.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "15053d8d85c7eccdbefef60f06769760a563c7f0a9d6902a13d35c7800b0ad65" -dependencies = [ - "futures-util", - "js-sys", - "wasm-bindgen", - "wasm-bindgen-futures", - "web-sys", -] - [[package]] name = "web-sys" version = "0.3.77" @@ -7106,18 +5863,6 @@ dependencies = [ "rustls-pki-types", ] -[[package]] -name = "which" -version = "4.4.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "87ba24419a2078cd2b0f2ede2691b6c66d8e47836da3b6db8265ebad47afbfc7" -dependencies = [ - "either", - "home", - "once_cell", - "rustix 0.38.44", -] - [[package]] name = "whoami" version = "1.6.1" @@ -7144,15 +5889,6 @@ version = "0.4.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6" -[[package]] -name = "winapi-util" -version = "0.1.9" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "cf221c93e13a30d793f7645a0e7762c55d169dbb0a49671918a2319d289b10bb" -dependencies = [ - "windows-sys 0.59.0", -] - [[package]] name = "winapi-x86_64-pc-windows-gnu" version = "0.4.0" @@ -7167,7 +5903,7 @@ checksum = "c0fdd3ddb90610c7638aa2b3a3ab2904fb9e5cdbecc643ddb3647212781c4ae3" dependencies = [ "windows-implement", "windows-interface", - "windows-link", + "windows-link 0.1.3", "windows-result", "windows-strings", ] @@ -7200,13 +5936,19 @@ version = "0.1.3" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "5e6ad25900d524eaabdbbb96d20b4311e1e7ae1699af4fb28c17ae66c80d798a" +[[package]] +name = "windows-link" +version = "0.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f0805222e57f7521d6a62e36fa9163bc891acd422f971defe97d64e70d0a4fe5" + [[package]] name = "windows-result" version = "0.3.4" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "56f42bd332cc6c8eac5af113fc0c1fd6a8fd2aa08a0119358686e5160d0586c6" dependencies = [ - "windows-link", + "windows-link 0.1.3", ] [[package]] @@ -7215,7 +5957,7 @@ version = "0.4.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "56e6c93f3a0c3b36176cb1327a4958a0353d5d166c2a35cb268ace15e91d3b57" dependencies = [ - "windows-link", + "windows-link 0.1.3", ] [[package]] @@ -7254,6 +5996,15 @@ dependencies = [ "windows-targets 0.53.3", ] +[[package]] +name = "windows-sys" +version = "0.61.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ae137229bcbd6cdf0f7b80a31df61766145077ddf49416a728b02cb3921ff3fc" +dependencies = [ + "windows-link 0.2.1", +] + [[package]] name = "windows-targets" version = "0.48.5" @@ -7291,7 +6042,7 @@ version = "0.53.3" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "d5fe6031c4041849d7c496a8ded650796e7b6ecc19df1a431c1a363342e5dc91" dependencies = [ - "windows-link", + "windows-link 0.1.3", "windows_aarch64_gnullvm 0.53.0", "windows_aarch64_msvc 0.53.0", "windows_i686_gnu 0.53.0", @@ -7442,9 +6193,9 @@ checksum = "271414315aff87387382ec3d271b52d7ae78726f5d44ac98b4f4030c91880486" [[package]] name = "winnow" -version = "0.7.12" +version = "0.7.13" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f3edebf492c8125044983378ecb5766203ad3b4c2f7a922bd7dd207f6d443e95" +checksum = "21a0236b59786fed61e2a80582dd500fe61f18b5dca67a4a067d0bc9039339cf" dependencies = [ "memchr", ] @@ -7455,7 +6206,7 @@ version = "0.39.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "6f42320e61fe2cfd34354ecb597f86f413484a798ba44a8ca1165c58d42da6c1" dependencies = [ - "bitflags 2.9.2", + "bitflags", ] [[package]] @@ -7480,20 +6231,14 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "af3a19837351dc82ba89f8a125e22a3c475f05aba604acc023d62b2739ae2909" dependencies = [ "libc", - "rustix 1.0.8", + "rustix", ] -[[package]] -name = "xxhash-rust" -version = "0.8.15" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "fdd20c5420375476fbd4394763288da7eb0cc0b8c11deed431a91562af7335d3" - [[package]] name = "yaml-rust2" -version = "0.10.3" +version = "0.10.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4ce2a4ff45552406d02501cea6c18d8a7e50228e7736a872951fe2fe75c91be7" +checksum = "2462ea039c445496d8793d052e13787f2b90e750b833afee748e601c17621ed9" dependencies = [ "arraydeque", "encoding_rs", @@ -7544,7 +6289,7 @@ dependencies = [ "seahash", "serde", "serde_json", - "thiserror 2.0.15", + "thiserror 2.0.17", "time", "tokio", "url", diff --git a/Cargo.toml b/Cargo.toml index 9c73118..9382e16 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -33,81 +33,75 @@ test-utils = [] # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html [dependencies] -# Apache Arrow support for efficient columnar data format -arrow = { version = "54", features = ["ipc"] } -arrow-ipc = "54" -arrow-schema = "54" -arrow-array = "54" -anyhow = "1.0" -#async-stream = "0.3" +arrow = { version = "56", features = ["ipc"] } +arrow-ipc = "56" +arrow-schema = "56" +arrow-array = "56" +anyhow = "1.0.100" async-trait = "0.1" -thiserror = "2.0" -axum = { version = "0.8", features = ["multipart", "macros"] } -#axum-streams = { version = "0.12", features = ["json", "csv", "text"] } +thiserror = "2.0.17" +axum = { version = "0.8.6", features = ["multipart", "macros"] } base64 = "0.22" -#bytes = "1.5" futures = "0.3" -#futures-util = { version = "0.3", features = ["io"] } -#http-body = "1.0" -#http-body-util = "0.1" -polars = { version = "0.50" } -sqlx = { version = "0.8", features = ["runtime-tokio", "uuid", "json", "time", "rust_decimal"] } -tokio = { version = "1.47", features = ["full"] } +sqlx = { version = "0.8", features = [ + "runtime-tokio", + "uuid", + "json", + "time", + "rust_decimal", +] } +tokio = { version = "1.48", features = ["full"] } tokio-stream = { version = "0.1", features = ["io-util"] } tokio-util = "0.7" tower = { version = "0.5", features = ["full"] } tower-http = { version = "0.6", features = ["full"] } tracing = { version = "0.1" } -tracing-subscriber = { version = "0.3", features = ["env-filter"] } -uuid = { version = "1.18", features = ["serde"] } +tracing-subscriber = { version = "0.3.20", features = ["env-filter"] } +uuid = { version = "1.18.1", features = ["serde"] } csv-async = "1.3" -rust_decimal = "1.37" -geo = "0.30" +rust_decimal = "1.39" +geo = "0.31" cached = { version = "0.56", features = ["async", "tokio", "async-trait"] } nom = "8.0" sindit-senml = "0.2" -serde_json = "1.0" -num-traits = "0.2" -hifitime = "4.1" +serde_json = "1.0.145" +hifitime = "4.2" iso8601 = "0.6" -duckdb = { version = "1.3", features = ["bundled"], optional = true } -config = "0.15" -serde = "1.0" +duckdb = { version = "1.4", features = ["bundled"], optional = true } +config = "0.15.18" +serde = "1.0.228" confique = { version = "0.3", features = ["toml"] } byte-unit = "5.1" -#prost = "0.12" prost = "0.14" snap = "1.1" hex = "0.4" blake3 = "1.8" -regex = "1.11" +regex = "1.12" influxdb-line-protocol = "2.0" -flate2 = "1.1" +flate2 = "1.1.4" smallvec = "1.15" once_cell = "1.21" urlencoding = "2.1" hybridmap = "0.1" -clap = { version = "4.5", features = ["derive"] } -serde-inline-default = "0.2" -serde_bytes = "0.11" -sentry = { version = "0.42", features = ["anyhow", "tower"] } -url = "2.5" -futures-lite = "2.6" -#gcp-bigquery-client = { git = "https://github.com/lquerel/gcp-bigquery-client.git", rev = "107a5557df6336933f6b0bcf330aa91fe6ca866a" } -gcp-bigquery-client = { version = "0.26.0", optional = true } -#prost = { version = "0.12", features = ["derive"] } -#enum_delegate = "0.2" +clap = { version = "4.5.49", features = ["derive"] } +sentry = { version = "0.45", features = ["anyhow", "tower"] } +url = "2.5.7" +gcp-bigquery-client = { version = "0.27.0", optional = true } sinteflake = { version = "0.1", features = ["async"] } -#tonic = "0.11" -tonic = "0.14" +tonic = "0.14.2" bigdecimal = { version = "0.4", optional = true } big-decimal-byte-string-encoder = { version = "0.1", optional = true } clru = "0.6" utoipa = { version = "5.4", features = ["axum_extras"] } utoipa-scalar = { version = "0.3", features = ["axum"] } -rrdcached-client = { version = "0.1", optional = true } -clickhouse = { version = "0.13", features = ["lz4", "uuid", "time", "inserter"], optional = true } -rustls = "0.23" +rrdcached-client = { version = "0.1.5", optional = true } +clickhouse = { version = "0.14", features = [ + "lz4", + "uuid", + "time", + "inserter", +], optional = true } +rustls = "0.23.33" [dev-dependencies] temp-env = "0.3" diff --git a/README.md b/README.md index c9bc3e4..e910d70 100644 --- a/README.md +++ b/README.md @@ -15,9 +15,9 @@ It enables the handling of small time series data of the edge efficiently to lar SensApp should be stateless and scale from the edge to big data. The message queue software and the database software solve the complex problems. SensApp is a simple adapter between. -* SensApp supports simple deployments without requiring a message queue and only an embedded SQLite database. -* SensApp supports medium deployments with a single message broker and a PostgreSQL database. -* For larger deployments, SensApp advises a distributed message queue, an automatic load balancer for the SensApp instances, and a ClickHouse cluster. +- SensApp supports simple deployments without requiring a message queue and only an embedded SQLite database. +- SensApp supports medium deployments with a single message broker and a PostgreSQL database. +- For larger deployments, SensApp advises a distributed message queue, an automatic load balancer for the SensApp instances, and a ClickHouse cluster. Check the [ARCHITECTURE.md](docs/ARCHITECTURE.md) file for more details. @@ -47,17 +47,7 @@ Override environment variables as needed: `DATABASE_URL`, `POSTGRES_USER`, etc. ## Built With Rust™️ -SensApp is developed using Rust, a language known for its performance, memory safety, and annoying borrow checker. SensApp used to be written in Scala, but the new author prefers Rust. - -Not only the language, it's also the extensive high quality open-source ecosystem that makes Rust a great choice for SensApp: - -* [Tokio](https://tokio.rs/) asynchronous runtime -* [Serde](https://serde.rs/) serialization framework -* [Axum](https://github.com/tokio-rs/axum) web framework -* [SQLx](https://github.com/launchbadge/sqlx) database driver -* [Polars](https://pola.rs) data frame library -* [nom](https://github.com/rust-bakery/nom) parser combinator library -* *and many more…* +SensApp is developed using Rust, a language known for its performance, memory safety, and annoying borrow checker. SensApp used to be written in Scala, but the new author prefers Rust. But most of the heavy lifting is done by the dependencies, that are listed in the [Cargo.toml](Cargo.toml) file. ## Contributing From c3a953fc0c7577fa7fb26feb324d1dc74173392f Mon Sep 17 00:00:00 2001 From: Antoine Pultier <45740+fungiboletus@users.noreply.github.com> Date: Fri, 24 Oct 2025 19:15:13 +0200 Subject: [PATCH 04/39] =?UTF-8?q?feat:=20=F0=9F=94=A7=20some=20clickhouse?= =?UTF-8?q?=20work?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../clickhouse/clickhouse_publishers.rs | 18 +++++++++--------- src/storage/clickhouse/clickhouse_utilities.rs | 6 ++++-- 2 files changed, 13 insertions(+), 11 deletions(-) diff --git a/src/storage/clickhouse/clickhouse_publishers.rs b/src/storage/clickhouse/clickhouse_publishers.rs index 2c48a9e..6c9f34b 100644 --- a/src/storage/clickhouse/clickhouse_publishers.rs +++ b/src/storage/clickhouse/clickhouse_publishers.rs @@ -143,7 +143,6 @@ impl<'a> ClickHousePublisher<'a> { self.label_inserter = Some( self.client .inserter("labels") - .map_err(|e| map_clickhouse_error(e, None, None))? ); } @@ -157,6 +156,7 @@ impl<'a> ClickHousePublisher<'a> { }; inserter .write(&row) + .await .map_err(|e| map_clickhouse_error(e, None, None))?; } @@ -206,7 +206,6 @@ impl<'a> ClickHousePublisher<'a> { self.integer_inserter = Some( self.client .inserter("integer_values") - .map_err(|e| map_clickhouse_error(e, None, None))? ); } @@ -220,6 +219,7 @@ impl<'a> ClickHousePublisher<'a> { }; inserter .write(&row) + .await .map_err(|e| map_clickhouse_error(e, None, None))?; } @@ -241,7 +241,6 @@ impl<'a> ClickHousePublisher<'a> { self.numeric_inserter = Some( self.client .inserter("numeric_values") - .map_err(|e| map_clickhouse_error(e, None, None))? ); } @@ -255,6 +254,7 @@ impl<'a> ClickHousePublisher<'a> { }; inserter .write(&row) + .await .map_err(|e| map_clickhouse_error(e, None, None))?; } @@ -272,7 +272,6 @@ impl<'a> ClickHousePublisher<'a> { self.float_inserter = Some( self.client .inserter("float_values") - .map_err(|e| map_clickhouse_error(e, None, None))? ); } @@ -286,6 +285,7 @@ impl<'a> ClickHousePublisher<'a> { }; inserter .write(&row) + .await .map_err(|e| map_clickhouse_error(e, None, None))?; } @@ -307,7 +307,6 @@ impl<'a> ClickHousePublisher<'a> { self.string_inserter = Some( self.client .inserter("string_values") - .map_err(|e| map_clickhouse_error(e, None, None))? ); } @@ -321,6 +320,7 @@ impl<'a> ClickHousePublisher<'a> { }; inserter .write(&row) + .await .map_err(|e| map_clickhouse_error(e, None, None))?; } @@ -338,7 +338,6 @@ impl<'a> ClickHousePublisher<'a> { self.boolean_inserter = Some( self.client .inserter("boolean_values") - .map_err(|e| map_clickhouse_error(e, None, None))? ); } @@ -352,6 +351,7 @@ impl<'a> ClickHousePublisher<'a> { }; inserter .write(&row) + .await .map_err(|e| map_clickhouse_error(e, None, None))?; } @@ -373,7 +373,6 @@ impl<'a> ClickHousePublisher<'a> { self.location_inserter = Some( self.client .inserter("location_values") - .map_err(|e| map_clickhouse_error(e, None, None))? ); } @@ -388,6 +387,7 @@ impl<'a> ClickHousePublisher<'a> { }; inserter .write(&row) + .await .map_err(|e| map_clickhouse_error(e, None, None))?; } @@ -409,7 +409,6 @@ impl<'a> ClickHousePublisher<'a> { self.json_inserter = Some( self.client .inserter("json_values") - .map_err(|e| map_clickhouse_error(e, None, None))? ); } @@ -423,6 +422,7 @@ impl<'a> ClickHousePublisher<'a> { }; inserter .write(&row) + .await .map_err(|e| map_clickhouse_error(e, None, None))?; } @@ -440,7 +440,6 @@ impl<'a> ClickHousePublisher<'a> { self.blob_inserter = Some( self.client .inserter("blob_values") - .map_err(|e| map_clickhouse_error(e, None, None))? ); } @@ -454,6 +453,7 @@ impl<'a> ClickHousePublisher<'a> { }; inserter .write(&row) + .await .map_err(|e| map_clickhouse_error(e, None, None))?; } diff --git a/src/storage/clickhouse/clickhouse_utilities.rs b/src/storage/clickhouse/clickhouse_utilities.rs index 9fb1142..ad56e9b 100644 --- a/src/storage/clickhouse/clickhouse_utilities.rs +++ b/src/storage/clickhouse/clickhouse_utilities.rs @@ -74,7 +74,8 @@ pub async fn get_sensor_id_or_create_sensor( }; let mut insert = client - .insert("sensors") + .insert::("sensors") + .await .map_err(|e| StorageError::invalid_data_format(&e.to_string(), Some(*uuid), Some(name)))?; insert @@ -127,7 +128,8 @@ async fn get_or_create_unit(client: &clickhouse::Client, unit: &Unit) -> Result< // Unit doesn't exist, create it let mut insert = client - .insert("units") + .insert::("units") + .await .map_err(|e| StorageError::invalid_data_format(&e.to_string(), None, None))?; insert From 0536bf44b6a729fa856cfc9e52fe710241ce5258 Mon Sep 17 00:00:00 2001 From: Antoine Pultier <45740+fungiboletus@users.noreply.github.com> Date: Fri, 24 Oct 2025 19:15:39 +0200 Subject: [PATCH 05/39] =?UTF-8?q?feat:=20=E2=AC=86=EF=B8=8F=20dependencies?= =?UTF-8?q?=20update?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- Cargo.lock | 1073 ++++++++++++++++++++++++++++++---------------------- Cargo.toml | 19 +- 2 files changed, 625 insertions(+), 467 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index a1a127f..6e78b56 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -21,9 +21,9 @@ dependencies = [ [[package]] name = "actix-http" -version = "3.11.0" +version = "3.11.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "44dfe5c9e0004c623edc65391dfd51daa201e7e30ebd9c9bedf873048ec32bc2" +checksum = "7926860314cbe2fb5d1f13731e387ab43bd32bca224e82e6e2db85de0a3dba49" dependencies = [ "actix-codec", "actix-rt", @@ -70,9 +70,9 @@ dependencies = [ [[package]] name = "actix-rt" -version = "2.10.0" +version = "2.11.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "24eda4e2a6e042aa4e55ac438a2ae052d3b5da0ecf83d7411e1a368946925208" +checksum = "92589714878ca59a7626ea19734f0e07a6a875197eec751bb5d3f99e64998c63" dependencies = [ "futures-core", "tokio", @@ -156,9 +156,9 @@ dependencies = [ [[package]] name = "addr2line" -version = "0.24.2" +version = "0.25.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "dfbe277e56a376000877090da837660b4427aad530e3028d44e0bffe4f89a1c1" +checksum = "1b5d307320b3181d6d7954e663bd7c774a838b8220fe0593c86d9fb09f498b4b" dependencies = [ "gimli", ] @@ -188,7 +188,7 @@ checksum = "5a15f179cd60c4584b8a8c596927aadc462e27f2ca70c04e0071964a73ba7a75" dependencies = [ "cfg-if", "const-random", - "getrandom 0.3.3", + "getrandom 0.3.4", "once_cell", "version_check", "zerocopy", @@ -224,12 +224,6 @@ version = "0.2.21" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "683d7910e743518b0e34f1186f92494becacb047c7b6bf616c96772180fef923" -[[package]] -name = "android-tzdata" -version = "0.1.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e999941b234f3131b00bc13c22d06e8c5ff726d1b6318ac7eb276997bbb4fef0" - [[package]] name = "android_system_properties" version = "0.1.5" @@ -241,9 +235,9 @@ dependencies = [ [[package]] name = "anstream" -version = "0.6.20" +version = "0.6.21" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3ae563653d1938f79b1ab1b5e668c87c76a9930414574a6583a7b7e11a8e6192" +checksum = "43d5b281e737544384e969a5ccad3f1cdd24b48086a0fc1b2a5262a26b8f4f4a" dependencies = [ "anstyle", "anstyle-parse", @@ -256,9 +250,9 @@ dependencies = [ [[package]] name = "anstyle" -version = "1.0.11" +version = "1.0.13" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "862ed96ca487e809f1c8e5a8447f6ee2cf102f846893800b20cebdf541fc6bbd" +checksum = "5192cca8006f1fd4f7237516f40fa183bb07f8fbdfedaa0036de5ea9b0b45e78" [[package]] name = "anstyle-parse" @@ -328,19 +322,37 @@ version = "56.2.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "6e833808ff2d94ed40d9379848a950d995043c7fb3e81a30b383f4c6033821cc" dependencies = [ - "arrow-arith", - "arrow-array", - "arrow-buffer", - "arrow-cast", + "arrow-arith 56.2.0", + "arrow-array 56.2.0", + "arrow-buffer 56.2.0", + "arrow-cast 56.2.0", + "arrow-data 56.2.0", + "arrow-ord 56.2.0", + "arrow-row 56.2.0", + "arrow-schema 56.2.0", + "arrow-select 56.2.0", + "arrow-string 56.2.0", +] + +[[package]] +name = "arrow" +version = "57.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4df8bb5b0bd64c0b9bc61317fcc480bad0f00e56d3bc32c69a4c8dada4786bae" +dependencies = [ + "arrow-arith 57.0.0", + "arrow-array 57.0.0", + "arrow-buffer 57.0.0", + "arrow-cast 57.0.0", "arrow-csv", - "arrow-data", + "arrow-data 57.0.0", "arrow-ipc", "arrow-json", - "arrow-ord", - "arrow-row", - "arrow-schema", - "arrow-select", - "arrow-string", + "arrow-ord 57.0.0", + "arrow-row 57.0.0", + "arrow-schema 57.0.0", + "arrow-select 57.0.0", + "arrow-string 57.0.0", ] [[package]] @@ -349,14 +361,28 @@ version = "56.2.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "ad08897b81588f60ba983e3ca39bda2b179bdd84dced378e7df81a5313802ef8" dependencies = [ - "arrow-array", - "arrow-buffer", - "arrow-data", - "arrow-schema", + "arrow-array 56.2.0", + "arrow-buffer 56.2.0", + "arrow-data 56.2.0", + "arrow-schema 56.2.0", "chrono", "num", ] +[[package]] +name = "arrow-arith" +version = "57.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a1a640186d3bd30a24cb42264c2dafb30e236a6f50d510e56d40b708c9582491" +dependencies = [ + "arrow-array 57.0.0", + "arrow-buffer 57.0.0", + "arrow-data 57.0.0", + "arrow-schema 57.0.0", + "chrono", + "num-traits", +] + [[package]] name = "arrow-array" version = "56.2.0" @@ -364,15 +390,33 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "8548ca7c070d8db9ce7aa43f37393e4bfcf3f2d3681df278490772fd1673d08d" dependencies = [ "ahash 0.8.12", - "arrow-buffer", - "arrow-data", - "arrow-schema", + "arrow-buffer 56.2.0", + "arrow-data 56.2.0", + "arrow-schema 56.2.0", "chrono", "half", "hashbrown 0.16.0", "num", ] +[[package]] +name = "arrow-array" +version = "57.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "219fe420e6800979744c8393b687afb0252b3f8a89b91027d27887b72aa36d31" +dependencies = [ + "ahash 0.8.12", + "arrow-buffer 57.0.0", + "arrow-data 57.0.0", + "arrow-schema 57.0.0", + "chrono", + "half", + "hashbrown 0.16.0", + "num-complex", + "num-integer", + "num-traits", +] + [[package]] name = "arrow-buffer" version = "56.2.0" @@ -384,17 +428,29 @@ dependencies = [ "num", ] +[[package]] +name = "arrow-buffer" +version = "57.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "76885a2697a7edf6b59577f568b456afc94ce0e2edc15b784ce3685b6c3c5c27" +dependencies = [ + "bytes", + "half", + "num-bigint", + "num-traits", +] + [[package]] name = "arrow-cast" version = "56.2.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "919418a0681298d3a77d1a315f625916cb5678ad0d74b9c60108eb15fd083023" dependencies = [ - "arrow-array", - "arrow-buffer", - "arrow-data", - "arrow-schema", - "arrow-select", + "arrow-array 56.2.0", + "arrow-buffer 56.2.0", + "arrow-data 56.2.0", + "arrow-schema 56.2.0", + "arrow-select 56.2.0", "atoi", "base64 0.22.1", "chrono", @@ -405,15 +461,35 @@ dependencies = [ "ryu", ] +[[package]] +name = "arrow-cast" +version = "57.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9c9ebb4c987e6b3b236fb4a14b20b34835abfdd80acead3ccf1f9bf399e1f168" +dependencies = [ + "arrow-array 57.0.0", + "arrow-buffer 57.0.0", + "arrow-data 57.0.0", + "arrow-schema 57.0.0", + "arrow-select 57.0.0", + "atoi", + "base64 0.22.1", + "chrono", + "half", + "lexical-core", + "num-traits", + "ryu", +] + [[package]] name = "arrow-csv" -version = "56.2.0" +version = "57.0.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "bfa9bf02705b5cf762b6f764c65f04ae9082c7cfc4e96e0c33548ee3f67012eb" +checksum = "92386159c8d4bce96f8bd396b0642a0d544d471bdc2ef34d631aec80db40a09c" dependencies = [ - "arrow-array", - "arrow-cast", - "arrow-schema", + "arrow-array 57.0.0", + "arrow-cast 57.0.0", + "arrow-schema 57.0.0", "chrono", "csv", "csv-core", @@ -426,44 +502,59 @@ version = "56.2.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "a5c64fff1d142f833d78897a772f2e5b55b36cb3e6320376f0961ab0db7bd6d0" dependencies = [ - "arrow-buffer", - "arrow-schema", + "arrow-buffer 56.2.0", + "arrow-schema 56.2.0", "half", "num", ] +[[package]] +name = "arrow-data" +version = "57.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "727681b95de313b600eddc2a37e736dcb21980a40f640314dcf360e2f36bc89b" +dependencies = [ + "arrow-buffer 57.0.0", + "arrow-schema 57.0.0", + "half", + "num-integer", + "num-traits", +] + [[package]] name = "arrow-ipc" -version = "56.2.0" +version = "57.0.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1d3594dcddccc7f20fd069bc8e9828ce37220372680ff638c5e00dea427d88f5" +checksum = "da9ba92e3de170295c98a84e5af22e2b037f0c7b32449445e6c493b5fca27f27" dependencies = [ - "arrow-array", - "arrow-buffer", - "arrow-data", - "arrow-schema", - "arrow-select", + "arrow-array 57.0.0", + "arrow-buffer 57.0.0", + "arrow-data 57.0.0", + "arrow-schema 57.0.0", + "arrow-select 57.0.0", "flatbuffers", ] [[package]] name = "arrow-json" -version = "56.2.0" +version = "57.0.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "88cf36502b64a127dc659e3b305f1d993a544eab0d48cce704424e62074dc04b" +checksum = "b969b4a421ae83828591c6bf5450bd52e6d489584142845ad6a861f42fe35df8" dependencies = [ - "arrow-array", - "arrow-buffer", - "arrow-cast", - "arrow-data", - "arrow-schema", + "arrow-array 57.0.0", + "arrow-buffer 57.0.0", + "arrow-cast 57.0.0", + "arrow-data 57.0.0", + "arrow-schema 57.0.0", "chrono", "half", "indexmap", + "itoa", "lexical-core", "memchr", - "num", - "serde", + "num-traits", + "ryu", + "serde_core", "serde_json", "simdutf8", ] @@ -474,11 +565,24 @@ version = "56.2.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "3c8f82583eb4f8d84d4ee55fd1cb306720cddead7596edce95b50ee418edf66f" dependencies = [ - "arrow-array", - "arrow-buffer", - "arrow-data", - "arrow-schema", - "arrow-select", + "arrow-array 56.2.0", + "arrow-buffer 56.2.0", + "arrow-data 56.2.0", + "arrow-schema 56.2.0", + "arrow-select 56.2.0", +] + +[[package]] +name = "arrow-ord" +version = "57.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "141c05298b21d03e88062317a1f1a73f5ba7b6eb041b350015b1cd6aabc0519b" +dependencies = [ + "arrow-array 57.0.0", + "arrow-buffer 57.0.0", + "arrow-data 57.0.0", + "arrow-schema 57.0.0", + "arrow-select 57.0.0", ] [[package]] @@ -487,10 +591,23 @@ version = "56.2.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "9d07ba24522229d9085031df6b94605e0f4b26e099fb7cdeec37abd941a73753" dependencies = [ - "arrow-array", - "arrow-buffer", - "arrow-data", - "arrow-schema", + "arrow-array 56.2.0", + "arrow-buffer 56.2.0", + "arrow-data 56.2.0", + "arrow-schema 56.2.0", + "half", +] + +[[package]] +name = "arrow-row" +version = "57.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c5f3c06a6abad6164508ed283c7a02151515cef3de4b4ff2cebbcaeb85533db2" +dependencies = [ + "arrow-array 57.0.0", + "arrow-buffer 57.0.0", + "arrow-data 57.0.0", + "arrow-schema 57.0.0", "half", ] @@ -503,6 +620,12 @@ dependencies = [ "bitflags", ] +[[package]] +name = "arrow-schema" +version = "57.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9cfa7a03d1eee2a4d061476e1840ad5c9867a544ca6c4c59256496af5d0a8be5" + [[package]] name = "arrow-select" version = "56.2.0" @@ -510,44 +633,72 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "8c41dbbd1e97bfcaee4fcb30e29105fb2c75e4d82ae4de70b792a5d3f66b2e7a" dependencies = [ "ahash 0.8.12", - "arrow-array", - "arrow-buffer", - "arrow-data", - "arrow-schema", + "arrow-array 56.2.0", + "arrow-buffer 56.2.0", + "arrow-data 56.2.0", + "arrow-schema 56.2.0", "num", ] +[[package]] +name = "arrow-select" +version = "57.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bafa595babaad59f2455f4957d0f26448fb472722c186739f4fac0823a1bdb47" +dependencies = [ + "ahash 0.8.12", + "arrow-array 57.0.0", + "arrow-buffer 57.0.0", + "arrow-data 57.0.0", + "arrow-schema 57.0.0", + "num-traits", +] + [[package]] name = "arrow-string" version = "56.2.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "53f5183c150fbc619eede22b861ea7c0eebed8eaac0333eaa7f6da5205fd504d" dependencies = [ - "arrow-array", - "arrow-buffer", - "arrow-data", - "arrow-schema", - "arrow-select", + "arrow-array 56.2.0", + "arrow-buffer 56.2.0", + "arrow-data 56.2.0", + "arrow-schema 56.2.0", + "arrow-select 56.2.0", "memchr", "num", "regex", "regex-syntax", ] +[[package]] +name = "arrow-string" +version = "57.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "32f46457dbbb99f2650ff3ac23e46a929e0ab81db809b02aa5511c258348bef2" +dependencies = [ + "arrow-array 57.0.0", + "arrow-buffer 57.0.0", + "arrow-data 57.0.0", + "arrow-schema 57.0.0", + "arrow-select 57.0.0", + "memchr", + "num-traits", + "regex", + "regex-syntax", +] + [[package]] name = "async-compression" -version = "0.4.27" +version = "0.4.32" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ddb939d66e4ae03cee6091612804ba446b12878410cfa17f785f4dd67d4014e8" +checksum = "5a89bce6054c720275ac2432fbba080a66a2106a44a1b804553930ca6909f4e0" dependencies = [ - "brotli", - "flate2", + "compression-codecs", + "compression-core", "futures-core", - "memchr", "pin-project-lite", "tokio", - "zstd", - "zstd-safe", ] [[package]] @@ -569,7 +720,7 @@ checksum = "c7c24de15d275a1ecfd47a380fb4d5ec9bfe0933f309ed5e705b775596a3574d" dependencies = [ "proc-macro2", "quote", - "syn 2.0.106", + "syn 2.0.108", ] [[package]] @@ -580,7 +731,7 @@ checksum = "9035ad2d096bed7955a320ee7e2230574d28fd3c3a0f186cbea1ff3c7eed5dbb" dependencies = [ "proc-macro2", "quote", - "syn 2.0.106", + "syn 2.0.108", ] [[package]] @@ -689,14 +840,14 @@ checksum = "604fde5e028fea851ce1d8570bbdc034bec850d157f7569d10f347d06808c05c" dependencies = [ "proc-macro2", "quote", - "syn 2.0.106", + "syn 2.0.108", ] [[package]] name = "backtrace" -version = "0.3.75" +version = "0.3.76" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6806a6321ec58106fea15becdad98371e28d92ccbc7c8f1b3b6dd724fe8f1002" +checksum = "bb531853791a215d7c62a30daf0dde835f381ab5de4589cfe7c649d2cbe92bd6" dependencies = [ "addr2line", "cfg-if", @@ -704,7 +855,7 @@ dependencies = [ "miniz_oxide", "object", "rustc-demangle", - "windows-targets 0.52.6", + "windows-link 0.2.1", ] [[package]] @@ -739,9 +890,9 @@ dependencies = [ [[package]] name = "bigdecimal" -version = "0.4.8" +version = "0.4.9" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1a22f228ab7a1b23027ccc6c350b72868017af7ea8356fbdf19f8d991c690013" +checksum = "560f42649de9fa436b73517378a147ec21f6c997a546581df4b4b31677828934" dependencies = [ "autocfg", "libm", @@ -759,7 +910,7 @@ dependencies = [ "bitflags", "cexpr", "clang-sys", - "itertools 0.12.1", + "itertools 0.13.0", "log", "prettyplease", "proc-macro2", @@ -767,16 +918,16 @@ dependencies = [ "regex", "rustc-hash", "shlex", - "syn 2.0.106", + "syn 2.0.108", ] [[package]] name = "bitflags" -version = "2.9.4" +version = "2.10.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2261d10cca569e4643e526d8dc2e62e433cc8aba21ab764233731f8d369bf394" +checksum = "812e12b5285cc515a9c72a5c1d3b6d46a19dac5acfef5265968c166106e31dd3" dependencies = [ - "serde", + "serde_core", ] [[package]] @@ -833,7 +984,7 @@ dependencies = [ "proc-macro-crate", "proc-macro2", "quote", - "syn 2.0.106", + "syn 2.0.108", ] [[package]] @@ -919,9 +1070,9 @@ checksum = "d71b6127be86fdcfddb610f7182ac57211d4b18a3e9c82eb2d17662f2227ad6a" [[package]] name = "bytestring" -version = "1.4.0" +version = "1.5.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e465647ae23b2823b0753f50decb2d5a86d2bb2cac04788fafd1f80e45378e5f" +checksum = "113b4343b5f6617e7ad401ced8de3cc8b012e73a594347c307b90db3e9271289" dependencies = [ "bytes", ] @@ -953,7 +1104,7 @@ dependencies = [ "darling", "proc-macro2", "quote", - "syn 2.0.106", + "syn 2.0.108", ] [[package]] @@ -970,10 +1121,11 @@ checksum = "37b2a672a2cb129a2e41c10b1224bb368f9f37a2b16b612598138befd7b37eb5" [[package]] name = "cc" -version = "1.2.33" +version = "1.2.41" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3ee0f8803222ba5a7e2777dd72ca451868909b1ac410621b676adf07280e9b5f" +checksum = "ac9fe6cdbb24b6ade63616c0a0688e45bb56732262c158df3c0c4bea4ca47cb7" dependencies = [ + "find-msvc-tools", "jobserver", "libc", "shlex", @@ -990,9 +1142,9 @@ dependencies = [ [[package]] name = "cfg-if" -version = "1.0.1" +version = "1.0.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9555578bc9e57714c812a1f84e4fc5b4d21fcb063490c624de019f7464c91268" +checksum = "9330f8b2ff13f34540b44e946ef35111825727b38d33286ef986142615121801" [[package]] name = "cfg_aliases" @@ -1002,17 +1154,16 @@ checksum = "613afe47fcd5fac7ccf1db93babcb082c5994d996f20b8b159f2ad1658eb5724" [[package]] name = "chrono" -version = "0.4.41" +version = "0.4.42" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c469d952047f47f91b68d1cba3f10d63c11d73e4636f24f08daf0278abf01c4d" +checksum = "145052bdd345b87320e369255277e3fb5152762ad123a901ef5c262dd38fe8d2" dependencies = [ - "android-tzdata", "iana-time-zone", "js-sys", "num-traits", "serde", "wasm-bindgen", - "windows-link 0.1.3", + "windows-link 0.2.1", ] [[package]] @@ -1034,9 +1185,9 @@ dependencies = [ [[package]] name = "clap" -version = "4.5.49" +version = "4.5.50" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f4512b90fa68d3a9932cea5184017c5d200f5921df706d45e853537dea51508f" +checksum = "0c2cfd7bf8a6017ddaa4e32ffe7403d547790db06bd171c1c53926faab501623" dependencies = [ "clap_builder", "clap_derive", @@ -1044,9 +1195,9 @@ dependencies = [ [[package]] name = "clap_builder" -version = "4.5.49" +version = "4.5.50" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0025e98baa12e766c67ba13ff4695a887a1eba19569aad00a472546795bd6730" +checksum = "0a4c05b9e80c5ccd3a7ef080ad7b6ba7d6fc00a985b8b157197075677c82c7a0" dependencies = [ "anstream", "anstyle", @@ -1063,14 +1214,14 @@ dependencies = [ "heck 0.5.0", "proc-macro2", "quote", - "syn 2.0.106", + "syn 2.0.108", ] [[package]] name = "clap_lex" -version = "0.7.5" +version = "0.7.6" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b94f61472cee1439c0b966b47e3aca9ae07e45d070759512cd390ea2bebc6675" +checksum = "a1d728cc89cf3aee9ff92b05e62b19ee65a02b5702cff7d5a377e32c6ae29d8d" [[package]] name = "clickhouse" @@ -1110,7 +1261,7 @@ dependencies = [ "proc-macro2", "quote", "serde_derive_internals", - "syn 2.0.106", + "syn 2.0.108", ] [[package]] @@ -1155,6 +1306,26 @@ dependencies = [ "unicode-width", ] +[[package]] +name = "compression-codecs" +version = "0.4.31" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ef8a506ec4b81c460798f572caead636d57d3d7e940f998160f52bd254bf2d23" +dependencies = [ + "brotli", + "compression-core", + "flate2", + "memchr", + "zstd", + "zstd-safe", +] + +[[package]] +name = "compression-core" +version = "0.4.29" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e47641d3deaf41fb1538ac1f54735925e275eaf3bf4d55c81b137fba797e5cbb" + [[package]] name = "concurrent-queue" version = "2.5.0" @@ -1204,7 +1375,7 @@ dependencies = [ "heck 0.5.0", "proc-macro2", "quote", - "syn 2.0.106", + "syn 2.0.108", ] [[package]] @@ -1359,14 +1530,14 @@ dependencies = [ [[package]] name = "csv" -version = "1.3.1" +version = "1.4.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "acdc4883a9c96732e4733212c01447ebd805833b7275a73ca3ee080fd77afdaf" +checksum = "52cd9d68cf7efc6ddfaaee42e7288d3a99d613d4b50f76ce9827ae0c6e14f938" dependencies = [ "csv-core", "itoa", "ryu", - "serde", + "serde_core", ] [[package]] @@ -1385,9 +1556,9 @@ dependencies = [ [[package]] name = "csv-core" -version = "0.1.12" +version = "0.1.13" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7d02f3b0da4c6504f86e9cd789d8dbafab48c2321be74e9987593de5a894d93d" +checksum = "704a3c26996a80471189265814dbc2c257598b96b8a7feae2d31ace646bb9782" dependencies = [ "memchr", ] @@ -1413,7 +1584,7 @@ dependencies = [ "proc-macro2", "quote", "strsim", - "syn 2.0.106", + "syn 2.0.108", ] [[package]] @@ -1424,7 +1595,7 @@ checksum = "fc34b93ccb385b40dc71c6fceac4b2ad23662c7eeb248cf10d529b7e055b6ead" dependencies = [ "darling_core", "quote", - "syn 2.0.106", + "syn 2.0.108", ] [[package]] @@ -1493,7 +1664,7 @@ checksum = "bda628edc44c4bb645fbe0f758797143e4e07926f7ebf4e9bdfbd3d2ce621df3" dependencies = [ "proc-macro2", "quote", - "syn 2.0.106", + "syn 2.0.108", "unicode-xid", ] @@ -1517,7 +1688,7 @@ checksum = "97369cbbc041bc366949bc74d34658d6cda5621039731c6310521892a3a20ae0" dependencies = [ "proc-macro2", "quote", - "syn 2.0.106", + "syn 2.0.108", ] [[package]] @@ -1531,9 +1702,9 @@ dependencies = [ [[package]] name = "doc-comment" -version = "0.3.3" +version = "0.3.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "fea41bba32d969b513997752735605054bc0dfa92b4c56bf1189f2e174be7a10" +checksum = "780955b8b195a21ab8e4ac6b60dd1dbdcec1dc6c51c0617964b08c81785e12c9" [[package]] name = "dotenvy" @@ -1547,7 +1718,7 @@ version = "1.4.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "2a093eed1c714143b257b95fa323e38527fabf05fbf02bb0d5d2045275ffdaef" dependencies = [ - "arrow", + "arrow 56.2.0", "cast", "fallible-iterator", "fallible-streaming-iterator", @@ -1606,22 +1777,23 @@ checksum = "877a4ace8713b0bcf2a4e7eec82529c029f1d0619886d18145fea96c3ffe5c0f" [[package]] name = "erased-serde" -version = "0.4.6" +version = "0.4.8" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e004d887f51fcb9fef17317a2f3525c887d8aa3f4f50fed920816a688284a5b7" +checksum = "259d404d09818dec19332e31d94558aeb442fea04c817006456c24b5460bbd4b" dependencies = [ "serde", + "serde_core", "typeid", ] [[package]] name = "errno" -version = "0.3.13" +version = "0.3.14" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "778e2ac28f6c47af28e4907f13ffd1e1ddbd400980a9abd7c8df189bf578a5ad" +checksum = "39cab71617ae0d63f51a36d69f866391735b51691dbda63cf6f96d042b63efeb" dependencies = [ "libc", - "windows-sys 0.60.2", + "windows-sys 0.61.2", ] [[package]] @@ -1666,16 +1838,22 @@ checksum = "37909eebbb50d72f9059c3b6d82c0463f2ff062c9e95845c43a6c9c0355411be" [[package]] name = "filetime" -version = "0.2.25" +version = "0.2.26" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "35c0522e981e68cbfa8c3f978441a5f34b30b96e146b33cd3359176b50fe8586" +checksum = "bc0505cd1b6fa6580283f6bdf70a73fcf4aba1184038c90902b92b3dd0df63ed" dependencies = [ "cfg-if", "libc", "libredox", - "windows-sys 0.59.0", + "windows-sys 0.60.2", ] +[[package]] +name = "find-msvc-tools" +version = "0.1.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "52051878f80a721bb68ebfbc930e07b65ba72f2da88968ea5c06fd6ca3d3a127" + [[package]] name = "findshlibs" version = "0.10.2" @@ -1706,9 +1884,9 @@ dependencies = [ [[package]] name = "flate2" -version = "1.1.4" +version = "1.1.5" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "dc5a4e564e38c699f2880d3fda590bedc2e69f3f84cd48b457bd892ce61d0aa9" +checksum = "bfe33edd8e85a12a67454e37f8c75e730830d83e313556ab9ebf9ee7fbeb3bfb" dependencies = [ "crc32fast", "miniz_oxide", @@ -1846,7 +2024,7 @@ checksum = "162ee34ebcb7c64a8abebc059ce0fee27c2262618d7b60ed8faf72fef13c3650" dependencies = [ "proc-macro2", "quote", - "syn 2.0.106", + "syn 2.0.108", ] [[package]] @@ -1914,9 +2092,9 @@ dependencies = [ [[package]] name = "generic-array" -version = "0.14.7" +version = "0.14.9" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "85649ca51fd72272d7821adaf274ad91c288277713d9c18820d8499a7ff69e9a" +checksum = "4bb6743198531e02858aeaea5398fcc883e71851fcbcb5a2f773e2fb6cb1edf2" dependencies = [ "typenum", "version_check", @@ -1971,29 +2149,29 @@ dependencies = [ "cfg-if", "js-sys", "libc", - "wasi 0.11.1+wasi-snapshot-preview1", + "wasi", "wasm-bindgen", ] [[package]] name = "getrandom" -version = "0.3.3" +version = "0.3.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "26145e563e54f2cadc477553f1ec5ee650b00862f0a58bcd12cbdc5f0ea2d2f4" +checksum = "899def5c37c4fd7b2664648c28120ecec138e4d395b459e5ca34f9cce2dd77fd" dependencies = [ "cfg-if", "js-sys", "libc", "r-efi", - "wasi 0.14.2+wasi-0.2.4", + "wasip2", "wasm-bindgen", ] [[package]] name = "gimli" -version = "0.31.1" +version = "0.32.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "07e28edb80900c19c28f1072f2e8aeca7fa06b23cd4169cefe1af5aa3260783f" +checksum = "e629b9b98ef3dd8afe6ca2bd0f89306cec16d43d907889945bc5d6687f2f13c7" [[package]] name = "glob" @@ -2022,13 +2200,14 @@ dependencies = [ [[package]] name = "half" -version = "2.6.0" +version = "2.7.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "459196ed295495a68f7d7fe1d84f6c4b7ff0e21fe3017b2f283c6fac3ad803c9" +checksum = "6ea2d84b969582b4b1864a92dc5d27cd2b77b622a8d79306834f1be5ba20d84b" dependencies = [ "cfg-if", "crunchy", "num-traits", + "zerocopy", ] [[package]] @@ -2127,16 +2306,16 @@ checksum = "7f24254aa9a54b5c858eaee2f5bccdb46aaf0e486a595ed5fd8f86ba55232a70" [[package]] name = "hifitime" -version = "4.2.1" +version = "4.2.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8ca4780c17998a6d7089dac984f76aa860324dbf7451f11cf915d7f199846bec" +checksum = "8813a4c78b7f391d4ab7f7facbf5b571cbbb608b633cdee0da5fd4138f6f6a86" dependencies = [ "js-sys", "lexical-core", "num-traits", "serde", "serde_derive", - "snafu 0.8.6", + "snafu 0.8.9", "wasm-bindgen", "web-sys", "web-time", @@ -2162,11 +2341,11 @@ dependencies = [ [[package]] name = "home" -version = "0.5.11" +version = "0.5.12" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "589533453244b0995c858700322199b2becb13b627df2851f64a2775d024abcf" +checksum = "cc627f471c528ff0c4a49e1d5e60450c8f6461dd6d10ba9dcd3a61d3dff7728d" dependencies = [ - "windows-sys 0.59.0", + "windows-sys 0.61.2", ] [[package]] @@ -2255,13 +2434,14 @@ dependencies = [ [[package]] name = "hyper" -version = "1.6.0" +version = "1.7.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "cc2b571658e38e0c01b1fdca3bbbe93c00d3d71693ff2770043f8c29bc7d6f80" +checksum = "eb3aa54a13a0dfe7fbe3a59e0c76093041720fdc77b110cc0fc260fafb4dc51e" dependencies = [ + "atomic-waker", "bytes", "futures-channel", - "futures-util", + "futures-core", "h2", "http 1.3.1", "http-body", @@ -2269,6 +2449,7 @@ dependencies = [ "httpdate", "itoa", "pin-project-lite", + "pin-utils", "smallvec 1.15.1", "tokio", "want", @@ -2323,9 +2504,9 @@ dependencies = [ [[package]] name = "hyper-util" -version = "0.1.16" +version = "0.1.17" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8d9b05277c7e8da2c93a568989bb6207bef0112e8d17df7a6eda4a3cf143bc5e" +checksum = "3c6995591a8f1380fcb4ba966a252a4b29188d51d2b89e3a252f5305be65aea8" dependencies = [ "base64 0.22.1", "bytes", @@ -2339,7 +2520,7 @@ dependencies = [ "libc", "percent-encoding", "pin-project-lite", - "socket2 0.6.0", + "socket2 0.6.1", "tokio", "tower-service", "tracing", @@ -2390,9 +2571,9 @@ checksum = "35e6d558e6d4c7b82bc51d9c771e7a927862a161a7d87bf2b0541450e0e20915" [[package]] name = "iana-time-zone" -version = "0.1.63" +version = "0.1.64" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b0c919e5debc312ad217002b8048a17b7d83f80703865bbfcfebb0458b0b27d8" +checksum = "33e57f83510bb73707521ebaffa789ec8caf86f9657cad665b092b581d40e9fb" dependencies = [ "android_system_properties", "core-foundation-sys", @@ -2533,9 +2714,9 @@ checksum = "e8a5a9a0ff0086c7a148acb942baaabeadf9504d10400b5a05645853729b9cd2" [[package]] name = "indexmap" -version = "2.11.4" +version = "2.12.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4b0f83760fb341a774ed326568e19f5a863af4a952def8c39f9ab92fd95b88e5" +checksum = "6717a8d2a5a929a1a2eb43a12812498ed141a0bcfb7e8f7844fbdbe4303bba9f" dependencies = [ "equivalent", "hashbrown 0.16.0", @@ -2574,9 +2755,9 @@ dependencies = [ [[package]] name = "is_terminal_polyfill" -version = "1.70.1" +version = "1.70.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7943c866cc5cd64cbc25b2e01621d07fa8eb2a1a23160ee81ce38704e97b8ecf" +checksum = "a6cb138bb79a146c1bd460005623e142ef0181e3d0219cb493e02f7d08a35695" [[package]] name = "iso8601" @@ -2598,9 +2779,9 @@ dependencies = [ [[package]] name = "itertools" -version = "0.12.1" +version = "0.13.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ba291022dbbd398a455acf126c1e341954079855bc60dfdda641363bd6922569" +checksum = "413ee7dfc52ee1a4949ceeb7dbc8a33f2d6c088194d9f922fb8318faf1f01186" dependencies = [ "either", ] @@ -2622,19 +2803,19 @@ checksum = "4a5f13b858c8d314ee3e8f639011f7ccefe71f97f96e50151fb991f267928e2c" [[package]] name = "jobserver" -version = "0.1.33" +version = "0.1.34" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "38f262f097c174adebe41eb73d66ae9c06b2844fb0da69969647bbddd9b0538a" +checksum = "9afb3de4395d6b3e67a780b6de64b51c978ecf11cb9a462c66be7d4ca9039d33" dependencies = [ - "getrandom 0.3.3", + "getrandom 0.3.4", "libc", ] [[package]] name = "js-sys" -version = "0.3.77" +version = "0.3.81" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1cfaf33c695fc6e08064efbc1f72ec937429614f25eef83af942d0e227c3a28f" +checksum = "ec48937a97411dcb524a265206ccd4c90bb711fca92b2792c407f268825b9305" dependencies = [ "once_cell", "wasm-bindgen", @@ -2668,9 +2849,9 @@ dependencies = [ [[package]] name = "lexical-core" -version = "1.0.5" +version = "1.0.6" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b765c31809609075565a70b4b71402281283aeda7ecaf4818ac14a7b2ade8958" +checksum = "7d8d125a277f807e55a77304455eb7b1cb52f2b18c143b60e766c120bd64a594" dependencies = [ "lexical-parse-float", "lexical-parse-integer", @@ -2681,60 +2862,53 @@ dependencies = [ [[package]] name = "lexical-parse-float" -version = "1.0.5" +version = "1.0.6" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "de6f9cb01fb0b08060209a057c048fcbab8717b4c1ecd2eac66ebfe39a65b0f2" +checksum = "52a9f232fbd6f550bc0137dcb5f99ab674071ac2d690ac69704593cb4abbea56" dependencies = [ "lexical-parse-integer", "lexical-util", - "static_assertions", ] [[package]] name = "lexical-parse-integer" -version = "1.0.5" +version = "1.0.6" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "72207aae22fc0a121ba7b6d479e42cbfea549af1479c3f3a4f12c70dd66df12e" +checksum = "9a7a039f8fb9c19c996cd7b2fcce303c1b2874fe1aca544edc85c4a5f8489b34" dependencies = [ "lexical-util", - "static_assertions", ] [[package]] name = "lexical-util" -version = "1.0.6" +version = "1.0.7" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5a82e24bf537fd24c177ffbbdc6ebcc8d54732c35b50a3f28cc3f4e4c949a0b3" -dependencies = [ - "static_assertions", -] +checksum = "2604dd126bb14f13fb5d1bd6a66155079cb9fa655b37f875b3a742c705dbed17" [[package]] name = "lexical-write-float" -version = "1.0.5" +version = "1.0.6" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c5afc668a27f460fb45a81a757b6bf2f43c2d7e30cb5a2dcd3abf294c78d62bd" +checksum = "50c438c87c013188d415fbabbb1dceb44249ab81664efbd31b14ae55dabb6361" dependencies = [ "lexical-util", "lexical-write-integer", - "static_assertions", ] [[package]] name = "lexical-write-integer" -version = "1.0.5" +version = "1.0.6" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "629ddff1a914a836fb245616a7888b62903aae58fa771e1d83943035efa0f978" +checksum = "409851a618475d2d5796377cad353802345cba92c867d9fbcde9cf4eac4e14df" dependencies = [ "lexical-util", - "static_assertions", ] [[package]] name = "libc" -version = "0.2.175" +version = "0.2.177" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6a82ae493e598baaea5209805c49bbf2ea7de956d50d7da0da1164f9c6d28543" +checksum = "2874a2af47a2325c2001a6e6fad9b16a53b802102b528163885171cf92b15976" [[package]] name = "libduckdb-sys" @@ -2753,12 +2927,12 @@ dependencies = [ [[package]] name = "libloading" -version = "0.8.8" +version = "0.8.9" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "07033963ba89ebaf1584d767badaa2e8fcec21aedea6b8c0346d487d49c28667" +checksum = "d7c4b02199fee7c5d21a5ae7d8cfa79a6ef5bb2fc834d6e9058e89c825efdc55" dependencies = [ "cfg-if", - "windows-targets 0.53.3", + "windows-link 0.2.1", ] [[package]] @@ -2769,9 +2943,9 @@ checksum = "f9fbbcab51052fe104eb5e5d351cf728d30a5be1fe14d9be8a3b097481fb97de" [[package]] name = "libredox" -version = "0.1.9" +version = "0.1.10" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "391290121bad3d37fbddad76d8f5d1c1c314cfc646d143d7e07a3086ddff0ce3" +checksum = "416f7e718bdb06000964960ffa43b4335ad4012ae8b99060261aa4a8088d5ccb" dependencies = [ "bitflags", "libc", @@ -2791,9 +2965,9 @@ dependencies = [ [[package]] name = "linux-raw-sys" -version = "0.9.4" +version = "0.11.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "cd945864f07fe9f5371a27ad7b52a172b4b499999f1d97574c9fa68373937e12" +checksum = "df1d3c3b53da64cf5760482273a98e575c651a67eec7f77df96b5b642de8f039" [[package]] name = "litemap" @@ -2820,11 +2994,10 @@ checksum = "4d873d7c67ce09b42110d801813efbc9364414e356be9935700d368351657487" [[package]] name = "lock_api" -version = "0.4.13" +version = "0.4.14" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "96936507f153605bddfcda068dd804796c84324ed2510809e5b2a624c81da765" +checksum = "224399e74b87b5f3557511d98dff8b14089b3dadafcab6bb93eab67d3aace965" dependencies = [ - "autocfg", "scopeguard", ] @@ -2873,9 +3046,9 @@ dependencies = [ [[package]] name = "memchr" -version = "2.7.5" +version = "2.7.6" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "32a282da65faaf38286cf3be983213fcf1d2e2a58700e808f83f4ea9a4804bc0" +checksum = "f52b00d39961fc5b2736ea853c9cc86238e165017a493d1d5c8eac6bdc4cc273" [[package]] name = "mime" @@ -2911,14 +3084,14 @@ dependencies = [ [[package]] name = "mio" -version = "1.0.4" +version = "1.1.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "78bed444cc8a2160f01cbcf811ef18cac863ad68ae8ca62092e8db51d51c761c" +checksum = "69d83b0086dc8ecf3ce9ae2874b2d1290252e2a30720bea58a5c6639b0092873" dependencies = [ "libc", "log", - "wasi 0.11.1+wasi-snapshot-preview1", - "windows-sys 0.59.0", + "wasi", + "windows-sys 0.61.2", ] [[package]] @@ -3107,9 +3280,9 @@ dependencies = [ [[package]] name = "object" -version = "0.36.7" +version = "0.37.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "62948e14d923ea95ea2c7c86c71013138b66525b86bdc08d2dcc262bdb497b87" +checksum = "ff76201f031d8863c38aa7f905eca4f53abbfa15f609db4277d44cd8938f33fe" dependencies = [ "memchr", ] @@ -3122,15 +3295,15 @@ checksum = "42f5e15c9953c5e4ccceeb2e7382a716482c34515315f7b03532b8b4e8393d2d" [[package]] name = "once_cell_polyfill" -version = "1.70.1" +version = "1.70.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a4895175b425cb1f87721b59f0f286c2092bd4af812243672510e1ac53e2e0ad" +checksum = "384b8ab6d37215f3c5301a95a4accb5d64aa607f1fcb26a11b5303878451b4fe" [[package]] name = "openssl" -version = "0.10.73" +version = "0.10.74" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8505734d46c8ab1e19a1dce3aef597ad87dcb4c37e7188231769bd6bd51cebf8" +checksum = "24ad14dd45412269e1a30f52ad8f0664f0f4f4a89ee8fe28c3b3527021ebb654" dependencies = [ "bitflags", "cfg-if", @@ -3149,7 +3322,7 @@ checksum = "a948666b637a0f465e8564c73e89d4dde00d72d4d473cc972f390fc3dcee7d9c" dependencies = [ "proc-macro2", "quote", - "syn 2.0.106", + "syn 2.0.108", ] [[package]] @@ -3160,9 +3333,9 @@ checksum = "d05e27ee213611ffe7d6348b942e8f942b37114c00cc03cec254295a4a17852e" [[package]] name = "openssl-sys" -version = "0.9.109" +version = "0.9.110" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "90096e2e47630d78b7d1c20952dc621f957103f8bc2c8359ec81290d75238571" +checksum = "0a9f0075ba3c21b09f8e8b2026584b1d18d49388648f2fbbf3c97ea8deced8e2" dependencies = [ "cc", "libc", @@ -3200,9 +3373,9 @@ checksum = "f38d5652c16fde515bb1ecef450ab0f6a219d619a7274976324d5e377f7dceba" [[package]] name = "parking_lot" -version = "0.12.4" +version = "0.12.5" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "70d58bf43669b5795d1576d0641cfb6fbb2057bf629506267a92807158584a13" +checksum = "93857453250e3077bd71ff98b6a65ea6621a19bb0f559a85248955ac12c45a1a" dependencies = [ "lock_api", "parking_lot_core", @@ -3210,15 +3383,15 @@ dependencies = [ [[package]] name = "parking_lot_core" -version = "0.9.11" +version = "0.9.12" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "bc838d2a56b5b1a6c25f55575dfc605fabb63bb2365f6c2353ef9159aa69e4a5" +checksum = "2621685985a2ebf1c516881c026032ac7deafcda1a2c9b7850dc81e3dfcb64c1" dependencies = [ "cfg-if", "libc", "redox_syscall", "smallvec 1.15.1", - "windows-targets 0.52.6", + "windows-link 0.2.1", ] [[package]] @@ -3244,20 +3417,19 @@ checksum = "9b4f627cb1b25917193a259e49bdad08f671f8d9708acfd5fe0a8c1455d87220" [[package]] name = "pest" -version = "2.8.1" +version = "2.8.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1db05f56d34358a8b1066f67cbb203ee3e7ed2ba674a6263a1d5ec6db2204323" +checksum = "989e7521a040efde50c3ab6bbadafbe15ab6dc042686926be59ac35d74607df4" dependencies = [ "memchr", - "thiserror 2.0.17", "ucd-trie", ] [[package]] name = "pest_derive" -version = "2.8.1" +version = "2.8.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "bb056d9e8ea77922845ec74a1c4e8fb17e7c218cc4fc11a15c5d25e189aa40bc" +checksum = "187da9a3030dbafabbbfb20cb323b976dc7b7ce91fcd84f2f74d6e31d378e2de" dependencies = [ "pest", "pest_generator", @@ -3265,22 +3437,22 @@ dependencies = [ [[package]] name = "pest_generator" -version = "2.8.1" +version = "2.8.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "87e404e638f781eb3202dc82db6760c8ae8a1eeef7fb3fa8264b2ef280504966" +checksum = "49b401d98f5757ebe97a26085998d6c0eecec4995cad6ab7fc30ffdf4b052843" dependencies = [ "pest", "pest_meta", "proc-macro2", "quote", - "syn 2.0.106", + "syn 2.0.108", ] [[package]] name = "pest_meta" -version = "2.8.1" +version = "2.8.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "edd1101f170f5903fde0914f899bb503d9ff5271d7ba76bbb70bea63690cc0d5" +checksum = "72f27a2cfee9f9039c4d86faa5af122a0ac3851441a34865b8a043b46be0065a" dependencies = [ "pest", "sha2", @@ -3313,7 +3485,7 @@ checksum = "6e918e4ff8c4549eb882f14b3a4bc8c8bc93de829416eacf579f1207a8fbf861" dependencies = [ "proc-macro2", "quote", - "syn 2.0.106", + "syn 2.0.108", ] [[package]] @@ -3357,9 +3529,9 @@ checksum = "7edddbd0b52d732b21ad9a5fab5c704c14cd949e5e9a1ec5929a24fded1b904c" [[package]] name = "plist" -version = "1.7.4" +version = "1.8.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3af6b589e163c5a788fab00ce0c0366f6efbb9959c2f9874b224936af7fce7e1" +checksum = "740ebea15c5d1428f910cd1a5f52cebf8d25006245ed8ade92702f4943d91e07" dependencies = [ "base64 0.22.1", "indexmap", @@ -3370,9 +3542,9 @@ dependencies = [ [[package]] name = "potential_utf" -version = "0.1.2" +version = "0.1.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e5a7c30837279ca13e7c867e9e40053bc68740f988cb07f7ca6df43cc734b585" +checksum = "84df19adbe5b5a0782edcab45899906947ab039ccf4573713735ee7de1e6b08a" dependencies = [ "zerovec", ] @@ -3394,28 +3566,28 @@ dependencies = [ [[package]] name = "prettyplease" -version = "0.2.36" +version = "0.2.37" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ff24dfcda44452b9816fff4cd4227e1bb73ff5a2f1bc1105aa92fb8565ce44d2" +checksum = "479ca8adacdd7ce8f1fb39ce9ecccbfe93a3f1344b3d0d97f20bc0196208f62b" dependencies = [ "proc-macro2", - "syn 2.0.106", + "syn 2.0.108", ] [[package]] name = "proc-macro-crate" -version = "3.3.0" +version = "3.4.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "edce586971a4dfaa28950c6f18ed55e0406c1ab88bbce2c6f6293a7aaba73d35" +checksum = "219cb19e96be00ab2e37d6e299658a0cfa83e52429179969b0f0121b4ac46983" dependencies = [ "toml_edit", ] [[package]] name = "proc-macro2" -version = "1.0.101" +version = "1.0.103" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "89ae43fd86e4158d6db51ad8e2b80f313af9cc74f5c0e03ccb87de09998732de" +checksum = "5ee95bc4ef87b8d5ba32e8b7714ccc834865276eab0aed5c9958d00ec45f49e8" dependencies = [ "unicode-ident", ] @@ -3448,7 +3620,7 @@ dependencies = [ "pulldown-cmark", "pulldown-cmark-to-cmark", "regex", - "syn 2.0.106", + "syn 2.0.108", "tempfile", ] @@ -3462,7 +3634,7 @@ dependencies = [ "itertools 0.14.0", "proc-macro2", "quote", - "syn 2.0.106", + "syn 2.0.108", ] [[package]] @@ -3524,25 +3696,25 @@ dependencies = [ "libc", "once_cell", "raw-cpuid", - "wasi 0.11.1+wasi-snapshot-preview1", + "wasi", "web-sys", "winapi", ] [[package]] name = "quick-xml" -version = "0.38.1" +version = "0.38.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9845d9dccf565065824e69f9f235fafba1587031eda353c1f1561cd6a6be78f4" +checksum = "42a232e7487fc2ef313d96dde7948e7a3c05101870d8985e4fd8d26aedd27b89" dependencies = [ "memchr", ] [[package]] name = "quinn" -version = "0.11.8" +version = "0.11.9" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "626214629cda6781b6dc1d316ba307189c85ba657213ce642d9c77670f8202c8" +checksum = "b9e20a958963c291dc322d98411f541009df2ced7b5a4f2bd52337638cfccf20" dependencies = [ "bytes", "cfg_aliases", @@ -3551,7 +3723,7 @@ dependencies = [ "quinn-udp", "rustc-hash", "rustls", - "socket2 0.5.10", + "socket2 0.6.1", "thiserror 2.0.17", "tokio", "tracing", @@ -3560,12 +3732,12 @@ dependencies = [ [[package]] name = "quinn-proto" -version = "0.11.12" +version = "0.11.13" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "49df843a9161c85bb8aae55f101bc0bac8bcafd637a620d9122fd7e0b2f7422e" +checksum = "f1906b49b0c3bc04b5fe5d86a77925ae6524a19b816ae38ce1e426255f1d8a31" dependencies = [ "bytes", - "getrandom 0.3.3", + "getrandom 0.3.4", "lru-slab", "rand 0.9.2", "ring", @@ -3581,23 +3753,23 @@ dependencies = [ [[package]] name = "quinn-udp" -version = "0.5.13" +version = "0.5.14" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "fcebb1209ee276352ef14ff8732e24cc2b02bbac986cd74a4c81bcb2f9881970" +checksum = "addec6a0dcad8a8d96a771f815f0eaf55f9d1805756410b39f5fa81332574cbd" dependencies = [ "cfg_aliases", "libc", "once_cell", - "socket2 0.5.10", + "socket2 0.6.1", "tracing", - "windows-sys 0.59.0", + "windows-sys 0.60.2", ] [[package]] name = "quote" -version = "1.0.40" +version = "1.0.41" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1885c039570dc00dcb4ff087a89e185fd56bae234ddc7f056a945bf36467248d" +checksum = "ce25767e7b499d1b604768e7cde645d14cc8584231ea6b295e9c9eb22c02e1d1" dependencies = [ "proc-macro2", ] @@ -3670,14 +3842,14 @@ version = "0.9.3" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "99d9a13982dcf210057a8a78572b2217b667c3beacbf3a0d8b454f6f82837d38" dependencies = [ - "getrandom 0.3.3", + "getrandom 0.3.4", ] [[package]] name = "raw-cpuid" -version = "11.5.0" +version = "11.6.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c6df7ab838ed27997ba19a4664507e6f82b41fe6e20be42929332156e5e85146" +checksum = "498cd0dc59d73224351ee52a95fee0f1a617a2eae0e7d9d720cc622c73a54186" dependencies = [ "bitflags", ] @@ -3704,9 +3876,9 @@ dependencies = [ [[package]] name = "redox_syscall" -version = "0.5.17" +version = "0.5.18" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5407465600fb0548f1442edf71dd20683c6ed326200ace4b1ef0763521bb3b77" +checksum = "ed2bf2547551a7053d6fdfafda3f938979645c44812fbfcda098faae3f1a362d" dependencies = [ "bitflags", ] @@ -3736,15 +3908,15 @@ dependencies = [ [[package]] name = "regex-lite" -version = "0.1.6" +version = "0.1.8" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "53a49587ad06b26609c52e423de037e7f57f20d53535d66e08c695f347df952a" +checksum = "8d942b98df5e658f56f20d592c7f868833fe38115e65c33003d8cd224b0155da" [[package]] name = "regex-syntax" -version = "0.8.5" +version = "0.8.8" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2b15c43186be67a4fd63bee50d0303afffcef381492ebe2c5d87f324e1b8815c" +checksum = "7a2d987857b319362043e95f5353c0535c1f58eec5336fdfcf626430af7def58" [[package]] name = "rend" @@ -3763,9 +3935,9 @@ checksum = "51743d3e274e2b18df81c4dc6caf8a5b8e15dbe799e0dca05c7617380094e884" [[package]] name = "reqwest" -version = "0.12.23" +version = "0.12.24" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d429f34c8092b2d42c7c93cec323bb4adeb7c67698f70839adec842ec10c7ceb" +checksum = "9d0946410b9f7b082a427e4ef5c8ff541a88b357bc6c637c40db3a68ac70a36f" dependencies = [ "base64 0.22.1", "bytes", @@ -3956,22 +4128,22 @@ dependencies = [ [[package]] name = "rustix" -version = "1.0.8" +version = "1.1.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "11181fbabf243db407ef8df94a6ce0b2f9a733bd8be4ad02b4eda9602296cac8" +checksum = "cd15f8a2c5551a84d56efdc1cd049089e409ac19a3072d5037a17fd70719ff3e" dependencies = [ "bitflags", "errno", "libc", "linux-raw-sys", - "windows-sys 0.60.2", + "windows-sys 0.61.2", ] [[package]] name = "rustls" -version = "0.23.33" +version = "0.23.34" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "751e04a496ca00bb97a5e043158d23d66b5aabf2e1d5aa2a0aaebb1aafe6f82c" +checksum = "6a9586e9ee2b4f8fab52a0048ca7334d7024eef48e2cb9407e3497bb7cab7fa7" dependencies = [ "aws-lc-rs", "log", @@ -3985,14 +4157,14 @@ dependencies = [ [[package]] name = "rustls-native-certs" -version = "0.8.1" +version = "0.8.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7fcff2dd52b58a8d98a70243663a0d234c4e2b79235637849d15913394a247d3" +checksum = "9980d917ebb0c0536119ba501e90834767bffc3d60641457fd84a1f3fd337923" dependencies = [ "openssl-probe", "rustls-pki-types", "schannel", - "security-framework 3.3.0", + "security-framework 3.5.1", ] [[package]] @@ -4049,11 +4221,11 @@ dependencies = [ [[package]] name = "schannel" -version = "0.1.27" +version = "0.1.28" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1f29ebaa345f945cec9fbbc532eb307f0fdad8161f281b6369539c8d84876b3d" +checksum = "891d81b926048e76efe18581bf793546b4c0eaf8448d72be8de2bbee5fd166e1" dependencies = [ - "windows-sys 0.59.0", + "windows-sys 0.61.2", ] [[package]] @@ -4082,7 +4254,7 @@ checksum = "22f968c5ea23d555e670b449c1c5e7b2fc399fdaec1d304a17cd48e288abc107" dependencies = [ "proc-macro2", "quote", - "syn 2.0.106", + "syn 2.0.108", ] [[package]] @@ -4100,9 +4272,9 @@ dependencies = [ [[package]] name = "security-framework" -version = "3.3.0" +version = "3.5.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "80fb1d92c5028aa318b4b8bd7302a5bfcf48be96a37fc6fc790f806b0004ee0c" +checksum = "b3297343eaf830f66ede390ea39da1d462b6b0c1b000f420d0a83f898bbbe6ef" dependencies = [ "bitflags", "core-foundation 0.10.1", @@ -4113,9 +4285,9 @@ dependencies = [ [[package]] name = "security-framework-sys" -version = "2.14.0" +version = "2.15.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "49db231d56a190491cb4aeda9527f1ad45345af50b0851622a7adb8c03b01c32" +checksum = "cc1f0cbffaac4852523ce30d8bd3c5cdc873501d96ff467ca09b6767bb8cd5c0" dependencies = [ "core-foundation-sys", "libc", @@ -4123,19 +4295,19 @@ dependencies = [ [[package]] name = "semver" -version = "1.0.26" +version = "1.0.27" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "56e6fa9c48d24d85fb3de5ad847117517440f6beceb7798af16b4a87d616b8d0" +checksum = "d767eb0aabc880b29956c35734170f26ed551a859dbd361d140cdbeca61ab1e2" [[package]] name = "sensapp" version = "0.3.0" dependencies = [ "anyhow", - "arrow", - "arrow-array", + "arrow 57.0.0", + "arrow-array 57.0.0", "arrow-ipc", - "arrow-schema", + "arrow-schema 57.0.0", "async-trait", "axum", "base64 0.22.1", @@ -4379,7 +4551,7 @@ checksum = "d540f220d3187173da220f885ab66608367b6574e925011a9353e4badda91d79" dependencies = [ "proc-macro2", "quote", - "syn 2.0.106", + "syn 2.0.108", ] [[package]] @@ -4390,7 +4562,7 @@ checksum = "18d26a20a969b9e3fdf2fc2d9f21eda6c40e2de84c9408bb5d3b05d499aae711" dependencies = [ "proc-macro2", "quote", - "syn 2.0.106", + "syn 2.0.108", ] [[package]] @@ -4408,12 +4580,13 @@ dependencies = [ [[package]] name = "serde_path_to_error" -version = "0.1.17" +version = "0.1.20" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "59fab13f937fa393d08645bf3a84bdfe86e296747b506ada67bb15f10f218b2a" +checksum = "10a9ff822e371bb5403e391ecd83e182e0e77ba7f6fe0160b795797109d1b457" dependencies = [ "itoa", "serde", + "serde_core", ] [[package]] @@ -4459,7 +4632,7 @@ checksum = "5d69265a08751de7844521fd15003ae0a888e035773ba05695c5c759a6f89eef" dependencies = [ "proc-macro2", "quote", - "syn 2.0.106", + "syn 2.0.108", ] [[package]] @@ -4598,12 +4771,12 @@ dependencies = [ [[package]] name = "snafu" -version = "0.8.6" +version = "0.8.9" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "320b01e011bf8d5d7a4a4a4be966d9160968935849c83b918827f6a435e7f627" +checksum = "6e84b3f4eacbf3a1ce05eac6763b4d629d60cbc94d632e4092c54ade71f1e1a2" dependencies = [ "backtrace", - "snafu-derive 0.8.6", + "snafu-derive 0.8.9", ] [[package]] @@ -4620,14 +4793,14 @@ dependencies = [ [[package]] name = "snafu-derive" -version = "0.8.6" +version = "0.8.9" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1961e2ef424c1424204d3a5d6975f934f56b6d50ff5732382d84ebf460e147f7" +checksum = "c1c97747dbf44bb1ca44a561ece23508e99cb592e862f22222dcf42f51d1e451" dependencies = [ "heck 0.5.0", "proc-macro2", "quote", - "syn 2.0.106", + "syn 2.0.108", ] [[package]] @@ -4648,12 +4821,12 @@ dependencies = [ [[package]] name = "socket2" -version = "0.6.0" +version = "0.6.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "233504af464074f9d066d7b5416c5f9b894a5862a6506e306f7b816cdd6f1807" +checksum = "17129e116933cf371d018bb80ae557e889637989d8638274fb25622827b03881" dependencies = [ "libc", - "windows-sys 0.59.0", + "windows-sys 0.60.2", ] [[package]] @@ -4747,7 +4920,7 @@ dependencies = [ "quote", "sqlx-core", "sqlx-macros-core", - "syn 2.0.106", + "syn 2.0.108", ] [[package]] @@ -4770,7 +4943,7 @@ dependencies = [ "sqlx-mysql", "sqlx-postgres", "sqlx-sqlite", - "syn 2.0.106", + "syn 2.0.108", "tokio", "url", ] @@ -4888,9 +5061,9 @@ dependencies = [ [[package]] name = "stable_deref_trait" -version = "1.2.0" +version = "1.2.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a8f112729512f8e442d81f95a8a7ddf2b7c6b8a1a6f509a95864142b30cab2d3" +checksum = "6ce2be8dc25455e1f91df71bfa12ad37d7af1092ae736f3a6cd0e37bc7810596" [[package]] name = "static_assertions" @@ -4940,7 +5113,7 @@ dependencies = [ "proc-macro2", "quote", "rustversion", - "syn 2.0.106", + "syn 2.0.108", ] [[package]] @@ -4952,7 +5125,7 @@ dependencies = [ "heck 0.5.0", "proc-macro2", "quote", - "syn 2.0.106", + "syn 2.0.108", ] [[package]] @@ -4974,9 +5147,9 @@ dependencies = [ [[package]] name = "syn" -version = "2.0.106" +version = "2.0.108" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ede7c438028d4436d71104916910f5bb611972c5cfd7f89b8300a8186e6fada6" +checksum = "da58917d35242480a05c2897064da0a80589a2a0476c9a3f2fdc83b53502e917" dependencies = [ "proc-macro2", "quote", @@ -5000,7 +5173,7 @@ checksum = "728a70f3dbaf5bab7f0c4b1ac8d7ae5ea60a4b5549c8a5914361c99147a709d2" dependencies = [ "proc-macro2", "quote", - "syn 2.0.106", + "syn 2.0.108", ] [[package]] @@ -5031,15 +5204,15 @@ dependencies = [ [[package]] name = "tempfile" -version = "3.20.0" +version = "3.23.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e8a64e3985349f2441a1a9ef0b853f869006c3855f2cda6862a94d26ebb9d6a1" +checksum = "2d31c77bdf42a745371d260a26ca7163f1e0924b64afa0b688e61b5a9fa02f16" dependencies = [ "fastrand", - "getrandom 0.3.3", + "getrandom 0.3.4", "once_cell", "rustix", - "windows-sys 0.59.0", + "windows-sys 0.61.2", ] [[package]] @@ -5068,7 +5241,7 @@ checksum = "4fee6c4efc90059e10f81e6d42c60a18f76588c3d74cb83a0b242a2b6c7504c1" dependencies = [ "proc-macro2", "quote", - "syn 2.0.106", + "syn 2.0.108", ] [[package]] @@ -5079,7 +5252,7 @@ checksum = "3ff15c8ecd7de3849db632e14d18d2571fa09dfc5ed93479bc4485c7a517c913" dependencies = [ "proc-macro2", "quote", - "syn 2.0.106", + "syn 2.0.108", ] [[package]] @@ -5145,9 +5318,9 @@ dependencies = [ [[package]] name = "tinyvec" -version = "1.9.0" +version = "1.10.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "09b3661f17e86524eccd4371ab0429194e0d7c008abb45f7a7495b1719463c71" +checksum = "bfa5fdc3bce6191a1dbc8c02d5c8bffcf557bafa17c124c5264a458f1b0613fa" dependencies = [ "tinyvec_macros", ] @@ -5170,7 +5343,7 @@ dependencies = [ "parking_lot", "pin-project-lite", "signal-hook-registry", - "socket2 0.6.0", + "socket2 0.6.1", "tokio-macros", "windows-sys 0.61.2", ] @@ -5183,7 +5356,7 @@ checksum = "af407857209536a95c8e56f8231ef2c2e2aff839b22e07a1ffcbc617e9db9fa5" dependencies = [ "proc-macro2", "quote", - "syn 2.0.106", + "syn 2.0.108", ] [[package]] @@ -5198,9 +5371,9 @@ dependencies = [ [[package]] name = "tokio-rustls" -version = "0.26.2" +version = "0.26.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8e727b36a1a0e8b74c376ac2211e40c2c8af09fb4013c60d910495810f008e9b" +checksum = "1729aa945f29d91ba541258c8df89027d5792d85a8841fb65e8bf0f4ede4ef61" dependencies = [ "rustls", "tokio", @@ -5252,18 +5425,12 @@ dependencies = [ "indexmap", "serde_core", "serde_spanned", - "toml_datetime 0.7.3", + "toml_datetime", "toml_parser", "toml_writer", "winnow", ] -[[package]] -name = "toml_datetime" -version = "0.6.11" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "22cddaf88f4fbc13c51aebbf5f8eceb5c7c5a9da2ac40a13519eb5b0a0e8f11c" - [[package]] name = "toml_datetime" version = "0.7.3" @@ -5275,12 +5442,13 @@ dependencies = [ [[package]] name = "toml_edit" -version = "0.22.27" +version = "0.23.7" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "41fe8c660ae4257887cf66394862d21dbca4a6ddd26f04a3560410406a2f819a" +checksum = "6485ef6d0d9b5d0ec17244ff7eb05310113c3f316f2d14200d4de56b3cb98f8d" dependencies = [ "indexmap", - "toml_datetime 0.6.11", + "toml_datetime", + "toml_parser", "winnow", ] @@ -5320,7 +5488,7 @@ dependencies = [ "percent-encoding", "pin-project", "rustls-native-certs", - "socket2 0.6.0", + "socket2 0.6.1", "sync_wrapper", "tokio", "tokio-rustls", @@ -5341,7 +5509,7 @@ dependencies = [ "prettyplease", "proc-macro2", "quote", - "syn 2.0.106", + "syn 2.0.108", ] [[package]] @@ -5366,7 +5534,7 @@ dependencies = [ "prost-build", "prost-types", "quote", - "syn 2.0.106", + "syn 2.0.108", "tempfile", "tonic-build", ] @@ -5454,7 +5622,7 @@ checksum = "81383ab64e72a7a8b8e13130c49e3dab29def6d0c7d76a03087b3cf71c5c6903" dependencies = [ "proc-macro2", "quote", - "syn 2.0.106", + "syn 2.0.108", ] [[package]] @@ -5510,9 +5678,9 @@ checksum = "bc7d623258602320d5c55d1bc22793b57daff0ec7efc270ea7d55ce1d5f5471c" [[package]] name = "typenum" -version = "1.18.0" +version = "1.19.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1dccffe3ce07af9386bfd29e80c0ab1a8205a2fc34e4bcd40364df902cfa8f3f" +checksum = "562d481066bde0658276a35467c4af00bdc6ee726305698a55b86e61d7ad82bb" [[package]] name = "ucd-trie" @@ -5543,9 +5711,9 @@ checksum = "5c1cb5db39152898a79168971543b1cb5020dff7fe43c8dc468b0885f5e29df5" [[package]] name = "unicode-ident" -version = "1.0.18" +version = "1.0.20" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5a5f39404a5da50712a4c1eecf25e90dd62b613502b7e925fd4e4d19b5c96512" +checksum = "462eeb75aeb73aea900253ce739c8e18a67423fadf006037cd3ff27e82748a06" [[package]] name = "unicode-normalization" @@ -5570,9 +5738,9 @@ checksum = "f6ccf251212114b54433ec949fd6a7841275f9ada20dddd2f29e9ceea4501493" [[package]] name = "unicode-width" -version = "0.2.1" +version = "0.2.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4a1a07cc7db3810833284e8d372ccdc6da29741639ecc70c9ec107df0fa6154c" +checksum = "b4ac048d71ede7ee76d585517add45da530660ef4390e49b098733c6e897f254" [[package]] name = "unicode-xid" @@ -5588,9 +5756,9 @@ checksum = "8ecb6da28b8a351d773b68d5825ac39017e680750f980f3a1a85cd8dd28a47c1" [[package]] name = "ureq" -version = "3.1.0" +version = "3.1.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "00432f493971db5d8e47a65aeb3b02f8226b9b11f1450ff86bb772776ebadd70" +checksum = "99ba1025f18a4a3fc3e9b48c868e9beb4f24f4b4b1a325bada26bd4119f46537" dependencies = [ "base64 0.22.1", "der", @@ -5606,9 +5774,9 @@ dependencies = [ [[package]] name = "ureq-proto" -version = "0.5.0" +version = "0.5.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c5b6cabebbecc4c45189ab06b52f956206cea7d8c8a20851c35a85cb169224cc" +checksum = "60b4531c118335662134346048ddb0e54cc86bd7e81866757873055f0e38f5d2" dependencies = [ "base64 0.22.1", "http 1.3.1", @@ -5679,7 +5847,7 @@ dependencies = [ "proc-macro2", "quote", "regex", - "syn 2.0.106", + "syn 2.0.108", ] [[package]] @@ -5700,7 +5868,7 @@ version = "1.18.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "2f87b8aa10b915a06587d0dec516c282ff295b475d94abf425d62b57710070a2" dependencies = [ - "getrandom 0.3.3", + "getrandom 0.3.4", "js-sys", "serde", "wasm-bindgen", @@ -5740,12 +5908,12 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "ccf3ec651a847eb01de73ccad15eb7d99f80485de043efb2f370cd654f4ea44b" [[package]] -name = "wasi" -version = "0.14.2+wasi-0.2.4" +name = "wasip2" +version = "1.0.1+wasi-0.2.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9683f9a5a998d873c0d21fcbe3c083009670149a8fab228644b8bd36b2c48cb3" +checksum = "0562428422c63773dad2c345a1882263bbf4d65cf3f42e90921f787ef5ad58e7" dependencies = [ - "wit-bindgen-rt", + "wit-bindgen", ] [[package]] @@ -5756,35 +5924,36 @@ checksum = "b8dad83b4f25e74f184f64c43b150b91efe7647395b42289f38e50566d82855b" [[package]] name = "wasm-bindgen" -version = "0.2.100" +version = "0.2.104" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1edc8929d7499fc4e8f0be2262a241556cfc54a0bea223790e71446f2aab1ef5" +checksum = "c1da10c01ae9f1ae40cbfac0bac3b1e724b320abfcf52229f80b547c0d250e2d" dependencies = [ "cfg-if", "once_cell", "rustversion", "wasm-bindgen-macro", + "wasm-bindgen-shared", ] [[package]] name = "wasm-bindgen-backend" -version = "0.2.100" +version = "0.2.104" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2f0a0651a5c2bc21487bde11ee802ccaf4c51935d0d3d42a6101f98161700bc6" +checksum = "671c9a5a66f49d8a47345ab942e2cb93c7d1d0339065d4f8139c486121b43b19" dependencies = [ "bumpalo", "log", "proc-macro2", "quote", - "syn 2.0.106", + "syn 2.0.108", "wasm-bindgen-shared", ] [[package]] name = "wasm-bindgen-futures" -version = "0.4.50" +version = "0.4.54" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "555d470ec0bc3bb57890405e5d4322cc9ea83cebb085523ced7be4144dac1e61" +checksum = "7e038d41e478cc73bae0ff9b36c60cff1c98b8f38f8d7e8061e79ee63608ac5c" dependencies = [ "cfg-if", "js-sys", @@ -5795,9 +5964,9 @@ dependencies = [ [[package]] name = "wasm-bindgen-macro" -version = "0.2.100" +version = "0.2.104" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7fe63fc6d09ed3792bd0897b314f53de8e16568c2b3f7982f468c0bf9bd0b407" +checksum = "7ca60477e4c59f5f2986c50191cd972e3a50d8a95603bc9434501cf156a9a119" dependencies = [ "quote", "wasm-bindgen-macro-support", @@ -5805,31 +5974,31 @@ dependencies = [ [[package]] name = "wasm-bindgen-macro-support" -version = "0.2.100" +version = "0.2.104" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8ae87ea40c9f689fc23f209965b6fb8a99ad69aeeb0231408be24920604395de" +checksum = "9f07d2f20d4da7b26400c9f4a0511e6e0345b040694e8a75bd41d578fa4421d7" dependencies = [ "proc-macro2", "quote", - "syn 2.0.106", + "syn 2.0.108", "wasm-bindgen-backend", "wasm-bindgen-shared", ] [[package]] name = "wasm-bindgen-shared" -version = "0.2.100" +version = "0.2.104" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1a05d73b933a847d6cccdda8f838a22ff101ad9bf93e33684f39c1f5f0eece3d" +checksum = "bad67dc8b2a1a6e5448428adec4c3e84c43e561d8c9ee8a9e5aabeb193ec41d1" dependencies = [ "unicode-ident", ] [[package]] name = "web-sys" -version = "0.3.77" +version = "0.3.81" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "33b6dd2ef9186f1f2072e409e99cd22a975331a6b3591b12c764e0e55c60d5d2" +checksum = "9367c417a924a74cae129e6a2ae3b47fabb1f8995595ab474029da749a8be120" dependencies = [ "js-sys", "wasm-bindgen", @@ -5847,18 +6016,18 @@ dependencies = [ [[package]] name = "webpki-root-certs" -version = "1.0.2" +version = "1.0.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4e4ffd8df1c57e87c325000a3d6ef93db75279dc3a231125aac571650f22b12a" +checksum = "05d651ec480de84b762e7be71e6efa7461699c19d9e2c272c8d93455f567786e" dependencies = [ "rustls-pki-types", ] [[package]] name = "webpki-roots" -version = "1.0.2" +version = "1.0.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7e8983c3ab33d6fb807cfcdad2491c4ea8cbc8ed839181c7dfd9c67c83e261b2" +checksum = "32b130c0d2d49f8b6889abc456e795e82525204f27c42cf767cf0d7734e089b8" dependencies = [ "rustls-pki-types", ] @@ -5897,37 +6066,37 @@ checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f" [[package]] name = "windows-core" -version = "0.61.2" +version = "0.62.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c0fdd3ddb90610c7638aa2b3a3ab2904fb9e5cdbecc643ddb3647212781c4ae3" +checksum = "b8e83a14d34d0623b51dce9581199302a221863196a1dde71a7663a4c2be9deb" dependencies = [ "windows-implement", "windows-interface", - "windows-link 0.1.3", + "windows-link 0.2.1", "windows-result", "windows-strings", ] [[package]] name = "windows-implement" -version = "0.60.0" +version = "0.60.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a47fddd13af08290e67f4acabf4b459f647552718f683a7b415d290ac744a836" +checksum = "053e2e040ab57b9dc951b72c264860db7eb3b0200ba345b4e4c3b14f67855ddf" dependencies = [ "proc-macro2", "quote", - "syn 2.0.106", + "syn 2.0.108", ] [[package]] name = "windows-interface" -version = "0.59.1" +version = "0.59.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "bd9211b69f8dcdfa817bfd14bf1c97c9188afa36f4750130fcdf3f400eca9fa8" +checksum = "3f316c4a2570ba26bbec722032c4099d8c8bc095efccdc15688708623367e358" dependencies = [ "proc-macro2", "quote", - "syn 2.0.106", + "syn 2.0.108", ] [[package]] @@ -5944,20 +6113,20 @@ checksum = "f0805222e57f7521d6a62e36fa9163bc891acd422f971defe97d64e70d0a4fe5" [[package]] name = "windows-result" -version = "0.3.4" +version = "0.4.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "56f42bd332cc6c8eac5af113fc0c1fd6a8fd2aa08a0119358686e5160d0586c6" +checksum = "7781fa89eaf60850ac3d2da7af8e5242a5ea78d1a11c49bf2910bb5a73853eb5" dependencies = [ - "windows-link 0.1.3", + "windows-link 0.2.1", ] [[package]] name = "windows-strings" -version = "0.4.2" +version = "0.5.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "56e6c93f3a0c3b36176cb1327a4958a0353d5d166c2a35cb268ace15e91d3b57" +checksum = "7837d08f69c77cf6b07689544538e017c1bfcf57e34b4c0ff58e6c2cd3b37091" dependencies = [ - "windows-link 0.1.3", + "windows-link 0.2.1", ] [[package]] @@ -5978,22 +6147,13 @@ dependencies = [ "windows-targets 0.52.6", ] -[[package]] -name = "windows-sys" -version = "0.59.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1e38bc4d79ed67fd075bcc251a1c39b32a1776bbe92e5bef1f0bf1f8c531853b" -dependencies = [ - "windows-targets 0.52.6", -] - [[package]] name = "windows-sys" version = "0.60.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "f2f500e4d28234f72040990ec9d39e3a6b950f9f22d3dba18416c35882612bcb" dependencies = [ - "windows-targets 0.53.3", + "windows-targets 0.53.5", ] [[package]] @@ -6038,19 +6198,19 @@ dependencies = [ [[package]] name = "windows-targets" -version = "0.53.3" +version = "0.53.5" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d5fe6031c4041849d7c496a8ded650796e7b6ecc19df1a431c1a363342e5dc91" +checksum = "4945f9f551b88e0d65f3db0bc25c33b8acea4d9e41163edf90dcd0b19f9069f3" dependencies = [ - "windows-link 0.1.3", - "windows_aarch64_gnullvm 0.53.0", - "windows_aarch64_msvc 0.53.0", - "windows_i686_gnu 0.53.0", - "windows_i686_gnullvm 0.53.0", - "windows_i686_msvc 0.53.0", - "windows_x86_64_gnu 0.53.0", - "windows_x86_64_gnullvm 0.53.0", - "windows_x86_64_msvc 0.53.0", + "windows-link 0.2.1", + "windows_aarch64_gnullvm 0.53.1", + "windows_aarch64_msvc 0.53.1", + "windows_i686_gnu 0.53.1", + "windows_i686_gnullvm 0.53.1", + "windows_i686_msvc 0.53.1", + "windows_x86_64_gnu 0.53.1", + "windows_x86_64_gnullvm 0.53.1", + "windows_x86_64_msvc 0.53.1", ] [[package]] @@ -6067,9 +6227,9 @@ checksum = "32a4622180e7a0ec044bb555404c800bc9fd9ec262ec147edd5989ccd0c02cd3" [[package]] name = "windows_aarch64_gnullvm" -version = "0.53.0" +version = "0.53.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "86b8d5f90ddd19cb4a147a5fa63ca848db3df085e25fee3cc10b39b6eebae764" +checksum = "a9d8416fa8b42f5c947f8482c43e7d89e73a173cead56d044f6a56104a6d1b53" [[package]] name = "windows_aarch64_msvc" @@ -6085,9 +6245,9 @@ checksum = "09ec2a7bb152e2252b53fa7803150007879548bc709c039df7627cabbd05d469" [[package]] name = "windows_aarch64_msvc" -version = "0.53.0" +version = "0.53.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c7651a1f62a11b8cbd5e0d42526e55f2c99886c77e007179efff86c2b137e66c" +checksum = "b9d782e804c2f632e395708e99a94275910eb9100b2114651e04744e9b125006" [[package]] name = "windows_i686_gnu" @@ -6103,9 +6263,9 @@ checksum = "8e9b5ad5ab802e97eb8e295ac6720e509ee4c243f69d781394014ebfe8bbfa0b" [[package]] name = "windows_i686_gnu" -version = "0.53.0" +version = "0.53.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c1dc67659d35f387f5f6c479dc4e28f1d4bb90ddd1a5d3da2e5d97b42d6272c3" +checksum = "960e6da069d81e09becb0ca57a65220ddff016ff2d6af6a223cf372a506593a3" [[package]] name = "windows_i686_gnullvm" @@ -6115,9 +6275,9 @@ checksum = "0eee52d38c090b3caa76c563b86c3a4bd71ef1a819287c19d586d7334ae8ed66" [[package]] name = "windows_i686_gnullvm" -version = "0.53.0" +version = "0.53.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9ce6ccbdedbf6d6354471319e781c0dfef054c81fbc7cf83f338a4296c0cae11" +checksum = "fa7359d10048f68ab8b09fa71c3daccfb0e9b559aed648a8f95469c27057180c" [[package]] name = "windows_i686_msvc" @@ -6133,9 +6293,9 @@ checksum = "240948bc05c5e7c6dabba28bf89d89ffce3e303022809e73deaefe4f6ec56c66" [[package]] name = "windows_i686_msvc" -version = "0.53.0" +version = "0.53.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "581fee95406bb13382d2f65cd4a908ca7b1e4c2f1917f143ba16efe98a589b5d" +checksum = "1e7ac75179f18232fe9c285163565a57ef8d3c89254a30685b57d83a38d326c2" [[package]] name = "windows_x86_64_gnu" @@ -6151,9 +6311,9 @@ checksum = "147a5c80aabfbf0c7d901cb5895d1de30ef2907eb21fbbab29ca94c5b08b1a78" [[package]] name = "windows_x86_64_gnu" -version = "0.53.0" +version = "0.53.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2e55b5ac9ea33f2fc1716d1742db15574fd6fc8dadc51caab1c16a3d3b4190ba" +checksum = "9c3842cdd74a865a8066ab39c8a7a473c0778a3f29370b5fd6b4b9aa7df4a499" [[package]] name = "windows_x86_64_gnullvm" @@ -6169,9 +6329,9 @@ checksum = "24d5b23dc417412679681396f2b49f3de8c1473deb516bd34410872eff51ed0d" [[package]] name = "windows_x86_64_gnullvm" -version = "0.53.0" +version = "0.53.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0a6e035dd0599267ce1ee132e51c27dd29437f63325753051e71dd9e42406c57" +checksum = "0ffa179e2d07eee8ad8f57493436566c7cc30ac536a3379fdf008f47f6bb7ae1" [[package]] name = "windows_x86_64_msvc" @@ -6187,9 +6347,9 @@ checksum = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec" [[package]] name = "windows_x86_64_msvc" -version = "0.53.0" +version = "0.53.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "271414315aff87387382ec3d271b52d7ae78726f5d44ac98b4f4030c91880486" +checksum = "d6bbff5f0aada427a1e5a6da5f1f98158182f26556f345ac9e04d36d0ebed650" [[package]] name = "winnow" @@ -6201,13 +6361,10 @@ dependencies = [ ] [[package]] -name = "wit-bindgen-rt" -version = "0.39.0" +name = "wit-bindgen" +version = "0.46.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6f42320e61fe2cfd34354ecb597f86f413484a798ba44a8ca1165c58d42da6c1" -dependencies = [ - "bitflags", -] +checksum = "f17a85883d4e6d00e8a97c586de764dabcc06133f7f1d55dce5cdc070ad7fe59" [[package]] name = "writeable" @@ -6226,9 +6383,9 @@ dependencies = [ [[package]] name = "xattr" -version = "1.5.1" +version = "1.6.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "af3a19837351dc82ba89f8a125e22a3c475f05aba604acc023d62b2739ae2909" +checksum = "32e45ad4206f6d2479085147f02bc2ef834ac85886624a23575ae137c8aa8156" dependencies = [ "libc", "rustix", @@ -6265,7 +6422,7 @@ checksum = "38da3c9736e16c5d3c8c597a9aaa5d1fa565d0532ae05e27c24aa62fb32c0ab6" dependencies = [ "proc-macro2", "quote", - "syn 2.0.106", + "syn 2.0.108", "synstructure", ] @@ -6297,22 +6454,22 @@ dependencies = [ [[package]] name = "zerocopy" -version = "0.8.26" +version = "0.8.27" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1039dd0d3c310cf05de012d8a39ff557cb0d23087fd44cad61df08fc31907a2f" +checksum = "0894878a5fa3edfd6da3f88c4805f4c8558e2b996227a3d864f47fe11e38282c" dependencies = [ "zerocopy-derive", ] [[package]] name = "zerocopy-derive" -version = "0.8.26" +version = "0.8.27" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9ecf5b4cc5364572d7f4c329661bcc82724222973f2cab6f050a4e5c22f75181" +checksum = "88d2b8d9c68ad2b9e4340d7832716a4d21a22a1154777ad56ea55c51a9cf3831" dependencies = [ "proc-macro2", "quote", - "syn 2.0.106", + "syn 2.0.108", ] [[package]] @@ -6332,15 +6489,15 @@ checksum = "d71e5d6e06ab090c67b5e44993ec16b72dcbaabc526db883a360057678b48502" dependencies = [ "proc-macro2", "quote", - "syn 2.0.106", + "syn 2.0.108", "synstructure", ] [[package]] name = "zeroize" -version = "1.8.1" +version = "1.8.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ced3678a2879b30306d323f4542626697a464a97c0a07c9aebf7ebca65cd4dde" +checksum = "b97154e67e32c85465826e8bcc1c59429aaaf107c1e4a9e53c8d8ccd5eff88d0" [[package]] name = "zerotrie" @@ -6372,7 +6529,7 @@ checksum = "5b96237efa0c878c64bd89c436f661be4e46b2f3eff1ebb976f7ef2321d2f58f" dependencies = [ "proc-macro2", "quote", - "syn 2.0.106", + "syn 2.0.108", ] [[package]] @@ -6395,9 +6552,9 @@ dependencies = [ [[package]] name = "zstd-sys" -version = "2.0.15+zstd.1.5.7" +version = "2.0.16+zstd.1.5.7" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "eb81183ddd97d0c74cedf1d50d85c8d08c1b8b68ee863bdee9e706eedba1a237" +checksum = "91e19ebc2adc8f83e43039e79776e3fda8ca919132d68a1fed6a5faca2683748" dependencies = [ "cc", "pkg-config", diff --git a/Cargo.toml b/Cargo.toml index 9382e16..f868c24 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -14,6 +14,7 @@ bigquery = [ "dep:gcp-bigquery-client", "dep:bigdecimal", "dep:big-decimal-byte-string-encoder", + "dep:tonic", ] rrdcached = ["dep:rrdcached-client"] clickhouse = ["dep:clickhouse"] @@ -33,10 +34,10 @@ test-utils = [] # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html [dependencies] -arrow = { version = "56", features = ["ipc"] } -arrow-ipc = "56" -arrow-schema = "56" -arrow-array = "56" +arrow = { version = "57", features = ["ipc"] } +arrow-ipc = "57" +arrow-schema = "57" +arrow-array = "57" anyhow = "1.0.100" async-trait = "0.1" thiserror = "2.0.17" @@ -83,25 +84,25 @@ smallvec = "1.15" once_cell = "1.21" urlencoding = "2.1" hybridmap = "0.1" -clap = { version = "4.5.49", features = ["derive"] } +clap = { version = "4.5", features = ["derive"] } sentry = { version = "0.45", features = ["anyhow", "tower"] } url = "2.5.7" -gcp-bigquery-client = { version = "0.27.0", optional = true } +gcp-bigquery-client = { version = "0.27", optional = true } sinteflake = { version = "0.1", features = ["async"] } -tonic = "0.14.2" +tonic = { version = "0.14", optional = true } bigdecimal = { version = "0.4", optional = true } big-decimal-byte-string-encoder = { version = "0.1", optional = true } clru = "0.6" utoipa = { version = "5.4", features = ["axum_extras"] } utoipa-scalar = { version = "0.3", features = ["axum"] } -rrdcached-client = { version = "0.1.5", optional = true } +rrdcached-client = { version = "0.1", optional = true } clickhouse = { version = "0.14", features = [ "lz4", "uuid", "time", "inserter", ], optional = true } -rustls = "0.23.33" +rustls = "0.23" [dev-dependencies] temp-env = "0.3" From 2ae9aceb434f2692982d84d63d4099967d556040 Mon Sep 17 00:00:00 2001 From: Antoine Pultier <45740+fungiboletus@users.noreply.github.com> Date: Fri, 24 Oct 2025 19:16:04 +0200 Subject: [PATCH 06/39] =?UTF-8?q?feat:=20=F0=9F=94=A5=20remove=20old=20vib?= =?UTF-8?q?ecoded=20documentation?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ANALYSIS_REPORT.md | 113 --------------------------------------------- MAKE_USAGE.md | 55 ---------------------- 2 files changed, 168 deletions(-) delete mode 100644 ANALYSIS_REPORT.md delete mode 100644 MAKE_USAGE.md diff --git a/ANALYSIS_REPORT.md b/ANALYSIS_REPORT.md deleted file mode 100644 index af2855b..0000000 --- a/ANALYSIS_REPORT.md +++ /dev/null @@ -1,113 +0,0 @@ -SensApp Codebase Analysis Report │ │ -│ │ │ │ -│ │ Code Quality Analysis Results │ │ -│ │ │ │ -│ │ 1. Code Duplication & Repetitive Patterns ⚠️ HIGH PRIORITY │ │ -│ │ │ │ -│ │ Major Duplication Found: │ │ -│ │ - Storage sync pattern: Identical sync logic repeated across all 6 storage backends: │ │ -│ │ if sync_sender.receiver_count() > 0 && !sync_sender.is_closed() { │ │ -│ │ let _= timeout(Duration::from_secs(15), sync_sender.broadcast(())).await?; │ │ -│ │ } │ │ -│ │ - Found in: PostgreSQL, SQLite, DuckDB, BigQuery, TimescaleDB, RRDCached │ │ -│ │ - Migration pattern: Nearly identical create_or_migrate() implementations across all backends │ │ -│ │ - Connection pattern: Similar connection string parsing and pool creation logic │ │ -│ │ │ │ -│ │ Recommended Solutions: │ │ -│ │ - Extract sync logic into a shared storage_utils module │ │ -│ │ - Create common base traits for migration and connection patterns │ │ -│ │ - Use macro or generic helper functions for repetitive implementations │ │ -│ │ │ │ -│ │ 2. Large Files & Functions ⚠️ MEDIUM PRIORITY │ │ -│ │ │ │ -│ │ Files Exceeding Recommended Size: │ │ -│ │ - src/storage/postgresql/mod.rs: 859 lines - Complex storage implementation │ │ -│ │ - src/storage/sqlite/sqlite.rs: 757 lines - Similar complexity │ │ -│ │ - src/infer/parsing.rs: 652 lines - Complex parsing logic with many functions │ │ -│ │ - src/ingestors/http/influxdb.rs: 559 lines - Protocol translation layer │ │ -│ │ │ │ -│ │ Recommendations: │ │ -│ │ - Split storage modules into separate files (queries, publishers, utilities) │ │ -│ │ - Extract parsing functions into specialized modules by data type │ │ -│ │ - Break down InfluxDB ingestion into smaller, focused modules │ │ -│ │ │ │ -│ │ 3. Error Handling Issues ⚠️ MEDIUM PRIORITY │ │ -│ │ │ │ -│ │ Problematic Patterns Found: │ │ -│ │ - Extensive unwrap() usage: 200+ instances, mostly in test code (acceptable) │ │ -│ │ - Production unwraps: Found in main.rs for critical initialization │ │ -│ │ - Missing error context: Some errors lack sufficient context for debugging │ │ -│ │ - Panic usage: Found in src/infer/columns.rs:53 and src/infer/parsing.rs:334 │ │ -│ │ │ │ -│ │ Critical Issues in main.rs: │ │ -│ │ load_configuration().expect("Failed to load configuration"); // Line 56 │ │ -│ │ let config = config::get().expect("Failed to get configuration"); // Line 57 │ │ -│ │ │ │ -│ │ 4. Technical Debt Indicators ⚠️ LOW-MEDIUM PRIORITY │ │ -│ │ │ │ -│ │ Dead Code Markers: 35+ #[allow(dead_code)] annotations │ │ -│ │ - Many marked for "future MQTT use" or "will be used later" │ │ -│ │ - Some legitimate (test utilities, error API completeness) │ │ -│ │ - Indicates incomplete feature implementation │ │ -│ │ │ │ -│ │ Hardcoded Values: │ │ -│ │ - Sentry DSN hardcoded in main.rs:25 │ │ -│ │ - Timeout durations (15 seconds) hardcoded across storage backends │ │ -│ │ - Default configuration values embedded in code │ │ -│ │ │ │ -│ │ 5. Missing Documentation ⚠️ MEDIUM PRIORITY │ │ -│ │ │ │ -│ │ Public API Coverage: Moderate documentation coverage │ │ -│ │ - Main storage trait has some documentation │ │ -│ │ - Many public functions lack doc comments │ │ -│ │ - Module-level documentation sparse │ │ -│ │ - No examples in public API docs │ │ -│ │ │ │ -│ │ 6. Code Smells Identified │ │ -│ │ │ │ -│ │ Positive Findings: │ │ -│ │ - ✅ No TODO/FIXME comments found │ │ -│ │ - ✅ No complex nested structures detected │ │ -│ │ - ✅ Generally good Rust naming conventions │ │ -│ │ - ✅ Proper async/await patterns │ │ -│ │ - ✅ Good use of type system │ │ -│ │ │ │ -│ │ Areas for Improvement: │ │ -│ │ - Inconsistent error handling strategies │ │ -│ │ - Storage backend implementations not following DRY principle │ │ -│ │ - Some functions in parsing module are quite complex │ │ -│ │ │ │ -│ │ 7. Test Coverage Assessment ⚠️ MEDIUM PRIORITY │ │ -│ │ │ │ -│ │ Current State: │ │ -│ │ - Integration tests present but limited │ │ -│ │ - Unit tests scattered, not comprehensive │ │ -│ │ - Storage backend testing varies by implementation │ │ -│ │ - Parser testing exists but could be expanded │ │ -│ │ │ │ -│ │ Priority Improvement Plan │ │ -│ │ │ │ -│ │ Phase 1 (High Priority) │ │ -│ │ │ │ -│ │ 1. Extract Duplicate Storage Logic - Create shared utilities for sync patterns │ │ -│ │ 2. Improve Error Handling - Replace critical expect() calls with proper error handling │ │ -│ │ 3. Split Large Files - Break down 750+ line files into logical modules │ │ -│ │ │ │ -│ │ Phase 2 (Medium Priority) │ │ -│ │ │ │ -│ │ 1. Clean Up Dead Code - Review and either implement or remove dead code markers │ │ -│ │ 2. Add Documentation - Document public APIs with examples │ │ -│ │ 3. Configuration Externalization - Move hardcoded values to configuration │ │ -│ │ │ │ -│ │ Phase 3 (Lower Priority) │ │ -│ │ │ │ -│ │ 1. Expand Test Coverage - Add comprehensive unit tests for core modules │ │ -│ │ 2. Refactor Complex Functions - Break down large parsing functions │ │ -│ │ 3. Performance Review - Profile and optimize bottlenecks │ │ -│ │ │ │ -│ │ Estimated Impact │ │ -│ │ │ │ -│ │ - Code Duplication Fix: 20-30% reduction in storage backend code │ │ -│ │ - Error Handling: Improved reliability and debugging capability │ │ -│ │ - File Organization: Improved maintainability and developer experience │ │ -│ │ - Overall: Significant improvement in code quality and technical debt reduction diff --git a/MAKE_USAGE.md b/MAKE_USAGE.md deleted file mode 100644 index eede2f2..0000000 --- a/MAKE_USAGE.md +++ /dev/null @@ -1,55 +0,0 @@ -# SensApp Build & Test Automation - -This project uses `cargo-make` for automated testing and quality checks across different database backends. - -## Installation - -```bash -cargo install cargo-make -``` - -## Available Tasks - -### Quick Tasks -- `cargo make check-all` - Run all checks for PostgreSQL and SQLite (default) -- `cargo make ci` - Full CI pipeline with formatting and checks -- `cargo make clean` - Clean build artifacts and test databases - -### Individual Database Testing -- `cargo make check-sqlite` - SQLite only (build, test, clippy) -- `cargo make check-postgres` - PostgreSQL only (build, test, clippy) - -### Extended Testing -- `cargo make check-working-features` - Test PostgreSQL + SQLite combined -- `cargo make ci-extended` - Full CI with all working features - -### Specific Operations -- `cargo make fmt-check` - Code formatting check -- `cargo make migrate-sqlite` - Run SQLite migrations -- `cargo make migrate-postgres` - Run PostgreSQL migrations - -## Environment Variables - -The build system automatically configures database connections: -- SQLite tests: Uses `sqlite://test.db` -- PostgreSQL tests: Uses `postgres://postgres:postgres@localhost:5432/sensapp` - -Override with `TEST_DATABASE_URL` if needed. - -## CI Usage - -For continuous integration, use: -```bash -cargo make ci -``` - -This runs: -1. Code formatting check -2. SQLite build, test, and clippy -3. PostgreSQL build, test, and clippy - -## List All Tasks - -```bash -cargo make --list-all-steps -``` From a8d607482fc0ee14c102a69497c64bffaa934371 Mon Sep 17 00:00:00 2001 From: Antoine Pultier <45740+fungiboletus@users.noreply.github.com> Date: Fri, 24 Oct 2025 19:19:07 +0200 Subject: [PATCH 07/39] =?UTF-8?q?feat:=20=F0=9F=9A=9B=20only=20http=20no?= =?UTF-8?q?=20ingestors?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/{ingestors => }/http/app_error.rs | 0 src/{ingestors => }/http/crud.rs | 4 ++-- src/{ingestors => }/http/health.rs | 0 src/{ingestors => }/http/influxdb.rs | 0 src/{ingestors => }/http/mod.rs | 0 src/{ingestors => }/http/prometheus.rs | 0 src/{ingestors => }/http/server.rs | 8 ++++---- src/{ingestors => }/http/state.rs | 0 src/ingestors/mod.rs | 1 - src/lib.rs | 2 +- src/main.rs | 6 +++--- tests/common/http.rs | 8 ++++---- 12 files changed, 14 insertions(+), 15 deletions(-) rename src/{ingestors => }/http/app_error.rs (100%) rename src/{ingestors => }/http/crud.rs (99%) rename src/{ingestors => }/http/health.rs (100%) rename src/{ingestors => }/http/influxdb.rs (100%) rename src/{ingestors => }/http/mod.rs (100%) rename src/{ingestors => }/http/prometheus.rs (100%) rename src/{ingestors => }/http/server.rs (97%) rename src/{ingestors => }/http/state.rs (100%) delete mode 100644 src/ingestors/mod.rs diff --git a/src/ingestors/http/app_error.rs b/src/http/app_error.rs similarity index 100% rename from src/ingestors/http/app_error.rs rename to src/http/app_error.rs diff --git a/src/ingestors/http/crud.rs b/src/http/crud.rs similarity index 99% rename from src/ingestors/http/crud.rs rename to src/http/crud.rs index bfdca5e..5750be3 100644 --- a/src/ingestors/http/crud.rs +++ b/src/http/crud.rs @@ -1,7 +1,7 @@ use crate::datamodel::SensAppDateTime; use crate::exporters::{ArrowConverter, CsvConverter, JsonlConverter, SenMLConverter}; -use crate::ingestors::http::app_error::AppError; -use crate::ingestors::http::state::HttpServerState; +use crate::http::app_error::AppError; +use crate::http::state::HttpServerState; use axum::Json; use axum::extract::{Path, Query, State}; use serde::Deserialize; diff --git a/src/ingestors/http/health.rs b/src/http/health.rs similarity index 100% rename from src/ingestors/http/health.rs rename to src/http/health.rs diff --git a/src/ingestors/http/influxdb.rs b/src/http/influxdb.rs similarity index 100% rename from src/ingestors/http/influxdb.rs rename to src/http/influxdb.rs diff --git a/src/ingestors/http/mod.rs b/src/http/mod.rs similarity index 100% rename from src/ingestors/http/mod.rs rename to src/http/mod.rs diff --git a/src/ingestors/http/prometheus.rs b/src/http/prometheus.rs similarity index 100% rename from src/ingestors/http/prometheus.rs rename to src/http/prometheus.rs diff --git a/src/ingestors/http/server.rs b/src/http/server.rs similarity index 97% rename from src/ingestors/http/server.rs rename to src/http/server.rs index f1766c8..940a926 100644 --- a/src/ingestors/http/server.rs +++ b/src/http/server.rs @@ -5,12 +5,12 @@ use super::prometheus::publish_prometheus; use super::state::HttpServerState; use crate::config; use crate::importers::csv::publish_csv_async; -use crate::ingestors::http::crud::{ +use crate::http::crud::{ __path_get_series_data, __path_list_metrics, __path_list_series, }; -use crate::ingestors::http::health::{__path_liveness, __path_readiness, liveness, readiness}; -use crate::ingestors::http::influxdb::__path_publish_influxdb; -use crate::ingestors::http::prometheus::__path_publish_prometheus; +use crate::http::health::{__path_liveness, __path_readiness, liveness, readiness}; +use crate::http::influxdb::__path_publish_influxdb; +use crate::http::prometheus::__path_publish_prometheus; use crate::storage::StorageInstance; use anyhow::Result; use axum::Json; diff --git a/src/ingestors/http/state.rs b/src/http/state.rs similarity index 100% rename from src/ingestors/http/state.rs rename to src/http/state.rs diff --git a/src/ingestors/mod.rs b/src/ingestors/mod.rs deleted file mode 100644 index 3883215..0000000 --- a/src/ingestors/mod.rs +++ /dev/null @@ -1 +0,0 @@ -pub mod http; diff --git a/src/lib.rs b/src/lib.rs index 2fa6dd7..84d01f5 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -3,9 +3,9 @@ pub mod config; pub mod datamodel; pub mod exporters; +pub mod http; pub mod importers; pub mod infer; -pub mod ingestors; pub mod parsing; pub mod storage; diff --git a/src/main.rs b/src/main.rs index 0d32a51..0cd40a2 100644 --- a/src/main.rs +++ b/src/main.rs @@ -1,7 +1,7 @@ #![forbid(unsafe_code)] use crate::config::load_configuration; -use crate::ingestors::http::server::run_http_server; -use crate::ingestors::http::state::HttpServerState; +use crate::http::server::run_http_server; +use crate::http::state::HttpServerState; use anyhow::{Context, Result}; use std::net::SocketAddr; use std::sync::Arc; @@ -11,9 +11,9 @@ use tracing::event; mod config; mod datamodel; mod exporters; +mod http; mod importers; mod infer; -mod ingestors; mod parsing; mod storage; diff --git a/tests/common/http.rs b/tests/common/http.rs index 496ad01..3d24e24 100644 --- a/tests/common/http.rs +++ b/tests/common/http.rs @@ -4,10 +4,10 @@ use axum::Router; use axum::body::Body; use axum::http::{HeaderMap, Request, StatusCode}; use axum::routing::{get, post}; -use sensapp::ingestors::http::crud::{get_series_data, list_metrics, list_series}; -use sensapp::ingestors::http::health::{liveness, readiness}; -use sensapp::ingestors::http::server::publish_senml_data; -use sensapp::ingestors::http::state::HttpServerState; +use sensapp::http::crud::{get_series_data, list_metrics, list_series}; +use sensapp::http::health::{liveness, readiness}; +use sensapp::http::server::publish_senml_data; +use sensapp::http::state::HttpServerState; use sensapp::storage::StorageInstance; use std::sync::Arc; use tower::ServiceExt; // for `oneshot` and `ready` From 732b592aa6587c2bc60f6f4f02c8ee403ab0c9ed Mon Sep 17 00:00:00 2001 From: Antoine Pultier <45740+fungiboletus@users.noreply.github.com> Date: Tue, 28 Oct 2025 08:37:47 +0100 Subject: [PATCH 08/39] =?UTF-8?q?fix:=20=E2=9A=A1=EF=B8=8F=20optimise=20vi?= =?UTF-8?q?be=20coding=20shit?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...20250819143000_add_sensor_catalog_view.sql | 10 ++- ...0250819144000_add_metrics_summary_view.sql | 3 +- src/storage/postgresql/mod.rs | 83 +++++++++---------- 3 files changed, 47 insertions(+), 49 deletions(-) diff --git a/src/storage/postgresql/migrations/20250819143000_add_sensor_catalog_view.sql b/src/storage/postgresql/migrations/20250819143000_add_sensor_catalog_view.sql index 12cf6ca..ee7d980 100644 --- a/src/storage/postgresql/migrations/20250819143000_add_sensor_catalog_view.sql +++ b/src/storage/postgresql/migrations/20250819143000_add_sensor_catalog_view.sql @@ -6,6 +6,12 @@ SELECT s.name, s.type, u.name as unit_name, - u.description as unit_description + u.description as unit_description, + jsonb_object_agg(lnd.name, ldd.description) as labels FROM sensors s -LEFT JOIN units u ON s.unit = u.id; +LEFT JOIN units u ON s.unit = u.id +left join labels l on s.sensor_id = l.sensor_id +left join labels_name_dictionary lnd on l."name" = lnd.id +left join labels_description_dictionary ldd on l.description = ldd.id +group by s.sensor_id, s.uuid, s.name, s.type, u.name, u.description +order by s.sensor_id diff --git a/src/storage/postgresql/migrations/20250819144000_add_metrics_summary_view.sql b/src/storage/postgresql/migrations/20250819144000_add_metrics_summary_view.sql index 6da1fbb..8bb3948 100644 --- a/src/storage/postgresql/migrations/20250819144000_add_metrics_summary_view.sql +++ b/src/storage/postgresql/migrations/20250819144000_add_metrics_summary_view.sql @@ -11,4 +11,5 @@ FROM sensors s LEFT JOIN units u ON s.unit = u.id LEFT JOIN labels l ON s.sensor_id = l.sensor_id LEFT JOIN labels_name_dictionary lnd ON l.name = lnd.id -GROUP BY s.name, s.type; +GROUP BY s.name, s.type +ORDER BY s.name; diff --git a/src/storage/postgresql/mod.rs b/src/storage/postgresql/mod.rs index 9cedced..d222185 100644 --- a/src/storage/postgresql/mod.rs +++ b/src/storage/postgresql/mod.rs @@ -10,6 +10,7 @@ use geo::Point; use serde_json::Value as JsonValue; use smallvec::smallvec; use sqlx::{PgPool, postgres::PgConnectOptions}; +use std::collections::HashMap; use std::{str::FromStr, sync::Arc}; use uuid::Uuid; @@ -78,15 +79,16 @@ impl StorageInstance for PostgresStorage { r#type: Option, unit_name: Option, unit_description: Option, + labels: Option>>, } // Query sensors with their metadata using the catalog view, optionally filtered by metric name let sensor_rows: Vec = sqlx::query_as( r#" - SELECT sensor_id, uuid, name, type, unit_name, unit_description + SELECT sensor_id, uuid, name, type, unit_name, unit_description, labels FROM sensor_catalog_view WHERE ($1::TEXT IS NULL OR name = $1) - ORDER BY uuid ASC + ORDER BY sensor_id ASC "#, ) .bind(metric_filter) @@ -96,7 +98,9 @@ impl StorageInstance for PostgresStorage { let mut sensors = Vec::new(); for sensor_row in sensor_rows { - // Parse sensor metadata with improved error handling + /*let sensor_id = sensor_row.sensor_id.ok_or_else(|| { + anyhow::Error::from(StorageError::missing_field("sensor_id", None, None)) + })?;*/ let sensor_uuid = sensor_row .uuid .ok_or_else(|| { @@ -129,46 +133,18 @@ impl StorageInstance for PostgresStorage { _ => None, }; - // Query labels for this sensor with proper error context - let sensor_id = sensor_row.sensor_id.ok_or_else(|| { - anyhow::Error::from(StorageError::missing_field( - "sensor_id", - Some(sensor_uuid), - Some(&sensor_name), - )) - })?; - - #[derive(sqlx::FromRow)] - struct LabelRow { - label_name: String, - label_value: String, - } - - let labels_rows: Vec = sqlx::query_as( - r#" - SELECT lnd.name as label_name, ldd.description as label_value - FROM labels l - JOIN labels_name_dictionary lnd ON l.name = lnd.id - JOIN labels_description_dictionary ldd ON l.description = ldd.id - WHERE l.sensor_id = $1 - "#, - ) - .bind(sensor_id) - .fetch_all(&self.pool) - .await - .with_context(|| { - format!( - "Failed to query labels for sensor UUID={} name='{}'", - sensor_uuid, sensor_name - ) - })?; + let labels: Option = if let Some(labels_json) = sensor_row.labels { + let mut labels: SensAppLabels = smallvec![]; + for (label_name, label_value) in labels_json.0 { + labels.push((label_name, label_value)); + } - let mut labels: SensAppLabels = smallvec![]; - for label_row in labels_rows { - labels.push((label_row.label_name, label_row.label_value)); - } + Some(labels) + } else { + None + }; - let sensor = Sensor::new(sensor_uuid, sensor_name, sensor_type, unit, Some(labels)); + let sensor = Sensor::new(sensor_uuid, sensor_name, sensor_type, unit, labels); sensors.push(sensor); } @@ -488,11 +464,26 @@ impl StorageInstance for PostgresStorage { // Step 5: Clear all cached function caches // The cached macro generates cache variables named after the function in uppercase use cached::Cached; - postgresql_utilities::GET_LABEL_NAME_ID_OR_CREATE.lock().await.cache_clear(); - postgresql_utilities::GET_LABEL_DESCRIPTION_ID_OR_CREATE.lock().await.cache_clear(); - postgresql_utilities::GET_UNIT_ID_OR_CREATE.lock().await.cache_clear(); - postgresql_utilities::GET_SENSOR_ID_OR_CREATE_SENSOR.lock().await.cache_clear(); - postgresql_utilities::GET_STRING_VALUE_ID_OR_CREATE.lock().await.cache_clear(); + postgresql_utilities::GET_LABEL_NAME_ID_OR_CREATE + .lock() + .await + .cache_clear(); + postgresql_utilities::GET_LABEL_DESCRIPTION_ID_OR_CREATE + .lock() + .await + .cache_clear(); + postgresql_utilities::GET_UNIT_ID_OR_CREATE + .lock() + .await + .cache_clear(); + postgresql_utilities::GET_SENSOR_ID_OR_CREATE_SENSOR + .lock() + .await + .cache_clear(); + postgresql_utilities::GET_STRING_VALUE_ID_OR_CREATE + .lock() + .await + .cache_clear(); Ok(()) } From 5b6179f6919f47789058729ac01e040af8d69620 Mon Sep 17 00:00:00 2001 From: Antoine Pultier <45740+fungiboletus@users.noreply.github.com> Date: Tue, 28 Oct 2025 11:46:06 +0100 Subject: [PATCH 09/39] =?UTF-8?q?feat:=20=F0=9F=8C=88=20sensors=20paginati?= =?UTF-8?q?on=20and=20prometheus=20reads=20in=20one=20single=20commit?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- Cargo.lock | 48 ++++ Cargo.toml | 1 + src/http/crud.rs | 58 ++++- src/http/mod.rs | 1 + src/http/prometheus_read.rs | 228 ++++++++++++++++++ src/http/server.rs | 9 +- src/parsing/prometheus/chunk_encoder.rs | 173 +++++++++++++ src/parsing/prometheus/common.rs | 30 +++ src/parsing/prometheus/mod.rs | 5 + src/parsing/prometheus/remote_read_models.rs | 209 ++++++++++++++++ src/parsing/prometheus/remote_read_parser.rs | 179 ++++++++++++++ src/parsing/prometheus/remote_write_models.rs | 2 +- src/parsing/prometheus/stream_writer.rs | 191 +++++++++++++++ src/storage/bigquery/mod.rs | 12 +- src/storage/clickhouse/mod.rs | 11 +- src/storage/duckdb/mod.rs | 4 +- src/storage/mod.rs | 20 +- ...20250819143000_add_sensor_catalog_view.sql | 15 +- src/storage/postgresql/mod.rs | 47 +++- src/storage/rrdcached/mod.rs | 7 +- src/storage/sqlite/storage.rs | 11 +- src/storage/timescaledb/mod.rs | 11 +- tests/clickhouse_integration.rs | 4 +- tests/common/db.rs | 12 +- tests/common/http.rs | 2 +- tests/common/mod.rs | 8 +- tests/crud_dcat_api.rs | 226 +++++++++++++++++ 27 files changed, 1481 insertions(+), 43 deletions(-) create mode 100644 src/http/prometheus_read.rs create mode 100644 src/parsing/prometheus/chunk_encoder.rs create mode 100644 src/parsing/prometheus/common.rs create mode 100644 src/parsing/prometheus/remote_read_models.rs create mode 100644 src/parsing/prometheus/remote_read_parser.rs create mode 100644 src/parsing/prometheus/stream_writer.rs diff --git a/Cargo.lock b/Cargo.lock index 6e78b56..3eea962 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -930,6 +930,15 @@ dependencies = [ "serde_core", ] +[[package]] +name = "bitstream-io" +version = "4.9.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "60d4bd9d1db2c6bdf285e223a7fa369d5ce98ec767dec949c6ca62863ce61757" +dependencies = [ + "core2", +] + [[package]] name = "bitvec" version = "1.0.1" @@ -1445,6 +1454,15 @@ version = "0.8.7" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "773648b94d0e5d620f64f280777445740e61fe701025087ec8b57f45c791888b" +[[package]] +name = "core2" +version = "0.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b49ba7ef1ad6107f8824dbe97de947cbaac53c44e7f9756a1fba0d37c1eec505" +dependencies = [ + "memchr", +] + [[package]] name = "cpufeatures" version = "0.2.17" @@ -1469,6 +1487,15 @@ version = "2.4.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "19d374276b40fb8bbdee95aef7c7fa6b5316ec764510eb64b8dd0e2ed0d7e7f5" +[[package]] +name = "crc32c" +version = "0.6.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3a47af21622d091a8f0fb295b88bc886ac74efcc613efc19f5d0b21de5c89e47" +dependencies = [ + "rustc_version", +] + [[package]] name = "crc32fast" version = "1.5.0" @@ -4204,6 +4231,20 @@ version = "1.0.22" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "b39cdef0fa800fc44525c84ccb54a029961a8215f9619753635a9c0d2538d46d" +[[package]] +name = "rusty-chunkenc" +version = "0.1.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "40d3e2ad7a6e17f15c09a73ea6904196350f81607b3a89a245d87f83e1e22a3f" +dependencies = [ + "bitstream-io", + "crc32c", + "nom 8.0.0", + "smallvec 2.0.0-alpha.11", + "thiserror 2.0.17", + "xxhash-rust", +] + [[package]] name = "ryu" version = "1.0.20" @@ -4339,6 +4380,7 @@ dependencies = [ "rrdcached-client", "rust_decimal", "rustls", + "rusty-chunkenc", "sensapp", "sentry", "serde", @@ -6391,6 +6433,12 @@ dependencies = [ "rustix", ] +[[package]] +name = "xxhash-rust" +version = "0.8.15" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fdd20c5420375476fbd4394763288da7eb0cc0b8c11deed431a91562af7335d3" + [[package]] name = "yaml-rust2" version = "0.10.4" diff --git a/Cargo.toml b/Cargo.toml index f868c24..ff92786 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -75,6 +75,7 @@ confique = { version = "0.3", features = ["toml"] } byte-unit = "5.1" prost = "0.14" snap = "1.1" +rusty-chunkenc = "0.1" hex = "0.4" blake3 = "1.8" regex = "1.12" diff --git a/src/http/crud.rs b/src/http/crud.rs index 5750be3..bc91582 100644 --- a/src/http/crud.rs +++ b/src/http/crud.rs @@ -63,6 +63,8 @@ pub struct SensorDataQuery { #[derive(Debug, Deserialize)] pub struct SeriesQuery { pub metric: Option, + pub limit: Option, + pub bookmark: Option, } /// List unique metrics (measurement types) with aggregated information in DCAT catalog format. @@ -178,12 +180,19 @@ pub async fn list_metrics(State(state): State) -> Result, Query(query): Query, -) -> Result, AppError> { +) -> Result { + // Validate and cap the limit + let limit = query.limit.map(|l| l.min(crate::storage::MAX_LIST_SERIES_LIMIT)); + // Get the series metadata including labels and UUIDs, optionally filtered by metric - let sensors = state.storage.list_series(query.metric.as_deref()).await?; + let result = state + .storage + .list_series(query.metric.as_deref(), limit, query.bookmark.as_deref()) + .await?; // Create DCAT catalog structure - let datasets: Vec = sensors + let datasets: Vec = result + .series .iter() .map(|sensor| { // Create keywords from sensor type, unit, and labels @@ -262,11 +271,13 @@ pub async fn list_series( }) .collect(); - let catalog = json!({ + // Build catalog with Hydra pagination metadata if there's a next page + let mut catalog = json!({ "@context": { "dcat": "http://www.w3.org/ns/dcat#", "dct": "http://purl.org/dc/terms/", - "foaf": "http://xmlns.com/foaf/0.1/" + "foaf": "http://xmlns.com/foaf/0.1/", + "hydra": "http://www.w3.org/ns/hydra/core#" }, "@type": "dcat:Catalog", "@id": "sensapp_series_catalog", @@ -279,7 +290,42 @@ pub async fn list_series( "dcat:dataset": datasets }); - Ok(Json(catalog)) + // Add Hydra pagination metadata if there's a next page + let link_header = if let Some(bookmark) = &result.bookmark { + // Build the next page URL + let mut next_url = format!("/series?limit={}&bookmark={}", limit.unwrap_or(crate::storage::DEFAULT_LIST_SERIES_LIMIT), bookmark); + if let Some(metric) = &query.metric { + next_url = format!("{}&metric={}", next_url, urlencoding::encode(metric)); + } + + // Add Hydra view to catalog + catalog["hydra:view"] = json!({ + "@type": "hydra:PartialCollectionView", + "hydra:next": next_url, + "hydra:itemsPerPage": limit.unwrap_or(crate::storage::DEFAULT_LIST_SERIES_LIMIT) + }); + + // Return Link header value + Some(format!("<{}>; rel=\"next\"", next_url)) + } else { + None + }; + + // Build response with optional Link header + let mut response = axum::response::Response::builder() + .status(200) + .header("Content-Type", "application/json"); + + if let Some(link) = link_header { + response = response.header("Link", link); + } + + let body = serde_json::to_string(&catalog) + .map_err(|e| AppError::internal_server_error(anyhow::anyhow!("Failed to serialize catalog: {}", e)))?; + + response + .body(axum::body::Body::from(body)) + .map_err(|e| AppError::internal_server_error(anyhow::anyhow!("Failed to build response: {}", e))) } /// Get series data in various formats based on query parameter. diff --git a/src/http/mod.rs b/src/http/mod.rs index 867dcfc..0e356f5 100644 --- a/src/http/mod.rs +++ b/src/http/mod.rs @@ -3,5 +3,6 @@ pub mod crud; pub mod health; pub mod influxdb; pub mod prometheus; +pub mod prometheus_read; pub mod server; pub mod state; diff --git a/src/http/prometheus_read.rs b/src/http/prometheus_read.rs new file mode 100644 index 0000000..f30ebce --- /dev/null +++ b/src/http/prometheus_read.rs @@ -0,0 +1,228 @@ +use crate::parsing::prometheus::remote_read_parser::{ + create_empty_read_response, parse_remote_read_request, serialize_read_response, +}; + +use super::{app_error::AppError, state::HttpServerState}; +use axum::{ + debug_handler, + extract::State, + http::{HeaderMap, StatusCode}, + response::Response, +}; +use tokio_util::bytes::Bytes; +use tracing::{debug, info, warn}; + +fn verify_read_headers(headers: &HeaderMap) -> Result<(), AppError> { + // Check that we have the right content encoding, that must be snappy + match headers.get("content-encoding") { + Some(content_encoding) => match content_encoding.to_str() { + Ok("snappy") | Ok("SNAPPY") => {} + _ => { + return Err(AppError::bad_request(anyhow::anyhow!( + "Unsupported content-encoding, must be snappy" + ))); + } + }, + None => { + return Err(AppError::bad_request(anyhow::anyhow!( + "Missing content-encoding header" + ))); + } + } + + // Check that the content type is protocol buffer + match headers.get("content-type") { + Some(content_type) => match content_type.to_str() { + Ok("application/x-protobuf") | Ok("APPLICATION/X-PROTOBUF") => {} + _ => { + return Err(AppError::bad_request(anyhow::anyhow!( + "Unsupported content-type, must be application/x-protobuf" + ))); + } + }, + None => { + return Err(AppError::bad_request(anyhow::anyhow!( + "Missing content-type header" + ))); + } + } + + // Check that the remote read version is supported + match headers.get("x-prometheus-remote-read-version") { + Some(version) => match version.to_str() { + Ok("0.1.0") => {} + _ => { + return Err(AppError::bad_request(anyhow::anyhow!( + "Unsupported x-prometheus-remote-read-version, must be 0.1.0" + ))); + } + }, + None => { + return Err(AppError::bad_request(anyhow::anyhow!( + "Missing x-prometheus-remote-read-version header" + ))); + } + } + + Ok(()) +} + +/// Prometheus Remote Read API. +/// +/// Allows you to read data from SensApp using Prometheus remote read protocol. +/// +/// It follows the [Prometheus Remote Read specification](https://prometheus.io/docs/prometheus/latest/querying/remote_read_api/). +#[utoipa::path( + post, + path = "/api/v1/prometheus_remote_read", + tag = "Prometheus", + request_body( + content_type = "application/x-protobuf", + description = "Prometheus Remote Read endpoint. [Reference](https://prometheus.io/docs/prometheus/latest/querying/remote_read_api/)", + ), + params( + ("content-encoding" = String, Header, format = "snappy", description = "Content encoding, must be snappy"), + ("content-type" = String, Header, format = "application/x-protobuf", description = "Content type, must be application/x-protobuf"), + ("x-prometheus-remote-read-version" = String, Header, format = "0.1.0", description = "Prometheus Remote Read version, must be 0.1.0"), + ), + responses( + (status = 200, description = "Read Response", content_type = "application/x-protobuf"), + (status = 400, description = "Bad Request", body = AppError), + (status = 500, description = "Internal Server Error", body = AppError), + ) +)] +#[debug_handler] +pub async fn prometheus_remote_read( + State(_state): State, + headers: HeaderMap, + bytes: Bytes, +) -> Result, AppError> { + debug!("Prometheus remote read: received {} bytes", bytes.len()); + + // Verify headers + verify_read_headers(&headers)?; + + // Parse the read request + let read_request = parse_remote_read_request(&bytes).map_err(|e| { + AppError::bad_request(anyhow::anyhow!("Failed to parse read request: {}", e)) + })?; + + info!( + "Prometheus remote read: Processing {} queries", + read_request.queries.len() + ); + + // Log detailed information about each query for debugging + for (i, query) in read_request.queries.iter().enumerate() { + info!( + "Query {}: time range {}ms - {}ms ({} matchers)", + i, + query.start_timestamp_ms, + query.end_timestamp_ms, + query.matchers.len() + ); + + for matcher in &query.matchers { + debug!( + " Matcher: {}={} (type={})", + matcher.name, matcher.value, matcher.r#type + ); + } + + if let Some(hints) = &query.hints { + //debug!(" Hints: step={}ms, func='{}'", hints.step_ms, hints.func); + debug!(" Hints: {:?}", hints); + } + } + + debug!( + "Accepted response types: {:?}", + read_request.accepted_response_types + ); + + // For now, create an empty response + warn!("Returning empty response - data fetching not yet implemented"); + let empty_response = create_empty_read_response(&read_request).map_err(|e| { + AppError::internal_server_error(anyhow::anyhow!("Failed to create response: {}", e)) + })?; + + // Serialize and compress the response + let response_bytes = serialize_read_response(&empty_response).map_err(|e| { + AppError::internal_server_error(anyhow::anyhow!("Failed to serialize response: {}", e)) + })?; + + info!( + "Prometheus remote read: Returning response with {} bytes", + response_bytes.len() + ); + + // Build HTTP response with appropriate headers + let response = Response::builder() + .status(StatusCode::OK) + .header("content-type", "application/x-protobuf") + .header("content-encoding", "snappy") + .body(axum::body::Body::from(response_bytes)) + .map_err(|e| { + AppError::internal_server_error(anyhow::anyhow!("Failed to build response: {}", e)) + })?; + + Ok(response) +} + +#[cfg(any(test, feature = "test-utils"))] +mod tests { + #![allow(dead_code)] + use super::*; + use axum::http::HeaderValue; + + fn create_test_headers() -> HeaderMap { + let mut headers = HeaderMap::new(); + headers.insert("content-encoding", HeaderValue::from_static("snappy")); + headers.insert( + "content-type", + HeaderValue::from_static("application/x-protobuf"), + ); + headers.insert( + "x-prometheus-remote-read-version", + HeaderValue::from_static("0.1.0"), + ); + headers + } + + #[test] + fn test_verify_read_headers_valid() { + let headers = create_test_headers(); + assert!(verify_read_headers(&headers).is_ok()); + } + + #[test] + fn test_verify_read_headers_missing_content_encoding() { + let mut headers = create_test_headers(); + headers.remove("content-encoding"); + assert!(verify_read_headers(&headers).is_err()); + } + + #[test] + fn test_verify_read_headers_invalid_content_encoding() { + let mut headers = create_test_headers(); + headers.insert("content-encoding", HeaderValue::from_static("gzip")); + assert!(verify_read_headers(&headers).is_err()); + } + + #[test] + fn test_verify_read_headers_missing_content_type() { + let mut headers = create_test_headers(); + headers.remove("content-type"); + assert!(verify_read_headers(&headers).is_err()); + } + + #[test] + fn test_verify_read_headers_invalid_version() { + let mut headers = create_test_headers(); + headers.insert( + "x-prometheus-remote-read-version", + HeaderValue::from_static("2.0.0"), + ); + assert!(verify_read_headers(&headers).is_err()); + } +} diff --git a/src/http/server.rs b/src/http/server.rs index 940a926..91cc0bf 100644 --- a/src/http/server.rs +++ b/src/http/server.rs @@ -2,6 +2,7 @@ use super::app_error::AppError; use super::crud::{get_series_data, list_metrics, list_series}; use super::influxdb::publish_influxdb; use super::prometheus::publish_prometheus; +use super::prometheus_read::prometheus_remote_read; use super::state::HttpServerState; use crate::config; use crate::importers::csv::publish_csv_async; @@ -11,6 +12,7 @@ use crate::http::crud::{ use crate::http::health::{__path_liveness, __path_readiness, liveness, readiness}; use crate::http::influxdb::__path_publish_influxdb; use crate::http::prometheus::__path_publish_prometheus; +use crate::http::prometheus_read::__path_prometheus_remote_read; use crate::storage::StorageInstance; use anyhow::Result; use axum::Json; @@ -42,7 +44,7 @@ use utoipa_scalar::{Scalar, Servable as ScalarServable}; (name = "Admin", description = "Administrative operations"), (name = "Health", description = "Health check endpoints"), ), - paths(frontpage, publish_sensors_data, list_metrics, list_series, get_series_data, publish_influxdb, publish_prometheus, vacuum_database, liveness, readiness), + paths(frontpage, publish_sensors_data, list_metrics, list_series, get_series_data, publish_influxdb, publish_prometheus, prometheus_remote_read, vacuum_database, liveness, readiness), )] struct ApiDoc; @@ -90,6 +92,11 @@ pub async fn run_http_server(state: HttpServerState, address: SocketAddr) -> Res "/api/v1/prometheus_remote_write", post(publish_prometheus).layer(max_body_layer), ) + // Prometheus Remote Read API + .route( + "/api/v1/prometheus_remote_read", + post(prometheus_remote_read).layer(max_body_layer), + ) // Admin API .route("/api/v1/admin/vacuum", post(vacuum_database)) // Health check endpoints diff --git a/src/parsing/prometheus/chunk_encoder.rs b/src/parsing/prometheus/chunk_encoder.rs new file mode 100644 index 0000000..77ab6df --- /dev/null +++ b/src/parsing/prometheus/chunk_encoder.rs @@ -0,0 +1,173 @@ +use super::remote_read_models::{Chunk as ProtoChunk, ChunkedReadResponse, ChunkedSeries, chunk}; +use super::remote_write_models::{Label, Sample}; +use anyhow::Result; +use rusty_chunkenc::chunk::Chunk; +use rusty_chunkenc::xor::XORSample; +use tracing::debug; + +/// Encodes time series samples into XOR-compressed chunks for Prometheus remote read. +#[allow(dead_code)] +pub struct ChunkEncoder; + +#[allow(dead_code)] +impl ChunkEncoder { + /// Encode a time series into a ChunkedSeries with XOR-compressed chunks. + /// + /// # Arguments + /// * `labels` - The labels for this time series + /// * `samples` - The samples to encode (must be sorted by timestamp) + /// + /// # Returns + /// A ChunkedSeries with XOR-encoded chunks + pub fn encode_series(labels: Vec