migrate logging to slog

Author: RedCommand

flatpak.go

@@ -1,20 +1,21 @@
 package main
 
 import (
+	"context"
+	"os"
 	"os/exec"
 	"slices"
 	"strings"
 	"sync"
 
-	"github.com/rs/zerolog/log"
 	"gopkg.in/ini.v1"
 )
 
-func getApps() ([]string, error) {
+func getApps(ctx context.Context) ([]string, error) {
 	cmd := exec.Command("flatpak", "list", "--app")
 	cmd.Dir = "/var/lib/flatpak"
 
-	log.Debug().Str("command", cmd.Path+strings.Join(cmd.Args, " ")).Msg("Running command")
+	log.DebugContext(ctx, "Running command", "command", cmd.Path+" "+strings.Join(cmd.Args, " "))
 	out, err := cmd.Output()
 	if err != nil {
 		return nil, err
@@ -29,29 +30,29 @@ func getApps() ([]string, error) {
 		}
 		data := strings.Split(app, "\t")
 		if len(data) < 2 {
-			log.Warn().Msgf("Skipping line: %s", app)
+			log.WarnContext(ctx, "Skipping line", "line", app)
 			continue
 		}
 		appID := strings.TrimSpace(data[1])
 		if appID == "" {
 			continue
 		}
-		log.Trace().Msgf("AppID: %s", appID)
+		log.DebugContext(ctx, "AppID found", "appid", appID)
 		apps = append(apps, appID)
 	}
 	return apps, nil
 }
 
-func getFlatpakApp(appID string) (Flatpak, error) {
+func getFlatpakApp(ctx context.Context, appID string) (Flatpak, error) {
 	cmd := exec.Command("flatpak", "info", "-m", appID)
 
-	log.Debug().Str("command", cmd.Path+strings.Join(cmd.Args, " ")).Str("appID", appID).Msg("Running command")
+	log.DebugContext(ctx, "Running command", "command", cmd.Path+" "+strings.Join(cmd.Args, " "), "appid", appID)
 	out, err := cmd.Output()
 	if err != nil {
 		return Flatpak{}, err
 	}
 
-	log.Trace().Str("data", string(out)).Msg("Parsing toml")
+	log.DebugContext(ctx, "Parsing toml", "data", string(out))
 	var flatpak Flatpak
 	cfg, err := ini.Load(out)
 	if err != nil {
@@ -62,15 +63,15 @@ func getFlatpakApp(appID string) (Flatpak, error) {
 		return Flatpak{}, err
 	}
 
-	flatpak.Application.Command, err = getCommand(&flatpak)
+	flatpak.Application.Command, err = getCommand(ctx, &flatpak)
 	if err != nil {
 		return Flatpak{}, err
 	}
 
 	return flatpak, nil
 }
 
-func removeDuplicates(apps []Flatpak) []Flatpak {
+func removeDuplicates(ctx context.Context, apps []Flatpak) []Flatpak {
 	keys := make(map[string]*Flatpak)
 	list := []Flatpak{}
 	duplicates := make(map[string][]Flatpak)
@@ -89,35 +90,36 @@ func removeDuplicates(apps []Flatpak) []Flatpak {
 	return slices.DeleteFunc(list, func(app Flatpak) bool {
 		apps, ok := duplicates[app.Application.Command]
 		if ok {
-			log.Warn().Str("command", app.Application.Command).Interface("apps", apps).Msg("Found duplicates")
+			log.WarnContext(ctx, "Found duplicates", "command", app.Application.Command, "apps", apps)
 		}
 		return ok
 	})
 }
 
-func getAllFlatpakApps() []Flatpak {
-	appsID, err := getApps()
+func getAllFlatpakApps(ctx context.Context) []Flatpak {
+	appsID, err := getApps(ctx)
 	if err != nil {
-		log.Fatal().Err(err).Msg("Error getting apps")
+		log.ErrorContext(ctx, "Error getting apps", "err", err)
+		os.Exit(1)
 	}
 
 	apps := make([]Flatpak, len(appsID))
 	wg := sync.WaitGroup{}
 	for i, appID := range appsID {
 		wg.Add(1)
-		go func(appID string) {
+		go func(i int, appID string) {
 			defer wg.Done()
-			app, err := getFlatpakApp(appID)
+			app, err := getFlatpakApp(ctx, appID)
 			if err != nil {
-				log.Error().Err(err).Str("appID", appID).Msg("Error getting app")
+				log.ErrorContext(ctx, "Error getting app", "err", err, "appid", appID)
 			}
 			// No need to lock since we are writing to different indexes
 			apps[i] = app
-		}(appID)
+		}(i, appID)
 	}
 	wg.Wait()
 
-	apps = removeDuplicates(apps)
+	apps = removeDuplicates(ctx, apps)
 
 	return apps
 }

go.mod

@@ -3,10 +3,9 @@ module github.com/RedCommand/flatpak-alias
 go 1.23.4
 
 require (
-	github.com/hbollon/go-edlib v1.6.0
-	github.com/rs/zerolog v1.33.0
-	gopkg.in/ini.v1 v1.67.0
-	gopkg.in/natefinch/lumberjack.v2 v2.2.1
+        github.com/hbollon/go-edlib v1.6.0
+        gopkg.in/ini.v1 v1.67.0
+        gopkg.in/natefinch/lumberjack.v2 v2.2.1
 )
 
 require (

go.sum

@@ -13,8 +13,6 @@ github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINE
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
 github.com/rs/xid v1.5.0/go.mod h1:trrq9SKmegXys3aeAKXMUTdJsYXVwGY3RLcfgqegfbg=
-github.com/rs/zerolog v1.33.0 h1:1cU2KZkvPxNyfgEmhHAz/1A9Bz+llsdYzklWFzgp0r8=
-github.com/rs/zerolog v1.33.0/go.mod h1:/7mN4D5sKwJLZQ2b/znpjC3/GQWY/xaDXUM0kKWRHss=
 github.com/stretchr/testify v1.10.0 h1:Xv5erBjTwe/5IxqUQTdXv5kgmIvbHo3QQyRwhJsOfJA=
 github.com/stretchr/testify v1.10.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
 golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=

logger.go

@@ -0,0 +1,44 @@
+package main
+
+import (
+	"context"
+	"log/slog"
+)
+
+type multiHandler struct {
+	handlers []slog.Handler
+}
+
+func (h multiHandler) Enabled(ctx context.Context, level slog.Level) bool {
+	for _, handler := range h.handlers {
+		if handler.Enabled(ctx, level) {
+			return true
+		}
+	}
+	return false
+}
+
+func (h multiHandler) Handle(ctx context.Context, r slog.Record) error {
+	for _, handler := range h.handlers {
+		if err := handler.Handle(ctx, r); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func (h multiHandler) WithAttrs(attrs []slog.Attr) slog.Handler {
+	hs := make([]slog.Handler, len(h.handlers))
+	for i, handler := range h.handlers {
+		hs[i] = handler.WithAttrs(attrs)
+	}
+	return multiHandler{handlers: hs}
+}
+
+func (h multiHandler) WithGroup(name string) slog.Handler {
+	hs := make([]slog.Handler, len(h.handlers))
+	for i, handler := range h.handlers {
+		hs[i] = handler.WithGroup(name)
+	}
+	return multiHandler{handlers: hs}
+}

main.go

@@ -1,15 +1,15 @@
 package main
 
 import (
+	"context"
 	_ "embed"
 	"os"
 	"path"
 	"text/template"
 	"time"
 
-	"github.com/rs/zerolog"
-	"github.com/rs/zerolog/log"
 	"gopkg.in/natefinch/lumberjack.v2"
+	"log/slog"
 )
 
 type Config struct {
@@ -27,6 +27,8 @@ type Flatpak struct {
 //go:embed script.gotmpl
 var scriptTemplateRaw string
 
+var log *slog.Logger
+
 func parseArgs() Config {
 	config := Config{}
 	if len(os.Args) > 1 {
@@ -37,7 +39,7 @@ func parseArgs() Config {
 	return config
 }
 
-func prepare(config *Config) (*template.Template, *lumberjack.Logger) {
+func prepare(ctx context.Context, config *Config) (*template.Template, *lumberjack.Logger) {
 	logFile := &lumberjack.Logger{
 		Filename:   path.Join(config.FlatpakDir, "flatpak-alias.log"), // Path to the log file
 		MaxSize:    1,                                                 // Maximum size in MB before rotation
@@ -46,36 +48,36 @@ func prepare(config *Config) (*template.Template, *lumberjack.Logger) {
 		Compress:   true,                                              // Compress rotated files
 	}
 
-	consoleWriter := zerolog.ConsoleWriter{Out: os.Stdout, TimeFormat: time.RFC3339}
-
-	multiWriter := zerolog.MultiLevelWriter(consoleWriter, logFile)
-
-	log.Logger = zerolog.New(multiWriter).With().Timestamp().Logger()
-
-	zerolog.SetGlobalLevel(zerolog.InfoLevel)
+	textHandler := slog.NewTextHandler(os.Stdout, &slog.HandlerOptions{Level: slog.LevelInfo})
+	jsonHandler := slog.NewJSONHandler(logFile, &slog.HandlerOptions{Level: slog.LevelInfo})
+	log = slog.New(multiHandler{handlers: []slog.Handler{textHandler, jsonHandler}})
+	slog.SetDefault(log)
 
 	scriptTemplate, err := template.New("script").Parse(scriptTemplateRaw)
 	if err != nil {
-		log.Fatal().Err(err).Msg("Error parsing template")
+		log.ErrorContext(ctx, "Error parsing template", "err", err)
+		os.Exit(1)
 	}
 
 	config.FlatpakDir = path.Join(config.FlatpakDir, "aliases")
-	log.Info().Str("path", config.FlatpakDir).Msg("Writing script")
+	log.InfoContext(ctx, "Writing script", "path", config.FlatpakDir)
 	err = os.MkdirAll(config.FlatpakDir, 0755)
 	if err != nil {
-		log.Fatal().Err(err).Msg("Error creating directory")
+		log.ErrorContext(ctx, "Error creating directory", "err", err)
+		os.Exit(1)
 	}
 
 	return scriptTemplate, logFile
 }
 
 func main() {
+	ctx := context.Background()
 	config := parseArgs()
-	scriptTemplate, logFile := prepare(&config)
+	scriptTemplate, logFile := prepare(ctx, &config)
 	defer logFile.Close()
-	log.Info().Msg("Starting flatpak-alias")
-	log.Info().Str("path", config.FlatpakDir).Any("args", os.Args).Msg("Writing script")
-	apps := getAllFlatpakApps()
-	removeOldScripts(config)
-	generateScripts(apps, scriptTemplate, config)
+	log.InfoContext(ctx, "Starting flatpak-alias")
+	log.InfoContext(ctx, "Writing script", "path", config.FlatpakDir, "args", os.Args)
+	apps := getAllFlatpakApps(ctx)
+	removeOldScripts(ctx, config)
+	generateScripts(ctx, apps, scriptTemplate, config)
 }

scripts.go

@@ -1,59 +1,59 @@
 package main
 
 import (
+	"context"
 	"os"
 	"path"
 	"text/template"
 	"time"
-
-	"github.com/rs/zerolog/log"
 )
 
-func removeOldScripts(config Config) {
+func removeOldScripts(ctx context.Context, config Config) {
 	files, err := os.ReadDir(config.FlatpakDir)
 	if err != nil {
-		log.Fatal().Err(err).Msg("Error reading output directory")
+		log.ErrorContext(ctx, "Error reading output directory", "err", err)
+		os.Exit(1)
 	}
 
 	for _, file := range files {
 		f, err := os.Open(path.Join(config.FlatpakDir, file.Name()))
 		if err != nil {
-			log.Error().Err(err).Str("file", file.Name()).Msg("Error opening file")
+			log.ErrorContext(ctx, "Error opening file", "err", err, "file", file.Name())
 			continue
 		}
 		content := make([]byte, 30)
 		i, err := f.ReadAt(content, 14)
 		if err != nil || i != 30 || string(content) != "**Generated by flatpak-alias**" {
-			log.Warn().Str("file", file.Name()).Msg("Not a managed file")
+			log.WarnContext(ctx, "Not a managed file", "file", file.Name())
 			continue
 		}
 
 		err = os.Remove(path.Join(config.FlatpakDir, file.Name()))
 		if err != nil {
-			log.Error().Err(err).Str("file", file.Name()).Msg("Error deleting file")
+			log.ErrorContext(ctx, "Error deleting file", "err", err, "file", file.Name())
 		}
 	}
 }
 
-func generateScripts(apps []Flatpak, scriptTemplate *template.Template, config Config) {
+func generateScripts(ctx context.Context, apps []Flatpak, scriptTemplate *template.Template, config Config) {
 	now := time.Now()
 	for _, app := range apps {
-		log.Info().Str("name", app.Application.Name).Str("command", app.Application.Command).Msg("Found application")
+		log.InfoContext(ctx, "Found application", "name", app.Application.Name, "command", app.Application.Command)
 		app.Timestamp = now
 
 		if _, err := os.Stat(path.Join(config.FlatpakDir, app.Application.Command)); err == nil {
-			log.Warn().Str("command", app.Application.Command).Msg("File already exists")
+			log.WarnContext(ctx, "File already exists", "command", app.Application.Command)
 			continue
 		}
 
 		file, err := os.Create(path.Join(config.FlatpakDir, app.Application.Command))
 		if err != nil {
-			log.Error().Err(err).Str("command", app.Application.Command).Msg("Error creating file")
+			log.ErrorContext(ctx, "Error creating file", "err", err, "command", app.Application.Command)
 			continue
 		}
 		err = scriptTemplate.Execute(file, app)
 		if err != nil {
-			log.Error().Err(err).Str("command", app.Application.Command).Msg("Error writing template")
+			log.ErrorContext(ctx, "Error writing template", "err", err, "command", app.Application.Command)
 			continue
 		}
 

scrore.go

@@ -1,11 +1,11 @@
 package main
 
 import (
+	"context"
 	"errors"
 	"strings"
 
 	"github.com/hbollon/go-edlib"
-	"github.com/rs/zerolog/log"
 )
 
 const threshold = 0.75
@@ -18,7 +18,7 @@ const (
 	matchNope = "nope"
 )
 
-func toCommand(str string) string {
+func toCommand(ctx context.Context, str string) string {
 	res := make([]byte, 0, len(str))
 	needSpace := false
 	lastUpper := false
@@ -50,11 +50,11 @@ func toCommand(str string) string {
 			needSpace = true
 		}
 	}
-	log.Trace().Str("input", str).Str("output", string(res)).Msg("Converted")
+	log.DebugContext(ctx, "Converted", "input", str, "output", string(res))
 	return string(res)
 }
 
-func getCommand(app *Flatpak) (string, error) {
+func getCommand(ctx context.Context, app *Flatpak) (string, error) {
 	var res string
 	var match string
 	command := strings.TrimSpace(app.Application.Command)
@@ -78,6 +78,6 @@ func getCommand(app *Flatpak) (string, error) {
 	if res == "" {
 		return "", errors.New("empty command")
 	}
-	log.Debug().Str("appID", appID).Str("name", name).Str("command", command).Float32("rank", similarity).Str("result", res).Msgf("Match %s", match)
-	return toCommand(res), nil
+	log.DebugContext(ctx, "Match", "appid", appID, "name", name, "command", command, "rank", similarity, "result", res, "match", match)
+	return toCommand(ctx, res), nil
 }