mirror of
https://github.com/mjl-/mox.git
synced 2025-02-02 01:08:29 +03:00
5b20cba50a
we don't want external software to include internal details like mlog. slog.Logger is/will be the standard. we still have mlog for its helper functions, and its handler that logs in concise logfmt used by mox. packages that are not meant for reuse still pass around mlog.Log for convenience. we use golang.org/x/exp/slog because we also support the previous Go toolchain version. with the next Go release, we'll switch to the builtin slog.
336 lines
8 KiB
Go
336 lines
8 KiB
Go
// Copyright 2022 The Go Authors. All rights reserved.
|
|
// Use of this source code is governed by a BSD-style
|
|
// license that can be found in the LICENSE file.
|
|
|
|
package slog
|
|
|
|
import (
|
|
"bytes"
|
|
"context"
|
|
"encoding/json"
|
|
"errors"
|
|
"fmt"
|
|
"io"
|
|
"strconv"
|
|
"time"
|
|
"unicode/utf8"
|
|
|
|
"golang.org/x/exp/slog/internal/buffer"
|
|
)
|
|
|
|
// JSONHandler is a Handler that writes Records to an io.Writer as
|
|
// line-delimited JSON objects.
|
|
type JSONHandler struct {
|
|
*commonHandler
|
|
}
|
|
|
|
// NewJSONHandler creates a JSONHandler that writes to w,
|
|
// using the given options.
|
|
// If opts is nil, the default options are used.
|
|
func NewJSONHandler(w io.Writer, opts *HandlerOptions) *JSONHandler {
|
|
if opts == nil {
|
|
opts = &HandlerOptions{}
|
|
}
|
|
return &JSONHandler{
|
|
&commonHandler{
|
|
json: true,
|
|
w: w,
|
|
opts: *opts,
|
|
},
|
|
}
|
|
}
|
|
|
|
// Enabled reports whether the handler handles records at the given level.
|
|
// The handler ignores records whose level is lower.
|
|
func (h *JSONHandler) Enabled(_ context.Context, level Level) bool {
|
|
return h.commonHandler.enabled(level)
|
|
}
|
|
|
|
// WithAttrs returns a new JSONHandler whose attributes consists
|
|
// of h's attributes followed by attrs.
|
|
func (h *JSONHandler) WithAttrs(attrs []Attr) Handler {
|
|
return &JSONHandler{commonHandler: h.commonHandler.withAttrs(attrs)}
|
|
}
|
|
|
|
func (h *JSONHandler) WithGroup(name string) Handler {
|
|
return &JSONHandler{commonHandler: h.commonHandler.withGroup(name)}
|
|
}
|
|
|
|
// Handle formats its argument Record as a JSON object on a single line.
|
|
//
|
|
// If the Record's time is zero, the time is omitted.
|
|
// Otherwise, the key is "time"
|
|
// and the value is output as with json.Marshal.
|
|
//
|
|
// If the Record's level is zero, the level is omitted.
|
|
// Otherwise, the key is "level"
|
|
// and the value of [Level.String] is output.
|
|
//
|
|
// If the AddSource option is set and source information is available,
|
|
// the key is "source"
|
|
// and the value is output as "FILE:LINE".
|
|
//
|
|
// The message's key is "msg".
|
|
//
|
|
// To modify these or other attributes, or remove them from the output, use
|
|
// [HandlerOptions.ReplaceAttr].
|
|
//
|
|
// Values are formatted as with an [encoding/json.Encoder] with SetEscapeHTML(false),
|
|
// with two exceptions.
|
|
//
|
|
// First, an Attr whose Value is of type error is formatted as a string, by
|
|
// calling its Error method. Only errors in Attrs receive this special treatment,
|
|
// not errors embedded in structs, slices, maps or other data structures that
|
|
// are processed by the encoding/json package.
|
|
//
|
|
// Second, an encoding failure does not cause Handle to return an error.
|
|
// Instead, the error message is formatted as a string.
|
|
//
|
|
// Each call to Handle results in a single serialized call to io.Writer.Write.
|
|
func (h *JSONHandler) Handle(_ context.Context, r Record) error {
|
|
return h.commonHandler.handle(r)
|
|
}
|
|
|
|
// Adapted from time.Time.MarshalJSON to avoid allocation.
|
|
func appendJSONTime(s *handleState, t time.Time) {
|
|
if y := t.Year(); y < 0 || y >= 10000 {
|
|
// RFC 3339 is clear that years are 4 digits exactly.
|
|
// See golang.org/issue/4556#c15 for more discussion.
|
|
s.appendError(errors.New("time.Time year outside of range [0,9999]"))
|
|
}
|
|
s.buf.WriteByte('"')
|
|
*s.buf = t.AppendFormat(*s.buf, time.RFC3339Nano)
|
|
s.buf.WriteByte('"')
|
|
}
|
|
|
|
func appendJSONValue(s *handleState, v Value) error {
|
|
switch v.Kind() {
|
|
case KindString:
|
|
s.appendString(v.str())
|
|
case KindInt64:
|
|
*s.buf = strconv.AppendInt(*s.buf, v.Int64(), 10)
|
|
case KindUint64:
|
|
*s.buf = strconv.AppendUint(*s.buf, v.Uint64(), 10)
|
|
case KindFloat64:
|
|
// json.Marshal is funny about floats; it doesn't
|
|
// always match strconv.AppendFloat. So just call it.
|
|
// That's expensive, but floats are rare.
|
|
if err := appendJSONMarshal(s.buf, v.Float64()); err != nil {
|
|
return err
|
|
}
|
|
case KindBool:
|
|
*s.buf = strconv.AppendBool(*s.buf, v.Bool())
|
|
case KindDuration:
|
|
// Do what json.Marshal does.
|
|
*s.buf = strconv.AppendInt(*s.buf, int64(v.Duration()), 10)
|
|
case KindTime:
|
|
s.appendTime(v.Time())
|
|
case KindAny:
|
|
a := v.Any()
|
|
_, jm := a.(json.Marshaler)
|
|
if err, ok := a.(error); ok && !jm {
|
|
s.appendString(err.Error())
|
|
} else {
|
|
return appendJSONMarshal(s.buf, a)
|
|
}
|
|
default:
|
|
panic(fmt.Sprintf("bad kind: %s", v.Kind()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func appendJSONMarshal(buf *buffer.Buffer, v any) error {
|
|
// Use a json.Encoder to avoid escaping HTML.
|
|
var bb bytes.Buffer
|
|
enc := json.NewEncoder(&bb)
|
|
enc.SetEscapeHTML(false)
|
|
if err := enc.Encode(v); err != nil {
|
|
return err
|
|
}
|
|
bs := bb.Bytes()
|
|
buf.Write(bs[:len(bs)-1]) // remove final newline
|
|
return nil
|
|
}
|
|
|
|
// appendEscapedJSONString escapes s for JSON and appends it to buf.
|
|
// It does not surround the string in quotation marks.
|
|
//
|
|
// Modified from encoding/json/encode.go:encodeState.string,
|
|
// with escapeHTML set to false.
|
|
func appendEscapedJSONString(buf []byte, s string) []byte {
|
|
char := func(b byte) { buf = append(buf, b) }
|
|
str := func(s string) { buf = append(buf, s...) }
|
|
|
|
start := 0
|
|
for i := 0; i < len(s); {
|
|
if b := s[i]; b < utf8.RuneSelf {
|
|
if safeSet[b] {
|
|
i++
|
|
continue
|
|
}
|
|
if start < i {
|
|
str(s[start:i])
|
|
}
|
|
char('\\')
|
|
switch b {
|
|
case '\\', '"':
|
|
char(b)
|
|
case '\n':
|
|
char('n')
|
|
case '\r':
|
|
char('r')
|
|
case '\t':
|
|
char('t')
|
|
default:
|
|
// This encodes bytes < 0x20 except for \t, \n and \r.
|
|
str(`u00`)
|
|
char(hex[b>>4])
|
|
char(hex[b&0xF])
|
|
}
|
|
i++
|
|
start = i
|
|
continue
|
|
}
|
|
c, size := utf8.DecodeRuneInString(s[i:])
|
|
if c == utf8.RuneError && size == 1 {
|
|
if start < i {
|
|
str(s[start:i])
|
|
}
|
|
str(`\ufffd`)
|
|
i += size
|
|
start = i
|
|
continue
|
|
}
|
|
// U+2028 is LINE SEPARATOR.
|
|
// U+2029 is PARAGRAPH SEPARATOR.
|
|
// They are both technically valid characters in JSON strings,
|
|
// but don't work in JSONP, which has to be evaluated as JavaScript,
|
|
// and can lead to security holes there. It is valid JSON to
|
|
// escape them, so we do so unconditionally.
|
|
// See http://timelessrepo.com/json-isnt-a-javascript-subset for discussion.
|
|
if c == '\u2028' || c == '\u2029' {
|
|
if start < i {
|
|
str(s[start:i])
|
|
}
|
|
str(`\u202`)
|
|
char(hex[c&0xF])
|
|
i += size
|
|
start = i
|
|
continue
|
|
}
|
|
i += size
|
|
}
|
|
if start < len(s) {
|
|
str(s[start:])
|
|
}
|
|
return buf
|
|
}
|
|
|
|
var hex = "0123456789abcdef"
|
|
|
|
// Copied from encoding/json/tables.go.
|
|
//
|
|
// safeSet holds the value true if the ASCII character with the given array
|
|
// position can be represented inside a JSON string without any further
|
|
// escaping.
|
|
//
|
|
// All values are true except for the ASCII control characters (0-31), the
|
|
// double quote ("), and the backslash character ("\").
|
|
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,
|
|
}
|