From e951dbd6cd30bf0a1b30a97c5e0506be2d3f06e5 Mon Sep 17 00:00:00 2001 From: Sam Catlow Date: Mon, 26 Oct 2026 00:25:37 +1100 Subject: [PATCH] fix(extension): log go-plugin output through the service slog logger --- internal/app/archied/forge_extensions.go | 4 +- .../app/archiemessaging/extension_channels.go | 4 +- internal/infrastructure/extension/hclog.go | 119 ++++++++++++++++++ internal/infrastructure/extension/host.go | 5 +- .../infrastructure/secretengine/runner.go | 6 +- .../secretengine/runner_test.go | 5 +- 6 files changed, 128 insertions(+), 15 deletions(-) create mode 100644 internal/infrastructure/extension/hclog.go diff --git a/internal/app/archied/forge_extensions.go b/internal/app/archied/forge_extensions.go index d2a9a330b..d5d072c19 100644 --- a/internal/app/archied/forge_extensions.go +++ b/internal/app/archied/forge_extensions.go @@ -8,8 +8,6 @@ import ( "slices" "sync" - "github.com/hashicorp/go-hclog" - "github.com/samcharles93/archie-core/internal/domain/storepkg" "github.com/samcharles93/archie-core/internal/forge" "github.com/samcharles93/archie-core/internal/infrastructure/configuration" @@ -52,7 +50,7 @@ func newForgeExtensions(source extension.Source, log *slog.Logger) *forgeExtensi return nil } return &forgeExtensions{ - host: extension.NewHost(hclog.New(&hclog.LoggerOptions{Name: "extension", Level: hclog.Warn})), + host: extension.NewHost(log), source: source, cacheDir: filepath.Join(cache, "extensions", "forge"), log: log, diff --git a/internal/app/archiemessaging/extension_channels.go b/internal/app/archiemessaging/extension_channels.go index ec81fd740..fefb7c539 100644 --- a/internal/app/archiemessaging/extension_channels.go +++ b/internal/app/archiemessaging/extension_channels.go @@ -8,8 +8,6 @@ import ( "slices" "strings" - "github.com/hashicorp/go-hclog" - "github.com/samcharles93/archie-core/internal/app/servicekit" "github.com/samcharles93/archie-core/internal/channels" "github.com/samcharles93/archie-core/internal/domain/storepkg" @@ -42,7 +40,7 @@ func openExtensionChannels(ctx context.Context, source extension.Source, secrets log.WarnContext(ctx, "channel extensions unavailable: installed packages", "err", err) return nil } - host := extension.NewHost(hclog.New(&hclog.LoggerOptions{Name: "extension", Level: hclog.Warn})) + host := extension.NewHost(log) var instances []*channelInstance for _, pkg := range installed { setting, ok := settings[pkg.Name] diff --git a/internal/infrastructure/extension/hclog.go b/internal/infrastructure/extension/hclog.go new file mode 100644 index 000000000..5385aa025 --- /dev/null +++ b/internal/infrastructure/extension/hclog.go @@ -0,0 +1,119 @@ +package extension + +import ( + "context" + "io" + "log" + "log/slog" + "strings" + + "github.com/hashicorp/go-hclog" +) + +// slogger adapts a slog.Logger to the hclog.Logger go-plugin requires, so +// extension lifecycle and plugin output land in the service's own log at its +// configured level. +type slogger struct { + log *slog.Logger + name string + args []any +} + +var _ hclog.Logger = slogger{} + +func newSlogger(log *slog.Logger) hclog.Logger { return slogger{log: log} } + +// levels maps hclog levels to slog; hclog's Trace sits below slog's Debug. +func level(l hclog.Level) slog.Level { + switch l { + case hclog.Trace: + return slog.LevelDebug - 4 + case hclog.Debug: + return slog.LevelDebug + case hclog.Warn: + return slog.LevelWarn + case hclog.Error: + return slog.LevelError + default: + return slog.LevelInfo + } +} + +func (s slogger) Log(l hclog.Level, msg string, args ...any) { + if s.name != "" { + args = append(args, "extension", s.name) + } + s.log.Log(context.Background(), level(l), msg, args...) +} + +func (s slogger) Trace(msg string, args ...any) { s.Log(hclog.Trace, msg, args...) } +func (s slogger) Debug(msg string, args ...any) { s.Log(hclog.Debug, msg, args...) } +func (s slogger) Info(msg string, args ...any) { s.Log(hclog.Info, msg, args...) } +func (s slogger) Warn(msg string, args ...any) { s.Log(hclog.Warn, msg, args...) } +func (s slogger) Error(msg string, args ...any) { s.Log(hclog.Error, msg, args...) } + +func (s slogger) enabled(l hclog.Level) bool { + return s.log.Enabled(context.Background(), level(l)) +} + +func (s slogger) IsTrace() bool { return s.enabled(hclog.Trace) } +func (s slogger) IsDebug() bool { return s.enabled(hclog.Debug) } +func (s slogger) IsInfo() bool { return s.enabled(hclog.Info) } +func (s slogger) IsWarn() bool { return s.enabled(hclog.Warn) } +func (s slogger) IsError() bool { return s.enabled(hclog.Error) } + +func (s slogger) ImpliedArgs() []any { return s.args } + +func (s slogger) With(args ...any) hclog.Logger { + s.log = s.log.With(args...) + s.args = append(append([]any(nil), s.args...), args...) + return s +} + +func (s slogger) Name() string { return s.name } + +func (s slogger) Named(name string) hclog.Logger { + if s.name != "" { + name = s.name + "." + name + } + return s.ResetNamed(name) +} + +func (s slogger) ResetNamed(name string) hclog.Logger { + s.name = name + return s +} + +// SetLevel is a no-op: the service's [log] level decides. +func (slogger) SetLevel(hclog.Level) {} + +func (s slogger) GetLevel() hclog.Level { + for _, l := range []hclog.Level{hclog.Trace, hclog.Debug, hclog.Info, hclog.Warn} { + if s.enabled(l) { + return l + } + } + return hclog.Error +} + +func (s slogger) StandardLogger(opts *hclog.StandardLoggerOptions) *log.Logger { + return log.New(s.StandardWriter(opts), "", 0) +} + +func (s slogger) StandardWriter(opts *hclog.StandardLoggerOptions) io.Writer { + l := hclog.Info + if opts != nil && opts.ForceLevel != hclog.NoLevel { + l = opts.ForceLevel + } + return lineWriter{s: s, level: l} +} + +type lineWriter struct { + s slogger + level hclog.Level +} + +func (w lineWriter) Write(p []byte) (int, error) { + w.s.Log(w.level, strings.TrimRight(string(p), "\n")) + return len(p), nil +} diff --git a/internal/infrastructure/extension/host.go b/internal/infrastructure/extension/host.go index 82a706bbd..4ceca14c1 100644 --- a/internal/infrastructure/extension/host.go +++ b/internal/infrastructure/extension/host.go @@ -10,6 +10,7 @@ import ( "errors" "fmt" "io" + "log/slog" "os" "os/exec" "sync" @@ -84,8 +85,8 @@ func command(ctx context.Context, binary *os.File, egress []string) (*exec.Cmd, } // NewHost returns a Host that reports plugin lifecycle problems to log. -func NewHost(log hclog.Logger) *Host { - return &Host{log: log, procs: make(map[string]*proc)} +func NewHost(log *slog.Logger) *Host { + return &Host{log: newSlogger(log), procs: make(map[string]*proc)} } // Start launches spec serving surface and returns the dispensed client. An diff --git a/internal/infrastructure/secretengine/runner.go b/internal/infrastructure/secretengine/runner.go index 5ca4643f1..b33830765 100644 --- a/internal/infrastructure/secretengine/runner.go +++ b/internal/infrastructure/secretengine/runner.go @@ -13,8 +13,6 @@ import ( "sync" "time" - "github.com/hashicorp/go-hclog" - "github.com/samcharles93/archie-core/internal/domain/applystatus" "github.com/samcharles93/archie-core/internal/domain/storepkg" "github.com/samcharles93/archie-core/internal/infrastructure/configuration" @@ -199,9 +197,9 @@ func Supervise(ctx context.Context, registry *secret.Registry, source Source, pr cache, err := configuration.DefaultCacheDir() if err != nil { log.WarnContext(ctx, "secret engines unavailable: no cache directory", "err", err) - return &Runner{host: extension.NewHost(hclog.NewNullLogger())} + return &Runner{host: extension.NewHost(slog.New(slog.DiscardHandler))} } - host := extension.NewHost(hclog.New(&hclog.LoggerOptions{Name: "extension", Level: hclog.Warn})) + host := extension.NewHost(log) runner := NewRunner(host, registry, source, filepath.Join(cache, "extensions", process), log) runner.ReportTo(report) if err := runner.Sync(ctx); err != nil { diff --git a/internal/infrastructure/secretengine/runner_test.go b/internal/infrastructure/secretengine/runner_test.go index 117c1342e..a5d658e6d 100644 --- a/internal/infrastructure/secretengine/runner_test.go +++ b/internal/infrastructure/secretengine/runner_test.go @@ -18,7 +18,6 @@ import ( "testing" "time" - "github.com/hashicorp/go-hclog" goplugin "github.com/hashicorp/go-plugin" "google.golang.org/grpc/codes" "google.golang.org/grpc/status" @@ -175,7 +174,7 @@ func TestHostLaunch(t *testing.T) { } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { - host := extension.NewHost(hclog.NewNullLogger()) + host := extension.NewHost(slog.New(slog.DiscardHandler)) t.Cleanup(host.Close) spec := extension.Spec{Name: "echo", Path: os.Args[0], SHA256: tt.sha, Env: []string{"ARCHIE_TEST_PASSED"}, Egress: []string{accepted, loopback}} if tt.open { @@ -256,7 +255,7 @@ func TestRunnerRunsOnlyWhatIsAcceptedAndEnabled(t *testing.T) { Layer: layerOf(t, "bin/echo", binary), }} registry := secret.NewRegistry() - host := extension.NewHost(hclog.NewNullLogger()) + host := extension.NewHost(slog.New(slog.DiscardHandler)) runner := NewRunner(host, registry, Source{Query: source, Packages: source}, t.TempDir(), slog.New(slog.DiscardHandler)) t.Cleanup(runner.Close) ctx := context.Background()