feat: Create log/ilog package from github.com/kunitsucom/ilog.go

Author: ginokent

go.work

@@ -4,4 +4,6 @@ use (
 	.
 	./grpc
 	./integrationtest
+	./log/ilog/implementations/zap
+	./log/ilog/implementations/zerolog
 )

log/ilog/context.go

@@ -0,0 +1,26 @@
+package ilog
+
+import "context"
+
+type contextKeyLogger struct{}
+
+func FromContext(ctx context.Context) (logger Logger) { //nolint:ireturn
+	if ctx == nil {
+		Global().Copy().AddCallerSkip(1).Errorf("ilog: nil context")
+		return Global().Copy()
+	}
+
+	v := ctx.Value(contextKeyLogger{})
+	l, ok := v.(Logger)
+
+	if !ok {
+		Global().Copy().AddCallerSkip(1).Errorf("ilog: type assertion failed: expected=ilog.Logger, actual=%T, value=%#v", v, v)
+		return Global().Copy()
+	}
+
+	return l.Copy()
+}
+
+func WithContext(ctx context.Context, logger Logger) context.Context {
+	return context.WithValue(ctx, contextKeyLogger{}, logger)
+}

log/ilog/context_test.go

@@ -0,0 +1,44 @@
+package ilog //nolint:testpackage
+
+import (
+	"bytes"
+	"context"
+	"regexp"
+	"testing"
+	"time"
+)
+
+//nolint:paralleltest,tparallel
+func TestContext(t *testing.T) {
+	//nolint:paralleltest,tparallel
+	t.Run("success", func(t *testing.T) {
+		buf := bytes.NewBuffer(nil)
+		ctx := WithContext(context.Background(), NewBuilder(DebugLevel, NewSyncWriter(buf)).SetTimestampZone(time.UTC).Build())
+		l := FromContext(ctx)
+		l.Debugf("Debugf")
+		if expected := regexp.MustCompilePOSIX(`{"severity":"DEBUG","timestamp":"[0-9]{4}-[0-9]{2}-[0-9]{2}T[0-9]{2}:[0-9]{2}:[0-9]{2}\.?[0-9]*Z","caller":"ilog\.go/[a-z_]+_test\.go:[0-9]+","message":"Debugf"}`); !expected.Match(buf.Bytes()) {
+			t.Errorf("❌: !expected.Match(buf.Bytes()):\n%s", buf)
+		}
+		t.Logf("ℹ️: buf:\n%s", buf)
+	})
+
+	t.Run("failure,nilContext", func(t *testing.T) {
+		buf := bytes.NewBuffer(nil)
+		defer SetGlobal(NewBuilder(DebugLevel, NewSyncWriter(buf)).SetTimestampZone(time.UTC).Build())()
+		_ = FromContext(nil) //nolint:staticcheck
+		if expected := regexp.MustCompilePOSIX(`{"severity":"ERROR","timestamp":"[0-9]{4}-[0-9]{2}-[0-9]{2}T[0-9]{2}:[0-9]{2}:[0-9]{2}\.?[0-9]*Z","caller":"ilog\.go/[a-z_]+\.go:[0-9]+","message":"ilog: nil context"}`); !expected.Match(buf.Bytes()) {
+			t.Errorf("❌: !expected.Match(buf.Bytes()):\n%s", buf)
+		}
+		t.Logf("ℹ️: buf:\n%s", buf)
+	})
+
+	t.Run("failure,invalidType", func(t *testing.T) {
+		buf := bytes.NewBuffer(nil)
+		defer SetGlobal(NewBuilder(DebugLevel, NewSyncWriter(buf)).SetTimestampZone(time.UTC).Build())()
+		_ = FromContext(context.WithValue(context.Background(), contextKeyLogger{}, "invalid")) //nolint:staticcheck
+		if expected := regexp.MustCompilePOSIX(`{"severity":"ERROR","timestamp":"[0-9]{4}-[0-9]{2}-[0-9]{2}T[0-9]{2}:[0-9]{2}:[0-9]{2}\.?[0-9]*Z","caller":"ilog\.go/[a-z_]+\.go:[0-9]+","message":"ilog: type assertion failed: expected=ilog.Logger, actual=string, value=\\"invalid\\""}`); !expected.Match(buf.Bytes()) {
+			t.Errorf("❌: !expected.Match(buf.Bytes()):\n%s", buf)
+		}
+		t.Logf("ℹ️: buf:\n%s", buf)
+	})
+}

log/ilog/global.go

