Golang如何在崩溃前存储日志

在Go中捕获panic并记录堆栈跟踪的正确方法如下：

package main

import (
	"io"
	"os"
	"runtime/debug"
	"time"

	"github.com/rs/zerolog"
	"gopkg.in/natefinch/lumberjack.v2"
)

func main() {
	// 设置日志轮转
	ljLogger := &lumberjack.Logger{
		Filename:   "/var/log/myapp.log",
		MaxSize:    10,
		MaxBackups: 5,
		MaxAge:     7,
		Compress:   true,
	}

	// 创建多路写入器（同时输出到文件和终端）
	mw := io.MultiWriter(ljLogger, os.Stdout)
	
	// 创建zerolog实例
	logger := zerolog.New(mw).
		With().
		Timestamp().
		Logger()

	// 设置全局panic处理
	defer handlePanic(&logger)

	// 你的应用逻辑
	abcd()
}

func handlePanic(logger *zerolog.Logger) {
	if r := recover(); r != nil {
		// 获取完整的堆栈跟踪
		stack := debug.Stack()
		
		// 记录panic信息
		logger.Error().
			Time("panic_time", time.Now()).
			Interface("panic_value", r).
			Str("stacktrace", string(stack)).
			Msg("Unhandled panic occurred")
		
		// 可以选择重新panic或优雅退出
		panic(r) // 重新抛出panic以保持原始行为
	}
}

func abcd() {
	defer func() {
		if r := recover(); r != nil {
			// 这里不应该递归调用，会导致堆栈溢出
			// 应该记录错误并退出或重新panic
			panic(r)
		}
	}()
	panic("something went wrong")
}

更健壮的实现可以使用自定义的panic处理器：

package main

import (
	"fmt"
	"io"
	"os"
	"runtime/debug"
	"time"

	"github.com/rs/zerolog"
	"gopkg.in/natefinch/lumberjack.v2"
)

type PanicHandler struct {
	logger zerolog.Logger
}

func NewPanicHandler(logger zerolog.Logger) *PanicHandler {
	return &PanicHandler{logger: logger}
}

func (ph *PanicHandler) HandlePanic() {
	if r := recover(); r != nil {
		// 获取堆栈信息
		stack := debug.Stack()
		
		// 记录详细信息
		ph.logger.Error().
			Time("timestamp", time.Now()).
			Str("panic", fmt.Sprintf("%v", r)).
			Str("goroutine_stack", string(stack)).
			Msg("PANIC RECOVERED")
		
		// 输出到stderr以便立即查看
		fmt.Fprintf(os.Stderr, "PANIC: %v\n%s\n", r, stack)
		
		// 根据需求选择退出或继续
		os.Exit(1)
	}
}

func (ph *PanicHandler) Run(f func()) {
	defer ph.HandlePanic()
	f()
}

func main() {
	// 配置日志
	ljLogger := &lumberjack.Logger{
		Filename:   "/var/log/myapp.log",
		MaxSize:    10,
		MaxBackups: 5,
		MaxAge:     7,
	}

	mw := io.MultiWriter(ljLogger, os.Stdout)
	logger := zerolog.New(mw).
		With().
		Timestamp().
		Logger()

	// 创建panic处理器
	handler := NewPanicHandler(logger)
	
	// 运行应用
	handler.Run(func() {
		abcd()
	})
}

func abcd() {
	// 正常的业务逻辑
	panic("simulated panic")
}

对于HTTP服务器，可以这样处理：

package main

import (
	"net/http"
	"runtime/debug"
	
	"github.com/rs/zerolog"
	"gopkg.in/natefinch/lumberjack.v2"
)

func panicMiddleware(logger zerolog.Logger, next http.Handler) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		defer func() {
			if err := recover(); err != nil {
				stack := debug.Stack()
				logger.Error().
					Interface("panic", err).
					Str("stack", string(stack)).
					Str("url", r.URL.String()).
					Str("method", r.Method).
					Msg("HTTP panic recovered")
				
				http.Error(w, "Internal Server Error", http.StatusInternalServerError)
			}
		}()
		next.ServeHTTP(w, r)
	})
}

func main() {
	// 日志配置
	ljLogger := &lumberjack.Logger{
		Filename:   "/var/log/myapp.log",
		MaxSize:    10,
		MaxBackups: 5,
		MaxAge:     7,
	}
	
	logger := zerolog.New(ljLogger).With().Timestamp().Logger()
	
	// 创建带panic恢复的handler
	mux := http.NewServeMux()
	mux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
		panic("HTTP handler panic")
	})
	
	handler := panicMiddleware(logger, mux)
	http.ListenAndServe(":8080", handler)
}

关键点：

1. 使用debug.Stack()获取完整堆栈跟踪
2. 在defer函数中处理panic
3. 避免在panic处理中递归调用导致堆栈溢出
4. 确保日志在panic后能正确刷新到文件
5. 对于不同的应用类型（CLI、HTTP服务等）采用适当的panic处理策略