聊聊golang的zap的Sink

序

本文主要研究一下golang的zap的Sink

Sink

zap@v1.16.0/sink.go

type Sink interface {
    zapcore.WriteSyncer
    io.Closer
}

type WriteSyncer interface {
    io.Writer
    Sync() error
}

type Writer interface {
    Write(p []byte) (n int, err error)
}

type Closer interface {
    Close() error
}

Sink接口内嵌了zapcore.WriteSyncer(Write、Sync)、io.Closer(Close)接口

RegisterSink

zap@v1.16.0/sink.go

const schemeFile = "file"

var (
    _sinkMutex     sync.RWMutex
    _sinkFactories map[string]func(*url.URL) (Sink, error) // keyed by scheme
)

func init() {
    resetSinkRegistry()
}

func resetSinkRegistry() {
    _sinkMutex.Lock()
    defer _sinkMutex.Unlock()

    _sinkFactories = map[string]func(*url.URL) (Sink, error){
        schemeFile: newFileSink,
    }
}

func RegisterSink(scheme string, factory func(*url.URL) (Sink, error)) error {
    _sinkMutex.Lock()
    defer _sinkMutex.Unlock()

    if scheme == "" {
        return errors.New("can't register a sink factory for empty string")
    }
    normalized, err := normalizeScheme(scheme)
    if err != nil {
        return fmt.Errorf("%q is not a valid scheme: %v", scheme, err)
    }
    if _, ok := _sinkFactories[normalized]; ok {
        return fmt.Errorf("sink factory already registered for scheme %q", normalized)
    }
    _sinkFactories[normalized] = factory
    return nil
}

RegisterSink方法会往_sinkFactories注册指定scheme的sink factory，该factory接收url.URL返回Sink；resetSinkRegistry方法默认注册了scheme为file的newFileSink

newFileSink

zap@v1.16.0/sink.go

func newFileSink(u *url.URL) (Sink, error) {
    if u.User != nil {
        return nil, fmt.Errorf("user and password not allowed with file URLs: got %v", u)
    }
    if u.Fragment != "" {
        return nil, fmt.Errorf("fragments not allowed with file URLs: got %v", u)
    }
    if u.RawQuery != "" {
        return nil, fmt.Errorf("query parameters not allowed with file URLs: got %v", u)
    }
    // Error messages are better if we check hostname and port separately.
    if u.Port() != "" {
        return nil, fmt.Errorf("ports not allowed with file URLs: got %v", u)
    }
    if hn := u.Hostname(); hn != "" && hn != "localhost" {
        return nil, fmt.Errorf("file URLs must leave host empty or use localhost: got %v", u)
    }
    switch u.Path {
    case "stdout":
        return nopCloserSink{os.Stdout}, nil
    case "stderr":
        return nopCloserSink{os.Stderr}, nil
    }
    return os.OpenFile(u.Path, os.O_WRONLY|os.O_APPEND|os.O_CREATE, 0666)
}

newFileSink使用os.OpenFile创建*os.File，由于*os.File拥有Write、Sync、Close方法，因而它实现了Sink接口

newSink

zap@v1.16.0/sink.go

func newSink(rawURL string) (Sink, error) {
    u, err := url.Parse(rawURL)
    if err != nil {
        return nil, fmt.Errorf("can't parse %q as a URL: %v", rawURL, err)
    }
    if u.Scheme == "" {
        u.Scheme = schemeFile
    }

    _sinkMutex.RLock()
    factory, ok := _sinkFactories[u.Scheme]
    _sinkMutex.RUnlock()
    if !ok {
        return nil, &errSinkNotFound{u.Scheme}
    }
    return factory(u)
}

newSink方法会根据rawURL解析对应的scheme，如果scheme为空则默认为file，然后从_sinkFactories找到对应的factory，创建sink返回

open

zap@v1.16.0/writer.go

func Open(paths ...string) (zapcore.WriteSyncer, func(), error) {
    writers, close, err := open(paths)
    if err != nil {
        return nil, nil, err
    }

    writer := CombineWriteSyncers(writers...)
    return writer, close, nil
}

func open(paths []string) ([]zapcore.WriteSyncer, func(), error) {
    writers := make([]zapcore.WriteSyncer, 0, len(paths))
    closers := make([]io.Closer, 0, len(paths))
    close := func() {
        for _, c := range closers {
            c.Close()
        }
    }

    var openErr error
    for _, path := range paths {
        sink, err := newSink(path)
        if err != nil {
            openErr = multierr.Append(openErr, fmt.Errorf("couldn't open sink %q: %v", path, err))
            continue
        }
        writers = append(writers, sink)
        closers = append(closers, sink)
    }
    if openErr != nil {
        close()
        return writers, nil, openErr
    }

    return writers, close, nil
}

zap.Open方法会使用newSink来创建sink作为zapcore.WriteSyncer

实例

func registerSinkDemo() {
    zap.RegisterSink("mq", mq.NewMqSink)
    writer, close, err := zap.Open("mq://192.168.99.100:9876/log")
    if err != nil {
        panic(err)
    }
    defer close()
    logger := zap.New(zapcore.NewCore(zapcore.NewJSONEncoder(zap.NewProductionEncoderConfig()), writer, zap.DebugLevel)).Sugar()
    logger.Info("hello")
}

type MqWriteSyncer struct {
    topic    string
    producer rocketmq.Producer
    ctx      context.Context
}

func (m *MqWriteSyncer) Close() error {
    return m.producer.Shutdown()
}

func (m *MqWriteSyncer) Write(p []byte) (n int, err error) {
    msg := &primitive.Message{
        Topic: m.topic,
        Body:  p,
    }
    err = m.producer.SendOneWay(m.ctx, msg)
    return len(p), err
}

func (m *MqWriteSyncer) Sync() error {
    return nil
}

func NewMqSink(url *url.URL) (zap.Sink, error) {
    broker := fmt.Sprintf("%s:%s", url.Hostname(), url.Port())
    topic := url.Path[1:len(url.Path)]
    p, _ := rocketmq.NewProducer(
        producer.WithNameServer([]string{broker}),
        producer.WithRetry(2),
    )
    err := p.Start()
    if err != nil {
        fmt.Printf("start producer error: %s", err.Error())
        return nil, err
    }

    return &MqWriteSyncer{producer: p, ctx: context.Background(), topic: topic}, nil
}

这里通过zap.RegisterSink来注册一个mq的sink factory，然后通过zap.Open来创建MqWriteSyncer；MqWriteSyncer实现了zapcore.WriteSyncer的Write、Sync方法，同时也实现了Sink的Close方法

小结

Sink接口内嵌了zapcore.WriteSyncer(Write、Sync)、io.Closer(Close)接口；zap.RegisterSink用于注册指定scheme的sink factory，而zap.Open则会解析url来找到对应的sink factory创建对应的sink，即writer。

doc

• zap