755 lines
18 KiB
Go
755 lines
18 KiB
Go
/*
|
||
Package tint implements a zero-dependency [slog.Handler] that writes tinted
|
||
(colorized) logs. The output format is inspired by the [zerolog.ConsoleWriter]
|
||
and [slog.TextHandler].
|
||
|
||
The output format can be customized using [Options], which is a drop-in
|
||
replacement for [slog.HandlerOptions].
|
||
|
||
# Customize Attributes
|
||
|
||
Options.ReplaceAttr can be used to alter or drop attributes. If set, it is
|
||
called on each non-group attribute before it is logged.
|
||
See [slog.HandlerOptions] for details.
|
||
|
||
Create a new logger with a custom TRACE level:
|
||
|
||
const LevelTrace = slog.LevelDebug - 4
|
||
|
||
w := os.Stderr
|
||
logger := slog.New(tint.NewHandler(w, &tint.Options{
|
||
Level: LevelTrace,
|
||
ReplaceAttr: func(groups []string, a slog.Attr) slog.Attr {
|
||
if a.Key == slog.LevelKey && len(groups) == 0 {
|
||
level, ok := a.Value.Any().(slog.Level)
|
||
if ok && level <= LevelTrace {
|
||
return tint.Attr(13, slog.String(a.Key, "TRC"))
|
||
}
|
||
}
|
||
return a
|
||
},
|
||
}))
|
||
|
||
Create a new logger that doesn't write the time:
|
||
|
||
w := os.Stderr
|
||
logger := slog.New(
|
||
tint.NewHandler(w, &tint.Options{
|
||
ReplaceAttr: func(groups []string, a slog.Attr) slog.Attr {
|
||
if a.Key == slog.TimeKey && len(groups) == 0 {
|
||
return slog.Attr{}
|
||
}
|
||
return a
|
||
},
|
||
}),
|
||
)
|
||
|
||
Create a new logger that writes all errors in red:
|
||
|
||
w := os.Stderr
|
||
logger := slog.New(
|
||
tint.NewHandler(w, &tint.Options{
|
||
ReplaceAttr: func(groups []string, a slog.Attr) slog.Attr {
|
||
if a.Value.Kind() == slog.KindAny {
|
||
if _, ok := a.Value.Any().(error); ok {
|
||
return tint.Attr(9, a)
|
||
}
|
||
}
|
||
return a
|
||
},
|
||
}),
|
||
)
|
||
|
||
# Automatically Enable Colors
|
||
|
||
Colors are enabled by default. Use the Options.NoColor field to disable
|
||
color output. To automatically enable colors based on terminal capabilities, use
|
||
e.g., the [go-isatty] package:
|
||
|
||
w := os.Stderr
|
||
logger := slog.New(
|
||
tint.NewHandler(w, &tint.Options{
|
||
NoColor: !isatty.IsTerminal(w.Fd()),
|
||
}),
|
||
)
|
||
|
||
# Windows Support
|
||
|
||
Color support on Windows can be added by using e.g., the [go-colorable] package:
|
||
|
||
w := os.Stderr
|
||
logger := slog.New(
|
||
tint.NewHandler(colorable.NewColorable(w), nil),
|
||
)
|
||
|
||
[zerolog.ConsoleWriter]: https://pkg.go.dev/github.com/rs/zerolog#ConsoleWriter
|
||
[go-isatty]: https://pkg.go.dev/github.com/mattn/go-isatty
|
||
[go-colorable]: https://pkg.go.dev/github.com/mattn/go-colorable
|
||
*/
|
||
package tint
|
||
|
||
import (
|
||
"context"
|
||
"encoding"
|
||
"fmt"
|
||
"io"
|
||
"log/slog"
|
||
"path/filepath"
|
||
"reflect"
|
||
"runtime"
|
||
"strconv"
|
||
"strings"
|
||
"sync"
|
||
"time"
|
||
"unicode"
|
||
"unicode/utf8"
|
||
)
|
||
|
||
const (
|
||
// ANSI modes
|
||
ansiEsc = '\u001b'
|
||
ansiReset = "\u001b[0m"
|
||
ansiFaint = "\u001b[2m"
|
||
ansiResetFaint = "\u001b[22m"
|
||
ansiBrightRed = "\u001b[91m"
|
||
ansiBrightGreen = "\u001b[92m"
|
||
ansiBrightYellow = "\u001b[93m"
|
||
|
||
errKey = "err"
|
||
|
||
defaultLevel = slog.LevelInfo
|
||
defaultTimeFormat = time.StampMilli
|
||
)
|
||
|
||
// Options for a slog.Handler that writes tinted logs. A zero Options consists
|
||
// entirely of default values.
|
||
//
|
||
// Options can be used as a drop-in replacement for [slog.HandlerOptions].
|
||
type Options struct {
|
||
// Enable source code location (Default: false)
|
||
AddSource bool
|
||
|
||
// Minimum level to log (Default: slog.LevelInfo)
|
||
Level slog.Leveler
|
||
|
||
// ReplaceAttr is called to rewrite each non-group attribute before it is logged.
|
||
// See https://pkg.go.dev/log/slog#HandlerOptions for details.
|
||
ReplaceAttr func(groups []string, attr slog.Attr) slog.Attr
|
||
|
||
// Time format (Default: time.StampMilli)
|
||
TimeFormat string
|
||
|
||
// Disable color (Default: false)
|
||
NoColor bool
|
||
}
|
||
|
||
func (o *Options) setDefaults() {
|
||
if o.Level == nil {
|
||
o.Level = defaultLevel
|
||
}
|
||
if o.TimeFormat == "" {
|
||
o.TimeFormat = defaultTimeFormat
|
||
}
|
||
}
|
||
|
||
// NewHandler creates a [slog.Handler] that writes tinted logs to Writer w,
|
||
// using the default options. If opts is nil, the default options are used.
|
||
func NewHandler(w io.Writer, opts *Options) slog.Handler {
|
||
if opts == nil {
|
||
opts = &Options{}
|
||
}
|
||
opts.setDefaults()
|
||
|
||
return &handler{
|
||
mu: &sync.Mutex{},
|
||
w: w,
|
||
opts: *opts,
|
||
}
|
||
}
|
||
|
||
// handler implements a [slog.Handler].
|
||
type handler struct {
|
||
attrsPrefix string
|
||
groupPrefix string
|
||
groups []string
|
||
|
||
mu *sync.Mutex
|
||
w io.Writer
|
||
|
||
opts Options
|
||
}
|
||
|
||
func (h *handler) clone() *handler {
|
||
return &handler{
|
||
attrsPrefix: h.attrsPrefix,
|
||
groupPrefix: h.groupPrefix,
|
||
groups: h.groups,
|
||
mu: h.mu, // mutex shared among all clones of this handler
|
||
w: h.w,
|
||
opts: h.opts,
|
||
}
|
||
}
|
||
|
||
func (h *handler) Enabled(_ context.Context, level slog.Level) bool {
|
||
return level >= h.opts.Level.Level()
|
||
}
|
||
|
||
func (h *handler) Handle(_ context.Context, r slog.Record) error {
|
||
// get a buffer from the sync pool
|
||
buf := newBuffer()
|
||
defer buf.Free()
|
||
|
||
rep := h.opts.ReplaceAttr
|
||
|
||
// write time
|
||
if !r.Time.IsZero() {
|
||
val := r.Time.Round(0) // strip monotonic to match Attr behavior
|
||
if rep == nil {
|
||
h.appendTintTime(buf, r.Time, -1)
|
||
buf.WriteByte(' ')
|
||
} else if a := rep(nil /* groups */, slog.Time(slog.TimeKey, val)); a.Key != "" {
|
||
val, color := h.resolve(a.Value)
|
||
if val.Kind() == slog.KindTime {
|
||
h.appendTintTime(buf, val.Time(), color)
|
||
} else {
|
||
h.appendTintValue(buf, val, false, color, true)
|
||
}
|
||
buf.WriteByte(' ')
|
||
}
|
||
}
|
||
|
||
// write level
|
||
if rep == nil {
|
||
h.appendTintLevel(buf, r.Level, -1)
|
||
buf.WriteByte(' ')
|
||
} else if a := rep(nil /* groups */, slog.Any(slog.LevelKey, r.Level)); a.Key != "" {
|
||
val, color := h.resolve(a.Value)
|
||
if val.Kind() == slog.KindAny {
|
||
if lvlVal, ok := val.Any().(slog.Level); ok {
|
||
h.appendTintLevel(buf, lvlVal, color)
|
||
} else {
|
||
h.appendTintValue(buf, val, false, color, false)
|
||
}
|
||
} else {
|
||
h.appendTintValue(buf, val, false, color, false)
|
||
}
|
||
buf.WriteByte(' ')
|
||
}
|
||
|
||
// write source
|
||
if h.opts.AddSource {
|
||
fs := runtime.CallersFrames([]uintptr{r.PC})
|
||
f, _ := fs.Next()
|
||
if f.File != "" {
|
||
src := &slog.Source{
|
||
Function: f.Function,
|
||
File: f.File,
|
||
Line: f.Line,
|
||
}
|
||
|
||
if rep == nil {
|
||
if h.opts.NoColor {
|
||
appendSource(buf, src)
|
||
} else {
|
||
buf.WriteString(ansiFaint)
|
||
appendSource(buf, src)
|
||
buf.WriteString(ansiReset)
|
||
}
|
||
buf.WriteByte(' ')
|
||
} else if a := rep(nil /* groups */, slog.Any(slog.SourceKey, src)); a.Key != "" {
|
||
val, color := h.resolve(a.Value)
|
||
h.appendTintValue(buf, val, false, color, true)
|
||
buf.WriteByte(' ')
|
||
}
|
||
}
|
||
}
|
||
|
||
// write message
|
||
if rep == nil {
|
||
buf.WriteString(r.Message)
|
||
buf.WriteByte(' ')
|
||
} else if a := rep(nil /* groups */, slog.String(slog.MessageKey, r.Message)); a.Key != "" {
|
||
val, color := h.resolve(a.Value)
|
||
h.appendTintValue(buf, val, false, color, false)
|
||
buf.WriteByte(' ')
|
||
}
|
||
|
||
// write handler attributes
|
||
if len(h.attrsPrefix) > 0 {
|
||
buf.WriteString(h.attrsPrefix)
|
||
}
|
||
|
||
// write attributes
|
||
r.Attrs(func(attr slog.Attr) bool {
|
||
h.appendAttr(buf, attr, h.groupPrefix, h.groups)
|
||
return true
|
||
})
|
||
|
||
if len(*buf) == 0 {
|
||
buf.WriteByte('\n')
|
||
} else {
|
||
(*buf)[len(*buf)-1] = '\n' // replace last space with newline
|
||
}
|
||
|
||
h.mu.Lock()
|
||
defer h.mu.Unlock()
|
||
|
||
_, err := h.w.Write(*buf)
|
||
return err
|
||
}
|
||
|
||
func (h *handler) WithAttrs(attrs []slog.Attr) slog.Handler {
|
||
if len(attrs) == 0 {
|
||
return h
|
||
}
|
||
h2 := h.clone()
|
||
|
||
buf := newBuffer()
|
||
defer buf.Free()
|
||
|
||
// write attributes to buffer
|
||
for _, attr := range attrs {
|
||
h.appendAttr(buf, attr, h.groupPrefix, h.groups)
|
||
}
|
||
h2.attrsPrefix = h.attrsPrefix + string(*buf)
|
||
return h2
|
||
}
|
||
|
||
func (h *handler) WithGroup(name string) slog.Handler {
|
||
if name == "" {
|
||
return h
|
||
}
|
||
h2 := h.clone()
|
||
h2.groupPrefix += name + "."
|
||
h2.groups = append(h2.groups, name)
|
||
return h2
|
||
}
|
||
|
||
func (h *handler) appendTintTime(buf *buffer, t time.Time, color int16) {
|
||
if h.opts.NoColor {
|
||
*buf = t.AppendFormat(*buf, h.opts.TimeFormat)
|
||
} else {
|
||
if color >= 0 {
|
||
appendAnsi(buf, uint8(color), true)
|
||
} else {
|
||
buf.WriteString(ansiFaint)
|
||
}
|
||
*buf = t.AppendFormat(*buf, h.opts.TimeFormat)
|
||
buf.WriteString(ansiReset)
|
||
}
|
||
}
|
||
|
||
func (h *handler) appendTintLevel(buf *buffer, level slog.Level, color int16) {
|
||
str := func(base string, val slog.Level) []byte {
|
||
if val == 0 {
|
||
return []byte(base)
|
||
} else if val > 0 {
|
||
return strconv.AppendInt(append([]byte(base), '+'), int64(val), 10)
|
||
}
|
||
return strconv.AppendInt([]byte(base), int64(val), 10)
|
||
}
|
||
|
||
if !h.opts.NoColor {
|
||
if color >= 0 {
|
||
appendAnsi(buf, uint8(color), false)
|
||
} else {
|
||
switch {
|
||
case level < slog.LevelInfo:
|
||
case level < slog.LevelWarn:
|
||
buf.WriteString(ansiBrightGreen)
|
||
case level < slog.LevelError:
|
||
buf.WriteString(ansiBrightYellow)
|
||
default:
|
||
buf.WriteString(ansiBrightRed)
|
||
}
|
||
}
|
||
}
|
||
|
||
switch {
|
||
case level < slog.LevelInfo:
|
||
buf.Write(str("DBG", level-slog.LevelDebug))
|
||
case level < slog.LevelWarn:
|
||
buf.Write(str("INF", level-slog.LevelInfo))
|
||
case level < slog.LevelError:
|
||
buf.Write(str("WRN", level-slog.LevelWarn))
|
||
default:
|
||
buf.Write(str("ERR", level-slog.LevelError))
|
||
}
|
||
|
||
if !h.opts.NoColor && level >= slog.LevelInfo {
|
||
buf.WriteString(ansiReset)
|
||
}
|
||
}
|
||
|
||
func appendSource(buf *buffer, src *slog.Source) {
|
||
dir, file := filepath.Split(src.File)
|
||
|
||
buf.WriteString(filepath.Join(filepath.Base(dir), file))
|
||
buf.WriteByte(':')
|
||
*buf = strconv.AppendInt(*buf, int64(src.Line), 10)
|
||
}
|
||
|
||
func (h *handler) resolve(val slog.Value) (resolvedVal slog.Value, color int16) {
|
||
if !h.opts.NoColor && val.Kind() == slog.KindLogValuer {
|
||
if tintVal, ok := val.Any().(tintValue); ok {
|
||
return tintVal.Value.Resolve(), int16(tintVal.Color)
|
||
}
|
||
}
|
||
return val.Resolve(), -1
|
||
}
|
||
|
||
func (h *handler) appendAttr(buf *buffer, attr slog.Attr, groupsPrefix string, groups []string) {
|
||
var color int16 // -1 if no color
|
||
attr.Value, color = h.resolve(attr.Value)
|
||
if rep := h.opts.ReplaceAttr; rep != nil && attr.Value.Kind() != slog.KindGroup {
|
||
attr = rep(groups, attr)
|
||
var colorRep int16
|
||
attr.Value, colorRep = h.resolve(attr.Value)
|
||
if colorRep >= 0 {
|
||
color = colorRep
|
||
}
|
||
}
|
||
|
||
if attr.Equal(slog.Attr{}) {
|
||
return
|
||
}
|
||
|
||
if attr.Value.Kind() == slog.KindGroup {
|
||
if attr.Key != "" {
|
||
groupsPrefix += attr.Key + "."
|
||
groups = append(groups, attr.Key)
|
||
}
|
||
for _, groupAttr := range attr.Value.Group() {
|
||
h.appendAttr(buf, groupAttr, groupsPrefix, groups)
|
||
}
|
||
return
|
||
}
|
||
|
||
if h.opts.NoColor {
|
||
h.appendKey(buf, attr.Key, groupsPrefix)
|
||
h.appendValue(buf, attr.Value, true)
|
||
} else {
|
||
if color >= 0 {
|
||
appendAnsi(buf, uint8(color), true)
|
||
h.appendKey(buf, attr.Key, groupsPrefix)
|
||
buf.WriteString(ansiResetFaint)
|
||
h.appendValue(buf, attr.Value, true)
|
||
buf.WriteString(ansiReset)
|
||
} else {
|
||
buf.WriteString(ansiFaint)
|
||
h.appendKey(buf, attr.Key, groupsPrefix)
|
||
buf.WriteString(ansiReset)
|
||
h.appendValue(buf, attr.Value, true)
|
||
}
|
||
}
|
||
buf.WriteByte(' ')
|
||
}
|
||
|
||
func (h *handler) appendKey(buf *buffer, key, groups string) {
|
||
appendString(buf, groups+key, true, !h.opts.NoColor)
|
||
buf.WriteByte('=')
|
||
}
|
||
|
||
func (h *handler) appendValue(buf *buffer, v slog.Value, quote bool) {
|
||
switch v.Kind() {
|
||
case slog.KindString:
|
||
appendString(buf, v.String(), quote, !h.opts.NoColor)
|
||
case slog.KindInt64:
|
||
*buf = strconv.AppendInt(*buf, v.Int64(), 10)
|
||
case slog.KindUint64:
|
||
*buf = strconv.AppendUint(*buf, v.Uint64(), 10)
|
||
case slog.KindFloat64:
|
||
*buf = strconv.AppendFloat(*buf, v.Float64(), 'g', -1, 64)
|
||
case slog.KindBool:
|
||
*buf = strconv.AppendBool(*buf, v.Bool())
|
||
case slog.KindDuration:
|
||
appendString(buf, v.Duration().String(), quote, !h.opts.NoColor)
|
||
case slog.KindTime:
|
||
*buf = appendRFC3339Millis(*buf, v.Time())
|
||
case slog.KindAny:
|
||
defer func() {
|
||
// Copied from log/slog/handler.go.
|
||
if r := recover(); r != nil {
|
||
// If it panics with a nil pointer, the most likely cases are
|
||
// an encoding.TextMarshaler or error fails to guard against nil,
|
||
// in which case "<nil>" seems to be the feasible choice.
|
||
//
|
||
// Adapted from the code in fmt/print.go.
|
||
if v := reflect.ValueOf(v.Any()); v.Kind() == reflect.Pointer && v.IsNil() {
|
||
buf.WriteString("<nil>")
|
||
return
|
||
}
|
||
|
||
// Otherwise just print the original panic message.
|
||
appendString(buf, fmt.Sprintf("!PANIC: %v", r), true, !h.opts.NoColor)
|
||
}
|
||
}()
|
||
|
||
switch cv := v.Any().(type) {
|
||
case encoding.TextMarshaler:
|
||
data, err := cv.MarshalText()
|
||
if err != nil {
|
||
break
|
||
}
|
||
appendString(buf, string(data), quote, !h.opts.NoColor)
|
||
case *slog.Source:
|
||
appendSource(buf, cv)
|
||
default:
|
||
appendString(buf, fmt.Sprintf("%+v", cv), quote, !h.opts.NoColor)
|
||
}
|
||
}
|
||
}
|
||
|
||
func (h *handler) appendTintValue(buf *buffer, val slog.Value, quote bool, color int16, faint bool) {
|
||
if h.opts.NoColor {
|
||
h.appendValue(buf, val, quote)
|
||
} else {
|
||
if color >= 0 {
|
||
appendAnsi(buf, uint8(color), faint)
|
||
} else if faint {
|
||
buf.WriteString(ansiFaint)
|
||
}
|
||
h.appendValue(buf, val, quote)
|
||
if color >= 0 || faint {
|
||
buf.WriteString(ansiReset)
|
||
}
|
||
}
|
||
}
|
||
|
||
// Copied from log/slog/handler.go.
|
||
func appendRFC3339Millis(b []byte, t time.Time) []byte {
|
||
// Format according to time.RFC3339Nano since it is highly optimized,
|
||
// but truncate it to use millisecond resolution.
|
||
// Unfortunately, that format trims trailing 0s, so add 1/10 millisecond
|
||
// to guarantee that there are exactly 4 digits after the period.
|
||
const prefixLen = len("2006-01-02T15:04:05.000")
|
||
n := len(b)
|
||
t = t.Truncate(time.Millisecond).Add(time.Millisecond / 10)
|
||
b = t.AppendFormat(b, time.RFC3339Nano)
|
||
b = append(b[:n+prefixLen], b[n+prefixLen+1:]...) // drop the 4th digit
|
||
return b
|
||
}
|
||
|
||
func appendAnsi(buf *buffer, color uint8, faint bool) {
|
||
buf.WriteString("\u001b[")
|
||
if faint {
|
||
buf.WriteString("2;")
|
||
}
|
||
if color < 8 {
|
||
*buf = strconv.AppendUint(*buf, uint64(color)+30, 10)
|
||
} else if color < 16 {
|
||
*buf = strconv.AppendUint(*buf, uint64(color)+82, 10)
|
||
} else {
|
||
buf.WriteString("38;5;")
|
||
*buf = strconv.AppendUint(*buf, uint64(color), 10)
|
||
}
|
||
buf.WriteByte('m')
|
||
}
|
||
|
||
func appendString(buf *buffer, s string, quote, color bool) {
|
||
if quote && !color {
|
||
// trim ANSI escape sequences
|
||
var inEscape bool
|
||
s = cut(s, func(r rune) bool {
|
||
if r == ansiEsc {
|
||
inEscape = true
|
||
} else if inEscape && unicode.IsLetter(r) {
|
||
inEscape = false
|
||
return true
|
||
}
|
||
|
||
return inEscape
|
||
})
|
||
}
|
||
|
||
quote = quote && needsQuoting(s)
|
||
switch {
|
||
case color && quote:
|
||
s = strconv.Quote(s)
|
||
s = strings.ReplaceAll(s, `\x1b`, string(ansiEsc))
|
||
buf.WriteString(s)
|
||
case !color && quote:
|
||
*buf = strconv.AppendQuote(*buf, s)
|
||
default:
|
||
buf.WriteString(s)
|
||
}
|
||
}
|
||
|
||
func cut(s string, f func(r rune) bool) string {
|
||
var res []rune
|
||
for i := 0; i < len(s); {
|
||
r, size := utf8.DecodeRuneInString(s[i:])
|
||
if r == utf8.RuneError {
|
||
break
|
||
}
|
||
if !f(r) {
|
||
res = append(res, r)
|
||
}
|
||
i += size
|
||
}
|
||
return string(res)
|
||
}
|
||
|
||
// Copied from log/slog/text_handler.go.
|
||
func needsQuoting(s string) bool {
|
||
if len(s) == 0 {
|
||
return true
|
||
}
|
||
for i := 0; i < len(s); {
|
||
b := s[i]
|
||
if b < utf8.RuneSelf {
|
||
// Quote anything except a backslash that would need quoting in a
|
||
// JSON string, as well as space and '='
|
||
if b != '\\' && (b == ' ' || b == '=' || !safeSet[b]) {
|
||
return true
|
||
}
|
||
i++
|
||
continue
|
||
}
|
||
r, size := utf8.DecodeRuneInString(s[i:])
|
||
if r == utf8.RuneError || unicode.IsSpace(r) || !unicode.IsPrint(r) {
|
||
return true
|
||
}
|
||
i += size
|
||
}
|
||
return false
|
||
}
|
||
|
||
// Copied from log/slog/json_handler.go.
|
||
//
|
||
// safeSet is extended by the ANSI escape code "\u001b".
|
||
var safeSet = [utf8.RuneSelf]bool{
|
||
' ': true,
|
||
'!': true,
|
||
'"': false,
|
||
'#': true,
|
||
'$': true,
|
||
'%': true,
|
||
'&': true,
|
||
'\'': true,
|
||
'(': true,
|
||
')': true,
|
||
'*': true,
|
||
'+': true,
|
||
',': true,
|
||
'-': true,
|
||
'.': true,
|
||
'/': true,
|
||
'0': true,
|
||
'1': true,
|
||
'2': true,
|
||
'3': true,
|
||
'4': true,
|
||
'5': true,
|
||
'6': true,
|
||
'7': true,
|
||
'8': true,
|
||
'9': true,
|
||
':': true,
|
||
';': true,
|
||
'<': true,
|
||
'=': true,
|
||
'>': true,
|
||
'?': true,
|
||
'@': true,
|
||
'A': true,
|
||
'B': true,
|
||
'C': true,
|
||
'D': true,
|
||
'E': true,
|
||
'F': true,
|
||
'G': true,
|
||
'H': true,
|
||
'I': true,
|
||
'J': true,
|
||
'K': true,
|
||
'L': true,
|
||
'M': true,
|
||
'N': true,
|
||
'O': true,
|
||
'P': true,
|
||
'Q': true,
|
||
'R': true,
|
||
'S': true,
|
||
'T': true,
|
||
'U': true,
|
||
'V': true,
|
||
'W': true,
|
||
'X': true,
|
||
'Y': true,
|
||
'Z': true,
|
||
'[': true,
|
||
'\\': false,
|
||
']': true,
|
||
'^': true,
|
||
'_': true,
|
||
'`': true,
|
||
'a': true,
|
||
'b': true,
|
||
'c': true,
|
||
'd': true,
|
||
'e': true,
|
||
'f': true,
|
||
'g': true,
|
||
'h': true,
|
||
'i': true,
|
||
'j': true,
|
||
'k': true,
|
||
'l': true,
|
||
'm': true,
|
||
'n': true,
|
||
'o': true,
|
||
'p': true,
|
||
'q': true,
|
||
'r': true,
|
||
's': true,
|
||
't': true,
|
||
'u': true,
|
||
'v': true,
|
||
'w': true,
|
||
'x': true,
|
||
'y': true,
|
||
'z': true,
|
||
'{': true,
|
||
'|': true,
|
||
'}': true,
|
||
'~': true,
|
||
'\u007f': true,
|
||
'\u001b': true,
|
||
}
|
||
|
||
type tintValue struct {
|
||
slog.Value
|
||
Color uint8
|
||
}
|
||
|
||
// LogValue implements the [slog.LogValuer] interface.
|
||
func (v tintValue) LogValue() slog.Value {
|
||
return v.Value
|
||
}
|
||
|
||
// Err returns a tinted (colorized) [slog.Attr] that will be written in red color
|
||
// by the [tint.Handler]. When used with any other [slog.Handler], it behaves as
|
||
//
|
||
// slog.Any("err", err)
|
||
func Err(err error) slog.Attr {
|
||
return Attr(9, slog.Any(errKey, err))
|
||
}
|
||
|
||
// Attr returns a tinted (colorized) [slog.Attr] that will be written in the
|
||
// specified color by the [tint.Handler]. When used with any other [slog.Handler], it behaves as a
|
||
// plain [slog.Attr].
|
||
//
|
||
// Use the uint8 color value to specify the color of the attribute:
|
||
//
|
||
// - 0-7: standard ANSI colors
|
||
// - 8-15: high intensity ANSI colors
|
||
// - 16-231: 216 colors (6×6×6 cube)
|
||
// - 232-255: grayscale from dark to light in 24 steps
|
||
//
|
||
// See https://en.wikipedia.org/wiki/ANSI_escape_code#8-bit
|
||
func Attr(color uint8, attr slog.Attr) slog.Attr {
|
||
attr.Value = slog.AnyValue(tintValue{attr.Value, color})
|
||
return attr
|
||
}
|