文档：https://godoc.org/go.uber.org/zap/zapcore
zapcore定义并实现了构建zap所依赖的底层接口。通过提供这些接口的替代实现，外部包可以扩展zap的功能

内部定义好的encoder

LevelEncoder
func CapitalColorLevelEncoder(l Level, enc PrimitiveArrayEncoder)
func CapitalLevelEncoder(l Level, enc PrimitiveArrayEncoder)
func LowercaseColorLevelEncoder(l Level, enc PrimitiveArrayEncoder)
func LowercaseLevelEncoder(l Level, enc PrimitiveArrayEncoder)

TimeEncoder
func EpochMillisTimeEncoder(t time.Time, enc PrimitiveArrayEncoder)
func EpochNanosTimeEncoder(t time.Time, enc PrimitiveArrayEncoder)
func EpochTimeEncoder(t time.Time, enc PrimitiveArrayEncoder)
func ISO8601TimeEncoder(t time.Time, enc PrimitiveArrayEncoder)
func MillisDurationEncoder(d time.Duration, enc PrimitiveArrayEncoder)
func NanosDurationEncoder(d time.Duration, enc PrimitiveArrayEncoder)
func RFC3339NanoTimeEncoder(t time.Time, enc PrimitiveArrayEncoder)
func RFC3339TimeEncoder(t time.Time, enc PrimitiveArrayEncoder)
func SecondsDurationEncoder(d time.Duration, enc PrimitiveArrayEncoder)
func StringDurationEncoder(d time.Duration, enc PrimitiveArrayEncoder)
CallerEncoder
func FullCallerEncoder(caller EntryCaller, enc PrimitiveArrayEncoder)
func ShortCallerEncoder(caller EntryCaller, enc PrimitiveArrayEncoder)

NameEncoder
func FullNameEncoder(loggerName string, enc PrimitiveArrayEncoder)

type Core

Core是一个最小的、快速的日志记录器接口。它是为库作者设计的，以包装在一个更用户友好的API中

  1. type Core interface {
  2.     LevelEnabler
  3.     With([]Field) Core
  4.     Check(Entry, *CheckedEntry) *CheckedEntry
  5.     Write(Entry, []Field) error
  6.     Sync() error
  7. }

func NewCore(enc Encoder, ws WriteSyncer, enab LevelEnabler) Core
func NewIncreaseLevelCore(core Core, level LevelEnabler) (Core, error)

  • 根据现有的core，创建一个等级更高的core
  • 如果级别降低了日志级别，则返回一个错误

func NewTee(cores …Core) Core 创建一个核心，该核心将日志条目复制到两个或多个底层核心中
func RegisterHooks(core Core, hooks …func(Entry) error) Core

  • registerhook包装一个核心，并在每次记录一条消息时运行用户定义的回调钩子集合

type Encoder

编码器是用于所有日志条目的格式接口
func NewConsoleEncoder(cfg EncoderConfig) Encoder 普通格式编码器
func NewJSONEncoder(cfg EncoderConfig) Encoder json格式编码器

type EncoderConfig

  1. type EncoderConfig struct {
  2.     MessageKey    string `json:"messageKey" yaml:"messageKey"`
  3.     LevelKey      string `json:"levelKey" yaml:"levelKey"`
  4.     TimeKey       string `json:"timeKey" yaml:"timeKey"`
  5.     NameKey       string `json:"nameKey" yaml:"nameKey"`
  6.     CallerKey     string `json:"callerKey" yaml:"callerKey"`
  7.     FunctionKey   string `json:"functionKey" yaml:"functionKey"`
  8.     StacktraceKey string `json:"stacktraceKey" yaml:"stacktraceKey"`
  9.     LineEnding    string `json:"lineEnding" yaml:"lineEnding"`  // 换行符
  11.     EncodeLevel    LevelEncoder    `json:"levelEncoder" yaml:"levelEncoder"`
  12.     EncodeTime     TimeEncoder     `json:"timeEncoder" yaml:"timeEncoder"`
  13.     EncodeDuration DurationEncoder `json:"durationEncoder" yaml:"durationEncoder"`
  14.     EncodeCaller   CallerEncoder   `json:"callerEncoder" yaml:"callerEncoder"`
  15.     EncodeName NameEncoder `json:"nameEncoder" yaml:"nameEncoder"`
  16.     // 普通格式的分隔符
  17.     ConsoleSeparator string `json:"consoleSeparator" yaml:"consoleSeparator"`
  18. }

