darpan 0.2.0

Linux developer service monitoring utility with auto-detection, real-time health checks, and interactive TUI for databases, APIs, Docker containers, and more
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149

use crate::health::HealthCheckerTrait;
use crate::models::{DatabaseType, HealthCheckType, HealthResult, Service, ServiceType};
use async_trait::async_trait;
use std::time::{Duration, Instant};
use tracing::trace;

pub struct DatabaseHealthChecker {
    timeout: Duration,
}

impl DatabaseHealthChecker {
    pub fn new(timeout: Duration) -> Self {
        Self { timeout }
    }

    #[cfg(feature = "db-health-checks")]
    async fn check_postgres(&self, host: &str, port: u16, database: Option<&str>) -> HealthResult {
        use tokio_postgres::NoTls;
        
        let db = database.unwrap_or("postgres");
        let config_str = format!("host={} port={} user=postgres dbname={} connect_timeout={}", 
            host, port, db, self.timeout.as_secs());
        
        let start = Instant::now();
        
        match tokio_postgres::connect(&config_str, NoTls).await {
            Ok((client, connection)) => {
                // Spawn connection in background
                tokio::spawn(async move {
                    if let Err(e) = connection.await {
                        trace!("PostgreSQL connection error: {}", e);
                    }
                });
                
                // Simple query to check health
                match client.simple_query("SELECT 1").await {
                    Ok(_) => {
                        let response_time = start.elapsed().as_millis() as u64;
                        trace!("PostgreSQL is healthy ({}ms)", response_time);
                        HealthResult::healthy(response_time)
                    }
                    Err(e) => {
                        HealthResult::unhealthy(
                            format!("PostgreSQL query failed: {}", e),
                            None,
                        )
                    }
                }
            }
            Err(e) => {
                HealthResult::unhealthy(
                    format!("Cannot connect to PostgreSQL: {}", e),
                    Some("Check if PostgreSQL is running and accepting connections".to_string()),
                )
            }
        }
    }

    #[cfg(feature = "db-health-checks")]
    async fn check_redis(&self, host: &str, port: u16) -> HealthResult {
        let url = format!("redis://{}:{}", host, port);
        let start = Instant::now();
        
        match redis::Client::open(url.as_str()) {
            Ok(client) => {
                match client.get_multiplexed_async_connection().await {
                    Ok(mut con) => {
                        // Use PING command - the proper way to check Redis health
                        match redis::cmd("PING").query_async(&mut con).await {
                            Ok(response) => {
                                let response: String = response;
                                if response == "PONG" {
                                    let response_time = start.elapsed().as_millis() as u64;
                                    trace!("Redis is healthy ({}ms)", response_time);
                                    HealthResult::healthy(response_time)
                                } else {
                                    HealthResult::unhealthy(
                                        format!("Redis PING returned unexpected response: {}", response),
                                        Some("Redis may be misconfigured".to_string()),
                                    )
                                }
                            }
                            Err(e) => {
                                HealthResult::unhealthy(
                                    format!("Redis PING failed: {}", e),
                                    Some("Check if Redis is running and accepting connections".to_string()),
                                )
                            }
                        }
                    }
                    Err(e) => {
                        HealthResult::unhealthy(
                            format!("Cannot connect to Redis: {}", e),
                            Some("Check if Redis is running and accepting connections".to_string()),
                        )
                    }
                }
            }
            Err(e) => {
                HealthResult::unhealthy(
                    format!("Invalid Redis URL: {}", e),
                    None,
                )
            }
        }
    }
}

#[async_trait]
impl HealthCheckerTrait for DatabaseHealthChecker {
    async fn check(&self, service: &Service) -> HealthResult {
        match &service.health_check.check_type {
            #[cfg(feature = "db-health-checks")]
            HealthCheckType::Postgres { database } => {
                self.check_postgres(&service.host, service.port, database.as_deref()).await
            }
            #[cfg(feature = "db-health-checks")]
            HealthCheckType::Redis => {
                self.check_redis(&service.host, service.port).await
            }
            _ => {
                // For other database types, fall back to basic checks
                match &service.service_type {
                    #[cfg(feature = "db-health-checks")]
                    ServiceType::Database(DatabaseType::Postgres) => {
                        self.check_postgres(&service.host, service.port, None).await
                    }
                    #[cfg(feature = "db-health-checks")]
                    ServiceType::Cache(crate::models::CacheType::Redis) => {
                        self.check_redis(&service.host, service.port).await
                    }
                    _ => {
                        HealthResult::unhealthy(
                            "Database health check not implemented for this type".to_string(),
                            Some("Use port connectivity check instead".to_string()),
                        )
                    }
                }
            }
        }
    }

    fn supports(&self, service: &Service) -> bool {
        matches!(service.health_check.check_type, HealthCheckType::Postgres { .. })
            || matches!(service.health_check.check_type, HealthCheckType::Redis)
            || matches!(service.service_type, ServiceType::Database(_))
            || matches!(service.service_type, ServiceType::Cache(_))
    }
}