feat(log): remove core dependency and update core interface to be dependency free

core/log/logger.go

@@ -7,6 +7,14 @@ const ModuleKey = "module"
 // cosmossdk.io/log is the implementation provided by the Cosmos SDK
 // All functionalities of the logger are available through the Impl() method.
 type Logger interface {
+	LoggerBase
+
+	// With returns a new wrapped logger with additional context provided by a set.
+	With(keyVals ...any) Logger
+}
+
+// LoggerBase defines basic logger functionality.
+type LoggerBase interface {
 	// Info takes a message and a set of key/value pairs and logs with level INFO.
 	// The key of the tuple must be a string.
 	Info(msg string, keyVals ...any)
@@ -23,11 +31,18 @@ type Logger interface {
 	// The key of the tuple must be a string.
 	Debug(msg string, keyVals ...any)
 
-	// With returns a new wrapped logger with additional context provided by a set.
-	With(keyVals ...any) Logger
-
 	// Impl returns the underlying logger implementation.
 	// It is used to access the full functionalities of the underlying logger.
 	// Advanced users can type cast the returned value to the actual logger.
 	Impl() any
 }
+
+// LoggerV2 is the newer Cosmos SDK logger interface. It can be used in libraries without any need to import
+// the core or log packages directly.
+type LoggerV2 interface {
+	LoggerBase
+
+	// WithV2 returns a type which can be cast to LoggerV2 with additional context provided by a set.
+	// any is returned instead of LoggerV2 to avoid the need for log users to import the log package directly.
+	WithV2(keyVals ...any) any
+}

log/logger.go

@@ -40,6 +40,12 @@ var ContextKey struct{}
 // All functionalities of the logger are available through the Impl() method.
 type Logger = corelog.Logger
 
+// LoggerV2 is the new type that logger's implement which supports the core Logger and LoggerV2 interfaces.
+type LoggerV2 = interface {
+	Logger
+	corelog.LoggerV2
+}
+
 // WithJSONMarshal configures zerolog global json encoding.
 func WithJSONMarshal(marshaler func(v any) ([]byte, error)) {
 	zerolog.InterfaceMarshalFunc = func(i any) ([]byte, error) {
@@ -68,7 +74,7 @@ type zeroLogWrapper struct {
 //
 // Stderr is the typical destination for logs,
 // so that any output from your application can still be piped to other processes.
-func NewLogger(dst io.Writer, options ...Option) Logger {
+func NewLogger(dst io.Writer, options ...Option) LoggerV2 {
 	logCfg := defaultConfig
 	for _, opt := range options {
 		opt(&logCfg)
@@ -110,7 +116,7 @@ func NewLogger(dst io.Writer, options ...Option) Logger {
 }
 
 // NewCustomLogger returns a new logger with the given zerolog logger.
-func NewCustomLogger(logger zerolog.Logger) Logger {
+func NewCustomLogger(logger zerolog.Logger) LoggerV2 {
 	return zeroLogWrapper{&logger}
 }
 
@@ -139,7 +145,12 @@ func (l zeroLogWrapper) Debug(msg string, keyVals ...interface{}) {
 }
 
 // With returns a new wrapped logger with additional context provided by a set.
-func (l zeroLogWrapper) With(keyVals ...interface{}) Logger {
+func (l zeroLogWrapper) With(keyVals ...interface{}) corelog.Logger {
+	logger := l.Logger.With().Fields(keyVals).Logger()
+	return zeroLogWrapper{&logger}
+}
+
+func (l zeroLogWrapper) WithV2(keyVals ...interface{}) any {
 	logger := l.Logger.With().Fields(keyVals).Logger()
 	return zeroLogWrapper{&logger}
 }
@@ -159,15 +170,19 @@ type LogWrapper struct {
 	corelog.Logger
 }
 
-func NewLogWrapper(logger corelog.Logger) Logger {
+func NewLogWrapper(logger corelog.Logger) LoggerV2 {
 	return LogWrapper{logger}
 }
 
 func (l LogWrapper) Impl() interface{} {
 	return l.Logger
 }
 
-func (l LogWrapper) With(keyVals ...interface{}) Logger {
+func (l LogWrapper) With(keyVals ...interface{}) corelog.Logger {
+	return NewLogWrapper(l.Logger.With(keyVals...))
+}
+
+func (l LogWrapper) WithV2(keyVals ...interface{}) any {
 	return NewLogWrapper(l.Logger.With(keyVals...))
 }
 

log/testing.go

@@ -16,7 +16,7 @@ type TestingT zerolog.TestingLog
 // If the logs may help debug a test failure,
 // you may want to use NewTestLogger(t) in your test.
 // Otherwise, use NewNopLogger().
-func NewTestLogger(t TestingT) Logger {
+func NewTestLogger(t TestingT) LoggerV2 {
 	return newTestLogger(t, zerolog.DebugLevel)
 }
 
@@ -25,7 +25,7 @@ func NewTestLogger(t TestingT) Logger {
 //
 // This is primarily helpful during active debugging of a test
 // with verbose logs.
-func NewTestLoggerInfo(t TestingT) Logger {
+func NewTestLoggerInfo(t TestingT) LoggerV2 {
 	return newTestLogger(t, zerolog.InfoLevel)
 }
 
@@ -34,11 +34,11 @@ func NewTestLoggerInfo(t TestingT) Logger {
 //
 // This is primarily helpful during active debugging of a test
 // with verbose logs.
-func NewTestLoggerError(t TestingT) Logger {
+func NewTestLoggerError(t TestingT) LoggerV2 {
 	return newTestLogger(t, zerolog.ErrorLevel)
 }
 
-func newTestLogger(t TestingT, lvl zerolog.Level) Logger {
+func newTestLogger(t TestingT, lvl zerolog.Level) LoggerV2 {
 	cw := zerolog.NewConsoleWriter()
 	cw.Out = zerolog.TestWriter{
 		T: t,