feat: add-heathcheck-database

docker-compose.prod.yml

@@ -5,23 +5,20 @@ services:
 #      dockerfile: docker/Dockerfile
 #      target: prod
     image: portabase/agent:latest
-#    platform: linux/arm64
     container_name: rust-prod
     volumes:
       - ./databases.json:/config/config.json
     environment:
-      #      APP_ENV: production
       LOG: info
       TZ: "Europe/Paris"
-      #      DATABASES_CONFIG_FILE: "config.toml"
-      EDGE_KEY: "eyJzZXJ2ZXJVcmwiOiJodHRwOi8vbG9jYWxob3N0Ojg4ODciLCJhZ2VudElkIjoiNWU1OGU2MGEtODhiMy00YTBjLWI0NDktNTQ3OWZhOTQzZDBkIiwibWFzdGVyS2V5QjY0IjoiQlhWM1hvbEM2NTZTVjdkTmdjV1BHUWxrKytycExJNmxHRGk3Q1BCNWllbz0ifQ=="
+      #DATABASES_CONFIG_FILE: "config.toml"
+      EDGE_KEY: "<to complete>"
     extra_hosts:
       - "localhost:host-gateway"
     networks:
       - portabase
 
 
-
   db-mongodb-auth:
     container_name: db-mongodb-auth
     image: mongo:latest

src/domain/redis/ping.rs

@@ -2,7 +2,7 @@ use crate::services::config::DatabaseConfig;
 use anyhow::{Context, Result};
 use tokio::process::Command;
 use tokio::time::{Duration, timeout};
-use tracing::{debug, info};
+use tracing::{debug, error, info};
 
 pub async fn run(cfg: DatabaseConfig) -> Result<bool> {
     let mut cmd = Command::new("redis-cli");
@@ -21,7 +21,7 @@ pub async fn run(cfg: DatabaseConfig) -> Result<bool> {
 
     cmd.arg("PING");
 
-    debug!("Command Ping: {:?}", cmd);
+    debug!("Command Ping Redis: {:?}", cmd);
 
     let result = timeout(Duration::from_secs(10), cmd.output()).await;
 
@@ -31,16 +31,17 @@ pub async fn run(cfg: DatabaseConfig) -> Result<bool> {
             let stdout = String::from_utf8_lossy(&output.stdout);
             let stderr = String::from_utf8_lossy(&output.stderr);
 
-            info!("Redis stdout: {}", stdout);
-            info!("Redis stderr: {}", stderr);
+            if !stdout.is_empty() {
+                error!("Redis stderr: {}", stderr);
+            }
 
             if stderr.contains("NOAUTH") {
-                info!("Redis authentication failed (NOAUTH required)");
+                error!("Redis authentication failed (NOAUTH required)");
                 return Ok(false);
             }
 
             if !output.status.success() {
-                info!("Redis command failed with status: {:?}", output.status);
+                error!("Redis command failed with status: {:?}", output.status);
                 return Ok(false);
             }
 

src/domain/valkey/ping.rs

@@ -2,7 +2,7 @@ use crate::services::config::DatabaseConfig;
 use anyhow::{Context, Result};
 use tokio::process::Command;
 use tokio::time::{Duration, timeout};
-use tracing::{debug, info};
+use tracing::{debug, info, error};
 
 pub async fn run(cfg: DatabaseConfig) -> Result<bool> {
     let mut cmd = Command::new("valkey-cli");
@@ -21,33 +21,34 @@ pub async fn run(cfg: DatabaseConfig) -> Result<bool> {
 
     cmd.arg("PING");
 
-    debug!("Command Ping: {:?}", cmd);
+    debug!("Command Ping Valkey: {:?}", cmd);
 
     let result = timeout(Duration::from_secs(10), cmd.output()).await;
 
     match result {
         Ok(output) => {
-            let output = output.context("Failed to execute redis-cli")?;
+            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);
 
-            info!("Redis stdout: {}", stdout);
-            info!("Redis stderr: {}", stderr);
+            if !stdout.is_empty() {
+                error!("Valkey stderr: {}", stderr);
+            }
 
             if stderr.contains("NOAUTH") {
-                info!("Redis authentication failed (NOAUTH required)");
+                error!("Valkey authentication failed (NOAUTH required)");
                 return Ok(false);
             }
 
             if !output.status.success() {
-                info!("Redis command failed with status: {:?}", output.status);
+                error!("Valkey command failed with status: {:?}", output.status);
                 return Ok(false);
             }
 
             Ok(stdout.contains("PONG"))
         }
         Err(_) => {
-            info!("Timeout connecting to Redis at {}:{}", cfg.host, cfg.port);
+            info!("Timeout connecting to Valkey at {}:{}", cfg.host, cfg.port);
             Ok(false)
         }
     }

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

@@ -11,6 +11,8 @@ pub struct DatabasePayload<'a> {
     pub dbms: &'a str,
     #[serde(rename = "generatedId")]
     pub generated_id: &'a str,
+    #[serde(rename = "pingStatus")]
+    pub ping_status: bool
 }
 
 #[derive(Serialize)]

src/services/status.rs

@@ -8,6 +8,8 @@ use crate::settings::CONFIG;
 use reqwest::Client;
 use std::error::Error;
 use std::sync::Arc;
+use futures_util::future::try_join_all;
+use crate::domain::factory::DatabaseFactory;
 
 pub struct StatusService {
     ctx: Arc<Context>,
@@ -25,14 +27,20 @@ impl StatusService {
     pub async fn ping(&self, databases: &[DatabaseConfig]) -> Result<PingResult, Box<dyn Error>> {
         let edge_key = &self.ctx.edge_key;
 
-        let databases_payload: Vec<DatabasePayload> = databases
-            .iter()
-            .map(|db| DatabasePayload {
-                name: &db.name,
-                dbms: &db.db_type.as_str(),
-                generated_id: &db.generated_id,
+        let databases_payload: Vec<DatabasePayload> = try_join_all(
+            databases.into_iter().map(|db| async move {
+                let db_engine = DatabaseFactory::create_for_backup(db.clone()).await;
+
+                let reachable = db_engine.ping().await?;
+
+                Ok::<DatabasePayload, anyhow::Error>(DatabasePayload {
+                    name: &db.name,
+                    dbms: &db.db_type.as_str(),
+                    generated_id: &db.generated_id,
+                    ping_status: reachable,
+                })
             })
-            .collect();
+        ).await?;
 
         let version_str = CONFIG.app_version.as_str();
         let result = self

src/settings.rs

@@ -25,6 +25,16 @@ impl Settings {
             .parse::<usize>()
             .expect("POOLING must be a valid positive integer");
 
+        if pooling_seconds < 1 || pooling_seconds > 600 {
+            panic!("POOLING must be between 1 second and 600 seconds (10 minutes)");
+        }
+
+        if pooling_seconds < 5 {
+            eprintln!(
+                "[WARNING] POOLING is set to {}s. Values under 5s are not recommended for production.",
+                pooling_seconds
+            );
+        }
         let tz = env::var("TZ").unwrap_or_else(|_| "UTC".to_string());
 
         Self {