update

cmd/atscanner.go

···
 import (
 	"context"
 	"flag"
+	"fmt"
 	"os"
 	"os/signal"
 	"syscall"
···
 	"github.com/atscan/atscanner/internal/worker"
 )
 
+const VERSION = "1.0.0"
+
 func main() {
 	configPath := flag.String("config", "config.yaml", "path to config file")
 	verbose := flag.Bool("verbose", false, "enable verbose logging")
···
 	// Load configuration
 	cfg, err := config.Load(*configPath)
 	if err != nil {
-		log.Fatal("Failed to load config: %v", err)
+		fmt.Fprintf(os.Stderr, "Failed to load config: %v\n", err)
+		os.Exit(1)
 	}
 
 	// Override verbose setting if flag is provided
···
 	// Initialize logger
 	log.Init(cfg.API.Verbose)
 
+	// Print banner
+	log.Banner(VERSION)
+
+	// Print configuration summary
+	log.PrintConfig(map[string]string{
+		"Database Type":     cfg.Database.Type,
+		"Database Path":     cfg.Database.Path, // Will be auto-redacted
+		"PLC Directory":     cfg.PLC.DirectoryURL,
+		"PLC Scan Interval": cfg.PLC.ScanInterval.String(),
+		"PLC Bundle Dir":    cfg.PLC.BundleDir,
+		"PLC Cache":         fmt.Sprintf("%v", cfg.PLC.UseCache),
+		"PLC Index DIDs":    fmt.Sprintf("%v", cfg.PLC.IndexDIDs),
+		"PDS Scan Interval": cfg.PDS.ScanInterval.String(),
+		"PDS Workers":       fmt.Sprintf("%d", cfg.PDS.Workers),
+		"PDS Timeout":       cfg.PDS.Timeout.String(),
+		"API Host":          cfg.API.Host,
+		"API Port":          fmt.Sprintf("%d", cfg.API.Port),
+		"Verbose Logging":   fmt.Sprintf("%v", cfg.API.Verbose),
+	})
+
 	// Initialize database using factory pattern
 	db, err := storage.NewDatabase(cfg.Database.Type, cfg.Database.Path)
 	if err != nil {
 		log.Fatal("Failed to initialize database: %v", err)
 	}
-	defer db.Close()
+	defer func() {
+		log.Info("Closing database connection...")
+		db.Close()
+	}()
 
 	// Set scan retention from config
-	db.SetScanRetention(cfg.PDS.ScanRetention)
+	if cfg.PDS.ScanRetention > 0 {
+		db.SetScanRetention(cfg.PDS.ScanRetention)
+		log.Verbose("Scan retention set to %d scans per endpoint", cfg.PDS.ScanRetention)
+	}
 
 	// Run migrations
 	if err := db.Migrate(); err != nil {
···
 	defer cancel()
 
 	// Initialize workers
+	log.Info("Initializing scanners...")
+
 	plcScanner := plc.NewScanner(db, cfg.PLC)
 	defer plcScanner.Close()
+	log.Verbose("✓ PLC scanner initialized")
 
 	pdsScanner := pds.NewScanner(db, cfg.PDS)
+	log.Verbose("✓ PDS scanner initialized")
 
 	scheduler := worker.NewScheduler()
 
···
 			log.Error("PLC scan error: %v", err)
 		}
 	})
+	log.Verbose("✓ PLC scan job scheduled (interval: %s)", cfg.PLC.ScanInterval)
 
 	// Schedule PDS availability checks
 	scheduler.AddJob("pds_scan", cfg.PDS.ScanInterval, func() {
···
 			log.Error("PDS scan error: %v", err)
 		}
 	})
+	log.Verbose("✓ PDS scan job scheduled (interval: %s)", cfg.PDS.ScanInterval)
 
 	// Start API server
+	log.Info("Starting API server on %s:%d...", cfg.API.Host, cfg.API.Port)
 	apiServer := api.NewServer(db, cfg.API, cfg.PLC)
 	go func() {
 		if err := apiServer.Start(); err != nil {
···
 		}
 	}()
 
+	// Give the API server a moment to start
+	time.Sleep(100 * time.Millisecond)
+	log.Info("✓ API server started successfully")
+	log.Info("")
+	log.Info("🚀 ATScanner is running!")
+	log.Info("   API available at: http://%s:%d", cfg.API.Host, cfg.API.Port)
+	log.Info("   Press Ctrl+C to stop")
+	log.Info("")
+
 	// Start scheduler
 	scheduler.Start(ctx)
 
···
 	signal.Notify(sigChan, os.Interrupt, syscall.SIGTERM)
 	<-sigChan
 
+	log.Info("")
 	log.Info("Shutting down gracefully...")
 	cancel()
+
+	log.Info("Stopping API server...")
 	apiServer.Shutdown(context.Background())
+
+	log.Info("Waiting for active tasks to complete...")
 	time.Sleep(2 * time.Second)
+
+	log.Info("✓ Shutdown complete. Goodbye!")
 }

internal/log/log.go

