add group feature

Author: Aiden

batcher.go

@@ -48,9 +48,25 @@ type chainData struct {
 	timeout time.Duration // option
 
 	lastUpdated time.Time
-	wait        time.Duration
+	wait        time.Duration // option
+
+	groupKey    string
+	groupValues []string
 }
 
+// type marshalZerologTexts []text
+// type text string
+
+// func (uu marshalZerologTexts) MarshalZerologArray(a *zerolog.Array) {
+// 	for _, u := range uu {
+// 		a.Object(u)
+// 	}
+// }
+
+// func (u text) MarshalZerologObject(e *zerolog.Event) {
+// 	e.Str("", string(u))
+// }
+
 func (c *chainData) needLogged() bool {
 	now := time.Now()
 	return c.count >= c.maxRelativeBatch || // reached max batch counts
@@ -125,7 +141,7 @@ func (b *chainedBatcher) Batch(e *event, opts ...BatchOption) {
 		if k == len(e.batchKeysA)-1 {
 			value, _ := node.nexts[v]
 			if value.data == nil {
-				value.data = rawChainData(e.event)
+				value.data = rawChainData(e)
 
 				if len(e.logger.opts) > 0 {
 					value.data.applyOpts(e.logger.opts...)
@@ -136,21 +152,29 @@ func (b *chainedBatcher) Batch(e *event, opts ...BatchOption) {
 
 			value.data.count++
 			value.data.lastUpdated = time.Now()
+
+			if len(e.group.key) > 0 {
+				value.data.groupValues = append(value.data.groupValues, e.group.value)
+			}
+
 			node.nexts[v] = value
 		}
 
 		node = node.nexts[v]
 	}
 }
 
-func rawChainData(event *zerolog.Event) *chainData {
+func rawChainData(event *event) *chainData {
 	return &chainData{
-		event:            event,
+		event:            event.event,
 		count:            0,
 		start:            time.Now(),
 		timeout:          10 * time.Second,
 		maxRelativeBatch: 20,
 		wait:             5 * time.Second,
+		// lastUpdated: time.Now(),
+		groupKey: event.group.key,
+		// groupValues: make([]string, 0),
 	}
 }
 
@@ -180,6 +204,11 @@ func (b *chainedBatcher) logging() {
 // and remove that element out of logger
 func batchOut(b *chainedBatcher, c *chainData, i int) {
 	c.event.Int("__repeat", c.count)
+
+	if len(c.groupValues) > 0 {
+		c.event.Strs(c.groupKey, c.groupValues)
+	}
+
 	c.event.Send()
 
 	b.logged[i].clean()

event_batch.go

@@ -8,17 +8,23 @@ import (
 	"github.com/rs/zerolog"
 )
 
+type pairString struct {
+	key   string
+	value string
+}
+
 // event is based on zerolog.Event, so dont reuse this after logging
 type event struct {
 	logger *Logger
 
 	level zerolog.Level
 	event *zerolog.Event
 	done  bool
-	// groupKey string
 
 	batchKeysM map[string]bool // map of keys that need to batched
 	batchKeysA []string        // array of keys that need to batched
+
+	group pairString
 }
 
 func newRawEvent(l *Logger, e func() *zerolog.Event, lvl zerolog.Level) *event {

event_group.go

@@ -0,0 +1,66 @@
+package batchlog
+
+import (
+	"encoding/json"
+	"strconv"
+)
+
+func (e *event) GroupBool(key string, value bool) *event {
+	e.group = pairString{
+		key:   key,
+		value: strconv.FormatBool(value),
+	}
+	return e
+}
+
+func (e *event) GroupInt(key string, value int) *event {
+	e.group = pairString{
+		key:   key,
+		value: strconv.FormatInt(int64(value), 10),
+	}
+	return e
+}
+
+func (e *event) GroupFloat32(key string, value float32) *event {
+	e.group = pairString{
+		key:   key,
+		value: strconv.FormatFloat(float64(value), 'f', -1, 32),
+	}
+	return e
+}
+
+func (e *event) GroupFloat64(key string, value float64) *event {
+	e.group = pairString{
+		key:   key,
+		value: strconv.FormatFloat(float64(value), 'f', -1, 64),
+	}
+	return e
+}
+
+func (e *event) GroupInterface(key string, i interface{}) *event {
+	if b, err := json.Marshal(i); err != nil {
+		return nil
+	} else {
+		e.group = pairString{
+			key:   key,
+			value: string(b),
+		}
+		return e
+	}
+}
+
+func (e *event) GroupStr(key string, value string) *event {
+	e.group = pairString{
+		key:   key,
+		value: value,
+	}
+	return e
+}
+
+func (e *event) GroupErr(err error) *event {
+	e.group = pairString{
+		key:   "error",
+		value: err.Error(),
+	}
+	return e
+}

logtest/log_test.go

@@ -56,6 +56,16 @@ func TestMaxRelatitveBatch(t *testing.T) {
 	time.Sleep(time.Hour)
 }
 
+func TestGroup(t *testing.T) {
+	logger := batchlog.NewLogger(batchlog.OptTimeout(time.Hour))
+	for i := 0; i < 30; i++ {
+		time.Sleep(1500 * time.Millisecond)
+		logger.Debug().BatchStr("tokenId", "123456").GroupInt("id", i).BatchMsg("hello")
+	}
+	fmt.Println("done")
+	time.Sleep(time.Hour)
+}
+
 func TestScenario(t *testing.T) {
 	logger := batchlog.NewLogger(batchlog.OptTimeout(time.Hour))