From c443be664800a2ff24d7c7cd64e95b233aa3ec71 Mon Sep 17 00:00:00 2001 From: Pat Downey Date: Fri, 31 Jul 2026 11:39:57 +0100 Subject: [PATCH] feat: add logadapter package for bridging zerolog to third-party loggers Third-party libraries (go-smtp, go-socks5, tcpproxy, and similar) each expect a logger satisfying a different ad hoc interface (io.Writer, Printf/Println, or Errorf). Adapter is a single type whose methods structurally satisfy all of them, so callers construct one zerolog.Logger with whatever fixed context they want and pass it wherever a foreign logger interface is required. Moved here from github.com/dioad/connect/sdk/logadapter since it has no connect-specific dependencies and dioad/cli is the shared utility module used across more of the org's repos. Co-Authored-By: Claude Sonnet 5 --- logadapter/logadapter.go | 60 +++++++++++++++++++++++++++++++++ logadapter/logadapter_test.go | 63 +++++++++++++++++++++++++++++++++++ 2 files changed, 123 insertions(+) create mode 100644 logadapter/logadapter.go create mode 100644 logadapter/logadapter_test.go diff --git a/logadapter/logadapter.go b/logadapter/logadapter.go new file mode 100644 index 0000000..ba89bd1 --- /dev/null +++ b/logadapter/logadapter.go @@ -0,0 +1,60 @@ +// Package logadapter bridges a zerolog.Logger into the ad hoc Write, +// Printf/Println, and Errorf interfaces that third-party libraries expect +// from a logger (io.Writer, go-smtp's Logger, go-socks5's Logger, +// tcpproxy's Logger, and the standard library's *log.Logger). +// +// Construct an Adapter from a logger that already carries any fixed +// context (component, module, tunnel ID, etc.) via zerolog's With(); the +// Adapter itself adds no context beyond the level at which it logs. +package logadapter + +import ( + "fmt" + "strings" + + "github.com/rs/zerolog" +) + +// Adapter adapts a zerolog.Logger to the logging interfaces expected by +// third-party libraries. A single Adapter value satisfies io.Writer, the +// Printf/Println-style Logger interface used by go-smtp and tcpproxy, and +// the Errorf-style Logger interface used by go-socks5 — pick whichever +// method(s) the target interface requires. +// +// All methods log a single event at Level, with any trailing newline +// trimmed since callers typically pass pre-formatted lines. +type Adapter struct { + Logger zerolog.Logger + Level zerolog.Level +} + +// New returns an Adapter that logs to logger at level. +func New(logger zerolog.Logger, level zerolog.Level) Adapter { + return Adapter{Logger: logger, Level: level} +} + +func (a Adapter) log(msg string) { + a.Logger.WithLevel(a.Level).Msg(strings.TrimRight(msg, "\n")) +} + +// Write implements io.Writer. +func (a Adapter) Write(p []byte) (int, error) { + a.log(string(p)) + return len(p), nil +} + +// Printf implements the Printf half of the Logger interfaces used by +// go-smtp and tcpproxy. +func (a Adapter) Printf(format string, v ...any) { + a.log(fmt.Sprintf(format, v...)) +} + +// Println implements the Println half of go-smtp's Logger interface. +func (a Adapter) Println(v ...any) { + a.log(fmt.Sprintln(v...)) +} + +// Errorf implements go-socks5's Logger interface. +func (a Adapter) Errorf(format string, v ...any) { + a.log(fmt.Sprintf(format, v...)) +} diff --git a/logadapter/logadapter_test.go b/logadapter/logadapter_test.go new file mode 100644 index 0000000..465079d --- /dev/null +++ b/logadapter/logadapter_test.go @@ -0,0 +1,63 @@ +package logadapter_test + +import ( + "bytes" + "testing" + + "github.com/rs/zerolog" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" + + "github.com/dioad/cli/logadapter" +) + +func newAdapter(t *testing.T, level zerolog.Level) (logadapter.Adapter, *bytes.Buffer) { + t.Helper() + buf := &bytes.Buffer{} + logger := zerolog.New(buf) + return logadapter.New(logger, level), buf +} + +func TestAdapter_Write(t *testing.T) { + t.Parallel() + + a, buf := newAdapter(t, zerolog.DebugLevel) + + n, err := a.Write([]byte("dial failed\n")) + + require.NoError(t, err) + assert.Equal(t, len("dial failed\n"), n) + assert.Contains(t, buf.String(), `"message":"dial failed"`) + assert.Contains(t, buf.String(), `"level":"debug"`) +} + +func TestAdapter_Printf(t *testing.T) { + t.Parallel() + + a, buf := newAdapter(t, zerolog.ErrorLevel) + + a.Printf("no route matched %q", "example.com") + + assert.Contains(t, buf.String(), `"message":"no route matched \"example.com\""`) + assert.Contains(t, buf.String(), `"level":"error"`) +} + +func TestAdapter_Println(t *testing.T) { + t.Parallel() + + a, buf := newAdapter(t, zerolog.ErrorLevel) + + a.Println("dial error:", "connection refused") + + assert.Contains(t, buf.String(), `"message":"dial error: connection refused"`) +} + +func TestAdapter_Errorf(t *testing.T) { + t.Parallel() + + a, buf := newAdapter(t, zerolog.ErrorLevel) + + a.Errorf("socks command %s failed", "connect") + + assert.Contains(t, buf.String(), `"message":"socks command connect failed"`) +}