@@ -0,0 +1,57 @@
+package ilog
+
+import (
+	"log"
+	"os"
+	"sync"
+)
+
+//nolint:gochecknoglobals
+var (
+	_globalLogger   Logger = NewBuilder(DebugLevel, os.Stdout).Build() //nolint:revive
+	_globalLoggerMu sync.RWMutex
+)
+
+func L() Logger { //nolint:ireturn
+	_globalLoggerMu.RLock()
+	l := _globalLogger
+	_globalLoggerMu.RUnlock()
+	return l
+}
+
+func Global() Logger { //nolint:ireturn
+	return L()
+}
+
+func SetGlobal(logger Logger) (rollback func()) {
+	_globalLoggerMu.Lock()
+	backup := _globalLogger
+	_globalLogger = logger
+	_globalLoggerMu.Unlock()
+	return func() {
+		SetGlobal(backup)
+	}
+}
+
+//nolint:gochecknoglobals
+var stdLoggerMu sync.Mutex
+
+func SetStdLogger(l Logger) (rollback func()) {
+	stdLoggerMu.Lock()
+	defer stdLoggerMu.Unlock()
+
+	backupFlags := log.Flags()
+	backupPrefix := log.Prefix()
+	backupWriter := log.Writer()
+
+	log.SetFlags(0)
+	log.SetPrefix("")
+	const skipForStgLogger = 2
+	log.SetOutput(l.Copy().AddCallerSkip(skipForStgLogger))
+
+	return func() {
+		log.SetFlags(backupFlags)
+		log.SetPrefix(backupPrefix)
+		log.SetOutput(backupWriter)
+	}
+}

log/ilog/global_test.go

@@ -0,0 +1,78 @@
+package ilog //nolint:testpackage
+
+import (
+	"bytes"
+	"io"
+	"log"
+	"regexp"
+	"testing"
+	"time"
+)
+
+//nolint:paralleltest,tparallel
+func TestGlobal(t *testing.T) {
+	//nolint:paralleltest,tparallel
+	t.Run("success", func(t *testing.T) {
+		buf := bytes.NewBuffer(nil)
+		defer SetGlobal(NewBuilder(DebugLevel, NewSyncWriter(buf)).SetTimestampZone(time.UTC).Build())()
+		expected := regexp.MustCompilePOSIX(`{"severity":"DEBUG","timestamp":"[0-9]{4}-[0-9]{2}-[0-9]{2}T[0-9]{2}:[0-9]{2}:[0-9]{2}\.?[0-9]*Z","caller":"ilog\.go/[a-z_]+_test\.go:[0-9]+","message":"Logf","any":"any","bool":true,"bytes":"bytes","duration":"1h1m1.001001001s","error":"unexpected EOF","eof":"EOF","float32":1\.234567,"float64":1\.23456789,"int":-1,"int32":123456789,"int64":123456789,"string":"string","time":"2023-08-13T04:38:39\.123456789\+09:00","uint":1,"uint32":123456789,"uint64":123456789}`)
+		l := Global().Copy().
+			Any("any", "any").
+			Bool("bool", true).
+			Bytes("bytes", []byte("bytes")).
+			Duration("duration", time.Hour+time.Minute+time.Second+time.Millisecond+time.Microsecond+time.Nanosecond).
+			Err(io.ErrUnexpectedEOF).
+			ErrWithKey("eof", io.EOF).
+			Float32("float32", 1.234567).
+			Float64("float64", 1.23456789).
+			Int("int", -1).
+			Int32("int32", 123456789).
+			Int64("int64", 123456789).
+			String("string", "string").
+			Time("time", time.Date(2023, 8, 13, 4, 38, 39, 123456789, time.FixedZone("Asia/Tokyo", int(9*time.Hour/time.Second)))).
+			Uint("uint", 1).
+			Uint32("uint32", 123456789).
+			Uint64("uint64", 123456789).
+			Logger()
+		l.Logf(DebugLevel, "Logf")
+		if !expected.Match(buf.Bytes()) {
+			t.Errorf("❌: !expected.Match(buf.Bytes()):\n%s", buf)
+		}
+		t.Logf("ℹ️: buf:\n%s", buf)
+	})
+}
+
+//nolint:paralleltest,tparallel
+func TestSetStdLogger(t *testing.T) {
+	//nolint:paralleltest,tparallel
+	t.Run("success", func(t *testing.T) {
+		buf := bytes.NewBuffer(nil)
+		expected := regexp.MustCompilePOSIX(`{"severity":"DEBUG","timestamp":"[0-9]{4}-[0-9]{2}-[0-9]{2}T[0-9]{2}:[0-9]{2}:[0-9]{2}\.?[0-9]*Z","caller":"ilog.go/global_test.go:[0-9]+","message":"Print\\n","any":"any","bool":true,"bytes":"bytes","duration":"1h1m1.001001001s","error":"unexpected EOF","eof":"EOF","float32":1\.234567,"float64":1\.23456789,"int":-1,"int32":123456789,"int64":123456789,"string":"string","time":"2023-08-13T04:38:39\.123456789\+09:00","uint":1,"uint32":123456789,"uint64":123456789}` + "\n")
+		l := NewBuilder(DebugLevel, NewSyncWriter(buf)).
+			SetTimestampZone(time.UTC).
+			Build().
+			Any("any", "any").
+			Bool("bool", true).
+			Bytes("bytes", []byte("bytes")).
+			Duration("duration", time.Hour+time.Minute+time.Second+time.Millisecond+time.Microsecond+time.Nanosecond).
+			Err(io.ErrUnexpectedEOF).
+			ErrWithKey("eof", io.EOF).
+			Float32("float32", 1.234567).
+			Float64("float64", 1.23456789).
+			Int("int", -1).
+			Int32("int32", 123456789).
+			Int64("int64", 123456789).
+			String("string", "string").
+			Time("time", time.Date(2023, 8, 13, 4, 38, 39, 123456789, time.FixedZone("Asia/Tokyo", int(9*time.Hour/time.Second)))).
+			Uint("uint", 1).
+			Uint32("uint32", 123456789).
+			Uint64("uint64", 123456789).
+			Logger()
+		defer SetStdLogger(l)()
+		log.Print("Print")
+		if !expected.Match(buf.Bytes()) {
+			t.Errorf("❌: !expected.Match(buf.Bytes()):\n%s", buf)
+		}
+		t.Logf("ℹ️: buf:\n%s", buf)
+	})
+}

