fix(nix): update vendorHash and vendor dir for new deps

2026-04-10 18:25:19 +02:00
parent da59d8f83b
commit 9dc664a3ba
2533 changed files with 1304328 additions and 2 deletions
@@ -0,0 +1,247 @@
+package zerolog
+
+import (
+	"context"
+	"log/slog"
+	"time"
+)
+
+// SlogHandler implements the slog.Handler interface using a zerolog.Logger
+// as the underlying log backend. This allows code that uses the standard
+// library's slog package to route log output through zerolog.
+type SlogHandler struct {
+	logger Logger
+	prefix string // group prefix for nested groups
+	attrs  []slog.Attr
+}
+
+// NewSlogHandler creates a new slog.Handler that writes log records to the
+// given zerolog.Logger. The handler maps slog levels to zerolog levels and
+// converts slog attributes to zerolog fields.
+func NewSlogHandler(logger Logger) *SlogHandler {
+	return &SlogHandler{logger: logger}
+}
+
+// Enabled reports whether the handler handles records at the given level.
+// It mirrors Logger.should's level and writer checks (without sampling).
+func (h *SlogHandler) Enabled(_ context.Context, level slog.Level) bool {
+	if h.logger.w == nil {
+		return false
+	}
+	zl := slogToZerologLevel(level)
+	if zl < GlobalLevel() {
+		return false
+	}
+	return zl >= h.logger.level
+}
+
+// Handle handles the Record. It converts the slog.Record into a zerolog event
+// and writes it using the underlying zerolog.Logger.
+func (h *SlogHandler) Handle(ctx context.Context, record slog.Record) error {
+	zlevel := slogToZerologLevel(record.Level)
+	event := h.logger.WithLevel(zlevel)
+	if event == nil {
+		return nil
+	}
+
+	// Propagate slog context to the zerolog event so that hooks
+	// relying on Event.GetCtx() (e.g. tracing) can access it.
+	if ctx != nil {
+		event = event.Ctx(ctx)
+	}
+
+	// Add pre-attached attrs from WithAttrs
+	for _, a := range h.attrs {
+		event = appendSlogAttr(event, a, h.prefix)
+	}
+
+	// Add attrs from the record itself
+	record.Attrs(func(a slog.Attr) bool {
+		event = appendSlogAttr(event, a, h.prefix)
+		return true
+	})
+
+	// Add timestamp from the slog record, but only if the logger doesn't
+	// already have a timestampHook (added via .With().Timestamp()) to
+	// avoid duplicate timestamp keys in the output.
+	if !record.Time.IsZero() && !h.hasTimestampHook() {
+		event.Time(TimestampFieldName, record.Time)
+	}
+
+	event.Msg(record.Message)
+	return nil
+}
+
+// hasTimestampHook reports whether the logger has a timestampHook installed,
+// which would cause duplicate timestamp fields if we also emit record.Time.
+func (h *SlogHandler) hasTimestampHook() bool {
+	for _, hook := range h.logger.hooks {
+		if _, ok := hook.(timestampHook); ok {
+			return true
+		}
+	}
+	return false
+}
+
+// WithAttrs returns a new Handler with the given attributes pre-attached.
+// These attributes will be included in every subsequent log record.
+func (h *SlogHandler) WithAttrs(attrs []slog.Attr) slog.Handler {
+	if len(attrs) == 0 {
+		return h
+	}
+	h2 := h.clone()
+	h2.attrs = append(h2.attrs, attrs...)
+	return h2
+}
+
+// WithGroup returns a new Handler with the given group name. All subsequent
+// attributes will be nested under this group name in the output.
+func (h *SlogHandler) WithGroup(name string) slog.Handler {
+	if name == "" {
+		return h
+	}
+	h2 := h.clone()
+	if h2.prefix != "" {
+		h2.prefix = h2.prefix + "." + name
+	} else {
+		h2.prefix = name
+	}
+	return h2
+}
+
+func (h *SlogHandler) clone() *SlogHandler {
+	h2 := &SlogHandler{
+		logger: h.logger,
+		prefix: h.prefix,
+	}
+	if len(h.attrs) > 0 {
+		h2.attrs = make([]slog.Attr, len(h.attrs))
+		copy(h2.attrs, h.attrs)
+	}
+	return h2
+}
+
+// slogToZerologLevel maps slog levels to zerolog levels.
+//
+// slog levels:  Debug=-4, Info=0, Warn=4, Error=8
+// zerolog levels: Trace=-1, Debug=0, Info=1, Warn=2, Error=3, Fatal=4, Panic=5
+func slogToZerologLevel(level slog.Level) Level {
+	switch {
+	case level < slog.LevelDebug:
+		return TraceLevel
+	case level < slog.LevelInfo:
+		return DebugLevel
+	case level < slog.LevelWarn:
+		return InfoLevel
+	case level < slog.LevelError:
+		return WarnLevel
+	default:
+		return ErrorLevel
+	}
+}
+
+// zerologToSlogLevel maps zerolog levels to slog levels.
+func zerologToSlogLevel(level Level) slog.Level {
+	switch level {
+	case TraceLevel:
+		return slog.LevelDebug - 4
+	case DebugLevel:
+		return slog.LevelDebug
+	case InfoLevel:
+		return slog.LevelInfo
+	case WarnLevel:
+		return slog.LevelWarn
+	case ErrorLevel:
+		return slog.LevelError
+	case FatalLevel:
+		return slog.LevelError + 4
+	case PanicLevel:
+		return slog.LevelError + 8
+	default:
+		return slog.LevelInfo
+	}
+}
+
+// joinPrefix concatenates a prefix and key with a dot separator.
+// It avoids allocations when either prefix or key is empty.
+func joinPrefix(prefix, key string) string {
+	if prefix == "" {
+		return key
+	}
+	if key == "" {
+		return prefix
+	}
+	return prefix + "." + key
+}
+
+// appendSlogAttr appends a single slog.Attr to the zerolog event, handling
+// type-specific encoding to avoid reflection where possible.
+func appendSlogAttr(event *Event, attr slog.Attr, prefix string) *Event {
+	if event == nil {
+		return event
+	}
+
+	// Resolve the attribute to handle LogValuer types.
+	// This handles slog.KindLogValuer implicitly by unwrapping
+	// any values that implement slog.LogValuer to their resolved form.
+	attr.Value = attr.Value.Resolve()
+
+	// For group kinds, handle grouping before key concatenation
+	if attr.Value.Kind() == slog.KindGroup {
+		attrs := attr.Value.Group()
+		if len(attrs) == 0 {
+			return event
+		}
+		groupPrefix := joinPrefix(prefix, attr.Key)
+		for _, ga := range attrs {
+			event = appendSlogAttr(event, ga, groupPrefix)
+		}
+		return event
+	}
+
+	// Skip empty keys for non-group attributes
+	if attr.Key == "" {
+		return event
+	}
+
+	key := joinPrefix(prefix, attr.Key)
+	val := attr.Value
+
+	switch val.Kind() {
+	case slog.KindString:
+		event = event.Str(key, val.String())
+	case slog.KindInt64:
+		event = event.Int64(key, val.Int64())
+	case slog.KindUint64:
+		event = event.Uint64(key, val.Uint64())
+	case slog.KindFloat64:
+		event = event.Float64(key, val.Float64())
+	case slog.KindBool:
+		event = event.Bool(key, val.Bool())
+	case slog.KindDuration:
+		event = event.Dur(key, val.Duration())
+	case slog.KindTime:
+		event = event.Time(key, val.Time())
+	case slog.KindAny:
+		v := val.Any()
+		switch cv := v.(type) {
+		case error:
+			event = event.AnErr(key, cv)
+		case time.Duration:
+			event = event.Dur(key, cv)
+		case time.Time:
+			event = event.Time(key, cv)
+		case []byte:
+			event = event.Bytes(key, cv)
+		default:
+			event = event.Interface(key, v)
+		}
+	default:
+		event = event.Interface(key, val.Any())
+	}
+
+	return event
+}
+
+// Verify at compile time that SlogHandler satisfies the slog.Handler interface.
+var _ slog.Handler = (*SlogHandler)(nil)