1 files changed, 68 insertions, 9 deletions

diff --git a/cmd/moncheck/main.go b/cmd/moncheck/main.go
index 73eee1a..12695d4 100644
--- a/cmd/moncheck/main.go
+++ b/cmd/moncheck/main.go
@@ -7,8 +7,10 @@ import (
 	"encoding/json"
 	"flag"
 	"fmt"
+	"io"
 	"io/ioutil"
 	"log"
+	"log/slog"
 	"os"
 	"strconv"
 	"strings"
@@ -30,6 +32,12 @@ type (
 		Path      []string `json:"path"`
 		Workers   int      `json:"workers"`
 		CheckerID int      `json:"checker_id"`
+
+		Log struct {
+			Format string `json:"format"`
+			Level  string `json:"level"`
+			Output string `json:"output"`
+		} `json:"log"`
 	}
 
 	States []int
@@ -47,27 +55,34 @@ func main() {
 		log.Fatalf("could not parse config: %s", err)
 	}
 
+	logger := parseLogger(config)
+
 	if err := os.Setenv("PATH", strings.Join(config.Path, ":")); err != nil {
-		log.Fatalf("could not set PATH: %s", err)
+		logger.Error("could not set PATH", "error", err, "configured path", config.Path)
+		os.Exit(1)
 	}
 
 	waitDuration, err := time.ParseDuration(config.Wait)
 	if err != nil {
-		log.Fatalf("could not parse wait duration: %s", err)
+		logger.Error("could not parse wait duration", "error", err, "wait duration", config.Wait)
+		os.Exit(1)
 	}
 	timeout, err := time.ParseDuration(config.Timeout)
 	if err != nil {
-		log.Fatalf("could not parse timeout: %s", err)
+		logger.Error("could not parse timeout", "error", err, "timeout", config.Timeout)
+		os.Exit(1)
 	}
 
 	db, err := sql.Open("postgres", config.DB)
 	if err != nil {
-		log.Fatalf("could not open database connection: %s", err)
+		logger.Error("could not open database connection", "error", err)
+		os.Exit(1)
 	}
 
 	hostname, err := os.Hostname()
 	if err != nil {
-		log.Fatalf("could not resolve hostname: %s", err)
+		logger.Error("could not resolve hostname", "error", err)
+		os.Exit(1)
 	}
 
 	checker, err := monzero.NewChecker(monzero.CheckerConfig{
@@ -78,22 +93,23 @@ func main() {
 		Executor:       monzero.CheckExec,
 	})
 	if err != nil {
-		log.Fatalf("could not create checker instance: %s", err)
+		logger.Error("could not create checker instance", "error", err)
+		os.Exit(1)
 	}
 
 	for i := 0; i < config.Workers; i++ {
-		go check(checker, waitDuration)
+		go check(checker, waitDuration, logger)
 	}
 	wg := sync.WaitGroup{}
 	wg.Add(1)
 	wg.Wait()
 }
 
-func check(checker *monzero.Checker, waitDuration time.Duration) {
+func check(checker *monzero.Checker, waitDuration time.Duration, logger *slog.Logger) {
 	for {
 		if err := checker.Next(); err != nil {
 			if err != monzero.ErrNoCheck {
-				log.Printf("could not run check: %s", err)
+				logger.Info("check returned error", "error", err)
 			}
 			time.Sleep(waitDuration)
 		}
@@ -171,3 +187,46 @@ func (s *States) ToOK() bool {
 	}
 	return false
 }
+
+// parse the log settings and generate the slog output
+func parseLogger(config Config) *slog.Logger {
+	var output io.Writer
+	switch config.Log.Output {
+	case "", "stderr":
+		output = os.Stderr
+	case "stdout":
+		output = os.Stdout
+	default:
+		var err error
+		output, err = os.OpenFile(config.Log.Output, os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0640)
+		if err != nil {
+			log.Fatalf("could not open log file handler: %s", err)
+		}
+	}
+
+	var level slog.Level
+	switch config.Log.Level {
+	case "debug":
+		level = slog.LevelDebug
+	case "", "info":
+		level = slog.LevelInfo
+	case "warn":
+		level = slog.LevelWarn
+	case "error":
+		level = slog.LevelError
+	default:
+		log.Fatalf("unknown log level '%s', only 'debug', 'info', 'warn' and 'error' are supported", config.Log.Level)
+	}
+
+	var handler slog.Handler
+	switch config.Log.Format {
+	case "", "text":
+		handler = slog.NewTextHandler(output, &slog.HandlerOptions{Level: level})
+	case "json":
+		handler = slog.NewJSONHandler(output, &slog.HandlerOptions{Level: level})
+	default:
+		log.Fatalf("unknown log format '%s', only 'text' and 'json' are supported", config.Log.Format)
+	}
+
+	return slog.New(handler)
+}