120 lines
3.1 KiB
Go
120 lines
3.1 KiB
Go
package host
|
|
|
|
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
|
|
}
|