Pull request 83: AGDNS-3219-agdcslog-syslog-tests

Merge in GO/adguarddnsclient from AGDNS-3219-agdcslog-syslog-tests to master

Squashed commit of the following:

commit aea29b1
Author: Stanislav Chzhen <s.chzhen@adguard.com>
Date:   Tue Sep 23 15:47:19 2025 +0300

    agdcslog: imp docs

commit 5b76c10
Author: Stanislav Chzhen <s.chzhen@adguard.com>
Date:   Mon Sep 22 17:29:28 2025 +0300

    agdcslog: imp tests

commit 6f75811
Merge: 2a0ac83 5a0279e
Author: Stanislav Chzhen <s.chzhen@adguard.com>
Date:   Fri Sep 19 14:53:04 2025 +0300

    Merge branch 'master' into AGDNS-3219-agdcslog-syslog-tests

commit 2a0ac83
Author: Stanislav Chzhen <s.chzhen@adguard.com>
Date:   Fri Sep 19 14:52:55 2025 +0300

    agdcslog: imp docs, tests

commit f6eaee7
Author: Stanislav Chzhen <s.chzhen@adguard.com>
Date:   Thu Sep 18 15:36:39 2025 +0300

    agdcslog: fix tests

commit a440082
Author: Stanislav Chzhen <s.chzhen@adguard.com>
Date:   Thu Sep 18 14:49:59 2025 +0300

    agdcslog: add syslog tests

Author: schzhn

internal/agdcslog/agdcslog_internal_test.go

@@ -0,0 +1,6 @@
+package agdcslog
+
+import "time"
+
+// testTimeout is the common timeout for tests.
+const testTimeout = 1 * time.Second

internal/agdcslog/syslog.go

