refactor(log): refactoring log related code

Author: lvan100

log/field_encoder.go

@@ -79,14 +79,12 @@ func (enc *JSONEncoder) Reset() {
 
 // AppendEncoderBegin writes the start of an encoder section, represented as a JSON object.
 func (enc *JSONEncoder) AppendEncoderBegin() {
-	enc.last = jsonTokenObjectBegin
-	enc.buf.WriteByte('{')
+	enc.AppendObjectBegin()
 }
 
 // AppendEncoderEnd writes the end of an encoder section (closes a JSON object).
 func (enc *JSONEncoder) AppendEncoderEnd() {
-	enc.last = jsonTokenObjectEnd
-	enc.buf.WriteByte('}')
+	enc.AppendObjectEnd()
 }
 
 // AppendObjectBegin starts a new JSON object.
@@ -114,24 +112,15 @@ func (enc *JSONEncoder) AppendArrayEnd() {
 }
 
 // appendSeparator inserts a comma if necessary before a key or value.
-func (enc *JSONEncoder) appendSeparator(curr jsonToken) {
-	switch curr {
-	case jsonTokenKey:
-		// Insert a comma between key-value pairs or elements
-		if enc.last == jsonTokenObjectEnd || enc.last == jsonTokenArrayEnd || enc.last == jsonTokenValue {
-			enc.buf.WriteByte(',')
-		}
-	case jsonTokenValue:
-		if enc.last == jsonTokenValue {
-			enc.buf.WriteByte(',')
-		}
-	default: // for linter
+func (enc *JSONEncoder) appendSeparator() {
+	if enc.last == jsonTokenObjectEnd || enc.last == jsonTokenArrayEnd || enc.last == jsonTokenValue {
+		enc.buf.WriteByte(',')
 	}
 }
 
 // AppendKey writes a JSON key (as a string followed by a colon).
 func (enc *JSONEncoder) AppendKey(key string) {
-	enc.appendSeparator(jsonTokenKey)
+	enc.appendSeparator()
 	enc.last = jsonTokenKey
 	enc.buf.WriteByte('"')
 	enc.safeAddString(key)
@@ -141,35 +130,35 @@ func (enc *JSONEncoder) AppendKey(key string) {
 
 // AppendBool writes a boolean value.
 func (enc *JSONEncoder) AppendBool(v bool) {
-	enc.appendSeparator(jsonTokenValue)
+	enc.appendSeparator()
 	enc.last = jsonTokenValue
 	enc.buf.WriteString(strconv.FormatBool(v))
 }
 
 // AppendInt64 writes a signed 64-bit integer.
 func (enc *JSONEncoder) AppendInt64(v int64) {
-	enc.appendSeparator(jsonTokenValue)
+	enc.appendSeparator()
 	enc.last = jsonTokenValue
 	enc.buf.WriteString(strconv.FormatInt(v, 10))
 }
 
 // AppendUint64 writes an unsigned 64-bit integer.
 func (enc *JSONEncoder) AppendUint64(u uint64) {
-	enc.appendSeparator(jsonTokenValue)
+	enc.appendSeparator()
 	enc.last = jsonTokenValue
 	enc.buf.WriteString(strconv.FormatUint(u, 10))
 }
 
 // AppendFloat64 writes a floating-point number.
 func (enc *JSONEncoder) AppendFloat64(v float64) {
-	enc.appendSeparator(jsonTokenValue)
+	enc.appendSeparator()
 	enc.last = jsonTokenValue
 	enc.buf.WriteString(strconv.FormatFloat(v, 'f', -1, 64))
 }
 
 // AppendString writes a string value (properly escaped).
 func (enc *JSONEncoder) AppendString(v string) {
-	enc.appendSeparator(jsonTokenValue)
+	enc.appendSeparator()
 	enc.last = jsonTokenValue
 	enc.buf.WriteByte('"')
 	enc.safeAddString(v)
@@ -178,7 +167,7 @@ func (enc *JSONEncoder) AppendString(v string) {
 
 // AppendReflect marshals any Go value into JSON and appends it.
 func (enc *JSONEncoder) AppendReflect(v interface{}) {
-	enc.appendSeparator(jsonTokenValue)
+	enc.appendSeparator()
 	enc.last = jsonTokenValue
 	b, err := json.Marshal(v)
 	if err != nil {
@@ -257,7 +246,7 @@ type TextEncoder struct {
 	separator   string        // Separator used between top-level key-value pairs
 	jsonEncoder *JSONEncoder  // Embedded JSON encoder for nested objects/arrays
 	jsonDepth   int8          // Tracks depth of nested JSON structures
-	init        bool          // Tracks if the first key-value has been written
+	firstField  bool          // Tracks if the first key-value has been written
 }
 
 // NewTextEncoder creates a new TextEncoder writing to the given buffer, using the specified separator.
@@ -313,10 +302,11 @@ func (enc *TextEncoder) AppendKey(key string) {
 		enc.jsonEncoder.AppendKey(key)
 		return
 	}
-	if enc.init {
+	if enc.firstField {
 		enc.buf.WriteString(enc.separator)
+	} else {
+		enc.firstField = true
 	}
-	enc.init = true
 	enc.buf.WriteString(key)
 	enc.buf.WriteByte('=')
 }

log/field_encoder_test.go

@@ -106,7 +106,7 @@ func TestJSONEncoder(t *testing.T) {
 		buf := bytes.NewBuffer(nil)
 		enc := NewJSONEncoder(buf)
 		enc.AppendEncoderBegin()
-		writeFields(enc, testFields)
+		WriteFields(enc, testFields)
 		enc.AppendEncoderEnd()
 		assert.ThatString(t, buf.String()).JsonEqual(`{
 	    "msg": "hello world\n\\\t\"\r",
@@ -254,7 +254,7 @@ func TestTextEncoder(t *testing.T) {
 		buf := bytes.NewBuffer(nil)
 		enc := NewTextEncoder(buf, "||")
 		enc.AppendEncoderBegin()
-		writeFields(enc, testFields)
+		WriteFields(enc, testFields)
 		{
 			enc.AppendKey("object_2")
 			enc.AppendObjectBegin()

log/field_value.go

@@ -239,19 +239,6 @@ func (v StringsValue) Encode(enc Encoder) {
 	enc.AppendArrayEnd()
 }
 
-// ObjectValue represents a slice of Field carried by Field.
-type ObjectValue []Field
-
-// Encode encodes the data represented by v to an Encoder.
-func (v ObjectValue) Encode(enc Encoder) {
-	enc.AppendObjectBegin()
-	for _, f := range v {
-		enc.AppendKey(f.Key)
-		f.Val.Encode(enc)
-	}
-	enc.AppendObjectEnd()
-}
-
 // ArrayValue represents a slice of Value carried by Field.
 type ArrayValue []Value
 
@@ -263,3 +250,21 @@ func (v ArrayValue) Encode(enc Encoder) {
 	}
 	enc.AppendArrayEnd()
 }
+
+// ObjectValue represents a slice of Field carried by Field.
+type ObjectValue []Field
+
+// Encode encodes the data represented by v to an Encoder.
+func (v ObjectValue) Encode(enc Encoder) {
+	enc.AppendObjectBegin()
+	WriteFields(enc, v)
+	enc.AppendObjectEnd()
+}
+
+// WriteFields writes a slice of Field objects to the encoder.
+func WriteFields(enc Encoder, fields []Field) {
+	for _, f := range fields {
+		enc.AppendKey(f.Key)
+		f.Val.Encode(enc)
+	}
+}

log/log.go

@@ -23,12 +23,6 @@ import (
 	"github.com/go-spring/spring-core/log/internal"
 )
 
-// TagDefault is a default tag that can be used to set the default logger.
-var TagDefault = GetTag("_def")
-
-// ctxDefault is the default context for formatted logging methods (e.g. Infof/Warnf).
-var ctxDefault = context.WithValue(context.Background(), "ctxDefault", "")
-
 // TimeNow is a function that can be overridden to provide custom timestamp behavior (e.g., for testing).
 var TimeNow func(ctx context.Context) time.Time
 
@@ -57,51 +51,26 @@ func Info(ctx context.Context, tag *Tag, fields ...Field) {
 	Record(ctx, InfoLevel, tag, fields...)
 }
 
-// Infof logs a formatted message at InfoLevel using the default tag.
-func Infof(format string, args ...interface{}) {
-	Record(ctxDefault, InfoLevel, TagDefault, Msgf(format, args...))
-}
-
 // Warn logs a message at WarnLevel using structured fields.
 func Warn(ctx context.Context, tag *Tag, fields ...Field) {
 	Record(ctx, WarnLevel, tag, fields...)
 }
 
-// Warnf logs a formatted message at WarnLevel using the default tag.
-func Warnf(format string, args ...interface{}) {
-	Record(ctxDefault, WarnLevel, TagDefault, Msgf(format, args...))
-}
-
 // Error logs a message at ErrorLevel using structured fields.
 func Error(ctx context.Context, tag *Tag, fields ...Field) {
 	Record(ctx, ErrorLevel, tag, fields...)
 }
 
-// Errorf logs a formatted message at ErrorLevel using the default tag.
-func Errorf(format string, args ...interface{}) {
-	Record(ctxDefault, ErrorLevel, TagDefault, Msgf(format, args...))
-}
-
 // Panic logs a message at PanicLevel using structured fields.
 func Panic(ctx context.Context, tag *Tag, fields ...Field) {
 	Record(ctx, PanicLevel, tag, fields...)
 }
 
-// Panicf logs a formatted message at PanicLevel using the default tag.
-func Panicf(format string, args ...interface{}) {
-	Record(ctxDefault, PanicLevel, TagDefault, Msgf(format, args...))
-}
-
 // Fatal logs a message at FatalLevel using structured fields.
 func Fatal(ctx context.Context, tag *Tag, fields ...Field) {
 	Record(ctx, FatalLevel, tag, fields...)
 }
 
-// Fatalf logs a formatted message at FatalLevel using the default tag.
-func Fatalf(format string, args ...interface{}) {
-	Record(ctxDefault, FatalLevel, TagDefault, Msgf(format, args...))
-}
-
 // Record is the core function that handles publishing log events.
 // It checks the logger level, captures caller information, gathers context fields,
 // and sends the log event to the logger.

log/log_level.go

@@ -21,6 +21,10 @@ import (
 	"strings"
 )
 
+func init() {
+	RegisterConverter(ParseLevel)
+}
+
 const (
 	NoneLevel  Level = iota // No logging
 	TraceLevel              // Very detailed logging, typically for debugging at a granular level

log/log_reader.go

@@ -70,14 +70,14 @@ func DumpNode(node *Node, indent int, buf *bytes.Buffer) {
 		}
 		buf.WriteString("}")
 	}
+	if node.Text != "" {
+		buf.WriteString(" : ")
+		buf.WriteString(node.Text)
+	}
 	for _, c := range node.Children {
 		buf.WriteString("\n")
 		DumpNode(c, indent+1, buf)
 	}
-	if node.Text != "" {
-		buf.WriteString(" : ")
-		buf.WriteString(strings.TrimSpace(node.Text))
-	}
 }
 
 // Reader is an interface for reading and parsing data into a Node structure.

log/log_refresh.go

@@ -181,6 +181,9 @@ func RefreshReader(input io.Reader, ext string) error {
 			}
 			ss := strings.Split(base.Tags, ",")
 			for _, s := range ss {
+				if s = strings.TrimSpace(s); s == "" {
+					return fmt.Errorf("RefreshReader: logger tag can not be empty")
+				}
 				cTags[s] = logger
 			}
 		}
@@ -215,7 +218,7 @@ func RefreshReader(input io.Reader, ext string) error {
 		}
 	}
 
-	for s, tag := range tags {
+	for s, tag := range tagMap {
 		logger := cRoot
 		for i, r := range tagArray {
 			if r.MatchString(s) {

log/log_tag.go

@@ -20,7 +20,7 @@ import (
 	"sync/atomic"
 )
 
-var tags = map[string]*Tag{}
+var tagMap = map[string]*Tag{}
 
 var initLogger = &Logger{
 	privateConfig: &LoggerConfig{
@@ -71,11 +71,11 @@ func (m *Tag) SetLogger(logger *Logger) {
 // GetTag creates or retrieves a Tag by name.
 // If the tag does not exist, it is created and added to the global registry.
 func GetTag(tag string) *Tag {
-	m, ok := tags[tag]
+	m, ok := tagMap[tag]
 	if !ok {
 		m = &Tag{s: tag}
 		m.v.Store(initLogger)
-		tags[tag] = m
+		tagMap[tag] = m
 	}
 	return m
 }

log/log_test.go

@@ -25,6 +25,7 @@ import (
 	"github.com/lvan100/go-assert"
 )
 
+var TagDefault = log.GetTag("_def")
 var TagRequestIn = log.GetTag("_com_request_in")
 var TagRequestOut = log.GetTag("_com_request_out")
 
@@ -50,7 +51,7 @@ func TestLog(t *testing.T) {
 		}
 	})
 
-	log.Infof("hello %s", "world")
+	log.Info(ctx, TagDefault, log.Msgf("hello %s", "world"))
 	log.Info(ctx, TagRequestIn, log.Msgf("hello %s", "world"))
 
 	xml := `
@@ -89,6 +90,6 @@ func TestLog(t *testing.T) {
 		}
 	})
 
-	log.Infof("hello %s", "world")
+	log.Info(ctx, TagDefault, log.Msgf("hello %s", "world"))
 	log.Info(ctx, TagRequestIn, log.Msgf("hello %s", "world"))
 }

log/plugin.go

@@ -28,10 +28,6 @@ import (
 
 var converters = map[reflect.Type]any{}
 
-func init() {
-	RegisterConverter(ParseLevel)
-}
-
 // Converter function type that converts string to a specific type T.
 type Converter[T any] func(string) (T, error)
 
@@ -41,11 +37,6 @@ func RegisterConverter[T any](fn Converter[T]) {
 	converters[t] = fn
 }
 
-// Initializer Optional initializer interface for plugin instances.
-type Initializer interface {
-	Init() error
-}
-
 // Lifecycle Optional lifecycle interface for plugin instances.
 type Lifecycle interface {
 	Start() error
@@ -77,12 +68,12 @@ type Plugin struct {
 }
 
 // RegisterPlugin Registers a plugin with a given name and type.
-func RegisterPlugin[T any](name string, typ PluginType) {
+func RegisterPlugin[T Lifecycle](name string, typ PluginType) {
 	_, file, line, _ := runtime.Caller(1)
 	if p, ok := plugins[name]; ok {
 		panic(fmt.Errorf("duplicate plugin %s in %s:%d and %s:%d", typ, p.File, p.Line, file, line))
 	}
-	t := reflect.TypeFor[T]()
+	t := reflect.TypeFor[T]().Elem()
 	if t.Kind() != reflect.Struct {
 		panic("T must be struct")
 	}
@@ -98,16 +89,8 @@ func RegisterPlugin[T any](name string, typ PluginType) {
 // NewPlugin Creates and initializes a plugin instance.
 func NewPlugin(t reflect.Type, node *Node, properties map[string]string) (reflect.Value, error) {
 	v := reflect.New(t)
-	err := inject(v.Elem(), t, node, properties)
-	if err != nil {
-		err = errutil.WrapError(err, "create plugin %s error", t.String())
-		return reflect.Value{}, err
-	}
-	if i, ok := v.Interface().(Initializer); ok {
-		if err = i.Init(); err != nil {
-			err = errutil.WrapError(err, "init plugin %s error", t.String())
-			return reflect.Value{}, err
-		}
+	if err := inject(v.Elem(), t, node, properties); err != nil {
+		return reflect.Value{}, errutil.WrapError(err, "create plugin %s error", t.String())
 	}
 	return v, nil
 }