优化

pkg/logging/zap.go

@@ -2,8 +2,10 @@ package logging
 
 import (
 	"context"
+	"fmt"
 	"log/slog"
 	"os"
+	"path/filepath"
 	"strings"
 	"sync"
 	"time"
@@ -136,12 +138,140 @@ func (c *moduleFilterCore) Write(entry zapcore.Entry, fields []zapcore.Field) er
 func moduleField(fields []zapcore.Field) string {
 	for _, field := range fields {
 		if field.Key == "mod" {
-			return field.String
+			if field.String != "" {
+				return field.String
+			}
+			if field.Interface != nil {
+				return fmt.Sprint(field.Interface)
+			}
 		}
 	}
 	return ""
 }
 
+type routedFileState struct {
+	mu      sync.Mutex
+	writers map[string]*DailyWriter
+}
+
+type routedFileCore struct {
+	base         zapcore.Core
+	encoder      zapcore.Encoder
+	level        zapcore.LevelEnabler
+	root         string
+	retentionDay int
+	state        *routedFileState
+	fields       []zapcore.Field
+}
+
+func (c *routedFileCore) Enabled(level zapcore.Level) bool { return c.level.Enabled(level) }
+
+func (c *routedFileCore) With(fields []zapcore.Field) zapcore.Core {
+	inherited := append([]zapcore.Field(nil), c.fields...)
+	inherited = append(inherited, fields...)
+	return &routedFileCore{base: c.base.With(fields), encoder: c.encoder, level: c.level, root: c.root, retentionDay: c.retentionDay, state: c.state, fields: inherited}
+}
+
+func (c *routedFileCore) Check(entry zapcore.Entry, checked *zapcore.CheckedEntry) *zapcore.CheckedEntry {
+	if c.Enabled(entry.Level) {
+		return checked.AddCore(entry, c)
+	}
+	return checked
+}
+
+func (c *routedFileCore) Write(entry zapcore.Entry, fields []zapcore.Field) error {
+	baseErr := c.base.Write(entry, fields)
+	allFields := append([]zapcore.Field(nil), c.fields...)
+	allFields = append(allFields, fields...)
+	paths := routedLogPaths(moduleField(allFields), entry.Level)
+	if len(paths) == 0 {
+		return baseErr
+	}
+	buffer, err := c.encoder.Clone().EncodeEntry(entry, allFields)
+	if err != nil {
+		if baseErr != nil {
+			return baseErr
+		}
+		return err
+	}
+	defer buffer.Free()
+	for _, name := range paths {
+		writer := c.writer(name)
+		if _, writeErr := writer.Write(buffer.Bytes()); writeErr != nil && baseErr == nil {
+			baseErr = writeErr
+		}
+	}
+	return baseErr
+}
+
+func (c *routedFileCore) Sync() error {
+	result := c.base.Sync()
+	c.state.mu.Lock()
+	defer c.state.mu.Unlock()
+	for _, writer := range c.state.writers {
+		if err := writer.Sync(); err != nil && result == nil {
+			result = err
+		}
+	}
+	return result
+}
+
+func (c *routedFileCore) writer(name string) *DailyWriter {
+	c.state.mu.Lock()
+	defer c.state.mu.Unlock()
+	writer := c.state.writers[name]
+	if writer == nil {
+		writer = NewDailyWriter(c.root, name, c.retentionDay)
+		c.state.writers[name] = writer
+	}
+	return writer
+}
+
+func (c *routedFileCore) Close() {
+	c.state.mu.Lock()
+	defer c.state.mu.Unlock()
+	for name, writer := range c.state.writers {
+		_ = writer.Close()
+		delete(c.state.writers, name)
+	}
+}
+
+func routedLogPaths(module string, level zapcore.Level) []string {
+	paths := make([]string, 0, 2)
+	if module = safeModuleName(module); module != "" {
+		switch module {
+		case "http":
+			paths = append(paths, filepath.Join("http", "access.log"))
+		case "timedTask":
+			paths = append(paths, filepath.Join("timedTask", "task.log"))
+		case "error":
+			paths = append(paths, filepath.Join("error", "error.log"))
+		default:
+			paths = append(paths, filepath.Join(module, "application.log"))
+		}
+	}
+	if level >= zapcore.ErrorLevel {
+		errorPath := filepath.Join("error", "error.log")
+		if len(paths) == 0 || paths[len(paths)-1] != errorPath {
+			paths = append(paths, errorPath)
+		}
+	}
+	return paths
+}
+
+func safeModuleName(value string) string {
+	value = strings.TrimSpace(value)
+	if value == "" {
+		return ""
+	}
+	return strings.Map(func(r rune) rune {
+		if r >= 'a' && r <= 'z' || r >= 'A' && r <= 'Z' || r >= '0' && r <= '9' || r == '-' || r == '_' {
+			return r
+		}
+		return -1
+	}, value)
+}
+
 // NewZapLogger adapts a Zap core to the slog logger used by Kratos v3.
 // The file layout remains compatible with the administration log viewer.
 func newZapHandler(root, filename string, options Options) (slog.Handler, func()) {
@@ -170,9 +300,14 @@ func newZapHandler(root, filename string, options Options) (slog.Handler, func()
 		}
 		outputEncoder = zapcore.NewConsoleEncoder(encoder)
 	}
-	level := zap.InfoLevel
-	if parsed := level.Set(strings.ToLower(options.Level)); parsed != nil {
-		level = zap.DebugLevel
+	level := zap.DebugLevel
+	// zapcore.Level.Set reports an error but does not make the intended
+	// configuration handling obvious here. Parse the configured value directly
+	// so debug/warn/error are actually applied after startup and hot reload.
+	if value := strings.TrimSpace(strings.ToLower(options.Level)); value != "" {
+		if err := level.UnmarshalText([]byte(value)); err != nil {
+			level = zap.DebugLevel
+		}
 	}
 	levelEnabler := zap.NewAtomicLevelAt(level)
 	fileCore := zapcore.NewCore(
@@ -189,7 +324,8 @@ func newZapHandler(root, filename string, options Options) (slog.Handler, func()
 		consoleCore := zapcore.NewCore(outputEncoder.Clone(), zapcore.AddSync(os.Stdout), levelEnabler)
 		core = zapcore.NewTee(fileCore, &moduleFilterCore{Core: consoleCore, fileOnly: fileOnly})
 	}
-	zapLogger := zap.New(core)
+	routed := &routedFileCore{base: core, encoder: outputEncoder.Clone(), level: levelEnabler, root: root, retentionDay: options.RetentionDay, state: &routedFileState{writers: map[string]*DailyWriter{}}}
+	zapLogger := zap.New(routed)
 	handlerOptions := []zapslog.HandlerOption{zapslog.AddStacktraceAt(slog.LevelError)}
 	if options.ShowLine {
 		handlerOptions = append(handlerOptions, zapslog.WithCaller(true))
@@ -197,6 +333,7 @@ func newZapHandler(root, filename string, options Options) (slog.Handler, func()
 	handler := zapslog.NewHandler(zapLogger.Core(), handlerOptions...)
 	cleanup := func() {
 		_ = zapLogger.Sync()
+		routed.Close()
 		_ = file.Close()
 	}
 	return handler, cleanup
@@ -205,10 +342,11 @@ func newZapHandler(root, filename string, options Options) (slog.Handler, func()
 // NewReloadableZapLogger keeps the slog/Kratos adapter stable while replacing
 // the underlying Zap core when the runtime configuration changes.
 func NewReloadableZapLogger(root, filename string, options Options, attrs ...any) (*slog.Logger, *ReloadableLogger) {
-	handler, cleanup := newZapHandler(root, filename, options)
-	state := &reloadableHandlerState{handler: handler, cleanup: cleanup}
+	baseHandler, cleanup := newZapHandler(root, filename, options)
+	state := &reloadableHandlerState{handler: baseHandler, cleanup: cleanup}
 	control := &ReloadableLogger{state: state, filename: filename}
-	logger := kratoslog.NewLogger(&reloadableHandler{state: state}, kratoslog.WithExtractor(tracing.TraceAttrs)).With(attrs...)
+	handler := &contextHandler{handler: &reloadableHandler{state: state}}
+	logger := kratoslog.NewLogger(handler, kratoslog.WithExtractor(tracing.TraceAttrs)).With(attrs...)
 	return logger, control
 }