@@ -9,7 +9,7 @@ import (
 //
 // TODO(e.burkov):  Consider moving to golibs.
 //
-// TODO(s.chzhen):  Add platform-specific tests.
+// TODO(s.chzhen):  Add platform-specific integration tests.
 type SystemLogger interface {
 	// Debug logs a message at debug level.
 	Debug(msg string) (err error)

internal/agdcslog/syslog_darwin.go

@@ -36,10 +36,10 @@ const defaultOutLimit datasize.ByteSize = 1 * datasize.KB
 //
 // TODO(e.burkov):  Get rid of it when golang/go#59229 is resolved.
 type systemLogger struct {
-	debug   *process
-	info    *process
-	warning *process
-	error   *process
+	debug   *osProcess
+	info    *osProcess
+	warning *osProcess
+	error   *osProcess
 
 	// tag is the prefix for all log messages.
 	//
@@ -50,6 +50,25 @@ type systemLogger struct {
 
 // newSystemLogger returns a macOS-specific system logger.
 func newSystemLogger(ctx context.Context, tag string) (l SystemLogger, err error) {
+	cmdCons := executil.SystemCommandConstructor{}
+	sysl, err := newSystemLoggerWithCommandConstructor(ctx, cmdCons, tag)
+	if err != nil {
+		// Don't wrap the error because it's informative enough as is.
+		return nil, err
+	}
+
+	return sysl, nil
+}
+
+// newSystemLoggerWithCommandConstructor returns a macOS-specific system logger
+// using the provided command constructor.
+//
+// TODO(s.chzhen):  Use this as the actual constructor.
+func newSystemLoggerWithCommandConstructor(
+	ctx context.Context,
+	cmdCons executil.CommandConstructor,
+	tag string,
+) (l SystemLogger, err error) {
 	sysl := &systemLogger{
 		tag: tag,
 	}
@@ -60,24 +79,22 @@ func newSystemLogger(ctx context.Context, tag string) (l SystemLogger, err error
 	// first argument and an error as the second.
 	const msgFmt = "creating %s logger process: %w"
 
-	cmdCons := executil.SystemCommandConstructor{}
-
-	sysl.debug, err = newProcess(ctx, cmdCons, sevDebug)
+	sysl.debug, err = newOSProcess(ctx, cmdCons, sevDebug)
 	if err != nil {
 		errs = append(errs, fmt.Errorf(msgFmt, sevDebug, err))
 	}
 
-	sysl.info, err = newProcess(ctx, cmdCons, sevInfo)
+	sysl.info, err = newOSProcess(ctx, cmdCons, sevInfo)
 	if err != nil {
 		errs = append(errs, fmt.Errorf(msgFmt, sevInfo, err))
 	}
 
-	sysl.warning, err = newProcess(ctx, cmdCons, sevWarning)
+	sysl.warning, err = newOSProcess(ctx, cmdCons, sevWarning)
 	if err != nil {
 		errs = append(errs, fmt.Errorf(msgFmt, sevWarning, err))
 	}
 
-	sysl.error, err = newProcess(ctx, cmdCons, sevError)
+	sysl.error, err = newOSProcess(ctx, cmdCons, sevError)
 	if err != nil {
 		errs = append(errs, fmt.Errorf(msgFmt, sevError, err))
 	}
@@ -121,7 +138,7 @@ func (l *systemLogger) Close() (err error) {
 	defer func() { err = errors.Annotate(err, "closing logger processes: %w") }()
 
 	var errs []error
-	procs := []*process{
+	procs := []*osProcess{
 		l.debug,
 		l.info,
 		l.warning,
@@ -143,8 +160,8 @@ func (l *systemLogger) Close() (err error) {
 	return errors.Join(errs...)
 }
 
-// process is an instance of the logger process with a particular severity.
-type process struct {
+// osProcess is an instance of the logger process with a particular severity.
+type osProcess struct {
 	// mu synchronizes writes to stdin between each other and with the process
 	// closing.
 	mu *sync.Mutex
@@ -166,12 +183,12 @@ type process struct {
 	severity severity
 }
 
-// newProcess creates a new process with a particular severity.
-func newProcess(
+// newOSProcess creates a new process with a particular severity.
+func newOSProcess(
 	ctx context.Context,
 	cmdCons executil.CommandConstructor,
 	sev severity,
-) (p *process, err error) {
+) (p *osProcess, err error) {
 	const (
 		binPath        = "/usr/bin/logger"
 		optionPriority = "-p"
@@ -204,7 +221,7 @@ func newProcess(
 		return nil, fmt.Errorf("starting command: %w", err)
 	}
 
-	return &process{
+	return &osProcess{
 		mu:       &sync.Mutex{},
 		cmd:      cmd,
 		stdin:    stdinWriter,
@@ -215,7 +232,7 @@ func newProcess(
 }
 
 // write writes the message to the logger.
-func (p *process) write(tag, msg string) (err error) {
+func (p *osProcess) write(tag, msg string) (err error) {
 	defer func() { err = errors.Annotate(err, "writing %s message", p.severity) }()
 
 	msg = strings.TrimSuffix(msg, "\n")
@@ -228,8 +245,8 @@ func (p *process) write(tag, msg string) (err error) {
 	return err
 }
 
-// close closes the process' pipes and waits for the command to exit.
-func (p *process) close() (err error) {
+// close closes the process's pipes and waits for the command to exit.
+func (p *osProcess) close() (err error) {
 	defer func() { err = errors.Annotate(err, "closing %s logger: %w", p.severity) }()
 
 	var errs []error

internal/agdcslog/syslog_darwin_internal_test.go

@@ -0,0 +1,97 @@
+//go:build darwin
+
+package agdcslog
+
+import (
+	"bytes"
+	"context"
+	"io"
+	"sync"
+	"testing"
+
+	"github.com/AdguardTeam/golibs/osutil/executil"
+	"github.com/AdguardTeam/golibs/testutil"
+	"github.com/AdguardTeam/golibs/testutil/fakeos/fakeexec"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+// lockedWriter protects concurrent writes to an underlying writer.
+type lockedWriter struct {
+	mu *sync.Mutex
+	w  io.Writer
+}
+
+// type check
+var _ io.Writer = (*lockedWriter)(nil)
+
+// Write implements the [io.Writer] interface for *lockedWriter.
+func (lw *lockedWriter) Write(b []byte) (n int, err error) {
+	lw.mu.Lock()
+	defer lw.mu.Unlock()
+
+	return lw.w.Write(b)
+}
+
+func TestSystemLogger(t *testing.T) {
+	t.Parallel()
+
+	const (
+		testTag = "tag"
+
+		debugMsg = "debug_msg"
+		infoMsg  = "info_msg"
+		warnMsg  = "warn_msg"
+		errMsg   = "err_msg"
+	)
+
+	stdoutBuf := bytes.Buffer{}
+	lw := &lockedWriter{
+		mu: &sync.Mutex{},
+		w:  &stdoutBuf,
+	}
+
+	onNew := func(_ context.Context, conf *executil.CommandConfig) (c executil.Command, err error) {
+		cmd := fakeexec.NewCommand()
+
+		done := make(chan struct{})
+		cmd.OnStart = func(_ context.Context) (err error) {
+			go func(r io.Reader) {
+				_, err = io.Copy(lw, r)
+				require.NoError(testutil.PanicT{}, err)
+
+				close(done)
+			}(conf.Stdin)
+
+			return nil
+		}
+
+		cmd.OnWait = func(_ context.Context) (err error) {
+			<-done
+
+			return nil
+		}
+
+		return cmd, nil
+	}
+
+	cmdCons := &fakeexec.CommandConstructor{
+		OnNew: onNew,
+	}
+
+	ctx := testutil.ContextWithTimeout(t, testTimeout)
+	l, err := newSystemLoggerWithCommandConstructor(ctx, cmdCons, testTag)
+	require.NoError(t, err)
+
+	require.NoError(t, l.Debug(debugMsg))
+	require.NoError(t, l.Info(infoMsg))
+	require.NoError(t, l.Warning(warnMsg))
+	require.NoError(t, l.Error(errMsg))
+	require.NoError(t, l.Close())
+
+	out := stdoutBuf.String()
+	assert.Contains(t, out, testTag+": "+debugMsg+"\n")
+	assert.Contains(t, out, testTag+": "+infoMsg+"\n")
+	assert.Contains(t, out, testTag+": "+warnMsg+"\n")
+	assert.Contains(t, out, testTag+": "+errMsg+"\n")
+}

internal/agdcslog/syslog_linux_internal_test.go

@@ -0,0 +1,66 @@
+//go:build linux
+
+package agdcslog
+
+import (
+	"io"
+	"log/syslog"
+	"net"
+	"net/netip"
+	"testing"
+	"time"
+
+	"github.com/AdguardTeam/golibs/netutil"
+	"github.com/AdguardTeam/golibs/testutil"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestSystemLogger(t *testing.T) {
+	t.Parallel()
+
+	const (
+		network = "tcp"
+
+		testTag = "tag"
+
+		debugMsg = "debug_msg"
+		infoMsg  = "info_msg"
+		warnMsg  = "warn_msg"
+		errMsg   = "err_msg"
+	)
+
+	localhostAnyPort := netip.AddrPortFrom(netutil.IPv4Localhost(), 0)
+	addr := net.TCPAddrFromAddrPort(localhostAnyPort)
+	ln, err := net.ListenTCP(network, addr)
+	require.NoError(t, err)
+	testutil.CleanupAndRequireSuccess(t, ln.Close)
+
+	w, err := syslog.Dial(network, ln.Addr().String(), syslog.LOG_LOCAL0, testTag)
+	require.NoError(t, err)
+
+	l := &systemLogger{writer: w}
+	require.NoError(t, l.Debug(debugMsg))
+	require.NoError(t, l.Info(infoMsg))
+	require.NoError(t, l.Warning(warnMsg))
+	require.NoError(t, l.Error(errMsg))
+
+	// Close the syslog writer to signal EOF to the reader.
+	require.NoError(t, l.Close())
+
+	conn, err := ln.Accept()
+	require.NoError(t, err)
+	testutil.CleanupAndRequireSuccess(t, conn.Close)
+
+	err = conn.SetReadDeadline(time.Now().Add(testTimeout))
+	require.NoError(t, err)
+
+	data, err := io.ReadAll(conn)
+	require.NoError(t, err)
+
+	out := string(data)
+	assert.Contains(t, out, debugMsg)
+	assert.Contains(t, out, infoMsg)
+	assert.Contains(t, out, warnMsg)
+	assert.Contains(t, out, errMsg)
+}

internal/agdcslog/syslog_windows.go

@@ -24,10 +24,26 @@ const (
 	debugEventID   = 4
 )
 
+// eventlogWriter abstracts the Windows event log.
+type eventlogWriter interface {
+	// Info logs at the info level.  The same method is also used for debug
+	// messages with a different event ID.
+	Info(id uint32, msg string) (err error)
+
+	// Warning logs a message at the warning level.
+	Warning(id uint32, msg string) (err error)
+
+	// Error logs a message at the error level.
+	Error(id uint32, msg string) (err error)
+
+	// Close closes the system log writer.
+	Close() (err error)
+}
+
 // systemLogger is the implementation of the [SystemLogger] interface for
 // Windows.
 type systemLogger struct {
-	writer *eventlog.Log
+	writer eventlogWriter
 }
 
 // newSystemLogger returns a Windows-specific system logger.