chore: release 1.12.3

Dev

.github/CODE_OF_CONDUCT.md

@@ -60,7 +60,7 @@ representative at an online or offline event.
 
 Instances of abusive, harassing, or otherwise unacceptable behavior may be
 reported to the community leaders responsible for enforcement at
-contact@soluce-technologies.com.
+contact@portabase.io.
 All complaints will be reviewed and investigated promptly and fairly.
 
 All community leaders are obligated to respect the privacy and security of the

.github/SECURITY.md

@@ -18,7 +18,7 @@ We take security seriously and aim to support the following versions of the proj
 If you discover a security vulnerability in this project, we appreciate your help in disclosing it responsibly.
 
 1. **Contact Us**  
-   Please report the vulnerability by emailing **[contact@soluce-technologies.com](mailto:contact@soluce-technologies.com)**. Include the following details:
+   Please report the vulnerability by emailing **[contact@portabase.io](mailto:contact@portabase.io)**. Include the following details:
     - A detailed description of the issue.
     - Steps to reproduce the vulnerability (if applicable).
     - Any potential impacts or risks.

.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 &&
+              mkdir -p /app/coverage &&
+              rm -rf /app/target/* /app/coverage/* &&
               cargo test --verbose &&
               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/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

@@ -3,4 +3,8 @@
 /src/data/
 
 .DS_Store
-.env
+.env
+
+.claude
+
+/docs

CITATION.cff

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

Cargo.lock

@@ -169,6 +169,19 @@ dependencies = [
  "syn",
 ]
 
+[[package]]
+name = "asynchronous-codec"
+version = "0.6.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4057f2c32adbb2fc158e22fb38433c8e9bbf76b75a4732c7c0cbaf695fb65568"
+dependencies = [
+ "bytes",
+ "futures-sink",
+ "futures-util",
+ "memchr",
+ "pin-project-lite",
+]
+
 [[package]]
 name = "atomic-waker"
 version = "1.1.2"
@@ -496,7 +509,7 @@ dependencies = [
  "pin-project-lite",
  "rustls 0.21.12",
  "rustls 0.23.37",
- "rustls-native-certs",
+ "rustls-native-certs 0.8.3",
  "rustls-pki-types",
  "tokio",
  "tokio-rustls 0.26.4",
@@ -770,7 +783,7 @@ dependencies = [
  "pin-project-lite",
  "rand 0.9.2",
  "rustls 0.23.37",
- "rustls-native-certs",
+ "rustls-native-certs 0.8.3",
  "rustls-pki-types",
  "serde",
  "serde_derive",
@@ -968,6 +981,12 @@ version = "0.4.31"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "75984efb6ed102a0d42db99afb6c1948f0380d1d91808d5529916e6c08b49d8d"
 
+[[package]]
+name = "connection-string"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "510ca239cf13b7f8d16a2b48f263de7b4f8c566f0af58d901031473c76afb1e3"
+
 [[package]]
 name = "const-oid"
 version = "0.9.6"
@@ -1436,6 +1455,26 @@ dependencies = [
  "syn",
 ]
 
+[[package]]
+name = "enumflags2"
+version = "0.7.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1027f7680c853e056ebcec683615fb6fbbc07dbaa13b4d5d9442b146ded4ecef"
+dependencies = [
+ "enumflags2_derive",
+]
+
+[[package]]
+name = "enumflags2_derive"
+version = "0.7.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "67c78a4d8fdf9953a5c9d458f9efe940fd97a0cab0941c075a813ac594733827"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
 [[package]]
 name = "equivalent"
 version = "1.0.2"
@@ -2050,7 +2089,7 @@ dependencies = [
  "hyper 1.8.1",
  "hyper-util",
  "rustls 0.23.37",
- "rustls-native-certs",
+ "rustls-native-certs 0.8.3",
  "rustls-pki-types",
  "tokio",
  "tokio-rustls 0.26.4",
@@ -2854,6 +2893,12 @@ dependencies = [
  "syn",
 ]
 
+[[package]]
+name = "openssl-probe"
+version = "0.1.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d05e27ee213611ffe7d6348b942e8f942b37114c00cc03cec254295a4a17852e"
+
 [[package]]
 name = "openssl-probe"
 version = "0.2.1"
@@ -3038,7 +3083,7 @@ dependencies = [
 
 [[package]]
 name = "portabase-agent"
-version = "1.7.0"
+version = "1.12.3"
 dependencies = [
  "aes",
  "aes-gcm",
@@ -3076,6 +3121,7 @@ dependencies = [
  "testcontainers",
  "testcontainers-modules",
  "thiserror 2.0.18",
+ "tiberius",
  "time",
  "tokio",
  "tokio-postgres",
@@ -3191,6 +3237,12 @@ dependencies = [
  "termtree",
 ]
 
+[[package]]
+name = "pretty-hex"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c6fa0831dd7cc608c38a5e323422a0077678fa5744aa2be4ad91c4ece8eec8d5"
+
 [[package]]
 name = "prettyplease"
 version = "0.2.37"
@@ -3677,16 +3729,37 @@ dependencies = [
  "zeroize",
 ]
 
+[[package]]
+name = "rustls-native-certs"
+version = "0.6.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a9aace74cb666635c918e9c12bc0d348266037aa8eb599b5cba565709a8dff00"
+dependencies = [
+ "openssl-probe 0.1.6",
+ "rustls-pemfile",
+ "schannel",
+ "security-framework 2.11.1",
+]
+
 [[package]]
 name = "rustls-native-certs"
 version = "0.8.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "612460d5f7bea540c490b2b6395d8e34a953e52b491accd6c86c8164c5932a63"
 dependencies = [
- "openssl-probe",
+ "openssl-probe 0.2.1",
  "rustls-pki-types",
  "schannel",
- "security-framework",
+ "security-framework 3.7.0",
+]
+
+[[package]]
+name = "rustls-pemfile"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1c74cae0a4cf6ccbbf5f359f08efdf8ee7e1dc532573bf0db71968cb56b1448c"
+dependencies = [
+ "base64 0.21.7",
 ]
 
 [[package]]
@@ -3711,10 +3784,10 @@ dependencies = [
  "log",
  "once_cell",
  "rustls 0.23.37",
- "rustls-native-certs",
+ "rustls-native-certs 0.8.3",
  "rustls-platform-verifier-android",
  "rustls-webpki 0.103.9",
- "security-framework",
+ "security-framework 3.7.0",
  "security-framework-sys",
  "webpki-root-certs",
  "windows-sys 0.61.2",
@@ -3832,6 +3905,19 @@ dependencies = [
  "zeroize",
 ]
 
+[[package]]
+name = "security-framework"
+version = "2.11.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "897b2245f0b511c87893af39b033e5ca9cce68824c4d7e7630b5a1d339658d02"
+dependencies = [
+ "bitflags 2.11.0",
+ "core-foundation 0.9.4",
+ "core-foundation-sys",
+ "libc",
+ "security-framework-sys",
+]
+
 [[package]]
 name = "security-framework"
 version = "3.7.0"
@@ -4353,6 +4439,34 @@ dependencies = [
  "cfg-if",
 ]
 
+[[package]]
+name = "tiberius"
+version = "0.12.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a1446cb4198848d1562301a3340424b4f425ef79f35ef9ee034769a9dd92c10d"
+dependencies = [
+ "async-trait",
+ "asynchronous-codec",
+ "byteorder",
+ "bytes",
+ "chrono",
+ "connection-string",
+ "encoding_rs",
+ "enumflags2",
+ "futures-util",
+ "num-traits",
+ "once_cell",
+ "pin-project-lite",
+ "pretty-hex",
+ "rustls-native-certs 0.6.3",
+ "rustls-pemfile",
+ "thiserror 1.0.69",
+ "tokio-rustls 0.24.1",
+ "tokio-util",
+ "tracing",
+ "uuid",
+]
+
 [[package]]
 name = "time"
 version = "0.3.47"
@@ -4668,6 +4782,7 @@ version = "0.1.44"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "63e71662fa4b2a2c3a26f570f037eb95bb1f85397f3cd8076caed2f026a6d100"
 dependencies = [
+ "log",
  "pin-project-lite",
  "tracing-attributes",
  "tracing-core",

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "portabase-agent"
-version = "1.7.0"
+version = "1.12.3"
 edition = "2024"
 
 [dependencies]
@@ -35,7 +35,8 @@ rand = "0.9.2"
 bytes = "1.11.0"
 async-stream = "0.3.6"
 uuid = { version = "1.20.0", features = ["v4"] }
-tokio-util = "0.7.18"
+tokio-util = { version = "0.7.18", features = ["compat"] }
+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"] }
 async-compression = { version = "0.4.37", features = ["tokio", "gzip"] }

Makefile

@@ -1,54 +0,0 @@
-include .env
-export $(shell sed 's/=.*//' .env)
-CLUSTER_SCRIPT=docker/entrypoints/app-dev-entrypoint.sh
-
-.PHONY: seed-mongo seed-mysql seed-postgres
-
-up:
-	@bash $(CLUSTER_SCRIPT)
-
-seed-mongo:
-	@echo "Seeding MongoDB..."
-	bash ./scripts/mongo/seed-mongo.sh
-
-seed-mongo-auth:
-	@echo "Seeding MongoDB with auth..."
-	bash ./scripts/mongo/seed-mongo.sh auth
-
-seed-mysql:
-	@echo "Seeding MySQL..."
-	mysql -h 127.0.0.1 -P "$$MYSQL_PORT" -u "$$MYSQL_USER" -p"$$MYSQL_PASSWORD" "$$MYSQL_DB" < ./scripts/mysql/seed-mysql.sql
-
-seed-mysql-1gb:
-	@echo "Seeding MySQL..."
-	mysql -h 127.0.0.1 -P "$$MYSQL_PORT" -u "$$MYSQL_USER" -p"$$MYSQL_PASSWORD" "$$MYSQL_DB" < ./scripts/mysql/seed-1gb.sql
-
-
-seed-postgres:
-	@echo "Seeding Postgres..."
-	docker exec -i -e PGPASSWORD=$$PG_PASSWORD $$PG_CONTAINER \
-		psql -U $$PG_USER -d $$PG_DB < ./scripts/postgres/seed.sql
-
-seed-postgres-1gb:
-	@echo "Seeding Postgres..."
-	docker exec -i -e PGPASSWORD=$$PG_PASSWORD $$PG_CONTAINER \
-		psql -U $$PG_USER -d $$PG_DB < ./scripts/postgres/seed-1gb.sql
-
-
-SQLITE_SEED_FILE := $(if $(filter big,$(SEED)),./scripts/sqlite/seed-big.sql,./scripts/sqlite/seed.sql)
-
-seed-sqlite:
-	@echo "Seeding Sqlite..."
-	@echo "Run as root to fix permissions inside the volume"
-	docker exec -u 0 -it db-sqlite sh -c "chmod -R 777 /workspace/data"
-	@echo "Create the database file (if it doesn’t exist)"
-	docker exec -u 0 -it db-sqlite sh -c "touch /workspace/data/app.db"
-	@echo "Seed the database"
-	docker exec -i db-sqlite sh -c "sqlite3 /workspace/data/app.db" < $(SQLITE_SEED_FILE)
-	@echo "Verify"
-	docker exec -it db-sqlite sqlite3 /workspace/data/app.db "SELECT name FROM sqlite_master WHERE type='table';"
-	@echo "Done"
-
-
-
-seed-all: seed-mongo seed-mysql seed-postgres seed-postgres-1gb

README.md

