Files
2026-10-30 16:35:46 +02:00

284 lines
7.8 KiB
Go
Raw Permalink Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
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)
}
}