Change to use a pool of byte buffer to encode data

buffer.go

@@ -5,44 +5,43 @@ import (
 )
 
 type buffer struct {
-	buf   []byte
+	buf   []*Message
 	mu    sync.Mutex
 	Dirty chan struct{}
 }
 
 func newBuffer() buffer {
 	return buffer{
-		buf:   []byte{},
 		Dirty: make(chan struct{}),
 	}
 }
 
-func (buffer *buffer) Add(raw []byte) {
+func (buffer *buffer) Add(message *Message) {
 	buffer.mu.Lock()
 	defer buffer.mu.Unlock()
 
-	buffer.buf = append(buffer.buf, raw...)
+	buffer.buf = append(buffer.buf, message)
 	go func() {
 		buffer.Dirty <- struct{}{}
 	}()
 }
 
-func (buffer *buffer) Remove() []byte {
+func (buffer *buffer) Remove() []*Message {
 	buffer.mu.Lock()
 	defer buffer.mu.Unlock()
 
 	if len(buffer.buf) == 0 {
 		return nil
 	}
 
-	data := buffer.buf
+	m := buffer.buf
 	buffer.buf = buffer.buf[:0]
-	return data
+	return m
 }
 
-func (buffer *buffer) Back(raw []byte) {
+func (buffer *buffer) Back(messages []*Message) {
 	buffer.mu.Lock()
 	defer buffer.mu.Unlock()
 
-	buffer.buf = append(buffer.buf, raw...)
+	buffer.buf = append(buffer.buf, messages...)
 }

logger.go

@@ -7,8 +7,6 @@ import (
 	"sync"
 	"time"
 
-	"bytes"
-
 	"gopkg.in/vmihailenco/msgpack.v2"
 )
 
@@ -66,12 +64,12 @@ func (logger *Logger) PostWithTime(tag string, t time.Time, obj interface{}) err
 		obj,
 	}
 
-	buf := bytes.NewBuffer([]byte{})
-	enc := msgpack.NewEncoder(buf)
+	m := getMessage()
+	enc := msgpack.NewEncoder(m.buf)
 	if err := enc.Encode(record); err != nil {
 		return err
 	}
-	logger.buf.Add(buf.Bytes())
+	logger.buf.Add(m)
 	return nil
 }
 
@@ -119,24 +117,31 @@ func (logger *Logger) disconnect() error {
 const maxWriteAttempts = 3
 
 func (logger *Logger) send() error {
-	data := logger.buf.Remove()
-	if len(data) == 0 {
+	messages := logger.buf.Remove()
+	if len(messages) == 0 {
 		return nil
 	}
+	var data []byte
+	for _, m := range messages {
+		data = append(data, m.buf.Bytes()...)
+	}
 
 	var err error
 	for i := 0; i < maxWriteAttempts; i++ {
 		err = logger.connect()
 		if err == nil {
 			_, err := logger.conn.Write(data)
 			if err == nil {
+				for _, m := range messages {
+					putMessage(m)
+				}
 				break
 			}
 		}
 		logger.disconnect()
 	}
 	if err != nil {
-		logger.buf.Back(data)
+		logger.buf.Back(messages)
 	}
 	return err
 }
@@ -149,12 +154,18 @@ func (logger *Logger) start() {
 		for {
 			select {
 			case <-logger.done:
-				logger.send()
+				err := logger.send()
+				if err != nil {
+					panic(err)
+				}
 				return
 			case <-logger.buf.Dirty:
 			case <-ticker.C:
 			}
-			logger.send()
+			err := logger.send()
+			if err != nil {
+				panic(err)
+			}
 		}
 	}()
 }

message.go

@@ -0,0 +1,32 @@
+package fluent
+
+import (
+	"bytes"
+	"sync"
+)
+
+type Message struct {
+	buf *bytes.Buffer
+}
+
+var messagePool = sync.Pool{
+	New: func() interface{} {
+		return newMessage()
+	},
+}
+
+func getMessage() *Message {
+	message := messagePool.Get().(*Message)
+	message.buf.Reset()
+	return message
+}
+
+func putMessage(message *Message) {
+	messagePool.Put(message)
+}
+
+func newMessage() *Message {
+	return &Message{
+		buf: bytes.NewBuffer([]byte{}),
+	}
+}