@@ -13,6 +13,7 @@
 
 [![License: Apache](https://img.shields.io/badge/License-apache-yellow.svg)](LICENSE)
 [![Docker Pulls](https://img.shields.io/docker/pulls/portabase/agent?color=brightgreen)](https://hub.docker.com/r/portabase/agent)
+[![Helm Chart](https://img.shields.io/badge/Helm-Kubernetes-326ce5?logo=helm&logoColor=white)](https://github.com/Portabase/agent/pkgs/container/charts%2Fportabase-agent)
 [![Platform](https://img.shields.io/badge/platform-linux%20%7C%20macos%20%7C%20windows-lightgrey)](https://github.com/Portabase/portabase)
 [![Support Portabase](https://img.shields.io/badge/Support-Portabase-orange)](https://www.buymeacoffee.com/portabase)
 
@@ -20,9 +21,12 @@
 [![MySQL](https://img.shields.io/badge/MySQL-4479A1?logo=mysql&logoColor=white)](https://www.mysql.com/)
 [![SQLite](https://img.shields.io/badge/-SQLite-blue?logo=sqlite&logoColor=white)](https://sqlite.org/)
 [![Redis](https://img.shields.io/badge/Redis-DC382D?style=flat&logo=Redis&logoColor=white)](https://redis.io/)
-[![Valkey](https://img.shields.io/badge/Valkey-6284fc?style=flat&logo=Valkey&logoColor=white)](https://valkey.io/)
 [![MariaDB](https://img.shields.io/badge/MariaDB-003545?logo=mariadb&logoColor=white)](https://mariadb.org/)
 [![MongoDB](https://img.shields.io/badge/-MongoDB-13aa52?logo=mongodb&logoColor=white)](https://www.mongodb.com/)
+[![Valkey](https://img.shields.io/badge/Valkey-6284fc?style=flat&logo=Valkey&logoColor=white)](https://valkey.io/)
+[![Firebird](https://img.shields.io/badge/Firebird-f55b14?style=flat&logo=Firebird&logoColor=white)](https://firebirdsql.org/)
+
+
 [![Self Hosted](https://img.shields.io/badge/self--hosted-yes-brightgreen)](https://github.com/Portabase/portabase)
 [![Open Source](https://img.shields.io/badge/open%20source-❤️-red)](https://github.com/Portabase/portabase)
 
@@ -50,7 +54,7 @@ You have 4 ways to install Portabase Agent:
 
 - Automated CLI (recommended) - [details](https://portabase.io/docs/agent/setup#cli)
 - Docker Compose setup - [details](https://portabase.io/docs/agent/setup#docker)
-- Kubernetes with Helm (soon)
+- Kubernetes with Helm [details](https://portabase.io/docs/agent/setup#helm)
 - Development setup - [details](https://portabase.io/docs/agent/setup#development)
 
 **Ensure Docker is installed on your machine before getting started.**

databases.json

@@ -21,7 +21,7 @@
       "generated_id": "16678124-ff7e-4c97-8c83-0adeff214681"
     },
     {
-      "name": "Test database 4 - MongoDB Auth",
+      "name": "Test database 3 - MongoDB Auth",
       "database": "testdbauth",
       "type": "mongodb",
       "username": "root",
@@ -31,7 +31,7 @@
       "generated_id": "16678145-ff7e-4c97-8c83-0adeff214681"
     },
     {
-      "name": "Test database 5 - MongoDB",
+      "name": "Test database 4 - MongoDB",
       "database": "testdb",
       "type": "mongodb",
       "port": 27017,
@@ -39,26 +39,26 @@
       "generated_id": "16678147-ff7e-4c97-8c83-0adeff214681"
     },
     {
-      "name": "Test database 6 - SQLite DB",
+      "name": "Test database 5 - SQLite DB",
       "type": "sqlite",
       "path": "/sqlite-data/workspace/data/app.db",
       "generated_id": "16678178-ff7e-4c97-8c83-0adeff214681"
     },
     {
-      "name": "Test database 7 - SQLite DB",
+      "name": "Test database 6 - SQLite DB",
       "type": "sqlite",
       "path": "/sqlite-data-2/workspace/data/app.db",
       "generated_id": "16678179-ff7e-4c97-8c83-0adeff214681"
     },
     {
-      "name": "Test database 8 - Redis",
+      "name": "Test database 7 - Redis",
       "type": "redis",
       "port": 6379,
       "host": "db-redis",
       "generated_id": "16678166-ff7e-4c97-8c83-0adeff214681"
     },
     {
-      "name": "Test database 9 - Redis Auth",
+      "name": "Test database 8 - Redis Auth",
       "type": "redis",
       "password": "supersecurepassword",
       "port": 6379,
@@ -67,14 +67,14 @@
       "generated_id": "16678160-ff7e-4c97-8c83-0adeff214681"
     },
     {
-      "name": "Test database 10 - Valkey",
+      "name": "Test database 9 - Valkey",
       "type": "valkey",
       "port": 6379,
       "host": "db-valkey",
       "generated_id": "16678560-ff7e-4c97-8c83-0adeff214681"
     },
     {
-      "name": "Test database 11 - Valkey Auth",
+      "name": "Test database 10 - Valkey Auth",
       "type": "valkey",
       "password": "supersecurepassword",
       "port": 6379,
@@ -83,7 +83,7 @@
       "generated_id": "16678561-ff7e-4c97-8c83-0adeff214681"
     },
     {
-      "name": "Test database 12 - Mysql",
+      "name": "Test database 11 - Mysql",
       "database": "mysqldb",
       "type": "mysql",
       "username": "mysqldb",
@@ -91,6 +91,26 @@
       "port": 3306,
       "host": "db-mysql",
       "generated_id": "16656124-ff7e-4c97-8c83-0adeff214681"
+    },
+    {
+      "name": "Test database 12 - Firebird",
+      "database": "/var/lib/firebird/data/mirror.fdb",
+      "type": "firebird",
+      "username": "alice",
+      "password": "fake_password",
+      "port": 3050,
+      "host": "db-firebird",
+      "generated_id": "16706124-ff7e-4c97-8c83-0adeff214681"
+    },
+    {
+      "name": "Test database 13 - MsSQL",
+      "database": "myappdb",
+      "type": "mssql",
+      "username": "sa",
+      "password": "Portabase!Strong1",
+      "port": 1433,
+      "host": "db-mssql",
+      "generated_id": "16706125-ff7e-4c97-8c83-0adeff214682"
     }
   ]
 }

databases.toml

@@ -29,11 +29,85 @@ host = "db-mongodb-auth"
 generated_id = "16678145-ff7e-4c97-8c83-0adeff214681"
 
 [[databases]]
-name = "Test database 3 - MongoDB"
+name = "Test database 4 - MongoDB"
 database = "testdb"
 type = "mongodb"
-username = ""
-password = ""
 port = 27017
 host = "db-mongodb"
 generated_id = "16678147-ff7e-4c97-8c83-0adeff214681"
+
+[[databases]]
+name = "Test database 5 - SQLite DB"
+type = "sqlite"
+path = "/sqlite-data/workspace/data/app.db"
+generated_id = "16678178-ff7e-4c97-8c83-0adeff214681"
+
+[[databases]]
+name = "Test database 6 - SQLite DB 2"
+type = "sqlite"
+path = "/sqlite-data-2/workspace/data/app.db"
+generated_id = "16678179-ff7e-4c97-8c83-0adeff214681"
+
+[[databases]]
+name = "Test database 7 - Redis"
+type = "redis"
+port = 6379
+host = "db-redis"
+generated_id = "16678166-ff7e-4c97-8c83-0adeff214681"
+
+[[databases]]
+name = "Test database 8 - Redis Auth"
+type = "redis"
+password = "supersecurepassword"
+username = "default"
+port = 6379
+host = "db-redis-auth"
+generated_id = "16678160-ff7e-4c97-8c83-0adeff214681"
+
+[[databases]]
+name = "Test database 9 - Valkey"
+type = "valkey"
+port = 6379
+host = "db-valkey"
+generated_id = "16678560-ff7e-4c97-8c83-0adeff214681"
+
+[[databases]]
+name = "Test database 10 - Valkey Auth"
+type = "valkey"
+password = "supersecurepassword"
+username = "default"
+port = 6379
+host = "db-valkey-auth"
+generated_id = "16678561-ff7e-4c97-8c83-0adeff214681"
+
+[[databases]]
+name = "Test database 11 - Mysql"
+database = "mysqldb"
+type = "mysql"
+password = "changeme"
+username = "mysqldb"
+port = 3306
+host = "db-mysql"
+generated_id = "16656124-ff7e-4c97-8c83-0adeff214681"
+
+[[databases]]
+name = "Test database 12 - Firebird"
+database = "/var/lib/firebird/data/mirror.fdb"
+type = "firebird"
+password = "fake_password"
+username = "alice"
+port = 3050
+host = "db-firebird"
+generated_id = "16706124-ff7e-4c97-8c83-0adeff214681"
+
+[[databases]]
+name = "Test database 13 - MSSQL"
+database = "myappdb"
+type = "mssql"
+username = "sa"
+password = "Portabase!Strong1"
+port = 1433
+host = "db-mssql"
+generated_id = "16706125-ff7e-4c97-8c83-0adeff214682"
+
+

docker-compose.databases.yml

@@ -0,0 +1,198 @@
+name: databases
+
+services:
+  db-postgres:
+    container_name: db-postgres
+    image: postgres:17-alpine
+    ports:
+      - "5436:5432"
+    volumes:
+      - postgres-data:/var/lib/postgresql/data
+    environment:
+      - POSTGRES_DB=devdb
+      - POSTGRES_USER=devuser
+      - POSTGRES_PASSWORD=changeme
+    networks:
+      - portabase
+
+  db-mariadb:
+    container_name: db-mariadb
+    image: mariadb:latest
+    ports:
+      - "3311:3306"
+    environment:
+      - MYSQL_DATABASE=mariadb
+      - MYSQL_USER=mariadb
+      - MYSQL_PASSWORD=changeme
+      - MYSQL_RANDOM_ROOT_PASSWORD=yes
+    volumes:
+      - mariadb-data:/var/lib/mysql
+    networks:
+      - portabase
+
+  db-mysql:
+    container_name: db-mysql
+    image: mysql:9.5
+    ports:
+      - "3312:3306"
+    environment:
+      - MYSQL_DATABASE=mysqldb
+      - MYSQL_USER=mysqldb
+      - MYSQL_PASSWORD=changeme
+      - MYSQL_RANDOM_ROOT_PASSWORD=yes
+    volumes:
+      - mysql-data:/var/lib/mysql
+    networks:
+      - portabase
+
+
+  db-mongodb-auth:
+    container_name: db-mongodb-auth
+    image: mongo:latest
+    ports:
+      - "27082:27017"
+    environment:
+      MONGO_INITDB_ROOT_USERNAME: root
+      MONGO_INITDB_ROOT_PASSWORD: rootpassword
+      MONGO_INITDB_DATABASE: testdbauth
+    command: mongod --auth
+    networks:
+      - portabase
+    volumes:
+      - mongodb-data-auth:/data/db
+    healthcheck:
+      test: [ "CMD", "mongo", "--eval", "db.adminCommand('ping')" ]
+      interval: 5s
+      timeout: 5s
+      retries: 10
+
+  db-mongodb:
+    container_name: db-mongodb
+    image: mongo:latest
+    ports:
+      - "27083:27017"
+    volumes:
+      - mongodb-data:/data/db
+    healthcheck:
+      test: [ "CMD", "mongosh", "--eval", "db.adminCommand('ping')" ]
+      interval: 5s
+      timeout: 5s
+      retries: 10
+    environment:
+      MONGO_INITDB_DATABASE: testdb
+    networks:
+      - portabase
+
+  sqlite:
+    container_name: db-sqlite
+    image: keinos/sqlite3
+    volumes:
+      - sqlite-data:/workspace/data
+    working_dir: /workspace
+    command: tail -f /dev/null
+    stdin_open: true
+    tty: true
+
+  db-redis:
+    image: redis:latest
+    container_name: db-redis
+    ports:
+      - "6378:6379"
+    volumes:
+      - redis-data:/data
+    command: [ "redis-server", "--appendonly", "yes" ]
+    networks:
+      - portabase
+
+  db-redis-auth:
+    image: redis:latest
+    container_name: db-redis-auth
+    ports:
+      - "6380:6379"
+    volumes:
+      - redis-data-auth:/data
+    environment:
+      - REDIS_PASSWORD=supersecurepassword
+    command: [ "redis-server", "--requirepass", "supersecurepassword", "--appendonly", "yes" ]
+    networks:
+      - portabase
+
+  db-valkey:
+    image: valkey/valkey
+    container_name: db-valkey
+    environment:
+      - ALLOW_EMPTY_PASSWORD=yes
+    ports:
+      - '6381:6379'
+    volumes:
+      - valkey-data:/data
+    networks:
+      - portabase
+
+  db-valkey-auth:
+    image: valkey/valkey
+    container_name: db-valkey-auth
+    command: >
+      --requirepass "supersecurepassword"
+    ports:
+      - '6382:6379'
+    volumes:
+      - valkey-data-auth:/data
+    networks:
+      - portabase
+
+  db-firebird:
+    image: firebirdsql/firebird
+    container_name: db-firebird
+    restart: always
+    environment:
+      - FIREBIRD_ROOT_PASSWORD=fake_root_password
+      - FIREBIRD_USER=alice
+      - FIREBIRD_PASSWORD=fake_password
+      - FIREBIRD_DATABASE=mirror.fdb
+      - FIREBIRD_DATABASE_DEFAULT_CHARSET=UTF8
+    volumes:
+      - firebird-data:/var/lib/firebird/data
+    ports:
+      - "3060:3050"
+
+    networks:
+      - portabase
+
+  db-mssql:
+    container_name: db-mssql
+    image: mcr.microsoft.com/azure-sql-edge:latest
+    ports:
+      - "1433:1433"
+    environment:
+      ACCEPT_EULA: "Y"
+      MSSQL_SA_PASSWORD: "Portabase!Strong1"
+    volumes:
+      - mssql-data:/var/opt/mssql
+    networks:
+      - portabase
+    healthcheck:
+      test: ["CMD-SHELL", "cat /proc/net/tcp6 | grep -q '059901' || exit 1"]
+      interval: 10s
+      timeout: 5s
+      retries: 20
+
+volumes:
+  postgres-data:
+  mariadb-data:
+  mysql-data:
+  mongodb-data:
+  mongodb-data-auth:
+  sqlite-data:
+  redis-data:
+  redis-data-auth:
+  valkey-data:
+  valkey-data-auth:
+  firebird-data:
+  mssql-data:
+
+networks:
+  portabase:
+    name: portabase_network
+    external: true
+

docker-compose.yml

@@ -7,19 +7,20 @@ services:
     container_name: rust-dev
     volumes:
       - .:/app
-      - ./databases.json:/config/config.json
-      #      - ./databases.toml:/config/config.toml
       - cargo-registry:/usr/local/cargo/registry
       - cargo-git:/usr/local/cargo/git
-#      - /var/run/docker.sock:/var/run/docker.sock
-    #      - cargo-target:/app/target
-    #      - sqlite-data:/sqlite-data/workspace/data
-    #      - ./scripts/sqlite/test-db:/sqlite-data-2/workspace/data
+      - ./databases.json:/config/config.json
+      #- ./databases.toml:/config/config.toml
+      #- /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
     environment:
       APP_ENV: development
       LOG: debug
       TZ: "Europe/Paris"
-      EDGE_KEY: "eyJzZXJ2ZXJVcmwiOiJodHRwOi8vbG9jYWxob3N0Ojg4ODciLCJhZ2VudElkIjoiNGI1OTM2MGItNTNkMi00ZTZmLWE1ODctODcyMmQ1NDc1MTNmIiwibWFzdGVyS2V5QjY0IjoiQlhWM1hvbEM2NTZTVjdkTmdjV1BHUWxrKytycExJNmxHRGk3Q1BCNWllbz0ifQ=="
+      EDGE_KEY: "eyJzZXJ2ZXJVcmwiOiJodHRwOi8vbG9jYWxob3N0Ojg4ODciLCJhZ2VudElkIjoiNWRkZTE1NTctZWQ1ZC00MjUxLThiZDMtMDE0MjkxOTg2OGZjIiwibWFzdGVyS2V5QjY0IjoiQlhWM1hvbEM2NTZTVjdkTmdjV1BHUWxrKytycExJNmxHRGk3Q1BCNWllbz0ifQ=="
+      #CHUNK_SIZE_MB: "1"
       #POOLING: 1
       #DATABASES_CONFIG_FILE: "config.toml"
     extra_hosts:
@@ -27,160 +28,20 @@ services:
     networks:
       - portabase
 
-#  db-postgres:
-#    container_name: db-postgres
-#    image: postgres:17-alpine
-#    ports:
-#      - "5436:5432"
-#    volumes:
-#      - postgres-data:/var/lib/postgresql/data
-#    environment:
-#      - POSTGRES_DB=devdb
-#      - POSTGRES_USER=devuser
-#      - POSTGRES_PASSWORD=changeme
-#    networks:
-#      - portabase
+    cpus: "1.50"
 
-  db-mariadb:
-    container_name: db-mariadb
-    image: mariadb:latest
-    ports:
-      - "3311:3306"
-    environment:
-      - MYSQL_DATABASE=mariadb
-      - MYSQL_USER=mariadb
-      - MYSQL_PASSWORD=changeme
-      - MYSQL_RANDOM_ROOT_PASSWORD=yes
-    volumes:
-      - mariadb-data:/var/lib/mysql
-    networks:
-      - portabase
+    mem_limit: 4g
+    memswap_limit: 4g
 
-  db-mysql:
-    container_name: db-mysql
-    image: mysql:9.5
-    ports:
-      - "3312:3306"
-    environment:
-      - MYSQL_DATABASE=mysqldb
-      - MYSQL_USER=mysqldb
-      - MYSQL_PASSWORD=changeme
-      - MYSQL_RANDOM_ROOT_PASSWORD=yes
-    volumes:
-      - mysql-data:/var/lib/mysql
-    networks:
-      - portabase
-  #
-  #
-  #  db-mongodb-auth:
-  #    container_name: db-mongodb-auth
-  #    image: mongo:latest
-  #    ports:
-  #      - "27082:27017"
-  #    environment:
-  #      MONGO_INITDB_ROOT_USERNAME: root
-  #      MONGO_INITDB_ROOT_PASSWORD: rootpassword
-  #      MONGO_INITDB_DATABASE: testdbauth
-  #    command: mongod --auth
-  #    networks:
-  #      - portabase
-  #    volumes:
-  #      - mongodb-data-auth:/data/db
-  #    healthcheck:
-  #      test: [ "CMD", "mongo", "--eval", "db.adminCommand('ping')" ]
-  #      interval: 5s
-  #      timeout: 5s
-  #      retries: 10
-  #
-  #  db-mongodb:
-  #    container_name: db-mongodb
-  #    image: mongo:latest
-  #    ports:
-  #      - "27083:27017"
-  #    volumes:
-  #      - mongodb-data:/data/db
-  #    healthcheck:
-  #      test: [ "CMD", "mongosh", "--eval", "db.adminCommand('ping')" ]
-  #      interval: 5s
-  #      timeout: 5s
-  #      retries: 10
-  #    environment:
-  #      MONGO_INITDB_DATABASE: testdb
-  #    networks:
-  #      - portabase
+    pids_limit: 512
 
-  #  sqlite:
-  #    container_name: db-sqlite
-  #    image: keinos/sqlite3
-  #    volumes:
-  #      - sqlite-data:/workspace/data
-  #    working_dir: /workspace
-  #    command: tail -f /dev/null
-  #    stdin_open: true
-  #    tty: true
-
-#  db-redis:
-#    image: redis:latest
-#    container_name: db-redis
-#    ports:
-#      - "6379:6379"
-#    volumes:
-#      - redis-data:/data
-#    command: [ "redis-server", "--appendonly", "yes" ]
-#    networks:
-#      - portabase
-#
-#  db-redis-auth:
-#    image: redis:latest
-#    container_name: db-redis-auth
-#    ports:
-#      - "6380:6379"
-#    volumes:
-#      - redis-data-auth:/data
-#    environment:
-#      - REDIS_PASSWORD=supersecurepassword
-#    command: [ "redis-server", "--requirepass", "supersecurepassword", "--appendonly", "yes" ]
-#    networks:
-#      - portabase
-#
-#  db-valkey:
-#    image: valkey/valkey
-#    container_name: db-valkey
-#    environment:
-#      - ALLOW_EMPTY_PASSWORD=yes
-#    ports:
-#      - '6381:6379'
-#    volumes:
-#      - valkey-data:/data
-#    networks:
-#      - portabase
-#
-#  db-valkey-auth:
-#    image: valkey/valkey
-#    container_name: db-valkey-auth
-#    command: >
-#      --requirepass "supersecurepassword"
-#    ports:
-#      - '6382:6379'
-#    volumes:
-#      - valkey-data-auth:/data
-#    networks:
-#      - portabase
 
 volumes:
   cargo-registry:
   cargo-git:
 #  cargo-target:
-#  postgres-data:
-  mariadb-data:
-  mysql-data:
-#  mongodb-data:
-#  mongodb-data-auth:
-#  sqlite-data:
-#  redis-data:
-#  redis-data-auth:
-#  valkey-data:
-#  valkey-data-auth:
+  databases_sqlite-data:
+    external: true
 
 networks:
   portabase:

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)
 # =========================
@@ -18,9 +26,24 @@ RUN apt-get update && DEBIAN_FRONTEND=noninteractive apt-get install -y \
     sqlite3 \
     redis-tools \
     valkey \
+    firebird3.0-utils \
     && apt-get clean \
     && rm -rf /var/lib/apt/lists/*
 
+ENV DOTNET_ROOT=/usr/local/dotnet
+RUN curl -sSL https://dot.net/v1/dotnet-install.sh -o /tmp/dotnet-install.sh \
+    && chmod +x /tmp/dotnet-install.sh \
+    && /tmp/dotnet-install.sh --channel 8.0 --install-dir /usr/local/dotnet \
+    && rm /tmp/dotnet-install.sh \
+    && /usr/local/dotnet/dotnet tool install --global microsoft.sqlpackage
+
+ENV PATH="$PATH:/usr/local/dotnet:/root/.dotnet/tools"
+
+RUN ARCH=$(uname -m | sed 's/x86_64/amd64/;s/aarch64/arm64/') \
+    && curl -sSL "https://github.com/microsoft/go-sqlcmd/releases/latest/download/sqlcmd-linux-${ARCH}.tar.bz2" \
+       | tar -xjf - -C /usr/local/bin sqlcmd \
+    && chmod +x /usr/local/bin/sqlcmd
+
 ARG TARGETARCH
 
 # =========================
@@ -53,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
 
 # =========================
@@ -96,12 +126,19 @@ RUN apt-get update && apt-get install -y \
     libreadline8 \
     libncurses6 \
     zlib1g \
+    curl \
     mariadb-client \
     sqlite3 \
     redis-tools \
     valkey \
+    firebird3.0-utils \
     && rm -rf /var/lib/apt/lists/*
 
+ENV DOTNET_ROOT=/usr/local/dotnet
+RUN curl -sSL https://dot.net/v1/dotnet-install.sh -o /tmp/dotnet-install.sh \
+    && chmod +x /tmp/dotnet-install.sh \
+    && /tmp/dotnet-install.sh --channel 8.0 --runtime dotnet --install-dir /usr/local/dotnet \
+    && rm /tmp/dotnet-install.sh
 
 WORKDIR /app
 
@@ -112,8 +149,12 @@ 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
 
 CMD ["/entrypoint.sh"]

docker/entrypoints/app-dev-entrypoint.sh

@@ -34,6 +34,11 @@ check_network() {
 check_docker
 check_network
 
-echo "Starting docker-compose..."
-docker compose -f ./docker-compose.yml up
-echo "Docker-compose started successfully."
+echo "Stopping old database containers..."
+docker compose -f ./docker-compose.databases.yml down
+
+echo "Starting database containers..."
+docker compose -f ./docker-compose.databases.yml up -d
+
+echo "Starting main services..."
+docker compose -f ./docker-compose.yml up

justfile

@@ -0,0 +1,71 @@
+set dotenv-load := true
+set shell := ["bash", "-cu"]
+
+CLUSTER_SCRIPT := "docker/entrypoints/app-dev-entrypoint.sh"
+
+up:
+    bash {{CLUSTER_SCRIPT}}
+
+seed-mongo:
+    echo "Seeding MongoDB..."
+    bash ./scripts/mongo/seed-mongo.sh
+
+seed-mongo-auth:
+    echo "Seeding MongoDB with auth..."
+    bash ./scripts/mongo/seed-mongo.sh auth
+
+seed-mysql:
+    echo "Seeding MySQL..."
+    mysql -h 127.0.0.1 -P "$MYSQL_PORT" -u "$MYSQL_USER" -p"$MYSQL_PASSWORD" "$MYSQL_DB" < ./scripts/mysql/seed-mysql.sql
+
+seed-mysql-1gb:
+    echo "Seeding MySQL (1GB)..."
+    mysql -h 127.0.0.1 -P "$MYSQL_PORT" -u "$MYSQL_USER" -p"$MYSQL_PASSWORD" "$MYSQL_DB" < ./scripts/mysql/seed-1gb.sql
+
+seed-postgres:
+    echo "Seeding Postgres..."
+    docker exec -i -e PGPASSWORD="$PG_PASSWORD" "$PG_CONTAINER" \
+        psql -U "$PG_USER" -d "$PG_DB" < ./scripts/postgres/seed.sql
+
+seed-postgres-1gb:
+    echo "Seeding Postgres (1GB)..."
+    docker exec -i -e PGPASSWORD="$PG_PASSWORD" "$PG_CONTAINER" \
+        psql -U "$PG_USER" -d "$PG_DB" < ./scripts/postgres/seed-1gb.sql
+
+seed-sqlite:
+    echo "Seeding SQLite..."
+    bash ./scripts/sqlite/seed.sh
+    echo "Done"
+
+seed-firebird:
+    echo "Seeding Firebird..."
+    docker exec -i db-firebird isql -user alice -password fake_password /var/lib/firebird/data/mirror.fdb < ./scripts/firebird/seed.sql
+
+    echo "Verifying Firebird tables..."
+    echo "SELECT RDB\$RELATION_NAME FROM RDB\$RELATIONS WHERE RDB\$SYSTEM_FLAG = 0 AND RDB\$VIEW_BLR IS NULL;" \
+    | docker exec -i db-firebird isql -user alice -password fake_password /var/lib/firebird/data/mirror.fdb
+
+seed-mssql:
+    echo "Seeding MSSQL..."
+    docker exec -i rust-dev sqlcmd -S "db-mssql,1433" -U sa -P "$MSSQL_SA_PASSWORD" -N disable -i /app/scripts/mssql/seed.sql
+    echo "Done"
+
+seed-all:
+    just seed-mongo
+    just seed-mysql
+    just seed-postgres
+    just seed-postgres-1gb
+    just seed-sqlite
+    just seed-mongo
+    just seed-firebird
+    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

scripts/firebird/seed.sql

@@ -0,0 +1,11 @@
+CREATE TABLE users (
+                       id INTEGER GENERATED BY DEFAULT AS IDENTITY PRIMARY KEY,
+                       email VARCHAR(255) NOT NULL UNIQUE,
+                       name VARCHAR(255),
+                       created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+);
+
+INSERT INTO users (email, name) VALUES ('alice@example.com', 'Alice');
+INSERT INTO users (email, name) VALUES ('bob@example.com', 'Bob');
+
+COMMIT;

scripts/mssql/seed.sql

@@ -0,0 +1,20 @@
+IF NOT EXISTS (SELECT name FROM sys.databases WHERE name = N'myappdb')
+    CREATE DATABASE [myappdb];
+GO
+
+USE [myappdb];
+GO
+
+IF OBJECT_ID('users', 'U') IS NULL
+    CREATE TABLE users (
+        id       INT IDENTITY(1,1) PRIMARY KEY,
+        email    NVARCHAR(255) NOT NULL UNIQUE,
+        name     NVARCHAR(255),
+        created_at DATETIME DEFAULT GETDATE()
+    );
+GO
+
+INSERT INTO users (email, name) VALUES ('alice@example.com', 'Alice');
+INSERT INTO users (email, name) VALUES ('bob@example.com',   'Bob');
+INSERT INTO users (email, name) VALUES ('charlie@example.com', 'Charlie');
+GO

scripts/sqlite/seed.sh

@@ -0,0 +1,14 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+SEED_VALUE="${SEED:-}"
+
+if [ "$SEED_VALUE" = "big" ]; then
+  SQLITE_SEED_FILE="./scripts/sqlite/seed-big.sql"
+else
+  SQLITE_SEED_FILE="./scripts/sqlite/seed.sql"
+fi
+
+docker exec -u 0 db-sqlite sh -c "chmod -R 777 /workspace/data"
+docker exec -u 0 db-sqlite sh -c "touch /workspace/data/app.db"
+docker exec -i db-sqlite sh -c "sqlite3 /workspace/data/app.db" < "$SQLITE_SEED_FILE"

src/domain/factory.rs

@@ -5,18 +5,21 @@ 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::mariadb::database::MariaDBDatabase;
 
 #[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;
@@ -34,6 +37,8 @@ impl DatabaseFactory {
             DbType::Sqlite => Arc::new(SqliteDatabase::new(cfg)),
             DbType::Redis => Arc::new(RedisDatabase::new(cfg)),
             DbType::Valkey => Arc::new(ValkeyDatabase::new(cfg)),
+            DbType::Firebird => Arc::new(FirebirdDatabase::new(cfg)),
+            DbType::Mssql => Arc::new(MssqlDatabase::new(cfg)),
         }
     }
 
@@ -49,6 +54,8 @@ impl DatabaseFactory {
             DbType::Sqlite => Arc::new(SqliteDatabase::new(cfg)),
             DbType::Redis => Arc::new(RedisDatabase::new(cfg)),
             DbType::Valkey => Arc::new(ValkeyDatabase::new(cfg)),
+            DbType::Firebird => Arc::new(FirebirdDatabase::new(cfg)),
+            DbType::Mssql => Arc::new(MssqlDatabase::new(cfg)),
         }
     }
 }

src/domain/firebird/backup.rs

@@ -0,0 +1,54 @@
+use crate::services::backup::logger::JobLogger;
+use crate::services::config::DatabaseConfig;
+use anyhow::{Context, Result};
+use std::path::PathBuf;
+use std::process::Command;
+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> {
+        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);
+
+        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(&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() {
+            logger.log_command("gbak", combined_output, Some(exit_code), Some(duration_ms));
+            anyhow::bail!("Firebird backup failed for {}: {}", cfg.name, stderr);
+        }
+
+        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

@@ -0,0 +1,51 @@
+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,
+}
+
+impl FirebirdDatabase {
+    pub fn new(cfg: DatabaseConfig) -> Self {
+        Self { cfg }
+    }
+
+}
+
+#[async_trait]
+impl Database for FirebirdDatabase {
+    fn file_extension(&self) -> &'static str {
+        ".fbk"
+    }
+
+    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.file_extension(),
+            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/firebird/mod.rs

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

src/domain/firebird/ping.rs

@@ -0,0 +1,57 @@
+use std::process::Stdio;
+use tracing::{error, info};
+use tokio::io::AsyncWriteExt;
+use crate::services::config::DatabaseConfig;
+use tokio::process::Command;
+use tokio::time::{Duration, timeout};
+
+pub async fn run(cfg: DatabaseConfig) -> anyhow::Result<bool> {
+    let db_path = format!("{}/{}:{}", cfg.host, cfg.port, cfg.database);
+
+    info!("Running Ping database from {}", db_path);
+
+    let mut child = Command::new("isql-fb")
+        .arg("-q")
+        .arg("-user")
+        .arg(&cfg.username)
+        .arg("-password")
+        .arg(&cfg.password)
+        .arg(&db_path)
+        .stdin(Stdio::piped())
+        .stdout(Stdio::piped())
+        .stderr(Stdio::piped())
+        .spawn()?;
+
+    let query = b"SELECT 1 FROM RDB$DATABASE;\nQUIT;\n";
+
+    if let Some(mut stdin) = child.stdin.take() {
+        stdin.write_all(query).await?;
+    }
+
+    let output = match timeout(Duration::from_secs(5), child.wait_with_output()).await {
+        Ok(res) => res?,
+        Err(_) => return Ok(false),
+    };
+
+    if !output.status.success() {
+        error!("Error output for firebird: {:?}", output);
+        return Ok(false);
+    }
+
+    let stdout = String::from_utf8_lossy(&output.stdout);
+    let stderr = String::from_utf8_lossy(&output.stderr);
+
+    if stderr.to_lowercase().contains("error") {
+        error!("Error output for firebird: {:?}", output);
+        return Ok(false);
+    }
+
+    if stdout.contains("1") {
+        return Ok(true);
+    }
+
+    info!("stdout {}", stdout);
+    error!("stderr {}", stderr);
+
+    Ok(false)
+}

src/domain/firebird/restore.rs

@@ -0,0 +1,48 @@
+use crate::services::backup::logger::JobLogger;
+use crate::services::config::DatabaseConfig;
+use anyhow::{Context, Result};
+use std::path::PathBuf;
+use std::process::Command;
+use std::sync::Arc;
+use std::time::Instant;
+
+pub async fn run(cfg: DatabaseConfig, restore_file: PathBuf, logger: Arc<JobLogger>) -> Result<()> {
+    tokio::task::spawn_blocking(move || -> Result<()> {
+        logger.log("debug", format!("Starting Firebird restore for database {}", cfg.name));
+
+        let db_path = format!("{}/{}:{}", cfg.host, cfg.port, cfg.database);
+
+        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")
+            .arg("-replace_database")
+            .arg("-user")
+            .arg(&cfg.username)
+            .arg("-password")
+            .arg(&cfg.password)
+            .arg(&restore_file)
+            .arg(&db_path)
+            .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() {
+            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);
+        }
+
+        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(())
+    })
+    .await?
+}

src/domain/mariadb/backup.rs

@@ -1,38 +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())
@@ -43,23 +51,30 @@ pub async fn run(
             .arg("--single-transaction")
             .arg("--quick")
             .arg("--skip-lock-tables")
-            .arg("--add-drop-database")
-            .arg("--databases").arg(&cfg.database)
+            .arg("--no-create-db")
+            .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)
             .arg("-r").arg(&file_path)
             .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};",
+            "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")
@@ -47,6 +54,7 @@ pub async fn run(cfg: DatabaseConfig, restore_file: PathBuf) -> Result<()> {
             .arg(cfg.port.to_string())
             .arg("--user")
             .arg(&cfg.username)
+            .arg("--database")
             .arg(&cfg.database)
             .env("MYSQL_PWD", &cfg.password)
             .stdin(std::process::Stdio::piped())
@@ -54,27 +62,30 @@ 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(())
     });
 
     handle.await??;
 
     Ok(())
-}
+}

src/domain/mod.rs

@@ -6,3 +6,5 @@ mod redis;
 mod sqlite;
 mod valkey;
 mod mariadb;
+mod firebird;
+pub mod mssql;

src/domain/mongodb/backup.rs

@@ -1,36 +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");
-        info!("{:?}", 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/connection.rs

@@ -28,3 +28,18 @@ pub fn get_mongo_uri(cfg: DatabaseConfig) -> Result<String> {
         ))
     }
 }
+
+
+pub fn extract_db_name(dry_output: &str) -> Option<String> {
+    let mut dbs = std::collections::HashSet::new();
+    for line in dry_output.lines() {
+        if let Some(pos) = line.find("archive prelude ") {
+            let rest = &line[pos + "archive prelude ".len()..];
+            if let Some(dot) = rest.find('.') {
+                let db = &rest[..dot];
+                dbs.insert(db.to_string());
+            }
+        }
+    }
+    dbs.into_iter().next()
+}

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,32 +1,74 @@
-use crate::domain::mongodb::connection::{get_mongo_uri, select_mongo_path};
+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 output = Command::new(mongorestore)
+        let dry_start = Instant::now();
+        let dry_run = Command::new(&mongorestore)
+            .arg(format!(
+                "--uri={}",
+                format!(
+                    "mongodb://{}:{}@{}:{}/?authSource=admin",
+                    cfg.username, cfg.password, cfg.host, cfg.port
+                )
+            ))
+            .arg(format!("--archive={}", restore_file.display()))
+            .arg("--gzip")
+            .arg("--dryRun")
+            .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);
+        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()
+        });
+
+        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()))
             .arg("--gzip")
             .arg("--drop")
+            .arg(format!("--nsInclude={}.*", source_db))
+            .arg(format!("--nsFrom={}.*", source_db))
+            .arg(format!("--nsTo={}.*", cfg.database))
             .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);
-            anyhow::bail!("MongoDB restore failed for : {}", cfg.name);
+            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

@@ -0,0 +1,56 @@
+use crate::services::backup::logger::JobLogger;
+use crate::services::config::DatabaseConfig;
+use anyhow::{Context, Result};
+use std::path::PathBuf;
+use std::process::Command;
+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> {
+        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!(
+            "Server=tcp:{},{};Database={};User Id={};Password={};TrustServerCertificate=True;Encrypt=False",
+            cfg.host, cfg.port, cfg.database, cfg.username, cfg.password
+        );
+
+        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() {
+            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);
+        }
+
+        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/connection.rs

@@ -0,0 +1,18 @@
+use crate::services::config::DatabaseConfig;
+use anyhow::Result;
+use tiberius::{AuthMethod, Client, Config};
+use tokio::net::TcpStream;
+use tokio_util::compat::{Compat, TokioAsyncWriteCompatExt};
+
+pub async fn build_client(cfg: &DatabaseConfig) -> Result<Client<Compat<TcpStream>>> {
+    let mut config = Config::new();
+    config.host(&cfg.host);
+    config.port(cfg.port);
+    config.authentication(AuthMethod::sql_server(&cfg.username, &cfg.password));
+    config.trust_cert();
+
+    let tcp = TcpStream::connect(config.get_addr()).await?;
+    tcp.set_nodelay(true)?;
+    let client = Client::connect(config, tcp.compat_write()).await?;
+    Ok(client)
+}

src/domain/mssql/database.rs

@@ -0,0 +1,50 @@
+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,
+}
+
+impl MssqlDatabase {
+    pub fn new(cfg: DatabaseConfig) -> Self {
+        Self { cfg }
+    }
+}
+
+#[async_trait]
+impl Database for MssqlDatabase {
+    fn file_extension(&self) -> &'static str {
+        ".bacpac"
+    }
+
+    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.file_extension(),
+            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/mssql/mod.rs

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

src/domain/mssql/ping.rs

@@ -0,0 +1,24 @@
+use crate::services::config::DatabaseConfig;
+use anyhow::Result;
+use tracing::{error, info};
+
+pub async fn run(cfg: DatabaseConfig) -> Result<bool> {
+    info!("Running ping for MSSQL database {}", cfg.name);
+
+    match super::connection::build_client(&cfg).await {
+        Ok(mut client) => match client.simple_query("SELECT 1").await {
+            Ok(_) => {
+                info!("MSSQL ping succeeded for {}", cfg.name);
+                Ok(true)
+            }
+            Err(e) => {
+                error!("MSSQL ping query failed for {}: {:?}", cfg.name, e);
+                Ok(false)
+            }
+        },
+        Err(e) => {
+            error!("MSSQL connection failed for {}: {:?}", cfg.name, e);
+            Ok(false)
+        }
+    }
+}

src/domain/mssql/restore.rs

@@ -0,0 +1,54 @@
+use crate::services::backup::logger::JobLogger;
+use crate::services::config::DatabaseConfig;
+use anyhow::{Context, Result};
+use std::path::PathBuf;
+use std::process::Command;
+use std::sync::Arc;
+use std::time::Instant;
+
+pub async fn run(cfg: DatabaseConfig, restore_file: PathBuf, logger: Arc<JobLogger>) -> Result<()> {
+    tokio::task::spawn_blocking(move || -> Result<()> {
+        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
+        );
+
+        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))
+            .arg(format!("/sf:{}", restore_file.display()))
+            .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() {
+            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);
+        }
+
+        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,67 +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));
 
-        // let mysql_dump = select_mysql_path(&version).join("mysqldump");
-        // info!("MySQL dump found: {}", mysql_dump.display());
+        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("--add-drop-database")
-            .arg("--databases")
-            .arg(cfg.database)
-            .arg("-r")
-            .arg(&file_path)
+            .arg("--skip-lock-tables")
+            .arg("--skip-add-drop-table")
+            .arg("--no-create-db")
+            .arg("--default-character-set=utf8mb4")
+            .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};",
+            "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")
@@ -47,6 +54,7 @@ pub async fn run(cfg: DatabaseConfig, restore_file: PathBuf) -> Result<()> {
             .arg(cfg.port.to_string())
             .arg("--user")
             .arg(&cfg.username)
+            .arg("--database")
             .arg(&cfg.database)
             .env("MYSQL_PWD", &cfg.password)
             .stdin(std::process::Stdio::piped())
@@ -54,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/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,91 @@ pub async fn server_version(cfg: &DatabaseConfig) -> Result<String> {
     Ok(version)
 }
 
+/// Resolves the `bin` directory of a PostgreSQL installation for the given
+/// major version, in a cross-platform way.
+///
+/// Resolution order:
+/// 1. The `PG_BIN_DIR` environment variable, if set, is used as-is. This
+///    allows users/CI to override detection for non-standard installs
+///    (e.g. portable PostgreSQL distributions, custom install locations).
+/// 2. Platform-specific default install locations (Debian/Ubuntu packages,
+///    the official Windows installer, Homebrew/Postgres.app on macOS, and
+///    common RPM-based layouts on other Linux distros).
+/// 3. A `PATH` lookup for `pg_dump` (`pg_dump.exe` on Windows), returning
+///    its parent directory.
+/// 4. The historical Debian/Ubuntu path as a last-resort fallback, so the
+///    function keeps returning a `PathBuf` (never panics) even when nothing
+///    was found, preserving the previous behavior for callers.
+///
+/// The override is sourced from `CONFIG.pg_bin_dir` (the `PG_BIN_DIR`
+/// environment variable). An empty value means "unset" and falls through to
+/// detection.
 pub fn select_pg_path(version: &str) -> std::path::PathBuf {
+    select_pg_path_with(version, &CONFIG.pg_bin_dir)
+}
+
+/// Inner resolver behind [`select_pg_path`], parameterized over the
+/// `PG_BIN_DIR` override. Kept pure (no env / no `CONFIG` access) so it is
+/// unit-testable without mutating process-global state.
+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_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();
@@ -68,6 +153,7 @@ pub async fn detect_format_from_size(cfg: &DatabaseConfig) -> PostgresDumpFormat
         "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/mod.rs

@@ -1,5 +1,5 @@
 pub mod backup;
-mod connection;
+pub(crate) mod connection;
 pub mod database;
 mod format;
 mod ping;

src/domain/postgres/restore.rs

@@ -1,94 +1,106 @@
 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, terminate_connections};
 use super::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<()> {
     tokio::task::spawn_blocking(move || -> Result<()> {
-        debug!("Starting restore for database {}", cfg.name);
+        logger.log("info", format!("Starting restore 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 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);
+        logger.log("debug", format!("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);
+            logger.log("error", format!("Failed to terminate connections for {}: {:?}", cfg.name, e));
             return Err(e.into());
         }
-        info!("Connections terminated for database {}", cfg.name);
-
-        let url = format!(
-            "postgresql://{}:{}@{}:{}/postgres",
-            cfg.username, cfg.password, cfg.host, cfg.port
-        );
-
-        debug!("Restore URL: {}", url);
+        logger.log("info", format!("Connections terminated for database {}", cfg.name));
 
         match format {
             PostgresDumpFormat::Fc => {
-                info!("Running FC restore for {}", cfg.name);
-                let status = Command::new(&pg_restore)
+                logger.log("info", format!("Running FC restore for {}", cfg.name));
+                let start = Instant::now();
+                let output = Command::new(&pg_restore)
                     .arg("--no-owner")
                     .arg("--no-privileges")
                     .arg("--clean")
                     .arg("--if-exists")
-                    .arg("--create")
-                    .arg("--dbname")
-                    .arg(&url)
+                    // .arg("--create")
+                    .arg("--host").arg(&cfg.host)
+                    .arg("--port").arg(cfg.port.to_string())
+                    .arg("--username").arg(&cfg.username)
+                    .arg("--dbname").arg(&cfg.database)
                     .arg("-v")
                     .arg(&restore_file)
-                    .env("PGPASSWORD", &cfg.password)
-                    .status();
+                    .envs(env)
+                    .output();
 
-                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);
+                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("pg_restore", if combined.is_empty() { None } else { Some(combined) }, Some(0), Some(duration_ms));
+                            logger.log("info", format!("FC restore completed successfully for {}", cfg.name))
+                        } else {
+                            logger.log_command("pg_restore", if combined.is_empty() { None } else { Some(combined) }, Some(exit_code), Some(duration_ms));
+                            logger.log("error", format!("FC restore failed with status {:?} for {}", o.status, cfg.name));
+                            anyhow::bail!("Postgres restore failed for {}", cfg.name);
+                        }
                     }
                     Err(e) => {
-                        error!("Error executing pg_restore for {}: {:?}", cfg.name, 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));
                         return Err(e.into());
                     }
                 }
             }
 
             PostgresDumpFormat::Fd => {
-                info!("Running FD restore for {}", cfg.name);
+                logger.log("info", format!("Running FD restore for {}", cfg.name));
 
                 let tar_gz = match std::fs::File::open(&restore_file) {
                     Ok(f) => f,
                     Err(e) => {
-                        error!(
+                        logger.log("error", format!(
                             "Failed to open restore file {:?} for {}: {:?}",
                             restore_file, cfg.name, e
-                        );
+                        ));
                         return Err(e.into());
                     }
                 };
 
-                info!("tar_gz {:?}", tar_gz);
+                logger.log("info", format!("tar_gz {:?}", tar_gz));
 
                 let dec = flate2::read::GzDecoder::new(tar_gz);
                 let mut archive = tar::Archive::new(dec);
@@ -96,31 +108,31 @@ pub async fn run(
                 let tmp_dir = match tempfile::TempDir::new() {
                     Ok(d) => d,
                     Err(e) => {
-                        error!(
+                        logger.log("error", format!(
                             "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);
+                    logger.log("error", format!("Failed to unpack FD archive for {}: {:?}", cfg.name, e));
                     return Err(e.into());
                 }
 
-                debug!("Listing contents of temp dir: {}", tmp_dir.path().display());
+                logger.log("debug", format!("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!(
+                        logger.log("debug", format!(
                             " - {} | is_dir: {} | is_file: {}",
                             path.display(),
                             file_type.is_dir(),
                             file_type.is_file()
-                        );
+                        ));
                     }
                 }
 
@@ -134,38 +146,52 @@ pub async fn run(
                         .ok_or_else(|| anyhow::anyhow!("Invalid FD archive: toc.dat not found"))?
                 };
 
-                let status = Command::new(&pg_restore)
+                let start = Instant::now();
+                let output = Command::new(&pg_restore)
                     .arg("--no-owner")
                     .arg("--no-privileges")
                     .arg("--clean")
                     .arg("--if-exists")
-                    .arg("--create")
-                    .arg("--dbname")
-                    .arg(&url)
+                    // .arg("--create")
+                    .arg("--host").arg(&cfg.host)
+                    .arg("--port").arg(cfg.port.to_string())
+                    .arg("--username").arg(&cfg.username)
+                    .arg("--dbname").arg(&cfg.database)
                     .arg("-v")
                     .arg("-j")
                     .arg("4")
                     .arg(dump_dir)
-                    .env("PGPASSWORD", &cfg.password)
-                    .status();
+                    .envs(env)
+                    .output();
 
-                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);
+                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("pg_restore", if combined.is_empty() { None } else { Some(combined) }, Some(0), Some(duration_ms));
+                            logger.log("info", format!("FD restore completed successfully for {}", cfg.name))
+                        } else {
+                            logger.log_command("pg_restore", if combined.is_empty() { None } else { Some(combined) }, Some(exit_code), Some(duration_ms));
+                            logger.log("error", format!("FD restore failed with status {:?} for {}", o.status, cfg.name));
+                            anyhow::bail!("Postgres FD restore failed for {}", cfg.name);
+                        }
                     }
                     Err(e) => {
-                        error!("Error executing pg_restore for {}: {:?}", cfg.name, 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));
                         return Err(e.into());
                     }
                 }
             }
         }
 
-        info!("Restore finished for database {}", cfg.name);
+        logger.log("info", format!("Restore finished for database {}", cfg.name));
 
         Ok(())
     })

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/redis/ping.rs

@@ -30,10 +30,7 @@ pub async fn run(cfg: DatabaseConfig) -> Result<bool> {
             let output = output.context("Failed to execute redis-cli")?;
             let stdout = String::from_utf8_lossy(&output.stdout);
             let stderr = String::from_utf8_lossy(&output.stderr);
-
-            if !stdout.is_empty() {
-                error!("Redis stderr: {}", stderr);
-            }
+            
 
             if stderr.contains("NOAUTH") {
                 error!("Redis authentication failed (NOAUTH required)");

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,26 +22,35 @@ pub async fn run(
         };
 
         let db_path = PathBuf::from(db_path_str);
+        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")?;
+        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/domain/valkey/ping.rs

@@ -30,11 +30,7 @@ pub async fn run(cfg: DatabaseConfig) -> Result<bool> {
             let output = output.context("Failed to execute valkey-cli")?;
             let stdout = String::from_utf8_lossy(&output.stdout);
             let stderr = String::from_utf8_lossy(&output.stderr);
-
-            if !stdout.is_empty() {
-                error!("Valkey stderr: {}", stderr);
-            }
-
+            
             if stderr.contains("NOAUTH") {
                 error!("Valkey authentication failed (NOAUTH required)");
                 return Ok(false);

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/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,21 +48,27 @@ 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(_) => Ok(BackupResult {
-                generated_id,
-                db_type,
-                status: "failed".into(),
-                backup_file: None,
-                code: None,
-            }),
+            Err(e) => {
+                logger.log("error", format!("Backup failed: {}", e));
+                Ok(BackupResult {
+                    generated_id,
+                    db_type,
+                    status: "failed".into(),
+                    backup_file: None,
+                    code: None,
+                })
+            }
         }
     }
 }

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,
@@ -107,20 +107,23 @@ impl BackupService {
                     )
                     .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")
+                    ));
                     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 +132,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 +162,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

@@ -21,6 +21,8 @@ pub enum DbType {
     Sqlite,
     Redis,
     Valkey,
+    Firebird,
+    Mssql,
 }
 
 impl DbType {
@@ -33,6 +35,8 @@ impl DbType {
             DbType::Sqlite => "sqlite",
             DbType::Redis => "redis",
             DbType::Valkey => "valkey",
+            DbType::Firebird => "firebird",
+            DbType::Mssql => "mssql",
         }
     }
 }
@@ -50,6 +54,7 @@ pub struct DatabaseConfig {
     pub host: String,
     pub generated_id: String,
     pub path: String,
+    pub max_packet_size: String,
 }
 
 #[allow(dead_code)]
@@ -71,6 +76,7 @@ pub struct InputDatabaseConfig {
     pub host: Option<String>,
     pub generated_id: String,
     pub path: Option<String>,
+    pub max_packet_size: Option<String>,
 }
 
 #[allow(dead_code)]
@@ -163,14 +169,14 @@ impl ConfigService {
             }
 
             let username = match db.db_type {
-                DbType::Postgresql | DbType::Mysql | DbType::Mariadb => {
+                DbType::Postgresql | 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::Postgresql | DbType::Mysql | DbType::Mariadb | DbType::Mssql => {
                     required(&db.password, &db.name, "password")?
                 }
                 _ => optional(&db.password),
@@ -182,7 +188,9 @@ impl ConfigService {
                 | DbType::Mariadb
                 | DbType::MongoDB
                 | DbType::Redis
-                | DbType::Valkey => required(&db.host, &db.name, "host")?,
+                | DbType::Firebird
+                | DbType::Valkey
+                | DbType::Mssql => required(&db.host, &db.name, "host")?,
                 DbType::Sqlite => optional(&db.host),
             };
 
@@ -192,7 +200,9 @@ impl ConfigService {
                 | DbType::Mariadb
                 | DbType::MongoDB
                 | DbType::Redis
-                | DbType::Valkey => required(&db.port, &db.name, "port")?,
+                | DbType::Firebird
+                | DbType::Valkey
+                | DbType::Mssql => required(&db.port, &db.name, "port")?,
                 DbType::Sqlite => db.port.unwrap_or(0),
             };
 
@@ -206,6 +216,13 @@ 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(),
+            };
+
             databases.push(DatabaseConfig {
                 name: db.name,
                 database: database_name,
@@ -216,6 +233,7 @@ impl ConfigService {
                 port,
                 generated_id: db.generated_id,
                 path: path_val,
+                max_packet_size,
             });
         }
 

src/services/restore/archive.rs

@@ -5,22 +5,30 @@ 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;
 
 impl RestoreService {
     pub async fn prepare_archive(
         &self,
         downloaded_file: PathBuf,
         tmp_path: &Path,
+        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,29 +37,50 @@ 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?;
+        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");
         }
 
+        logger.log("info", format!("Archive prepared, {} file(s) extracted", files.len()));
+
         if files.len() == 1 {
+            logger.log("debug", format!("Using single extracted file: {}", files[0].display()));
             Ok(files[0].clone())
         } else {
+            logger.log("debug", format!("Multiple files extracted, using archive root: {}", archive.display()));
             Ok(archive)
         }
     }

src/services/restore/downloader.rs

@@ -3,15 +3,19 @@ use super::service::RestoreService;
 use anyhow::Result;
 use reqwest::{Client, Url};
 use std::path::{Path, PathBuf};
-use tracing::info;
+use std::sync::Arc;
+use crate::services::backup::logger::JobLogger;
 
 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>) -> Result<PathBuf> {
+        logger.log("info", "Start downloading backup archive".to_string());
+
         let client = Client::new();
 
         let response = client.get(file_url).send().await?;
 
         if !response.status().is_success() {
+            logger.log("error", "Failed to download".to_string());
             anyhow::bail!("download failed");
         }
 
@@ -39,8 +43,7 @@ impl RestoreService {
 
         tokio::fs::write(&path, &bytes).await?;
 
-        info!("Backup downloaded to {}", path.display());
-
+        logger.log("info", format!("Backup downloaded to {}", path.display()));
         Ok(path)
     }
 }

src/services/restore/executor.rs

@@ -1,23 +1,36 @@
 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<()> {
+        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)).await?;
 
-        let backup_file = self.prepare_archive(downloaded, tmp_path).await?;
+        let backup_file = self.prepare_archive(downloaded, tmp_path, 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

@@ -9,6 +9,7 @@ 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 {
@@ -32,6 +33,7 @@ impl StatusService {
                 let db_engine = DatabaseFactory::create_for_backup(db.clone()).await;
 
                 let reachable = db_engine.ping().await?;
+                info!("Ping {} => {:?}",db.name, reachable);
 
                 Ok::<DatabasePayload, anyhow::Error>(DatabasePayload {
                     name: &db.name,

src/settings.rs

@@ -11,9 +11,11 @@ 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,
+    pub chunk_size: usize, // bytes
 }
 
 impl Settings {
@@ -35,6 +37,18 @@ impl Settings {
                 pooling_seconds
             );
         }
+
+        let chunk_size_mb = env::var("CHUNK_SIZE_MB")
+            .unwrap_or_else(|_| "1".to_string())
+            .parse::<usize>()
+            .expect("CHUNK_SIZE_MB must be a valid positive integer");
+
+        if chunk_size_mb == 0 || chunk_size_mb > 10 {
+            panic!("CHUNK_SIZE_MB must be between 1 and 10 MB");
+        }
+
+        let chunk_size = chunk_size_mb * 1024 * 1024;
+
         let tz = env::var("TZ").unwrap_or_else(|_| "UTC".to_string());
 
         Self {
@@ -46,9 +60,11 @@ 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()),
+            chunk_size
         }
     }
 }

src/tests/domain/firebird.rs

@@ -0,0 +1,109 @@
+use crate::domain::factory::DatabaseFactory;
+use crate::services::config::{DatabaseConfig, DbType};
+use crate::tests::init_tracing_for_test;
+use crate::utils::compress::{compress_to_tar_gz_large, decompress_large_tar_gz};
+use std::path::PathBuf;
+use std::time::Duration;
+use tempfile::TempDir;
+use testcontainers::runners::AsyncRunner;
+use testcontainers::{ContainerAsync, GenericImage, ImageExt};
+use testcontainers::core::IntoContainerPort;
+use tracing::{error, info};
+
+async fn create_config() -> (ContainerAsync<GenericImage>, DatabaseConfig) {
+    let container = GenericImage::new("firebirdsql/firebird", "latest")
+        .with_exposed_port(3050.tcp())
+        .with_env_var("FIREBIRD_ROOT_PASSWORD", "fake_root_password")
+        .with_env_var("FIREBIRD_USER", "alice")
+        .with_env_var("FIREBIRD_PASSWORD", "fake_password")
+        .with_env_var("FIREBIRD_DATABASE", "mirror.fdb")
+        .with_env_var("FIREBIRD_DATABASE_DEFAULT_CHARSET", "UTF8")
+        .start()
+        .await
+        .expect("Firebird started");
+
+    tokio::time::sleep(Duration::from_secs(15)).await;
+
+    let host = container.get_host().await.unwrap().to_string();
+    let port = container.get_host_port_ipv4(3050).await.unwrap();
+
+    let database = "/var/lib/firebird/data/mirror.fdb";
+
+    let config = DatabaseConfig {
+        name: "Test Firebird".to_string(),
+        database: database.to_string(),
+        db_type: DbType::Firebird,
+        username: "alice".to_string(),
+        password: "fake_password".to_string(),
+        port,
+        host,
+        generated_id: "3c445eb4-c2c6-4bde-a423-ee1385dcf6d2".to_string(),
+        path: "".to_string(),
+        max_packet_size: "".to_string(),
+    };
+
+    (container, config)
+}
+
+#[tokio::test]
+async fn firebird_ping_test() {
+    init_tracing_for_test();
+
+    let (_container, config) = create_config().await;
+
+    let db = DatabaseFactory::create_for_backup(config.clone()).await;
+    let reachable = db.ping().await.unwrap_or(false);
+
+    assert!(reachable);
+}
+
+#[tokio::test]
+async fn firebird_backup_restore_test() {
+    init_tracing_for_test();
+
+    let (_container, config) = create_config().await;
+
+    let temp_dir = TempDir::new().unwrap();
+    let backup_path = temp_dir.path();
+
+    let db = DatabaseFactory::create_for_backup(config.clone()).await;
+
+    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, 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(),
+    )
+        .await
+        .unwrap();
+
+    let backup_file: PathBuf = if files.len() == 1 {
+        files[0].clone()
+    } else {
+        panic!("Unexpected number of files after decompression");
+    };
+
+    let db = DatabaseFactory::create_for_restore(config.clone(), &backup_file).await;
+
+    let reachable = db.ping().await.unwrap_or(false);
+    info!("Reachable: {}", reachable);
+    assert!(reachable);
+
+    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)
+        }
+        Err(e) => {
+            error!("Restore failed for {}: {:?}", config.generated_id, e);
+            assert!(false)
+        }
+    }
+}

src/tests/domain/mariadb.rs

@@ -31,6 +31,7 @@ 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(),
     };
 
     (container, config)
@@ -58,11 +59,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 +82,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

@@ -4,3 +4,5 @@ mod mysql;
 mod postgres;
 mod redis;
 mod valkey;
+mod firebird;
+mod mssql;

src/tests/domain/mongodb.rs

@@ -29,6 +29,7 @@ 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(),
     };
 
     (container, config)
@@ -75,7 +76,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 +86,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)

src/tests/domain/mssql.rs

@@ -0,0 +1,152 @@
+use crate::domain::factory::DatabaseFactory;
+use crate::services::config::{DatabaseConfig, DbType};
+use crate::tests::init_tracing_for_test;
+use crate::utils::compress::{compress_to_tar_gz_large, decompress_large_tar_gz};
+use std::path::PathBuf;
+use std::time::Duration;
+use tempfile::TempDir;
+use tiberius::{AuthMethod, Client, Config};
+use testcontainers::runners::AsyncRunner;
+use testcontainers::{ContainerAsync, GenericImage, ImageExt};
+use testcontainers::core::IntoContainerPort;
+use tokio::net::TcpStream;
+use tokio_util::compat::TokioAsyncWriteCompatExt;
+use tracing::{error, info};
+
+const SA_PASSWORD: &str = "Test!Str0ng1";
+
+async fn start_container() -> ContainerAsync<GenericImage> {
+    GenericImage::new("mcr.microsoft.com/azure-sql-edge", "latest")
+        .with_exposed_port(1433.tcp())
+        .with_env_var("ACCEPT_EULA", "Y")
+        .with_env_var("MSSQL_SA_PASSWORD", SA_PASSWORD)
+        .start()
+        .await
+        .expect("azure-sql-edge container started")
+}
+
+async fn create_user_database(host: &str, port: u16, db_name: &str) {
+    let mut config = Config::new();
+    config.host(host);
+    config.port(port);
+    config.authentication(AuthMethod::sql_server("sa", SA_PASSWORD));
+    config.trust_cert();
+
+    let tcp = TcpStream::connect(config.get_addr()).await.unwrap();
+    tcp.set_nodelay(true).unwrap();
+    let mut client = Client::connect(config, tcp.compat_write()).await.unwrap();
+
+    let sql = format!(
+        "IF NOT EXISTS (SELECT name FROM sys.databases WHERE name = N'{}') CREATE DATABASE [{}]",
+        db_name, db_name
+    );
+    client.simple_query(sql.as_str()).await.unwrap();
+}
+
+fn make_config(host: String, port: u16, database: &str, generated_id: &str) -> DatabaseConfig {
+    DatabaseConfig {
+        name: "Test MSSQL".to_string(),
+        database: database.to_string(),
+        db_type: DbType::Mssql,
+        username: "sa".to_string(),
+        password: SA_PASSWORD.to_string(),
+        port,
+        host,
+        generated_id: generated_id.to_string(),
+        path: "".to_string(),
+        max_packet_size: "".to_string(),
+    }
+}
+
+#[tokio::test]
+async fn mssql_ping_test() {
+    init_tracing_for_test();
+
+    let container = start_container().await;
+    tokio::time::sleep(Duration::from_secs(30)).await;
+
+    let host = container.get_host().await.unwrap().to_string();
+    let port = container.get_host_port_ipv4(1433).await.unwrap();
+    let config = make_config(host, port, "master", "5a445eb4-c2c6-4bde-a423-ee1385dcf6d3");
+
+    let db = DatabaseFactory::create_for_backup(config).await;
+    let reachable = db.ping().await.unwrap_or(false);
+
+    assert!(reachable, "MSSQL ping should succeed");
+}
+
+#[tokio::test]
+async fn mssql_backup_test() {
+    init_tracing_for_test();
+
+    let container = start_container().await;
+    tokio::time::sleep(Duration::from_secs(30)).await;
+
+    let host = container.get_host().await.unwrap().to_string();
+    let port = container.get_host_port_ipv4(1433).await.unwrap();
+
+    create_user_database(&host, port, "backupdb").await;
+
+    let config = make_config(host, port, "backupdb", "5a445eb4-c2c6-4bde-a423-ee1385dcf6d4");
+    let temp_dir = TempDir::new().unwrap();
+
+    let db = DatabaseFactory::create_for_backup(config).await;
+    let file_path = db.backup(temp_dir.path(), std::sync::Arc::new(crate::services::backup::logger::JobLogger::new())).await.unwrap();
+
+    assert!(file_path.is_file(), "backup file should exist");
+    assert!(
+        file_path.metadata().unwrap().len() > 0,
+        "backup file should be non-empty"
+    );
+    assert!(
+        file_path.extension().and_then(|e| e.to_str()) == Some("bacpac"),
+        "backup file should have .bacpac extension"
+    );
+}
+
+#[tokio::test]
+async fn mssql_backup_restore_test() {
+    init_tracing_for_test();
+
+    let container = start_container().await;
+    tokio::time::sleep(Duration::from_secs(30)).await;
+
+    let host = container.get_host().await.unwrap().to_string();
+    let port = container.get_host_port_ipv4(1433).await.unwrap();
+
+    create_user_database(&host, port, "sourcedb").await;
+
+    let backup_config = make_config(host.clone(), port, "sourcedb", "5a445eb4-c2c6-4bde-a423-ee1385dcf6d5");
+    let temp_dir = TempDir::new().unwrap();
+
+    let db = DatabaseFactory::create_for_backup(backup_config).await;
+    let file_path = db.backup(temp_dir.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, 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(),
+    )
+    .await
+    .unwrap();
+
+    let backup_file: PathBuf = if files.len() == 1 {
+        files[0].clone()
+    } else {
+        panic!("Unexpected number of files after decompression: {}", files.len());
+    };
+
+    let restore_config = make_config(host, port, "restoreddb", "5a445eb4-c2c6-4bde-a423-ee1385dcf6d5");
+    let db_restore = DatabaseFactory::create_for_restore(restore_config, &backup_file).await;
+
+    match db_restore.restore(&backup_file, std::sync::Arc::new(crate::services::backup::logger::JobLogger::new())).await {
+        Ok(_) => info!("MSSQL restore succeeded"),
+        Err(e) => {
+            error!("MSSQL restore failed: {:?}", e);
+            panic!("Restore failed: {:?}", e);
+        }
+    }
+}

src/tests/domain/mysql.rs

@@ -31,6 +31,7 @@ async fn create_config() -> (ContainerAsync<Mysql>, DatabaseConfig) {
         host: host.to_string(),
         generated_id: "0f1bb8f2-35a0-4c91-8098-e36873d3ce31".to_string(),
         path: "".to_string(),
+        max_packet_size: "512M".to_string(),
     };
 
     (container, config)
@@ -58,11 +59,11 @@ async fn mysql_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 +82,7 @@ async fn mysql_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/postgres.rs

@@ -38,6 +38,7 @@ async fn create_config() -> (ContainerAsync<Postgres>, DatabaseConfig) {
         host: host.to_string(),
         generated_id: "40875631-e3d2-4dfe-a26b-2a347ecc64fd".to_string(),
         path: "".to_string(),
+        max_packet_size: "".to_string(),
     };
 
     (container, config)
@@ -66,11 +67,11 @@ async fn postgres_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();
 
     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());
 
@@ -96,7 +97,7 @@ async fn postgres_backup_restore_test() {
 
     info!("Running pg_restore: {:?}", backup_file);
 
-    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)
@@ -107,3 +108,105 @@ async fn postgres_backup_restore_test() {
         }
     }
 }
+
+#[tokio::test]
+async fn postgres_password_with_slash_test() {
+    init_tracing_for_test();
+
+    let special_password = "ch/ange:me@1";
+
+    let container = Postgres::default()
+        .with_env_var("POSTGRES_DB", "testdb")
+        .with_env_var("POSTGRES_USER", "testuser")
+        .with_env_var("POSTGRES_PASSWORD", special_password)
+        .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: "My test Postgres Database with slash password".to_string(),
+        database: "testdb".to_string(),
+        db_type: DbType::Postgresql,
+        username: "testuser".to_string(),
+        password: special_password.to_string(),
+        port,
+        host: host.to_string(),
+        generated_id: "5a1f0e3c-9b8a-4a8e-9b1b-0a1c2d3e4f5a".to_string(),
+        path: "".to_string(),
+        max_packet_size: "".to_string(),
+    };
+
+    let db = DatabaseFactory::create_for_backup(config.clone()).await;
+    let reachable = db.ping().await.unwrap_or(false);
+
+    assert_eq!(reachable, true);
+}
+
+mod select_pg_path_tests {
+    use crate::domain::postgres::connection::{
+        pg_dump_binary_name, pg_dump_exists_in, select_pg_path_with,
+    };
+
+    // `select_pg_path_with` takes the `PG_BIN_DIR` override as a plain
+    // argument, so these tests never touch process-global env state or the
+    // cached `CONFIG`. They stay deterministic regardless of whether — or at
+    // which version — a real PostgreSQL install exists on the host.
+
+    #[test]
+    fn respects_pg_bin_dir_override() {
+        let custom = if cfg!(target_os = "windows") {
+            r"C:\custom\pg\bin"
+        } else {
+            "/custom/pg/bin"
+        };
+        let path = select_pg_path_with("16.4", custom);
+        assert_eq!(path, std::path::PathBuf::from(custom));
+    }
+
+    #[test]
+    fn pg_bin_dir_override_ignores_requested_version() {
+        // The override is taken as-is, regardless of which version was
+        // requested — this documents/locks in that behavior.
+        let custom = if cfg!(target_os = "windows") {
+            r"C:\custom\pg\bin"
+        } else {
+            "/custom/pg/bin"
+        };
+        let path = select_pg_path_with("not-a-version", custom);
+        assert_eq!(path, std::path::PathBuf::from(custom));
+    }
+
+    #[test]
+    fn empty_pg_bin_dir_falls_through_to_detection() {
+        // An empty override means "unset" (matches `CONFIG.pg_bin_dir` when
+        // `PG_BIN_DIR` is absent). It must not be returned as a literal empty
+        // path — resolution falls through to platform defaults / PATH lookup
+        // and yields a non-empty path.
+        let path = select_pg_path_with("17", "");
+        assert_ne!(path, std::path::PathBuf::from(""));
+    }
+
+    #[test]
+    fn pg_dump_binary_name_is_platform_specific() {
+        let name = pg_dump_binary_name();
+        if cfg!(target_os = "windows") {
+            assert_eq!(name, "pg_dump.exe");
+        } else {
+            assert_eq!(name, "pg_dump");
+        }
+    }
+
+    #[test]
+    fn pg_dump_exists_in_is_false_for_nonexistent_dir() {
+        let dir = std::path::Path::new("this/path/almost-certainly/does-not-exist-12345");
+        assert!(!pg_dump_exists_in(dir));
+    }
+}

src/tests/domain/redis.rs

@@ -28,6 +28,7 @@ async fn create_config() -> (ContainerAsync<Redis>, DatabaseConfig) {
         host: host.to_string(),
         generated_id: "40875631-e3d2-4dfe-a26b-2a347ecc64fd".to_string(),
         path: "".to_string(),
+        max_packet_size: "".to_string(),
     };
 
     (container, config)
@@ -56,7 +57,7 @@ async fn redis_backup_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();
 
     assert!(file_path.is_file());
 }

src/tests/domain/valkey.rs

@@ -27,6 +27,7 @@ async fn create_config() -> (ContainerAsync<Valkey>, DatabaseConfig) {
         host: host.to_string(),
         generated_id: "40875485-e3d2-4dfe-a26b-2a347ecc64fd".to_string(),
         path: "".to_string(),
+        max_packet_size: "".to_string(),
     };
 
     (container, config)
@@ -55,7 +56,7 @@ async fn valkey_backup_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();
 
     assert!(file_path.is_file());
 }

src/tests/utils/compress_tests.rs

@@ -9,7 +9,7 @@ async fn compress_creates_tar_gz() -> Result<()> {
     let file_path = tmp.path().join("test.txt");
     write(&file_path, b"hello world").await?;
 
-    let result = compress_to_tar_gz_large(&file_path).await?;
+    let result = compress_to_tar_gz_large(&file_path, std::sync::Arc::new(crate::services::backup::logger::JobLogger::new())).await?;
     assert!(result.compressed_path.exists());
     assert_eq!(result.compressed_path.extension().unwrap(), "gz");
 
@@ -22,8 +22,7 @@ async fn compress_skips_existing_tar_gz() -> Result<()> {
     let file_path = tmp.path().join("already.tar.gz");
     write(&file_path, b"compressed").await?;
 
-    let result = compress_to_tar_gz_large(&file_path).await?;
-    // Should return same path without creating a new file
+    let result = compress_to_tar_gz_large(&file_path, std::sync::Arc::new(crate::services::backup::logger::JobLogger::new())).await?;
     assert_eq!(result.compressed_path, file_path);
 
     Ok(())
@@ -35,7 +34,7 @@ async fn decompress_restores_file() -> Result<()> {
     let file_path = tmp.path().join("file.txt");
     write(&file_path, b"data for decompress").await?;
 
-    let compress_result = compress_to_tar_gz_large(&file_path).await?;
+    let compress_result = compress_to_tar_gz_large(&file_path, std::sync::Arc::new(crate::services::backup::logger::JobLogger::new())).await?;
     let output_dir = tmp.path().join("out");
     tokio::fs::create_dir_all(&output_dir).await?;
 
@@ -58,8 +57,8 @@ async fn decompress_multiple_files() -> Result<()> {
     write(&file2, b"file2").await?;
 
     // Compress both files individually (for simplicity in this test)
-    let compress1 = compress_to_tar_gz_large(&file1).await?;
-    let compress2 = compress_to_tar_gz_large(&file2).await?;
+    let compress1 = compress_to_tar_gz_large(&file1, std::sync::Arc::new(crate::services::backup::logger::JobLogger::new())).await?;
+    let compress2 = compress_to_tar_gz_large(&file2, std::sync::Arc::new(crate::services::backup::logger::JobLogger::new())).await?;
 
     let output_dir = tmp.path().join("out_multi");
     tokio::fs::create_dir_all(&output_dir).await?;

src/utils/compress.rs

@@ -3,6 +3,7 @@ use async_compression::tokio::bufread::GzipDecoder;
 use async_compression::tokio::write::GzipEncoder as AsyncGzipEncoder;
 use futures::StreamExt;
 use std::path::{Path, PathBuf};
+use std::sync::Arc;
 use tokio::fs::File;
 use tokio::fs::create_dir_all;
 use tokio::io::AsyncWriteExt;
@@ -11,19 +12,21 @@ use tokio_tar::Archive;
 use tokio_tar::Builder as TokioTarBuilder;
 use tracing::info;
 
+use crate::services::backup::logger::JobLogger;
+
 #[allow(dead_code)]
 pub struct CompressionResult {
     pub compressed_path: PathBuf,
 }
 
-pub async fn compress_to_tar_gz_large(file: &PathBuf) -> Result<CompressionResult> {
+pub async fn compress_to_tar_gz_large(file: &PathBuf, logger: Arc<JobLogger>) -> Result<CompressionResult> {
     if file
         .file_name()
         .and_then(|n| n.to_str())
         .map(|n| n.ends_with(".tar.gz"))
         .unwrap_or(false)
     {
-        info!("File {:?} is already a tar.gz, skipping compression", file);
+        logger.log("info", format!("File {:?} is already a tar.gz, skipping compression", file));
         return Ok(CompressionResult {
             compressed_path: file.clone(),
         });
@@ -31,34 +34,56 @@ pub async fn compress_to_tar_gz_large(file: &PathBuf) -> Result<CompressionResul
 
     let tar_gz_path = file.with_extension("").with_extension("tar.gz");
 
-    let output_file = File::create(&tar_gz_path).await?;
+    let output_file = File::create(&tar_gz_path)
+        .await
+        .map_err(|e| {
+            logger.log("error", format!("Failed to create output file {:?}: {}", tar_gz_path, e));
+            anyhow::anyhow!("Failed to create output file {:?}: {}", tar_gz_path, e)
+        })?;
+
     let gzip_writer = AsyncGzipEncoder::new(output_file);
     let mut tar_builder = TokioTarBuilder::new(gzip_writer);
 
     let file_name = file
         .file_name()
-        .ok_or_else(|| anyhow::anyhow!("Cannot get file name for {:?}", file))?;
+        .ok_or_else(|| {
+            logger.log("error", format!("Cannot get file name for {:?}", file));
+            anyhow::anyhow!("Cannot get file name for {:?}", file)
+        })?;
 
     tar_builder
         .append_path_with_name(file, file_name)
         .await
-        .map_err(|e| anyhow::anyhow!("Failed to append path: {}", e))?;
+        .map_err(|e| {
+            logger.log("error", format!("Failed to append path: {}", e));
+            anyhow::anyhow!("Failed to append path: {}", e)
+        })?;
 
     tar_builder
         .finish()
         .await
-        .map_err(|e| anyhow::anyhow!("Failed to finish tar: {}", e))?;
+        .map_err(|e| {
+            logger.log("error", format!("Failed to finish tar: {}", e));
+            anyhow::anyhow!("Failed to finish tar: {}", e)
+        })?;
 
     let mut gzip = tar_builder
         .into_inner()
         .await
-        .map_err(|e| anyhow::anyhow!("Failed to extract gzip encoder: {}", e))?;
+        .map_err(|e| {
+            logger.log("error", format!("Failed to extract gzip encoder: {}", e));
+            anyhow::anyhow!("Failed to extract gzip encoder: {}", e)
+        })?;
 
     gzip.shutdown()
         .await
-        .map_err(|e| anyhow::anyhow!("Gzip shutdown failed: {}", e))?;
+        .map_err(|e| {
+            logger.log("error", format!("Gzip shutdown failed: {}", e));
+            anyhow::anyhow!("Gzip shutdown failed: {}", e)
+        })?;
 
-    info!("Compressing {:?} to {:?}", &file, &tar_gz_path);
+
+    logger.log("info", format!("Compressed {:?} to {:?}", &file, &tar_gz_path));
 
     Ok(CompressionResult {
         compressed_path: tar_gz_path,

src/utils/stream.rs

@@ -3,12 +3,15 @@ use anyhow::Result;
 use bytes::Bytes;
 use futures::{Stream, StreamExt};
 use std::pin::Pin;
-use tokio_util::io::ReaderStream;
+use tokio::io::{AsyncReadExt};
+use crate::settings::CONFIG;
 
 pub struct UploadStream {
     pub stream: Pin<Box<dyn Stream<Item = Result<Bytes, std::io::Error>> + Send>>,
 }
 
+
+
 pub async fn build_stream(
     file_path: &std::path::Path,
     encrypt: bool,
@@ -25,13 +28,27 @@ pub async fn build_stream(
 
         Ok(UploadStream { stream })
     } else {
-        let file = tokio::fs::File::open(file_path).await?;
-        let reader = ReaderStream::new(file);
+        let mut file = tokio::fs::File::open(file_path).await?;
 
-        let stream = Box::pin(
-            reader.map(|r| r.map_err(|e| std::io::Error::new(std::io::ErrorKind::Other, e))),
-        );
+        let stream = async_stream::stream! {
+            let mut buffer = vec![0u8; CONFIG.chunk_size];
 
-        Ok(UploadStream { stream })
+            loop {
+                let n = match file.read(&mut buffer).await {
+                    Ok(0) => break,
+                    Ok(n) => n,
+                    Err(e) => {
+                        yield Err(e);
+                        break;
+                    }
+                };
+
+                yield Ok(Bytes::copy_from_slice(&buffer[..n]));
+            }
+        };
+
+        Ok(UploadStream {
+            stream: Box::pin(stream),
+        })
     }
 }

src/utils/tus.rs

@@ -3,8 +3,7 @@ use bytes::Bytes;
 use futures::{Stream, StreamExt};
 use reqwest::header::{CONTENT_TYPE, HeaderMap, HeaderValue};
 use tracing::{error, info};
-
-const PATCH_CHUNK_SIZE: usize = 1 * 1024 * 1024;
+use crate::settings::CONFIG;
 
 pub async fn upload_to_tus_stream_with_headers<S>(
     encrypted_stream: S,
@@ -66,7 +65,9 @@ where
     while let Some(chunk) = stream.next().await {
         let chunk = chunk.context("Stream produced IO error")?;
 
-        for sub_chunk in chunk.chunks(PATCH_CHUNK_SIZE) {
+        info!("Chunk: {:?}", CONFIG.chunk_size);
+
+        for sub_chunk in chunk.chunks(CONFIG.chunk_size) {
             let mut patch_headers = extra_headers.clone();
             patch_headers.insert("Tus-Resumable", HeaderValue::from_static("1.0.0"));
             patch_headers.insert(