Added SubSecondPrecision flag in fluentd logger
Signed-off-by: dungeonmaster18 <umesh4257@gmail.com> Upstream-commit: a1ebda09bab5bf22d96a15e71618c4a0ac08bb55 Component: engine
This commit is contained in:
Umesh Yadav
committed by
dungeonmaster18
dungeonmaster18
parent
ae808b0eb3
commit
12e67ce519
11
components/engine/vendor/github.com/fluent/fluent-logger-golang/README.md
generated
vendored
11
components/engine/vendor/github.com/fluent/fluent-logger-golang/README.md
generated
vendored
@ -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
|
||||
|
||||
33
components/engine/vendor/github.com/fluent/fluent-logger-golang/fluent/fluent.go
generated
vendored
33
components/engine/vendor/github.com/fluent/fluent-logger-golang/fluent/fluent.go
generated
vendored
@ -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()
|
||||
|
||||
72
components/engine/vendor/github.com/fluent/fluent-logger-golang/fluent/proto.go
generated
vendored
72
components/engine/vendor/github.com/fluent/fluent-logger-golang/fluent/proto.go
generated
vendored
@ -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
|
||||
}
|
||||
|
||||
313
components/engine/vendor/github.com/fluent/fluent-logger-golang/fluent/proto_gen.go
generated
vendored
313
components/engine/vendor/github.com/fluent/fluent-logger-golang/fluent/proto_gen.go
generated
vendored
@ -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 err
|
||||
}
|
||||
err = en.WriteInt64(z.Entries[zbai].Time)
|
||||
if err != nil {
|
||||
return
|
||||
}
|
||||
err = en.WriteInt64(z.Entries[xvk].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)
|
||||
z.Entries = make([]Entry, zcua)
|
||||
}
|
||||
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[xvk].Time, bts, err = msgp.ReadInt64Bytes(bts)
|
||||
for zbai := range z.Entries {
|
||||
var zxhx uint32
|
||||
zxhx, bts, err = msgp.ReadArrayHeaderBytes(bts)
|
||||
if err != nil {
|
||||
return
|
||||
}
|
||||
z.Entries[xvk].Record, bts, err = msgp.ReadIntfBytes(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[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
|
||||
}
|
||||
|
||||
7
components/engine/vendor/github.com/fluent/fluent-logger-golang/fluent/test_message.go
generated
vendored
Normal file
7
components/engine/vendor/github.com/fluent/fluent-logger-golang/fluent/test_message.go
generated
vendored
Normal file
@ -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"`
|
||||
}
|
||||
125
components/engine/vendor/github.com/fluent/fluent-logger-golang/fluent/test_message_gen.go
generated
vendored
Normal file
125
components/engine/vendor/github.com/fluent/fluent-logger-golang/fluent/test_message_gen.go
generated
vendored
Normal file
@ -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)
|
||||
if err != nil {
|
||||
return
|
||||
}
|
||||
for zbzg > 0 {
|
||||
zbzg--
|
||||
field, bts, err = msgp.ReadMapKeyZC(bts)
|
||||
if err != nil {
|
||||
return
|
||||
}
|
||||
switch msgp.UnsafeString(field) {
|
||||
case "foo":
|
||||
z.Foo, bts, err = msgp.ReadStringBytes(bts)
|
||||
if err != nil {
|
||||
return
|
||||
}
|
||||
case "hoge":
|
||||
z.Hoge, bts, err = msgp.ReadStringBytes(bts)
|
||||
if err != nil {
|
||||
return
|
||||
}
|
||||
default:
|
||||
bts, err = msgp.Skip(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 TestMessage) Msgsize() (s int) {
|
||||
s = 1 + 4 + msgp.StringPrefixSize + len(z.Foo) + 5 + msgp.StringPrefixSize + len(z.Hoge)
|
||||
return
|
||||
}
|
||||
2
components/engine/vendor/github.com/fluent/fluent-logger-golang/fluent/version.go
generated
vendored
2
components/engine/vendor/github.com/fluent/fluent-logger-golang/fluent/version.go
generated
vendored
@ -1,3 +1,3 @@
|
||||
package fluent
|
||||
|
||||
const Version = "1.2.1"
|
||||
const Version = "1.3.0"
|
||||
|
||||
Reference in New Issue
Block a user