feat(logr): init

Author: morlay

logr/level.go

@@ -0,0 +1,68 @@
+package logr
+
+import (
+	"fmt"
+	"strings"
+)
+
+// Level type
+type Level uint32
+
+const (
+	// ErrorLevel level. Logs. Used for errors that should definitely be noted.
+	// Commonly used for hooks to send errors to an error tracking service.
+	ErrorLevel Level = iota
+	// WarnLevel level. Non-critical entries that deserve eyes.
+	WarnLevel
+	// InfoLevel level. General operational entries about what's going on inside the
+	// application.
+	InfoLevel
+	// DebugLevel level. Usually only enabled when debugging. Very verbose logging.
+	DebugLevel
+)
+
+func (level Level) String() string {
+	if b, err := level.MarshalText(); err == nil {
+		return string(b)
+	} else {
+		return "unknown"
+	}
+}
+
+// ParseLevel takes a string level and returns the Logrus log level constant.
+func ParseLevel(lvl string) (Level, error) {
+	switch strings.ToLower(lvl) {
+	case "error":
+		return ErrorLevel, nil
+	case "warn", "warning":
+		return WarnLevel, nil
+	case "info":
+		return InfoLevel, nil
+	case "debug":
+		return DebugLevel, nil
+	}
+	return 0, fmt.Errorf("not a valid logrus Level: %q", lvl)
+}
+
+func (level *Level) UnmarshalText(text []byte) error {
+	l, err := ParseLevel(string(text))
+	if err != nil {
+		return err
+	}
+	*level = l
+	return nil
+}
+
+func (level Level) MarshalText() ([]byte, error) {
+	switch level {
+	case DebugLevel:
+		return []byte("debug"), nil
+	case InfoLevel:
+		return []byte("info"), nil
+	case WarnLevel:
+		return []byte("warning"), nil
+	case ErrorLevel:
+		return []byte("error"), nil
+	}
+	return nil, fmt.Errorf("not a valid logrus level %d", level)
+}

logr/logr.go

@@ -0,0 +1,30 @@
+package logr
+
+import (
+	"context"
+)
+
+type Logger interface {
+	// Start start span for tracing
+	//
+	// 	ctx log = logr.Start(ctx, "SpanName")
+	// 	defer log.End()
+	//
+	Start(ctx context.Context, name string, keyAndValues ...any) (context.Context, Logger)
+	// End end span
+	End()
+
+	// WithValues key value pairs
+	WithValues(keyAndValues ...any) Logger
+
+	// Debug debug info
+	Debug(msg string, args ...any)
+	// Info info
+	Info(msg string, args ...any)
+
+	// Warn
+	Warn(err error)
+
+	// Error
+	Error(err error)
+}

logr/logr_ctx.go

@@ -0,0 +1,29 @@
+package logr
+
+import "context"
+
+type contextKey struct{}
+
+func WithLogger(ctx context.Context, logger Logger) context.Context {
+	return context.WithValue(ctx, contextKey{}, logger)
+}
+
+func FromContext(ctx context.Context) Logger {
+	if v, ok := ctx.Value(contextKey{}).(Logger); ok {
+		return v
+	}
+	return Discard()
+}
+
+func Start(ctx context.Context, name string, keyAndValues ...any) (context.Context, Logger) {
+	return FromContext(ctx).Start(ctx, name, keyAndValues...)
+}
+
+func LoggerFromContext(ctx context.Context) (Logger, bool) {
+	v, ok := ctx.Value(contextKey{}).(Logger)
+	return v, ok
+}
+
+func LoggerInjectContext(ctx context.Context, logger Logger) context.Context {
+	return context.WithValue(ctx, contextKey{}, logger)
+}

logr/logr_discord.go

@@ -0,0 +1,32 @@
+package logr
+
+import "context"
+
+func Discard() Logger {
+	return &discardLogger{}
+}
+
+type discardLogger struct{}
+
+func (d *discardLogger) WithValues(keyAndValues ...any) Logger {
+	return d
+}
+
+func (d *discardLogger) Start(ctx context.Context, name string, keyAndValues ...any) (context.Context, Logger) {
+	return ctx, d
+}
+
+func (discardLogger) End() {
+}
+
+func (discardLogger) Debug(format string, args ...any) {
+}
+
+func (discardLogger) Info(format string, args ...any) {
+}
+
+func (discardLogger) Warn(err error) {
+}
+
+func (discardLogger) Error(err error) {
+}

