284 lines
7.8 KiB
Go
284 lines
7.8 KiB
Go
package main
|
||
|
||
import (
|
||
"log"
|
||
"net/http"
|
||
"os"
|
||
"os/signal"
|
||
"path/filepath"
|
||
"sync"
|
||
"syscall"
|
||
"time"
|
||
|
||
"github.com/mahmoud/db-monitor/alert"
|
||
"github.com/mahmoud/db-monitor/api"
|
||
"github.com/mahmoud/db-monitor/collector"
|
||
"github.com/mahmoud/db-monitor/config"
|
||
"github.com/mahmoud/db-monitor/storage"
|
||
)
|
||
|
||
// collectorManager manages dynamic add/remove of collectors
|
||
type collectorManager struct {
|
||
mu sync.RWMutex
|
||
collectors map[string]*collector.PostgresCollector // name -> collector
|
||
}
|
||
|
||
func newCollectorManager() *collectorManager {
|
||
return &collectorManager{
|
||
collectors: make(map[string]*collector.PostgresCollector),
|
||
}
|
||
}
|
||
|
||
func (cm *collectorManager) add(name string, c *collector.PostgresCollector) {
|
||
cm.mu.Lock()
|
||
defer cm.mu.Unlock()
|
||
cm.collectors[name] = c
|
||
}
|
||
|
||
func (cm *collectorManager) remove(name string) {
|
||
cm.mu.Lock()
|
||
defer cm.mu.Unlock()
|
||
if c, ok := cm.collectors[name]; ok {
|
||
c.Close()
|
||
delete(cm.collectors, name)
|
||
}
|
||
}
|
||
|
||
func (cm *collectorManager) list() []*collector.PostgresCollector {
|
||
cm.mu.RLock()
|
||
defer cm.mu.RUnlock()
|
||
var list []*collector.PostgresCollector
|
||
for _, c := range cm.collectors {
|
||
list = append(list, c)
|
||
}
|
||
return list
|
||
}
|
||
|
||
func (cm *collectorManager) closeAll() {
|
||
cm.mu.Lock()
|
||
defer cm.mu.Unlock()
|
||
for _, c := range cm.collectors {
|
||
c.Close()
|
||
}
|
||
}
|
||
|
||
func main() {
|
||
log.SetFlags(log.LstdFlags | log.Lshortfile)
|
||
log.Println("🔍 DB Monitor starting...")
|
||
|
||
// Load configuration
|
||
cfg := config.Load()
|
||
|
||
// Ensure data directory exists
|
||
dataDir := filepath.Dir(cfg.SQLitePath)
|
||
if err := os.MkdirAll(dataDir, 0755); err != nil {
|
||
log.Fatalf("❌ Failed to create data directory: %v", err)
|
||
}
|
||
|
||
// Initialize storage
|
||
store, err := storage.NewStore(cfg.SQLitePath)
|
||
if err != nil {
|
||
log.Fatalf("❌ Failed to initialize storage: %v", err)
|
||
}
|
||
defer store.Close()
|
||
log.Println("✅ SQLite storage initialized")
|
||
|
||
// Initialize collector manager
|
||
cm := newCollectorManager()
|
||
defer cm.closeAll()
|
||
|
||
// Load databases: first from SQLite, then fallback to env
|
||
trackedDBs, _ := store.ListTrackedDatabases()
|
||
if len(trackedDBs) > 0 {
|
||
log.Printf("📊 Loading %d database(s) from settings", len(trackedDBs))
|
||
for _, db := range trackedDBs {
|
||
c, err := collector.NewPostgresCollector(db.DSN)
|
||
if err != nil {
|
||
log.Printf("⚠️ Failed to create collector for %s: %v", db.Name, err)
|
||
continue
|
||
}
|
||
cm.add(c.DBName, c)
|
||
log.Printf("✅ Collector ready for database: %s", c.DBName)
|
||
}
|
||
} else if len(cfg.DatabaseDSNs) > 0 {
|
||
// Fallback: load from env and save to SQLite for future
|
||
log.Printf("📊 Loading %d database(s) from environment, interval: %ds", len(cfg.DatabaseDSNs), cfg.Interval)
|
||
for _, dsn := range cfg.DatabaseDSNs {
|
||
c, err := collector.NewPostgresCollector(dsn)
|
||
if err != nil {
|
||
log.Printf("⚠️ Failed to create collector for DSN: %v", err)
|
||
continue
|
||
}
|
||
cm.add(c.DBName, c)
|
||
// Save to SQLite so it persists
|
||
store.AddTrackedDatabase(c.DBName, dsn)
|
||
log.Printf("✅ Collector ready for database: %s", c.DBName)
|
||
}
|
||
}
|
||
|
||
if len(cm.list()) == 0 {
|
||
log.Println("ℹ️ No databases configured. Add databases via the Settings page.")
|
||
}
|
||
|
||
// Initialize alert engine (now loads config from SQLite)
|
||
alertEngine := alert.NewEngine(store)
|
||
log.Println("🔔 Alert engine initialized (configure via Settings)")
|
||
|
||
// Migrate env-based Telegram config to SQLite if set
|
||
if cfg.TelegramBotToken != "" && cfg.TelegramChatID != "" {
|
||
existing, _ := store.GetNotificationChannel("telegram")
|
||
if existing == nil {
|
||
configJSON := []byte(`{"bot_token":"` + cfg.TelegramBotToken + `","chat_id":"` + cfg.TelegramChatID + `"}`)
|
||
store.SaveNotificationChannel("telegram", configJSON, true)
|
||
log.Println("📲 Migrated Telegram config from env to settings")
|
||
}
|
||
}
|
||
|
||
// Initialize API handlers
|
||
handler := api.NewHandler(store)
|
||
settingsHandler := api.NewSettingsHandler(store)
|
||
|
||
// Set callbacks for dynamic collector management
|
||
settingsHandler.SetDBCallbacks(
|
||
// onDBAdded
|
||
func(id int64, name, dsn string) error {
|
||
c, err := collector.NewPostgresCollector(dsn)
|
||
if err != nil {
|
||
return err
|
||
}
|
||
cm.add(c.DBName, c)
|
||
log.Printf("✅ Added collector for: %s", c.DBName)
|
||
return nil
|
||
},
|
||
// onDBRemoved
|
||
func(id int64, name string) error {
|
||
cm.remove(name)
|
||
handler.RemoveLatest(name)
|
||
log.Printf("🗑️ Removed collector for: %s", name)
|
||
return nil
|
||
},
|
||
)
|
||
|
||
// Start collection loop
|
||
go func() {
|
||
ticker := time.NewTicker(time.Duration(cfg.Interval) * time.Second)
|
||
defer ticker.Stop()
|
||
|
||
// Collect immediately on start
|
||
collectAll(cm, store, handler, alertEngine)
|
||
|
||
for range ticker.C {
|
||
collectAll(cm, store, handler, alertEngine)
|
||
}
|
||
}()
|
||
|
||
// Cleanup old data every hour
|
||
go func() {
|
||
ticker := time.NewTicker(1 * time.Hour)
|
||
defer ticker.Stop()
|
||
for range ticker.C {
|
||
if err := store.Cleanup(7 * 24 * time.Hour); err != nil {
|
||
log.Printf("⚠️ Cleanup error: %v", err)
|
||
}
|
||
}
|
||
}()
|
||
|
||
// HTTP server
|
||
mux := http.NewServeMux()
|
||
|
||
// API routes
|
||
handler.RegisterRoutes(mux)
|
||
settingsHandler.RegisterRoutes(mux)
|
||
|
||
// Static files (web dashboard)
|
||
webDir := "./web"
|
||
if _, err := os.Stat(webDir); os.IsNotExist(err) {
|
||
webDir = "/app/web"
|
||
}
|
||
mux.Handle("/", http.FileServer(http.Dir(webDir)))
|
||
|
||
server := &http.Server{
|
||
Addr: ":" + cfg.Port,
|
||
Handler: mux,
|
||
ReadTimeout: 15 * time.Second,
|
||
WriteTimeout: 15 * time.Second,
|
||
IdleTimeout: 60 * time.Second,
|
||
}
|
||
|
||
// Graceful shutdown
|
||
go func() {
|
||
sigChan := make(chan os.Signal, 1)
|
||
signal.Notify(sigChan, syscall.SIGINT, syscall.SIGTERM)
|
||
<-sigChan
|
||
log.Println("🛑 Shutting down...")
|
||
server.Close()
|
||
}()
|
||
|
||
log.Printf("🚀 DB Monitor running on http://0.0.0.0:%s", cfg.Port)
|
||
if err := server.ListenAndServe(); err != http.ErrServerClosed {
|
||
log.Fatalf("❌ Server error: %v", err)
|
||
}
|
||
log.Println("👋 DB Monitor stopped")
|
||
}
|
||
|
||
func collectAll(
|
||
cm *collectorManager,
|
||
store *storage.Store,
|
||
handler *api.Handler,
|
||
alertEngine *alert.Engine,
|
||
) {
|
||
collectors := cm.list()
|
||
for _, c := range collectors {
|
||
m := c.Collect()
|
||
|
||
// Update in-memory latest
|
||
handler.UpdateLatest(m.DatabaseName, m)
|
||
|
||
// Save snapshot
|
||
if err := store.SaveSnapshot(m.DatabaseName, m.CollectedAt, m); err != nil {
|
||
log.Printf("⚠️ Failed to save snapshot for %s: %v", m.DatabaseName, err)
|
||
}
|
||
|
||
// Save individual metrics for time-series
|
||
metrics := map[string]float64{
|
||
"latency_ms": m.LatencyMs,
|
||
"active_connections": float64(m.ActiveConns),
|
||
"idle_connections": float64(m.IdleConns),
|
||
"total_connections": float64(m.TotalConns),
|
||
"connection_usage_pct": m.ConnUsagePct,
|
||
"active_queries": float64(m.ActiveQueries),
|
||
"long_running_queries": float64(m.LongRunning),
|
||
"database_size_bytes": float64(m.DatabaseSizeBytes),
|
||
"tx_commit": float64(m.TxCommit),
|
||
"tx_rollback": float64(m.TxRollback),
|
||
"cache_hit_ratio": m.CacheHitRatio,
|
||
"active_locks": float64(m.ActiveLocks),
|
||
"waiting_locks": float64(m.WaitingLocks),
|
||
"deadlocks": float64(m.Deadlocks),
|
||
"replication_lag_ms": m.ReplicationLagMs,
|
||
"tup_inserted": float64(m.TupInserted),
|
||
"tup_updated": float64(m.TupUpdated),
|
||
"tup_deleted": float64(m.TupDeleted),
|
||
"tup_fetched": float64(m.TupFetched),
|
||
"blks_read": float64(m.BlksRead),
|
||
"blks_hit": float64(m.BlksHit),
|
||
"temp_files": float64(m.TempFiles),
|
||
"temp_bytes": float64(m.TempBytes),
|
||
}
|
||
if err := store.SaveMetricsBatch(m.DatabaseName, m.CollectedAt, metrics); err != nil {
|
||
log.Printf("⚠️ Failed to save metrics for %s: %v", m.DatabaseName, err)
|
||
}
|
||
|
||
// Evaluate alerts
|
||
alertEngine.Evaluate(m)
|
||
|
||
status := "🟢"
|
||
if m.Status != "UP" {
|
||
status = "🔴"
|
||
}
|
||
log.Printf("%s %s | latency: %.1fms | conns: %d/%d | queries: %d | size: %s | cache: %.1f%%",
|
||
status, m.DatabaseName, m.LatencyMs, m.TotalConns, m.MaxConns,
|
||
m.ActiveQueries, m.DatabaseSizeHuman, m.CacheHitRatio)
|
||
}
|
||
}
|