snapshot of https://github.com/cortezaproject/corteza.git (2024.9.x, 2026-09-18; blobs > 131072B omitted)

server/pkg/logger/rrbuf.go

@@ -0,0 +1,154 @@
+package logger
+
+import (
+	"fmt"
+	"io"
+	"sync"
+
+	"go.uber.org/zap"
+	"go.uber.org/zap/zapcore"
+)
+
+type (
+	rrBufEntry struct {
+		num int
+		rec []byte
+	}
+
+	// simple round-robin struct that holds our buffer with log entries
+	rr struct {
+		mux sync.RWMutex
+		num int
+		buf []*rrBufEntry
+	}
+
+	debugBufferingLogger struct {
+		zapcore.LevelEnabler
+		out *rr
+		enc zapcore.Encoder
+	}
+)
+
+const (
+	// allowing 10k entries (no limiting the entry size)
+	debugLogCap = 10240
+)
+
+var (
+	// initialize debug logger round robin db
+	debugLogRR = &rr{
+		buf: make([]*rrBufEntry, 0),
+	}
+)
+
+// WriteLogBuffer provides access to default debug log buffer
+func WriteLogBuffer(w io.Writer, after, limit int) (_ int, err error) {
+	return writeLogBuffer(w, debugLogRR, after, limit)
+}
+
+// writes stream of entries from log buffer into provided writer array of JSON objects.
+func writeLogBuffer(w io.Writer, logBuf *rr, after, limit int) (_ int, err error) {
+	var (
+		// was at least one entry outputted?
+		has bool
+	)
+
+	debugLogRR.mux.RLock()
+	defer debugLogRR.mux.RUnlock()
+	if _, err = w.Write([]byte{'['}); err != nil {
+		return
+	}
+
+	for _, e := range logBuf.buf {
+		if after >= e.num {
+			continue
+		}
+
+		// count back to zero
+		limit--
+
+		if has {
+			if _, err = w.Write([]byte{','}); err != nil {
+				return
+			}
+		}
+
+		if _, err = w.Write(e.rec); err != nil {
+			return
+		}
+
+		if limit == 0 {
+			break
+		}
+
+		has = true
+	}
+
+	if _, err = w.Write([]byte{']'}); err != nil {
+		return
+	}
+
+	return
+}
+
+func (r *rr) append(ent []byte) {
+	r.mux.Lock()
+	defer r.mux.Unlock()
+
+	r.num++
+
+	// modify serialized json
+	var bufEnt = &rrBufEntry{r.num, append(ent[:len(ent)-2], []byte(fmt.Sprintf(`,"index":%d}`, r.num))...)}
+
+	if len(r.buf) >= debugLogCap {
+		r.buf = append(r.buf[1:], bufEnt)
+	} else {
+		r.buf = append(r.buf, bufEnt)
+	}
+}
+
+// DebugBufferedLogger provides buffered logger compatible with zap.
+func DebugBufferedLogger(out *rr) *debugBufferingLogger {
+	var encConf = zap.NewProductionEncoderConfig()
+	encConf.EncodeTime = zapcore.RFC3339NanoTimeEncoder
+
+	return &debugBufferingLogger{
+		LevelEnabler: zapcore.DebugLevel,
+		out:          out,
+		enc:          zapcore.NewJSONEncoder(encConf),
+	}
+}
+
+func (c *debugBufferingLogger) With(fields []zapcore.Field) zapcore.Core {
+	clone := c.clone()
+	for i := range fields {
+		fields[i].AddTo(clone.enc)
+	}
+	return clone
+}
+
+func (c *debugBufferingLogger) Check(ent zapcore.Entry, ce *zapcore.CheckedEntry) *zapcore.CheckedEntry {
+	if c.Enabled(ent.Level) {
+		return ce.AddCore(ent, c)
+	}
+	return ce
+}
+
+func (c *debugBufferingLogger) Write(ent zapcore.Entry, fields []zapcore.Field) error {
+	encbuf, err := c.enc.EncodeEntry(ent, fields)
+	if err != nil {
+		return err
+	}
+
+	c.out.append(encbuf.Bytes())
+	return nil
+}
+
+func (c *debugBufferingLogger) Sync() error { return nil }
+func (c *debugBufferingLogger) clone() *debugBufferingLogger {
+	return &debugBufferingLogger{
+		LevelEnabler: c.LevelEnabler,
+		enc:          c.enc.Clone(),
+		out:          c.out,
+	}
+}