feat: backup-restore-job-logs

.github/workflows/codecov.yml

@@ -1,86 +1,3 @@
-#name: Codecov Rust
-#
-#on:
-#  push:
-#    branches: ["main"]
-#  pull_request:
-#    branches: ["main"]
-#
-#env:
-#  CARGO_TERM_COLOR: always
-#
-#jobs:
-#  coverage:
-#    runs-on: ubuntu-latest
-#    steps:
-#      - uses: actions/checkout@v4
-#
-#      - name: Install Rust toolchain
-#        uses: dtolnay/rust-toolchain@stable
-#        with:
-#          components: llvm-tools-preview
-#
-#      - name: Build test image (with grcov included)
-#        run: docker compose -f docker-compose.test.yml build agent-test
-#
-#      - name: Run tests in container
-#        env:
-#          CARGO_TARGET_DIR: /app/target
-#          CARGO_INCREMENTAL: 0
-#          RUSTFLAGS: "-C instrument-coverage -C link-dead-code"
-#          LLVM_PROFILE_FILE: "/app/coverage/cargo-test-%p-%m.profraw"
-#        run: |
-#          docker compose -f docker-compose.test.yml run \
-#            -e CARGO_TARGET_DIR \
-#            -e CARGO_INCREMENTAL \
-#            -e RUSTFLAGS \
-#            -e LLVM_PROFILE_FILE \
-#            agent-test bash -c "cargo clean && cargo test --verbose && sync"
-#
-#      - name: Verify profraw files exist
-#        run: |
-#          docker compose -f docker-compose.test.yml run agent-test \
-#            find /app/coverage -type f -name "*.profraw" | wc -l || true
-#
-#      - name: Generate coverage report inside container
-#        run: |
-#          docker compose -f docker-compose.test.yml run agent-test bash -c "
-#            rustup component add llvm-tools &&
-#            grcov /app/coverage \
-#              --binary-path /app/target/debug \
-#              -s /app \
-#              --llvm \
-#              -t lcov \
-#              --branch \
-#              --ignore-not-existing \
-#              --ignore '/app/target/*' \
-#              --ignore '/*' \
-#              -o /app/lcov.info
-#          "
-#
-#      - name: Copy lcov.info from container to host
-#        run: |
-#          docker compose -f docker-compose.test.yml cp agent-test:/app/lcov.info ./lcov.info
-#
-#      - name: Remove container
-#        run: |
-#          docker rm agent-test-run
-#
-#      - name: Show basic coverage report info (debug)
-#        run: |
-#          echo "lcov.info size:" $(wc -c ./lcov.info | awk '{print $1}')
-#          head -n 30 ./lcov.info || true
-#
-#      - name: Upload coverage to Codecov
-#        uses: codecov/codecov-action@v5
-#        with:
-#          files: ./lcov.info
-#          flags: unittests
-#          name: rust-unit-coverage
-#          verbose: true
-#          fail_ci_if_error: true
-#        env:
-#          CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}
 name: Codecov Rust
 
 on:

docker-compose.test.yml

@@ -10,6 +10,7 @@ services:
       - .:/app
       - cargo-registry:/usr/local/cargo/registry
       - cargo-git:/usr/local/cargo/git
+      - cargo-target:/app/target
       - /var/run/docker.sock:/var/run/docker.sock
     environment:
       APP_ENV: test
@@ -20,3 +21,4 @@ services:
 volumes:
   cargo-registry:
   cargo-git:
+  cargo-target:

docker-compose.yml

@@ -12,14 +12,14 @@ services:
       - ./databases.json:/config/config.json
       #- ./databases.toml:/config/config.toml
       #- /var/run/docker.sock:/var/run/docker.sock
-      #- cargo-target:/app/target
+      - cargo-target:/app/target
       - databases_sqlite-data:/sqlite-data/workspace/data
       - ./scripts/sqlite/test-db:/sqlite-data-2/workspace/data
     environment:
       APP_ENV: development
       LOG: debug
       TZ: "Europe/Paris"
