GitRoot

  1// SPDX-FileCopyrightText: 2025 Romain Maneschi <romain@gitroot.dev>
  2//
  3// SPDX-License-Identifier: EUPL-1.2
  4
  5package logger
  6
  7import (
  8	"context"
  9	"crypto/rand"
 10	"encoding/hex"
 11	"fmt"
 12	"log/slog"
 13	"os"
 14)
 15
 16const (
 17	FS_LOGGER_NAME          LoggerName = "GitRootFs"
 18	SSH_SERVER_LOGGER_NAME  LoggerName = "ServerSsh"
 19	HTTP_SERVER_LOGGER_NAME LoggerName = "ServerHttp"
 20	FS_STORER_LOGGER_NAME   LoggerName = "GitRootFsStorer"
 21	FS_PLUGIN               LoggerName = "FsPlugin"
 22	REPOSITORY_MANAGER      LoggerName = "RepositoryManager"
 23	PLUGIN_MANAGER          LoggerName = "PluginManager"
 24	BACKGROUND_MANAGER      LoggerName = "BackgroundManager"
 25	WASM                    LoggerName = "Wasm"
 26	EXEC                    LoggerName = "Exec"
 27)
 28
 29var levelByName = map[LoggerName]slog.Level{
 30	FS_LOGGER_NAME:          slog.LevelWarn,
 31	SSH_SERVER_LOGGER_NAME:  slog.LevelWarn,
 32	HTTP_SERVER_LOGGER_NAME: slog.LevelWarn,
 33	FS_STORER_LOGGER_NAME:   slog.LevelWarn,
 34	FS_PLUGIN:               slog.LevelWarn,
 35	REPOSITORY_MANAGER:      slog.LevelWarn,
 36	PLUGIN_MANAGER:          slog.LevelWarn,
 37	BACKGROUND_MANAGER:      slog.LevelWarn,
 38	WASM:                    slog.LevelWarn,
 39	EXEC:                    slog.LevelWarn,
 40}
 41
 42type LoggerName string
 43
 44type Logger struct {
 45	c     context.Context
 46	l     *slog.Logger
 47	level slog.Level
 48	name  LoggerName
 49}
 50
 51type LoggerPair struct {
 52	key   string
 53	value any
 54}
 55
 56func NewLogger(name LoggerName) *Logger {
 57	return NewLoggerCtx(name, context.Background())
 58}
 59
 60func NewLoggerCtx(name LoggerName, ctx context.Context) *Logger {
 61	var level = slog.LevelWarn
 62	if l, ok := levelByName[name]; ok {
 63		level = l
 64	}
 65	log := slog.New(slog.NewTextHandler(os.Stdout, &slog.HandlerOptions{Level: level}))
 66	l := &Logger{
 67		c:     ctx,
 68		l:     log,
 69		level: level,
 70		name:  name,
 71	}
 72	return l.With("name", string(name))
 73}
 74
 75func GenerateRandomID() string {
 76	bytes := make([]byte, 16)
 77	if _, err := rand.Read(bytes); err != nil {
 78		panic(err)
 79	}
 80	return hex.EncodeToString(bytes)
 81}
 82
 83func NewLoggerPair(key string, value any) LoggerPair {
 84	return LoggerPair{
 85		key:   key,
 86		value: value,
 87	}
 88}
 89
 90func (l *Logger) NewSubLogger(name string) *Logger {
 91	return l.NewSubLoggerCtx(name, l.c)
 92}
 93
 94func (l *Logger) NewSubLoggerCtx(name string, ctx context.Context) *Logger {
 95	subName := fmt.Sprintf("%s::%s", l.name, name)
 96	log := slog.New(slog.NewTextHandler(os.Stdout, &slog.HandlerOptions{Level: l.level}))
 97	sub := &Logger{
 98		c:     ctx,
 99		l:     log,
100		level: l.level,
101		name:  LoggerName(subName),
102	}
103	return sub.With("name", subName)
104}
105
106func (l *Logger) With(key string, value string) *Logger {
107	l.l = slog.New(l.l.Handler().WithAttrs([]slog.Attr{{Key: key, Value: slog.StringValue(value)}}))
108	return l
109}
110
111func (l *Logger) Debug(msg string, attr ...LoggerPair) *Logger {
112	attrs := make([]slog.Attr, len(attr))
113	for i, a := range attr {
114		attrs[i] = slog.Attr{Key: a.key, Value: slog.AnyValue(a.value)}
115	}
116	if caller, ok := extractCaller(l.c); ok {
117		attrs = append(attrs, slog.Attr{Key: "caller", Value: slog.StringValue(caller)})
118	}
119	l.l.LogAttrs(l.c, slog.LevelDebug, msg, attrs...)
120	return l
121}
122
123func (l *Logger) Info(msg string, attr ...LoggerPair) *Logger {
124	attrs := make([]slog.Attr, len(attr))
125	for i, a := range attr {
126		attrs[i] = slog.Attr{Key: a.key, Value: slog.AnyValue(a.value)}
127	}
128	if caller, ok := extractCaller(l.c); ok {
129		attrs = append(attrs, slog.Attr{Key: "caller", Value: slog.StringValue(caller)})
130	}
131	l.l.LogAttrs(l.c, slog.LevelInfo, msg, attrs...)
132	return l
133}
134
135func (l *Logger) Warn(msg string, attr ...LoggerPair) *Logger {
136	attrs := make([]slog.Attr, len(attr))
137	for i, a := range attr {
138		attrs[i] = slog.Attr{Key: a.key, Value: slog.AnyValue(a.value)}
139	}
140	l.l.LogAttrs(l.c, slog.LevelWarn, msg, attrs...)
141	return l
142}
143
144func (l *Logger) Error(msg string, err error, attr ...LoggerPair) *Logger {
145	attrs := make([]slog.Attr, len(attr)+1)
146	attrs[0] = slog.Attr{Key: "err", Value: slog.AnyValue(err)}
147	for i, a := range attr {
148		attrs[i+1] = slog.Attr{Key: a.key, Value: slog.AnyValue(a.value)}
149	}
150	l.l.LogAttrs(l.c, slog.LevelError, msg, attrs...)
151	return l
152}
153
154func (l *Logger) LogCaller(ctx context.Context, msg string) *Logger {
155	attr := slog.Attr{Key: "caller", Value: slog.StringValue("NO")}
156	if caller, ok := extractCaller(ctx); ok {
157		attr = slog.Attr{Key: "caller", Value: slog.StringValue(caller)}
158	}
159	l.l.LogAttrs(l.c, slog.LevelInfo, msg, attr)
160	return l
161}