type Level

  1. type Level int8
  2. const (
  3.     // DebugLevel logs are typically voluminous, and are usually disabled in
  4.     // production.
  5.     DebugLevel Level = iota - 1
  6.     // InfoLevel is the default logging priority.
  7.     InfoLevel
  8.     // WarnLevel logs are more important than Info, but don't need individual
  9.     // human review.
  10.     WarnLevel
  11.     // ErrorLevel logs are high-priority. If an application is running smoothly,
  12.     // it shouldn't generate any error-level logs.
  13.     ErrorLevel
  14.     // DPanicLevel logs are particularly important errors. In development the
  15.     // logger panics after writing the message.
  16.     DPanicLevel
  17.     // PanicLevel logs a message, then panics.
  18.     PanicLevel
  19.     // FatalLevel logs a message, then calls os.Exit(1).
  20.     FatalLevel
  21. )

func (l Level) CapitalString() string
func (l Level) Enabled(lvl Level) bool
func (l Level) Get() interface{}
func (l Level) Set(s string) error
func (l Level) String() string

type LevelEnabler

LevelEnabler决定在记录消息时是否启用给定的日志级别，他会给本身或更高的级别返回true

  1. type LevelEnabler interface {
  2.     Enabled(Level) bool
  3. }

type TimeEncoder

时间格式化器

  1. type TimeEncoder func(time.Time, PrimitiveArrayEncoder)

func TimeEncoderOfLayout(layout string) TimeEncoder 指定一个序列化格式（版本低的没这个方法）

type WriteSyncer

WriteSyncer是一个io。也可以刷新任何缓冲数据的写入器
*os.File (and thus, os.Stderr and os.Stdout) 已实现也这个接口

  1. type WriteSyncer interface {
  2.     io.Writer
  3.     Sync() error
  4. }

func AddSync(w io.Writer) WriteSyncer
func Lock(ws WriteSyncer) WriteSyncer Lock将WriteSyncer包装在互斥锁中，以确保并发使用时安全
func NewMultiWriteSyncer(ws …WriteSyncer) WriteSyncer

type Entry

entry表示一直完整的日志信息

  1. type Entry struct {
  2.     Level      Level
  3.     Time       time.Time
  4.     LoggerName string
  5.     Message    string
  6.     Caller     EntryCaller
  7.     Stack      string
  8. }

type EntryCaller

EntryCaller表示日志函数的调用者

  1. type EntryCaller struct {
  2.     Defined  bool
  3.     PC       uintptr
  4.     File     string
  5.     Line     int
  6.     Function string
  7. }
  9. func NewEntryCaller(pc uintptr, file string, line int, ok bool) EntryCaller
  10. func (ec EntryCaller) FullPath() string
  11. func (ec EntryCaller) String() string
  12. func (ec EntryCaller) TrimmedPath() string

type Field

用于向记录器的上下文添加键-值对

  1. type Field struct {
  2.     Key       string
  3.     Type      FieldType
  4.     Integer   int64
  5.     String    string
  6.     Interface interface{}
  7. }

例子

按级输出