···
 package log
 
 import (
+	"fmt"
 	"io"
 	"log"
 	"os"
+	"strings"
 )
 
 var (
···
 func Fatal(format string, v ...interface{}) {
 	errorLog.Fatalf(format, v...)
 }
+
+// Banner prints a startup banner
+func Banner(version string) {
+	banner := `
+╔════════════════════════════════════════════════════════════╗
+║                                                            ║
+║     █████╗ ████████╗███████╗ ██████╗ █████╗ ███╗   ██╗     ║
+║    ██╔══██╗╚══██╔══╝██╔════╝██╔════╝██╔══██╗████╗  ██║     ║
+║    ███████║   ██║   ███████╗██║     ███████║██╔██╗ ██║     ║
+║    ██╔══██║   ██║   ╚════██║██║     ██╔══██║██║╚██╗██║     ║
+║    ██║  ██║   ██║   ███████║╚██████╗██║  ██║██║ ╚████║     ║
+║    ╚═╝  ╚═╝   ╚═╝   ╚══════╝ ╚═════╝╚═╝  ╚═╝╚═╝  ╚═══╝     ║
+║                                                            ║
+║            AT Protocol Network Scanner & Indexer           ║
+║                      Version %s                       ║
+║                                                            ║
+╚════════════════════════════════════════════════════════════╝
+`
+	fmt.Printf(banner, padVersion(version))
+}
+
+// padVersion pads the version string to fit the banner
+func padVersion(version string) string {
+	targetLen := 7
+	if len(version) < targetLen {
+		padding := strings.Repeat(" ", (targetLen-len(version))/2)
+		return padding + version + padding
+	}
+	return version
+}
+
+// RedactPassword redacts passwords from connection strings
+func RedactPassword(connStr string) string {
+	// Handle PostgreSQL URI format: postgresql://user:password@host/db
+	// Pattern: find everything between :// and @ that contains a colon
+	if strings.Contains(connStr, "://") && strings.Contains(connStr, "@") {
+		// Find the credentials section
+		parts := strings.SplitN(connStr, "://", 2)
+		if len(parts) == 2 {
+			scheme := parts[0]
+			remainder := parts[1]
+
+			// Find the @ symbol
+			atIndex := strings.Index(remainder, "@")
+			if atIndex > 0 {
+				credentials := remainder[:atIndex]
+				hostAndDb := remainder[atIndex:]
+
+				// Check if there's a password (look for colon in credentials)
+				colonIndex := strings.Index(credentials, ":")
+				if colonIndex > 0 {
+					username := credentials[:colonIndex]
+					return fmt.Sprintf("%s://%s:***%s", scheme, username, hostAndDb)
+				}
+			}
+		}
+	}
+
+	// Handle key-value format: host=localhost password=secret user=myuser
+	if strings.Contains(connStr, "password=") {
+		parts := strings.Split(connStr, " ")
+		for i, part := range parts {
+			if strings.HasPrefix(part, "password=") {
+				parts[i] = "password=***"
+			}
+		}
+		return strings.Join(parts, " ")
+	}
+
+	return connStr
+}
+
+// PrintConfig prints configuration summary
+func PrintConfig(items map[string]string) {
+	Info("=== Configuration ===")
+	maxKeyLen := 0
+	for key := range items {
+		if len(key) > maxKeyLen {
+			maxKeyLen = len(key)
+		}
+	}
+
+	for key, value := range items {
+		padding := strings.Repeat(" ", maxKeyLen-len(key))
+
+		// Redact database connection strings
+		displayValue := value
+		if strings.Contains(key, "Database Path") || strings.Contains(key, "Connection") || strings.Contains(strings.ToLower(key), "password") {
+			displayValue = RedactPassword(value)
+		}
+
+		fmt.Printf("  %s:%s %s\n", key, padding, displayValue)
+	}
+	Info("====================")
+}

internal/storage/postgres.go

···
 	"strings"
 	"time"
 
+	"github.com/atscan/atscanner/internal/log"
 	"github.com/jackc/pgx/v5"
 	"github.com/jackc/pgx/v5/pgxpool"
 	_ "github.com/jackc/pgx/v5/stdlib"
···
 }
 
 func NewPostgresDB(connString string) (*PostgresDB, error) {
+	log.Info("Connecting to PostgreSQL database...")
+
 	// Open standard sql.DB (for compatibility)
 	db, err := sql.Open("pgx", connString)
 	if err != nil {
-		return nil, err
+		return nil, fmt.Errorf("failed to open database: %w", err)
 	}
 
 	// Connection pool settings
···
 	db.SetMaxIdleConns(25)
 	db.SetConnMaxLifetime(5 * time.Minute)
 	db.SetConnMaxIdleTime(2 * time.Minute)
+
+	log.Verbose("  Max open connections: 50")
+	log.Verbose("  Max idle connections: 25")
+	log.Verbose("  Connection max lifetime: 5m")
 
 	// Test connection
+	log.Info("Testing database connection...")
 	if err := db.Ping(); err != nil {
 		return nil, fmt.Errorf("failed to ping database: %w", err)
 	}
+	log.Info("✓ Database connection successful")
 
 	// Also create pgx pool for COPY operations
+	log.Verbose("Creating pgx connection pool...")
 	pool, err := pgxpool.New(context.Background(), connString)
 	if err != nil {
 		return nil, fmt.Errorf("failed to create pgx pool: %w", err)
 	}
+	log.Verbose("✓ Connection pool created")
 
 	return &PostgresDB{
 		db:            db,
 		pool:          pool,
-		scanRetention: 3,
+		scanRetention: 3, // Default
 	}, nil
 }
 
···
 }
 
 func (p *PostgresDB) Migrate() error {
+	log.Info("Running database migrations...")
+
 	schema := `
     -- Endpoints table (NO user_count, NO ip_info)
     CREATE TABLE IF NOT EXISTS endpoints (
···
     `
 
 	_, err := p.db.Exec(schema)
-	return err
+	if err != nil {
+		return err
+	}
+
+	log.Info("✓ Database migrations completed successfully")
+	return nil
 }
 
 // ===== ENDPOINT OPERATIONS =====