From 78deb80923a30ed5c1877521d3fbdd3f6e0bfabe Mon Sep 17 00:00:00 2001 From: Adrien CABARBAYE Date: Mon, 12 Dec 2022 15:44:07 +0000 Subject: [PATCH 1/2] :sparkles: `[logs]` multiple loggers --- changes/20221212133537.feature | 1 + utils/logs/file_logger_test.go | 2 +- utils/logs/interfaces.go | 17 +++- utils/logs/log_test.go | 20 ++-- utils/logs/logr_logger.go | 16 ++- utils/logs/logr_logger_test.go | 5 +- utils/logs/logrus_logger_test.go | 2 +- utils/logs/message_logger_test.go | 6 +- utils/logs/multiple_logger.go | 130 ++++++++++++++++++++++++ utils/logs/multiple_logger_test.go | 60 ++++++++++++ utils/logs/noop_logger_test.go | 2 +- utils/logs/std_logger_test.go | 4 +- utils/logs/string_logger_test.go | 2 +- utils/logs/writer_test.go | 2 +- utils/mocks/mock_logs.go | 152 ++++++++++++++++++++++++++++- 15 files changed, 392 insertions(+), 29 deletions(-) create mode 100644 changes/20221212133537.feature create mode 100644 utils/logs/multiple_logger.go create mode 100644 utils/logs/multiple_logger_test.go diff --git a/changes/20221212133537.feature b/changes/20221212133537.feature new file mode 100644 index 0000000000..3f5f01604e --- /dev/null +++ b/changes/20221212133537.feature @@ -0,0 +1 @@ +:sparkles: `[logs]` Added a way to manage multiple loggers transparently in the same way as a single logger diff --git a/utils/logs/file_logger_test.go b/utils/logs/file_logger_test.go index 3928e01b44..ec102d31a3 100644 --- a/utils/logs/file_logger_test.go +++ b/utils/logs/file_logger_test.go @@ -15,7 +15,7 @@ import ( func TestFileLogger(t *testing.T) { file, err := filesystem.TempFileInTempDir("test-filelog-*.log") - require.Nil(t, err) + require.NoError(t, err) err = file.Close() require.NoError(t, err) diff --git a/utils/logs/interfaces.go b/utils/logs/interfaces.go index 6949f8f31b..439ae06ef7 100644 --- a/utils/logs/interfaces.go +++ b/utils/logs/interfaces.go @@ -4,9 +4,13 @@ */ package logs -import "io" +import ( + "io" -//go:generate mockgen -destination=../mocks/mock_$GOPACKAGE.go -package=mocks github.com/ARM-software/golang-utils/utils/$GOPACKAGE Loggers,WriterWithSource,StdLogger + "github.com/go-logr/logr" +) + +//go:generate mockgen -destination=../mocks/mock_$GOPACKAGE.go -package=mocks github.com/ARM-software/golang-utils/utils/$GOPACKAGE Loggers,IMultipleLoggers,WriterWithSource,StdLogger // Loggers define generic loggers. type Loggers interface { @@ -23,6 +27,15 @@ type Loggers interface { LogError(err ...interface{}) } +// IMultipleLoggers provides an interface to manage multiple loggers the same way as a single logger. +type IMultipleLoggers interface { + Loggers + // AppendLogger appends generic loggers to the internal list of loggers managed by this system. + AppendLogger(l ...logr.Logger) error + // Append appends loggers to the internal list of loggers managed by this system. + Append(l ...Loggers) error +} + type WriterWithSource interface { io.WriteCloser SetSource(source string) error diff --git a/utils/logs/log_test.go b/utils/logs/log_test.go index bb3cd4d609..47b560efec 100644 --- a/utils/logs/log_test.go +++ b/utils/logs/log_test.go @@ -14,20 +14,20 @@ import ( func TestLog(t *testing.T) { var loggers Loggers = &GenericLoggers{} err := loggers.Check() - assert.NotNil(t, err) + assert.Error(t, err) err = loggers.Close() - assert.Nil(t, err) + assert.NoError(t, err) } func testLog(t *testing.T, loggers Loggers) { err := loggers.Check() - require.Nil(t, err) + require.NoError(t, err) defer func() { _ = loggers.Close() }() err = loggers.SetLogSource("source1") - require.Nil(t, err) + require.NoError(t, err) err = loggers.SetLoggerSource("LoggerSource1") - require.Nil(t, err) + require.NoError(t, err) loggers.Log("Test output1") loggers.Log("Test output2") @@ -35,21 +35,21 @@ func testLog(t *testing.T, loggers Loggers) { loggers.Log("\n") loggers.LogError("\n") err = loggers.SetLogSource("source2") - require.Nil(t, err) + require.NoError(t, err) loggers.Log("Test output3") loggers.LogError("Test err1") err = loggers.SetLogSource("source3") - require.Nil(t, err) + require.NoError(t, err) err = loggers.SetLoggerSource("LoggerSource2") - require.Nil(t, err) + require.NoError(t, err) loggers.LogError("Test err2") err = loggers.SetLogSource("source4") - require.Nil(t, err) + require.NoError(t, err) loggers.LogError("Test err3") err = loggers.Close() - require.Nil(t, err) + require.NoError(t, err) } diff --git a/utils/logs/logr_logger.go b/utils/logs/logr_logger.go index 97424643c4..641aa8d1d1 100644 --- a/utils/logs/logr_logger.go +++ b/utils/logs/logr_logger.go @@ -38,7 +38,7 @@ func (l *logrLogger) SetLogSource(source string) error { if reflection.IsEmpty(source) { return commonerrors.ErrNoLogSource } - l.logger.WithValues(KeyLogSource, source) + l.logger = l.logger.WithValues(KeyLogSource, source) return nil } @@ -46,8 +46,7 @@ func (l *logrLogger) SetLoggerSource(source string) error { if reflection.IsEmpty(source) { return commonerrors.ErrNoLoggerSource } - l.logger.WithName(source) - l.logger.WithValues(KeyLoggerSource, source) + l.logger = l.logger.WithName(source).WithValues(KeyLoggerSource, source) return nil } @@ -56,7 +55,16 @@ func (l *logrLogger) Log(output ...interface{}) { } func (l *logrLogger) LogError(err ...interface{}) { - l.logger.Error(nil, fmt.Sprintln(err...)) + if len(err) > 0 { + if subErr, ok := err[0].(error); ok { + l.logger.Error(subErr, fmt.Sprintln(err...)) + } else { + l.logger.Error(nil, fmt.Sprintln(err...)) + } + } else { + l.logger.Error(nil, "") + } + } // NewLogrLogger creates loggers based on a logr implementation (https://github.com/go-logr/logr) diff --git a/utils/logs/logr_logger_test.go b/utils/logs/logr_logger_test.go index d997ce39c4..bd84c6a738 100644 --- a/utils/logs/logr_logger_test.go +++ b/utils/logs/logr_logger_test.go @@ -16,13 +16,14 @@ import ( func TestLogrLogger(t *testing.T) { loggers, err := NewLogrLogger(logstest.NewTestLogger(t), "Test") - require.Nil(t, err) + require.NoError(t, err) testLog(t, loggers) + loggers.LogError(commonerrors.ErrUnexpected, ": no idea what happened") } func TestLogrLoggerConversion(t *testing.T) { loggers, err := NewLogrLogger(logstest.NewTestLogger(t), "Test") - require.Nil(t, err) + require.NoError(t, err) converted := NewLogrLoggerFromLoggers(loggers) converted.WithName(faker.Name()).WithValues(faker.Word(), faker.Name()).Error(commonerrors.ErrUnexpected, faker.Sentence()) } diff --git a/utils/logs/logrus_logger_test.go b/utils/logs/logrus_logger_test.go index 4464072547..969e04cdd0 100644 --- a/utils/logs/logrus_logger_test.go +++ b/utils/logs/logrus_logger_test.go @@ -13,6 +13,6 @@ import ( func TestLogrusLogger(t *testing.T) { loggers, err := NewLogrusLogger(logrus.StandardLogger(), "Test") - require.Nil(t, err) + require.NoError(t, err) testLog(t, loggers) } diff --git a/utils/logs/message_logger_test.go b/utils/logs/message_logger_test.go index be3ce9fd06..2a754b0865 100644 --- a/utils/logs/message_logger_test.go +++ b/utils/logs/message_logger_test.go @@ -13,15 +13,15 @@ import ( func TestLogMessage(t *testing.T) { loggers, err := NewJSONLogger(&StdWriter{}, "Test", "TestLogMessage") - require.Nil(t, err) + require.NoError(t, err) testLog(t, loggers) } func TestLogMessageToSlowLogger(t *testing.T) { stdloggers, err := NewStdLogger("ERR:") - require.Nil(t, err) + require.NoError(t, err) loggers, err := NewJSONLoggerForSlowWriter(&SlowWriter{}, 1024, 2*time.Millisecond, "Test", "TestLogMessageToSlowLogger", stdloggers) - require.Nil(t, err) + require.NoError(t, err) testLog(t, loggers) time.Sleep(100 * time.Millisecond) } diff --git a/utils/logs/multiple_logger.go b/utils/logs/multiple_logger.go new file mode 100644 index 0000000000..4306efa563 --- /dev/null +++ b/utils/logs/multiple_logger.go @@ -0,0 +1,130 @@ +package logs + +import ( + "sync" + + "github.com/go-logr/logr" + "golang.org/x/sync/errgroup" + + "github.com/ARM-software/golang-utils/utils/commonerrors" +) + +type MultipleLogger struct { + mu sync.RWMutex + loggers []Loggers + loggerSource string +} + +func (c *MultipleLogger) Close() error { + c.mu.Lock() + defer c.mu.Unlock() + g := new(errgroup.Group) + for i := range c.loggers { + g.Go(c.loggers[i].Close) + } + return g.Wait() +} + +func (c *MultipleLogger) Check() error { + c.mu.Lock() + defer c.mu.Unlock() + g := new(errgroup.Group) + for i := range c.loggers { + g.Go(c.loggers[i].Check) + } + return g.Wait() +} + +func (c *MultipleLogger) SetLogSource(source string) error { + c.mu.Lock() + defer c.mu.Unlock() + var err error + for i := range c.loggers { + err = c.loggers[i].SetLogSource(source) + } + return err +} + +func (c *MultipleLogger) SetLoggerSource(source string) error { + c.mu.Lock() + defer c.mu.Unlock() + return c.setLoggerSource(source) +} + +func (c *MultipleLogger) setLoggerSource(source string) error { + var err error + for i := range c.loggers { + err = c.loggers[i].SetLoggerSource(source) + } + if err == nil { + c.loggerSource = source + } + return err +} + +func (c *MultipleLogger) Log(output ...interface{}) { + c.mu.RLock() + defer c.mu.RUnlock() + for i := range c.loggers { + c.loggers[i].Log(output...) + } +} + +func (c *MultipleLogger) LogError(err ...interface{}) { + c.mu.RLock() + defer c.mu.RUnlock() + for i := range c.loggers { + c.loggers[i].LogError(err...) + } +} + +func (c *MultipleLogger) GetLoggerSource() string { + c.mu.RLock() + defer c.mu.RUnlock() + return c.loggerSource +} + +func (c *MultipleLogger) AppendLogger(l ...logr.Logger) error { + for i := range l { + logger, err := NewLogrLogger(l[i], c.GetLoggerSource()) + if err != nil { + return err + } + err = c.Append(logger) + if err != nil { + return err + } + } + return nil +} + +func (c *MultipleLogger) Append(l ...Loggers) error { + c.mu.Lock() + defer c.mu.Unlock() + c.loggers = append(c.loggers, l...) + return c.setLoggerSource(c.loggerSource) +} + +// NewMultipleLoggers returns a logger which abstracts and internally manages a list of loggers. +// if no default loggers are provided, the logger will be set to print to the standard output. +func NewMultipleLoggers(loggerSource string, defaultLoggers ...Loggers) (l IMultipleLoggers, err error) { + if loggerSource == "" { + err = commonerrors.ErrNoLoggerSource + return + } + list := defaultLoggers + if len(list) == 0 { + std, err := NewStdLogger(loggerSource) + if err != nil { + return nil, err + } + list = []Loggers{std} + } + l = &MultipleLogger{} + err = l.Append(list...) + if err != nil { + return + } + err = l.SetLoggerSource(loggerSource) + return +} diff --git a/utils/logs/multiple_logger_test.go b/utils/logs/multiple_logger_test.go new file mode 100644 index 0000000000..6b578ac2ca --- /dev/null +++ b/utils/logs/multiple_logger_test.go @@ -0,0 +1,60 @@ +/* + * Copyright (C) 2020-2022 Arm Limited or its affiliates and Contributors. All rights reserved. + * SPDX-License-Identifier: Apache-2.0 + */ +package logs + +import ( + "testing" + + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" + + "github.com/ARM-software/golang-utils/utils/filesystem" +) + +func TestMultipleLogger(t *testing.T) { + loggers, err := NewMultipleLoggers("Test") + require.NoError(t, err) + testLog(t, loggers) +} + +func TestMultipleLoggers(t *testing.T) { + // With default logger + loggers, err := NewMultipleLoggers("Test Multiple") + require.NoError(t, err) + testLog(t, loggers) + + // Adding a file logger to the mix. + file, err := filesystem.TempFileInTempDir("test-multiplelog-filelog-*.log") + require.NoError(t, err) + + err = file.Close() + require.NoError(t, err) + + defer func() { _ = filesystem.Rm(file.Name()) }() + + empty, err := filesystem.IsEmpty(file.Name()) + require.NoError(t, err) + assert.True(t, empty) + + fl, err := NewFileLogger(file.Name(), "Test") + require.NoError(t, err) + + require.NoError(t, loggers.Append(fl)) + + nl, err := NewNoopLogger("Test2") + require.NoError(t, err) + + // Adding various loggers + require.NoError(t, loggers.Append(fl, nl)) + + testLog(t, loggers) + + empty, err = filesystem.IsEmpty(file.Name()) + require.NoError(t, err) + assert.False(t, empty) + + err = filesystem.Rm(file.Name()) + require.NoError(t, err) +} diff --git a/utils/logs/noop_logger_test.go b/utils/logs/noop_logger_test.go index a8c9dba8c9..508cab0291 100644 --- a/utils/logs/noop_logger_test.go +++ b/utils/logs/noop_logger_test.go @@ -12,6 +12,6 @@ import ( func TestNoopLogger(t *testing.T) { loggers, err := NewNoopLogger("Test") - require.Nil(t, err) + require.NoError(t, err) testLog(t, loggers) } diff --git a/utils/logs/std_logger_test.go b/utils/logs/std_logger_test.go index 7f7073f687..e930502096 100644 --- a/utils/logs/std_logger_test.go +++ b/utils/logs/std_logger_test.go @@ -13,12 +13,12 @@ import ( func TestStdLogger(t *testing.T) { loggers, err := NewStdLogger("Test") - require.Nil(t, err) + require.NoError(t, err) testLog(t, loggers) } func TestAsynchronousStdLogger(t *testing.T) { loggers, err := NewAsynchronousStdLogger("Test", 1024, 2*time.Millisecond, "test source") - require.Nil(t, err) + require.NoError(t, err) testLog(t, loggers) } diff --git a/utils/logs/string_logger_test.go b/utils/logs/string_logger_test.go index 91377f190b..1290676897 100644 --- a/utils/logs/string_logger_test.go +++ b/utils/logs/string_logger_test.go @@ -13,7 +13,7 @@ import ( func TestStringLogger(t *testing.T) { loggers, err := NewStringLogger("Test") - require.Nil(t, err) + require.NoError(t, err) testLog(t, loggers) loggers.LogError("Test err") loggers.Log("Test1") diff --git a/utils/logs/writer_test.go b/utils/logs/writer_test.go index 18b137a043..a595380d23 100644 --- a/utils/logs/writer_test.go +++ b/utils/logs/writer_test.go @@ -34,7 +34,7 @@ func CreateMultipleWriterLogger(prefix string) (loggers Loggers, err error) { func TestMultipleWriters(t *testing.T) { stdloggers, err := CreateMultipleWriterLogger("Test") - require.Nil(t, err) + require.NoError(t, err) testLog(t, stdloggers) time.Sleep(100 * time.Millisecond) } diff --git a/utils/mocks/mock_logs.go b/utils/mocks/mock_logs.go index 98cfb37fbd..d4a4ba7acc 100644 --- a/utils/mocks/mock_logs.go +++ b/utils/mocks/mock_logs.go @@ -4,7 +4,7 @@ */ // Code generated by MockGen. DO NOT EDIT. -// Source: github.com/ARM-software/golang-utils/utils/logs (interfaces: Loggers,WriterWithSource,StdLogger) +// Source: github.com/ARM-software/golang-utils/utils/logs (interfaces: Loggers,IMultipleLoggers,WriterWithSource,StdLogger) // Package mocks is a generated GoMock package. package mocks @@ -12,7 +12,10 @@ package mocks import ( reflect "reflect" + logr "github.com/go-logr/logr" gomock "github.com/golang/mock/gomock" + + logs "github.com/ARM-software/golang-utils/utils/logs" ) // MockLoggers is a mock of Loggers interface. @@ -126,6 +129,153 @@ func (mr *MockLoggersMockRecorder) SetLoggerSource(arg0 interface{}) *gomock.Cal return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetLoggerSource", reflect.TypeOf((*MockLoggers)(nil).SetLoggerSource), arg0) } +// MockIMultipleLoggers is a mock of IMultipleLoggers interface. +type MockIMultipleLoggers struct { + ctrl *gomock.Controller + recorder *MockIMultipleLoggersMockRecorder +} + +// MockIMultipleLoggersMockRecorder is the mock recorder for MockIMultipleLoggers. +type MockIMultipleLoggersMockRecorder struct { + mock *MockIMultipleLoggers +} + +// NewMockIMultipleLoggers creates a new mock instance. +func NewMockIMultipleLoggers(ctrl *gomock.Controller) *MockIMultipleLoggers { + mock := &MockIMultipleLoggers{ctrl: ctrl} + mock.recorder = &MockIMultipleLoggersMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockIMultipleLoggers) EXPECT() *MockIMultipleLoggersMockRecorder { + return m.recorder +} + +// Append mocks base method. +func (m *MockIMultipleLoggers) Append(arg0 ...logs.Loggers) error { + m.ctrl.T.Helper() + varargs := []interface{}{} + for _, a := range arg0 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "Append", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// Append indicates an expected call of Append. +func (mr *MockIMultipleLoggersMockRecorder) Append(arg0 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Append", reflect.TypeOf((*MockIMultipleLoggers)(nil).Append), arg0...) +} + +// AppendLogger mocks base method. +func (m *MockIMultipleLoggers) AppendLogger(arg0 ...logr.Logger) error { + m.ctrl.T.Helper() + varargs := []interface{}{} + for _, a := range arg0 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "AppendLogger", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// AppendLogger indicates an expected call of AppendLogger. +func (mr *MockIMultipleLoggersMockRecorder) AppendLogger(arg0 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AppendLogger", reflect.TypeOf((*MockIMultipleLoggers)(nil).AppendLogger), arg0...) +} + +// Check mocks base method. +func (m *MockIMultipleLoggers) Check() error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Check") + ret0, _ := ret[0].(error) + return ret0 +} + +// Check indicates an expected call of Check. +func (mr *MockIMultipleLoggersMockRecorder) Check() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Check", reflect.TypeOf((*MockIMultipleLoggers)(nil).Check)) +} + +// Close mocks base method. +func (m *MockIMultipleLoggers) Close() error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Close") + ret0, _ := ret[0].(error) + return ret0 +} + +// Close indicates an expected call of Close. +func (mr *MockIMultipleLoggersMockRecorder) Close() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockIMultipleLoggers)(nil).Close)) +} + +// Log mocks base method. +func (m *MockIMultipleLoggers) Log(arg0 ...interface{}) { + m.ctrl.T.Helper() + varargs := []interface{}{} + for _, a := range arg0 { + varargs = append(varargs, a) + } + m.ctrl.Call(m, "Log", varargs...) +} + +// Log indicates an expected call of Log. +func (mr *MockIMultipleLoggersMockRecorder) Log(arg0 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Log", reflect.TypeOf((*MockIMultipleLoggers)(nil).Log), arg0...) +} + +// LogError mocks base method. +func (m *MockIMultipleLoggers) LogError(arg0 ...interface{}) { + m.ctrl.T.Helper() + varargs := []interface{}{} + for _, a := range arg0 { + varargs = append(varargs, a) + } + m.ctrl.Call(m, "LogError", varargs...) +} + +// LogError indicates an expected call of LogError. +func (mr *MockIMultipleLoggersMockRecorder) LogError(arg0 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LogError", reflect.TypeOf((*MockIMultipleLoggers)(nil).LogError), arg0...) +} + +// SetLogSource mocks base method. +func (m *MockIMultipleLoggers) SetLogSource(arg0 string) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetLogSource", arg0) + ret0, _ := ret[0].(error) + return ret0 +} + +// SetLogSource indicates an expected call of SetLogSource. +func (mr *MockIMultipleLoggersMockRecorder) SetLogSource(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetLogSource", reflect.TypeOf((*MockIMultipleLoggers)(nil).SetLogSource), arg0) +} + +// SetLoggerSource mocks base method. +func (m *MockIMultipleLoggers) SetLoggerSource(arg0 string) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetLoggerSource", arg0) + ret0, _ := ret[0].(error) + return ret0 +} + +// SetLoggerSource indicates an expected call of SetLoggerSource. +func (mr *MockIMultipleLoggersMockRecorder) SetLoggerSource(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetLoggerSource", reflect.TypeOf((*MockIMultipleLoggers)(nil).SetLoggerSource), arg0) +} + // MockWriterWithSource is a mock of WriterWithSource interface. type MockWriterWithSource struct { ctrl *gomock.Controller From 1c734de5c1923ec7aa5be74dfb4af3f08e0781f4 Mon Sep 17 00:00:00 2001 From: Adrien CABARBAYE Date: Mon, 12 Dec 2022 16:10:35 +0000 Subject: [PATCH 2/2] added some test cases --- utils/logs/log_test.go | 7 +++++++ utils/logs/logr_logger_test.go | 3 +++ 2 files changed, 10 insertions(+) diff --git a/utils/logs/log_test.go b/utils/logs/log_test.go index 47b560efec..cb8272ca2d 100644 --- a/utils/logs/log_test.go +++ b/utils/logs/log_test.go @@ -9,6 +9,8 @@ import ( "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" + + "github.com/ARM-software/golang-utils/utils/commonerrors" ) func TestLog(t *testing.T) { @@ -50,6 +52,11 @@ func testLog(t *testing.T, loggers Loggers) { require.NoError(t, err) loggers.LogError("Test err3") + loggers.LogError(commonerrors.ErrCancelled) + loggers.LogError(nil) + loggers.LogError(commonerrors.ErrUnexpected, "some error") + loggers.LogError("some error", commonerrors.ErrUnexpected) + loggers.LogError(nil, "no error") err = loggers.Close() require.NoError(t, err) } diff --git a/utils/logs/logr_logger_test.go b/utils/logs/logr_logger_test.go index bd84c6a738..49d827f1de 100644 --- a/utils/logs/logr_logger_test.go +++ b/utils/logs/logr_logger_test.go @@ -19,6 +19,9 @@ func TestLogrLogger(t *testing.T) { require.NoError(t, err) testLog(t, loggers) loggers.LogError(commonerrors.ErrUnexpected, ": no idea what happened") + loggers.LogError(nil, ": no idea what happened") + loggers.LogError("no idea what happened") + loggers.LogError("no idea what happened", nil) } func TestLogrLoggerConversion(t *testing.T) {