errors & log — 错误处理与日志记录

// 简单错误（静态字符串）
err := errors.New("something went wrong")

// 格式化错误
err := fmt.Errorf("user %s not found", username)

// Go 1.13+: 错误包装（关键特性）
err := fmt.Errorf("failed to process: %w", originalErr)

// errors.Is — 判断是否为 io.EOF（可能在多层包装内）
if errors.Is(err, io.EOF) {
    // 正常结束
}

// errors.As — 获取具体错误类型以读取字段
var pathError *os.PathError
if errors.As(err, &pathError) {
    fmt.Println("出问题的路径:", pathError.Path)
}

// 方案 A：简单哨兵错误
var ErrNotFound = errors.New("not found")

// 方案 B：带字段的错误类型
type ValidationError struct {
    Field   string
    Value   any
    Message string
}

func (e *ValidationError) Error() string {
    return fmt.Sprintf("validation: field=%s value=%v: %s", e.Field, e.Value, e.Message)
}

// 方案 C：包装底层错误 + 添加上下文
func getUser(ctx context.Context, id string) (*User, error) {
    user, err := db.Find(ctx, id)
    if err != nil {
        if errors.Is(err, sql.ErrNoRows) {
            return nil, fmt.Errorf("get user %s: %w", id, ErrNotFound)
        }
        return nil, fmt.Errorf("get user %s: %w", id, err)
    }
    return user, nil
}

// 手动遍历解包链
for err != nil {
    fmt.Println(err)
    err = errors.Unwrap(err)
}

// Go 1.20+: 多重错误
err1 := errors.New("err1")
err2 := errors.New("err2")
combined := errors.Join(err1, err2)
fmt.Println(combined) // "err1\nerr2"
// errors.Is(combined, err1) → true
// errors.Is(combined, err2) → true

log.Print("message")
log.Printf("formatted %s", "msg")
log.Fatal("critical")  // Print 后 os.Exit(1) —— defer 不执行！
log.Panic("fatal")     // Print 后 panic() —— defer 执行

log.SetFlags(log.Ldate | log.Ltime | log.Lshortfile)
// 输出：2024/01/15 10:30:00 server.go:42: message

// 不同级别用不同 logger，输出到不同目的地
var (
    Info  = log.New(os.Stdout, "[INFO] ", log.LstdFlags)
    Error = log.New(os.Stderr, "[ERROR] ", log.LstdFlags|log.Lshortfile)
)

// 同时写文件 + 控制台
file, _ := os.OpenFile("app.log", os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0644)
log.SetOutput(io.MultiWriter(file, os.Stdout))

logger := slog.New(slog.NewJSONHandler(os.Stdout, nil))

logger.Info("user logged in",
    "user_id", 123,
    "ip", "192.168.1.1",
    "duration", 150*time.Millisecond,
)
// {"time":"...","level":"INFO","msg":"user logged in","user_id":123,"ip":"192.168.1.1","duration":"150ms"}

slog.SetDefault(slog.New(slog.NewJSONHandler(os.Stderr, &slog.HandlerOptions{Level: slog.LevelInfo})))
slog.Info("startup", slog.String("version", buildVersion))

// 交替 key/value 的 ...any 形式
logger.Info("event", "user_id", 123, "ip", "1.2.3.4")

// 显式 Attr 形式（推荐）
logger.Info("event", slog.Int("user_id", 123), slog.String("ip", "1.2.3.4"))

// 最高效：直接传 []Attr，完全绕过 any 装箱
attrs := []slog.Attr{slog.Int("user_id", 123), slog.String("ip", "1.2.3.4")}
logger.LogAttrs(ctx, slog.LevelInfo, "event", attrs...)

// 错误：即使 Debug 关闭，fmt.Sprintf 仍然执行
logger.Debug("payload: " + expensiveString())

// 正确：先用 Enabled 短路，昂贵的构造根本不发生
if logger.Enabled(ctx, slog.LevelDebug) {
    logger.DebugContext(ctx, "payload", slog.String("data", expensiveString()))
}

logger.InfoContext(ctx, "processing request",
    slog.String("method", "GET"),
    slog.String("path", "/api/users"),
)

// 方案 1：请求入口用 With 把 ctx 里已知的值绑到 logger 上（最简单可靠）
reqLogger := logger.With("trace_id", traceIDFromCtx(ctx))
reqLogger.InfoContext(ctx, "processing")

// 方案 2：自定义 Handler，在 Handle 里从 ctx 参数抽值（框架级做法）
type ctxHandler struct{ slog.Handler }
func (h ctxHandler) Handle(ctx context.Context, r slog.Record) error {
    if tid, ok := ctx.Value(traceKey).(string); ok {
        r.AddAttrs(slog.String("trace_id", tid))
    }
    return h.Handler.Handle(ctx, r)
}
// 注意：ctx 是 Handle 的第一个入参，不要写成 r.Context()——Record 早已不提供该方法。

logger.Info("db query",
    slog.Group("metrics",
        slog.Duration("latency", 12*time.Millisecond),
        slog.Int("rows", 50),
    ),
)
// {"msg":"db query","metrics":{"latency":"12ms","rows":50}}

var lvl slog.LevelVar
lvl.Set(slog.LevelInfo)
logger := slog.New(slog.NewJSONHandler(os.Stdout, &slog.HandlerOptions{Level: &lvl}))
// 收到 SIGHUP 时： lvl.Set(slog.LevelDebug)

slog.LevelDebug  // -4
slog.LevelInfo   // 0（默认）
slog.LevelWarn   // 4
slog.LevelError  // 8