logr/logr_test.go

@@ -0,0 +1,30 @@
+package logr_test
+
+import (
+	"context"
+	stdslog "log/slog"
+
+	"github.com/octohelm/x/logr"
+	"github.com/octohelm/x/logr/slog"
+)
+
+func ExampleLogger() {
+	ctx := logr.WithLogger(context.Background(), slog.Logger(slog.Default()))
+
+	log := logr.FromContext(ctx).WithValues("k", "k")
+
+	log.Debug("test %d", 1)
+	log.Info("test %d", 1)
+	// Output:
+}
+
+func ExampleLogger_Start() {
+	ctx := logr.WithLogger(context.Background(), slog.Logger(slog.Default(slog.EnableLevel(stdslog.LevelDebug))))
+
+	_, log := logr.Start(ctx, "span", "k", "k")
+	defer log.End()
+
+	log.Debug("test %d", 1)
+	log.Info("test %d", 1)
+	// Output:
+}

logr/slog/handler.go

@@ -0,0 +1,41 @@
+package slog
+
+import (
+	"context"
+	"log/slog"
+)
+
+func EnableLevel(lvl slog.Level) func(h *handler) {
+	return func(h *handler) {
+		h.lvl = lvl
+	}
+}
+
+func Default(optFns ...func(h *handler)) *slog.Logger {
+	h := &handler{h: slog.Default().Handler()}
+	for _, fn := range optFns {
+		fn(h)
+	}
+	return slog.New(h)
+}
+
+type handler struct {
+	h   slog.Handler
+	lvl slog.Level
+}
+
+func (h *handler) Handle(ctx context.Context, r slog.Record) error {
+	return h.h.Handle(ctx, r)
+}
+
+func (h *handler) WithAttrs(attrs []slog.Attr) slog.Handler {
+	return &handler{h: h.h.WithAttrs(attrs)}
+}
+
+func (h *handler) WithGroup(name string) slog.Handler {
+	return &handler{h: h.h.WithGroup(name)}
+}
+
+func (h *handler) Enabled(ctx context.Context, l slog.Level) bool {
+	return l >= h.lvl
+}

logr/slog/logger.go

@@ -0,0 +1,75 @@
+package slog
+
+import (
+	"context"
+	"fmt"
+	"log/slog"
+	"strings"
+
+	"github.com/octohelm/x/logr"
+)
+
+func Logger(l *slog.Logger) logr.Logger {
+	return &logger{slog: l, ctx: context.Background()}
+}
+
+type logger struct {
+	ctx   context.Context
+	slog  *slog.Logger
+	spans []string
+}
+
+func (d *logger) WithValues(keyAndValues ...any) logr.Logger {
+	return &logger{
+		spans: d.spans,
+		slog:  d.slog.With(keyAndValues...),
+	}
+}
+
+func (d *logger) Start(ctx context.Context, name string, keyAndValues ...any) (context.Context, logr.Logger) {
+	spans := append(d.spans, name)
+
+	if len(keyAndValues) == 0 {
+		return ctx, &logger{
+			ctx:   ctx,
+			spans: spans,
+			slog:  d.slog.WithGroup(strings.Join(spans, "/")),
+		}
+	}
+
+	return ctx, &logger{
+		spans: spans,
+		slog:  d.slog.WithGroup(strings.Join(spans, "/")).With(keyAndValues...),
+	}
+}
+
+func (d *logger) End() {
+	if len(d.spans) != 0 {
+		d.spans = d.spans[0 : len(d.spans)-1]
+	}
+}
+
+func (d *logger) Debug(format string, args ...any) {
+	if !d.slog.Enabled(d.ctx, slog.LevelDebug) {
+		return
+	}
+	d.slog.Log(d.ctx, slog.LevelDebug, fmt.Sprintf(format, args...))
+}
+
+func (d *logger) Info(format string, args ...any) {
+	if !d.slog.Enabled(d.ctx, slog.LevelInfo) {
+		return
+	}
+	d.slog.Log(d.ctx, slog.LevelInfo, fmt.Sprintf(format, args...))
+}
+
+func (d *logger) Warn(err error) {
+	if !d.slog.Enabled(d.ctx, slog.LevelWarn) {
+		return
+	}
+	d.slog.Log(d.ctx, slog.LevelWarn, err.Error(), slog.Any("err", err))
+}
+
+func (d *logger) Error(err error) {
+	d.slog.Error("", slog.Any("error", err))
+}