From a51b997a6e5f5212ebd0afbeaf9698385daaef7f Mon Sep 17 00:00:00 2001
From: Eugene Burkov <e.burkov@adguard.com>
Date: Mon, 22 Jul 2024 13:56:32 +0300
Subject: [PATCH] Pull request 60: 3 darwin syslog

Updates #3.

Squashed commit of the following:

commit d7f07aff8e10729aac1c4c8a09199afee9f715a0
Author: Eugene Burkov <E.Burkov@AdGuard.COM>
Date:   Thu Jul 18 14:48:34 2024 +0300

    agdcslog: imp code

commit 4c4abd7d0dc54f57242c6c0c8d89b3578b30f7dd
Author: Eugene Burkov <E.Burkov@AdGuard.COM>
Date:   Wed Jul 17 19:45:27 2024 +0300

    agdcslog: fix panic

commit 3b2c62ab87a86a914e5fb736ca6e7b6375e91564
Author: Eugene Burkov <E.Burkov@AdGuard.COM>
Date:   Wed Jul 17 19:34:37 2024 +0300

    agdcslog: imp code, docs

commit 39a9e61fc20e9576f15117b690e3487ad2ffa426
Author: Eugene Burkov <E.Burkov@AdGuard.COM>
Date:   Wed Jul 17 17:48:34 2024 +0300

    all: implement piped logger on darwin
---
 CHANGELOG.md                                  |   4 +
 internal/agdcslog/agdcslog.go                 |  49 ++--
 internal/agdcslog/agdcslog_test.go            |  41 ++-
 internal/agdcslog/syslog.go                   |  29 ++
 internal/agdcslog/syslog_darwin.go            | 257 ++++++++++++++++++
 .../{agdcslog_unix.go => syslog_linux.go}     |  20 +-
 ...{agdcslog_windows.go => syslog_windows.go} |  19 +-
 internal/cmd/log.go                           |   2 +-
 8 files changed, 348 insertions(+), 73 deletions(-)
 create mode 100644 internal/agdcslog/syslog.go
 create mode 100644 internal/agdcslog/syslog_darwin.go
 rename internal/agdcslog/{agdcslog_unix.go => syslog_linux.go} (56%)
 rename internal/agdcslog/{agdcslog_windows.go => syslog_windows.go} (76%)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 682fae8..f7e0485 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -30,12 +30,16 @@ NOTE: Add new changes BELOW THIS COMMENT.
 
 ### Fixed
 