log/ilog/ilog.go

@@ -0,0 +1,93 @@
+// ilog is a simple logging interface library package for Go.
+// By defining only the logger interface `ilog.Logger`, users can easily swap out the underlying logging implementation without changing their application code.
+package ilog
+
+import (
+	"errors"
+	"time"
+)
+
+// ErrLogEntryIsNotWritten is the error returned when a log entry is not written.
+var ErrLogEntryIsNotWritten = errors.New("ilog: log entry not written")
+
+// Level is the type for logging level.
+type Level int8
+
+const (
+	DebugLevel Level = -8
+	InfoLevel  Level = 0
+	WarnLevel  Level = 8
+	ErrorLevel Level = 16
+)
+
+// Logger is the interface that has the basic logging methods.
+type Logger interface {
+	// Level returns the current logging level of the logger.
+	Level() (currentLoggerLevel Level)
+	// SetLevel sets the logging level of the logger.
+	SetLevel(level Level) (copied Logger)
+	// AddCallerSkip adds the number of stack frames to skip to the logger.
+	AddCallerSkip(skip int) (copied Logger)
+	// Copy returns a copy of the logger.
+	Copy() (copied Logger)
+
+	// common is the interface that has the common logging methods for both ilog.Logger and ilog.LogEntry.
+	common
+}
+
+// common is the interface that has the common logging methods for both ilog.Logger and ilog.LogEntry.
+type common interface {
+	Any(key string, value interface{}) (entry LogEntry)
+	Bool(key string, value bool) (entry LogEntry)
+	Bytes(key string, value []byte) (entry LogEntry)
+	Duration(key string, value time.Duration) (entry LogEntry)
+	Err(err error) (entry LogEntry)
+	ErrWithKey(key string, err error) (entry LogEntry)
+	Float32(key string, value float32) (entry LogEntry)
+	Float64(key string, value float64) (entry LogEntry)
+	Int(key string, value int) (entry LogEntry)
+	Int32(key string, value int32) (entry LogEntry)
+	Int64(key string, value int64) (entry LogEntry)
+	String(key, value string) (entry LogEntry)
+	Time(key string, value time.Time) (entry LogEntry)
+	Uint(key string, value uint) (entry LogEntry)
+	Uint32(key string, value uint32) (entry LogEntry)
+	Uint64(key string, value uint64) (entry LogEntry)
+
+	// Debugf logs a message at debug level.
+	// If the argument is one, it is treated 1st argument as a simple string.
+	// If the argument is more than one, it is treated 1st argument as a format string.
+	Debugf(format string, args ...interface{})
+	// Infof logs a message at info level.
+	// If the argument is one, it is treated 1st argument as a simple string.
+	// If the argument is more than one, it is treated 1st argument as a format string.
+	Infof(format string, args ...interface{})
+	// Warnf logs a message at warn level.
+	// If the argument is one, it is treated 1st argument as a simple string.
+	// If the argument is more than one, it is treated 1st argument as a format string.
+	Warnf(format string, args ...interface{})
+	// Errorf logs a message at error level.
+	// If the argument is one, it is treated 1st argument as a simple string.
+	// If the argument is more than one, it is treated 1st argument as a format string.
+	Errorf(format string, args ...interface{})
+	// Logf logs a message at the specified level.
+	// If the argument is one, it is treated 1st argument as a simple string.
+	// If the argument is more than one, it is treated 1st argument as a format string.
+	Logf(level Level, format string, args ...interface{})
+
+	// Write implements io.Writer interface.
+	// It outputs logs at the logger's log level.
+	Write(p []byte) (n int, err error)
+}
+
+// LogEntry is the interface that has the logging methods for a single log entry.
+type LogEntry interface {
+	// common is the interface that has the common logging methods for both ilog.Logger and ilog.LogEntry.
+	common
+
+	// Logger returns a new logger with the same fields of the log entry.
+	Logger() (copied Logger)
+
+	// error: for considering undispatched LogEntry as error so that they can be detected by Go static analysis.
+	error
+}