错误处理与日志记录的专业分析

你的设计思路基本正确，但有几个关键问题需要改进。以下是具体的实现建议：

1. 错误接口设计问题

你的 RestErr 接口暴露了太多日志相关方法，这违反了接口隔离原则。应该将错误响应和日志记录分离：

// 客户端错误响应接口
type ClientError interface {
    Status() int
    Title() string
    Cause() string
    Error() string
}

// 日志错误接口（内部使用）
type LoggableError interface {
    ClientError
    Path() string
    RawCode() string
    RawMessage() string
    WrapPath(string)
}

// 具体实现
type restErr struct {
    errStatus  int
    errTitle   string
    errCause   string
    
    errPath    string
    errCode    string
    errMessage string
}

func (e *restErr) Status() int { return e.errStatus }
func (e *restErr) Title() string { return e.errTitle }
func (e *restErr) Cause() string { return e.errCause }
func (e *restErr) Path() string { return e.errPath }
func (e *restErr) RawCode() string { return e.errCode }
func (e *restErr) RawMessage() string { return e.errMessage }
func (e *restErr) WrapPath(component string) { 
    e.errPath = component + "/" + e.errPath 
}

2. 错误工厂函数

创建统一的错误创建函数，确保错误格式一致：

func NewRestError(status int, title, cause string) *restErr {
    return &restErr{
        errStatus: status,
        errTitle:  title,
        errCause:  cause,
        errPath:   "",
    }
}

func WrapError(err error, component string, code, message string) *restErr {
    var restErr *restErr
    if errors.As(err, &restErr) {
        restErr.WrapPath(component)
        if code != "" {
            restErr.errCode = code
        }
        if message != "" {
            restErr.errMessage = message
        }
        return restErr
    }
    
    // 如果是普通error，转换为restErr
    return &restErr{
        errStatus:  http.StatusInternalServerError,
        errTitle:   "Internal Server Error",
        errCause:   err.Error(),
        errPath:    component,
        errCode:    code,
        errMessage: message,
    }
}

3. 中间件日志记录

在控制器层面统一记录日志，而不是在每个控制器方法中：

func LoggingMiddleware(logger *zap.Logger) func(http.Handler) http.Handler {
    return func(next http.Handler) http.Handler {
        return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
            start := time.Now()
            
            // 创建自定义ResponseWriter来捕获状态码
            rw := &responseWriter{ResponseWriter: w, statusCode: http.StatusOK}
            
            next.ServeHTTP(rw, r)
            
            duration := time.Since(start)
            
            // 记录请求日志
            logger.Info("request completed",
                zap.String("method", r.Method),
                zap.String("path", r.URL.Path),
                zap.Int("status", rw.statusCode),
                zap.Duration("duration", duration),
                zap.String("user_agent", r.UserAgent()),
            )
        })
    }
}

type responseWriter struct {
    http.ResponseWriter
    statusCode int
}

func (rw *responseWriter) WriteHeader(code int) {
    rw.statusCode = code
    rw.ResponseWriter.WriteHeader(code)
}

4. 错误响应格式化

统一错误响应格式，确保不泄露敏感信息：

func WriteError(w http.ResponseWriter, err error) {
    var clientErr ClientError
    if errors.As(err, &clientErr) {
        response := map[string]interface{}{
            "status": clientErr.Status(),
            "title":  clientErr.Title(),
            "cause":  clientErr.Cause(),
        }
        
        w.Header().Set("Content-Type", "application/json")
        w.WriteHeader(clientErr.Status())
        json.NewEncoder(w).Encode(response)
        
        // 如果是可记录的错误，记录详细信息
        var logErr LoggableError
        if errors.As(err, &logErr) {
            zap.L().Error("request error",
                zap.String("path", logErr.Path()),
                zap.String("code", logErr.RawCode()),
                zap.String("message", logErr.RawMessage()),
                zap.Int("http_status", logErr.Status()),
            )
        }
        return
    }
    
    // 未知错误，返回通用错误
    w.WriteHeader(http.StatusInternalServerError)
    json.NewEncoder(w).Encode(map[string]string{
        "status": "500",
        "title":  "Internal Server Error",
        "cause":  "An unexpected error occurred",
    })
}

5. 使用示例

// 仓库层
func (r *ProductRepo) GetByID(id string) (*Product, error) {
    var product Product
    err := r.db.QueryRow("SELECT * FROM products WHERE id = $1", id).Scan(&product)
    if err != nil {
        if err == sql.ErrNoRows {
            return nil, NewRestError(http.StatusNotFound, "Not Found", "Product not found")
        }
        // 包装数据库错误
        return nil, WrapError(err, "productrepo.GetByID", "DB_ERROR", err.Error())
    }
    return &product, nil
}

// 服务层
func (s *ProductService) GetProduct(id string) (*Product, error) {
    product, err := s.repo.GetByID(id)
    if err != nil {
        return nil, WrapError(err, "productservice.GetProduct", "", "")
    }
    return product, nil
}

// 控制器层
func (c *ProductController) GetProduct(w http.ResponseWriter, r *http.Request) {
    id := r.URL.Query().Get("id")
    product, err := c.service.GetProduct(id)
    if err != nil {
        WriteError(w, WrapError(err, "productcontroller.GetProduct", "", ""))
        return
    }
    
    json.NewEncoder(w).Encode(product)
}

6. 日志聚合器兼容性

对于常见的日志聚合器（如ELK、Loki、Datadog），建议使用结构化日志格式：

// 初始化Zap日志
func NewLogger() *zap.Logger {
    config := zap.NewProductionConfig()
    config.OutputPaths = []string{"stdout"}
    config.EncoderConfig.TimeKey = "timestamp"
    config.EncoderConfig.EncodeTime = zapcore.ISO8601TimeEncoder
    
    logger, _ := config.Build()
    return logger
}

// 日志格式示例（JSON）：
// {
//   "timestamp": "2024-01-15T10:30:00Z",
//   "level": "error",
//   "msg": "request error",
//   "path": "productcontroller.GetProduct/productservice.GetProduct/productrepo.GetByID",
//   "code": "DB_ERROR",
//   "message": "connection refused",
//   "http_status": 500,
//   "trace_id": "abc-123-xyz"  // 分布式追踪ID
// }

关键改进点：

1. 接口分离：将客户端错误和日志错误接口分离
2. 错误包装：使用WrapError统一包装错误，保持调用链
3. 中间件日志：在中间件中统一记录请求日志，避免控制器污染
4. 结构化日志：使用Zap等结构化日志库，方便日志聚合器解析
5. 错误工厂：统一错误创建方式，确保一致性

这种设计符合微服务错误处理的最佳实践，同时满足日志聚合器的格式要求。