如何在Go中强制库定义错误与消费者计数器构建时一一匹配？

我维护一个Go库，为特定函数定义了若干错误类别，示例代码如下：

var (
    ErrNotFound         = errors.New("not found")
    ErrFailedParsing    = errors.New("failed parsing")
    ErrFailedProcessing = errors.New("failed processing")
)

func Run() error {
    if 1 != 2 {
        return ErrNotFound
    }

    return nil
}

调用方针对这些错误设置了指标计数器，示例代码：

var (
    NotFoundCounter         int
    FailedParsingCounter    int
    FailedProcessingCounter int
)

func main() {
    err := Run()
    if err != nil {
        switch err {
        case ErrNotFound:
            NotFoundCounter += 1
        case ErrFailedParsing:
            FailedParsingCounter += 1
        case ErrFailedProcessing:
            FailedProcessingCounter += 1
        }
    }

    fmt.Printf("counters: %d %d %d\n", NotFoundCounter, FailedParsingCounter, FailedProcessingCounter)
}

当前实现存在脆弱性：如果库新增ErrServiceUnavailable这类错误，调用方的计数器逻辑会直接忽略该错误，最多只能在运行时归为未分类错误。我需要构建时强制库定义的错误与计数器一一对应，类似Rust的穷尽式switch/case。已知反射（单元测试）、库内注册指标、go vet等方案，但认为这些都是权宜之计，求更优解。

1. 自定义错误枚举类型（编译期检查核心方案） #

放弃直接用errors.New创建独立错误，改用带枚举标记的自定义错误类型，配合go vet的枚举穷尽检查，实现编译期强制覆盖：

库端实现 #

package mylib

// 定义错误类型枚举，所有库错误必须属于此枚举的取值
type ErrType int

const (
    ErrTypeNotFound ErrType = iota
    ErrTypeFailedParsing
    ErrTypeFailedProcessing
    // 新增错误时必须在此添加对应枚举值
)

// 自定义错误类型，包含枚举标记与错误信息
type LibError struct {
    Type ErrType
    Msg  string
}

func (e LibError) Error() string {
    return e.Msg
}

// 预定义库错误，与枚举值一一绑定
var (
    ErrNotFound         = LibError{Type: ErrTypeNotFound, Msg: "not found"}
    ErrFailedParsing    = LibError{Type: ErrTypeFailedParsing, Msg: "failed parsing"}
    ErrFailedProcessing = LibError{Type: ErrTypeFailedProcessing, Msg: "failed processing"}
)

func Run() error {
    if 1 != 2 {
        return ErrNotFound
    }
    return nil
}

调用方实现 #

调用方通过type switch识别库错误，配合exhaustive vet检查器强制覆盖所有枚举分支：

package main

import (
    "fmt"
    "mylib"
)

var (
    NotFoundCounter         int
    FailedParsingCounter    int
    FailedProcessingCounter int
    // 新增错误时必须同步新增对应计数器
)

func main() {
    err := mylib.Run()
    if err != nil {
        libErr, ok := err.(mylib.LibError)
        if !ok {
            // 处理非库定义错误（可选逻辑）
            return
        }

        // switch分支未覆盖所有ErrType枚举值时，exhaustive vet会触发编译警告
        switch libErr.Type {
        case mylib.ErrTypeNotFound:
            NotFoundCounter += 1
        case mylib.ErrTypeFailedParsing:
            FailedParsingCounter += 1
        case mylib.ErrTypeFailedProcessing:
            FailedProcessingCounter += 1
        }
    }

    fmt.Printf("counters: %d %d %d\n", NotFoundCounter, FailedParsingCounter, FailedProcessingCounter)
}

使用时需安装exhaustive vet检查器：go install github.com/nishanths/exhaustive@latest，然后执行go vet -vettool=$(which exhaustive) ./...，只要库新增了ErrType枚举值，调用方未更新switch分支就会触发错误，实现编译期检查。

2. 代码生成（彻底自动化方案） #

如果不想手动维护枚举与计数器的对应关系，可通过代码生成实现全自动化：

• 库端维护一份错误定义清单（比如用注释标记、JSON或YAML文件）
• 编写Go生成器，自动生成：
  1. 库的错误变量、枚举类型以及所有错误的列表
  2. 调用方的计数器变量、完整的switch分支逻辑
• 每次库新增错误，只需更新清单并重新生成代码，生成器会自动确保计数器与错误一一对应，漏写直接导致编译失败。

3. 错误-计数器绑定接口（准编译期检查） #

库端提供注册接口，强制调用方为所有预定义错误绑定计数器，在程序启动阶段检查覆盖情况：

库端实现 #

package mylib

import "errors"

var (
    ErrNotFound         = errors.New("not found")
    ErrFailedParsing    = errors.New("failed parsing")
    ErrFailedProcessing = errors.New("failed processing")

    // 导出所有库错误的列表，新增错误必须加入此列表
    AllErrors = []error{ErrNotFound, ErrFailedParsing, ErrFailedProcessing}
)

// CounterBinder 定义错误到计数器的绑定逻辑
type CounterBinder func(err error) *int

// RegisterCounters 必须传入覆盖所有AllErrors的绑定函数，否则初始化时 panic
func RegisterCounters(binder CounterBinder) {
    for _, err := range AllErrors {
        if binder(err) == nil {
            panic("unregistered error: " + err.Error())
        }
    }
}

调用方实现 #

package main

import (
    "fmt"
    "mylib"
)

var (
    NotFoundCounter         int
    FailedParsingCounter    int
    FailedProcessingCounter int
)

// 全局绑定函数，必须覆盖所有库错误
var counterBinder = func(err error) *int {
    switch err {
    case mylib.ErrNotFound:
        return &NotFoundCounter
    case mylib.ErrFailedParsing:
        return &FailedParsingCounter
    case mylib.ErrFailedProcessing:
        return &FailedProcessingCounter
    default:
        return nil
    }
}

func main() {
    // 启动时检查是否遗漏错误绑定，CI阶段即可发现问题
    mylib.RegisterCounters(counterBinder)

    err := mylib.Run()
    if err != nil {
        if cnt := counterBinder(err); cnt != nil {
            *cnt += 1
        }
    }

    fmt.Printf("counters: %d %d %d\n", NotFoundCounter, FailedParsingCounter, FailedProcessingCounter)
}

该方案虽不是严格编译期检查，但能在程序启动（或CI测试）阶段立即发现遗漏，避免错误在生产环境被忽略。

内容的提问来源于stack exchange，提问作者Lem0n