slogのドキュメントを読み込む（和訳）

// logger.go
// A Logger records structured information about each call to its
// Log, Debug, Info, Warn, and Error methods.
// For each call, it creates a Record and passes it to a Handler.
//
// To create a new Logger, call [New] or a Logger method
// that begins "With".
type Logger struct {
	handler Handler // for structured logging
}

// handler.go
type Handler interface {
	Enabled(context.Context, Level) bool
	Handle(context.Context, Record) error
	WithAttrs(attrs []Attr) Handler
	WithGroup(name string) Handler
}

logger := slog.New(slog.NewTextHandler(os.Stdout, nil))
logger.Info("hello", "count", 3) // => time=2022-11-08T15:28:26.000-05:00 level=INFO msg=hello count=3

logger := slog.New(slog.NewJSONHandler(os.Stdout, nil))
logger.Info("hello", "count", 3) // => {"time":"2022-11-08T15:28:26.000000000-05:00","level":"INFO","msg":"hello","count":3}

// Default returns the default Logger.
func Default() *Logger { return defaultLogger.Load().(*Logger) }

// SetDefault makes l the default Logger.
// After this call, output from the log package's default Logger
// (as with [log.Print], etc.) will be logged at LevelInfo using l's Handler.
func SetDefault(l *Logger) {
	defaultLogger.Store(l)

	if _, ok := l.Handler().(*defaultHandler); !ok {
		capturePC := log.Flags()&(log.Lshortfile|log.Llongfile) != 0
		log.SetOutput(&handlerWriter{l.Handler(), LevelInfo, capturePC})
		log.SetFlags(0) // we want just the log message, no time or location
	}
}

// Error calls Logger.Error on the default logger.
func Error(msg string, args ...any) {
	Default().log(nil, LevelError, msg, args...)
}

// ErrorContext calls Logger.ErrorContext on the default logger.
func ErrorContext(ctx context.Context, msg string, args ...any) {
	Default().log(ctx, LevelError, msg, args...)
}

applogger := logger.With("url", req.URL)

var programLevel = new(slog.LevelVar) // Info by default

h := slog.NewJSONHandler(os.Stderr, &slog.HandlerOptions{Level: programLevel})
slog.SetDefault(slog.New(h))

programLevel.Set(slog.LevelDebug)

slog.Group("request", "method", r.Method, "url", r.URL)

出力は次のようになる
・TextHandler
=> request.method=GET request.url=http://example.com
・JSONHandler
=> "request":{"method":"GET","url":"http://example.com"}

logger := slog.Default().With("id", systemID)
parserLogger := logger.WithGroup("parser")

type Attr struct {
	Key   string
	Value Value
}

// 下記２つはどちらも同じ
// Attr を渡す例
slog.Info("hello", slog.Int("count", 3))
// key, value を渡す例
slog.Info("hello", "count", 3)

slog.Info("hello", "count", 3)
// ↓こっちの方が効率的
logger.LogAttrs(nil, slog.LevelInfo, "hello", slog.Int("count", 3))

type LogValuer interface {
	LogValue() Value
}

import (
	"os"

	"golang.org/x/exp/slog"
	"golang.org/x/exp/slog/internal/testutil"
)

// A token is a secret value that grants permissions.
type Token string

// LogValue implements slog.LogValuer.
// It avoids revealing the token.
func (Token) LogValue() slog.Value {
	return slog.StringValue("REDACTED_TOKEN")
}

// This example demonstrates a Value that replaces itself
// with an alternative representation to avoid revealing secrets.
func main() {
	t := Token("shhhh!")
	logger := slog.New(slog.NewTextHandler(os.Stdout, &slog.HandlerOptions{ReplaceAttr: testutil.RemoveTime}))
	logger.Info("permission granted", "user", "Perry", "token", t)

}

package main

import "golang.org/x/exp/slog"

type Name struct {
	First, Last string
}

// LogValue implements slog.LogValuer.
// It returns a group containing the fields of
// the Name, so that they appear together in the log output.
func (n Name) LogValue() slog.Value {
	return slog.GroupValue(
		slog.String("first", n.First),
		slog.String("last", n.Last))
}

func main() {
	n := Name{"Perry", "Platypus"}
	slog.Info("mission accomplished", "agent", n)

	// JSON Output would look in part like:
	// {
	//     ...
	//     "msg": "mission accomplished",
	//     "agent": {
	//         "first": "Perry",
	//         "last": "Platypus"
	//     }
	// }
}

// mylog.go
func Infof(format string, args ...any) {
    slog.Default().Info(fmt.Sprintf(format, args...))
}

// main.go
Infof(slog.Default(), "hello, %s", "world") // 引数の型が間違っているのでエラーになる。

package main

import (
	"context"
	"fmt"
	"os"
	"path/filepath"
	"runtime"
	"time"

	"golang.org/x/exp/slog"
)

// Infof is an example of a user-defined logging function that wraps slog.
// The log record contains the source position of the caller of Infof.
func Infof(logger *slog.Logger, format string, args ...any) {
	if !logger.Enabled(context.Background(), slog.LevelInfo) {
		return
	}
	var pcs [1]uintptr
	runtime.Callers(2, pcs[:]) // skip [Callers, Infof]
	r := slog.NewRecord(time.Now(), slog.LevelInfo, fmt.Sprintf(format, args...), pcs[0])
	_ = logger.Handler().Handle(context.Background(), r)
}

func main() {
	replace := func(groups []string, a slog.Attr) slog.Attr {
		// Remove time.
		if a.Key == slog.TimeKey && len(groups) == 0 {
			return slog.Attr{}
		}
		// Remove the directory from the source's filename.
		if a.Key == slog.SourceKey {
			source := a.Value.Any().(*slog.Source)
			source.File = filepath.Base(source.File)
		}
		return a
	}
	logger := slog.New(slog.NewTextHandler(os.Stdout, &slog.HandlerOptions{AddSource: true, ReplaceAttr: replace}))
	Infof(logger, "message, %s", "formatted")

}

slog.Info("starting request", "url", r.URL.String()) // bad String()呼び出しが無駄になる可能性がある
slog.Info("starting request", "url", &r.URL) // ログ出力するときのみ URL.String() が呼ばれる

// computeExpensiveValue はコストがかかる処理
slog.Debug("frobbing", "value", computeExpensiveValue(arg))

type expensive struct { arg int }

func (e expensive) LogValue() slog.Value {
    return slog.AnyValue(computeExpensiveValue(e.arg))
}

// ログ呼び出し部分では expensive型の値を渡す
slog.Debug("frobbing", "value", expensive{arg})