FIX: retry usage configuration after read or close failures

Author: merefield

internal/codex/usage_coverage.go

@@ -134,16 +134,26 @@ func (r *LiveUsageReader) localAsyncCompaction(path, session string) (bool, stri
 		diagnostics.Error("local-config", "open", err, fields)
 		return false, "background usage configuration could not be read"
 	}
+	return r.readLocalAsyncCompaction(file, info, fields)
+}
+
+func (r *LiveUsageReader) readLocalAsyncCompaction(file io.ReadCloser, info os.FileInfo, fields diagnostics.Fields) (bool, string) {
 	data, err := io.ReadAll(io.LimitReader(file, 1<<20+1))
-	if closeErr := file.Close(); closeErr != nil {
+	closeErr := file.Close()
+	if closeErr != nil {
 		diagnostics.Error("local-config", "close", closeErr, fields)
 	}
-	check := localFeatureCheck{info: info}
-	var config map[string]any
 	if err != nil {
 		diagnostics.Error("local-config", "read", err, fields)
-		check.issue = "background usage configuration could not be verified"
-	} else if len(data) > 1<<20 {
+	}
+	// Transient filesystem failures must be retried, not cached as a valid
+	// configuration (or as a persistent failure for otherwise unchanged bytes).
+	if err != nil || closeErr != nil {
+		return false, "background usage configuration could not be verified"
+	}
+	check := localFeatureCheck{info: info}
+	var config map[string]any
+	if len(data) > 1<<20 {
 		diagnostics.Error("local-config", "configuration exceeds 1 MiB limit", nil, fields)
 		check.issue = "background usage configuration could not be verified"
 	} else if parseErr := toml.Unmarshal(data, &config); parseErr != nil {
@@ -157,7 +167,7 @@ func (r *LiveUsageReader) localAsyncCompaction(path, session string) (bool, stri
 	if len(r.localFeatureChecks) >= 256 {
 		clear(r.localFeatureChecks)
 	}
-	r.localFeatureChecks[path] = check
+	r.localFeatureChecks[fields.Path] = check
 	return check.enabled, check.issue
 }
 

internal/codex/usage_coverage_logging_test.go

@@ -1,15 +1,82 @@
 package codex
 
 import (
+	"io"
 	"os"
 	"path/filepath"
 	"runtime"
 	"strings"
 	"testing"
+	"testing/iotest"
 
 	"github.com/merefield/codexometer/internal/diagnostics"
 )
 
+type coverageReadCloser struct {
+	io.Reader
+	closeErr error
+	closed   bool
+}
+
+func (f *coverageReadCloser) Close() error {
+	f.closed = true
+	return f.closeErr
+}
+
+func TestUsageCoverageReadAndCloseFailuresAreLoggedAndRetried(t *testing.T) {
+	for _, failure := range []string{"read", "close", "read and close"} {
+		t.Run(failure, func(t *testing.T) {
+			dir := t.TempDir()
+			path, logPath := filepath.Join(dir, "config.toml"), filepath.Join(dir, "error.log")
+			const config = "[features]\nasync_compaction = true\n"
+			if err := os.WriteFile(path, []byte(config), 0600); err != nil {
+				t.Fatal(err)
+			}
+			info, err := os.Stat(path)
+			if err != nil {
+				t.Fatal(err)
+			}
+			closeLog, err := diagnostics.Install(logPath, false)
+			if err != nil {
+				t.Fatal(err)
+			}
+			t.Cleanup(func() { closeLog() })
+			file := &coverageReadCloser{Reader: strings.NewReader(config)}
+			if strings.Contains(failure, "read") {
+				file.Reader = iotest.ErrReader(os.ErrPermission)
+			}
+			if strings.Contains(failure, "close") {
+				file.closeErr = os.ErrPermission
+			}
+			r := &LiveUsageReader{localFeatureChecks: make(map[string]localFeatureCheck)}
+			enabled, issue := r.readLocalAsyncCompaction(file, info, diagnostics.Fields{Path: path, Session: "thread"})
+			if enabled || issue != "background usage configuration could not be verified" || !file.closed {
+				t.Fatal("filesystem failure did not block verification and close the file", enabled, issue, file.closed)
+			}
+			if len(r.localFeatureChecks) != 0 {
+				t.Fatal("failed filesystem operation was cached", r.localFeatureChecks)
+			}
+			if err := closeLog(); err != nil {
+				t.Fatal(err)
+			}
+			data, err := os.ReadFile(logPath)
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, operation := range []string{"read", "close"} {
+				if strings.Contains(failure, operation) && !strings.Contains(string(data), `"msg":"`+operation+`"`) {
+					t.Fatal("filesystem failure was not logged", operation, string(data))
+				}
+			}
+			// Retry the same path and unchanged metadata after the transient
+			// failure. A successful read must now detect and cache the flag.
+			if enabled, issue := r.localAsyncCompaction(path, "thread"); !enabled || issue != "" || !r.localFeatureChecks[path].enabled {
+				t.Fatal("unchanged configuration was not successfully retried", enabled, issue)
+			}
+		})
+	}
+}
+
 func TestUsageCoverageLogsFilesystemCauseWithoutChangingTheGuard(t *testing.T) {
 	home := t.TempDir()
 	logPath, config := filepath.Join(home, "error.log"), filepath.Join(home, "config.toml")