也可以参考logrus写两个log记录器

  1. import (
  2.     "github.com/lestrrat-go/file-rotatelogs"
  3.     "go.uber.org/zap"
  4.     "go.uber.org/zap/zapcore"
  5.     "io"
  6.     "strings"
  7.     "time"
  8. )
  10. var log *zap.Logger
  12. func init() {
  13.     // 设置一些基本日志格式 具体含义还比较好理解，直接看zap源码也不难懂
  14.     encoder := zapcore.NewConsoleEncoder(zapcore.EncoderConfig{
  15.         MessageKey:    "msg",
  16.         LevelKey:      "level",
  17.         CallerKey:     "caller",
  18.         StacktraceKey: "stacktrace",
  19.         TimeKey:       "ts",
  20.         LineEnding:    zapcore.DefaultLineEnding,   //换行符
  21.         EncodeLevel:   zapcore.CapitalLevelEncoder, // 小写编码器
  22.         EncodeTime: zapcore.TimeEncoderOfLayout("2006-01-02 15:04:05"),
  23.         EncodeCaller: zapcore.FullCallerEncoder, // 全路径编码器
  24.         EncodeName:   zapcore.FullNameEncoder,
  25.         EncodeDuration: func(d time.Duration, enc zapcore.PrimitiveArrayEncoder) {
  26.             enc.AppendInt64(int64(d) / 1000000)
  27.         },
  28.     })
  30.     // 实现两个判断日志等级的interface
  31.     infoLevel := zap.LevelEnablerFunc(func(lvl zapcore.Level) bool {
  32.         return lvl <= zapcore.InfoLevel
  33.     })
  35.     errorLevel := zap.LevelEnablerFunc(func(lvl zapcore.Level) bool {
  36.         return lvl >= zapcore.ErrorLevel
  37.     })
  39.     //infoLevel := zap.NewAtomicLevelAt(zapcore.InfoLevel)
  40.     //errorLevel := zap.NewAtomicLevelAt(zapcore.ErrorLevel)
  42.     // 获取 info、error日志文件的io.Writer 抽象 getWriter() 在下方实现
  43.     infoWriter := getWriter("./logs/demo_info.log")
  44.     errorWriter := getWriter("./logs/demo_error.log")
  46.     // 最后创建具体的Logger
  47.     core := zapcore.NewTee(
  48.         zapcore.NewCore(encoder, zapcore.AddSync(infoWriter), infoLevel),
  49.         zapcore.NewCore(encoder, zapcore.AddSync(errorWriter), errorLevel),
  50.     )
  52.     log = zap.New(core, zap.AddCaller())
  53. }
  55. func getWriter(filename string) io.Writer {
  56.     // 生成rotatelogs的Logger 实际生成的文件名 demo.log.YYmmddHH
  57.     // demo.log是指向最新日志的链接
  58.     // 保存7天内的日志，每1小时(整点)分割一次日志
  59.     hook, err := rotatelogs.New(
  60.         strings.Replace(filename, ".log", "", -1) + "-%Y%m%d%H.log", // 没有使用go风格反人类的format格式
  61.         //rotatelogs.WithLinkName(filename),
  62.         //rotatelogs.WithMaxAge(time.Hour*24*7),
  63.         //rotatelogs.WithRotationTime(time.Hour),
  64.     )
  66.     if err != nil {
  67.         panic(err)
  68.     }
  69.     return hook
  70. }
  72. func main() {
  73.     log.Info("1111111111")
  74.     log.Error("22222222222")
  75. }

日志分割

  1. type trace zap.LevelEnablerFunc
  3. func (t trace) Enabled(zapcore.Level) bool {
  4.     return true
  5. }
  7. func main() {
  8.     hook := lumberjack.Logger{
  9.         Filename:   "./logs/spikeProxy1.log", // 日志文件路径
  10.         MaxSize:    128,                      // 每个日志文件保存的最大尺寸 单位：M
  11.         MaxBackups: 30,                       // 日志文件最多保存多少个备份
  12.         MaxAge:     7,                        // 文件最多保存多少天
  13.         Compress:   true,                     // 是否压缩
  14.     }
  16.     encoderConfig := zapcore.EncoderConfig{
  17.         TimeKey:        "time",
  18.         LevelKey:       "level",
  19.         NameKey:        "logger",
  20.         CallerKey:      "caller",
  21.         MessageKey:     "msg",
  22.         StacktraceKey:  "stacktrace",
  23.         LineEnding:     zapcore.DefaultLineEnding,
  24.         EncodeLevel:    zapcore.LowercaseLevelEncoder,  // 小写编码器
  25.         EncodeTime:     zapcore.ISO8601TimeEncoder,     // ISO8601 UTC 时间格式
  26.         EncodeDuration: zapcore.SecondsDurationEncoder, //
  27.         EncodeCaller:   zapcore.FullCallerEncoder,      // 全路径编码器
  28.         EncodeName:     zapcore.FullNameEncoder,
  29.     }
  31.     // 设置日志级别
  32.     atomicLevel := zap.NewAtomicLevel()
  33.     atomicLevel.SetLevel(zap.InfoLevel)
  35.     core := zapcore.NewCore(
  36.         zapcore.NewJSONEncoder(encoderConfig),                                           // 编码器配置
  37.         zapcore.NewMultiWriteSyncer(zapcore.AddSync(os.Stdout), zapcore.AddSync(&hook)), // 打印到控制台和文件
  38.         atomicLevel, // 日志级别
  39.     )
  41.     // 开启调用者信息
  42.     caller := zap.AddCaller()
  43.     var t trace
  44.     stacktrace := zap.AddStacktrace(t)
  45.     // 设置初始化字段
  46.     filed := zap.Fields(zap.String("serviceName", "serviceName"))
  47.     // 构造日志
  48.     logger := zap.New(core, caller, stacktrace, filed)
  49.     run(logger)
  51. }
  53. func run(logger *zap.Logger) {
  54.     logger.Info("log 初始化成功")
  55.     logger.Info("无法获取网址",
  56.         zap.String("url", "http://www.baidu.com"),
  57.         zap.Int("attempt", 3),
  58.         zap.Duration("backoff", time.Second))
  59. }