+- The `syslog` log output on macOS ([#3]).
+
+  **NOTE:** The implementation is actually a workaround for a known [Go issue][go-59229], and uses the `/usr/bin/logger` utility. This approach is suboptimal and will be improved once the Go issue is resolved.
 - DNS proxy logs being written to `stderr` instead of `log.output` ([#1]).
 
 [#1]: https://github.com/AdguardTeam/AdGuardDNSClient/issues/1
 [#2]: https://github.com/AdguardTeam/AdGuardDNSClient/issues/2
 
 [go-1.22.5]: https://groups.google.com/g/golang-announce/c/gyb7aM1C9H4
+[go-59229]:  https://github.com/golang/go/issues/59229
 
 <!--
 NOTE: Add new changes ABOVE THIS COMMENT.
diff --git a/internal/agdcslog/agdcslog.go b/internal/agdcslog/agdcslog.go
index a3a881a..2b34c90 100644
--- a/internal/agdcslog/agdcslog.go
+++ b/internal/agdcslog/agdcslog.go
@@ -40,33 +40,18 @@ func (h *bufferedTextHandler) reset() {
 	h.buffer.Reset()
 }
 
-// Logger is a platform-specific system Logger.
-type Logger interface {
-	Debug(msg string) (err error)
-	Info(msg string) (err error)
-	Warning(msg string) (err error)
-	Error(msg string) (err error)
-	Close() (err error)
-}
-
-// NewSystemLogger returns a platform-specific system logger that writes to
-// system log.  name is the service name.
-func NewSystemLogger(name string) (l Logger, err error) {
-	return newSystemLogger(name)
-}
-
-// SystemHandler is a [slog.Handler] that writes to system log.
-type SystemHandler struct {
-	logger      Logger
+// SyslogHandler is a [slog.Handler] that writes to system log.
+type SyslogHandler struct {
+	logger      SystemLogger
 	level       slog.Leveler
 	bufTextPool *syncutil.Pool[bufferedTextHandler]
 	attrs       []slog.Attr
 }
 
-// NewSystemHandler returns an initialized SystemHandler that writes to system
+// NewSyslogHandler returns an initialized SyslogHandler that writes to system
 // log.  opts must not be nil and contain Level.
-func NewSystemHandler(logger Logger, opts *slog.HandlerOptions) (h *SystemHandler) {
-	return &SystemHandler{
+func NewSyslogHandler(logger SystemLogger, opts *slog.HandlerOptions) (h *SyslogHandler) {
+	return &SyslogHandler{
 		logger: logger,
 		level:  opts.Level,
 		bufTextPool: syncutil.NewPool(func() (bufTextHdlr *bufferedTextHandler) {
@@ -77,15 +62,15 @@ func NewSystemHandler(logger Logger, opts *slog.HandlerOptions) (h *SystemHandle
 }
 
 // type check
-var _ slog.Handler = (*SystemHandler)(nil)
+var _ slog.Handler = (*SyslogHandler)(nil)
 
-// Enabled implements the [slog.Handler] interface for *SystemHandler.
-func (h *SystemHandler) Enabled(_ context.Context, level slog.Level) (enabled bool) {
+// Enabled implements the [slog.Handler] interface for *SyslogHandler.
+func (h *SyslogHandler) Enabled(_ context.Context, level slog.Level) (enabled bool) {
 	return level >= h.level.Level()
 }
 
-// Handle implements the [slog.Handler] interface for *SystemHandler.
-func (h *SystemHandler) Handle(ctx context.Context, rec slog.Record) (err error) {
+// Handle implements the [slog.Handler] interface for *SyslogHandler.
+func (h *SyslogHandler) Handle(ctx context.Context, rec slog.Record) (err error) {
 	bufTextHdlr := h.bufTextPool.Get()
 	defer h.bufTextPool.Put(bufTextHdlr)
 
@@ -126,9 +111,9 @@ func (h *SystemHandler) Handle(ctx context.Context, rec slog.Record) (err error)
 	return err
 }
 
-// WithAttrs implements the [slog.Handler] interface for *SystemHandler.
-func (h *SystemHandler) WithAttrs(attrs []slog.Attr) (handler slog.Handler) {
-	return &SystemHandler{
+// WithAttrs implements the [slog.Handler] interface for *SyslogHandler.
+func (h *SyslogHandler) WithAttrs(attrs []slog.Attr) (handler slog.Handler) {
+	return &SyslogHandler{
 		logger:      h.logger,
 		level:       h.level,
 		bufTextPool: h.bufTextPool,
@@ -136,12 +121,12 @@ func (h *SystemHandler) WithAttrs(attrs []slog.Attr) (handler slog.Handler) {
 	}
 }
 
-// WithGroup implements the [slog.Handler] interface for *SystemHandler.
-func (h *SystemHandler) WithGroup(name string) (handler slog.Handler) {
+// WithGroup implements the [slog.Handler] interface for *SyslogHandler.
+func (h *SyslogHandler) WithGroup(name string) (handler slog.Handler) {
 	return h
 }
 
 // Close closes an underlying system logger.
-func (h *SystemHandler) Close() (err error) {
+func (h *SyslogHandler) Close() (err error) {
 	return h.logger.Close()
 }
diff --git a/internal/agdcslog/agdcslog_test.go b/internal/agdcslog/agdcslog_test.go
index fdcca0c..94dee6c 100644
--- a/internal/agdcslog/agdcslog_test.go
+++ b/internal/agdcslog/agdcslog_test.go
@@ -14,7 +14,7 @@ import (
 	"github.com/stretchr/testify/require"
 )
 
-// mockLogger is a mock implementation of [agdcslog.Logger] interface for tests.
+// mockLogger is a mock implementation of [agdcslog.SystemLogger] interface for tests.
 type mockLogger struct {
 	onDebug   func(msg string) (err error)
 	onInfo    func(msg string) (err error)
@@ -43,34 +43,34 @@ func NewMockLogger() (l *mockLogger) {
 }
 
 // type check
-var _ agdcslog.Logger = (*mockLogger)(nil)
+var _ agdcslog.SystemLogger = (*mockLogger)(nil)
 
-// Debug implements [agdcslog.Logger] interface for *mockLogger.
+// Debug implements [agdcslog.SystemLogger] interface for *mockLogger.
 func (l *mockLogger) Debug(msg string) (err error) {
 	return l.onDebug(msg)
 }
 
-// Info implements [agdcslog.Logger] interface for *mockLogger.
+// Info implements [agdcslog.SystemLogger] interface for *mockLogger.
 func (l *mockLogger) Info(msg string) (err error) {
 	return l.onInfo(msg)
 }
 
-// Warning implements [agdcslog.Logger] interface for *mockLogger.
+// Warning implements [agdcslog.SystemLogger] interface for *mockLogger.
 func (l *mockLogger) Warning(msg string) (err error) {
 	return l.onWarning(msg)
 }
 
-// Error implements [agdcslog.Logger] interface for *mockLogger.
+// Error implements [agdcslog.SystemLogger] interface for *mockLogger.
 func (l *mockLogger) Error(msg string) (err error) {
 	return l.onError(msg)
 }
 
-// Close implements [agdcslog.Logger] interface for *mockLogger.
+// Close implements [agdcslog.SystemLogger] interface for *mockLogger.
 func (l *mockLogger) Close() (err error) {
 	return l.onClose()
 }
 
-func TestSystemHandler_Handle(t *testing.T) {
+func TestSyslogHandler_Handle(t *testing.T) {
 	var (
 		mu     = sync.Mutex{}
 		output = &bytes.Buffer{}
@@ -91,7 +91,7 @@ func TestSystemHandler_Handle(t *testing.T) {
 	l.onError = outputWrite
 	l.onDebug = outputWrite
 
-	handler := agdcslog.NewSystemHandler(l, &slog.HandlerOptions{
+	handler := agdcslog.NewSyslogHandler(l, &slog.HandlerOptions{
 		Level: slog.LevelDebug,
 	})
 
@@ -153,7 +153,7 @@ func TestSystemHandler_Handle(t *testing.T) {
 	}
 }
 
-func TestSystemHandler_Handle_race(t *testing.T) {
+func TestSyslogHandler_Handle_race(t *testing.T) {
 	var (
 		mu     = sync.Mutex{}
 		output = &bytes.Buffer{}
@@ -169,7 +169,7 @@ func TestSystemHandler_Handle_race(t *testing.T) {
 		return nil
 	}
 
-	h := agdcslog.NewSystemHandler(l, &slog.HandlerOptions{
+	h := agdcslog.NewSyslogHandler(l, &slog.HandlerOptions{
 		Level: slog.LevelDebug,
 	})
 
@@ -182,11 +182,11 @@ func TestSystemHandler_Handle_race(t *testing.T) {
 	for i := 0; i < numGoroutine; i++ {
 		wg.Add(1)
 
-		go func(i int) {
+		go func() {
 			defer wg.Done()
 
 			logger.Info("test message", "attr", "abc")
-		}(i)
+		}()
 	}
 
 	wg.Wait()
@@ -203,11 +203,11 @@ func TestSystemHandler_Handle_race(t *testing.T) {
 // errSink is a sink for benchmark results.
 var errSink error
 
-func BenchmarkSystemHandler_Handle(b *testing.B) {
+func BenchmarkSyslogHandler_Handle(b *testing.B) {
 	l := NewMockLogger()
 	l.onInfo = func(_ string) (_ error) { return nil }
 
-	h := agdcslog.NewSystemHandler(l, &slog.HandlerOptions{
+	h := agdcslog.NewSyslogHandler(l, &slog.HandlerOptions{
 		Level: slog.LevelDebug,
 	})
 
@@ -226,10 +226,9 @@ func BenchmarkSystemHandler_Handle(b *testing.B) {
 
 	require.NoError(b, errSink)
 
-	// Most recent result, on a ThinkPad P15s with a Intel Core i7-10510U CPU:
-	//	goos: linux
-	//	goarch: amd64
-	//	pkg: github.com/AdguardTeam/AdGuardDNSClient/internal/agdcslog
-	//	cpu: Intel(R) Core(TM) i7-10510U CPU @ 1.80GHz
-	//	BenchmarkSystemHandler_Handle-8   	 2595381	       448.2 ns/op	      64 B/op	       1 allocs/op
+	// goos: darwin
+	// goarch: amd64
+	// pkg: github.com/AdguardTeam/AdGuardDNSClient/internal/agdcslog
+	// cpu: Intel(R) Core(TM) i7-9750H CPU @ 2.60GHz
+	// BenchmarkSyslogHandler_Handle-12		2365461		501.1 ns/op		64 B/op		1 allocs/op
 }
diff --git a/internal/agdcslog/syslog.go b/internal/agdcslog/syslog.go
new file mode 100644
index 0000000..ed44d60
--- /dev/null
+++ b/internal/agdcslog/syslog.go
@@ -0,0 +1,29 @@
+package agdcslog
+
+import "io"
+
+// SystemLogger is a platform-specific system logger.
+//
+// TODO(e.burkov):  Consider moving to golibs.
+type SystemLogger interface {
+	// Debug logs a message at debug level.
+	Debug(msg string) (err error)
+
+	// Info logs a message at info level.
+	Info(msg string) (err error)
+
+	// Warning logs a message at warning level.
+	Warning(msg string) (err error)
+
+	// Error logs a message at error level.
+	Error(msg string) (err error)
+
+	// Close detaches from the system logger.
+	io.Closer
+}
+
+// NewSystemLogger returns a platform-specific system logger.  name is the
+// name of service.
+func NewSystemLogger(name string) (l SystemLogger, err error) {
+	return newSystemLogger(name)
+}
diff --git a/internal/agdcslog/syslog_darwin.go b/internal/agdcslog/syslog_darwin.go
new file mode 100644
index 0000000..a0987aa
--- /dev/null
+++ b/internal/agdcslog/syslog_darwin.go
@@ -0,0 +1,257 @@
+//go:build darwin
+
+package agdcslog
+
+import (
+	"bytes"
+	"fmt"
+	"io"
+	"os/exec"
+	"strings"
+	"sync"
+
+	"github.com/AdguardTeam/golibs/errors"
+	"github.com/AdguardTeam/golibs/ioutil"
+	"github.com/c2h5oh/datasize"
+)
+
+// severity is a semantic alias for logging severity level name.
+type severity = string
+
+// Possible severity values.
+const (
+	sevDebug   severity = "debug"
+	sevInfo    severity = "info"
+	sevWarning severity = "warning"
+	sevError   severity = "error"
+)
+
+// defaultOutLimit is the default limit of the output message size.  It's
+// applied separately to stdout and stderr.
+const defaultOutLimit datasize.ByteSize = 1 * datasize.KB
+
+// systemLogger is the implementation of the [SystemLogger] interface for macOS,
+// which uses the /usr/bin/logger command.
+//
+// TODO(e.burkov):  Get rid of it when golang/go#59229 is resolved.
+type systemLogger struct {
+	debug   *process
+	info    *process
+	warning *process
+	error   *process
+
+	// tag is the prefix for all log messages.
+	//
+	// TODO(e.burkov):  This is only needed because the /usr/bin/logger command
+	// doesn't support the -t option.  Remove it if the situation changes.
+	tag string
+}
+
+// newSystemLogger returns a macOS-specific system logger.
+func newSystemLogger(tag string) (l SystemLogger, err error) {
+	sysl := &systemLogger{
+		tag: tag,
+	}
+
+	var errs []error
+
+	// msgFmt is the local error message template.  It expects a severity as the
+	// first argument and an error as the second.
+	const msgFmt = "creating %s logger process: %w"
+
+	sysl.debug, err = newProcess(sevDebug)
+	if err != nil {
+		errs = append(errs, fmt.Errorf(msgFmt, sevDebug, err))
+	}
+
+	sysl.info, err = newProcess(sevInfo)
+	if err != nil {
+		errs = append(errs, fmt.Errorf(msgFmt, sevInfo, err))
+	}
+
+	sysl.warning, err = newProcess(sevWarning)
+	if err != nil {
+		errs = append(errs, fmt.Errorf(msgFmt, sevWarning, err))
+	}
+
+	sysl.error, err = newProcess(sevError)
+	if err != nil {
+		errs = append(errs, fmt.Errorf(msgFmt, sevError, err))
+	}
+
+	if err = errors.Join(errs...); err != nil {
+		return nil, errors.WithDeferred(err, sysl.Close())
+	}
+
+	return sysl, nil
+}
+
+// type check
+var _ SystemLogger = (*systemLogger)(nil)
+
+// Debug implements the [SystemLogger] interface for *systemLogger.
+func (l *systemLogger) Debug(msg string) (err error) {
+	// Don't wrap the error since it's informative enough as is.
+	return l.debug.write(l.tag, msg)
+}
+
+// Info implements the [SystemLogger] interface for *systemLogger.
+func (l *systemLogger) Info(msg string) (err error) {
+	// Don't wrap the error since it's informative enough as is.
+	return l.info.write(l.tag, msg)
+}
+
+// Warning implements the [SystemLogger] interface for *systemLogger.
+func (l *systemLogger) Warning(msg string) (err error) {
+	// Don't wrap the error since it's informative enough as is.
+	return l.warning.write(l.tag, msg)
+}
+
+// Error implements the [SystemLogger] interface for *systemLogger.
+func (l *systemLogger) Error(msg string) (err error) {
+	// Don't wrap the error since it's informative enough as is.
+	return l.error.write(l.tag, msg)
+}
+
+// Close implements the [SystemLogger] interface for *systemLogger.
+func (l *systemLogger) Close() (err error) {
+	var errs []error
+	procs := []*process{
+		l.debug,
+		l.info,
+		l.warning,
+		l.error,
+	}
+
+	for _, p := range procs {
+		if p == nil {
+			continue
+		}
+
+		err = p.close()
+		if err != nil {
+			// Don't wrap the error since it's informative enough as is.
+			errs = append(errs, err)
+		}
+	}
+
+	err = errors.Join(errs...)
+	if err != nil {
+		return fmt.Errorf("closing logger processes: %w", err)
+	}
+
+	return nil
+}
+
+// process is an instance of the logger process with a particular severity.
+type process struct {
+	// mu synchronizes writes to stdin between each other and with the process
+	// closing.
+	mu *sync.Mutex
+
+	// cmd is the logger command of a particular severity.
+	cmd *exec.Cmd
+
+	// stdin is the pipe to stdin of cmd.
+	stdin io.WriteCloser
+
+	// stdout is the truncated standard output of cmd.
+	stdout *bytes.Buffer
+
+	// stderr is the truncated standard error of cmd.
+	stderr *bytes.Buffer
+
+	// severity is the severity level this logger process correponds to.  See
+	// [severity].
+	severity severity
+}
+
+// newProcess creates a new process with a particular severity.
+func newProcess(sev severity) (p *process, err error) {
+	const (
+		binPath        = "/usr/bin/logger"
+		optionPriority = "-p"
+		facilityVal    = "user"
+	)
+
+	priorityVal := facilityVal + "." + sev
+
+	// #nosec G204 -- Trust the variable to be a valid syslog priority since it
+	// always constructed from the predefined constants.
+	cmd := exec.Command(binPath, optionPriority, priorityVal)
+	if cmd.Err != nil {
+		return nil, fmt.Errorf("creating command: %w", cmd.Err)
+	}
+
+	stdin, err := cmd.StdinPipe()
+	if err != nil {
+		return nil, fmt.Errorf("creating stdin pipe: %w", err)
+	}
+
+	limit := uint(defaultOutLimit.Bytes())
+
+	stdout := &bytes.Buffer{}
+	stderr := &bytes.Buffer{}
+
+	cmd.Stdout = ioutil.NewTruncatedWriter(stdout, limit)
+	cmd.Stderr = ioutil.NewTruncatedWriter(stderr, limit)
+
+	if err = cmd.Start(); err != nil {
+		return nil, fmt.Errorf("starting command: %w", err)
+	}
+
+	return &process{
+		mu:       &sync.Mutex{},
+		cmd:      cmd,
+		stdin:    stdin,
+		stdout:   stdout,
+		stderr:   stderr,
+		severity: sev,
+	}, nil
+}
+
+// write writes the message to the logger.
+func (p *process) write(tag, msg string) (err error) {
+	defer func() { err = errors.Annotate(err, "writing %s message", p.severity) }()
+
+	msg = strings.TrimSuffix(msg, "\n")
+
+	p.mu.Lock()
+	defer p.mu.Unlock()
+
+	_, err = fmt.Fprintf(p.stdin, "%s: %s\n", tag, msg)
+
+	return err
+}
+
+// close closes the process' pipes and waits for the command to exit.
+func (p *process) close() (err error) {
+	defer func() { err = errors.Annotate(err, "closing %s logger: %w", p.severity) }()
+
+	var errs []error
+
+	p.mu.Lock()
+	defer p.mu.Unlock()
+
+	if err = p.stdin.Close(); err != nil {
+		err = fmt.Errorf("closing stdin: %w", err)
+		errs = append(errs, err)
+	}
+
+	if err = p.cmd.Wait(); err != nil {
+		err = fmt.Errorf("waiting: %w", err)
+		errs = append(errs, err)
+	}
+
+	if p.stdout.Len() > 0 {
+		err = fmt.Errorf("unexpected stdout output: %q", p.stdout)
+		errs = append(errs, err)
+	}
+
+	if p.stderr.Len() > 0 {
+		err = fmt.Errorf("unexpected stderr output: %q", p.stderr)
+		errs = append(errs, err)
+	}
+
+	return errors.Join(errs...)
+}
diff --git a/internal/agdcslog/agdcslog_unix.go b/internal/agdcslog/syslog_linux.go
similarity index 56%
rename from internal/agdcslog/agdcslog_unix.go
rename to internal/agdcslog/syslog_linux.go
index bde6c98..eb30912 100644
--- a/internal/agdcslog/agdcslog_unix.go
+++ b/internal/agdcslog/syslog_linux.go
@@ -1,4 +1,4 @@
-//go:build !windows
+//go:build linux
 
 package agdcslog
 
@@ -6,13 +6,13 @@ import (
 	"log/syslog"
 )
 
-// systemLogger is a wrapper around [eventlog.Log].
+// systemLogger is the implementation of the [SystemLogger] interface for Linux.
 type systemLogger struct {
 	writer *syslog.Writer
 }
 
-// newSystemLogger returns a unix specific system logger.
-func newSystemLogger(tag string) (l Logger, err error) {
+// newSystemLogger returns a Linux-specific system logger.
+func newSystemLogger(tag string) (l SystemLogger, err error) {
 	const priority = syslog.LOG_NOTICE | syslog.LOG_USER
 
 	w, err := syslog.New(priority, tag)
@@ -27,29 +27,29 @@ func newSystemLogger(tag string) (l Logger, err error) {
 }
 
 // type check
-var _ Logger = (*systemLogger)(nil)
+var _ SystemLogger = (*systemLogger)(nil)
 
-// Debug implements [Logger] interface for *systemLogger.
+// Debug implements the [SystemLogger] interface for *systemLogger.
 func (l *systemLogger) Debug(msg string) (err error) {
 	return l.writer.Debug(msg)
 }
 
-// Info implements [Logger] interface for *systemLogger.
+// Info implements the [SystemLogger] interface for *systemLogger.
 func (l *systemLogger) Info(msg string) (err error) {
 	return l.writer.Info(msg)
 }
 
-// Warning implements [Logger] interface for *systemLogger.
+// Warning implements the [SystemLogger] interface for *systemLogger.
 func (l *systemLogger) Warning(msg string) (err error) {
 	return l.writer.Warning(msg)
 }
 
-// Error implements [Logger] interface for *systemLogger.
+// Error implements the [SystemLogger] interface for *systemLogger.
 func (l *systemLogger) Error(msg string) (err error) {
 	return l.writer.Err(msg)
 }
 
-// Close implements [Logger] interface for *systemLogger.
+// Close implements the [SystemLogger] interface for *systemLogger.
 func (l *systemLogger) Close() (err error) {
 	return l.writer.Close()
 }
diff --git a/internal/agdcslog/agdcslog_windows.go b/internal/agdcslog/syslog_windows.go
similarity index 76%
rename from internal/agdcslog/agdcslog_windows.go
rename to internal/agdcslog/syslog_windows.go
index cee7f0a..47d8fa5 100644
--- a/internal/agdcslog/agdcslog_windows.go
+++ b/internal/agdcslog/syslog_windows.go
@@ -23,17 +23,18 @@ const (
 	debugEventID   = 4
 )
 
-// systemLogger is a wrapper around [eventlog.Log].
+// systemLogger is the implementation of the [SystemLogger] interface for
+// Windows.
 type systemLogger struct {
 	writer *eventlog.Log
 }
 
-// newSystemLogger returns a windows specific system logger.
+// newSystemLogger returns a Windows-specific system logger.
 //
 // Note that the eventlog src is the same as the service name.  Otherwise, we
 // will get "the description for event id cannot be found" warning in every log
 // record.
-func newSystemLogger(src string) (l Logger, err error) {
+func newSystemLogger(src string) (l SystemLogger, err error) {
 	const events = eventlog.Info | eventlog.Warning | eventlog.Error
 
 	// Continue if we receive "registry key already exists" or if we get
@@ -59,30 +60,30 @@ func newSystemLogger(src string) (l Logger, err error) {
 }
 
 // type check
-var _ Logger = (*systemLogger)(nil)
+var _ SystemLogger = (*systemLogger)(nil)
 
-// Debug implements [Logger] interface for *systemLogger.
+// Debug implements the [SystemLogger] interface for *systemLogger.
 func (l *systemLogger) Debug(msg string) (err error) {
 	// Event Log doesn't have Debug log level, use Info.
 	return l.writer.Info(debugEventID, msg)
 }
 
-// Info implements [Logger] interface for *systemLogger.
+// Info implements the [SystemLogger] interface for *systemLogger.
 func (l *systemLogger) Info(msg string) (err error) {
 	return l.writer.Info(infoEventID, msg)
 }
 
-// Warning implements [Logger] interface for *systemLogger.
+// Warning implements the [SystemLogger] interface for *systemLogger.
 func (l *systemLogger) Warning(msg string) (err error) {
 	return l.writer.Warning(warningEventID, msg)
 }
 
-// Error implements [Logger] interface for *systemLogger.
+// Error implements the [SystemLogger] interface for *systemLogger.
 func (l *systemLogger) Error(msg string) (err error) {
 	return l.writer.Error(errorEventID, msg)
 }
 
-// Close implements [Logger] interface for *systemLogger.
+// Close implements the [SystemLogger] interface for *systemLogger.
 func (l *systemLogger) Close() (err error) {
 	return l.writer.Close()
 }
diff --git a/internal/cmd/log.go b/internal/cmd/log.go
index 584a6bb..6aa40c9 100644
--- a/internal/cmd/log.go
+++ b/internal/cmd/log.go
@@ -154,7 +154,7 @@ func newSystemLogger(isVerbose bool) (l *slog.Logger, err error) {
 		lvl = slog.LevelDebug
 	}
 
-	h := agdcslog.NewSystemHandler(sl, &slog.HandlerOptions{
+	h := agdcslog.NewSyslogHandler(sl, &slog.HandlerOptions{
 		Level: lvl,
 	})