Merge pull request #33 from dl1998/add-async-structuredlogger

Add async structuredlogger

docs/architecture/diagrams/plantuml/class_diagram.plantuml

@@ -455,6 +455,28 @@ package pkg {
             + Critical(parameters : ...any)
             + Emergency(parameters : ...any)
         }
+        struct baseAsyncLogger implements baseLoggerInterface {
+            ~ *baseLogger
+            ~ messageQueue : chan logrecord.Interface
+            ~ waitGroup sync.WaitGroup
+            ~ startListeningMessages()
+            + WaitToFinishLogging()
+            + Open(queueSize : int)
+            + Close()
+            + Log(level : level.Level, parameters : ...any)
+        }
+        interface AsyncLoggerInterface extends Interface {
+            + Interface
+            + WaitToFinishLogging()
+            + Open(queueSize : int)
+            + Close()
+        }
+        struct AsyncLogger implements AsyncLoggerInterface {
+            + *Logger
+            + WaitToFinishLogging()
+            + Open(queueSize : int)
+            + Close()
+        }
         struct Configuration {
             ~ fromLevel : level.Level
             ~ toLevel : level.Level
@@ -475,6 +497,7 @@ package pkg {
             ~ template : map[string]string
             ~ init()
             + New(name : string, timeFormat : string) : *Logger
+            + NewAsyncLogger(name : string, timeFormat : string, queueSize : int) : *AsyncLogger
             + WithFromLevel(fromLevel : level.Level) : Option
             + WithToLevel(toLevel : level.Level) : Option
             + WithTemplate(template : map[string]string) : Option
@@ -504,7 +527,9 @@ package pkg {
             + Emergency(message : string, parameters : ...any)
         }
 
+        baseAsyncLogger *-- baseLogger
         Logger *-- baseLoggerInterface
+        AsyncLogger *-- Logger
         "<<module>>" ..> Logger : uses
         "<<module>>" ..> Option : uses
         "<<module>>" ..> Configuration : uses

examples/README.md

@@ -9,6 +9,13 @@ Demonstrates how to create a new custom logger for the application.
 It creates an async logger with provided queue size that writes messages on the console asynchronously. It also provides
 an example how to wait for all messages to be written.
 
+## customasyncstructuredlogger
+
+Demonstrates how to create a new custom structured logger for the application.
+
+It creates an async structured logger with provided queue size that writes messages on the console asynchronously. It
+also provides an example how to wait for all messages to be written.
+
 ## customlogger
 
 Demonstrates how to create a new custom logger for the application.

examples/customasyncstructuredlogger/main.go

@@ -0,0 +1,33 @@
+// Example that shows how to create and use custom async structured logger.
+package main
+
+import (
+	"fmt"
+	"github.com/dl1998/go-logging/pkg/common/level"
+	"github.com/dl1998/go-logging/pkg/structuredlogger"
+	"github.com/dl1998/go-logging/pkg/structuredlogger/formatter"
+	"github.com/dl1998/go-logging/pkg/structuredlogger/handler"
+	"time"
+)
+
+func main() {
+	asyncQueueSize := 10
+
+	applicationLogger := structuredlogger.NewAsyncLogger("example", time.DateTime, asyncQueueSize)
+
+	applicationFormatter := formatter.NewJSON(map[string]string{
+		"time":  "%(datetime)",
+		"level": "%(level)",
+		"name":  "%(name)",
+	}, false)
+	consoleHandler := handler.NewConsoleHandler(level.Debug, level.Null, applicationFormatter)
+	applicationLogger.AddHandler(consoleHandler)
+
+	for index := 0; index < asyncQueueSize; index++ {
+		applicationLogger.Warning("message", "This message will be displayed.")
+	}
+
+	fmt.Println("This will be printed before the last warning log message.")
+
+	applicationLogger.WaitToFinishLogging()
+}

pkg/logger/asynclogger_test.go

@@ -1,8 +1,8 @@
 package logger
 
 import (
+	"fmt"
 	"github.com/dl1998/go-logging/internal/testutils"
-	"github.com/dl1998/go-logging/pkg/common/level"
 	"github.com/dl1998/go-logging/pkg/logger/handler"
 	"github.com/dl1998/go-logging/pkg/logger/logrecord"
 	"sync"
@@ -27,7 +27,7 @@ func TestBaseAsyncLogger_startListeningMessages(t *testing.T) {
 		waitGroup:    sync.WaitGroup{},
 	}
 
-	record := logrecord.New(loggerName, 0, timeFormat, message, parameters, 3)
+	record := logrecord.New(loggerName, logLevel, timeFormat, message, parameters, skipCallers)
 	newBaseAsyncLogger.messageQueue <- record
 
 	go newBaseAsyncLogger.startListeningMessages()
@@ -37,8 +37,9 @@ func TestBaseAsyncLogger_startListeningMessages(t *testing.T) {
 	testutils.AssertEquals(t, record, mockHandler.Parameters[0].(*logrecord.LogRecord))
 }
 
-// TestBaseAsyncLogger_WaitToFinishLogging tests
-// baseAsyncLogger.WaitToFinishLogging method of the baseAsyncLogger.
+// TestBaseAsyncLogger_WaitToFinishLogging tests that
+// baseAsyncLogger.WaitToFinishLogging waits until async logger finish logging
+// messages.
 func TestBaseAsyncLogger_WaitToFinishLogging(t *testing.T) {
 	mockHandler := &MockHandler{}
 	newBaseAsyncLogger := &baseAsyncLogger{
@@ -63,8 +64,8 @@ func TestBaseAsyncLogger_WaitToFinishLogging(t *testing.T) {
 	testutils.AssertEquals(t, true, waited)
 }
 
-// TestBaseAsyncLogger_Open tests baseAsyncLogger.Open method of the
-// baseAsyncLogger.
+// TestBaseAsyncLogger_Open tests that baseAsyncLogger.Open creates a new message
+// queue and start listening messages.
 func TestBaseAsyncLogger_Open(t *testing.T) {
 	mockHandler := &MockHandler{}
 	newBaseAsyncLogger := &baseAsyncLogger{
@@ -91,8 +92,8 @@ func isChannelClosed(ch <-chan logrecord.Interface) bool {
 	}
 }
 
-// TestBaseAsyncLogger_Close tests baseAsyncLogger.Close method of the
-// baseAsyncLogger.
+// TestBaseAsyncLogger_Close tests that baseAsyncLogger.Close closes message
+// queue channel.
 func TestBaseAsyncLogger_Close(t *testing.T) {
 	mockHandler := &MockHandler{}
 	newBaseAsyncLogger := &baseAsyncLogger{
@@ -109,7 +110,8 @@ func TestBaseAsyncLogger_Close(t *testing.T) {
 	testutils.AssertEquals(t, true, isChannelClosed(newBaseAsyncLogger.messageQueue))
 }
 
-// TestBaseAsyncLogger_Log tests baseAsyncLogger.Log method of the baseAsyncLogger.
+// TestBaseAsyncLogger_Log tests that baseAsyncLogger.Log sends a new record on
+// the message queue.
 func TestBaseAsyncLogger_Log(t *testing.T) {
 	mockHandler := &MockHandler{}
 	newBaseAsyncLogger := &baseAsyncLogger{
@@ -121,12 +123,11 @@ func TestBaseAsyncLogger_Log(t *testing.T) {
 		waitGroup:    sync.WaitGroup{},
 	}
 
-	expectedMessage := "test"
-	newBaseAsyncLogger.Log(0, expectedMessage)
-	actualMessage, ok := <-newBaseAsyncLogger.messageQueue
+	newBaseAsyncLogger.Log(logLevel, message, parameters...)
+	record := <-newBaseAsyncLogger.messageQueue
 
-	testutils.AssertEquals(t, true, ok)
-	testutils.AssertEquals(t, expectedMessage, actualMessage.Message())
+	testutils.AssertEquals(t, logLevel, record.Level())
+	testutils.AssertEquals(t, fmt.Sprintf(message, parameters...), record.Message())
 }
 
 // BenchmarkBaseAsyncLogger_Log benchmarks baseAsyncLogger.Log method of the
@@ -145,11 +146,12 @@ func BenchmarkBaseAsyncLogger_Log(b *testing.B) {
 	b.ResetTimer()
 
 	for index := 0; index < b.N; index++ {
-		newBaseAsyncLogger.Log(level.Trace, message, parameters...)
+		newBaseAsyncLogger.Log(logLevel, message, parameters...)
 	}
 }
 
-// TestNewAsyncLogger tests NewAsyncLogger function of the baseAsyncLogger.
+// TestNewAsyncLogger tests that NewAsyncLogger creates and return a new
+// AsyncLogger.
 func TestNewAsyncLogger(t *testing.T) {
 	newAsyncLogger := NewAsyncLogger(loggerName, timeFormat, messageQueueSize)
 
@@ -158,16 +160,15 @@ func TestNewAsyncLogger(t *testing.T) {
 	testutils.AssertEquals(t, messageQueueSize, cap(newAsyncLogger.baseLogger.(*baseAsyncLogger).messageQueue))
 }
 
-// BenchmarkNewAsyncLogger benchmarks NewAsyncLogger function of the
-// baseAsyncLogger.
+// BenchmarkNewAsyncLogger benchmarks NewAsyncLogger.
 func BenchmarkNewAsyncLogger(b *testing.B) {
 	for index := 0; index < b.N; index++ {
 		NewAsyncLogger(loggerName, timeFormat, messageQueueSize)
 	}
 }
 
-// TestAsyncLogger_WaitToFinishLogging tests AsyncLogger.WaitToFinishLogging
-// method of the AsyncLogger.
+// TestAsyncLogger_WaitToFinishLogging tests that AsyncLogger.WaitToFinishLogging
+// waits until async logger finish logging messages.
 func TestAsyncLogger_WaitToFinishLogging(t *testing.T) {
 	mockHandler := &MockHandler{}
 	newAsyncLogger := &AsyncLogger{
@@ -195,7 +196,8 @@ func TestAsyncLogger_WaitToFinishLogging(t *testing.T) {
 	testutils.AssertEquals(t, true, waited)
 }
 
-// TestAsyncLogger_Open tests AsyncLogger.Open method of the AsyncLogger.
+// TestAsyncLogger_Open tests that AsyncLogger.Open creates a new message queue
+// and start listening messages.
 func TestAsyncLogger_Open(t *testing.T) {
 	mockHandler := &MockHandler{}
 	newAsyncLogger := &AsyncLogger{
@@ -216,7 +218,8 @@ func TestAsyncLogger_Open(t *testing.T) {
 	testutils.AssertNotNil(t, newAsyncLogger.baseLogger.(*baseAsyncLogger).messageQueue)
 }
 
-// TestAsyncLogger_Close tests AsyncLogger.Close method of the AsyncLogger.
+// TestAsyncLogger_Close tests that AsyncLogger.Close closes message queue
+// channel.
 func TestAsyncLogger_Close(t *testing.T) {
 	mockHandler := &MockHandler{}
 	newAsyncLogger := &AsyncLogger{

pkg/logger/common_test.go

@@ -15,11 +15,13 @@ import (
 var (
 	loggerTemplate = "%(level):%(name):%(message)"
 	loggerName     = "test"
+	logLevel       = level.Debug
 	message        = "Test Message: %s."
 	parameters     = []any{
 		"test",
 	}
-	timeFormat = time.RFC3339
+	timeFormat  = time.RFC3339
+	skipCallers = 3
 )
 
 // MockLogger is used to mock baseLogger.
@@ -110,7 +112,7 @@ func (mock *MockHandler) FromLevel() level.Level {
 	mock.CalledName = "FromLevel"
 	mock.Called = true
 	mock.Parameters = make([]any, 0)
-	returnValue := level.Debug
+	returnValue := logLevel
 	mock.Return = returnValue
 	return returnValue
 }
@@ -128,7 +130,7 @@ func (mock *MockHandler) ToLevel() level.Level {
 	mock.CalledName = "ToLevel"
 	mock.Called = true
 	mock.Parameters = make([]any, 0)
-	returnValue := level.Debug
+	returnValue := logLevel
 	mock.Return = returnValue
 	return returnValue
 }
@@ -170,8 +172,6 @@ func TestBaseLogger_Log(t *testing.T) {
 		},
 	}
 
-	logLevel := level.Debug
-
 	newBaseLogger.Log(logLevel, message, parameters...)
 
 	handlerRecord := newHandler.Parameters[0].(*logrecord.LogRecord)
@@ -190,8 +190,6 @@ func BenchmarkBaseLogger_Log(b *testing.B) {
 		},
 	}
 
-	logLevel := level.Debug
-
 	for index := 0; index < b.N; index++ {
 		newBaseLogger.Log(logLevel, message, parameters...)
 	}

pkg/logger/logger_test.go

@@ -406,18 +406,18 @@ func BenchmarkLogger_Emergency(b *testing.B) {
 func TestWithFromLevel(t *testing.T) {
 	configuration := NewConfiguration()
 
-	option := WithFromLevel(level.Trace)
+	option := WithFromLevel(logLevel)
 
 	option(configuration)
 
-	testutils.AssertEquals(t, level.Trace, configuration.fromLevel)
+	testutils.AssertEquals(t, logLevel, configuration.fromLevel)
 }
 
 // BenchmarkWithFromLevel perform benchmarking of the WithFromLevel().
 func BenchmarkWithFromLevel(b *testing.B) {
 	configuration := NewConfiguration()
 
-	option := WithFromLevel(level.Trace)
+	option := WithFromLevel(logLevel)
 
 	for index := 0; index < b.N; index++ {
 		option(configuration)
@@ -428,18 +428,18 @@ func BenchmarkWithFromLevel(b *testing.B) {
 func TestWithToLevel(t *testing.T) {
 	configuration := NewConfiguration()
 
-	option := WithToLevel(level.Trace)
+	option := WithToLevel(logLevel)
 
 	option(configuration)
 
-	testutils.AssertEquals(t, level.Trace, configuration.toLevel)
+	testutils.AssertEquals(t, logLevel, configuration.toLevel)
 }
 
 // BenchmarkWithToLevel perform benchmarking of the WithToLevel().
 func BenchmarkWithToLevel(b *testing.B) {
 	configuration := NewConfiguration()
 
-	option := WithToLevel(level.Trace)
+	option := WithToLevel(logLevel)
 
 	for index := 0; index < b.N; index++ {
 		option(configuration)