image.png
文件如下

  1. {"level":"info","time":"2020-10-28T12:10:21.458+0800","caller":"C:/Users/user/Desktop/GOProject/src/study/zap/demo1/demo4.go:72","msg":"log 初始化成功","serviceName":"serviceName","stacktrace":"main.run\n\tC:/Users/user/Desktop/GOProject/src/study/zap/demo1/demo4.go:72\nmain.main\n\tC:/Users/user/Desktop/GOProject/src/study/zap/demo1/demo4.go:67\nruntime.main\n\tD:/Go1.14/src/runtime/proc.go:203"}
  2. {"level":"info","time":"2020-10-28T12:10:21.517+0800","caller":"C:/Users/user/Desktop/GOProject/src/study/zap/demo1/demo4.go:73","msg":"无法获取网址","serviceName":"serviceName","url":"http://www.baidu.com","attempt":3,"backoff":1,"stacktrace":"main.run\n\tC:/Users/user/Desktop/GOProject/src/study/zap/demo1/demo4.go:73\nmain.main\n\tC:/Users/user/Desktop/GOProject/src/study/zap/demo1/demo4.go:67\nruntime.main\n\tD:/Go1.14/src/runtime/proc.go:203"}

重写callerEncoder加上requesID

以grpc为例

  1. var (
  2.     option    *Option
  3.     accessLog *zap.Logger
  4. )
  6. type Option struct {
  7.     Name   string
  8.     Trace  bool
  9.     Logger *logging.ZapLogger
  10. }
  12. func Init(opt *Option) error {
  13.     option = opt
  14.     if option.Logger == nil {
  15.         option.Logger = logging.ConfigLogger()
  16.     }
  17.     logging.ReplaceGrpcLoggerV2(option.Logger.Logger)
  18.     logging.ReplaceGormLogger(option.Logger.Logger)
  19.     if accessLog == nil {
  20.         accessLog = logging.NewAccessLogger(&config.LoggerConfig{}, opt.Name)
  21.     }
  22.     fmt.Printf("grpckit init %s trace %t\n", option.Name, option.Trace)
  23.     grpclog.Infof("grpckit init %s trace %t", option.Name, option.Trace)
  25.     loadDotenv()
  27.     return nil
  28. }
  30. func loadDotenv() {
  31.     _ = godotenv.Load(".env")               // 项目根目录
  32.     _ = godotenv.Load("/etc/dotenv/dotenv") // k8s 挂载目录
  33. }
  35. func NewServer() *grpc.Server {
  36.     var interceptors []grpc.UnaryServerInterceptor
  38.     opts := []grpc_zap.Option{
  39.         grpc_zap.WithDecider(logging.Decider()),
  40.         grpc_zap.WithMessageProducer(logging.MessageProducer()),
  41.     }
  43.     interceptors = append(interceptors, grpc_zap.UnaryServerInterceptor(accessLog, opts...))
  44.     // alwaysLoggingDeciderServer := func(ctx context.Context, fullMethodName string, servingObject interface{}) bool {
  45.     //     return !strings.Contains(fullMethodName, "ExecuteTask")
  46.     // }
  47.     // interceptors = append(interceptors, grpc_zap.PayloadUnaryServerInterceptor(accessLog, alwaysLoggingDeciderServer))
  49.     if option.Trace {
  50.         interceptors = append(
  51.             interceptors,
  52.             UnaryServerTraceInterceptor(),
  53.         )
  54.     }
  56.     maxMsgSize := 1024 * 1024 * 16
  57.     grpcServer := grpc.NewServer(
  58.         grpc.MaxRecvMsgSize(maxMsgSize),
  59.         grpc.UnaryInterceptor(grpc_middleware.ChainUnaryServer(
  60.             interceptors...,
  61.         )),
  62.     )
  64.     healthService := health.NewGrpcHealthChecker()
  65.     grpc_health_v1.RegisterHealthServer(grpcServer, healthService)
  67.     return grpcServer
  68. }
  1. type ZapLogger struct {
  2.     Logger *zap.Logger
  3. }
  5. func NewLogger(conf *config.LoggerConfig) *ZapLogger {
  6.     return NewLoggerWithEncoder(conf, zapcore.ISO8601TimeEncoder, GrpcCallerEncoder)
  7. }
  9. func NewLoggerWithEncoder(conf *config.LoggerConfig, timeEncoder zapcore.TimeEncoder, callerEncoder zapcore.CallerEncoder) *ZapLogger {
  11.     encoderConf := zap.NewProductionEncoderConfig()
  12.     encoderConf.EncodeTime = timeEncoder
  13.     encoderConf.EncodeCaller = callerEncoder
  14.     encoder := zapcore.NewConsoleEncoder(encoderConf)
  15.     ws, level := Conf2LogArgs(conf)
  16.     return &ZapLogger{
  17.         Logger: zap.New(
  18.             zapcore.NewCore(encoder, ws, zap.NewAtomicLevelAt(level)),
  19.             zap.AddCaller(),
  20.             zap.AddCallerSkip(2),
  21.         ),
  22.     }
  23. }
  25. func GrpcCallerEncoder(caller zapcore.EntryCaller, enc zapcore.PrimitiveArrayEncoder) {
  26.     if ctx, ok := GetContext(); ok {
  27.         value := fmt.Sprintf(" request-id: %s group-id: %s station-id: %s account-id: %s username: %s ", ctx.RequestId, ctx.GroupId, ctx.StationId, ctx.AccountId, ctx.Username)
  28.         enc.AppendString(value)
  29.     }
  31.     enc.AppendString(caller.TrimmedPath())
  32. }
  1. // 将 proto message 转化为对人友好的字符串
  2. func formatMessage(msg interface{}) string {
  3.     if m, ok := msg.(proto.Message); ok {
  4.         return fmt.Sprintf("%v", protojson.MarshalOptions{}.Format(m))
  5.     }
  6.     return fmt.Sprintf("%v", msg)
  7. }
  9. func UnaryServerTraceInterceptor() grpc.UnaryServerInterceptor {
  10.     return func(ctx context.Context, req interface{}, info *grpc.UnaryServerInfo, handler grpc.UnaryHandler) (resp interface{}, err error) {
  11.         shortMethod := info.FullMethod[strings.LastIndex(info.FullMethod, ".")+1:]
  13.         md, _ := metadata.FromIncomingContext(ctx)
  15.         logging.SetContext(shortMethod, md)
  17.         defer func() {
  18.             if r := recover(); r != nil {
  19.                 stack := debug.Stack()
  20.                 msg := fmt.Sprintf("server panic %s %v\n%s", shortMethod, r, stack)
  21.                 os.Stderr.Write([]byte(msg))
  22.                 grpclog.Errorf(msg)
  23.                 err = status.Errorf(codes.Internal, "server panic")
  24.                 resp = nil
  25.             }
  26.         }()
  27.         startTime := time.Now()
  28.         resp, err = handler(ctx, req)
  29.         if err == nil {
  30.             //grpclog.Infof("server trace response method: %s response: %s", shortMethod, formatMessage(resp))
  31.             if info.FullMethod != "/grpc.health.v1.Health/Check" && !strings.Contains(info.FullMethod, "SysSync") && !strings.Contains(info.FullMethod, "UploadFile") {
  32.                 grpclog.Infof("server trace method: %s elapsed: %v request: %v", shortMethod, time.Since(startTime), formatMessage(req))
  33.             }
  34.         } else {
  35.             grpclog.Infof("server trace method: %s metadata: %v request: %s response: %s error: %v", shortMethod, md, formatMessage(req), formatMessage(resp), err)
  36.         }
  38.         logging.DelContext()
  40.         return resp, err
  41.     }
  42. }
  44. func UnaryClientTraceInterceptor() grpc.UnaryClientInterceptor {
  45.     return func(ctx context.Context, method string, req, resp interface{}, cc *grpc.ClientConn, invoker grpc.UnaryInvoker, opts ...grpc.CallOption) error {
  46.         shortMethod := method[strings.LastIndex(method, ".")+1:]
  48.         startTime := time.Now()
  49.         err := invoker(ctx, method, req, resp, cc, opts...)
  50.         if err == nil {
  51.             if method != "/grpc.health.v1.Health/Check" && !strings.Contains(method, "SysSync") {
  52.                 grpclog.Infof("client trace method: %s elapsed: %v", shortMethod, time.Since(startTime))
  53.             }
  55.             // grpclog.Infof("client trace response method: %s response: %s", shortMethod, formatMessage(resp))
  56.             // grpclog.Infof("client trace response method: %s", shortMethod)
  57.         } else {
  58.             grpclog.Infof("client trace method: %s request: %s response: %s error: %v", shortMethod, formatMessage(req), formatMessage(resp), err)
  59.         }
  61.         return err
  62.     }
  63. }
  65. func UnaryClientOutgoingContextInterceptor() grpc.UnaryClientInterceptor {
  66.     return func(ctx context.Context, method string, req, resp interface{}, cc *grpc.ClientConn, invoker grpc.UnaryInvoker, opts ...grpc.CallOption) error {
  67.         md, ok := metadata.FromIncomingContext(ctx)
  68.         if ok {
  69.             ctx = metadata.NewOutgoingContext(ctx, md)
  70.         }
  72.         err := invoker(ctx, method, req, resp, cc, opts...)
  73.         return err
  74.     }
  75. }
  1. var (
  2.     UserIdKey    = "x-user-id"
  3.     ClientIdKey  = "x-client-id"
  4.     RequestIdKey = "x-request-id"
  5.     GroupIdKey   = "x-group-id"
  6.     StationIdKey = "x-station-id"
  7.     AccountIdKey = "x-account-id"
  8.     UsernameKey  = "x-username"
  10.     Contexts sync.Map
  11. )
  13. type Context struct {
  14.     Method    string
  15.     UserId    string
  16.     ClientId  string
  17.     RequestId string
  18.     GroupId   string
  19.     StationId string
  20.     AccountId string
  21.     Username  string
  22. }
  24. func SetContext(method string, md metadata.MD) {
  25.     ctx := &Context{
  26.         Method:    method,
  27.         UserId:    "-",
  28.         ClientId:  "-",
  29.         RequestId: "-",
  30.         GroupId:   "-",
  31.         StationId: "-",
  32.         AccountId: "-",
  33.         Username:  "-",
  34.     }
  36.     ctx.Method = method
  38.     var values []string
  40.     values = md[UserIdKey]
  41.     if len(values) == 1 {
  42.         ctx.UserId = values[0]
  43.     }
  45.     values = md[ClientIdKey]
  46.     if len(values) == 1 {
  47.         ctx.ClientId = values[0]
  48.     }
  50.     values = md[RequestIdKey]
  51.     if len(values) == 1 {
  52.         ctx.RequestId = values[0]
  53.     }
  55.     values = md[GroupIdKey]
  56.     if len(values) == 1 {
  57.         ctx.GroupId = values[0]
  58.     }
  60.     values = md[StationIdKey]
  61.     if len(values) == 1 {
  62.         ctx.StationId = values[0]
  63.     }
  65.     values = md[AccountIdKey]
  66.     if len(values) == 1 {
  67.         ctx.AccountId = values[0]
  68.     }
  70.     values = md[UsernameKey]
  71.     if len(values) == 1 {
  72.         ctx.Username = values[0]
  73.     }
  75.     Contexts.Store(routine.Getgid(), ctx)
  76. }
  78. func GetContext() (*Context, bool) {
  79.     if v, ok := Contexts.Load(routine.Getgid()); ok {
  80.         if ctx, ok := v.(*Context); ok {
  81.             return ctx, true
  82.         }
  83.     }
  84.     return nil, false
  85. }
  87. func DelContext() {
  88.     Contexts.Delete(routine.Getgid())
  89. }
  91. func Getgid() int64 {
  92.     b := make([]byte, 64)
  93.     b = b[:runtime.Stack(b, false)]
  94.     b = bytes.TrimPrefix(b, []byte("goroutine "))
  95.     b = b[:bytes.IndexByte(b, ' ')]
  96.     i, _ := strconv.ParseInt(string(b), 10, 64)
  97.     return i
  98. }

需要注意的是，实现了proto的message接口的，在用protoc生成代码时，都会有一个String方法，能方便的打印结构体(嵌套，指针)