@@ -48,11 +48,12 @@ const (

 	defaultRetryWait  = 1000

 	defaultMaxRetries = math.MaxInt32

-	addressKey      = "fluentd-address"

-	bufferLimitKey  = "fluentd-buffer-limit"

-	retryWaitKey    = "fluentd-retry-wait"

-	maxRetriesKey   = "fluentd-max-retries"

-	asyncConnectKey = "fluentd-async-connect"

+	addressKey            = "fluentd-address"

+	bufferLimitKey        = "fluentd-buffer-limit"

+	retryWaitKey          = "fluentd-retry-wait"

+	maxRetriesKey         = "fluentd-max-retries"

+	asyncConnectKey       = "fluentd-async-connect"

+	subSecondPrecisionKey = "fluentd-sub-second-precision"

 )

 func init() {

@@ -117,15 +118,23 @@ func New(info logger.Info) (logger.Logger, error) {

 		}

 	}

+	subSecondPrecision := false

+	if info.Config[subSecondPrecisionKey] != "" {

+		if subSecondPrecision, err = strconv.ParseBool(info.Config[subSecondPrecisionKey]); err != nil {

+			return nil, err

+		}

+	}

+

 	fluentConfig := fluent.Config{

-		FluentPort:       loc.port,

-		FluentHost:       loc.host,

-		FluentNetwork:    loc.protocol,

-		FluentSocketPath: loc.path,

-		BufferLimit:      bufferLimit,

-		RetryWait:        retryWait,

-		MaxRetry:         maxRetries,

-		AsyncConnect:     asyncConnect,

+		FluentPort:         loc.port,

+		FluentHost:         loc.host,

+		FluentNetwork:      loc.protocol,

+		FluentSocketPath:   loc.path,

+		BufferLimit:        bufferLimit,

+		RetryWait:          retryWait,

+		MaxRetry:           maxRetries,

+		AsyncConnect:       asyncConnect,

+		SubSecondPrecision: subSecondPrecision,

 	}

 	logrus.WithField("container", info.ContainerID).WithField("config", fluentConfig).

