Add option to override sink and encoder (uber-go#1438)

Makes it possible to override/wrap encoder/sink

config.go

@@ -237,12 +237,12 @@ func NewDevelopmentConfig() Config {
 
 // Build constructs a logger from the Config and Options.
 func (cfg Config) Build(opts ...Option) (*Logger, error) {
-	enc, err := cfg.buildEncoder()
+	enc, err := cfg.buildEncoder(filterOptions[WrapEncoderOption](opts...)...)
 	if err != nil {
 		return nil, err
 	}
 
-	sink, errSink, err := cfg.openSinks()
+	sink, errSink, err := cfg.openSinks(filterOptions[WrapSinkersOption](opts...)...)
 	if err != nil {
 		return nil, err
 	}
@@ -256,7 +256,7 @@ func (cfg Config) Build(opts ...Option) (*Logger, error) {
 		cfg.buildOptions(errSink)...,
 	)
 	if len(opts) > 0 {
-		log = log.WithOptions(opts...)
+		log = log.WithOptions(filterOptions[Option](opts...)...)
 	}
 	return log, nil
 }
@@ -312,19 +312,38 @@ func (cfg Config) buildOptions(errSink zapcore.WriteSyncer) []Option {
 	return opts
 }
 
-func (cfg Config) openSinks() (zapcore.WriteSyncer, zapcore.WriteSyncer, error) {
+func (cfg Config) openSinks(opts ...WrapSinkersOption) (zapcore.WriteSyncer, zapcore.WriteSyncer, error) {
 	sink, closeOut, err := Open(cfg.OutputPaths...)
 	if err != nil {
 		return nil, nil, err
 	}
-	errSink, _, err := Open(cfg.ErrorOutputPaths...)
+	errSink, errCloseOut, err := Open(cfg.ErrorOutputPaths...)
 	if err != nil {
 		closeOut()
 		return nil, nil, err
 	}
+
+	for _, opt := range opts {
+		sink, errSink, err = opt.wrapSink(cfg.OutputPaths, sink, cfg.ErrorOutputPaths, errSink)
+		if err != nil {
+			closeOut()
+			errCloseOut()
+			return nil, nil, err
+		}
+	}
 	return sink, errSink, nil
 }
 
-func (cfg Config) buildEncoder() (zapcore.Encoder, error) {
-	return newEncoder(cfg.Encoding, cfg.EncoderConfig)
+func (cfg Config) buildEncoder(opts ...WrapEncoderOption) (zapcore.Encoder, error) {
+	enc, err := newEncoder(cfg.Encoding, cfg.EncoderConfig)
+	if err != nil {
+		return nil, err
+	}
+	for _, opt := range opts {
+		enc, err = opt.wrapEncoder(cfg.Encoding, cfg.EncoderConfig, enc)
+		if err != nil {
+			return nil, err
+		}
+	}
+	return enc, nil
 }

options.go

@@ -26,11 +26,61 @@ import (
 	"go.uber.org/zap/zapcore"
 )
 
+func filterOptions[T Option](in ...Option) []T {
+	var opts []T
+	for _, opt := range in {
+		if o, ok := opt.(T); ok {
+			opts = append(opts, o)
+		}
+	}
+	return opts
+}
+
 // An Option configures a Logger.
 type Option interface {
 	apply(*Logger)
 }
 
+// WrapEncoderOption wraps or creates new encoder.
+type WrapEncoderOption interface {
+	Option
+	wrapEncoder(encoding string, cfg zapcore.EncoderConfig, encoder zapcore.Encoder) (zapcore.Encoder, error)
+}
+
+// wrapEncoderOption wraps a func to make it satisfy the WrapEncoderOption interface.
+type wrapEncoderOption func(encoding string, cfg zapcore.EncoderConfig, encoder zapcore.Encoder) (zapcore.Encoder, error)
+
+func (f wrapEncoderOption) wrapEncoder(encoding string, cfg zapcore.EncoderConfig, encoder zapcore.Encoder) (zapcore.Encoder, error) {
+	return f(encoding, cfg, encoder)
+}
+
+func (f wrapEncoderOption) apply(_ *Logger) {}
+
+// WrapEncoder wraps or replaces the Logger's underlying zapcore.Encoder.
+func WrapEncoder(fn func(encoding string, cfg zapcore.EncoderConfig, encoder zapcore.Encoder) (zapcore.Encoder, error)) WrapEncoderOption {
+	return wrapEncoderOption(fn)
+}
+
+// WrapSinkersOption wraps or creates new sinker pair.
+type WrapSinkersOption interface {
+	Option
+	wrapSink(paths []string, sink zapcore.WriteSyncer, errPath []string, errSink zapcore.WriteSyncer) (zapcore.WriteSyncer, zapcore.WriteSyncer, error)
+}
+
+// wrapEncoderOption wraps a func to make it satisfy the WrapSinkersOption interface.
+type wrapSinkerOption func(paths []string, sink zapcore.WriteSyncer, errPath []string, errSink zapcore.WriteSyncer) (zapcore.WriteSyncer, zapcore.WriteSyncer, error)
+
+func (f wrapSinkerOption) wrapSink(paths []string, sink zapcore.WriteSyncer, errPath []string, errSink zapcore.WriteSyncer) (zapcore.WriteSyncer, zapcore.WriteSyncer, error) {
+	return f(paths, sink, errPath, errSink)
+}
+
+func (f wrapSinkerOption) apply(_ *Logger) {}
+
+// WrapSinker wraps or replaces the Logger's underlying zapcore.Encoder.
+func WrapSinker(fn func(paths []string, sink zapcore.WriteSyncer, errPath []string, errSink zapcore.WriteSyncer) (zapcore.WriteSyncer, zapcore.WriteSyncer, error)) WrapSinkersOption {
+	return wrapSinkerOption(fn)
+}
+
 // optionFunc wraps a func so it satisfies the Option interface.
 type optionFunc func(*Logger)