Use circular buffer for zap logs

internal/util/logging/logging.go

@@ -31,11 +31,18 @@ func Setup(level zapcore.Level) {
 		log.Fatal(err)
 	}
 
-	SetupWithLogger(logger)
+	RecentEntries = NewCircularBuffer(1024)
+
+	logger = logger.WithOptions(zap.Hooks(func(entry zapcore.Entry) error {
+		RecentEntries.append(&entry)
+		return nil
+	}))
+
+	setupWithLogger(logger)
 }
 
-// SetupWithLogger initializes logging with a given logger and its level.
-func SetupWithLogger(logger *zap.Logger) {
+// setupWithLogger initializes logging with a given logger and its level.
+func setupWithLogger(logger *zap.Logger) {
 	zap.ReplaceGlobals(logger)
 
 	if _, err := zap.RedirectStdLogAt(logger, zap.InfoLevel); err != nil {

internal/util/logging/logram.go

@@ -0,0 +1,71 @@
+// Copyright 2021 FerretDB Inc.
+//
+// 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.
+
+package logging
+
+import (
+	"fmt"
+	"sync"
+
+	"go.uber.org/zap/zapcore"
+)
+
+// RecentEntries implements zap logging entries interception
+// and stores the last 1024 entries in circular buffer in memory.
+var RecentEntries *circularBuffer
+
+// circularBuffer is a storage of log records in memory.
+type circularBuffer struct {
+	mu    sync.RWMutex
+	log   []*zapcore.Entry
+	index int64
+}
+
+// NewCircularBuffer creates a circular buffer for log entries in memory.
+func NewCircularBuffer(size int64) *circularBuffer {
+	if size < 1 {
+		panic(fmt.Sprintf("buffer size must be at least 1, but %d provided", size))
+	}
+
+	return &circularBuffer{
+		log: make([]*zapcore.Entry, size),
+	}
+}
+
+// append adds an entry in circularBuffer.
+func (l *circularBuffer) append(entry *zapcore.Entry) {
+	l.mu.Lock()
+	defer l.mu.Unlock()
+
+	l.log[l.index] = entry
+	l.index = (l.index + 1) % int64(len(l.log))
+}
+
+// Get returns entries from circularBuffer.
+func (l *circularBuffer) Get() []*zapcore.Entry {
+	l.mu.RLock()
+	defer l.mu.RUnlock()
+
+	n := len(l.log)
+	entries := make([]*zapcore.Entry, 0, n)
+	for i := int64(0); i < int64(len(l.log)); i++ {
+		k := (i + l.index) % int64(len(l.log))
+
+		if l.log[k] != nil {
+			entries = append(entries, l.log[k])
+		}
+	}
+
+	return entries
+}

internal/util/logging/logram_test.go

@@ -0,0 +1,140 @@
+// Copyright 2021 FerretDB Inc.
+//
+// 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.
+
+package logging
+
+import (
+	"fmt"
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/assert"
+	"go.uber.org/zap"
+	"go.uber.org/zap/zapcore"
+)
+
+func TestCircularBuffer(t *testing.T) {
+	for name, tc := range map[string]struct {
+		size     int64
+		msgPanic string
+	}{
+		"PanicNegativSize": {
+			size:     -2,
+			msgPanic: "buffer size must be at least 1, but -2 provided",
+		},
+		"PanicZeroSize": {
+			size:     0,
+			msgPanic: "buffer size must be at least 1, but 0 provided",
+		},
+	} {
+		name, tc := name, tc
+		t.Run(name, func(t *testing.T) {
+			assert.PanicsWithValue(t, tc.msgPanic, func() { NewCircularBuffer(tc.size) })
+		})
+	}
+
+	logram := NewCircularBuffer(2)
+	for n, tc := range []struct {
+		inLog    zapcore.Entry
+		expected []zapcore.Entry
+	}{{
+		inLog: zapcore.Entry{
+			Level:      1,
+			Time:       time.Date(2022, 12, 31, 11, 59, 1, 0, time.UTC),
+			LoggerName: "logger_1",
+			Message:    "message 1",
+		},
+		expected: []zapcore.Entry{{
+			Level:      1,
+			Time:       time.Date(2022, 12, 31, 11, 59, 1, 0, time.UTC),
+			LoggerName: "logger_1",
+			Message:    "message 1",
+		}},
+	}, {
+		inLog: zapcore.Entry{
+			Level:      2,
+			Time:       time.Date(2022, 12, 31, 11, 59, 2, 0, time.UTC),
+			LoggerName: "logger_2",
+			Message:    "message 2",
+		},
+		expected: []zapcore.Entry{{
+			Level:      1,
+			Time:       time.Date(2022, 12, 31, 11, 59, 1, 0, time.UTC),
+			LoggerName: "logger_1",
+			Message:    "message 1",
+		}, {
+			Level:      2,
+			Time:       time.Date(2022, 12, 31, 11, 59, 2, 0, time.UTC),
+			LoggerName: "logger_2",
+			Message:    "message 2",
+		}},
+	}, {
+		inLog: zapcore.Entry{
+			Level:      3,
+			Time:       time.Date(2022, 12, 31, 11, 59, 3, 0, time.UTC),
+			LoggerName: "logger_3",
+			Message:    "message 3",
+		},
+		expected: []zapcore.Entry{{
+			Level:      2,
+			Time:       time.Date(2022, 12, 31, 11, 59, 2, 0, time.UTC),
+			LoggerName: "logger_2",
+			Message:    "message 2",
+		}, {
+			Level:      3,
+			Time:       time.Date(2022, 12, 31, 11, 59, 3, 0, time.UTC),
+			LoggerName: "logger_3",
+			Message:    "message 3",
+		}},
+	}} {
+		name := fmt.Sprintf("AppendGet_%d", n)
+		tc := tc
+		t.Run(name, func(t *testing.T) {
+			logram.append(&tc.inLog)
+			actual := logram.Get()
+			for i, exp := range tc.expected {
+				assert.Equal(t, exp, *actual[i])
+			}
+		})
+	}
+
+	Setup(zap.DebugLevel)
+	logger := zap.L()
+	for n, tc := range []struct {
+		addMsg   string
+		expected []string
+	}{{
+		addMsg:   "Test message 1",
+		expected: []string{"Test message 1"},
+	}, {
+		addMsg:   "Test message 2",
+		expected: []string{"Test message 1", "Test message 2"},
+	}, {
+		addMsg:   "Test message 3",
+		expected: []string{"Test message 1", "Test message 2", "Test message 3"},
+	}, {
+		addMsg:   "Test message 4",
+		expected: []string{"Test message 1", "Test message 2", "Test message 3", "Test message 4"},
+	}} {
+		name := fmt.Sprintf("ZapHooks_%d", n)
+		tc := tc
+		t.Run(name, func(t *testing.T) {
+			logger.Info(tc.addMsg)
+			actual := RecentEntries.Get()
+			for i, exp := range tc.expected {
+				assert.Equal(t, exp, actual[i].Message)
+			}
+		})
+	}
+}