feat: Custom interface{} object Encoder

[psrajat]

Description

We log a lot of structs using zap. And zap uses json.Encoder for encoding these interface{} (or ReflectType) fields.
It would be great if we can use something else other than encoding/json lib.

For instance, json-iterator is faster than std lib and provides other customizations on top of it.

This would provide 2 benefits:

1. Better performance
2. Logging interface{} objects in a custom way.

For example: json-iterator provides the functionality to have custom tags instead of json.

type UserData struct {
  Name string `json:"name" log:"name"`
  Age int64 `json:"age" log:"age"`
  Email string `json:"email" log:"-"`
  Address string `json:"address" log:"-"`
}

With this feature, we can control what we want to log.
In the above example, we want to only log Name and Age but don't want to log Email and Address.
Since this is using its own instance, it won't affect other serializations/deserializations taking place somewhere else.

On Implementation

I figured one way we can do this is by replacing the type of reflectEnc variable to a newly defined ReflectTypeEncoder interface in json_encoder.go.

This interface will expose mainly 2 methods:

1. WithBuffer(*buffer.Buffer): which will provide the encoder the Buffer where it needs to write the data
2. Encode(interface{}): which encodes the object and writes it to the provided buffer above

The configuration can be provided while initializing Logger:

jsonIterConfig := jsoniter.Config{
  EscapeHTML:             false,
  TagKey: "log",
}

zapConfig := zap.NewProductionConfig()
zapConfig.EncoderConfig.EncodeReflectType = NewJsonIterReflectTypeEncoder(jsonIterConfig)

If not provided, we can continue using the default encoding/json one so won't be a breaking change.

LMK if there are any concerns with this approach.
Or there are other ways I can do this.
If you're okay with it, I can raise a PR.

Note: This may also solve #993

[abhinav]

Hey, @psrajat. This is a reasonable feature request, although I would suggest some small changes to it:
I think we'd prefer to hide the buffer.Buffer type as an implementation detail and give the encoder only an io.Writer.

So maybe something like this:

type ReflectedEncoder interface { Encode(interface{}) error }
// json.Encoder and jsoniter.Encoder both match this interface.

type EncoderConfig struct {
  // ...
  NewReflectedEncoder func(io.Writer) ReflectedEncoder
}

Zap would still own the buffer and reset it as needed.
The encoder will write to the buffer as requested, and won't be able to read from it or reset it.

[psrajat]

@abhinav Makes sense.

Raised #1039 for this

[abhinav]

Thanks, @psrajat! We'll tag a new release of Zap in January.
You can pin to the master branch meanwhile, if you need to use this feature sooner.

[psrajat]

Thanks a lot for helping out @abhinav :)