-      EDGE_KEY: "eyJzZXJ2ZXJVcmwiOiJodHRwOi8vbG9jYWxob3N0Ojg4ODciLCJhZ2VudElkIjoiNzNlZmJhNjMtNTkzMy00Mzk3LWI0ZmMtMjlmNTViNmI5YzA4IiwibWFzdGVyS2V5QjY0IjoiQlhWM1hvbEM2NTZTVjdkTmdjV1BHUWxrKytycExJNmxHRGk3Q1BCNWllbz0ifQ=="
+      EDGE_KEY: "eyJzZXJ2ZXJVcmwiOiJodHRwOi8vbG9jYWxob3N0Ojg4ODciLCJhZ2VudElkIjoiNzA5ZDc0ZjYtYzY5Yy00ZjNiLWJiZWYtZmJkNTU1YmM4Njg2IiwibWFzdGVyS2V5QjY0IjoiQlhWM1hvbEM2NTZTVjdkTmdjV1BHUWxrKytycExJNmxHRGk3Q1BCNWllbz0ifQ=="
       #CHUNK_SIZE_MB: "1"
       #POOLING: 1
       #DATABASES_CONFIG_FILE: "config.toml"
@@ -31,7 +31,7 @@ services:
 volumes:
   cargo-registry:
   cargo-git:
-  #cargo-target:
+  cargo-target:
   databases_sqlite-data:
     external: true
 

justfile

@@ -58,4 +58,12 @@ seed-all:
     just seed-sqlite
     just seed-mongo
     just seed-firebird
-    just seed-mssql
+    just seed-mssql
+
+test:
+    echo "Build test image (with grcov included)"
+    docker compose -f docker-compose.test.yml build agent-test
+    echo "Start agent-test container"
+    docker compose -f docker-compose.test.yml up -d agent-test
+    echo "Run tests inside container"
+    docker compose -f docker-compose.test.yml exec -e CARGO_INCREMENTAL -e RUSTFLAGS -e LLVM_PROFILE_FILE agent-test bash -c "cargo test --verbose && sync"

src/domain/factory.rs

@@ -5,19 +5,20 @@ use crate::domain::postgres::{detect_format_from_file, detect_format_from_size};
 use crate::domain::redis::database::RedisDatabase;
 use crate::domain::sqlite::database::SqliteDatabase;
 use crate::domain::valkey::database::ValkeyDatabase;
+use crate::domain::firebird::database::FirebirdDatabase;
+use crate::domain::mariadb::database::MariaDBDatabase;
+use crate::domain::mssql::database::MssqlDatabase;
+use crate::services::backup::logger::JobLogger;
 use crate::services::config::{DatabaseConfig, DbType};
 use anyhow::Result;
 use std::path::{Path, PathBuf};
 use std::sync::Arc;
-use crate::domain::firebird::database::FirebirdDatabase;
-use crate::domain::mariadb::database::MariaDBDatabase;
-use crate::domain::mssql::database::MssqlDatabase;
 
 #[async_trait::async_trait]
 pub trait Database: Send + Sync {
     fn file_extension(&self) -> &'static str;
     async fn ping(&self) -> Result<bool>;
-    async fn backup(&self, backup_dir: &Path) -> Result<PathBuf>;
+    async fn backup(&self, backup_dir: &Path, logger: Arc<JobLogger>) -> Result<PathBuf>;
     async fn restore(&self, restore_file: &Path) -> Result<()>;
 }
 

src/domain/firebird/backup.rs

@@ -1,47 +1,53 @@
+use crate::services::backup::logger::JobLogger;
 use crate::services::config::DatabaseConfig;
 use anyhow::{Context, Result};
 use std::path::PathBuf;
 use std::process::Command;
