Save logs to disk

Thomas Stromberg · Thomas Stromberg · commit 25f14d666acc · 2025-09-16T13:40:47.000-04:00
diff --git a/cmd/goose/github.go b/cmd/goose/github.go
@@ -446,10 +446,17 @@ func (app *App) fetchTurnDataSync(ctx context.Context, issues []*github.Issue, u
 	// Collect results and update PRs directly
 	turnSuccesses := 0
 	turnFailures := 0
+	actualAPICalls := 0
+	cacheHits := 0
 
 	for result := range results {
 		if result.err == nil && result.turnData != nil && result.turnData.PRState.UnblockAction != nil {
 			turnSuccesses++
+			if result.wasFromCache {
+				cacheHits++
+			} else {
+				actualAPICalls++
+			}
 
 			// Check if user needs to review and get action reason
 			needsReview := false
@@ -487,6 +494,17 @@ func (app *App) fetchTurnDataSync(ctx context.Context, issues []*github.Issue, u
 		}
 	}
 
-	slog.Info("[TURN] Turn API queries completed",
-		"duration", time.Since(turnStart), "succeeded", turnSuccesses, "total", turnSuccesses+turnFailures)
+	// Only log if there were actual API calls or failures
+	if actualAPICalls > 0 || turnFailures > 0 {
+		slog.Info("[TURN] API queries completed",
+			"duration", time.Since(turnStart),
+			"api_calls", actualAPICalls,
+			"cache_hits", cacheHits,
+			"failures", turnFailures,
+			"total", turnSuccesses+turnFailures)
+	} else if cacheHits > 0 {
+		slog.Debug("[TURN] All data served from cache",
+			"cache_hits", cacheHits,
+			"duration", time.Since(turnStart))
+	}
 }
diff --git a/cmd/goose/main.go b/cmd/goose/main.go
@@ -78,6 +78,7 @@ type App struct {
 	turnClient          *turn.Client
 	previousBlockedPRs  map[string]bool
 	authError           string
+	lastFetchError      string
 	cacheDir            string
 	targetUser          string
 	lastMenuTitles      []string
@@ -208,6 +209,30 @@ func main() {
 		os.Exit(1)
 	}
 
+	// Set up file-based logging alongside cache
+	logDir := filepath.Join(cacheDir, "logs")
+	if err := os.MkdirAll(logDir, dirPerm); err != nil {
+		slog.Error("Failed to create log directory", "error", err)
+		// Continue without file logging
+	} else {
+		// Create log file with daily rotation
+		logPath := filepath.Join(logDir, fmt.Sprintf("goose-%s.log", time.Now().Format("2006-01-02")))
+		logFile, err := os.OpenFile(logPath, os.O_CREATE|os.O_APPEND|os.O_WRONLY, 0o600)
+		if err != nil {
+			slog.Error("Failed to open log file", "error", err)
+		} else {
+			// Update logger to write to both stderr and file
+			multiHandler := &MultiHandler{
+				handlers: []slog.Handler{
+					slog.NewTextHandler(os.Stderr, opts),
+					slog.NewTextHandler(logFile, opts),
+				},
+			}
+			slog.SetDefault(slog.New(multiHandler))
+			slog.Info("Logs are being written to", "path", logPath)
+		}
+	}
+
 	startTime := time.Now()
 	app := &App{
 		cacheDir:           cacheDir,
@@ -376,6 +401,7 @@ func (app *App) updatePRs(ctx context.Context) {
 		app.mu.Lock()
 		app.consecutiveFailures++
 		failureCount := app.consecutiveFailures
+		app.lastFetchError = err.Error()
 		app.mu.Unlock()
 
 		// Progressive degradation based on failure count
@@ -431,6 +457,7 @@ func (app *App) updatePRs(ctx context.Context) {
 	app.mu.Lock()
 	app.lastSuccessfulFetch = time.Now()
 	app.consecutiveFailures = 0
+	app.lastFetchError = ""
 	app.mu.Unlock()
 
 	// Update state atomically
@@ -513,6 +540,7 @@ func (app *App) updatePRsWithWait(ctx context.Context) {
 		app.mu.Lock()
 		app.consecutiveFailures++
 		failureCount := app.consecutiveFailures
+		app.lastFetchError = err.Error()
 		app.mu.Unlock()
 
 		// Progressive degradation based on failure count
@@ -535,7 +563,7 @@ func (app *App) updatePRsWithWait(ctx context.Context) {
 		systray.SetTitle(title)
 		systray.SetTooltip(tooltip)
 
-		// Still create initial menu even on error
+		// Create or update menu to show error state
 		if !app.menuInitialized {
 			// Create initial menu despite error
 			app.rebuildMenu(ctx)
@@ -547,6 +575,9 @@ func (app *App) updatePRsWithWait(ctx context.Context) {
 			app.lastMenuTitles = menuTitles
 			app.mu.Unlock()
 			// Menu initialization complete
+		} else if failureCount == 1 {
+			// On first failure, rebuild menu to show error at top
+			app.rebuildMenu(ctx)
 		}
 		return
 	}
@@ -555,6 +586,7 @@ func (app *App) updatePRsWithWait(ctx context.Context) {
 	app.mu.Lock()
 	app.lastSuccessfulFetch = time.Now()
 	app.consecutiveFailures = 0
+	app.lastFetchError = ""
 	app.mu.Unlock()
 
 	// Update state
diff --git a/cmd/goose/multihandler.go b/cmd/goose/multihandler.go
@@ -0,0 +1,49 @@
+package main
+
+import (
+	"context"
+	"log/slog"
+)
+
+// MultiHandler implements slog.Handler to write logs to multiple destinations.
+type MultiHandler struct {
+	handlers []slog.Handler
+}
+
+// Enabled returns true if at least one handler is enabled.
+func (h *MultiHandler) Enabled(ctx context.Context, level slog.Level) bool {
+	for _, handler := range h.handlers {
+		if handler.Enabled(ctx, level) {
+			return true
+		}
+	}
+	return false
+}
+
+// Handle writes the record to all handlers.
+func (h *MultiHandler) Handle(ctx context.Context, record slog.Record) error {
+	for _, handler := range h.handlers {
+		if handler.Enabled(ctx, record.Level) {
+			handler.Handle(ctx, record) //nolint:errcheck // Continue logging to other destinations
+		}
+	}
+	return nil
+}
+
+// WithAttrs returns a new handler with additional attributes.
+func (h *MultiHandler) WithAttrs(attrs []slog.Attr) slog.Handler {
+	handlers := make([]slog.Handler, len(h.handlers))
+	for i, handler := range h.handlers {
+		handlers[i] = handler.WithAttrs(attrs)
+	}
+	return &MultiHandler{handlers: handlers}
+}
+
+// WithGroup returns a new handler with a group name.
+func (h *MultiHandler) WithGroup(name string) slog.Handler {
+	handlers := make([]slog.Handler, len(h.handlers))
+	for i, handler := range h.handlers {
+		handlers[i] = handler.WithGroup(name)
+	}
+	return &MultiHandler{handlers: handlers}
+}
diff --git a/cmd/goose/settings.go b/cmd/goose/settings.go
@@ -16,62 +16,43 @@ type Settings struct {
 	EnableAutoBrowser bool            `json:"enable_auto_browser"`
 }
 
-// settingsDir returns the configuration directory for settings.
-func settingsDir() (string, error) {
-	configDir, err := os.UserConfigDir()
-	if err != nil {
-		return "", err
-	}
-	return filepath.Join(configDir, "review-goose"), nil
-}
-
 // loadSettings loads settings from disk or returns defaults.
 func (app *App) loadSettings() {
-	settingsDir, err := settingsDir()
+	// Set defaults first
+	app.enableAudioCues = true
+	app.hideStaleIncoming = true
+	app.enableAutoBrowser = false
+	app.hiddenOrgs = make(map[string]bool)
+
+	configDir, err := os.UserConfigDir()
 	if err != nil {
 		slog.Error("Failed to get settings directory", "error", err)
-		// Use defaults
-		app.enableAudioCues = true
-		app.hideStaleIncoming = true
-		app.enableAutoBrowser = false
-		app.hiddenOrgs = make(map[string]bool)
 		return
 	}
 
-	settingsPath := filepath.Join(settingsDir, "settings.json")
-
+	settingsPath := filepath.Join(configDir, "review-goose", "settings.json")
 	data, err := os.ReadFile(settingsPath)
 	if err != nil {
 		if !os.IsNotExist(err) {
 			slog.Debug("Failed to read settings", "error", err)
 		}
-		// Use defaults
-		app.enableAudioCues = true
-		app.hideStaleIncoming = true
-		app.enableAutoBrowser = false
-		app.hiddenOrgs = make(map[string]bool)
 		return
 	}
 
 	var settings Settings
 	if err := json.Unmarshal(data, &settings); err != nil {
 		slog.Error("Failed to parse settings", "error", err)
-		// Use defaults
-		app.enableAudioCues = true
-		app.hideStaleIncoming = true
-		app.enableAutoBrowser = false
-		app.hiddenOrgs = make(map[string]bool)
 		return
 	}
 
+	// Override defaults with loaded values
 	app.enableAudioCues = settings.EnableAudioCues
 	app.hideStaleIncoming = settings.HideStale
 	app.enableAutoBrowser = settings.EnableAutoBrowser
 	if settings.HiddenOrgs != nil {
 		app.hiddenOrgs = settings.HiddenOrgs
-	} else {
-		app.hiddenOrgs = make(map[string]bool)
 	}
+
 	slog.Info("Loaded settings",
 		"audio_cues", app.enableAudioCues,
 		"hide_stale", app.hideStaleIncoming,
@@ -81,11 +62,12 @@ func (app *App) loadSettings() {
 
 // saveSettings saves current settings to disk.
 func (app *App) saveSettings() {
-	settingsDir, err := settingsDir()
+	configDir, err := os.UserConfigDir()
 	if err != nil {
 		slog.Error("Failed to get settings directory", "error", err)
 		return
 	}
+	settingsDir := filepath.Join(configDir, "review-goose")
 
 	app.mu.RLock()
 	settings := Settings{
diff --git a/cmd/goose/ui.go b/cmd/goose/ui.go
@@ -10,6 +10,7 @@ import (
 	"os/exec"
 	"runtime"
 	"sort"
+	"strings"
 	"time"
 
 	"github.com/energye/systray" // needed for MenuItem type
@@ -407,16 +408,23 @@ func (app *App) rebuildMenu(ctx context.Context) {
 	// Clear all existing menu items
 	app.systrayInterface.ResetMenu()
 
-	// Check for auth error first
-	if app.authError != "" {
+	// Check for errors (auth or connection failures)
+	app.mu.RLock()
+	authError := app.authError
+	failureCount := app.consecutiveFailures
+	lastFetchError := app.lastFetchError
+	app.mu.RUnlock()
+
+	// Show auth error if present
+	if authError != "" {
 		// Show authentication error message
 		errorTitle := app.systrayInterface.AddMenuItem("⚠️ Authentication Error", "")
 		errorTitle.Disable()
 
 		app.systrayInterface.AddSeparator()
 
 		// Add error details
-		errorMsg := app.systrayInterface.AddMenuItem(app.authError, "Click to see setup instructions")
+		errorMsg := app.systrayInterface.AddMenuItem(authError, "Click to see setup instructions")
 		errorMsg.Click(func() {
 			if err := openURL(ctx, "https://cli.github.com/manual/gh_auth_login"); err != nil {
 				slog.Error("failed to open setup instructions", "error", err)
@@ -449,6 +457,78 @@ func (app *App) rebuildMenu(ctx context.Context) {
 		return
 	}
 
+	// Show connection error if we have consecutive failures
+	if failureCount > 0 && lastFetchError != "" {
+		var errorMsg string
+		switch {
+		case failureCount == 1:
+			errorMsg = "⚠️ Connection Error"
+		case failureCount <= 3:
+			errorMsg = fmt.Sprintf("⚠️ Connection Issues (%d failures)", failureCount)
+		case failureCount <= 10:
+			errorMsg = "❌ Multiple Connection Failures"
+		default:
+			errorMsg = "💀 Service Degraded"
+		}
+
+		errorTitle := app.systrayInterface.AddMenuItem(errorMsg, "")
+		errorTitle.Disable()
+
+		// Determine hostname and error type
+		hostname := "api.github.com"
+		for _, h := range []struct{ match, host string }{
+			{"ready-to-review.dev", "dash.ready-to-review.dev"},
+			{"api.github.com", "api.github.com"},
+			{"github.com", "github.com"},
+		} {
+			if strings.Contains(lastFetchError, h.match) {
+				hostname = h.host
+				break
+			}
+		}
+
+		errorType := "Connection failed"
+		for _, e := range []struct{ match, errType string }{
+			{"timeout", "Request timeout"},
+			{"context deadline", "Request timeout (context deadline)"},
+			{"rate limit", "Rate limit exceeded"},
+			{"401", "Authentication failed"},
+			{"unauthorized", "Authentication failed"},
+			{"403", "Access forbidden"},
+			{"forbidden", "Access forbidden"},
+			{"404", "Resource not found"},
+			{"connection refused", "Connection refused"},
+			{"no such host", "DNS resolution failed"},
+			{"TLS", "TLS/Certificate error"},
+			{"x509", "TLS/Certificate error"},
+		} {
+			if strings.Contains(lastFetchError, e.match) {
+				errorType = e.errType
+				break
+			}
+		}
+
+		// Show technical details
+		techDetails := app.systrayInterface.AddMenuItem(fmt.Sprintf("Host: %s", hostname), "")
+		techDetails.Disable()
+
+		errorTypeItem := app.systrayInterface.AddMenuItem(fmt.Sprintf("Error: %s", errorType), "")
+		errorTypeItem.Disable()
+
+		// Show truncated raw error for debugging (max 80 chars)
+		rawError := lastFetchError
+		if len(rawError) > 80 {
+			rawError = rawError[:77] + "..."
+		}
+		rawErrorItem := app.systrayInterface.AddMenuItem(fmt.Sprintf("Details: %s", rawError), "Click to copy full error")
+		rawErrorItem.Click(func() {
+			// Would need clipboard support to implement copy
+			slog.Info("Full error", "error", lastFetchError)
+		})
+
+		app.systrayInterface.AddSeparator()
+	}
+
 	// Update tray title
 	app.setTrayTitle()
 
