fix: ghcr.yml

fix: postgres-provider

.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:
@@ -99,15 +16,11 @@ env:
 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)
+      - name: Build test image
         run: docker compose -f docker-compose.test.yml build agent-test
 
       - name: Start agent-test container
@@ -115,28 +28,32 @@ jobs:
 
       - name: Run tests inside container
         run: |
-          docker compose -f docker-compose.test.yml exec \
+          docker compose -f docker-compose.test.yml exec -T \
             -e CARGO_TARGET_DIR \
             -e CARGO_INCREMENTAL \
             -e RUSTFLAGS \
             -e LLVM_PROFILE_FILE \
             agent-test bash -c "
-              cargo clean &&
-              cargo test --verbose &&
+              mkdir -p /app/coverage &&
+              rm -rf /app/target/* /app/coverage/* &&
+              cargo test --verbose -- --test-threads=2 &&
               sync
             "
 
       - name: Verify profraw files exist
         run: |
-          docker compose -f docker-compose.test.yml exec \
-            -e LLVM_PROFILE_FILE \
-            agent-test find /app/coverage -type f -name "*.profraw" | wc -l || true
+          docker compose -f docker-compose.test.yml exec -T \
+            agent-test bash -c '
+              count=$(find /app/coverage -type f -name "*.profraw" | wc -l)
+              echo "profraw files: $count"
+              test "$count" -gt 0
+            '
 
       - name: Generate coverage report inside container
         run: |
-          docker compose -f docker-compose.test.yml exec \
+          docker compose -f docker-compose.test.yml exec -T \
             agent-test bash -c "
-              rustup component add llvm-tools &&
+              rustup component add llvm-tools-preview &&
               grcov /app/coverage \
                 --binary-path /app/target/debug \
                 -s /app \
@@ -145,17 +62,17 @@ jobs:
                 --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: Show basic coverage report info (debug)
+      - name: Show basic coverage report info
         run: |
           echo "lcov.info size:" $(wc -c ./lcov.info | awk '{print $1}')
           head -n 30 ./lcov.info || true
+          test -s ./lcov.info
 
       - name: Upload coverage to Codecov
         uses: codecov/codecov-action@v5
@@ -165,8 +82,9 @@ jobs:
           name: rust-unit-coverage
           verbose: true
           fail_ci_if_error: true
-        env:
-          CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}
+          token: ${{ secrets.CODECOV_TOKEN }}
+          use_pypi: true
 
       - name: Stop and remove container
-        run: docker compose -f docker-compose.test.yml down
+        if: always()
+        run: docker compose -f docker-compose.test.yml down --volumes

.github/workflows/ghcr.yml

@@ -0,0 +1,134 @@
+name: GHCR Publish
+
+on:
+  workflow_call:
+    inputs:
+      version:
+        required: true
+        type: string
+      ref:
+        required: true
+        type: string
+      add_latest:
+        required: false
+        type: boolean
+        default: false
+      dockerfile:
+        required: false
+        type: string
+        default: "./docker/Dockerfile"
+      target:
+        required: false
+        type: string
+        default: "prod"
+
+permissions:
+  contents: read
+  packages: write
+
+jobs:
+  build:
+    name: Build ${{ matrix.platform }}
+    runs-on: ${{ matrix.platform == 'linux/amd64' && 'ubuntu-latest' || 'ubuntu-24.04-arm' }}
+    strategy:
+      fail-fast: false
+      matrix:
+        platform: [ linux/amd64, linux/arm64 ]
+    steps:
+      - name: Prepare vars
+        id: prep
+        run: |
+          ARCH="${{ matrix.platform == 'linux/amd64' && 'amd64' || 'arm64' }}"
+          echo "arch=$ARCH" >> "$GITHUB_OUTPUT"
+          echo "image=ghcr.io/${GITHUB_REPOSITORY_OWNER,,}/agent" >> "$GITHUB_OUTPUT"
+
+      - name: Checkout
+        uses: actions/checkout@v4
+        with:
+          ref: ${{ inputs.ref }}
+          fetch-depth: 1
+
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v3
+
+      - name: Log in to GHCR
+        uses: docker/login-action@v3
+        with:
+          registry: ghcr.io
+          username: ${{ github.actor }}
+          password: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Build and push by digest
+        id: build
+        uses: docker/build-push-action@v6
+        with:
+          context: .
+          file: ${{ inputs.dockerfile }}
+          platforms: ${{ matrix.platform }}
+          target: ${{ inputs.target }}
+          provenance: false
+          outputs: type=image,name=${{ steps.prep.outputs.image }},push-by-digest=true,name-canonical=true,push=true
+          cache-from: type=gha,scope=ghcr-${{ steps.prep.outputs.arch }}
+          cache-to: type=gha,mode=max,scope=ghcr-${{ steps.prep.outputs.arch }},ignore-error=true
+
+      - name: Export digest
+        env:
+          DIGEST: ${{ steps.build.outputs.digest }}
+        run: |
+          mkdir -p /tmp/digests
+          touch "/tmp/digests/${DIGEST#sha256:}"
+
+      - name: Upload digest
+        uses: actions/upload-artifact@v4
+        with:
+          name: digest-${{ steps.prep.outputs.arch }}
+          path: /tmp/digests/*
+          if-no-files-found: error
+          retention-days: 1
+
+  merge:
+    name: Create multi-arch manifest
+    runs-on: ubuntu-latest
+    needs: build
+    steps:
+      - name: Prepare vars
+        id: prep
+        run: echo "image=ghcr.io/${GITHUB_REPOSITORY_OWNER,,}/agent" >> "$GITHUB_OUTPUT"
+
+      - name: Download digests
+        uses: actions/download-artifact@v4
+        with:
+          path: /tmp/digests
+          pattern: digest-*
+          merge-multiple: true
+
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v3
+
+      - name: Log in to GHCR
+        uses: docker/login-action@v3
+        with:
+          registry: ghcr.io
+          username: ${{ github.actor }}
+          password: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Extract Docker metadata
+        id: meta
+        uses: docker/metadata-action@v5
+        with:
+          images: ${{ steps.prep.outputs.image }}
+          tags: |
+            type=semver,pattern={{version}},value=${{ inputs.version }}
+            type=semver,pattern={{major}}.{{minor}},value=${{ inputs.version }}
+            type=semver,pattern={{major}},value=${{ inputs.version }}
+            type=raw,value=latest,enable=${{ inputs.add_latest }}
+
+      - name: Create and push manifest list
+        working-directory: /tmp/digests
+        run: |
+          docker buildx imagetools create \
+            $(jq -cr '.tags | map("-t " + .) | join(" ")' <<< "$DOCKER_METADATA_OUTPUT_JSON") \
+            $(printf '${{ steps.prep.outputs.image }}@sha256:%s ' *)
+
+      - name: Inspect
+        run: docker buildx imagetools inspect ${{ steps.prep.outputs.image }}:${{ inputs.version }}

.github/workflows/release.yml

@@ -100,6 +100,15 @@ jobs:
       DOCKER_USERNAME: ${{ secrets.DOCKER_USERNAME }}
       DOCKER_PASSWORD: ${{ secrets.DOCKER_PASSWORD }}
 
+  publish-docker-ghcr:
+    needs: create-release
+    if: ${{ needs.create-release.result == 'success' }}
+    uses: ./.github/workflows/ghcr.yml
+    with:
+      version: ${{ needs.create-release.outputs.version }}
+      ref: ${{ needs.create-release.outputs.version }}
+      add_latest: true
+
   publish-helm:
     needs: create-release
     if: ${{ needs.create-release.result == 'success' }}

.github/workflows/windows-release.yml

@@ -0,0 +1,96 @@
+name: Build Windows release
+
+
+on:
+  workflow_dispatch:
+  push:
+    tags:
+      - '[0-9]+.[0-9]+.[0-9]+'
+    branches:
+      - main
+      - master
+
+jobs:
+  build-windows:
+    runs-on: windows-latest
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      - name: Set up Rust toolchain (MSVC)
+        uses: actions-rs/toolchain@v1
+        with:
+          toolchain: stable-x86_64-pc-windows-msvc
+          profile: minimal
+          override: true
+
+      - name: Install vcpkg and OpenSSL (x64)
+        shell: pwsh
+        run: |
+          # Install vcpkg and the prebuilt OpenSSL package
+          git clone https://github.com/microsoft/vcpkg C:\vcpkg
+          C:\vcpkg\bootstrap-vcpkg.bat
+          C:\vcpkg\vcpkg install openssl:x64-windows
+          # Export variables for subsequent steps
+          'VCPKG_ROOT=C:\vcpkg' | Out-File -FilePath $env:GITHUB_ENV -Encoding utf8 -Append
+          'OPENSSL_DIR=C:\vcpkg\installed\x64-windows' | Out-File -FilePath $env:GITHUB_ENV -Encoding utf8 -Append
+
+      - name: Build (cargo release)
+        shell: pwsh
+        env:
+          # Cargo / openssl-sys will pick up OPENSSL_DIR from the environment
+          OPENSSL_DIR: ${{ env.OPENSSL_DIR }}
+        run: |
+          # Ensure the environment variable is present for this step
+          if (-Not $env:OPENSSL_DIR) { Write-Host "OPENSSL_DIR not set, printing env for debugging"; Get-ChildItem Env: | ForEach-Object { Write-Host $_ } }
+          # Build the declared bin target explicitly (Cargo.toml [[bin]] name = "app")
+          cargo build --release --bin app
+
+      - name: Prepare artifact zip
+        id: prepare_artifact
+        shell: pwsh
+        env:
+          RELEASE_TAG: ${{ github.ref_name }}
+        run: |
+          $tag = $env:RELEASE_TAG
+          if (-not $tag) { $tag = $env:GITHUB_SHA }
+
+          # Package the declared bin target deterministically (Cargo.toml [[bin]] name = "app")
+          $exe = "target\release\app.exe"
+          if (-not (Test-Path $exe)) { Write-Error "Built binary $exe not found in target/release"; exit 1 }
+
+          $outDir = "artifact"
+          New-Item -ItemType Directory -Path $outDir -Force | Out-Null
+          # Ship under the package name, not the internal bin name "app"
+          Copy-Item -Path $exe -Destination "$outDir\portabase-agent.exe"
+
+          $zipName = "windows-release-$tag.zip"
+          if (Test-Path $zipName) { Remove-Item $zipName }
+          Compress-Archive -Path "$outDir\*" -DestinationPath $zipName -Force
+          Write-Host "ZIP=$zipName"
+          Write-Output "zip=$zipName" | Out-File -FilePath $env:GITHUB_OUTPUT -Encoding utf8 -Append
+
+      - name: Upload build artifact
+        uses: actions/upload-artifact@v4
+        with:
+          name: windows-release
+          path: windows-release-*.zip
+
+      - name: Create GitHub Release
+        if: startsWith(github.ref, 'refs/tags/')
+        id: create_release
+        uses: softprops/action-gh-release@v1
+        with:
+          tag_name: ${{ github.ref_name }}
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Upload release asset
+        if: startsWith(github.ref, 'refs/tags/')
+        uses: actions/upload-release-asset@v1
+        with:
+          upload_url: ${{ steps.create_release.outputs.upload_url }}
+          asset_path: windows-release-${{ github.ref_name }}.zip
+          asset_name: windows-release-${{ github.ref_name }}.zip
+          asset_content_type: application/zip

.gitignore

@@ -6,4 +6,5 @@
 .env
 
 .claude
-/docs
+
+/docs

CITATION.cff

@@ -27,5 +27,5 @@ keywords:
   - self-hosted
   - portabase
 license: Apache-2.0
-version: 1.11.0
+version: 1.17.1
 date-released: '2026-02-24'

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "portabase-agent"
-version = "1.11.0"
+version = "1.17.1"
 edition = "2024"
 
 [dependencies]
@@ -35,10 +35,14 @@ rand = "0.9.2"
 bytes = "1.11.0"
 async-stream = "0.3.6"
 uuid = { version = "1.20.0", features = ["v4"] }
-tokio-util = { version = "0.7.18", features = ["compat"] }
+tokio-util = { version = "0.7.18", features = ["compat", "io"] }
 tiberius = { version = "0.12", default-features = false, features = ["rustls", "chrono"] }
 aws-config = "1.8.13"
 aws-sdk-s3 = { version = "1.122.0", features = ["behavior-version-latest"] }
+azure_core = "1.0.0"
+azure_storage_blob = "1.0.0"
+google-cloud-storage = "1.15"
+google-cloud-auth = "1.13"
 async-compression = { version = "0.4.37", features = ["tokio", "gzip"] }
 tokio-tar = "0.3.1"
 oauth2 = "5.0.0"
@@ -53,6 +57,7 @@ testcontainers = "0.27.1"
 testcontainers-modules = { version = "0.15.0", features = ["postgres", "redis", "valkey", "mysql", "mariadb", "mongo"] }
 postgres = "0.19.12"
 url = "2.5.8"
+bollard = "0.20.0"
 
 [dev-dependencies]
 tokio = { version = "1", features = ["full"] }

databases.json

@@ -10,6 +10,19 @@
       "host": "db-postgres",
       "generated_id": "16678159-ff7e-4c97-8c83-0adeff214681"
     },
+    {
+      "name": "Test database 1 - PostgreSQL - BIS",
+      "database": "devdb2",
+      "type": "postgresql",
+      "username": "devuser2",
+      "password": "changeme2",
+      "port": 5432,
+      "host": "db-postgres-2",
+      "generated_id": "16678159-ff7e-5697-8c83-0adeff214681",
+      "options": {
+        "keep_ownership": true
+      }
+    },
     {
       "name": "Test database 2 - MariaDB",
       "database": "mariadb",
@@ -103,7 +116,7 @@
       "generated_id": "16706124-ff7e-4c97-8c83-0adeff214681"
     },
     {
-      "name": "Test database 13 - MysSQL",
+      "name": "Test database 13 - MsSQL",
       "database": "myappdb",
       "type": "mssql",
       "username": "sa",
@@ -111,6 +124,13 @@
       "port": 1433,
       "host": "db-mssql",
       "generated_id": "16706125-ff7e-4c97-8c83-0adeff214682"
+    },
+    {
+      "name": "Test database 14 - Docker Volume",
+      "type": "docker-volume",
+      "volume_name": "databases_sqlite-data",
+      "generated_id": "16706126-ff7e-4c97-8c83-0adeff214690",
+      "container_name": "db-sqlite"
     }
   ]
 }

docker-compose.databases.yml

@@ -15,6 +15,20 @@ services:
     networks:
       - portabase
 
+  db-postgres-2:
+    container_name: db-postgres-2
+    image: postgres:17-alpine
+    ports:
+      - "5438:5432"
+    volumes:
+      - postgres-data-2:/var/lib/postgresql/data
+    environment:
+      - POSTGRES_DB=devdb2
+      - POSTGRES_USER=devuser2
+      - POSTGRES_PASSWORD=changeme2
+    networks:
+      - portabase
+
   db-mariadb:
     container_name: db-mariadb
     image: mariadb:latest
@@ -179,6 +193,7 @@ services:
 
 volumes:
   postgres-data:
+  postgres-data-2:
   mariadb-data:
   mysql-data:
   mongodb-data:

docker-compose.yml

@@ -11,15 +11,17 @@ services:
       - cargo-git:/usr/local/cargo/git
       - ./databases.json:/config/config.json
       #- ./databases.toml:/config/config.toml
-      #- /var/run/docker.sock:/var/run/docker.sock
-      #- cargo-target:/app/target
+      - /var/run/docker.sock:/var/run/docker.sock
+#      - cargo-target:/app/target
       - databases_sqlite-data:/sqlite-data/workspace/data
       - ./scripts/sqlite/test-db:/sqlite-data-2/workspace/data
+#      - /bigdisk:/scratch
     environment:
       APP_ENV: development
       LOG: debug
       TZ: "Europe/Paris"
-      EDGE_KEY: "eyJzZXJ2ZXJVcmwiOiJodHRwOi8vbG9jYWxob3N0Ojg4ODciLCJhZ2VudElkIjoiOTFlYmY4MmYtY2I4OC00N2M3LWE5MWUtMDUyMmU2NzNjZjE4IiwibWFzdGVyS2V5QjY0IjoiQlhWM1hvbEM2NTZTVjdkTmdjV1BHUWxrKytycExJNmxHRGk3Q1BCNWllbz0ifQ=="
+#      TMPDIR: /scratch
+      EDGE_KEY: "eyJzZXJ2ZXJVcmwiOiJodHRwOi8vbG9jYWxob3N0Ojg4ODciLCJhZ2VudElkIjoiNmM4NWE3ODQtODRkMi00YzUyLTgzYmUtZTc2MDZkZjg2YjM5IiwibWFzdGVyS2V5QjY0IjoiMUh0djdtWCtYVkJxL0IzUEV2WDlZZjlQeUdVZW5oRHlXemo5THRqNW90WT0ifQ=="
       #CHUNK_SIZE_MB: "1"
       #POOLING: 1
       #DATABASES_CONFIG_FILE: "config.toml"
@@ -27,11 +29,16 @@ services:
       - "localhost:host-gateway"
     networks:
       - portabase
+    cpus: "1.50"
+    mem_limit: 4g
+    memswap_limit: 4g
+    pids_limit: 512
+
 
 volumes:
   cargo-registry:
   cargo-git:
-  #cargo-target:
+#  cargo-target:
   databases_sqlite-data:
     external: true
 

docker/Dockerfile

@@ -1,3 +1,11 @@
+# =========================
+# MySQL client tools
+# =========================
+FROM mysql:8.4 AS mysql-client-tools
+RUN mkdir -p /mysql-exports/bin /mysql-exports/lib \
+    && cp /usr/bin/mysqldump /mysql-exports/bin/ \
+    && find /usr/lib -name "libmysqlclient.so.21*" -exec cp {} /mysql-exports/lib/ \;
+
 # =========================
 # Base image (shared)
 # =========================
@@ -68,6 +76,13 @@ RUN if [ "$TARGETARCH" = "amd64" ]; then \
 COPY assets/tools/${TARGETARCH}/mongodb/ /usr/local/mongodb/
 RUN chmod +x /usr/local/mongodb/bin/*
 
+# =========================
+# MySQL real mysqldump binary
+# =========================
+COPY --from=mysql-client-tools /mysql-exports/bin/mysqldump /usr/local/bin/mysqldump
+COPY --from=mysql-client-tools /mysql-exports/lib/ /usr/local/lib/
+RUN chmod +x /usr/local/bin/mysqldump && ldconfig
+
 WORKDIR /app
 
 # =========================
@@ -116,6 +131,7 @@ RUN apt-get update && apt-get install -y \
     sqlite3 \
     redis-tools \
     valkey \
+    firebird3.0-utils \
     && rm -rf /var/lib/apt/lists/*
 
 ENV DOTNET_ROOT=/usr/local/dotnet
@@ -134,6 +150,9 @@ RUN chmod +x /entrypoint.sh
 COPY --from=base /usr/lib/postgresql/ /usr/lib/postgresql/
 COPY --from=base /usr/local/mongodb/bin/ /usr/local/mongodb/bin/
 COPY --from=base /root/.dotnet/tools/ /root/.dotnet/tools/
+COPY --from=mysql-client-tools /mysql-exports/bin/mysqldump /usr/local/bin/mysqldump
+COPY --from=mysql-client-tools /mysql-exports/lib/ /usr/local/lib/
+RUN chmod +x /usr/local/bin/mysqldump && ldconfig
 
 ENV PATH="$PATH:/usr/local/dotnet:/root/.dotnet/tools"
 ENV APP_ENV=production

justfile

@@ -58,4 +58,14 @@ 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"
+    echo "Down volumes tests databases"
+    docker compose -f docker-compose.test.yml down --volumes

src/domain/docker_volume/backup.rs

@@ -0,0 +1,68 @@
+use crate::domain::docker_volume::docker::{
+    client, create_helper, remove_helper, resolve_helper_image, start_container, stop_container,
+};
+use crate::services::backup::logger::JobLogger;
+use crate::services::config::DatabaseConfig;
+use anyhow::{Context, Result};
+use bollard::query_parameters::DownloadFromContainerOptions;
+use futures_util::StreamExt;
+use std::path::PathBuf;
+use std::sync::Arc;
+use std::time::Instant;
+use tokio::fs::File;
+use tokio::io::AsyncWriteExt;
+
+pub async fn run(cfg: DatabaseConfig, backup_dir: PathBuf, logger: Arc<JobLogger>) -> Result<PathBuf> {
+    tokio::task::spawn_blocking(move || -> Result<PathBuf> {
+        futures::executor::block_on(async move {
+            logger.log("info", format!("Starting docker-volume backup for {}", cfg.name));
+
+            let docker = client()?;
+            let image = resolve_helper_image(&docker).await?;
+            logger.log("debug", format!("Helper image: {image}"));
+
+            if let Some(name) = &cfg.container_name {
+                logger.log("info", format!("Stopping container {name} for consistent backup"));
+                stop_container(&docker, name).await?;
+            }
+
+            let result = async {
+                let helper = create_helper(&docker, &image, &cfg.volume_name, &cfg.generated_id, true, None).await?;
+
+                let file_path = backup_dir.join(format!("{}.tar", cfg.generated_id));
+                let start = Instant::now();
+
+                let dl_opts = DownloadFromContainerOptions { path: "/vol".to_string() };
+                let mut stream = docker.download_from_container(&helper.id, Some(dl_opts));
+
+                let mut out = File::create(&file_path)
+                    .await
+                    .with_context(|| format!("Failed to create backup file {}", file_path.display()))?;
+                let mut bytes_written: u64 = 0;
+                while let Some(chunk) = stream.next().await {
+                    let chunk = chunk.context("Error streaming volume archive from Docker")?;
+                    bytes_written += chunk.len() as u64;
+                    out.write_all(&chunk).await?;
+                }
+                out.flush().await?;
+
+                let duration_ms = start.elapsed().as_millis() as f64;
+                logger.log_command("docker download_from_container", None, Some(0), Some(duration_ms));
+                logger.log("info", format!("Volume backup wrote {bytes_written} bytes to {}", file_path.display()));
+
+                remove_helper(&docker, &helper.id).await;
+                anyhow::Ok(file_path)
+            }
+            .await;
+
+            if let Some(name) = &cfg.container_name {
+                if let Err(e) = start_container(&docker, name).await {
+                    logger.log("error", format!("Failed to restart container {name}: {e}"));
+                }
+            }
+
+            result
+        })
+    })
+    .await?
+}

src/domain/docker_volume/database.rs

@@ -0,0 +1,45 @@
+use anyhow::Result;
+use async_trait::async_trait;
+use std::path::{Path, PathBuf};
+use std::sync::Arc;
+
+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};
+
+pub struct DockerVolumeDatabase {
+    cfg: DatabaseConfig,
+}
+
+impl DockerVolumeDatabase {
+    pub fn new(cfg: DatabaseConfig) -> Self {
+        Self { cfg }
+    }
+}
+
+#[async_trait]
+impl Database for DockerVolumeDatabase {
+    fn file_extension(&self) -> &'static str {
+        ".tar"
+    }
+
+    async fn ping(&self) -> Result<bool> {
+        ping::run(self.cfg.clone()).await
+    }
+
+    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(), logger).await;
+        FileLock::release(&self.cfg.generated_id).await?;
+        res
+    }
+
+    async fn restore(&self, file: &Path, logger: Arc<JobLogger>) -> Result<()> {
+        FileLock::acquire(&self.cfg.generated_id, DbOpLock::Restore.as_str()).await?;
+        let res = restore::run(self.cfg.clone(), file.to_path_buf(), logger).await;
+        FileLock::release(&self.cfg.generated_id).await?;
+        res
+    }
+}

src/domain/docker_volume/docker.rs

@@ -0,0 +1,169 @@
+#![allow(dead_code)]
+
+use anyhow::{Context, Result};
+use bollard::Docker;
+use bollard::models::{ContainerCreateBody, HostConfig};
+use bollard::query_parameters::{
+    CreateContainerOptions, InspectContainerOptions, ListContainersOptions,
+    RemoveContainerOptions, StartContainerOptions, StopContainerOptions,
+};
+use std::collections::HashMap;
+use tracing::{info, warn};
+use uuid::Uuid;
+
+pub const EPHEMERAL_LABEL: &str = "io.portabase.ephemeral";
+const HELPER_MOUNT: &str = "/vol";
+
+pub fn client() -> Result<Docker> {
+    Docker::connect_with_unix_defaults().context("Failed to connect to Docker daemon socket")
+}
+
+pub fn parse_container_id(mountinfo: &str, cgroup: &str) -> Option<String> {
+    for src in [mountinfo, cgroup] {
+        for line in src.lines() {
+            for marker in ["/containers/", "/docker/"] {
+                if let Some(idx) = line.find(marker) {
+                    let rest = &line[idx + marker.len()..];
+                    let id: String = rest.chars().take_while(|c| c.is_ascii_hexdigit()).collect();
+                    if id.len() >= 64 {
+                        return Some(id[..64].to_string());
+                    }
+                }
+            }
+        }
+    }
+    None
+}
+
+pub async fn resolve_helper_image(docker: &Docker) -> Result<String> {
+    if let Ok(img) = std::env::var("PORTABASE_HELPER_IMAGE") {
+        if !img.trim().is_empty() {
+            return Ok(img);
+        }
+    }
+    let mountinfo = std::fs::read_to_string("/proc/self/mountinfo").unwrap_or_default();
+    let cgroup = std::fs::read_to_string("/proc/self/cgroup").unwrap_or_default();
+    let id = parse_container_id(&mountinfo, &cgroup).context(
+        "Could not determine own container id; set PORTABASE_HELPER_IMAGE to a locally-present image",
+    )?;
+    let info = docker
+        .inspect_container(&id, None::<InspectContainerOptions>)
+        .await
+        .with_context(|| format!("Failed to inspect self container {id}"))?;
+    info.image
+        .context("Self container inspection returned no image reference")
+}
+
+pub struct Helper {
+    pub id: String,
+}
+
+pub async fn create_helper(
+    docker: &Docker,
+    image: &str,
+    volume_name: &str,
+    generated_id: &str,
+    read_only: bool,
+    cmd: Option<Vec<String>>,
+) -> Result<Helper> {
+    let bind = format!(
+        "{volume_name}:{HELPER_MOUNT}{}",
+        if read_only { ":ro" } else { "" }
+    );
+    let mut labels = HashMap::new();
+    labels.insert(EPHEMERAL_LABEL.to_string(), "true".to_string());
+    labels.insert("com.docker.compose.project".to_string(), String::new());
+    labels.insert("com.docker.compose.service".to_string(), String::new());
+    labels.insert("com.docker.compose.oneoff".to_string(), String::new());
+
+    let name = format!(
+        "portabase-vol-{generated_id}-{}",
+        &Uuid::new_v4().to_string()[..8]
+    );
+
+    let body = ContainerCreateBody {
+        image: Some(image.to_string()),
+        cmd,
+        labels: Some(labels),
+        host_config: Some(HostConfig {
+            binds: Some(vec![bind]),
+            auto_remove: Some(false),
+            ..Default::default()
+        }),
+        ..Default::default()
+    };
+
+    let opts = CreateContainerOptions {
+        name: Some(name),
+        ..Default::default()
+    };
+
+    let res = docker
+        .create_container(Some(opts), body)
+        .await
+        .with_context(|| format!("Failed to create helper container for volume {volume_name}"))?;
+
+    Ok(Helper { id: res.id })
+}
+
+
+pub async fn remove_helper(docker: &Docker, id: &str) {
+    let stop_opts = StopContainerOptions {
+        t: Some(2),
+        ..Default::default()
+    };
+    let _ = docker.stop_container(id, Some(stop_opts)).await;
+
+    if let Ok(info) = docker
+        .inspect_container(id, None::<InspectContainerOptions>)
+        .await
+    {
+        let name = info.name.unwrap_or_default();
+        let name = name.trim_start_matches('/');
+        let code = info.state.and_then(|s| s.exit_code).unwrap_or_default();
+        info!("Helper container {name} exited with code {code}");
+    }
+
+    let opts = RemoveContainerOptions {
+        force: true,
+        ..Default::default()
+    };
+    if let Err(e) = docker.remove_container(id, Some(opts)).await {
+        warn!("Failed to remove helper container {id}: {e}");
+    }
+}
+
+pub async fn stop_container(docker: &Docker, name: &str) -> Result<()> {
+    docker
+        .stop_container(name, None::<StopContainerOptions>)
+        .await
+        .with_context(|| format!("Failed to stop container {name}"))
+}
+
+pub async fn start_container(docker: &Docker, name: &str) -> Result<()> {
+    docker
+        .start_container(name, None::<StartContainerOptions>)
+        .await
+        .with_context(|| format!("Failed to start container {name}"))
+}
+
+pub async fn sweep_ephemeral(docker: &Docker) -> Result<usize> {
+    let mut filters = HashMap::new();
+    filters.insert("label".to_string(), vec![format!("{EPHEMERAL_LABEL}=true")]);
+
+    let opts = ListContainersOptions {
+        all: true,
+        filters: Some(filters),
+        ..Default::default()
+    };
+
+    let list = docker.list_containers(Some(opts)).await?;
+    let mut removed = 0;
+    for c in list {
+        if let Some(id) = c.id {
+            remove_helper(docker, &id).await;
+            removed += 1;
+        }
+    }
+    Ok(removed)
+}

src/domain/docker_volume/mod.rs

@@ -0,0 +1,5 @@
+pub mod backup;
+pub mod database;
+pub mod docker;
+pub mod ping;
+pub mod restore;

src/domain/docker_volume/ping.rs

@@ -0,0 +1,12 @@
+use crate::domain::docker_volume::docker::client;
+use crate::services::config::DatabaseConfig;
+use anyhow::Result;
+
+pub async fn run(cfg: DatabaseConfig) -> Result<bool> {
+    let docker = client()?;
+    match docker.inspect_volume(&cfg.volume_name).await {
+        Ok(_) => Ok(true),
+        Err(bollard::errors::Error::DockerResponseServerError { status_code: 404, .. }) => Ok(false),
+        Err(e) => Err(e.into()),
+    }
+}

src/domain/docker_volume/restore.rs

@@ -0,0 +1,102 @@
+use crate::domain::docker_volume::docker::{
+    client, create_helper, remove_helper, resolve_helper_image, start_container, stop_container,
+};
+use crate::services::backup::logger::JobLogger;
+use crate::services::config::DatabaseConfig;
+use anyhow::{Context, Result};
+use bollard::exec::StartExecResults;
+use bollard::models::ExecConfig;
+use bollard::query_parameters::UploadToContainerOptions;
+use futures_util::StreamExt;
+use std::path::PathBuf;
+use std::sync::Arc;
+use std::time::Instant;
+
+pub async fn run(cfg: DatabaseConfig, archive: PathBuf, logger: Arc<JobLogger>) -> Result<()> {
+    tokio::task::spawn_blocking(move || -> Result<()> {
+        futures::executor::block_on(async move {
+            logger.log("info", format!("Starting docker-volume restore for {}", cfg.name));
+
+            let docker = client()?;
+            let image = resolve_helper_image(&docker).await?;
+
+            logger.log("debug", format!("Restore archive: {}", archive.display()));
+
+            if let Some(name) = &cfg.container_name {
+                logger.log("info", format!("Stopping container {name} for restore"));
+                stop_container(&docker, name).await?;
+            }
+
+            let result = async {
+                let helper = create_helper(
+                    &docker,
+                    &image,
+                    &cfg.volume_name,
+                    &cfg.generated_id,
+                    false,
+                    Some(vec![
+                        "sh".into(),
+                        "-c".into(),
+                        "trap 'exit 0' TERM; sleep 2147483647 & wait".into(),
+                    ]),
+                )
+                .await?;
+                start_container(&docker, &helper.id).await?;
+
+
+                let exec = docker
+                    .create_exec(
+                        &helper.id,
+                        ExecConfig {
+                            cmd: Some(vec![
+                                "sh".to_string(),
+                                "-c".to_string(),
+                                "rm -rf /vol/* /vol/.[!.]* 2>/dev/null || true".to_string(),
+                            ]),
+                            attach_stdout: Some(true),
+                            attach_stderr: Some(true),
+                            ..Default::default()
+                        },
+                    )
+                    .await
+                    .context("Failed to create wipe exec")?;
+
+                if let StartExecResults::Attached { mut output, .. } =
+                    docker.start_exec(&exec.id, None).await.context("Failed to run wipe exec")?
+                {
+                    while output.next().await.is_some() {}
+                }
+
+                let start = Instant::now();
+
+                let file = tokio::fs::File::open(&archive)
+                    .await
+                    .with_context(|| format!("Failed to open {}", archive.display()))?;
+                let stream = tokio_util::io::ReaderStream::new(file);
+
+                let up_opts = UploadToContainerOptions { path: "/".to_string(), ..Default::default() };
+                docker
+                    .upload_to_container(&helper.id, Some(up_opts), bollard::body_try_stream(stream))
+                    .await
+                    .context("Failed to upload volume archive")?;
+
+                let duration_ms = start.elapsed().as_millis() as f64;
+                logger.log_command("docker upload_to_container", None, Some(0), Some(duration_ms));
+
+                remove_helper(&docker, &helper.id).await;
+                logger.log("info", format!("Volume restore completed for {}", cfg.name));
+                anyhow::Ok(())
+            }
+            .await;
+
+            if let Some(name) = &cfg.container_name {
+                if let Err(e) = start_container(&docker, name).await {
+                    logger.log("error", format!("Failed to restart container {name}: {e}"));
+                }
+            }
+
+            result
+        })
+    })
+    .await?
+}

src/domain/factory.rs

@@ -1,24 +1,27 @@
+use crate::domain::docker_volume::database::DockerVolumeDatabase;
 use crate::domain::mongodb::database::MongoDatabase;
 use crate::domain::mysql::database::MySQLDatabase;
+use crate::domain::postgres::cluster::database::PostgresClusterDatabase;
 use crate::domain::postgres::database::PostgresDatabase;
 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 restore(&self, restore_file: &Path) -> Result<()>;
+    async fn backup(&self, backup_dir: &Path, logger: Arc<JobLogger>) -> Result<PathBuf>;
+    async fn restore(&self, restore_file: &Path, logger: Arc<JobLogger>) -> Result<()>;
 }
 
 pub struct DatabaseFactory;
@@ -30,6 +33,7 @@ impl DatabaseFactory {
                 let format = detect_format_from_size(&cfg).await;
                 Arc::new(PostgresDatabase::new(cfg, format))
             }
+            DbType::PostgresqlCluster => Arc::new(PostgresClusterDatabase::new(cfg)),
             DbType::Mysql => Arc::new(MySQLDatabase::new(cfg)),
             DbType::Mariadb => Arc::new(MariaDBDatabase::new(cfg)),
             DbType::MongoDB => Arc::new(MongoDatabase::new(cfg)),
@@ -38,6 +42,7 @@ impl DatabaseFactory {
             DbType::Valkey => Arc::new(ValkeyDatabase::new(cfg)),
             DbType::Firebird => Arc::new(FirebirdDatabase::new(cfg)),
             DbType::Mssql => Arc::new(MssqlDatabase::new(cfg)),
+            DbType::DockerVolume => Arc::new(DockerVolumeDatabase::new(cfg)),
         }
     }
 
@@ -47,6 +52,7 @@ impl DatabaseFactory {
                 let format = detect_format_from_file(restore_file);
                 Arc::new(PostgresDatabase::new(cfg, format))
             }
+            DbType::PostgresqlCluster => Arc::new(PostgresClusterDatabase::new(cfg)),
             DbType::Mysql => Arc::new(MySQLDatabase::new(cfg)),
             DbType::Mariadb => Arc::new(MariaDBDatabase::new(cfg)),
             DbType::MongoDB => Arc::new(MongoDatabase::new(cfg)),
@@ -55,6 +61,7 @@ impl DatabaseFactory {
             DbType::Valkey => Arc::new(ValkeyDatabase::new(cfg)),
             DbType::Firebird => Arc::new(FirebirdDatabase::new(cfg)),
             DbType::Mssql => Arc::new(MssqlDatabase::new(cfg)),
+            DbType::DockerVolume => Arc::new(DockerVolumeDatabase::new(cfg)),
         }
     }
 }

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("info", 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,21 +29,22 @@ 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?;
         res
     }
 
-    async fn restore(&self, file: &Path) -> Result<()> {
+    async fn restore(&self, file: &Path, logger: Arc<JobLogger>) -> Result<()> {
         FileLock::acquire(&self.cfg.generated_id, DbOpLock::Restore.as_str()).await?;
-        let res = restore::run(self.cfg.clone(), file.to_path_buf()).await;
+        let res = restore::run(self.cfg.clone(), file.to_path_buf(), logger).await;
         FileLock::release(&self.cfg.generated_id).await?;
         res
     }

src/domain/firebird/restore.rs

@@ -1,18 +1,21 @@
+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, restore_file: PathBuf) -> Result<()> {
+pub async fn run(cfg: DatabaseConfig, restore_file: PathBuf, logger: Arc<JobLogger>) -> Result<()> {
     tokio::task::spawn_blocking(move || -> Result<()> {
-        debug!("Starting Firebird restore for database {}", cfg.name);
+        logger.log("debug", format!("Starting Firebird restore for database {}", cfg.name));
 
         let db_path = format!("{}/{}:{}", cfg.host, cfg.port, cfg.database);
 
-        info!("Restore source: {}", restore_file.display());
-        info!("Restore target: {}", db_path);
+        logger.log("info", format!("Restore source: {}", restore_file.display()));
+        logger.log("info", format!("Restore target: {}", db_path));
 
+        let start = Instant::now();
         let output = Command::new("gbak")
             .arg("-c")
             .arg("-v")
@@ -26,13 +29,18 @@ pub async fn run(cfg: DatabaseConfig, restore_file: PathBuf) -> Result<()> {
             .output()
             .with_context(|| format!("Failed to run gbak restore 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();
+
         if !output.status.success() {
-            let stderr = String::from_utf8_lossy(&output.stderr);
-            error!("Firebird restore failed for {}: {}", cfg.name, stderr);
+            logger.log_command("gbak", Some(stderr.clone()), Some(exit_code), Some(duration_ms));
+            logger.log("error", format!("Firebird restore failed for {}: {}", cfg.name, stderr));
             anyhow::bail!("Firebird restore failed for {}: {}", cfg.name, stderr);
         }
 
-        info!("Firebird restore completed for {}", cfg.name);
+        logger.log_command("gbak", if stderr.is_empty() { None } else { Some(stderr) }, Some(0), Some(duration_ms));
+        logger.log("info", format!("Firebird restore completed for {}", cfg.name));
 
         Ok(())
     })

src/domain/mariadb/backup.rs

@@ -1,39 +1,46 @@
 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("info", 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("info", 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()));
 
+        if let Ok(out) = Command::new("mariadb-dump").arg("--version").output() {
+            logger.log("debug", format!("mariadb-dump client: {}", String::from_utf8_lossy(&out.stdout).trim()));
+        }
 
+        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,9 +52,10 @@ 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("--max-allowed-packet=512M")
+            .arg("--verbose")
+            .arg(format!("--max-allowed-packet={}", cfg.max_packet_size))
             .arg("--net-buffer-length=16K")
             .arg("--default-character-set=utf8mb4")
             .arg(&cfg.database)
@@ -55,12 +63,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,22 +35,23 @@ 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?;
         res
     }
 
-    async fn restore(&self, file: &Path) -> Result<()> {
+    async fn restore(&self, file: &Path, logger: Arc<JobLogger>) -> Result<()> {
         FileLock::acquire(&self.cfg.generated_id, DbOpLock::Restore.as_str()).await?;
-        let res = restore::run(self.cfg.clone(), file.to_path_buf()).await;
+        let res = restore::run(self.cfg.clone(), file.to_path_buf(), logger).await;
         FileLock::release(&self.cfg.generated_id).await?;
         res
     }

src/domain/mariadb/restore.rs

@@ -1,27 +1,26 @@
+use crate::services::backup::logger::JobLogger;
 use crate::services::config::DatabaseConfig;
 use anyhow::{Context, Result};
 use std::fs::File;
-use std::io::{Read, Write};
 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, restore_file: PathBuf) -> Result<()> {
+pub async fn run(cfg: DatabaseConfig, restore_file: PathBuf, logger: Arc<JobLogger>) -> Result<()> {
     let handle = tokio::task::spawn_blocking(move || -> Result<()> {
-        debug!("Starting restore for database {}", cfg.name);
+        logger.log("info", format!("Starting restore for database {}", cfg.name));
 
-        let mut sql_content = String::new();
         let mut file = File::open(&restore_file)
             .with_context(|| format!("Failed to open restore file {}", restore_file.display()))?;
-        file.read_to_string(&mut sql_content)
-            .with_context(|| format!("Failed to read restore file {}", restore_file.display()))?;
-        
+
         let drop_create_cmd = format!(
             "DROP DATABASE IF EXISTS `{0}`; CREATE DATABASE `{0}`;",
             cfg.database
         );
 
-        let drop_status = Command::new("mariadb")
+        let drop_start = Instant::now();
+        let drop_output = Command::new("mariadb")
             .arg("--host")
             .arg(&cfg.host)
             .arg("--port")
@@ -31,14 +30,22 @@ pub async fn run(cfg: DatabaseConfig, restore_file: PathBuf) -> Result<()> {
             .arg("-e")
             .arg(&drop_create_cmd)
             .env("MYSQL_PWD", &cfg.password)
-            .status()
+            .output()
             .with_context(|| format!("Failed to drop/recreate database {}", cfg.name))?;
 
-        if !drop_status.success() {
-            error!("Drop/create database failed for {}", cfg.name);
+        let drop_duration_ms = drop_start.elapsed().as_millis() as f64;
+        let drop_exit_code = drop_output.status.code().unwrap_or(-1);
+        let drop_stderr = String::from_utf8_lossy(&drop_output.stderr).to_string();
+
+        if !drop_output.status.success() {
+            logger.log_command("mariadb", Some(drop_stderr.clone()), Some(drop_exit_code), Some(drop_duration_ms));
+            logger.log("error", format!("Drop/create database failed for {}: {}", cfg.name, drop_stderr));
             anyhow::bail!("Failed to drop/recreate database {}", cfg.name);
         }
-        info!("Database {} dropped and recreated", cfg.name);
+        logger.log_command("mariadb", if drop_stderr.is_empty() { None } else { Some(drop_stderr) }, Some(0), Some(drop_duration_ms));
+        logger.log("info", format!("Database {} dropped and recreated", cfg.name));
+
+        let start = Instant::now();
 
         let mut child = Command::new("mariadb")
             .arg("--host")
@@ -55,23 +62,26 @@ pub async fn run(cfg: DatabaseConfig, restore_file: PathBuf) -> Result<()> {
             .with_context(|| format!("Failed to start MariaDB restore for {}", cfg.name))?;
 
         let mut stdin = child.stdin.take().context("Failed to open child stdin")?;
-        stdin
-            .write_all(sql_content.as_bytes())
-            .context("Failed to write SQL content to MariaDB stdin")?;
-        stdin.flush()?;
+        std::io::copy(&mut file, &mut stdin)
+            .context("Failed to stream SQL content to MariaDB stdin")?;
         drop(stdin);
 
         let output = child
             .wait_with_output()
             .with_context(|| format!("Failed to complete MariaDB restore 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();
+
         if !output.status.success() {
-            let stderr = String::from_utf8_lossy(&output.stderr);
-            error!("MariaDB restore failed for {}: {}", cfg.name, stderr);
+            logger.log_command("mariadb", Some(stderr.clone()), Some(exit_code), Some(duration_ms));
+            logger.log("error", format!("MariaDB restore failed for {}: {}", cfg.name, stderr));
             anyhow::bail!("MariaDB restore failed for {}", cfg.name);
         }
 
-        info!("Restore finished successfully for database {}", cfg.name);
+        logger.log_command("mariadb", if stderr.is_empty() { None } else { Some(stderr) }, Some(0), Some(duration_ms));
+        logger.log("info", format!("Restore finished successfully for database {}", cfg.name));
         Ok(())
     });
 

src/domain/mod.rs

@@ -1,3 +1,4 @@
+pub mod docker_volume;
 pub mod factory;
 mod mongodb;
 pub mod mysql;

src/domain/mongodb/backup.rs

@@ -1,35 +1,48 @@
 use crate::domain::mongodb::connection::{get_mongo_uri, select_mongo_path};
+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 MongoDB backup for database {}", cfg.name);
+        logger.log("info", format!("Starting MongoDB backup for database {}", cfg.name));
 
         let file_path = backup_dir.join(format!("{}{}", cfg.generated_id, file_extension));
         let mongodump = select_mongo_path().join("mongodump");
         let uri = get_mongo_uri(cfg.clone())?;
 
+        logger.log("info", format!("Running mongodump for {}", cfg.name));
+
+        let start = Instant::now();
         let output = Command::new(mongodump)
             .arg(format!("--uri={}", uri))
             .arg(format!("--archive={}", file_path.display()))
             .arg("--gzip")
+            .arg("--verbose")
             .output()
             .context("MongoDB backup failed")?;
+        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();
 
         if !output.status.success() {
-            let stderr = String::from_utf8_lossy(&output.stderr);
-            error!("MongoDB backup failed for {}: {}", cfg.name, stderr);
+            logger.log("error", format!("MongoDB backup failed for {}: {}", cfg.name, stderr));
+            logger.log_command("mongodump", Some(stderr.clone()), Some(exit_code), Some(duration_ms));
             anyhow::bail!("MongoDB backup failed for {}: {}", cfg.name, stderr);
         }
-        info!("MongoDB backup completed for {}", cfg.name);
+
+        logger.log_command("mongodump", if stderr.is_empty() { None } else { Some(stderr) }, Some(0), Some(duration_ms));
+        logger.log("info", format!("MongoDB backup completed for {}", cfg.name));
         Ok(file_path)
     })
     .await?

src/domain/mongodb/database.rs

@@ -1,9 +1,11 @@
 use anyhow::Result;
 use async_trait::async_trait;
 use std::path::{Path, PathBuf};
+use std::sync::Arc;
 
 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};
 
@@ -27,16 +29,16 @@ impl Database for MongoDatabase {
         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()).await;
+        let res = backup::run(self.cfg.clone(), dir.to_path_buf(), self.file_extension(), logger).await;
         FileLock::release(&self.cfg.generated_id).await?;
         res
     }
 
-    async fn restore(&self, file: &Path) -> Result<()> {
+    async fn restore(&self, file: &Path, logger: Arc<JobLogger>) -> Result<()> {
         FileLock::acquire(&self.cfg.generated_id, DbOpLock::Restore.as_str()).await?;
-        let res = restore::run(self.cfg.clone(), file.to_path_buf()).await;
+        let res = restore::run(self.cfg.clone(), file.to_path_buf(), logger).await;
         FileLock::release(&self.cfg.generated_id).await?;
         res
     }

src/domain/mongodb/restore.rs

@@ -1,17 +1,20 @@
 use crate::domain::mongodb::connection::{extract_db_name, get_mongo_uri, select_mongo_path};
+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, restore_file: PathBuf) -> Result<()> {
+pub async fn run(cfg: DatabaseConfig, restore_file: PathBuf, logger: Arc<JobLogger>) -> Result<()> {
     tokio::task::spawn_blocking(move || -> Result<()> {
-        debug!("Starting MongoDB restore for database {}", cfg.name);
+        logger.log("debug", format!("Starting MongoDB restore for database {}", cfg.name));
 
         let mongorestore = select_mongo_path().join("mongorestore");
         let uri = get_mongo_uri(cfg.clone())?;
 
+        let dry_start = Instant::now();
         let dry_run = Command::new(&mongorestore)
             .arg(format!(
                 "--uri={}",
@@ -26,12 +29,23 @@ pub async fn run(cfg: DatabaseConfig, restore_file: PathBuf) -> Result<()> {
             .arg("--verbose")
             .output()?;
 
+        let dry_duration_ms = dry_start.elapsed().as_millis() as f64;
+        let dry_exit_code = dry_run.status.code().unwrap_or(-1);
         let dry_output = String::from_utf8_lossy(&dry_run.stderr);
-        let source_db = extract_db_name(&dry_output)
-            .context("Could not detect source database name from archive")?;
+        logger.log_command(
+            "mongorestore --dryRun",
+            if dry_output.is_empty() { None } else { Some(dry_output.to_string()) },
+            Some(dry_exit_code),
+            Some(dry_duration_ms),
+        );
+        let source_db = extract_db_name(&dry_output).unwrap_or_else(|| {
+            logger.log("info", format!("Could not detect source database from archive, falling back to configured database: {}", cfg.database));
+            cfg.database.clone()
+        });
 
-        info!("Detected source database in archive: {}", source_db);
+        logger.log("info", format!("Using source database in archive: {}", source_db));
 
+        let start = Instant::now();
         let output = Command::new(&mongorestore)
             .arg(format!("--uri={}", uri))
             .arg(format!("--archive={}", restore_file.display()))
@@ -43,13 +57,18 @@ pub async fn run(cfg: DatabaseConfig, restore_file: PathBuf) -> Result<()> {
             .output()
             .with_context(|| format!("Failed to run mongorestore 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();
+
         if !output.status.success() {
-            let stderr = String::from_utf8_lossy(&output.stderr);
-            error!("MongoDB restore failed for {}: {}", cfg.name, stderr);
+            logger.log_command("mongorestore", Some(stderr.clone()), Some(exit_code), Some(duration_ms));
+            logger.log("error", format!("MongoDB restore failed for {}: {}", cfg.name, stderr));
             anyhow::bail!("MongoDB restore failed for: {}", cfg.name);
         }
 
-        info!("MongoDB restore completed for {}", cfg.name);
+        logger.log_command("mongorestore", if stderr.is_empty() { None } else { Some(stderr) }, Some(0), Some(duration_ms));
+        logger.log("info", format!("MongoDB restore completed for {}", cfg.name));
         Ok(())
     })
     .await?

src/domain/mssql/backup.rs

@@ -1,16 +1,19 @@
+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 MSSQL backup for database {}", cfg.name);
+        logger.log("info", format!("Starting MSSQL backup for database {}", cfg.name));
 
         let file_path = backup_dir.join(format!("{}{}", cfg.generated_id, file_extension));
         let connection_string = format!(
@@ -18,29 +21,35 @@ pub async fn run(
             cfg.host, cfg.port, cfg.database, cfg.username, cfg.password
         );
 
-        info!(
-            "MSSQL backup: {}:{}/{} → {}",
-            cfg.host,
-            cfg.port,
-            cfg.database,
-            file_path.display()
-        );
+        logger.log("info", format!("MSSQL backup: {}:{}/{} → {}", cfg.host, cfg.port, cfg.database, file_path.display()));
 
+        let start = Instant::now();
         let output = Command::new("sqlpackage")
             .arg("/a:Export")
             .arg(format!("/scs:{}", connection_string))
             .arg(format!("/tf:{}", file_path.display()))
             .output()
             .with_context(|| format!("Failed to run sqlpackage 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();
 
         if !output.status.success() {
-            let stderr = String::from_utf8_lossy(&output.stderr);
-            let stdout = String::from_utf8_lossy(&output.stdout);
-            error!("MSSQL backup failed — stderr: {} stdout: {}", stderr, stdout);
+            logger.log("error", format!("MSSQL backup failed — stderr: {} stdout: {}", stderr, stdout));
+            let out = format!("stderr: {} stdout: {}", stderr, stdout);
+            logger.log_command("sqlpackage", Some(out), Some(exit_code), Some(duration_ms));
             anyhow::bail!("MSSQL backup failed for {}: {}", cfg.name, stderr);
         }
 
-        info!("MSSQL backup completed: {}", file_path.display());
+        let combined = if stdout.is_empty() && stderr.is_empty() {
+            None
+        } else {
+            Some(format!("{}{}", stdout, stderr).trim().to_string())
+        };
+        logger.log_command("sqlpackage", combined, Some(0), Some(duration_ms));
+        logger.log("info", format!("MSSQL backup completed for {}", cfg.name));
         Ok(file_path)
     })
     .await?

src/domain/mssql/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 MssqlDatabase {
     cfg: DatabaseConfig,
@@ -26,21 +28,22 @@ impl Database for MssqlDatabase {
         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?;
         res
     }
 
-    async fn restore(&self, file: &Path) -> Result<()> {
+    async fn restore(&self, file: &Path, logger: Arc<JobLogger>) -> Result<()> {
         FileLock::acquire(&self.cfg.generated_id, DbOpLock::Restore.as_str()).await?;
-        let res = restore::run(self.cfg.clone(), file.to_path_buf()).await;
+        let res = restore::run(self.cfg.clone(), file.to_path_buf(), logger).await;
         FileLock::release(&self.cfg.generated_id).await?;
         res
     }

src/domain/mssql/restore.rs

@@ -1,26 +1,29 @@
+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, restore_file: PathBuf) -> Result<()> {
+pub async fn run(cfg: DatabaseConfig, restore_file: PathBuf, logger: Arc<JobLogger>) -> Result<()> {
     tokio::task::spawn_blocking(move || -> Result<()> {
-        debug!("Starting MSSQL restore for database {}", cfg.name);
+        logger.log("debug", format!("Starting MSSQL restore for database {}", cfg.name));
 
         let connection_string = format!(
             "Server=tcp:{},{};Database={};User Id={};Password={};TrustServerCertificate=True;Encrypt=False",
             cfg.host, cfg.port, cfg.database, cfg.username, cfg.password
         );
 
-        info!(
+        logger.log("info", format!(
             "MSSQL restore: {} → {}:{}/{}",
             restore_file.display(),
             cfg.host,
             cfg.port,
             cfg.database
-        );
+        ));
 
+        let start = Instant::now();
         let output = Command::new("sqlpackage")
             .arg("/a:Import")
             .arg(format!("/tcs:{}", connection_string))
@@ -28,17 +31,23 @@ pub async fn run(cfg: DatabaseConfig, restore_file: PathBuf) -> Result<()> {
             .output()
             .with_context(|| format!("Failed to run sqlpackage restore 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 = format!("{}{}", stdout, stderr);
+
         if !output.status.success() {
-            let stderr = String::from_utf8_lossy(&output.stderr);
-            let stdout = String::from_utf8_lossy(&output.stdout);
-            error!(
+            logger.log_command("sqlpackage", if combined.is_empty() { None } else { Some(combined.clone()) }, Some(exit_code), Some(duration_ms));
+            logger.log("error", format!(
                 "MSSQL restore failed for {} — stderr: {} stdout: {}",
                 cfg.name, stderr, stdout
-            );
+            ));
             anyhow::bail!("MSSQL restore failed for {}: {}", cfg.name, stderr);
         }
 
-        info!("MSSQL restore completed for {}", cfg.name);
+        logger.log_command("sqlpackage", if combined.is_empty() { None } else { Some(combined) }, Some(0), Some(duration_ms));
+        logger.log("info", format!("MSSQL restore completed for {}", cfg.name));
         Ok(())
     })
     .await?

src/domain/mysql/backup.rs

@@ -1,65 +1,79 @@
 use crate::domain::mysql::connection::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("info", format!("Starting backup for database {}", cfg.name));
 
-        let version = match futures::executor::block_on(server_version(&cfg)) {
+        let _version = match futures::executor::block_on(server_version(&cfg)) {
             Ok(v) => {
-                debug!("Mysql version detected: {}", v);
+                logger.log("debug", format!("MySQL 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!("Mysql version found: {}", version);
-
         let file_path = backup_dir.join(format!("{}{}", cfg.generated_id, file_extension));
 
+        if let Ok(out) = Command::new("mysqldump").arg("--version").output() {
+            logger.log("debug", format!("mysqldump client: {}", String::from_utf8_lossy(&out.stdout).trim()));
+        }
+
+        logger.log("info", format!("Running mysqldump for {}", cfg.name));
+
+        let start = Instant::now();
         let output = Command::new("mysqldump")
-            .arg("--host")
-            .arg(&cfg.host)
-            .arg("--port")
-            .arg(cfg.port.to_string())
-            .arg("--user")
-            .arg(&cfg.username)
+            .arg("--host").arg(&cfg.host)
+            .arg("--port").arg(cfg.port.to_string())
+            .arg("--user").arg(&cfg.username)
             .arg("--routines")
             .arg("--events")
             .arg("--triggers")
+            .arg("--verbose")
             .arg("--single-transaction")
+            .arg("--set-gtid-purged=OFF")
+            .arg("--no-tablespaces")
             .arg("--quick")
             .arg("--skip-lock-tables")
             .arg("--skip-add-drop-table")
-            .arg("--no-create-db") // IMPORTANT
+            .arg("--no-create-db")
             .arg("--default-character-set=utf8mb4")
-            .arg(&cfg.database) // IMPORTANT: NOT --databases
-            .arg("-r")
-            .arg(&file_path)
+            .arg("--network-timeout")
+            .arg(format!("--max-allowed-packet={}", cfg.max_packet_size))
+            .arg(&cfg.database)
+            .arg("-r").arg(&file_path)
             .envs(env)
             .output()
             .with_context(|| format!("Failed to run mysqldump for {}", cfg.name))?;
+        let duration_ms = start.elapsed().as_millis() as f64;
+        let exit_code = output.status.code().unwrap_or(-1);
+
+        let _stdout = String::from_utf8_lossy(&output.stdout).to_string();
+        let stderr = String::from_utf8_lossy(&output.stderr).to_string();
 
         if !output.status.success() {
-            let stderr = String::from_utf8_lossy(&output.stderr);
-            info!("mysqldump stderr: {}", stderr);
+            logger.log_command("mysqldump", Some(stderr.clone()), Some(exit_code), Some(duration_ms));
             anyhow::bail!("MySQL backup failed for {}: {}", cfg.name, stderr);
         }
 
-        info!("Output {}", String::from_utf8_lossy(&output.stdout));
+        logger.log_command("mysqldump", if stderr.is_empty() { None } else { Some(stderr) }, Some(0), Some(duration_ms));
+        logger.log("info", format!("mysqldump completed for {}", cfg.name));
 
         Ok(file_path)
     })

src/domain/mysql/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 MySQLDatabase {
     cfg: DatabaseConfig,
@@ -33,22 +35,23 @@ impl Database for MySQLDatabase {
         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?;
         res
     }
 
-    async fn restore(&self, file: &Path) -> Result<()> {
+    async fn restore(&self, file: &Path, logger: Arc<JobLogger>) -> Result<()> {
         FileLock::acquire(&self.cfg.generated_id, DbOpLock::Restore.as_str()).await?;
-        let res = restore::run(self.cfg.clone(), file.to_path_buf()).await;
+        let res = restore::run(self.cfg.clone(), file.to_path_buf(), logger).await;
         FileLock::release(&self.cfg.generated_id).await?;
         res
     }

src/domain/mysql/restore.rs

@@ -1,27 +1,26 @@
+use crate::services::backup::logger::JobLogger;
 use crate::services::config::DatabaseConfig;
 use anyhow::{Context, Result};
 use std::fs::File;
-use std::io::{Read, Write};
 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, restore_file: PathBuf) -> Result<()> {
+pub async fn run(cfg: DatabaseConfig, restore_file: PathBuf, logger: Arc<JobLogger>) -> Result<()> {
     let handle = tokio::task::spawn_blocking(move || -> Result<()> {
-        debug!("Starting restore for database {}", cfg.name);
+        logger.log("info", format!("Starting restore for database {}", cfg.name));
 
-        let mut sql_content = String::new();
         let mut file = File::open(&restore_file)
             .with_context(|| format!("Failed to open restore file {}", restore_file.display()))?;
-        file.read_to_string(&mut sql_content)
-            .with_context(|| format!("Failed to read restore file {}", restore_file.display()))?;
 
         let drop_create_cmd = format!(
             "DROP DATABASE IF EXISTS `{0}`; CREATE DATABASE `{0}`;",
             cfg.database
         );
 
-        let drop_status = Command::new("mysql")
+        let drop_start = Instant::now();
+        let drop_output = Command::new("mysql")
             .arg("--host")
             .arg(&cfg.host)
             .arg("--port")
@@ -31,14 +30,22 @@ pub async fn run(cfg: DatabaseConfig, restore_file: PathBuf) -> Result<()> {
             .arg("-e")
             .arg(&drop_create_cmd)
             .env("MYSQL_PWD", &cfg.password)
-            .status()
+            .output()
             .with_context(|| format!("Failed to drop/recreate database {}", cfg.name))?;
 
-        if !drop_status.success() {
-            error!("Drop/create database failed for {}", cfg.name);
+        let drop_duration_ms = drop_start.elapsed().as_millis() as f64;
+        let drop_exit_code = drop_output.status.code().unwrap_or(-1);
+        let drop_stderr = String::from_utf8_lossy(&drop_output.stderr).to_string();
+
+        if !drop_output.status.success() {
+            logger.log_command("mysql", Some(drop_stderr.clone()), Some(drop_exit_code), Some(drop_duration_ms));
+            logger.log("error", format!("Drop/create database failed for {}: {}", cfg.name, drop_stderr));
             anyhow::bail!("Failed to drop/recreate database {}", cfg.name);
         }
-        info!("Database {} dropped and recreated", cfg.name);
+        logger.log_command("mysql", if drop_stderr.is_empty() { None } else { Some(drop_stderr) }, Some(0), Some(drop_duration_ms));
+        logger.log("info", format!("Database {} dropped and recreated", cfg.name));
+
+        let start = Instant::now();
 
         let mut child = Command::new("mysql")
             .arg("--host")
@@ -55,23 +62,26 @@ pub async fn run(cfg: DatabaseConfig, restore_file: PathBuf) -> Result<()> {
             .with_context(|| format!("Failed to start mysql restore for {}", cfg.name))?;
 
         let mut stdin = child.stdin.take().context("Failed to open child stdin")?;
-        stdin
-            .write_all(sql_content.as_bytes())
-            .context("Failed to write SQL content to mysql stdin")?;
-        stdin.flush()?;
+        std::io::copy(&mut file, &mut stdin)
+            .context("Failed to stream SQL content to mysql stdin")?;
         drop(stdin);
 
         let output = child
             .wait_with_output()
             .with_context(|| format!("Failed to complete mysql restore 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();
+
         if !output.status.success() {
-            let stderr = String::from_utf8_lossy(&output.stderr);
-            error!("MySQL restore failed for {}: {}", cfg.name, stderr);
+            logger.log_command("mysql", Some(stderr.clone()), Some(exit_code), Some(duration_ms));
+            logger.log("error", format!("MySQL restore failed for {}: {}", cfg.name, stderr));
             anyhow::bail!("MySQL restore failed for {}", cfg.name);
         }
 
-        info!("Restore finished successfully for database {}", cfg.name);
+        logger.log_command("mysql", if stderr.is_empty() { None } else { Some(stderr) }, Some(0), Some(duration_ms));
+        logger.log("info", format!("Restore finished successfully for database {}", cfg.name));
         Ok(())
     });
 

src/domain/postgres/backup.rs

@@ -1,142 +1,150 @@
 use anyhow::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;
 
 use super::connection::{select_pg_path, server_version};
 use super::format::PostgresDumpFormat;
+use crate::services::backup::logger::JobLogger;
 use crate::services::config::DatabaseConfig;
 
 pub async fn run(
     cfg: DatabaseConfig,
     format: PostgresDumpFormat,
     backup_dir: PathBuf,
+    env: HashMap<String, String>,
+    logger: Arc<JobLogger>,
 ) -> Result<PathBuf> {
     tokio::task::spawn_blocking(move || -> Result<PathBuf> {
-        debug!("Starting backup for database {}", cfg.name);
+        logger.log("info", format!("Starting backup for database {}", cfg.name));
 
         let version = match futures::executor::block_on(server_version(&cfg)) {
             Ok(v) => {
-                debug!("Postgres version detected: {}", v);
+                logger.log("debug", format!("Postgres 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());
             }
         };
 
         let pg_dump = select_pg_path(&version).join("pg_dump");
-
-        debug!("Using pg_dump at {:?}", pg_dump);
+        logger.log("debug", format!("Using pg_dump at {:?}", pg_dump));
 
         match format {
             PostgresDumpFormat::Fc => {
-                info!("Running FC backup for {}", cfg.name);
-                let file_path = backup_dir.join(format!("{}.dump", cfg.generated_id));
-                let url = format!(
-                    "postgresql://{}:{}@{}:{}/{}",
-                    cfg.username, cfg.password, cfg.host, cfg.port, cfg.database
-                );
+                logger.log("info", format!("Running FC backup for {}", cfg.name));
 
-                let status = Command::new(&pg_dump)
-                    .arg("--dbname")
-                    .arg(&url)
+                let file_path = backup_dir.join(format!("{}.dump", cfg.generated_id));
+
+                let start = Instant::now();
+                let output = Command::new(&pg_dump)
+                    .arg("--host").arg(&cfg.host)
+                    .arg("--port").arg(cfg.port.to_string())
+                    .arg("--username").arg(&cfg.username)
+                    .arg("--dbname").arg(&cfg.database)
                     .arg("-Fc")
-                    .arg("-f")
-                    .arg(&file_path)
+                    .arg("-f").arg(&file_path)
                     .arg("-v")
                     .arg("--compress=3")
-                    .status();
+                    .envs(env)
+                    .output();
+                let duration_ms = start.elapsed().as_millis() as f64;
 
-                match status {
-                    Ok(s) if s.success() => info!(
-                        "FC backup completed successfully for {} at {:?}",
-                        cfg.name, file_path
-                    ),
-                    Ok(s) => {
-                        error!("FC backup failed with status {:?} for {}", s, cfg.name);
-                        anyhow::bail!("Postgres backup failed for {}", cfg.name);
+                match output {
+                    Ok(o) => {
+                        let stderr = String::from_utf8_lossy(&o.stderr).to_string();
+                        let exit_code = o.status.code().unwrap_or(-1);
+
+                        if o.status.success() {
+                            logger.log("info", format!("FC backup completed successfully for {} at {:?}", cfg.name, file_path));
+                            logger.log_command("pg_dump", if stderr.is_empty() { None } else { Some(stderr) }, Some(0), Some(duration_ms));
+                        } else {
+                            logger.log("error", format!("FC backup failed with status {:?} for {}", o.status, cfg.name));
+                            logger.log_command("pg_dump", Some(stderr), Some(exit_code), Some(duration_ms));
+                            anyhow::bail!("Postgres backup failed for {}", cfg.name);
+                        }
                     }
                     Err(e) => {
-                        error!("Error executing pg_dump for {}: {:?}", cfg.name, e);
+                        logger.log("error", format!("Error executing pg_dump for {}: {:?}", cfg.name, e));
+                        logger.log_command("pg_dump", Some(e.to_string()), Some(-1), Some(duration_ms));
                         return Err(e.into());
                     }
                 }
-                info!("Backup finished for database {}", cfg.name);
+                logger.log("info", format!("Backup finished for database {}", cfg.name));
                 Ok(file_path)
             }
 
             PostgresDumpFormat::Fd => {
-                info!("Running FD backup for {}", cfg.name);
+                logger.log("info", format!("Running FD backup for {}", cfg.name));
+
                 let dump_dir = backup_dir.join(format!("{}_dir", cfg.generated_id));
                 let tar_file = backup_dir.join(format!("{}.tar.gz", cfg.generated_id));
 
                 if let Err(e) = std::fs::create_dir_all(&dump_dir) {
-                    error!(
-                        "Failed to create dump directory {:?} for {}: {:?}",
-                        dump_dir, cfg.name, e
-                    );
+                    logger.log("error", format!("Failed to create dump directory {:?} for {}: {:?}", dump_dir, cfg.name, e));
                     return Err(e.into());
                 }
 
-                let url = format!(
-                    "postgresql://{}:{}@{}:{}/{}",
-                    cfg.username, cfg.password, cfg.host, cfg.port, cfg.database
-                );
+                let cmd_label = format!("pg_dump -Fd {}@{}:{}/{}", cfg.username, cfg.host, cfg.port, cfg.database);
 
-                let status = Command::new(&pg_dump)
-                    .arg("--dbname")
-                    .arg(&url)
+                let start = Instant::now();
+                let output = Command::new(&pg_dump)
+                    .arg("--host").arg(&cfg.host)
+                    .arg("--port").arg(cfg.port.to_string())
+                    .arg("--username").arg(&cfg.username)
+                    .arg("--dbname").arg(&cfg.database)
                     .arg("-Fd")
-                    .arg("-j")
-                    .arg("4")
-                    .arg("-f")
-                    .arg(&dump_dir)
+                    .arg("-j").arg("4")
+                    .arg("-f").arg(&dump_dir)
                     .arg("-v")
-                    .status();
+                    .envs(env)
+                    .output();
+                let duration_ms = start.elapsed().as_millis() as f64;
 
-                match status {
-                    Ok(s) if s.success() => {
-                        info!("FD backup pg_dump completed successfully for {}", cfg.name)
-                    }
-                    Ok(s) => {
-                        error!(
-                            "FD backup pg_dump failed with status {:?} for {}",
-                            s, cfg.name
-                        );
-                        anyhow::bail!("Postgres FD backup failed for {}", cfg.name);
+                match output {
+                    Ok(o) => {
+                        let stderr = String::from_utf8_lossy(&o.stderr).to_string();
+                        let exit_code = o.status.code().unwrap_or(-1);
+                        if o.status.success() {
+                            logger.log("info", format!("FD backup pg_dump completed successfully for {}", cfg.name));
+                            logger.log_command(cmd_label, if stderr.is_empty() { None } else { Some(stderr) }, Some(0), Some(duration_ms));
+                        } else {
+                            logger.log("error", format!("FD backup pg_dump failed with status {:?} for {}", o.status, cfg.name));
+                            logger.log_command(cmd_label, Some(stderr), Some(exit_code), Some(duration_ms));
+                            anyhow::bail!("Postgres FD backup failed for {}", cfg.name);
+                        }
                     }
                     Err(e) => {
-                        error!("Error executing pg_dump for {}: {:?}", cfg.name, e);
+                        logger.log("error", format!("Error executing pg_dump for {}: {:?}", cfg.name, e));
+                        logger.log_command(cmd_label, Some(e.to_string()), Some(-1), Some(duration_ms));
                         return Err(e.into());
                     }
                 }
 
                 match std::fs::File::create(&tar_file) {
                     Ok(tar_gz) => {
-                        let enc =
-                            flate2::write::GzEncoder::new(tar_gz, flate2::Compression::default());
+                        let enc = flate2::write::GzEncoder::new(tar_gz, flate2::Compression::default());
                         let mut tar = tar::Builder::new(enc);
                         if let Err(e) = tar.append_dir_all(".", &dump_dir) {
-                            error!("Failed to append dump_dir to tar for {}: {:?}", cfg.name, e);
+                            logger.log("error", format!("Failed to append dump_dir to tar for {}: {:?}", cfg.name, e));
                             return Err(e.into());
                         }
                         if let Err(e) = tar.finish() {
-                            error!("Failed to finish tar archive for {}: {:?}", cfg.name, e);
+                            logger.log("error", format!("Failed to finish tar archive for {}: {:?}",  cfg.name, e));
                             return Err(e.into());
                         }
-                        info!("FD backup archive created at {:?}", tar_file);
+                        logger.log("info", format!("FD backup archive created at {:?}", tar_file));
                     }
                     Err(e) => {
-                        error!(
-                            "Failed to create tar.gz file {:?} for {}: {:?}",
-                            tar_file, cfg.name, e
-                        );
+                        logger.log("error", format!("Failed to create tar.gz file {:?} for {}: {:?}", tar_file, cfg.name, e));
                         return Err(e.into());
                     }
                 }
-                info!("Backup finished for database {}", cfg.name);
+                logger.log("info", format!("Backup finished for database {}", cfg.name));
                 Ok(tar_file)
             }
         }

src/domain/postgres/clean_mode.rs

@@ -0,0 +1,25 @@
+use crate::services::config::DatabaseConfig;
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum RestoreCleanMode {
+    None,
+    Clean,
+    DropSchemas,
+    DropDatabase,
+}
+
+impl RestoreCleanMode {
+    pub fn from_config(cfg: &DatabaseConfig) -> (Self, Option<String>) {
+        match cfg.options.get("clean_mode").and_then(|v| v.as_str()) {
+            None | Some("clean") => (Self::Clean, None),
+            Some("none") => (Self::None, None),
+            Some("drop_schemas") => (Self::DropSchemas, None),
+            Some("drop_database") => (Self::DropDatabase, None),
+            Some(other) => (Self::Clean, Some(other.to_string())),
+        }
+    }
+
+    pub fn uses_pg_restore_clean(self) -> bool {
+        matches!(self, Self::Clean)
+    }
+}

src/domain/postgres/cluster/backup.rs

@@ -0,0 +1,81 @@
+use anyhow::Result;
+use std::collections::HashMap;
+use std::path::PathBuf;
+use std::process::Command;
+use std::sync::Arc;
+use std::time::Instant;
+
+use super::super::connection::{
+    is_superuser, pg_dumpall_binary_name, select_pg_path, server_version,
+};
+use crate::services::backup::logger::JobLogger;
+use crate::services::config::DatabaseConfig;
+
+pub async fn run(
+    cfg: DatabaseConfig,
+    backup_dir: PathBuf,
+    env: HashMap<String, String>,
+    logger: Arc<JobLogger>,
+) -> Result<PathBuf> {
+    tokio::task::spawn_blocking(move || -> Result<PathBuf> {
+        logger.log("info", format!("Starting cluster backup for {}", cfg.name));
+
+        let version = match futures::executor::block_on(server_version(&cfg)) {
+            Ok(v) => v,
+            Err(e) => {
+                logger.log("error", format!("Failed to get server version for {}: {:?}", cfg.name, e));
+                return Err(e.into());
+            }
+        };
+
+        match futures::executor::block_on(is_superuser(&cfg)) {
+            Ok(true) => {}
+            Ok(false) => {
+                logger.log("error", format!("postgresql-cluster backup requires a superuser role for {}", cfg.name));
+                anyhow::bail!("postgresql-cluster backup requires a superuser role for {}", cfg.name);
+            }
+            Err(e) => {
+                logger.log("error", format!("Failed to check superuser status for {}: {:?}", cfg.name, e));
+                return Err(e.into());
+            }
+        }
+
+        let pg_dumpall = select_pg_path(&version).join(pg_dumpall_binary_name());
+        let file_path = backup_dir.join(format!("{}.sql", cfg.generated_id));
+
+        logger.log("info", format!("Running pg_dumpall for cluster {} via {:?}", cfg.name, pg_dumpall));
+
+        let start = Instant::now();
+        let output = Command::new(&pg_dumpall)
+            .arg("--host").arg(&cfg.host)
+            .arg("--port").arg(cfg.port.to_string())
+            .arg("--username").arg(&cfg.username)
+            .arg("--clean")
+            .arg("--if-exists")
+            .arg("-v")
+            .arg("-f").arg(&file_path)
+            .envs(env)
+            .output();
+        let duration_ms = start.elapsed().as_millis() as f64;
+
+        match output {
+            Ok(o) => {
+                let stderr = String::from_utf8_lossy(&o.stderr).to_string();
+                let exit_code = o.status.code().unwrap_or(-1);
+                if o.status.success() {
+                    logger.log_command("pg_dumpall", if stderr.is_empty() { None } else { Some(stderr) }, Some(0), Some(duration_ms));
+                    logger.log("info", format!("Cluster backup completed for {} at {:?}", cfg.name, file_path));
+                    Ok(file_path)
+                } else {
+                    logger.log_command("pg_dumpall", Some(stderr), Some(exit_code), Some(duration_ms));
+                    anyhow::bail!("Cluster backup (pg_dumpall) failed for {}", cfg.name);
+                }
+            }
+            Err(e) => {
+                logger.log_command("pg_dumpall", Some(e.to_string()), Some(-1), Some(duration_ms));
+                Err(e.into())
+            }
+        }
+    })
+    .await?
+}

src/domain/postgres/cluster/database.rs

@@ -0,0 +1,53 @@
+use anyhow::Result;
+use async_trait::async_trait;
+use std::collections::HashMap;
+use std::path::{Path, PathBuf};
+use std::sync::Arc;
+
+use super::super::ping;
+use super::{backup, restore};
+use crate::domain::factory::Database;
+use crate::services::backup::logger::JobLogger;
+use crate::services::config::DatabaseConfig;
+use crate::utils::locks::{DbOpLock, FileLock};
+
+pub struct PostgresClusterDatabase {
+    pub cfg: DatabaseConfig,
+}
+
+impl PostgresClusterDatabase {
+    pub fn new(cfg: DatabaseConfig) -> Self {
+        Self { cfg }
+    }
+
+    fn build_env(&self) -> HashMap<String, String> {
+        let mut envs = std::env::vars().collect::<HashMap<_, _>>();
+        envs.insert("PGPASSWORD".to_string(), self.cfg.password.to_string());
+        envs
+    }
+}
+
+#[async_trait]
+impl Database for PostgresClusterDatabase {
+    fn file_extension(&self) -> &'static str {
+        ".sql"
+    }
+
+    async fn ping(&self) -> Result<bool> {
+        ping::run(self.cfg.clone()).await
+    }
+
+    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(), logger).await;
+        FileLock::release(&self.cfg.generated_id).await?;
+        res
+    }
+
+    async fn restore(&self, file: &Path, logger: Arc<JobLogger>) -> Result<()> {
+        FileLock::acquire(&self.cfg.generated_id, DbOpLock::Restore.as_str()).await?;
+        let res = restore::run(self.cfg.clone(), file.to_path_buf(), self.build_env(), logger).await;
+        FileLock::release(&self.cfg.generated_id).await?;
+        res
+    }
+}

src/domain/postgres/cluster/mod.rs

@@ -0,0 +1,3 @@
+pub mod backup;
+pub mod database;
+pub mod restore;

src/domain/postgres/cluster/restore.rs

@@ -0,0 +1,85 @@
+use anyhow::Result;
+use std::collections::HashMap;
+use std::path::PathBuf;
+use std::process::Command;
+use std::sync::Arc;
+use std::time::Instant;
+
+use super::super::connection::{is_superuser, psql_binary_name, select_pg_path, server_version, terminate_all_connections};
+use crate::services::backup::logger::JobLogger;
+use crate::services::config::DatabaseConfig;
+
+pub async fn run(
+    cfg: DatabaseConfig,
+    restore_file: PathBuf,
+    env: HashMap<String, String>,
+    logger: Arc<JobLogger>,
+) -> Result<()> {
+    let handle = tokio::runtime::Handle::current();
+    tokio::task::spawn_blocking(move || -> Result<()> {
+        logger.log("info", format!("Starting cluster restore for {}", cfg.name));
+
+        let version = match handle.block_on(server_version(&cfg)) {
+            Ok(v) => v,
+            Err(e) => {
+                logger.log("error", format!("Failed to get server version for {}: {:?}", cfg.name, e));
+                return Err(e.into());
+            }
+        };
+
+        match handle.block_on(is_superuser(&cfg)) {
+            Ok(true) => {}
+            Ok(false) => {
+                logger.log("error", format!("postgresql-cluster restore requires a superuser role for {}", cfg.name));
+                anyhow::bail!("postgresql-cluster restore requires a superuser role for {}", cfg.name);
+            }
+            Err(e) => {
+                logger.log("error", format!("Failed to check superuser status for {}: {:?}", cfg.name, e));
+                return Err(e.into());
+            }
+        }
+
+        let psql = select_pg_path(&version).join(psql_binary_name());
+
+        if let Err(e) = handle.block_on(terminate_all_connections(&cfg)) {
+            logger.log("error", format!("Failed to terminate connections for cluster {}: {:?}", cfg.name, e));
+            return Err(e.into());
+        }
+        logger.log("info", format!("All user database connections terminated for cluster {}", cfg.name));
+
+        logger.log("info", format!("Replaying cluster dump for {} via {:?}", cfg.name, psql));
+
+        let start = Instant::now();
+        let output = Command::new(&psql)
+            .arg("--host").arg(&cfg.host)
+            .arg("--port").arg(cfg.port.to_string())
+            .arg("--username").arg(&cfg.username)
+            .arg("--dbname").arg("postgres")
+            .arg("-f").arg(&restore_file)
+            .envs(env)
+            .output();
+        let duration_ms = start.elapsed().as_millis() as f64;
+
+        match output {
+            Ok(o) => {
+                let stderr = String::from_utf8_lossy(&o.stderr).to_string();
+                let stdout = String::from_utf8_lossy(&o.stdout).to_string();
+                let combined = format!("{}{}", stdout, stderr);
+                let exit_code = o.status.code().unwrap_or(-1);
+                if o.status.success() {
+                    logger.log_command("psql", if combined.is_empty() { None } else { Some(combined) }, Some(0), Some(duration_ms));
+                    logger.log("info", format!("Cluster restore completed for {}", cfg.name));
+                    Ok(())
+                } else {
+                    logger.log_command("psql", if combined.is_empty() { None } else { Some(combined) }, Some(exit_code), Some(duration_ms));
+                    anyhow::bail!("Cluster restore (psql) failed for {}", cfg.name);
+                }
+            }
+            Err(e) => {
+                logger.log_command("psql", Some(e.to_string()), Some(-1), Some(duration_ms));
+                Err(e.into())
+            }
+        }
+    })
+    .await?
+}

src/domain/postgres/connection.rs

@@ -1,18 +1,23 @@
 use crate::domain::postgres::format::PostgresDumpFormat;
 use crate::services::config::DatabaseConfig;
+use crate::settings::CONFIG;
 use anyhow::Result;
 use std::path::Path;
-use tokio_postgres::{Client, NoTls};
+use tokio_postgres::{Client, Config, NoTls};
 use tracing::{error, info};
 
 pub async fn connect(cfg: &DatabaseConfig) -> Result<Client> {
     info!("Connecting to postgres database {}:{}", cfg.host, cfg.port);
-    let dsn = format!(
-        "host={} port={} user={} password={} dbname={}",
-        cfg.host, cfg.port, cfg.username, cfg.password, cfg.database
-    );
 
-    let (client, connection) = tokio_postgres::connect(&dsn, NoTls).await?;
+    let mut config = Config::new();
+    config
+        .host(&cfg.host)
+        .port(cfg.port)
+        .user(&cfg.username)
+        .password(&cfg.password)
+        .dbname(&cfg.database);
+
+    let (client, connection) = config.connect(NoTls).await?;
     tokio::spawn(async move {
         if let Err(e) = connection.await {
             error!("Postgres connection error: {}", e);
@@ -28,11 +33,133 @@ pub async fn server_version(cfg: &DatabaseConfig) -> Result<String> {
     Ok(version)
 }
 
+pub async fn server_version_major(cfg: &DatabaseConfig) -> Result<u32> {
+    let v = server_version(cfg).await?;
+    Ok(v.split(['.', ' '])
+        .next()
+        .and_then(|s| s.parse().ok())
+        .unwrap_or(17))
+}
+
+pub async fn is_superuser(cfg: &DatabaseConfig) -> Result<bool> {
+    let client = connect(cfg).await?;
+    let is_super: bool = client
+        .query_one("SELECT current_setting('is_superuser') = 'on';", &[])
+        .await?
+        .get(0);
+
+    Ok(is_super)
+}
+
+pub async fn can_drop_database(cfg: &DatabaseConfig) -> Result<bool> {
+    let client = connect(cfg).await?;
+    let row = client
+        .query_one(
+            "SELECT r.rolsuper OR (r.rolcreatedb AND pg_catalog.pg_has_role(current_user, d.datdba, 'USAGE')) \
+             FROM pg_roles r, pg_database d \
+             WHERE r.rolname = current_user AND d.datname = current_database()",
+            &[],
+        )
+        .await?;
+    Ok(row.get(0))
+}
+
+
 pub fn select_pg_path(version: &str) -> std::path::PathBuf {
+    select_pg_path_with(version, &CONFIG.pg_bin_dir)
+}
+
+pub(crate) fn select_pg_path_with(version: &str, pg_bin_dir: &str) -> std::path::PathBuf {
     let major = version.split('.').next().unwrap_or("17");
+
+    if !pg_bin_dir.is_empty() {
+        return pg_bin_dir.into();
+    }
+
+    let candidates: Vec<std::path::PathBuf> = if cfg!(target_os = "windows") {
+        vec![
+            // Default install path used by the official EDB Windows installer
+            format!(r"C:\Program Files\PostgreSQL\{major}\bin").into(),
+            format!(r"C:\Program Files (x86)\PostgreSQL\{major}\bin").into(),
+        ]
+    } else if cfg!(target_os = "macos") {
+        vec![
+            // Homebrew on Apple Silicon
+            format!("/opt/homebrew/opt/postgresql@{major}/bin").into(),
+            // Homebrew on Intel
+            format!("/usr/local/opt/postgresql@{major}/bin").into(),
+            // Postgres.app
+            format!("/Applications/Postgres.app/Contents/Versions/{major}/bin").into(),
+        ]
+    } else {
+        vec![
+            // Debian/Ubuntu packages
+            format!("/usr/lib/postgresql/{major}/bin").into(),
+            // Common RPM-based distro layout
+            format!("/usr/pgsql-{major}/bin").into(),
+        ]
+    };
+
+    if let Some(found) = candidates.into_iter().find(|p| pg_dump_exists_in(p)) {
+        return found;
+    }
+
+    if let Some(dir) = find_pg_dump_in_path() {
+        return dir;
+    }
+
     format!("/usr/lib/postgresql/{}/bin", major).into()
 }
 
+pub(crate) fn pg_dump_binary_name() -> &'static str {
+    if cfg!(target_os = "windows") {
+        "pg_dump.exe"
+    } else {
+        "pg_dump"
+    }
+}
+
+pub(crate) fn pg_dumpall_binary_name() -> &'static str {
+    if cfg!(target_os = "windows") {
+        "pg_dumpall.exe"
+    } else {
+        "pg_dumpall"
+    }
+}
+
+pub(crate) fn psql_binary_name() -> &'static str {
+    if cfg!(target_os = "windows") {
+        "psql.exe"
+    } else {
+        "psql"
+    }
+}
+
+pub(crate) fn pg_restore_binary_name() -> &'static str {
+    if cfg!(target_os = "windows") {
+        "pg_restore.exe"
+    } else {
+        "pg_restore"
+    }
+}
+
+pub(crate) fn quote_ident(s: &str) -> String {
+    format!("\"{}\"", s.replace('"', "\"\""))
+}
+
+pub(crate) fn quote_literal(s: &str) -> String {
+    format!("'{}'", s.replace('\'', "''"))
+}
+
+pub(crate) fn pg_dump_exists_in(dir: &std::path::Path) -> bool {
+    dir.join(pg_dump_binary_name()).is_file()
+}
+
+fn find_pg_dump_in_path() -> Option<std::path::PathBuf> {
+    let path_var = std::env::var_os("PATH")?;
+    std::env::split_paths(&path_var).find(|dir| pg_dump_exists_in(dir))
+}
+
 pub async fn terminate_connections(cfg: &DatabaseConfig) -> Result<()> {
     let mut admin = cfg.clone();
     admin.database = "postgres".to_string().into();
@@ -54,6 +181,128 @@ pub async fn terminate_connections(cfg: &DatabaseConfig) -> Result<()> {
     Ok(())
 }
 
+pub async fn terminate_all_connections(cfg: &DatabaseConfig) -> Result<()> {
+    let mut admin = cfg.clone();
+    admin.database = "postgres".to_string().into();
+
+    let client = connect(&admin).await?;
+
+    client
+        .execute(
+            r#"
+            SELECT pg_terminate_backend(pid)
+            FROM pg_stat_activity
+            WHERE datname NOT IN ('postgres', 'template0', 'template1')
+              AND pid <> pg_backend_pid();
+            "#,
+            &[],
+        )
+        .await?;
+
+    Ok(())
+}
+
+pub async fn drop_and_recreate_database(cfg: &DatabaseConfig) -> Result<()> {
+    let mut admin_cfg = cfg.clone();
+    admin_cfg.database = "postgres".to_string();
+    let admin = connect(&admin_cfg).await?;
+
+    let row = admin
+        .query_opt(
+            r#"
+            SELECT pg_encoding_to_char(encoding), datcollate, datctype,
+                   pg_get_userbyid(datdba), datistemplate
+            FROM pg_database WHERE datname = $1
+            "#,
+            &[&cfg.database],
+        )
+        .await?;
+
+    let (encoding, collate, ctype, owner) = match &row {
+        Some(r) => (
+            r.get::<_, String>(0),
+            r.get::<_, String>(1),
+            r.get::<_, String>(2),
+            r.get::<_, String>(3),
+        ),
+        None => ("UTF8".into(), "C".into(), "C".into(), cfg.username.clone()),
+    };
+
+    if let Some(r) = &row {
+        if r.get::<_, bool>(4) {
+            anyhow::bail!("Refusing to drop template database {}", cfg.database);
+        }
+    }
+
+    let db = quote_ident(&cfg.database);
+
+    if let Err(e) = admin
+        .batch_execute(&format!("ALTER DATABASE {db} WITH ALLOW_CONNECTIONS false"))
+        .await
+    {
+        tracing::warn!("ALLOW_CONNECTIONS false failed for {}: {e}", cfg.database);
+    }
+
+    let major = server_version_major(&admin_cfg).await?;
+    let drop_stmt = if major >= 13 {
+        format!("DROP DATABASE IF EXISTS {db} WITH (FORCE)")
+    } else {
+        format!("DROP DATABASE IF EXISTS {db}")
+    };
+
+    let mut last_err = None;
+    let mut dropped = false;
+    for _ in 0..3 {
+        let _ = terminate_connections(cfg).await;
+        match admin.batch_execute(&drop_stmt).await {
+            Ok(()) => {
+                dropped = true;
+                break;
+            }
+            Err(e) => {
+                last_err = Some(e);
+                tokio::time::sleep(std::time::Duration::from_millis(500)).await;
+            }
+        }
+    }
+
+    if !dropped {
+        let _ = admin
+            .batch_execute(&format!("ALTER DATABASE {db} WITH ALLOW_CONNECTIONS true"))
+            .await;
+        return Err(last_err
+            .map(anyhow::Error::from)
+            .unwrap_or_else(|| anyhow::anyhow!("DROP DATABASE {} failed", cfg.database)));
+    }
+
+    admin
+        .batch_execute(&format!(
+            "CREATE DATABASE {db} OWNER {} TEMPLATE template0 ENCODING {} LC_COLLATE {} LC_CTYPE {}",
+            quote_ident(&owner),
+            quote_literal(&encoding),
+            quote_literal(&collate),
+            quote_literal(&ctype),
+        ))
+        .await?;
+
+    Ok(())
+}
+
+pub fn sniff_format(restore_file: &Path) -> Result<PostgresDumpFormat> {
+    use std::io::Read;
+    let mut f = std::fs::File::open(restore_file)?;
+    let mut magic = [0u8; 5];
+    let n = f.read(&mut magic)?;
+    let head = &magic[..n];
+    if head.starts_with(b"PGDMP") {
+        Ok(PostgresDumpFormat::Fc)
+    } else if head.starts_with(&[0x1f, 0x8b]) {
+        Ok(PostgresDumpFormat::Fd)
+    } else {
+        anyhow::bail!("Unrecognized dump format for {:?}", restore_file)
+    }
+}
+
 pub fn detect_format_from_file(restore_file: &Path) -> PostgresDumpFormat {
     match restore_file.extension().and_then(|e| e.to_str()) {
         Some("dump") => PostgresDumpFormat::Fc,
@@ -63,11 +312,50 @@ pub fn detect_format_from_file(restore_file: &Path) -> PostgresDumpFormat {
     }
 }
 
+pub async fn drop_all_schemas(cfg: &DatabaseConfig) -> Result<Vec<String>> {
+    let client = connect(cfg).await?;
+    let rows = client
+        .query(
+            r#"
+            SELECT nspname FROM pg_namespace
+            WHERE nspname NOT IN ('pg_catalog', 'information_schema', 'pg_toast')
+              AND nspname NOT LIKE 'pg\_temp\_%'
+              AND nspname NOT LIKE 'pg\_toast\_temp\_%'
+            ORDER BY nspname
+            "#,
+            &[],
+        )
+        .await?;
+    let schemas: Vec<String> = rows.iter().map(|r| r.get::<_, String>(0)).collect();
+    for s in &schemas {
+        client
+            .batch_execute(&format!("DROP SCHEMA IF EXISTS {} CASCADE", quote_ident(s)))
+            .await?;
+    }
+    client
+        .batch_execute("SELECT lo_unlink(oid) FROM pg_largeobject_metadata")
+        .await
+        .ok();
+    Ok(schemas)
+}
+
+pub async fn recreate_public_schema(cfg: &DatabaseConfig, owner: &str) -> Result<()> {
+    let client = connect(cfg).await?;
+    client
+        .batch_execute(&format!(
+            "CREATE SCHEMA IF NOT EXISTS public AUTHORIZATION {}; GRANT USAGE ON SCHEMA public TO PUBLIC;",
+            quote_ident(owner)
+        ))
+        .await?;
+    Ok(())
+}
+
 pub async fn detect_format_from_size(cfg: &DatabaseConfig) -> PostgresDumpFormat {
     info!(
         "Detecting database format {:?} - {:?}",
         cfg.name, cfg.generated_id
     );
+
     let client = match connect(cfg).await {
         Ok(c) => c,
         Err(_) => return PostgresDumpFormat::Fc,

src/domain/postgres/database.rs

@@ -1,9 +1,11 @@
 use anyhow::Result;
 use async_trait::async_trait;
+use std::collections::HashMap;
 use std::path::{Path, PathBuf};
-
+use std::sync::Arc;
 use super::{backup, format::PostgresDumpFormat, ping, restore};
 use crate::domain::factory::Database;
+use crate::services::backup::logger::JobLogger;
 use crate::services::config::DatabaseConfig;
 use crate::utils::locks::{DbOpLock, FileLock};
 
@@ -16,6 +18,12 @@ impl PostgresDatabase {
     pub fn new(cfg: DatabaseConfig, format: PostgresDumpFormat) -> Self {
         Self { cfg, format }
     }
+
+    fn build_env(&self) -> HashMap<String, String> {
+        let mut envs = std::env::vars().collect::<HashMap<_, _>>();
+        envs.insert("PGPASSWORD".to_string(), self.cfg.password.to_string());
+        envs
+    }
 }
 
 #[async_trait]
@@ -31,16 +39,30 @@ impl Database for PostgresDatabase {
         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(), self.format, dir.to_path_buf()).await;
+        let res = backup::run(
+            self.cfg.clone(),
+            self.format,
+            dir.to_path_buf(),
+            self.build_env(),
+            logger,
+        )
+        .await;
         FileLock::release(&self.cfg.generated_id).await?;
         res
     }
 
-    async fn restore(&self, file: &Path) -> Result<()> {
+    async fn restore(&self, file: &Path, logger: Arc<JobLogger>) -> Result<()> {
         FileLock::acquire(&self.cfg.generated_id, DbOpLock::Restore.as_str()).await?;
-        let res = restore::run(self.cfg.clone(), self.format, file.to_path_buf()).await;
+        let res = restore::run(
+            self.cfg.clone(),
+            self.format,
+            file.to_path_buf(),
+            self.build_env(),
+            logger,
+        )
+        .await;
         FileLock::release(&self.cfg.generated_id).await?;
         res
     }

src/domain/postgres/format.rs

@@ -1,4 +1,4 @@
-#[derive(Clone, Copy)]
+#[derive(Clone, Copy, PartialEq, Debug)]
 pub enum PostgresDumpFormat {
     Fc,
     Fd,

src/domain/postgres/mod.rs

@@ -1,8 +1,10 @@
 pub mod backup;
-mod connection;
+pub(crate) mod cluster;
+pub(crate) mod clean_mode;
+pub(crate) mod connection;
 pub mod database;
-mod format;
+pub(crate) mod format;
 mod ping;
-mod restore;
+pub(crate) mod restore;
 
 pub use connection::{detect_format_from_file, detect_format_from_size};

src/domain/postgres/restore.rs

@@ -1,173 +0,0 @@
-use anyhow::Result;
-use std::path::PathBuf;
-use std::process::Command;
-use tracing::{debug, error, info};
-
-use super::connection::{select_pg_path, server_version, terminate_connections};
-use super::format::PostgresDumpFormat;
-use crate::services::config::DatabaseConfig;
-
-pub async fn run(
-    cfg: DatabaseConfig,
-    format: PostgresDumpFormat,
-    restore_file: PathBuf,
-) -> Result<()> {
-    tokio::task::spawn_blocking(move || -> Result<()> {
-        debug!("Starting restore for database {}", cfg.name);
-
-        let version = match futures::executor::block_on(server_version(&cfg)) {
-            Ok(v) => {
-                debug!("Postgres version detected: {}", v);
-                v
-            }
-            Err(e) => {
-                error!("Failed to get server version for {}: {:?}", cfg.name, e);
-                return Err(e.into());
-            }
-        };
-
-        let pg_restore = select_pg_path(&version).join("pg_restore");
-
-        debug!("Using pg_restore at {:?}", pg_restore);
-
-        if let Err(e) = futures::executor::block_on(terminate_connections(&cfg)) {
-            error!("Failed to terminate connections for {}: {:?}", cfg.name, e);
-            return Err(e.into());
-        }
-        info!("Connections terminated for database {}", cfg.name);
-
-        let url = format!(
-            "postgresql://{}:{}@{}:{}/{}",
-            cfg.username, cfg.password, cfg.host, cfg.port, cfg.database
-        );
-
-        debug!("Restore URL: {}", url);
-
-        match format {
-            PostgresDumpFormat::Fc => {
-                info!("Running FC restore for {}", cfg.name);
-                let status = Command::new(&pg_restore)
-                    .arg("--no-owner")
-                    .arg("--no-privileges")
-                    .arg("--clean")
-                    .arg("--if-exists")
-                    // .arg("--create")
-                    .arg("--dbname")
-                    .arg(&url)
-                    .arg("-v")
-                    .arg(&restore_file)
-                    .env("PGPASSWORD", &cfg.password)
-                    .status();
-
-                match status {
-                    Ok(s) if s.success() => {
-                        info!("FC restore completed successfully for {}", cfg.name)
-                    }
-                    Ok(s) => {
-                        error!("FC restore failed with status {:?} for {}", s, cfg.name);
-                        anyhow::bail!("Postgres restore failed for {}", cfg.name);
-                    }
-                    Err(e) => {
-                        error!("Error executing pg_restore for {}: {:?}", cfg.name, e);
-                        return Err(e.into());
-                    }
-                }
-            }
-
-            PostgresDumpFormat::Fd => {
-                info!("Running FD restore for {}", cfg.name);
-
-                let tar_gz = match std::fs::File::open(&restore_file) {
-                    Ok(f) => f,
-                    Err(e) => {
-                        error!(
-                            "Failed to open restore file {:?} for {}: {:?}",
-                            restore_file, cfg.name, e
-                        );
-                        return Err(e.into());
-                    }
-                };
-
-                info!("tar_gz {:?}", tar_gz);
-
-                let dec = flate2::read::GzDecoder::new(tar_gz);
-                let mut archive = tar::Archive::new(dec);
-
-                let tmp_dir = match tempfile::TempDir::new() {
-                    Ok(d) => d,
-                    Err(e) => {
-                        error!(
-                            "Failed to create temporary directory for FD restore of {}: {:?}",
-                            cfg.name, e
-                        );
-                        return Err(e.into());
-                    }
-                };
-
-                if let Err(e) = archive.unpack(tmp_dir.path()) {
-                    error!("Failed to unpack FD archive for {}: {:?}", cfg.name, e);
-                    return Err(e.into());
-                }
-
-                debug!("Listing contents of temp dir: {}", tmp_dir.path().display());
-
-                for entry in std::fs::read_dir(tmp_dir.path())? {
-                    if let Ok(entry) = entry {
-                        let path = entry.path();
-                        let file_type = entry.file_type()?;
-                        debug!(
-                            " - {} | is_dir: {} | is_file: {}",
-                            path.display(),
-                            file_type.is_dir(),
-                            file_type.is_file()
-                        );
-                    }
-                }
-
-                let dump_dir = if tmp_dir.path().join("toc.dat").exists() {
-                    tmp_dir.path().to_path_buf()
-                } else {
-                    std::fs::read_dir(tmp_dir.path())?
-                        .filter_map(|e| e.ok())
-                        .find(|entry| entry.path().join("toc.dat").exists())
-                        .map(|e| e.path())
-                        .ok_or_else(|| anyhow::anyhow!("Invalid FD archive: toc.dat not found"))?
-                };
-
-                let status = Command::new(&pg_restore)
-                    .arg("--no-owner")
-                    .arg("--no-privileges")
-                    .arg("--clean")
-                    .arg("--if-exists")
-                    // .arg("--create")
-                    .arg("--dbname")
-                    .arg(&url)
-                    .arg("-v")
-                    .arg("-j")
-                    .arg("4")
-                    .arg(dump_dir)
-                    .env("PGPASSWORD", &cfg.password)
-                    .status();
-
-                match status {
-                    Ok(s) if s.success() => {
-                        info!("FD restore completed successfully for {}", cfg.name)
-                    }
-                    Ok(s) => {
-                        error!("FD restore failed with status {:?} for {}", s, cfg.name);
-                        anyhow::bail!("Postgres FD restore failed for {}", cfg.name);
-                    }
-                    Err(e) => {
-                        error!("Error executing pg_restore for {}: {:?}", cfg.name, e);
-                        return Err(e.into());
-                    }
-                }
-            }
-        }
-
-        info!("Restore finished for database {}", cfg.name);
-
-        Ok(())
-    })
-    .await?
-}

src/domain/postgres/restore/command.rs

@@ -0,0 +1,41 @@
+use anyhow::Result;
+use std::process::Command;
+use std::time::Instant;
+
+use crate::services::backup::logger::JobLogger;
+use crate::services::config::DatabaseConfig;
+
+pub(crate) fn run_pg_restore(
+    mut cmd: Command,
+    logger: &JobLogger,
+    cfg: &DatabaseConfig,
+) -> Result<()> {
+    let start = Instant::now();
+    let output = cmd.output();
+    let duration_ms = start.elapsed().as_millis() as f64;
+
+    match output {
+        Ok(o) => {
+            let stderr = String::from_utf8_lossy(&o.stderr).to_string();
+            let stdout = String::from_utf8_lossy(&o.stdout).to_string();
+            let combined = format!("{}{}", stdout, stderr);
+            let exit_code = o.status.code().unwrap_or(-1);
+            let payload = if combined.is_empty() { None } else { Some(combined) };
+
+            if o.status.success() {
+                logger.log_command("pg_restore", payload, Some(0), Some(duration_ms));
+                logger.log("info", format!("Restore completed successfully for {}", cfg.name));
+                Ok(())
+            } else {
+                logger.log_command("pg_restore", payload, Some(exit_code), Some(duration_ms));
+                logger.log("error", format!("Restore failed with status {:?} for {}", o.status, cfg.name));
+                anyhow::bail!("Postgres restore failed for {}", cfg.name);
+            }
+        }
+        Err(e) => {
+            logger.log_command("pg_restore", Some(e.to_string()), Some(-1), Some(duration_ms));
+            logger.log("error", format!("Error executing pg_restore for {}: {:?}", cfg.name, e));
+            Err(e.into())
+        }
+    }
+}

src/domain/postgres/restore/mod.rs

@@ -0,0 +1,9 @@
+mod command;
+mod prepare;
+mod run;
+mod toc;
+
+pub use run::run;
+pub(crate) use command::run_pg_restore;
+pub(crate) use prepare::prepare_archive;
+pub(crate) use toc::toc_creates_public_schema;

src/domain/postgres/restore/prepare.rs

@@ -0,0 +1,67 @@
+use anyhow::Result;
+use std::path::{Path, PathBuf};
+use std::process::Command;
+
+use crate::domain::postgres::connection::sniff_format;
+use crate::domain::postgres::format::PostgresDumpFormat;
+use crate::services::backup::logger::JobLogger;
+
+pub(crate) struct PreparedArchive {
+    path: PathBuf,
+    _tmp: Option<tempfile::TempDir>,
+    toc: String,
+}
+
+impl PreparedArchive {
+    pub(crate) fn path(&self) -> &Path {
+        &self.path
+    }
+    pub(crate) fn toc(&self) -> &str {
+        &self.toc
+    }
+}
+
+pub(crate) fn prepare_archive(
+    format: PostgresDumpFormat,
+    restore_file: &Path,
+    pg_restore: &Path,
+    logger: &JobLogger,
+) -> Result<PreparedArchive> {
+    let sniffed = sniff_format(restore_file)?;
+    if sniffed != format {
+        logger.log("warn", format!("Declared format {:?} != sniffed {:?}; using sniffed", format, sniffed));
+    }
+    let format = sniffed;
+
+    let (path, tmp) = match format {
+        PostgresDumpFormat::Fc => (restore_file.to_path_buf(), None),
+        PostgresDumpFormat::Fd => {
+            let tar_gz = std::fs::File::open(restore_file)?;
+            let dec = flate2::read::GzDecoder::new(tar_gz);
+            let mut archive = tar::Archive::new(dec);
+            let tmp_dir = tempfile::TempDir::new()?;
+            archive.unpack(tmp_dir.path())?;
+
+            let dump_dir = if tmp_dir.path().join("toc.dat").exists() {
+                tmp_dir.path().to_path_buf()
+            } else {
+                std::fs::read_dir(tmp_dir.path())?
+                    .filter_map(|e| e.ok())
+                    .find(|entry| entry.path().join("toc.dat").exists())
+                    .map(|e| e.path())
+                    .ok_or_else(|| anyhow::anyhow!("Invalid FD archive: toc.dat not found"))?
+            };
+            (dump_dir, Some(tmp_dir))
+        }
+    };
+
+    let toc_out = Command::new(pg_restore).arg("-l").arg(&path).output()?;
+    if !toc_out.status.success() {
+        let stderr = String::from_utf8_lossy(&toc_out.stderr).to_string();
+        logger.log("error", format!("pg_restore -l failed: {}", stderr));
+        anyhow::bail!("Archive validation failed (pg_restore -l): {}", stderr);
+    }
+    let toc = String::from_utf8_lossy(&toc_out.stdout).to_string();
+
+    Ok(PreparedArchive { path, _tmp: tmp, toc })
+}

src/domain/postgres/restore/run.rs

@@ -0,0 +1,108 @@
+use anyhow::Result;
+use std::collections::HashMap;
+use std::path::PathBuf;
+use std::process::Command;
+use std::sync::Arc;
+
+use super::{prepare_archive, run_pg_restore, toc_creates_public_schema};
+use crate::domain::postgres::clean_mode::RestoreCleanMode;
+use crate::domain::postgres::connection::{
+    can_drop_database, drop_all_schemas, drop_and_recreate_database, pg_restore_binary_name,
+    recreate_public_schema, select_pg_path, server_version, terminate_connections,
+};
+use crate::domain::postgres::format::PostgresDumpFormat;
+use crate::services::backup::logger::JobLogger;
+use crate::services::config::DatabaseConfig;
+
+pub async fn run(
+    cfg: DatabaseConfig,
+    format: PostgresDumpFormat,
+    restore_file: PathBuf,
+    env: HashMap<String, String>,
+    logger: Arc<JobLogger>,
+) -> Result<()> {
+    let handle = tokio::runtime::Handle::current();
+    tokio::task::spawn_blocking(move || -> Result<()> {
+        logger.log("info", format!("Starting restore for database {}", cfg.name));
+
+        let version = match handle.block_on(server_version(&cfg)) {
+            Ok(v) => {
+                logger.log("debug", format!("Postgres version detected: {}", v));
+                v
+            }
+            Err(e) => {
+                logger.log("error", format!("Failed to get server version for {}: {:?}", cfg.name, e));
+                return Err(e.into());
+            }
+        };
+
+        let pg_restore = select_pg_path(&version).join(pg_restore_binary_name());
+
+        logger.log("debug", format!("Using pg_restore at {:?}", pg_restore));
+
+        let keep_ownership = cfg.options
+            .get("keep_ownership")
+            .and_then(|v| v.as_bool())
+            .unwrap_or(false);
+
+        if keep_ownership {
+            logger.log("info", format!("Restoring ownership and privileges for {}", cfg.name));
+        } else {
+            logger.log("info", format!("Stripping ownership and privileges for {} (--no-owner --no-privileges)", cfg.name));
+        }
+
+        let (mode, bad_value) = RestoreCleanMode::from_config(&cfg);
+        if let Some(v) = bad_value {
+            logger.log("warn", format!("Unknown clean_mode '{}' for {}, falling back to 'clean'", v, cfg.name));
+        }
+
+        let prepared = prepare_archive(format, &restore_file, &pg_restore, &logger)?;
+
+        match mode {
+            RestoreCleanMode::DropSchemas => {
+                handle.block_on(terminate_connections(&cfg))?;
+                let owner = cfg.username.clone();
+                let dropped = handle.block_on(drop_all_schemas(&cfg))?;
+                logger.log("warn", format!("clean_mode=drop_schemas dropped schemas {:?} in {}", dropped, cfg.database));
+                if !toc_creates_public_schema(prepared.toc()) {
+                    handle.block_on(recreate_public_schema(&cfg, &owner))?;
+                }
+            }
+            RestoreCleanMode::DropDatabase => {
+                if !handle.block_on(can_drop_database(&cfg))? {
+                    anyhow::bail!(
+                        "clean_mode=drop_database requires CREATEDB + ownership on {}; use clean_mode=drop_schemas instead",
+                        cfg.database
+                    );
+                }
+                logger.log("warn", format!("clean_mode=drop_database DROPPING database {} before restore", cfg.database));
+                handle.block_on(drop_and_recreate_database(&cfg))?;
+            }
+            RestoreCleanMode::Clean | RestoreCleanMode::None => {
+                handle.block_on(terminate_connections(&cfg))?;
+            }
+        }
+
+        let mut cmd = Command::new(&pg_restore);
+        if !keep_ownership {
+            cmd.args(["--no-owner", "--no-privileges"]);
+        }
+        if mode.uses_pg_restore_clean() {
+            cmd.args(["--clean", "--if-exists"]);
+        }
+        cmd.arg("--host").arg(&cfg.host)
+            .arg("--port").arg(cfg.port.to_string())
+            .arg("--username").arg(&cfg.username)
+            .arg("--dbname").arg(&cfg.database)
+            .arg("-v");
+        if matches!(format, PostgresDumpFormat::Fd) {
+            cmd.arg("-j").arg("4");
+        }
+        cmd.arg(prepared.path()).envs(env);
+
+        run_pg_restore(cmd, &logger, &cfg)?;
+        logger.log("info", format!("Restore finished for database {}", cfg.name));
+        Ok(())
+    })
+    .await?
+}

src/domain/postgres/restore/toc.rs

@@ -0,0 +1,8 @@
+pub(crate) fn toc_creates_public_schema(toc: &str) -> bool {
+    toc.lines().any(|l| {
+        l.split(" SCHEMA - ")
+            .nth(1)
+            .and_then(|rest| rest.split_whitespace().next())
+            == Some("public")
+    })
+}

src/domain/redis/backup.rs

@@ -1,21 +1,26 @@
+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 Redis backup for database {}", cfg.name);
+        logger.log(
+            "info",
+            format!("Starting Redis backup for database {}", cfg.name),
+        );
 
         let file_path = backup_dir.join(format!("{}{}", cfg.generated_id, file_extension));
 
         let mut cmd = Command::new("redis-cli");
-
         cmd.arg("-h")
             .arg(&cfg.host)
             .arg("-p")
@@ -24,40 +29,66 @@ pub async fn run(
         if !cfg.username.is_empty() {
             cmd.arg("--user").arg(&cfg.username);
         }
-
         if !cfg.password.is_empty() {
             cmd.arg("-a").arg(&cfg.password);
         }
-
         cmd.arg("--rdb").arg(&file_path);
 
-        debug!("Command Backup: {:?}", cmd);
+        logger.log("info", format!("Running redis-cli --rdb for {}", cfg.name));
 
+        let start = Instant::now();
         let output = cmd.output().context("Redis backup command failed")?;
+        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);
         let stdout = String::from_utf8_lossy(&output.stdout);
 
         if !output.status.success() {
             if stderr.contains("NOAUTH") {
-                error!(
-                    "Redis backup failed for {}: Authentication required (NOAUTH)",
-                    cfg.name
+                logger.log(
+                    "error",
+                    format!(
+                        "Redis backup failed for {}: Authentication required (NOAUTH)",
+                        cfg.name
+                    ),
+                );
+                logger.log_command(
+                    "redis-cli",
+                    Some("Authentication required (NOAUTH)".into()),
+                    Some(exit_code),
+                    Some(duration_ms),
                 );
                 anyhow::bail!(
                     "Redis backup failed for {}: Authentication required",
                     cfg.name
                 );
             } else {
-                error!("Redis backup failed for {}: {}", cfg.name, stderr);
+                logger.log(
+                    "error",
+                    format!("Redis backup failed for {}: {}", cfg.name, stderr),
+                );
+                logger.log_command(
+                    "redis-cli",
+                    Some(stderr.to_string()),
+                    Some(exit_code),
+                    Some(duration_ms),
+                );
                 anyhow::bail!("Redis backup failed for {}: {}", cfg.name, stderr);
             }
         }
 
-        info!(
-            "Redis backup completed for {}. Output: {}",
-            cfg.name, stdout
+        logger.log_command(
+            "redis-cli",
+            if stdout.is_empty() {
+                None
+            } else {
+                Some(stdout.to_string())
+            },
+            Some(0),
+            Some(duration_ms),
         );
+        logger.log("info", format!("Redis backup completed for {}", cfg.name));
 
         Ok(file_path)
     })

src/domain/redis/database.rs

@@ -1,9 +1,11 @@
 use anyhow::{Result, bail};
 use async_trait::async_trait;
 use std::path::{Path, PathBuf};
+use std::sync::Arc;
 
 use crate::domain::factory::Database;
 use crate::domain::redis::{backup, ping};
+use crate::services::backup::logger::JobLogger;
 use crate::services::config::DatabaseConfig;
 use crate::utils::locks::{DbOpLock, FileLock};
 
@@ -27,14 +29,14 @@ impl Database for RedisDatabase {
         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()).await;
+        let res = backup::run(self.cfg.clone(), dir.to_path_buf(), self.file_extension(), logger).await;
         FileLock::release(&self.cfg.generated_id).await?;
         res
     }
 
-    async fn restore(&self, _file: &Path) -> Result<()> {
+    async fn restore(&self, _file: &Path, _logger: Arc<JobLogger>) -> Result<()> {
         bail!("Restore not supported for Redis databases")
     }
 }

src/domain/sqlite/backup.rs

@@ -1,16 +1,19 @@
+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 SQLite backup for database {}", cfg.name);
+        logger.log("info", format!("Starting SQLite backup for database {}", cfg.name));
 
         let db_path_str = if cfg.path.is_empty() {
             anyhow::bail!("Database path not configured");
@@ -19,27 +22,35 @@ pub async fn run(
         };
 
         let db_path = PathBuf::from(db_path_str);
-        info!("database path: {}", db_path.display());
+        logger.log("info", format!("Database path: {}", db_path.display()));
 
         if !db_path.exists() {
+            logger.log("error", format!("SQLite database file not found: {}", db_path.display()));
             anyhow::bail!("SQLite database file not found: {}", db_path.display());
         }
 
         let file_path = backup_dir.join(format!("{}{}", cfg.generated_id, file_extension));
 
+        logger.log("info", format!("Running sqlite3 backup for {}", cfg.name));
+
+        let start = Instant::now();
         let output = Command::new("sqlite3")
             .arg(db_path.as_os_str())
             .arg(format!(".backup '{}'", file_path.display()))
             .output()
             .context("SQLite backup command failed to start")?;
-        info!("Backup successful: {:?}", output);
+        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);
-            error!("SQLite backup failed for {}: {}", cfg.name, stderr);
+            let stderr = String::from_utf8_lossy(&output.stderr).to_string();
+            logger.log("error", format!("SQLite backup failed for {}: {}", cfg.name, stderr));
+            logger.log_command("sqlite3", Some(stderr.clone()), Some(exit_code), Some(duration_ms));
             anyhow::bail!("SQLite backup failed for {}: {}", cfg.name, stderr);
         }
 
-        info!("SQLite backup completed for {}", cfg.name);
+        logger.log_command("sqlite3", None, Some(0), Some(duration_ms));
+        logger.log("info", format!("SQLite backup completed for {}", cfg.name));
         Ok(file_path)
     })
     .await?

src/domain/sqlite/database.rs

@@ -1,9 +1,11 @@
 use anyhow::Result;
 use async_trait::async_trait;
 use std::path::{Path, PathBuf};
+use std::sync::Arc;
 
 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};
 
@@ -27,15 +29,15 @@ impl Database for SqliteDatabase {
         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()).await;
+        let res = backup::run(self.cfg.clone(), dir.to_path_buf(), self.file_extension(), logger).await;
         FileLock::release(&self.cfg.generated_id).await?;
         res
     }
-    async fn restore(&self, file: &Path) -> Result<()> {
+    async fn restore(&self, file: &Path, logger: Arc<JobLogger>) -> Result<()> {
         FileLock::acquire(&self.cfg.generated_id, DbOpLock::Restore.as_str()).await?;
-        let res = restore::run(self.cfg.clone(), file.to_path_buf()).await;
+        let res = restore::run(self.cfg.clone(), file.to_path_buf(), logger).await;
         FileLock::release(&self.cfg.generated_id).await?;
         res
     }

src/domain/sqlite/restore.rs

@@ -1,12 +1,14 @@
+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, restore_file: PathBuf) -> Result<()> {
+pub async fn run(cfg: DatabaseConfig, restore_file: PathBuf, logger: Arc<JobLogger>) -> Result<()> {
     tokio::task::spawn_blocking(move || -> Result<()> {
-        debug!("Starting SQLite restore for database {}", cfg.name);
+        logger.log("debug", format!("Starting SQLite restore for database {}", cfg.name));
 
         let db_path_str = if cfg.path.is_empty() {
             anyhow::bail!("Database path not configured");
@@ -25,19 +27,25 @@ pub async fn run(cfg: DatabaseConfig, restore_file: PathBuf) -> Result<()> {
                 .with_context(|| format!("Failed to remove existing DB {}", db_path.display()))?;
         }
 
+        let start = Instant::now();
         let output = Command::new("sqlite3")
             .arg(db_path.as_os_str())
             .arg(format!(".restore '{}'", restore_file.display()))
             .output()
             .with_context(|| format!("Failed to run sqlite3 restore 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();
+
         if !output.status.success() {
-            let stderr = String::from_utf8_lossy(&output.stderr);
-            error!("SQLite restore failed for {}: {}", cfg.name, stderr);
+            logger.log_command("sqlite3", Some(stderr.clone()), Some(exit_code), Some(duration_ms));
+            logger.log("error", format!("SQLite restore failed for {}: {}", cfg.name, stderr));
             anyhow::bail!("SQLite restore failed for {}", cfg.name);
         }
 
-        info!("SQLite restore completed for {}", cfg.name);
+        logger.log_command("sqlite3", if stderr.is_empty() { None } else { Some(stderr) }, Some(0), Some(duration_ms));
+        logger.log("info", format!("SQLite restore completed for {}", cfg.name));
         Ok(())
     })
     .await?

src/domain/valkey/backup.rs

@@ -1,21 +1,26 @@
+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 Valkey backup for database {}", cfg.name);
+        logger.log(
+            "info",
+            format!("Starting Valkey backup for database {}", cfg.name),
+        );
 
         let file_path = backup_dir.join(format!("{}{}", cfg.generated_id, file_extension));
 
         let mut cmd = Command::new("valkey-cli");
-
         cmd.arg("-h")
             .arg(&cfg.host)
             .arg("-p")
@@ -24,40 +29,66 @@ pub async fn run(
         if !cfg.username.is_empty() {
             cmd.arg("--user").arg(&cfg.username);
         }
-
         if !cfg.password.is_empty() {
             cmd.arg("-a").arg(&cfg.password);
         }
-
         cmd.arg("--rdb").arg(&file_path);
 
-        debug!("Command Backup: {:?}", cmd);
+        logger.log("info", format!("Running valkey-cli --rdb for {}", cfg.name));
 
+        let start = Instant::now();
         let output = cmd.output().context("Valkey backup command failed")?;
+        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);
         let stdout = String::from_utf8_lossy(&output.stdout);
 
         if !output.status.success() {
             if stderr.contains("NOAUTH") {
-                error!(
-                    "Valkey backup failed for {}: Authentication required (NOAUTH)",
-                    cfg.name
+                logger.log(
+                    "error",
+                    format!(
+                        "Valkey backup failed for {}: Authentication required (NOAUTH)",
+                        cfg.name
+                    ),
+                );
+                logger.log_command(
+                    "valkey-cli",
+                    Some("Authentication required (NOAUTH)".into()),
+                    Some(exit_code),
+                    Some(duration_ms),
                 );
                 anyhow::bail!(
                     "Valkey backup failed for {}: Authentication required",
                     cfg.name
                 );
             } else {
-                error!("Valkey backup failed for {}: {}", cfg.name, stderr);
+                logger.log(
+                    "error",
+                    format!("Valkey backup failed for {}: {}", cfg.name, stderr),
+                );
+                logger.log_command(
+                    "valkey-cli",
+                    Some(stderr.to_string()),
+                    Some(exit_code),
+                    Some(duration_ms),
+                );
                 anyhow::bail!("Valkey backup failed for {}: {}", cfg.name, stderr);
             }
         }
 
-        info!(
-            "Valkey backup completed for {}. Output: {}",
-            cfg.name, stdout
+        logger.log_command(
+            "valkey-cli",
+            if stdout.is_empty() {
+                None
+            } else {
+                Some(stdout.to_string())
+            },
+            Some(0),
+            Some(duration_ms),
         );
+        logger.log("info", format!("Valkey backup completed for {}", cfg.name));
 
         Ok(file_path)
     })

src/domain/valkey/database.rs

@@ -1,9 +1,11 @@
 use anyhow::{Result, bail};
 use async_trait::async_trait;
 use std::path::{Path, PathBuf};
+use std::sync::Arc;
 
 use crate::domain::factory::Database;
 use crate::domain::valkey::{backup, ping};
+use crate::services::backup::logger::JobLogger;
 use crate::services::config::DatabaseConfig;
 use crate::utils::locks::{DbOpLock, FileLock};
 
@@ -27,14 +29,14 @@ impl Database for ValkeyDatabase {
         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()).await;
+        let res = backup::run(self.cfg.clone(), dir.to_path_buf(), self.file_extension(), logger).await;
         FileLock::release(&self.cfg.generated_id).await?;
         res
     }
 
-    async fn restore(&self, _file: &Path) -> Result<()> {
+    async fn restore(&self, _file: &Path, _logger: Arc<JobLogger>) -> Result<()> {
         bail!("Restore not supported for Valkey databases")
     }
 }

src/main.rs

@@ -22,6 +22,16 @@ async fn main() {
         eprintln!("Failed to clean locks on startup: {:?}", e);
     }
 
+    // Best-effort cleanup of ephemeral helper containers orphaned by a crash.
+    match crate::domain::docker_volume::docker::client() {
+        Ok(docker) => match crate::domain::docker_volume::docker::sweep_ephemeral(&docker).await {
+            Ok(n) if n > 0 => tracing::info!("Removed {n} orphaned ephemeral helper container(s)"),
+            Ok(_) => {}
+            Err(e) => tracing::warn!("Ephemeral helper sweep failed: {e}"),
+        },
+        Err(e) => tracing::debug!("Docker socket unavailable, skipping helper sweep: {e}"),
+    }
+
     tokio::join!(ping_server(), async {
         let conn = redis_client::redis_connection().await;
         scheduler::scheduler_loop(conn).await;

src/services/api/endpoints/agent/backup/mod.rs

@@ -2,6 +2,7 @@ pub mod upload;
 
 use crate::services::api::models::agent::backup::BackupResponse;
 use crate::services::api::{ApiClient, ApiError};
+use crate::services::backup::logger::JobLogEntry;
 use anyhow::Result;
 use reqwest::Method;
 use serde::Serialize;
@@ -21,6 +22,9 @@ pub struct BackupUpdateRequest {
     pub size: Option<u64>,
     #[serde(rename = "generatedId")]
     pub generated_id: String,
+    pub logs: Vec<JobLogEntry>,
+    #[serde(rename = "durationMs")]
+    pub duration_ms: f64,
 }
 
 impl ApiClient {
@@ -49,12 +53,16 @@ impl ApiClient {
         status: impl Into<String>,
         file_size: impl Into<Option<u64>>,
         generated_id: impl Into<String>,
+        job_logs: Vec<JobLogEntry>,
+        duration_ms: f64,
     ) -> Result<Option<BackupResponse>, ApiError> {
         let body = BackupUpdateRequest {
             backup_id: backup_id.into(),
             status: status.into(),
             size: file_size.into(),
             generated_id: generated_id.into(),
+            logs: job_logs,
+            duration_ms: duration_ms,
         };
 
         let agent_id = agent_id.into();

src/services/api/endpoints/agent/restore/mod.rs

@@ -3,12 +3,16 @@ use crate::services::api::{ApiClient, ApiError};
 use anyhow::Result;
 use reqwest::Method;
 use serde::Serialize;
+use crate::services::backup::logger::JobLogEntry;
 
 #[derive(Serialize)]
 pub struct ResultRestoreRequest {
     #[serde(rename = "generatedId")]
     pub generated_id: String,
     pub status: String,
+    pub logs: Vec<JobLogEntry>,
+    #[serde(rename = "durationMs")]
+    pub duration_ms: f64,
 }
 
 impl ApiClient {
@@ -17,10 +21,14 @@ impl ApiClient {
         agent_id: impl Into<String>,
         generated_id: impl Into<String>,
         status: impl Into<String>,
+        job_logs: Vec<JobLogEntry>,
+        duration_ms: f64,
     ) -> Result<Option<ResultRestoreResponse>, ApiError> {
         let body = ResultRestoreRequest {
             generated_id: generated_id.into(),
             status: status.into(),
+            logs: job_logs,
+            duration_ms,
         };
 
         let agent_id = agent_id.into();

src/services/api/models/agent/status.rs

@@ -1,6 +1,6 @@
 #![allow(dead_code)]
 
-use crate::utils::deserializer::deserialize_snake_case;
+use crate::utils::deserializer::{deserialize_snake_case, string_or_number_to_string};
 use serde::{Deserialize, Serialize};
 use toml::Value;
 
@@ -24,6 +24,8 @@ pub struct DatabaseStorage {
     #[serde(deserialize_with = "deserialize_snake_case")]
     pub config: Value,
     pub provider: String,
+    #[serde(default, rename = "folderName")]
+    pub folder_name: Option<String>,
 }
 
 #[derive(Debug, Deserialize)]
@@ -31,7 +33,12 @@ pub struct DatabaseStatus {
     pub dbms: String,
     #[serde(rename = "generatedId")]
     pub generated_id: String,
+    #[serde(default)]
     pub storages: Vec<DatabaseStorage>,
+    #[serde(default)]
+    pub storages_encrypted: Option<bool>,
+    #[serde(default)]
+    pub storages_ciphertext: Option<String>,
     pub encrypt: bool,
     pub data: DatabaseData,
 }
@@ -54,4 +61,6 @@ pub struct RestoreInfo {
     pub file: Option<String>,
     #[serde(rename = "metaFile")]
     pub meta_file: Option<String>,
+    #[serde(default, deserialize_with = "string_or_number_to_string")]
+    pub size: Option<String>,
 }

src/services/backup/compressor.rs

@@ -1,14 +1,17 @@
+use super::logger::JobLogger;
 use super::service::BackupService;
 use crate::utils::compress::compress_to_tar_gz_large;
 use anyhow::Result;
 use std::path::PathBuf;
+use std::sync::Arc;
 
 impl BackupService {
-    pub async fn compress_backup(&self, backup_file: Option<PathBuf>) -> Result<PathBuf> {
+    pub async fn compress_backup(&self, backup_file: Option<PathBuf>, logger: Arc<JobLogger>) -> Result<PathBuf> {
         let file = backup_file.ok_or_else(|| anyhow::anyhow!("No backup file generated"))?;
 
-        let compression = compress_to_tar_gz_large(&file).await?;
-
+        logger.log("info", "Start compressing archive".to_string());
+        let compression = compress_to_tar_gz_large(&file, logger).await?;
+        
         Ok(compression.compressed_path)
     }
 }

src/services/backup/executor.rs

@@ -1,3 +1,4 @@
+use super::logger::JobLogger;
 use super::service::BackupService;
 use crate::services::api::models::agent::status::DatabaseStorage;
 use crate::services::config::DatabaseConfig;
@@ -5,6 +6,8 @@ use crate::utils::common::BackupMethod;
 use crate::utils::locks::FileLock;
 
 use anyhow::Result;
+use std::sync::Arc;
+use std::time::Instant;
 use tempfile::TempDir;
 
 impl BackupService {
@@ -16,9 +19,13 @@ impl BackupService {
         storages: Vec<DatabaseStorage>,
         encrypt: bool,
     ) -> Result<()> {
+        let logger = Arc::new(JobLogger::new());
+
         if FileLock::is_locked(&generated_id).await? {
             anyhow::bail!("backup already running");
         }
+        let start = Instant::now();
+        logger.log("info", "Database backup job started".to_string());
 
         let backup = self.create_backup_record(&generated_id, &method).await?;
         let backup_id = backup.backup.id;
@@ -26,21 +33,27 @@ impl BackupService {
         let temp_dir = TempDir::new()?;
         let tmp_path = temp_dir.path();
 
-        let mut result = Self::run(db_cfg, tmp_path).await?;
+        let mut result = Self::run(db_cfg, tmp_path, Arc::clone(&logger)).await?;
 
         if result.status == "failed" {
-            self.send_result(result, vec![], &backup_id).await?;
+            let duration_ms = start.elapsed().as_millis() as f64;
+            let logs = Arc::try_unwrap(logger).unwrap_or_else(|_| JobLogger::new()).into_entries();
+            self.send_result(result, vec![], &backup_id, logs, duration_ms).await?;
             return Ok(());
         }
 
-        let compressed = self.compress_backup(result.backup_file.take()).await?;
+        let compressed = self.compress_backup(result.backup_file.take(), Arc::clone(&logger)).await?;
         result.backup_file = Some(compressed);
 
         let uploads = self
-            .upload(result.clone(), method, storages, encrypt, &backup_id)
+            .upload(result.clone(), method, storages, encrypt, &backup_id, Arc::clone(&logger))
             .await?;
 
-        self.send_result(result, uploads, &backup_id).await?;
+        logger.log("info", "Database backup job finished".to_string());
+
+        let duration_ms = start.elapsed().as_millis() as f64;
+        let logs = Arc::try_unwrap(logger).unwrap_or_else(|_| JobLogger::new()).into_entries();
+        self.send_result(result, uploads, &backup_id, logs, duration_ms).await?;
 
         Ok(())
     }

src/services/backup/logger.rs

@@ -0,0 +1,137 @@
+use chrono::Utc;
+use serde::Serialize;
+use std::sync::Mutex;
+use tracing::{event, Level};
+
+#[derive(Serialize, Clone, Debug)]
+pub struct JobLogEntry {
+    pub timestamp: String,
+    #[serde(rename = "type")]
+    pub entry_type: &'static str,
+    pub level: &'static str,
+    pub message: String,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub command: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub output: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub exit_code: Option<i32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub duration_ms: Option<f64>,
+}
+
+#[derive(Default, Debug)]
+pub struct JobLogger {
+    entries: Mutex<Vec<JobLogEntry>>,
+}
+
+impl JobLogger {
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    fn trace_log(level: &'static str, message: &str) {
+        match level {
+            "trace" => event!(Level::TRACE, "{message}"),
+            "debug" => event!(Level::DEBUG, "{message}"),
+            "info" => event!(Level::INFO, "{message}"),
+            "warn" | "warning" => event!(Level::WARN, "{message}"),
+            "error" => event!(Level::ERROR, "{message}"),
+            _ => event!(Level::INFO, "{message}"),
+        }
+    }
+
+
+    #[allow(dead_code)]
+    pub fn log(&self, level: &'static str, message: impl Into<String>) {
+        let message = message.into();
+
+        Self::trace_log(level, &message);
+
+        let mut entries = self.entries.lock().unwrap();
+        entries.push(JobLogEntry {
+            timestamp: Utc::now().to_rfc3339(),
+            entry_type: "log",
+            level,
+            message,
+            command: None,
+            output: None,
+            exit_code: None,
+            duration_ms: None,
+        });
+    }
+
+    pub fn log_command(
+        &self,
+        command: impl Into<String>,
+        output: Option<String>,
+        exit_code: Option<i32>,
+        duration_ms: Option<f64>,
+    ) {
+        let level = match exit_code {
+            Some(0) | None => "debug",
+            _ => "error",
+        };
+
+
+        let cmd = command.into();
+        let message = format!("Executed: {}", cmd);
+
+        match level {
+            "debug" => {
+                tracing::debug!(
+                command = %cmd,
+                exit_code = ?exit_code,
+                duration_ms = ?duration_ms,
+                "Command executed"
+            );
+            }
+            "error" => {
+                tracing::error!(
+                command = %cmd,
+                exit_code = ?exit_code,
+                duration_ms = ?duration_ms,
+                "Command failed"
+            );
+            }
+            _ => {
+                tracing::info!(
+                command = %cmd,
+                exit_code = ?exit_code,
+                duration_ms = ?duration_ms,
+                "Command executed"
+            );
+            }
+        }
+
+        if let Some(output_text) = output.as_deref() {
+            for line in output_text.lines() {
+                if line.trim().is_empty() {
+                    continue;
+                }
+
+                match level {
+                    "debug" => tracing::debug!("{line}"),
+                    "error" => tracing::error!("{line}"),
+                    _ => tracing::info!("{line}"),
+                }
+            }
+        }
+
+        let mut entries = self.entries.lock().unwrap();
+        entries.push(JobLogEntry {
+            timestamp: Utc::now().to_rfc3339(),
+            entry_type: "command",
+            level,
+            message,
+            command: Some(cmd),
+            output,
+            exit_code,
+            duration_ms,
+        });
+    }
+
+    pub fn into_entries(self) -> Vec<JobLogEntry> {
+        self.entries.into_inner().unwrap()
+    }
+}

src/services/backup/mod.rs

@@ -1,4 +1,5 @@
 pub mod compressor;
+pub mod logger;
 pub mod dispatcher;
 pub mod executor;
 pub mod helpers;

src/services/backup/result.rs

@@ -1,3 +1,4 @@
+use super::logger::JobLogEntry;
 use super::models::{BackupResult, UploadResult};
 use super::service::BackupService;
 use crate::services::api::ApiError;
@@ -11,6 +12,8 @@ impl BackupService {
         result: BackupResult,
         upload_results: Vec<UploadResult>,
         backup_id: &String,
+        logs: Vec<JobLogEntry>,
+        duration_ms: f64,
     ) -> Result<Option<BackupResponse>, ApiError> {
         let status = if upload_results.iter().any(|r| r.success) {
             "success"
@@ -32,6 +35,8 @@ impl BackupService {
                 status,
                 file_size,
                 &result.generated_id,
+                logs,
+                duration_ms
             )
             .await
             .map_err(|e| {

src/services/backup/runner.rs

@@ -1,3 +1,4 @@
+use super::logger::JobLogger;
 use super::models::BackupResult;
 use super::service::BackupService;
 
@@ -6,10 +7,11 @@ use crate::services::config::DatabaseConfig;
 
 use anyhow::Result;
 use std::path::Path;
-use tracing::{error, info};
+use std::sync::Arc;
+use tracing::error;
 
 impl BackupService {
-    pub async fn run(cfg: DatabaseConfig, tmp_path: &Path) -> Result<BackupResult> {
+    pub async fn run(cfg: DatabaseConfig, tmp_path: &Path, logger: Arc<JobLogger>) -> Result<BackupResult> {
         let db = DatabaseFactory::create_for_backup(cfg.clone()).await;
 
         let generated_id = cfg.generated_id.clone();
@@ -19,13 +21,15 @@ impl BackupService {
             Ok(v) => v,
             Err(e) => {
                 error!("Ping failed: {}", e);
+                logger.log("error", format!("Ping failed: {}", e));
                 return Err(e.into());
             }
         };
 
-        info!("Reachable: {}", reachable);
+        logger.log("info", format!("Database reachable: {}", reachable));
 
         if !reachable {
+            logger.log("error", "Database unreachable, backup aborted");
             return Ok(BackupResult {
                 generated_id,
                 db_type,
@@ -35,7 +39,7 @@ impl BackupService {
             });
         }
 
-        match db.backup(tmp_path).await {
+        match db.backup(tmp_path, Arc::clone(&logger)).await {
             Ok(file) => Ok(BackupResult {
                 generated_id,
                 db_type,
@@ -44,16 +48,19 @@ impl BackupService {
                 code: None,
             }),
 
-            Err(e) if e.to_string() == "backup_already_in_progress" => Ok(BackupResult {
-                generated_id,
-                db_type,
-                status: "failed".into(),
-                backup_file: None,
-                code: Some("backup_already_in_progress".into()),
-            }),
+            Err(e) if e.to_string() == "backup_already_in_progress" => {
+                logger.log("warn", "Backup already in progress");
+                Ok(BackupResult {
+                    generated_id,
+                    db_type,
+                    status: "failed".into(),
+                    backup_file: None,
+                    code: Some("backup_already_in_progress".into()),
+                })
+            }
 
             Err(e) => {
-                error!("Backup failed for {}: {:?}", generated_id, e);
+                logger.log("error", format!("Backup failed: {}", e));
                 Ok(BackupResult {
                     generated_id,
                     db_type,

src/services/backup/uploader.rs

@@ -1,13 +1,13 @@
+use super::logger::JobLogger;
 use super::models::{BackupResult, UploadResult};
 use super::service::BackupService;
-
 use crate::services::api::models::agent::status::DatabaseStorage;
 use crate::services::storage;
 use crate::utils::common::BackupMethod;
-
 use anyhow::{Result, bail};
 use futures::future::join_all;
-use tracing::{error, info};
+use std::sync::Arc;
+use tracing::info;
 
 impl BackupService {
     pub async fn upload(
@@ -17,6 +17,7 @@ impl BackupService {
         storages: Vec<DatabaseStorage>,
         encrypt: bool,
         backup_id: &String,
+        logger: Arc<JobLogger>,
     ) -> Result<Vec<UploadResult>> {
         if result.code.as_deref() == Some("backup_already_in_progress") {
             info!("Skipping send: backup already in progress");
@@ -29,15 +30,13 @@ impl BackupService {
             let ctx_clone = ctx.clone();
             let result_clone = result.clone();
             let provider = storage::get_provider(&storage);
+            let logger_clone = Arc::clone(&logger);
 
             let storage_id = storage.id.clone();
             let generated_id = result_clone.generated_id.clone();
 
             async move {
-                info!(
-                    "Uploading storage -> {:?} for {:?}",
-                    storage.provider, storage_id
-                );
+                logger_clone.log("info", format!("Uploading storage {:?} (id: {})", storage.provider, storage_id));
 
                 /*
                  INIT STEP
@@ -54,7 +53,7 @@ impl BackupService {
                 {
                     Ok(v) => v,
                     Err(e) => {
-                        error!("backup_upload_init failed: {}", e);
+                        logger_clone.log("error", format!("Upload init failed: {}", e));
 
                         return UploadResult {
                             storage_id,
@@ -69,6 +68,7 @@ impl BackupService {
                 let backup_storage_id = match init {
                     Some(v) => v.backup_storage.id,
                     None => {
+                        logger_clone.log("error", "Upload init returned empty response");
                         return UploadResult {
                             storage_id,
                             success: false,
@@ -83,7 +83,7 @@ impl BackupService {
                  PROVIDER CHECK
                 */
                 let Some(provider) = provider else {
-                    error!("Skipping storage due to missing provider");
+                    logger_clone.log("error", format!("Missing provider for storage {}", storage_id));
 
                     return UploadResult {
                         storage_id,
@@ -104,23 +104,49 @@ impl BackupService {
                         method,
                         &storage,
                         Some(encrypt),
+                        &backup_storage_id,
                     )
                     .await;
 
-                let status = if upload_result.success {
-                    "success"
-                } else {
-                    "failed"
-                };
+                let status = if upload_result.success { "success" } else { "failed" };
 
                 if status != "success" {
+                    logger_clone.log("error", format!(
+                        "Upload failed for storage {}: {}",
+                        storage_id,
+                        upload_result.error.as_deref().unwrap_or("unknown error")
+                    ));
+
+                    // `backup_upload_init` opened a per-storage record; close it as "failed"
+                    // so the server is notified of the failure (no path/size on this path).
+                    if let Err(err) = ctx_clone
+                        .api
+                        .backup_upload_status(
+                            ctx_clone.edge_key.agent_id.clone(),
+                            generated_id.clone(),
+                            backup_storage_id.clone(),
+                            status,
+                            String::new(),
+                            0u64,
+                            backup_id,
+                        )
+                        .await
+                    {
+                        logger_clone.log("error", format!(
+                            "Failed-status update failed for {}: {}",
+                            storage_id, err
+                        ));
+                    }
+
                     return upload_result;
                 }
 
-                info!(
-                    "Storage {} uploaded to remote path {:?}",
-                    storage_id, upload_result.remote_file_path
-                );
+                logger_clone.log("info", format!(
+                    "Storage {} uploaded to {:?} ({} bytes)",
+                    storage_id,
+                    upload_result.remote_file_path.clone().unwrap().to_string(),
+                    upload_result.total_size.unwrap_or(0)
+                ));
 
                 /*
                  METADATA VALIDATION
@@ -129,6 +155,7 @@ impl BackupService {
                     match (&upload_result.remote_file_path, upload_result.total_size) {
                         (Some(path), Some(size)) => (path.clone(), size),
                         _ => {
+                            logger_clone.log("error", format!("Missing remote_file_path or total_size for storage {}", storage_id));
                             return UploadResult {
                                 storage_id,
                                 success: false,
@@ -158,10 +185,7 @@ impl BackupService {
                     Ok(_) => upload_result,
 
                     Err(err) => {
-                        error!(
-                            "backup_upload_status failed (storage_id={}): {}",
-                            storage_id, err
-                        );
+                        logger_clone.log("error", format!("Upload status update failed for {}: {}", storage_id, err));
 
                         UploadResult {
                             storage_id,

src/services/config.rs

@@ -3,6 +3,7 @@
 use crate::core::context::Context;
 use serde::Deserialize;
 use serde_json;
+use std::collections::HashMap;
 use std::fs::File;
 use std::io::Read;
 use std::path::Path;
@@ -17,12 +18,16 @@ pub enum DbType {
     Mysql,
     Mariadb,
     Postgresql,
+    #[serde(rename = "postgresql-cluster")]
+    PostgresqlCluster,
     MongoDB,
     Sqlite,
     Redis,
     Valkey,
     Firebird,
     Mssql,
+    #[serde(rename = "docker-volume")]
+    DockerVolume,
 }
 
 impl DbType {
@@ -31,12 +36,14 @@ impl DbType {
             DbType::Mysql => "mysql",
             DbType::Mariadb => "mariadb",
             DbType::Postgresql => "postgresql",
+            DbType::PostgresqlCluster => "postgresql-cluster",
             DbType::MongoDB => "mongodb",
             DbType::Sqlite => "sqlite",
             DbType::Redis => "redis",
             DbType::Valkey => "valkey",
             DbType::Firebird => "firebird",
             DbType::Mssql => "mssql",
+            DbType::DockerVolume => "docker-volume",
         }
     }
 }
@@ -54,6 +61,10 @@ pub struct DatabaseConfig {
     pub host: String,
     pub generated_id: String,
     pub path: String,
+    pub max_packet_size: String,
+    pub volume_name: String,
+    pub container_name: Option<String>,
+    pub options: HashMap<String, serde_json::Value>,
 }
 
 #[allow(dead_code)]
@@ -75,6 +86,10 @@ pub struct InputDatabaseConfig {
     pub host: Option<String>,
     pub generated_id: String,
     pub path: Option<String>,
+    pub max_packet_size: Option<String>,
+    pub volume_name: Option<String>,
+    pub container_name: Option<String>,
+    pub options: Option<HashMap<String, serde_json::Value>>,
 }
 
 #[allow(dead_code)]
@@ -167,21 +182,26 @@ impl ConfigService {
             }
 
             let username = match db.db_type {
-                DbType::Postgresql | DbType::Mysql | DbType::Mariadb | DbType::Mssql => {
-                    required(&db.username, &db.name, "username")?
-                }
+                DbType::Postgresql
+                | DbType::PostgresqlCluster
+                | DbType::Mysql
+                | DbType::Mariadb
+                | DbType::Mssql => required(&db.username, &db.name, "username")?,
                 _ => optional(&db.username),
             };
 
             let password = match db.db_type {
-                DbType::Postgresql | DbType::Mysql | DbType::Mariadb | DbType::Mssql => {
-                    required(&db.password, &db.name, "password")?
-                }
+                DbType::Postgresql
+                | DbType::PostgresqlCluster
+                | DbType::Mysql
+                | DbType::Mariadb
+                | DbType::Mssql => required(&db.password, &db.name, "password")?,
                 _ => optional(&db.password),
             };
 
             let host = match db.db_type {
                 DbType::Postgresql
+                | DbType::PostgresqlCluster
                 | DbType::Mysql
                 | DbType::Mariadb
                 | DbType::MongoDB
@@ -189,11 +209,12 @@ impl ConfigService {
                 | DbType::Firebird
                 | DbType::Valkey
                 | DbType::Mssql => required(&db.host, &db.name, "host")?,
-                DbType::Sqlite => optional(&db.host),
+                DbType::Sqlite | DbType::DockerVolume => optional(&db.host),
             };
 
             let port = match db.db_type {
                 DbType::Postgresql
+                | DbType::PostgresqlCluster
                 | DbType::Mysql
                 | DbType::Mariadb
                 | DbType::MongoDB
@@ -201,11 +222,17 @@ impl ConfigService {
                 | DbType::Firebird
                 | DbType::Valkey
                 | DbType::Mssql => required(&db.port, &db.name, "port")?,
-                DbType::Sqlite => db.port.unwrap_or(0),
+                DbType::Sqlite | DbType::DockerVolume => db.port.unwrap_or(0),
             };
 
             let database_name = match db.db_type {
-                DbType::Sqlite | DbType::Redis | DbType::Valkey => optional(&db.database),
+                DbType::Sqlite | DbType::Redis | DbType::Valkey | DbType::DockerVolume => {
+                    optional(&db.database)
+                }
+                DbType::PostgresqlCluster => db
+                    .database
+                    .clone()
+                    .unwrap_or_else(|| "postgres".to_string()),
                 _ => required(&db.database, &db.name, "database")?,
             };
 
@@ -214,6 +241,19 @@ impl ConfigService {
                 _ => optional(&db.path),
             };
 
+            let max_packet_size = match db.db_type {
+                DbType::Mysql | DbType::Mariadb => {
+                    db.max_packet_size.unwrap_or_else(|| "512M".to_string())
+                }
+                _ => String::new(),
+            };
+
+            let volume_name = match db.db_type {
+                DbType::DockerVolume => required(&db.volume_name, &db.name, "volume_name")?,
+                _ => optional(&db.volume_name),
+            };
+            let container_name = db.container_name.clone();
+
             databases.push(DatabaseConfig {
                 name: db.name,
                 database: database_name,
@@ -224,6 +264,10 @@ impl ConfigService {
                 port,
                 generated_id: db.generated_id,
                 path: path_val,
+                max_packet_size,
+                volume_name,
+                container_name,
+                options: db.options.unwrap_or_default(),
             });
         }
 

src/services/mod.rs

@@ -4,4 +4,4 @@ pub mod config;
 pub mod cron;
 pub mod restore;
 pub mod status;
-mod storage;
+pub mod storage;

src/services/restore/archive.rs

@@ -1,26 +1,35 @@
 use super::service::RestoreService;
-
 use crate::utils::compress::decompress_large_tar_gz;
 use crate::utils::file::decrypt_file_stream_gcm;
-
 use anyhow::Result;
 use std::path::{Path, PathBuf};
+use std::sync::Arc;
+use crate::services::backup::logger::JobLogger;
+use crate::services::config::DbType;
+use crate::utils::common::choose_restore_path;
 
 impl RestoreService {
     pub async fn prepare_archive(
         &self,
         downloaded_file: PathBuf,
         tmp_path: &Path,
+        db_type: &DbType,
+        logger: Arc<JobLogger>
     ) -> Result<PathBuf> {
+        logger.log("info", "Start preparing backup archive".to_string());
+
         let filename = downloaded_file
             .file_name()
             .unwrap()
             .to_string_lossy()
             .to_string();
 
+        logger.log("debug", format!("Archive filename: {}", filename));
+
         let is_legacy = filename.ends_with(".sql") || filename.ends_with(".dump");
 
         if is_legacy {
+            logger.log("info", "Legacy archive detected, skipping extraction".to_string());
             return Ok(downloaded_file);
         }
 
@@ -29,30 +38,54 @@ impl RestoreService {
         let mut archive = downloaded_file.clone();
 
         if encrypted {
+            logger.log("info", "Archive is encrypted, decrypting".to_string());
+
             let new_name = filename.strip_suffix(".enc").unwrap();
 
             let decrypted = tmp_path.join(new_name);
 
-            decrypt_file_stream_gcm(
+            if let Err(e) = decrypt_file_stream_gcm(
                 downloaded_file,
                 decrypted.clone(),
                 self.ctx.edge_key.master_key_b64.clone(),
             )
-            .await?;
+            .await
+            {
+                logger.log("error", format!("Failed to decrypt archive: {}", e));
+                return Err(e);
+            }
+
+            logger.log("info", format!("Archive decrypted to {}", decrypted.display()));
 
             archive = decrypted;
         }
 
-        let files = decompress_large_tar_gz(archive.as_path(), tmp_path).await?;
+        if matches!(db_type, DbType::DockerVolume) {
+            let raw_tar = tmp_path.join("volume.tar");
+            crate::utils::compress::gunzip_to_file(archive.as_path(), &raw_tar).await?;
+            logger.log("info", format!("Docker volume archive gunzipped to {}", raw_tar.display()));
+            return Ok(raw_tar);
+        }
+
+        logger.log("info", format!("Decompressing archive {}", archive.display()));
+
+        let files = match decompress_large_tar_gz(archive.as_path(), tmp_path).await {
+            Ok(f) => f,
+            Err(e) => {
+                logger.log("error", format!("Failed to decompress archive: {}", e));
+                return Err(e);
+            }
+        };
 
         if files.is_empty() {
+            logger.log("error", "Archive is empty after decompression".to_string());
             anyhow::bail!("archive empty");
         }
 
-        if files.len() == 1 {
-            Ok(files[0].clone())
-        } else {
-            Ok(archive)
-        }
+        logger.log("info", format!("Archive prepared, {} file(s) extracted", files.len()));
+
+        let chosen = choose_restore_path(&files, tmp_path, &archive);
+        logger.log("debug", format!("Restore source resolved to: {}", chosen.display()));
+        Ok(chosen)
     }
 }

src/services/restore/dispatcher.rs

@@ -20,6 +20,8 @@ impl RestoreService {
             return;
         };
 
+        let expected_size = db.data.restore.size.clone();
+
         let service = Self {
             ctx: self.ctx.clone(),
         };
@@ -27,7 +29,10 @@ impl RestoreService {
         let db_cfg = cfg.clone();
 
         tokio::spawn(async move {
-            if let Err(e) = service.execute_restore(db_cfg, file_to_restore).await {
+            if let Err(e) = service
+                .execute_restore(db_cfg, file_to_restore, expected_size)
+                .await
+            {
                 error!("Restore failed: {}", e);
             }
         });

src/services/restore/downloader.rs

@@ -1,17 +1,41 @@
 use super::service::RestoreService;
 
 use anyhow::Result;
+use futures::StreamExt;
 use reqwest::{Client, Url};
 use std::path::{Path, PathBuf};
-use tracing::info;
+use std::sync::Arc;
+use std::time::Instant;
+use tokio::io::AsyncWriteExt;
+use crate::services::backup::logger::JobLogger;
+
+fn human_size(bytes: u64) -> String {
+    if bytes >= 1024 * 1024 {
+        format!("{} MB", bytes / 1024 / 1024)
+    } else if bytes >= 1024 {
+        format!("{} KB", bytes / 1024)
+    } else {
+        format!("{bytes} B")
+    }
+}
 
 impl RestoreService {
-    pub async fn download_backup(&self, file_url: &str, tmp_path: &Path) -> Result<PathBuf> {
+    pub async fn download_backup(
+        &self,
+        file_url: &str,
+        tmp_path: &Path,
+        logger: Arc<JobLogger>,
+        expected_size: Option<String>,
+    ) -> Result<PathBuf> {
+        logger.log("info", "Start downloading backup archive".to_string());
+
         let client = Client::new();
 
         let response = client.get(file_url).send().await?;
+        let status = response.status();
 
-        if !response.status().is_success() {
+        if !status.is_success() {
+            logger.log("error", "Failed to download".to_string());
             anyhow::bail!("download failed");
         }
 
@@ -35,11 +59,65 @@ impl RestoreService {
 
         let path = tmp_path.join(&filename);
 
-        let bytes = response.bytes().await?;
+        let total = expected_size
+            .as_deref()
+            .and_then(|s| s.trim().parse::<u64>().ok())
+            .filter(|&n| n > 0);
 
-        tokio::fs::write(&path, &bytes).await?;
+        logger.log(
+            "info",
+            format!(
+                "Downloading backup '{}' ({})",
+                filename,
+                total.map(human_size).unwrap_or_else(|| "unknown size".to_string())
+            ),
+        );
 
-        info!("Backup downloaded to {}", path.display());
+        let start = Instant::now();
+        let mut file = tokio::fs::File::create(&path).await?;
+        let mut stream = response.bytes_stream();
+        let mut downloaded: u64 = 0;
+        let mut next_pct: u64 = 10;
+
+        while let Some(chunk) = stream.next().await {
+            let chunk = chunk?;
+            file.write_all(&chunk).await?;
+            downloaded += chunk.len() as u64;
+
+            if let Some(total) = total {
+                let pct = (downloaded.saturating_mul(100) / total).min(100);
+                let milestone = pct / 10 * 10;
+                if milestone >= next_pct {
+                    logger.log(
+                        "info",
+                        format!(
+                            "Download progress: {}% ({} / {} bytes)",
+                            milestone, downloaded, total
+                        ),
+                    );
+                    next_pct = milestone + 10;
+                }
+            }
+        }
+
+        file.flush().await?;
+
+        if downloaded == 0 {
+            logger.log(
+                "warn",
+                format!("Downloaded 0 bytes (status {status}); backup body was empty"),
+            );
+        }
+
+        logger.log(
+            "info",
+            format!(
+                "Backup downloaded to {} ( {} bytes in {:.1}s)",
+                path.display(),
+                downloaded,
+                start.elapsed().as_secs_f64()
+            ),
+        );
 
         Ok(path)
     }

src/services/restore/executor.rs

@@ -1,23 +1,45 @@
 use super::service::RestoreService;
+use crate::services::backup::logger::JobLogger;
 use crate::services::config::DatabaseConfig;
 use anyhow::Result;
+use std::sync::Arc;
+use std::time::Instant;
 use tempfile::TempDir;
-use tracing::info;
 
 impl RestoreService {
-    pub async fn execute_restore(&self, cfg: DatabaseConfig, file_url: String) -> Result<()> {
+    pub async fn execute_restore(
+        &self,
+        cfg: DatabaseConfig,
+        file_url: String,
+        expected_size: Option<String>,
+    ) -> Result<()> {
+        let logger = Arc::new(JobLogger::new());
+        let start = Instant::now();
+
+        logger.log("info", "Database restoration job started".to_string());
+
         let temp_dir = TempDir::new()?;
         let tmp_path = temp_dir.path();
 
-        info!("Created temp directory {}", tmp_path.display());
+        logger.log("info", format!("Created temp directory {}", tmp_path.display()));
 
-        let downloaded = self.download_backup(&file_url, tmp_path).await?;
+        let downloaded = self
+            .download_backup(&file_url, tmp_path, Arc::clone(&logger), expected_size)
+            .await?;
 
-        let backup_file = self.prepare_archive(downloaded, tmp_path).await?;
+        let backup_file = self
+            .prepare_archive(downloaded, tmp_path, &cfg.db_type, Arc::clone(&logger))
+            .await?;
 
-        let result = self.run_restore(cfg, backup_file).await?;
+        let result = self.run_restore(cfg, backup_file, Arc::clone(&logger)).await?;
 
-        self.send_result(result).await;
+        logger.log("info", "Database restore job finished".to_string());
+
+        let duration_ms = start.elapsed().as_millis() as f64;
+        let logs = Arc::try_unwrap(logger)
+            .unwrap_or_else(|_| JobLogger::new())
+            .into_entries();
+        self.send_result(result, logs, duration_ms).await?;
 
         Ok(())
     }

src/services/restore/result.rs

@@ -1,31 +1,38 @@
 use super::models::RestoreResult;
 use super::service::RestoreService;
+use crate::services::api::ApiError;
+use crate::services::api::models::agent::restore::ResultRestoreResponse;
 
 use tracing::{error, info};
+use crate::services::backup::logger::JobLogEntry;
 
 impl RestoreService {
-    pub async fn send_result(&self, result: RestoreResult) {
+    pub async fn send_result(
+        &self,
+        result: RestoreResult,
+        logs: Vec<JobLogEntry>,
+        duration_ms: f64,
+    ) -> Result<Option<ResultRestoreResponse>, ApiError> {
         info!(
-            "[RestoreService] DB: {} | Status: {}",
-            result.generated_id, result.status
+            "[RestoreService] DB: {} | Status: {} | Duration: {}ms",
+            result.generated_id,
+            result.status,
+            duration_ms
         );
 
-        match self
-            .ctx
+        self.ctx
             .api
             .restore_result(
                 self.ctx.edge_key.agent_id.clone(),
                 &result.generated_id,
                 &result.status,
+                logs,
+                duration_ms
             )
             .await
-        {
-            Ok(_) => {
-                info!("Restoration result sent successfully");
-            }
-            Err(e) => {
+            .map_err(|e| {
                 error!("Failed to send restoration result: {}", e);
-            }
-        }
+                e.into()
+            })
     }
-}
+}

src/services/restore/runner.rs

@@ -4,39 +4,65 @@ use super::service::RestoreService;
 use crate::domain::factory::DatabaseFactory;
 use crate::services::config::DatabaseConfig;
 
+use crate::services::backup::logger::JobLogger;
 use anyhow::Result;
 use std::path::PathBuf;
-use tracing::{error, info};
+use std::sync::Arc;
 
 impl RestoreService {
     pub async fn run_restore(
         &self,
         cfg: DatabaseConfig,
         backup_file: PathBuf,
+        logger: Arc<JobLogger>,
     ) -> Result<RestoreResult> {
         let generated_id = cfg.generated_id.clone();
 
+        logger.log(
+            "info",
+            format!("Preparing restore for database {}", cfg.name),
+        );
+
         let db = DatabaseFactory::create_for_restore(cfg.clone(), &backup_file).await;
 
+        logger.log(
+            "debug",
+            format!("Checking reachability for database {}", cfg.name),
+        );
+
         let reachable = db.ping().await.unwrap_or(false);
 
-        info!("Reachable: {}", reachable);
+        logger.log("info", format!("Reachable: {}", reachable));
 
         if !reachable {
+            logger.log(
+                "error",
+                format!("Database {} unreachable, aborting restore", cfg.name),
+            );
+
             return Ok(RestoreResult {
                 generated_id,
                 status: "failed".into(),
             });
         }
 
-        match db.restore(&backup_file).await {
-            Ok(_) => Ok(RestoreResult {
-                generated_id,
-                status: "success".into(),
-            }),
+        match db.restore(&backup_file, Arc::clone(&logger)).await {
+            Ok(_) => {
+                logger.log(
+                    "info",
+                    format!("Restore completed successfully for database {}", cfg.name),
+                );
+                Ok(RestoreResult {
+                    generated_id,
+                    status: "success".into(),
+                })
+            }
 
             Err(e) => {
-                error!("Restore failed: {:?}", e);
+                logger.log(
+                    "error",
+                    format!("Restore failed for database {}: {:?}", cfg.name, e),
+                );
 
                 Ok(RestoreResult {
                     generated_id,

src/services/status.rs

@@ -1,16 +1,18 @@
 #![allow(dead_code)]
 
 use crate::core::context::Context;
+use crate::domain::factory::DatabaseFactory;
 use crate::services::api::endpoints::status::DatabasePayload;
+use crate::services::api::models::agent::status::DatabaseStorage;
 use crate::services::api::models::agent::status::PingResult;
 use crate::services::config::DatabaseConfig;
 use crate::settings::CONFIG;
+use crate::utils::file::decrypt_json_gcm;
+use futures_util::future::try_join_all;
 use reqwest::Client;
 use std::error::Error;
 use std::sync::Arc;
-use futures_util::future::try_join_all;
 use tracing::info;
-use crate::domain::factory::DatabaseFactory;
 
 pub struct StatusService {
     ctx: Arc<Context>,
@@ -28,12 +30,12 @@ impl StatusService {
     pub async fn ping(&self, databases: &[DatabaseConfig]) -> Result<PingResult, Box<dyn Error>> {
         let edge_key = &self.ctx.edge_key;
 
-        let databases_payload: Vec<DatabasePayload> = try_join_all(
-            databases.into_iter().map(|db| async move {
+        let databases_payload: Vec<DatabasePayload> =
+            try_join_all(databases.into_iter().map(|db| async move {
                 let db_engine = DatabaseFactory::create_for_backup(db.clone()).await;
 
                 let reachable = db_engine.ping().await?;
-                info!("Ping {} => {:?}",db.name, reachable);
+                info!("Ping {} => {:?}", db.name, reachable);
 
                 Ok::<DatabasePayload, anyhow::Error>(DatabasePayload {
                     name: &db.name,
@@ -41,16 +43,31 @@ impl StatusService {
                     generated_id: &db.generated_id,
                     ping_status: reachable,
                 })
-            })
-        ).await?;
+            }))
+            .await?;
 
         let version_str = CONFIG.app_version.as_str();
-        let result = self
+        let mut result = self
             .ctx
             .api
             .agent_status(&edge_key.agent_id, &version_str, databases_payload)
             .await?
             .unwrap();
+
+        for db in result.databases.iter_mut() {
+            if db.storages_encrypted == Some(true) {
+                let ciphertext = db
+                    .storages_ciphertext
+                    .as_deref()
+                    .ok_or("storages_encrypted set but storages_ciphertext missing")?;
+
+                let plaintext = decrypt_json_gcm(ciphertext, &edge_key.master_key_b64)
+                    .map_err(|e| format!("Failed to decrypt storages: {e}"))?;
+
+                db.storages = serde_json::from_slice::<Vec<DatabaseStorage>>(&plaintext)
+                    .map_err(|e| format!("Failed to parse decrypted storages: {e}"))?;
+            }
+        }
         Ok(result)
     }
 }

src/services/storage/mod.rs

@@ -5,6 +5,8 @@ use crate::services::api::models::agent::status::DatabaseStorage;
 use crate::services::backup::models::{BackupResult, UploadResult};
 use crate::utils::common::BackupMethod;
 use async_trait::async_trait;
+use providers::azure_blob;
+use providers::google_cloud_storage;
 use providers::google_drive;
 use providers::local;
 use providers::s3;
@@ -20,6 +22,7 @@ pub trait StorageProvider: Send + Sync {
         method: BackupMethod,
         config: &DatabaseStorage,
         encrypt: Option<bool>,
+        backup_storage_id: &str,
     ) -> UploadResult;
 }
 
@@ -31,7 +34,11 @@ pub fn get_provider(storage: &DatabaseStorage) -> Option<Box<dyn StorageProvider
     match storage.provider.as_str() {
         "local" => Some(Box::new(local::LocalProvider {})),
         "s3" => Some(Box::new(s3::S3Provider {})),
+        "blob" => Some(Box::new(azure_blob::AzureBlobProvider {})),
         "google-drive" => Some(Box::new(google_drive::GoogleDriveProvider {})),
+        "google-cloud-storage" => Some(Box::new(
+            google_cloud_storage::GoogleCloudStorageProvider {},
+        )),
         _ => {
             error!("Unknown storage provider: {}", storage.provider);
             None

src/services/storage/providers/azure_blob/helpers.rs

@@ -0,0 +1,174 @@
+use anyhow::{Context as _, Result, anyhow};
+use base64::Engine;
+use base64::engine::general_purpose::STANDARD;
+use chrono::{Duration, Utc};
+use openssl::hash::MessageDigest;
+use openssl::pkey::PKey;
+use openssl::sign::Signer;
+use url::Url;
+use azure_core::http::RequestContent;
+use azure_storage_blob::clients::{BlobClient, BlockBlobClient};
+use azure_storage_blob::models::BlockLookupList;
+use bytes::{Bytes, BytesMut};
+use futures::{Stream, StreamExt};
+use std::pin::Pin;
+use tracing::info;
+
+#[derive(Debug, Clone)]
+pub struct ResolvedAzure {
+    pub account_name: String,
+    pub account_key: String,
+    pub blob_endpoint: String,
+}
+
+#[derive(Clone, Copy)]
+pub enum SasResource {
+    Blob,
+    #[allow(dead_code)]
+    Container,
+}
+
+impl SasResource {
+    fn code(self) -> &'static str {
+        match self { SasResource::Blob => "b", SasResource::Container => "c" }
+    }
+}
+
+pub(crate) const SAS_VERSION: &str = "2022-11-02";
+
+pub(crate) fn hmac_sha256_b64(key: &[u8], data: &str) -> Result<String> {
+    let pkey = PKey::hmac(key).context("hmac key")?;
+    let mut signer = Signer::new(MessageDigest::sha256(), &pkey).context("signer")?;
+    signer.update(data.as_bytes()).context("signer update")?;
+    let sig = signer.sign_to_vec().context("sign")?;
+    Ok(STANDARD.encode(sig))
+}
+
+pub fn build_service_sas(
+    resolved: &ResolvedAzure,
+    canonical_resource: &str,
+    resource: SasResource,
+    permissions: &str,
+) -> Result<Vec<(String, String)>> {
+    let key = STANDARD
+        .decode(&resolved.account_key)
+        .map_err(|_| anyhow!("account key is not valid base64"))?;
+
+    let signed_start = String::new();
+    let signed_expiry = (Utc::now() + Duration::hours(1))
+        .format("%Y-%m-%dT%H:%M:%SZ").to_string();
+    let signed_protocol = "https,http"; // Azurite is http
+    let signed_resource = resource.code();
+
+    let string_to_sign = format!(
+        "{sp}\n{st}\n{se}\n{canon}\n{si}\n{sip}\n{spr}\n{sv}\n{sr}\n{snap}\n{enc}\n{rscc}\n{rscd}\n{rsce}\n{rscl}\n{rsct}",
+        sp = permissions, st = signed_start, se = signed_expiry, canon = canonical_resource,
+        si = "", sip = "", spr = signed_protocol, sv = SAS_VERSION, sr = signed_resource,
+        snap = "", enc = "", rscc = "", rscd = "", rsce = "", rscl = "", rsct = "",
+    );
+
+    let sig = hmac_sha256_b64(&key, &string_to_sign)?;
+
+    Ok(vec![
+        ("sv".into(), SAS_VERSION.into()),
+        ("sr".into(), signed_resource.into()),
+        ("sp".into(), permissions.into()),
+        ("se".into(), signed_expiry),
+        ("spr".into(), signed_protocol.into()),
+        ("sig".into(), sig),
+    ])
+}
+
+pub fn build_sas_url(
+    resolved: &ResolvedAzure,
+    container: &str,
+    blob: &str,
+    resource: SasResource,
+    permissions: &str,
+) -> Result<Url> {
+    let canonical = if blob.is_empty() {
+        format!("/blob/{}/{}", resolved.account_name, container)
+    } else {
+        format!("/blob/{}/{}/{}", resolved.account_name, container, blob)
+    };
+    let pairs = build_service_sas(resolved, &canonical, resource, permissions)?;
+
+    let base = if blob.is_empty() {
+        format!("{}/{}", resolved.blob_endpoint.trim_end_matches('/'), container)
+    } else {
+        format!("{}/{}/{}", resolved.blob_endpoint.trim_end_matches('/'), container, blob)
+    };
+
+    let mut url = Url::parse(&base).context("invalid blob endpoint/url")?;
+    {
+        let mut qp = url.query_pairs_mut();
+        for (k, v) in pairs { qp.append_pair(&k, &v); }
+    }
+    Ok(url)
+}
+
+pub const BLOCK_SIZE: usize = 100 * 1024 * 1024;
+
+type ByteStream = Pin<Box<dyn Stream<Item = Result<Bytes, std::io::Error>> + Send>>;
+
+async fn stage_block(
+    bbc: &BlockBlobClient,
+    index: u32,
+    block: Bytes,
+    block_ids: &mut Vec<Vec<u8>>,
+) -> Result<()> {
+    let raw_id = format!("{index:032}").into_bytes();
+    let len = block.len() as u64;
+    bbc.stage_block(&raw_id, len, RequestContent::from(block.to_vec()), None)
+        .await
+        .map_err(|e| anyhow!("stage_block {index} failed: {e}"))?;
+    block_ids.push(raw_id);
+    info!("staged azure block {index} ({len} bytes)");
+    Ok(())
+}
+
+pub async fn upload_stream_to_azure(
+    resolved: &ResolvedAzure,
+    container: &str,
+    blob: &str,
+    mut body: ByteStream,
+    block_size: usize,
+) -> Result<()> {
+    let url = build_sas_url(resolved, container, blob, SasResource::Blob, "cw")?;
+    let blob_client = BlobClient::new(url, None, None).context("blob client")?;
+    let bbc = blob_client.block_blob_client();
+
+    let mut buffer = BytesMut::with_capacity(block_size);
+    let mut block_ids: Vec<Vec<u8>> = Vec::new();
+    let mut index: u32 = 0;
+
+    while let Some(item) = body.next().await {
+        let bytes = item.context("stream error during upload")?;
+        buffer.extend_from_slice(&bytes);
+
+        while buffer.len() >= block_size {
+            let block = buffer.split_to(block_size).freeze();
+            stage_block(&bbc, index, block, &mut block_ids).await?;
+            index += 1;
+        }
+    }
+
+    if !buffer.is_empty() {
+        let block = buffer.split().freeze();
+        stage_block(&bbc, index, block, &mut block_ids).await?;
+    }
+
+    if block_ids.is_empty() {
+        stage_block(&bbc, 0, Bytes::new(), &mut block_ids).await?;
+    }
+
+    let block_list = BlockLookupList {
+        latest: Some(block_ids),
+        ..Default::default()
+    };
+    bbc.commit_block_list(block_list.try_into()?, None)
+        .await
+        .map_err(|e| anyhow!("commit_block_list failed: {e}"))?;
+
+    Ok(())
+}

src/services/storage/providers/azure_blob/mod.rs

@@ -0,0 +1,135 @@
+pub mod helpers;
+pub(crate) mod models;
+
+use crate::core::context::Context;
+use crate::services::api::models::agent::status::DatabaseStorage;
+use crate::services::backup::models::{BackupResult, UploadResult};
+use crate::services::storage::StorageProvider;
+use crate::services::storage::providers::azure_blob::helpers::{BLOCK_SIZE, upload_stream_to_azure};
+use crate::services::storage::providers::azure_blob::models::AzureBlobProviderConfig;
+use crate::utils::common::BackupMethod;
+use crate::utils::file::{full_file_name, full_file_path};
+use crate::utils::stream::build_stream;
+use async_trait::async_trait;
+use std::sync::Arc;
+use tokio::fs;
+use tracing::{error, info};
+
+pub struct AzureBlobProvider {}
+
+#[async_trait]
+impl StorageProvider for AzureBlobProvider {
+    async fn upload(
+        &self,
+        ctx: Arc<Context>,
+        result: BackupResult,
+        _method: BackupMethod,
+        storage: &DatabaseStorage,
+        encrypt: Option<bool>,
+        _backup_storage_id: &str,
+    ) -> UploadResult {
+        let Some(file_path) = result.backup_file else {
+            return UploadResult {
+                storage_id: storage.id.clone(),
+                success: false,
+                error: Some("Missing backup file path".to_string()),
+                remote_file_path: None,
+                total_size: None,
+            };
+        };
+
+        let total_size = match fs::metadata(&file_path).await {
+            Ok(meta) => meta.len(),
+            Err(e) => {
+                error!("Failed to get file size: {}", e);
+                return UploadResult {
+                    storage_id: storage.id.clone(),
+                    success: false,
+                    error: Some(e.to_string()),
+                    remote_file_path: None,
+                    total_size: None,
+                };
+            }
+        };
+
+        let encrypt = encrypt.unwrap_or(false);
+
+        let upload = match build_stream(&file_path, encrypt, &ctx.edge_key.master_key_b64).await {
+            Ok(u) => u,
+            Err(e) => {
+                error!("Stream build failed: {}", e);
+                return UploadResult {
+                    storage_id: storage.id.clone(),
+                    success: false,
+                    error: Some(e.to_string()),
+                    remote_file_path: None,
+                    total_size: None,
+                };
+            }
+        };
+
+        let config: AzureBlobProviderConfig = match storage.clone().config.try_into() {
+            Ok(c) => c,
+            Err(e) => {
+                return UploadResult {
+                    storage_id: storage.id.clone(),
+                    success: false,
+                    error: Some(e.to_string()),
+                    remote_file_path: None,
+                    total_size: None,
+                };
+            }
+        };
+
+        let resolved = match config.resolve() {
+            Ok(r) => r,
+            Err(e) => {
+                return UploadResult {
+                    storage_id: storage.id.clone(),
+                    success: false,
+                    error: Some(e.to_string()),
+                    remote_file_path: None,
+                    total_size: None,
+                };
+            }
+        };
+
+        let file_name = full_file_name(encrypt);
+        let remote_file_path = full_file_path(&file_name, storage.folder_name.as_deref());
+        info!(
+            "Starting block upload to azure blob {}/{}",
+            config.container_name, remote_file_path
+        );
+
+        match upload_stream_to_azure(
+            &resolved,
+            &config.container_name,
+            &remote_file_path,
+            upload.stream,
+            BLOCK_SIZE,
+        )
+        .await
+        {
+            Ok(_) => {
+                info!("Azure blob upload successful: {}", remote_file_path);
+                UploadResult {
+                    storage_id: storage.id.clone(),
+                    success: true,
+                    error: None,
+                    remote_file_path: Some(remote_file_path),
+                    total_size: Some(total_size),
+                }
+            }
+            Err(e) => {
+                error!("Azure blob upload failed: {:?}", e);
+                UploadResult {
+                    storage_id: storage.id.clone(),
+                    success: false,
+                    error: Some(e.to_string()),
+                    remote_file_path: None,
+                    total_size: None,
+                }
+            }
+        }
+    }
+}

src/services/storage/providers/azure_blob/models.rs

@@ -0,0 +1,106 @@
+use crate::services::storage::providers::azure_blob::helpers::ResolvedAzure;
+use anyhow::{Result, anyhow};
+use serde::{Deserialize, Serialize};
+use url::Url;
+
+#[derive(Debug, Deserialize, Serialize)]
+pub struct AzureBlobProviderConfig {
+    #[serde(default)]
+    pub account_name: String,
+    #[serde(default)]
+    pub account_key: String,
+    pub container_name: String,
+    #[serde(default)]
+    pub auth_mode: Option<String>,
+    #[serde(default)]
+    pub connection_string: String,
+    #[serde(default)]
+    pub endpoint_url: Option<String>,
+}
+
+fn parse_connection_string(cs: &str) -> std::collections::HashMap<String, String> {
+    cs.split(';')
+        .filter(|s| !s.trim().is_empty())
+        .filter_map(|pair| {
+            let mut it = pair.splitn(2, '=');
+            let k = it.next()?.trim().to_string();
+            let v = it.next()?.trim().to_string();
+            Some((k, v))
+        })
+        .collect()
+}
+
+
+pub(crate) fn ensure_account_in_endpoint(endpoint: &str, account: &str) -> String {
+    let trimmed = endpoint.trim_end_matches('/');
+    if account.is_empty() {
+        return trimmed.to_string();
+    }
+    if let Ok(url) = Url::parse(trimmed) {
+        let host = url.host_str().unwrap_or("");
+        if host.contains(account) {
+            return trimmed.to_string();
+        }
+        let path = url.path().trim_matches('/');
+        if path == account || path.starts_with(&format!("{account}/")) {
+            return trimmed.to_string();
+        }
+    }
+    format!("{trimmed}/{account}")
+}
+
+impl AzureBlobProviderConfig {
+    pub fn resolve(&self) -> Result<ResolvedAzure> {
+        let mode = self.auth_mode.as_deref().unwrap_or("").trim();
+        let has_connection_string = !self.connection_string.trim().is_empty();
+
+        if mode == "connectionString" || (mode.is_empty() && has_connection_string) {
+            if !has_connection_string {
+                return Err(anyhow!(
+                    "authMode is connectionString but connectionString is empty"
+                ));
+            }
+            let map = parse_connection_string(&self.connection_string);
+            let account_name = map
+                .get("AccountName")
+                .cloned()
+                .unwrap_or_else(|| self.account_name.clone());
+            let account_key = map
+                .get("AccountKey")
+                .cloned()
+                .unwrap_or_else(|| self.account_key.clone());
+            let blob_endpoint = map
+                .get("BlobEndpoint")
+                .cloned()
+                .ok_or_else(|| anyhow!("connection string missing BlobEndpoint"))?;
+            return Ok(ResolvedAzure {
+                account_name,
+                account_key,
+                blob_endpoint,
+            });
+        }
+
+        if self.account_name.trim().is_empty() {
+            return Err(anyhow!("accountName required for accountKey auth"));
+        }
+        if self.account_key.trim().is_empty() {
+            return Err(anyhow!("accountKey required for accountKey auth"));
+        }
+
+        let blob_endpoint = match self
+            .endpoint_url
+            .as_deref()
+            .map(str::trim)
+            .filter(|s| !s.is_empty())
+        {
+            Some(endpoint) => ensure_account_in_endpoint(endpoint, &self.account_name),
+            None => format!("https://{}.blob.core.windows.net", self.account_name),
+        };
+
+        Ok(ResolvedAzure {
+            account_name: self.account_name.clone(),
+            account_key: self.account_key.clone(),
+            blob_endpoint,
+        })
+    }
+}

src/services/storage/providers/google_cloud_storage/helpers.rs

@@ -0,0 +1,122 @@
+use crate::services::storage::providers::google_cloud_storage::models::GoogleCloudStorageProviderConfig;
+use anyhow::{Context, Result};
+use bytes::Bytes;
+use futures::Stream;
+use futures::StreamExt;
+use google_cloud_auth::credentials::Credentials;
+use google_cloud_storage::client::Storage;
+use google_cloud_storage::streaming_source::{SizeHint, StreamingSource};
+use std::pin::Pin;
+
+pub fn build_credentials(cfg: &GoogleCloudStorageProviderConfig) -> Result<Credentials> {
+    // Service-account JSON stores the PEM with `\n` escape sequences. When the key is
+    // carried through config as a JSON string those can arrive as literal two-char `\n`
+    // sequences rather than real newlines, so the PEM parser finds no `-----BEGIN-----`
+    // line ("no items found"). Normalize them back to real newlines. A PEM that already
+    // has real newlines contains no literal `\n` pairs, so this is a no-op for it.
+    let private_key = cfg.private_key.replace("\\n", "\n");
+
+    let key = serde_json::json!({
+        "type": "service_account",
+        "project_id": cfg.project_id,
+        "client_email": cfg.client_email,
+        "private_key": private_key,
+        "private_key_id": "",
+        "token_uri": "https://oauth2.googleapis.com/token",
+        "universe_domain": "googleapis.com",
+    });
+
+    google_cloud_auth::credentials::service_account::Builder::new(key)
+        .build()
+        .context("failed to build GCS service account credentials")
+}
+
+pub async fn build_client(cfg: &GoogleCloudStorageProviderConfig) -> Result<Storage> {
+    let endpoint = cfg.api_endpoint.as_deref().filter(|s| !s.trim().is_empty());
+
+    // A custom endpoint means a local emulator (fake-gcs-server), which does not verify
+    // credentials. Use anonymous creds so a dummy/empty `private_key` in the emulator
+    // config doesn't trip the service-account PEM parser. Real GCS still uses the
+    // service-account key built from config.
+    let builder = if let Some(ep) = endpoint {
+        let creds = google_cloud_auth::credentials::anonymous::Builder::new().build();
+        Storage::builder()
+            .with_credentials(creds)
+            .with_endpoint(ep.to_string())
+    } else {
+        Storage::builder().with_credentials(build_credentials(cfg)?)
+    };
+
+    builder.build().await.context("failed to build GCS client")
+}
+
+/// Bridges `build_stream`'s `Send`-only byte stream into the SDK's `StreamingSource`
+/// (which `send_buffered` requires to be `Send + Sync + 'static`) via a bounded mpsc
+/// channel. Also reports an exact `size_hint`: the SDK picks single-shot vs resumable
+/// upload from `size_hint().upper()` — an unknown bound forces resumable unconditionally
+/// (see `upload_with_client`).
+pub struct StreamSource {
+    rx: tokio::sync::mpsc::Receiver<Result<Bytes, std::io::Error>>,
+    total_size: u64,
+}
+
+impl StreamSource {
+    pub fn from_stream(
+        mut stream: Pin<Box<dyn Stream<Item = Result<Bytes, std::io::Error>> + Send>>,
+        total_size: u64,
+    ) -> Self {
+        let (tx, rx) = tokio::sync::mpsc::channel(8);
+        tokio::spawn(async move {
+            while let Some(item) = stream.next().await {
+                if tx.send(item).await.is_err() {
+                    break;
+                }
+            }
+        });
+        StreamSource { rx, total_size }
+    }
+}
+
+impl StreamingSource for StreamSource {
+    type Error = std::io::Error;
+    async fn next(&mut self) -> Option<Result<Bytes, Self::Error>> {
+        self.rx.recv().await
+    }
+
+    // Report the exact size so the SDK can choose single-shot uploads. The default
+    // impl returns an unknown bound, which forces the resumable path unconditionally.
+    async fn size_hint(&self) -> Result<SizeHint, Self::Error> {
+        Ok(SizeHint::with_exact(self.total_size))
+    }
+}
+
+pub async fn upload_with_client(
+    client: &Storage,
+    bucket: &str,
+    object: &str,
+    source: StreamSource,
+    force_single_shot: bool,
+) -> Result<()> {
+    // `write_object` uses gRPC-style resource names: the bucket must be passed as
+    // `projects/_/buckets/<name>`, not the bare bucket id.
+    let bucket_resource = format!("projects/_/buckets/{bucket}");
+
+    let mut builder = client.write_object(bucket_resource, object, source);
+
+    // Resumable uploads follow a server-generated `Location` URL. When pointed at a
+    // custom `apiEndpoint` on a non-443 port, the SDK's transport drops the port from
+    // the `Host` header (google-cloud-gax-internal `host.rs`), so emulators that build
+    // the `Location` from `Host` hand back a portless URL the SDK then hangs on. A
+    // single-shot upload issues one request to the configured endpoint (no `Location`
+    // to follow), sidestepping the bug. We force it only for custom endpoints; against
+    // real GCS we keep resumable (bounded memory + resume on large backups).
+    if force_single_shot {
+        builder = builder.with_resumable_upload_threshold(usize::MAX);
+    }
+
+    builder
+        .send_buffered()
+        .await
+        .context("GCS write_object failed")?;
+    Ok(())
+}

src/services/storage/providers/google_cloud_storage/mod.rs

@@ -0,0 +1,149 @@
+pub mod helpers;
+mod models;
+
+use crate::core::context::Context;
+use crate::services::api::models::agent::status::DatabaseStorage;
+use crate::services::backup::models::{BackupResult, UploadResult};
+use crate::services::storage::StorageProvider;
+use crate::services::storage::providers::google_cloud_storage::helpers::{
+    StreamSource, build_client, upload_with_client,
+};
+use crate::services::storage::providers::google_cloud_storage::models::GoogleCloudStorageProviderConfig;
+use crate::utils::common::BackupMethod;
+use crate::utils::file::{full_file_name, full_file_path};
+use crate::utils::stream::build_stream;
+use async_trait::async_trait;
+use std::sync::Arc;
+use tokio::fs;
+use tracing::{error, info};
+
+pub struct GoogleCloudStorageProvider {}
+
+#[async_trait]
+impl StorageProvider for GoogleCloudStorageProvider {
+    async fn upload(
+        &self,
+        ctx: Arc<Context>,
+        result: BackupResult,
+        _method: BackupMethod,
+        storage: &DatabaseStorage,
+        encrypt: Option<bool>,
+        _backup_storage_id: &str,
+    ) -> UploadResult {
+        let Some(file_path) = result.backup_file else {
+            return UploadResult {
+                storage_id: storage.id.clone(),
+                success: false,
+                error: Some("Missing backup file path".to_string()),
+                remote_file_path: None,
+                total_size: None,
+            };
+        };
+
+        let total_size = match fs::metadata(&file_path).await {
+            Ok(meta) => meta.len(),
+            Err(e) => {
+                error!("Failed to get file size: {}", e);
+                return UploadResult {
+                    storage_id: storage.id.clone(),
+                    success: false,
+                    error: Some(e.to_string()),
+                    remote_file_path: None,
+                    total_size: None,
+                };
+            }
+        };
+
+        let encrypt = encrypt.unwrap_or(false);
+
+        let upload = match build_stream(&file_path, encrypt, &ctx.edge_key.master_key_b64).await {
+            Ok(u) => u,
+            Err(e) => {
+                error!("Stream build failed: {}", e);
+                return UploadResult {
+                    storage_id: storage.id.clone(),
+                    success: false,
+                    error: Some(e.to_string()),
+                    remote_file_path: None,
+                    total_size: None,
+                };
+            }
+        };
+
+        let config: GoogleCloudStorageProviderConfig = match storage.clone().config.try_into() {
+            Ok(c) => c,
+            Err(e) => {
+                return UploadResult {
+                    storage_id: storage.id.clone(),
+                    success: false,
+                    error: Some(e.to_string()),
+                    remote_file_path: None,
+                    total_size: None,
+                };
+            }
+        };
+
+        let file_name = full_file_name(encrypt);
+        info!("Uploading file {}", file_name);
+        let remote_file_path = full_file_path(&file_name, storage.folder_name.as_deref());
+
+        let client = match build_client(&config).await {
+            Ok(c) => c,
+            Err(e) => {
+                error!("GCS client build failed: {:?}", e);
+                return UploadResult {
+                    storage_id: storage.id.clone(),
+                    success: false,
+                    error: Some(e.to_string()),
+                    remote_file_path: None,
+                    total_size: None,
+                };
+            }
+        };
+
+        let source = StreamSource::from_stream(upload.stream, total_size);
+
+        // A custom apiEndpoint (self-hosted / emulator) on a non-443 port trips an
+        // upstream SDK bug in the resumable-upload path; force single-shot for it.
+        let force_single_shot = config
+            .api_endpoint
+            .as_deref()
+            .is_some_and(|s| !s.trim().is_empty());
+
+        info!(
+            "Starting GCS upload to {}/{} (single_shot={})",
+            config.bucket_name, remote_file_path, force_single_shot
+        );
+
+        match upload_with_client(
+            &client,
+            &config.bucket_name,
+            &remote_file_path,
+            source,
+            force_single_shot,
+        )
+        .await
+        {
+            Ok(_) => {
+                info!("GCS upload successful: {}", remote_file_path);
+                UploadResult {
+                    storage_id: storage.id.clone(),
+                    success: true,
+                    error: None,
+                    remote_file_path: Some(remote_file_path),
+                    total_size: Some(total_size),
+                }
+            }
+            Err(e) => {
+                error!("GCS upload failed: {:?}", e);
+                UploadResult {
+                    storage_id: storage.id.clone(),
+                    success: false,
+                    error: Some(e.to_string()),
+                    remote_file_path: None,
+                    total_size: Some(total_size),
+                }
+            }
+        }
+    }
+}

src/services/storage/providers/google_cloud_storage/models.rs

@@ -0,0 +1,11 @@
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, Deserialize, Serialize)]
+pub struct GoogleCloudStorageProviderConfig {
+    pub project_id: String,
+    pub bucket_name: String,
+    pub client_email: String,
+    pub private_key: String,
+    #[serde(default)]
+    pub api_endpoint: Option<String>,
+}

src/services/storage/providers/google_drive/mod.rs

@@ -26,6 +26,7 @@ impl StorageProvider for GoogleDriveProvider {
         _method: BackupMethod,
         storage: &DatabaseStorage,
         encrypt: Option<bool>,
+        _backup_storage_id: &str,
     ) -> UploadResult {
         let Some(file_path) = result.backup_file else {
             return UploadResult {
@@ -84,7 +85,7 @@ impl StorageProvider for GoogleDriveProvider {
 
         info!("Uploading file {}", file_name);
 
-        let remote_file_path = full_file_path(&file_name);
+        let remote_file_path = full_file_path(&file_name, storage.folder_name.as_deref());
 
         match upload_stream_to_google_drive(
             &config,

src/services/storage/providers/local.rs

@@ -23,6 +23,7 @@ impl StorageProvider for LocalProvider {
         method: BackupMethod,
         storage: &DatabaseStorage,
         encrypt: Option<bool>,
+        backup_storage_id: &str,
     ) -> UploadResult {
         let Some(file_path) = result.backup_file else {
             return UploadResult {
@@ -37,7 +38,7 @@ impl StorageProvider for LocalProvider {
         let encrypt = encrypt.unwrap_or(false);
 
         let file_name = full_file_name(encrypt);
-        let remote_file_path = full_file_path(&file_name);
+        let remote_file_path = full_file_path(&file_name, storage.folder_name.as_deref());
 
         let total_size = match fs::metadata(&file_path).await {
             Ok(meta) => meta.len(),
@@ -82,6 +83,10 @@ impl StorageProvider for LocalProvider {
             "X-Generated-Id",
             HeaderValue::from_str(&result.generated_id).unwrap(),
         );
+        extra_headers.insert(
+            "X-Backup-Storage-Id",
+            HeaderValue::from_str(backup_storage_id).unwrap(),
+        );
         extra_headers.insert("X-Status", HeaderValue::from_str(&result.status).unwrap());
         extra_headers.insert(
             "X-Method",

src/services/storage/providers/mod.rs

@@ -1,3 +1,5 @@
+pub mod azure_blob;
+pub mod google_cloud_storage;
 pub mod google_drive;
 pub mod local;
 pub mod s3;

src/services/storage/providers/s3/mod.rs

@@ -34,6 +34,7 @@ impl StorageProvider for S3Provider {
         _method: BackupMethod,
         storage: &DatabaseStorage,
         encrypt: Option<bool>,
+        _backup_storage_id: &str,
     ) -> UploadResult {
         let Some(file_path) = result.backup_file else {
             return UploadResult {
@@ -147,7 +148,7 @@ impl StorageProvider for S3Provider {
         info!("Uploading file {}", file_name);
 
         let bucket = &config.bucket_name;
-        let remote_file_path = full_file_path(&file_name);
+        let remote_file_path = full_file_path(&file_name, storage.folder_name.as_deref());
         info!("S3 key {:}", remote_file_path);
         info!(
             "Starting multipart upload to s3://{}/{}",

src/settings.rs

@@ -11,6 +11,7 @@ pub struct Settings {
     pub edge_key: String,
     pub databases_config_file: String,
     pub data_path: String,
+    pub pg_bin_dir: String,
     pub pooling: usize,
     pub timezone: String,
     pub log: String,
@@ -59,6 +60,7 @@ impl Settings {
             databases_config_file: env::var("DATABASES_CONFIG_FILE")
                 .unwrap_or_else(|_| "config.json".into()),
             data_path: env::var("DATA_PATH").unwrap_or_else(|_| "/config".into()),
+            pg_bin_dir: env::var("PG_BIN_DIR").unwrap_or_default(),
             pooling: pooling_seconds,
             timezone: tz,
             log: env::var("LOG").unwrap_or_else(|_| "info".into()),

src/tests/domain/cluster/backup.rs

@@ -0,0 +1,53 @@
+use super::{env_for, start_cluster};
+use crate::domain::postgres::{cluster, connection};
+use crate::services::backup::logger::JobLogger;
+use crate::tests::init_tracing_for_test;
+use std::sync::Arc;
+use tempfile::TempDir;
+
+#[tokio::test]
+async fn produces_sql_with_roles_and_databases() {
+    init_tracing_for_test();
+    let (_c, cfg) = start_cluster("testuser").await;
+
+    let dir = TempDir::new().unwrap();
+    let logger = Arc::new(JobLogger::new());
+    let sql = cluster::backup::run(cfg.clone(), dir.path().to_path_buf(), env_for(&cfg), logger)
+        .await
+        .unwrap();
+
+    assert!(sql.is_file());
+    let contents = std::fs::read_to_string(&sql).unwrap();
+    assert!(contents.contains("CREATE ROLE"), "expected CREATE ROLE in dump");
+    assert!(
+        contents.contains("CREATE DATABASE") || contents.contains("\\connect"),
+        "expected database statements in dump"
+    );
+}
+
+#[tokio::test]
+async fn requires_superuser() {
+    init_tracing_for_test();
+    let (_c, super_cfg) = start_cluster("testuser").await;
+
+    // Create a NON-superuser login role on the cluster.
+    let client = connection::connect(&super_cfg).await.unwrap();
+    client
+        .batch_execute("CREATE ROLE appuser LOGIN PASSWORD 'changeme' NOSUPERUSER;")
+        .await
+        .unwrap();
+
+    let mut weak = super_cfg.clone();
+    weak.username = "appuser".to_string();
+
+    let dir = TempDir::new().unwrap();
+    let logger = Arc::new(JobLogger::new());
+    let err = cluster::backup::run(weak.clone(), dir.path().to_path_buf(), env_for(&weak), logger)
+        .await
+        .unwrap_err();
+
+    assert!(
+        err.to_string().contains("superuser"),
+        "expected a superuser error, got: {err}"
+    );
+}

src/tests/domain/cluster/database.rs

@@ -0,0 +1,33 @@
+use crate::domain::factory::DatabaseFactory;
+use crate::services::config::{DatabaseConfig, DbType};
+use std::path::Path;
+
+fn cluster_config() -> DatabaseConfig {
+    DatabaseConfig {
+        name: "cluster".to_string(),
+        database: "postgres".to_string(),
+        db_type: DbType::PostgresqlCluster,
+        username: "postgres".to_string(),
+        password: "changeme".to_string(),
+        port: 5432,
+        host: "localhost".to_string(),
+        generated_id: "40875631-e3d2-4dfe-a26b-2a347ecc64fd".to_string(),
+        path: String::new(),
+        max_packet_size: String::new(),
+        volume_name: String::new(),
+        container_name: None,
+        options: std::collections::HashMap::new(),
+    }
+}
+
+#[tokio::test]
+async fn factory_routes_cluster_for_backup_with_sql_extension() {
+    let db = DatabaseFactory::create_for_backup(cluster_config()).await;
+    assert_eq!(db.file_extension(), ".sql");
+}
+
+#[tokio::test]
+async fn factory_routes_cluster_for_restore_with_sql_extension() {
+    let db = DatabaseFactory::create_for_restore(cluster_config(), Path::new("dump.sql")).await;
+    assert_eq!(db.file_extension(), ".sql");
+}

src/tests/domain/cluster/mod.rs

@@ -0,0 +1,50 @@
+mod backup;
+mod database;
+mod restore;
+
+use crate::services::config::{DatabaseConfig, DbType};
+use std::collections::HashMap;
+use testcontainers::runners::AsyncRunner;
+use testcontainers::{ContainerAsync, ImageExt};
+use testcontainers_modules::postgres::Postgres;
+use url::Host;
+
+async fn start_cluster(user: &str) -> (ContainerAsync<Postgres>, DatabaseConfig) {
+    let container = Postgres::default()
+        .with_env_var("POSTGRES_DB", "postgres")
+        .with_env_var("POSTGRES_USER", user)
+        .with_env_var("POSTGRES_PASSWORD", "changeme")
+        .with_tag("17")
+        .start()
+        .await
+        .unwrap();
+
+    let host = container
+        .get_host()
+        .await
+        .unwrap_or(Host::parse("127.0.0.1").unwrap());
+    let port = container.get_host_port_ipv4(5432).await.unwrap_or(5432);
+
+    let config = DatabaseConfig {
+        name: format!("cluster-{}", user),
+        database: "postgres".to_string(),
+        db_type: DbType::PostgresqlCluster,
+        username: user.to_string(),
+        password: "changeme".to_string(),
+        port,
+        host: host.to_string(),
+        generated_id: "40875631-e3d2-4dfe-a26b-2a347ecc64fd".to_string(),
+        path: "".to_string(),
+        max_packet_size: "".to_string(),
+        volume_name: "".to_string(),
+        container_name: None,
+        options: std::collections::HashMap::new(),
+    };
+    (container, config)
+}
+
+fn env_for(cfg: &DatabaseConfig) -> HashMap<String, String> {
+    let mut env = std::env::vars().collect::<HashMap<_, _>>();
+    env.insert("PGPASSWORD".to_string(), cfg.password.clone());
+    env
+}

src/tests/domain/cluster/restore.rs

@@ -0,0 +1,83 @@
+use super::{env_for, start_cluster};
+use crate::domain::postgres::{cluster, connection};
+use crate::services::backup::logger::JobLogger;
+use crate::tests::init_tracing_for_test;
+use std::sync::Arc;
+use tempfile::TempDir;
+
+#[tokio::test]
+async fn backup_restore_round_trip_preserves_ownership() {
+    init_tracing_for_test();
+
+    // Source cluster A: seed a role + a table owned by that role.
+    let (_a, src) = start_cluster("testuser").await;
+    let client = connection::connect(&src).await.unwrap();
+    client
+        .batch_execute(
+            "CREATE ROLE appowner LOGIN PASSWORD 'changeme' NOSUPERUSER;\n\
+             CREATE TABLE owned_tbl (id int);\n\
+             ALTER TABLE owned_tbl OWNER TO appowner;",
+        )
+        .await
+        .unwrap();
+
+    let dir = TempDir::new().unwrap();
+    let sql = cluster::backup::run(src.clone(), dir.path().to_path_buf(), env_for(&src), Arc::new(JobLogger::new()))
+        .await
+        .unwrap();
+
+    // Target cluster B: fresh, same bootstrap user.
+    let (_b, mut dst) = start_cluster("testuser").await;
+
+    cluster::restore::run(dst.clone(), sql.clone(), env_for(&dst), Arc::new(JobLogger::new()))
+        .await
+        .unwrap();
+
+    // Verify the seeded role exists and the table's owner was preserved on B.
+    dst.database = "postgres".to_string();
+    let bclient = connection::connect(&dst).await.unwrap();
+    let role_exists: bool = bclient
+        .query_one("SELECT EXISTS (SELECT 1 FROM pg_roles WHERE rolname = 'appowner');", &[])
+        .await
+        .unwrap()
+        .get(0);
+    assert!(role_exists, "appowner role must be recreated on the target");
+
+    let owner: String = bclient
+        .query_one(
+            "SELECT tableowner FROM pg_tables WHERE tablename = 'owned_tbl';",
+            &[],
+        )
+        .await
+        .unwrap()
+        .get(0);
+    assert_eq!(owner, "appowner", "table ownership must be preserved");
+}
+
+#[tokio::test]
+async fn requires_superuser() {
+    init_tracing_for_test();
+    let (_c, super_cfg) = start_cluster("testuser").await;
+
+    // A non-superuser login role must be rejected before psql runs.
+    let client = connection::connect(&super_cfg).await.unwrap();
+    client
+        .batch_execute("CREATE ROLE appuser LOGIN PASSWORD 'changeme' NOSUPERUSER;")
+        .await
+        .unwrap();
+
+    let mut weak = super_cfg.clone();
+    weak.username = "appuser".to_string();
+
+    // The superuser pre-check happens before the dump file is read, so a
+    // non-existent restore path is fine — it must never be touched.
+    let missing = std::path::PathBuf::from("/nonexistent/cluster.sql");
+    let err = cluster::restore::run(weak.clone(), missing, env_for(&weak), Arc::new(JobLogger::new()))
+        .await
+        .unwrap_err();
+
+    assert!(
+        err.to_string().contains("superuser"),
+        "expected a superuser error, got: {err}"
+    );
+}

src/tests/domain/docker_volume.rs

@@ -0,0 +1,279 @@
+use crate::domain::docker_volume::docker::parse_container_id;
+
+static ENV_GUARD: tokio::sync::Mutex<()> = tokio::sync::Mutex::const_new(());
+
+#[test]
+fn parse_container_id_from_mountinfo_line() {
+    let id = "a".repeat(64);
+    let mountinfo = format!(
+        "1234 1000 0:50 / /etc/hostname rw shared:1 - ext4 /var/lib/docker/containers/{id}/hostname rw"
+    );
+    assert_eq!(parse_container_id(&mountinfo, ""), Some(id));
+}
+
+#[test]
+fn parse_container_id_from_cgroup_v1() {
+    let id = "b".repeat(64);
+    let cgroup = format!("12:memory:/docker/{id}\n11:cpu:/docker/{id}\n");
+    assert_eq!(parse_container_id("", &cgroup), Some(id));
+}
+
+#[test]
+fn parse_container_id_none_on_cgroup_v2() {
+    assert_eq!(parse_container_id("", "0::/\n"), None);
+}
+
+#[tokio::test]
+async fn docker_volume_ping_true_for_existing_volume() {
+    use crate::domain::docker_volume::docker::client;
+    use bollard::models::VolumeCreateRequest;
+    use bollard::query_parameters::RemoveVolumeOptions;
+
+    let docker = client().expect("docker daemon required for this test");
+    let vol = format!("portabase-test-{}", uuid::Uuid::new_v4());
+    docker
+        .create_volume(VolumeCreateRequest { name: Some(vol.clone()), ..Default::default() })
+        .await
+        .unwrap();
+
+    let cfg = volume_config(&vol);
+    let reachable = crate::domain::docker_volume::ping::run(cfg).await.unwrap();
+    assert!(reachable);
+
+    let missing = volume_config("portabase-does-not-exist-xyz");
+    assert!(!crate::domain::docker_volume::ping::run(missing).await.unwrap());
+
+    docker.remove_volume(&vol, None::<RemoveVolumeOptions>).await.ok();
+}
+
+fn volume_config(volume_name: &str) -> crate::services::config::DatabaseConfig {
+    use crate::services::config::{DatabaseConfig, DbType};
+    DatabaseConfig {
+        name: "vol-test".to_string(),
+        database: "".to_string(),
+        db_type: DbType::DockerVolume,
+        username: "".to_string(),
+        password: "".to_string(),
+        port: 0,
+        host: "".to_string(),
+        generated_id: uuid::Uuid::new_v4().to_string(),
+        path: "".to_string(),
+        max_packet_size: "".to_string(),
+        volume_name: volume_name.to_string(),
+        container_name: None,
+        options: std::collections::HashMap::new(),
+    }
+}
+
+async fn ensure_image(docker: &bollard::Docker, image: &str) {
+    use bollard::query_parameters::CreateImageOptionsBuilder;
+    use futures_util::StreamExt;
+
+    let (name, tag) = image.split_once(':').unwrap_or((image, "latest"));
+    let opts = CreateImageOptionsBuilder::default()
+        .from_image(name)
+        .tag(tag)
+        .build();
+    let mut stream = docker.create_image(Some(opts), None, None);
+    while let Some(item) = stream.next().await {
+        item.unwrap();
+    }
+}
+
+async fn seed_volume(docker: &bollard::Docker, volume: &str, filename: &str, content: &str) {
+    use bollard::models::{ContainerCreateBody, HostConfig};
+    use bollard::query_parameters::{
+        CreateContainerOptions, RemoveContainerOptions, StartContainerOptions,
+        WaitContainerOptions,
+    };
+    use futures_util::StreamExt;
+
+    ensure_image(docker, "busybox").await;
+
+    let body = ContainerCreateBody {
+        image: Some("busybox".to_string()),
+        cmd: Some(vec![
+            "sh".into(),
+            "-c".into(),
+            format!("printf '%s' '{content}' > /vol/{filename}"),
+        ]),
+        host_config: Some(HostConfig {
+            binds: Some(vec![format!("{volume}:/vol")]),
+            ..Default::default()
+        }),
+        ..Default::default()
+    };
+    let created = docker
+        .create_container(None::<CreateContainerOptions>, body)
+        .await
+        .unwrap();
+    docker.start_container(&created.id, None::<StartContainerOptions>).await.unwrap();
+    let mut wait = docker.wait_container(&created.id, None::<WaitContainerOptions>);
+    while wait.next().await.is_some() {}
+    docker
+        .remove_container(&created.id, Some(RemoveContainerOptions { force: true, ..Default::default() }))
+        .await
+        .ok();
+}
+
+#[tokio::test]
+async fn docker_volume_backup_captures_files() {
+    use crate::domain::docker_volume::docker::client;
+    use bollard::models::VolumeCreateRequest;
+    use bollard::query_parameters::RemoveVolumeOptions;
+
+    let _env_guard = ENV_GUARD.lock().await;
+    unsafe { std::env::set_var("PORTABASE_HELPER_IMAGE", "busybox"); }
+
+    let docker = client().expect("docker daemon required");
+    let vol = format!("portabase-test-{}", uuid::Uuid::new_v4());
+    docker
+        .create_volume(VolumeCreateRequest { name: Some(vol.clone()), ..Default::default() })
+        .await
+        .unwrap();
+    seed_volume(&docker, &vol, "hello.txt", "backup-me").await;
+
+    let tmp = tempfile::TempDir::new().unwrap();
+    let cfg = volume_config(&vol);
+    let logger = std::sync::Arc::new(crate::services::backup::logger::JobLogger::new());
+    let tar = crate::domain::docker_volume::backup::run(cfg, tmp.path().to_path_buf(), logger)
+        .await
+        .unwrap();
+
+    assert!(tar.is_file());
+    let names = tar_entry_names(&tar).await;
+    assert!(names.iter().any(|n| n.ends_with("hello.txt")), "entries: {names:?}");
+
+    docker.remove_volume(&vol, None::<RemoveVolumeOptions>).await.ok();
+}
+
+async fn tar_entry_names(tar_path: &std::path::Path) -> Vec<String> {
+    use tokio_stream::StreamExt;
+    let f = tokio::fs::File::open(tar_path).await.unwrap();
+    let mut archive = tokio_tar::Archive::new(f);
+    let mut names = Vec::new();
+    let mut entries = archive.entries().unwrap();
+    while let Some(e) = entries.next().await {
+        let e = e.unwrap();
+        names.push(e.path().unwrap().to_string_lossy().to_string());
+    }
+    names
+}
+
+#[tokio::test]
+async fn docker_volume_restore_is_clean_replace() {
+    use crate::domain::docker_volume::docker::client;
+    use bollard::models::VolumeCreateRequest;
+    use bollard::query_parameters::RemoveVolumeOptions;
+    
+    let _env_guard = ENV_GUARD.lock().await;
+    unsafe { std::env::set_var("PORTABASE_HELPER_IMAGE", "busybox"); }
+
+    let docker = client().expect("docker daemon required");
+    let vol = format!("portabase-test-{}", uuid::Uuid::new_v4());
+    docker
+        .create_volume(VolumeCreateRequest { name: Some(vol.clone()), ..Default::default() })
+        .await
+        .unwrap();
+
+    seed_volume(&docker, &vol, "keeper.txt", "original").await;
+
+    let tmp = tempfile::TempDir::new().unwrap();
+    let logger = std::sync::Arc::new(crate::services::backup::logger::JobLogger::new());
+    let tar = crate::domain::docker_volume::backup::run(
+        volume_config(&vol),
+        tmp.path().to_path_buf(),
+        logger.clone(),
+    )
+    .await
+    .unwrap();
+    
+    seed_volume(&docker, &vol, "drift.txt", "added-later").await;
+
+    // Restore uploads the raw Docker tar directly.
+    crate::domain::docker_volume::restore::run(volume_config(&vol), tar.clone(), logger)
+        .await
+        .unwrap();
+
+    let listing = list_volume(&docker, &vol).await;
+    assert!(listing.contains("keeper.txt"), "listing: {listing}");
+    assert!(!listing.contains("drift.txt"), "clean-replace failed, listing: {listing}");
+
+    docker.remove_volume(&vol, None::<RemoveVolumeOptions>).await.ok();
+}
+
+async fn list_volume(docker: &bollard::Docker, volume: &str) -> String {
+    use bollard::models::{ContainerCreateBody, HostConfig};
+    use bollard::query_parameters::{
+        CreateContainerOptions, LogsOptions, RemoveContainerOptions, StartContainerOptions,
+        WaitContainerOptions,
+    };
+    use tokio_stream::StreamExt;
+
+    ensure_image(docker, "busybox").await;
+
+    let body = ContainerCreateBody {
+        image: Some("busybox".to_string()),
+        cmd: Some(vec!["sh".into(), "-c".into(), "ls -A /vol".into()]),
+        host_config: Some(HostConfig {
+            binds: Some(vec![format!("{volume}:/vol")]),
+            ..Default::default()
+        }),
+        ..Default::default()
+    };
+    let created = docker.create_container(None::<CreateContainerOptions>, body).await.unwrap();
+    docker.start_container(&created.id, None::<StartContainerOptions>).await.unwrap();
+    let mut wait = docker.wait_container(&created.id, None::<WaitContainerOptions>);
+    while wait.next().await.is_some() {}
+
+    let mut logs = docker.logs(
+        &created.id,
+        Some(LogsOptions { stdout: true, stderr: false, ..Default::default() }),
+    );
+    let mut out = String::new();
+    while let Some(chunk) = logs.next().await {
+        if let Ok(l) = chunk {
+            out.push_str(&l.to_string());
+        }
+    }
+    docker
+        .remove_container(&created.id, Some(RemoveContainerOptions { force: true, ..Default::default() }))
+        .await
+        .ok();
+    out
+}
+
+#[tokio::test]
+async fn sweep_removes_labeled_helpers() {
+    use crate::domain::docker_volume::docker::{client, create_helper, sweep_ephemeral, EPHEMERAL_LABEL};
+    use bollard::models::VolumeCreateRequest;
+    use bollard::query_parameters::{ListContainersOptions, RemoveVolumeOptions};
+    use std::collections::HashMap;
+    
+    let _env_guard = ENV_GUARD.lock().await;
+    unsafe { std::env::set_var("PORTABASE_HELPER_IMAGE", "busybox"); }
+    let docker = client().expect("docker daemon required");
+
+    let vol = format!("portabase-test-{}", uuid::Uuid::new_v4());
+    docker
+        .create_volume(VolumeCreateRequest { name: Some(vol.clone()), ..Default::default() })
+        .await
+        .unwrap();
+
+    ensure_image(&docker, "busybox").await;
+
+    let helper = create_helper(&docker, "busybox", &vol, "sweep-test", true, None).await.unwrap();
+
+    let removed = sweep_ephemeral(&docker).await.unwrap();
+    assert!(removed >= 1);
+
+    let mut filters = HashMap::new();
+    filters.insert("label".to_string(), vec![format!("{EPHEMERAL_LABEL}=true")]);
+    let remaining = docker
+        .list_containers(Some(ListContainersOptions { all: true, filters: Some(filters), ..Default::default() }))
+        .await
+        .unwrap();
+    assert!(remaining.iter().all(|c| c.id.as_deref() != Some(helper.id.as_str())));
+
+    docker.remove_volume(&vol, None::<RemoveVolumeOptions>).await.ok();
+}

src/tests/domain/firebird.rs

@@ -7,18 +7,12 @@ use std::time::Duration;
 use tempfile::TempDir;
 use testcontainers::runners::AsyncRunner;
 use testcontainers::{ContainerAsync, GenericImage, ImageExt};
-use testcontainers::core::{AccessMode, IntoContainerPort};
+use testcontainers::core::IntoContainerPort;
 use tracing::{error, info};
-use testcontainers::core::{Mount};
 
 async fn create_config() -> (ContainerAsync<GenericImage>, DatabaseConfig) {
-
-    let mount = Mount::volume_mount("firebird-test-data", "/var/lib/firebird/data")
-        .with_access_mode(AccessMode::ReadWrite);
-
     let container = GenericImage::new("firebirdsql/firebird", "latest")
         .with_exposed_port(3050.tcp())
-        .with_mount(mount)
         .with_env_var("FIREBIRD_ROOT_PASSWORD", "fake_root_password")
         .with_env_var("FIREBIRD_USER", "alice")
         .with_env_var("FIREBIRD_PASSWORD", "fake_password")
@@ -45,6 +39,10 @@ async fn create_config() -> (ContainerAsync<GenericImage>, DatabaseConfig) {
         host,
         generated_id: "3c445eb4-c2c6-4bde-a423-ee1385dcf6d2".to_string(),
         path: "".to_string(),
+        max_packet_size: "".to_string(),
+        volume_name: "".to_string(),
+        container_name: None,
+        options: std::collections::HashMap::new(),
     };
 
     (container, config)
@@ -73,13 +71,13 @@ async fn firebird_backup_restore_test() {
 
     let db = DatabaseFactory::create_for_backup(config.clone()).await;
 
-    let file_path = db.backup(backup_path).await.unwrap();
+    let file_path = db.backup(backup_path, std::sync::Arc::new(crate::services::backup::logger::JobLogger::new())).await.unwrap();
 
     tokio::time::sleep(Duration::from_secs(10)).await;
 
     assert!(file_path.is_file());
 
-    let compression = compress_to_tar_gz_large(&file_path).await.unwrap();
+    let compression = compress_to_tar_gz_large(&file_path, std::sync::Arc::new(crate::services::backup::logger::JobLogger::new())).await.unwrap();
     assert!(compression.compressed_path.is_file());
 
     let files = decompress_large_tar_gz(
@@ -101,7 +99,7 @@ async fn firebird_backup_restore_test() {
     info!("Reachable: {}", reachable);
     assert!(reachable);
 
-    match db.restore(&backup_file).await {
+    match db.restore(&backup_file, std::sync::Arc::new(crate::services::backup::logger::JobLogger::new())).await {
         Ok(_) => {
             info!("Restore succeeded for {}", config.generated_id);
             assert!(true)
@@ -111,4 +109,4 @@ async fn firebird_backup_restore_test() {
             assert!(false)
         }
     }
-}
+}

src/tests/domain/mariadb.rs

@@ -31,6 +31,10 @@ async fn create_config() -> (ContainerAsync<Mariadb>, DatabaseConfig) {
         host: host.to_string(),
         generated_id: "3c4b4eb4-c2c6-4bde-a423-ee1385dcf6d2".to_string(),
         path: "".to_string(),
+        max_packet_size: "512M".to_string(),
+        volume_name: "".to_string(),
+        container_name: None,
+        options: std::collections::HashMap::new(),
     };
 
     (container, config)
@@ -58,11 +62,11 @@ async fn mariadb_backup_restore_test() {
     let backup_path = temp_dir.path();
 
     let db = DatabaseFactory::create_for_backup(config.clone()).await;
-    let file_path = db.backup(backup_path).await.unwrap();
+    let file_path = db.backup(backup_path, std::sync::Arc::new(crate::services::backup::logger::JobLogger::new())).await.unwrap();
 
     assert!(file_path.is_file());
 
-    let compression = compress_to_tar_gz_large(&file_path).await.unwrap();
+    let compression = compress_to_tar_gz_large(&file_path, std::sync::Arc::new(crate::services::backup::logger::JobLogger::new())).await.unwrap();
     assert!(compression.compressed_path.is_file());
 
     let files = decompress_large_tar_gz(compression.compressed_path.as_path(), temp_dir.path())
@@ -81,7 +85,7 @@ async fn mariadb_backup_restore_test() {
     info!("Reachable: {}", reachable);
     assert!(reachable);
 
-    match db.restore(&backup_file).await {
+    match db.restore(&backup_file, std::sync::Arc::new(crate::services::backup::logger::JobLogger::new())).await {
         Ok(_) => {
             info!("Restore succeeded for {}", config.generated_id);
             assert!(true)

src/tests/domain/mod.rs

@@ -2,7 +2,9 @@ mod mariadb;
 mod mongodb;
 mod mysql;
 mod postgres;
+mod cluster;
 mod redis;
 mod valkey;
 mod firebird;
 mod mssql;
+mod docker_volume;

src/tests/domain/mongodb.rs

@@ -29,6 +29,10 @@ async fn create_config() -> (ContainerAsync<Mongo>, DatabaseConfig) {
         host: host.to_string(),
         generated_id: "96d30a9f-ff4b-47c9-aaab-f3147bb34f16".to_string(),
         path: "".to_string(),
+        max_packet_size: "".to_string(),
+        volume_name: "".to_string(),
+        container_name: None,
+        options: std::collections::HashMap::new(),
     };
 
     (container, config)
@@ -75,7 +79,7 @@ async fn mongodb_backup_restore_test() {
     let backup_path = temp_dir.path();
 
     let db = DatabaseFactory::create_for_backup(config.clone()).await;
-    let file_path = db.backup(backup_path).await.unwrap();
+    let file_path = db.backup(backup_path, std::sync::Arc::new(crate::services::backup::logger::JobLogger::new())).await.unwrap();
     info!("Backup path: {:?}", file_path);
     assert!(file_path.is_file());
 
@@ -85,7 +89,7 @@ async fn mongodb_backup_restore_test() {
     info!("Reachable: {}", reachable);
     assert!(reachable);
 
-    match db.restore(&file_path).await {
+    match db.restore(&file_path, std::sync::Arc::new(crate::services::backup::logger::JobLogger::new())).await {
         Ok(_) => {
             info!("Restore succeeded for {}", config.generated_id);
             assert!(true)