REORG/MEDIUM: migrate from standard log to log/slog

Replaced the standard log package with the structured logging package log/slog across the codebase. All existing log.Printf, log.Println, and log.Fatal calls have been updated to use appropriate slog levels (slog.Info, slog.Warn, slog.Error) with key-value pairs.

Author: oktalz

aspell/aspell.go

@@ -3,7 +3,7 @@ package aspell
 import (
 	"bytes"
 	"fmt"
-	"log"
+	"log/slog"
 	"os"
 	"os/exec"
 	"path/filepath"
@@ -224,7 +224,7 @@ func (a Aspell) collectIdentifiers(content []CommitDiff) []string {
 				readFiles[name] = struct{}{}
 				data, err := os.ReadFile(name)
 				if err != nil {
-					log.Printf("aspell: could not read file %s for identifiers, using diff: %v", name, err)
+					slog.Warn("could not read file for identifiers, using diff", "file", name, "err", err)
 					addWords(name, d.Files[name])
 					continue
 				}
@@ -258,7 +258,7 @@ func (a Aspell) collectIdentifiers(content []CommitDiff) []string {
 		identifierWords = append(identifierWords, w)
 	}
 	if len(identifierWords) > 0 {
-		log.Printf("collected %d identifiers (scope: %s) for spell check filtering", len(identifierWords), a.IdentifierScope)
+		slog.Info("collected identifiers for spell check filtering", "count", len(identifierWords), "scope", string(a.IdentifierScope))
 	}
 	return identifierWords
 }
@@ -267,7 +267,7 @@ func (a Aspell) checkSubjects(commits []Commit, junitSuite junit.Interface, resp
 	for _, c := range commits {
 		if err := a.checkSingle(c.Subject, []string{}); err != nil {
 			junitSuite.AddMessageFailed("commit message", "aspell check failed", err.Error())
-			log.Printf("commit %s subject %q %s", c.Hash, c.Subject, err.Error())
+			slog.Error("aspell check failed on subject", "commit", c.Hash, "subject", c.Subject, "err", err)
 			_, _ = fmt.Fprintf(response, "commit %s %q: %s\n", c.Hash, c.Subject, err)
 		}
 	}
@@ -297,9 +297,11 @@ func (a Aspell) checkFiles(content []CommitDiff, identifierWords []string, junit
 				location := name
 				if d.Hash != "" {
 					location = fmt.Sprintf("commit %s %q %s", d.Hash, d.Subject, name)
+					slog.Error("aspell check failed", "commit", d.Hash, "subject", d.Subject, "file", name, "err", err)
+				} else {
+					slog.Error("aspell check failed", "file", name, "err", err)
 				}
 				junitSuite.AddMessageFailed(location, "aspell check failed", err.Error())
-				log.Println(location, err.Error())
 				_, _ = fmt.Fprintf(response, "%s: %s\n", location, err)
 			}
 		}
@@ -312,13 +314,13 @@ func (a Aspell) checkCommitMessages(commits []Commit, identifierWords []string,
 		subject := parts[0]
 		if err := a.checkSingle(subject, []string{}); err != nil {
 			junitSuite.AddMessageFailed("commit message", "aspell check failed", err.Error())
-			log.Printf("commit %s subject %q %s", c.Hash, subject, err.Error())
+			slog.Error("aspell check failed on subject", "commit", c.Hash, "subject", subject, "err", err)
 			_, _ = fmt.Fprintf(response, "commit %s %q: %s\n", c.Hash, subject, err)
 		}
 		if len(parts) > 1 {
 			if err := a.checkSingle(parts[1], identifierWords); err != nil {
 				junitSuite.AddMessageFailed("commit message", "aspell check failed", err.Error())
-				log.Printf("commit %s body %q %s", c.Hash, subject, err.Error())
+				slog.Error("aspell check failed on body", "commit", c.Hash, "subject", subject, "err", err)
 				_, _ = fmt.Fprintf(response, "commit %s %q (body): %s\n", c.Hash, subject, err)
 			}
 		}
@@ -362,7 +364,7 @@ func checkWithAspellExec(subject string, extraDicts ...string) (string, error) {
 	cmd.Stderr = &stderr
 	err := cmd.Run()
 	if err != nil {
-		log.Printf("aspell error: %s, stderr: %s", err, stderr.String())
+		slog.Error("aspell execution failed", "err", err, "stderr", stderr.String())
 		return "", err
 	}
 

aspell/fetch_dictionaries.go

@@ -4,7 +4,7 @@ import (
 	"encoding/json"
 	"fmt"
 	"io"
-	"log"
+	"log/slog"
 	"net/http"
 	"os"
 	"path/filepath"
@@ -107,7 +107,7 @@ func fetchGitHubDirectory(gh GitHubDictionary) (fetchedDictionaries, error) {
 	owner, repo, ref, path := m[1], m[2], m[3], m[4]
 
 	apiURL := fmt.Sprintf("https://api.github.com/repos/%s/%s/contents/%s?ref=%s", owner, repo, path, ref)
-	log.Printf("aspell dictionaries: listing GitHub directory: %s", apiURL)
+	slog.Info("listing GitHub dictionary directory", "url", apiURL)
 
 	req, err := http.NewRequest("GET", apiURL, nil)
 	if err != nil {
@@ -119,7 +119,7 @@ func fetchGitHubDirectory(gh GitHubDictionary) (fetchedDictionaries, error) {
 		if token != "" {
 			req.Header.Set("Authorization", "Bearer "+token)
 		} else {
-			log.Printf("aspell dictionaries: warning: token env %s is empty", gh.TokenEnv)
+			slog.Warn("dictionary token env is empty", "env", gh.TokenEnv)
 		}
 	}
 
@@ -148,7 +148,7 @@ func fetchGitHubDirectory(gh GitHubDictionary) (fetchedDictionaries, error) {
 		if entry.DownloadURL == "" {
 			continue
 		}
-		log.Printf("aspell dictionaries: fetching %s", entry.DownloadURL)
+		slog.Info("fetching dictionary", "url", entry.DownloadURL)
 		fetched, err := fetchSingleFile(entry.DownloadURL, entry.Name, gh.TokenEnv)
 		if err != nil {
 			return result, fmt.Errorf("fetching %s: %w", entry.Name, err)
@@ -157,7 +157,7 @@ func fetchGitHubDirectory(gh GitHubDictionary) (fetchedDictionaries, error) {
 		result.rwsFiles = append(result.rwsFiles, fetched.rwsFiles...)
 	}
 
-	log.Printf("aspell dictionaries: loaded %d words and %d .rws files from %s", len(result.words), len(result.rwsFiles), gh.URL)
+	slog.Info("loaded dictionaries", "words", len(result.words), "rwsFiles", len(result.rwsFiles), "url", gh.URL)
 	return result, nil
 }
 
@@ -176,7 +176,7 @@ func fetchGitLabDirectory(gl GitLabDictionary) (fetchedDictionaries, error) {
 	encodedProject := strings.ReplaceAll(project, "/", "%2F")
 	apiURL := fmt.Sprintf("%s/api/v4/projects/%s/repository/tree?path=%s&ref=%s&per_page=100",
 		baseURL, encodedProject, path, ref)
-	log.Printf("aspell dictionaries: listing GitLab directory: %s", apiURL)
+	slog.Info("listing GitLab dictionary directory", "url", apiURL)
 
 	req, err := http.NewRequest("GET", apiURL, nil)
 	if err != nil {
@@ -210,7 +210,7 @@ func fetchGitLabDirectory(gl GitLabDictionary) (fetchedDictionaries, error) {
 		encodedPath := strings.ReplaceAll(entry.Path, "/", "%2F")
 		rawURL := fmt.Sprintf("%s/api/v4/projects/%s/repository/files/%s/raw?ref=%s",
 			baseURL, encodedProject, encodedPath, ref)
-		log.Printf("aspell dictionaries: fetching %s", rawURL)
+		slog.Info("fetching dictionary", "url", rawURL)
 		fetched, err := fetchSingleFile(rawURL, entry.Name, gl.TokenEnv)
 		if err != nil {
 			return result, fmt.Errorf("fetching %s: %w", entry.Name, err)
@@ -219,7 +219,7 @@ func fetchGitLabDirectory(gl GitLabDictionary) (fetchedDictionaries, error) {
 		result.rwsFiles = append(result.rwsFiles, fetched.rwsFiles...)
 	}
 
-	log.Printf("aspell dictionaries: loaded %d words and %d .rws files from %s", len(result.words), len(result.rwsFiles), gl.URL)
+	slog.Info("loaded dictionaries", "words", len(result.words), "rwsFiles", len(result.rwsFiles), "url", gl.URL)
 	return result, nil
 }
 
@@ -229,7 +229,7 @@ func setGitLabToken(req *http.Request, tokenEnv string) {
 	}
 	token := os.Getenv(tokenEnv)
 	if token == "" {
-		log.Printf("aspell dictionaries: warning: token env %s is empty", tokenEnv)
+		slog.Warn("dictionary token env is empty", "env", tokenEnv)
 		return
 	}
 	req.Header.Set("PRIVATE-TOKEN", token)
@@ -238,7 +238,7 @@ func setGitLabToken(req *http.Request, tokenEnv string) {
 // fetchDictionaryURL fetches a single dictionary file from a URL.
 func fetchDictionaryURL(rawURL string) (fetchedDictionaries, error) {
 	name := filepath.Base(rawURL)
-	log.Printf("aspell dictionaries: fetching %s", rawURL)
+	slog.Info("fetching dictionary", "url", rawURL)
 	return fetchSingleFile(rawURL, name, "")
 }
 
@@ -290,16 +290,16 @@ func fetchSingleFile(url, name, tokenEnv string) (fetchedDictionaries, error) {
 		}
 		_ = tmpFile.Close()
 		result.rwsFiles = append(result.rwsFiles, tmpFile.Name())
-		log.Printf("aspell dictionaries: saved .rws dictionary %s to %s", name, tmpFile.Name())
+		slog.Info("saved .rws dictionary", "file", name, "path", tmpFile.Name())
 	case strings.HasSuffix(lower, ".txt"):
 		words := parseTxtDictionary(string(data))
 		result.words = append(result.words, words...)
-		log.Printf("aspell dictionaries: loaded %d words from %s", len(words), name)
+		slog.Info("loaded dictionary words", "count", len(words), "file", name)
 	default:
 		// Treat unknown extensions as plain text word lists
 		words := parseTxtDictionary(string(data))
 		result.words = append(result.words, words...)
-		log.Printf("aspell dictionaries: loaded %d words from %s (treated as text)", len(words), name)
+		slog.Info("loaded dictionary words as plain text", "count", len(words), "file", name)
 	}
 
 	return result, nil

aspell/new.go

@@ -2,7 +2,7 @@ package aspell
 
 import (
 	"fmt"
-	"log"
+	"log/slog"
 	"os"
 	"strings"
 
@@ -14,7 +14,7 @@ func New(filename string) (Aspell, error) {
 	var err error
 	fileExists := true
 	if data, err = os.ReadFile(filename); err != nil {
-		log.Printf("warning: aspell exceptions file not found (%s)", err.Error())
+		slog.Info("aspell exceptions file not found", "err", err)
 		fileExists = false
 	}
 
@@ -28,20 +28,18 @@ func New(filename string) (Aspell, error) {
 	if aspell.RemoteFile.URL != "" || aspell.RemoteFile.URLEnv != "" {
 		extraAllowedWords, err = fetchRemoteFile(aspell)
 		if err != nil {
-			log.Printf("warning: aspell remote file (%s)", err.Error())
-			return Aspell{}, err
+			return Aspell{}, err // logged by the caller as one config error
 		}
 		if len(extraAllowedWords) == 0 {
-			log.Print("warning: aspell remote file is empty")
+			slog.Warn("aspell remote file is empty")
 		}
 	}
 
 	// Fetch remote dictionaries if configured
 	if len(aspell.Dictionaries.GitHub) > 0 || len(aspell.Dictionaries.GitLab) > 0 || len(aspell.Dictionaries.URLs) > 0 {
 		fetched, dictErr := fetchDictionaries(aspell.Dictionaries)
 		if dictErr != nil {
-			log.Printf("warning: aspell dictionaries fetch failed: %s", dictErr)
-			return Aspell{}, dictErr
+			return Aspell{}, dictErr // logged by the caller as one config error
 		}
 		extraAllowedWords = append(extraAllowedWords, fetched.words...)
 		aspell.ExtraDicts = fetched.rwsFiles
@@ -88,7 +86,7 @@ func New(filename string) (Aspell, error) {
 		}
 	}
 
-	log.Printf("aspell mode set to %s", aspell.Mode)
+	slog.Info("aspell mode set", "mode", string(aspell.Mode))
 	if fileExists {
 		aspell.HelpText = `aspell can be configured with .aspell.yml file.
 Add words to allowed list if its false positive`
@@ -123,7 +121,7 @@ dictionaries:
 	ignoreFiles := []string{"go.mod", "go.sum"}
 	for _, file := range ignoreFiles {
 		if _, err := os.Stat(file); err == nil {
-			log.Printf("aspell: added %s to ignore list", file)
+			slog.Info("added file to aspell ignore list", "file", file)
 			aspell.IgnoreFiles = append(aspell.IgnoreFiles, file)
 		}
 	}

aspell/remote.go

@@ -4,7 +4,7 @@ import (
 	"encoding/json"
 	"errors"
 	"fmt"
-	"log"
+	"log/slog"
 	"net/http"
 	"os"
 	"strings"
@@ -16,9 +16,9 @@ func fetchRemoteFile(aspell Aspell) ([]string, error) {
 	url := aspell.RemoteFile.URL
 	if aspell.RemoteFile.URLEnv != "" {
 		url = os.Getenv(aspell.RemoteFile.URLEnv)
-		log.Printf("aspell remote file: using URL from env %s: %q", aspell.RemoteFile.URLEnv, url)
+		slog.Info("aspell remote file: using URL from env", "env", aspell.RemoteFile.URLEnv, "url", url)
 	} else {
-		log.Printf("aspell remote file: using URL: %q", url)
+		slog.Info("aspell remote file: using URL", "url", url)
 	}
 
 	if url == "" {
@@ -33,14 +33,14 @@ func fetchRemoteFile(aspell Aspell) ([]string, error) {
 	if aspell.RemoteFile.HeaderFromENV != "" {
 		envValue := os.Getenv(aspell.RemoteFile.HeaderFromENV)
 		if envValue == "" {
-			log.Printf("aspell remote file: warning: header env %s is empty", aspell.RemoteFile.HeaderFromENV)
+			slog.Warn("aspell remote file: header env is empty", "env", aspell.RemoteFile.HeaderFromENV)
 		}
 		req.Header.Set(aspell.RemoteFile.HeaderFromENV, envValue)
 	}
 	if aspell.RemoteFile.PrivateTokenENV != "" {
 		envValue := os.Getenv(aspell.RemoteFile.PrivateTokenENV)
 		if envValue == "" {
-			log.Printf("aspell remote file: warning: private token env %s is empty", aspell.RemoteFile.PrivateTokenENV)
+			slog.Warn("aspell remote file: private token env is empty", "env", aspell.RemoteFile.PrivateTokenENV)
 		}
 		req.Header.Set("PRIVATE-TOKEN", envValue)
 	}
@@ -78,16 +78,16 @@ func fetchRemoteFile(aspell Aspell) ([]string, error) {
 			if err != nil {
 				return nil, fmt.Errorf("aspell remote file: failed to parse YAML block: %w", err)
 			}
-			log.Printf("aspell remote file: loaded %d words (yaml block): %v", len(allowedWords), wordSample(allowedWords))
+			slog.Info("aspell remote file: loaded words", "format", "yaml block", "count", len(allowedWords), "sample", wordSample(allowedWords))
 			return allowedWords, nil
 		}
 		allowedWords = strings.Split(content, "\n")
-		log.Printf("aspell remote file: loaded %d words (newline-separated): %v", len(allowedWords), wordSample(allowedWords))
+		slog.Info("aspell remote file: loaded words", "format", "newline-separated", "count", len(allowedWords), "sample", wordSample(allowedWords))
 	} else {
 		for _, item := range items {
 			allowedWords = append(allowedWords, item.(string))
 		}
-		log.Printf("aspell remote file: loaded %d words (JSON array): %v", len(allowedWords), wordSample(allowedWords))
+		slog.Info("aspell remote file: loaded words", "format", "JSON array", "count", len(allowedWords), "sample", wordSample(allowedWords))
 	}
 
 	return allowedWords, nil

aspell/repowords.go

@@ -1,7 +1,7 @@
 package aspell
 
 import (
-	"log"
+	"log/slog"
 	"os"
 	"path/filepath"
 
@@ -29,7 +29,7 @@ func collectManifestWords(dir string) []string {
 		}
 		extracted := m.extract(string(data))
 		words = append(words, extracted...)
-		log.Printf("aspell: collected %d words from %s", len(extracted), m.name)
+		slog.Info("collected words from manifest", "count", len(extracted), "file", m.name)
 	}
 	return words
 }
@@ -54,6 +54,6 @@ func collectPathWords(root string) []string {
 		return nil
 	})
 	words := match.GetPathWords(paths)
-	log.Printf("aspell: collected %d words from %d repository paths", len(words), len(paths))
+	slog.Info("collected words from repository paths", "count", len(words), "paths", len(paths))
 	return words
 }

aspell_test.go

@@ -2,7 +2,6 @@ package main
 
 import (
 	"bufio"
-	"log"
 	"os"
 	"strings"
 	"testing"
@@ -12,8 +11,6 @@ import (
 )
 
 func Test_Aspell(t *testing.T) {
-	log.SetFlags(log.LstdFlags | log.Lshortfile)
-
 	aspellCheck, err := aspell.New(".aspell.yml")
 	if err != nil {
 		t.Errorf("checkWithAspell() error = %v", err)