pax_global_header00006660000000000000000000000064126542716560014530gustar00rootroot0000000000000052 comment=97f4695b4d3f76180d24a8ba6d578e4e395ddc4c fluent-logger-golang-1.1.0/000077500000000000000000000000001265427165600155465ustar00rootroot00000000000000fluent-logger-golang-1.1.0/.gitignore000066400000000000000000000000371265427165600175360ustar00rootroot00000000000000.DS_Store *~ .project .settingsfluent-logger-golang-1.1.0/.travis.yml000066400000000000000000000003241265427165600176560ustar00rootroot00000000000000language: go go: - 1.3 - 1.4 - tip install: - go get github.com/bmizerany/assert - go get github.com/philhofer/fwd - go get github.com/tinylib/msgp sudo: false matrix: allow_failures: - go: tip fluent-logger-golang-1.1.0/CHANGELOG.md000066400000000000000000000015241265427165600173610ustar00rootroot00000000000000# CHANGELOG ## 1.0.0 * Fix API of `Post` and `PostWithTime` to return error when encoding * Add argument checks to get `map` with string keys and `struct` only * Logger refers tags (`msg` or `codec`) of fields of struct ## 0.6.0 * Change dependency from ugorji/go/codec to tinylib/msgp * Add `PostRawData` method to post pre-encoded data to servers ## 0.5.1 * Lock when writing pending buffers (Thanks @eagletmt) ## 0.5.0 * Add TagPrefix in Config (Thanks @hotchpotch) ## 0.4.4 * Fixes runtime error of close function.(Thanks @y-matsuwitter) ## 0.4.3 * Added method PostWithTime(Thanks [@choplin]) ## 0.4.2 * Use sync.Mutex * Fix BufferLimit comparison * Export toMsgpack function to utils.go ## 0.4.1 * Remove unused fmt.Println ## 0.4.0 * Update msgpack library ("github.com/ugorji/go-msgpack" -> "github.com/ugorji/go/codec") fluent-logger-golang-1.1.0/LICENSE000066400000000000000000000010511265427165600165500ustar00rootroot00000000000000Copyright (c) 2013 Tatsuo Kaniwa Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.fluent-logger-golang-1.1.0/README.md000066400000000000000000000024041265427165600170250ustar00rootroot00000000000000fluent-logger-golang ==== [![Build Status](https://travis-ci.org/fluent/fluent-logger-golang.png?branch=master)](https://travis-ci.org/fluent/fluent-logger-golang) ## A structured event logger for Fluentd (Golang) ## How to install ``` go get github.com/fluent/fluent-logger-golang/fluent ``` ## Usage Install the package with `go get` and use `import` to include it in your project. ``` import "github.com/fluent/fluent-logger-golang/fluent" ``` GoDoc: http://godoc.org/github.com/fluent/fluent-logger-golang/fluent ##Example ```go package main import ( "github.com/fluent/fluent-logger-golang/fluent" "fmt" "time" ) func main() { logger, err := fluent.New(fluent.Config{}) if err != nil { fmt.Println(err) } defer logger.Close() tag := "myapp.access" var data = map[string]string{ "foo": "bar", "hoge": "hoge", } error := logger.Post(tag, data) // error := logger.Post(tag, time.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. ## Setting config values ```go f := fluent.New(fluent.Config{FluentPort: 80, FluentHost: "example.com"}) ``` ## Tests ``` go test ``` fluent-logger-golang-1.1.0/_examples/000077500000000000000000000000001265427165600175235ustar00rootroot00000000000000fluent-logger-golang-1.1.0/_examples/main.go000066400000000000000000000006351265427165600210020ustar00rootroot00000000000000package main import ( "fmt" "github.com/fluent/fluent-logger-golang/fluent" // "../fluent" ) func main() { logger, err := fluent.New(fluent.Config{FluentPort: 24224, FluentHost: "127.0.0.1"}) if err != nil { fmt.Println(err) } defer logger.Close() tag := "myapp.access" var data = map[string]string{ "foo": "bar", "hoge": "hoge"} i := 0 for i < 100 { logger.Post(tag, data) i = i + 1 } } fluent-logger-golang-1.1.0/fluent/000077500000000000000000000000001265427165600170435ustar00rootroot00000000000000fluent-logger-golang-1.1.0/fluent/fluent.go000066400000000000000000000137211265427165600206730ustar00rootroot00000000000000package fluent import ( "errors" "fmt" "io" "math" "net" "reflect" "strconv" "sync" "time" ) const ( defaultHost = "127.0.0.1" defaultNetwork = "tcp" defaultSocketPath = "" defaultPort = 24224 defaultTimeout = 3 * time.Second defaultBufferLimit = 8 * 1024 * 1024 defaultRetryWait = 500 defaultMaxRetry = 13 defaultReconnectWaitIncreRate = 1.5 ) type Config struct { FluentPort int FluentHost string FluentNetwork string FluentSocketPath string Timeout time.Duration BufferLimit int RetryWait int MaxRetry int TagPrefix string AsyncConnect bool } type Fluent struct { Config conn io.WriteCloser pending []byte reconnecting bool mu sync.Mutex } // New creates a new Logger. func New(config Config) (f *Fluent, err error) { if config.FluentNetwork == "" { config.FluentNetwork = defaultNetwork } if config.FluentHost == "" { config.FluentHost = defaultHost } if config.FluentPort == 0 { config.FluentPort = defaultPort } if config.FluentSocketPath == "" { config.FluentSocketPath = defaultSocketPath } if config.Timeout == 0 { config.Timeout = defaultTimeout } if config.BufferLimit == 0 { config.BufferLimit = defaultBufferLimit } if config.RetryWait == 0 { config.RetryWait = defaultRetryWait } if config.MaxRetry == 0 { config.MaxRetry = defaultMaxRetry } if config.AsyncConnect { f = &Fluent{Config: config, reconnecting: true} f.reconnect() } else { f = &Fluent{Config: config, reconnecting: false} err = f.connect() } return } // Post writes the output for a logging event. // // Examples: // // // send string // f.Post("tag_name", "data") // // // send map[string] // mapStringData := map[string]string{ // "foo": "bar", // } // f.Post("tag_name", mapStringData) // // // send message with specified time // mapStringData := map[string]string{ // "foo": "bar", // } // tm := time.Now() // f.PostWithTime("tag_name", tm, mapStringData) // // // send struct // structData := struct { // Name string `msg:"name"` // } { // "john smith", // } // f.Post("tag_name", structData) // func (f *Fluent) Post(tag string, message interface{}) error { timeNow := time.Now() return f.PostWithTime(tag, timeNow, message) } func (f *Fluent) PostWithTime(tag string, tm time.Time, message interface{}) error { if len(f.TagPrefix) > 0 { tag = f.TagPrefix + "." + tag } msg := reflect.ValueOf(message) msgtype := msg.Type() if msgtype.Kind() == reflect.Struct { // message should be tagged by "codec" or "msg" kv := make(map[string]interface{}) fields := msgtype.NumField() for i := 0; i < fields; i++ { field := msgtype.Field(i) name := field.Name if n1 := field.Tag.Get("msg"); n1 != "" { name = n1 } else if n2 := field.Tag.Get("codec"); n2 != "" { name = n2 } kv[name] = msg.FieldByIndex(field.Index).Interface() } return f.EncodeAndPostData(tag, tm, kv) } if msgtype.Kind() != reflect.Map { return errors.New("messge must be a map") } else if msgtype.Key().Kind() != reflect.String { return errors.New("map keys must be strings") } kv := make(map[string]interface{}) for _, k := range msg.MapKeys() { kv[k.String()] = msg.MapIndex(k).Interface() } return f.EncodeAndPostData(tag, tm, kv) } func (f *Fluent) EncodeAndPostData(tag string, tm time.Time, message interface{}) error { if data, dumperr := f.EncodeData(tag, tm, message); dumperr != nil { return fmt.Errorf("fluent#EncodeAndPostData: can't convert '%s' to msgpack:%s", message, dumperr) // fmt.Println("fluent#Post: can't convert to msgpack:", message, dumperr) } else { f.PostRawData(data) return nil } } func (f *Fluent) PostRawData(data []byte) { f.mu.Lock() f.pending = append(f.pending, data...) f.mu.Unlock() if err := f.send(); err != nil { f.close() if len(f.pending) > f.Config.BufferLimit { f.flushBuffer() } } else { f.flushBuffer() } } func (f *Fluent) EncodeData(tag string, tm time.Time, message interface{}) (data []byte, err error) { timeUnix := tm.Unix() msg := &Message{Tag: tag, Time: timeUnix, Record: message} data, err = msg.MarshalMsg(nil) return } // Close closes the connection. func (f *Fluent) Close() (err error) { if len(f.pending) > 0 { err = f.send() } f.close() return } // close closes the connection. func (f *Fluent) close() (err error) { if f.conn != nil { f.mu.Lock() defer f.mu.Unlock() } else { return } if f.conn != nil { f.conn.Close() f.conn = nil } return } // connect establishes a new connection using the specified transport. func (f *Fluent) connect() (err error) { switch f.Config.FluentNetwork { case "tcp": f.conn, err = net.DialTimeout(f.Config.FluentNetwork, f.Config.FluentHost+":"+strconv.Itoa(f.Config.FluentPort), f.Config.Timeout) case "unix": f.conn, err = net.DialTimeout(f.Config.FluentNetwork, f.Config.FluentSocketPath, f.Config.Timeout) default: err = net.UnknownNetworkError(f.Config.FluentNetwork) } return } func e(x, y float64) int { return int(math.Pow(x, y)) } func (f *Fluent) reconnect() { go func() { for i := 0; ; i++ { err := f.connect() if err == nil { f.mu.Lock() f.reconnecting = false f.mu.Unlock() break } else { if i == f.Config.MaxRetry { panic("fluent#reconnect: failed to reconnect!") } waitTime := f.Config.RetryWait * e(defaultReconnectWaitIncreRate, float64(i-1)) time.Sleep(time.Duration(waitTime) * time.Millisecond) } } }() } func (f *Fluent) flushBuffer() { f.mu.Lock() defer f.mu.Unlock() f.pending = f.pending[0:0] } func (f *Fluent) send() (err error) { if f.conn == nil { if f.reconnecting == false { f.mu.Lock() f.reconnecting = true f.mu.Unlock() f.reconnect() } err = errors.New("fluent#send: can't send logs, client is reconnecting") } else { f.mu.Lock() _, err = f.conn.Write(f.pending) f.mu.Unlock() } return } fluent-logger-golang-1.1.0/fluent/fluent_test.go000066400000000000000000000122151265427165600217270ustar00rootroot00000000000000package fluent import ( "bytes" "net" "runtime" "testing" "time" "github.com/bmizerany/assert" ) const ( RECV_BUF_LEN = 1024 ) // Conn is io.WriteCloser type Conn struct { bytes.Buffer } func (c *Conn) Close() error { return nil } func init() { numProcs := runtime.NumCPU() if numProcs < 2 { numProcs = 2 } runtime.GOMAXPROCS(numProcs) listener, err := net.Listen("tcp", "0.0.0.0:6666") if err != nil { println("error listening:", err.Error()) } go func() { for { conn, err := listener.Accept() if err != nil { println("Error accept:", err.Error()) return } go EchoFunc(conn) } }() } func EchoFunc(conn net.Conn) { for { buf := make([]byte, RECV_BUF_LEN) n, err := conn.Read(buf) if err != nil { println("Error reading:", err.Error()) return } println("received ", n, " bytes of data =", string(buf)) } } func Test_New_itShouldUseDefaultConfigValuesIfNoOtherProvided(t *testing.T) { f, _ := New(Config{}) assert.Equal(t, f.Config.FluentPort, defaultPort) assert.Equal(t, f.Config.FluentHost, defaultHost) assert.Equal(t, f.Config.Timeout, defaultTimeout) assert.Equal(t, f.Config.BufferLimit, defaultBufferLimit) assert.Equal(t, f.Config.FluentNetwork, defaultNetwork) assert.Equal(t, f.Config.FluentSocketPath, defaultSocketPath) } func Test_New_itShouldUseUnixDomainSocketIfUnixSocketSpecified(t *testing.T) { socketFile := "/tmp/fluent-logger-golang.sock" network := "unix" l, err := net.Listen(network, socketFile) if err != nil { t.Error(err) return } defer l.Close() f, err := New(Config{ FluentNetwork: network, FluentSocketPath: socketFile}) if err != nil { t.Error(err) return } defer f.Close() assert.Equal(t, f.Config.FluentNetwork, network) assert.Equal(t, f.Config.FluentSocketPath, socketFile) socketFile = "/tmp/fluent-logger-golang-xxx.sock" network = "unixxxx" fUnknown, err := New(Config{ FluentNetwork: network, FluentSocketPath: socketFile}) if _, ok := err.(net.UnknownNetworkError); !ok { t.Errorf("err type: %T", err) } if err == nil { t.Error(err) fUnknown.Close() return } } func Test_New_itShouldUseConfigValuesFromArguments(t *testing.T) { f, _ := New(Config{FluentPort: 6666, FluentHost: "foobarhost"}) assert.Equal(t, f.Config.FluentPort, 6666) assert.Equal(t, f.Config.FluentHost, "foobarhost") } func Test_send_WritePendingToConn(t *testing.T) { f := &Fluent{Config: Config{}, reconnecting: false} buf := &Conn{} f.conn = buf msg := "This is test writing." bmsg := []byte(msg) f.pending = append(f.pending, bmsg...) err := f.send() if err != nil { t.Error(err) } rcv := buf.String() if rcv != msg { t.Errorf("got %s, except %s", rcv, msg) } } func Benchmark_PostWithShortMessage(b *testing.B) { b.StopTimer() f, err := New(Config{}) if err != nil { panic(err) } b.StartTimer() data := map[string]string{"message": "Hello World"} for i := 0; i < b.N; i++ { if err := f.Post("tag", data); err != nil { panic(err) } } } func Benchmark_LogWithChunks(b *testing.B) { b.StopTimer() f, err := New(Config{}) if err != nil { panic(err) } b.StartTimer() data := map[string]string{"msg": "sdfsdsdfdsfdsddddfsdfsdsdfdsfdsddddfsdfsdsdfdsfdsddddfsdfsdsdfdsfdsddddfsdfsdsdfdsfdsddddfsdfsdsdfdsfdsddddfsdfsdsdfdsfdsddddfsdfsdsdfdsfdsddddf"} for i := 0; i < b.N; i++ { if err := f.Post("tag", data); err != nil { panic(err) } } } func Benchmark_PostWithStruct(b *testing.B) { b.StopTimer() f, err := New(Config{}) if err != nil { panic(err) } b.StartTimer() data := struct { Name string `msg:"msgnamename"` }{ "john smith", } for i := 0; i < b.N; i++ { if err := f.Post("tag", data); err != nil { panic(err) } } } func Benchmark_PostWithStructTaggedAsCodec(b *testing.B) { b.StopTimer() f, err := New(Config{}) if err != nil { panic(err) } b.StartTimer() data := struct { Name string `codec:"codecname"` }{ "john smith", } for i := 0; i < b.N; i++ { if err := f.Post("tag", data); err != nil { panic(err) } } } func Benchmark_PostWithStructWithoutTag(b *testing.B) { b.StopTimer() f, err := New(Config{}) if err != nil { panic(err) } b.StartTimer() data := struct { Name string }{ "john smith", } for i := 0; i < b.N; i++ { if err := f.Post("tag", data); err != nil { panic(err) } } } func Benchmark_PostWithMapString(b *testing.B) { b.StopTimer() f, err := New(Config{}) if err != nil { panic(err) } b.StartTimer() data := map[string]string{ "foo": "bar", } for i := 0; i < b.N; i++ { if err := f.Post("tag", data); err != nil { panic(err) } } } func Benchmark_PostWithMapSlice(b *testing.B) { b.StopTimer() f, err := New(Config{}) if err != nil { panic(err) } b.StartTimer() data := map[string][]int{ "foo": {1, 2, 3}, } for i := 0; i < b.N; i++ { if err := f.Post("tag", data); err != nil { panic(err) } } } func Benchmark_PostWithMapStringAndTime(b *testing.B) { b.StopTimer() f, err := New(Config{}) if err != nil { panic(err) } b.StartTimer() data := map[string]string{ "foo": "bar", } tm := time.Now() for i := 0; i < b.N; i++ { if err := f.PostWithTime("tag", tm, data); err != nil { panic(err) } } } fluent-logger-golang-1.1.0/fluent/proto.go000066400000000000000000000007361265427165600205430ustar00rootroot00000000000000//go:generate msgp package fluent //msgp:tuple Entry type Entry struct { Time int64 `msg:"time"` Record interface{} `msg:"record"` } //msgp:tuple Forward type Forward struct { Tag string `msg:"tag"` Entries []Entry `msg:"entries"` Option interface{} `msg:"option"` } //msgp:tuple Message type Message struct { Tag string `msg:"tag"` Time int64 `msg:"time"` Record interface{} `msg:"record"` Option interface{} `msg:"option"` } fluent-logger-golang-1.1.0/fluent/proto_gen.go000066400000000000000000000160011265427165600213640ustar00rootroot00000000000000package 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 *Entry) DecodeMsg(dc *msgp.Reader) (err error) { var ssz uint32 ssz, err = dc.ReadArrayHeader() if err != nil { return } if ssz != 2 { err = msgp.ArrayError{Wanted: 2, Got: ssz} return } z.Time, err = dc.ReadInt64() if err != nil { return } z.Record, err = dc.ReadIntf() if err != nil { return } return } // EncodeMsg implements msgp.Encodable func (z Entry) EncodeMsg(en *msgp.Writer) (err error) { err = en.WriteArrayHeader(2) if err != nil { return } err = en.WriteInt64(z.Time) if err != nil { return } err = en.WriteIntf(z.Record) if err != nil { return } return } // 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) o = msgp.AppendInt64(o, z.Time) o, err = msgp.AppendIntf(o, z.Record) if err != nil { return } return } // 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 } } z.Time, bts, err = msgp.ReadInt64Bytes(bts) if err != nil { return } z.Record, bts, err = msgp.ReadIntfBytes(bts) if err != nil { return } o = bts return } func (z Entry) Msgsize() (s int) { s = msgp.ArrayHeaderSize + 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() if err != nil { return } if ssz != 3 { err = msgp.ArrayError{Wanted: 3, Got: ssz} return } z.Tag, err = dc.ReadString() if err != nil { return } var xsz uint32 xsz, err = dc.ReadArrayHeader() if err != nil { return } if cap(z.Entries) >= int(xsz) { z.Entries = z.Entries[:xsz] } else { z.Entries = make([]Entry, xsz) } for xvk := range z.Entries { var ssz uint32 ssz, err = dc.ReadArrayHeader() if err != nil { return } if ssz != 2 { err = msgp.ArrayError{Wanted: 2, Got: ssz} return } z.Entries[xvk].Time, err = dc.ReadInt64() if err != nil { return } z.Entries[xvk].Record, err = dc.ReadIntf() if err != nil { return } } z.Option, err = dc.ReadIntf() if err != nil { return } return } // EncodeMsg implements msgp.Encodable func (z *Forward) EncodeMsg(en *msgp.Writer) (err error) { err = en.WriteArrayHeader(3) if err != nil { return } err = en.WriteString(z.Tag) if err != nil { return } err = en.WriteArrayHeader(uint32(len(z.Entries))) if err != nil { return } for xvk := range z.Entries { err = en.WriteArrayHeader(2) if err != nil { return } err = en.WriteInt64(z.Entries[xvk].Time) if err != nil { return } err = en.WriteIntf(z.Entries[xvk].Record) if err != nil { return } } err = en.WriteIntf(z.Option) if err != nil { return } return } // 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) 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) if err != nil { return } } o, err = msgp.AppendIntf(o, z.Option) if err != nil { return } return } // 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 } } z.Tag, bts, err = msgp.ReadStringBytes(bts) if err != nil { return } var xsz uint32 xsz, bts, err = msgp.ReadArrayHeaderBytes(bts) if err != nil { return } if cap(z.Entries) >= int(xsz) { z.Entries = z.Entries[:xsz] } 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[xvk].Time, bts, err = msgp.ReadInt64Bytes(bts) if err != nil { return } z.Entries[xvk].Record, bts, err = msgp.ReadIntfBytes(bts) if err != nil { return } } z.Option, bts, err = msgp.ReadIntfBytes(bts) if err != nil { return } o = bts return } 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 += msgp.GuessSize(z.Option) return } // DecodeMsg implements msgp.Decodable func (z *Message) DecodeMsg(dc *msgp.Reader) (err error) { var ssz uint32 ssz, err = dc.ReadArrayHeader() if err != nil { return } if ssz != 4 { err = msgp.ArrayError{Wanted: 4, Got: ssz} return } z.Tag, err = dc.ReadString() if err != nil { return } z.Time, err = dc.ReadInt64() 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 *Message) EncodeMsg(en *msgp.Writer) (err error) { err = en.WriteArrayHeader(4) if err != nil { return } err = en.WriteString(z.Tag) if err != nil { return } err = en.WriteInt64(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 *Message) MarshalMsg(b []byte) (o []byte, err error) { o = msgp.Require(b, z.Msgsize()) o = msgp.AppendArrayHeader(o, 4) o = msgp.AppendString(o, z.Tag) o = msgp.AppendInt64(o, z.Time) 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 *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 } } z.Tag, bts, err = msgp.ReadStringBytes(bts) if err != nil { return } z.Time, bts, err = msgp.ReadInt64Bytes(bts) 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 } func (z *Message) Msgsize() (s int) { s = msgp.ArrayHeaderSize + msgp.StringPrefixSize + len(z.Tag) + msgp.Int64Size + msgp.GuessSize(z.Record) + msgp.GuessSize(z.Option) return } fluent-logger-golang-1.1.0/fluent/proto_gen_test.go000066400000000000000000000146361265427165600224370ustar00rootroot00000000000000package fluent // NOTE: THIS FILE WAS PRODUCED BY THE // MSGP CODE GENERATION TOOL (github.com/tinylib/msgp) // DO NOT EDIT import ( "bytes" "github.com/tinylib/msgp/msgp" "testing" ) func TestEntryMarshalUnmarshal(t *testing.T) { v := Entry{} bts, err := v.MarshalMsg(nil) if err != nil { t.Fatal(err) } left, err := v.UnmarshalMsg(bts) if err != nil { t.Fatal(err) } if len(left) > 0 { t.Errorf("%d bytes left over after UnmarshalMsg(): %q", len(left), left) } left, err = msgp.Skip(bts) if err != nil { t.Fatal(err) } if len(left) > 0 { t.Errorf("%d bytes left over after Skip(): %q", len(left), left) } } func BenchmarkEntryMarshalMsg(b *testing.B) { v := Entry{} b.ReportAllocs() b.ResetTimer() for i := 0; i < b.N; i++ { v.MarshalMsg(nil) } } func BenchmarkEntryAppendMsg(b *testing.B) { v := Entry{} bts := make([]byte, 0, v.Msgsize()) bts, _ = v.MarshalMsg(bts[0:0]) b.SetBytes(int64(len(bts))) b.ReportAllocs() b.ResetTimer() for i := 0; i < b.N; i++ { bts, _ = v.MarshalMsg(bts[0:0]) } } func BenchmarkEntryUnmarshal(b *testing.B) { v := Entry{} bts, _ := v.MarshalMsg(nil) b.ReportAllocs() b.SetBytes(int64(len(bts))) b.ResetTimer() for i := 0; i < b.N; i++ { _, err := v.UnmarshalMsg(bts) if err != nil { b.Fatal(err) } } } func TestEntryEncodeDecode(t *testing.T) { v := Entry{} var buf bytes.Buffer msgp.Encode(&buf, &v) m := v.Msgsize() if buf.Len() > m { t.Logf("WARNING: Msgsize() for %v is inaccurate", v) } vn := Entry{} err := msgp.Decode(&buf, &vn) if err != nil { t.Error(err) } buf.Reset() msgp.Encode(&buf, &v) err = msgp.NewReader(&buf).Skip() if err != nil { t.Error(err) } } func BenchmarkEntryEncode(b *testing.B) { v := Entry{} var buf bytes.Buffer msgp.Encode(&buf, &v) b.SetBytes(int64(buf.Len())) en := msgp.NewWriter(msgp.Nowhere) b.ReportAllocs() b.ResetTimer() for i := 0; i < b.N; i++ { v.EncodeMsg(en) } en.Flush() } func BenchmarkEntryDecode(b *testing.B) { v := Entry{} var buf bytes.Buffer msgp.Encode(&buf, &v) b.SetBytes(int64(buf.Len())) rd := msgp.NewEndlessReader(buf.Bytes(), b) dc := msgp.NewReader(rd) b.ReportAllocs() b.ResetTimer() for i := 0; i < b.N; i++ { err := v.DecodeMsg(dc) if err != nil { b.Fatal(err) } } } func TestForwardMarshalUnmarshal(t *testing.T) { v := Forward{} bts, err := v.MarshalMsg(nil) if err != nil { t.Fatal(err) } left, err := v.UnmarshalMsg(bts) if err != nil { t.Fatal(err) } if len(left) > 0 { t.Errorf("%d bytes left over after UnmarshalMsg(): %q", len(left), left) } left, err = msgp.Skip(bts) if err != nil { t.Fatal(err) } if len(left) > 0 { t.Errorf("%d bytes left over after Skip(): %q", len(left), left) } } func BenchmarkForwardMarshalMsg(b *testing.B) { v := Forward{} b.ReportAllocs() b.ResetTimer() for i := 0; i < b.N; i++ { v.MarshalMsg(nil) } } func BenchmarkForwardAppendMsg(b *testing.B) { v := Forward{} bts := make([]byte, 0, v.Msgsize()) bts, _ = v.MarshalMsg(bts[0:0]) b.SetBytes(int64(len(bts))) b.ReportAllocs() b.ResetTimer() for i := 0; i < b.N; i++ { bts, _ = v.MarshalMsg(bts[0:0]) } } func BenchmarkForwardUnmarshal(b *testing.B) { v := Forward{} bts, _ := v.MarshalMsg(nil) b.ReportAllocs() b.SetBytes(int64(len(bts))) b.ResetTimer() for i := 0; i < b.N; i++ { _, err := v.UnmarshalMsg(bts) if err != nil { b.Fatal(err) } } } func TestForwardEncodeDecode(t *testing.T) { v := Forward{} var buf bytes.Buffer msgp.Encode(&buf, &v) m := v.Msgsize() if buf.Len() > m { t.Logf("WARNING: Msgsize() for %v is inaccurate", v) } vn := Forward{} err := msgp.Decode(&buf, &vn) if err != nil { t.Error(err) } buf.Reset() msgp.Encode(&buf, &v) err = msgp.NewReader(&buf).Skip() if err != nil { t.Error(err) } } func BenchmarkForwardEncode(b *testing.B) { v := Forward{} var buf bytes.Buffer msgp.Encode(&buf, &v) b.SetBytes(int64(buf.Len())) en := msgp.NewWriter(msgp.Nowhere) b.ReportAllocs() b.ResetTimer() for i := 0; i < b.N; i++ { v.EncodeMsg(en) } en.Flush() } func BenchmarkForwardDecode(b *testing.B) { v := Forward{} var buf bytes.Buffer msgp.Encode(&buf, &v) b.SetBytes(int64(buf.Len())) rd := msgp.NewEndlessReader(buf.Bytes(), b) dc := msgp.NewReader(rd) b.ReportAllocs() b.ResetTimer() for i := 0; i < b.N; i++ { err := v.DecodeMsg(dc) if err != nil { b.Fatal(err) } } } func TestMessageMarshalUnmarshal(t *testing.T) { v := Message{} bts, err := v.MarshalMsg(nil) if err != nil { t.Fatal(err) } left, err := v.UnmarshalMsg(bts) if err != nil { t.Fatal(err) } if len(left) > 0 { t.Errorf("%d bytes left over after UnmarshalMsg(): %q", len(left), left) } left, err = msgp.Skip(bts) if err != nil { t.Fatal(err) } if len(left) > 0 { t.Errorf("%d bytes left over after Skip(): %q", len(left), left) } } func BenchmarkMessageMarshalMsg(b *testing.B) { v := Message{} b.ReportAllocs() b.ResetTimer() for i := 0; i < b.N; i++ { v.MarshalMsg(nil) } } func BenchmarkMessageAppendMsg(b *testing.B) { v := Message{} bts := make([]byte, 0, v.Msgsize()) bts, _ = v.MarshalMsg(bts[0:0]) b.SetBytes(int64(len(bts))) b.ReportAllocs() b.ResetTimer() for i := 0; i < b.N; i++ { bts, _ = v.MarshalMsg(bts[0:0]) } } func BenchmarkMessageUnmarshal(b *testing.B) { v := Message{} bts, _ := v.MarshalMsg(nil) b.ReportAllocs() b.SetBytes(int64(len(bts))) b.ResetTimer() for i := 0; i < b.N; i++ { _, err := v.UnmarshalMsg(bts) if err != nil { b.Fatal(err) } } } func TestMessageEncodeDecode(t *testing.T) { v := Message{} var buf bytes.Buffer msgp.Encode(&buf, &v) m := v.Msgsize() if buf.Len() > m { t.Logf("WARNING: Msgsize() for %v is inaccurate", v) } vn := Message{} err := msgp.Decode(&buf, &vn) if err != nil { t.Error(err) } buf.Reset() msgp.Encode(&buf, &v) err = msgp.NewReader(&buf).Skip() if err != nil { t.Error(err) } } func BenchmarkMessageEncode(b *testing.B) { v := Message{} var buf bytes.Buffer msgp.Encode(&buf, &v) b.SetBytes(int64(buf.Len())) en := msgp.NewWriter(msgp.Nowhere) b.ReportAllocs() b.ResetTimer() for i := 0; i < b.N; i++ { v.EncodeMsg(en) } en.Flush() } func BenchmarkMessageDecode(b *testing.B) { v := Message{} var buf bytes.Buffer msgp.Encode(&buf, &v) b.SetBytes(int64(buf.Len())) rd := msgp.NewEndlessReader(buf.Bytes(), b) dc := msgp.NewReader(rd) b.ReportAllocs() b.ResetTimer() for i := 0; i < b.N; i++ { err := v.DecodeMsg(dc) if err != nil { b.Fatal(err) } } } fluent-logger-golang-1.1.0/fluent/version.go000066400000000000000000000000501265427165600210520ustar00rootroot00000000000000package fluent const Version = "1.1.0"