@@ -183,6 +192,7 @@ func ValidateLogOpt(cfg map[string]string) error {

 		case retryWaitKey:

 		case maxRetriesKey:

 		case asyncConnectKey:

+		case subSecondPrecisionKey:

 			// Accepted

 		default:

 			return fmt.Errorf("unknown log opt '%s' for fluentd log driver", key)

@@ -79,10 +79,10 @@ github.com/golang/protobuf 7a211bcf3bce0e3f1d74f9894916e6f116ae83b4

 # gelf logging driver deps

 github.com/Graylog2/go-gelf v2

-github.com/fluent/fluent-logger-golang v1.2.1

+github.com/fluent/fluent-logger-golang v1.3.0

 # fluent-logger-golang deps

 github.com/philhofer/fwd 98c11a7a6ec829d672b03833c3d69a7fae1ca972

-github.com/tinylib/msgp 75ee40d2601edf122ef667e2a07d600d4c44490c

+github.com/tinylib/msgp 3b556c64540842d4f82967be066a7f7fffc3adad

 # fsnotify

 github.com/fsnotify/fsnotify v1.4.2

@@ -21,7 +21,7 @@ import "github.com/fluent/fluent-logger-golang/fluent"

 GoDoc: http://godoc.org/github.com/fluent/fluent-logger-golang/fluent

-##Example

+## Example

 ```go

 package main

@@ -44,14 +44,14 @@ func main() {

     "hoge": "hoge",

   }

   error := logger.Post(tag, data)

-  // error := logger.Post(tag, time.Time.Now(), data)

+  // error := logger.PostWithTime(tag, time.Now(), data)

   if error != nil {

     panic(error)

   }

 }

 ```

-`data` must be a value like `map[string]literal`, `map[string]interface{}` or `struct`. Logger refers tags `msg` or `codec` of each fields of structs.

+`data` must be a value like `map[string]literal`, `map[string]interface{}`, `struct` or [`msgp.Marshaler`](http://godoc.org/github.com/tinylib/msgp/msgp#Marshaler). Logger refers tags `msg` or `codec` of each fields of structs.

 ## Setting config values

@@ -59,6 +59,11 @@ func main() {

 f := fluent.New(fluent.Config{FluentPort: 80, FluentHost: "example.com"})

 ```

+### WriteTimeout

+

+Sets the timeout for Write call of logger.Post.

+Since the default is zero value, Write will not time out.

+

 ## Tests

 ```

 go test

@@ -4,13 +4,14 @@ import (

 	"encoding/json"

 	"errors"

 	"fmt"

-	"io"

 	"math"

 	"net"

 	"reflect"

 	"strconv"

 	"sync"

 	"time"

+

+	"github.com/tinylib/msgp/msgp"

 )

 const (

@@ -19,10 +20,14 @@ const (

 	defaultSocketPath             = ""

 	defaultPort                   = 24224

 	defaultTimeout                = 3 * time.Second

+	defaultWriteTimeout           = time.Duration(0) // Write() will not time out

 	defaultBufferLimit            = 8 * 1024 * 1024

 	defaultRetryWait              = 500

 	defaultMaxRetry               = 13

 	defaultReconnectWaitIncreRate = 1.5

+	// Default sub-second precision value to false since it is only compatible

+	// with fluentd versions v0.14 and above.

+	defaultSubSecondPrecision = false

 )

 type Config struct {

@@ -31,12 +36,17 @@ type Config struct {

 	FluentNetwork    string        `json:"fluent_network"`

 	FluentSocketPath string        `json:"fluent_socket_path"`

 	Timeout          time.Duration `json:"timeout"`

+	WriteTimeout     time.Duration `json:"write_timeout"`

 	BufferLimit      int           `json:"buffer_limit"`

 	RetryWait        int           `json:"retry_wait"`

 	MaxRetry         int           `json:"max_retry"`

 	TagPrefix        string        `json:"tag_prefix"`

 	AsyncConnect     bool          `json:"async_connect"`

 	MarshalAsJSON    bool          `json:"marshal_as_json"`

+

+	// Sub-second precision timestamps are only possible for those using fluentd

+	// v0.14+ and serializing their messages with msgpack.

+	SubSecondPrecision bool `json:"sub_second_precision"`

 }

 type Fluent struct {

@@ -46,7 +56,7 @@ type Fluent struct {

 	pending []byte

 	muconn       sync.Mutex

-	conn         io.WriteCloser

+	conn         net.Conn

 	reconnecting bool

 }

@@ -67,6 +77,9 @@ func New(config Config) (f *Fluent, err error) {

 	if config.Timeout == 0 {

 		config.Timeout = defaultTimeout

 	}

+	if config.WriteTimeout == 0 {

+		config.WriteTimeout = defaultWriteTimeout

+	}

 	if config.BufferLimit == 0 {

 		config.BufferLimit = defaultBufferLimit

 	}

@@ -90,9 +103,6 @@ func New(config Config) (f *Fluent, err error) {

 //

 // Examples:

 //

-//  // send string

-//  f.Post("tag_name", "data")

-//

 //  // send map[string]

 //  mapStringData := map[string]string{

 //  	"foo":  "bar",

@@ -124,6 +134,10 @@ func (f *Fluent) PostWithTime(tag string, tm time.Time, message interface{}) err

 		tag = f.TagPrefix + "." + tag

 	}

+	if m, ok := message.(msgp.Marshaler); ok {

+		return f.EncodeAndPostData(tag, tm, m)

+	}

+

 	msg := reflect.ValueOf(message)

 	msgtype := msg.Type()

@@ -203,6 +217,9 @@ func (f *Fluent) EncodeData(tag string, tm time.Time, message interface{}) (data

 		msg := Message{Tag: tag, Time: timeUnix, Record: message}

 		chunk := &MessageChunk{message: msg}

 		data, err = json.Marshal(chunk)

+	} else if f.Config.SubSecondPrecision {

+		msg := &MessageExt{Tag: tag, Time: EventTime(tm), Record: message}

+		data, err = msg.MarshalMsg(nil)

 	} else {

 		msg := &Message{Tag: tag, Time: timeUnix, Record: message}

 		data, err = msg.MarshalMsg(nil)

@@ -297,6 +314,12 @@ func (f *Fluent) send() error {

 	var err error

 	if len(f.pending) > 0 {

+		t := f.Config.WriteTimeout

+		if time.Duration(0) < t {

+			f.conn.SetWriteDeadline(time.Now().Add(t))

+		} else {

+			f.conn.SetWriteDeadline(time.Time{})

+		}

 		_, err = f.conn.Write(f.pending)

 		if err != nil {

 			f.conn.Close()

@@ -2,6 +2,12 @@

 package fluent

+import (

+	"time"

+

+	"github.com/tinylib/msgp/msgp"

+)

+

 //msgp:tuple Entry

 type Entry struct {

 	Time   int64       `msg:"time"`

@@ -22,3 +28,69 @@ type Message struct {

 	Record interface{} `msg:"record"`

 	Option interface{} `msg:"option"`

 }

+

+//msgp:tuple MessageExt

+type MessageExt struct {

+	Tag    string      `msg:"tag"`

+	Time   EventTime   `msg:"time,extension"`

+	Record interface{} `msg:"record"`

+	Option interface{} `msg:"option"`

+}

+

+// EventTime is an extension to the serialized time value. It builds in support

+// for sub-second (nanosecond) precision in serialized timestamps.

+//

+// You can find the full specification for the msgpack message payload here:

+// https://github.com/fluent/fluentd/wiki/Forward-Protocol-Specification-v1.

+//

+// You can find more information on msgpack extension types here:

+// https://github.com/tinylib/msgp/wiki/Using-Extensions.

+type EventTime time.Time

+

+const (

+	extensionType = 0

+	length        = 8

+)

+

+func init() {

+	msgp.RegisterExtension(extensionType, func() msgp.Extension { return new(EventTime) })

+}

+

+func (t *EventTime) ExtensionType() int8 { return extensionType }

+

+func (t *EventTime) Len() int { return length }

+

+func (t *EventTime) MarshalBinaryTo(b []byte) error {

+	// Unwrap to Golang time

+	goTime := time.Time(*t)

+

+	// There's no support for timezones in fluentd's protocol for EventTime.

+	// Convert to UTC.

+	utc := goTime.UTC()

+

+	// Warning! Converting seconds to an int32 is a lossy operation. This code

+	// will hit the "Year 2038" problem.

+	sec := int32(utc.Unix())

+	nsec := utc.Nanosecond()

+

+	// Fill the buffer with 4 bytes for the second component of the timestamp.

+	b[0] = byte(sec >> 24)

+	b[1] = byte(sec >> 16)

+	b[2] = byte(sec >> 8)

+	b[3] = byte(sec)

+

+	// Fill the buffer with 4 bytes for the nanosecond component of the

+	// timestamp.

+	b[4] = byte(nsec >> 24)

+	b[5] = byte(nsec >> 16)

+	b[6] = byte(nsec >> 8)

+	b[7] = byte(nsec)

+

+	return nil

+}

+

+// UnmarshalBinary is not implemented since decoding messages is not supported

+// by this library.

+func (t *EventTime) UnmarshalBinary(b []byte) error {

+	return nil

+}

@@ -10,13 +10,13 @@ import (

 // DecodeMsg implements msgp.Decodable

 func (z *Entry) DecodeMsg(dc *msgp.Reader) (err error) {

-	var ssz uint32

-	ssz, err = dc.ReadArrayHeader()

+	var zxvk uint32

+	zxvk, err = dc.ReadArrayHeader()

 	if err != nil {

 		return

 	}

-	if ssz != 2 {

-		err = msgp.ArrayError{Wanted: 2, Got: ssz}

+	if zxvk != 2 {

+		err = msgp.ArrayError{Wanted: 2, Got: zxvk}

 		return

 	}

 	z.Time, err = dc.ReadInt64()

@@ -32,9 +32,10 @@ func (z *Entry) DecodeMsg(dc *msgp.Reader) (err error) {

 // EncodeMsg implements msgp.Encodable

 func (z Entry) EncodeMsg(en *msgp.Writer) (err error) {

-	err = en.WriteArrayHeader(2)

+	// array header, size 2

+	err = en.Append(0x92)

 	if err != nil {

-		return

+		return err

 	}

 	err = en.WriteInt64(z.Time)

 	if err != nil {

@@ -50,7 +51,8 @@ func (z Entry) EncodeMsg(en *msgp.Writer) (err error) {

 // MarshalMsg implements msgp.Marshaler

 func (z Entry) MarshalMsg(b []byte) (o []byte, err error) {

 	o = msgp.Require(b, z.Msgsize())

-	o = msgp.AppendArrayHeader(o, 2)

+	// array header, size 2

+	o = append(o, 0x92)

 	o = msgp.AppendInt64(o, z.Time)

 	o, err = msgp.AppendIntf(o, z.Record)

 	if err != nil {

@@ -61,16 +63,14 @@ func (z Entry) MarshalMsg(b []byte) (o []byte, err error) {

 // UnmarshalMsg implements msgp.Unmarshaler

 func (z *Entry) UnmarshalMsg(bts []byte) (o []byte, err error) {

-	{

-		var ssz uint32

-		ssz, bts, err = msgp.ReadArrayHeaderBytes(bts)

-		if err != nil {

-			return

-		}

-		if ssz != 2 {

-			err = msgp.ArrayError{Wanted: 2, Got: ssz}

-			return

-		}

+	var zbzg uint32

+	zbzg, bts, err = msgp.ReadArrayHeaderBytes(bts)

+	if err != nil {

+		return

+	}

+	if zbzg != 2 {

+		err = msgp.ArrayError{Wanted: 2, Got: zbzg}

+		return

 	}

 	z.Time, bts, err = msgp.ReadInt64Bytes(bts)

 	if err != nil {

@@ -84,51 +84,52 @@ func (z *Entry) UnmarshalMsg(bts []byte) (o []byte, err error) {

 	return

 }

+// Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message

 func (z Entry) Msgsize() (s int) {

-	s = msgp.ArrayHeaderSize + msgp.Int64Size + msgp.GuessSize(z.Record)

+	s = 1 + msgp.Int64Size + msgp.GuessSize(z.Record)

 	return

 }

 // DecodeMsg implements msgp.Decodable

 func (z *Forward) DecodeMsg(dc *msgp.Reader) (err error) {

-	var ssz uint32

-	ssz, err = dc.ReadArrayHeader()

+	var zcmr uint32

+	zcmr, err = dc.ReadArrayHeader()

 	if err != nil {

 		return

 	}

-	if ssz != 3 {

-		err = msgp.ArrayError{Wanted: 3, Got: ssz}

+	if zcmr != 3 {

+		err = msgp.ArrayError{Wanted: 3, Got: zcmr}

 		return

 	}

 	z.Tag, err = dc.ReadString()

 	if err != nil {

 		return

 	}

-	var xsz uint32

-	xsz, err = dc.ReadArrayHeader()

+	var zajw uint32

+	zajw, err = dc.ReadArrayHeader()

 	if err != nil {

 		return

 	}

-	if cap(z.Entries) >= int(xsz) {

-		z.Entries = z.Entries[:xsz]

+	if cap(z.Entries) >= int(zajw) {

+		z.Entries = (z.Entries)[:zajw]

 	} else {

-		z.Entries = make([]Entry, xsz)

+		z.Entries = make([]Entry, zajw)

 	}

-	for xvk := range z.Entries {

-		var ssz uint32

-		ssz, err = dc.ReadArrayHeader()

+	for zbai := range z.Entries {

+		var zwht uint32

+		zwht, err = dc.ReadArrayHeader()

 		if err != nil {

 			return

 		}

-		if ssz != 2 {

-			err = msgp.ArrayError{Wanted: 2, Got: ssz}

+		if zwht != 2 {

+			err = msgp.ArrayError{Wanted: 2, Got: zwht}

 			return

 		}

-		z.Entries[xvk].Time, err = dc.ReadInt64()

+		z.Entries[zbai].Time, err = dc.ReadInt64()

 		if err != nil {

 			return

 		}

-		z.Entries[xvk].Record, err = dc.ReadIntf()

+		z.Entries[zbai].Record, err = dc.ReadIntf()

 		if err != nil {

 			return

 		}

@@ -142,9 +143,10 @@ func (z *Forward) DecodeMsg(dc *msgp.Reader) (err error) {

 // EncodeMsg implements msgp.Encodable

 func (z *Forward) EncodeMsg(en *msgp.Writer) (err error) {

-	err = en.WriteArrayHeader(3)

+	// array header, size 3

+	err = en.Append(0x93)

 	if err != nil {

-		return

+		return err

 	}

 	err = en.WriteString(z.Tag)

 	if err != nil {

@@ -154,16 +156,17 @@ func (z *Forward) EncodeMsg(en *msgp.Writer) (err error) {

 	if err != nil {

 		return

 	}

-	for xvk := range z.Entries {

-		err = en.WriteArrayHeader(2)

+	for zbai := range z.Entries {

+		// array header, size 2

+		err = en.Append(0x92)

 		if err != nil {

-			return

+			return err

 		}

-		err = en.WriteInt64(z.Entries[xvk].Time)

+		err = en.WriteInt64(z.Entries[zbai].Time)

 		if err != nil {

 			return

 		}

-		err = en.WriteIntf(z.Entries[xvk].Record)

+		err = en.WriteIntf(z.Entries[zbai].Record)

 		if err != nil {

 			return

 		}

@@ -178,13 +181,15 @@ func (z *Forward) EncodeMsg(en *msgp.Writer) (err error) {

 // MarshalMsg implements msgp.Marshaler

 func (z *Forward) MarshalMsg(b []byte) (o []byte, err error) {

 	o = msgp.Require(b, z.Msgsize())

-	o = msgp.AppendArrayHeader(o, 3)

+	// array header, size 3

+	o = append(o, 0x93)

 	o = msgp.AppendString(o, z.Tag)

 	o = msgp.AppendArrayHeader(o, uint32(len(z.Entries)))

-	for xvk := range z.Entries {

-		o = msgp.AppendArrayHeader(o, 2)

-		o = msgp.AppendInt64(o, z.Entries[xvk].Time)

-		o, err = msgp.AppendIntf(o, z.Entries[xvk].Record)

+	for zbai := range z.Entries {

+		// array header, size 2

+		o = append(o, 0x92)

+		o = msgp.AppendInt64(o, z.Entries[zbai].Time)

+		o, err = msgp.AppendIntf(o, z.Entries[zbai].Record)

 		if err != nil {

 			return

 		}

@@ -198,48 +203,44 @@ func (z *Forward) MarshalMsg(b []byte) (o []byte, err error) {

 // UnmarshalMsg implements msgp.Unmarshaler

 func (z *Forward) UnmarshalMsg(bts []byte) (o []byte, err error) {

-	{

-		var ssz uint32

-		ssz, bts, err = msgp.ReadArrayHeaderBytes(bts)

-		if err != nil {

-			return

-		}

-		if ssz != 3 {

-			err = msgp.ArrayError{Wanted: 3, Got: ssz}

-			return

-		}

+	var zhct uint32

+	zhct, bts, err = msgp.ReadArrayHeaderBytes(bts)

+	if err != nil {

+		return

+	}

+	if zhct != 3 {

+		err = msgp.ArrayError{Wanted: 3, Got: zhct}

+		return

 	}

 	z.Tag, bts, err = msgp.ReadStringBytes(bts)

 	if err != nil {

 		return

 	}

-	var xsz uint32

-	xsz, bts, err = msgp.ReadArrayHeaderBytes(bts)

+	var zcua uint32

+	zcua, bts, err = msgp.ReadArrayHeaderBytes(bts)

 	if err != nil {

 		return

 	}

-	if cap(z.Entries) >= int(xsz) {

-		z.Entries = z.Entries[:xsz]

+	if cap(z.Entries) >= int(zcua) {

+		z.Entries = (z.Entries)[:zcua]

 	} else {

-		z.Entries = make([]Entry, xsz)

-	}

-	for xvk := range z.Entries {

-		{

-			var ssz uint32

-			ssz, bts, err = msgp.ReadArrayHeaderBytes(bts)

-			if err != nil {

-				return

-			}

-			if ssz != 2 {

-				err = msgp.ArrayError{Wanted: 2, Got: ssz}

-				return

-			}

+		z.Entries = make([]Entry, zcua)

+	}

+	for zbai := range z.Entries {

+		var zxhx uint32

+		zxhx, bts, err = msgp.ReadArrayHeaderBytes(bts)

+		if err != nil {

+			return

 		}

-		z.Entries[xvk].Time, bts, err = msgp.ReadInt64Bytes(bts)

+		if zxhx != 2 {

+			err = msgp.ArrayError{Wanted: 2, Got: zxhx}

+			return

+		}

+		z.Entries[zbai].Time, bts, err = msgp.ReadInt64Bytes(bts)

 		if err != nil {

 			return

 		}

-		z.Entries[xvk].Record, bts, err = msgp.ReadIntfBytes(bts)

+		z.Entries[zbai].Record, bts, err = msgp.ReadIntfBytes(bts)

 		if err != nil {

 			return

 		}

@@ -252,10 +253,11 @@ func (z *Forward) UnmarshalMsg(bts []byte) (o []byte, err error) {

 	return

 }

+// Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message

 func (z *Forward) Msgsize() (s int) {

-	s = msgp.ArrayHeaderSize + msgp.StringPrefixSize + len(z.Tag) + msgp.ArrayHeaderSize

-	for xvk := range z.Entries {

-		s += msgp.ArrayHeaderSize + msgp.Int64Size + msgp.GuessSize(z.Entries[xvk].Record)

+	s = 1 + msgp.StringPrefixSize + len(z.Tag) + msgp.ArrayHeaderSize

+	for zbai := range z.Entries {

+		s += 1 + msgp.Int64Size + msgp.GuessSize(z.Entries[zbai].Record)

 	}

 	s += msgp.GuessSize(z.Option)

 	return

@@ -263,13 +265,13 @@ func (z *Forward) Msgsize() (s int) {

 // DecodeMsg implements msgp.Decodable

 func (z *Message) DecodeMsg(dc *msgp.Reader) (err error) {

-	var ssz uint32

-	ssz, err = dc.ReadArrayHeader()

+	var zlqf uint32

+	zlqf, err = dc.ReadArrayHeader()

 	if err != nil {

 		return

 	}

-	if ssz != 4 {

-		err = msgp.ArrayError{Wanted: 4, Got: ssz}

+	if zlqf != 4 {

+		err = msgp.ArrayError{Wanted: 4, Got: zlqf}

 		return

 	}

 	z.Tag, err = dc.ReadString()

@@ -293,9 +295,10 @@ func (z *Message) DecodeMsg(dc *msgp.Reader) (err error) {

 // EncodeMsg implements msgp.Encodable

 func (z *Message) EncodeMsg(en *msgp.Writer) (err error) {

-	err = en.WriteArrayHeader(4)

+	// array header, size 4

+	err = en.Append(0x94)

 	if err != nil {

-		return

+		return err

 	}

 	err = en.WriteString(z.Tag)

 	if err != nil {

@@ -319,7 +322,8 @@ func (z *Message) EncodeMsg(en *msgp.Writer) (err error) {

 // MarshalMsg implements msgp.Marshaler

 func (z *Message) MarshalMsg(b []byte) (o []byte, err error) {

 	o = msgp.Require(b, z.Msgsize())

-	o = msgp.AppendArrayHeader(o, 4)

+	// array header, size 4

+	o = append(o, 0x94)

 	o = msgp.AppendString(o, z.Tag)

 	o = msgp.AppendInt64(o, z.Time)

 	o, err = msgp.AppendIntf(o, z.Record)

@@ -335,16 +339,14 @@ func (z *Message) MarshalMsg(b []byte) (o []byte, err error) {

 // UnmarshalMsg implements msgp.Unmarshaler

 func (z *Message) UnmarshalMsg(bts []byte) (o []byte, err error) {

-	{

-		var ssz uint32

-		ssz, bts, err = msgp.ReadArrayHeaderBytes(bts)

-		if err != nil {

-			return

-		}

-		if ssz != 4 {

-			err = msgp.ArrayError{Wanted: 4, Got: ssz}

-			return

-		}

+	var zdaf uint32

+	zdaf, bts, err = msgp.ReadArrayHeaderBytes(bts)

+	if err != nil {

+		return

+	}

+	if zdaf != 4 {

+		err = msgp.ArrayError{Wanted: 4, Got: zdaf}

+		return

 	}

 	z.Tag, bts, err = msgp.ReadStringBytes(bts)

 	if err != nil {

@@ -366,7 +368,122 @@ func (z *Message) UnmarshalMsg(bts []byte) (o []byte, err error) {

 	return

 }

+// Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message

 func (z *Message) Msgsize() (s int) {

-	s = msgp.ArrayHeaderSize + msgp.StringPrefixSize + len(z.Tag) + msgp.Int64Size + msgp.GuessSize(z.Record) + msgp.GuessSize(z.Option)

+	s = 1 + msgp.StringPrefixSize + len(z.Tag) + msgp.Int64Size + msgp.GuessSize(z.Record) + msgp.GuessSize(z.Option)

+	return

+}

+

+// DecodeMsg implements msgp.Decodable

+func (z *MessageExt) DecodeMsg(dc *msgp.Reader) (err error) {

+	var zpks uint32

+	zpks, err = dc.ReadArrayHeader()

+	if err != nil {

+		return

+	}

+	if zpks != 4 {

+		err = msgp.ArrayError{Wanted: 4, Got: zpks}

+		return

+	}

+	z.Tag, err = dc.ReadString()

+	if err != nil {

+		return

+	}

+	err = dc.ReadExtension(&z.Time)

+	if err != nil {

+		return

+	}

+	z.Record, err = dc.ReadIntf()

+	if err != nil {

+		return

+	}

+	z.Option, err = dc.ReadIntf()

+	if err != nil {

+		return

+	}

+	return

+}

+

+// EncodeMsg implements msgp.Encodable

+func (z *MessageExt) EncodeMsg(en *msgp.Writer) (err error) {

+	// array header, size 4

+	err = en.Append(0x94)

+	if err != nil {

+		return err

+	}

+	err = en.WriteString(z.Tag)

+	if err != nil {

+		return

+	}

+	err = en.WriteExtension(&z.Time)

+	if err != nil {

+		return

+	}

+	err = en.WriteIntf(z.Record)

+	if err != nil {

+		return

+	}

+	err = en.WriteIntf(z.Option)

+	if err != nil {

+		return

+	}

+	return

+}

+

+// MarshalMsg implements msgp.Marshaler

+func (z *MessageExt) MarshalMsg(b []byte) (o []byte, err error) {

+	o = msgp.Require(b, z.Msgsize())

+	// array header, size 4

+	o = append(o, 0x94)

+	o = msgp.AppendString(o, z.Tag)

+	o, err = msgp.AppendExtension(o, &z.Time)

+	if err != nil {

+		return

+	}

+	o, err = msgp.AppendIntf(o, z.Record)

+	if err != nil {

+		return

+	}

+	o, err = msgp.AppendIntf(o, z.Option)

+	if err != nil {

+		return

+	}

+	return

+}

+

+// UnmarshalMsg implements msgp.Unmarshaler

+func (z *MessageExt) UnmarshalMsg(bts []byte) (o []byte, err error) {

+	var zjfb uint32

+	zjfb, bts, err = msgp.ReadArrayHeaderBytes(bts)

+	if err != nil {

+		return

+	}

+	if zjfb != 4 {

+		err = msgp.ArrayError{Wanted: 4, Got: zjfb}

+		return

+	}

+	z.Tag, bts, err = msgp.ReadStringBytes(bts)

+	if err != nil {

+		return

+	}

+	bts, err = msgp.ReadExtensionBytes(bts, &z.Time)

+	if err != nil {

+		return

+	}

+	z.Record, bts, err = msgp.ReadIntfBytes(bts)

+	if err != nil {

+		return

+	}

+	z.Option, bts, err = msgp.ReadIntfBytes(bts)

+	if err != nil {

+		return

+	}

+	o = bts

+	return

+}

+

+// Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message

+func (z *MessageExt) Msgsize() (s int) {

+	s = 1 + msgp.StringPrefixSize + len(z.Tag) + msgp.ExtensionPrefixSize + z.Time.Len() + msgp.GuessSize(z.Record) + msgp.GuessSize(z.Option)

 	return

 }

new file mode 100644

@@ -0,0 +1,7 @@

+package fluent

+

+//go:generate msgp

+type TestMessage struct {

+	Foo  string `msg:"foo" json:"foo,omitempty"`

+	Hoge string `msg:"hoge" json:"hoge,omitempty"`

+}

new file mode 100644

@@ -0,0 +1,125 @@

+package fluent

+

+// NOTE: THIS FILE WAS PRODUCED BY THE

+// MSGP CODE GENERATION TOOL (github.com/tinylib/msgp)

+// DO NOT EDIT

+

+import (

+	"github.com/tinylib/msgp/msgp"

+)

+

+// DecodeMsg implements msgp.Decodable

+func (z *TestMessage) DecodeMsg(dc *msgp.Reader) (err error) {

+	var field []byte

+	_ = field

+	var zxvk uint32

+	zxvk, err = dc.ReadMapHeader()

+	if err != nil {

+		return

+	}

+	for zxvk > 0 {

+		zxvk--

+		field, err = dc.ReadMapKeyPtr()

+		if err != nil {

+			return

+		}

+		switch msgp.UnsafeString(field) {

+		case "foo":

+			z.Foo, err = dc.ReadString()

+			if err != nil {

+				return

+			}

+		case "hoge":

+			z.Hoge, err = dc.ReadString()

+			if err != nil {

+				return

+			}

+		default:

+			err = dc.Skip()

+			if err != nil {

+				return

+			}

+		}

+	}

+	return

+}

+

+// EncodeMsg implements msgp.Encodable

+func (z TestMessage) EncodeMsg(en *msgp.Writer) (err error) {

+	// map header, size 2

+	// write "foo"

+	err = en.Append(0x82, 0xa3, 0x66, 0x6f, 0x6f)

+	if err != nil {

+		return err

+	}

+	err = en.WriteString(z.Foo)

+	if err != nil {

+		return

+	}

+	// write "hoge"

+	err = en.Append(0xa4, 0x68, 0x6f, 0x67, 0x65)

+	if err != nil {

+		return err

+	}

+	err = en.WriteString(z.Hoge)

+	if err != nil {

+		return

+	}

+	return

+}

+

+// MarshalMsg implements msgp.Marshaler

+func (z TestMessage) MarshalMsg(b []byte) (o []byte, err error) {

+	o = msgp.Require(b, z.Msgsize())

+	// map header, size 2

+	// string "foo"

+	o = append(o, 0x82, 0xa3, 0x66, 0x6f, 0x6f)

+	o = msgp.AppendString(o, z.Foo)

+	// string "hoge"

+	o = append(o, 0xa4, 0x68, 0x6f, 0x67, 0x65)

+	o = msgp.AppendString(o, z.Hoge)

+	return

+}

+

+// UnmarshalMsg implements msgp.Unmarshaler

+func (z *TestMessage) UnmarshalMsg(bts []byte) (o []byte, err error) {

+	var field []byte

+	_ = field

+	var zbzg uint32

+	zbzg, bts, err = msgp.ReadMapHeaderBytes(bts)