序
本文主要研究一下golang的zap的Sink
Sink
[email protected]/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
[email protected]/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
[email protected]/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
[email protected]/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
[email protected]/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。