From f09848204fa5283d21ea43e262ee41aa578e1808 Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Mon, 26 Aug 2024 10:15:24 +0200 Subject: Merging upstream version 1.47.0. Signed-off-by: Daniel Baumann --- src/go/logger/default.go | 30 ++++++++++++++ src/go/logger/handler.go | 90 ++++++++++++++++++++++++++++++++++++++++++ src/go/logger/journal_linux.go | 33 ++++++++++++++++ src/go/logger/journal_stub.go | 9 +++++ src/go/logger/level.go | 54 +++++++++++++++++++++++++ src/go/logger/logger.go | 80 +++++++++++++++++++++++++++++++++++++ src/go/logger/logger_test.go | 21 ++++++++++ 7 files changed, 317 insertions(+) create mode 100644 src/go/logger/default.go create mode 100644 src/go/logger/handler.go create mode 100644 src/go/logger/journal_linux.go create mode 100644 src/go/logger/journal_stub.go create mode 100644 src/go/logger/level.go create mode 100644 src/go/logger/logger.go create mode 100644 src/go/logger/logger_test.go (limited to 'src/go/logger') diff --git a/src/go/logger/default.go b/src/go/logger/default.go new file mode 100644 index 000000000..c8bfb4d42 --- /dev/null +++ b/src/go/logger/default.go @@ -0,0 +1,30 @@ +// SPDX-License-Identifier: GPL-3.0-or-later + +package logger + +import ( + "log/slog" + "os" + + "github.com/mattn/go-isatty" +) + +func newDefaultLogger() *Logger { + if isatty.IsTerminal(os.Stderr.Fd()) { + // skip 2 slog pkg calls, 3 this pkg calls + return &Logger{sl: slog.New(withCallDepth(5, newTerminalHandler()))} + } + return &Logger{sl: slog.New(newTextHandler()).With(pluginAttr)} +} + +var defaultLogger = newDefaultLogger() + +func Error(a ...any) { defaultLogger.Error(a...) } +func Warning(a ...any) { defaultLogger.Warning(a...) } +func Info(a ...any) { defaultLogger.Info(a...) } +func Debug(a ...any) { defaultLogger.Debug(a...) } +func Errorf(format string, a ...any) { defaultLogger.Errorf(format, a...) } +func Warningf(format string, a ...any) { defaultLogger.Warningf(format, a...) } +func Infof(format string, a ...any) { defaultLogger.Infof(format, a...) } +func Debugf(format string, a ...any) { defaultLogger.Debugf(format, a...) } +func With(args ...any) *Logger { return defaultLogger.With(args...) } diff --git a/src/go/logger/handler.go b/src/go/logger/handler.go new file mode 100644 index 000000000..40282ead6 --- /dev/null +++ b/src/go/logger/handler.go @@ -0,0 +1,90 @@ +package logger + +import ( + "context" + "log/slog" + "os" + "runtime" + "strings" + + "github.com/lmittmann/tint" +) + +func newTextHandler() slog.Handler { + return slog.NewTextHandler(os.Stderr, &slog.HandlerOptions{ + Level: Level.lvl, + ReplaceAttr: func(groups []string, a slog.Attr) slog.Attr { + switch a.Key { + case slog.TimeKey: + if isJournal { + return slog.Attr{} + } + case slog.LevelKey: + lvl := a.Value.Any().(slog.Level) + s, ok := customLevels[lvl] + if !ok { + s = lvl.String() + } + return slog.String(a.Key, strings.ToLower(s)) + } + return a + }, + }) +} + +func newTerminalHandler() slog.Handler { + return tint.NewHandler(os.Stderr, &tint.Options{ + AddSource: true, + Level: Level.lvl, + ReplaceAttr: func(groups []string, a slog.Attr) slog.Attr { + switch a.Key { + case slog.TimeKey: + return slog.Attr{} + case slog.SourceKey: + if !Level.Enabled(slog.LevelDebug) { + return slog.Attr{} + } + case slog.LevelKey: + lvl := a.Value.Any().(slog.Level) + if s, ok := customLevelsTerm[lvl]; ok { + return slog.String(a.Key, s) + } + } + return a + }, + }) +} + +func withCallDepth(depth int, sh slog.Handler) slog.Handler { + if v, ok := sh.(*callDepthHandler); ok { + sh = v.sh + } + return &callDepthHandler{depth: depth, sh: sh} +} + +type callDepthHandler struct { + depth int + sh slog.Handler +} + +func (h *callDepthHandler) Enabled(ctx context.Context, level slog.Level) bool { + return h.sh.Enabled(ctx, level) +} + +func (h *callDepthHandler) WithAttrs(attrs []slog.Attr) slog.Handler { + return withCallDepth(h.depth, h.sh.WithAttrs(attrs)) +} + +func (h *callDepthHandler) WithGroup(name string) slog.Handler { + return withCallDepth(h.depth, h.sh.WithGroup(name)) +} + +func (h *callDepthHandler) Handle(ctx context.Context, r slog.Record) error { + // https://pkg.go.dev/log/slog#example-package-Wrapping + var pcs [1]uintptr + // skip Callers and this function + runtime.Callers(h.depth+2, pcs[:]) + r.PC = pcs[0] + + return h.sh.Handle(ctx, r) +} diff --git a/src/go/logger/journal_linux.go b/src/go/logger/journal_linux.go new file mode 100644 index 000000000..00f335075 --- /dev/null +++ b/src/go/logger/journal_linux.go @@ -0,0 +1,33 @@ +// SPDX-License-Identifier: GPL-3.0-or-later + +//go:build linux + +package logger + +import ( + "os" + "strconv" + "strings" + "syscall" +) + +func isStderrConnectedToJournal() bool { + stream := os.Getenv("JOURNAL_STREAM") + if stream == "" { + return false + } + + idx := strings.IndexByte(stream, ':') + if idx <= 0 { + return false + } + + dev, ino := stream[:idx], stream[idx+1:] + + var stat syscall.Stat_t + if err := syscall.Fstat(int(os.Stderr.Fd()), &stat); err != nil { + return false + } + + return dev == strconv.Itoa(int(stat.Dev)) && ino == strconv.FormatUint(stat.Ino, 10) +} diff --git a/src/go/logger/journal_stub.go b/src/go/logger/journal_stub.go new file mode 100644 index 000000000..6726a02d8 --- /dev/null +++ b/src/go/logger/journal_stub.go @@ -0,0 +1,9 @@ +// SPDX-License-Identifier: GPL-3.0-or-later + +//go:build !linux + +package logger + +func isStderrConnectedToJournal() bool { + return false +} diff --git a/src/go/logger/level.go b/src/go/logger/level.go new file mode 100644 index 000000000..97dccb205 --- /dev/null +++ b/src/go/logger/level.go @@ -0,0 +1,54 @@ +// SPDX-License-Identifier: GPL-3.0-or-later + +package logger + +import ( + "log/slog" + "strings" +) + +const ( + levelNotice = slog.Level(2) + levelDisable = slog.Level(99) +) + +var ( + customLevels = map[slog.Leveler]string{ + levelNotice: "NOTICE", + } + customLevelsTerm = map[slog.Leveler]string{ + levelNotice: "\u001B[34m" + "NTC" + "\u001B[0m", + } +) + +var Level = &level{lvl: &slog.LevelVar{}} + +type level struct { + lvl *slog.LevelVar +} + +func (l *level) Enabled(level slog.Level) bool { + return level >= l.lvl.Level() +} + +func (l *level) Set(level slog.Level) { + l.lvl.Set(level) +} + +func (l *level) SetByName(level string) { + // https://github.com/netdata/netdata/tree/master/src/libnetdata/log#log-levels + switch strings.ToLower(level) { + case "err", "error": + l.lvl.Set(slog.LevelError) + case "warn", "warning": + l.lvl.Set(slog.LevelWarn) + case "notice": + l.lvl.Set(levelNotice) + case "info": + l.lvl.Set(slog.LevelInfo) + case "debug": + l.lvl.Set(slog.LevelDebug) + case "emergency", "alert", "critical": + l.lvl.Set(levelDisable) + } +} diff --git a/src/go/logger/logger.go b/src/go/logger/logger.go new file mode 100644 index 000000000..b32a00cc0 --- /dev/null +++ b/src/go/logger/logger.go @@ -0,0 +1,80 @@ +// SPDX-License-Identifier: GPL-3.0-or-later + +package logger + +import ( + "context" + "fmt" + "log/slog" + "os" + "sync/atomic" + + "github.com/netdata/netdata/go/plugins/pkg/executable" + + "github.com/mattn/go-isatty" +) + +var isTerm = isatty.IsTerminal(os.Stderr.Fd()) + +var isJournal = isStderrConnectedToJournal() + +var pluginAttr = slog.String("plugin", executable.Name) + +func New() *Logger { + if isTerm { + // skip 2 slog pkg calls, 2 this pkg calls + return &Logger{sl: slog.New(withCallDepth(4, newTerminalHandler()))} + } + return &Logger{sl: slog.New(newTextHandler()).With(pluginAttr)} +} + +type Logger struct { + muted atomic.Bool + sl *slog.Logger +} + +func (l *Logger) Error(a ...any) { l.log(slog.LevelError, fmt.Sprint(a...)) } +func (l *Logger) Warning(a ...any) { l.log(slog.LevelWarn, fmt.Sprint(a...)) } +func (l *Logger) Notice(a ...any) { l.log(levelNotice, fmt.Sprint(a...)) } +func (l *Logger) Info(a ...any) { l.log(slog.LevelInfo, fmt.Sprint(a...)) } +func (l *Logger) Debug(a ...any) { l.log(slog.LevelDebug, fmt.Sprint(a...)) } +func (l *Logger) Errorf(format string, a ...any) { l.log(slog.LevelError, fmt.Sprintf(format, a...)) } +func (l *Logger) Warningf(format string, a ...any) { l.log(slog.LevelWarn, fmt.Sprintf(format, a...)) } +func (l *Logger) Noticef(format string, a ...any) { l.log(levelNotice, fmt.Sprintf(format, a...)) } +func (l *Logger) Infof(format string, a ...any) { l.log(slog.LevelInfo, fmt.Sprintf(format, a...)) } +func (l *Logger) Debugf(format string, a ...any) { l.log(slog.LevelDebug, fmt.Sprintf(format, a...)) } +func (l *Logger) Mute() { l.mute(true) } +func (l *Logger) Unmute() { l.mute(false) } + +func (l *Logger) With(args ...any) *Logger { + if l.isNil() { + return &Logger{sl: New().sl.With(args...)} + } + + ll := &Logger{sl: l.sl.With(args...)} + ll.muted.Store(l.muted.Load()) + + return ll +} + +func (l *Logger) log(level slog.Level, msg string) { + if l.isNil() { + nilLogger.sl.Log(context.Background(), level, msg) + return + } + + if !l.muted.Load() { + l.sl.Log(context.Background(), level, msg) + } +} + +func (l *Logger) mute(v bool) { + if l.isNil() || isTerm && Level.Enabled(slog.LevelDebug) { + return + } + l.muted.Store(v) +} + +func (l *Logger) isNil() bool { return l == nil || l.sl == nil } + +var nilLogger = New() diff --git a/src/go/logger/logger_test.go b/src/go/logger/logger_test.go new file mode 100644 index 000000000..df7049d0a --- /dev/null +++ b/src/go/logger/logger_test.go @@ -0,0 +1,21 @@ +package logger + +import ( + "testing" + + "github.com/stretchr/testify/assert" +) + +func TestNew(t *testing.T) { + tests := map[string]*Logger{ + "default logger": New(), + "nil logger": nil, + } + + for name, logger := range tests { + t.Run(name, func(t *testing.T) { + f := func() { logger.Infof("test %s", "test") } + assert.NotPanics(t, f) + }) + } +} -- cgit v1.2.3