-use tracing::{debug, error, info};
+use std::sync::Arc;
+use std::time::Instant;
 
 pub async fn run(
     cfg: DatabaseConfig,
     backup_dir: PathBuf,
     file_extension: &'static str,
+    logger: Arc<JobLogger>,
 ) -> Result<PathBuf> {
     tokio::task::spawn_blocking(move || -> Result<PathBuf> {
-        debug!("Starting backup for database {}", cfg.name);
+        logger.log("debug", format!("Starting Firebird backup for database: {}", cfg.name));
 
         let file_path = backup_dir.join(format!("{}{}", cfg.generated_id, file_extension));
+        let db_path = format!("{}/{}:{}", cfg.host, cfg.port, cfg.database);
 
-        let db_path = format!(
-            "{}/{}:{}",
-            cfg.host,
-            cfg.port,
-            cfg.database
-        );
-
-        info!("Firebird database target: {}", db_path);
-        info!("Backup file: {}", file_path.display());
-
+        logger.log("info", format!("Firebird target: {} → {}", db_path, file_path.display()));
+
+        let start = Instant::now();
         let output = Command::new("gbak")
             .arg("-b")
             .arg("-v")
             .arg("-user").arg(&cfg.username)
             .arg("-password").arg(&cfg.password)
-            .arg(db_path)
+            .arg(&db_path)
             .arg(&file_path)
             .output()
             .with_context(|| format!("Failed to run gbak for {}", cfg.name))?;
+        let duration_ms = start.elapsed().as_millis() as f64;
+        let exit_code = output.status.code().unwrap_or(-1);
+
+        let stderr = String::from_utf8_lossy(&output.stderr).to_string();
+        let stdout = String::from_utf8_lossy(&output.stdout).to_string();
+        let combined_output = if stderr.is_empty() && stdout.is_empty() {
+            None
+        } else {
+            Some(format!("{}{}", stdout, stderr).trim().to_string())
+        };
 
         if !output.status.success() {
-            let stderr = String::from_utf8_lossy(&output.stderr);
-            error!("Firebird backup failed: {}", stderr);
+            logger.log_command("gbak", combined_output, Some(exit_code), Some(duration_ms));
             anyhow::bail!("Firebird backup failed for {}: {}", cfg.name, stderr);
         }
 
-        info!("Firebird backup completed: {}", file_path.display());
-
+        logger.log_command("gbak", combined_output, Some(0), Some(duration_ms));
+        logger.log("info", format!("Firebird backup completed for {}", cfg.name));
         Ok(file_path)
     })
     .await?

src/domain/firebird/database.rs

@@ -1,10 +1,12 @@
 use super::{backup, ping, restore};
 use crate::domain::factory::Database;
+use crate::services::backup::logger::JobLogger;
 use crate::services::config::DatabaseConfig;
 use crate::utils::locks::{DbOpLock, FileLock};
 use anyhow::Result;
 use async_trait::async_trait;
 use std::path::{Path, PathBuf};
+use std::sync::Arc;
 
 pub struct FirebirdDatabase {
     cfg: DatabaseConfig,
@@ -27,12 +29,13 @@ impl Database for FirebirdDatabase {
         ping::run(self.cfg.clone()).await
     }
 
-    async fn backup(&self, dir: &Path) -> Result<PathBuf> {
+    async fn backup(&self, dir: &Path, logger: Arc<JobLogger>) -> Result<PathBuf> {
         FileLock::acquire(&self.cfg.generated_id, DbOpLock::Backup.as_str()).await?;
         let res = backup::run(
             self.cfg.clone(),
             dir.to_path_buf(),
             self.file_extension(),
+            logger,
         )
         .await;
         FileLock::release(&self.cfg.generated_id).await?;

src/domain/mariadb/backup.rs

@@ -1,39 +1,41 @@
 use crate::domain::mariadb::connection::{select_mariadb_path, server_version};
+use crate::services::backup::logger::JobLogger;
 use crate::services::config::DatabaseConfig;
 use anyhow::{Context, Result};
 use std::collections::HashMap;
 use std::path::PathBuf;
 use std::process::Command;
-use tracing::{debug, error, info};
+use std::sync::Arc;
+use std::time::Instant;
 
 pub async fn run(
     cfg: DatabaseConfig,
     backup_dir: PathBuf,
     env: HashMap<String, String>,
     file_extension: &'static str,
+    logger: Arc<JobLogger>,
 ) -> Result<PathBuf> {
     tokio::task::spawn_blocking(move || -> Result<PathBuf> {
-        debug!("Starting backup for database {}", cfg.name);
+        logger.log("debug", format!("Starting backup for database {}", cfg.name));
 
         let version = match futures::executor::block_on(server_version(&cfg)) {
             Ok(v) => {
-                debug!("Mariadb version detected: {}", v);
+                logger.log("debug", format!("MariaDB version detected: {}", v));
                 v
             }
             Err(e) => {
-                error!("Failed to get server version for {}: {:?}", cfg.name, e);
+                logger.log("error", format!("Failed to get server version: {}", e));
                 return Err(e.into());
             }
         };
 
-        info!("Mariadb version found: {}", version);
-
         let file_path = backup_dir.join(format!("{}{}", cfg.generated_id, file_extension));
+        let _mariadb_dump = select_mariadb_path(&version).join("mariadb-dump");
 
-        let mariadb_dump = select_mariadb_path(&version).join("mariadb-dump");
-        info!("Mariadb dump found: {}", mariadb_dump.display());
-
+        logger.log("debug", format!("Using mariadb-dump at {}", _mariadb_dump.display()));
+        logger.log("info", format!("Running mariadb-dump for {}", cfg.name));
 
+        let start = Instant::now();
         let output = Command::new("mariadb-dump")
             .arg("--host").arg(&cfg.host)
             .arg("--port").arg(cfg.port.to_string())
@@ -45,8 +47,9 @@ pub async fn run(
             .arg("--quick")
             .arg("--skip-lock-tables")
             .arg("--no-create-db")
-            .arg("--skip-add-drop-table") 
+            .arg("--skip-add-drop-table")
             .arg("--compress")
+            .arg("--verbose")
             .arg("--max-allowed-packet=512M")
             .arg("--net-buffer-length=16K")
             .arg("--default-character-set=utf8mb4")
@@ -55,12 +58,18 @@ pub async fn run(
             .envs(env)
             .output()
             .with_context(|| format!("Failed to run mariadb-dump for {}", cfg.name))?;
+        let duration_ms = start.elapsed().as_millis() as f64;
+        let exit_code = output.status.code().unwrap_or(-1);
 
         if !output.status.success() {
-            let stderr = String::from_utf8_lossy(&output.stderr);
+            let stderr = String::from_utf8_lossy(&output.stderr).to_string();
+            logger.log_command("mariadb-dump", Some(stderr.clone()), Some(exit_code), Some(duration_ms));
             anyhow::bail!("Mariadb backup failed for {}: {}", cfg.name, stderr);
         }
 
+        let stderr = String::from_utf8_lossy(&output.stderr).to_string();
+        logger.log_command("mariadb-dump", if stderr.is_empty() { None } else { Some(stderr) }, Some(0), Some(duration_ms));
+        logger.log("info", format!("mariadb-dump completed for {}", cfg.name));
         Ok(file_path)
     })
     .await?

src/domain/mariadb/database.rs

@@ -1,11 +1,13 @@
 use super::{backup, ping, restore};
 use crate::domain::factory::Database;
+use crate::services::backup::logger::JobLogger;
 use crate::services::config::DatabaseConfig;
 use crate::utils::locks::{DbOpLock, FileLock};
 use anyhow::Result;
 use async_trait::async_trait;
 use std::collections::HashMap;
 use std::path::{Path, PathBuf};
+use std::sync::Arc;
 
 pub struct MariaDBDatabase {
     cfg: DatabaseConfig,
@@ -33,13 +35,14 @@ impl Database for MariaDBDatabase {
         ping::run(self.cfg.clone(), self.build_env().clone()).await
     }
 
-    async fn backup(&self, dir: &Path) -> Result<PathBuf> {
+    async fn backup(&self, dir: &Path, logger: Arc<JobLogger>) -> Result<PathBuf> {
         FileLock::acquire(&self.cfg.generated_id, DbOpLock::Backup.as_str()).await?;
         let res = backup::run(
             self.cfg.clone(),
             dir.to_path_buf(),
             self.build_env().clone(),
             self.file_extension(),
+            logger,
         )
         .await;
         FileLock::release(&self.cfg.generated_id).await?;