Add logging

Author: MasloMaslane

Cargo.lock

@@ -8,7 +8,8 @@ tokio = { version = "1.44.1", features = ["full"] }
 axum = { version = "0.8.1", features = ["macros"] }
 tower-http = { version = "0.6.2", features = ["full"] }
 tracing = "0.1.41"
-tracing-subscriber = { version = "0.3.19", features = ["env-filter"] }
+tracing-subscriber = { version = "0.3.19", features = ["env-filter", "json"] }
 serde = { version = "1.0.219", features = ["derive"] }
 serde_json = "1.0.140"
-sqlx = { version = "0.8.3", features = ["postgres", "sqlite", "runtime-tokio"]}
+sqlx = { version = "0.8.3", features = ["postgres", "sqlite", "runtime-tokio"]}
+log = "0.4.26"

Cargo.toml

@@ -1,7 +1,11 @@
 {
+  "logging": {
+    "level": "debug",
+    "json": false
+  },
   "kvstorage_type": "sqlite",
   "sqlite": {
-    "path": "sqlite.db",
+    "path": "kv.db",
     "pool_size": 10
   },
   "locks_type": "memory"

config.json

@@ -3,9 +3,12 @@ use crate::kvstorage::postgres::PostgresConfig;
 use crate::kvstorage::sqlite::SQLiteConfig;
 use crate::locks::LocksType;
 use std::error::Error;
+use crate::logging::LoggingConfig;
 
 #[derive(Debug, serde::Deserialize, Clone)]
 pub struct Config {
+    pub logging: LoggingConfig,
+
     pub kvstorage_type: KVStorageType,
 
     #[serde(default)]

src/config.rs

@@ -1,6 +1,7 @@
 use crate::config::Config;
 use serde::Deserialize;
 use std::error::Error;
+use tracing::{debug, info};
 
 mod pooled;
 pub mod postgres;
@@ -74,10 +75,12 @@ impl KVStorage {
     pub async fn new(config: &Config) -> Result<Box<Self>, Box<dyn Error>> {
         match config.kvstorage_type {
             KVStorageType::Postgres => {
+                info!("Using Postgres as KV storage");
                 let storage = postgres::Postgres::new(config).await?;
                 Ok(Box::new(KVStorage::Postgres(*storage)))
             }
             KVStorageType::SQLite => {
+                info!("Using SQLite as KV storage");
                 let storage = sqlite::SQLite::new(config).await?;
                 Ok(Box::new(KVStorage::SQLite(*storage)))
             }
@@ -92,6 +95,7 @@ impl KVStorage {
     }
 
     pub async fn get_ref_count(&mut self, bucket: &str, hash: &str) -> Result<i32, Box<dyn Error>> {
+        debug!("Getting ref count for bucket: {}, hash: {}", bucket, hash);
         match self {
             KVStorage::Postgres(storage) => storage.get_ref_count(bucket, hash).await,
             KVStorage::SQLite(storage) => storage.get_ref_count(bucket, hash).await,
@@ -104,6 +108,10 @@ impl KVStorage {
         hash: &str,
         ref_cnt: i32,
     ) -> Result<(), Box<dyn Error>> {
+        debug!(
+            "Setting ref count for bucket: {}, hash: {} to {}",
+            bucket, hash, ref_cnt
+        );
         match self {
             KVStorage::Postgres(storage) => storage.set_ref_count(bucket, hash, ref_cnt).await,
             KVStorage::SQLite(storage) => storage.set_ref_count(bucket, hash, ref_cnt).await,
@@ -115,6 +123,7 @@ impl KVStorage {
         bucket: &str,
         hash: &str,
     ) -> Result<(), Box<dyn Error>> {
+        debug!("Incrementing ref count for bucket: {}, hash: {}", bucket, hash);
         match self {
             KVStorage::Postgres(storage) => storage.increment_ref_count(bucket, hash).await,
             KVStorage::SQLite(storage) => storage.increment_ref_count(bucket, hash).await,
@@ -126,13 +135,15 @@ impl KVStorage {
         bucket: &str,
         hash: &str,
     ) -> Result<(), Box<dyn Error>> {
+        debug!("Decrementing ref count for bucket: {}, hash: {}", bucket, hash);
         match self {
             KVStorage::Postgres(storage) => storage.decrement_ref_count(bucket, hash).await,
             KVStorage::SQLite(storage) => storage.decrement_ref_count(bucket, hash).await,
         }
     }
 
     pub async fn get_modified(&mut self, bucket: &str, path: &str) -> Result<i64, Box<dyn Error>> {
+        debug!("Getting modified time for bucket: {}, path: {}", bucket, path);
         match self {
             KVStorage::Postgres(storage) => storage.get_modified(bucket, path).await,
             KVStorage::SQLite(storage) => storage.get_modified(bucket, path).await,
@@ -145,6 +156,10 @@ impl KVStorage {
         path: &str,
         modified: i64,
     ) -> Result<(), Box<dyn Error>> {
+        debug!(
+            "Setting modified time for bucket: {}, path: {} to {}",
+            bucket, path, modified
+        );
         match self {
             KVStorage::Postgres(storage) => storage.set_modified(bucket, path, modified).await,
             KVStorage::SQLite(storage) => storage.set_modified(bucket, path, modified).await,
@@ -156,6 +171,7 @@ impl KVStorage {
         bucket: &str,
         path: &str,
     ) -> Result<(), Box<dyn Error>> {
+        debug!("Deleting modified time for bucket: {}, path: {}", bucket, path);
         match self {
             KVStorage::Postgres(storage) => storage.delete_modified(bucket, path).await,
             KVStorage::SQLite(storage) => storage.delete_modified(bucket, path).await,
@@ -167,6 +183,7 @@ impl KVStorage {
         bucket: &str,
         path: &str,
     ) -> Result<String, Box<dyn Error>> {
+        debug!("Getting ref file for bucket: {}, path: {}", bucket, path);
         match self {
             KVStorage::Postgres(storage) => storage.get_ref_file(bucket, path).await,
             KVStorage::SQLite(storage) => storage.get_ref_file(bucket, path).await,
@@ -179,6 +196,10 @@ impl KVStorage {
         path: &str,
         hash: &str,
     ) -> Result<(), Box<dyn Error>> {
+        debug!(
+            "Setting ref file for bucket: {}, path: {} to {}",
+            bucket, path, hash
+        );
         match self {
             KVStorage::Postgres(storage) => storage.set_ref_file(bucket, path, hash).await,
             KVStorage::SQLite(storage) => storage.set_ref_file(bucket, path, hash).await,
@@ -190,6 +211,7 @@ impl KVStorage {
         bucket: &str,
         path: &str,
     ) -> Result<(), Box<dyn Error>> {
+        debug!("Deleting ref file for bucket: {}, path: {}", bucket, path);
         match self {
             KVStorage::Postgres(storage) => storage.delete_ref_file(bucket, path).await,
             KVStorage::SQLite(storage) => storage.delete_ref_file(bucket, path).await,

src/kvstorage/mod.rs

@@ -5,6 +5,7 @@ use serde::Deserialize;
 use sqlx::PgPool;
 use sqlx::postgres::PgPoolOptions;
 use std::error::Error;
+use tracing::debug;
 
 #[derive(Debug, Clone, Deserialize)]
 pub struct PostgresConfig {
@@ -28,6 +29,7 @@ impl KVStorageTrait for Postgres {
             "postgres://{}:{}@{}:{}/{}",
             pg_config.user, pg_config.password, pg_config.host, pg_config.port, pg_config.dbname
         );
+        debug!("Connecting to Postgres database: {}", db_url);
         let pool = PgPoolOptions::new()
             .max_connections(pg_config.pool_size)
             .connect(&db_url)

src/kvstorage/postgres.rs

@@ -1,8 +1,11 @@
+use std::path::Path;
 use crate::config::Config;
 use crate::kvstorage::KVStorageTrait;
 use crate::kvstorage::pooled::{RowModified, RowRefFile, RowRefcount};
 use serde::Deserialize;
 use sqlx::SqlitePool;
+use tracing::debug;
+use tracing::field::debug;
 
 #[derive(Debug, Clone, Deserialize)]
 pub struct SQLiteConfig {
@@ -18,7 +21,13 @@ pub struct SQLite {
 impl KVStorageTrait for SQLite {
     async fn new(config: &Config) -> Result<Box<Self>, Box<dyn std::error::Error>> {
         let sqlite_config = config.sqlite.as_ref().unwrap();
+
+        if !Path::new(&sqlite_config.path).exists() {
+            std::fs::File::create(&sqlite_config.path)?;
+        }
+
         let db_url = format!("sqlite://{}", sqlite_config.path);
+        debug!("Connecting to SQLite database: {}", db_url);
         let pool = SqlitePool::connect(&db_url).await?;
         Ok(Box::new(SQLite { pool }))
     }

src/kvstorage/sqlite.rs

@@ -1,4 +1,5 @@
 use serde::Deserialize;
+use tracing::{debug, info};
 
 pub mod memory;
 
@@ -26,11 +27,15 @@ pub enum LocksStorage {
 impl LocksStorage {
     pub fn new(lock_type: &LocksType) -> Box<Self> {
         match lock_type {
-            LocksType::Memory => Box::new(LocksStorage::Memory(*memory::MemoryLocks::new())),
+            LocksType::Memory => {
+                info!("Using memory as locks storage");
+                Box::new(LocksStorage::Memory(*memory::MemoryLocks::new()))
+            },
         }
     }
 
     pub fn acquire_shared(&mut self, key: &str) {
+        debug!("Acquiring shared lock for key: {}", key);
         match self {
             LocksStorage::Memory(lock) => {
                 lock.acquire_shared(key);
@@ -39,6 +44,7 @@ impl LocksStorage {
     }
 
     pub fn acquire_exclusive(&mut self, key: &str) {
+        debug!("Acquiring exclusive lock for key: {}", key);
         match self {
             LocksStorage::Memory(lock) => {
                 lock.acquire_exclusive(key);
@@ -47,6 +53,7 @@ impl LocksStorage {
     }
 
     pub fn release(&mut self, key: &str) -> bool {
+        debug!("Releasing lock for key: {}", key);
         match self {
             LocksStorage::Memory(lock) => lock.release(key),
         }

src/locks/mod.rs

@@ -0,0 +1,24 @@
+use tracing::dispatcher::SetGlobalDefaultError;
+use tracing_subscriber::{fmt, EnvFilter};
+
+#[derive(Clone, Debug, serde::Deserialize)]
+pub struct LoggingConfig {
+    level: String,
+    json: bool,
+}
+
+pub fn setup(logging_config: &LoggingConfig) -> Result<(), SetGlobalDefaultError> {
+    let filter = EnvFilter::new(&logging_config.level);
+    if logging_config.json {
+        let subscriber = fmt::Subscriber::builder()
+            .with_env_filter(filter)
+            .json()
+            .finish();
+        tracing::subscriber::set_global_default(subscriber)
+    } else {
+        let subscriber = fmt::Subscriber::builder()
+            .with_env_filter(filter)
+            .finish();
+        tracing::subscriber::set_global_default(subscriber)
+    }
+}

src/logging.rs

@@ -5,11 +5,14 @@ use axum::routing::put;
 use routes::ft::put_file::ft_put_file;
 use std::error::Error;
 use std::sync::Arc;
+use tower_http::trace::{DefaultMakeSpan, DefaultOnResponse, TraceLayer};
+use tracing::Level;
 
 mod config;
 mod kvstorage;
 mod locks;
 mod routes;
+mod logging;
 
 #[derive(Clone)]
 struct AppState {
@@ -33,11 +36,17 @@ impl AppState {
 #[tokio::main]
 async fn main() {
     let config = config::Config::new("config.json").unwrap();
+    logging::setup(&config.logging).unwrap();
     let mut app_state = AppState::new(config).await.unwrap();
     app_state.kvstorage.setup().await.unwrap();
 
     let app = Router::new()
         .route("/ft/files/{path}", put(ft_put_file))
+        .layer(
+            TraceLayer::new_for_http()
+                .make_span_with(DefaultMakeSpan::new().level(Level::INFO))
+                .on_response(DefaultOnResponse::new().level(Level::INFO)),
+        )
         .with_state(Arc::new(app_state));
     let listener = tokio::net::TcpListener::bind("0.0.0.0:3000").await.unwrap();
     axum::serve(listener, app).await.unwrap();