优化

internal/helper/goroutine.go

@@ -0,0 +1,53 @@
+// Package helper provides shared utilities.
+package helper
+
+import (
+	"fmt"
+	"os"
+	"runtime/debug"
+
+	"go.uber.org/zap"
+)
+
+// Go runs fn in a new goroutine and recovers from panics so that a failure in
+// a background task (scraper parsing remote responses, cloud-drive sync, ...)
+// is logged instead of crashing the whole process. log may be nil.
+func Go(log *zap.Logger, name string, fn func()) {
+	go Run(log, name, fn)
+}
+
+// Run executes fn and recovers from panics, logging the task name and stack.
+// Use it as the first statement inside goroutines spawned elsewhere, or wrap
+// loop bodies so one bad iteration cannot kill a long-running worker.
+func Run(log *zap.Logger, name string, fn func()) {
+	defer func() {
+		if r := recover(); r != nil {
+			logPanic(log, name, r)
+		}
+	}()
+	fn()
+}
+
+// Recover runs fn and converts a panic into an error so callers can run their
+// own deferred cleanup (releasing locks, updating job state) before unwinding.
+func Recover(log *zap.Logger, name string, fn func() error) (err error) {
+	defer func() {
+		if r := recover(); r != nil {
+			logPanic(log, name, r)
+			err = fmt.Errorf("%s panicked: %v", name, r)
+		}
+	}()
+	return fn()
+}
+
+func logPanic(log *zap.Logger, name string, r any) {
+	if log == nil {
+		fmt.Fprintf(os.Stderr, "background task panicked: task=%s panic=%v\n%s\n", name, r, debug.Stack())
+		return
+	}
+	log.Error("background task panicked",
+		zap.String("task", name),
+		zap.Any("panic", r),
+		zap.ByteString("stack", debug.Stack()),
+	)
+}

internal/helper/goroutine_test.go

@@ -0,0 +1,95 @@
+package helper
+
+import (
+	"errors"
+	"strings"
+	"testing"
+	"time"
+
+	"go.uber.org/zap"
+	"go.uber.org/zap/zaptest/observer"
+)
+
+func newObservedLogger(t *testing.T) (*zap.Logger, *observer.ObservedLogs) {
+	t.Helper()
+	core, logs := observer.New(zap.ErrorLevel)
+	return zap.New(core), logs
+}
+
+func waitForLogs(t *testing.T, logs *observer.ObservedLogs, n int) []observer.LoggedEntry {
+	t.Helper()
+	deadline := time.Now().Add(2 * time.Second)
+	for time.Now().Before(deadline) {
+		if entries := logs.All(); len(entries) >= n {
+			return entries
+		}
+		time.Sleep(5 * time.Millisecond)
+	}
+	t.Fatalf("timed out waiting for %d log entries, got %d", n, logs.Len())
+	return nil
+}
+
+func TestRunRecoversPanic(t *testing.T) {
+	log, logs := newObservedLogger(t)
+	ran := false
+	Run(log, "unit.panic", func() {
+		ran = true
+		panic("boom")
+	})
+	if !ran {
+		t.Fatal("fn should have run before panicking")
+	}
+	entries := waitForLogs(t, logs, 1)
+	if entries[0].Message != "background task panicked" {
+		t.Fatalf("unexpected message: %s", entries[0].Message)
+	}
+	found := false
+	for _, f := range entries[0].Context {
+		if f.Key == "task" && f.String == "unit.panic" {
+			found = true
+		}
+	}
+	if !found {
+		t.Fatalf("expected task name in log context: %v", entries[0].Context)
+	}
+}
+
+func TestRunNoPanicNoLog(t *testing.T) {
+	log, logs := newObservedLogger(t)
+	Run(log, "unit.ok", func() {})
+	time.Sleep(10 * time.Millisecond)
+	if logs.Len() != 0 {
+		t.Fatalf("expected no error log, got %d", logs.Len())
+	}
+}
+
+func TestRecoverConvertsPanicToError(t *testing.T) {
+	log, _ := newObservedLogger(t)
+	err := Recover(log, "unit.recover", func() error {
+		panic("kaboom")
+	})
+	if err == nil {
+		t.Fatal("expected error from recovered panic")
+	}
+	if !strings.Contains(err.Error(), "kaboom") {
+		t.Fatalf("panic value should be in error: %v", err)
+	}
+}
+
+func TestRecoverReturnsFnError(t *testing.T) {
+	sentinel := errors.New("plain failure")
+	err := Recover(nil, "unit.err", func() error { return sentinel })
+	if !errors.Is(err, sentinel) {
+		t.Fatalf("expected fn error, got %v", err)
+	}
+}
+
+func TestRunWithNilLoggerDoesNotCrash(t *testing.T) {
+	Run(nil, "unit.nillog", func() { panic("still caught") })
+}
+
+func TestGoLogsPanicFromSpawnedGoroutine(t *testing.T) {
+	log, logs := newObservedLogger(t)
+	Go(log, "unit.go", func() { panic("async boom") })
+	waitForLogs(t, logs, 1)
+}