Avoid isolation issues

Author: jedisct1

www/db.go

@@ -2,6 +2,7 @@ package main
 
 import (
 	"database/sql"
+	"fmt"
 	"time"
 
 	_ "github.com/mattn/go-sqlite3"
@@ -44,11 +45,23 @@ type ResolverStats struct {
 }
 
 func NewDB(path string) (*DB, error) {
-	db, err := sql.Open("sqlite3", path+"?_journal_mode=WAL&_busy_timeout=5000")
+	db, err := sql.Open("sqlite3", path+"?_journal_mode=WAL&_busy_timeout=5000&_synchronous=NORMAL")
 	if err != nil {
 		return nil, err
 	}
 
+	// Use a single connection to avoid WAL snapshot isolation issues.
+	// With multiple connections, readers can see stale data because each
+	// connection may hold an old snapshot of the WAL. A single connection
+	// ensures all reads see the latest committed writes.
+	db.SetMaxOpenConns(1)
+
+	// Verify connection works
+	if err := db.Ping(); err != nil {
+		db.Close()
+		return nil, fmt.Errorf("failed to ping database: %w", err)
+	}
+
 	if err := createTables(db); err != nil {
 		db.Close()
 		return nil, err
@@ -111,11 +124,19 @@ func (d *DB) UpsertResolver(name, typ, description, sourceFile string) (int64, e
 }
 
 func (d *DB) RecordTest(resolverID int64, stamp string, success bool, rttMs int64, errMsg string) error {
-	_, err := d.db.Exec(`
+	result, err := d.db.Exec(`
 		INSERT INTO test_results (resolver_id, stamp, success, rtt_ms, error)
 		VALUES (?, ?, ?, ?, ?)
 	`, resolverID, stamp, success, rttMs, errMsg)
-	return err
+	if err != nil {
+		return err
+	}
+	// Verify the insert actually happened
+	rows, _ := result.RowsAffected()
+	if rows == 0 {
+		return fmt.Errorf("no rows inserted for resolver %d", resolverID)
+	}
+	return nil
 }
 
 func (d *DB) GetAllStats() ([]ResolverStats, error) {
@@ -251,3 +272,18 @@ func (d *DB) RemoveStaleResolvers(noSuccessSince time.Duration) ([]string, error
 
 	return names, nil
 }
+
+// GetTestCount returns the total number of test results and the timestamp of the most recent one
+func (d *DB) GetTestCount() (count int64, lastTest time.Time, err error) {
+	var lastTestStr sql.NullString
+	err = d.db.QueryRow(`
+		SELECT COUNT(*), MAX(tested_at) FROM test_results
+	`).Scan(&count, &lastTestStr)
+	if err != nil {
+		return 0, time.Time{}, err
+	}
+	if lastTestStr.Valid {
+		lastTest, _ = time.Parse("2006-01-02 15:04:05", lastTestStr.String)
+	}
+	return count, lastTest, nil
+}

www/main.go

@@ -31,6 +31,9 @@ func main() {
 	tester := NewTester(db, *concurrency, *timeout)
 
 	runTests := func() {
+		startTime := time.Now()
+		log.Printf("Starting test run at %s", startTime.Format(time.RFC3339))
+
 		resolvers, err := parser.ParseAll()
 		if err != nil {
 			log.Printf("Failed to parse resolvers: %v", err)
@@ -45,6 +48,16 @@ func main() {
 		} else if len(removed) > 0 {
 			log.Printf("Removed %d stale resolvers: %v", len(removed), removed)
 		}
+
+		// Log database state after test run
+		count, lastTest, err := db.GetTestCount()
+		if err != nil {
+			log.Printf("Failed to get test count: %v", err)
+		} else {
+			log.Printf("Database: %d total tests, last at %s", count, lastTest.Format(time.RFC3339))
+		}
+
+		log.Printf("Test run completed in %v", time.Since(startTime))
 	}
 
 	if *runOnce {

www/tester.go

@@ -121,7 +121,7 @@ func (t *Tester) TestAll(resolvers []Resolver) {
 		close(results)
 	}()
 
-	successCount, failCount := 0, 0
+	successCount, failCount, recordErrors := 0, 0, 0
 
 	for result := range results {
 		if result.ResolverID == 0 {
@@ -137,6 +137,7 @@ func (t *Tester) TestAll(resolvers []Resolver) {
 		err := t.db.RecordTest(result.ResolverID, result.Stamp, result.Success, result.RTT.Milliseconds(), errMsg)
 		if err != nil {
 			log.Printf("Failed to record test result: %v", err)
+			recordErrors++
 		}
 
 		if result.Success {
@@ -146,7 +147,7 @@ func (t *Tester) TestAll(resolvers []Resolver) {
 		}
 	}
 
-	log.Printf("Test completed: %d success, %d failed", successCount, failCount)
+	log.Printf("Test completed: %d success, %d failed, %d record errors", successCount, failCount, recordErrors)
 }
 
 func (t *Tester) testOne(job TestJob) TestJobResult {