From 26a4ca6ab56d23054f606bc378ba355cebce485a Mon Sep 17 00:00:00 2001
From: Gibheer <gibheer+git@zero-knowledge.org>
Date: Tue, 5 Sep 2023 15:07:38 +0200
Subject: migrate moncheck to slog

With this moncheck itself is also changed to use slog.
The early config parsing is still using log as we do not have any idea
what else to use.
But from then slog is used at all points.

With the additional config options a man page was also added to explain
the new config options.
---
 cmd/moncheck/main.go | 77 ++++++++++++++++++++++++++++++++++++++++++++++------
 1 file changed, 68 insertions(+), 9 deletions(-)

(limited to 'cmd')

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)
+}
-- 
cgit v1.2.3-70-g09d2