bug处理优化

bug处理优化

cmd/server/log_rotate.go

@@ -76,14 +76,19 @@ func (w *rotatingFileWriter) Sync() error {
 	if w.file == nil {
 		return nil
 	}
-	err := w.file.Sync()
-	closeErr := w.file.Close()
+	return w.file.Sync()
+}
+
+func (w *rotatingFileWriter) Close() error {
+	w.mu.Lock()
+	defer w.mu.Unlock()
+	if w.file == nil {
+		return nil
+	}
+	err := w.file.Close()
 	w.file = nil
 	w.size = 0
-	if err != nil {
-		return err
-	}
-	return closeErr
+	return err
 }
 
 func (w *rotatingFileWriter) open() error {

cmd/server/logging.go

@@ -13,8 +13,14 @@ import (
 
 // newLogger 根据 cfg.Logging 构建 Zap。
 func newLogger(cfg *config.Config) (*zap.Logger, error) {
+	log, _, err := newLoggerWithCloser(cfg)
+	return log, err
+}
+
+func newLoggerWithCloser(cfg *config.Config) (*zap.Logger, func(), error) {
 	if cfg.App.Debug {
-		return zap.NewDevelopment()
+		log, err := zap.NewDevelopment()
+		return log, func() {}, err
 	}
 	level := configuredLogLevel(cfg.Logging.Level)
 	encoderCfg := zap.NewProductionEncoderConfig()
@@ -28,33 +34,42 @@ func newLogger(cfg *config.Config) (*zap.Logger, error) {
 	cores := []zapcore.Core{
 		zapcore.NewCore(encoder, zapcore.Lock(os.Stdout), level),
 	}
+	var closers []func() error
 	appPath, warnPath, errorPath := logFilePaths(cfg)
 	if appPath != "" {
 		appWriter, err := newRotatingFileWriter(appPath, cfg.Logging)
 		if err != nil {
-			return nil, err
+			return nil, nil, err
 		}
 		cores = append(cores, zapcore.NewCore(encoder, appWriter, level))
+		closers = append(closers, appWriter.Close)
 	}
 	if warnPath != "" {
 		warnWriter, err := newRotatingFileWriter(warnPath, cfg.Logging)
 		if err != nil {
-			return nil, err
+			return nil, nil, err
 		}
 		cores = append(cores, zapcore.NewCore(encoder, warnWriter, zap.LevelEnablerFunc(func(lvl zapcore.Level) bool {
 			return lvl == zapcore.WarnLevel && level.Enabled(lvl)
 		})))
+		closers = append(closers, warnWriter.Close)
 	}
 	if errorPath != "" {
 		errorWriter, err := newRotatingFileWriter(errorPath, cfg.Logging)
 		if err != nil {
-			return nil, err
+			return nil, nil, err
 		}
 		cores = append(cores, zapcore.NewCore(encoder, errorWriter, zap.LevelEnablerFunc(func(lvl zapcore.Level) bool {
 			return lvl >= zapcore.ErrorLevel && level.Enabled(lvl)
 		})))
+		closers = append(closers, errorWriter.Close)
 	}
-	return zap.New(zapcore.NewTee(cores...), zap.AddCaller(), zap.AddStacktrace(zapcore.ErrorLevel), zap.ErrorOutput(zapcore.Lock(os.Stderr))), nil
+	closeFn := func() {
+		for _, c := range closers {
+			_ = c()
+		}
+	}
+	return zap.New(zapcore.NewTee(cores...), zap.AddCaller(), zap.AddStacktrace(zapcore.ErrorLevel), zap.ErrorOutput(zapcore.Lock(os.Stderr))), closeFn, nil
 }
 
 func configuredLogLevel(raw string) zapcore.Level {

cmd/server/logging_test.go

@@ -22,10 +22,11 @@ func TestProductionLoggerWritesConfiguredInfoToAppLogAndSplitsWarnError(t *testi
 	cfg.Logging.MaxSizeMB = 1
 	cfg.Logging.MaxBackups = 2
 
-	log, err := newLogger(cfg)
+	log, closeFn, err := newLoggerWithCloser(cfg)
 	if err != nil {
 		t.Fatal(err)
 	}
+	defer closeFn()
 	log.Info("info should be stored")
 	log.Warn("warning only", zap.String("kind", "warn"))
 	log.Error("error only", zap.String("kind", "error"))
@@ -70,10 +71,11 @@ func TestProductionLoggerDefaultsToWarnInAppLog(t *testing.T) {
 	cfg.Logging.OutputPath = filepath.Join(dir, "logs")
 	cfg.Logging.EnableRotation = true
 
-	log, err := newLogger(cfg)
+	log, closeFn, err := newLoggerWithCloser(cfg)
 	if err != nil {
 		t.Fatal(err)
 	}
+	defer closeFn()
 	log.Info("info should stay quiet by default")
 	log.Warn("warning should be stored")
 	_ = log.Sync()
@@ -101,6 +103,7 @@ func TestRotatingFileWriterCapsFileSize(t *testing.T) {
 	if err != nil {
 		t.Fatal(err)
 	}
+	defer writer.Close()
 	chunk := strings.Repeat("x", 700*1024)
 	if _, err := writer.Write([]byte(chunk)); err != nil {
 		t.Fatal(err)

cmd/server/network.go

@@ -1,8 +1,10 @@
 package main
 
 import (
+	"io"
 	"net"
 	"net/http"
+	"strings"
 	"time"
 )
 
@@ -42,10 +44,12 @@ func getPublicIP(timeout time.Duration) string {
 		return ""
 	}
 	defer resp.Body.Close()
-	buf := make([]byte, 64)
-	n, err := resp.Body.Read(buf)
-	if err != nil || n == 0 || resp.StatusCode != http.StatusOK {
+	if resp.StatusCode != http.StatusOK {
 		return ""
 	}
-	return string(buf[:n])
+	data, err := io.ReadAll(io.LimitReader(resp.Body, 64))
+	if err != nil || len(data) == 0 {
+		return ""
+	}
+	return strings.TrimSpace(string(data))
 }