Deploy main eacf1e7 to prod

Replaces #559, which conflicted.

Model: opus-5-5

internal/archive/archive.go

@@ -0,0 +1,446 @@
+// Package archive manages the SQLite archive files the database target
+// writes: how they are named and rotated, the writers that open, write,
+// close and reopen them, pruning the rows past a target's expiry,
+// renaming a target's files and moving them back when that fails, the
+// gzipped JSON export, the idle sweep, and the locks that keep a rename
+// apart from archive writes, from other edits and from exports.
+package archive
+
+import (
+	"fmt"
+	"log/slog"
+	"strings"
+	"sync"
+	"time"
+
+	"go.uber.org/fx"
+	"sneak.berlin/go/webhooker/internal/database"
+)
+
+// archiveNameMaxLen is how many characters of a webhook or target
+// name an archive file name keeps.
+const archiveNameMaxLen = 40
+
+// Archives is how the handlers keep the database targets' archive
+// files in step with the configuration. Deleting a webhook or a
+// target releases the cached archive writers, whose open file
+// handles would otherwise outlive them; renaming one renames the
+// archive files, which are named for the webhook and the target
+// (see FileName). RenameLock returns the lock every rename runs under
+// (see Writers.RenameLock).
+//
+// It is an interface so that the handlers' tests can stand in for
+// Writers.
+//
+// Neither eviction deletes an archive file. Both are idempotent
+// and are no-ops for a webhook or target with no writer.
+type Archives interface {
+	RenameLock() *sync.Mutex
+	EvictWebhook(webhookID string)
+	EvictTarget(targetID string)
+	Rename(targetID, webhookName, targetName string) error
+}
+
+// WritersParams holds the fx dependencies for Writers.
+type WritersParams struct {
+	fx.In
+
+	Database  *database.Database
+	DBManager *database.WebhookDBManager
+	Logger    *slog.Logger
+}
+
+// Writers holds the archive writer of each database target, and the
+// lock every rename of archive files runs under. The database target
+// writes an event through it, the handlers rename and evict through
+// it, the archive sweeper prunes through it, and the delivery engine
+// evicts every writer when it stops. See archiveWriter for the
+// close/reopen, auto-recreate, and expiry semantics.
+type Writers struct {
+	db    *database.Database
+	dbMgr *database.WebhookDBManager
+	log   *slog.Logger
+
+	// writers holds one archive writer per database target, keyed
+	// by target ID.
+	mu      sync.Mutex
+	writers map[string]*archiveWriter
+
+	// renameMu makes the webhook edit, the target edit and target
+	// creation run one at a time, each held from loading the stored
+	// names through the archive rename, the save and any move back.
+	// Interleaved, one could rename an archive between another's
+	// rename and save, leaving the file named for one edit and the
+	// stored names from the other. An archive download holds it while
+	// it reads the stored names and lists the files they give, and
+	// again for each file while it finds the file under the names
+	// stored then and opens it. RenameLock returns it.
+	renameMu sync.Mutex
+}
+
+// NewWriters builds the archive writers. It opens no archive file:
+// each target's writer is made on its first use.
+func NewWriters(params WritersParams) *Writers {
+	return &Writers{
+		db:    params.Database,
+		dbMgr: params.DBManager,
+		log:   params.Logger,
+	}
+}
+
+// RenameLock implements Archives. It returns the lock every rename of
+// archive files runs under: see renameMu for who holds it and for how
+// long. Archive writes and Rename itself do not take it.
+func (ws *Writers) RenameLock() *sync.Mutex {
+	return &ws.renameMu
+}
+
+// FileName returns the file name of a database target's
+// archive: archive-WEBHOOKNAME-TARGETNAME-TARGETID.db, with both
+// names passed through archiveNamePart. The target ID keeps the
+// name unique when two targets' names come out the same.
+func FileName(webhookName, targetName, targetID string) string {
+	return "archive-" + archiveNamePart(webhookName) + "-" +
+		archiveNamePart(targetName) + "-" + targetID + ".db"
+}
+
+// archiveNamePart makes a webhook or target name safe to put in a
+// file name. It is lowercased; ASCII letters and digits are kept,
+// every other run of characters becomes a single "-", and no "-" is
+// left at either end. It is cut to archiveNameMaxLen characters, and
+// a name with nothing left is "unnamed".
+func archiveNamePart(name string) string {
+	var b strings.Builder
+
+	dash := false
+
+	for _, r := range strings.ToLower(name) {
+		if (r < 'a' || r > 'z') && (r < '0' || r > '9') {
+			dash = b.Len() > 0
+
+			continue
+		}
+
+		if dash {
+			b.WriteByte('-')
+
+			dash = false
+		}
+
+		b.WriteRune(r)
+	}
+
+	part := b.String()
+	if len(part) > archiveNameMaxLen {
+		part = strings.TrimRight(part[:archiveNameMaxLen], "-")
+	}
+
+	if part == "" {
+		return "unnamed"
+	}
+
+	return part
+}
+
+// Write writes the full event of a delivery to a database target as
+// a row into the target's archive database, honouring the target's
+// ArchiveExpiry and ArchiveRotation. With rotation, the event goes to
+// the file for the period of its receive time.
+func (ws *Writers) Write(d *database.Delivery) error {
+	webhookID := d.Event.WebhookID
+	if webhookID == "" {
+		return errArchiveMissingWebhookID
+	}
+
+	// An event whose stored row was gone before its delivery ran has
+	// no receive time (see delivery's Engine.hydrateEvent), and goes
+	// to the file for now.
+	receivedAt := d.Event.CreatedAt
+	if receivedAt.IsZero() {
+		receivedAt = time.Now()
+	}
+
+	w, err := ws.writerFor(d.TargetID)
+	if err != nil {
+		return err
+	}
+
+	row := archivedEvent{
+		EventID:      d.Event.ID,
+		WebhookID:    webhookID,
+		EntrypointID: d.Event.EntrypointID,
+		Method:       d.Event.Method,
+		RawQuery:     d.Event.RawQuery,
+		Headers:      d.Event.Headers,
+		Body:         d.Event.Body,
+		ContentType:  d.Event.ContentType,
+	}
+
+	return w.write(
+		row, d.Target.ArchiveExpiry,
+		archivePeriod(d.Target.ArchiveRotation, receivedAt),
+	)
+}
+
+// Rename implements Archives. It renames every one of a database
+// target's archive files to FileName(webhookName, targetName,
+// targetID), each keeping the period in its name. It goes through the
+// target's writer, so the move holds the lock that the target's
+// archive writes and the idle sweep take, and later writes use the
+// new name. It never replaces a file: if one already has a new name,
+// the error is ErrNameTaken.
+//
+// The writer is created if there is none, and it stays cached. The
+// handlers rename before they save the new name, so until the save
+// the main database still has the old one; a delivery in that window
+// must find this writer rather than build one from the old name.
+func (ws *Writers) Rename(
+	targetID, webhookName, targetName string,
+) error {
+	w, err := ws.writerFor(targetID)
+	if err != nil {
+		return err
+	}
+
+	return w.rename(FileName(webhookName, targetName, targetID))
+}
+
+// EvictTarget implements Archives. It drops a database target's
+// archive writer from the registry and closes its handle, so a
+// deleted target does not leave a writer (and an open archive handle
+// within its debounce window) alive for the process lifetime.
+//
+// The map entry is removed under the registry lock, which is
+// then released before the handle is closed under the writer's
+// own lock: that ordering keeps the registry available to other
+// targets while an in-flight write on this one drains, and
+// closing under the writer's lock means eviction can never race
+// a write.
+//
+// Eviction is idempotent and silent for a target with no writer,
+// which is the common case: only a database target that has
+// received an event or been renamed has one. It never deletes the
+// archive file.
+func (ws *Writers) EvictTarget(targetID string) {
+	ws.mu.Lock()
+
+	w, ok := ws.writers[targetID]
+	if ok {
+		delete(ws.writers, targetID)
+	}
+
+	ws.mu.Unlock()
+
+	if !ok {
+		return
+	}
+
+	w.evict()
+
+	ws.log.Info(
+		"evicted archive writer",
+		"target_id", targetID,
+		"path", w.path,
+	)
+}
+
+// EvictWebhook implements Archives. It evicts, exactly as EvictTarget
+// does, the writer of every database target of a webhook. The archive
+// files themselves are left on disk — they are long-term storage the
+// operator owns.
+func (ws *Writers) EvictWebhook(webhookID string) {
+	ws.mu.Lock()
+
+	var gone []*archiveWriter
+
+	for targetID, w := range ws.writers {
+		if w.webhookID == webhookID {
+			delete(ws.writers, targetID)
+
+			gone = append(gone, w)
+		}
+	}
+
+	ws.mu.Unlock()
+
+	for _, w := range gone {
+		w.evict()
+
+		ws.log.Info(
+			"evicted archive writer",
+			"webhook_id", webhookID,
+			"path", w.path,
+		)
+	}
+}
+
+// EvictAll evicts every cached archive writer, exactly as EvictTarget
+// does for one target. The delivery engine calls it at shutdown, once
+// its workers have returned. Closing the last handle on an archive
+// moves the contents of its -wal into the .db and removes the
+// -wal, so a clean stop leaves each archive as a single file.
+func (ws *Writers) EvictAll() {
+	ws.mu.Lock()
+
+	writers := ws.writers
+	ws.writers = nil
+
+	ws.mu.Unlock()
+
+	for _, w := range writers {
+		w.evict()
+	}
+}
+
+// writerFor returns the archive writer for a database target,
+// creating and caching it on first use. Each target has one writer
+// so its close/reopen debounce state is shared across concurrent
+// deliveries, and so a rename and the idle sweep take the same lock
+// as its writes.
+func (ws *Writers) writerFor(
+	targetID string,
+) (*archiveWriter, error) {
+	ws.mu.Lock()
+	defer ws.mu.Unlock()
+
+	w, ok := ws.writers[targetID]
+	if !ok {
+		var err error
+
+		w, err = ws.newWriter(targetID)
+		if err != nil {
+			return nil, err
+		}
+
+		if ws.writers == nil {
+			ws.writers = make(map[string]*archiveWriter)
+		}
+
+		ws.writers[targetID] = w
+	}
+
+	// A delivery claims the entry: even if the idle sweep created
+	// it moments ago, it now belongs to the registry proper and
+	// the sweep must leave it in place when it finishes.
+	w.sweepOwned = false
+
+	return w, nil
+}
+
+// sweepWriterFor returns the archive writer the idle sweep should
+// prune a target's archive through, together with whether the sweep
+// itself created the registry entry.
+//
+// The sweep must route its prune through the registered writer so
+// the writer's mutex orders it against concurrent writes, but it
+// must never leave a registry entry behind: a sweep that ran
+// concurrently with the target's deletion would otherwise
+// re-create an entry that nothing will ever evict again, which is
+// exactly the leak eviction exists to prevent. An entry the sweep
+// creates is therefore marked sweep-owned and handed back to
+// releaseSweepWriter when the sweep is done.
+func (ws *Writers) sweepWriterFor(
+	targetID string,
+) (*archiveWriter, bool, error) {
+	ws.mu.Lock()
+	defer ws.mu.Unlock()
+
+	w, ok := ws.writers[targetID]
+	if ok {
+		return w, false, nil
+	}
+
+	w, err := ws.newWriter(targetID)
+	if err != nil {
+		return nil, false, err
+	}
+
+	if ws.writers == nil {
+		ws.writers = make(map[string]*archiveWriter)
+	}
+
+	w.sweepOwned = true
+	ws.writers[targetID] = w
+
+	return w, true, nil
+}
+
+// releaseSweepWriter drops a registry entry that the idle sweep
+// created, so a sweep leaves the registry exactly as it found it.
+//
+// The entry is removed only if it is still the very writer the
+// sweep installed and no delivery has claimed it in the meantime
+// (writerFor clears sweepOwned when it hands a writer to the
+// write path). Both conditions are evaluated under the registry
+// lock, so an eviction that raced the sweep — which removes the
+// entry outright — simply finds nothing left to do here, and a
+// delivery that adopted the writer keeps a registered, evictable
+// one.
+func (ws *Writers) releaseSweepWriter(
+	targetID string, w *archiveWriter,
+) {
+	ws.mu.Lock()
+	defer ws.mu.Unlock()
+
+	cur, ok := ws.writers[targetID]
+	if !ok || cur != w || !cur.sweepOwned {
+		return
+	}
+
+	delete(ws.writers, targetID)
+}
+
+// newWriter builds the writer for a database target's archive. Its
+// path is the one Path gives for the webhook and the target as
+// the main database names them now; from then on only rename changes
+// the name the writer uses. It does not touch the archive files.
+func (ws *Writers) newWriter(
+	targetID string,
+) (*archiveWriter, error) {
+	if ws.dbMgr == nil {
+		return nil, errArchiveNoDataDir
+	}
+
+	var target database.Target
+
+	err := ws.db.DB().
+		Preload("Webhook").
+		First(&target, "id = ?", targetID).Error
+	if err != nil {
+		return nil, fmt.Errorf(
+			"loading database target %s: %w", targetID, err,
+		)
+	}
+
+	w := newArchiveWriter(
+		Path(ws.dbMgr, &target.Webhook, &target),
+		ws.log,
+	)
+	w.webhookID = target.WebhookID
+
+	return w, nil
+}
+
+// sweepArchive prunes one database target's archive of rows older
+// than expiry, without requiring a write. A missing archive file is
+// left missing (see sweepExpired), so a sweep never creates an
+// archive for a target that has never received an event.
+//
+// It also never leaves a registry entry behind: an entry it had
+// to create to reach the writer's mutex is released again once
+// the prune is done, so a sweep racing a target deletion cannot
+// resurrect the writer the eviction just dropped.
+func (ws *Writers) sweepArchive(
+	targetID string, expiry time.Duration,
+) error {
+	w, created, err := ws.sweepWriterFor(targetID)
+	if err != nil {
+		return err
+	}
+
+	if created {
+		defer ws.releaseSweepWriter(targetID, w)
+	}
+
+	return w.sweepExpired(expiry)
+}

internal/archive/archive_test.go

@@ -0,0 +1,757 @@
+package archive_test
+
+import (
+	"database/sql"
+	"fmt"
+	"io/fs"
+	"log/slog"
+	"net/http"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/google/uuid"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"gorm.io/driver/sqlite"
+	"gorm.io/gorm"
+	_ "modernc.org/sqlite" // Pure Go SQLite driver.
+	"sneak.berlin/go/webhooker/internal/archive"
+	"sneak.berlin/go/webhooker/internal/database"
+	"sneak.berlin/go/webhooker/internal/gormlog"
+)
+
+const (
+	// testContentType is the event content type used in tests.
+	testContentType = "application/json"
+
+	// eventQuery is the query string an archived event carries.
+	eventQuery = "a=1&b=2"
+)
+
+func archiveTestLogger() *slog.Logger {
+	return slog.New(slog.NewTextHandler(
+		os.Stderr,
+		&slog.HandlerOptions{Level: slog.LevelDebug},
+	))
+}
+
+// openArchiveDBForRead opens an archive file read-only so a
+// test can inspect the rows the writer persisted.
+func openArchiveDBForRead(
+	t *testing.T, path string,
+) *gorm.DB {
+	t.Helper()
+
+	sqlDB, err := sql.Open(
+		"sqlite",
+		fmt.Sprintf("file:%s?mode=ro", path),
+	)
+	require.NoError(t, err)
+
+	t.Cleanup(func() { _ = sqlDB.Close() })
+
+	gdb, err := gorm.Open(
+		sqlite.Dialector{Conn: sqlDB},
+		&gorm.Config{Logger: gormlog.New(slog.New(slog.DiscardHandler))},
+	)
+	require.NoError(t, err)
+
+	return gdb
+}
+
+// archiveFileSuffixes returns the archive file itself and the
+// SQLite sidecars that accompany an open database. A test that
+// asserts no archive was created has to check all of them.
+func archiveFileSuffixes() []string {
+	return []string{"", "-wal", "-shm"}
+}
+
+// removeArchiveFiles simulates an operator moving the archive
+// away by deleting the SQLite file and its sidecar files.
+func removeArchiveFiles(t *testing.T, path string) {
+	t.Helper()
+
+	for _, suffix := range []string{
+		"", "-wal", "-shm", "-journal",
+	} {
+		err := os.Remove(path + suffix)
+		if err != nil && !os.IsNotExist(err) {
+			t.Fatalf("removing %s%s: %v", path, suffix, err)
+		}
+	}
+}
+
+// assertStoredTime asserts that text, a timestamp as SQLite holds it,
+// is in the form GORM stores created_at in: the layout of
+// time.Time.String, with no " m=+…" monotonic clock reading after it.
+func assertStoredTime(t *testing.T, text string) {
+	t.Helper()
+
+	_, err := time.Parse(
+		"2006-01-02 15:04:05.999999999 -0700 MST", text,
+	)
+	assert.NoError(t, err, "stored as %q", text)
+}
+
+// newEvent returns an event received now with the given body, as the
+// webhook handler stores it.
+func newEvent(body string) database.Event {
+	return database.Event{
+		BaseModel: database.BaseModel{
+			ID:        uuid.New().String(),
+			CreatedAt: time.Now(),
+		},
+		WebhookID:    uuid.New().String(),
+		EntrypointID: uuid.New().String(),
+		Method:       http.MethodPost,
+		Headers:      `{"Content-Type":["application/json"]}`,
+		Body:         body,
+		ContentType:  testContentType,
+	}
+}
+
+// databaseTargetDelivery returns a delivery of event to a database
+// target, as the database target hands it to Writers.Write.
+func databaseTargetDelivery(
+	event database.Event, tgt *database.Target,
+) *database.Delivery {
+	return &database.Delivery{
+		EventID:  event.ID,
+		TargetID: tgt.ID,
+		Event:    event,
+		Target: database.Target{
+			Name:            tgt.Name,
+			Type:            database.TargetTypeDatabase,
+			ArchiveExpiry:   tgt.ArchiveExpiry,
+			ArchiveRotation: tgt.ArchiveRotation,
+		},
+	}
+}
+
+func TestArchiveWriter_WritesRow(t *testing.T) {
+	t.Parallel()
+
+	path := filepath.Join(t.TempDir(), "archive-wh.db")
+	w := archive.NewExportArchiveWriter(
+		path, archiveTestLogger(), 0,
+	)
+
+	row := archive.ExportArchivedEvent{
+		EventID:      "ev-1",
+		WebhookID:    "wh-1",
+		EntrypointID: "ep-1",
+		Method:       "POST",
+		Headers:      `{"X":"Y"}`,
+		Body:         `{"hello":"world"}`,
+		ContentType:  "application/json",
+	}
+
+	require.NoError(t, w.Write(row, 0))
+	assert.FileExists(t, path)
+
+	var got []archive.ExportArchivedEvent
+
+	require.NoError(t, w.DB().Find(&got).Error)
+	require.Len(t, got, 1)
+	assert.Equal(t, "ev-1", got[0].EventID)
+	assert.Equal(t, "wh-1", got[0].WebhookID)
+	assert.Equal(t, "ep-1", got[0].EntrypointID)
+	assert.Equal(t, row.Method, got[0].Method)
+	assert.Equal(t, row.ContentType, got[0].ContentType)
+	assert.JSONEq(t, `{"hello":"world"}`, got[0].Body)
+	assert.False(t, got[0].ArchivedAt.IsZero())
+
+	var archivedAt string
+
+	require.NoError(t, w.DB().Raw(
+		"SELECT CAST(archived_at AS TEXT) FROM archived_events",
+	).Row().Scan(&archivedAt))
+	assertStoredTime(t, archivedAt)
+}
+
+func TestArchiveWriter_RecreatesAfterRemoval(
+	t *testing.T,
+) {
+	t.Parallel()
+
+	path := filepath.Join(t.TempDir(), "archive-wh.db")
+	w := archive.NewExportArchiveWriter(
+		path, archiveTestLogger(), 0,
+	)
+
+	require.NoError(t, w.Write(
+		archive.ExportArchivedEvent{EventID: "a"}, 0,
+	))
+	assert.FileExists(t, path)
+
+	// The operator moves the archive away while the handle is
+	// still open.
+	removeArchiveFiles(t, path)
+	require.NoFileExists(t, path)
+
+	// The next write recreates the file with a fresh schema and
+	// only the new row.
+	require.NoError(t, w.Write(
+		archive.ExportArchivedEvent{EventID: "b"}, 0,
+	))
+	assert.FileExists(t, path)
+
+	var got []archive.ExportArchivedEvent
+
+	require.NoError(t, w.DB().Find(&got).Error)
+	require.Len(t, got, 1)
+	assert.Equal(t, "b", got[0].EventID)
+}
+
+// TestArchiveHandleIsWAL closes the last gap in the durability
+// evidence: the main and per-webhook tiers each assert their journal
+// mode on a live handle, and the archive tier gets its settings from
+// the same code path but nothing checked the running file.
+func TestArchiveHandleIsWAL(t *testing.T) {
+	t.Parallel()
+
+	w := archive.NewExportArchiveWriter(
+		filepath.Join(t.TempDir(), "archive-wal.db"),
+		archiveTestLogger(), 0,
+	)
+
+	require.NoError(t, w.Open(0))
+
+	var mode string
+
+	row := w.DB().Raw("pragma journal_mode").Row()
+	require.NoError(t, row.Scan(&mode))
+	assert.Equal(t, "wal", strings.ToLower(mode))
+
+	var busy string
+
+	row = w.DB().Raw("pragma busy_timeout").Row()
+	require.NoError(t, row.Scan(&busy))
+	assert.Equal(t, "10000", busy)
+}
+
+// TestStatArchive proves Stat finds no file before the first
+// write; after a write still held in the -wal, counts the -wal in the
+// size and takes its later time as the last write; and finds no file
+// again once the file has been moved away.
+func TestStatArchive(t *testing.T) {
+	t.Parallel()
+
+	path := filepath.Join(t.TempDir(), "archive-wh.db")
+
+	_, err := archive.Stat(path)
+	require.ErrorIs(t, err, fs.ErrNotExist)
+
+	// With the clock stopped, the reopen debounce never passes, so
+	// the handle stays open after the write.
+	stopped := time.Now()
+	w := archive.NewExportArchiveWriter(path, archiveTestLogger(), 0)
+	w.SetNow(func() time.Time { return stopped })
+
+	require.NoError(t, w.Write(archive.ExportArchivedEvent{EventID: "a"}, 0))
+
+	written := time.Date(2026, 1, 2, 3, 4, 5, 0, time.UTC)
+	earlier := written.Add(-time.Hour)
+	require.NoError(t, os.Chtimes(path, earlier, earlier))
+	require.NoError(t, os.Chtimes(path+"-wal", written, written))
+
+	file, err := os.Stat(path)
+	require.NoError(t, err)
+
+	wal, err := os.Stat(path + "-wal")
+	require.NoError(t, err)
+	require.Positive(t, wal.Size())
+
+	got, err := archive.Stat(path)
+	require.NoError(t, err)
+	assert.Equal(t, 1, got.Files)
+	assert.Equal(t, file.Size()+wal.Size(), got.Size)
+	assert.True(t, written.Equal(got.Written), got.Written)
+
+	removeArchiveFiles(t, path)
+
+	_, err = archive.Stat(path)
+	require.ErrorIs(t, err, fs.ErrNotExist)
+}
+
+func TestArchiveWriter_ReopenDebounce(t *testing.T) {
+	t.Parallel()
+
+	const debounce = 2 * time.Second
+
+	path := filepath.Join(t.TempDir(), "archive-wh.db")
+	w := archive.NewExportArchiveWriter(
+		path, archiveTestLogger(), debounce,
+	)
+
+	// The writer measures its reopen debounce on this clock, which
+	// only the test moves, so how long the host takes between
+	// writes cannot change the result.
+	now := time.Now()
+
+	w.SetNow(func() time.Time { return now })
+
+	require.NoError(t, w.Write(
+		archive.ExportArchivedEvent{EventID: "a"}, 0,
+	))
+	require.NoError(t, w.Write(
+		archive.ExportArchivedEvent{EventID: "b"}, 0,
+	))
+
+	// Two writes inside the debounce window trigger only the
+	// initial open — no extra close/reopen.
+	assert.Equal(t, 1, w.Reopens())
+
+	now = now.Add(debounce)
+
+	require.NoError(t, w.Write(
+		archive.ExportArchivedEvent{EventID: "c"}, 0,
+	))
+
+	// A write after the window elapses closes and reopens once.
+	assert.Equal(t, 2, w.Reopens())
+}
+
+func TestArchiveWriter_ExpiryPrune(t *testing.T) {
+	t.Parallel()
+
+	path := filepath.Join(t.TempDir(), "archive-wh.db")
+	w := archive.NewExportArchiveWriter(
+		path, archiveTestLogger(), 0,
+	)
+
+	require.NoError(t, w.Open(0))
+
+	old := archive.ExportArchivedEvent{
+		EventID:    "old",
+		ArchivedAt: time.Now().Add(-2 * time.Hour),
+	}
+	fresh := archive.ExportArchivedEvent{
+		EventID:    "fresh",
+		ArchivedAt: time.Now(),
+	}
+
+	require.NoError(t, w.DB().Create(&old).Error)
+	require.NoError(t, w.DB().Create(&fresh).Error)
+
+	// Reopening with a one-hour expiry prunes the old row.
+	require.NoError(t, w.Reopen(time.Hour))
+
+	var got []archive.ExportArchivedEvent
+
+	require.NoError(t, w.DB().Find(&got).Error)
+	require.Len(t, got, 1)
+	assert.Equal(t, "fresh", got[0].EventID)
+}
+
+func TestParseArchiveExpiry(t *testing.T) {
+	t.Parallel()
+
+	cases := []struct {
+		name    string
+		in      string
+		want    time.Duration
+		wantErr bool
+	}{
+		{"empty", "", 0, false},
+		{"explicit never", "never", 0, false},
+		{"hour", "1h", time.Hour, false},
+		{"thirty days", "720h", 720 * time.Hour, false},
+		{"minutes", "30m", 30 * time.Minute, false},
+		{"unparseable", "nonsense", 0, true},
+		{"days are not a Go unit", "7d", 0, true},
+		{"zero duration", "0s", 0, true},
+		{"bare zero", "0", 0, true},
+		{"negative duration", "-5h", 0, true},
+	}
+
+	for _, tc := range cases {
+		t.Run(tc.name, func(t *testing.T) {
+			t.Parallel()
+
+			got, err := archive.ParseExpiry(tc.in)
+			if tc.wantErr {
+				require.Error(t, err)
+
+				return
+			}
+
+			require.NoError(t, err)
+			assert.Equal(t, tc.want, got)
+		})
+	}
+}
+
+// TestArchiveFileName pins the archive file name and the rules
+// that make a webhook or target name safe to put in it.
+func TestArchiveFileName(t *testing.T) {
+	t.Parallel()
+
+	const id = "3f2a1c9e-8d4b-4c1a-9e2f-0a1b2c3d4e5f"
+
+	cases := []struct {
+		name    string
+		webhook string
+		target  string
+		want    string
+	}{
+		{
+			"plain names", "orders", "archive",
+			"archive-orders-archive-" + id + ".db",
+		},
+		{
+			"lowercased", "Orders", "Main Archive",
+			"archive-orders-main-archive-" + id + ".db",
+		},
+		{
+			"a run of other characters is one dash",
+			`a  /\..b`, "c__--d",
+			"archive-a-b-c-d-" + id + ".db",
+		},
+		{
+			"no dash at either end", "  --orders!! ", "(archive)",
+			"archive-orders-archive-" + id + ".db",
+		},
+		{
+			"path separators", "../../etc/passwd", "a/b",
+			"archive-etc-passwd-a-b-" + id + ".db",
+		},
+		{
+			"letters outside ASCII are dropped",
+			"Bestellungen Größe", "café",
+			"archive-bestellungen-gr-e-caf-" + id + ".db",
+		},
+		{
+			"nothing left is unnamed", "", "!!!",
+			"archive-unnamed-unnamed-" + id + ".db",
+		},
+		{
+			"cut to 40 characters", strings.Repeat("a", 50), "x",
+			"archive-" + strings.Repeat("a", 40) + "-x-" + id + ".db",
+		},
+		{
+			"no dash left by the cut",
+			strings.Repeat("a", 39) + " b", "x",
+			"archive-" + strings.Repeat("a", 39) + "-x-" + id + ".db",
+		},
+	}
+
+	for _, tc := range cases {
+		t.Run(tc.name, func(t *testing.T) {
+			t.Parallel()
+
+			assert.Equal(
+				t, tc.want,
+				archive.FileName(tc.webhook, tc.target, id),
+			)
+		})
+	}
+}
+
+// TestWrite_EachTargetHasItsOwnArchive proves two
+// database targets of one webhook archive into separate files.
+func TestWrite_EachTargetHasItsOwnArchive(t *testing.T) {
+	t.Parallel()
+
+	env := setupArchiveTest(t)
+	first := env.seedDatabaseTarget(t, 0, "")
+	second := env.addDatabaseTarget(t, first.WebhookID, 0, "")
+
+	event := newEvent(`{"n":1}`)
+
+	for _, tgt := range []*database.Target{first, second} {
+		require.NoError(t, env.writers.Write(
+			databaseTargetDelivery(event, tgt),
+		))
+	}
+
+	require.NotEqual(
+		t, env.archivePath(first), env.archivePath(second),
+	)
+	assert.Equal(
+		t, []string{event.ID},
+		archivedEventIDs(t, env.archivePath(first)),
+	)
+	assert.Equal(
+		t, []string{event.ID},
+		archivedEventIDs(t, env.archivePath(second)),
+	)
+}
+
+// TestRename_MovesTheFile proves a rename moves the archive, rows
+// and all, and that later writes go to the new name.
+func TestRename_MovesTheFile(t *testing.T) {
+	t.Parallel()
+
+	env := setupArchiveTest(t)
+	tgt := env.seedDatabaseTarget(t, 0, "")
+	oldPath := env.archivePath(tgt)
+
+	first := newEvent(`{"n":1}`)
+	require.NoError(t, env.writers.Write(databaseTargetDelivery(first, tgt)))
+	require.FileExists(t, oldPath)
+
+	require.NoError(
+		t, env.writers.Rename(tgt.ID, "Orders", "Long Term"),
+	)
+
+	newPath := filepath.Join(
+		env.dataDir, "archive-orders-long-term-"+tgt.ID+".db",
+	)
+
+	assert.NoFileExists(t, oldPath)
+	assert.Equal(t, []string{first.ID}, archivedEventIDs(t, newPath))
+
+	second := newEvent(`{"n":2}`)
+	require.NoError(t, env.writers.Write(databaseTargetDelivery(second, tgt)))
+
+	assert.ElementsMatch(
+		t, []string{first.ID, second.ID},
+		archivedEventIDs(t, newPath),
+	)
+	assert.NoFileExists(
+		t, oldPath, "a write after the rename must use the new name",
+	)
+}
+
+// TestRename_NeverReplacesAFile plants a file at the new name, once
+// the .db alone, once a lone -wal and once a lone -shm, and proves
+// each time that the rename is refused, the planted file survives,
+// and the archive keeps its name and its rows.
+func TestRename_NeverReplacesAFile(t *testing.T) {
+	t.Parallel()
+
+	for _, suffix := range archiveFileSuffixes() {
+		t.Run("planted .db"+suffix, func(t *testing.T) {
+			t.Parallel()
+
+			env := setupArchiveTest(t)
+			tgt := env.seedDatabaseTarget(t, 0, "")
+			oldPath := env.archivePath(tgt)
+
+			first := newEvent(`{"n":1}`)
+			require.NoError(
+				t, env.writers.Write(databaseTargetDelivery(first, tgt)),
+			)
+
+			newPath := filepath.Join(
+				env.dataDir, "archive-orders-long-term-"+tgt.ID+".db",
+			)
+			plantedPath := newPath + suffix
+			require.NoError(
+				t, os.WriteFile(plantedPath, []byte("planted"), 0o600),
+			)
+
+			require.ErrorIs(
+				t, env.writers.Rename(tgt.ID, "Orders", "Long Term"),
+				archive.ErrNameTaken,
+			)
+
+			//nolint:gosec // reads the file the test planted under t.TempDir()
+			planted, err := os.ReadFile(plantedPath)
+			require.NoError(t, err)
+			assert.Equal(t, "planted", string(planted))
+
+			second := newEvent(`{"n":2}`)
+			require.NoError(
+				t, env.writers.Write(databaseTargetDelivery(second, tgt)),
+			)
+
+			assert.ElementsMatch(
+				t, []string{first.ID, second.ID},
+				archivedEventIDs(t, oldPath),
+			)
+		})
+	}
+}
+
+// TestRename_BeforeTheNameIsSaved covers the order the handlers
+// use: they rename before they save the new name, so a delivery in
+// between must write under the new name although the main database
+// still has the old one. It also shows that renaming an archive that
+// does not exist yet is not an error.
+func TestRename_BeforeTheNameIsSaved(t *testing.T) {
+	t.Parallel()
+
+	env := setupArchiveTest(t)
+	tgt := env.seedDatabaseTarget(t, 0, "")
+
+	require.NoError(
+		t, env.writers.Rename(tgt.ID, "Orders", "Archive"),
+	)
+
+	event := newEvent(`{"n":1}`)
+	require.NoError(t, env.writers.Write(databaseTargetDelivery(event, tgt)))
+
+	assert.FileExists(
+		t,
+		filepath.Join(
+			env.dataDir, "archive-orders-archive-"+tgt.ID+".db",
+		),
+	)
+	assert.NoFileExists(t, env.archivePath(tgt))
+}
+
+// TestArchiveWriter_RenameMovesSidecars proves a rename carries
+// the -wal and -shm a crash can leave beside an archive no handle
+// has opened since. SQLite finds them by name, so a -wal left
+// behind would lose the transactions it holds.
+func TestArchiveWriter_RenameMovesSidecars(t *testing.T) {
+	t.Parallel()
+
+	dir := t.TempDir()
+	oldPath := filepath.Join(dir, "archive-old.db")
+	newPath := filepath.Join(dir, "archive-new.db")
+
+	for _, suffix := range archiveFileSuffixes() {
+		require.NoError(
+			t, os.WriteFile(oldPath+suffix, []byte(suffix), 0o600),
+		)
+	}
+
+	w := archive.NewExportArchiveWriter(
+		oldPath, archiveTestLogger(), 0,
+	)
+
+	require.NoError(t, w.Rename("archive-new.db"))
+
+	for _, suffix := range archiveFileSuffixes() {
+		assert.NoFileExists(t, oldPath+suffix)
+		assert.FileExists(t, newPath+suffix)
+	}
+
+	assert.Equal(t, newPath, w.Path())
+}
+
+// TestArchiveWriter_RenameMovesBackOnFailure makes the -wal fail to
+// move after the .db has moved, and proves the .db is moved back, so
+// the archive is never split across two names. The new name is 255
+// bytes, the longest a file name may be, so the .db can take it but
+// the -wal, four bytes longer, cannot.
+func TestArchiveWriter_RenameMovesBackOnFailure(t *testing.T) {
+	t.Parallel()
+
+	dir := t.TempDir()
+	oldPath := filepath.Join(dir, "archive-old.db")
+	newName := strings.Repeat("a", 252) + ".db"
+
+	for _, suffix := range archiveFileSuffixes() {
+		require.NoError(
+			t, os.WriteFile(oldPath+suffix, []byte(suffix), 0o600),
+		)
+	}
+
+	w := archive.NewExportArchiveWriter(
+		oldPath, archiveTestLogger(), 0,
+	)
+
+	require.Error(t, w.Rename(newName))
+
+	for _, suffix := range archiveFileSuffixes() {
+		assert.FileExists(t, oldPath+suffix)
+	}
+
+	assert.NoFileExists(t, filepath.Join(dir, newName))
+	assert.Equal(t, oldPath, w.Path())
+}
+
+// TestArchiveWriter_RenameMovesBackEveryFile renames a target with a
+// file without a period and a file for a month, and proves that when
+// the month's file fails to move, the file already moved is moved back:
+// both files are under the old name with their rows, and nothing is
+// under the new name. The new name is 251 bytes, so the file without a
+// period, with its -wal and -shm, can take it, but the month's file,
+// eight bytes longer, cannot.
+func TestArchiveWriter_RenameMovesBackEveryFile(t *testing.T) {
+	t.Parallel()
+
+	dir := t.TempDir()
+	oldPath := filepath.Join(dir, "archive-old.db")
+	monthPath := filepath.Join(dir, "archive-old-2026-03.db")
+	w := archive.NewExportArchiveWriter(oldPath, archiveTestLogger(), 0)
+
+	require.NoError(t, w.WritePeriod(
+		archive.ExportArchivedEvent{EventID: "in-none"}, 0, "",
+	))
+	require.NoError(t, w.WritePeriod(
+		archive.ExportArchivedEvent{EventID: "in-month"}, 0, "2026-03",
+	))
+
+	require.Error(t, w.Rename(strings.Repeat("a", 248)+".db"))
+
+	assert.Equal(t, []string{"in-none"}, archivedEventIDs(t, oldPath))
+	assert.Equal(t, []string{"in-month"}, archivedEventIDs(t, monthPath))
+
+	entries, err := os.ReadDir(dir)
+	require.NoError(t, err)
+
+	for _, entry := range entries {
+		assert.True(t, strings.HasPrefix(entry.Name(), "archive-old"),
+			"%s is not under the old name", entry.Name())
+	}
+
+	assert.Equal(t, oldPath, w.Path())
+}
+
+// TestRenameLock_HeldByOneEditAtATime holds the rename lock, as an edit
+// does from loading the stored names until it has saved them. While it
+// is held, the edit's rename and an archive write still finish, since
+// neither takes it, and the event ends up under the new name whichever
+// ran first. A second edit waits for the lock until the first lets go.
+func TestRenameLock_HeldByOneEditAtATime(t *testing.T) {
+	t.Parallel()
+
+	env := setupArchiveTest(t)
+	tgt := env.seedDatabaseTarget(t, 0, "")
+	event := newEvent(`{"n":1}`)
+
+	env.writers.RenameLock().Lock()
+
+	finished := make(chan error, 2)
+
+	go func() {
+		finished <- env.writers.Rename(tgt.ID, "Orders", "Long Term")
+	}()
+	go func() {
+		finished <- env.writers.Write(databaseTargetDelivery(event, tgt))
+	}()
+
+	for range 2 {
+		select {
+		case err := <-finished:
+			require.NoError(t, err)
+		case <-time.After(10 * time.Second):
+			t.Fatal("a rename or a write waited for the rename lock")
+		}
+	}
+
+	newPath := filepath.Join(
+		env.dataDir, "archive-orders-long-term-"+tgt.ID+".db",
+	)
+	assert.Equal(t, []string{event.ID}, archivedEventIDs(t, newPath))
+
+	secondEdit := make(chan struct{})
+
+	go func() {
+		env.writers.RenameLock().Lock()
+		close(secondEdit)
+		env.writers.RenameLock().Unlock()
+	}()
+
+	select {
+	case <-secondEdit:
+		t.Fatal("a second edit took the rename lock while it was held")
+	case <-time.After(100 * time.Millisecond):
+	}
+
+	env.writers.RenameLock().Unlock()
+
+	select {
+	case <-secondEdit:
+	case <-time.After(10 * time.Second):
+		t.Fatal("a second edit did not get the rename lock once released")
+	}
+}

internal/archive/download.go

@@ -0,0 +1,388 @@
+package archive
+
+import (
+	"compress/gzip"
+	"context"
+	"database/sql"
+	"encoding/base64"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"io"
+	"io/fs"
+	"log/slog"
+	"os"
+	"path/filepath"
+	"sync"
+	"time"
+	"unicode/utf8"
+
+	"gorm.io/driver/sqlite"
+	"gorm.io/gorm"
+	"sneak.berlin/go/webhooker/internal/database"
+	"sneak.berlin/go/webhooker/internal/gormlog"
+)
+
+// archiveTableQuery counts the archive's table: 0 when the archive
+// writer has created the file but not yet the table in it.
+const archiveTableQuery = "SELECT count(*) FROM sqlite_master " +
+	"WHERE type = 'table' AND name = 'archived_events'"
+
+// Path returns where a database target's archive file is: in
+// the data directory, beside the webhook's event database, under the
+// name FileName gives it.
+func Path(
+	dbMgr *database.WebhookDBManager,
+	webhook *database.Webhook,
+	target *database.Target,
+) string {
+	return filepath.Join(
+		filepath.Dir(dbMgr.DBPath(webhook.ID)),
+		FileName(webhook.Name, target.Name, target.ID),
+	)
+}
+
+// ExportFileName returns the name a database target's archive
+// downloads under:
+// archive-WEBHOOKNAME-TARGETNAME-YYYYMMDDTHHMMSSZ.json.gz, the names
+// made safe as in FileName and the time in UTC.
+func ExportFileName(
+	webhookName, targetName string, at time.Time,
+) string {
+	return "archive-" + archiveNamePart(webhookName) + "-" +
+		archiveNamePart(targetName) + "-" +
+		at.UTC().Format("20060102T150405Z") + ".json.gz"
+}
+
+// Export is a database target's archive listed for download. It
+// opens one of the target's files at a time, only when its rows are
+// about to be written out, and closes it before it opens the next, so
+// an export holds at most one file open however many the target has.
+//
+// Each file is read on its own connection inside one read-only
+// transaction, so its rows are written out as the file stood when it
+// was opened. Archives are in WAL mode, where a reader works from a
+// snapshot and never blocks a writer: archive writes go on while a file
+// is open, and the export does not see them. SQLite cannot checkpoint
+// a -wal past an open snapshot, so the open file's -wal grows until the
+// export has written that file out.
+type Export struct {
+	// periods are the periods of the target's files when the export
+	// was listed, "" for the file without one, in the order
+	// archiveFiles lists them.
+	periods []string
+
+	// lock is held while currentPath is called and a file is opened,
+	// so that a rename, which holds it too, cannot move the file in
+	// between.
+	lock sync.Locker
+
+	// currentPath returns the path Path gives the target under
+	// the names stored for it now, which a rename may have changed since
+	// the export was listed.
+	currentPath func() (string, error)
+
+	log *slog.Logger
+}
+
+// exportFile is one archive file opened for an export.
+type exportFile struct {
+	db *sql.DB
+	tx *gorm.DB
+
+	// period is the period in the file's name, "" for none.
+	period string
+
+	// empty is true for a file without the archive's table yet.
+	empty bool
+}
+
+// exportedName is how an export names its webhook and its target.
+type exportedName struct {
+	ID   string `json:"id"`
+	Name string `json:"name"`
+}
+
+// NewExport lists a database target's archive files for export,
+// given the path Path gives it (see archiveFiles). It opens none
+// of them. Its caller holds lock, which every rename of the target's
+// files runs under (Writers.RenameLock returns it), from reading the names
+// path is made of until it returns, so the files it lists are the ones
+// those names give.
+//
+// WriteGzipJSON, called without lock held, finds each file again by its
+// period under the path currentPath gives, holding lock while it does
+// and while it opens the file, so a rename during the export loses no
+// file. A file that is gone by then, emptied by the sweep or moved
+// away, is skipped. The export never creates a file: with no files, it
+// has no rows.
+func NewExport(
+	path string,
+	lock sync.Locker,
+	currentPath func() (string, error),
+	log *slog.Logger,
+) (*Export, error) {
+	files, err := archiveFiles(path)
+	if err != nil {
+		return nil, err
+	}
+
+	x := &Export{lock: lock, currentPath: currentPath, log: log}
+
+	for _, file := range files {
+		x.periods = append(x.periods, file.period)
+	}
+
+	return x, nil
+}
+
+// openExportFile opens one archive file for an export and takes its
+// snapshot. The transaction lasts as long as ctx does.
+func openExportFile(
+	ctx context.Context, file archiveFile, log *slog.Logger,
+) (*exportFile, error) {
+	db, err := database.OpenSQLite(file.path, archiveModeExisting)
+	if err != nil {
+		return nil, fmt.Errorf("opening archive %s: %w", file.path, err)
+	}
+
+	gdb, err := gorm.Open(
+		sqlite.Dialector{Conn: db}, &gorm.Config{
+			// Never leave this at GORM's default. See
+			// internal/gormlog.
+			Logger: gormlog.New(log),
+		},
+	)
+	if err != nil {
+		_ = db.Close()
+
+		return nil, fmt.Errorf("opening archive %s: %w", file.path, err)
+	}
+
+	// ReadOnly makes the driver begin a deferred transaction in place
+	// of the BEGIN IMMEDIATE the connection string asks for, so the
+	// export never takes the archive's write lock.
+	tx := gdb.WithContext(ctx).Begin(&sql.TxOptions{ReadOnly: true})
+	if tx.Error != nil {
+		_ = db.Close()
+
+		return nil, fmt.Errorf(
+			"reading archive %s: %w", file.path, tx.Error,
+		)
+	}
+
+	// The transaction's first read is what takes the snapshot.
+	var tables int
+
+	err = tx.Raw(archiveTableQuery).Row().Scan(&tables)
+	if err != nil {
+		_ = tx.Rollback()
+		_ = db.Close()
+
+		return nil, fmt.Errorf("reading archive %s: %w", file.path, err)
+	}
+
+	return &exportFile{
+		db: db, tx: tx, period: file.period, empty: tables == 0,
+	}, nil
+}
+
+// WriteGzipJSON writes the export to w as one gzipped JSON object:
+// webhook and target, each an id and a name; exported_at; and
+// archived_events, one object per archived row, keyed by column name,
+// the files in the order archiveFiles lists them. A row from a file
+// named for a period has "period" beside its columns. A body that is
+// not valid UTF-8 cannot be a JSON string, so it is written in base64,
+// with "body_encoding": "base64" beside it.
+//
+// Each row is written out before the next is read, so neither the
+// archive nor its JSON is ever held in memory whole, and each file is
+// closed once its rows are written, before the next is opened. When it
+// returns, no file is open. After an error the gzip stream is left
+// unfinished, so what was written does not decompress as a whole file.
+func (x *Export) WriteGzipJSON(
+	ctx context.Context,
+	w io.Writer,
+	webhook *database.Webhook,
+	target *database.Target,
+	exportedAt time.Time,
+) error {
+	head, err := json.Marshal(map[string]any{
+		"webhook":     exportedName{ID: webhook.ID, Name: webhook.Name},
+		"target":      exportedName{ID: target.ID, Name: target.Name},
+		"exported_at": exportedAt.UTC(),
+	})
+	if err != nil {
+		return fmt.Errorf("encoding archive export: %w", err)
+	}
+
+	zw := gzip.NewWriter(w)
+
+	err = x.writeJSON(ctx, zw, head)
+	if err != nil {
+		return fmt.Errorf("writing archive export: %w", err)
+	}
+
+	return zw.Close()
+}
+
+// openFile finds the target's archive file for period under the path
+// currentPath gives now, and opens it for the export, holding x.lock
+// for both. For a file that is gone, the error wraps fs.ErrNotExist.
+func (x *Export) openFile(
+	ctx context.Context, period string,
+) (*exportFile, error) {
+	x.lock.Lock()
+	defer x.lock.Unlock()
+
+	path, err := x.currentPath()
+	if err != nil {
+		return nil, fmt.Errorf("finding archive file: %w", err)
+	}
+
+	file := archiveFile{path: archivePeriodPath(path, period), period: period}
+
+	_, err = os.Stat(file.path)
+	if err != nil {
+		return nil, err
+	}
+
+	return openExportFile(ctx, file, x.log)
+}
+
+// close ends the file's transaction and closes its connection.
+func (f *exportFile) close() error {
+	_ = f.tx.Rollback()
+
+	return f.db.Close()
+}
+
+// writeJSON writes head with archived_events added as its last key,
+// the rows going into it one at a time.
+func (x *Export) writeJSON(
+	ctx context.Context, w io.Writer, head []byte,
+) error {
+	// head goes out without its closing brace, so that
+	// archived_events can follow it.
+	_, err := w.Write(head[:len(head)-1])
+	if err != nil {
+		return err
+	}
+
+	_, err = io.WriteString(w, `,"archived_events":[`)
+	if err != nil {
+		return err
+	}
+
+	err = x.writeRows(ctx, w)
+	if err != nil {
+		return err
+	}
+
+	_, err = io.WriteString(w, "\n]}\n")
+
+	return err
+}
+
+// writeRows writes the archived rows of each file to w, one per line,
+// separated by commas, opening each file in turn and closing it once
+// its rows are written.
+func (x *Export) writeRows(ctx context.Context, w io.Writer) error {
+	sep := "\n"
+
+	for _, period := range x.periods {
+		f, err := x.openFile(ctx, period)
+		if errors.Is(err, fs.ErrNotExist) {
+			continue
+		}
+
+		if err != nil {
+			return err
+		}
+
+		sep, err = f.writeRows(ctx, w, sep)
+
+		err = errors.Join(err, f.close())
+		if err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+// writeRows writes the file's archived rows to w, oldest first, the
+// first after sep and each other after ",\n". It returns what goes
+// before the next row: sep again when the file had no rows.
+func (f *exportFile) writeRows(
+	ctx context.Context, w io.Writer, sep string,
+) (string, error) {
+	if f.empty {
+		return sep, nil
+	}
+
+	rows, err := f.tx.WithContext(ctx).
+		Model(&archivedEvent{}).Order("id").Rows()
+	if err != nil {
+		return "", err
+	}
+
+	defer func() { _ = rows.Close() }()
+
+	for ; rows.Next(); sep = ",\n" {
+		var ev archivedEvent
+
+		err = f.tx.ScanRows(rows, &ev)
+		if err != nil {
+			return "", err
+		}
+
+		_, err = io.WriteString(w, sep)
+		if err != nil {
+			return "", err
+		}
+
+		err = writeRow(w, &ev, f.period)
+		if err != nil {
+			return "", err
+		}
+	}
+
+	return sep, rows.Err()
+}
+
+// writeRow writes an archived row to w as a JSON object keyed by
+// column name, its body in base64 when it is not valid UTF-8, with
+// the period of its file beside them unless that is "".
+func writeRow(w io.Writer, ev *archivedEvent, period string) error {
+	row := map[string]any{
+		"id":            ev.ID,
+		"event_id":      ev.EventID,
+		"webhook_id":    ev.WebhookID,
+		"entrypoint_id": ev.EntrypointID,
+		"method":        ev.Method,
+		"raw_query":     ev.RawQuery,
+		"headers":       ev.Headers,
+		"body":          ev.Body,
+		"content_type":  ev.ContentType,
+		"archived_at":   ev.ArchivedAt.UTC(),
+	}
+
+	if !utf8.ValidString(ev.Body) {
+		row["body"] = base64.StdEncoding.EncodeToString([]byte(ev.Body))
+		row["body_encoding"] = "base64"
+	}
+
+	if period != "" {
+		row["period"] = period
+	}
+
+	line, err := json.Marshal(row)
+	if err != nil {
+		return err
+	}
+
+	_, err = w.Write(line)
+
+	return err
+}

internal/archive/download_test.go

@@ -0,0 +1,573 @@
+package archive_test
+
+import (
+	"bufio"
+	"bytes"
+	"compress/gzip"
+	"crypto/rand"
+	"encoding/base64"
+	"encoding/json"
+	"fmt"
+	"io"
+	"os"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"sync"
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"sneak.berlin/go/webhooker/internal/archive"
+	"sneak.berlin/go/webhooker/internal/database"
+)
+
+// The webhook and the target the export tests' archives belong to.
+const (
+	exportWebhookID   = "wh-export"
+	exportWebhookName = "Orders (EU)"
+	exportTargetID    = "tgt-export"
+	exportTargetName  = "Long-term archive"
+)
+
+// binaryBody is a body that is not valid UTF-8.
+const binaryBody = "\xff\xfe\x00\x01binary\x80"
+
+// writeExportTo writes export to w as the archive of the export tests'
+// webhook and target, exported at 2026-10-02T12:03:04Z.
+func writeExportTo(
+	t *testing.T, export *archive.Export, w io.Writer,
+) error {
+	t.Helper()
+
+	return export.WriteGzipJSON(
+		t.Context(), w,
+		&database.Webhook{
+			BaseModel: database.BaseModel{ID: exportWebhookID},
+			Name:      exportWebhookName,
+		},
+		&database.Target{
+			BaseModel: database.BaseModel{ID: exportTargetID},
+			Name:      exportTargetName,
+		},
+		time.Date(2026, 10, 2, 12, 3, 4, 0, time.UTC),
+	)
+}
+
+// listExport lists the archive at path for export, as the archive of a
+// target whose names do not change.
+func listExport(t *testing.T, path string) *archive.Export {
+	t.Helper()
+
+	return newExport(t, path, &sync.Mutex{}, func() (string, error) {
+		return path, nil
+	})
+}
+
+// newExport lists the archive at path for export, to find each file
+// again under the path currentPath gives, holding lock while it does.
+// Nothing else takes lock while it lists, so it does not hold lock.
+func newExport(
+	t *testing.T,
+	path string,
+	lock sync.Locker,
+	currentPath func() (string, error),
+) *archive.Export {
+	t.Helper()
+
+	export, err := archive.NewExport(
+		path, lock, currentPath, archiveTestLogger(),
+	)
+	require.NoError(t, err)
+
+	return export
+}
+
+// exportArchive runs a whole export of the archive at path and returns
+// its JSON, decompressed and parsed.
+func exportArchive(t *testing.T, path string) map[string]any {
+	t.Helper()
+
+	return writeExport(t, listExport(t, path))
+}
+
+// writeExport writes an opened export and returns its JSON,
+// decompressed and parsed. Reading to the end makes the gzip reader
+// check that the stream was finished.
+func writeExport(
+	t *testing.T, export *archive.Export,
+) map[string]any {
+	t.Helper()
+
+	var buf bytes.Buffer
+
+	require.NoError(t, writeExportTo(t, export, &buf))
+
+	zr, err := gzip.NewReader(&buf)
+	require.NoError(t, err)
+
+	raw, err := io.ReadAll(zr)
+	require.NoError(t, err)
+
+	var got map[string]any
+
+	require.NoError(t, json.Unmarshal(raw, &got))
+
+	return got
+}
+
+// exportedEvents returns an export's archived_events.
+func exportedEvents(t *testing.T, got map[string]any) []map[string]any {
+	t.Helper()
+
+	list, ok := got["archived_events"].([]any)
+	require.True(t, ok, "archived_events must be an array: %v", got)
+
+	events := make([]map[string]any, len(list))
+
+	for i, v := range list {
+		events[i], ok = v.(map[string]any)
+		require.True(t, ok, "an archived event must be an object: %v", v)
+	}
+
+	return events
+}
+
+// exportedEventIDs returns the event_id of each of an export's
+// archived_events.
+func exportedEventIDs(t *testing.T, got map[string]any) []string {
+	t.Helper()
+
+	events := exportedEvents(t, got)
+	ids := make([]string, 0, len(events))
+
+	for _, ev := range events {
+		ids = append(ids, fmt.Sprint(ev["event_id"]))
+	}
+
+	return ids
+}
+
+// TestArchiveExport_MatchesStoredRows proves an export holds the
+// webhook, the target, the time, and every column of every stored
+// row: a body that is valid UTF-8 as a string, and one that is not in
+// base64, marked as such.
+func TestArchiveExport_MatchesStoredRows(t *testing.T) {
+	t.Parallel()
+
+	path := filepath.Join(t.TempDir(), "archive.db")
+	w := archive.NewExportArchiveWriter(path, archiveTestLogger(), 0)
+	bodies := []string{`{"order":1}`, "plain text", "", binaryBody}
+
+	for i, body := range bodies {
+		require.NoError(t, w.Write(archive.ExportArchivedEvent{
+			EventID:      fmt.Sprintf("ev-%d", i),
+			WebhookID:    exportWebhookID,
+			EntrypointID: "ep-1",
+			Method:       "POST",
+			RawQuery:     eventQuery,
+			Headers:      `{"X-Test":["yes"]}`,
+			Body:         body,
+			ContentType:  testContentType,
+		}, 0))
+	}
+
+	var stored []archive.ExportArchivedEvent
+
+	require.NoError(t, openArchiveDBForRead(t, path).
+		Order("id").Find(&stored).Error)
+
+	got := exportArchive(t, path)
+
+	assert.Equal(t,
+		map[string]any{"id": exportWebhookID, "name": exportWebhookName},
+		got["webhook"],
+	)
+	assert.Equal(t,
+		map[string]any{"id": exportTargetID, "name": exportTargetName},
+		got["target"],
+	)
+	assert.Equal(t, "2026-10-02T12:03:04Z", got["exported_at"])
+
+	events := exportedEvents(t, got)
+	require.Len(t, events, len(bodies))
+
+	for i, row := range stored {
+		assertExportedRow(t, row, events[i])
+	}
+}
+
+// assertExportedRow checks that ev, from an export, holds every column
+// of the stored row.
+func assertExportedRow(
+	t *testing.T, row archive.ExportArchivedEvent, ev map[string]any,
+) {
+	t.Helper()
+
+	archivedAt, err := time.Parse(
+		time.RFC3339Nano, fmt.Sprint(ev["archived_at"]),
+	)
+	require.NoError(t, err)
+	assert.True(t, archivedAt.Equal(row.ArchivedAt))
+
+	assert.EqualValues(t, row.ID, ev["id"])
+	assert.Equal(t, row.EventID, ev["event_id"])
+	assert.Equal(t, row.WebhookID, ev["webhook_id"])
+	assert.Equal(t, row.EntrypointID, ev["entrypoint_id"])
+	assert.Equal(t, row.Method, ev["method"])
+	assert.Equal(t, row.RawQuery, ev["raw_query"])
+	assert.Equal(t, row.Headers, ev["headers"])
+	assert.Equal(t, row.ContentType, ev["content_type"])
+
+	if row.Body != binaryBody {
+		assert.Equal(t, row.Body, ev["body"])
+		assert.Len(t, ev, 10, "the ten columns and nothing else: %v", ev)
+
+		return
+	}
+
+	body, err := base64.StdEncoding.DecodeString(fmt.Sprint(ev["body"]))
+	require.NoError(t, err)
+	assert.Equal(t, binaryBody, string(body))
+	assert.Equal(t, "base64", ev["body_encoding"])
+	assert.Len(t, ev, 11, "the ten columns and body_encoding: %v", ev)
+}
+
+// TestArchiveExport_Empty proves an archive with nothing in it exports
+// as an empty archived_events: no file, which the export must not
+// create; a file the archive writer has not yet put its table in; and
+// a table with no rows.
+func TestArchiveExport_Empty(t *testing.T) {
+	t.Parallel()
+
+	dir := t.TempDir()
+	missing := filepath.Join(dir, "missing.db")
+	noTable := filepath.Join(dir, "no-table.db")
+	noRows := filepath.Join(dir, "no-rows.db")
+
+	require.NoError(t, os.WriteFile(noTable, nil, 0o600))
+	require.NoError(t,
+		archive.NewExportArchiveWriter(noRows, archiveTestLogger(), 0).
+			Open(0),
+	)
+
+	for _, path := range []string{missing, noTable, noRows} {
+		assert.Empty(t, exportedEvents(t, exportArchive(t, path)), path)
+	}
+
+	for _, suffix := range archiveFileSuffixes() {
+		assert.NoFileExists(t, missing+suffix)
+	}
+}
+
+// unlockHook is a sync.Locker that runs fn each time it is unlocked. An
+// export unlocks its lock right after it opens a file.
+type unlockHook struct {
+	sync.Mutex
+
+	fn func()
+}
+
+func (u *unlockHook) Unlock() {
+	u.Mutex.Unlock()
+	u.fn()
+}
+
+// TestArchiveExport_ReadsOneSnapshot proves an export writes a file
+// out as it was when the export opened it, and holds up no archive
+// write: a row written after the export was listed but before the file
+// was opened is in the export, and one written while the file is open
+// is stored, and is not. A write held up for the whole busy timeout
+// would fail.
+func TestArchiveExport_ReadsOneSnapshot(t *testing.T) {
+	t.Parallel()
+
+	path := filepath.Join(t.TempDir(), "archive.db")
+	w := archive.NewExportArchiveWriter(path, archiveTestLogger(), 0)
+
+	require.NoError(t, w.Write(archive.ExportArchivedEvent{EventID: "listed"}, 0))
+
+	opened := &unlockHook{fn: func() {
+		require.NoError(t, w.Write(archive.ExportArchivedEvent{EventID: "during"}, 0))
+	}}
+	export := newExport(t, path, opened, func() (string, error) {
+		return path, nil
+	})
+
+	require.NoError(t, w.Write(archive.ExportArchivedEvent{EventID: "before-open"}, 0))
+
+	assert.Equal(t,
+		[]string{"listed", "before-open"},
+		exportedEventIDs(t, writeExport(t, export)),
+	)
+
+	var stored int64
+
+	require.NoError(t, openArchiveDBForRead(t, path).
+		Model(&archive.ExportArchivedEvent{}).Count(&stored).Error)
+	assert.Equal(t, int64(3), stored)
+}
+
+// TestArchiveExport_FindsFilesAfterRename proves that renaming the
+// archive after an export has listed it, as renaming its webhook or
+// target does, loses no file: the export finds each file again by its
+// period under the new name. A file moved away by then is skipped.
+func TestArchiveExport_FindsFilesAfterRename(t *testing.T) {
+	t.Parallel()
+
+	dir := t.TempDir()
+	path := filepath.Join(dir, "archive-old.db")
+	w := archive.NewExportArchiveWriter(path, archiveTestLogger(), 0)
+
+	for _, period := range []string{"", dayPeriod, hourPeriod} {
+		require.NoError(t, w.WritePeriod(
+			archive.ExportArchivedEvent{EventID: "in-" + period}, 0, period,
+		))
+	}
+
+	current := path
+	export := newExport(t, path, &sync.Mutex{}, func() (string, error) {
+		return current, nil
+	})
+
+	require.NoError(t, w.Rename("archive-new.db"))
+
+	current = filepath.Join(dir, "archive-new.db")
+
+	removeArchiveFiles(t, periodPath(current, dayPeriod))
+
+	assert.Equal(t,
+		[]string{"in-", "in-" + hourPeriod},
+		exportedEventIDs(t, writeExport(t, export)),
+	)
+}
+
+// TestArchiveExport_EveryFileOldestFirst writes a row to a target's
+// file without a period and to its files for a month, an hour and a
+// day, and proves the export holds every row: the file without a
+// period first, then the others oldest period first, each row from a
+// file named for a period carrying that period. A file made after the
+// export was listed is not in it.
+func TestArchiveExport_EveryFileOldestFirst(t *testing.T) {
+	t.Parallel()
+
+	path := filepath.Join(t.TempDir(), "archive-wh.db")
+	w := archive.NewExportArchiveWriter(path, archiveTestLogger(), 0)
+
+	// Written in an order that is not the export's.
+	for _, period := range []string{nextDayPeriod, "", hourPeriod, "2026-03"} {
+		require.NoError(t, w.WritePeriod(
+			archive.ExportArchivedEvent{EventID: "in-" + period}, 0, period,
+		))
+	}
+
+	export := listExport(t, path)
+
+	require.NoError(t, w.WritePeriod(
+		archive.ExportArchivedEvent{EventID: "later"}, 0, "2026-03-06",
+	))
+
+	events := exportedEvents(t, writeExport(t, export))
+	ids := make([]string, 0, len(events))
+	periods := make([]any, 0, len(events))
+
+	for _, ev := range events {
+		ids = append(ids, fmt.Sprint(ev["event_id"]))
+		periods = append(periods, ev["period"])
+	}
+
+	assert.Equal(t,
+		[]string{"in-", "in-2026-03", "in-" + hourPeriod, "in-" + nextDayPeriod},
+		ids,
+	)
+	assert.Equal(t,
+		[]any{nil, "2026-03", hourPeriod, nextDayPeriod}, periods,
+	)
+	assert.NotContains(t, events[0], "period",
+		"a row from the file without a period has no period")
+}
+
+// openFilesPeak is an io.Writer that discards what it is given and
+// records the most archive files in dir the process had open at any
+// write, as /proc/self/fd lists the files a process has open.
+type openFilesPeak struct {
+	dir string
+	max int
+}
+
+func (p *openFilesPeak) Write(b []byte) (int, error) {
+	fds, err := os.ReadDir("/proc/self/fd")
+	if err != nil {
+		return 0, err
+	}
+
+	open := map[string]bool{}
+
+	for _, fd := range fds {
+		file, err := os.Readlink(filepath.Join("/proc/self/fd", fd.Name()))
+		if err == nil && filepath.Dir(file) == p.dir &&
+			strings.HasSuffix(file, ".db") {
+			open[file] = true
+		}
+	}
+
+	p.max = max(p.max, len(open))
+
+	return len(b), nil
+}
+
+// TestArchiveExport_OneFileOpenAtATime exports a target with a file for
+// each of 24 hours and proves the export never had more than one of
+// them open, and had one open while it wrote. Each file holds a row of
+// 48 KiB of random base64, which gzip shrinks little, so the export
+// writes output while it reads each file.
+func TestArchiveExport_OneFileOpenAtATime(t *testing.T) {
+	t.Parallel()
+
+	if runtime.GOOS != "linux" {
+		t.Skip("only Linux lists a process's open files in /proc/self/fd")
+	}
+
+	// Readlink gives each open file's path with no symbolic link in it.
+	dir, err := filepath.EvalSymlinks(t.TempDir())
+	require.NoError(t, err)
+
+	path := filepath.Join(dir, "archive-wh.db")
+	w := archive.NewExportArchiveWriter(path, archiveTestLogger(), 0)
+	random := make([]byte, 36<<10)
+
+	for hour := range 24 {
+		_, _ = rand.Read(random)
+
+		require.NoError(t, w.WritePeriod(archive.ExportArchivedEvent{
+			Body: base64.StdEncoding.EncodeToString(random),
+		}, 0, fmt.Sprintf("2026-10-01-%02d", hour)))
+	}
+
+	// The writer's own handle on the last file is not the export's.
+	w.Evict()
+
+	// Through a buffer, the open files are listed once per 8 KiB of
+	// output, a few times for each file, rather than at each of gzip's
+	// small writes, which takes far longer.
+	peak := &openFilesPeak{dir: dir}
+	buffered := bufio.NewWriterSize(peak, 8<<10)
+
+	require.NoError(t, writeExportTo(t, listExport(t, path), buffered))
+	require.NoError(t, buffered.Flush())
+	assert.Equal(t, 1, peak.max)
+}
+
+// heapPeak is an io.Writer that discards what it is given and records
+// the largest heap it saw at a write. It collects garbage twice before
+// each reading, so the heap it reads is what is still held. Once is not
+// enough: the libraries the export calls (regexp, under GORM's table
+// names, and encoding/json among them) cache buffers in a sync.Pool,
+// which keeps them through one collection, so after one the reading
+// counts however many happen to be cached. That varies from run to run
+// by about as much as the limit in TestArchiveExport_Streams.
+type heapPeak struct {
+	max uint64
+}
+
+func (p *heapPeak) Write(b []byte) (int, error) {
+	var m runtime.MemStats
+
+	runtime.GC()
+	runtime.GC()
+	runtime.ReadMemStats(&m)
+	p.max = max(p.max, m.HeapAlloc)
+
+	return len(b), nil
+}
+
+// exportHeapGrowth exports an archive of rows random bodies, each
+// bodySize bytes of base64, and returns how far the heap rose above
+// where it stood when the export began, at its highest.
+func exportHeapGrowth(t *testing.T, rows, bodySize int) uint64 {
+	t.Helper()
+
+	path := filepath.Join(t.TempDir(), "archive.db")
+	w := archive.NewExportArchiveWriter(path, archiveTestLogger(), 0)
+
+	// Base64 makes four characters of every three bytes.
+	random := make([]byte, bodySize/4*3)
+
+	for range rows {
+		_, _ = rand.Read(random)
+
+		require.NoError(t, w.Write(archive.ExportArchivedEvent{
+			Body: base64.StdEncoding.EncodeToString(random),
+		}, 0))
+	}
+
+	export := listExport(t, path)
+
+	// Twice, for the reason heapPeak gives.
+	runtime.GC()
+	runtime.GC()
+
+	var start runtime.MemStats
+
+	runtime.ReadMemStats(&start)
+
+	// Through a buffer, the heap is read once per 8 KiB of output
+	// rather than at each of gzip's small writes, which takes far
+	// longer.
+	peak := &heapPeak{max: start.HeapAlloc}
+	buffered := bufio.NewWriterSize(peak, 8<<10)
+
+	require.NoError(t, writeExportTo(t, export, buffered))
+	require.NoError(t, buffered.Flush())
+
+	return peak.max - start.HeapAlloc
+}
+
+// TestArchiveExport_Streams proves an export holds neither the archive
+// nor its output in memory whole: exporting 384 KiB more of archive
+// raises the heap's peak by less than half of that. The export's own
+// memory, mostly gzip's compressor, is the same for both archives, so
+// it cancels out. The bodies are random bytes in base64, which gzip
+// shrinks by only a quarter, so an export that read every row before
+// writing, or built the JSON or the gzipped file before writing it,
+// would raise the peak by at least three quarters of the difference.
+//
+// The smaller archive has two rows so that its export, too, writes
+// out more than the 8 KiB buffer in exportHeapGrowth before it ends:
+// the heap must be read while the export's own memory is held.
+//
+//nolint:paralleltest // It measures the heap, which tests share.
+func TestArchiveExport_Streams(t *testing.T) {
+	const (
+		bodySize  = 16 << 10
+		smallRows = 2
+		largeRows = smallRows + 24
+		limit     = (largeRows - smallRows) * bodySize / 2
+	)
+
+	small := exportHeapGrowth(t, smallRows, bodySize)
+	large := exportHeapGrowth(t, largeRows, bodySize)
+
+	assert.Less(t, large, small+limit,
+		"the heap rose by %d for %d rows and by %d for %d rows",
+		small, smallRows, large, largeRows,
+	)
+}
+
+// TestArchiveExportFileName proves the download is named for the
+// webhook and the target, with the names made safe as for the archive
+// file, and the export time in UTC.
+func TestArchiveExportFileName(t *testing.T) {
+	t.Parallel()
+
+	cest := time.FixedZone("CEST", int((2 * time.Hour).Seconds()))
+
+	assert.Equal(t,
+		"archive-orders-eu-long-term-archive-20261002T120304Z.json.gz",
+		archive.ExportFileName(
+			exportWebhookName, exportTargetName,
+			time.Date(2026, 10, 2, 14, 3, 4, 0, cest),
+		),
+	)
+}

internal/archive/evict_test.go

@@ -1,7 +1,6 @@
-package delivery_test
+package archive_test
 
 import (
-	"context"
 	"errors"
 	"fmt"
 	"net/http"
@@ -13,96 +12,117 @@ import (
 
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
+	"sneak.berlin/go/webhooker/internal/archive"
 	"sneak.berlin/go/webhooker/internal/database"
-	"sneak.berlin/go/webhooker/internal/delivery"
 )
 
-// evictTestEngine builds an engine backed by a temporary data
-// directory and returns it along with that directory.
-func evictTestEngine(t *testing.T) (*delivery.Engine, string) {
+// deliverTo archives one event to a database target, leaving the
+// target's writer cached with its handle open.
+func deliverTo(
+	t *testing.T, env *archiveEnv, tgt *database.Target,
+) {
 	t.Helper()
 
-	dataDir := t.TempDir()
+	event := newEvent(`{"archived":true}`)
 
-	eng := delivery.NewTestEngineWithDB(
-		nil,
-		database.NewTestWebhookDBManager(dataDir),
-		archiveTestLogger(),
-		&http.Client{Timeout: 5 * time.Second},
-		1,
-	)
-
-	return eng, dataDir
+	require.NoError(t, env.writers.Write(databaseTargetDelivery(event, tgt)))
 }
 
 // TestEvictWebhook_ClosesAndRemovesWriter proves that evicting
-// a webhook drops its archive writer from the registry and
-// closes the open archive handle, rather than leaving both
-// alive for the process lifetime.
+// a webhook drops the archive writers of its database targets
+// from the registry and closes their open handles, rather than
+// leaving them alive for the process lifetime, and leaves another
+// webhook's writer alone.
 func TestEvictWebhook_ClosesAndRemovesWriter(t *testing.T) {
 	t.Parallel()
 
-	eng, dataDir := evictTestEngine(t)
+	env := setupArchiveTest(t)
+	first := env.seedDatabaseTarget(t, 0, "")
+	second := env.addDatabaseTarget(t, first.WebhookID, 0, "")
+	other := env.seedDatabaseTarget(t, 0, "")
 
-	webhookDB := testWebhookDB(t)
-	event := seedEvent(t, webhookDB, `{"archived":true}`)
-	d := seedDatabaseTargetDelivery(t, webhookDB, event, "")
+	for _, tgt := range []*database.Target{first, second, other} {
+		deliverTo(t, env, tgt)
 
-	eng.ExportDeliverDatabase(webhookDB, d)
+		require.True(
+			t, env.writers.ExportArchiveHandleOpen(tgt.ID),
+			"the writer should hold an open handle after a write",
+		)
+	}
 
-	webhookID := event.WebhookID
+	env.writers.EvictWebhook(first.WebhookID)
 
-	require.True(
-		t, eng.ExportHasArchiveWriter(webhookID),
-		"a delivery should have cached an archive writer",
-	)
-	require.True(
-		t, eng.ExportArchiveHandleOpen(webhookID),
-		"the writer should hold an open handle after a write",
+	for _, tgt := range []*database.Target{first, second} {
+		assert.False(
+			t, env.writers.ExportHasArchiveWriter(tgt.ID),
+			"eviction should remove the registry entry",
+		)
+		assert.False(
+			t, env.writers.ExportArchiveHandleOpen(tgt.ID),
+			"eviction should close the archive handle",
+		)
+		assert.FileExists(
+			t, env.archivePath(tgt),
+			"eviction must not delete the archive file",
+		)
+	}
+
+	assert.True(
+		t, env.writers.ExportArchiveHandleOpen(other.ID),
+		"another webhook's writer must be left alone",
 	)
+}
 
-	eng.EvictWebhook(webhookID)
+// TestEvictTarget_LeavesOtherTargets proves that evicting one
+// database target leaves the writer of another target of the same
+// webhook in place.
+func TestEvictTarget_LeavesOtherTargets(t *testing.T) {
+	t.Parallel()
 
-	assert.False(
-		t, eng.ExportHasArchiveWriter(webhookID),
-		"eviction should remove the registry entry",
-	)
-	assert.False(
-		t, eng.ExportArchiveHandleOpen(webhookID),
-		"eviction should close the archive handle",
-	)
+	env := setupArchiveTest(t)
+	doomed := env.seedDatabaseTarget(t, 0, "")
+	kept := env.addDatabaseTarget(t, doomed.WebhookID, 0, "")
 
-	archivePath := filepath.Join(
-		dataDir, fmt.Sprintf("archive-%s.db", webhookID),
-	)
+	deliverTo(t, env, doomed)
+	deliverTo(t, env, kept)
+
+	env.writers.EvictTarget(doomed.ID)
+
+	assert.False(t, env.writers.ExportHasArchiveWriter(doomed.ID))
 	assert.FileExists(
-		t, archivePath,
+		t, env.archivePath(doomed),
 		"eviction must not delete the archive file",
 	)
+	assert.True(
+		t, env.writers.ExportArchiveHandleOpen(kept.ID),
+		"the other target's writer must be left alone",
+	)
 }
 
 // TestEvictWebhook_UnknownWebhookIsNoOp proves eviction is safe
-// for the common case of a webhook that never had a database
-// target, and that repeating it does not panic.
+// for the common case of a webhook or target that never had an
+// archive writer, and that repeating it does not panic.
 func TestEvictWebhook_UnknownWebhookIsNoOp(t *testing.T) {
 	t.Parallel()
 
-	eng, _ := evictTestEngine(t)
+	env := setupArchiveTest(t)
 
 	assert.NotPanics(t, func() {
-		eng.EvictWebhook("no-such-webhook")
-		eng.EvictWebhook("no-such-webhook")
+		env.writers.EvictWebhook("no-such-webhook")
+		env.writers.EvictWebhook("no-such-webhook")
+		env.writers.EvictTarget("no-such-target")
+		env.writers.EvictTarget("no-such-target")
 	})
 
 	assert.False(
-		t, eng.ExportHasArchiveWriter("no-such-webhook"),
+		t, env.writers.ExportHasArchiveWriter("no-such-target"),
 		"eviction must not create a writer",
 	)
 }
 
 // evictTestRow builds an archive row for the eviction tests.
-func evictTestRow(eventID string) delivery.ExportArchivedEvent {
-	return delivery.ExportArchivedEvent{
+func evictTestRow(eventID string) archive.ExportArchivedEvent {
+	return archive.ExportArchivedEvent{
 		EventID:   eventID,
 		WebhookID: "wh-evict",
 		Method:    http.MethodPost,
@@ -123,7 +143,7 @@ func TestEvictedWriter_WriteDoesNotReopenFile(t *testing.T) {
 
 	path := filepath.Join(t.TempDir(), "archive-evicted.db")
 
-	w := delivery.NewExportArchiveWriter(
+	w := archive.NewExportArchiveWriter(
 		path, archiveTestLogger(), 0,
 	)
 
@@ -140,7 +160,7 @@ func TestEvictedWriter_WriteDoesNotReopenFile(t *testing.T) {
 	err := w.Write(evictTestRow("ev-2"), 0)
 
 	require.ErrorIs(
-		t, err, delivery.ErrExportArchiveWriterEvicted,
+		t, err, archive.ErrExportArchiveWriterEvicted,
 		"an evicted writer must refuse writes",
 	)
 	assert.NoFileExists(
@@ -163,7 +183,7 @@ func TestEvictedWriter_SweepDoesNotReopenFile(t *testing.T) {
 
 	path := filepath.Join(t.TempDir(), "archive-evicted.db")
 
-	w := delivery.NewExportArchiveWriter(
+	w := archive.NewExportArchiveWriter(
 		path, archiveTestLogger(), 0,
 	)
 
@@ -175,7 +195,7 @@ func TestEvictedWriter_SweepDoesNotReopenFile(t *testing.T) {
 	err := w.SweepExpired(time.Hour)
 
 	require.ErrorIs(
-		t, err, delivery.ErrExportArchiveWriterEvicted,
+		t, err, archive.ErrExportArchiveWriterEvicted,
 		"an evicted writer must refuse an idle sweep",
 	)
 	assert.False(
@@ -206,7 +226,7 @@ const racingWriteGoroutines = 4
 // against a hang, not a timing assumption: the first write after
 // the eviction is refused.
 func startRacingWrites(
-	w *delivery.ExportArchiveWriter,
+	w *archive.ExportArchiveWriter,
 ) *racingWrites {
 	r := &racingWrites{
 		started: make(chan struct{}, racingWriteGoroutines),
@@ -252,7 +272,7 @@ func (r *racingWrites) record(err error) {
 	r.mu.Lock()
 	defer r.mu.Unlock()
 
-	if errors.Is(err, delivery.ErrExportArchiveWriterEvicted) {
+	if errors.Is(err, archive.ErrExportArchiveWriterEvicted) {
 		r.sawEvicted = true
 
 		return
@@ -283,23 +303,20 @@ func (r *racingWrites) wait() (bool, error) {
 // contending for the writer's mutex when the eviction takes it.
 // The write that wins the mutex after the eviction must abandon
 // its work rather than reopen the archive, leaving the writer
-// permanently handle-free. Run under -race.
+// permanently handle-free.
 func TestEvictWebhook_RacingWriteDoesNotReopenHandle(
 	t *testing.T,
 ) {
 	t.Parallel()
 
-	eng, _ := evictTestEngine(t)
-
-	webhookDB := testWebhookDB(t)
-	event := seedEvent(t, webhookDB, `{"archived":true}`)
-	d := seedDatabaseTargetDelivery(t, webhookDB, event, "")
+	env := setupArchiveTest(t)
+	tgt := env.seedDatabaseTarget(t, 0, "")
 
 	// Prime the registry so the test can hold the very writer the
 	// eviction is about to detach.
-	eng.ExportDeliverDatabase(webhookDB, d)
+	deliverTo(t, env, tgt)
 
-	w := eng.ExportArchiveWriterFor(event.WebhookID)
+	w := env.writers.ExportArchiveWriterFor(tgt.ID)
 	require.NotNil(t, w)
 	require.True(t, w.HandleOpen())
 
@@ -309,7 +326,7 @@ func TestEvictWebhook_RacingWriteDoesNotReopenHandle(
 	// eviction has to contend for the writer's mutex.
 	race.awaitFirstWrite()
 
-	eng.EvictWebhook(event.WebhookID)
+	env.writers.EvictWebhook(tgt.WebhookID)
 
 	sawEvicted, otherErr := race.wait()
 
@@ -324,70 +341,59 @@ func TestEvictWebhook_RacingWriteDoesNotReopenHandle(
 			"been evicted",
 	)
 	assert.False(
-		t, eng.ExportHasArchiveWriter(event.WebhookID),
+		t, env.writers.ExportHasArchiveWriter(tgt.ID),
 		"the registry entry must stay gone",
 	)
 }
 
 // TestEvictWebhook_LaterDeliveryRecreatesWriter proves eviction
-// does not break archiving for a webhook that is still alive: a
+// does not break archiving for a target that is still alive: a
 // subsequent delivery gets a brand new writer from the registry.
 // It says nothing about the evicted writer itself — that is what
 // TestEvictedWriter_WriteDoesNotReopenFile covers.
 func TestEvictWebhook_LaterDeliveryRecreatesWriter(t *testing.T) {
 	t.Parallel()
 
-	eng, _ := evictTestEngine(t)
+	env := setupArchiveTest(t)
+	tgt := env.seedDatabaseTarget(t, 0, "")
 
-	webhookDB := testWebhookDB(t)
-	event := seedEvent(t, webhookDB, `{"archived":true}`)
-	d := seedDatabaseTargetDelivery(t, webhookDB, event, "")
+	deliverTo(t, env, tgt)
+	require.True(t, env.writers.ExportHasArchiveWriter(tgt.ID))
 
-	eng.ExportDeliverDatabase(webhookDB, d)
-	require.True(
-		t, eng.ExportHasArchiveWriter(event.WebhookID),
-	)
+	env.writers.EvictWebhook(tgt.WebhookID)
 
-	eng.EvictWebhook(event.WebhookID)
-
-	// A fresh delivery for the same webhook gets a brand new
+	// A fresh delivery for the same target gets a brand new
 	// writer from the registry, so archiving keeps working.
-	second := seedDatabaseTargetDelivery(
-		t, webhookDB, event, "",
-	)
-	eng.ExportDeliverDatabase(webhookDB, second)
+	deliverTo(t, env, tgt)
 
 	assert.True(
-		t, eng.ExportHasArchiveWriter(event.WebhookID),
+		t, env.writers.ExportHasArchiveWriter(tgt.ID),
 		"a later delivery should recreate the writer",
 	)
 }
 
-// TestEngineStop_WriteAfterStopIsRefused proves the engine's stop
-// closes each archive writer the way deleting its webhook does: a
-// write that reaches a writer after the stop is refused, reopens
-// nothing and adds no row.
-func TestEngineStop_WriteAfterStopIsRefused(t *testing.T) {
+// TestEvictAll_WriteAfterIsRefused proves that EvictAll, which the
+// delivery engine calls when it stops, closes each archive writer the
+// way deleting its webhook does: a write that reaches a writer after
+// it is refused, reopens nothing and adds no row.
+func TestEvictAll_WriteAfterIsRefused(t *testing.T) {
 	t.Parallel()
 
-	eng, _ := evictTestEngine(t)
+	env := setupArchiveTest(t)
+	tgt := env.seedDatabaseTarget(t, 0, "")
 
-	webhookDB := testWebhookDB(t)
-	event := seedEvent(t, webhookDB, `{"archived":true}`)
-	d := seedDatabaseTargetDelivery(t, webhookDB, event, "")
+	deliverTo(t, env, tgt)
 
-	eng.ExportDeliverDatabase(webhookDB, d)
-
-	w := eng.ExportArchiveWriterFor(event.WebhookID)
+	w := env.writers.ExportArchiveWriterFor(tgt.ID)
 	require.NotNil(t, w)
 	require.True(t, w.HandleOpen())
 
-	require.NoError(t, eng.ExportStop(context.Background()))
+	env.writers.EvictAll()
 
 	err := w.Write(evictTestRow("ev-after-stop"), 0)
 
 	require.ErrorIs(
-		t, err, delivery.ErrExportArchiveWriterEvicted,
+		t, err, archive.ErrExportArchiveWriterEvicted,
 		"a write after the stop must be refused",
 	)
 	assert.False(
@@ -395,7 +401,7 @@ func TestEngineStop_WriteAfterStopIsRefused(t *testing.T) {
 		"a refused write must not reopen the archive",
 	)
 	assert.False(
-		t, eng.ExportHasArchiveWriter(event.WebhookID),
+		t, env.writers.ExportHasArchiveWriter(tgt.ID),
 		"the stop should empty the registry",
 	)
 

internal/archive/export_test.go

@@ -0,0 +1,280 @@
+package archive
+
+import (
+	"context"
+	"log/slog"
+	"time"
+
+	"go.uber.org/fx"
+	"gorm.io/gorm"
+	"sneak.berlin/go/webhooker/internal/database"
+)
+
+// ErrExportArchiveWriterEvicted exposes the sentinel returned by
+// an evicted archive writer. It carries the Err prefix rather
+// than this file's usual Export one because it is a sentinel
+// error.
+var ErrExportArchiveWriterEvicted = errArchiveWriterEvicted
+
+// ExportArchivedEvent aliases the archive row type so black-box
+// tests can construct and read archive rows.
+type ExportArchivedEvent = archivedEvent
+
+// ExportArchiveWriter wraps an archiveWriter so black-box tests
+// can exercise the archive file mechanics.
+type ExportArchiveWriter struct {
+	w *archiveWriter
+}
+
+// NewExportArchiveWriter builds an archive writer for tests,
+// optionally overriding the reopen debounce (a non-positive
+// debounce keeps the production default).
+func NewExportArchiveWriter(
+	path string, log *slog.Logger, debounce time.Duration,
+) *ExportArchiveWriter {
+	w := newArchiveWriter(path, log)
+	if debounce > 0 {
+		w.debounce = debounce
+	}
+
+	return &ExportArchiveWriter{w: w}
+}
+
+// Write archives a row through the writer, into the file named
+// without a period.
+func (e *ExportArchiveWriter) Write(
+	row ExportArchivedEvent, expiry time.Duration,
+) error {
+	return e.w.write(row, expiry, "")
+}
+
+// WritePeriod archives a row through the writer, into the file for
+// period.
+func (e *ExportArchiveWriter) WritePeriod(
+	row ExportArchivedEvent, expiry time.Duration, period string,
+) error {
+	return e.w.write(row, expiry, period)
+}
+
+// Open opens the archive file, pruning when expiry is positive.
+func (e *ExportArchiveWriter) Open(expiry time.Duration) error {
+	return e.w.open(e.w.path, expiry)
+}
+
+// Reopen closes and reopens the archive file.
+func (e *ExportArchiveWriter) Reopen(
+	expiry time.Duration,
+) error {
+	return e.w.reopen(e.w.path, expiry)
+}
+
+// SetNow replaces the clock the writer measures its reopen
+// debounce on.
+func (e *ExportArchiveWriter) SetNow(now func() time.Time) {
+	e.w.now = now
+}
+
+// Reopens reports how many times the file has been opened.
+func (e *ExportArchiveWriter) Reopens() int {
+	return e.w.reopens
+}
+
+// DB returns the writer's current open handle for row
+// inspection in tests.
+func (e *ExportArchiveWriter) DB() *gorm.DB {
+	return e.w.db
+}
+
+// Path returns the archive file the writer owns.
+func (e *ExportArchiveWriter) Path() string {
+	return e.w.path
+}
+
+// OpenExisting opens the archive without permitting creation,
+// the way the idle sweep does.
+func (e *ExportArchiveWriter) OpenExisting(
+	expiry time.Duration,
+) error {
+	return e.w.openMode(e.w.path, archiveModeExisting, expiry)
+}
+
+// SweepExpired runs an idle sweep of the archive.
+func (e *ExportArchiveWriter) SweepExpired(
+	expiry time.Duration,
+) error {
+	return e.w.sweepExpired(expiry)
+}
+
+// Evict marks the writer evicted and closes its handle, exactly
+// as leaving the registry does.
+func (e *ExportArchiveWriter) Evict() {
+	e.w.evict()
+}
+
+// Rename gives the archive file a new name in the same directory,
+// as a rename of the webhook or target does.
+func (e *ExportArchiveWriter) Rename(name string) error {
+	return e.w.rename(name)
+}
+
+// HandleOpen reports whether the writer currently holds an open
+// archive handle.
+func (e *ExportArchiveWriter) HandleOpen() bool {
+	e.w.mu.Lock()
+	defer e.w.mu.Unlock()
+
+	return e.w.db != nil
+}
+
+// Same reports whether both wrappers refer to the very same
+// underlying archive writer, so a test can prove a registry entry
+// is the writer it was handed rather than a replacement.
+func (e *ExportArchiveWriter) Same(
+	other *ExportArchiveWriter,
+) bool {
+	return other != nil && e.w == other.w
+}
+
+// ExportArchiveWriterFor returns the archive writer the registry
+// currently caches for a database target, or nil when none is
+// cached. It never creates one, so a test can hold a reference to
+// the very writer an eviction is about to detach.
+func (ws *Writers) ExportArchiveWriterFor(
+	targetID string,
+) *ExportArchiveWriter {
+	ws.mu.Lock()
+	defer ws.mu.Unlock()
+
+	w, ok := ws.writers[targetID]
+	if !ok {
+		return nil
+	}
+
+	return &ExportArchiveWriter{w: w}
+}
+
+// ExportHasArchiveWriter reports whether the registry currently
+// caches an archive writer for a target.
+func (ws *Writers) ExportHasArchiveWriter(
+	targetID string,
+) bool {
+	ws.mu.Lock()
+	defer ws.mu.Unlock()
+
+	_, ok := ws.writers[targetID]
+
+	return ok
+}
+
+// ExportArchiveHandleOpen reports whether the cached archive
+// writer for a target holds an open database handle. It
+// returns false when no writer is cached.
+func (ws *Writers) ExportArchiveHandleOpen(
+	targetID string,
+) bool {
+	ws.mu.Lock()
+	w, ok := ws.writers[targetID]
+	ws.mu.Unlock()
+
+	if !ok {
+		return false
+	}
+
+	w.mu.Lock()
+	defer w.mu.Unlock()
+
+	return w.db != nil
+}
+
+// ExportEnsureArchiveWriter creates (if needed) and returns the
+// archive file path of the cached writer for a target, so a
+// test can prime the registry the way a delivery would.
+func (ws *Writers) ExportEnsureArchiveWriter(
+	targetID string,
+) (string, error) {
+	w, err := ws.writerFor(targetID)
+	if err != nil {
+		return "", err
+	}
+
+	return w.path, nil
+}
+
+// ExportSweepWriterFor takes a target's registry writer exactly
+// as the idle sweep does, reporting whether the sweep had to
+// create the entry. It lets a test drive the registry through the
+// sweep's own entry point instead of choreographing goroutines.
+func (ws *Writers) ExportSweepWriterFor(
+	targetID string,
+) (*ExportArchiveWriter, bool, error) {
+	w, created, err := ws.sweepWriterFor(targetID)
+	if err != nil {
+		return nil, false, err
+	}
+
+	return &ExportArchiveWriter{w: w}, created, nil
+}
+
+// ExportReleaseSweepWriter releases a sweep-created registry entry
+// exactly as a finished sweep does.
+func (ws *Writers) ExportReleaseSweepWriter(
+	targetID string, w *ExportArchiveWriter,
+) {
+	ws.releaseSweepWriter(targetID, w.w)
+}
+
+// NewTestSweeper builds a Sweeper backed by the given main
+// database and archive writers, without the fx lifecycle.
+// Intended for tests.
+func NewTestSweeper(
+	db *database.Database,
+	writers *Writers,
+	log *slog.Logger,
+) *Sweeper {
+	return &Sweeper{
+		db:       db,
+		writers:  writers,
+		log:      log,
+		interval: time.Hour,
+	}
+}
+
+// ExportSweep runs a single archive sweep synchronously for
+// tests.
+func (s *Sweeper) ExportSweep(ctx context.Context) {
+	s.sweep(ctx)
+}
+
+// ExportStart starts the sweeper's background loop for tests.
+func (s *Sweeper) ExportStart() {
+	s.start()
+}
+
+// ExportRegisterHooks registers the sweeper's real fx lifecycle
+// hooks on a lifecycle supplied by a test, so a test can drive
+// the exact OnStart/OnStop functions the application runs and
+// hand OnStart the kind of context fx actually supplies.
+func (s *Sweeper) ExportRegisterHooks(lc fx.Lifecycle) {
+	s.registerHooks(lc)
+}
+
+// ExportStop stops the sweeper's background loop for tests.
+func (s *Sweeper) ExportStop(ctx context.Context) error {
+	return s.stop(ctx)
+}
+
+// ExportWedgeLoop adds a goroutine to the sweeper's WaitGroup
+// that never observes cancellation and returns only when release
+// is closed. It stands in for a prune stuck on a locked archive.
+func (s *Sweeper) ExportWedgeLoop(
+	release <-chan struct{},
+) {
+	s.wg.Go(func() {
+		<-release
+	})
+}
+
+// ExportSetInterval overrides the sweep interval for tests.
+func (s *Sweeper) ExportSetInterval(d time.Duration) {
+	s.interval = d
+}

internal/archive/rotation.go

@@ -0,0 +1,167 @@
+package archive
+
+import (
+	"errors"
+	"fmt"
+	"os"
+	"path/filepath"
+	"slices"
+	"strings"
+	"time"
+
+	"sneak.berlin/go/webhooker/internal/database"
+)
+
+// The archive rotations: how often a database target starts a new
+// archive file. Every rotation but none puts the period of an event's
+// receive time, in UTC, in the name of the file the event goes to,
+// written in the layout beside it.
+const (
+	archiveRotationNone    = "none"
+	archiveRotationMonthly = "monthly"
+	archiveRotationDaily   = "daily"
+	archiveRotationHourly  = "hourly"
+
+	archiveMonthLayout = "2006-01"
+	archiveDayLayout   = "2006-01-02"
+	archiveHourLayout  = "2006-01-02-15"
+)
+
+// errArchiveRotationUnknown is returned for a rotation that is not one
+// of the four.
+var errArchiveRotationUnknown = errors.New(
+	"rotation must be none, monthly, daily or hourly",
+)
+
+// archiveFile is one of a database target's archive files, and the
+// period in its name: "" for the file named without one.
+type archiveFile struct {
+	path   string
+	period string
+}
+
+// ValidateRotation checks a user-supplied archive rotation for
+// a database target: empty or none (both meaning one file), monthly,
+// daily or hourly.
+func ValidateRotation(rotation string) error {
+	switch rotation {
+	case "", archiveRotationNone, archiveRotationMonthly,
+		archiveRotationDaily, archiveRotationHourly:
+		return nil
+	default:
+		return fmt.Errorf("%w: %q", errArchiveRotationUnknown, rotation)
+	}
+}
+
+// archivePeriod returns the period, in UTC, that a rotation puts an
+// event received at receivedAt in: "2026-10" for monthly,
+// "2026-10-01" for daily, "2026-10-01-19" for hourly, and "" for none
+// or an empty rotation.
+func archivePeriod(rotation string, receivedAt time.Time) string {
+	switch rotation {
+	case archiveRotationMonthly:
+		return receivedAt.UTC().Format(archiveMonthLayout)
+	case archiveRotationDaily:
+		return receivedAt.UTC().Format(archiveDayLayout)
+	case archiveRotationHourly:
+		return receivedAt.UTC().Format(archiveHourLayout)
+	default:
+		return ""
+	}
+}
+
+// archivePeriodPath returns the path of a database target's archive
+// file for a period: path, as Path gives it, with "-" and the
+// period put before its ".db". The period "" gives path itself.
+func archivePeriodPath(path, period string) string {
+	if period == "" {
+		return path
+	}
+
+	return strings.TrimSuffix(path, ".db") + "-" + period + ".db"
+}
+
+// PathAt returns the archive file a database target writes an
+// event received at receivedAt to: Path's file, with the
+// period in its name when the target rotates.
+func PathAt(
+	dbMgr *database.WebhookDBManager,
+	webhook *database.Webhook,
+	target *database.Target,
+	receivedAt time.Time,
+) string {
+	return archivePeriodPath(
+		Path(dbMgr, webhook, target),
+		archivePeriod(target.ArchiveRotation, receivedAt),
+	)
+}
+
+// archiveFiles lists the database target's archive files that exist,
+// given the path Path gives it: the file at path, then each
+// file archivePeriodPath names for path and a period, oldest period
+// first. Which rotation wrote a file does not matter, so the files of
+// an earlier rotation setting are listed too.
+func archiveFiles(path string) ([]archiveFile, error) {
+	dir := filepath.Dir(path)
+
+	entries, err := os.ReadDir(dir)
+	if err != nil {
+		return nil, fmt.Errorf("listing archive files: %w", err)
+	}
+
+	stem := strings.TrimSuffix(filepath.Base(path), ".db")
+
+	var files []archiveFile
+
+	for _, entry := range entries {
+		period, ok := archiveFilePeriod(stem, entry.Name())
+		if ok {
+			files = append(files, archiveFile{
+				path:   filepath.Join(dir, entry.Name()),
+				period: period,
+			})
+		}
+	}
+
+	// A month sorts before the days and hours in it.
+	slices.SortFunc(files, func(a, b archiveFile) int {
+		return strings.Compare(a.period, b.period)
+	})
+
+	return files, nil
+}
+
+// archiveFilePeriod reports whether name is the name of an archive
+// file of the target whose file name without a period is stem+".db",
+// and the period in it.
+func archiveFilePeriod(stem, name string) (string, bool) {
+	rest, ok := strings.CutPrefix(name, stem)
+	if !ok {
+		return "", false
+	}
+
+	rest, ok = strings.CutSuffix(rest, ".db")
+	if !ok {
+		return "", false
+	}
+
+	if rest == "" {
+		return "", true
+	}
+
+	period, ok := strings.CutPrefix(rest, "-")
+	if !ok {
+		return "", false
+	}
+
+	for _, layout := range []string{
+		archiveMonthLayout, archiveDayLayout, archiveHourLayout,
+	} {
+		_, err := time.Parse(layout, period)
+		if err == nil {
+			return period, true
+		}
+	}
+
+	return "", false
+}

internal/archive/rotation_test.go

@@ -0,0 +1,375 @@
+package archive_test
+
+import (
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"sneak.berlin/go/webhooker/internal/archive"
+	"sneak.berlin/go/webhooker/internal/database"
+	"sneak.berlin/go/webhooker/internal/database/databasetest"
+)
+
+// The archive rotations.
+const (
+	rotationNone    = "none"
+	rotationMonthly = "monthly"
+	rotationDaily   = "daily"
+	rotationHourly  = "hourly"
+)
+
+// The periods the tests archive into most: two days, and an hour of
+// the first.
+const (
+	dayPeriod     = "2026-03-04"
+	nextDayPeriod = "2026-03-05"
+	hourPeriod    = "2026-03-04-05"
+)
+
+// periodPath returns the archive file for a period of the target whose
+// file without a period is path.
+func periodPath(path, period string) string {
+	return strings.TrimSuffix(path, ".db") + "-" + period + ".db"
+}
+
+// deliverReceivedAt archives, as a delivery to a database target
+// does, an event whose receive time is receivedAt, and returns the
+// event's id. The receive time is what decides a rotated archive's
+// file, so setting it is how these tests move the clock across a
+// period boundary.
+func (env *archiveEnv) deliverReceivedAt(
+	t *testing.T, tgt *database.Target, receivedAt time.Time,
+) string {
+	t.Helper()
+
+	event := newEvent(`{"n":1}`)
+	event.CreatedAt = receivedAt
+
+	require.NoError(t, env.writers.Write(databaseTargetDelivery(event, tgt)))
+
+	return event.ID
+}
+
+// TestWrite_RotatesAtEachPeriodBoundary writes, for each
+// rotation, an event received in the last second of a period and one
+// received in the first second of the next, and checks each lands in
+// the file named for its own period, in UTC. Rotation none keeps both
+// in the one file.
+func TestWrite_RotatesAtEachPeriodBoundary(t *testing.T) {
+	t.Parallel()
+
+	berlin := time.FixedZone("CEST", 2*60*60)
+
+	cases := []struct {
+		name          string
+		rotation      string
+		before, after time.Time
+		// periods are the periods of before and after.
+		periods [2]string
+	}{
+		{
+			rotationMonthly, rotationMonthly,
+			time.Date(2026, 1, 31, 23, 59, 59, 0, time.UTC),
+			time.Date(2026, 2, 1, 0, 0, 0, 0, time.UTC),
+			[2]string{"2026-01", "2026-02"},
+		},
+		{
+			rotationDaily, rotationDaily,
+			time.Date(2026, 3, 4, 23, 59, 59, 0, time.UTC),
+			time.Date(2026, 3, 5, 0, 0, 0, 0, time.UTC),
+			[2]string{dayPeriod, nextDayPeriod},
+		},
+		{
+			// The same instants, received in a zone two hours ahead
+			// of UTC, where they fall on 5 March: the period is UTC's.
+			"daily in another zone", rotationDaily,
+			time.Date(2026, 3, 5, 1, 59, 59, 0, berlin),
+			time.Date(2026, 3, 5, 2, 0, 0, 0, berlin),
+			[2]string{dayPeriod, nextDayPeriod},
+		},
+		{
+			rotationHourly, rotationHourly,
+			time.Date(2026, 3, 4, 5, 59, 59, 0, time.UTC),
+			time.Date(2026, 3, 4, 6, 0, 0, 0, time.UTC),
+			[2]string{hourPeriod, "2026-03-04-06"},
+		},
+	}
+
+	for _, tc := range cases {
+		t.Run(tc.name, func(t *testing.T) {
+			t.Parallel()
+
+			env := setupArchiveTest(t)
+			tgt := env.seedDatabaseTarget(t, 0, tc.rotation)
+			path := env.archivePath(tgt)
+
+			first := env.deliverReceivedAt(t, tgt, tc.before)
+			second := env.deliverReceivedAt(t, tgt, tc.after)
+
+			assert.Equal(t, []string{first},
+				archivedEventIDs(t, periodPath(path, tc.periods[0])))
+			assert.Equal(t, []string{second},
+				archivedEventIDs(t, periodPath(path, tc.periods[1])))
+			assert.NoFileExists(t, path,
+				"a rotated target never writes the file without a period")
+		})
+	}
+
+	t.Run(rotationNone, func(t *testing.T) {
+		t.Parallel()
+
+		env := setupArchiveTest(t)
+		tgt := env.seedDatabaseTarget(t, 0, rotationNone)
+
+		first := env.deliverReceivedAt(t, tgt, cases[0].before)
+		second := env.deliverReceivedAt(t, tgt, cases[0].after)
+
+		assert.ElementsMatch(t, []string{first, second},
+			archivedEventIDs(t, env.archivePath(tgt)))
+	})
+}
+
+// TestWrite_EventWithoutReceiveTime proves an event whose
+// receive time is not known goes to the file for the time it is
+// archived, rather than to one for the year 1.
+func TestWrite_EventWithoutReceiveTime(t *testing.T) {
+	t.Parallel()
+
+	env := setupArchiveTest(t)
+	tgt := env.seedDatabaseTarget(t, 0, rotationMonthly)
+	path := env.archivePath(tgt)
+
+	before := time.Now().UTC().Format("2006-01")
+	id := env.deliverReceivedAt(t, tgt, time.Time{})
+
+	file := periodPath(path, time.Now().UTC().Format("2006-01"))
+
+	_, err := os.Stat(file)
+	if err != nil {
+		// The month turned during the delivery.
+		file = periodPath(path, before)
+	}
+
+	assert.Equal(t, []string{id}, archivedEventIDs(t, file))
+	assert.NoFileExists(t, periodPath(path, "0001-01"))
+}
+
+// TestWrite_RotationChangeKeepsOldFiles changes a target's
+// rotation from none to daily between two events, and checks the
+// second goes to the daily file while the first stays where it was.
+func TestWrite_RotationChangeKeepsOldFiles(t *testing.T) {
+	t.Parallel()
+
+	env := setupArchiveTest(t)
+	tgt := env.seedDatabaseTarget(t, 0, rotationNone)
+	path := env.archivePath(tgt)
+	at := time.Date(2026, 3, 4, 12, 0, 0, 0, time.UTC)
+
+	first := env.deliverReceivedAt(t, tgt, at)
+
+	tgt.ArchiveRotation = rotationDaily
+	second := env.deliverReceivedAt(t, tgt, at)
+
+	assert.Equal(t, []string{first}, archivedEventIDs(t, path))
+	assert.Equal(t, []string{second},
+		archivedEventIDs(t, periodPath(path, dayPeriod)))
+}
+
+// TestArchiveSweep_PrunesEveryFile gives a daily target three files:
+// the file without a period, left from before it rotated, and two
+// daily files. Each holds a row older than the expiry, and one daily
+// file also a newer row. The sweep prunes the old row from every file,
+// deletes the daily file it leaves empty, and keeps the file without a
+// period although it is empty too.
+func TestArchiveSweep_PrunesEveryFile(t *testing.T) {
+	t.Parallel()
+
+	env := setupArchiveTest(t)
+	tgt := env.seedDatabaseTarget(t, time.Hour, rotationDaily)
+	path := env.archivePath(tgt)
+	emptied := periodPath(path, dayPeriod)
+	kept := periodPath(path, nextDayPeriod)
+
+	now := time.Now()
+	old := now.Add(-48 * time.Hour)
+
+	seedArchiveFile(t, path, tgt.WebhookID, old)
+	seedArchiveFile(t, emptied, tgt.WebhookID, old)
+	seedArchiveFile(t, kept, tgt.WebhookID, old, now.Add(-time.Minute))
+
+	env.sweeper.ExportSweep(t.Context())
+
+	assert.Empty(t, archivedEventIDs(t, path))
+	assert.Equal(t, []string{sweepRowNew}, archivedEventIDs(t, kept))
+
+	for _, suffix := range archiveFileSuffixes() {
+		assert.NoFileExists(t, emptied+suffix)
+	}
+}
+
+// TestRename_MovesEveryFile renames a daily target that also has a
+// file without a period, and checks every file moves to the new name
+// with its period, rows and all, and that a later write uses the new
+// name.
+func TestRename_MovesEveryFile(t *testing.T) {
+	t.Parallel()
+
+	env := setupArchiveTest(t)
+	tgt := env.seedDatabaseTarget(t, 0, rotationNone)
+	oldPath := env.archivePath(tgt)
+	day := time.Date(2026, 3, 4, 12, 0, 0, 0, time.UTC)
+
+	unrotated := env.deliverReceivedAt(t, tgt, day)
+
+	tgt.ArchiveRotation = rotationDaily
+	first := env.deliverReceivedAt(t, tgt, day)
+	second := env.deliverReceivedAt(t, tgt, day.Add(24*time.Hour))
+
+	require.NoError(t, env.writers.Rename(tgt.ID, "Orders", "Long Term"))
+
+	newPath := filepath.Join(
+		env.dataDir, "archive-orders-long-term-"+tgt.ID+".db",
+	)
+
+	for _, old := range []string{
+		oldPath,
+		periodPath(oldPath, dayPeriod),
+		periodPath(oldPath, nextDayPeriod),
+	} {
+		assert.NoFileExists(t, old)
+	}
+
+	assert.Equal(t, []string{unrotated}, archivedEventIDs(t, newPath))
+	assert.Equal(t, []string{first},
+		archivedEventIDs(t, periodPath(newPath, dayPeriod)))
+	assert.Equal(t, []string{second},
+		archivedEventIDs(t, periodPath(newPath, nextDayPeriod)))
+
+	third := env.deliverReceivedAt(t, tgt, day.Add(48*time.Hour))
+	assert.Equal(t, []string{third},
+		archivedEventIDs(t, periodPath(newPath, "2026-03-06")))
+}
+
+// TestRename_NeverReplacesARotatedFile plants a file at the new name
+// of a target's daily file, and proves the rename is refused and moves
+// none of the target's files.
+func TestRename_NeverReplacesARotatedFile(t *testing.T) {
+	t.Parallel()
+
+	env := setupArchiveTest(t)
+	tgt := env.seedDatabaseTarget(t, 0, rotationDaily)
+	oldPath := env.archivePath(tgt)
+	day := time.Date(2026, 3, 4, 12, 0, 0, 0, time.UTC)
+
+	env.deliverReceivedAt(t, tgt, day)
+	env.deliverReceivedAt(t, tgt, day.Add(24*time.Hour))
+
+	newPath := filepath.Join(
+		env.dataDir, "archive-orders-long-term-"+tgt.ID+".db",
+	)
+	planted := periodPath(newPath, nextDayPeriod)
+	require.NoError(t, os.WriteFile(planted, []byte("planted"), 0o600))
+
+	require.ErrorIs(
+		t, env.writers.Rename(tgt.ID, "Orders", "Long Term"),
+		archive.ErrNameTaken,
+	)
+
+	assert.FileExists(t, periodPath(oldPath, dayPeriod))
+	assert.FileExists(t, periodPath(oldPath, nextDayPeriod))
+	assert.NoFileExists(t, periodPath(newPath, dayPeriod))
+}
+
+// TestStatArchive_EveryFile proves Stat counts and adds up every
+// one of a target's files, takes the latest write of any of them, and
+// leaves out files whose names only look like the target's.
+func TestStatArchive_EveryFile(t *testing.T) {
+	t.Parallel()
+
+	dir := t.TempDir()
+	path := filepath.Join(dir, "archive-wh.db")
+	files := []string{
+		path, periodPath(path, "2026-03"), periodPath(path, hourPeriod),
+	}
+	written := time.Date(2026, 3, 4, 5, 6, 7, 0, time.UTC)
+
+	var size int64
+
+	for i, file := range files {
+		require.NoError(t, os.WriteFile(file, make([]byte, 100*(i+1)), 0o600))
+
+		size += int64(100 * (i + 1))
+		at := written.Add(-time.Duration(i) * time.Hour)
+		require.NoError(t, os.Chtimes(file, at, at))
+	}
+
+	for _, other := range []string{
+		"archive-wh-2026-13.db", "archive-wh-2026-3.db",
+		"archive-wh-other.db", "archive-wh-2026-03.json",
+		"archive-whx.db",
+	} {
+		require.NoError(t,
+			os.WriteFile(filepath.Join(dir, other), []byte("x"), 0o600))
+	}
+
+	got, err := archive.Stat(path)
+	require.NoError(t, err)
+	assert.Equal(t, len(files), got.Files)
+	assert.Equal(t, size, got.Size)
+	assert.True(t, written.Equal(got.Written), got.Written)
+}
+
+// TestArchivePathAt names the file each rotation writes an event to.
+func TestArchivePathAt(t *testing.T) {
+	t.Parallel()
+
+	dataDir := t.TempDir()
+	dbMgr := databasetest.NewWebhookDBManager(t, dataDir)
+	webhook := &database.Webhook{
+		BaseModel: database.BaseModel{ID: "wh-id"}, Name: "Orders",
+	}
+	at := time.Date(2026, 10, 1, 19, 30, 0, 0, time.UTC)
+
+	cases := map[string]string{
+		"":              "",
+		rotationNone:    "",
+		rotationMonthly: "-2026-10",
+		rotationDaily:   "-2026-10-01",
+		rotationHourly:  "-2026-10-01-19",
+	}
+
+	for rotation, period := range cases {
+		target := &database.Target{
+			BaseModel:       database.BaseModel{ID: "tgt-id"},
+			Name:            "Archive",
+			ArchiveRotation: rotation,
+		}
+
+		assert.Equal(t,
+			filepath.Join(
+				dataDir, "archive-orders-archive-tgt-id"+period+".db",
+			),
+			archive.PathAt(dbMgr, webhook, target, at), rotation,
+		)
+	}
+}
+
+// TestValidateArchiveRotation accepts the four rotations, and empty,
+// and refuses anything else.
+func TestValidateArchiveRotation(t *testing.T) {
+	t.Parallel()
+
+	for _, ok := range []string{
+		"", rotationNone, rotationMonthly, rotationDaily, rotationHourly,
+	} {
+		require.NoError(t, archive.ValidateRotation(ok), ok)
+	}
+
+	for _, bad := range []string{"weekly", "Daily", "hourly "} {
+		require.Error(t, archive.ValidateRotation(bad), bad)
+	}
+}

internal/archive/sweeper.go

@@ -1,4 +1,4 @@
-package delivery
+package archive
 
 import (
 	"context"
@@ -8,56 +8,62 @@ import (
 	"time"
 
 	"go.uber.org/fx"
+	"gorm.io/gorm"
 	"sneak.berlin/go/webhooker/internal/config"
 	"sneak.berlin/go/webhooker/internal/database"
 	"sneak.berlin/go/webhooker/internal/lifecycle"
 	"sneak.berlin/go/webhooker/internal/logger"
 )
 
-// ArchiveSweeperParams holds the fx dependencies for the
-// ArchiveSweeper.
-type ArchiveSweeperParams struct {
+// SweeperParams holds the fx dependencies for the
+// Sweeper.
+type SweeperParams struct {
 	fx.In
 
 	Config   *config.Config
 	Database *database.Database
-	Engine   *Engine
+	Writers  *Writers
 	Logger   *logger.Logger
 }
 
-// ArchiveSweeper periodically prunes expired rows from
-// per-webhook archive databases whose database target carries a
-// positive expiry.
+// Sweeper periodically prunes expired rows from the
+// archive databases of database targets that carry a positive
+// expiry.
 //
 // Without it, pruning happens only when an archive is
 // (re)opened, and archives are only ever reopened by writes: an
-// archive belonging to a webhook that has stopped receiving
-// events would keep its expired rows forever. The sweep closes
+// archive whose target has stopped receiving events would keep
+// its expired rows forever. The sweep closes
 // that gap without changing anything for archives whose expiry
 // is unset or "never".
 //
 // It reuses Config.RetentionSweepInterval rather than
 // introducing a second interval: this is a retention sweep with
 // the same semantics as the event retention reaper.
-type ArchiveSweeper struct {
+type Sweeper struct {
 	db       *database.Database
-	eng      *Engine
+	writers  *Writers
 	log      *slog.Logger
 	interval time.Duration
-	cancel   context.CancelFunc
-	wg       sync.WaitGroup
+
+	// cancel needs no lock: fx calls the stop hook only after the
+	// start hook has returned, so stop never reads it while start
+	// is still setting it.
+	cancel context.CancelFunc
+
+	wg sync.WaitGroup
 }
 
-// NewArchiveSweeper creates the archive sweeper and registers
+// NewSweeper creates the archive sweeper and registers
 // its fx lifecycle hooks. The background sweep loop starts on
 // OnStart and stops cleanly on OnStop via context cancellation.
-func NewArchiveSweeper(
+func NewSweeper(
 	lc fx.Lifecycle,
-	params ArchiveSweeperParams,
-) *ArchiveSweeper {
-	s := &ArchiveSweeper{
+	params SweeperParams,
+) *Sweeper {
+	s := &Sweeper{
 		db:       params.Database,
-		eng:      params.Engine,
+		writers:  params.Writers,
 		log:      params.Logger.Get(),
 		interval: params.Config.RetentionSweepInterval,
 	}
@@ -71,7 +77,7 @@ func NewArchiveSweeper(
 // lifecycle. The start hook's context is deliberately ignored
 // (see start for why the background loop must not inherit it);
 // the stop hook's context is honoured (see stop).
-func (s *ArchiveSweeper) registerHooks(lc fx.Lifecycle) {
+func (s *Sweeper) registerHooks(lc fx.Lifecycle) {
 	lc.Append(fx.Hook{
 		//nolint:contextcheck // Not passing the hook context is
 		// the point: see start.
@@ -97,7 +103,7 @@ func (s *ArchiveSweeper) registerHooks(lc fx.Lifecycle) {
 // goroutine must outlive the startup phase, so its lifetime is
 // bounded by OnStop instead: stop cancels this context and waits
 // on the WaitGroup.
-func (s *ArchiveSweeper) start() {
+func (s *Sweeper) start() {
 	ctx, cancel := context.WithCancel(context.Background())
 	s.cancel = cancel
 
@@ -115,7 +121,7 @@ func (s *ArchiveSweeper) start() {
 // exit, bounded by the stop hook's context: a prune wedged on a
 // locked archive must not hang the process past fx's stop
 // timeout.
-func (s *ArchiveSweeper) stop(ctx context.Context) error {
+func (s *Sweeper) stop(ctx context.Context) error {
 	s.log.Info("archive sweeper stopping")
 
 	if s.cancel != nil {
@@ -134,7 +140,7 @@ func (s *ArchiveSweeper) stop(ctx context.Context) error {
 	return nil
 }
 
-func (s *ArchiveSweeper) run(ctx context.Context) {
+func (s *Sweeper) run(ctx context.Context) {
 	defer s.wg.Done()
 
 	ticker := time.NewTicker(s.interval)
@@ -155,17 +161,25 @@ func (s *ArchiveSweeper) run(ctx context.Context) {
 // soft-deleted along with it, so GORM's default scope already
 // excludes them.
 //
-// A failure for one webhook is logged and the sweep continues,
+// A failure for one target is logged and the sweep continues,
 // matching how the write path already treats a prune error as
 // non-fatal.
-func (s *ArchiveSweeper) sweep(ctx context.Context) {
+func (s *Sweeper) sweep(ctx context.Context) {
 	var targets []database.Target
 
 	err := s.db.DB().
+		WithContext(ctx).
 		Model(&database.Target{}).
 		Where("type = ?", database.TargetTypeDatabase).
 		Find(&targets).Error
 	if err != nil {
+		// The app stopping as a sweep starts cancels the listing.
+		// Stopping is not a failure, so it must not produce an
+		// error line.
+		if ctx.Err() != nil {
+			return
+		}
+
 		s.log.Error(
 			"archive sweep: failed to list database targets",
 			"error", err,
@@ -185,44 +199,33 @@ func (s *ArchiveSweeper) sweep(ctx context.Context) {
 	}
 }
 
-// sweepTarget prunes the archive of a single database target.
-// A missing, empty, or "never" expiry parses as a zero duration
-// and is skipped entirely, so those archives keep exactly the
-// behaviour they had before the sweep existed.
-func (s *ArchiveSweeper) sweepTarget(target *database.Target) {
-	expiry, err := parseArchiveExpiry(target.Config)
-	if err != nil {
-		s.log.Error(
-			"archive sweep: invalid database target config",
-			"webhook_id", target.WebhookID,
-			"target_id", target.ID,
-			"error", err,
-		)
-
-		return
-	}
-
+// sweepTarget prunes the archive of a single database target. A
+// target with an ArchiveExpiry of 0 keeps its archive forever and is
+// skipped entirely, so that archive is never pruned.
+func (s *Sweeper) sweepTarget(target *database.Target) {
+	expiry := target.ArchiveExpiry
 	if expiry <= 0 {
 		return
 	}
 
-	if s.eng == nil || s.eng.dbTarget == nil {
+	if s.writers == nil {
 		return
 	}
 
-	err = s.eng.dbTarget.sweepWebhook(target.WebhookID, expiry)
+	err := s.writers.sweepArchive(target.ID, expiry)
 	if err == nil {
 		return
 	}
 
-	// A writer evicted underneath the sweep means the operator
-	// deleted the webhook (or its last database target) while the
-	// sweep was walking the target list. That is an ordinary
+	// A writer evicted, or a target row gone, underneath the sweep
+	// means the operator deleted the target or its webhook while
+	// the sweep was walking the target list. That is an ordinary
 	// interleaving, not a failure, so it must not produce an
 	// error line.
-	if errors.Is(err, errArchiveWriterEvicted) {
+	if errors.Is(err, errArchiveWriterEvicted) ||
+		errors.Is(err, gorm.ErrRecordNotFound) {
 		s.log.Debug(
-			"archive sweep: writer evicted mid-sweep",
+			"archive sweep: target deleted mid-sweep",
 			"webhook_id", target.WebhookID,
 			"target_id", target.ID,
 		)

internal/archive/sweeper_test.go

@@ -1,9 +1,11 @@
-package delivery_test
+package archive_test
 
 import (
+	"bytes"
 	"context"
 	"database/sql"
 	"fmt"
+	"log/slog"
 	"net/http"
 	"os"
 	"path/filepath"
@@ -14,12 +16,16 @@ import (
 	"github.com/google/uuid"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
+	"go.uber.org/fx"
 	"gorm.io/driver/sqlite"
 	"gorm.io/gorm"
 	"gorm.io/gorm/clause"
 	_ "modernc.org/sqlite" // Pure Go SQLite driver.
+	"sneak.berlin/go/webhooker/internal/archive"
 	"sneak.berlin/go/webhooker/internal/database"
-	"sneak.berlin/go/webhooker/internal/delivery"
+	"sneak.berlin/go/webhooker/internal/database/databasetest"
+	"sneak.berlin/go/webhooker/internal/db/migrations"
+	"sneak.berlin/go/webhooker/internal/gormlog"
 )
 
 const (
@@ -32,81 +38,84 @@ const (
 	// sweepConcurrentWrites is how many deliveries the
 	// concurrent write-plus-sweep test races against the sweep.
 	sweepConcurrentWrites = 20
+
+	// hookStopTimeout bounds how long a lifecycle test waits for
+	// the sweeper's OnStop hook to return before declaring the
+	// shutdown hung.
+	hookStopTimeout = 10 * time.Second
+
+	// wedgeStopTimeout is the stop timeout a wedged-shutdown test
+	// hands OnStop, standing in for fx's StopTimeout. The test
+	// asserts only that the hook returns at all, and allows it
+	// hookStopTimeout — forty times this budget — to do so, so no
+	// assertion here races the wall clock.
+	wedgeStopTimeout = 250 * time.Millisecond
 )
 
-// sweeperEnv bundles the pieces an archive sweep test drives:
-// a main configuration database holding webhooks and targets, a
-// delivery engine owning the archive writer registry, and the
-// data directory the archive files live in.
-type sweeperEnv struct {
-	sweeper *delivery.ArchiveSweeper
-	eng     *delivery.Engine
+// archiveTestWebhookName is the name of every webhook
+// seedDatabaseTarget creates. It is not safe in a file name as it
+// stands, so every archive test goes through archiveNamePart.
+const archiveTestWebhookName = "Sweep Test!"
+
+// archiveEnv bundles the pieces an archive test drives: a main
+// configuration database holding webhooks and targets, the archive
+// writers, the archive sweeper, and the data directory the archive
+// files live in.
+type archiveEnv struct {
+	sweeper *archive.Sweeper
+	writers *archive.Writers
 	mainDB  *database.Database
 	dataDir string
 }
 
-func setupSweeperTest(t *testing.T) *sweeperEnv {
+func setupArchiveTest(t *testing.T) *archiveEnv {
 	t.Helper()
 
 	dataDir := t.TempDir()
 	log := archiveTestLogger()
 
-	sqlDB, err := sql.Open(
-		"sqlite",
-		fmt.Sprintf(
-			"file:%s?mode=rwc",
-			filepath.Join(dataDir, "main.db"),
-		),
-	)
+	mainDB, err := database.Open(dataDir, slog.New(slog.DiscardHandler))
 	require.NoError(t, err)
 
-	t.Cleanup(func() { _ = sqlDB.Close() })
+	t.Cleanup(func() { _ = mainDB.Close() })
 
-	gdb, err := gorm.Open(
-		sqlite.Dialector{Conn: sqlDB}, &gorm.Config{},
-	)
-	require.NoError(t, err)
+	writers := archive.NewWriters(archive.WritersParams{
+		Database:  mainDB,
+		DBManager: databasetest.NewWebhookDBManager(t, dataDir),
+		Logger:    log,
+	})
 
-	mainDB := database.NewTestDatabase(gdb)
-	require.NoError(t, mainDB.Migrate())
-
-	eng := delivery.NewTestEngineWithDB(
-		mainDB,
-		database.NewTestWebhookDBManager(dataDir),
-		log,
-		&http.Client{Timeout: 5 * time.Second},
-		1,
-	)
-
-	return &sweeperEnv{
-		sweeper: delivery.NewTestArchiveSweeper(
-			mainDB, eng, log,
+	return &archiveEnv{
+		sweeper: archive.NewTestSweeper(
+			mainDB, writers, log,
 		),
-		eng:     eng,
+		writers: writers,
 		mainDB:  mainDB,
 		dataDir: dataDir,
 	}
 }
 
-// archivePath returns where the engine keeps a webhook's
-// archive file.
-func (env *sweeperEnv) archivePath(webhookID string) string {
+// archivePath returns where the writers keep a database target's
+// archive file, for the names seedDatabaseTarget gave it.
+func (env *archiveEnv) archivePath(tgt *database.Target) string {
 	return filepath.Join(
-		env.dataDir, fmt.Sprintf("archive-%s.db", webhookID),
+		env.dataDir,
+		archive.FileName(
+			archiveTestWebhookName, tgt.Name, tgt.ID,
+		),
 	)
 }
 
-// seedDatabaseTarget creates a webhook with one database target
-// carrying the given target config JSON, and returns the
-// webhook id.
-func (env *sweeperEnv) seedDatabaseTarget(
-	t *testing.T, configJSON string,
-) string {
+// seedDatabaseTarget creates a webhook with one database target with
+// the given archive expiry and rotation, and returns the target.
+func (env *archiveEnv) seedDatabaseTarget(
+	t *testing.T, expiry time.Duration, rotation string,
+) *database.Target {
 	t.Helper()
 
 	wh := &database.Webhook{
 		UserID: uuid.New().String(),
-		Name:   "sweep-test",
+		Name:   archiveTestWebhookName,
 	}
 	require.NoError(
 		t,
@@ -115,12 +124,27 @@ func (env *sweeperEnv) seedDatabaseTarget(
 			Create(wh).Error,
 	)
 
+	return env.addDatabaseTarget(t, wh.ID, expiry, rotation)
+}
+
+// addDatabaseTarget creates one more database target on an
+// existing webhook and returns it.
+func (env *archiveEnv) addDatabaseTarget(
+	t *testing.T,
+	webhookID string,
+	expiry time.Duration,
+	rotation string,
+) *database.Target {
+	t.Helper()
+
 	tgt := &database.Target{
-		WebhookID: wh.ID,
-		Name:      "archive",
-		Type:      database.TargetTypeDatabase,
-		Active:    true,
-		Config:    configJSON,
+		WebhookID:       webhookID,
+		Name:            "Archive",
+		Type:            database.TargetTypeDatabase,
+		Active:          true,
+		ArchiveExpiry:   expiry,
+		ArchiveRotation: rotation,
+		MaxAttempts:     1,
 	}
 	require.NoError(
 		t,
@@ -129,19 +153,30 @@ func (env *sweeperEnv) seedDatabaseTarget(
 			Create(tgt).Error,
 	)
 
-	return wh.ID
+	return tgt
 }
 
-// seedArchiveRows creates the archive file for a webhook and
+// seedArchiveRows creates the archive file for a target and
 // inserts one row per supplied archived-at timestamp, returning
 // the archive path. The handle is closed before returning, so
 // the archive is idle exactly as it would be with no traffic.
-func (env *sweeperEnv) seedArchiveRows(
-	t *testing.T, webhookID string, archivedAt ...time.Time,
+func (env *archiveEnv) seedArchiveRows(
+	t *testing.T, tgt *database.Target, archivedAt ...time.Time,
 ) string {
 	t.Helper()
 
-	path := env.archivePath(webhookID)
+	path := env.archivePath(tgt)
+	seedArchiveFile(t, path, tgt.WebhookID, archivedAt...)
+
+	return path
+}
+
+// seedArchiveFile creates the archive file at path and inserts one row
+// per supplied archived-at timestamp, as seedArchiveRows does.
+func seedArchiveFile(
+	t *testing.T, path, webhookID string, archivedAt ...time.Time,
+) {
+	t.Helper()
 
 	sqlDB, err := sql.Open(
 		"sqlite", fmt.Sprintf("file:%s?mode=rwc", path),
@@ -149,16 +184,15 @@ func (env *sweeperEnv) seedArchiveRows(
 	require.NoError(t, err)
 
 	gdb, err := gorm.Open(
-		sqlite.Dialector{Conn: sqlDB}, &gorm.Config{},
+		sqlite.Dialector{Conn: sqlDB},
+		&gorm.Config{Logger: gormlog.New(slog.New(slog.DiscardHandler))},
 	)
 	require.NoError(t, err)
 
-	require.NoError(
-		t, gdb.AutoMigrate(&delivery.ExportArchivedEvent{}),
-	)
+	require.NoError(t, migrations.Apply(gdb, migrations.Archive))
 
 	for i, at := range archivedAt {
-		row := delivery.ExportArchivedEvent{
+		row := archive.ExportArchivedEvent{
 			EventID:    fmt.Sprintf("ev-%d", i),
 			WebhookID:  webhookID,
 			Method:     http.MethodPost,
@@ -169,8 +203,6 @@ func (env *sweeperEnv) seedArchiveRows(
 	}
 
 	require.NoError(t, sqlDB.Close())
-
-	return path
 }
 
 // archivedEventIDs returns the event ids currently stored in an
@@ -180,7 +212,7 @@ func archivedEventIDs(
 ) []string {
 	t.Helper()
 
-	var rows []delivery.ExportArchivedEvent
+	var rows []archive.ExportArchivedEvent
 
 	rdb := openArchiveDBForRead(t, path)
 	require.NoError(t, rdb.Order("event_id").Find(&rows).Error)
@@ -208,7 +240,8 @@ func countArchivedRows(path string) (int64, error) {
 	defer func() { _ = sqlDB.Close() }()
 
 	gdb, err := gorm.Open(
-		sqlite.Dialector{Conn: sqlDB}, &gorm.Config{},
+		sqlite.Dialector{Conn: sqlDB},
+		&gorm.Config{Logger: gormlog.New(slog.New(slog.DiscardHandler))},
 	)
 	if err != nil {
 		return 0, err
@@ -216,7 +249,7 @@ func countArchivedRows(path string) (int64, error) {
 
 	var count int64
 
-	err = gdb.Model(&delivery.ExportArchivedEvent{}).
+	err = gdb.Model(&archive.ExportArchivedEvent{}).
 		Count(&count).Error
 	if err != nil {
 		return 0, err
@@ -225,6 +258,55 @@ func countArchivedRows(path string) (int64, error) {
 	return count, nil
 }
 
+// recordingLifecycle is a minimal fx.Lifecycle that records the
+// hooks a component registers, so a test can invoke the real
+// OnStart/OnStop functions with a context of its choosing.
+type recordingLifecycle struct {
+	hooks []fx.Hook
+}
+
+func (l *recordingLifecycle) Append(h fx.Hook) {
+	l.hooks = append(l.hooks, h)
+}
+
+// requireStopHookExpires drives hook.OnStop with a stop context
+// that expires while a wedged goroutine is still running, and
+// requires the hook to return the deadline error naming
+// component instead of blocking on the WaitGroup forever.
+func requireStopHookExpires(
+	t *testing.T, hook fx.Hook, component string,
+) {
+	t.Helper()
+
+	stopCtx, cancel := context.WithTimeout(
+		context.Background(), wedgeStopTimeout,
+	)
+	defer cancel()
+
+	var stopErr error
+
+	stopped := make(chan struct{})
+
+	go func() {
+		defer close(stopped)
+
+		stopErr = hook.OnStop(stopCtx)
+	}()
+
+	select {
+	case <-stopped:
+	case <-time.After(hookStopTimeout):
+		t.Fatal(
+			"OnStop did not return: it discarded the stop " +
+				"context and is waiting on a wedged goroutine " +
+				"that will never observe cancellation",
+		)
+	}
+
+	require.ErrorIs(t, stopErr, context.DeadlineExceeded)
+	require.ErrorContains(t, stopErr, component)
+}
+
 // TestArchiveSweeper_LoopOutlivesStartHookContext is the
 // regression test for a sweeper that never swept. fx calls
 // OnStart with a context carrying the application's start
@@ -243,13 +325,13 @@ func TestArchiveSweeper_LoopOutlivesStartHookContext(
 ) {
 	t.Parallel()
 
-	env := setupSweeperTest(t)
+	env := setupArchiveTest(t)
 
-	webhookID := env.seedDatabaseTarget(t, `{"expiry":"1h"}`)
+	tgt := env.seedDatabaseTarget(t, time.Hour, "")
 
 	now := time.Now()
 	path := env.seedArchiveRows(
-		t, webhookID,
+		t, tgt,
 		now.Add(-48*time.Hour),
 		now.Add(-time.Minute),
 	)
@@ -287,60 +369,60 @@ func TestArchiveSweeper_LoopOutlivesStartHookContext(
 }
 
 // TestArchiveSweep_DoesNotResurrectEvictedWriter covers the
-// interleaving where a sweep tick has already listed a webhook's
-// target when the webhook is deleted and its writer evicted. The
-// sweep must not put a writer back into the registry: nothing
-// would ever evict it again, which is precisely the leak this
-// change exists to close.
+// interleaving where a sweep tick has already listed a target
+// when the target is deleted and its writer evicted. The sweep
+// must not put a writer back into the registry: nothing would
+// ever evict it again, which is precisely the leak this change
+// exists to close.
 func TestArchiveSweep_DoesNotResurrectEvictedWriter(
 	t *testing.T,
 ) {
 	t.Parallel()
 
-	env := setupSweeperTest(t)
+	env := setupArchiveTest(t)
 
-	webhookID := env.seedDatabaseTarget(t, `{"expiry":"1h"}`)
+	tgt := env.seedDatabaseTarget(t, time.Hour, "")
 	env.seedArchiveRows(
-		t, webhookID, time.Now().Add(-48*time.Hour),
+		t, tgt, time.Now().Add(-48*time.Hour),
 	)
 
 	// Prime the registry the way a delivery would, then evict as
 	// the deletion path does. The target row is deliberately left
-	// in place: this is the tick that listed the webhook before
+	// in place: this is the tick that listed the target before
 	// the deletion committed.
-	_, err := env.eng.ExportEnsureArchiveWriter(webhookID)
+	_, err := env.writers.ExportEnsureArchiveWriter(tgt.ID)
 	require.NoError(t, err)
 
-	env.eng.EvictWebhook(webhookID)
-	require.False(t, env.eng.ExportHasArchiveWriter(webhookID))
+	env.writers.EvictTarget(tgt.ID)
+	require.False(t, env.writers.ExportHasArchiveWriter(tgt.ID))
 
 	env.sweeper.ExportSweep(context.Background())
 
 	assert.False(
-		t, env.eng.ExportHasArchiveWriter(webhookID),
-		"a sweep must never re-register a writer for a webhook "+
+		t, env.writers.ExportHasArchiveWriter(tgt.ID),
+		"a sweep must never re-register a writer for a target "+
 			"whose registry entry has already been released",
 	)
 }
 
 // TestArchiveSweep_LeavesNoRegistryEntry states the same
 // invariant in its general form: sweeping an archive whose
-// webhook has no cached writer must not leave one behind, so the
+// target has no cached writer must not leave one behind, so the
 // registry keeps holding only writers a delivery created and an
 // eviction can reach.
 func TestArchiveSweep_LeavesNoRegistryEntry(t *testing.T) {
 	t.Parallel()
 
-	env := setupSweeperTest(t)
+	env := setupArchiveTest(t)
 
-	webhookID := env.seedDatabaseTarget(t, `{"expiry":"1h"}`)
+	tgt := env.seedDatabaseTarget(t, time.Hour, "")
 	path := env.seedArchiveRows(
-		t, webhookID,
+		t, tgt,
 		time.Now().Add(-48*time.Hour),
 		time.Now().Add(-time.Minute),
 	)
 
-	require.False(t, env.eng.ExportHasArchiveWriter(webhookID))
+	require.False(t, env.writers.ExportHasArchiveWriter(tgt.ID))
 
 	env.sweeper.ExportSweep(context.Background())
 
@@ -349,7 +431,7 @@ func TestArchiveSweep_LeavesNoRegistryEntry(t *testing.T) {
 		"the sweep must still prune an idle archive",
 	)
 	assert.False(
-		t, env.eng.ExportHasArchiveWriter(webhookID),
+		t, env.writers.ExportHasArchiveWriter(tgt.ID),
 		"the sweep must release the registry entry it created",
 	)
 }
@@ -364,34 +446,29 @@ func TestArchiveSweep_KeepsWriterAdoptedByDelivery(
 ) {
 	t.Parallel()
 
-	env := setupSweeperTest(t)
+	env := setupArchiveTest(t)
 
-	webhookID := env.seedDatabaseTarget(t, `{"expiry":"1h"}`)
+	tgt := env.seedDatabaseTarget(t, time.Hour, "")
 	env.seedArchiveRows(
-		t, webhookID, time.Now().Add(-48*time.Hour),
+		t, tgt, time.Now().Add(-48*time.Hour),
 	)
 
-	webhookDB := testWebhookDB(t)
-	event := seedEvent(t, webhookDB, `{"n":1}`)
-	event.WebhookID = webhookID
-	d := seedDatabaseTargetDelivery(
-		t, webhookDB, event, `{"expiry":"1h"}`,
-	)
+	d := databaseTargetDelivery(newEvent(`{"n":1}`), tgt)
 
 	env.sweeper.ExportSweep(context.Background())
-	require.False(t, env.eng.ExportHasArchiveWriter(webhookID))
+	require.False(t, env.writers.ExportHasArchiveWriter(tgt.ID))
 
-	env.eng.ExportDeliverDatabase(webhookDB, d)
+	require.NoError(t, env.writers.Write(d))
 
 	assert.True(
-		t, env.eng.ExportHasArchiveWriter(webhookID),
+		t, env.writers.ExportHasArchiveWriter(tgt.ID),
 		"a delivery's writer must stay registered",
 	)
 
 	env.sweeper.ExportSweep(context.Background())
 
 	assert.True(
-		t, env.eng.ExportHasArchiveWriter(webhookID),
+		t, env.writers.ExportHasArchiveWriter(tgt.ID),
 		"a sweep must not drop a writer a delivery owns",
 	)
 }
@@ -423,15 +500,15 @@ func TestArchiveSweep_KeepsWriterAdoptedDuringSweep(
 ) {
 	t.Parallel()
 
-	env := setupSweeperTest(t)
+	env := setupArchiveTest(t)
 
-	webhookID := env.seedDatabaseTarget(t, `{"expiry":"1h"}`)
+	tgt := env.seedDatabaseTarget(t, time.Hour, "")
 	env.seedArchiveRows(
-		t, webhookID, time.Now().Add(-48*time.Hour),
+		t, tgt, time.Now().Add(-48*time.Hour),
 	)
 
-	sweepWriter, created, err := env.eng.ExportSweepWriterFor(
-		webhookID,
+	sweepWriter, created, err := env.writers.ExportSweepWriterFor(
+		tgt.ID,
 	)
 	require.NoError(t, err)
 	require.True(
@@ -440,39 +517,34 @@ func TestArchiveSweep_KeepsWriterAdoptedDuringSweep(
 	)
 
 	// The delivery lands mid-sweep and adopts the entry.
-	webhookDB := testWebhookDB(t)
-	event := seedEvent(t, webhookDB, `{"n":1}`)
-	event.WebhookID = webhookID
-	d := seedDatabaseTargetDelivery(
-		t, webhookDB, event, `{"expiry":"1h"}`,
-	)
+	d := databaseTargetDelivery(newEvent(`{"n":1}`), tgt)
 
-	env.eng.ExportDeliverDatabase(webhookDB, d)
+	require.NoError(t, env.writers.Write(d))
 
-	adopted := env.eng.ExportArchiveWriterFor(webhookID)
+	adopted := env.writers.ExportArchiveWriterFor(tgt.ID)
 	require.NotNil(t, adopted)
 	require.True(
 		t, sweepWriter.Same(adopted),
 		"the delivery must have adopted the sweep's writer",
 	)
 	require.True(
-		t, env.eng.ExportArchiveHandleOpen(webhookID),
+		t, env.writers.ExportArchiveHandleOpen(tgt.ID),
 		"the delivery leaves the archive handle open",
 	)
 
 	// The sweep finishes.
-	env.eng.ExportReleaseSweepWriter(webhookID, sweepWriter)
+	env.writers.ExportReleaseSweepWriter(tgt.ID, sweepWriter)
 
 	require.True(
-		t, env.eng.ExportHasArchiveWriter(webhookID),
+		t, env.writers.ExportHasArchiveWriter(tgt.ID),
 		"a writer adopted by a delivery during a sweep must "+
 			"stay registered, or its open handle is unreachable",
 	)
 
-	env.eng.EvictWebhook(webhookID)
+	env.writers.EvictTarget(tgt.ID)
 
 	assert.False(
-		t, env.eng.ExportHasArchiveWriter(webhookID),
+		t, env.writers.ExportHasArchiveWriter(tgt.ID),
 		"the adopted writer must still be evictable",
 	)
 	assert.False(
@@ -481,34 +553,29 @@ func TestArchiveSweep_KeepsWriterAdoptedDuringSweep(
 	)
 }
 
-// TestArchiveSweep_ContinuesAfterPerWebhookFailure proves a
-// failure for one webhook does not abort the sweep for the
-// others: an unparseable expiry and an unreadable archive both
-// have to be logged and stepped over.
-func TestArchiveSweep_ContinuesAfterPerWebhookFailure(
+// TestArchiveSweep_ContinuesAfterPerTargetFailure proves a
+// failure for one target does not abort the sweep for the
+// others: an unreadable archive has to be logged and stepped
+// over.
+func TestArchiveSweep_ContinuesAfterPerTargetFailure(
 	t *testing.T,
 ) {
 	t.Parallel()
 
-	env := setupSweeperTest(t)
+	env := setupArchiveTest(t)
 
-	// Seeded first so the sweep reaches them before the healthy
-	// webhook: targets come back in insertion order.
-	badConfigID := env.seedDatabaseTarget(t, `{"expiry":"!!!"}`)
-	env.seedArchiveRows(
-		t, badConfigID, time.Now().Add(-48*time.Hour),
-	)
-
-	corruptID := env.seedDatabaseTarget(t, `{"expiry":"1h"}`)
+	// Seeded first so the sweep reaches it before the healthy
+	// target: targets come back in insertion order.
+	corrupt := env.seedDatabaseTarget(t, time.Hour, "")
 	require.NoError(t, os.WriteFile(
-		env.archivePath(corruptID),
+		env.archivePath(corrupt),
 		[]byte("this is not a sqlite database"),
 		0o600,
 	))
 
-	healthyID := env.seedDatabaseTarget(t, `{"expiry":"1h"}`)
+	healthy := env.seedDatabaseTarget(t, time.Hour, "")
 	healthyPath := env.seedArchiveRows(
-		t, healthyID,
+		t, healthy,
 		time.Now().Add(-48*time.Hour),
 		time.Now().Add(-time.Minute),
 	)
@@ -518,14 +585,14 @@ func TestArchiveSweep_ContinuesAfterPerWebhookFailure(
 	assert.Equal(
 		t, []string{sweepRowNew},
 		archivedEventIDs(t, healthyPath),
-		"a failure for an earlier webhook must not stop the "+
+		"a failure for an earlier target must not stop the "+
 			"sweep from pruning the ones after it",
 	)
 }
 
 // TestArchiveSweep_OpenExistingDoesNotCreateFile pins the second
 // of the two no-create guards. The first is the stat in
-// sweepWebhook; this one is the SQLite open mode, which is what
+// sweepExpired; this one is the SQLite open mode, which is what
 // protects the window between that stat and the open. Flipping
 // the sweep's mode to create-if-missing makes this fail.
 func TestArchiveSweep_OpenExistingDoesNotCreateFile(
@@ -536,7 +603,7 @@ func TestArchiveSweep_OpenExistingDoesNotCreateFile(
 	dir := t.TempDir()
 	path := filepath.Join(dir, "archive-absent.db")
 
-	w := delivery.NewExportArchiveWriter(
+	w := archive.NewExportArchiveWriter(
 		path, archiveTestLogger(), 0,
 	)
 
@@ -561,13 +628,13 @@ func TestArchiveSweep_OpenExistingDoesNotCreateFile(
 func TestArchiveSweep_PrunesIdleArchive(t *testing.T) {
 	t.Parallel()
 
-	env := setupSweeperTest(t)
+	env := setupArchiveTest(t)
 
-	webhookID := env.seedDatabaseTarget(t, `{"expiry":"1h"}`)
+	tgt := env.seedDatabaseTarget(t, time.Hour, "")
 
 	now := time.Now()
 	path := env.seedArchiveRows(
-		t, webhookID,
+		t, tgt,
 		now.Add(-48*time.Hour),
 		now.Add(-time.Minute),
 	)
@@ -600,14 +667,14 @@ func TestArchiveSweep_PrunesIdleArchive(t *testing.T) {
 func TestArchiveSweep_LeavesArchiveClosed(t *testing.T) {
 	t.Parallel()
 
-	env := setupSweeperTest(t)
+	env := setupArchiveTest(t)
 
-	webhookID := env.seedDatabaseTarget(t, `{"expiry":"1h"}`)
+	tgt := env.seedDatabaseTarget(t, time.Hour, "")
 	path := env.seedArchiveRows(
-		t, webhookID, time.Now().Add(-48*time.Hour),
+		t, tgt, time.Now().Add(-48*time.Hour),
 	)
 
-	w := delivery.NewExportArchiveWriter(
+	w := archive.NewExportArchiveWriter(
 		path, archiveTestLogger(), 0,
 	)
 
@@ -640,70 +707,116 @@ func TestArchiveSweep_ClosesHandleOfRegisteredWriter(
 ) {
 	t.Parallel()
 
-	env := setupSweeperTest(t)
+	env := setupArchiveTest(t)
 
-	webhookID := env.seedDatabaseTarget(t, `{"expiry":"1h"}`)
+	tgt := env.seedDatabaseTarget(t, time.Hour, "")
 	env.seedArchiveRows(
-		t, webhookID, time.Now().Add(-48*time.Hour),
+		t, tgt, time.Now().Add(-48*time.Hour),
 	)
 
-	webhookDB := testWebhookDB(t)
-	event := seedEvent(t, webhookDB, `{"n":1}`)
-	event.WebhookID = webhookID
-	d := seedDatabaseTargetDelivery(
-		t, webhookDB, event, `{"expiry":"1h"}`,
-	)
+	d := databaseTargetDelivery(newEvent(`{"n":1}`), tgt)
 
-	env.eng.ExportDeliverDatabase(webhookDB, d)
+	require.NoError(t, env.writers.Write(d))
 
 	require.True(
-		t, env.eng.ExportArchiveHandleOpen(webhookID),
+		t, env.writers.ExportArchiveHandleOpen(tgt.ID),
 		"the delivery must leave the archive handle open",
 	)
 
 	env.sweeper.ExportSweep(context.Background())
 
 	require.True(
-		t, env.eng.ExportHasArchiveWriter(webhookID),
+		t, env.writers.ExportHasArchiveWriter(tgt.ID),
 		"the delivery's registry entry must survive the sweep",
 	)
 	assert.False(
-		t, env.eng.ExportArchiveHandleOpen(webhookID),
+		t, env.writers.ExportArchiveHandleOpen(tgt.ID),
 		"the sweep must leave the archive closed",
 	)
 }
 
+// TestArchiveSweep_ClosesHandleBeforeReopening proves the sweep
+// closes the handle it finds open before it reopens the file.
+// TestArchiveSweep_LeavesArchiveClosed cannot see this: without the
+// close, the reopen replaces the handle without closing it, the
+// sweep then closes only the new one, and one connection leaks per
+// archive per sweep.
+func TestArchiveSweep_ClosesHandleBeforeReopening(t *testing.T) {
+	t.Parallel()
+
+	path := filepath.Join(t.TempDir(), "archive.db")
+
+	w := archive.NewExportArchiveWriter(
+		path, archiveTestLogger(), 0,
+	)
+
+	require.NoError(t, w.Open(time.Hour))
+
+	before, err := w.DB().DB()
+	require.NoError(t, err)
+
+	require.NoError(t, w.SweepExpired(time.Hour))
+
+	assert.Error(
+		t, before.PingContext(t.Context()),
+		"the handle open before the sweep must be closed by it",
+	)
+}
+
+// TestArchiveSweep_CancelledSweepLogsNoError proves a sweep whose
+// context is already cancelled, as when the app stops just as a
+// sweep starts, returns without an error line: stopping is not a
+// failure.
+func TestArchiveSweep_CancelledSweepLogsNoError(t *testing.T) {
+	t.Parallel()
+
+	env := setupArchiveTest(t)
+
+	var errorLines bytes.Buffer
+
+	sweeper := archive.NewTestSweeper(
+		env.mainDB, env.writers,
+		slog.New(slog.NewTextHandler(
+			&errorLines,
+			&slog.HandlerOptions{Level: slog.LevelError},
+		)),
+	)
+
+	ctx, cancel := context.WithCancel(context.Background())
+	cancel()
+
+	sweeper.ExportSweep(ctx)
+
+	assert.Empty(
+		t, errorLines.String(),
+		"a cancelled sweep must not log at error level",
+	)
+}
+
 // TestArchiveSweep_NeverExpiryUntouched proves the sweep is a
-// no-op for the default retention policy, so archives with no
-// expiry (or the literal "never") behave exactly as before.
+// no-op for the default retention policy, so an archive with an
+// expiry of 0, which keeps it forever, is left alone.
 func TestArchiveSweep_NeverExpiryUntouched(t *testing.T) {
 	t.Parallel()
 
-	for _, configJSON := range []string{
-		`{"expiry":"never"}`,
-		`{"expiry":""}`,
-		"",
-	} {
-		env := setupSweeperTest(t)
+	env := setupArchiveTest(t)
 
-		webhookID := env.seedDatabaseTarget(t, configJSON)
-		path := env.seedArchiveRows(
-			t, webhookID,
-			time.Now().Add(-10000*time.Hour),
-		)
+	tgt := env.seedDatabaseTarget(t, 0, "")
+	path := env.seedArchiveRows(
+		t, tgt,
+		time.Now().Add(-10000*time.Hour),
+	)
 
-		env.sweeper.ExportSweep(context.Background())
+	env.sweeper.ExportSweep(context.Background())
 
-		assert.Equal(
-			t, []string{sweepRowOld}, archivedEventIDs(t, path),
-			"config %q must keep rows forever", configJSON,
-		)
-		assert.False(
-			t, env.eng.ExportHasArchiveWriter(webhookID),
-			"config %q must leave no registry entry behind",
-			configJSON,
-		)
-	}
+	assert.Equal(
+		t, []string{sweepRowOld}, archivedEventIDs(t, path),
+		"an expiry of 0 must keep rows forever",
+	)
+	assert.False(
+		t, env.writers.ExportHasArchiveWriter(tgt.ID),
+		"an expiry of 0 must leave no registry entry behind",
+	)
 }
 
 // TestArchiveSweep_NeverExpirySkipsBeforeOpening pins the
@@ -714,18 +827,18 @@ func TestArchiveSweep_NeverExpiryUntouched(t *testing.T) {
 //
 // The spec is stronger than that — a "never" archive is skipped
 // before any file is touched — so the archive here exists but has
-// never been migrated. Opening it at all would run AutoMigrate
-// and create the archive table, which is exactly what must not
-// happen.
+// never been migrated. Opening it at all would apply the archive
+// schema and create the archive table, which is exactly what must
+// not happen.
 func TestArchiveSweep_NeverExpirySkipsBeforeOpening(
 	t *testing.T,
 ) {
 	t.Parallel()
 
-	env := setupSweeperTest(t)
+	env := setupArchiveTest(t)
 
-	webhookID := env.seedDatabaseTarget(t, `{"expiry":"never"}`)
-	path := env.archivePath(webhookID)
+	tgt := env.seedDatabaseTarget(t, 0, "")
+	path := env.archivePath(tgt)
 
 	seedUnmigratedArchive(t, path)
 	require.False(t, archiveTableExists(t, path))
@@ -740,7 +853,7 @@ func TestArchiveSweep_NeverExpirySkipsBeforeOpening(
 
 // seedUnmigratedArchive creates an archive file that exists but
 // carries no archive schema, so any open of it is observable: the
-// archive table appears only if something ran AutoMigrate.
+// archive table appears only if something applied the schema.
 func seedUnmigratedArchive(t *testing.T, path string) {
 	t.Helper()
 
@@ -764,20 +877,20 @@ func archiveTableExists(t *testing.T, path string) bool {
 
 	return openArchiveDBForRead(t, path).
 		Migrator().
-		HasTable(&delivery.ExportArchivedEvent{})
+		HasTable(&archive.ExportArchivedEvent{})
 }
 
 // TestArchiveSweep_DoesNotCreateArchiveFile proves the sweep
-// never conjures an archive: a webhook with a database target
-// that has never received an event must still have no archive
-// file (nor SQLite sidecar) after a sweep.
+// never conjures an archive: a database target that has never
+// received an event must still have no archive file (nor SQLite
+// sidecar) after a sweep, and no registry entry either.
 func TestArchiveSweep_DoesNotCreateArchiveFile(t *testing.T) {
 	t.Parallel()
 
-	env := setupSweeperTest(t)
+	env := setupArchiveTest(t)
 
-	webhookID := env.seedDatabaseTarget(t, `{"expiry":"1h"}`)
-	path := env.archivePath(webhookID)
+	tgt := env.seedDatabaseTarget(t, time.Hour, "")
+	path := env.archivePath(tgt)
 
 	require.NoFileExists(t, path)
 
@@ -789,6 +902,11 @@ func TestArchiveSweep_DoesNotCreateArchiveFile(t *testing.T) {
 			"the sweep must not create an archive file",
 		)
 	}
+
+	assert.False(
+		t, env.writers.ExportHasArchiveWriter(tgt.ID),
+		"the sweep must leave no registry entry behind",
+	)
 }
 
 // TestArchiveSweep_DoesNotCreateAfterWriterExists covers the
@@ -800,11 +918,11 @@ func TestArchiveSweep_DoesNotCreateAfterWriterExists(
 ) {
 	t.Parallel()
 
-	env := setupSweeperTest(t)
+	env := setupArchiveTest(t)
 
-	webhookID := env.seedDatabaseTarget(t, `{"expiry":"1h"}`)
+	tgt := env.seedDatabaseTarget(t, time.Hour, "")
 
-	path, err := env.eng.ExportEnsureArchiveWriter(webhookID)
+	path, err := env.writers.ExportEnsureArchiveWriter(tgt.ID)
 	require.NoError(t, err)
 	require.NoFileExists(t, path)
 
@@ -819,17 +937,17 @@ func TestArchiveSweep_DoesNotCreateAfterWriterExists(
 func TestArchiveSweep_SkipsDeletedWebhookTargets(t *testing.T) {
 	t.Parallel()
 
-	env := setupSweeperTest(t)
+	env := setupArchiveTest(t)
 
-	webhookID := env.seedDatabaseTarget(t, `{"expiry":"1h"}`)
+	tgt := env.seedDatabaseTarget(t, time.Hour, "")
 	path := env.seedArchiveRows(
-		t, webhookID, time.Now().Add(-48*time.Hour),
+		t, tgt, time.Now().Add(-48*time.Hour),
 	)
 
 	require.NoError(
 		t,
 		env.mainDB.DB().
-			Where("webhook_id = ?", webhookID).
+			Where("webhook_id = ?", tgt.WebhookID).
 			Delete(&database.Target{}).Error,
 	)
 
@@ -841,34 +959,26 @@ func TestArchiveSweep_SkipsDeletedWebhookTargets(t *testing.T) {
 	)
 }
 
-// TestArchiveSweep_ConcurrentWrites proves the sweep serialises
-// against writes through the per-webhook writer mutex. Run
-// under -race, an unsynchronised sweep would be caught here.
+// TestArchiveSweep_ConcurrentWrites runs the sweep while writes to
+// the same target are under way. The sweep serialises against them
+// through the target's writer mutex; the suite runs without Go's race
+// detector, so a sweep that did not would fail this test only by
+// panicking, hanging or leaving no archive file.
 func TestArchiveSweep_ConcurrentWrites(t *testing.T) {
 	t.Parallel()
 
-	env := setupSweeperTest(t)
+	env := setupArchiveTest(t)
 
-	webhookID := env.seedDatabaseTarget(t, `{"expiry":"1h"}`)
+	tgt := env.seedDatabaseTarget(t, time.Hour, "")
 
-	webhookDB := testWebhookDB(t)
-
-	// The deliveries are seeded up front, on the test's own
-	// goroutine: the seed helpers assert, and testify assertions
-	// must not run off the test goroutine.
 	deliveries := make(
 		[]*database.Delivery, 0, sweepConcurrentWrites,
 	)
 
 	for range sweepConcurrentWrites {
-		event := seedEvent(t, webhookDB, `{"n":1}`)
-		event.WebhookID = webhookID
-
 		deliveries = append(
 			deliveries,
-			seedDatabaseTargetDelivery(
-				t, webhookDB, event, `{"expiry":"1h"}`,
-			),
+			databaseTargetDelivery(newEvent(`{"n":1}`), tgt),
 		)
 	}
 
@@ -880,7 +990,7 @@ func TestArchiveSweep_ConcurrentWrites(t *testing.T) {
 		defer wg.Done()
 
 		for _, d := range deliveries {
-			env.eng.ExportDeliverDatabase(webhookDB, d)
+			_ = env.writers.Write(d)
 		}
 	}()
 
@@ -894,7 +1004,7 @@ func TestArchiveSweep_ConcurrentWrites(t *testing.T) {
 
 	wg.Wait()
 
-	assert.FileExists(t, env.archivePath(webhookID))
+	assert.FileExists(t, env.archivePath(tgt))
 }
 
 // TestArchiveSweeper_StopsCleanly proves the background loop
@@ -902,11 +1012,11 @@ func TestArchiveSweep_ConcurrentWrites(t *testing.T) {
 func TestArchiveSweeper_StopsCleanly(t *testing.T) {
 	t.Parallel()
 
-	env := setupSweeperTest(t)
+	env := setupArchiveTest(t)
 
-	webhookID := env.seedDatabaseTarget(t, `{"expiry":"1h"}`)
+	tgt := env.seedDatabaseTarget(t, time.Hour, "")
 	env.seedArchiveRows(
-		t, webhookID, time.Now().Add(-48*time.Hour),
+		t, tgt, time.Now().Add(-48*time.Hour),
 	)
 
 	env.sweeper.ExportSetInterval(time.Millisecond)
@@ -930,7 +1040,7 @@ func TestArchiveSweeper_StopHookHonoursStopTimeout(
 ) {
 	t.Parallel()
 
-	env := setupSweeperTest(t)
+	env := setupArchiveTest(t)
 
 	lc := &recordingLifecycle{}
 	env.sweeper.ExportRegisterHooks(lc)

internal/archive/writer.go

@@ -0,0 +1,638 @@
+package archive
+
+import (
+	"errors"
+	"fmt"
+	"io/fs"
+	"log/slog"
+	"os"
+	"path/filepath"
+	"sync"
+	"time"
+
+	"gorm.io/driver/sqlite"
+	"gorm.io/gorm"
+	"sneak.berlin/go/webhooker/internal/database"
+	"sneak.berlin/go/webhooker/internal/db/migrations"
+	"sneak.berlin/go/webhooker/internal/gormlog"
+)
+
+// ExpiryNever is the archive expiry, as the target forms take it,
+// that disables pruning so archived rows are kept forever. It is
+// stored as an ArchiveExpiry of 0.
+const ExpiryNever = "never"
+
+// archiveReopenDebounce bounds how often an archive file is
+// closed and reopened. After each write the handle is closed
+// and reopened so an operator can move the file away for
+// offline archiving, but never more than once per this window.
+const archiveReopenDebounce = time.Second
+
+const (
+	// archiveModeCreate is the SQLite URI mode used by the write
+	// path: open the archive file, creating it if missing, so a
+	// first write (or a write after the operator moved the file
+	// away) recreates it.
+	archiveModeCreate = database.SQLiteModeCreate
+
+	// archiveModeExisting is the SQLite URI mode used by the idle
+	// sweep: open read-write but never create. A sweep must never
+	// conjure an empty archive file for a webhook that has a
+	// database target but has never received an event.
+	archiveModeExisting = database.SQLiteModeExisting
+)
+
+var (
+	// errArchiveMissingWebhookID is returned when an event to
+	// archive has no webhook id to record in its archive row.
+	errArchiveMissingWebhookID = errors.New(
+		"cannot archive event without a webhook id",
+	)
+
+	// errArchiveNoDataDir is returned when the database target
+	// has no webhook database manager and so cannot locate the
+	// data directory for archive files.
+	errArchiveNoDataDir = errors.New(
+		"database target has no data directory",
+	)
+
+	// errArchiveExpiryNotPositive is returned when a
+	// user-supplied archive expiry parses as a duration but is
+	// zero or negative; "never" is the way to disable pruning.
+	errArchiveExpiryNotPositive = errors.New(
+		"expiry must be a positive duration or \"never\"",
+	)
+
+	// errArchiveWriterEvicted is returned when a writer that has
+	// been evicted (its target or its webhook was deleted) is used
+	// again. An evicted writer is no longer in the registry, so
+	// reopening its file would leak a handle nothing owns.
+	errArchiveWriterEvicted = errors.New(
+		"archive writer has been evicted",
+	)
+
+	// ErrNameTaken is returned when an archive cannot be
+	// renamed because a file already has the new name. That file may
+	// be an archive with rows of its own, so it is never replaced.
+	ErrNameTaken = errors.New(
+		"a file already has the archive's new name",
+	)
+)
+
+// archivedEvent is one fully captured webhook event stored in a
+// database target's archive for long-term retention. It is a
+// self-contained copy — independent of the per-webhook event
+// database, which may prune events under its own retention.
+type archivedEvent struct {
+	ID           uint   `gorm:"primaryKey;autoIncrement"`
+	EventID      string `gorm:"index"`
+	WebhookID    string
+	EntrypointID string
+	Method       string
+	RawQuery     string
+	Headers      string
+	Body         string
+	ContentType  string
+
+	// ArchivedAt is when the row was archived and is the age
+	// basis for expiry pruning.
+	ArchivedAt time.Time `gorm:"index"`
+}
+
+// ParseExpiry reads a user-supplied archive expiry for a database
+// target, as the target forms submit it, into the ArchiveExpiry the
+// target stores. Empty and "never" both mean keep forever, which is
+// 0; anything else must be a positive Go duration such as "720h". Any
+// other value is an error, so a bad expiry is refused at the form
+// rather than stored.
+func ParseExpiry(expiry string) (time.Duration, error) {
+	if expiry == "" || expiry == ExpiryNever {
+		return 0, nil
+	}
+
+	dur, err := time.ParseDuration(expiry)
+	if err != nil {
+		return 0, fmt.Errorf(
+			"expiry must be %q or a Go duration "+
+				"such as \"720h\": %w",
+			ExpiryNever, err,
+		)
+	}
+
+	if dur <= 0 {
+		return 0, fmt.Errorf(
+			"%w: %q", errArchiveExpiryNotPositive, expiry,
+		)
+	}
+
+	return dur, nil
+}
+
+// archiveWriter owns one database target's archive SQLite files.
+// It serialises writes, and after each write closes and reopens
+// the file (debounced to at most once per debounce window) so
+// an operator can move the file away for offline archiving. The
+// next write recreates a moved or removed file, because the
+// file is opened create-if-missing and its schema is migrated
+// on every open.
+type archiveWriter struct {
+	mu sync.Mutex
+
+	// path is the target's archive file as Path names it. A
+	// target that rotates writes to the files archivePeriodPath names
+	// for path and a period instead.
+	path string
+
+	// current is the file db is open on.
+	current string
+
+	log        *slog.Logger
+	debounce   time.Duration
+	db         *gorm.DB
+	lastReopen time.Time
+	reopens    int
+
+	// now is the clock the reopen debounce is measured on. It is
+	// time.Now outside tests.
+	now func() time.Time
+
+	// evicted marks a writer that has been removed from the
+	// registry. Its handle is closed and it must never open the
+	// file again: nothing holds it any more, so a reopen would
+	// leak the handle for the process lifetime.
+	evicted bool
+
+	// webhookID is the webhook the archive's target belongs to,
+	// so deleting the webhook can find its writers. It is set
+	// when the writer is created and never changes.
+	webhookID string
+
+	// sweepOwned marks a registry entry that the idle sweep
+	// created because no writer was cached for the target. The
+	// sweep removes such an entry again when it is done, so a
+	// sweep can never leave — or resurrect — a registry entry
+	// for a target that has been deleted. A delivery that adopts
+	// the writer clears the flag, handing the entry to the
+	// registry proper.
+	//
+	// Unlike every other field here it is guarded by
+	// Writers.mu, not by this writer's mu: it describes the
+	// registry entry rather than the file.
+	sweepOwned bool
+}
+
+// newArchiveWriter builds an archiveWriter for a file path with
+// the default reopen debounce.
+func newArchiveWriter(
+	path string, log *slog.Logger,
+) *archiveWriter {
+	return &archiveWriter{
+		path:     path,
+		log:      log,
+		debounce: archiveReopenDebounce,
+		now:      time.Now,
+	}
+}
+
+// write appends the event as a row to the archive file for period
+// (see archivePeriodPath), then applies the debounced close/reopen.
+// When period names a different file from the one open, the open one
+// is closed first. It recreates the archive file if it was moved or
+// removed since the last open. A positive expiry prunes rows older
+// than it on each (re)open.
+func (w *archiveWriter) write(
+	row archivedEvent, expiry time.Duration, period string,
+) error {
+	w.mu.Lock()
+	defer w.mu.Unlock()
+
+	if w.evicted {
+		return fmt.Errorf(
+			"%w: %s", errArchiveWriterEvicted, w.path,
+		)
+	}
+
+	file := archivePeriodPath(w.path, period)
+
+	if w.db == nil || w.current != file || !fileExists(file) {
+		err := w.reopen(file, expiry)
+		if err != nil {
+			return err
+		}
+	}
+
+	// GORM's clock, the one that stamps created_at in the other
+	// databases, so this is stored in the same form. A bare time.Now()
+	// carries a monotonic clock reading, which the driver would store
+	// as an " m=+…" suffix.
+	row.ArchivedAt = w.db.NowFunc()
+
+	err := w.db.Create(&row).Error
+	if err != nil {
+		return fmt.Errorf(
+			"archiving event to %s: %w", file, err,
+		)
+	}
+
+	if w.now().Sub(w.lastReopen) >= w.debounce {
+		return w.reopen(file, expiry)
+	}
+
+	return nil
+}
+
+// open opens (creating if missing) an archive file, migrates
+// its schema, records the reopen time, and prunes expired rows
+// when expiry is positive.
+func (w *archiveWriter) open(file string, expiry time.Duration) error {
+	return w.openMode(file, archiveModeCreate, expiry)
+}
+
+// openMode opens an archive file with the given SQLite URI
+// mode, migrates its schema, records the reopen time, and
+// prunes expired rows when expiry is positive. The write path
+// passes archiveModeCreate so a missing file is recreated; the
+// idle sweep passes archiveModeExisting so a missing file is an
+// error rather than a newly conjured empty archive.
+func (w *archiveWriter) openMode(
+	file, mode string, expiry time.Duration,
+) error {
+	// Opened through database.OpenSQLite so an archive file carries
+	// the same WAL journaling, busy timeout, immediate-transaction
+	// locking, and pool bounds as every other database file. See
+	// internal/database/sqlite_open.go.
+	sqlDB, err := database.OpenSQLite(file, mode)
+	if err != nil {
+		return fmt.Errorf(
+			"opening archive database %s: %w", file, err,
+		)
+	}
+
+	gdb, err := gorm.Open(
+		sqlite.Dialector{Conn: sqlDB}, &gorm.Config{
+			// Never leave this at GORM's default. See
+			// internal/gormlog.
+			Logger: gormlog.New(w.log),
+		},
+	)
+	if err != nil {
+		_ = sqlDB.Close()
+
+		return fmt.Errorf(
+			"connecting to archive database %s: %w",
+			file, err,
+		)
+	}
+
+	err = migrations.Apply(gdb, migrations.Archive)
+	if err != nil {
+		_ = sqlDB.Close()
+
+		return fmt.Errorf(
+			"migrating archive database %s: %w", file, err,
+		)
+	}
+
+	w.db = gdb
+	w.current = file
+	w.lastReopen = w.now()
+	w.reopens++
+
+	if expiry > 0 {
+		w.prune(expiry)
+	}
+
+	return nil
+}
+
+// reopen closes any open handle and opens file afresh. The
+// fresh open recreates the file if it was moved away.
+func (w *archiveWriter) reopen(file string, expiry time.Duration) error {
+	w.close()
+
+	return w.open(file, expiry)
+}
+
+// close closes the underlying handle, if any.
+func (w *archiveWriter) close() {
+	if w.db == nil {
+		return
+	}
+
+	sqlDB, err := w.db.DB()
+	if err == nil {
+		_ = sqlDB.Close()
+	}
+
+	w.db = nil
+}
+
+// sweepExpired prunes the target's archive files, which may have
+// gone idle, with no write to trigger the usual on-reopen prune. It
+// lists the files under the writer's own mutex, then takes the mutex
+// again for one file at a time, so a write waits for at most one
+// file's prune, and each prune is ordered against concurrent writes
+// rather than reaching around them to the file.
+//
+// It never creates an archive file: it prunes only the files
+// archiveFiles lists, skips one that is gone by the time it is
+// reached (moved away, or renamed since the listing), and opens each
+// with archiveModeExisting so SQLite itself refuses to create one if
+// the file disappears between the check and the open. A file named
+// for a period that the prune leaves empty is deleted.
+//
+// The archive is left CLOSED afterwards. An idle archive holding
+// no handle is what keeps the operator's move-the-file-away
+// workflow working; the next write reopens (and recreates) the
+// file as it always has.
+func (w *archiveWriter) sweepExpired(expiry time.Duration) error {
+	w.mu.Lock()
+	files, err := archiveFiles(w.path)
+	w.mu.Unlock()
+
+	if err != nil {
+		return err
+	}
+
+	var errs []error
+
+	for _, file := range files {
+		err = w.sweepFile(file, expiry)
+		if errors.Is(err, errArchiveWriterEvicted) {
+			return err
+		}
+
+		if err != nil {
+			errs = append(errs, err)
+		}
+	}
+
+	return errors.Join(errs...)
+}
+
+// sweepFile prunes one of the target's archive files for sweepExpired,
+// holding w.mu while it does. It skips a file that is gone, and deletes
+// the file, with its -wal and -shm, when it is named for a period and
+// the prune leaves it empty.
+func (w *archiveWriter) sweepFile(
+	file archiveFile, expiry time.Duration,
+) error {
+	w.mu.Lock()
+	defer w.mu.Unlock()
+
+	if w.evicted {
+		return fmt.Errorf(
+			"%w: %s", errArchiveWriterEvicted, w.path,
+		)
+	}
+
+	if !fileExists(file.path) {
+		return nil
+	}
+
+	// Drop any live handle first so the prune runs against a
+	// freshly opened file, matching the write path's semantics.
+	w.close()
+
+	err := w.openMode(file.path, archiveModeExisting, expiry)
+	if err != nil {
+		return err
+	}
+
+	if file.period == "" {
+		w.close()
+
+		return nil
+	}
+
+	var rows int64
+
+	err = w.db.Model(&archivedEvent{}).Count(&rows).Error
+
+	w.close()
+
+	if err != nil {
+		return fmt.Errorf(
+			"counting rows in archive %s: %w", file.path, err,
+		)
+	}
+
+	if rows > 0 {
+		return nil
+	}
+
+	for _, suffix := range []string{"", "-wal", "-shm"} {
+		err = os.Remove(file.path + suffix)
+		if err != nil && !errors.Is(err, fs.ErrNotExist) {
+			return fmt.Errorf("deleting empty archive file: %w", err)
+		}
+	}
+
+	w.log.Info("deleted empty archive file", "path", file.path)
+
+	return nil
+}
+
+// rename gives every one of the target's archive files the new
+// name, keeping the period in the name of each (see
+// archivePeriodPath), and the writer uses the files under that name
+// from now on. The handle is closed first, which folds the -wal into
+// the .db; any -wal or -shm still beside a file (left by a crash) is
+// moved with it, because SQLite finds them by name. A target with no
+// files is not an error: the operator may have moved them away, and
+// the next write creates its file under the new name.
+//
+// If a file already has one of the new names, nothing is moved and
+// the error is ErrNameTaken. If one file fails to move, those
+// already moved are moved back before the error is returned, so the
+// archive is never split across two names.
+func (w *archiveWriter) rename(name string) error {
+	w.mu.Lock()
+	defer w.mu.Unlock()
+
+	if w.evicted {
+		return fmt.Errorf(
+			"%w: %s", errArchiveWriterEvicted, w.path,
+		)
+	}
+
+	path := filepath.Join(filepath.Dir(w.path), name)
+	if path == w.path {
+		return nil
+	}
+
+	files, err := archiveFiles(w.path)
+	if err != nil {
+		return err
+	}
+
+	// from[i] moves to to[i].
+	var from, to []string
+
+	for _, file := range files {
+		renamed := archivePeriodPath(path, file.period)
+
+		for _, suffix := range []string{"", "-wal", "-shm"} {
+			from = append(from, file.path+suffix)
+			to = append(to, renamed+suffix)
+		}
+	}
+
+	for _, taken := range to {
+		if fileExists(taken) {
+			return fmt.Errorf(
+				"%w: %s", ErrNameTaken, filepath.Base(taken),
+			)
+		}
+	}
+
+	w.close()
+
+	for i := range from {
+		err = os.Rename(from[i], to[i])
+		if err == nil || errors.Is(err, fs.ErrNotExist) {
+			continue
+		}
+
+		for j := range i {
+			backErr := os.Rename(to[j], from[j])
+			if backErr != nil && !errors.Is(backErr, fs.ErrNotExist) {
+				w.log.Error(
+					"failed to move archive file back",
+					"from", to[j],
+					"to", from[j],
+					"error", backErr,
+				)
+			}
+		}
+
+		return fmt.Errorf(
+			"renaming archive %s to %s: %w", from[i], to[i], err,
+		)
+	}
+
+	w.path = path
+
+	return nil
+}
+
+// evict closes the writer's handle and marks it unusable. It is
+// called when the writer leaves the registry, because its target
+// or its webhook was deleted, or at shutdown. The archive FILE is
+// deliberately left on disk: it is long-term storage an operator
+// may still want.
+func (w *archiveWriter) evict() {
+	w.mu.Lock()
+	defer w.mu.Unlock()
+
+	w.evicted = true
+
+	w.close()
+}
+
+// prune deletes archived rows older than expiry, measured from
+// each row's archived time. It runs on every (re)open, so a
+// steadily written archive is swept by its own write traffic. An
+// archive that goes idle receives no further reopens, which is
+// why Sweeper exists to drive sweepExpired on a timer.
+// Failures are logged, not fatal: a prune error must not stop
+// archiving.
+func (w *archiveWriter) prune(expiry time.Duration) {
+	cutoff := time.Now().Add(-expiry)
+
+	res := w.db.Where("archived_at < ?", cutoff).
+		Delete(&archivedEvent{})
+	if res.Error != nil {
+		w.log.Error(
+			"failed to prune expired archive rows",
+			"path", w.current,
+			"error", res.Error,
+		)
+
+		return
+	}
+
+	if res.RowsAffected > 0 {
+		w.log.Info(
+			"pruned expired archive rows",
+			"path", w.current,
+			"rows_deleted", res.RowsAffected,
+		)
+	}
+}
+
+// FileInfo is what the metadata of a database target's archive
+// files says about them.
+type FileInfo struct {
+	// Files counts the files.
+	Files int
+
+	// Size is the bytes on disk of the files and their -wal together.
+	Size int64
+
+	// Written is when a file or a -wal was last modified, whichever is
+	// latest: a write lands in the -wal first.
+	Written time.Time
+}
+
+// Stat reads the metadata of a database target's archive
+// files, given the path Path gives it (see archiveFiles), and
+// of their -wal, without opening them. With no files, which is so
+// before the first write and after the operator moved them away, the
+// error wraps fs.ErrNotExist.
+func Stat(path string) (FileInfo, error) {
+	files, err := archiveFiles(path)
+	if err != nil {
+		return FileInfo{}, err
+	}
+
+	var info FileInfo
+
+	for _, file := range files {
+		db, err := os.Stat(file.path)
+		if errors.Is(err, fs.ErrNotExist) {
+			continue
+		}
+
+		if err != nil {
+			return FileInfo{}, err
+		}
+
+		info.Files++
+		info.Size += db.Size()
+
+		if db.ModTime().After(info.Written) {
+			info.Written = db.ModTime()
+		}
+
+		wal, err := os.Stat(file.path + "-wal")
+		if errors.Is(err, fs.ErrNotExist) {
+			continue
+		}
+
+		if err != nil {
+			return FileInfo{}, err
+		}
+
+		info.Size += wal.Size()
+
+		if wal.ModTime().After(info.Written) {
+			info.Written = wal.ModTime()
+		}
+	}
+
+	if info.Files == 0 {
+		return FileInfo{}, fmt.Errorf(
+			"no archive file for %s: %w", path, fs.ErrNotExist,
+		)
+	}
+
+	return info, nil
+}
+
+// fileExists reports whether a path currently exists.
+func fileExists(path string) bool {
+	_, err := os.Stat(path)
+
+	return err == nil
+}

internal/archive/writer_gormlog_test.go

@@ -1,4 +1,4 @@
-package delivery_test
+package archive_test
 
 import (
 	"bytes"
@@ -14,7 +14,7 @@ import (
 	"github.com/stretchr/testify/require"
 	"gorm.io/gorm"
 	gormlogger "gorm.io/gorm/logger"
-	"sneak.berlin/go/webhooker/internal/delivery"
+	"sneak.berlin/go/webhooker/internal/archive"
 	"sneak.berlin/go/webhooker/internal/middleware"
 )
 
@@ -57,7 +57,7 @@ func (g *gormDefaultBuf) String() string {
 // without exporting production code to carry it, and a logging
 // detector is not worth a production symbol. What it detects is the
 // third gorm.Open in this service, at
-// internal/delivery/target_database_archive.go — the archive writer,
+// internal/archive/writer.go — the archive writer,
 // whose type is unexported, so nothing outside this package can drive
 // it.
 func captureArchiveGORMDefault(t *testing.T) *gormDefaultBuf {
@@ -85,7 +85,7 @@ func captureArchiveGORMDefault(t *testing.T) *gormDefaultBuf {
 // writer's gorm.Open to the adapter.
 //
 // Restore a bare &gorm.Config{} at
-// internal/delivery/target_database_archive.go and this fails: the
+// internal/archive/writer.go and this fails: the
 // default logger prints the fully interpolated SELECT on every
 // ErrRecordNotFound, so the client-chosen event id below arrives whole
 // and unbounded on stdout, answering to no level the operator set.
@@ -100,7 +100,7 @@ func TestArchiveWriter_NeverUsesGORMsDefaultLogger(t *testing.T) {
 
 	gormDefault := captureArchiveGORMDefault(t)
 
-	w := delivery.NewExportArchiveWriter(
+	w := archive.NewExportArchiveWriter(
 		filepath.Join(t.TempDir(), "archive.db"),
 		slog.New(slog.NewTextHandler(
 			&captured, &slog.HandlerOptions{Level: slog.LevelDebug},
@@ -118,7 +118,7 @@ func TestArchiveWriter_NeverUsesGORMsDefaultLogger(t *testing.T) {
 	value := strings.Repeat("\x01", archiveGORMFillBytes) +
 		archiveGORMTailMarker
 
-	var row delivery.ExportArchivedEvent
+	var row archive.ExportArchivedEvent
 
 	err := w.DB().Where("event_id = ?", value).First(&row).Error
 	require.ErrorIs(t, err, gorm.ErrRecordNotFound)

internal/ciscript/ci_mark_superseded_test.go

@@ -1,387 +0,0 @@
-package ciscript_test
-
-import (
-	"maps"
-	"os"
-	"os/exec"
-	"path/filepath"
-	"slices"
-	"strings"
-	"testing"
-
-	"github.com/stretchr/testify/require"
-	"gopkg.in/yaml.v3"
-)
-
-const (
-	// supersededDesc is the description script/ci-mark-superseded
-	// writes, and the one an earlier revision of it wrote alongside a
-	// `skipped` state.
-	supersededDesc = "Superseded by a newer commit; never tested"
-
-	// liveContext is the commit-status context Gitea uses for this
-	// repository's runs, as seen in its API. The script derives it from
-	// the workflow and job names rather than hardcoding it; the
-	// derivation is checked against this value below.
-	liveContext = "check / check (push)"
-
-	scriptPath = "../../script/ci-mark-superseded"
-	workflow   = "../../.gitea/workflows/check.yml"
-
-	// failure is the only state that neither folds into a combined
-	// `success` (as `skipped` does) nor blocks the commit forever (as
-	// `pending` does).
-	failure = "failure"
-)
-
-// repo is a throwaway git history: parent is the commit a run would be
-// cancelled on, head the commit that superseded it.
-type repo struct {
-	dir    string
-	head   string
-	parent string
-}
-
-// scriptEnv is the run identity the Gitea runner exports and the script
-// builds its context string from.
-type scriptEnv struct {
-	workflow string
-	job      string
-	event    string
-}
-
-func defaultEnv() scriptEnv {
-	return scriptEnv{workflow: "check", job: "check", event: "push"}
-}
-
-func cancelled() commitStatus {
-	return commitStatus{
-		Context:     liveContext,
-		Status:      failure,
-		Description: "Has been cancelled",
-	}
-}
-
-func running() commitStatus {
-	return commitStatus{
-		Context:     liveContext,
-		Status:      "pending",
-		Description: "Has started running",
-	}
-}
-
-func TestMarkSuperseded(t *testing.T) {
-	t.Parallel()
-
-	cases := map[string]struct {
-		parent   commitStatus
-		wantMark bool
-	}{
-		"a cancelled run is marked": {
-			parent:   cancelled(),
-			wantMark: true,
-		},
-		"a laundered skipped status is marked": {
-			parent: commitStatus{
-				Context:     liveContext,
-				Status:      "skipped",
-				Description: supersededDesc,
-			},
-			wantMark: true,
-		},
-		"a genuine failure is left alone": {
-			parent: commitStatus{
-				Context:     liveContext,
-				Status:      failure,
-				Description: "Failing after 3m1s",
-			},
-			wantMark: false,
-		},
-		"a passing run is left alone": {
-			parent: commitStatus{
-				Context:     liveContext,
-				Status:      "success",
-				Description: "Successful in 2m52s",
-			},
-			wantMark: false,
-		},
-		"another context is left alone": {
-			parent: commitStatus{
-				Context:     "other / other (push)",
-				Status:      failure,
-				Description: "Has been cancelled",
-			},
-			wantMark: false,
-		},
-	}
-
-	for name, tc := range cases {
-		t.Run(name, func(t *testing.T) {
-			t.Parallel()
-			requireTools(t)
-
-			history := newRepo(t)
-			fake, api := newFakeGitea(t)
-			fake.setStatus(history.head, running())
-			fake.setStatus(history.parent, tc.parent)
-
-			out, err := runScript(t, history, api, defaultEnv())
-			require.NoError(t, err, out)
-
-			posted := fake.postedFor(history.parent)
-			if !tc.wantMark {
-				require.Empty(t, posted)
-
-				return
-			}
-
-			require.Equal(t, []postedStatus{{
-				Context: liveContext,
-				// Not `skipped`: Gitea's combined status folds
-				// that into `success`, which is what made a
-				// never-tested commit read green.
-				State:       failure,
-				Description: supersededDesc,
-			}}, posted)
-		})
-	}
-}
-
-// A second run must not rewrite what the first one wrote, or every
-// later push would post a duplicate status.
-func TestMarkSupersededIsIdempotent(t *testing.T) {
-	t.Parallel()
-	requireTools(t)
-
-	history := newRepo(t)
-	fake, api := newFakeGitea(t)
-	fake.setStatus(history.head, running())
-	fake.setStatus(history.parent, cancelled())
-
-	for range 2 {
-		out, err := runScript(t, history, api, defaultEnv())
-		require.NoError(t, err, out)
-	}
-
-	require.Len(t, fake.postedFor(history.parent), 1)
-}
-
-// Renaming the workflow or the job changes the context string Gitea
-// uses. The script must say so instead of quietly matching nothing.
-func TestMarkSupersededRejectsAnUnknownContext(t *testing.T) {
-	t.Parallel()
-	requireTools(t)
-
-	history := newRepo(t)
-	fake, api := newFakeGitea(t)
-	fake.setStatus(history.head, running())
-	fake.setStatus(history.parent, cancelled())
-
-	env := defaultEnv()
-	env.job = "renamed"
-
-	out, err := runScript(t, history, api, env)
-	require.Error(t, err)
-	require.Contains(t, out, "renamed")
-	require.Contains(t, out, liveContext)
-	require.Empty(t, fake.postedFor(history.parent))
-}
-
-// ANCESTOR_LIMIT is a documented knob. A value that is set but unusable
-// must abort: handing it to git and discarding the exit status left the
-// walk empty and the step green, marking nothing.
-func TestMarkSupersededRejectsAnUnparseableAncestorLimit(t *testing.T) {
-	t.Parallel()
-	requireTools(t)
-
-	history := newRepo(t)
-	fake, api := newFakeGitea(t)
-	fake.setStatus(history.head, running())
-	fake.setStatus(history.parent, cancelled())
-
-	out, err := runScript(
-		t, history, api, defaultEnv(), "ANCESTOR_LIMIT=twenty",
-	)
-	require.Error(t, err)
-	require.Contains(t, out, "ANCESTOR_LIMIT")
-	require.Contains(t, out, "twenty")
-	require.Empty(t, fake.postedFor(history.parent))
-}
-
-// A status read that fails is not the same as a commit with nothing to
-// do. Losing curl's exit status through a pipe made the two identical
-// and left a laundered commit laundered with no signal.
-func TestMarkSupersededFailsOnAnUnreadableAncestorStatus(t *testing.T) {
-	t.Parallel()
-	requireTools(t)
-
-	history := newRepo(t)
-	fake, api := newFakeGitea(t)
-	fake.setStatus(history.head, running())
-	fake.setStatus(history.parent, cancelled())
-	fake.failStatusRead(history.parent)
-
-	out, err := runScript(t, history, api, defaultEnv())
-	require.Error(t, err)
-	require.Contains(t, out, history.parent)
-	require.Contains(t, out, "cannot read commit statuses")
-	require.Empty(t, fake.postedFor(history.parent))
-}
-
-// A shallow clone cannot resolve the parent, so it is indistinguishable
-// from a root commit to rev-parse and the walk would exit 0 having
-// marked nothing. It must abort instead: dropping `fetch-depth: 0` from
-// the checkout step is one edit, and a silent no-op there restores the
-// false-green bug this script exists to prevent.
-func TestMarkSupersededRejectsAShallowRepository(t *testing.T) {
-	t.Parallel()
-	requireTools(t)
-
-	history := shallowClone(t, newRepo(t))
-	fake, api := newFakeGitea(t)
-	fake.setStatus(history.head, running())
-	fake.setStatus(history.parent, cancelled())
-
-	out, err := runScript(t, history, api, defaultEnv())
-	require.Error(t, err)
-	require.Contains(t, out, "shallow repository")
-	require.Empty(t, fake.postedFor(history.parent))
-	require.Empty(t, fake.postedFor(history.head))
-}
-
-// shallowClone returns the same history as a depth-1 clone. The `file://`
-// URL is required: git ignores --depth for a plain local path.
-func shallowClone(t *testing.T, history repo) repo {
-	t.Helper()
-
-	dir := t.TempDir()
-
-	//nolint:gosec // fixed argv, arguments are test-local paths
-	cmd := exec.CommandContext(t.Context(), "git", "clone", "-q",
-		"--depth=1", "file://"+history.dir, dir)
-
-	out, err := cmd.CombinedOutput()
-	require.NoError(t, err, string(out))
-
-	return repo{dir: dir, head: history.head, parent: history.parent}
-}
-
-// The derived context must equal the one Gitea actually uses, which is
-// built from the same workflow and job names.
-func TestDerivedContextMatchesGitea(t *testing.T) {
-	t.Parallel()
-	requireTools(t)
-
-	name, job := workflowIdentity(t)
-
-	history := newRepo(t)
-	fake, api := newFakeGitea(t)
-	fake.setStatus(history.head, running())
-	fake.setStatus(history.parent, cancelled())
-
-	out, err := runScript(t, history, api, scriptEnv{
-		workflow: name,
-		job:      job,
-		event:    "push",
-	})
-	require.NoError(t, err, out)
-
-	posted := fake.postedFor(history.parent)
-	require.Len(t, posted, 1)
-	require.Equal(t, liveContext, posted[0].Context)
-}
-
-// workflowIdentity reads the workflow name and its single job id out of
-// the checked-in workflow file.
-func workflowIdentity(t *testing.T) (string, string) {
-	t.Helper()
-
-	raw, err := os.ReadFile(workflow)
-	require.NoError(t, err)
-
-	var parsed struct {
-		Name string         `yaml:"name"`
-		Jobs map[string]any `yaml:"jobs"`
-	}
-
-	require.NoError(t, yaml.Unmarshal(raw, &parsed))
-
-	jobs := slices.Collect(maps.Keys(parsed.Jobs))
-	require.Len(t, jobs, 1)
-
-	return parsed.Name, jobs[0]
-}
-
-func runScript(
-	t *testing.T, history repo, api string, env scriptEnv,
-	extra ...string,
-) (string, error) {
-	t.Helper()
-
-	script, err := filepath.Abs(scriptPath)
-	require.NoError(t, err)
-
-	//nolint:gosec // fixed argv, repo-local script under test
-	cmd := exec.CommandContext(t.Context(), "sh", script)
-	cmd.Dir = history.dir
-	cmd.Env = append(os.Environ(),
-		"GITHUB_API_URL="+api,
-		"GITHUB_REPOSITORY=sneak/webhooker",
-		"GITHUB_SHA="+history.head,
-		"GITHUB_WORKFLOW="+env.workflow,
-		"GITHUB_JOB="+env.job,
-		"GITHUB_EVENT_NAME="+env.event,
-		"GITEA_TOKEN=test-token",
-	)
-	cmd.Env = append(cmd.Env, extra...)
-
-	out, err := cmd.CombinedOutput()
-
-	return string(out), err
-}
-
-func newRepo(t *testing.T) repo {
-	t.Helper()
-
-	dir := t.TempDir()
-
-	git := func(args ...string) string {
-		//nolint:gosec // fixed argv, arguments are test constants
-		cmd := exec.CommandContext(t.Context(), "git", args...)
-		cmd.Dir = dir
-
-		out, err := cmd.CombinedOutput()
-		require.NoError(t, err, string(out))
-
-		return strings.TrimSpace(string(out))
-	}
-
-	commit := func(message string) string {
-		git(
-			"-c", "user.email=ci@example.invalid",
-			"-c", "user.name=ci",
-			"-c", "commit.gpgsign=false",
-			"commit", "-q", "--allow-empty", "-m", message,
-		)
-
-		return git("rev-parse", "HEAD")
-	}
-
-	git("init", "-q", "-b", "main")
-
-	parent := commit("parent")
-	head := commit("head")
-
-	return repo{dir: dir, head: head, parent: parent}
-}
-
-func requireTools(t *testing.T) {
-	t.Helper()
-
-	for _, tool := range []string{"sh", "git", "curl", "jq"} {
-		_, err := exec.LookPath(tool)
-		if err != nil {
-			t.Skipf("%s is not installed: %v", tool, err)
-		}
-	}
-}

internal/ciscript/doc.go

@@ -1,10 +0,0 @@
-// Package ciscript holds the tests for the repository's CI shell
-// scripts in script/. It carries no runtime code: the scripts run on
-// the CI runner, not inside the binary, but their behaviour still has
-// to be verified by the test suite.
-//
-// The scripts under test are outside the Go build graph, so `go test`'s
-// result cache serves a stale PASS when only a script changed: run the
-// container build, or GOFLAGS=-count=1, to trust a result here after
-// editing script/.
-package ciscript

internal/ciscript/fakegitea_test.go

@@ -1,162 +0,0 @@
-package ciscript_test
-
-import (
-	"encoding/json"
-	"net/http"
-	"net/http/httptest"
-	"sync"
-	"testing"
-)
-
-// commitStatus is the part of an entry in Gitea's combined-status
-// response that script/ci-mark-superseded reads.
-type commitStatus struct {
-	Context     string `json:"context"`
-	Status      string `json:"status"`
-	Description string `json:"description"`
-}
-
-// postedStatus is the part of a create-status request body the script
-// writes.
-type postedStatus struct {
-	Context     string `json:"context"`
-	State       string `json:"state"`
-	Description string `json:"description"`
-}
-
-// fakeGitea serves the two endpoints the script talks to. Like Gitea,
-// the newest status for a context replaces the previous one, so a
-// second run of the script sees what the first one wrote.
-type fakeGitea struct {
-	mu       sync.Mutex
-	statuses map[string][]commitStatus
-	posted   map[string][]postedStatus
-	// failRead is a commit whose combined-status read answers HTTP
-	// 500, standing in for a status API that is down.
-	failRead string
-}
-
-// newFakeGitea returns the fake and the base URL to hand the script as
-// GITHUB_API_URL.
-func newFakeGitea(t *testing.T) (*fakeGitea, string) {
-	t.Helper()
-
-	fake := &fakeGitea{
-		mu:       sync.Mutex{},
-		statuses: map[string][]commitStatus{},
-		posted:   map[string][]postedStatus{},
-		failRead: "",
-	}
-
-	srv := httptest.NewServer(fake.routes())
-	t.Cleanup(srv.Close)
-
-	return fake, srv.URL
-}
-
-func (f *fakeGitea) routes() http.Handler {
-	mux := http.NewServeMux()
-
-	mux.HandleFunc(
-		"GET /repos/{owner}/{repo}/commits/{sha}/status",
-		f.handleCombined,
-	)
-	mux.HandleFunc(
-		"POST /repos/{owner}/{repo}/statuses/{sha}",
-		f.handleCreate,
-	)
-
-	return mux
-}
-
-func (f *fakeGitea) handleCombined(
-	w http.ResponseWriter, r *http.Request,
-) {
-	f.mu.Lock()
-	defer f.mu.Unlock()
-
-	sha := r.PathValue("sha")
-	if f.failRead != "" && f.failRead == sha {
-		http.Error(w, "boom", http.StatusInternalServerError)
-
-		return
-	}
-
-	body := struct {
-		Statuses []commitStatus `json:"statuses"`
-	}{Statuses: f.statuses[sha]}
-
-	payload, err := json.Marshal(body)
-	if err != nil {
-		http.Error(w, err.Error(), http.StatusInternalServerError)
-
-		return
-	}
-
-	w.Header().Set("Content-Type", "application/json")
-
-	_, _ = w.Write(payload)
-}
-
-func (f *fakeGitea) handleCreate(w http.ResponseWriter, r *http.Request) {
-	var got postedStatus
-
-	err := json.NewDecoder(r.Body).Decode(&got)
-	if err != nil {
-		http.Error(w, err.Error(), http.StatusBadRequest)
-
-		return
-	}
-
-	sha := r.PathValue("sha")
-
-	f.mu.Lock()
-	defer f.mu.Unlock()
-
-	f.posted[sha] = append(f.posted[sha], got)
-	f.replaceLocked(sha, commitStatus{
-		Context:     got.Context,
-		Status:      got.State,
-		Description: got.Description,
-	})
-
-	w.WriteHeader(http.StatusCreated)
-}
-
-// failStatusRead makes the combined-status read for one commit answer
-// HTTP 500.
-func (f *fakeGitea) failStatusRead(sha string) {
-	f.mu.Lock()
-	defer f.mu.Unlock()
-
-	f.failRead = sha
-}
-
-// setStatus gives a commit its latest status for a context.
-func (f *fakeGitea) setStatus(sha string, status commitStatus) {
-	f.mu.Lock()
-	defer f.mu.Unlock()
-
-	f.replaceLocked(sha, status)
-}
-
-// postedFor returns the statuses the script created for a commit.
-func (f *fakeGitea) postedFor(sha string) []postedStatus {
-	f.mu.Lock()
-	defer f.mu.Unlock()
-
-	return append([]postedStatus(nil), f.posted[sha]...)
-}
-
-// replaceLocked requires f.mu.
-func (f *fakeGitea) replaceLocked(sha string, status commitStatus) {
-	for i, existing := range f.statuses[sha] {
-		if existing.Context == status.Context {
-			f.statuses[sha][i] = status
-
-			return
-		}
-	}
-
-	f.statuses[sha] = append(f.statuses[sha], status)
-}

internal/config/clearenv_test.go

@@ -0,0 +1,37 @@
+package config_test
+
+import (
+	"os"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"sneak.berlin/go/webhooker/internal/config"
+	"sneak.berlin/go/webhooker/internal/config/configtest"
+)
+
+// TestClearEnv_RemovesAddedVariables pins that a variable set
+// after the clear other than through t.Setenv, as a test's .env file
+// sets one, is gone once the test ends, so it cannot reach the tests
+// that run after it.
+//
+//nolint:paralleltest // ClearEnv uses t.Setenv.
+func TestClearEnv_RemovesAddedVariables(t *testing.T) {
+	// The outer clear keeps a value of the key exported in the shell
+	// from making it a variable the inner clear has to put back.
+	configtest.ClearEnv(t)
+
+	t.Run("loads a .env file after the clear", func(t *testing.T) {
+		configtest.ClearEnv(t)
+
+		path := writeDotEnv(t, dotEnvKey+"=from-dot-env\n")
+		require.NoError(t, config.LoadDotEnvFileForTest(path))
+		require.Equal(t, "from-dot-env", os.Getenv(dotEnvKey))
+	})
+
+	_, present := os.LookupEnv(dotEnvKey)
+	assert.False(
+		t, present,
+		"a variable set after the clear must not outlive the test",
+	)
+}

internal/config/config.go

@@ -68,6 +68,10 @@ const (
 	// authenticated activity before it expires.
 	defaultSessionIdleTimeout = 24 * time.Hour
 
+	// defaultHSTSMaxAge is the max-age of the Strict-Transport-Security
+	// header when HSTS_MAX_AGE is unset: ten years.
+	defaultHSTSMaxAge = 87600 * time.Hour
+
 	// defaultReceiverRateLimit is the default number of requests
 	// per minute each client IP may send to a single webhook
 	// receiver entrypoint. Generous for legitimate webhook
@@ -75,8 +79,12 @@ const (
 	// internet-exposed endpoint.
 	defaultReceiverRateLimit = 120
 
-	// maxPort is the highest valid TCP port number. The lower
-	// bound (at least 1) is enforced by envPositiveInt.
+	// defaultTrustedProxies is TRUSTED_PROXIES when it is unset: the
+	// RFC 1918 private ranges, which a reverse proxy reaching the
+	// process over a Docker network or a private LAN connects from.
+	defaultTrustedProxies = "10.0.0.0/8,172.16.0.0/12,192.168.0.0/16"
+
+	// maxPort is the highest valid TCP port number.
 	maxPort = 65535
 
 	// mappedV4Offset is the number of leading bits an IPv4-mapped
@@ -100,7 +108,7 @@ var ErrInvalidEnvironment = errors.New("invalid environment")
 var ErrNonPositiveValue = errors.New("value must be positive")
 
 // ErrInvalidPort is returned when an environment variable holding a
-// TCP port number is set above the valid port range.
+// TCP port number is set to a number outside 1 to 65535.
 var ErrInvalidPort = errors.New("invalid port")
 
 // ErrInvalidCIDR is returned when an environment variable holding a
@@ -116,6 +124,10 @@ var ErrInvalidBindAddress = errors.New("invalid bind address")
 // the Sentry SDK cannot parse as a DSN.
 var ErrInvalidSentryDSN = errors.New("invalid Sentry DSN")
 
+// ErrInvalidHSTSMaxAge is returned when HSTS_MAX_AGE is set to a
+// negative duration or one that is not a whole number of seconds.
+var ErrInvalidHSTSMaxAge = errors.New("invalid HSTS max-age")
+
 // ErrDotEnvUnreadable is returned when the optional .env file exists
 // but cannot be read or parsed. A file that is not there is not an
 // error; a file that is there and broken is.
@@ -144,7 +156,6 @@ type ConfigParams struct {
 type Config struct {
 	DataDir         string
 	Debug           bool
-	MaintenanceMode bool
 	Environment     string
 	MetricsPassword string
 	MetricsUsername string
@@ -166,19 +177,24 @@ type Config struct {
 	// which a session expires. Non-positive disables idle expiry.
 	SessionIdleTimeout time.Duration
 
+	// HSTSMaxAge is the max-age of the Strict-Transport-Security
+	// header. Zero means the header is not sent at all.
+	HSTSMaxAge time.Duration
+
 	// ReceiverRateLimit is the number of requests per minute each
 	// client IP may send to a single webhook receiver entrypoint.
 	ReceiverRateLimit int
 
 	// TrustedProxies is the set of networks whose members are
 	// allowed to speak for the client with X-Forwarded-For, the
-	// only forwarded header read. It is empty unless
-	// TRUSTED_PROXIES is set, and empty means no peer is
-	// trusted: forwarded headers are then ignored entirely and
-	// clients are identified by the connection's own address.
-	// Members can choose their own rate-limit key, so this must
-	// name proxy hosts only, never a block that also covers
-	// clients.
+	// only forwarded header read. Unless TRUSTED_PROXIES is set it
+	// is the RFC 1918 private ranges (defaultTrustedProxies); a set
+	// value replaces them. If any client can reach the process, or
+	// the proxy in front of it, from an RFC 1918 source address
+	// (directly, or through anything that can rewrite source
+	// addresses, such as NAT or a published container port), it
+	// must be set to the proxy's address alone, or every rate limit
+	// can be bypassed by those clients.
 	TrustedProxies []netip.Prefix
 
 	// AllowedEgressCIDRs is the set of networks a delivery target
@@ -190,12 +206,13 @@ type Config struct {
 	// otherwise refuse. The guard itself is always on: there is no
 	// setting that disables SSRF protection, and delivery's
 	// alwaysBlockedNetworks stays blocked no matter what is listed
-	// here. That set is link-local plus the cloud metadata
-	// endpoints outside it that disclose credentials or user data
-	// at a provider-fixed, non-public address; it is not
-	// exhaustive of every cloud's metadata address. See
-	// alwaysBlockedNetworks for the authoritative list and the
-	// criterion it is built from.
+	// here. That set is link-local, the unspecified addresses
+	// 0.0.0.0 and ::, and the cloud metadata endpoints outside
+	// link-local that disclose credentials or user data at a
+	// provider-fixed, non-public address; it is not exhaustive of
+	// every cloud's metadata address. See
+	// alwaysBlockedNetworks for the authoritative list and why
+	// each entry is on it.
 	AllowedEgressCIDRs []netip.Prefix
 
 	params *ConfigParams
@@ -357,17 +374,27 @@ func envPositiveInt(
 // envPort returns the value of the named environment variable parsed
 // as a TCP port number. Returns defaultValue if not set. A set value
 // that is unparseable, below 1, or above maxPort is a hard error
-// naming the key and the bad value.
+// naming the key and the bad value; every out-of-range value wraps
+// ErrInvalidPort, including one too large or too small for an int.
 func envPort(key string, defaultValue int) (int, error) {
-	port, err := envPositiveInt(key, defaultValue)
-	if err != nil {
-		return 0, err
+	v := os.Getenv(key)
+	if v == "" {
+		return defaultValue, nil
 	}
 
-	if port > maxPort {
+	// strconv.ErrRange means a number too large or too small for an
+	// int, which is outside the port range as well.
+	port, err := strconv.Atoi(v)
+	if err != nil && !errors.Is(err, strconv.ErrRange) {
 		return 0, fmt.Errorf(
-			"%w: %s must be at most %d, got %d",
-			ErrInvalidPort, key, maxPort, port,
+			"invalid integer for %s: %q: %w", key, v, err,
+		)
+	}
+
+	if err != nil || port < 1 || port > maxPort {
+		return 0, fmt.Errorf(
+			"%w: %s must be from 1 to %d, got %q",
+			ErrInvalidPort, key, maxPort, v,
 		)
 	}
 
@@ -460,14 +487,15 @@ func parseCIDR(entry string) (netip.Prefix, error) {
 
 // envPrefixList returns the value of the named environment variable
 // parsed as a comma-separated list of CIDR blocks (bare addresses
-// allowed). An unset, empty, or blank value yields an empty list. A
-// set value containing an unparseable entry is a hard error naming
-// the key and the bad entry, so startup fails loudly rather than
-// silently running with a list the operator did not intend.
-func envPrefixList(key string) ([]netip.Prefix, error) {
+// allowed). An unset, empty, or blank value is read as defaultValue
+// instead. A set value containing an unparseable entry is a hard
+// error naming the key and the bad entry, so startup fails loudly
+// rather than silently running with a list the operator did not
+// intend.
+func envPrefixList(key, defaultValue string) ([]netip.Prefix, error) {
 	v := strings.TrimSpace(os.Getenv(key))
 	if v == "" {
-		return nil, nil
+		v = defaultValue
 	}
 
 	var prefixes []netip.Prefix
@@ -608,6 +636,27 @@ func resolveEnvironment() (string, error) {
 	return environment, nil
 }
 
+// resolveHSTSMaxAge reads HSTS_MAX_AGE. Zero is allowed and turns the
+// Strict-Transport-Security header off. A fraction of a second is an
+// error rather than rounded, because the header carries whole seconds
+// and would otherwise say something other than what was set.
+func resolveHSTSMaxAge() (time.Duration, error) {
+	maxAge, err := envDuration("HSTS_MAX_AGE", defaultHSTSMaxAge)
+	if err != nil {
+		return 0, err
+	}
+
+	if maxAge < 0 || maxAge%time.Second != 0 {
+		return 0, fmt.Errorf(
+			"%w: HSTS_MAX_AGE must be zero or a positive whole "+
+				"number of seconds, got %s",
+			ErrInvalidHSTSMaxAge, maxAge,
+		)
+	}
+
+	return maxAge, nil
+}
+
 // resolveListener reads the two variables that describe the HTTP
 // listener: which port it claims and which address it claims it on.
 // They are read together because neither is meaningful alone, and
@@ -650,11 +699,6 @@ func loadFromEnv() (*Config, error) {
 		return nil, err
 	}
 
-	maintenanceMode, err := envBool("MAINTENANCE_MODE", false)
-	if err != nil {
-		return nil, err
-	}
-
 	retentionSweepInterval, err := envPositiveDuration(
 		"RETENTION_SWEEP_INTERVAL",
 		defaultRetentionSweepInterval,
@@ -673,6 +717,11 @@ func loadFromEnv() (*Config, error) {
 		return nil, err
 	}
 
+	hstsMaxAge, err := resolveHSTSMaxAge()
+	if err != nil {
+		return nil, err
+	}
+
 	receiverRateLimit, err := envPositiveInt(
 		"RECEIVER_RATE_LIMIT",
 		defaultReceiverRateLimit,
@@ -681,12 +730,12 @@ func loadFromEnv() (*Config, error) {
 		return nil, err
 	}
 
-	trustedProxies, err := envPrefixList("TRUSTED_PROXIES")
+	trustedProxies, err := envPrefixList("TRUSTED_PROXIES", defaultTrustedProxies)
 	if err != nil {
 		return nil, err
 	}
 
-	allowedEgressCIDRs, err := envPrefixList("ALLOWED_EGRESS_CIDRS")
+	allowedEgressCIDRs, err := envPrefixList("ALLOWED_EGRESS_CIDRS", "")
 	if err != nil {
 		return nil, err
 	}
@@ -704,7 +753,6 @@ func loadFromEnv() (*Config, error) {
 	return &Config{
 		DataDir:                DataDir(),
 		Debug:                  debug,
-		MaintenanceMode:        maintenanceMode,
 		Environment:            environment,
 		MetricsUsername:        metricsUsername,
 		MetricsPassword:        metricsPassword,
@@ -713,6 +761,7 @@ func loadFromEnv() (*Config, error) {
 		SentryDSN:              sentryDSN,
 		RetentionSweepInterval: retentionSweepInterval,
 		SessionIdleTimeout:     sessionIdleTimeout,
+		HSTSMaxAge:             hstsMaxAge,
 		ReceiverRateLimit:      receiverRateLimit,
 		TrustedProxies:         trustedProxies,
 		AllowedEgressCIDRs:     allowedEgressCIDRs,
@@ -760,50 +809,6 @@ func (c *Config) warnEgressAllowlist(log *slog.Logger) {
 	)
 }
 
-// warnSharedRateLimitBucket logs a startup warning whenever
-// TRUSTED_PROXIES is empty, in any environment.
-//
-// With no trusted proxies every rate limiter keys on the connecting
-// peer's address. Whether that is harmless or dangerous depends on
-// what is in front of the process, which this code cannot observe:
-// with nothing in front, the peer is the client and the limits are
-// per-client as intended; behind a reverse proxy the peer is the proxy
-// for every request, so all clients share one bucket per limiter.
-//
-// The login endpoint no longer spends budget on arrival — it verifies
-// credentials first and charges only failures — so a shared bucket
-// cannot deny the operator a correct password. What it does collapse
-// is the failure counting: one client's wrong passwords throttle
-// everyone else's wrong passwords, and the receiver's limits become
-// service-wide ceilings.
-//
-// The warning is deliberately not gated on WEBHOOKER_ENVIRONMENT:
-// behind a proxy every client shares one bucket in dev and prod alike.
-//
-// The default of trusting nobody is deliberate — trusting forwarded
-// headers from arbitrary peers lets any client choose its own bucket —
-// so this warns rather than failing startup or changing the key.
-func (c *Config) warnSharedRateLimitBucket(log *slog.Logger) {
-	if len(c.TrustedProxies) > 0 {
-		return
-	}
-
-	log.Warn(
-		"TRUSTED_PROXIES is empty: every rate limit keys on the "+
-			"connecting peer's address. With nothing proxying to "+
-			"this process that is the client itself and the limits "+
-			"are per-client as intended. Behind a reverse proxy the "+
-			"peer is the proxy on every request, so all clients "+
-			"share one bucket per limit: the receiver limits become "+
-			"service-wide ceilings, and one client's failed logins "+
-			"throttle every other client's failed logins — a "+
-			"correct password still gets in. If anything proxies to "+
-			"this process, set TRUSTED_PROXIES to its address.",
-		"environment", c.Environment,
-		"trustedProxies", len(c.TrustedProxies),
-	)
-}
-
 // New creates a Config by reading environment variables.
 //
 //nolint:revive // lc parameter is required by fx even if unused.
@@ -835,13 +840,13 @@ func New(lc fx.Lifecycle, params ConfigParams) (*Config, error) {
 		// host can reach the admin UI.
 		"bindAddress", s.BindAddress,
 		"debug", s.Debug,
-		"maintenanceMode", s.MaintenanceMode,
 		"dataDir", s.DataDir,
 		"retentionSweepInterval", s.RetentionSweepInterval.String(),
 		// Logged because a perfectly valid non-positive value here
 		// disables idle expiry entirely, and that is worth showing
 		// back to the operator.
 		"sessionIdleTimeout", s.SessionIdleTimeout.String(),
+		"hstsMaxAge", s.HSTSMaxAge.String(),
 		"receiverRateLimit", s.ReceiverRateLimit,
 		"trustedProxies", len(s.TrustedProxies),
 		"allowedEgressCIDRs", len(s.AllowedEgressCIDRs),
@@ -849,7 +854,6 @@ func New(lc fx.Lifecycle, params ConfigParams) (*Config, error) {
 		"hasMetricsAuth", s.MetricsAuthEnabled(),
 	)
 
-	s.warnSharedRateLimitBucket(log)
 	s.warnEgressAllowlist(log)
 
 	return s, nil

internal/config/config_test.go

@@ -3,7 +3,6 @@ package config_test
 import (
 	"bytes"
 	"log/slog"
-	"os"
 	"testing"
 	"time"
 
@@ -12,6 +11,7 @@ import (
 	"go.uber.org/fx"
 	"go.uber.org/fx/fxtest"
 	"sneak.berlin/go/webhooker/internal/config"
+	"sneak.berlin/go/webhooker/internal/config/configtest"
 	"sneak.berlin/go/webhooker/internal/globals"
 	"sneak.berlin/go/webhooker/internal/logger"
 )
@@ -71,14 +71,12 @@ func TestEnvironmentConfig(t *testing.T) {
 		t.Run(tt.name, func(t *testing.T) {
 			// Cannot use t.Parallel() here because t.Setenv
 			// is incompatible with parallel subtests.
+			configtest.ClearEnv(t)
+
 			if tt.envValue != "" {
 				t.Setenv(
 					"WEBHOOKER_ENVIRONMENT", tt.envValue,
 				)
-			} else {
-				require.NoError(t, os.Unsetenv(
-					"WEBHOOKER_ENVIRONMENT",
-				))
 			}
 
 			for k, v := range tt.envVars {
@@ -124,6 +122,11 @@ func testEnvironmentConfigSuccess(
 
 	app := fxtest.New(
 		t,
+		// fx's own log is discarded, not sent to t.Logf: a hook still
+		// running after a start or stop timeout would write there after
+		// the test has returned. The same holds for every fxtest.New
+		// below.
+		fx.NopLogger,
 		fx.Provide(
 			globals.New,
 			logger.New,
@@ -194,14 +197,11 @@ func TestRetentionSweepInterval(t *testing.T) {
 		t.Run(tt.name, func(t *testing.T) {
 			// Cannot use t.Parallel() here because t.Setenv
 			// is incompatible with parallel subtests.
+			configtest.ClearEnv(t)
 			t.Setenv("WEBHOOKER_ENVIRONMENT", "dev")
 
 			if tt.set {
 				t.Setenv("RETENTION_SWEEP_INTERVAL", tt.value)
-			} else {
-				require.NoError(t, os.Unsetenv(
-					"RETENTION_SWEEP_INTERVAL",
-				))
 			}
 
 			if tt.expectError {
@@ -272,6 +272,7 @@ func testRetentionSweepIntervalSuccess(
 
 	app := fxtest.New(
 		t,
+		fx.NopLogger,
 		fx.Provide(
 			globals.New,
 			logger.New,
@@ -335,14 +336,11 @@ func TestSessionIdleTimeout(t *testing.T) {
 		t.Run(tt.name, func(t *testing.T) {
 			// Cannot use t.Parallel() here because t.Setenv
 			// is incompatible with parallel subtests.
+			configtest.ClearEnv(t)
 			t.Setenv("WEBHOOKER_ENVIRONMENT", "dev")
 
 			if tt.set {
 				t.Setenv("SESSION_IDLE_TIMEOUT", tt.value)
-			} else {
-				require.NoError(t, os.Unsetenv(
-					"SESSION_IDLE_TIMEOUT",
-				))
 			}
 
 			if tt.expectError {
@@ -364,6 +362,7 @@ func testSessionIdleTimeoutSuccess(
 
 	app := fxtest.New(
 		t,
+		fx.NopLogger,
 		fx.Provide(
 			globals.New,
 			logger.New,
@@ -380,6 +379,83 @@ func testSessionIdleTimeoutSuccess(
 	assert.Equal(t, expected, cfg.SessionIdleTimeout)
 }
 
+func TestHSTSMaxAge(t *testing.T) {
+	tests := []struct {
+		name        string
+		set         bool
+		value       string
+		expectError bool
+		// sentinel, when set, must be wrapped by the startup
+		// error; every error case must additionally name the
+		// variable in its message.
+		sentinel error
+		expected time.Duration
+	}{
+		{
+			name:     caseUnsetUsesDefault,
+			set:      false,
+			expected: 87600 * time.Hour,
+		},
+		{
+			name:     caseValidValueParsed,
+			set:      true,
+			value:    "720h",
+			expected: 720 * time.Hour,
+		},
+		{
+			// Zero turns the header off; it is not an error.
+			name:     "zero is accepted",
+			set:      true,
+			value:    "0",
+			expected: 0,
+		},
+		{
+			name:        caseUnparseableFails,
+			set:         true,
+			value:       "10 years",
+			expectError: true,
+		},
+		{
+			// A whole number of seconds, so only the sign is wrong.
+			name:        "negative whole seconds fail startup",
+			set:         true,
+			value:       "-1s",
+			expectError: true,
+			sentinel:    config.ErrInvalidHSTSMaxAge,
+		},
+		{
+			name:        "fraction of a second fails startup",
+			set:         true,
+			value:       "1500ms",
+			expectError: true,
+			sentinel:    config.ErrInvalidHSTSMaxAge,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			// Cannot use t.Parallel() here because t.Setenv
+			// is incompatible with parallel subtests.
+			configtest.ClearEnv(t)
+			t.Setenv("WEBHOOKER_ENVIRONMENT", "dev")
+
+			if tt.set {
+				t.Setenv("HSTS_MAX_AGE", tt.value)
+			}
+
+			if tt.expectError {
+				expectStartupErrorFor(t, "HSTS_MAX_AGE", tt.sentinel)
+
+				return
+			}
+
+			cfg, err := buildConfig(t)
+			require.NoError(t, err)
+			assert.Equal(t, tt.expected, cfg.HSTSMaxAge)
+		})
+	}
+}
+
 func TestDefaultDataDir(t *testing.T) {
 	for _, env := range []string{"", "dev", "prod"} {
 		name := env
@@ -390,20 +466,17 @@ func TestDefaultDataDir(t *testing.T) {
 		t.Run("env="+name, func(t *testing.T) {
 			// Cannot use t.Parallel() here because t.Setenv
 			// is incompatible with parallel subtests.
+			configtest.ClearEnv(t)
+
 			if env != "" {
 				t.Setenv("WEBHOOKER_ENVIRONMENT", env)
-			} else {
-				require.NoError(t, os.Unsetenv(
-					"WEBHOOKER_ENVIRONMENT",
-				))
 			}
 
-			require.NoError(t, os.Unsetenv("DATA_DIR"))
-
 			var cfg *config.Config
 
 			app := fxtest.New(
 				t,
+				fx.NopLogger,
 				fx.Provide(
 					globals.New,
 					logger.New,
@@ -438,9 +511,9 @@ func TestDataDirHelper(t *testing.T) {
 		t.Run(name, func(t *testing.T) {
 			// Cannot use t.Parallel() here because t.Setenv
 			// is incompatible with parallel subtests.
-			if set == "" {
-				require.NoError(t, os.Unsetenv("DATA_DIR"))
-			} else {
+			configtest.ClearEnv(t)
+
+			if set != "" {
 				t.Setenv("DATA_DIR", set)
 			}
 
@@ -503,14 +576,11 @@ func TestReceiverRateLimit(t *testing.T) {
 		t.Run(tt.name, func(t *testing.T) {
 			// Cannot use t.Parallel() here because t.Setenv
 			// is incompatible with parallel subtests.
+			configtest.ClearEnv(t)
 			t.Setenv("WEBHOOKER_ENVIRONMENT", "dev")
 
 			if tt.set {
 				t.Setenv("RECEIVER_RATE_LIMIT", tt.value)
-			} else {
-				require.NoError(t, os.Unsetenv(
-					"RECEIVER_RATE_LIMIT",
-				))
 			}
 
 			if tt.expectError {
@@ -534,6 +604,7 @@ func testReceiverRateLimitSuccess(
 
 	app := fxtest.New(
 		t,
+		fx.NopLogger,
 		fx.Provide(
 			globals.New,
 			logger.New,
@@ -551,6 +622,11 @@ func testReceiverRateLimitSuccess(
 }
 
 func TestTrustedProxies(t *testing.T) {
+	// Unset, the RFC 1918 private ranges are trusted, so a reverse
+	// proxy on a Docker network or a private LAN is covered without
+	// configuration.
+	defaultProxies := []string{cidrPrivateV4, "172.16.0.0/12", "192.168.0.0/16"}
+
 	tests := []struct {
 		name        string
 		set         bool
@@ -559,18 +635,21 @@ func TestTrustedProxies(t *testing.T) {
 		expected    []string
 	}{
 		{
-			// The default must be "trust nobody": an empty list
-			// means forwarded headers are ignored, never that
-			// every peer may speak for the client.
 			name:     caseUnsetUsesDefault,
 			set:      false,
-			expected: []string{},
+			expected: defaultProxies,
 		},
 		{
-			name:     "blank value trusts nothing",
+			name:     "blank value uses default",
 			set:      true,
 			value:    "  ",
-			expected: []string{},
+			expected: defaultProxies,
+		},
+		{
+			name:     "set value replaces the default entirely",
+			set:      true,
+			value:    "203.0.113.7",
+			expected: []string{"203.0.113.7/32"},
 		},
 		{
 			name:  caseValidValueParsed,
@@ -613,12 +692,11 @@ func TestTrustedProxies(t *testing.T) {
 		t.Run(tt.name, func(t *testing.T) {
 			// Cannot use t.Parallel() here because t.Setenv
 			// is incompatible with parallel subtests.
+			configtest.ClearEnv(t)
 			t.Setenv("WEBHOOKER_ENVIRONMENT", "dev")
 
 			if tt.set {
 				t.Setenv("TRUSTED_PROXIES", tt.value)
-			} else {
-				require.NoError(t, os.Unsetenv("TRUSTED_PROXIES"))
 			}
 
 			if tt.expectError {
@@ -642,6 +720,7 @@ func testTrustedProxiesSuccess(
 
 	app := fxtest.New(
 		t,
+		fx.NopLogger,
 		fx.Provide(
 			globals.New,
 			logger.New,
@@ -724,14 +803,11 @@ func TestAllowedEgressCIDRs(t *testing.T) {
 		t.Run(tt.name, func(t *testing.T) {
 			// Cannot use t.Parallel() here because t.Setenv
 			// is incompatible with parallel subtests.
+			configtest.ClearEnv(t)
 			t.Setenv("WEBHOOKER_ENVIRONMENT", "dev")
 
 			if tt.set {
 				t.Setenv("ALLOWED_EGRESS_CIDRS", tt.value)
-			} else {
-				require.NoError(
-					t, os.Unsetenv("ALLOWED_EGRESS_CIDRS"),
-				)
 			}
 
 			if tt.expectError {
@@ -755,6 +831,7 @@ func testAllowedEgressCIDRsSuccess(
 
 	app := fxtest.New(
 		t,
+		fx.NopLogger,
 		fx.Provide(
 			globals.New,
 			logger.New,
@@ -798,13 +875,10 @@ func TestEgressAllowlistWarning(t *testing.T) {
 		t.Run(tt.name, func(t *testing.T) {
 			// Cannot use t.Parallel() here because t.Setenv
 			// is incompatible with parallel subtests.
+			configtest.ClearEnv(t)
 			t.Setenv("WEBHOOKER_ENVIRONMENT", config.EnvironmentDev)
 
-			if tt.allowed == "" {
-				require.NoError(
-					t, os.Unsetenv("ALLOWED_EGRESS_CIDRS"),
-				)
-			} else {
+			if tt.allowed != "" {
 				t.Setenv("ALLOWED_EGRESS_CIDRS", tt.allowed)
 			}
 
@@ -845,101 +919,6 @@ func TestEgressAllowlistWarning(t *testing.T) {
 	}
 }
 
-// TestSharedRateLimitBucketWarning covers the startup warning that
-// tells an operator a deployment behind a reverse proxy shares one
-// rate-limit bucket between every client, which turns the receiver
-// limits into service-wide ceilings and collapses login failure
-// counting. It must fire whenever TRUSTED_PROXIES is empty, in any
-// environment, because behind a proxy every client shares one bucket
-// in dev and prod alike. It stays quiet once proxies are named.
-func TestSharedRateLimitBucketWarning(t *testing.T) {
-	tests := []struct {
-		name           string
-		environment    string
-		trustedProxies string
-		expectWarning  bool
-	}{
-		{
-			name:          "prod without trusted proxies warns",
-			environment:   config.EnvironmentProd,
-			expectWarning: true,
-		},
-		{
-			name:           "prod with trusted proxies is quiet",
-			environment:    config.EnvironmentProd,
-			trustedProxies: cidrPrivateV4,
-			expectWarning:  false,
-		},
-		{
-			name:          "dev without trusted proxies warns",
-			environment:   config.EnvironmentDev,
-			expectWarning: true,
-		},
-		{
-			name:           "dev with trusted proxies is quiet",
-			environment:    config.EnvironmentDev,
-			trustedProxies: cidrPrivateV4,
-			expectWarning:  false,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			// Cannot use t.Parallel() here because t.Setenv
-			// is incompatible with parallel subtests.
-			t.Setenv("WEBHOOKER_ENVIRONMENT", tt.environment)
-
-			if tt.trustedProxies == "" {
-				require.NoError(
-					t, os.Unsetenv("TRUSTED_PROXIES"),
-				)
-			} else {
-				t.Setenv("TRUSTED_PROXIES", tt.trustedProxies)
-			}
-
-			var buf bytes.Buffer
-
-			log := slog.New(slog.NewJSONHandler(
-				&buf, &slog.HandlerOptions{
-					Level: slog.LevelDebug,
-				},
-			))
-
-			require.NoError(
-				t,
-				config.WarnSharedRateLimitBucketForTest(log),
-			)
-
-			if !tt.expectWarning {
-				assert.Empty(t, buf.String())
-
-				return
-			}
-
-			logged := buf.String()
-
-			assert.Contains(t, logged, `"level":"WARN"`)
-			assert.Contains(t, logged, "TRUSTED_PROXIES")
-			assert.Contains(t, logged, "share one bucket")
-			assert.Contains(
-				t, logged, "throttle every other client's failed logins",
-			)
-			// The warning must not claim a lockout the login
-			// endpoint no longer permits: credentials are verified
-			// before any budget is spent.
-			assert.Contains(
-				t, logged, "a correct password still gets in",
-			)
-			// The text must stay accurate for a developer with
-			// nothing in front of the process, where an empty
-			// list costs nothing.
-			assert.Contains(
-				t, logged, "nothing proxying to this process",
-			)
-		})
-	}
-}
-
 // metricsEnv describes what one subtest below puts in the
 // environment for a single METRICS_ variable. A variable that is
 // set to the empty string and one that is not set at all are
@@ -1032,20 +1011,14 @@ func TestMetricsAuthConfig(t *testing.T) {
 		t.Run(tt.name, func(t *testing.T) {
 			// Cannot use t.Parallel() here because t.Setenv
 			// is incompatible with parallel subtests.
+			configtest.ClearEnv(t)
+
 			if tt.username.set {
 				t.Setenv("METRICS_USERNAME", tt.username.value)
-			} else {
-				require.NoError(
-					t, os.Unsetenv("METRICS_USERNAME"),
-				)
 			}
 
 			if tt.password.set {
 				t.Setenv("METRICS_PASSWORD", tt.password.value)
-			} else {
-				require.NoError(
-					t, os.Unsetenv("METRICS_PASSWORD"),
-				)
 			}
 
 			if tt.expectError {
@@ -1093,6 +1066,7 @@ func assertMetricsAuthAccepted(t *testing.T, expectAuth bool) {
 
 	app := fxtest.New(
 		t,
+		fx.NopLogger,
 		fx.Provide(globals.New, logger.New, config.New),
 		fx.Populate(&cfg),
 	)

internal/config/configtest/configtest.go

@@ -0,0 +1,52 @@
+// Package configtest holds test support for code that reads the
+// process environment.
+package configtest
+
+import (
+	"os"
+	"strings"
+	"testing"
+)
+
+// ClearEnv unsets every variable in the process environment
+// for the rest of the test, so a test sees only the variables it sets
+// itself, not whatever the developer's shell exports. When the test
+// ends it leaves the environment exactly as it found it: each variable
+// it unset is put back, and any variable added since is removed.
+func ClearEnv(t *testing.T) {
+	t.Helper()
+
+	present := make(map[string]bool)
+
+	for _, entry := range os.Environ() {
+		key, _, _ := strings.Cut(entry, "=")
+		present[key] = true
+
+		// t.Setenv registers the restore; the Unsetenv after it is
+		// what makes the key absent, since a key set to the empty
+		// string is still present, and godotenv will not overwrite a
+		// present key.
+		t.Setenv(key, "")
+
+		err := os.Unsetenv(key)
+		if err != nil {
+			t.Fatalf("unsetting %s: %v", key, err)
+		}
+	}
+
+	// A variable the test adds other than through t.Setenv, as loading
+	// a .env file does, has no restore of its own.
+	t.Cleanup(func() {
+		for _, entry := range os.Environ() {
+			key, _, _ := strings.Cut(entry, "=")
+			if present[key] {
+				continue
+			}
+
+			err := os.Unsetenv(key)
+			if err != nil {
+				t.Errorf("unsetting %s: %v", key, err)
+			}
+		}
+	})
+}

internal/config/dotenv_test.go

@@ -8,6 +8,7 @@ import (
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 	"sneak.berlin/go/webhooker/internal/config"
+	"sneak.berlin/go/webhooker/internal/config/configtest"
 )
 
 // dotEnvKey is a throwaway variable name the .env tests write and
@@ -22,17 +23,6 @@ const malformedDotEnv = "PORT 19615\n" +
 	"this is not = valid ! syntax\n" +
 	"\"unclosed\n"
 
-// unsetDotEnvKey makes dotEnvKey genuinely absent for the duration of
-// the test and restores it afterwards. t.Setenv registers the restore;
-// the Unsetenv that follows is what the test actually needs, because a
-// variable set to the empty string is still present in os.Environ and
-// godotenv would refuse to overwrite it.
-func unsetDotEnvKey(t *testing.T) {
-	t.Helper()
-	t.Setenv(dotEnvKey, "placeholder")
-	require.NoError(t, os.Unsetenv(dotEnvKey))
-}
-
 // writeDotEnv writes contents to a .env file in a fresh temporary
 // directory and returns its path.
 func writeDotEnv(t *testing.T, contents string) string {
@@ -50,9 +40,9 @@ func writeDotEnv(t *testing.T, contents string) string {
 // normally rather than be refused for a file it was never meant to
 // have.
 //
-//nolint:paralleltest // unsetDotEnvKey uses t.Setenv.
+//nolint:paralleltest // ClearEnv uses t.Setenv.
 func TestLoadDotEnv_MissingFileIsFine(t *testing.T) {
-	unsetDotEnvKey(t)
+	configtest.ClearEnv(t)
 
 	absent := filepath.Join(t.TempDir(), config.DotEnvPath)
 	require.NoError(t, config.LoadDotEnvFileForTest(absent))
@@ -65,9 +55,9 @@ func TestLoadDotEnv_MissingFileIsFine(t *testing.T) {
 // reaches the environment, which is the whole reason the file is read
 // at all.
 //
-//nolint:paralleltest // unsetDotEnvKey uses t.Setenv.
+//nolint:paralleltest // ClearEnv uses t.Setenv.
 func TestLoadDotEnv_AppliesValues(t *testing.T) {
-	unsetDotEnvKey(t)
+	configtest.ClearEnv(t)
 
 	path := writeDotEnv(t, "# a comment\n"+dotEnvKey+"=from-dot-env\n")
 
@@ -93,9 +83,9 @@ func TestLoadDotEnv_RealEnvironmentWins(t *testing.T) {
 // reverts to its default; the process used to start that way with no
 // log line naming the file at all.
 //
-//nolint:paralleltest // unsetDotEnvKey uses t.Setenv.
+//nolint:paralleltest // ClearEnv uses t.Setenv.
 func TestLoadDotEnv_MalformedFileAborts(t *testing.T) {
-	unsetDotEnvKey(t)
+	configtest.ClearEnv(t)
 
 	path := writeDotEnv(
 		t, malformedDotEnv+dotEnvKey+"=from-dot-env\n",
@@ -143,7 +133,7 @@ func TestLoadDotEnv_UnreadableFileAborts(t *testing.T) {
 //
 //nolint:paralleltest // t.Chdir moves the whole process.
 func TestLoadDotEnv_ReadsTheWorkingDirectory(t *testing.T) {
-	unsetDotEnvKey(t)
+	configtest.ClearEnv(t)
 
 	dir := t.TempDir()
 	require.NoError(t, os.WriteFile(

internal/config/env_test.go

@@ -1,13 +1,13 @@
 package config_test
 
 import (
-	"os"
 	"testing"
 
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 	"go.uber.org/fx"
 	"sneak.berlin/go/webhooker/internal/config"
+	"sneak.berlin/go/webhooker/internal/config/configtest"
 	"sneak.berlin/go/webhooker/internal/globals"
 	"sneak.berlin/go/webhooker/internal/logger"
 )
@@ -18,10 +18,9 @@ const testEnvKey = "WEBHOOKER_TEST_VALUE"
 
 // Real configuration variables exercised by the config.New tests.
 const (
-	envKeyPort            = "PORT"
-	envKeyDebug           = "DEBUG"
-	envKeyMaintenanceMode = "MAINTENANCE_MODE"
-	envKeyBindAddress     = "BIND_ADDRESS"
+	envKeyPort        = "PORT"
+	envKeyDebug       = "DEBUG"
+	envKeyBindAddress = "BIND_ADDRESS"
 )
 
 // Sample BIND_ADDRESS values used by the tables below.
@@ -122,10 +121,10 @@ func TestEnvBool(t *testing.T) {
 		t.Run(tt.name, func(t *testing.T) {
 			// Cannot use t.Parallel() here because t.Setenv
 			// is incompatible with parallel subtests.
+			configtest.ClearEnv(t)
+
 			if tt.set {
 				t.Setenv(testEnvKey, tt.value)
-			} else {
-				require.NoError(t, os.Unsetenv(testEnvKey))
 			}
 
 			got, err := config.EnvBoolForTest(
@@ -146,17 +145,62 @@ func TestEnvBool(t *testing.T) {
 	}
 }
 
+// envIntCase is one row of the envPositiveInt and envPort tables.
+type envIntCase struct {
+	name        string
+	set         bool
+	value       string
+	expectError bool
+	errIs       error
+	expected    int
+}
+
+// runEnvIntCases runs each row through parse, which is
+// envPositiveInt or envPort, with testEnvKey set to the row's value
+// or left unset.
+func runEnvIntCases(
+	t *testing.T,
+	parse func(key string, defaultValue int) (int, error),
+	defaultValue int,
+	tests []envIntCase,
+) {
+	t.Helper()
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			// Cannot use t.Parallel() here because t.Setenv
+			// is incompatible with parallel subtests.
+			configtest.ClearEnv(t)
+
+			if tt.set {
+				t.Setenv(testEnvKey, tt.value)
+			}
+
+			got, err := parse(testEnvKey, defaultValue)
+
+			if tt.expectError {
+				require.Error(t, err)
+				assert.Contains(t, err.Error(), testEnvKey)
+				assert.Contains(t, err.Error(), tt.value)
+
+				if tt.errIs != nil {
+					require.ErrorIs(t, err, tt.errIs)
+				}
+
+				return
+			}
+
+			require.NoError(t, err)
+			assert.Equal(t, tt.expected, got)
+		})
+	}
+}
+
+//nolint:paralleltest // runEnvIntCases uses t.Setenv.
 func TestEnvPositiveInt(t *testing.T) {
 	const defaultValue = 7
 
-	tests := []struct {
-		name        string
-		set         bool
-		value       string
-		expectError bool
-		errIs       error
-		expected    int
-	}{
+	runEnvIntCases(t, config.EnvPositiveIntForTest, defaultValue, []envIntCase{
 		{
 			name:     "unset returns the default integer",
 			expected: defaultValue,
@@ -193,51 +237,14 @@ func TestEnvPositiveInt(t *testing.T) {
 			expectError: true,
 			errIs:       config.ErrNonPositiveValue,
 		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			// Cannot use t.Parallel() here because t.Setenv
-			// is incompatible with parallel subtests.
-			if tt.set {
-				t.Setenv(testEnvKey, tt.value)
-			} else {
-				require.NoError(t, os.Unsetenv(testEnvKey))
-			}
-
-			got, err := config.EnvPositiveIntForTest(
-				testEnvKey, defaultValue,
-			)
-
-			if tt.expectError {
-				require.Error(t, err)
-				assert.Contains(t, err.Error(), testEnvKey)
-				assert.Contains(t, err.Error(), tt.value)
-
-				if tt.errIs != nil {
-					require.ErrorIs(t, err, tt.errIs)
-				}
-
-				return
-			}
-
-			require.NoError(t, err)
-			assert.Equal(t, tt.expected, got)
-		})
-	}
+	})
 }
 
+//nolint:paralleltest // runEnvIntCases uses t.Setenv.
 func TestEnvPort(t *testing.T) {
 	const defaultValue = 8080
 
-	tests := []struct {
-		name        string
-		set         bool
-		value       string
-		expectError bool
-		errIs       error
-		expected    int
-	}{
+	runEnvIntCases(t, config.EnvPortForTest, defaultValue, []envIntCase{
 		{
 			name:     "unset returns the default port",
 			expected: defaultValue,
@@ -265,7 +272,14 @@ func TestEnvPort(t *testing.T) {
 			set:         true,
 			value:       "0",
 			expectError: true,
-			errIs:       config.ErrNonPositiveValue,
+			errIs:       config.ErrInvalidPort,
+		},
+		{
+			name:        "negative is rejected",
+			set:         true,
+			value:       "-1",
+			expectError: true,
+			errIs:       config.ErrInvalidPort,
 		},
 		{
 			name:        "above the port range is rejected",
@@ -274,37 +288,14 @@ func TestEnvPort(t *testing.T) {
 			expectError: true,
 			errIs:       config.ErrInvalidPort,
 		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			// Cannot use t.Parallel() here because t.Setenv
-			// is incompatible with parallel subtests.
-			if tt.set {
-				t.Setenv(testEnvKey, tt.value)
-			} else {
-				require.NoError(t, os.Unsetenv(testEnvKey))
-			}
-
-			got, err := config.EnvPortForTest(
-				testEnvKey, defaultValue,
-			)
-
-			if tt.expectError {
-				require.Error(t, err)
-				assert.Contains(t, err.Error(), testEnvKey)
-
-				if tt.errIs != nil {
-					require.ErrorIs(t, err, tt.errIs)
-				}
-
-				return
-			}
-
-			require.NoError(t, err)
-			assert.Equal(t, tt.expected, got)
-		})
-	}
+		{
+			name:        "too large for an int is rejected",
+			set:         true,
+			value:       "99999999999999999999",
+			expectError: true,
+			errIs:       config.ErrInvalidPort,
+		},
+	})
 }
 
 // TestEnvBindAddress covers BIND_ADDRESS parsing.
@@ -320,10 +311,10 @@ func TestEnvBindAddress(t *testing.T) {
 		t.Run(tt.name, func(t *testing.T) {
 			// Cannot use t.Parallel() here because t.Setenv
 			// is incompatible with parallel subtests.
+			configtest.ClearEnv(t)
+
 			if tt.set {
 				t.Setenv(testEnvKey, tt.value)
-			} else {
-				require.NoError(t, os.Unsetenv(testEnvKey))
 			}
 
 			got, err := config.EnvBindAddressForTest(
@@ -486,6 +477,7 @@ func TestNewRejectsBadEnvValues(t *testing.T) {
 		t.Run(tt.name, func(t *testing.T) {
 			// Cannot use t.Parallel() here because t.Setenv
 			// is incompatible with parallel subtests.
+			configtest.ClearEnv(t)
 			t.Setenv("WEBHOOKER_ENVIRONMENT", "dev")
 			t.Setenv(tt.key, tt.value)
 
@@ -604,12 +596,6 @@ func flagEnvValueCases() []badEnvValueCase {
 			value:       "ture",
 			expectError: true,
 		},
-		{
-			name:        "unparseable MAINTENANCE_MODE aborts startup",
-			key:         envKeyMaintenanceMode,
-			value:       "sometimes",
-			expectError: true,
-		},
 	}
 }
 
@@ -653,22 +639,15 @@ func sentryEnvValueCases() []badEnvValueCase {
 // break the legitimate unset case: absent variables still get their
 // documented defaults.
 func TestNewUsesDefaultsWhenUnset(t *testing.T) {
+	configtest.ClearEnv(t)
 	t.Setenv("WEBHOOKER_ENVIRONMENT", "dev")
 
-	for _, key := range []string{
-		envKeyPort, envKeyDebug, envKeyMaintenanceMode,
-		envKeyBindAddress, envKeySentryDSN,
-	} {
-		require.NoError(t, os.Unsetenv(key))
-	}
-
 	cfg, err := buildConfig(t)
 	require.NoError(t, err)
 	require.NotNil(t, cfg)
 
 	assert.Equal(t, 8080, cfg.Port)
 	assert.False(t, cfg.Debug)
-	assert.False(t, cfg.MaintenanceMode)
 
 	// Loopback, not the wildcard: the default must not publish the
 	// cleartext admin UI and the unauthenticated receiver on every

internal/config/export_test.go

@@ -6,21 +6,6 @@ import "log/slog"
 // the external config_test package so each helper can be covered by
 // its own table-driven test without weakening the package API.
 
-// WarnSharedRateLimitBucketForTest loads a Config from the current
-// environment and emits its startup warnings to log. The real logger
-// writes to stdout, so this lets the warning's firing condition be
-// asserted against a handler the test controls.
-func WarnSharedRateLimitBucketForTest(log *slog.Logger) error {
-	c, err := loadFromEnv()
-	if err != nil {
-		return err
-	}
-
-	c.warnSharedRateLimitBucket(log)
-
-	return nil
-}
-
 // WarnEgressAllowlistForTest loads a Config from the current
 // environment and emits its egress-allowlist startup warning to
 // log, so a test can assert both that the warning fires only when

internal/config/sentry_test.go

@@ -1,12 +1,12 @@
 package config_test
 
 import (
-	"os"
 	"testing"
 
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 	"sneak.berlin/go/webhooker/internal/config"
+	"sneak.berlin/go/webhooker/internal/config/configtest"
 )
 
 // envKeySentryDSN is the variable envSentryDSN reads in production.
@@ -101,10 +101,10 @@ func TestEnvSentryDSN(t *testing.T) {
 		t.Run(tt.name, func(t *testing.T) {
 			// Cannot use t.Parallel() here because t.Setenv
 			// is incompatible with parallel subtests.
+			configtest.ClearEnv(t)
+
 			if tt.set {
 				t.Setenv(envKeySentryDSN, tt.value)
-			} else {
-				require.NoError(t, os.Unsetenv(envKeySentryDSN))
 			}
 
 			got, err := config.EnvSentryDSNForTest(envKeySentryDSN)

internal/database/bootstrap_banner_test.go

@@ -4,6 +4,7 @@ import (
 	"bytes"
 	"context"
 	"log/slog"
+	"os"
 	"path/filepath"
 	"strings"
 	"testing"
@@ -119,3 +120,26 @@ func TestNewDatabase_IsLoggedWithItsPath(t *testing.T) {
 		t, second, created, "an existing database is not new",
 	)
 }
+
+// TestZeroLengthDatabase_IsLoggedAsNew covers what
+// https://git.eeqj.de/sneak/webhooker/issues/290 found: SQLite opens a
+// zero-length file as an empty database, so a start on one is a first
+// start, and it must say so exactly as a start with no file does.
+func TestZeroLengthDatabase_IsLoggedAsNew(t *testing.T) {
+	t.Parallel()
+
+	dir := t.TempDir()
+	path := filepath.Join(dir, database.MainDBFileName)
+	require.NoError(t, os.WriteFile(path, nil, database.SQLiteFilePerm))
+
+	var out bytes.Buffer
+
+	db, err := database.Open(dir, slog.New(slog.NewTextHandler(&out, nil)))
+	require.NoError(t, err)
+	require.NoError(t, db.Close())
+
+	assert.Contains(
+		t, out.String(),
+		`level=WARN msg="created a new, empty database" path=`+path,
+	)
+}

internal/database/database.go

@@ -8,7 +8,6 @@ import (
 	"errors"
 	"fmt"
 	"io"
-	"io/fs"
 	"log/slog"
 	"os"
 	"path/filepath"
@@ -19,6 +18,7 @@ import (
 	"sneak.berlin/go/webhooker/internal/banner"
 	"sneak.berlin/go/webhooker/internal/config"
 	"sneak.berlin/go/webhooker/internal/datadir"
+	"sneak.berlin/go/webhooker/internal/db/migrations"
 	"sneak.berlin/go/webhooker/internal/gormlog"
 	"sneak.berlin/go/webhooker/internal/logger"
 )
@@ -203,8 +203,7 @@ func (d *Database) connectTo(dataDir string) error {
 	// Checked before opening, which creates the file. A DATA_DIR that
 	// is unexpectedly empty -- its volume not mounted, say -- looks
 	// exactly like a first start, so a new database is a warning.
-	_, statErr := os.Stat(dbPath)
-	created := errors.Is(statErr, fs.ErrNotExist)
+	created := missingOrEmpty(dbPath)
 
 	// Opened through OpenSQLite so this handle carries the same WAL
 	// journaling, busy timeout, immediate-transaction locking, and pool
@@ -213,13 +212,15 @@ func (d *Database) connectTo(dataDir string) error {
 	if err != nil {
 		d.log.Error(
 			"failed to open database",
+			"path", dbPath,
 			"error", err,
 		)
 
 		return err
 	}
 
-	// Then use it with GORM
+	// Then use it with GORM. Its errors are SQLite's alone and name no
+	// file, so the path is added to them here.
 	db, err := gorm.Open(sqlite.Dialector{
 		Conn: sqlDB,
 	}, &gorm.Config{
@@ -229,10 +230,11 @@ func (d *Database) connectTo(dataDir string) error {
 	if err != nil {
 		d.log.Error(
 			"failed to connect to database",
+			"path", dbPath,
 			"error", err,
 		)
 
-		return err
+		return fmt.Errorf("connecting to %s: %w", dbPath, err)
 	}
 
 	d.db = db
@@ -243,13 +245,26 @@ func (d *Database) connectTo(dataDir string) error {
 		d.log.Info("connected to database", "path", dbPath)
 	}
 
-	// Run migrations
-	return d.migrate()
+	err = d.migrate()
+	if err != nil {
+		return fmt.Errorf("migrating %s: %w", dbPath, err)
+	}
+
+	err = parseModels(
+		db, &Setting{}, &User{}, &APIKey{},
+		&Webhook{}, &Entrypoint{}, &Target{},
+	)
+	if err != nil {
+		return fmt.Errorf("connecting to %s: %w", dbPath, err)
+	}
+
+	return nil
 }
 
+// migrate applies the main database's SQL files. See
+// internal/db/migrations.
 func (d *Database) migrate() error {
-	// Run GORM auto-migrations
-	err := d.Migrate()
+	err := migrations.Apply(d.db, migrations.Main)
 	if err != nil {
 		d.log.Error(
 			"failed to run database migrations",
@@ -264,6 +279,21 @@ func (d *Database) migrate() error {
 	return nil
 }
 
+// parseModels has GORM parse each model for db before the handle is
+// shared. GORM parses a model the first time a handle uses it, and two
+// goroutines doing that at once for models that refer to each other,
+// as Webhook and Target do, race inside GORM.
+func parseModels(db *gorm.DB, models ...any) error {
+	for _, model := range models {
+		err := (&gorm.Statement{DB: db}).Parse(model)
+		if err != nil {
+			return fmt.Errorf("parsing model %T: %w", model, err)
+		}
+	}
+
+	return nil
+}
+
 // ensureAdminUser creates the bootstrap admin account when the
 // deployment has no users at all.
 func (d *Database) ensureAdminUser() error {

internal/database/database_test.go

@@ -1,9 +1,15 @@
 package database_test
 
 import (
+	"bytes"
 	"context"
+	"log/slog"
+	"os"
+	"path/filepath"
 	"testing"
 
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 	"go.uber.org/fx/fxtest"
 	"sneak.berlin/go/webhooker/internal/config"
 	"sneak.berlin/go/webhooker/internal/database"
@@ -100,3 +106,22 @@ func TestDatabaseConnection(t *testing.T) {
 		)
 	}
 }
+
+// TestOpen_UnreadableDatabaseIsNamed pins
+// https://git.eeqj.de/sneak/webhooker/issues/459: when SQLite cannot
+// read webhooker.db, the error that stops the server and `webhooker
+// resetpw` names the file, not only SQLite's own message.
+func TestOpen_UnreadableDatabaseIsNamed(t *testing.T) {
+	t.Parallel()
+
+	dir := t.TempDir()
+	path := filepath.Join(dir, database.MainDBFileName)
+	require.NoError(t, os.WriteFile(
+		path, bytes.Repeat([]byte("junk"), 1024), database.SQLiteFilePerm,
+	))
+
+	_, err := database.Open(dir, slog.New(slog.DiscardHandler))
+	require.Error(t, err)
+	assert.Contains(t, err.Error(), path)
+	assert.Contains(t, err.Error(), "file is not a database")
+}

internal/database/databasetest/databasetest.go

@@ -0,0 +1,55 @@
+// Package databasetest builds a WebhookDBManager for tests in other
+// packages.
+package databasetest
+
+import (
+	"log/slog"
+	"os"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+	"go.uber.org/fx/fxtest"
+	"sneak.berlin/go/webhooker/internal/config"
+	"sneak.berlin/go/webhooker/internal/database"
+)
+
+// NewWebhookDBManager creates a WebhookDBManager backed by the given
+// data directory, logging at DEBUG to standard error.
+func NewWebhookDBManager(
+	t *testing.T, dataDir string,
+) *database.WebhookDBManager {
+	t.Helper()
+
+	return NewWebhookDBManagerWithLogger(
+		t,
+		dataDir,
+		slog.New(slog.NewTextHandler(
+			os.Stderr,
+			&slog.HandlerOptions{Level: slog.LevelDebug},
+		)),
+	)
+}
+
+// NewWebhookDBManagerWithLogger is NewWebhookDBManager with the
+// logger supplied by the caller. The per-webhook databases this manager
+// opens hand that logger to gormlog, so a test that needs to see the SQL
+// the service emits can capture it.
+//
+// It is built through database.NewWebhookDBManager on a lifecycle that
+// is never started, so nothing closes its databases but the caller.
+func NewWebhookDBManagerWithLogger(
+	t *testing.T, dataDir string, log *slog.Logger,
+) *database.WebhookDBManager {
+	t.Helper()
+
+	mgr, err := database.NewWebhookDBManager(
+		fxtest.NewLifecycle(t),
+		database.WebhookDBManagerParams{
+			Config: &config.Config{DataDir: dataDir},
+			Logger: log,
+		},
+	)
+	require.NoError(t, err)
+
+	return mgr
+}

internal/database/event_db_isolation.go

@@ -2,7 +2,6 @@ package database
 
 import (
 	"fmt"
-	"log/slog"
 
 	"gorm.io/gorm"
 	"gorm.io/gorm/clause"
@@ -18,14 +17,14 @@ const omitAssociationsCallback = "webhooker:omit_associations"
 //
 // A per-webhook database holds the event tier only, but Delivery
 // declares belongs-to Event and Target and the delivery engine fills
-// both in memory before writing. Without this guard GORM upserts
-// those parent rows here on the delivery and retry write paths,
-// copying targets.config, which holds destination URLs and bearer
-// credentials, into the file most likely to be backed up or handed
-// to someone else. Registering the guard on the connection covers
-// every write path, including writes inside a transaction and write
-// paths added later. Every event-tier row this file holds is written
-// explicitly, so nothing depends on the automatic save.
+// both in memory before writing. Without this guard GORM upserts those
+// parent rows here on the delivery and retry write paths, and the
+// target, whose config holds destination URLs and bearer credentials,
+// goes to a targets table this file does not have, which fails the
+// write. Registering the guard on the connection
+// covers every write path, including writes inside a transaction and
+// write paths added later. Every event-tier row this file holds is
+// written explicitly, so nothing depends on the automatic save.
 func omitAssociations(db *gorm.DB) error {
 	omit := func(tx *gorm.DB) {
 		tx.Statement.Omits = append(
@@ -53,107 +52,3 @@ func omitAssociations(db *gorm.DB) error {
 
 	return nil
 }
-
-// eventDBSweptVersion is the PRAGMA user_version purgeTargetRows
-// stamps into a per-webhook database once it has removed any leaked
-// target rows *and* the VACUUM that removes their bytes has returned.
-// Nothing else in the tree uses user_version, so 0 means "not swept
-// by this build".
-//
-// The stamp, not the DELETE, is what records that a file is done. A
-// DELETE commits on its own, so a sweep that is interrupted or whose
-// VACUUM fails leaves a file whose rows are gone but whose credential
-// bytes are still in the free pages -- indistinguishable, by row
-// count, from a file that never leaked. Both leave the stamp unset,
-// so the next open sweeps again.
-const eventDBSweptVersion = 1
-
-// purgeTargetRows deletes target rows that an earlier build's
-// association upsert wrote into a per-webhook database, and rewrites
-// the file so their bytes are gone with them. AutoMigrate creates a
-// targets table in every one of these files because Delivery declares
-// a belongs-to Target, but nothing in the event tier may put rows in
-// it. The rows it did put there are junk, not history: they carry an
-// empty webhook_id, and delivery rows resolve their target against
-// the main database, so nothing here refers to them.
-//
-// The DELETE only unlinks the rows: modernc.org/sqlite leaves
-// secure_delete at SQLite's default of off, so the credential bytes
-// stay readable in the file's free pages and a backup of a swept file
-// would still hand them over. VACUUM rewrites the file without them.
-//
-// This runs before every migration and is gated on
-// eventDBSweptVersion, so a file pays for the rewrite once, on the
-// first open that finds it unstamped, and every open after that is a
-// PRAGMA read. A file this build created is stamped before its
-// targets table exists, so it never vacuums at all. A failure here
-// fails the open with the stamp left unset, so the sweep is retried
-// rather than skipped -- a webhook whose file cannot be swept stays
-// unusable instead of quietly serving from a file that still holds
-// recoverable credentials.
-func purgeTargetRows(
-	db *gorm.DB, log *slog.Logger, webhookID string,
-) error {
-	var version int
-
-	// Row().Scan, not (*gorm.DB).Scan: see internal/gormlog.
-	err := db.Raw("PRAGMA user_version").Row().Scan(&version)
-	if err != nil {
-		return fmt.Errorf(
-			"reading sweep marker of webhook database %s: %w",
-			webhookID, err,
-		)
-	}
-
-	if version >= eventDBSweptVersion {
-		return nil
-	}
-
-	var purged int64
-
-	if db.Migrator().HasTable("targets") {
-		res := db.Exec("DELETE FROM targets")
-		if res.Error != nil {
-			return fmt.Errorf(
-				"purging target rows from webhook database %s: %w",
-				webhookID, res.Error,
-			)
-		}
-
-		purged = res.RowsAffected
-
-		// Unconditional: a zero row count here does not mean there is
-		// nothing to remove, only that no *live* row is left. See
-		// eventDBSweptVersion.
-		err = db.Exec("VACUUM").Error
-		if err != nil {
-			return fmt.Errorf(
-				"purged %d leaked target rows from webhook database "+
-					"%s but vacuuming it failed, so the deleted "+
-					"target credentials are still recoverable from "+
-					"the file; it stays marked unswept and the next "+
-					"open retries: %w",
-				purged, webhookID, err,
-			)
-		}
-	}
-
-	err = db.Exec(fmt.Sprintf(
-		"PRAGMA user_version = %d", eventDBSweptVersion,
-	)).Error
-	if err != nil {
-		return fmt.Errorf(
-			"marking webhook database %s swept: %w", webhookID, err,
-		)
-	}
-
-	if purged > 0 {
-		log.Warn(
-			"purged leaked target rows from per-webhook database",
-			"webhook_id", webhookID,
-			"rows", purged,
-		)
-	}
-
-	return nil
-}

internal/database/event_db_isolation_test.go

@@ -1,391 +1,15 @@
 package database_test
 
 import (
-	"bytes"
-	"database/sql"
-	"fmt"
-	"os"
-	"path/filepath"
 	"testing"
 
 	"github.com/google/uuid"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
-	_ "modernc.org/sqlite"
 	"sneak.berlin/go/webhooker/internal/database"
+	"sneak.berlin/go/webhooker/internal/database/databasetest"
 )
 
-// testDataDirPerm is the mode the test data directory is created
-// with.
-const testDataDirPerm = 0o750
-
-// eventDBDataDir returns a data directory that a WebhookDBManager
-// can be pointed at.
-func eventDBDataDir(t *testing.T) string {
-	t.Helper()
-
-	dir := filepath.Join(t.TempDir(), "events")
-	require.NoError(t, os.MkdirAll(dir, testDataDirPerm))
-
-	return dir
-}
-
-// openRawEventDB opens the per-webhook database file directly,
-// without the manager, so a test can put a file on disk in a state
-// the manager has to cope with, or inspect one afterwards.
-func openRawEventDB(
-	t *testing.T, dataDir, webhookID string,
-) *sql.DB {
-	t.Helper()
-
-	path := filepath.Join(
-		dataDir, fmt.Sprintf("events-%s.db", webhookID),
-	)
-
-	sqlDB, err := sql.Open(
-		"sqlite",
-		fmt.Sprintf("file:%s?mode=rwc", path),
-	)
-	require.NoError(t, err)
-
-	t.Cleanup(func() { _ = sqlDB.Close() })
-
-	return sqlDB
-}
-
-// eventDBFileBytes reads a per-webhook database file off disk, so a
-// test can assert on what the file itself still holds rather than on
-// what a query returns.
-func eventDBFileBytes(t *testing.T, dataDir, webhookID string) []byte {
-	t.Helper()
-
-	//nolint:gosec // reads a file the test just created under t.TempDir()
-	raw, err := os.ReadFile(filepath.Join(
-		dataDir, fmt.Sprintf("events-%s.db", webhookID),
-	))
-	require.NoError(t, err)
-
-	return raw
-}
-
-// eventDBUserVersion returns the PRAGMA user_version of a per-webhook
-// database file, which is the marker purgeTargetRows stamps once it
-// has swept and vacuumed.
-func eventDBUserVersion(t *testing.T, sqlDB *sql.DB) int {
-	t.Helper()
-
-	var version int
-
-	require.NoError(t, sqlDB.QueryRowContext(
-		t.Context(), "PRAGMA user_version",
-	).Scan(&version))
-
-	return version
-}
-
-// clearEventDBSweptMarker resets the sweep marker to 0, which is what
-// a file written by a build without the sweep looks like. Tests that
-// seed a leaked row have to create the file through the manager to
-// get the real targets table shape, and that stamps it.
-func clearEventDBSweptMarker(t *testing.T, sqlDB *sql.DB) {
-	t.Helper()
-
-	_, err := sqlDB.ExecContext(t.Context(), "PRAGMA user_version = 0")
-	require.NoError(t, err)
-}
-
-// countTargetRows returns the number of rows in the targets table of
-// a per-webhook database file, or -1 if the table does not exist.
-func countTargetRows(t *testing.T, sqlDB *sql.DB) int {
-	t.Helper()
-
-	var tables int
-
-	require.NoError(t, sqlDB.QueryRowContext(
-		t.Context(),
-		"SELECT count(*) FROM sqlite_master "+
-			"WHERE type = 'table' AND name = 'targets'",
-	).Scan(&tables))
-
-	if tables == 0 {
-		return -1
-	}
-
-	var rows int
-
-	require.NoError(t, sqlDB.QueryRowContext(
-		t.Context(), "SELECT count(*) FROM targets",
-	).Scan(&rows))
-
-	return rows
-}
-
-// TestOpenPurgesLeakedTargetRows covers the sweep for event
-// databases written by a build that let GORM upsert target rows
-// into them: opening the database clears them, and opening it again
-// is a no-op.
-func TestOpenPurgesLeakedTargetRows(t *testing.T) {
-	t.Parallel()
-
-	dataDir := eventDBDataDir(t)
-	webhookID := uuid.New().String()
-
-	// Create the file the way the application does, so the targets
-	// table has exactly the shape AutoMigrate gives it, then write
-	// a leaked row into it the way the association upsert did.
-	initial := database.NewTestWebhookDBManager(dataDir)
-
-	_, err := initial.GetDB(webhookID)
-	require.NoError(t, err)
-	require.NoError(t, initial.CloseAll())
-
-	seed := openRawEventDB(t, dataDir, webhookID)
-
-	_, err = seed.ExecContext(
-		t.Context(),
-		"INSERT INTO targets "+
-			"(id, webhook_id, name, type, config) "+
-			"VALUES (?, '', ?, ?, ?)",
-		uuid.New().String(),
-		"leaked-target",
-		"slack",
-		`{"webhookUrl":"https://hooks.example/T000/B000/secret"}`,
-	)
-	require.NoError(t, err)
-	require.Equal(t, 1, countTargetRows(t, seed))
-	clearEventDBSweptMarker(t, seed)
-	require.NoError(t, seed.Close())
-
-	mgr := database.NewTestWebhookDBManager(dataDir)
-
-	_, err = mgr.GetDB(webhookID)
-	require.NoError(t, err)
-	require.NoError(t, mgr.CloseAll())
-
-	check := openRawEventDB(t, dataDir, webhookID)
-	assert.Zero(t, countTargetRows(t, check))
-	assert.Equal(
-		t, 1, eventDBUserVersion(t, check),
-		"a completed sweep must mark the file so later opens skip it",
-	)
-	require.NoError(t, check.Close())
-
-	// Idempotent: a second open leaves it at zero and does not
-	// error.
-	again := database.NewTestWebhookDBManager(dataDir)
-
-	_, err = again.GetDB(webhookID)
-	require.NoError(t, err)
-	require.NoError(t, again.CloseAll())
-
-	recheck := openRawEventDB(t, dataDir, webhookID)
-	assert.Zero(t, countTargetRows(t, recheck))
-}
-
-// TestOpenPurgeRemovesCredentialBytes covers the sweep at the level
-// that matters for a backup handed to someone else: the leaked
-// credential must be gone from the raw bytes of the file, not merely
-// unreachable by query. A bare DELETE unlinks the row and leaves the
-// bytes readable in the free pages, so this fails without the VACUUM
-// in purgeTargetRows.
-func TestOpenPurgeRemovesCredentialBytes(t *testing.T) {
-	t.Parallel()
-
-	dataDir := eventDBDataDir(t)
-	webhookID := uuid.New().String()
-	credential := "T00000000/B00000000/" + uuid.New().String()
-
-	initial := database.NewTestWebhookDBManager(dataDir)
-
-	_, err := initial.GetDB(webhookID)
-	require.NoError(t, err)
-	require.NoError(t, initial.CloseAll())
-
-	seed := openRawEventDB(t, dataDir, webhookID)
-
-	_, err = seed.ExecContext(
-		t.Context(),
-		"INSERT INTO targets "+
-			"(id, webhook_id, name, type, config) "+
-			"VALUES (?, '', ?, ?, ?)",
-		uuid.New().String(),
-		"leaked-target",
-		"slack",
-		fmt.Sprintf(
-			`{"webhookUrl":"https://hooks.example/%s"}`, credential,
-		),
-	)
-	require.NoError(t, err)
-	clearEventDBSweptMarker(t, seed)
-	require.NoError(t, seed.Close())
-
-	// The seed has to be in the file for its absence later to mean
-	// anything.
-	require.True(
-		t,
-		bytes.Contains(
-			eventDBFileBytes(t, dataDir, webhookID),
-			[]byte(credential),
-		),
-		"seeded credential is not in the file, so this test proves nothing",
-	)
-
-	mgr := database.NewTestWebhookDBManager(dataDir)
-
-	_, err = mgr.GetDB(webhookID)
-	require.NoError(t, err)
-	require.NoError(t, mgr.CloseAll())
-
-	assert.NotContains(
-		t,
-		string(eventDBFileBytes(t, dataDir, webhookID)),
-		credential,
-		"leaked credential is still recoverable from the raw file",
-	)
-}
-
-// TestOpenRevacuumsAfterIncompleteSweep covers the case a row count
-// cannot see: the rows are already deleted but the file was never
-// vacuumed, because an earlier sweep died between the two or its
-// VACUUM failed. The credential bytes are still recoverable, and the
-// unset marker is the only thing that says so, so the next open must
-// vacuum rather than conclude from the empty table that there is
-// nothing to do.
-func TestOpenRevacuumsAfterIncompleteSweep(t *testing.T) {
-	t.Parallel()
-
-	dataDir := eventDBDataDir(t)
-	webhookID := uuid.New().String()
-	credential := "T00000000/B00000000/" + uuid.New().String()
-
-	initial := database.NewTestWebhookDBManager(dataDir)
-
-	_, err := initial.GetDB(webhookID)
-	require.NoError(t, err)
-	require.NoError(t, initial.CloseAll())
-
-	seed := openRawEventDB(t, dataDir, webhookID)
-
-	_, err = seed.ExecContext(
-		t.Context(),
-		"INSERT INTO targets "+
-			"(id, webhook_id, name, type, config) "+
-			"VALUES (?, '', ?, ?, ?)",
-		uuid.New().String(),
-		"leaked-target",
-		"slack",
-		fmt.Sprintf(
-			`{"webhookUrl":"https://hooks.example/%s"}`, credential,
-		),
-	)
-	require.NoError(t, err)
-
-	// Exactly the state an interrupted sweep leaves: rows gone,
-	// marker unset, bytes still in the free pages.
-	_, err = seed.ExecContext(t.Context(), "DELETE FROM targets")
-	require.NoError(t, err)
-	require.Zero(t, countTargetRows(t, seed))
-	clearEventDBSweptMarker(t, seed)
-	require.NoError(t, seed.Close())
-
-	require.True(
-		t,
-		bytes.Contains(
-			eventDBFileBytes(t, dataDir, webhookID),
-			[]byte(credential),
-		),
-		"the deleted row's bytes must still be in the file, or this "+
-			"test proves nothing",
-	)
-
-	mgr := database.NewTestWebhookDBManager(dataDir)
-
-	_, err = mgr.GetDB(webhookID)
-	require.NoError(t, err)
-	require.NoError(t, mgr.CloseAll())
-
-	assert.NotContains(
-		t,
-		string(eventDBFileBytes(t, dataDir, webhookID)),
-		credential,
-		"an interrupted sweep was not retried, so the credential is "+
-			"still recoverable from the raw file",
-	)
-
-	check := openRawEventDB(t, dataDir, webhookID)
-	assert.Equal(t, 1, eventDBUserVersion(t, check))
-}
-
-// TestOpenSkipsSweptDatabase covers the other half of the marker: a
-// file this build created is marked without ever being vacuumed, and
-// a marked file is not swept again.
-func TestOpenSkipsSweptDatabase(t *testing.T) {
-	t.Parallel()
-
-	dataDir := eventDBDataDir(t)
-	webhookID := uuid.New().String()
-
-	mgr := database.NewTestWebhookDBManager(dataDir)
-
-	_, err := mgr.GetDB(webhookID)
-	require.NoError(t, err)
-	require.NoError(t, mgr.CloseAll())
-
-	marked := openRawEventDB(t, dataDir, webhookID)
-	assert.Equal(t, 1, eventDBUserVersion(t, marked))
-
-	// A marked file is left alone, so a row written into it survives
-	// a reopen. Nothing writes target rows any more; this stands in
-	// for the sweep having run.
-	_, err = marked.ExecContext(
-		t.Context(),
-		"INSERT INTO targets "+
-			"(id, webhook_id, name, type, config) "+
-			"VALUES (?, '', ?, ?, ?)",
-		uuid.New().String(), "sentinel", "slack", `{}`,
-	)
-	require.NoError(t, err)
-	require.NoError(t, marked.Close())
-
-	again := database.NewTestWebhookDBManager(dataDir)
-
-	_, err = again.GetDB(webhookID)
-	require.NoError(t, err)
-	require.NoError(t, again.CloseAll())
-
-	check := openRawEventDB(t, dataDir, webhookID)
-	assert.Equal(
-		t, 1, countTargetRows(t, check),
-		"a marked file must not be swept again",
-	)
-}
-
-// TestOpenSucceedsWithoutTargetsTable covers an existing event
-// database that never grew a targets table. The sweep must not fail
-// startup on it.
-func TestOpenSucceedsWithoutTargetsTable(t *testing.T) {
-	t.Parallel()
-
-	dataDir := eventDBDataDir(t)
-	webhookID := uuid.New().String()
-
-	seed := openRawEventDB(t, dataDir, webhookID)
-
-	_, err := seed.ExecContext(
-		t.Context(),
-		"CREATE TABLE events (id text PRIMARY KEY)",
-	)
-	require.NoError(t, err)
-	require.NoError(t, seed.Close())
-
-	mgr := database.NewTestWebhookDBManager(dataDir)
-
-	db, err := mgr.GetDB(webhookID)
-	require.NoError(t, err)
-	assert.NotNil(t, db)
-	require.NoError(t, mgr.CloseAll())
-}
-
 // TestEventDBCreateOmitsAssociations covers the connection-level
 // guard directly: a Delivery carrying its Event and Target in
 // memory, written through the manager's handle, must store only the
@@ -393,19 +17,19 @@ func TestOpenSucceedsWithoutTargetsTable(t *testing.T) {
 func TestEventDBCreateOmitsAssociations(t *testing.T) {
 	t.Parallel()
 
-	dataDir := eventDBDataDir(t)
 	webhookID := uuid.New().String()
 
-	mgr := database.NewTestWebhookDBManager(dataDir)
+	mgr := databasetest.NewWebhookDBManager(t, t.TempDir())
 
 	db, err := mgr.GetDB(webhookID)
 	require.NoError(t, err)
 
 	target := database.Target{
-		WebhookID: webhookID,
-		Name:      "leaky-target",
-		Type:      database.TargetTypeSlack,
-		Config:    `{"webhookUrl":"https://hooks.example/secret"}`,
+		WebhookID:   webhookID,
+		Name:        "leaky-target",
+		Type:        database.TargetTypeSlack,
+		URL:         "https://hooks.example/secret",
+		MaxAttempts: 1,
 	}
 	target.ID = uuid.New().String()
 
@@ -431,8 +55,9 @@ func TestEventDBCreateOmitsAssociations(t *testing.T) {
 	require.NoError(t, db.Model(d).
 		Update("status", database.DeliveryStatusDelivered).
 		Error)
-	require.NoError(t, mgr.CloseAll())
 
-	check := openRawEventDB(t, dataDir, webhookID)
-	assert.Zero(t, countTargetRows(t, check))
+	// The file has no targets table, so the create and update above
+	// would have failed had GORM tried to save the target.
+	assert.False(t, db.Migrator().HasTable(&database.Target{}))
+	require.NoError(t, mgr.CloseAll())
 }

internal/database/event_tier_indexes_test.go

@@ -13,10 +13,8 @@ import (
 	"sneak.berlin/go/webhooker/internal/database"
 )
 
-// TestWebhookDBManager_OpenAddsEventTierIndexes verifies that opening a
-// per-webhook database that predates these indexes creates them. It
-// stands in for an older database file by dropping the indexes
-// AutoMigrate just created, then reopening the same file.
+// TestWebhookDBManager_OpenAddsEventTierIndexes verifies that a new
+// per-webhook database has these indexes.
 func TestWebhookDBManager_OpenAddsEventTierIndexes(t *testing.T) {
 	t.Parallel()
 
@@ -42,27 +40,9 @@ func TestWebhookDBManager_OpenAddsEventTierIndexes(t *testing.T) {
 	db, err := mgr.GetDB(webhookID)
 	require.NoError(t, err)
 
-	// A fresh database has them.
-	for _, ix := range indexes {
-		require.True(t, db.Migrator().HasIndex(ix.model, ix.name))
-	}
-
-	// Stand in for a database file created before the indexes existed.
-	for _, ix := range indexes {
-		require.NoError(t, db.Migrator().DropIndex(ix.model, ix.name))
-		require.False(t, db.Migrator().HasIndex(ix.model, ix.name))
-	}
-
-	// Drop the cached connection so the next open reopens the file and
-	// runs AutoMigrate against it, as a restart would.
-	require.NoError(t, mgr.CloseAll())
-
-	db, err = mgr.GetDB(webhookID)
-	require.NoError(t, err)
-
 	for _, ix := range indexes {
 		assert.True(t, db.Migrator().HasIndex(ix.model, ix.name),
-			"opening the existing database should create %s", ix.name)
+			"a new database should have %s", ix.name)
 	}
 }
 
@@ -93,14 +73,15 @@ func TestEventTierQueriesUseTheirIndexes(t *testing.T) {
 		deliveries []database.Delivery
 		results    []database.DeliveryResult
 		depths     []struct{ Depth int }
+		removed    []database.TargetTotals
 	)
 
 	byStatus := "idx_deliveries_status (status=? AND deleted_at=?)"
 	byEvent := "idx_deliveries_event_id (event_id=? AND deleted_at=?)"
-	byAge := "idx_events_deleted_at_created_at (deleted_at=? AND created_at<?)"
 
-	// The delivery engine: recovery and the retry sweep, the sweep for
-	// stranded pending deliveries, and the queue depth count.
+	// The delivery engine: the recovery routine, which reads the
+	// retrying deliveries and, on a tick of the sweep, the pending ones
+	// untouched for a while; and the queue depth count.
 	assertPlanUses(t, db, dry.Where(
 		"status = ?", database.DeliveryStatusRetrying,
 	).Find(&deliveries), byStatus)
@@ -123,25 +104,207 @@ func TestEventTierQueriesUseTheirIndexes(t *testing.T) {
 		Order("attempt_num ASC").Find(&results),
 		"idx_delivery_results_delivery_id (delivery_id=? AND deleted_at=?)")
 
-	// Retention's three deletes (reapExpired), whose subqueries are built
-	// afresh for each statement as it builds them.
-	expiredEventIDs := func() *gorm.DB {
-		return dry.Model(&database.Event{}).Select("id").
-			Where("created_at < ?", cutoff)
+	// Retention (reapExpired, deleteEvents): one batch of expired
+	// events, then their attempts, deliveries and the events.
+	var expired []string
+
+	assertPlanUses(t, db, dry.Unscoped().Model(&database.Event{}).
+		Where("created_at < ?", cutoff).
+		Limit(database.ExportReapBatchSize).Pluck("id", &expired),
+		"idx_events_created_at (created_at<?)")
+	assertPlanUses(t, db, dry.Unscoped().Where(
+		"delivery_id IN (?)", dry.Unscoped().Model(&database.Delivery{}).
+			Select("id").Where("event_id IN ?", ids),
+	).Delete(&database.DeliveryResult{}),
+		"idx_delivery_results_delivery_id (delivery_id=?)",
+		"idx_deliveries_event_id (event_id=?)")
+	assertPlanUses(t, db, dry.Unscoped().Model(&database.Delivery{}).
+		Select("target_id, count(*) AS deliveries_removed, "+
+			"count(CASE WHEN status = ? THEN 1 END) AS failed_removed",
+			database.DeliveryStatusFailed).
+		Where("event_id IN ?", ids).Group("target_id").Find(&removed),
+		"idx_deliveries_event_id (event_id=?)")
+	assertPlanUses(t, db, dry.Unscoped().Where("event_id IN ?", ids).
+		Delete(&database.Delivery{}), "idx_deliveries_event_id (event_id=?)")
+	assertPlanUses(t, db, dry.Unscoped().Where("id IN ?", ids).
+		Delete(&database.Event{}), "sqlite_autoindex_events_1 (id=?)")
+}
+
+// TestEventLogFiltersUseTheStatusIndex does the same for the event log's
+// Failed and Pending lists, of the newest events with a delivery in
+// given statuses, and for their counts (eventsWithStatus and
+// countEventsWithStatus in the handlers). The lists must also reach
+// the events table only by ID: from the matching deliveries, then from
+// the newest of those events.
+func TestEventLogFiltersUseTheStatusIndex(t *testing.T) {
+	t.Parallel()
+
+	mgr, lc := setupTestWebhookDBManager(t)
+	ctx := context.Background()
+	require.NoError(t, lc.Start(ctx))
+
+	defer func() { require.NoError(t, lc.Stop(ctx)) }()
+
+	webhookID := uuid.New().String()
+
+	db, err := mgr.GetDB(webhookID)
+	require.NoError(t, err)
+
+	dry := db.Session(&gorm.Session{DryRun: true})
+	byStatus := "idx_deliveries_status (status=? AND deleted_at=?)"
+	pending := []database.DeliveryStatus{
+		database.DeliveryStatusPending,
+		database.DeliveryStatusRetrying,
 	}
 
-	assertPlanUses(t, db, dry.Unscoped().Where(
-		"delivery_id IN (?)", dry.Model(&database.Delivery{}).
-			Select("id").Where("event_id IN (?)", expiredEventIDs()),
-	).Delete(&database.DeliveryResult{}),
-		"idx_delivery_results_delivery_id (delivery_id=?)", byEvent, byAge)
-	assertPlanUses(t, db, dry.Unscoped().Where(
-		"event_id IN (?)", expiredEventIDs(),
-	).Delete(&database.Delivery{}),
-		"idx_deliveries_event_id (event_id=?)", byAge)
-	assertPlanUses(t, db, dry.Unscoped().Where(
-		"created_at < ?", cutoff,
-	).Delete(&database.Event{}), "idx_events_created_at (created_at<?)")
+	var (
+		rows  []struct{ ID string }
+		count int64
+	)
+
+	matching := dry.Model(&database.Delivery{}).
+		Distinct("event_id").Where("status IN ?", pending)
+	newest := dry.Table("(?) AS matching", matching).
+		Joins("CROSS JOIN events ON events.id = matching.event_id").
+		Where(
+			"events.webhook_id = ? AND events.deleted_at IS NULL",
+			webhookID,
+		).
+		Order("events.created_at DESC").Limit(50).
+		Select("events.id AS event_id")
+
+	// Each step of the plan is printed in braces, so these name the
+	// lookup that follows each scan.
+	byID := "{SEARCH events USING INDEX sqlite_autoindex_events_1 (id=?)}"
+
+	assertPlanUses(t, db, dry.Table("(?) AS newest", newest).
+		Joins("CROSS JOIN events ON events.id = newest.event_id").
+		Select("id").Order("created_at DESC").Limit(50).Find(&rows),
+		byStatus, "{SCAN matching} "+byID, "{SCAN newest} "+byID)
+	assertPlanUses(t, db, dry.Model(&database.Delivery{}).
+		Distinct("event_id").Where("status IN ?", pending).Count(&count),
+		byStatus)
+}
+
+// TestStatisticsQueriesUseTheirIndexes does the same for the webhook
+// page's statistics (readEventStats in the handlers): deliveries in
+// progress, each target's deliveries finished since a time, which must
+// come from the index alone, and events received since a time.
+func TestStatisticsQueriesUseTheirIndexes(t *testing.T) {
+	t.Parallel()
+
+	mgr, lc := setupTestWebhookDBManager(t)
+	ctx := context.Background()
+	require.NoError(t, lc.Start(ctx))
+
+	defer func() { require.NoError(t, lc.Stop(ctx)) }()
+
+	db, err := mgr.GetDB(uuid.New().String())
+	require.NoError(t, err)
+
+	dry := db.Session(&gorm.Session{DryRun: true})
+	since := time.Now()
+
+	var (
+		count    int64
+		byTarget []struct{ TargetID string }
+	)
+
+	assertPlanUses(t, db, dry.Model(&database.Delivery{}).
+		Where("status IN ?", []database.DeliveryStatus{
+			database.DeliveryStatusPending,
+			database.DeliveryStatusRetrying,
+		}).Count(&count),
+		"idx_deliveries_status (status=? AND deleted_at=?)")
+	assertPlanUses(t, db, dry.Model(&database.Delivery{}).
+		Select("target_id, "+
+			"count(CASE WHEN status = ? THEN 1 END) AS delivered, "+
+			"count(CASE WHEN status = ? THEN 1 END) AS failed",
+			database.DeliveryStatusDelivered,
+			database.DeliveryStatusFailed).
+		Where("status IN ? AND finished_at >= ?",
+			[]database.DeliveryStatus{
+				database.DeliveryStatusDelivered,
+				database.DeliveryStatusFailed,
+			}, since).
+		Group("target_id").Find(&byTarget),
+		"COVERING INDEX idx_deliveries_status "+
+			"(status=? AND deleted_at=? AND finished_at>?)")
+	assertPlanUses(t, db, dry.Model(&database.Event{}).
+		Where("created_at >= ?", since).Count(&count),
+		"idx_events_deleted_at_created_at "+
+			"(deleted_at=? AND created_at>?)")
+}
+
+// TestResubmitCountUsesItsIndex does the same for the event log's count
+// of the events resubmitted from each of a page's events (resubmitCounts
+// in the handlers). It passes a full page of 25 ids: with an index on
+// resubmitted_from_id alone, SQLite uses it for three ids and turns to
+// the deleted_at index from five.
+func TestResubmitCountUsesItsIndex(t *testing.T) {
+	t.Parallel()
+
+	mgr, lc := setupTestWebhookDBManager(t)
+	ctx := context.Background()
+	require.NoError(t, lc.Start(ctx))
+
+	defer func() { require.NoError(t, lc.Stop(ctx)) }()
+
+	db, err := mgr.GetDB(uuid.New().String())
+	require.NoError(t, err)
+
+	dry := db.Session(&gorm.Session{DryRun: true})
+
+	page := make([]string, 25)
+	for i := range page {
+		page[i] = uuid.New().String()
+	}
+
+	var counts []struct{ Total int }
+
+	assertPlanUses(t, db, dry.Model(&database.Event{}).
+		Select("resubmitted_from_id, count(*) AS total").
+		Where("resubmitted_from_id IN ?", page).
+		Group("resubmitted_from_id").Find(&counts),
+		"idx_events_resubmitted_from_id "+
+			"(resubmitted_from_id=? AND deleted_at=?)")
+}
+
+// TestEntrypointEventsUseTheirIndex does the same for the webhook
+// page's count, for each entrypoint, of the events that arrived on its
+// URL since the retention cutoff (addEntrypointEvents in the
+// handlers), which must come from the index alone. It passes 25
+// entrypoints, as TestResubmitCountUsesItsIndex passes 25 events.
+func TestEntrypointEventsUseTheirIndex(t *testing.T) {
+	t.Parallel()
+
+	mgr, lc := setupTestWebhookDBManager(t)
+	ctx := context.Background()
+	require.NoError(t, lc.Start(ctx))
+
+	defer func() { require.NoError(t, lc.Stop(ctx)) }()
+
+	db, err := mgr.GetDB(uuid.New().String())
+	require.NoError(t, err)
+
+	dry := db.Session(&gorm.Session{DryRun: true})
+
+	entrypoints := make([]string, 25)
+	for i := range entrypoints {
+		entrypoints[i] = uuid.New().String()
+	}
+
+	var rows []struct{ Events int }
+
+	assertPlanUses(t, db, dry.Model(&database.Event{}).
+		Select("entrypoint_id, count(*) AS events").
+		Where("entrypoint_id IN ? AND resubmitted_from_id IS NULL",
+			entrypoints).
+		Where("created_at >= ?", time.Now()).
+		Group("entrypoint_id").Find(&rows),
+		"COVERING INDEX idx_events_entrypoint_id "+
+			"(entrypoint_id=? AND deleted_at=? AND "+
+			"resubmitted_from_id=? AND created_at>?)")
 }
 
 // assertPlanUses asserts that SQLite's plan for a statement GORM built

internal/database/export_test.go

@@ -5,6 +5,7 @@ import (
 	"io"
 	"log/slog"
 	"os"
+	"testing"
 	"time"
 
 	"go.uber.org/fx"
@@ -28,6 +29,10 @@ func NewTestRetentionReaper(
 	}
 }
 
+// ExportReapBatchSize exposes how many expired events one retention
+// transaction deletes.
+const ExportReapBatchSize = reapBatchSize
+
 // ExportSweep runs a single retention sweep synchronously for tests.
 func (r *RetentionReaper) ExportSweep(ctx context.Context) {
 	r.sweep(ctx)
@@ -79,3 +84,14 @@ func (d *Database) ExportSetBannerOut(w io.Writer) {
 func DummyPasswordHashForTest() string {
 	return dummyPasswordHash()
 }
+
+// HashAtShippedCostForTest makes HashPassword hash at the shipped
+// memory cost until t ends. t must not run in parallel with other
+// tests, which would hash at that cost alongside it.
+func HashAtShippedCostForTest(t *testing.T) {
+	t.Helper()
+
+	hashAtShippedCostInTest = true
+
+	t.Cleanup(func() { hashAtShippedCostInTest = false })
+}

internal/database/model_apikey.go

@@ -15,6 +15,7 @@ type APIKey struct {
 	Description string     `json:"description"`
 	LastUsedAt  *time.Time `json:"lastUsedAt,omitempty"`
 
-	// Relations
-	User User `json:"user,omitzero"`
+	// Relations. No model marshals the record it belongs to:
+	// User.APIKeys leads back here, and the JSON could loop.
+	User User `json:"-"`
 }

internal/database/model_delivery.go

@@ -1,6 +1,10 @@
 package database
 
-import "gorm.io/gorm"
+import (
+	"time"
+
+	"gorm.io/gorm"
+)
 
 // DeliveryStatus represents the status of a delivery
 type DeliveryStatus string
@@ -37,7 +41,7 @@ type Delivery struct {
 	BaseModel
 
 	EventID  string         `gorm:"type:uuid;not null;index:idx_deliveries_event_id,priority:1"       json:"eventId"`
-	TargetID string         `gorm:"type:uuid;not null"                                                json:"targetId"`
+	TargetID string         `gorm:"type:uuid;not null;index:idx_deliveries_status,priority:4"         json:"targetId"`
 	Status   DeliveryStatus `gorm:"not null;default:'pending';index:idx_deliveries_status,priority:1" json:"status"`
 
 	// DeletedAt repeats the BaseModel field only to be the second column
@@ -45,8 +49,21 @@ type Delivery struct {
 	// gives.
 	DeletedAt gorm.DeletedAt `gorm:"index:idx_deliveries_event_id,priority:2;index:idx_deliveries_status,priority:2" json:"deletedAt,omitzero"`
 
-	// Relations
-	Event           Event            `json:"event,omitzero"`
-	Target          Target           `json:"target,omitzero"`
+	// FinishedAt is when the delivery became delivered or failed, and
+	// nil while it is pending or retrying. It and then TargetID end the
+	// status index, so the webhook page counts each target's deliveries
+	// that finished in a recent window by reading just that window from
+	// the index.
+	FinishedAt *time.Time `gorm:"index:idx_deliveries_status,priority:3" json:"finishedAt,omitempty"`
+
+	// Replay is set on a delivery created by the event log's Replay
+	// action, so the pages can tell it from the delivery it repeats.
+	Replay bool `gorm:"not null;default:false" json:"replay"`
+
+	// Relations. No model marshals the record it belongs to:
+	// Event.Deliveries and Target.Deliveries lead back here, and the
+	// JSON could loop.
+	Event           Event            `json:"-"`
+	Target          Target           `json:"-"`
 	DeliveryResults []DeliveryResult `json:"deliveryResults,omitempty"`
 }

internal/database/model_delivery_result.go

@@ -23,6 +23,7 @@ type DeliveryResult struct {
 	Error        string `json:"error,omitempty"`
 	Duration     int64  `json:"durationMs"` // Duration in milliseconds
 
-	// Relations
-	Delivery Delivery `json:"delivery,omitzero"`
+	// Relations. No model marshals the record it belongs to:
+	// Delivery.DeliveryResults leads back here, and the JSON could loop.
+	Delivery Delivery `json:"-"`
 }

internal/database/model_entrypoint.go

@@ -15,6 +15,7 @@ type Entrypoint struct {
 	Description string `json:"description"`
 	Active      bool   `gorm:"default:true" json:"active"`
 
-	// Relations
-	Webhook Webhook `json:"webhook,omitzero"`
+	// Relations. No model marshals the record it belongs to:
+	// Webhook.Entrypoints leads back here, and the JSON could loop.
+	Webhook Webhook `json:"-"`
 }

internal/database/model_event.go

@@ -19,28 +19,40 @@ type Event struct {
 	// narrows by a < only on the last column it uses. Its final delete
 	// has no deleted_at condition and uses the index on created_at
 	// alone. The other tables keep the unindexed BaseModel created_at.
-	CreatedAt time.Time      `gorm:"index;index:idx_events_deleted_at_created_at,priority:2" json:"createdAt"`
-	DeletedAt gorm.DeletedAt `gorm:"index:idx_events_deleted_at_created_at,priority:1"       json:"deletedAt,omitzero"`
+	// DeletedAt is also the second column of the resubmitted_from_id
+	// index, for the reason DeliveryResult gives. The entrypoint_id
+	// index, for the webhook page's entrypoint list, has it second too,
+	// resubmitted_from_id third, and created_at last, which the list
+	// compares with a range.
+	CreatedAt time.Time      `gorm:"index;index:idx_events_deleted_at_created_at,priority:2;index:idx_events_entrypoint_id,priority:4"                                           json:"createdAt"`
+	DeletedAt gorm.DeletedAt `gorm:"index:idx_events_deleted_at_created_at,priority:1;index:idx_events_resubmitted_from_id,priority:2;index:idx_events_entrypoint_id,priority:2" json:"deletedAt,omitzero"`
 
-	WebhookID    string `gorm:"type:uuid;not null" json:"webhookId"`
-	EntrypointID string `gorm:"type:uuid;not null" json:"entrypointId"`
+	WebhookID    string `gorm:"type:uuid;not null"                                           json:"webhookId"`
+	EntrypointID string `gorm:"type:uuid;not null;index:idx_events_entrypoint_id,priority:1" json:"entrypointId"`
 
-	// Request data
+	// Request data. RawQuery is the receiving request's query string
+	// as sent, without the leading "?".
 	Method      string `gorm:"not null"    json:"method"`
+	RawQuery    string `gorm:"type:text"   json:"rawQuery"`
 	Headers     string `gorm:"type:text"   json:"headers"` // JSON
 	Body        string `gorm:"type:text"   json:"body"`
 	ContentType string `json:"contentType"`
 
+	// BodyBytes is the size of Body in bytes, recorded when the event
+	// is stored, so that the recent events list, which reads only the
+	// start of each body, knows the whole body's size.
+	BodyBytes int64 `gorm:"not null" json:"bodyBytes"`
+
 	// ResubmittedFromID names the event this one was copied from by
 	// an operator resubmit. It is nil for an event that arrived on
-	// the receiver, which is every event created before the column
-	// existed. It is not a foreign key: the source event can be
+	// the receiver. It is not a foreign key: the source event can be
 	// reaped by retention while its copies remain, and the id is
 	// kept as the record of where the copy came from either way.
-	ResubmittedFromID *string `gorm:"type:uuid;index" json:"resubmittedFromId,omitempty"`
+	ResubmittedFromID *string `gorm:"type:uuid;index:idx_events_resubmitted_from_id,priority:1;index:idx_events_entrypoint_id,priority:3" json:"resubmittedFromId,omitempty"`
 
-	// Relations
-	Webhook    Webhook    `json:"webhook,omitzero"`
-	Entrypoint Entrypoint `json:"entrypoint,omitzero"`
+	// Relations. No model marshals the record it belongs to, so
+	// Webhook and Entrypoint are left out of the JSON.
+	Webhook    Webhook    `json:"-"`
+	Entrypoint Entrypoint `json:"-"`
 	Deliveries []Delivery `json:"deliveries,omitempty"`
 }

internal/database/model_parent_test.go

@@ -0,0 +1,127 @@
+package database_test
+
+import (
+	"testing"
+
+	"github.com/google/uuid"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"sneak.berlin/go/webhooker/internal/database"
+)
+
+// TestPreloadedModelsMarshalWithoutTheirParent pins that a child's
+// reference to the record it belongs to is left out of the JSON, so a
+// webhook and its targets cannot marshal each other in a loop, and that
+// GORM still preloads that reference, since it ignores json tags.
+func TestPreloadedModelsMarshalWithoutTheirParent(t *testing.T) {
+	t.Parallel()
+
+	db := startedTestDB(t)
+
+	stored := database.Webhook{
+		UserID:      uuid.New().String(),
+		Name:        testWebhookName,
+		Entrypoints: []database.Entrypoint{{Path: uuid.New().String()}},
+		Targets: []database.Target{{
+			Name:        "log",
+			Type:        database.TargetTypeLog,
+			MaxAttempts: 1,
+		}},
+	}
+	require.NoError(t, db.Create(&stored).Error)
+
+	entrypointID := stored.Entrypoints[0].ID
+	targetID := stored.Targets[0].ID
+
+	var webhook database.Webhook
+
+	require.NoError(t, db.
+		Preload("Entrypoints.Webhook").
+		Preload("Targets.Webhook").
+		First(&webhook, "id = ?", stored.ID).Error)
+
+	require.Len(t, webhook.Entrypoints, 1)
+	require.Len(t, webhook.Targets, 1)
+	assert.Equal(t, stored.ID, webhook.Entrypoints[0].Webhook.ID)
+	assert.Equal(t, stored.ID, webhook.Targets[0].Webhook.ID)
+
+	encoded := marshalModel(t, webhook)
+
+	assert.Contains(t, encoded, entrypointID)
+	assert.Contains(t, encoded, targetID)
+
+	// Each child holds the parent's id as its webhookId, so the parent
+	// is looked for by its own id field.
+	parentIDField := `"id":"` + stored.ID + `"`
+
+	assert.NotContains(t, marshalModel(t, webhook.Entrypoints[0]), parentIDField)
+	assert.NotContains(t, marshalModel(t, webhook.Targets[0]), parentIDField)
+
+	var target database.Target
+
+	require.NoError(t, db.
+		Preload("Webhook").
+		First(&target, "id = ?", targetID).Error)
+
+	assert.Equal(t, stored.ID, target.Webhook.ID)
+
+	encoded = marshalModel(t, target)
+
+	assert.Contains(t, encoded, stored.ID)
+	assert.NotContains(t, encoded, parentIDField)
+}
+
+// TestModelsMarshalWithoutTheirParent covers the other references to a
+// parent: each model is built with its parent set, and the parent's id
+// must not appear in the JSON.
+func TestModelsMarshalWithoutTheirParent(t *testing.T) {
+	t.Parallel()
+
+	parent := database.BaseModel{ID: uuid.New().String()}
+
+	cases := []struct {
+		name  string
+		model any
+	}{
+		{
+			name:  "Webhook.User",
+			model: database.Webhook{User: database.User{BaseModel: parent}},
+		},
+		{
+			name:  "APIKey.User",
+			model: database.APIKey{User: database.User{BaseModel: parent}},
+		},
+		{
+			name:  "Delivery.Event",
+			model: database.Delivery{Event: database.Event{BaseModel: parent}},
+		},
+		{
+			name:  "Delivery.Target",
+			model: database.Delivery{Target: database.Target{BaseModel: parent}},
+		},
+		{
+			name: "DeliveryResult.Delivery",
+			model: database.DeliveryResult{
+				Delivery: database.Delivery{BaseModel: parent},
+			},
+		},
+		{
+			name:  "Event.Webhook",
+			model: database.Event{Webhook: database.Webhook{BaseModel: parent}},
+		},
+		{
+			name: "Event.Entrypoint",
+			model: database.Event{
+				Entrypoint: database.Entrypoint{BaseModel: parent},
+			},
+		},
+	}
+
+	for _, tc := range cases {
+		t.Run(tc.name, func(t *testing.T) {
+			t.Parallel()
+
+			assert.NotContains(t, marshalModel(t, tc.model), parent.ID)
+		})
+	}
+}

internal/database/model_secrets_test.go

@@ -29,8 +29,10 @@ func marshalModel(t *testing.T, v any) string {
 // these tags the first handler that marshals a model serialises the
 // secret with it. Each field below is a live credential:
 //
-//   - Target.Config holds an incoming-webhook URL whose path segments
-//     are the bearer token.
+//   - Target.URL is an incoming-webhook URL whose path segments are
+//     the bearer token.
+//   - Target.Headers holds header values, routinely authorization
+//     tokens.
 //   - APIKey.Key is a bearer token outright.
 //   - Setting.Value holds the session encryption key.
 //   - User.Password holds the Argon2 hash, and was already tagged.
@@ -44,11 +46,21 @@ func TestModelsDoNotMarshalTheirSecrets(t *testing.T) {
 		model any
 	}{
 		{
-			name: "target config",
+			name: "target url",
 			model: database.Target{
-				Name:   keptField,
-				Type:   database.TargetTypeSlack,
-				Config: `{"webhookUrl":"https://h/s/` + marker + `"}`,
+				Name:        keptField,
+				Type:        database.TargetTypeSlack,
+				URL:         "https://h/s/" + marker,
+				MaxAttempts: 1,
+			},
+		},
+		{
+			name: "target headers",
+			model: database.Target{
+				Name:        keptField,
+				Type:        database.TargetTypeHTTP,
+				Headers:     map[string]string{"Authorization": marker},
+				MaxAttempts: 1,
 			},
 		},
 		{
@@ -86,10 +98,10 @@ func TestModelsDoNotMarshalTheirSecrets(t *testing.T) {
 	}
 }
 
-// TestWebhookMarshalsNoTargetConfig covers the nested case: a webhook
+// TestWebhookMarshalsNoTargetURL covers the nested case: a webhook
 // marshalled with its targets preloaded must not carry the credential
 // through the association either.
-func TestWebhookMarshalsNoTargetConfig(t *testing.T) {
+func TestWebhookMarshalsNoTargetURL(t *testing.T) {
 	t.Parallel()
 
 	const marker = "QQNESTEDMARKERQQ"
@@ -97,8 +109,9 @@ func TestWebhookMarshalsNoTargetConfig(t *testing.T) {
 	encoded := marshalModel(t, database.Webhook{
 		Name: keptField,
 		Targets: []database.Target{{
-			Name:   "slack",
-			Config: `{"webhookUrl":"https://h/s/` + marker + `"}`,
+			Name:        "slack",
+			URL:         "https://h/s/" + marker,
+			MaxAttempts: 1,
 		}},
 	})
 

internal/database/model_target.go

@@ -1,5 +1,7 @@
 package database
 
+import "time"
+
 // TargetType represents the type of delivery target
 type TargetType string
 
@@ -11,7 +13,9 @@ const (
 	TargetTypeSlack    TargetType = "slack"
 )
 
-// Target represents a delivery target for a webhook
+// Target represents a delivery target for a webhook. Its settings
+// are the fields from URL to ArchiveRotation; each type uses some of
+// them, and the ones a type does not use stay empty.
 type Target struct {
 	BaseModel
 
@@ -20,21 +24,45 @@ type Target struct {
 	Type      TargetType `gorm:"not null"           json:"type"`
 	Active    bool       `gorm:"default:true"       json:"active"`
 
-	// Configuration fields (JSON stored based on type).
+	// URL is where an http or slack target sends each event.
 	//
-	// json:"-" because the blob holds the target's credential — a
-	// Slack incoming-webhook URL, or an http destination whose path
-	// segments are the secret. delivery.TargetView is the masking
-	// barrier for the HTML path; this tag is the barrier for any
-	// handler that marshals the model itself.
-	Config string `gorm:"type:text" json:"-"` // JSON configuration
+	// json:"-" because the URL is the target's credential: a Slack
+	// incoming-webhook URL, or an http destination whose path segments
+	// are the secret. delivery.TargetView is the masking barrier for
+	// the HTML path; this tag is the barrier for any handler that
+	// marshals the model itself.
+	URL string `json:"-"`
 
-	// For HTTP targets (max_retries=0 means fire-and-forget,
-	// >0 enables retries with backoff)
-	MaxRetries   int `json:"maxRetries,omitempty"`
-	MaxQueueSize int `json:"maxQueueSize,omitempty"`
+	// Headers is an http target's extra request headers, name to
+	// value, stored as JSON text. json:"-" for the same reason as URL:
+	// a header value is routinely an authorization token.
+	Headers map[string]string `gorm:"serializer:json" json:"-"`
 
-	// Relations
-	Webhook    Webhook    `json:"webhook,omitzero"`
+	// TimeoutSeconds is an http target's per-request timeout; 0 uses
+	// the delivery engine's shared client timeout.
+	TimeoutSeconds int `json:"timeoutSeconds,omitempty"`
+
+	// ForwardQuery passes each event's query string on to an http
+	// target, appended to URL. Off, URL is sent exactly as stored.
+	ForwardQuery bool `json:"forwardQuery,omitempty"`
+
+	// ArchiveExpiry is how long a database target keeps each archived
+	// event; 0 keeps them forever.
+	ArchiveExpiry time.Duration `json:"archiveExpiry,omitempty"`
+
+	// ArchiveRotation is how often a database target starts a new
+	// archive file: none, monthly, daily or hourly.
+	ArchiveRotation string `json:"archiveRotation,omitempty"`
+
+	// MaxAttempts is how many times an HTTP or Slack target attempts
+	// each delivery in all, at least 1. 1 is a single attempt with no
+	// circuit breaker; above 1, a failed attempt is retried with
+	// backoff behind the breaker. The table's check constraint refuses
+	// a target saved with less than 1, whatever its type.
+	MaxAttempts int `gorm:"not null;check:max_attempts >= 1" json:"maxAttempts,omitempty"`
+
+	// Relations. No model marshals the record it belongs to:
+	// Webhook.Targets leads back here, and the JSON could loop.
+	Webhook    Webhook    `json:"-"`
 	Deliveries []Delivery `json:"deliveries,omitempty"`
 }

internal/database/model_target_test.go

@@ -0,0 +1,63 @@
+package database_test
+
+import (
+	"testing"
+
+	"github.com/google/uuid"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"sneak.berlin/go/webhooker/internal/database"
+)
+
+// newHTTPTarget returns an http target that makes maxAttempts attempts
+// at each delivery.
+func newHTTPTarget(maxAttempts int) *database.Target {
+	return &database.Target{
+		WebhookID:   uuid.New().String(),
+		Name:        "target",
+		Type:        database.TargetTypeHTTP,
+		URL:         "https://example.com/",
+		MaxAttempts: maxAttempts,
+	}
+}
+
+// TestTargetCreate_RefusesZeroAttempts relies on the targets table
+// alone: nothing in the model checks the number, so the check
+// constraint is what keeps a target with 0 attempts out of the
+// database.
+func TestTargetCreate_RefusesZeroAttempts(t *testing.T) {
+	t.Parallel()
+
+	db := startedTestDB(t)
+
+	err := db.Create(newHTTPTarget(0)).Error
+	require.Error(t, err)
+	assert.Contains(t, err.Error(), "CHECK constraint failed")
+}
+
+func TestTargetCreate_AcceptsOneAttempt(t *testing.T) {
+	t.Parallel()
+
+	db := startedTestDB(t)
+
+	require.NoError(t, db.Create(newHTTPTarget(1)).Error)
+}
+
+// TestTargetHeaders_StoredAsJSON reads the headers column back as
+// text, to show it holds the header map as JSON.
+func TestTargetHeaders_StoredAsJSON(t *testing.T) {
+	t.Parallel()
+
+	db := startedTestDB(t)
+
+	target := newHTTPTarget(1)
+	target.Headers = map[string]string{"Authorization": "Bearer x"}
+	require.NoError(t, db.Create(target).Error)
+
+	var headers string
+
+	require.NoError(t, db.Raw(
+		"SELECT headers FROM targets WHERE id = ?", target.ID,
+	).Scan(&headers).Error)
+	assert.JSONEq(t, `{"Authorization":"Bearer x"}`, headers)
+}

internal/database/model_totals.go

@@ -0,0 +1,136 @@
+package database
+
+import (
+	"fmt"
+	"time"
+
+	"gorm.io/gorm"
+)
+
+// The running totals in a webhook's event database keep the webhook
+// page's lifetime figures right after retention has removed the rows
+// they count, and let the page show them without counting every row.
+// Each total changes in the transaction that writes or deletes the
+// rows it counts.
+
+// EventTotals is the single row counting a webhook's events: every
+// event ever stored, how many of them retention has deleted, and when
+// the newest arrived, which retention leaves as it is.
+type EventTotals struct {
+	ID int64 `gorm:"primaryKey"`
+
+	Events        int64 `gorm:"not null"`
+	EventsRemoved int64 `gorm:"not null"`
+
+	// LastEventAt is when the newest event arrived, or nil before the
+	// first.
+	LastEventAt *time.Time
+}
+
+// TableName names the table AddEventTotals updates.
+func (EventTotals) TableName() string {
+	return "event_totals"
+}
+
+// TargetTotals is one row per target counting its deliveries: every
+// delivery ever created, how many became delivered and how many
+// failed, and how many deliveries and failed deliveries retention has
+// deleted. The webhook's delivery figures are these rows summed.
+type TargetTotals struct {
+	TargetID string `gorm:"type:uuid;primaryKey"`
+
+	Deliveries int64 `gorm:"not null"`
+	Delivered  int64 `gorm:"not null"`
+	Failed     int64 `gorm:"not null"`
+
+	DeliveriesRemoved int64 `gorm:"not null"`
+	FailedRemoved     int64 `gorm:"not null"`
+}
+
+// TableName names the table AddTargetTotals updates.
+func (TargetTotals) TableName() string {
+	return "target_totals"
+}
+
+// EntrypointTotals is one row per entrypoint, created by the first
+// event that arrives on its URL: when the newest such event arrived,
+// which retention leaves as it is. A resubmitted copy did not arrive
+// on the URL and does not change it.
+type EntrypointTotals struct {
+	EntrypointID string `gorm:"type:uuid;primaryKey"`
+
+	LastEventAt time.Time `gorm:"not null"`
+}
+
+// TableName names the table AddEntrypointTotals updates.
+func (EntrypointTotals) TableName() string {
+	return "entrypoint_totals"
+}
+
+// AddEventTotals adds each count in add to the webhook's event totals,
+// and records add.LastEventAt as when the newest event arrived if it is
+// set. Call it on the transaction that writes or deletes the events it
+// counts.
+func AddEventTotals(tx *gorm.DB, add EventTotals) error {
+	err := tx.Exec(
+		`UPDATE event_totals SET
+			events = events + ?,
+			events_removed = events_removed + ?,
+			last_event_at = coalesce(?, last_event_at)`,
+		add.Events, add.EventsRemoved, add.LastEventAt,
+	).Error
+	if err != nil {
+		return fmt.Errorf("adding to event totals: %w", err)
+	}
+
+	return nil
+}
+
+// AddTargetTotals adds each count in add to the totals of the target
+// add.TargetID names, creating its row the first time. Call it on the
+// transaction that writes or deletes the deliveries it counts.
+func AddTargetTotals(tx *gorm.DB, add TargetTotals) error {
+	err := tx.Exec(
+		`INSERT INTO target_totals (target_id, deliveries, delivered,
+			failed, deliveries_removed, failed_removed)
+		VALUES (?, ?, ?, ?, ?, ?)
+		ON CONFLICT (target_id) DO UPDATE SET
+			deliveries = deliveries + excluded.deliveries,
+			delivered = delivered + excluded.delivered,
+			failed = failed + excluded.failed,
+			deliveries_removed =
+				deliveries_removed + excluded.deliveries_removed,
+			failed_removed = failed_removed + excluded.failed_removed`,
+		add.TargetID, add.Deliveries, add.Delivered,
+		add.Failed, add.DeliveriesRemoved, add.FailedRemoved,
+	).Error
+	if err != nil {
+		return fmt.Errorf(
+			"adding to totals of target %s: %w", add.TargetID, err,
+		)
+	}
+
+	return nil
+}
+
+// AddEntrypointTotals records add.LastEventAt as when the newest event
+// arrived on the URL of the entrypoint add.EntrypointID names, creating
+// its row the first time. Call it on the transaction that stores the
+// event.
+func AddEntrypointTotals(tx *gorm.DB, add EntrypointTotals) error {
+	err := tx.Exec(
+		`INSERT INTO entrypoint_totals (entrypoint_id, last_event_at)
+		VALUES (?, ?)
+		ON CONFLICT (entrypoint_id) DO UPDATE SET
+			last_event_at = excluded.last_event_at`,
+		add.EntrypointID, add.LastEventAt,
+	).Error
+	if err != nil {
+		return fmt.Errorf(
+			"adding to totals of entrypoint %s: %w",
+			add.EntrypointID, err,
+		)
+	}
+
+	return nil
+}

internal/database/model_user.go

@@ -1,13 +1,58 @@
 package database
 
+import (
+	"errors"
+	"fmt"
+
+	"gorm.io/gorm"
+)
+
+// MaxUsernameBytes is the longest username, in bytes, that a user may
+// have. The same number appears in the check constraint on
+// User.Username, because a struct tag cannot reference a constant.
+//
+// A login stores the username in the session cookie, and both
+// securecookie and browsers refuse a cookie value past about 4096
+// bytes. That value is the session base64-encoded twice, so it holds
+// 4096 × 3/4 × 3/4 = 2304 bytes of session, and the signature,
+// timestamp and the session's other values take about 270 of those: a
+// username longer than about 2030 bytes can never log in. The limit is
+// about half that, so the session can carry more values later without
+// locking out an account whose username is already at the limit.
+const MaxUsernameBytes = 1024
+
+// ErrUsernameTooLong is returned when a user is saved with a username
+// longer than MaxUsernameBytes.
+var ErrUsernameTooLong = errors.New("username is too long")
+
 // User represents a user of the webhooker service
+//
+//nolint:lll // a struct tag cannot wrap
 type User struct {
 	BaseModel
 
-	Username string `gorm:"uniqueIndex;not null" json:"username"`
-	Password string `gorm:"not null"             json:"-"` // Argon2 hashed
+	Username string `gorm:"uniqueIndex;not null;check:length(CAST(username AS BLOB)) <= 1024" json:"username"`
+	Password string `gorm:"not null"                                                          json:"-"` // Argon2 hashed
 
 	// Relations
 	Webhooks []Webhook `json:"webhooks,omitempty"`
 	APIKeys  []APIKey  `json:"apiKeys,omitempty"`
 }
+
+// BeforeSave rejects a username longer than MaxUsernameBytes when a whole
+// User is created or saved, so those calls get ErrUsernameTooLong rather
+// than the database's constraint error. A column update such as
+// Update("username", ...) is caught only by the check constraint, as is
+// any path that writes the table without this model.
+func (u *User) BeforeSave(_ *gorm.DB) error {
+	if len(u.Username) > MaxUsernameBytes {
+		return fmt.Errorf(
+			"%w: %d bytes, limit is %d",
+			ErrUsernameTooLong,
+			len(u.Username),
+			MaxUsernameBytes,
+		)
+	}
+
+	return nil
+}

internal/database/model_user_test.go

@@ -0,0 +1,65 @@
+package database_test
+
+import (
+	"strings"
+	"testing"
+
+	"github.com/google/uuid"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"sneak.berlin/go/webhooker/internal/database"
+)
+
+// usernameAtLimit is exactly MaxUsernameBytes long, built from a
+// two-byte character. A check that counted characters rather than bytes
+// would see half the length and let the one-byte-longer name through.
+func usernameAtLimit() string {
+	return strings.Repeat("é", database.MaxUsernameBytes/2)
+}
+
+func TestUserCreate_RejectsOverlongUsername(t *testing.T) {
+	t.Parallel()
+
+	db := startedTestDB(t)
+
+	err := db.Create(&database.User{
+		Username: usernameAtLimit() + "x",
+		Password: "hash",
+	}).Error
+
+	require.ErrorIs(t, err, database.ErrUsernameTooLong)
+}
+
+func TestUserCreate_AcceptsUsernameAtLimit(t *testing.T) {
+	t.Parallel()
+
+	db := startedTestDB(t)
+
+	require.NoError(t, db.Create(&database.User{
+		Username: usernameAtLimit(),
+		Password: "hash",
+	}).Error)
+}
+
+// TestUsersTable_EnforcesUsernameLimitWithoutTheModel inserts with raw
+// SQL, as a path that bypassed User.BeforeSave would, so only the
+// table's check constraint stands between it and an over-long
+// username. Accepting the name at the limit and refusing the next byte
+// also pins the constraint's number to MaxUsernameBytes.
+func TestUsersTable_EnforcesUsernameLimitWithoutTheModel(t *testing.T) {
+	t.Parallel()
+
+	db := startedTestDB(t)
+
+	insert := "INSERT INTO users (id, username, password) VALUES (?, ?, ?)"
+
+	require.NoError(t, db.Exec(
+		insert, uuid.New().String(), usernameAtLimit(), "hash",
+	).Error)
+
+	err := db.Exec(
+		insert, uuid.New().String(), usernameAtLimit()+"x", "hash",
+	).Error
+	require.Error(t, err)
+	assert.Contains(t, err.Error(), "CHECK constraint failed")
+}

internal/database/model_webhook.go

@@ -4,27 +4,13 @@ import (
 	"math"
 	"strconv"
 	"time"
-
-	"gorm.io/gorm"
 )
 
 const (
-	// DefaultRetentionDays is the event retention period applied to a
-	// webhook created without an explicit retention value. It is the
-	// single source of truth for that policy and must stay in sync
-	// with the `gorm:"default:30"` column default on
-	// Webhook.RetentionDays below; a struct tag cannot reference a
-	// constant, so a test asserts the two agree.
+	// DefaultRetentionDays is the event retention period the new
+	// webhook form applies when its retention field is left blank.
 	DefaultRetentionDays = 30
 
-	// RetentionForeverDays is the sentinel RetentionDays value meaning
-	// "retain events forever". Users express that intent as 0, which
-	// Webhook.BeforeSave rewrites to this value: the column default
-	// substitutes DefaultRetentionDays for a zero value at insert
-	// time, so a zero can never survive a round trip to the database.
-	// Nothing outside this file may hardcode the number.
-	RetentionForeverDays = 365 * 1000
-
 	// MaxFiniteRetentionDays is the largest finite retention period the
 	// reaper's cutoff arithmetic can represent, and therefore the
 	// largest one a caller may request. It is derived from that
@@ -38,9 +24,7 @@ const (
 	// turns the cutoff into a timestamp in the far future that matches
 	// every row in the webhook's database. That is why this bound is
 	// enforced on input and why retentionCutoff saturates underneath
-	// it. Note that RetentionForeverDays deliberately sits above this
-	// ceiling: such webhooks are skipped before any cutoff is
-	// computed, and never reach the arithmetic at all.
+	// it.
 	MaxFiniteRetentionDays = int(
 		math.MaxInt64 / int64(time.Hour) / hoursPerDay,
 	)
@@ -48,12 +32,10 @@ const (
 
 // Webhook represents a webhook processing unit that groups entrypoints and targets
 //
-// Every method below takes a pointer receiver. BeforeSave has to,
-// because it mutates the record and GORM only invokes hooks declared
-// that way; the display helpers follow suit so the receiver kinds do
-// not mix. Handlers therefore put a *Webhook into template data:
-// html/template cannot call a pointer method on a value held in a map,
-// because a map element is not addressable.
+// Every method below takes a pointer receiver, so handlers put a
+// *Webhook into template data: html/template cannot call a pointer
+// method on a value held in a map, because a map element is not
+// addressable.
 type Webhook struct {
 	BaseModel
 
@@ -61,47 +43,28 @@ type Webhook struct {
 	Name        string `gorm:"not null"           json:"name"`
 	Description string `json:"description"`
 
-	// RetentionDays is the number of days to retain events. A value of
-	// RetentionForeverDays means retain forever. The column default
-	// must equal DefaultRetentionDays.
-	RetentionDays int `gorm:"default:30" json:"retentionDays"`
+	// RetentionDays is the number of days to retain events, and 0
+	// means retain them forever.
+	RetentionDays int `json:"retentionDays"`
 
-	// Relations
-	User        User         `json:"user,omitzero"`
+	// Relations. No model marshals the record it belongs to:
+	// User.Webhooks leads back here, and the JSON could loop.
+	User        User         `json:"-"`
 	Entrypoints []Entrypoint `json:"entrypoints,omitempty"`
 	Targets     []Target     `json:"targets,omitempty"`
 }
 
-// BeforeSave normalises RetentionDays on every insert and update. A
-// non-positive value is the user's way of asking for "retain forever",
-// which is stored as the RetentionForeverDays sentinel.
-//
-// This has to happen in a hook rather than at the call sites. GORM
-// substitutes the column default (DefaultRetentionDays) for a zero
-// value while building the insert statement, which runs after
-// BeforeSave; rewriting any later than this loses that race and the
-// row lands at 30 days. Living on the model also means a future call
-// site — a REST API, a fixture, a migration — cannot bypass it.
-func (w *Webhook) BeforeSave(_ *gorm.DB) error {
-	if w.RetentionDays <= 0 {
-		w.RetentionDays = RetentionForeverDays
-	}
-
-	return nil
-}
-
-// retainsForever reports whether a stored RetentionDays value means
-// "keep events indefinitely". It is the single definition of that
-// question, shared by Webhook.RetainsForever and by the reaper's
+// retainsForever reports whether a RetentionDays value means "keep
+// events indefinitely", which 0 does. It is the single definition of
+// that question, shared by Webhook.RetainsForever and by the reaper's
 // cutoff computation so the two cannot disagree about which webhooks
 // are exempt from reaping.
 //
-// It accepts the RetentionForeverDays sentinel written by BeforeSave
-// and, defensively, the non-positive values that rows written before
-// the sentinel existed may still carry.
+// A negative value, which the forms refuse, is read the same way: as a
+// day count it would put the cutoff in the future, where it matches
+// every event the webhook has.
 func retainsForever(retentionDays int) bool {
-	return retentionDays <= 0 ||
-		retentionDays >= RetentionForeverDays
+	return retentionDays <= 0
 }
 
 // RetainsForever reports whether this webhook's events are kept
@@ -110,8 +73,16 @@ func (w *Webhook) RetainsForever() bool {
 	return retainsForever(w.RetentionDays)
 }
 
+// RetentionCutoff returns the time before which this webhook's events
+// have expired, as the reaper computes it, and false when the webhook
+// retains them forever.
+func (w *Webhook) RetentionCutoff(now time.Time) (time.Time, bool) {
+	return retentionCutoff(now, w.RetentionDays)
+}
+
 // RetentionLabel returns the webhook's retention policy as display
-// text, so that no template has to know about the sentinel value.
+// text: "forever" rather than "0 days" for a webhook that keeps its
+// events.
 func (w *Webhook) RetentionLabel() string {
 	if w.RetainsForever() {
 		return "forever"

internal/database/model_webhook_test.go

@@ -2,8 +2,6 @@ package database_test
 
 import (
 	"context"
-	"reflect"
-	"strconv"
 	"testing"
 	"time"
 
@@ -47,8 +45,7 @@ func storedRetention(t *testing.T, db *gorm.DB, id string) int {
 }
 
 // newWebhookWithRetention creates a webhook through the ordinary Create
-// path, so the BeforeSave hook and the GORM column default both apply
-// exactly as they do in production.
+// path, as the new webhook form does.
 func newWebhookWithRetention(
 	t *testing.T,
 	db *gorm.DB,
@@ -67,7 +64,7 @@ func newWebhookWithRetention(
 	return wh.ID
 }
 
-func TestWebhookBeforeSave_ZeroBecomesForeverSentinel(t *testing.T) {
+func TestWebhookRetentionDays_ZeroIsStoredAsZero(t *testing.T) {
 	t.Parallel()
 
 	db := startedTestDB(t)
@@ -75,31 +72,10 @@ func TestWebhookBeforeSave_ZeroBecomesForeverSentinel(t *testing.T) {
 	wh := &database.Webhook{RetentionDays: 0}
 	id := newWebhookWithRetention(t, db, wh)
 
-	assert.Equal(
-		t,
-		database.RetentionForeverDays,
-		storedRetention(t, db, id),
-		"a zero retention must be stored as the sentinel, "+
-			"not replaced by the column default",
-	)
+	assert.Equal(t, 0, storedRetention(t, db, id))
 }
 
-func TestWebhookBeforeSave_NegativeBecomesForeverSentinel(t *testing.T) {
-	t.Parallel()
-
-	db := startedTestDB(t)
-
-	wh := &database.Webhook{RetentionDays: -5}
-	id := newWebhookWithRetention(t, db, wh)
-
-	assert.Equal(
-		t,
-		database.RetentionForeverDays,
-		storedRetention(t, db, id),
-	)
-}
-
-func TestWebhookBeforeSave_PositiveIsPreserved(t *testing.T) {
+func TestWebhookRetentionDays_DayCountIsStored(t *testing.T) {
 	t.Parallel()
 
 	db := startedTestDB(t)
@@ -110,10 +86,9 @@ func TestWebhookBeforeSave_PositiveIsPreserved(t *testing.T) {
 	assert.Equal(t, 7, storedRetention(t, db, id))
 }
 
-// TestWebhookBeforeSave_UpdateToZeroBecomesSentinel proves the hook
-// fires on update as well as insert, via the same Save call the edit
-// handler makes.
-func TestWebhookBeforeSave_UpdateToZeroBecomesSentinel(t *testing.T) {
+// TestWebhookRetentionDays_UpdateToZeroIsStoredAsZero changes a day
+// count to 0 through the same Save call the edit handler makes.
+func TestWebhookRetentionDays_UpdateToZeroIsStoredAsZero(t *testing.T) {
 	t.Parallel()
 
 	db := startedTestDB(t)
@@ -125,28 +100,7 @@ func TestWebhookBeforeSave_UpdateToZeroBecomesSentinel(t *testing.T) {
 	wh.RetentionDays = 0
 	require.NoError(t, db.Omit(clause.Associations).Save(wh).Error)
 
-	assert.Equal(
-		t,
-		database.RetentionForeverDays,
-		storedRetention(t, db, id),
-	)
-}
-
-// TestWebhookRetentionColumnDefaultMatchesConstant guards the one place
-// the default lives twice: a struct tag cannot reference a constant, so
-// this asserts the tag and DefaultRetentionDays agree.
-func TestWebhookRetentionColumnDefaultMatchesConstant(t *testing.T) {
-	t.Parallel()
-
-	field, ok := reflect.TypeFor[database.Webhook]().
-		FieldByName("RetentionDays")
-	require.True(t, ok, "Webhook.RetentionDays must exist")
-
-	assert.Equal(
-		t,
-		"default:"+strconv.Itoa(database.DefaultRetentionDays),
-		field.Tag.Get("gorm"),
-	)
+	assert.Equal(t, 0, storedRetention(t, db, id))
 }
 
 // TestMaxFiniteRetentionDaysIsTheOverflowCeiling asserts that the
@@ -176,14 +130,6 @@ func TestMaxFiniteRetentionDaysIsTheOverflowCeiling(t *testing.T) {
 		time.Duration(overCeiling*hoursPerDay)*time.Hour,
 		"one day past the ceiling must overflow",
 	)
-
-	assert.Less(
-		t,
-		database.MaxFiniteRetentionDays,
-		database.RetentionForeverDays,
-		"the sentinel sits above the ceiling and is only safe "+
-			"because retain-forever webhooks skip the arithmetic",
-	)
 }
 
 func TestWebhookRetainsForeverAndLabel(t *testing.T) {
@@ -195,16 +141,8 @@ func TestWebhookRetainsForeverAndLabel(t *testing.T) {
 		forever bool
 		label   string
 	}{
-		{
-			"sentinel",
-			database.RetentionForeverDays, true, testForeverLabel,
-		},
-		{
-			"above sentinel",
-			database.RetentionForeverDays + 1, true, testForeverLabel,
-		},
-		{"legacy zero", 0, true, testForeverLabel},
-		{"legacy negative", -1, true, testForeverLabel},
+		{"zero", 0, true, testForeverLabel},
+		{"negative", -1, true, testForeverLabel},
 		{"default", database.DefaultRetentionDays, false, "30 days"},
 		{"one day", 1, false, "1 day"},
 	}

internal/database/models.go

@@ -1,16 +0,0 @@
-package database
-
-// Migrate runs database migrations for the main application database.
-// Only configuration-tier models are stored in the main database.
-// Event-tier models (Event, Delivery, DeliveryResult) live in
-// per-webhook dedicated databases managed by WebhookDBManager.
-func (d *Database) Migrate() error {
-	return d.db.AutoMigrate(
-		&Setting{},
-		&User{},
-		&APIKey{},
-		&Webhook{},
-		&Entrypoint{},
-		&Target{},
-	)
-}

internal/database/password.go

@@ -9,6 +9,7 @@ import (
 	"math/big"
 	"strings"
 	"sync"
+	"testing"
 
 	"golang.org/x/crypto/argon2"
 )
@@ -63,10 +64,31 @@ func DefaultPasswordConfig() *PasswordConfig {
 	}
 }
 
-// HashPassword generates an Argon2id hash of the password
+// testArgon2Memory is the Argon2id memory cost, in KiB, that a test
+// binary hashes with: 1 MB instead of the shipped 64 MB. Every test
+// that starts a database hashes the bootstrap admin password, dozens
+// of them run in parallel, and each 64 MB hash holds at least 64 MB
+// while it runs (about 150 MB when the suite ran under the race
+// detector). VerifyPassword reads the cost from the hash it checks, so
+// verification follows.
+const testArgon2Memory = 1024
+
+// hashAtShippedCostInTest makes a test binary hash at the shipped
+// memory cost. Only TestHashPassword_ShippedParameters sets it.
+//
+//nolint:gochecknoglobals // set by one test, see above
+var hashAtShippedCostInTest bool
+
+// HashPassword generates an Argon2id hash of the password. A binary
+// built by go test hashes at testArgon2Memory; one built by go build
+// always hashes at the defaults.
 func HashPassword(password string) (string, error) {
 	config := DefaultPasswordConfig()
 
+	if testing.Testing() && !hashAtShippedCostInTest {
+		config.Memory = testArgon2Memory
+	}
+
 	// Generate a salt
 	salt := make([]byte, config.SaltLen)
 

internal/database/password_test.go

@@ -192,6 +192,39 @@ func TestHashPasswordUniqueness(t *testing.T) {
 	}
 }
 
+// TestHashPassword_ShippedParameters hashes and verifies through
+// HashPassword at the shipped Argon2id parameters. Every other test
+// hashes at the lower memory cost a test binary uses, so this is the
+// one that keeps production hashing covered. One hash and one
+// verification: each costs 64 MB.
+//
+//nolint:paralleltest // changes the hashing cost for the whole binary
+func TestHashPassword_ShippedParameters(t *testing.T) {
+	database.HashAtShippedCostForTest(t)
+
+	password := "correct horse battery staple"
+
+	hash, err := database.HashPassword(password)
+	if err != nil {
+		t.Fatalf("hashing with the shipped parameters: %v", err)
+	}
+
+	const shipped = "$argon2id$v=19$m=65536,t=1,p=4$"
+
+	if !strings.HasPrefix(hash, shipped) {
+		t.Errorf("hash = %q, want prefix %q", hash, shipped)
+	}
+
+	valid, err := database.VerifyPassword(password, hash)
+	if err != nil {
+		t.Fatalf("VerifyPassword() error = %v", err)
+	}
+
+	if !valid {
+		t.Error("VerifyPassword() returned false for correct password")
+	}
+}
+
 // TestVerifyDummyPassword_DoesRealWork covers the anti-enumeration
 // path. Login charges an unknown username a verification against a
 // dummy hash so that a nonexistent account is not answered in

internal/database/retention.go

@@ -18,6 +18,19 @@ import (
 // computation.
 const hoursPerDay = 24
 
+// reapBatchSize is how many expired events one retention transaction
+// deletes. A transaction holds the event database's write lock, which
+// the receiver and the delivery workers wait for, so a large prune is
+// split into transactions each short enough to finish well inside the
+// busy timeout.
+const reapBatchSize = 1000
+
+// reapBatchPause is how long retention waits after one batch before
+// starting the next. A writer waiting for the write lock checks for it
+// again after at most 100 ms, so a longer pause lets it in between two
+// batches instead of only after the whole prune.
+const reapBatchPause = 200 * time.Millisecond
+
 // RetentionReaperParams holds the fx dependencies for the
 // RetentionReaper.
 type RetentionReaperParams struct {
@@ -171,32 +184,32 @@ func (r *RetentionReaper) sweep(ctx context.Context) {
 
 		wh := webhooks[i]
 
-		// Skip retain-forever webhooks before building any query.
-		// RetainsForever covers both the RetentionForeverDays
-		// sentinel and the non-positive values that predate it: the
-		// sentinel is a positive number, so without this the reaper
-		// would compute a cutoff a thousand years in the past and
-		// issue a DELETE matching nothing on every single sweep.
-		if wh.RetainsForever() {
-			continue
-		}
-
-		// Nothing to reap if the per-webhook database has never
-		// been created.
+		// A missing database has nothing to reap. The delivery
+		// engine's recovery routine reports a lost one at start (see
+		// WebhookDBManager.GetDB).
 		if !r.dbManager.DBExists(wh.ID) {
 			continue
 		}
 
-		r.reapWebhook(wh.ID, wh.RetentionDays)
+		r.reapWebhook(ctx, wh.ID, wh.RetentionDays)
 	}
 }
 
 // reapWebhook removes every expired event (and its dependents) from a
-// single webhook's database.
+// single webhook's database, or as many as it reaches before ctx is
+// cancelled.
 func (r *RetentionReaper) reapWebhook(
+	ctx context.Context,
 	webhookID string,
 	retentionDays int,
 ) {
+	// A retain-forever webhook has no cutoff, so its database is not
+	// even opened.
+	cutoff, ok := retentionCutoff(time.Now(), retentionDays)
+	if !ok {
+		return
+	}
+
 	db, err := r.dbManager.GetDB(webhookID)
 	if err != nil {
 		r.log.Error(
@@ -208,12 +221,7 @@ func (r *RetentionReaper) reapWebhook(
 		return
 	}
 
-	cutoff, ok := retentionCutoff(time.Now(), retentionDays)
-	if !ok {
-		return
-	}
-
-	deleted, err := reapExpired(db, cutoff)
+	deleted, err := reapExpired(ctx, db, cutoff)
 	if err != nil {
 		r.log.Error(
 			"retention sweep: failed to reap expired events",
@@ -236,7 +244,8 @@ func (r *RetentionReaper) reapWebhook(
 
 // retentionCutoff returns the timestamp before which a webhook's
 // events have expired, and whether any cutoff applies at all. It
-// reports false for a retain-forever policy, so no DELETE is issued.
+// reports false for a retention of 0, which means retain forever, so
+// no DELETE is issued.
 //
 // The day count is clamped to MaxFiniteRetentionDays first. This is
 // defense in depth rather than decoration: a time.Duration is an int64
@@ -246,7 +255,7 @@ func (r *RetentionReaper) reapWebhook(
 // row in the database: the sweep then deletes every event, delivery,
 // and delivery result, including ones created seconds ago. Rejecting
 // out-of-range input at the form is the primary guard; saturating here
-// means an old row, a migration, or a future call site cannot turn a
+// means a value that reaches the row by any other path cannot turn a
 // too-large retention into total data loss.
 func retentionCutoff(
 	now time.Time,
@@ -265,57 +274,107 @@ func retentionCutoff(
 	), true
 }
 
-// reapExpired hard-deletes, in foreign-key-safe order, the delivery
-// results, deliveries, and events associated with events older than
-// cutoff. Deletes are unscoped so rows are physically removed rather
-// than soft-deleted, reclaiming disk. It returns the number of events
-// deleted.
-func reapExpired(db *gorm.DB, cutoff time.Time) (int64, error) {
-	// Fresh subqueries are built per statement to avoid reusing a
-	// mutated builder across executions.
-	expiredEventIDs := func() *gorm.DB {
-		return db.Model(&Event{}).
-			Select("id").
-			Where("created_at < ?", cutoff)
-	}
-	expiredDeliveryIDs := func() *gorm.DB {
-		return db.Model(&Delivery{}).
-			Select("id").
-			Where("event_id IN (?)", expiredEventIDs())
-	}
+// reapExpired hard-deletes the events older than cutoff, with their
+// deliveries and delivery results, reapBatchSize events per
+// transaction with reapBatchPause between transactions, until none is
+// left. Once ctx is cancelled it returns after the batch in hand,
+// leaving the rest to the next sweep, so stopping the app does not
+// wait for a long prune. It returns the number of events deleted.
+func reapExpired(
+	ctx context.Context, db *gorm.DB, cutoff time.Time,
+) (int64, error) {
+	var total int64
 
-	// 1. Delivery results whose delivery belongs to an expired event.
-	res := db.Unscoped().
-		Where("delivery_id IN (?)", expiredDeliveryIDs()).
-		Delete(&DeliveryResult{})
-	if res.Error != nil {
-		return 0, fmt.Errorf(
-			"deleting expired delivery results: %w",
-			res.Error,
-		)
-	}
+	for {
+		var eventIDs []string
 
-	// 2. Deliveries belonging to an expired event.
-	del := db.Unscoped().
-		Where("event_id IN (?)", expiredEventIDs()).
-		Delete(&Delivery{})
-	if del.Error != nil {
-		return 0, fmt.Errorf(
-			"deleting expired deliveries: %w",
-			del.Error,
-		)
-	}
+		err := db.Transaction(func(tx *gorm.DB) error {
+			err := tx.Unscoped().Model(&Event{}).
+				Where("created_at < ?", cutoff).
+				Limit(reapBatchSize).
+				Pluck("id", &eventIDs).Error
+			if err != nil {
+				return fmt.Errorf("selecting expired events: %w", err)
+			}
 
-	// 3. The expired events themselves.
-	ev := db.Unscoped().
-		Where("created_at < ?", cutoff).
-		Delete(&Event{})
-	if ev.Error != nil {
-		return 0, fmt.Errorf(
-			"deleting expired events: %w",
-			ev.Error,
-		)
-	}
+			if len(eventIDs) == 0 {
+				return nil
+			}
 
-	return ev.RowsAffected, nil
+			return deleteEvents(tx, eventIDs)
+		})
+		if err != nil {
+			return total, err
+		}
+
+		total += int64(len(eventIDs))
+
+		if len(eventIDs) < reapBatchSize {
+			return total, nil
+		}
+
+		select {
+		case <-ctx.Done():
+			return total, nil
+		case <-time.After(reapBatchPause):
+		}
+	}
+}
+
+// deleteEvents hard-deletes the given events and, in foreign-key-safe
+// order before them, their delivery results and deliveries, then adds
+// what it deleted to the running totals. It runs on reapExpired's
+// transaction, so the totals change exactly when the rows do. Deletes
+// are unscoped so rows are physically removed rather than
+// soft-deleted, reclaiming disk.
+func deleteEvents(tx *gorm.DB, eventIDs []string) error {
+	// 1. The delivery results of the events' deliveries.
+	err := tx.Unscoped().
+		Where("delivery_id IN (?)", tx.Unscoped().Model(&Delivery{}).
+			Select("id").
+			Where("event_id IN ?", eventIDs)).
+		Delete(&DeliveryResult{}).Error
+	if err != nil {
+		return fmt.Errorf("deleting expired delivery results: %w", err)
+	}
+
+	// 2. The events' deliveries, after counting them, and the failed
+	// ones among them, per target. The status is tested in the select
+	// list rather than the WHERE clause: there, SQLite would read every
+	// failed delivery the webhook has through the status index,
+	// instead of only these through the event_id index.
+	var removed []TargetTotals
+
+	err = tx.Unscoped().Model(&Delivery{}).
+		Select("target_id, count(*) AS deliveries_removed, "+
+			"count(CASE WHEN status = ? THEN 1 END) AS failed_removed",
+			DeliveryStatusFailed).
+		Where("event_id IN ?", eventIDs).
+		Group("target_id").
+		Find(&removed).Error
+	if err != nil {
+		return fmt.Errorf("counting expired deliveries: %w", err)
+	}
+
+	err = tx.Unscoped().
+		Where("event_id IN ?", eventIDs).
+		Delete(&Delivery{}).Error
+	if err != nil {
+		return fmt.Errorf("deleting expired deliveries: %w", err)
+	}
+
+	// 3. The events themselves.
+	ev := tx.Unscoped().Where("id IN ?", eventIDs).Delete(&Event{})
+	if ev.Error != nil {
+		return fmt.Errorf("deleting expired events: %w", ev.Error)
+	}
+
+	for i := range removed {
+		err = AddTargetTotals(tx, removed[i])
+		if err != nil {
+			return err
+		}
+	}
+
+	return AddEventTotals(tx, EventTotals{EventsRemoved: ev.RowsAffected})
 }

internal/database/retention_test.go

@@ -51,7 +51,7 @@ func setupRetentionTest(t *testing.T) *retentionTestEnv {
 
 	mgr, err := database.NewWebhookDBManager(
 		lc,
-		database.WebhookDBManagerParams{Config: cfg, Logger: l},
+		database.WebhookDBManagerParams{Config: cfg, Logger: l.Get()},
 	)
 	require.NoError(t, err)
 
@@ -85,41 +85,6 @@ func createWebhook(
 		db.Omit(clause.Associations).Create(wh).Error,
 	)
 
-	// Webhook.BeforeSave rewrites a non-positive RetentionDays to the
-	// retain-forever sentinel, and the column's GORM default would
-	// otherwise substitute 30. Force the requested value with a
-	// column-level update so tests can plant legacy rows that predate
-	// the sentinel and still carry a literal 0 or negative value.
-	require.NoError(
-		t,
-		db.Model(wh).
-			Update("retention_days", retentionDays).Error,
-	)
-
-	return wh.ID
-}
-
-// createWebhookNormally inserts a webhook through the ordinary Create
-// path, with no column-level forcing, so Webhook.BeforeSave applies
-// exactly as it does in production. Passing 0 therefore yields a row
-// holding the RetentionForeverDays sentinel.
-func createWebhookNormally(
-	t *testing.T,
-	db *gorm.DB,
-	retentionDays int,
-) string {
-	t.Helper()
-
-	wh := &database.Webhook{
-		UserID:        uuid.New().String(),
-		Name:          testWebhookName,
-		RetentionDays: retentionDays,
-	}
-	require.NoError(
-		t,
-		db.Omit(clause.Associations).Create(wh).Error,
-	)
-
 	return wh.ID
 }
 
@@ -281,19 +246,19 @@ func TestRetentionReaper_ReapsExpiredKeepsRecent(t *testing.T) {
 	assertChainPresent(t, db, recent)
 }
 
-// TestRetentionReaper_SkipsSentinelReapsFiniteInSameSweep covers the
-// end-to-end retain-forever path: a webhook created the normal way with
-// a requested retention of 0 lands on the RetentionForeverDays
-// sentinel, and the reaper leaves its ancient events alone while still
-// reaping a finite-retention webhook in the very same sweep.
-func TestRetentionReaper_SkipsSentinelReapsFiniteInSameSweep(
+// TestRetentionReaper_SkipsZeroReapsFiniteInSameSweep covers the
+// end-to-end retain-forever path: a webhook created with a retention
+// of 0 reads back 0, and the reaper leaves its ancient events alone
+// while still reaping a finite-retention webhook in the very same
+// sweep.
+func TestRetentionReaper_SkipsZeroReapsFiniteInSameSweep(
 	t *testing.T,
 ) {
 	t.Parallel()
 
 	env := setupRetentionTest(t)
 
-	foreverID := createWebhookNormally(t, env.mainDB.DB(), 0)
+	foreverID := createWebhook(t, env.mainDB.DB(), 0)
 
 	var stored database.Webhook
 
@@ -302,14 +267,12 @@ func TestRetentionReaper_SkipsSentinelReapsFiniteInSameSweep(
 		env.mainDB.DB().Where("id = ?", foreverID).
 			First(&stored).Error,
 	)
-	require.Equal(
-		t,
-		database.RetentionForeverDays,
-		stored.RetentionDays,
-		"a requested retention of 0 must persist as the sentinel",
+	require.Zero(
+		t, stored.RetentionDays,
+		"a retention of 0 must be stored as 0",
 	)
 
-	finiteID := createWebhookNormally(t, env.mainDB.DB(), 30)
+	finiteID := createWebhook(t, env.mainDB.DB(), 30)
 
 	foreverDB, err := env.mgr.GetDB(foreverID)
 	require.NoError(t, err)
@@ -335,14 +298,10 @@ func TestRetentionReaper_SkipsSentinelReapsFiniteInSameSweep(
 // negative, so subtracting it moves the cutoff into the far future,
 // where "created_at < cutoff" matches every row: an event created a
 // moment ago, and its delivery and delivery result, were all deleted
-// on the first sweep. 200000 is inside that band and below the
-// retain-forever sentinel, so it is treated as a finite policy and
-// really does reach the arithmetic.
+// on the first sweep. 200000 is inside that band.
 //
-// The row is planted at the column level because such a value can no
-// longer be submitted through the form; the point of the test is that
-// a row from an older version, or a future call site, still cannot
-// trigger the wipe.
+// The form refuses such a value; the point of the test is that a row
+// written by any other path still cannot trigger the wipe.
 func TestRetentionReaper_HugeFiniteRetentionRetainsRecentEvents(
 	t *testing.T,
 ) {
@@ -358,12 +317,6 @@ func TestRetentionReaper_HugeFiniteRetentionRetainsRecentEvents(
 		database.MaxFiniteRetentionDays,
 		"the test value must exceed what the cutoff can represent",
 	)
-	require.Less(
-		t,
-		overflowingRetentionDays,
-		database.RetentionForeverDays,
-		"the test value must not be rescued by the forever skip",
-	)
 
 	webhookID := createWebhook(
 		t, env.mainDB.DB(), overflowingRetentionDays,
@@ -379,14 +332,15 @@ func TestRetentionReaper_HugeFiniteRetentionRetainsRecentEvents(
 	assertChainPresent(t, db, fresh)
 }
 
-func TestRetentionReaper_RetainsForeverWhenNonPositive(t *testing.T) {
+// TestRetentionReaper_RetainsForeverWhenNegative checks that a negative
+// retention, which the forms refuse, keeps every event rather than
+// putting the cutoff in the future, where it would match them all.
+func TestRetentionReaper_RetainsForeverWhenNegative(t *testing.T) {
 	t.Parallel()
 
 	env := setupRetentionTest(t)
 
-	// A legacy row written before the sentinel existed still carries a
-	// literal 0; the <= 0 guard must keep honouring it.
-	webhookID := createWebhook(t, env.mainDB.DB(), 0)
+	webhookID := createWebhook(t, env.mainDB.DB(), -1)
 
 	db, err := env.mgr.GetDB(webhookID)
 	require.NoError(t, err)

internal/database/schema_test.go

@@ -0,0 +1,173 @@
+package database_test
+
+import (
+	"log/slog"
+	"net/http"
+	"testing"
+	"time"
+
+	"github.com/google/uuid"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"gorm.io/gorm"
+	"sneak.berlin/go/webhooker/internal/database"
+	"sneak.berlin/go/webhooker/internal/database/databasetest"
+)
+
+// withFixedNow returns db with GORM's clock stopped at a time in UTC,
+// so that the created and updated times it writes come back from
+// SQLite equal to the row written, which holds them in UTC.
+func withFixedNow(db *gorm.DB) (*gorm.DB, time.Time) {
+	at := time.Date(2026, 10, 13, 12, 30, 45, 123456789, time.UTC)
+
+	return db.Session(&gorm.Session{
+		NowFunc: func() time.Time { return at },
+	}), at
+}
+
+// newBaseModel returns a BaseModel with a new ID.
+func newBaseModel() database.BaseModel {
+	return database.BaseModel{ID: uuid.New().String()}
+}
+
+// assertRoundTrip writes row, which must be the only row of its
+// table, and reads back the same row.
+func assertRoundTrip[T any](t *testing.T, db *gorm.DB, row *T) {
+	t.Helper()
+
+	require.NoError(t, db.Create(row).Error)
+
+	var got T
+
+	require.NoError(t, db.First(&got).Error)
+	assert.Equal(t, *row, got)
+}
+
+// TestMainSchemaHoldsEveryModel writes a row of each main database
+// model, every field set, into a database made from its SQL files.
+func TestMainSchemaHoldsEveryModel(t *testing.T) {
+	t.Parallel()
+
+	mainDB, err := database.Open(
+		t.TempDir(), slog.New(slog.DiscardHandler),
+	)
+	require.NoError(t, err)
+
+	t.Cleanup(func() { _ = mainDB.Close() })
+
+	db, at := withFixedNow(mainDB.DB())
+
+	assertRoundTrip(t, db, &database.Setting{
+		Key: "session_key", Value: "value",
+	})
+	assertRoundTrip(t, db, &database.User{
+		BaseModel: newBaseModel(),
+		Username:  "user",
+		Password:  "password hash",
+	})
+	assertRoundTrip(t, db, &database.APIKey{
+		BaseModel:   newBaseModel(),
+		UserID:      uuid.New().String(),
+		Key:         "key",
+		Description: "API key description",
+		LastUsedAt:  &at,
+	})
+	assertRoundTrip(t, db, &database.Webhook{
+		BaseModel:     newBaseModel(),
+		UserID:        uuid.New().String(),
+		Name:          "webhook",
+		Description:   "webhook description",
+		RetentionDays: 7,
+	})
+	assertRoundTrip(t, db, &database.Entrypoint{
+		BaseModel:   newBaseModel(),
+		WebhookID:   uuid.New().String(),
+		Path:        uuid.New().String(),
+		Description: "entrypoint description",
+		Active:      true,
+	})
+	assertRoundTrip(t, db, &database.Target{
+		BaseModel:       newBaseModel(),
+		WebhookID:       uuid.New().String(),
+		Name:            "target",
+		Type:            database.TargetTypeHTTP,
+		Active:          true,
+		URL:             "https://example.com/",
+		Headers:         map[string]string{"X-Api-Key": "key"},
+		TimeoutSeconds:  30,
+		ForwardQuery:    true,
+		ArchiveExpiry:   720 * time.Hour,
+		ArchiveRotation: "daily",
+		MaxAttempts:     3,
+	})
+}
+
+// TestEventSchemaHoldsEveryModel does the same for a webhook's event
+// database, which the manager makes from its SQL files.
+func TestEventSchemaHoldsEveryModel(t *testing.T) {
+	t.Parallel()
+
+	mgr := databasetest.NewWebhookDBManager(t, t.TempDir())
+
+	t.Cleanup(func() { _ = mgr.CloseAll() })
+
+	events, err := mgr.GetDB(uuid.New().String())
+	require.NoError(t, err)
+
+	db, at := withFixedNow(events)
+	source := uuid.New().String()
+
+	assertRoundTrip(t, db, &database.Event{
+		BaseModel:         newBaseModel(),
+		WebhookID:         uuid.New().String(),
+		EntrypointID:      uuid.New().String(),
+		Method:            http.MethodPost,
+		RawQuery:          "a=1",
+		Headers:           `{"X":"Y"}`,
+		Body:              "body",
+		ContentType:       "text/plain",
+		BodyBytes:         4,
+		ResubmittedFromID: &source,
+	})
+	assertRoundTrip(t, db, &database.Delivery{
+		BaseModel:  newBaseModel(),
+		EventID:    uuid.New().String(),
+		TargetID:   uuid.New().String(),
+		Status:     database.DeliveryStatusDelivered,
+		FinishedAt: &at,
+		Replay:     true,
+	})
+	assertRoundTrip(t, db, &database.DeliveryResult{
+		BaseModel:    newBaseModel(),
+		DeliveryID:   uuid.New().String(),
+		AttemptNum:   2,
+		Success:      true,
+		StatusCode:   200,
+		ResponseBody: "ok",
+		Error:        "error",
+		Duration:     15,
+	})
+	assertRoundTrip(t, db, &database.TargetTotals{
+		TargetID:          uuid.New().String(),
+		Deliveries:        5,
+		Delivered:         3,
+		Failed:            1,
+		DeliveriesRemoved: 2,
+		FailedRemoved:     1,
+	})
+	assertRoundTrip(t, db, &database.EntrypointTotals{
+		EntrypointID: uuid.New().String(), LastEventAt: at,
+	})
+
+	// A new event database has its one row of event totals already.
+	require.NoError(t, database.AddEventTotals(db, database.EventTotals{
+		Events: 3, EventsRemoved: 1, LastEventAt: &at,
+	}))
+
+	var totals []database.EventTotals
+
+	require.NoError(t, db.Find(&totals).Error)
+	assert.Equal(t, []database.EventTotals{{
+		ID: 1, Events: 3, EventsRemoved: 1, LastEventAt: &at,
+	}}, totals)
+}

internal/database/sqlite_mode_test.go

@@ -137,7 +137,7 @@ func TestPerWebhookEventDatabaseFilesAreOwnerOnly(t *testing.T) {
 }
 
 // TestArchiveDatabaseFilesAreOwnerOnly covers the archive-*.db tier.
-// internal/delivery builds that path and opens it through OpenSQLite,
+// internal/archive builds that path and opens it through OpenSQLite,
 // the same single open path exercised here, so the mode is settled for
 // all three tiers in one place.
 func TestArchiveDatabaseFilesAreOwnerOnly(t *testing.T) {
@@ -182,6 +182,29 @@ func TestOpenSQLiteTightensFilesLeftWorldReadable(t *testing.T) {
 	requireDatabaseSetOwnerOnly(t, path)
 }
 
+// TestOpenSQLiteRefusesADirectorySidecar covers a directory in place
+// of -wal or -shm. Beside a -shm directory SQLite opens the database
+// read-only without a word, and every write then fails naming no file,
+// so the open must stop instead, naming the directory.
+func TestOpenSQLiteRefusesADirectorySidecar(t *testing.T) {
+	t.Parallel()
+
+	for _, suffix := range []string{"-wal", "-shm"} {
+		t.Run(suffix, func(t *testing.T) {
+			t.Parallel()
+
+			path := filepath.Join(t.TempDir(), database.MainDBFileName)
+			require.NoError(t, os.Mkdir(path+suffix, 0o700))
+
+			_, err := database.OpenSQLite(
+				path, database.SQLiteModeCreate,
+			)
+			require.Error(t, err)
+			assert.Contains(t, err.Error(), path+suffix)
+		})
+	}
+}
+
 // TestOpenSQLiteExistingModeDoesNotCreateTheFile guards the mechanism
 // the fix uses: OpenSQLite now creates the database file itself, and
 // must not do so for a caller that asked for an existing database. An

internal/database/sqlite_open.go

@@ -7,6 +7,7 @@ import (
 	"io/fs"
 	"net/url"
 	"os"
+	"syscall"
 	"time"
 
 	_ "modernc.org/sqlite" // Pure Go SQLite driver
@@ -93,7 +94,8 @@ const (
 const SQLiteFilePerm fs.FileMode = 0o600
 
 // reserveSQLiteFile puts path at SQLiteFilePerm before the driver ever
-// touches it, and tightens any sidecar already on disk.
+// touches it, and tightens any sidecar already on disk. A directory in
+// place of any of them is an error naming it.
 //
 // The mode has to be settled here rather than by a chmod after opening,
 // because SQLite picks it: robust_open substitutes
@@ -116,9 +118,8 @@ const SQLiteFilePerm fs.FileMode = 0o600
 // SQLite still reports the absence rather than this function
 // materializing an empty database the caller asked not to create.
 //
-// Chmod of a file that already exists is what tightens a data
-// directory an earlier build left at 0644 — including a developer's
-// own scratch directory — without any migration machinery.
+// The mode is set on every open, whoever created the file, so a
+// database or sidecar found at a wider mode is tightened too.
 func reserveSQLiteFile(path string, create bool) error {
 	if create {
 		// gosec G304: the path is the database file the caller asked
@@ -143,7 +144,15 @@ func reserveSQLiteFile(path string, create bool) error {
 	for _, p := range append(
 		[]string{path}, sqliteSidecarPaths(path)...,
 	) {
-		err := os.Chmod(p, SQLiteFilePerm)
+		// Chmod accepts a directory, and SQLite opens a database whose
+		// -shm is one read-only, without a word: every write then
+		// fails naming no file.
+		info, err := os.Stat(p)
+		if err == nil && info.IsDir() {
+			return fmt.Errorf("securing %s: %w", p, syscall.EISDIR)
+		}
+
+		err = os.Chmod(p, SQLiteFilePerm)
 		if err != nil && !errors.Is(err, fs.ErrNotExist) {
 			return fmt.Errorf("securing %s: %w", p, err)
 		}
@@ -152,6 +161,20 @@ func reserveSQLiteFile(path string, create bool) error {
 	return nil
 }
 
+// missingOrEmpty reports whether opening path in SQLiteModeCreate
+// would start a new, empty database: the file is not there, or it is
+// zero-length, which SQLite opens as an empty database. A file left at
+// zero length by an interrupted first start or a truncated copy holds
+// as little as a missing one, and must be reported the same way.
+func missingOrEmpty(path string) bool {
+	info, err := os.Stat(path)
+	if errors.Is(err, fs.ErrNotExist) {
+		return true
+	}
+
+	return err == nil && info.Size() == 0
+}
+
 // sqliteSidecarPaths returns the files SQLite maintains beside a
 // database under WAL. They carry the same rows as the database itself,
 // so a fix that tightens only the main file has fixed nothing.
@@ -218,7 +241,19 @@ func SQLiteDSN(path, mode string) string {
 	)
 	q.Add("_pragma", "journal_mode(WAL)")
 
-	return "file:" + path + "?" + q.Encode()
+	// SQLite reads a file: URI's path only up to the first ? or #, and
+	// decodes %XX escapes in it, so url.URL escapes the path. OmitHost
+	// keeps a relative path as "file:data/x.db"; written
+	// "file://data/x.db", SQLite would reject "data" as the URI's
+	// authority.
+	dsn := url.URL{
+		Scheme:   "file",
+		Path:     path,
+		OmitHost: true,
+		RawQuery: q.Encode(),
+	}
+
+	return dsn.String()
 }
 
 // OpenSQLite opens the SQLite file at path with the service's

internal/database/sqlite_open_test.go

@@ -2,6 +2,8 @@ package database_test
 
 import (
 	"context"
+	"database/sql"
+	"os"
 	"path/filepath"
 	"strings"
 	"testing"
@@ -112,6 +114,79 @@ func TestMainDBAppliesPragmasOnALiveHandle(t *testing.T) {
 	assert.Equal(t, "10000", busy)
 }
 
+// TestOpenSQLiteOpensThePathAskedFor uses a data directory whose name
+// holds ?, # and %. SQLite reads a file: URI's path only up to a ? or
+// #, and decodes %41 to A, so an unescaped path sent every database in
+// that directory to one file outside it.
+func TestOpenSQLiteOpensThePathAskedFor(t *testing.T) {
+	t.Parallel()
+
+	dir := filepath.Join(t.TempDir(), "hooks#1?x%41")
+	require.NoError(t, os.Mkdir(dir, 0o700))
+
+	for _, name := range []string{
+		database.MainDBFileName,
+		"events-" + uuid.New().String() + ".db",
+	} {
+		path := filepath.Join(dir, name)
+
+		sqlDB, err := database.OpenSQLite(
+			path, database.SQLiteModeCreate,
+		)
+		require.NoError(t, err)
+
+		t.Cleanup(func() { assert.NoError(t, sqlDB.Close()) })
+
+		assertOpenedFile(t, sqlDB, path)
+	}
+}
+
+// TestOpenSQLiteOpensARelativePath opens a database at a path relative
+// to the working directory, which is what a relative DATA_DIR such as
+// the README's DATA_DIR=../webhooker-data gives OpenSQLite.
+//
+//nolint:paralleltest // t.Chdir moves the whole process.
+func TestOpenSQLiteOpensARelativePath(t *testing.T) {
+	t.Chdir(t.TempDir())
+	require.NoError(t, os.Mkdir("data", 0o700))
+
+	path := filepath.Join("data", database.MainDBFileName)
+
+	sqlDB, err := database.OpenSQLite(path, database.SQLiteModeCreate)
+	require.NoError(t, err)
+
+	defer func() { require.NoError(t, sqlDB.Close()) }()
+
+	assertOpenedFile(t, sqlDB, path)
+}
+
+// assertOpenedFile checks that sqlDB is the SQLite file at path.
+// database_list names the file SQLite actually opened, as an absolute
+// path with symlinks resolved, so the files are compared, not the names.
+func assertOpenedFile(t *testing.T, sqlDB *sql.DB, path string) {
+	t.Helper()
+
+	var (
+		seq          int
+		schema, file string
+	)
+
+	require.NoError(t, sqlDB.
+		QueryRowContext(t.Context(), "pragma database_list").
+		Scan(&seq, &schema, &file))
+
+	asked, err := os.Stat(path)
+	require.NoError(t, err)
+
+	opened, err := os.Stat(file)
+	require.NoError(t, err)
+
+	assert.True(
+		t, os.SameFile(asked, opened),
+		"asked for %s, SQLite opened %s", path, file,
+	)
+}
+
 // TestConcurrentReaderDoesNotBlockWrites is the unit-scale form of the
 // reproduction in
 // https://git.eeqj.de/sneak/webhooker/issues/256: an operator's

internal/database/testing.go

@@ -1,47 +0,0 @@
-package database
-
-import (
-	"log/slog"
-	"os"
-
-	"gorm.io/gorm"
-)
-
-// NewTestDatabase creates a Database wrapper around a pre-opened *gorm.DB.
-// Intended for use in tests that need a *database.Database without the
-// full fx lifecycle. The caller is responsible for closing the underlying
-// sql.DB connection.
-func NewTestDatabase(db *gorm.DB) *Database {
-	return &Database{
-		db: db,
-		log: slog.New(slog.NewTextHandler(
-			os.Stderr,
-			&slog.HandlerOptions{Level: slog.LevelDebug},
-		)),
-	}
-}
-
-// NewTestWebhookDBManager creates a WebhookDBManager backed by the given
-// data directory. Intended for use in tests without the fx lifecycle.
-func NewTestWebhookDBManager(dataDir string) *WebhookDBManager {
-	return NewTestWebhookDBManagerWithLogger(
-		dataDir,
-		slog.New(slog.NewTextHandler(
-			os.Stderr,
-			&slog.HandlerOptions{Level: slog.LevelDebug},
-		)),
-	)
-}
-
-// NewTestWebhookDBManagerWithLogger is NewTestWebhookDBManager with the
-// logger supplied by the caller. The per-webhook databases this manager
-// opens hand that logger to gormlog, so a test that needs to see the SQL
-// the service emits can capture it.
-func NewTestWebhookDBManagerWithLogger(
-	dataDir string, log *slog.Logger,
-) *WebhookDBManager {
-	return &WebhookDBManager{
-		dataDir: dataDir,
-		log:     log,
-	}
-}

internal/database/totals_test.go

@@ -0,0 +1,417 @@
+package database_test
+
+import (
+	"context"
+	"net/http"
+	"testing"
+	"time"
+
+	"github.com/google/uuid"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"gorm.io/gorm"
+	"sneak.berlin/go/webhooker/internal/database"
+)
+
+// readEventTotals reads a webhook database's row of event totals,
+// asserting that it has exactly one.
+func readEventTotals(t *testing.T, db *gorm.DB) database.EventTotals {
+	t.Helper()
+
+	var rows []database.EventTotals
+
+	require.NoError(t, db.Find(&rows).Error)
+	require.Len(t, rows, 1)
+
+	return rows[0]
+}
+
+// readTargetTotals reads a webhook database's target totals, keyed by
+// target.
+func readTargetTotals(
+	t *testing.T, db *gorm.DB,
+) map[string]database.TargetTotals {
+	t.Helper()
+
+	var rows []database.TargetTotals
+
+	require.NoError(t, db.Find(&rows).Error)
+
+	byTarget := make(map[string]database.TargetTotals, len(rows))
+	for _, row := range rows {
+		byTarget[row.TargetID] = row
+	}
+
+	return byTarget
+}
+
+// TestWebhookDBManager_TotalsSurviveReopen verifies that a new event
+// database starts with one row of zero event totals and no target
+// totals, that adding to a target twice adds to the one row, and that
+// opening the database again keeps everything added.
+func TestWebhookDBManager_TotalsSurviveReopen(t *testing.T) {
+	t.Parallel()
+
+	mgr, lc := setupTestWebhookDBManager(t)
+	ctx := context.Background()
+	require.NoError(t, lc.Start(ctx))
+
+	defer func() { require.NoError(t, lc.Stop(ctx)) }()
+
+	webhookID := uuid.New().String()
+
+	db, err := mgr.GetDB(webhookID)
+	require.NoError(t, err)
+
+	fresh := readEventTotals(t, db)
+	assert.Equal(t, database.EventTotals{ID: fresh.ID}, fresh)
+	assert.Empty(t, readTargetTotals(t, db))
+
+	first, second := uuid.New().String(), uuid.New().String()
+
+	require.NoError(t, database.AddEventTotals(db, database.EventTotals{
+		Events: 2,
+	}))
+	require.NoError(t, database.AddTargetTotals(db, database.TargetTotals{
+		TargetID: first, Deliveries: 2, Delivered: 1,
+	}))
+	require.NoError(t, database.AddTargetTotals(db, database.TargetTotals{
+		TargetID: first, Failed: 1,
+	}))
+	require.NoError(t, database.AddTargetTotals(db, database.TargetTotals{
+		TargetID: second, Deliveries: 1,
+	}))
+
+	// Drop the cached connection so the next open reopens the file,
+	// as a restart would.
+	require.NoError(t, mgr.CloseAll())
+
+	db, err = mgr.GetDB(webhookID)
+	require.NoError(t, err)
+
+	assert.Equal(t, database.EventTotals{ID: fresh.ID, Events: 2},
+		readEventTotals(t, db))
+	assert.Equal(t, map[string]database.TargetTotals{
+		first: {
+			TargetID: first, Deliveries: 2, Delivered: 1, Failed: 1,
+		},
+		second: {TargetID: second, Deliveries: 1},
+	}, readTargetTotals(t, db))
+}
+
+// seedExpiredEvents stores count events created at the given time,
+// each with a delivered delivery to one target and a failed delivery
+// to the other, and one attempt for each delivery.
+//
+// It and seedBareEvents insert 50 rows per statement, not more. The
+// SQLite driver looks up each parameter's value by scanning the
+// statement's arguments from the first until it reaches that
+// parameter's, so the time to bind a statement grows with the square of
+// its parameter count: at 500 rows, several thousand parameters, the
+// seeding took most of these tests' time under -race.
+func seedExpiredEvents(
+	t *testing.T,
+	db *gorm.DB,
+	webhookID string,
+	count int,
+	createdAt time.Time,
+	delivered, failed string,
+) {
+	t.Helper()
+
+	events := make([]database.Event, count)
+	deliveries := make([]database.Delivery, 0, 2*count)
+
+	for i := range events {
+		events[i] = database.Event{
+			WebhookID:    webhookID,
+			EntrypointID: uuid.New().String(),
+			Method:       http.MethodPost,
+		}
+		events[i].ID = uuid.New().String()
+		events[i].CreatedAt = createdAt
+
+		deliveries = append(deliveries,
+			database.Delivery{
+				EventID:  events[i].ID,
+				TargetID: delivered,
+				Status:   database.DeliveryStatusDelivered,
+			},
+			database.Delivery{
+				EventID:  events[i].ID,
+				TargetID: failed,
+				Status:   database.DeliveryStatusFailed,
+			},
+		)
+	}
+
+	require.NoError(t, db.CreateInBatches(events, 50).Error)
+	require.NoError(t, db.CreateInBatches(deliveries, 50).Error)
+
+	results := make([]database.DeliveryResult, len(deliveries))
+	for i := range deliveries {
+		results[i] = database.DeliveryResult{
+			DeliveryID: deliveries[i].ID, AttemptNum: 1,
+		}
+	}
+
+	require.NoError(t, db.CreateInBatches(results, 50).Error)
+}
+
+// seedBareEvents stores count events created at the given time, with
+// no deliveries.
+func seedBareEvents(
+	t *testing.T,
+	db *gorm.DB,
+	webhookID string,
+	count int,
+	createdAt time.Time,
+) {
+	t.Helper()
+
+	events := make([]database.Event, count)
+	for i := range events {
+		events[i] = database.Event{
+			WebhookID:    webhookID,
+			EntrypointID: uuid.New().String(),
+			Method:       http.MethodPost,
+		}
+		events[i].CreatedAt = createdAt
+	}
+
+	require.NoError(t, db.CreateInBatches(events, 50).Error)
+}
+
+// TestRetentionReaper_PrunesMoreThanOneBatch verifies that a prune
+// larger than one transaction's batch removes every expired event with
+// its deliveries and delivery results, keeps the recent event, and
+// adds what it removed to the event and target totals, so the totals
+// within retention match the rows still stored.
+func TestRetentionReaper_PrunesMoreThanOneBatch(t *testing.T) {
+	t.Parallel()
+
+	env := setupRetentionTest(t)
+
+	webhookID := createWebhook(t, env.mainDB.DB(), 30)
+
+	db, err := env.mgr.GetDB(webhookID)
+	require.NoError(t, err)
+
+	expired := database.ExportReapBatchSize + 1
+	delivered, failed := uuid.New().String(), uuid.New().String()
+	seedExpiredEvents(t, db, webhookID, expired,
+		time.Now().Add(-40*24*time.Hour), delivered, failed)
+
+	// One recent event, delivered to the first target.
+	recent := seedEventChain(t, db, webhookID, time.Now())
+	require.NoError(t, db.Model(&database.Delivery{}).
+		Where("id = ?", recent.deliveryID).
+		Update("target_id", delivered).Error)
+
+	// The totals storing those rows would have left.
+	n := int64(expired)
+	require.NoError(t, database.AddEventTotals(db, database.EventTotals{
+		Events: n + 1,
+	}))
+	require.NoError(t, database.AddTargetTotals(db, database.TargetTotals{
+		TargetID: delivered, Deliveries: n + 1, Delivered: n + 1,
+	}))
+	require.NoError(t, database.AddTargetTotals(db, database.TargetTotals{
+		TargetID: failed, Deliveries: n, Failed: n,
+	}))
+
+	env.reaper.ExportSweep(context.Background())
+
+	// Only the recent event's rows are left.
+	for _, model := range []any{
+		&database.Event{}, &database.Delivery{}, &database.DeliveryResult{},
+	} {
+		var count int64
+
+		require.NoError(t, db.Model(model).Count(&count).Error)
+		assert.Equal(t, int64(1), count, "%T rows left", model)
+	}
+
+	assertChainPresent(t, db, recent)
+
+	eventTotals := readEventTotals(t, db)
+	assert.Equal(t, database.EventTotals{
+		ID: eventTotals.ID, Events: n + 1, EventsRemoved: n,
+	}, eventTotals)
+
+	targetTotals := readTargetTotals(t, db)
+	assert.Equal(t, map[string]database.TargetTotals{
+		delivered: {
+			TargetID: delivered, Deliveries: n + 1, Delivered: n + 1,
+			DeliveriesRemoved: n,
+		},
+		failed: {
+			TargetID: failed, Deliveries: n, Failed: n,
+			DeliveriesRemoved: n, FailedRemoved: n,
+		},
+	}, targetTotals)
+
+	// A sweep with nothing left to remove changes nothing.
+	env.reaper.ExportSweep(context.Background())
+
+	assert.Equal(t, eventTotals, readEventTotals(t, db))
+	assert.Equal(t, targetTotals, readTargetTotals(t, db))
+}
+
+// TestRetentionReaper_WriteDuringPruneSucceeds verifies that a prune
+// of several batches lets other writers in between its batches: an
+// event stored once the first batch is deleted is stored while expired
+// events are still left, not only after the prune has finished.
+func TestRetentionReaper_WriteDuringPruneSucceeds(t *testing.T) {
+	t.Parallel()
+
+	env := setupRetentionTest(t)
+
+	webhookID := createWebhook(t, env.mainDB.DB(), 30)
+
+	db, err := env.mgr.GetDB(webhookID)
+	require.NoError(t, err)
+
+	// Three batches of expired events, with nothing else stored: only
+	// the number of batches matters here.
+	expired := 3 * database.ExportReapBatchSize
+	seedBareEvents(t, db, webhookID, expired,
+		time.Now().Add(-40*24*time.Hour))
+
+	cutoff := time.Now().Add(-30 * 24 * time.Hour)
+	countExpired := func() int64 {
+		var count int64
+
+		require.NoError(t, db.Model(&database.Event{}).
+			Where("created_at < ?", cutoff).
+			Count(&count).Error)
+
+		return count
+	}
+
+	pruned := make(chan struct{})
+
+	go func() {
+		defer close(pruned)
+
+		env.reaper.ExportSweep(context.Background())
+	}()
+
+	t.Cleanup(func() { <-pruned })
+
+	// Every stored event is expired until the write below.
+	require.Eventually(t, func() bool {
+		var count int64
+
+		err := db.Model(&database.Event{}).Count(&count).Error
+
+		return err == nil && count < int64(expired)
+	}, 10*time.Second, 10*time.Millisecond)
+
+	event := &database.Event{
+		WebhookID:    webhookID,
+		EntrypointID: uuid.New().String(),
+		Method:       http.MethodPost,
+	}
+	require.NoError(t, db.Create(event).Error)
+
+	assert.Positive(t, countExpired(),
+		"the event was stored only after the whole prune")
+
+	<-pruned
+
+	assert.Zero(t, countExpired())
+
+	var stored database.Event
+
+	require.NoError(t, db.First(&stored, "id = ?", event.ID).Error)
+}
+
+// TestRetentionReaper_StopDuringPruneLeavesTheRest verifies that
+// stopping the reaper during a prune of several batches returns
+// between two batches, well inside the stop timeout, leaving the
+// remaining expired events for the next sweep, and that the totals
+// match the rows left.
+func TestRetentionReaper_StopDuringPruneLeavesTheRest(t *testing.T) {
+	t.Parallel()
+
+	env := setupRetentionTest(t)
+
+	webhookID := createWebhook(t, env.mainDB.DB(), 30)
+
+	db, err := env.mgr.GetDB(webhookID)
+	require.NoError(t, err)
+
+	// Two batches and one more of expired events, a few of them with a
+	// delivered and a failed delivery for the target totals to count.
+	// Most carry nothing else, to keep the test quick.
+	const withDeliveries = 10
+
+	expiredAt := time.Now().Add(-40 * 24 * time.Hour)
+	delivered, failed := uuid.New().String(), uuid.New().String()
+	seedExpiredEvents(t, db, webhookID, withDeliveries, expiredAt,
+		delivered, failed)
+	seedBareEvents(t, db, webhookID,
+		2*database.ExportReapBatchSize+1-withDeliveries, expiredAt)
+
+	n := int64(2*database.ExportReapBatchSize + 1)
+	require.NoError(t, database.AddEventTotals(db, database.EventTotals{
+		Events: n,
+	}))
+	require.NoError(t, database.AddTargetTotals(db, database.TargetTotals{
+		TargetID: delivered, Deliveries: withDeliveries,
+		Delivered: withDeliveries,
+	}))
+	require.NoError(t, database.AddTargetTotals(db, database.TargetTotals{
+		TargetID: failed, Deliveries: withDeliveries,
+		Failed: withDeliveries,
+	}))
+
+	env.reaper.ExportSetInterval(time.Millisecond)
+	env.reaper.ExportStart()
+
+	// Stop once the first batch is deleted. The stop lands in the pause
+	// after it, or at worst during the second batch, so at least the
+	// last event is left.
+	require.Eventually(t, func() bool {
+		var count int64
+
+		err := db.Model(&database.Event{}).Count(&count).Error
+
+		return err == nil && count < n
+	}, 10*time.Second, 10*time.Millisecond)
+
+	// The app's stop timeout.
+	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+	defer cancel()
+
+	require.NoError(t, env.reaper.ExportStop(ctx))
+
+	var events int64
+
+	require.NoError(t, db.Model(&database.Event{}).Count(&events).Error)
+	assert.Positive(t, events, "the stop waited for the whole prune")
+
+	eventTotals := readEventTotals(t, db)
+	assert.Equal(t, events, eventTotals.Events-eventTotals.EventsRemoved)
+
+	targetTotals := readTargetTotals(t, db)
+	require.Len(t, targetTotals, 2)
+
+	for target, totals := range targetTotals {
+		var deliveries, failures int64
+
+		require.NoError(t, db.Model(&database.Delivery{}).
+			Where("target_id = ?", target).
+			Count(&deliveries).Error)
+		require.NoError(t, db.Model(&database.Delivery{}).
+			Where("target_id = ? AND status = ?",
+				target, database.DeliveryStatusFailed).
+			Count(&failures).Error)
+
+		assert.Equal(t, deliveries,
+			totals.Deliveries-totals.DeliveriesRemoved, target)
+		assert.Equal(t, failures, totals.Failed-totals.FailedRemoved,
+			target)
+	}
+}

internal/database/webhook_db_manager.go

@@ -14,8 +14,8 @@ import (
 	"gorm.io/gorm"
 	"sneak.berlin/go/webhooker/internal/config"
 	"sneak.berlin/go/webhooker/internal/datadir"
+	"sneak.berlin/go/webhooker/internal/db/migrations"
 	"sneak.berlin/go/webhooker/internal/gormlog"
-	"sneak.berlin/go/webhooker/internal/logger"
 )
 
 // WebhookDBManagerParams holds the fx dependencies for
@@ -24,7 +24,7 @@ type WebhookDBManagerParams struct {
 	fx.In
 
 	Config *config.Config
-	Logger *logger.Logger
+	Logger *slog.Logger
 }
 
 // errInvalidCachedDBType indicates a type assertion failure
@@ -33,9 +33,23 @@ var errInvalidCachedDBType = errors.New(
 	"invalid cached database type",
 )
 
+// ErrEventDBNotRemoved is in DeleteDB's error when the event
+// database file itself could not be removed: it is still on disk.
+var ErrEventDBNotRemoved = errors.New(
+	"event database file not removed",
+)
+
+// ErrSidecarNotRemoved is in DeleteDB's error when the event
+// database file was removed, so its events are gone, but its -wal
+// or -shm sidecar could not be.
+var ErrSidecarNotRemoved = errors.New(
+	"event database file removed, but a -wal or -shm sidecar was not",
+)
+
 // WebhookDBManager manages per-webhook SQLite database files
 // for event storage. Each webhook gets its own dedicated
-// database containing Events, Deliveries, and DeliveryResults.
+// database containing Events, Deliveries, DeliveryResults and the
+// running totals of them (EventTotals, TargetTotals, EntrypointTotals).
 // Database connections are opened lazily and cached.
 type WebhookDBManager struct {
 	dataDir string
@@ -56,7 +70,7 @@ func NewWebhookDBManager(
 ) (*WebhookDBManager, error) {
 	m := &WebhookDBManager{
 		dataDir: params.Config.DataDir,
-		log:     params.Logger.Get(),
+		log:     params.Logger,
 	}
 
 	// Create data directory if it doesn't exist. datadir.DirPerm is the
@@ -84,34 +98,37 @@ func NewWebhookDBManager(
 	return m, nil
 }
 
-// GetDB returns the database connection for a webhook,
-// creating the database file lazily if it doesn't exist.
+// GetDB returns the database connection for a webhook, opening it on
+// first use.
+//
+// The file is made by CreateDB when the webhook is created. One that is
+// missing or zero-length here means the webhook's events and pending
+// deliveries are gone: an empty database is created in its place so
+// the webhook keeps receiving, and that is logged as a warning naming
+// the file, as a new main database is.
 func (m *WebhookDBManager) GetDB(
 	webhookID string,
 ) (*gorm.DB, error) {
-	// Fast path: already open
-	if val, ok := m.dbs.Load(webhookID); ok {
-		return asGormDB(val, webhookID)
-	}
+	return m.getDB(webhookID, false)
+}
 
-	// Slow path: open the database under the lock, looking in the
-	// cache again first. A caller that raced another one here then
-	// waits for its handle instead of opening a second one.
+// GetDBIf is GetDB, done only when check reports true. check runs under
+// the lock DeleteDB holds while it removes the files, so a caller can
+// confirm the webhook still exists and open its database with no delete
+// in between. The handle is nil when check reports false. check must
+// not call the manager.
+func (m *WebhookDBManager) GetDBIf(
+	webhookID string, check func() (bool, error),
+) (*gorm.DB, error) {
 	m.mu.Lock()
 	defer m.mu.Unlock()
 
-	if val, ok := m.dbs.Load(webhookID); ok {
-		return asGormDB(val, webhookID)
-	}
-
-	db, err := m.openDB(webhookID)
-	if err != nil {
+	ok, err := check()
+	if err != nil || !ok {
 		return nil, err
 	}
 
-	m.dbs.Store(webhookID, db)
-
-	return db, nil
+	return m.getDBLocked(webhookID, false)
 }
 
 // asGormDB returns a value read from the cache as the database
@@ -129,12 +146,12 @@ func asGormDB(val any, webhookID string) (*gorm.DB, error) {
 	return db, nil
 }
 
-// CreateDB explicitly creates a new per-webhook database file
-// and runs migrations.
+// CreateDB creates a new webhook's database file and runs
+// migrations.
 func (m *WebhookDBManager) CreateDB(
 	webhookID string,
 ) error {
-	_, err := m.GetDB(webhookID)
+	_, err := m.getDB(webhookID, true)
 
 	return err
 }
@@ -150,7 +167,10 @@ func (m *WebhookDBManager) DBExists(
 }
 
 // DeleteDB closes the connection and deletes the database file
-// for a webhook. The file is permanently removed.
+// for a webhook, with its -wal and -shm sidecars. The files are
+// permanently removed. Each file is tried even when another could
+// not be removed, and the error wraps ErrEventDBNotRemoved or
+// ErrSidecarNotRemoved to say which was left, naming each file.
 func (m *WebhookDBManager) DeleteDB(
 	webhookID string,
 ) error {
@@ -169,16 +189,23 @@ func (m *WebhookDBManager) DeleteDB(
 		}
 	}
 
-	// Delete the main DB file and WAL/SHM files
 	path := m.dbPath(webhookID)
-	for _, suffix := range []string{"", "-wal", "-shm"} {
-		err := os.Remove(path + suffix)
-		if err != nil && !os.IsNotExist(err) {
-			return fmt.Errorf(
-				"deleting webhook database file %s%s: %w",
-				path, suffix, err,
-			)
-		}
+
+	dbErr := removeFile(path)
+	sidecarErr := errors.Join(
+		removeFile(path+"-wal"),
+		removeFile(path+"-shm"),
+	)
+
+	if dbErr != nil {
+		return fmt.Errorf(
+			"%w: %w",
+			ErrEventDBNotRemoved, errors.Join(dbErr, sidecarErr),
+		)
+	}
+
+	if sidecarErr != nil {
+		return fmt.Errorf("%w: %w", ErrSidecarNotRemoved, sidecarErr)
 	}
 
 	m.log.Info(
@@ -189,6 +216,17 @@ func (m *WebhookDBManager) DeleteDB(
 	return nil
 }
 
+// removeFile removes path. A file that is already gone counts as
+// removed; the error from any other failure names the file.
+func removeFile(path string) error {
+	err := os.Remove(path)
+	if errors.Is(err, os.ErrNotExist) {
+		return nil
+	}
+
+	return err
+}
+
 // CloseAll closes all open per-webhook database connections.
 // Called during application shutdown.
 func (m *WebhookDBManager) CloseAll() error {
@@ -231,6 +269,54 @@ func (m *WebhookDBManager) DBPath(
 	return m.dbPath(webhookID)
 }
 
+// getDB is GetDB, and CreateDB when isNew is true: the webhook has just
+// been created, so a missing file is expected rather than lost.
+func (m *WebhookDBManager) getDB(
+	webhookID string, isNew bool,
+) (*gorm.DB, error) {
+	// Fast path: already open
+	if val, ok := m.dbs.Load(webhookID); ok {
+		return asGormDB(val, webhookID)
+	}
+
+	m.mu.Lock()
+	defer m.mu.Unlock()
+
+	return m.getDBLocked(webhookID, isNew)
+}
+
+// getDBLocked is getDB's slow path, run with m.mu held. It looks in the
+// cache again first: a caller that raced another one to the lock then
+// gets its handle instead of opening a second one.
+func (m *WebhookDBManager) getDBLocked(
+	webhookID string, isNew bool,
+) (*gorm.DB, error) {
+	if val, ok := m.dbs.Load(webhookID); ok {
+		return asGormDB(val, webhookID)
+	}
+
+	// Checked before opening, which creates the file. See GetDB.
+	path := m.dbPath(webhookID)
+	replaced := !isNew && missingOrEmpty(path)
+
+	db, err := m.openDB(webhookID)
+	if err != nil {
+		return nil, err
+	}
+
+	if replaced {
+		m.log.Warn(
+			"created a new, empty database",
+			"webhook_id", webhookID,
+			"path", path,
+		)
+	}
+
+	m.dbs.Store(webhookID, db)
+
+	return db, nil
+}
+
 func (m *WebhookDBManager) dbPath(
 	webhookID string,
 ) string {
@@ -285,17 +371,7 @@ func (m *WebhookDBManager) openDB(
 		)
 	}
 
-	err = purgeTargetRows(db, m.log, webhookID)
-	if err != nil {
-		_ = sqlDB.Close()
-
-		return nil, err
-	}
-
-	// Run migrations for event-tier models only
-	err = db.AutoMigrate(
-		&Event{}, &Delivery{}, &DeliveryResult{},
-	)
+	err = migrations.Apply(db, migrations.Events)
 	if err != nil {
 		_ = sqlDB.Close()
 
@@ -305,6 +381,19 @@ func (m *WebhookDBManager) openDB(
 		)
 	}
 
+	err = parseModels(
+		db, &Event{}, &Delivery{}, &DeliveryResult{},
+		&EventTotals{}, &TargetTotals{}, &EntrypointTotals{},
+	)
+	if err != nil {
+		_ = sqlDB.Close()
+
+		return nil, fmt.Errorf(
+			"connecting to webhook database %s: %w",
+			webhookID, err,
+		)
+	}
+
 	m.log.Info(
 		"opened per-webhook database",
 		"webhook_id", webhookID,

internal/database/webhook_db_manager_test.go

@@ -18,6 +18,7 @@ import (
 	"gorm.io/gorm"
 	"sneak.berlin/go/webhooker/internal/config"
 	"sneak.berlin/go/webhooker/internal/database"
+	"sneak.berlin/go/webhooker/internal/database/databasetest"
 	"sneak.berlin/go/webhooker/internal/globals"
 	"sneak.berlin/go/webhooker/internal/logger"
 )
@@ -50,7 +51,7 @@ func setupTestWebhookDBManager(
 		lc,
 		database.WebhookDBManagerParams{
 			Config: cfg,
-			Logger: l,
+			Logger: l.Get(),
 		},
 	)
 	require.NoError(t, err)
@@ -117,7 +118,8 @@ func TestWebhookDBManager_ConcurrentFirstTouchOpensOnce(t *testing.T) {
 
 	var logs bytes.Buffer
 
-	mgr := database.NewTestWebhookDBManagerWithLogger(
+	mgr := databasetest.NewWebhookDBManagerWithLogger(
+		t,
 		t.TempDir(),
 		slog.New(slog.NewTextHandler(&logs, nil)),
 	)
@@ -182,17 +184,91 @@ func TestWebhookDBManager_DeleteDB(t *testing.T) {
 	}
 	require.NoError(t, db.Create(event).Error)
 
+	// Under WAL, an open database that has been written to has both
+	// sidecars beside it.
+	dbPath := mgr.DBPath(webhookID)
+	require.FileExists(t, dbPath+"-wal")
+	require.FileExists(t, dbPath+"-shm")
+
 	// Delete the DB
 	require.NoError(t, mgr.DeleteDB(webhookID))
 
 	// File should no longer exist
 	assert.False(t, mgr.DBExists(webhookID))
 
-	// Verify the file is actually gone from disk
+	// Verify the files are actually gone from disk
+	assert.NoFileExists(t, dbPath)
+	assert.NoFileExists(t, dbPath+"-wal")
+	assert.NoFileExists(t, dbPath+"-shm")
+}
+
+// blockRemoval puts a non-empty directory at path, which os.Remove
+// cannot remove whoever runs the test, root included.
+func blockRemoval(t *testing.T, path string) {
+	t.Helper()
+
+	require.NoError(t, os.MkdirAll(filepath.Join(path, "keep"), 0o700))
+}
+
+// TestWebhookDBManager_DeleteDBKeepsDatabaseFile proves that when the
+// event database file cannot be removed, the error says so, and both
+// sidecars are still removed.
+func TestWebhookDBManager_DeleteDBKeepsDatabaseFile(t *testing.T) {
+	t.Parallel()
+
+	mgr, lc := setupTestWebhookDBManager(t)
+	ctx := context.Background()
+	require.NoError(t, lc.Start(ctx))
+
+	defer func() { require.NoError(t, lc.Stop(ctx)) }()
+
+	webhookID := uuid.New().String()
 	dbPath := mgr.DBPath(webhookID)
 
-	_, err = os.Stat(dbPath)
-	assert.True(t, os.IsNotExist(err))
+	blockRemoval(t, dbPath)
+	require.NoError(t, os.WriteFile(dbPath+"-wal", nil, 0o600))
+	require.NoError(t, os.WriteFile(dbPath+"-shm", nil, 0o600))
+
+	err := mgr.DeleteDB(webhookID)
+
+	require.ErrorIs(t, err, database.ErrEventDBNotRemoved)
+	require.NotErrorIs(t, err, database.ErrSidecarNotRemoved)
+	assert.Contains(t, err.Error(), dbPath)
+	assert.NoFileExists(t, dbPath+"-wal")
+	assert.NoFileExists(t, dbPath+"-shm")
+}
+
+// TestWebhookDBManager_DeleteDBKeepsSidecar proves that when the
+// event database file is removed but a sidecar is not, the error
+// says the database file is gone, and the other sidecar is still
+// removed.
+func TestWebhookDBManager_DeleteDBKeepsSidecar(t *testing.T) {
+	t.Parallel()
+
+	mgr, lc := setupTestWebhookDBManager(t)
+	ctx := context.Background()
+	require.NoError(t, lc.Start(ctx))
+
+	defer func() { require.NoError(t, lc.Stop(ctx)) }()
+
+	webhookID := uuid.New().String()
+	dbPath := mgr.DBPath(webhookID)
+
+	require.NoError(t, mgr.CreateDB(webhookID))
+	// Closing removes the sidecars, so the ones below are the only
+	// ones there.
+	require.NoError(t, mgr.CloseAll())
+
+	blockRemoval(t, dbPath+"-wal")
+	require.NoError(t, os.WriteFile(dbPath+"-shm", nil, 0o600))
+
+	err := mgr.DeleteDB(webhookID)
+
+	require.ErrorIs(t, err, database.ErrSidecarNotRemoved)
+	require.NotErrorIs(t, err, database.ErrEventDBNotRemoved)
+	assert.Contains(t, err.Error(), dbPath+"-wal")
+	assert.NoFileExists(t, dbPath)
+	assert.NoFileExists(t, dbPath+"-shm")
 }
 
 func TestWebhookDBManager_LazyCreation(t *testing.T) {
@@ -215,6 +291,76 @@ func TestWebhookDBManager_LazyCreation(t *testing.T) {
 	assert.True(t, mgr.DBExists(webhookID))
 }
 
+// A webhook's database is made by CreateDB along with the webhook. One
+// that GetDB finds missing or zero-length has lost the webhook's events
+// and pending deliveries, so the empty database made in its place is
+// logged as a warning naming the file
+// (https://git.eeqj.de/sneak/webhooker/issues/290). CreateDB, and
+// reopening a database that is there, log no such warning.
+func TestWebhookDBManager_LostDatabaseIsLogged(t *testing.T) {
+	t.Parallel()
+
+	const created = `level=WARN msg="created a new, empty database"`
+
+	open := func(
+		t *testing.T, prepare func(*database.WebhookDBManager, string),
+	) (string, string) {
+		t.Helper()
+
+		var logs bytes.Buffer
+
+		mgr := databasetest.NewWebhookDBManagerWithLogger(
+			t,
+			t.TempDir(),
+			slog.New(slog.NewTextHandler(&logs, nil)),
+		)
+
+		webhookID := uuid.New().String()
+		prepare(mgr, webhookID)
+
+		_, err := mgr.GetDB(webhookID)
+		require.NoError(t, err)
+		require.NoError(t, mgr.CloseAll())
+
+		return logs.String(),
+			" webhook_id=" + webhookID + " path=" + mgr.DBPath(webhookID)
+	}
+
+	t.Run("missing", func(t *testing.T) {
+		t.Parallel()
+
+		logs, fields := open(
+			t, func(*database.WebhookDBManager, string) {},
+		)
+		assert.Contains(t, logs, created+fields)
+	})
+
+	t.Run("zero-length", func(t *testing.T) {
+		t.Parallel()
+
+		logs, fields := open(
+			t, func(mgr *database.WebhookDBManager, webhookID string) {
+				require.NoError(t, os.WriteFile(
+					mgr.DBPath(webhookID), nil, database.SQLiteFilePerm,
+				))
+			},
+		)
+		assert.Contains(t, logs, created+fields)
+	})
+
+	t.Run("created with the webhook, then reopened", func(t *testing.T) {
+		t.Parallel()
+
+		logs, _ := open(
+			t, func(mgr *database.WebhookDBManager, webhookID string) {
+				require.NoError(t, mgr.CreateDB(webhookID))
+				require.NoError(t, mgr.CloseAll())
+			},
+		)
+		assert.NotContains(t, logs, created)
+	})
+}
+
 func TestWebhookDBManager_DeliveryWorkflow(t *testing.T) {
 	t.Parallel()
 

internal/db/migrations/archive/000_migration.sql

@@ -0,0 +1,9 @@
+-- Migration 000: the table recording which migrations this file has
+-- had. Applied before the others; it records itself.
+
+CREATE TABLE IF NOT EXISTS schema_migrations (
+    version INTEGER PRIMARY KEY,
+    applied_at DATETIME DEFAULT CURRENT_TIMESTAMP
+);
+
+INSERT OR IGNORE INTO schema_migrations (version) VALUES (0);

internal/db/migrations/archive/001_schema.sql

@@ -0,0 +1,18 @@
+-- Migration 001: the schema of a database target's archive file. The
+-- archivedEvent model in internal/archive must agree with it.
+
+CREATE TABLE archived_events (
+    id integer PRIMARY KEY AUTOINCREMENT,
+    event_id text,
+    webhook_id text,
+    entrypoint_id text,
+    method text,
+    raw_query text,
+    headers text,
+    body text,
+    content_type text,
+    archived_at datetime
+);
+
+CREATE INDEX idx_archived_events_event_id ON archived_events (event_id);
+CREATE INDEX idx_archived_events_archived_at ON archived_events (archived_at);

internal/db/migrations/events/000_migration.sql

@@ -0,0 +1,9 @@
+-- Migration 000: the table recording which migrations this file has
+-- had. Applied before the others; it records itself.
+
+CREATE TABLE IF NOT EXISTS schema_migrations (
+    version INTEGER PRIMARY KEY,
+    applied_at DATETIME DEFAULT CURRENT_TIMESTAMP
+);
+
+INSERT OR IGNORE INTO schema_migrations (version) VALUES (0);

internal/db/migrations/events/001_schema.sql

@@ -0,0 +1,98 @@
+-- Migration 001: the schema of a webhook's event database. The models
+-- in internal/database must agree with it. The webhook, entrypoint and
+-- target ids here name rows in the main database, which has those
+-- tables; this file does not.
+
+CREATE TABLE events (
+    id uuid,
+    created_at datetime,
+    updated_at datetime,
+    deleted_at datetime,
+    webhook_id uuid NOT NULL,
+    entrypoint_id uuid NOT NULL,
+    method text NOT NULL,
+    raw_query text,
+    headers text,
+    body text,
+    content_type text,
+    body_bytes integer NOT NULL,
+    resubmitted_from_id uuid,
+    PRIMARY KEY (id)
+);
+
+CREATE INDEX idx_events_created_at ON events (created_at);
+CREATE INDEX idx_events_deleted_at ON events (deleted_at);
+CREATE INDEX idx_events_deleted_at_created_at
+    ON events (deleted_at, created_at);
+CREATE INDEX idx_events_resubmitted_from_id
+    ON events (resubmitted_from_id, deleted_at);
+CREATE INDEX idx_events_entrypoint_id
+    ON events (entrypoint_id, deleted_at, resubmitted_from_id, created_at);
+
+CREATE TABLE deliveries (
+    id uuid,
+    created_at datetime,
+    updated_at datetime,
+    deleted_at datetime,
+    event_id uuid NOT NULL,
+    target_id uuid NOT NULL,
+    status text NOT NULL DEFAULT 'pending',
+    finished_at datetime,
+    replay numeric NOT NULL DEFAULT false,
+    PRIMARY KEY (id),
+    CONSTRAINT fk_events_deliveries
+        FOREIGN KEY (event_id) REFERENCES events (id)
+);
+
+CREATE INDEX idx_deliveries_deleted_at ON deliveries (deleted_at);
+CREATE INDEX idx_deliveries_event_id ON deliveries (event_id, deleted_at);
+CREATE INDEX idx_deliveries_status
+    ON deliveries (status, deleted_at, finished_at, target_id);
+
+CREATE TABLE delivery_results (
+    id uuid,
+    created_at datetime,
+    updated_at datetime,
+    deleted_at datetime,
+    delivery_id uuid NOT NULL,
+    attempt_num integer NOT NULL,
+    success numeric,
+    status_code integer,
+    response_body text,
+    error text,
+    duration integer,
+    PRIMARY KEY (id),
+    CONSTRAINT fk_deliveries_delivery_results
+        FOREIGN KEY (delivery_id) REFERENCES deliveries (id)
+);
+
+CREATE INDEX idx_delivery_results_deleted_at
+    ON delivery_results (deleted_at);
+CREATE INDEX idx_delivery_results_delivery_id
+    ON delivery_results (delivery_id, deleted_at);
+
+CREATE TABLE event_totals (
+    id integer PRIMARY KEY AUTOINCREMENT,
+    events integer NOT NULL,
+    events_removed integer NOT NULL,
+    last_event_at datetime
+);
+
+-- The one row of event totals, all zero.
+INSERT INTO event_totals (events, events_removed) VALUES (0, 0);
+
+CREATE TABLE target_totals (
+    target_id uuid,
+    deliveries integer NOT NULL,
+    delivered integer NOT NULL,
+    failed integer NOT NULL,
+    deliveries_removed integer NOT NULL,
+    failed_removed integer NOT NULL,
+    PRIMARY KEY (target_id)
+);
+
+CREATE TABLE entrypoint_totals (
+    entrypoint_id uuid,
+    last_event_at datetime NOT NULL,
+    PRIMARY KEY (entrypoint_id)
+);

internal/db/migrations/main/000_migration.sql

@@ -0,0 +1,9 @@
+-- Migration 000: the table recording which migrations this file has
+-- had. Applied before the others; it records itself.
+
+CREATE TABLE IF NOT EXISTS schema_migrations (
+    version INTEGER PRIMARY KEY,
+    applied_at DATETIME DEFAULT CURRENT_TIMESTAMP
+);
+
+INSERT OR IGNORE INTO schema_migrations (version) VALUES (0);

internal/db/migrations/main/001_schema.sql

@@ -0,0 +1,95 @@
+-- Migration 001: the main database's schema. The models in
+-- internal/database must agree with it.
+
+CREATE TABLE settings (
+    "key" text,
+    value text NOT NULL,
+    PRIMARY KEY ("key")
+);
+
+CREATE TABLE users (
+    id uuid,
+    created_at datetime,
+    updated_at datetime,
+    deleted_at datetime,
+    username text NOT NULL,
+    password text NOT NULL,
+    PRIMARY KEY (id),
+    CONSTRAINT chk_users_username
+        CHECK (length(CAST(username AS BLOB)) <= 1024)
+);
+
+CREATE INDEX idx_users_deleted_at ON users (deleted_at);
+CREATE UNIQUE INDEX idx_users_username ON users (username);
+
+CREATE TABLE api_keys (
+    id uuid,
+    created_at datetime,
+    updated_at datetime,
+    deleted_at datetime,
+    user_id uuid NOT NULL,
+    "key" text NOT NULL,
+    description text,
+    last_used_at datetime,
+    PRIMARY KEY (id),
+    CONSTRAINT fk_users_api_keys FOREIGN KEY (user_id) REFERENCES users (id)
+);
+
+CREATE INDEX idx_api_keys_deleted_at ON api_keys (deleted_at);
+CREATE UNIQUE INDEX idx_api_keys_key ON api_keys ("key");
+
+CREATE TABLE webhooks (
+    id uuid,
+    created_at datetime,
+    updated_at datetime,
+    deleted_at datetime,
+    user_id uuid NOT NULL,
+    name text NOT NULL,
+    description text,
+    retention_days integer,
+    PRIMARY KEY (id),
+    CONSTRAINT fk_users_webhooks FOREIGN KEY (user_id) REFERENCES users (id)
+);
+
+CREATE INDEX idx_webhooks_deleted_at ON webhooks (deleted_at);
+
+CREATE TABLE entrypoints (
+    id uuid,
+    created_at datetime,
+    updated_at datetime,
+    deleted_at datetime,
+    webhook_id uuid NOT NULL,
+    path text NOT NULL,
+    description text,
+    active numeric DEFAULT true,
+    PRIMARY KEY (id),
+    CONSTRAINT fk_webhooks_entrypoints
+        FOREIGN KEY (webhook_id) REFERENCES webhooks (id)
+);
+
+CREATE INDEX idx_entrypoints_deleted_at ON entrypoints (deleted_at);
+CREATE UNIQUE INDEX idx_entrypoints_path ON entrypoints (path);
+
+CREATE TABLE targets (
+    id uuid,
+    created_at datetime,
+    updated_at datetime,
+    deleted_at datetime,
+    webhook_id uuid NOT NULL,
+    name text NOT NULL,
+    type text NOT NULL,
+    active numeric DEFAULT true,
+    url text,
+    headers text,
+    timeout_seconds integer,
+    forward_query numeric,
+    archive_expiry integer,
+    archive_rotation text,
+    max_attempts integer NOT NULL,
+    PRIMARY KEY (id),
+    CONSTRAINT fk_webhooks_targets
+        FOREIGN KEY (webhook_id) REFERENCES webhooks (id),
+    CONSTRAINT chk_targets_max_attempts CHECK (max_attempts >= 1)
+);
+
+CREATE INDEX idx_targets_deleted_at ON targets (deleted_at);

internal/db/migrations/migrations.go

@@ -0,0 +1,135 @@
+// Package migrations holds the schema of each kind of SQLite file
+// webhooker writes, as numbered SQL files embedded in the binary, and
+// applies it when a file is opened.
+//
+// Each kind of file has its own directory. In each, 000_migration.sql
+// creates only the schema_migrations table, and 001_schema.sql holds
+// the whole schema. Before 1.0 a schema change is an edit to
+// 001_schema.sql, never a new file.
+package migrations
+
+import (
+	"embed"
+	"fmt"
+	"io/fs"
+	"path"
+	"strconv"
+	"strings"
+
+	"gorm.io/gorm"
+)
+
+// The directories, one for each kind of database file.
+const (
+	// Main is the main database, webhooker.db.
+	Main = "main"
+
+	// Events is a webhook's event database, events-{uuid}.db.
+	Events = "events"
+
+	// Archive is a database target's archive file.
+	Archive = "archive"
+)
+
+//go:embed main/*.sql events/*.sql archive/*.sql
+var files embed.FS
+
+// Apply runs each SQL file in dir, which is Main, Events or Archive,
+// that the database has not had yet, in the order of the number its
+// name starts with, and records that number in schema_migrations.
+// 000_migration.sql creates that table and records itself, so it runs
+// first, and only when the table is missing.
+//
+// It all runs in one transaction, so a failure leaves the file as it
+// was.
+func Apply(db *gorm.DB, dir string) error {
+	return db.Transaction(func(tx *gorm.DB) error {
+		var tables int
+
+		// Row().Scan, not (*gorm.DB).Scan: see internal/gormlog.
+		err := tx.Raw(
+			"SELECT count(*) FROM sqlite_master "+
+				"WHERE type = 'table' AND name = ?",
+			"schema_migrations",
+		).Row().Scan(&tables)
+		if err != nil {
+			return fmt.Errorf("looking for schema_migrations: %w", err)
+		}
+
+		if tables == 0 {
+			err = run(tx, path.Join(dir, "000_migration.sql"))
+			if err != nil {
+				return err
+			}
+		}
+
+		// fs.Glob lists the files in name order, which is number order.
+		names, err := fs.Glob(files, path.Join(dir, "*.sql"))
+		if err != nil {
+			return fmt.Errorf("listing migrations: %w", err)
+		}
+
+		for _, name := range names {
+			err = applyOnce(tx, name)
+			if err != nil {
+				return err
+			}
+		}
+
+		return nil
+	})
+}
+
+// applyOnce runs the migration file name and records its number,
+// unless schema_migrations already has that number.
+func applyOnce(tx *gorm.DB, name string) error {
+	number, _, _ := strings.Cut(path.Base(name), "_")
+
+	version, err := strconv.Atoi(number)
+	if err != nil {
+		return fmt.Errorf("numbering migration %s: %w", name, err)
+	}
+
+	var applied int
+
+	err = tx.Raw(
+		"SELECT count(*) FROM schema_migrations WHERE version = ?",
+		version,
+	).Row().Scan(&applied)
+	if err != nil {
+		return fmt.Errorf("checking migration %s: %w", name, err)
+	}
+
+	if applied > 0 {
+		return nil
+	}
+
+	err = run(tx, name)
+	if err != nil {
+		return err
+	}
+
+	err = tx.Exec(
+		"INSERT INTO schema_migrations (version) VALUES (?)", version,
+	).Error
+	if err != nil {
+		return fmt.Errorf("recording migration %s: %w", name, err)
+	}
+
+	return nil
+}
+
+// run executes every statement in the migration file name.
+func run(tx *gorm.DB, name string) error {
+	script, err := files.ReadFile(name)
+	if err != nil {
+		return fmt.Errorf("reading migration %s: %w", name, err)
+	}
+
+	err = tx.Exec(string(script)).Error
+	if err != nil {
+		return fmt.Errorf("applying migration %s: %w", name, err)
+	}
+
+	return nil
+}

internal/db/migrations/migrations_test.go

@@ -0,0 +1,57 @@
+package migrations_test
+
+import (
+	"database/sql"
+	"log/slog"
+	"path/filepath"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"gorm.io/driver/sqlite"
+	"gorm.io/gorm"
+	_ "modernc.org/sqlite"
+	"sneak.berlin/go/webhooker/internal/db/migrations"
+	"sneak.berlin/go/webhooker/internal/gormlog"
+)
+
+// TestApplyRunsEachFileOnce applies each kind of database file's
+// migrations to a new file twice. The first time records every file.
+// The second finds them all recorded and runs none, which is the only
+// way it can succeed: 001_schema.sql creates tables that then exist.
+func TestApplyRunsEachFileOnce(t *testing.T) {
+	t.Parallel()
+
+	for _, dir := range []string{
+		migrations.Main, migrations.Events, migrations.Archive,
+	} {
+		t.Run(dir, func(t *testing.T) {
+			t.Parallel()
+
+			sqlDB, err := sql.Open(
+				"sqlite", filepath.Join(t.TempDir(), "test.db"),
+			)
+			require.NoError(t, err)
+
+			t.Cleanup(func() { _ = sqlDB.Close() })
+
+			db, err := gorm.Open(
+				sqlite.Dialector{Conn: sqlDB},
+				&gorm.Config{
+					Logger: gormlog.New(slog.New(slog.DiscardHandler)),
+				},
+			)
+			require.NoError(t, err)
+
+			require.NoError(t, migrations.Apply(db, dir))
+			require.NoError(t, migrations.Apply(db, dir))
+
+			var versions string
+
+			require.NoError(t, sqlDB.QueryRowContext(t.Context(),
+				"SELECT group_concat(version) FROM schema_migrations",
+			).Scan(&versions))
+			assert.Equal(t, "0,1", versions)
+		})
+	}
+}

internal/delivery/circuit_breaker.go

@@ -102,6 +102,20 @@ func (cb *CircuitBreaker) CooldownRemaining() time.Duration {
 	return remaining
 }
 
+// StateAndCooldown returns the circuit state and, while the circuit is
+// open, what is left of the cooldown, or zero once that has passed.
+// Both are read under one lock, so they always agree.
+func (cb *CircuitBreaker) StateAndCooldown() (CircuitState, time.Duration) {
+	cb.mu.Lock()
+	defer cb.mu.Unlock()
+
+	if cb.state != CircuitOpen {
+		return cb.state, 0
+	}
+
+	return cb.state, max(cb.cooldown-time.Since(cb.lastFailure), 0)
+}
+
 // RecordSuccess records a successful delivery and resets
 // the circuit breaker to closed state.
 func (cb *CircuitBreaker) RecordSuccess() {

internal/delivery/client_ssrf_test.go

@@ -46,12 +46,7 @@ func TestClientForRequest_TimeoutKeepsSSRFGuard(t *testing.T) {
 		t.Run(target, func(t *testing.T) {
 			t.Parallel()
 
-			cfg := &delivery.HTTPTargetConfig{
-				URL:     target,
-				Timeout: 5,
-			}
-
-			client := engine.ExportClientForRequest(cfg, nil)
+			client := engine.ExportClientForRequest(5, nil)
 
 			require.NotSame(t, engine.ExportClient(), client,
 				"a per-target timeout must yield a "+
@@ -101,11 +96,7 @@ func TestClientForRequest_NoTimeoutUnchanged(t *testing.T) {
 
 	engine := newSSRFTestEngine()
 
-	cfg := &delivery.HTTPTargetConfig{
-		URL: "https://example.com/hook",
-	}
-
-	client := engine.ExportClientForRequest(cfg, nil)
+	client := engine.ExportClientForRequest(0, nil)
 
 	assert.Same(t, engine.ExportClient(), client,
 		"without a per-target timeout the shared client "+
@@ -123,15 +114,8 @@ func TestClientForRequest_HeadersKeepSSRFGuard(t *testing.T) {
 
 	engine := newSSRFTestEngine()
 
-	cfg := &delivery.HTTPTargetConfig{
-		URL: "https://example.com/with-headers",
-		Headers: map[string]string{
-			"X-Api-Key": "configured",
-		},
-	}
-
 	client := engine.ExportClientForRequest(
-		cfg, []string{"X-Api-Key"},
+		0, []string{probeHeaderName},
 	)
 
 	require.NotNil(t, client.CheckRedirect,

internal/delivery/delivery_totals_test.go

@@ -0,0 +1,188 @@
+package delivery_test
+
+import (
+	"testing"
+	"time"
+
+	"github.com/google/uuid"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"gorm.io/gorm"
+	"sneak.berlin/go/webhooker/internal/database"
+)
+
+// targetTotals reads one target's totals from a webhook database, all
+// zero when it has no row.
+func targetTotals(
+	t *testing.T, db *gorm.DB, targetID string,
+) database.TargetTotals {
+	t.Helper()
+
+	var rows []database.TargetTotals
+
+	require.NoError(t, db.Where("target_id = ?", targetID).
+		Find(&rows).Error)
+
+	if len(rows) == 0 {
+		return database.TargetTotals{TargetID: targetID}
+	}
+
+	return rows[0]
+}
+
+// TestUpdateDeliveryStatus_FinishTimeAndTargetTotals pins what a status
+// write records for the webhook page's statistics: the time a delivery
+// finished, set only when it becomes delivered or failed and stored in
+// the same form as created_at, and one more on its target's delivered
+// or failed total.
+func TestUpdateDeliveryStatus_FinishTimeAndTargetTotals(t *testing.T) {
+	t.Parallel()
+
+	tests := []struct {
+		status    database.DeliveryStatus
+		finished  bool
+		delivered int64
+		failed    int64
+	}{
+		{database.DeliveryStatusRetrying, false, 0, 0},
+		{database.DeliveryStatusDelivered, true, 1, 0},
+		{database.DeliveryStatusFailed, true, 0, 1},
+	}
+
+	for _, tt := range tests {
+		t.Run(string(tt.status), func(t *testing.T) {
+			t.Parallel()
+
+			db := testWebhookDB(t)
+			e := testEngine(t, 1)
+			event := seedEvent(t, db, `{}`)
+			targetID := uuid.New().String()
+			d := seedDelivery(
+				t, db, event.ID, targetID,
+				database.DeliveryStatusPending,
+			)
+
+			before := time.Now()
+
+			require.NoError(t, e.ExportUpdateDeliveryStatus(
+				db, &d, tt.status,
+			))
+
+			var stored database.Delivery
+
+			require.NoError(t, db.First(&stored, "id = ?", d.ID).Error)
+			assert.Equal(t, tt.status, stored.Status)
+
+			if tt.finished {
+				require.NotNil(t, stored.FinishedAt)
+				assert.False(t, stored.FinishedAt.Before(before))
+
+				var createdAt, finishedAt string
+
+				require.NoError(t, db.Raw(
+					`SELECT CAST(created_at AS TEXT),
+						CAST(finished_at AS TEXT)
+					FROM deliveries WHERE id = ?`, d.ID,
+				).Row().Scan(&createdAt, &finishedAt))
+				assertStoredTime(t, createdAt)
+				assertStoredTime(t, finishedAt)
+			} else {
+				assert.Nil(t, stored.FinishedAt)
+			}
+
+			assert.Equal(t, database.TargetTotals{
+				TargetID:  targetID,
+				Delivered: tt.delivered,
+				Failed:    tt.failed,
+			}, targetTotals(t, db, targetID))
+		})
+	}
+}
+
+// TestUpdateDeliveryStatus_DeletedDeliveryIsNotCounted covers a
+// delivery retention deleted while the engine still held it. Failing
+// it afterwards writes no row, so it adds no failure either: retention
+// has already counted what it removed.
+func TestUpdateDeliveryStatus_DeletedDeliveryIsNotCounted(t *testing.T) {
+	t.Parallel()
+
+	db := testWebhookDB(t)
+	e := testEngine(t, 1)
+	event := seedEvent(t, db, `{}`)
+	targetID := uuid.New().String()
+	d := seedDelivery(
+		t, db, event.ID, targetID,
+		database.DeliveryStatusRetrying,
+	)
+
+	require.NoError(t, db.Unscoped().
+		Delete(&database.Delivery{}, "id = ?", d.ID).Error)
+
+	require.NoError(t, e.ExportUpdateDeliveryStatus(
+		db, &d, database.DeliveryStatusFailed,
+	))
+
+	assert.Equal(t, database.TargetTotals{TargetID: targetID},
+		targetTotals(t, db, targetID))
+}
+
+// TestUpdateDeliveryStatus_FinishedDeliveryIsNotSettledAgain covers a
+// delivery settled a second time, as recovery can do when a worker has
+// settled it since recovery read it. Neither status writes over the
+// first, and the totals do not move.
+func TestUpdateDeliveryStatus_FinishedDeliveryIsNotSettledAgain(
+	t *testing.T,
+) {
+	t.Parallel()
+
+	finished := []database.DeliveryStatus{
+		database.DeliveryStatusDelivered,
+		database.DeliveryStatusFailed,
+	}
+
+	for _, first := range finished {
+		t.Run(string(first), func(t *testing.T) {
+			t.Parallel()
+
+			db := testWebhookDB(t)
+			e := testEngine(t, 1)
+			event := seedEvent(t, db, `{}`)
+			targetID := uuid.New().String()
+			d := seedDelivery(
+				t, db, event.ID, targetID,
+				database.DeliveryStatusRetrying,
+			)
+
+			// The delivery as recovery read it, before the worker
+			// settled it.
+			readBefore := d
+
+			require.NoError(t, e.ExportUpdateDeliveryStatus(
+				db, &d, first,
+			))
+
+			var settled database.Delivery
+
+			require.NoError(t, db.First(&settled, "id = ?", d.ID).Error)
+			require.NotNil(t, settled.FinishedAt)
+
+			totals := targetTotals(t, db, targetID)
+
+			for _, again := range finished {
+				stale := readBefore
+
+				require.NoError(t, e.ExportUpdateDeliveryStatus(
+					db, &stale, again,
+				))
+			}
+
+			var stored database.Delivery
+
+			require.NoError(t, db.First(&stored, "id = ?", d.ID).Error)
+			assert.Equal(t, first, stored.Status)
+			require.NotNil(t, stored.FinishedAt)
+			assert.True(t, settled.FinishedAt.Equal(*stored.FinishedAt))
+			assert.Equal(t, totals, targetTotals(t, db, targetID))
+		})
+	}
+}

internal/delivery/engine_integration_test.go

@@ -1,15 +1,14 @@
 package delivery_test
 
 import (
+	"bytes"
 	"context"
-	"encoding/json"
 	"fmt"
 	"io"
 	"log/slog"
 	"net/http"
 	"net/http/httptest"
 	"os"
-	"path/filepath"
 	"strings"
 	"sync/atomic"
 	"testing"
@@ -18,10 +17,10 @@ import (
 	"github.com/google/uuid"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
-	"gorm.io/driver/sqlite"
 	"gorm.io/gorm"
 	_ "modernc.org/sqlite"
 	"sneak.berlin/go/webhooker/internal/database"
+	"sneak.berlin/go/webhooker/internal/database/databasetest"
 	"sneak.berlin/go/webhooker/internal/delivery"
 )
 
@@ -43,12 +42,12 @@ func newISetup(t *testing.T) iSetup {
 	wDB := iSeedWebhookDB(t, dbMgr, wID)
 
 	return iSetup{
-		MainDB:    mainDB,
+		MainDB:    mainDB.DB(),
 		DBMgr:     dbMgr,
 		WebhookID: wID,
 		WebhookDB: wDB,
 		Engine: delivery.NewTestEngineWithDB(
-			database.NewTestDatabase(mainDB),
+			mainDB,
 			dbMgr,
 			slog.New(slog.NewTextHandler(
 				os.Stderr,
@@ -62,34 +61,16 @@ func newISetup(t *testing.T) iSetup {
 	}
 }
 
-func iMainDB(t *testing.T) *gorm.DB {
+// iMainDB opens a main database through database.Open, the way the
+// service opens it, so these tests cannot pass against journal and
+// locking settings production does not use.
+func iMainDB(t *testing.T) *database.Database {
 	t.Helper()
 
-	dbPath := filepath.Join(
-		t.TempDir(), "main-test.db",
-	)
-
-	// Opened the way the service opens the main database, so these
-	// tests cannot pass against journal and locking settings
-	// production does not use.
-	sqlDB, err := database.OpenSQLite(
-		dbPath, database.SQLiteModeCreate,
-	)
+	db, err := database.Open(t.TempDir(), slog.New(slog.DiscardHandler))
 	require.NoError(t, err)
 
-	t.Cleanup(func() { _ = sqlDB.Close() })
-
-	db, err := gorm.Open(
-		sqlite.Dialector{Conn: sqlDB}, &gorm.Config{},
-	)
-	require.NoError(t, err)
-
-	require.NoError(t, db.AutoMigrate(
-		&database.Webhook{},
-		&database.Target{},
-		&database.User{},
-		&database.Setting{},
-	))
+	t.Cleanup(func() { _ = db.Close() })
 
 	return db
 }
@@ -99,7 +80,7 @@ func iDBManager(
 ) *database.WebhookDBManager {
 	t.Helper()
 
-	return database.NewTestWebhookDBManager(t.TempDir())
+	return databasetest.NewWebhookDBManager(t, t.TempDir())
 }
 
 func iSeedWebhookDB(
@@ -115,17 +96,6 @@ func iSeedWebhookDB(
 	return db
 }
 
-func iHTTPConfig(url string) string {
-	cfg := delivery.HTTPTargetConfig{URL: url}
-
-	data, err := json.Marshal(cfg)
-	if err != nil {
-		panic("failed to marshal HTTPTargetConfig")
-	}
-
-	return string(data)
-}
-
 func iEngine(
 	t *testing.T, workers int,
 ) *delivery.Engine {
@@ -187,24 +157,24 @@ func iSeedDelivery(
 func iTask(
 	d database.Delivery,
 	event database.Event,
-	webhookID, targetID, name, config string,
-	maxRetries, attemptNum int,
+	webhookID, targetID, name, targetURL string,
+	maxAttempts, attemptNum int,
 	body *string,
 ) delivery.Task {
 	return delivery.Task{
-		DeliveryID:   d.ID,
-		EventID:      event.ID,
-		WebhookID:    webhookID,
-		TargetID:     targetID,
-		TargetName:   name,
-		TargetType:   database.TargetTypeHTTP,
-		TargetConfig: config,
-		MaxRetries:   maxRetries,
-		Method:       event.Method,
-		Headers:      event.Headers,
-		ContentType:  event.ContentType,
-		Body:         body,
-		AttemptNum:   attemptNum,
+		DeliveryID:  d.ID,
+		EventID:     event.ID,
+		WebhookID:   webhookID,
+		TargetID:    targetID,
+		TargetName:  name,
+		TargetType:  database.TargetTypeHTTP,
+		TargetURL:   targetURL,
+		MaxAttempts: maxAttempts,
+		Method:      event.Method,
+		Headers:     event.Headers,
+		ContentType: event.ContentType,
+		Body:        body,
+		AttemptNum:  attemptNum,
 	}
 }
 
@@ -257,10 +227,9 @@ func TestProcessNewTask_InlineBody(t *testing.T) {
 	)
 
 	bodyStr := event.Body
-	cfg := iHTTPConfig(ts.URL)
 	task := iTask(
 		d, event, s.WebhookID, targetID,
-		"test-target", cfg, 0, 1, &bodyStr,
+		"test-target", ts.URL, 1, 1, &bodyStr,
 	)
 
 	s.Engine.ExportProcessNewTask(
@@ -308,10 +277,9 @@ func TestProcessNewTask_LargeBody_FetchFromDB(
 		database.DeliveryStatusPending,
 	)
 
-	cfg := iHTTPConfig(ts.URL)
 	task := iTask(
 		d, event, s.WebhookID, targetID,
-		"test-large", cfg, 0, 1, nil,
+		"test-large", ts.URL, 1, 1, nil,
 	)
 
 	s.Engine.ExportProcessNewTask(
@@ -331,16 +299,16 @@ func TestProcessNewTask_InvalidWebhookID(t *testing.T) {
 	s := newISetup(t)
 
 	task := delivery.Task{
-		DeliveryID:   uuid.New().String(),
-		EventID:      uuid.New().String(),
-		WebhookID:    uuid.New().String(),
-		TargetID:     uuid.New().String(),
-		TargetName:   "test",
-		TargetType:   database.TargetTypeHTTP,
-		TargetConfig: iHTTPConfig("http://localhost:9999"),
-		MaxRetries:   0,
-		Body:         nil,
-		AttemptNum:   1,
+		DeliveryID:  uuid.New().String(),
+		EventID:     uuid.New().String(),
+		WebhookID:   uuid.New().String(),
+		TargetID:    uuid.New().String(),
+		TargetName:  "test",
+		TargetType:  database.TargetTypeHTTP,
+		TargetURL:   "http://localhost:9999",
+		MaxAttempts: 1,
+		Body:        nil,
+		AttemptNum:  1,
 	}
 
 	s.Engine.ExportProcessNewTask(
@@ -355,9 +323,14 @@ func TestProcessRetryTask_SuccessfulRetry(t *testing.T) {
 
 	s := newISetup(t)
 
+	var receivedBody string
+
 	ts := httptest.NewServer(
 		http.HandlerFunc(
-			func(w http.ResponseWriter, _ *http.Request) {
+			func(w http.ResponseWriter, r *http.Request) {
+				body, _ := io.ReadAll(r.Body)
+				receivedBody = string(body)
+
 				w.WriteHeader(http.StatusOK)
 			},
 		),
@@ -376,7 +349,6 @@ func TestProcessRetryTask_SuccessfulRetry(t *testing.T) {
 	)
 
 	bodyStr := event.Body
-	cfg := iHTTPConfig(ts.URL)
 
 	// The target row exists because the engine confirms a scheduled
 	// retry's target has not been deleted before it runs it. A retry
@@ -385,18 +357,20 @@ func TestProcessRetryTask_SuccessfulRetry(t *testing.T) {
 	// task. See https://git.eeqj.de/sneak/webhooker/issues/107.
 	iCreateTarget(
 		t, s.MainDB, targetID, s.WebhookID, "retry-target",
-		database.TargetTypeHTTP, cfg, 5,
+		database.TargetTypeHTTP, ts.URL, 5,
 	)
 
 	task := iTask(
 		d, event, s.WebhookID, targetID,
-		"retry-target", cfg, 5, 2, &bodyStr,
+		"retry-target", ts.URL, 5, 2, &bodyStr,
 	)
 
 	s.Engine.ExportProcessRetryTask(
 		context.TODO(), &task,
 	)
 
+	assert.Equal(t, event.Body, receivedBody)
+
 	iAssertStatus(t, s.WebhookDB, d.ID,
 		database.DeliveryStatusDelivered,
 	)
@@ -421,10 +395,9 @@ func TestProcessRetryTask_SkipsNonRetryingDelivery(
 	)
 
 	bodyStr := event.Body
-	cfg := iHTTPConfig("http://localhost:1")
 	task := iTask(
 		d, event, s.WebhookID, targetID,
-		"skip-target", cfg, 5, 2, &bodyStr,
+		"skip-target", "http://localhost:1", 5, 2, &bodyStr,
 	)
 
 	s.Engine.ExportProcessRetryTask(
@@ -443,9 +416,14 @@ func TestProcessRetryTask_LargeBody_FetchFromDB(
 
 	s := newISetup(t)
 
+	var receivedBody string
+
 	ts := httptest.NewServer(
 		http.HandlerFunc(
-			func(w http.ResponseWriter, _ *http.Request) {
+			func(w http.ResponseWriter, r *http.Request) {
+				body, _ := io.ReadAll(r.Body)
+				receivedBody = string(body)
+
 				w.WriteHeader(http.StatusOK)
 			},
 		),
@@ -466,22 +444,22 @@ func TestProcessRetryTask_LargeBody_FetchFromDB(
 		database.DeliveryStatusRetrying,
 	)
 
-	cfg := iHTTPConfig(ts.URL)
-
 	iCreateTarget(
 		t, s.MainDB, targetID, s.WebhookID, "retry-large",
-		database.TargetTypeHTTP, cfg, 5,
+		database.TargetTypeHTTP, ts.URL, 5,
 	)
 
 	task := iTask(
 		d, event, s.WebhookID, targetID,
-		"retry-large", cfg, 5, 2, nil,
+		"retry-large", ts.URL, 5, 2, nil,
 	)
 
 	s.Engine.ExportProcessRetryTask(
 		context.TODO(), &task,
 	)
 
+	assert.Equal(t, largeBody, receivedBody)
+
 	iAssertStatus(t, s.WebhookDB, d.ID,
 		database.DeliveryStatusDelivered,
 	)
@@ -510,11 +488,11 @@ func TestWorkerLifecycle_StartStop(t *testing.T) {
 	task := iTask(
 		d, event, s.WebhookID, targetID,
 		"lifecycle-test", "",
-		0, 1, &bodyStr,
+		1, 1, &bodyStr,
 	)
 	task.TargetType = database.TargetTypeLog
 
-	s.Engine.Notify([]delivery.Task{task})
+	s.Engine.ExportNotify([]delivery.Task{task})
 
 	iWaitForDelivered(t, s.WebhookDB, d.ID)
 
@@ -574,16 +552,15 @@ func TestWorkerLifecycle_ProcessesRetryChannel(
 	s.Engine.ExportStart()
 
 	bodyStr := event.Body
-	cfg := iHTTPConfig(ts.URL)
 
 	iCreateTarget(
 		t, s.MainDB, targetID, s.WebhookID, "retry-chan-test",
-		database.TargetTypeHTTP, cfg, 5,
+		database.TargetTypeHTTP, ts.URL, 5,
 	)
 
 	task := iTask(
 		d, event, s.WebhookID, targetID,
-		"retry-chan-test", cfg, 5, 2, &bodyStr,
+		"retry-chan-test", ts.URL, 5, 2, &bodyStr,
 	)
 
 	s.Engine.ExportRetryCh() <- task
@@ -649,16 +626,21 @@ func TestRecoverPendingDeliveries(t *testing.T) {
 
 	iCreateTarget(t, s.MainDB, targetID,
 		s.WebhookID, "recovery-target",
-		database.TargetTypeLog, "", 0,
+		database.TargetTypeLog, "", 1,
 	)
 
 	iSeedPendingDeliveries(
 		t, s.WebhookDB, s.WebhookID, targetID, 3,
 	)
 
+	// A recovered delivery still carries its event's query string.
+	require.NoError(t, s.WebhookDB.Model(&database.Event{}).
+		Where("webhook_id = ?", s.WebhookID).
+		Update("raw_query", eventQuery).Error)
+
 	s.Engine.ExportRecoverPendingDeliveries(
 		context.Background(), s.WebhookDB,
-		s.WebhookID,
+		s.WebhookID, atStart,
 	)
 
 	for i := range 3 {
@@ -670,6 +652,8 @@ func TestRecoverPendingDeliveries(t *testing.T) {
 				database.TargetTypeLog,
 				task.TargetType,
 			)
+
+			assert.Equal(t, eventQuery, task.RawQuery)
 		case <-time.After(2 * time.Second):
 			t.Fatalf("expected task %d", i)
 		}
@@ -682,18 +666,18 @@ func iCreateTarget(
 	mainDB *gorm.DB,
 	targetID, webhookID, name string,
 	targetType database.TargetType,
-	config string,
-	maxRetries int,
+	targetURL string,
+	maxAttempts int,
 ) {
 	t.Helper()
 
 	target := database.Target{
-		WebhookID:  webhookID,
-		Name:       name,
-		Type:       targetType,
-		Active:     true,
-		Config:     config,
-		MaxRetries: maxRetries,
+		WebhookID:   webhookID,
+		Name:        name,
+		Type:        targetType,
+		Active:      true,
+		URL:         targetURL,
+		MaxAttempts: maxAttempts,
 	}
 	target.ID = targetID
 
@@ -733,7 +717,7 @@ func TestRecoverWebhookDeliveries_RetryingDeliveries(
 	iCreateTarget(t, s.MainDB, targetID,
 		s.WebhookID, "retry-recovery",
 		database.TargetTypeHTTP,
-		iHTTPConfig("http://example.com/hook"), 5,
+		"http://example.com/hook", 5,
 	)
 
 	event := iSeedEvent(
@@ -753,7 +737,7 @@ func TestRecoverWebhookDeliveries_RetryingDeliveries(
 	)
 
 	s.Engine.ExportRecoverWebhookDeliveries(
-		context.Background(), s.WebhookID,
+		context.Background(), s.WebhookID, atStart,
 	)
 
 	select {
@@ -793,7 +777,7 @@ func iSeedRetryingWithType(
 
 	iCreateTarget(t, s.MainDB, targetID,
 		s.WebhookID, "mutated-target", targetType,
-		iHTTPConfig("http://example.com/hook"), 5,
+		"http://example.com/hook", 5,
 	)
 
 	event := iSeedEvent(
@@ -877,7 +861,7 @@ func TestRecoverSingleRetry_TypeNoLongerRetries(
 	)
 
 	s.Engine.ExportRecoverWebhookDeliveries(
-		context.Background(), s.WebhookID,
+		context.Background(), s.WebhookID, atStart,
 	)
 
 	iAssertTerminallyFailed(
@@ -885,7 +869,7 @@ func TestRecoverSingleRetry_TypeNoLongerRetries(
 	)
 }
 
-func TestSweepSingleRetry_TypeNoLongerRetries(
+func TestRecoverSingleRetry_OnTick_TypeNoLongerRetries(
 	t *testing.T,
 ) {
 	t.Parallel()
@@ -900,8 +884,8 @@ func TestSweepSingleRetry_TypeNoLongerRetries(
 		t, s, database.TargetTypeDatabase,
 	)
 
-	s.Engine.ExportSweepWebhookRetries(
-		context.Background(), s.WebhookID,
+	s.Engine.ExportRecoverWebhookDeliveries(
+		context.Background(), s.WebhookID, onTick,
 	)
 
 	iAssertTerminallyFailed(
@@ -931,14 +915,14 @@ func TestFailUnretryableRetry_WritesNoTargetRow(
 
 	targetID := uuid.New().String()
 
-	// A Slack incoming-webhook URL: the target config IS the
+	// A Slack incoming-webhook URL: the target's URL IS the
 	// credential, which is what makes a leaked target row a
 	// disclosure rather than a curiosity.
 	hookURL := "https://hooks.slack.com/services/T00/B00/x"
 
 	iCreateTarget(t, s.MainDB, targetID,
 		s.WebhookID, "credential-bearing",
-		database.TargetTypeLog, iHTTPConfig(hookURL), 5,
+		database.TargetTypeLog, hookURL, 5,
 	)
 
 	event := iSeedEvent(
@@ -952,37 +936,20 @@ func TestFailUnretryableRetry_WritesNoTargetRow(
 
 	iSeedFailedResult(t, s.WebhookDB, d.ID)
 
-	s.Engine.ExportSweepWebhookRetries(
-		context.Background(), s.WebhookID,
+	s.Engine.ExportRecoverWebhookDeliveries(
+		context.Background(), s.WebhookID, onTick,
 	)
 
 	iAssertStatus(t, s.WebhookDB, d.ID,
 		database.DeliveryStatusFailed,
 	)
 
-	// The table exists in the per-webhook database because GORM
-	// migrates the Delivery relation's model alongside it. It must
-	// stay empty.
-	var targetRows int64
-
-	require.NoError(t, s.WebhookDB.
-		Table("targets").
-		Count(&targetRows).Error)
-
-	assert.Zero(t, targetRows,
+	// The per-webhook database has no targets table, so writing a
+	// target row there would have failed the status write above.
+	assert.False(t, s.WebhookDB.Migrator().HasTable("targets"),
 		"orphaned-retry terminal failure wrote a target row "+
 			"into the per-webhook event database",
 	)
-
-	var configs []string
-
-	require.NoError(t, s.WebhookDB.
-		Table("targets").
-		Pluck("config", &configs).Error)
-
-	assert.NotContains(
-		t, strings.Join(configs, " "), hookURL,
-	)
 }
 
 func TestRecoverSingleRetry_UnknownTargetType(
@@ -1001,13 +968,13 @@ func TestRecoverSingleRetry_UnknownTargetType(
 	deliveryID := iSeedRetryingWithType(t, s, unknown)
 
 	s.Engine.ExportRecoverWebhookDeliveries(
-		context.Background(), s.WebhookID,
+		context.Background(), s.WebhookID, atStart,
 	)
 
 	iAssertTerminallyFailed(t, s, deliveryID, unknown)
 }
 
-func TestSweepSingleRetry_UnknownTargetType(
+func TestRecoverSingleRetry_OnTick_UnknownTargetType(
 	t *testing.T,
 ) {
 	t.Parallel()
@@ -1022,8 +989,8 @@ func TestSweepSingleRetry_UnknownTargetType(
 
 	deliveryID := iSeedRetryingWithType(t, s, unknown)
 
-	s.Engine.ExportSweepWebhookRetries(
-		context.Background(), s.WebhookID,
+	s.Engine.ExportRecoverWebhookDeliveries(
+		context.Background(), s.WebhookID, onTick,
 	)
 
 	iAssertTerminallyFailed(t, s, deliveryID, unknown)
@@ -1065,19 +1032,19 @@ func iCreateWebhook(
 	require.NoError(t, mainDB.Create(&webhook).Error)
 }
 
-// --- recoverInFlight Tests ---
+// --- recoverDeliveries Tests ---
 
-func TestRecoverInFlight_NoWebhooks(t *testing.T) {
+func TestRecoverDeliveries_NoWebhooks(t *testing.T) {
 	t.Parallel()
 
 	s := newISetup(t)
 
-	s.Engine.ExportRecoverInFlight(
-		context.Background(),
+	s.Engine.ExportRecoverDeliveries(
+		context.Background(), atStart,
 	)
 }
 
-func TestRecoverInFlight_WithPendingDeliveries(
+func TestRecoverDeliveries_WithPendingDeliveries(
 	t *testing.T,
 ) {
 	t.Parallel()
@@ -1091,7 +1058,7 @@ func TestRecoverInFlight_WithPendingDeliveries(
 
 	iCreateTarget(t, s.MainDB, targetID,
 		s.WebhookID, "recover-target",
-		database.TargetTypeLog, "", 0,
+		database.TargetTypeLog, "", 1,
 	)
 
 	event := iSeedEvent(
@@ -1104,8 +1071,8 @@ func TestRecoverInFlight_WithPendingDeliveries(
 		database.DeliveryStatusPending,
 	)
 
-	s.Engine.ExportRecoverInFlight(
-		context.Background(),
+	s.Engine.ExportRecoverDeliveries(
+		context.Background(), atStart,
 	)
 
 	select {
@@ -1116,11 +1083,91 @@ func TestRecoverInFlight_WithPendingDeliveries(
 			database.TargetTypeLog, task.TargetType,
 		)
 	case <-time.After(2 * time.Second):
-		t.Fatal("expected task from recoverInFlight")
+		t.Fatal("expected task from recovery at start")
 	}
 }
 
-// --- HTTP Config with custom headers ---
+// TestRecoverDeliveries_ReportsAMissingWebhookDatabase covers a webhook
+// whose database file is gone, after a partial restore say. Recovery at
+// start opens every webhook's database, so the empty one made in its
+// place is reported at start, naming the file
+// (https://git.eeqj.de/sneak/webhooker/issues/290).
+func TestRecoverDeliveries_ReportsAMissingWebhookDatabase(t *testing.T) {
+	t.Parallel()
+
+	mainDB := iMainDB(t)
+	webhookID := uuid.New().String()
+	iCreateWebhook(t, mainDB.DB(), webhookID, "lost-database")
+
+	var logs bytes.Buffer
+
+	dbMgr := databasetest.NewWebhookDBManagerWithLogger(
+		t, t.TempDir(), slog.New(slog.NewTextHandler(&logs, nil)),
+	)
+	t.Cleanup(func() { _ = dbMgr.CloseAll() })
+
+	engine := delivery.NewTestEngineWithDB(
+		mainDB, dbMgr,
+		slog.New(slog.DiscardHandler),
+		&http.Client{Timeout: 5 * time.Second}, 1,
+	)
+
+	engine.ExportRecoverDeliveries(context.Background(), atStart)
+
+	assert.Contains(
+		t, logs.String(),
+		`level=WARN msg="created a new, empty database" webhook_id=`+
+			webhookID+" path="+dbMgr.DBPath(webhookID),
+	)
+}
+
+// TestRecoverDeliveries_SkipsAWebhookDeletedAfterTheListIsRead covers a
+// webhook deleted from the web interface while the recovery routine
+// runs. Its database file is gone, and recovery must not create it
+// again.
+func TestRecoverDeliveries_SkipsAWebhookDeletedAfterTheListIsRead(
+	t *testing.T,
+) {
+	t.Parallel()
+
+	mainDB := iMainDB(t)
+	webhookID := uuid.New().String()
+	iCreateWebhook(t, mainDB.DB(), webhookID, "deleted-during-recovery")
+
+	// The first query to return is recovery's read of the list of
+	// webhooks. Deleting the webhook right after it puts the delete
+	// between that read and the opening of the webhook's database.
+	deleted := false
+
+	require.NoError(t, mainDB.DB().Callback().Query().After("gorm:query").
+		Register("delete-after-list", func(*gorm.DB) {
+			if deleted {
+				return
+			}
+
+			deleted = true
+
+			require.NoError(t, mainDB.DB().Delete(
+				&database.Webhook{}, "id = ?", webhookID,
+			).Error)
+		}))
+
+	dbMgr := databasetest.NewWebhookDBManager(t, t.TempDir())
+	t.Cleanup(func() { _ = dbMgr.CloseAll() })
+
+	engine := delivery.NewTestEngineWithDB(
+		mainDB, dbMgr,
+		slog.New(slog.DiscardHandler),
+		&http.Client{Timeout: 5 * time.Second}, 1,
+	)
+
+	engine.ExportRecoverDeliveries(context.Background(), atStart)
+
+	require.True(t, deleted)
+	assert.False(t, dbMgr.DBExists(webhookID))
+}
+
+// --- HTTP target with custom headers ---
 
 func TestDeliverHTTP_CustomTargetHeaders(t *testing.T) {
 	t.Parallel()
@@ -1142,16 +1189,6 @@ func TestDeliverHTTP_CustomTargetHeaders(t *testing.T) {
 	)
 	defer ts.Close()
 
-	cfg := delivery.HTTPTargetConfig{
-		URL: ts.URL,
-		Headers: map[string]string{
-			"Authorization": "Bearer secret-token",
-		},
-	}
-
-	cfgJSON, err := json.Marshal(cfg)
-	require.NoError(t, err)
-
 	event := iSeedEvent(
 		t, s.WebhookDB, s.WebhookID,
 		`{"auth":"test"}`,
@@ -1166,9 +1203,12 @@ func TestDeliverHTTP_CustomTargetHeaders(t *testing.T) {
 	bodyStr := event.Body
 	task := iTask(
 		d, event, s.WebhookID, targetID,
-		"auth-target", string(cfgJSON),
-		0, 1, &bodyStr,
+		"auth-target", ts.URL,
+		1, 1, &bodyStr,
 	)
+	task.TargetHeaders = map[string]string{
+		headerAuthorization: "Bearer secret-token",
+	}
 
 	s.Engine.ExportProcessNewTask(
 		context.TODO(), &task,
@@ -1181,11 +1221,14 @@ func TestDeliverHTTP_CustomTargetHeaders(t *testing.T) {
 
 // --- HTTP delivery with custom timeout ---
 
+// TestDeliverHTTP_TargetTimeout proves a task's TimeoutSeconds reaches
+// the delivery through the engine. The destination answers after two
+// seconds, inside the engine's own five-second client timeout, so only
+// the task's one second can fail the delivery.
 func TestDeliverHTTP_TargetTimeout(t *testing.T) {
 	t.Parallel()
 
-	db := testWebhookDB(t)
-	e := iEngine(t, 1)
+	s := newISetup(t)
 
 	ts := httptest.NewServer(
 		http.HandlerFunc(
@@ -1197,31 +1240,30 @@ func TestDeliverHTTP_TargetTimeout(t *testing.T) {
 	)
 	defer ts.Close()
 
-	cfg := delivery.HTTPTargetConfig{
-		URL:     ts.URL,
-		Timeout: 1,
-	}
+	event := iSeedEvent(
+		t, s.WebhookDB, s.WebhookID, `{"timeout":"test"}`,
+	)
+	targetID := uuid.New().String()
 
-	cfgJSON, err := json.Marshal(cfg)
-	require.NoError(t, err)
-
-	event, del := iSeedEventAndDelivery(
-		t, db, `{"timeout":"test"}`,
-		string(cfgJSON),
+	d := iSeedDelivery(
+		t, s.WebhookDB, event.ID, targetID,
+		database.DeliveryStatusPending,
 	)
 
-	task, d := iHTTPTaskAndDelivery(
-		event, del, "timeout-target",
-		string(cfgJSON), 0, 1,
+	bodyStr := event.Body
+	task := iTask(
+		d, event, s.WebhookID, targetID,
+		"timeout-target", ts.URL, 1, 1, &bodyStr,
 	)
+	task.TimeoutSeconds = 1
 
-	e.ExportDeliverHTTP(context.TODO(), db, d, task)
+	s.Engine.ExportProcessNewTask(context.TODO(), &task)
 
-	iAssertStatus(t, db, del.ID,
+	iAssertStatus(t, s.WebhookDB, d.ID,
 		database.DeliveryStatusFailed,
 	)
 
-	iAssertResultFailed(t, db, del.ID)
+	iAssertResultFailed(t, s.WebhookDB, d.ID)
 }
 
 // TestDeliverHTTP_CutsStoredResponseAtMaxBodyLog pins the size
@@ -1259,8 +1301,6 @@ func TestDeliverHTTP_CutsStoredResponseAtMaxBodyLog(
 	))
 	defer ts.Close()
 
-	cfgJSON := iHTTPConfig(ts.URL)
-
 	event := iSeedEvent(
 		t, s.WebhookDB, s.WebhookID, `{"cut":"test"}`,
 	)
@@ -1274,7 +1314,7 @@ func TestDeliverHTTP_CutsStoredResponseAtMaxBodyLog(
 	bodyStr := event.Body
 	task := iTask(
 		del, event, s.WebhookID, targetID,
-		"cut-target", cfgJSON, 0, 1, &bodyStr,
+		"cut-target", ts.URL, 1, 1, &bodyStr,
 	)
 
 	s.Engine.ExportProcessNewTask(context.TODO(), &task)
@@ -1306,7 +1346,7 @@ func TestDeliverHTTP_CutsStoredResponseAtMaxBodyLog(
 func iSeedEventAndDelivery(
 	t *testing.T,
 	db *gorm.DB,
-	body, _ string,
+	body string,
 ) (database.Event, database.Delivery) {
 	t.Helper()
 
@@ -1337,19 +1377,19 @@ func iSeedEventAndDelivery(
 func iHTTPTaskAndDelivery(
 	event database.Event,
 	del database.Delivery,
-	name, config string,
-	maxRetries, attemptNum int,
+	name, targetURL string,
+	maxAttempts, attemptNum int,
 ) (*delivery.Task, *database.Delivery) {
 	task := &delivery.Task{
-		DeliveryID:   del.ID,
-		EventID:      event.ID,
-		WebhookID:    event.WebhookID,
-		TargetID:     del.TargetID,
-		TargetName:   name,
-		TargetType:   database.TargetTypeHTTP,
-		TargetConfig: config,
-		MaxRetries:   maxRetries,
-		AttemptNum:   attemptNum,
+		DeliveryID:  del.ID,
+		EventID:     event.ID,
+		WebhookID:   event.WebhookID,
+		TargetID:    del.TargetID,
+		TargetName:  name,
+		TargetType:  database.TargetTypeHTTP,
+		TargetURL:   targetURL,
+		MaxAttempts: maxAttempts,
+		AttemptNum:  attemptNum,
 	}
 
 	d := &database.Delivery{
@@ -1358,9 +1398,10 @@ func iHTTPTaskAndDelivery(
 		Status:   database.DeliveryStatusPending,
 		Event:    event,
 		Target: database.Target{
-			Name:   name,
-			Type:   database.TargetTypeHTTP,
-			Config: config,
+			Name:        name,
+			Type:        database.TargetTypeHTTP,
+			URL:         targetURL,
+			MaxAttempts: maxAttempts,
 		},
 	}
 	d.ID = del.ID
@@ -1388,30 +1429,30 @@ func iAssertResultFailed(
 	assert.NotEmpty(t, result.Error)
 }
 
-// --- HTTP request with invalid config ---
+// --- HTTP request with no URL ---
 
-func TestDeliverHTTP_InvalidConfig(t *testing.T) {
+// TestDeliverHTTP_NoURL proves an http target without a URL, which
+// the forms never store, fails its delivery and records why.
+func TestDeliverHTTP_NoURL(t *testing.T) {
 	t.Parallel()
 
 	db := testWebhookDB(t)
 	e := iEngine(t, 1)
 
-	event, del := iSeedEventAndDelivery(
-		t, db, `{"config":"invalid"}`, "",
-	)
+	event, del := iSeedEventAndDelivery(t, db, `{"url":"none"}`)
 
-	task, d := iHTTPTaskAndDelivery(
-		event, del, "bad-config", `not-json`, 0, 1,
-	)
+	task, d := iHTTPTaskAndDelivery(event, del, "no-url", "", 1, 1)
 
 	e.ExportDeliverHTTP(context.TODO(), db, d, task)
 
 	iAssertStatus(t, db, del.ID,
 		database.DeliveryStatusFailed,
 	)
+
+	iAssertResultFailed(t, db, del.ID)
 }
 
-// --- Notify batching ---
+// --- notify batching ---
 
 func TestNotify_MultipleTasks(t *testing.T) {
 	t.Parallel()
@@ -1426,7 +1467,7 @@ func TestNotify_MultipleTasks(t *testing.T) {
 		}
 	}
 
-	e.Notify(tasks)
+	e.ExportNotify(tasks)
 
 	for i := range 5 {
 		select {

internal/delivery/engine_lifecycle_test.go

@@ -2,14 +2,19 @@ package delivery_test
 
 import (
 	"context"
-	"fmt"
+	"io"
+	"net/http"
+	"net/http/httptest"
 	"path/filepath"
+	"sync"
 	"testing"
 	"time"
 
 	"github.com/google/uuid"
+	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 	"go.uber.org/fx"
+	"gorm.io/gorm/clause"
 	"sneak.berlin/go/webhooker/internal/database"
 	"sneak.berlin/go/webhooker/internal/delivery"
 )
@@ -24,7 +29,7 @@ const (
 	// OnStart before the caller may enqueue work. A worker pool
 	// wrongly rooted in the already-done hook context has nothing
 	// but ctx.Done() ready in its select, so it is deterministically
-	// gone by the end of this window. Without the wait, Notify would
+	// gone by the end of this window. Without the wait, notify would
 	// race the pool's very first select, in which a ready ctx.Done()
 	// and a ready deliveryCh are chosen between at random and a
 	// doomed pool still delivers.
@@ -94,7 +99,7 @@ func requireStopHookExpires(
 // the caller can drive OnStop too.
 //
 // Callers must not seed pending or retrying deliveries before
-// calling this: restart recovery enqueues those during startup,
+// calling this: the recovery routine's run at start enqueues those,
 // which would put work in the queue while the pool is still
 // racing its first select.
 func startEngineViaHook(
@@ -144,7 +149,7 @@ func seedLogTask(
 	bodyStr := event.Body
 	task := iTask(
 		d, event, s.WebhookID, targetID,
-		"hook-context-test", "", 0, 1, &bodyStr,
+		"hook-context-test", "", 1, 1, &bodyStr,
 	)
 	task.TargetType = database.TargetTypeLog
 
@@ -173,11 +178,11 @@ func TestEngine_WorkersOutliveStartHookContext(t *testing.T) {
 		_ = lc.hooks[0].OnStop(context.Background())
 	})
 
-	// Seeded only after the pool has settled, so restart recovery
-	// cannot enqueue it during startup.
+	// Seeded only after the pool has settled, so the recovery
+	// routine's run at start cannot enqueue it.
 	deliveryID, task := seedLogTask(t, s)
 
-	s.Engine.Notify([]delivery.Task{task})
+	s.Engine.ExportNotify([]delivery.Task{task})
 
 	iWaitForDelivered(t, s.WebhookDB, deliveryID)
 }
@@ -197,7 +202,7 @@ func TestEngine_StopHookStopsWorkers(t *testing.T) {
 	// Let the pool prove it is running before stopping it, so a
 	// fast OnStop cannot pass by stopping something already dead.
 	firstID, firstTask := seedLogTask(t, s)
-	s.Engine.Notify([]delivery.Task{firstTask})
+	s.Engine.ExportNotify([]delivery.Task{firstTask})
 	iWaitForDelivered(t, s.WebhookDB, firstID)
 
 	var stopErr error
@@ -227,7 +232,7 @@ func TestEngine_StopHookStopsWorkers(t *testing.T) {
 	// With every worker gone, a freshly notified task must sit
 	// untouched in the queue rather than being delivered.
 	secondID, secondTask := seedLogTask(t, s)
-	s.Engine.Notify([]delivery.Task{secondTask})
+	s.Engine.ExportNotify([]delivery.Task{secondTask})
 
 	time.Sleep(200 * time.Millisecond)
 
@@ -272,22 +277,184 @@ func TestEngine_StopHookHonoursStopTimeout(t *testing.T) {
 	requireStopHookExpires(t, lc.hooks[0], "delivery engine")
 }
 
-// deliverToArchive runs one delivery to a database target through
-// the running engine and returns the webhook's archive file path.
-// The archive writer holds the file open afterwards.
+// seedHeldDelivery gives the setup's webhook an http target with
+// maxAttempts, pointed at a receiver that keeps every request open until
+// the client gives up on it, and seeds one delivery to that target at
+// status. It returns the task that sends attempt attemptNum of the
+// delivery, and a channel that is closed when a request reaches the
+// receiver.
+func seedHeldDelivery(
+	t *testing.T,
+	s iSetup,
+	maxAttempts int,
+	status database.DeliveryStatus,
+	attemptNum int,
+) (delivery.Task, <-chan struct{}) {
+	t.Helper()
+
+	arrived := make(chan struct{})
+
+	var once sync.Once
+
+	ts := httptest.NewServer(http.HandlerFunc(
+		func(_ http.ResponseWriter, r *http.Request) {
+			// The server notices the client hanging up only once the
+			// body has been read; until then r.Context() never ends.
+			_, _ = io.Copy(io.Discard, r.Body)
+
+			once.Do(func() { close(arrived) })
+
+			<-r.Context().Done()
+		},
+	))
+	t.Cleanup(ts.Close)
+
+	targetID := uuid.New().String()
+
+	iCreateWebhook(t, s.MainDB, s.WebhookID, "hook")
+	iCreateTarget(
+		t, s.MainDB, targetID, s.WebhookID, "held",
+		database.TargetTypeHTTP, ts.URL, maxAttempts,
+	)
+
+	event := iSeedEvent(t, s.WebhookDB, s.WebhookID, `{"held":true}`)
+	d := iSeedDelivery(t, s.WebhookDB, event.ID, targetID, status)
+
+	bodyStr := event.Body
+
+	return iTask(
+		d, event, s.WebhookID, targetID, "held", ts.URL,
+		maxAttempts, attemptNum, &bodyStr,
+	), arrived
+}
+
+// stopDuringAttempt waits until the receiver holds an attempt open, then
+// stops the engine through its real stop hook.
+func stopDuringAttempt(
+	t *testing.T, lc *recordingLifecycle, arrived <-chan struct{},
+) {
+	t.Helper()
+
+	select {
+	case <-arrived:
+	case <-time.After(5 * time.Second):
+		t.Fatal("the delivery attempt never reached the receiver")
+	}
+
+	require.NoError(t, lc.hooks[0].OnStop(context.Background()))
+}
+
+// requireRequeued runs the recovery routine as at start on the stopped
+// engine and requires it to queue task's attempt again on ch.
+func requireRequeued(
+	t *testing.T, s iSetup, ch <-chan delivery.Task, task delivery.Task,
+) {
+	t.Helper()
+
+	s.Engine.ExportRecoverWebhookDeliveries(
+		context.Background(), s.WebhookID, atStart,
+	)
+
+	select {
+	case got := <-ch:
+		assert.Equal(t, task.DeliveryID, got.DeliveryID)
+		assert.Equal(t, task.AttemptNum, got.AttemptNum)
+	case <-time.After(5 * time.Second):
+		t.Fatal("recovery at start did not queue the delivery again")
+	}
+}
+
+// TestEngine_StopLeavesFireAndForgetAttemptPending is the regression
+// test for a stop that turned an attempt in flight into a terminal
+// failure. Stopping the engine cancels the request; for a target with
+// no retries that was the delivery's only attempt, recorded as failed
+// with "context canceled", and nothing ever sent it again. The
+// delivery must instead stay pending, with no result and no count in
+// the attempt metrics, for the recovery routine to send at the next
+// start.
+func TestEngine_StopLeavesFireAndForgetAttemptPending(t *testing.T) {
+	t.Parallel()
+
+	s := newISetup(t)
+	reg := mIsolate(t, s)
+	lc := startEngineViaHook(t, s.Engine)
+
+	task, arrived := seedHeldDelivery(
+		t, s, 1, database.DeliveryStatusPending, 1,
+	)
+
+	s.Engine.ExportNotify([]delivery.Task{task})
+	stopDuringAttempt(t, lc, arrived)
+
+	iAssertStatus(
+		t, s.WebhookDB, task.DeliveryID, database.DeliveryStatusPending,
+	)
+	assert.Empty(t, iResults(t, s.WebhookDB, task.DeliveryID))
+	assert.Zero(t, mCounter(t, reg, mAttempts, mTypeHTTP))
+	assert.Zero(t, mHTTPDurations(t, reg))
+
+	requireRequeued(t, s, s.Engine.ExportDeliveryCh(), task)
+}
+
+// TestEngine_StopLeavesLastRetryAttemptRetrying is the same regression
+// for a target with retries, on its last attempt: the cancelled attempt
+// used to exhaust the retries and end the delivery failed. It must stay
+// retrying with only its earlier attempt recorded, and the recovery
+// routine at the next start must send that last attempt again.
+func TestEngine_StopLeavesLastRetryAttemptRetrying(t *testing.T) {
+	t.Parallel()
+
+	const maxAttempts = 2
+
+	s := newISetup(t)
+	lc := startEngineViaHook(t, s.Engine)
+
+	task, arrived := seedHeldDelivery(
+		t, s, maxAttempts, database.DeliveryStatusRetrying, maxAttempts,
+	)
+	iSeedFailedResult(t, s.WebhookDB, task.DeliveryID)
+
+	s.Engine.ExportScheduleRetry(task, 0)
+	stopDuringAttempt(t, lc, arrived)
+
+	iAssertStatus(
+		t, s.WebhookDB, task.DeliveryID, database.DeliveryStatusRetrying,
+	)
+	assert.Len(t, iResults(t, s.WebhookDB, task.DeliveryID), 1)
+
+	requireRequeued(t, s, s.Engine.ExportRetryCh(), task)
+}
+
+// deliverToArchive gives the setup's webhook a database target,
+// runs one delivery to it through the running engine, and returns
+// the target's archive file path. The archive writer holds the file
+// open afterwards.
 func deliverToArchive(t *testing.T, s iSetup) string {
 	t.Helper()
 
+	iCreateWebhook(t, s.MainDB, s.WebhookID, "hook")
+
+	tgt := &database.Target{
+		WebhookID:   s.WebhookID,
+		Name:        "archive",
+		Type:        database.TargetTypeDatabase,
+		MaxAttempts: 1,
+	}
+	require.NoError(
+		t, s.MainDB.Omit(clause.Associations).Create(tgt).Error,
+	)
+
 	deliveryID, task := seedLogTask(t, s)
+	task.TargetID = tgt.ID
 	task.TargetType = database.TargetTypeDatabase
 
-	s.Engine.Notify([]delivery.Task{task})
+	s.Engine.ExportNotify([]delivery.Task{task})
 
 	iWaitForDelivered(t, s.WebhookDB, deliveryID)
 
 	return filepath.Join(
 		filepath.Dir(s.DBMgr.DBPath(s.WebhookID)),
-		fmt.Sprintf("archive-%s.db", s.WebhookID),
+		"archive-hook-archive-"+tgt.ID+".db",
 	)
 }
 
@@ -338,21 +505,23 @@ func TestEngine_StopHookTimeoutLeavesArchivesOpen(t *testing.T) {
 
 	lc := startEngineViaHook(t, s.Engine)
 
-	deliverToArchive(t, s)
+	path := deliverToArchive(t, s)
 
 	release := make(chan struct{})
 
 	t.Cleanup(func() {
 		close(release)
-		s.Engine.EvictWebhook(s.WebhookID)
+		s.Engine.ExportArchives().EvictWebhook(s.WebhookID)
 	})
 
 	s.Engine.ExportWedgeWorker(release)
 
 	requireStopHookExpires(t, lc.hooks[0], "delivery engine")
 
-	require.True(
-		t, s.Engine.ExportArchiveHandleOpen(s.WebhookID),
+	// Closing the last handle on an archive removes its -wal, so a
+	// -wal still there is a writer still open.
+	require.FileExists(
+		t, path+"-wal",
 		"a stop that timed out must not close archive writers",
 	)
 }

internal/delivery/engine_test.go

@@ -5,11 +5,12 @@ import (
 	"context"
 	"encoding/json"
 	"fmt"
+	"io"
 	"log/slog"
 	"net/http"
 	"net/http/httptest"
 	"os"
-	"path/filepath"
+	"strconv"
 	"strings"
 	"sync"
 	"sync/atomic"
@@ -20,10 +21,10 @@ import (
 	"github.com/prometheus/client_golang/prometheus"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
-	"gorm.io/driver/sqlite"
 	"gorm.io/gorm"
 	_ "modernc.org/sqlite"
 	"sneak.berlin/go/webhooker/internal/database"
+	"sneak.berlin/go/webhooker/internal/database/databasetest"
 	"sneak.berlin/go/webhooker/internal/delivery"
 	"sneak.berlin/go/webhooker/internal/metrics"
 )
@@ -34,31 +35,18 @@ const testContentType = "application/json"
 func testWebhookDB(t *testing.T) *gorm.DB {
 	t.Helper()
 
-	dbPath := filepath.Join(
-		t.TempDir(), "events-test.db",
+	// Opened by the manager the service uses, so these tests cannot
+	// pass against a schema, journal and locking settings or write
+	// guard production does not use.
+	mgr := databasetest.NewWebhookDBManagerWithLogger(
+		t, t.TempDir(), slog.New(slog.DiscardHandler),
 	)
 
-	// Opened the way the service opens a per-webhook database, so
-	// these tests cannot pass against journal and locking settings
-	// production does not use.
-	sqlDB, err := database.OpenSQLite(
-		dbPath, database.SQLiteModeCreate,
-	)
+	t.Cleanup(func() { _ = mgr.CloseAll() })
+
+	db, err := mgr.GetDB(uuid.New().String())
 	require.NoError(t, err)
 
-	t.Cleanup(func() { _ = sqlDB.Close() })
-
-	db, err := gorm.Open(
-		sqlite.Dialector{Conn: sqlDB}, &gorm.Config{},
-	)
-	require.NoError(t, err)
-
-	require.NoError(t, db.AutoMigrate(
-		&database.Event{},
-		&database.Delivery{},
-		&database.DeliveryResult{},
-	))
-
 	return db
 }
 
@@ -77,20 +65,6 @@ func testEngine(
 	)
 }
 
-func newHTTPTargetConfig(url string) string {
-	cfg := delivery.HTTPTargetConfig{URL: url}
-
-	data, err := json.Marshal(cfg)
-	if err != nil {
-		panic(
-			"failed to marshal HTTPTargetConfig: " +
-				err.Error(),
-		)
-	}
-
-	return string(data)
-}
-
 func seedEvent(
 	t *testing.T, db *gorm.DB, body string,
 ) database.Event {
@@ -129,6 +103,18 @@ func seedDelivery(
 	return d
 }
 
+// assertStoredTime asserts that text, a timestamp as SQLite holds it,
+// is in the form GORM stores created_at in: the layout of
+// time.Time.String, with no " m=+…" monotonic clock reading after it.
+func assertStoredTime(t *testing.T, text string) {
+	t.Helper()
+
+	_, err := time.Parse(
+		"2006-01-02 15:04:05.999999999 -0700 MST", text,
+	)
+	assert.NoError(t, err, "stored as %q", text)
+}
+
 // httpDeliveryFixture holds the task and delivery needed
 // for HTTP delivery tests.
 type httpDeliveryFixture struct {
@@ -141,19 +127,19 @@ type httpDeliveryFixture struct {
 func buildHTTPFixture(
 	dlv database.Delivery,
 	event database.Event,
-	targetID, name, config string,
-	maxRetries, attemptNum int,
+	targetID, name, targetURL string,
+	maxAttempts, attemptNum int,
 ) httpDeliveryFixture {
 	task := &delivery.Task{
-		DeliveryID:   dlv.ID,
-		EventID:      event.ID,
-		WebhookID:    event.WebhookID,
-		TargetID:     targetID,
-		TargetName:   name,
-		TargetType:   database.TargetTypeHTTP,
-		TargetConfig: config,
-		MaxRetries:   maxRetries,
-		AttemptNum:   attemptNum,
+		DeliveryID:  dlv.ID,
+		EventID:     event.ID,
+		WebhookID:   event.WebhookID,
+		TargetID:    targetID,
+		TargetName:  name,
+		TargetType:  database.TargetTypeHTTP,
+		TargetURL:   targetURL,
+		MaxAttempts: maxAttempts,
+		AttemptNum:  attemptNum,
 	}
 
 	d := &database.Delivery{
@@ -162,10 +148,10 @@ func buildHTTPFixture(
 		Status:   dlv.Status,
 		Event:    event,
 		Target: database.Target{
-			Name:       name,
-			Type:       database.TargetTypeHTTP,
-			Config:     config,
-			MaxRetries: maxRetries,
+			Name:        name,
+			Type:        database.TargetTypeHTTP,
+			URL:         targetURL,
+			MaxAttempts: maxAttempts,
 		},
 	}
 	d.ID = dlv.ID
@@ -232,7 +218,7 @@ func TestNotify_NonBlocking(t *testing.T) {
 	done := make(chan struct{})
 
 	go func() {
-		e.Notify([]delivery.Task{
+		e.ExportNotify([]delivery.Task{
 			{DeliveryID: "overflow-1"},
 			{DeliveryID: "overflow-2"},
 		})
@@ -243,7 +229,7 @@ func TestNotify_NonBlocking(t *testing.T) {
 	case <-done:
 	case <-time.After(2 * time.Second):
 		t.Fatal(
-			"Notify blocked when delivery channel was full",
+			"notify blocked when delivery channel was full",
 		)
 	}
 }
@@ -275,9 +261,8 @@ func TestDeliverHTTP_Success(t *testing.T) {
 		database.DeliveryStatusPending,
 	)
 
-	cfg := newHTTPTargetConfig(ts.URL)
 	fix := buildHTTPFixture(
-		dlv, event, targetID, "test-http", cfg, 0, 1,
+		dlv, event, targetID, "test-http", ts.URL, 1, 1,
 	)
 
 	e.ExportDeliverHTTP(
@@ -321,10 +306,9 @@ func TestDeliverHTTP_Failure(t *testing.T) {
 		database.DeliveryStatusPending,
 	)
 
-	cfg := newHTTPTargetConfig(ts.URL)
 	fix := buildHTTPFixture(
 		dlv, event, targetID,
-		"test-http-fail", cfg, 0, 1,
+		"test-http-fail", ts.URL, 1, 1,
 	)
 
 	e.ExportDeliverHTTP(
@@ -348,23 +332,15 @@ func TestDeliverDatabase_ImmediateSuccess(
 
 	db := testWebhookDB(t)
 
-	// The database target archives for real now, so the engine
-	// needs a webhook DB manager to locate the data directory.
-	e := delivery.NewTestEngineWithDB(
-		nil,
-		database.NewTestWebhookDBManager(t.TempDir()),
-		slog.New(slog.NewTextHandler(
-			os.Stderr,
-			&slog.HandlerOptions{Level: slog.LevelDebug},
-		)),
-		&http.Client{Timeout: 5 * time.Second},
-		1,
-	)
+	// The database target archives for real, so the engine needs
+	// the target in the main database and a data directory.
+	env := setupArchiveTest(t)
+	tgt := env.seedDatabaseTarget(t)
 
 	event := seedEvent(t, db, `{"db":"target"}`)
-	d := seedDatabaseTargetDelivery(t, db, event, "")
+	d := seedDatabaseTargetDelivery(t, db, event, tgt)
 
-	e.ExportDeliverDatabase(db, d)
+	env.eng.ExportDeliverDatabase(db, d)
 
 	var updated database.Delivery
 
@@ -460,10 +436,9 @@ func TestDeliverHTTP_WithRetries_Success(t *testing.T) {
 		database.DeliveryStatusPending,
 	)
 
-	cfg := newHTTPTargetConfig(ts.URL)
 	fix := buildHTTPFixture(
 		dlv, event, targetID,
-		"test-http-retry", cfg, 5, 1,
+		"test-http-retry", ts.URL, 5, 1,
 	)
 
 	e.ExportDeliverHTTP(
@@ -481,14 +456,23 @@ func TestDeliverHTTP_WithRetries_Success(t *testing.T) {
 	)
 }
 
-func TestDeliverHTTP_MaxRetriesExhausted(t *testing.T) {
+// TestDeliverHTTP_MaxAttemptsExhausted proves a target with three
+// delivery attempts makes at most three: the first two failures are
+// retried, the third is final, and each attempt goes through the
+// target's circuit breaker.
+func TestDeliverHTTP_MaxAttemptsExhausted(t *testing.T) {
 	t.Parallel()
 
+	const maxAttempts = 3
+
 	db := testWebhookDB(t)
 
+	var requests atomic.Int32
+
 	ts := httptest.NewServer(
 		http.HandlerFunc(
 			func(w http.ResponseWriter, _ *http.Request) {
+				requests.Add(1)
 				w.WriteHeader(http.StatusBadGateway)
 			},
 		),
@@ -497,26 +481,101 @@ func TestDeliverHTTP_MaxRetriesExhausted(t *testing.T) {
 
 	e := testEngine(t, 1)
 	targetID := uuid.New().String()
+
+	// It opens on the last failure only if every attempt reached it.
+	cb := delivery.NewTestCircuitBreaker(maxAttempts, time.Minute)
+	e.ExportSetCircuitBreaker(targetID, cb)
+
 	event := seedEvent(t, db, `{"retry":"exhaust"}`)
 
 	dlv := seedDelivery(
 		t, db, event.ID, targetID,
-		database.DeliveryStatusRetrying,
+		database.DeliveryStatusPending,
 	)
 
-	cfg := newHTTPTargetConfig(ts.URL)
-	fix := buildHTTPFixture(
-		dlv, event, targetID,
-		"test-http-exhaust", cfg, 3, 3,
-	)
+	sched := &recordingScheduler{}
 
-	e.ExportDeliverHTTP(
-		context.TODO(), db, fix.Delivery, fix.Task,
-	)
+	for attempt := 1; attempt <= maxAttempts; attempt++ {
+		fix := buildHTTPFixture(
+			dlv, event, targetID,
+			"test-http-exhaust", ts.URL, maxAttempts, attempt,
+		)
 
+		e.ExportDeliverHTTPWithScheduler(
+			context.TODO(), db, fix.Delivery, fix.Task, sched,
+		)
+	}
+
+	assert.Equal(t, int32(maxAttempts), requests.Load())
+	assert.Len(t, sched.delays, maxAttempts-1,
+		"every failure but the last should be retried",
+	)
 	assertDeliveryStatus(t, db, dlv.ID,
 		database.DeliveryStatusFailed,
 	)
+	assert.Equal(t, delivery.CircuitOpen, cb.State(),
+		"every attempt should be counted by the circuit breaker",
+	)
+}
+
+// TestDeliverHTTP_SingleAttemptSkipsCircuitBreaker proves a target
+// with one delivery attempt makes exactly that attempt, even while
+// its circuit breaker is open, and that a failure is final.
+func TestDeliverHTTP_SingleAttemptSkipsCircuitBreaker(t *testing.T) {
+	t.Parallel()
+
+	db := testWebhookDB(t)
+
+	var requests atomic.Int32
+
+	ts := httptest.NewServer(
+		http.HandlerFunc(
+			func(w http.ResponseWriter, _ *http.Request) {
+				requests.Add(1)
+				w.WriteHeader(http.StatusBadGateway)
+			},
+		),
+	)
+	defer ts.Close()
+
+	e := testEngine(t, 1)
+	targetID := uuid.New().String()
+
+	cb := e.ExportGetCircuitBreaker(targetID)
+
+	for range delivery.ExportDefaultFailureThreshold {
+		cb.RecordFailure()
+	}
+
+	require.Equal(t, delivery.CircuitOpen, cb.State())
+
+	event := seedEvent(t, db, `{"retry":"none"}`)
+
+	dlv := seedDelivery(
+		t, db, event.ID, targetID,
+		database.DeliveryStatusPending,
+	)
+
+	fix := buildHTTPFixture(
+		dlv, event, targetID,
+		"test-http-single", ts.URL, 1, 1,
+	)
+	sched := &recordingScheduler{}
+
+	e.ExportDeliverHTTPWithScheduler(
+		context.TODO(), db, fix.Delivery, fix.Task, sched,
+	)
+
+	assert.Equal(t, int32(1), requests.Load(),
+		"the open circuit breaker should not hold the attempt back",
+	)
+	assert.Empty(t, sched.delays, "no retry should be scheduled")
+	assertDeliveryStatus(t, db, dlv.ID,
+		database.DeliveryStatusFailed,
+	)
+	assertDeliveryResult(
+		t, db, dlv.ID, false, http.StatusBadGateway,
+	)
 }
 
 func TestDeliverHTTP_SchedulesRetryOnFailure(
@@ -546,10 +605,9 @@ func TestDeliverHTTP_SchedulesRetryOnFailure(
 		database.DeliveryStatusPending,
 	)
 
-	cfg := newHTTPTargetConfig(ts.URL)
 	fix := buildHTTPFixture(
 		dlv, event, targetID,
-		"test-http-schedule", cfg, 5, 1,
+		"test-http-schedule", ts.URL, 5, 1,
 	)
 
 	e.ExportDeliverHTTP(
@@ -711,7 +769,7 @@ func seedConcurrencyTasks(
 	t *testing.T,
 	db *gorm.DB,
 	n int,
-	targetCfg string,
+	targetURL string,
 ) ([]database.Delivery, []delivery.Task) {
 	t.Helper()
 
@@ -735,22 +793,23 @@ func seedConcurrencyTasks(
 			Status:   database.DeliveryStatusPending,
 			Event:    event,
 			Target: database.Target{
-				Name:   fmt.Sprintf("task-%d", i),
-				Type:   database.TargetTypeHTTP,
-				Config: targetCfg,
+				Name:        fmt.Sprintf("task-%d", i),
+				Type:        database.TargetTypeHTTP,
+				URL:         targetURL,
+				MaxAttempts: 1,
 			},
 		}
 		tasks[i].ID = dlv.ID
 
 		dtasks[i] = delivery.Task{
-			DeliveryID:   tasks[i].ID,
-			EventID:      tasks[i].EventID,
-			TargetID:     tasks[i].TargetID,
-			TargetName:   tasks[i].Target.Name,
-			TargetType:   tasks[i].Target.Type,
-			TargetConfig: tasks[i].Target.Config,
-			MaxRetries:   0,
-			AttemptNum:   1,
+			DeliveryID:  tasks[i].ID,
+			EventID:     tasks[i].EventID,
+			TargetID:    tasks[i].TargetID,
+			TargetName:  tasks[i].Target.Name,
+			TargetType:  tasks[i].Target.Type,
+			TargetURL:   tasks[i].Target.URL,
+			MaxAttempts: 1,
+			AttemptNum:  1,
 		}
 	}
 
@@ -786,9 +845,8 @@ func TestWorkerPool_BoundedConcurrency(t *testing.T) {
 	defer ts.Close()
 
 	e := testEngine(t, numWorkers)
-	cfg := newHTTPTargetConfig(ts.URL)
 	tasks, dtasks := seedConcurrencyTasks(
-		t, db, numTasks, cfg,
+		t, db, numTasks, ts.URL,
 	)
 
 	runConcurrencyWorkers(
@@ -869,12 +927,9 @@ func TestDeliverHTTP_CircuitBreakerBlocks(t *testing.T) {
 		database.DeliveryStatusPending,
 	)
 
-	cfg := newHTTPTargetConfig(
-		"http://will-not-be-called.invalid",
-	)
 	fix := buildHTTPFixture(
 		dlv, event, targetID,
-		"test-cb-block", cfg, 5, 1,
+		"test-cb-block", "http://will-not-be-called.invalid", 5, 1,
 	)
 
 	e.ExportDeliverHTTP(
@@ -937,9 +992,8 @@ func TestDeliverHTTP_HalfOpenBreakerDelaysQueuedTasks(t *testing.T) {
 	require.True(t, cb.Allow(), "the probe delivery should go through")
 	require.Equal(t, delivery.CircuitHalfOpen, cb.State())
 
-	cfg := newHTTPTargetConfig(
-		"http://will-not-be-called.invalid",
-	)
+	const targetURL = "http://will-not-be-called.invalid"
+
 	sched := &recordingScheduler{}
 
 	const queued, passes = 3, 4
@@ -961,7 +1015,7 @@ func TestDeliverHTTP_HalfOpenBreakerDelaysQueuedTasks(t *testing.T) {
 
 			fix := buildHTTPFixture(
 				row, event, targetID,
-				"test-cb-half-open", cfg, 5, 1,
+				"test-cb-half-open", targetURL, 5, 1,
 			)
 
 			e.ExportDeliverHTTPWithScheduler(
@@ -1020,45 +1074,60 @@ func TestGetCircuitBreaker_CreatesOnDemand(t *testing.T) {
 	)
 }
 
-func TestParseHTTPConfig_Valid(t *testing.T) {
+// TestStateAndCooldown_ReadsHTTPAndSlackBreakers proves the engine
+// reads the state of an http or a slack target's circuit breaker, with
+// what is left of its cooldown while it is open, and no cooldown while
+// it is half-open, once it closes, or for a target with no breaker.
+func TestStateAndCooldown_ReadsHTTPAndSlackBreakers(t *testing.T) {
 	t.Parallel()
 
 	e := testEngine(t, 1)
 
-	cfg, err := e.ExportParseHTTPConfig(
-		`{"url":"https://example.com/hook",` +
-			`"headers":{"X-Token":"secret"}}`,
-	)
+	httpID := uuid.New().String()
+	slackID := uuid.New().String()
 
-	require.NoError(t, err)
-	assert.Equal(t, "https://example.com/hook", cfg.URL)
-	assert.Equal(t, "secret", cfg.Headers["X-Token"])
-}
+	state, cooldown := e.StateAndCooldown(httpID)
+	assert.Equal(t, delivery.CircuitClosed, state, "no breaker")
+	assert.Zero(t, cooldown, "no breaker")
 
-func TestParseHTTPConfig_Empty(t *testing.T) {
-	t.Parallel()
+	httpCB := delivery.NewTestCircuitBreaker(1, time.Hour)
+	e.ExportSetCircuitBreaker(httpID, httpCB)
 
-	e := testEngine(t, 1)
+	slackCB := delivery.NewTestCircuitBreaker(1, time.Hour)
+	e.ExportSetSlackCircuitBreaker(slackID, slackCB)
 
-	_, err := e.ExportParseHTTPConfig("")
+	httpCB.RecordFailure()
+	slackCB.RecordFailure()
 
-	assert.Error(t, err,
-		"empty config should return error",
-	)
-}
+	for _, id := range []string{httpID, slackID} {
+		state, cooldown := e.StateAndCooldown(id)
+		assert.Equal(t, delivery.CircuitOpen, state)
+		assert.Greater(t, cooldown, 59*time.Minute)
+		assert.LessOrEqual(t, cooldown, time.Hour)
+	}
 
-func TestParseHTTPConfig_MissingURL(t *testing.T) {
-	t.Parallel()
+	httpCB.RecordSuccess()
+	slackCB.RecordSuccess()
 
-	e := testEngine(t, 1)
+	for _, id := range []string{httpID, slackID} {
+		state, cooldown := e.StateAndCooldown(id)
+		assert.Equal(t, delivery.CircuitClosed, state, "closed")
+		assert.Zero(t, cooldown, "closed")
+	}
 
-	_, err := e.ExportParseHTTPConfig(
-		`{"headers":{"X-Token":"secret"}}`,
-	)
+	// A breaker with no cooldown goes half-open on the first Allow
+	// after it trips, letting that one delivery through to test the
+	// target.
+	halfOpenID := uuid.New().String()
+	halfOpenCB := delivery.NewTestCircuitBreaker(1, 0)
+	e.ExportSetCircuitBreaker(halfOpenID, halfOpenCB)
 
-	assert.Error(t, err,
-		"config without URL should return error",
-	)
+	halfOpenCB.RecordFailure()
+	require.True(t, halfOpenCB.Allow())
+
+	state, cooldown = e.StateAndCooldown(halfOpenID)
+	assert.Equal(t, delivery.CircuitHalfOpen, state)
+	assert.Zero(t, cooldown, "half-open")
 }
 
 func TestScheduleRetry_SendsToRetryChannel(
@@ -1208,7 +1277,7 @@ func TestDoHTTPRequest_ForwardsHeaders(t *testing.T) {
 
 	e := testEngine(t, 1)
 
-	cfg := &delivery.HTTPTargetConfig{
+	target := &database.Target{
 		URL: ts.URL,
 		Headers: map[string]string{
 			"X-Target-Auth": "bearer xyz",
@@ -1223,7 +1292,7 @@ func TestDoHTTPRequest_ForwardsHeaders(t *testing.T) {
 	}
 
 	statusCode, _, _, err := e.ExportDoHTTPRequest(
-		context.TODO(), cfg, event,
+		context.TODO(), target, event,
 	)
 
 	require.NoError(t, err)
@@ -1244,11 +1313,33 @@ func TestDoHTTPRequest_ForwardsHeaders(t *testing.T) {
 		testContentType,
 		receivedHeaders.Get("Content-Type"),
 	)
+}
 
-	assert.Equal(t,
-		"webhooker/1.0",
-		receivedHeaders.Get("User-Agent"),
+// A response that ends before the length it announced is an error, not
+// a short body.
+func TestDoHTTPRequest_CutShortResponseIsAnError(t *testing.T) {
+	t.Parallel()
+
+	ts := httptest.NewServer(
+		http.HandlerFunc(
+			func(w http.ResponseWriter, _ *http.Request) {
+				w.Header().Set("Content-Length", "100")
+				_, _ = w.Write([]byte("cut short"))
+			},
+		),
 	)
+	defer ts.Close()
+
+	e := testEngine(t, 1)
+
+	_, body, _, err := e.ExportDoHTTPRequest(
+		context.TODO(),
+		&database.Target{URL: ts.URL},
+		&database.Event{},
+	)
+
+	require.ErrorIs(t, err, io.ErrUnexpectedEOF)
+	assert.Empty(t, body)
 }
 
 // The event's stored inbound headers carry the same Content-Type the
@@ -1295,9 +1386,9 @@ func TestApplyRequestHeaders_SendsOneContentType(t *testing.T) {
 			})
 			require.NoError(t, err)
 
-			cfg := &delivery.HTTPTargetConfig{}
+			var configured map[string]string
 			if tc.configured != "" {
-				cfg.Headers = map[string]string{
+				configured = map[string]string{
 					headerContentType: tc.configured,
 				}
 			}
@@ -1316,7 +1407,8 @@ func TestApplyRequestHeaders_SendsOneContentType(t *testing.T) {
 					Headers:     string(inbound),
 					ContentType: tc.event,
 				},
-				cfg,
+				configured,
+				"webhooker/dev",
 			)
 
 			assert.Equal(t,
@@ -1326,6 +1418,34 @@ func TestApplyRequestHeaders_SendsOneContentType(t *testing.T) {
 	}
 }
 
+// Stored inbound headers that do not decode forward nothing, not the
+// part of them that happened to decode.
+func TestApplyRequestHeaders_UndecodableInboundForwardsNothing(
+	t *testing.T,
+) {
+	t.Parallel()
+
+	req, err := http.NewRequestWithContext(
+		context.Background(),
+		http.MethodPost,
+		"https://target.example.com/hook",
+		http.NoBody,
+	)
+	require.NoError(t, err)
+
+	names := delivery.ExportApplyRequestHeaders(
+		req,
+		&database.Event{
+			Headers: `{"X-Custom":["value1"],"X-Broken":"not a list"}`,
+		},
+		nil,
+		"webhooker/dev",
+	)
+
+	assert.Empty(t, names)
+	assert.Empty(t, req.Header.Get("X-Custom"))
+}
+
 func TestProcessDelivery_RoutesToCorrectHandler(
 	t *testing.T,
 ) {
@@ -1333,32 +1453,27 @@ func TestProcessDelivery_RoutesToCorrectHandler(
 
 	db := testWebhookDB(t)
 
-	// The database target archives for real now, so the engine
-	// needs a webhook DB manager to locate the data directory.
-	e := delivery.NewTestEngineWithDB(
-		nil,
-		database.NewTestWebhookDBManager(t.TempDir()),
-		slog.New(slog.NewTextHandler(
-			os.Stderr,
-			&slog.HandlerOptions{Level: slog.LevelDebug},
-		)),
-		&http.Client{Timeout: 5 * time.Second},
-		1,
-	)
+	// The database target archives for real, so the engine needs
+	// the target in the main database and a data directory.
+	env := setupArchiveTest(t)
+	archive := env.seedDatabaseTarget(t)
 
 	tests := []struct {
 		name       string
 		targetType database.TargetType
+		targetID   string
 		wantStatus database.DeliveryStatus
 	}{
 		{
 			"database target",
 			database.TargetTypeDatabase,
+			archive.ID,
 			database.DeliveryStatusDelivered,
 		},
 		{
 			"log target",
 			database.TargetTypeLog,
+			uuid.New().String(),
 			database.DeliveryStatusDelivered,
 		},
 	}
@@ -1368,7 +1483,7 @@ func TestProcessDelivery_RoutesToCorrectHandler(
 			t.Parallel()
 
 			runRoutingSubtest(
-				t, db, e, tt.targetType,
+				t, db, env.eng, tt.targetType, tt.targetID,
 				tt.wantStatus,
 			)
 		})
@@ -1380,6 +1495,7 @@ func runRoutingSubtest(
 	db *gorm.DB,
 	e *delivery.Engine,
 	targetType database.TargetType,
+	targetID string,
 	wantStatus database.DeliveryStatus,
 ) {
 	t.Helper()
@@ -1387,8 +1503,7 @@ func runRoutingSubtest(
 	event := seedEvent(t, db, `{"routing":"test"}`)
 
 	dlv := seedDelivery(
-		t, db, event.ID,
-		uuid.New().String(),
+		t, db, event.ID, targetID,
 		database.DeliveryStatusPending,
 	)
 
@@ -1426,51 +1541,6 @@ func TestMaxInlineBodySize_Constant(t *testing.T) {
 	)
 }
 
-func TestParseSlackConfig_Valid(t *testing.T) {
-	t.Parallel()
-
-	e := testEngine(t, 1)
-
-	cfg, err := e.ExportParseSlackConfig(
-		`{"webhookUrl":"https://hooks.slack.com/services/T00/B00/xxx"}`,
-	)
-
-	require.NoError(t, err)
-
-	assert.Equal(t,
-		"https://hooks.slack.com/services/T00/B00/xxx",
-		cfg.WebhookURL,
-	)
-}
-
-func TestParseSlackConfig_Empty(t *testing.T) {
-	t.Parallel()
-
-	e := testEngine(t, 1)
-
-	_, err := e.ExportParseSlackConfig("")
-
-	assert.Error(t, err,
-		"empty config should return error",
-	)
-}
-
-func TestParseSlackConfig_MissingWebhookURL(
-	t *testing.T,
-) {
-	t.Parallel()
-
-	e := testEngine(t, 1)
-
-	_, err := e.ExportParseSlackConfig(
-		`{"other":"field"}`,
-	)
-
-	assert.Error(t, err,
-		"config without webhook_url should return error",
-	)
-}
-
 func TestFormatSlackMessage_JSONBody(t *testing.T) {
 	t.Parallel()
 
@@ -1567,11 +1637,11 @@ func TestFormatSlackMessage_LargeJSONTruncated(
 }
 
 // buildSlackDelivery creates a database.Delivery
-// with a Slack target config for testing.
+// to a Slack target with the given webhook URL for testing.
 func buildSlackDelivery(
 	dlv database.Delivery,
 	event database.Event,
-	targetID, name, slackCfg string,
+	targetID, name, webhookURL string,
 ) *database.Delivery {
 	d := &database.Delivery{
 		EventID:  event.ID,
@@ -1579,9 +1649,10 @@ func buildSlackDelivery(
 		Status:   dlv.Status,
 		Event:    event,
 		Target: database.Target{
-			Name:   name,
-			Type:   database.TargetTypeSlack,
-			Config: slackCfg,
+			Name:        name,
+			Type:        database.TargetTypeSlack,
+			URL:         webhookURL,
+			MaxAttempts: 1,
 		},
 	}
 	d.ID = dlv.ID
@@ -1618,11 +1689,10 @@ func TestDeliverSlack_Success(t *testing.T) {
 	)
 	defer ts.Close()
 
-	e, targetID, slackCfg, event, dlv :=
-		setupSlackTest(t, db, ts.URL)
+	e, targetID, event, dlv := setupSlackTest(t, db)
 
 	d := buildSlackDelivery(
-		dlv, event, targetID, "test-slack", slackCfg,
+		dlv, event, targetID, "test-slack", ts.URL,
 	)
 
 	e.ExportDeliverSlack(context.TODO(), db, d)
@@ -1641,9 +1711,8 @@ func TestDeliverSlack_Success(t *testing.T) {
 func setupSlackTest(
 	t *testing.T,
 	db *gorm.DB,
-	serverURL string,
 ) (
-	*delivery.Engine, string, string,
+	*delivery.Engine, string,
 	database.Event, database.Delivery,
 ) {
 	t.Helper()
@@ -1651,13 +1720,6 @@ func setupSlackTest(
 	e := testEngine(t, 1)
 	targetID := uuid.New().String()
 
-	cfgBytes, err := json.Marshal(
-		delivery.SlackTargetConfig{
-			WebhookURL: serverURL,
-		},
-	)
-	require.NoError(t, err)
-
 	event := seedEvent(
 		t, db, `{"action":"test","data":"value"}`,
 	)
@@ -1667,7 +1729,7 @@ func setupSlackTest(
 		database.DeliveryStatusPending,
 	)
 
-	return e, targetID, string(cfgBytes), event, dlv
+	return e, targetID, event, dlv
 }
 
 func assertSlackPayload(
@@ -1716,13 +1778,6 @@ func TestDeliverSlack_Failure(t *testing.T) {
 	e := testEngine(t, 1)
 	targetID := uuid.New().String()
 
-	slackCfg, err := json.Marshal(
-		delivery.SlackTargetConfig{
-			WebhookURL: ts.URL,
-		},
-	)
-	require.NoError(t, err)
-
 	event := seedEvent(t, db, `{"test":true}`)
 
 	dlv := seedDelivery(
@@ -1732,7 +1787,7 @@ func TestDeliverSlack_Failure(t *testing.T) {
 
 	d := buildSlackDelivery(
 		dlv, event, targetID,
-		"test-slack-fail", string(slackCfg),
+		"test-slack-fail", ts.URL,
 	)
 
 	e.ExportDeliverSlack(context.TODO(), db, d)
@@ -1746,7 +1801,10 @@ func TestDeliverSlack_Failure(t *testing.T) {
 	)
 }
 
-func TestDeliverSlack_InvalidConfig(t *testing.T) {
+// TestDeliverSlack_NoURL proves a Slack target without a URL, which
+// the forms never store, fails its delivery rather than reporting it
+// delivered.
+func TestDeliverSlack_NoURL(t *testing.T) {
 	t.Parallel()
 
 	db := testWebhookDB(t)
@@ -1765,9 +1823,9 @@ func TestDeliverSlack_InvalidConfig(t *testing.T) {
 		Status:   database.DeliveryStatusPending,
 		Event:    event,
 		Target: database.Target{
-			Name:   "test-slack-bad",
-			Type:   database.TargetTypeSlack,
-			Config: `{"not_webhook_url":"missing"}`,
+			Name:        "test-slack-bad",
+			Type:        database.TargetTypeSlack,
+			MaxAttempts: 1,
 		},
 	}
 	d.ID = dlv.ID
@@ -1804,13 +1862,6 @@ func TestProcessDelivery_RoutesToSlack(t *testing.T) {
 
 	e := testEngine(t, 1)
 
-	slackCfg, err := json.Marshal(
-		delivery.SlackTargetConfig{
-			WebhookURL: ts.URL,
-		},
-	)
-	require.NoError(t, err)
-
 	event := seedEvent(t, db, `{"route":"slack"}`)
 
 	dlv := seedDelivery(
@@ -1820,12 +1871,13 @@ func TestProcessDelivery_RoutesToSlack(t *testing.T) {
 
 	d := buildSlackDelivery(
 		dlv, event, dlv.TargetID,
-		"test-slack-route", string(slackCfg),
+		"test-slack-route", ts.URL,
 	)
 
 	task := &delivery.Task{
-		DeliveryID: dlv.ID,
-		TargetType: database.TargetTypeSlack,
+		DeliveryID:  dlv.ID,
+		TargetType:  database.TargetTypeSlack,
+		MaxAttempts: 1,
 	}
 
 	e.ExportProcessDelivery(
@@ -1875,6 +1927,10 @@ func assertLogLineComplete(
 		"log line must contain the full request headers",
 	)
 
+	assert.Contains(t, out, "raw_query="+strconv.Quote(event.RawQuery),
+		"log line must contain the query string",
+	)
+
 	assert.Contains(t, out, event.EntrypointID,
 		"log line must contain the entrypoint id",
 	)
@@ -1897,6 +1953,7 @@ func TestDeliverLog_LogsFullContent(t *testing.T) {
 	event := seedEvent(
 		t, db, `{"log-body-marker":"abc123"}`,
 	)
+	event.RawQuery = eventQuery
 
 	dlv := seedDelivery(
 		t, db, event.ID, uuid.New().String(),
@@ -1929,7 +1986,7 @@ func TestDeliverLog_LogsFullContent(t *testing.T) {
 func buildSlackRetryDelivery(
 	dlv database.Delivery,
 	event database.Event,
-	targetID, cfg string,
+	targetID, webhookURL string,
 ) *database.Delivery {
 	d := &database.Delivery{
 		EventID:  event.ID,
@@ -1937,10 +1994,10 @@ func buildSlackRetryDelivery(
 		Status:   database.DeliveryStatusPending,
 		Event:    event,
 		Target: database.Target{
-			Name:       "test-slack-retry",
-			Type:       database.TargetTypeSlack,
-			Config:     cfg,
-			MaxRetries: 5,
+			Name:        "test-slack-retry",
+			Type:        database.TargetTypeSlack,
+			URL:         webhookURL,
+			MaxAttempts: 5,
 		},
 	}
 	d.ID = dlv.ID
@@ -1958,11 +2015,6 @@ func TestDeliverSlack_WithRetries_SchedulesRetry(
 	e := testEngine(t, 1)
 	targetID := uuid.New().String()
 
-	slackCfg, err := json.Marshal(
-		delivery.SlackTargetConfig{WebhookURL: ts.URL},
-	)
-	require.NoError(t, err)
-
 	event := seedEvent(t, db, `{"slack":"retry"}`)
 
 	dlv := seedDelivery(
@@ -1971,15 +2023,15 @@ func TestDeliverSlack_WithRetries_SchedulesRetry(
 	)
 
 	d := buildSlackRetryDelivery(
-		dlv, event, targetID, string(slackCfg),
+		dlv, event, targetID, ts.URL,
 	)
 
 	task := &delivery.Task{
-		DeliveryID: dlv.ID,
-		TargetID:   targetID,
-		TargetType: database.TargetTypeSlack,
-		MaxRetries: 5,
-		AttemptNum: 1,
+		DeliveryID:  dlv.ID,
+		TargetID:    targetID,
+		TargetType:  database.TargetTypeSlack,
+		MaxAttempts: 5,
+		AttemptNum:  1,
 	}
 
 	e.ExportProcessDelivery(context.TODO(), db, d, task)

internal/delivery/event_db_isolation_test.go

@@ -69,7 +69,6 @@ func TestEventDBHoldsNoTargetRows(t *testing.T) {
 	))
 	defer ts.Close()
 
-	cfg := iHTTPConfig(ts.URL)
 	targetID := uuid.New().String()
 	dbPath := s.DBMgr.DBPath(s.WebhookID)
 
@@ -85,7 +84,7 @@ func TestEventDBHoldsNoTargetRows(t *testing.T) {
 	)
 	task := iTask(
 		d, event, s.WebhookID, targetID,
-		"leaky-target", cfg, 5, 1, &body,
+		"leaky-target", ts.URL, 5, 1, &body,
 	)
 
 	s.Engine.ExportProcessNewTask(context.TODO(), &task)
@@ -102,7 +101,7 @@ func TestEventDBHoldsNoTargetRows(t *testing.T) {
 	// https://git.eeqj.de/sneak/webhooker/issues/107.
 	iCreateTarget(
 		t, s.MainDB, targetID, s.WebhookID, "leaky-target",
-		database.TargetTypeHTTP, cfg, 5,
+		database.TargetTypeHTTP, ts.URL, 5,
 	)
 
 	rd := iSeedDelivery(
@@ -111,7 +110,7 @@ func TestEventDBHoldsNoTargetRows(t *testing.T) {
 	)
 	rTask := iTask(
 		rd, event, s.WebhookID, targetID,
-		"leaky-target", cfg, 5, 2, &body,
+		"leaky-target", ts.URL, 5, 2, &body,
 	)
 
 	s.Engine.ExportProcessRetryTask(context.TODO(), &rTask)
@@ -138,7 +137,6 @@ func TestEventDBHoldsNoTargetRowsOnFailedDelivery(t *testing.T) {
 	))
 	defer ts.Close()
 
-	cfg := iHTTPConfig(ts.URL)
 	targetID := uuid.New().String()
 
 	event := iSeedEvent(
@@ -152,7 +150,7 @@ func TestEventDBHoldsNoTargetRowsOnFailedDelivery(t *testing.T) {
 	)
 	task := iTask(
 		d, event, s.WebhookID, targetID,
-		"leaky-target", cfg, 0, 1, &body,
+		"leaky-target", ts.URL, 1, 1, &body,
 	)
 
 	s.Engine.ExportProcessNewTask(context.TODO(), &task)

internal/delivery/event_timestamp_test.go

@@ -93,17 +93,6 @@ func (s *tsSink) text(t *testing.T) string {
 	}
 }
 
-func tsSlackConfig(t *testing.T, url string) string {
-	t.Helper()
-
-	data, err := json.Marshal(
-		delivery.SlackTargetConfig{WebhookURL: url},
-	)
-	require.NoError(t, err)
-
-	return string(data)
-}
-
 // tsSeedEvent writes an event whose CreatedAt is tsEventCreatedAt
 // rather than the write time, so an assertion on the rendered
 // timestamp cannot pass by accident against "roughly now".
@@ -142,16 +131,17 @@ func tsSeedEvent(
 // tsSeedTarget writes the slack target row into the main database.
 // The retry path confirms the target still exists before sending.
 func tsSeedTarget(
-	t *testing.T, mainDB *gorm.DB, webhookID, config string,
+	t *testing.T, mainDB *gorm.DB, webhookID, webhookURL string,
 ) database.Target {
 	t.Helper()
 
 	target := database.Target{
-		WebhookID: webhookID,
-		Name:      "slack-sink",
-		Type:      database.TargetTypeSlack,
-		Config:    config,
-		Active:    true,
+		WebhookID:   webhookID,
+		Name:        "slack-sink",
+		Type:        database.TargetTypeSlack,
+		URL:         webhookURL,
+		Active:      true,
+		MaxAttempts: 1,
 	}
 
 	require.NoError(t, mainDB.Create(&target).Error)
@@ -175,8 +165,8 @@ func tsTask(
 		TargetID:     target.ID,
 		TargetName:   target.Name,
 		TargetType:   database.TargetTypeSlack,
-		TargetConfig: target.Config,
-		MaxRetries:   0,
+		TargetURL:    target.URL,
+		MaxAttempts:  1,
 		Method:       event.Method,
 		Headers:      event.Headers,
 		ContentType:  event.ContentType,
@@ -225,8 +215,7 @@ func (c tsCase) run(t *testing.T) (iSetup, database.Delivery, string) {
 	s := newISetup(t)
 	sink := newTSSink(t)
 
-	cfg := tsSlackConfig(t, sink.URL)
-	target := tsSeedTarget(t, s.MainDB, s.WebhookID, cfg)
+	target := tsSeedTarget(t, s.MainDB, s.WebhookID, sink.URL)
 	event := tsSeedEvent(t, s.WebhookDB, s.WebhookID)
 
 	d := iSeedDelivery(
@@ -337,8 +326,7 @@ func TestFormatSlackMessageOverTaskReconstructedEvent(
 
 	s := newISetup(t)
 
-	cfg := tsSlackConfig(t, tsUndeliverableHook)
-	target := tsSeedTarget(t, s.MainDB, s.WebhookID, cfg)
+	target := tsSeedTarget(t, s.MainDB, s.WebhookID, tsUndeliverableHook)
 	event := tsSeedEvent(t, s.WebhookDB, s.WebhookID)
 
 	d := iSeedDelivery(
@@ -409,8 +397,7 @@ func TestEventReconstructionSurvivesAReapedRow(t *testing.T) {
 
 	s := newISetup(t)
 
-	cfg := tsSlackConfig(t, tsUndeliverableHook)
-	target := tsSeedTarget(t, s.MainDB, s.WebhookID, cfg)
+	target := tsSeedTarget(t, s.MainDB, s.WebhookID, tsUndeliverableHook)
 	event := tsSeedEvent(t, s.WebhookDB, s.WebhookID)
 
 	d := iSeedDelivery(

internal/delivery/export_test.go

@@ -9,18 +9,14 @@ import (
 	"net/url"
 	"time"
 
+	"github.com/prometheus/client_golang/prometheus"
 	"go.uber.org/fx"
 	"gorm.io/gorm"
+	"sneak.berlin/go/webhooker/internal/archive"
 	"sneak.berlin/go/webhooker/internal/database"
 	"sneak.berlin/go/webhooker/internal/metrics"
 )
 
-// ErrExportArchiveWriterEvicted exposes the sentinel returned by
-// an evicted archive writer. It carries the Err prefix rather
-// than this file's usual Export one because it is a sentinel
-// error.
-var ErrExportArchiveWriterEvicted = errArchiveWriterEvicted
-
 // Exported constants for test access.
 const (
 	ExportDeliveryChannelSize     = deliveryChannelSize
@@ -40,11 +36,6 @@ const (
 	ExportPendingSweepMinAge = pendingSweepMinAge
 )
 
-// ExportIsBlockedIP exposes isBlockedIP for testing.
-func ExportIsBlockedIP(ip net.IP) bool {
-	return isBlockedIP(ip)
-}
-
 // NewTestGuard builds an SSRF Guard from an explicit egress
 // allowlist, without going through config. Passing no prefixes
 // yields the default guard, which blocks every private/reserved
@@ -70,6 +61,11 @@ func ExportBlockedNetworks() []*net.IPNet {
 	return blockedNetworks
 }
 
+// ExportBlockedPublicNetworks exposes blockedPublicNetworks.
+func ExportBlockedPublicNetworks() []*net.IPNet {
+	return blockedPublicNetworks
+}
+
 // ExportIsForwardableHeader exposes isForwardableHeader.
 func ExportIsForwardableHeader(name string) bool {
 	return isForwardableHeader(name)
@@ -81,9 +77,10 @@ func ExportIsForwardableHeader(name string) bool {
 func ExportApplyRequestHeaders(
 	req *http.Request,
 	event *database.Event,
-	cfg *HTTPTargetConfig,
+	configured map[string]string,
+	userAgent string,
 ) []string {
-	return applyRequestHeaders(req, event, cfg)
+	return applyRequestHeaders(req, event, configured, userAgent)
 }
 
 // ExportTruncate exposes truncate for testing.
@@ -140,9 +137,10 @@ func (e *Engine) ExportDeliverSlack(
 	d *database.Delivery,
 ) {
 	task := &Task{
-		DeliveryID: d.ID,
-		TargetID:   d.TargetID,
-		AttemptNum: 1,
+		DeliveryID:  d.ID,
+		TargetID:    d.TargetID,
+		MaxAttempts: d.Target.MaxAttempts,
+		AttemptNum:  1,
 	}
 
 	e.targets[database.TargetTypeSlack].Deliver(
@@ -150,6 +148,21 @@ func (e *Engine) ExportDeliverSlack(
 	)
 }
 
+// ExportUpdateDeliveryStatus exposes updateDeliveryStatus. It passes no
+// target type, so no metric moves.
+func (e *Engine) ExportUpdateDeliveryStatus(
+	webhookDB *gorm.DB,
+	d *database.Delivery,
+	status database.DeliveryStatus,
+) error {
+	return e.updateDeliveryStatus(webhookDB, d, "", status)
+}
+
+// ExportNotify exposes notify.
+func (e *Engine) ExportNotify(tasks []Task) {
+	e.notify(tasks)
+}
+
 // ExportProcessNewTask exposes processNewTask.
 func (e *Engine) ExportProcessNewTask(
 	ctx context.Context, task *Task,
@@ -200,37 +213,31 @@ func (e *Engine) ExportSetCircuitBreaker(
 	e.httpTarget.circuitBreakers.Store(targetID, cb)
 }
 
-// ExportParseHTTPConfig exposes parseHTTPConfig.
-func (e *Engine) ExportParseHTTPConfig(
-	configJSON string,
-) (*HTTPTargetConfig, error) {
-	return parseHTTPConfig(configJSON)
-}
-
-// ExportParseSlackConfig exposes parseSlackConfig.
-func (e *Engine) ExportParseSlackConfig(
-	configJSON string,
-) (*SlackTargetConfig, error) {
-	return parseSlackConfig(configJSON)
+// ExportSetSlackCircuitBreaker is ExportSetCircuitBreaker for the
+// slack target.
+func (e *Engine) ExportSetSlackCircuitBreaker(
+	targetID string, cb *CircuitBreaker,
+) {
+	e.slackTarget.circuitBreakers.Store(targetID, cb)
 }
 
 // ExportDoHTTPRequest exposes the http target's
 // doHTTPRequest.
 func (e *Engine) ExportDoHTTPRequest(
 	ctx context.Context,
-	cfg *HTTPTargetConfig,
+	target *database.Target,
 	event *database.Event,
 ) (int, string, int64, error) {
-	return e.httpTarget.doHTTPRequest(ctx, cfg, event)
+	return e.httpTarget.doHTTPRequest(ctx, target, event)
 }
 
 // ExportClientForRequest exposes the http target's
 // clientForRequest.
 func (e *Engine) ExportClientForRequest(
-	cfg *HTTPTargetConfig,
+	timeoutSeconds int,
 	originScoped []string,
 ) *http.Client {
-	return e.httpTarget.clientForRequest(cfg, originScoped)
+	return e.httpTarget.clientForRequest(timeoutSeconds, originScoped)
 }
 
 // ErrExportTooManyRedirects exposes the sentinel the redirect
@@ -265,32 +272,27 @@ func (e *Engine) ExportRecoverPendingDeliveries(
 	ctx context.Context,
 	webhookDB *gorm.DB,
 	webhookID string,
+	atStart bool,
 ) {
 	e.recoverPendingDeliveries(
-		ctx, webhookDB, webhookID,
+		ctx, webhookDB, webhookID, atStart,
 	)
 }
 
 // ExportRecoverWebhookDeliveries exposes
 // recoverWebhookDeliveries.
 func (e *Engine) ExportRecoverWebhookDeliveries(
-	ctx context.Context, webhookID string,
+	ctx context.Context, webhookID string, atStart bool,
 ) {
-	e.recoverWebhookDeliveries(ctx, webhookID)
+	e.recoverWebhookDeliveries(ctx, webhookID, atStart)
 }
 
-// ExportRecoverInFlight exposes recoverInFlight.
-func (e *Engine) ExportRecoverInFlight(
-	ctx context.Context,
+// ExportRecoverDeliveries exposes recoverDeliveries, the recovery
+// routine.
+func (e *Engine) ExportRecoverDeliveries(
+	ctx context.Context, atStart bool,
 ) {
-	e.recoverInFlight(ctx)
-}
-
-// ExportSweepWebhookRetries exposes sweepWebhookRetries.
-func (e *Engine) ExportSweepWebhookRetries(
-	ctx context.Context, webhookID string,
-) {
-	e.sweepWebhookRetries(ctx, webhookID)
+	e.recoverDeliveries(ctx, atStart)
 }
 
 // ExportStart exposes start for testing.
@@ -337,9 +339,9 @@ func (e *Engine) ExportRetainDelivery(deliveryID string) bool {
 
 // ExportRecoverRetryingDeliveries exposes recoverRetryingDeliveries.
 func (e *Engine) ExportRecoverRetryingDeliveries(
-	webhookDB *gorm.DB, webhookID string,
+	ctx context.Context, webhookDB *gorm.DB, webhookID string,
 ) {
-	e.recoverRetryingDeliveries(webhookDB, webhookID)
+	e.recoverRetryingDeliveries(ctx, webhookDB, webhookID)
 }
 
 // ExportFailMissingTarget exposes failMissingTarget, so a test can hand
@@ -378,7 +380,8 @@ func (e *Engine) ExportRetryCh() chan Task {
 }
 
 // NewTestEngine creates an Engine for unit tests without
-// database dependencies.
+// database dependencies. Its archive writers have no data
+// directory, so a delivery to a database target fails.
 func NewTestEngine(
 	log *slog.Logger,
 	client *http.Client,
@@ -389,7 +392,8 @@ func NewTestEngine(
 		deliveryCh: make(chan Task, deliveryChannelSize),
 		retryCh:    make(chan Task, retryChannelSize),
 		workers:    workers,
-		mtr:        metrics.Default(),
+		mtr:        metrics.New(prometheus.NewRegistry()),
+		archives:   archive.NewWriters(archive.WritersParams{Logger: log}),
 	}
 	e.initTargets(client)
 
@@ -402,9 +406,10 @@ func NewTestEngineSmallRetry(
 	log *slog.Logger,
 ) *Engine {
 	e := &Engine{
-		log:     log,
-		retryCh: make(chan Task, 1),
-		mtr:     metrics.Default(),
+		log:      log,
+		retryCh:  make(chan Task, 1),
+		mtr:      metrics.New(prometheus.NewRegistry()),
+		archives: archive.NewWriters(archive.WritersParams{Logger: log}),
 	}
 	e.initTargets(nil)
 
@@ -412,7 +417,8 @@ func NewTestEngineSmallRetry(
 }
 
 // NewTestEngineWithDB creates an Engine with a real
-// database and dbManager for integration tests.
+// database and dbManager for integration tests, and archive
+// writers of its own over the same two.
 func NewTestEngineWithDB(
 	db *database.Database,
 	dbMgr *database.WebhookDBManager,
@@ -427,16 +433,25 @@ func NewTestEngineWithDB(
 		deliveryCh: make(chan Task, deliveryChannelSize),
 		retryCh:    make(chan Task, retryChannelSize),
 		workers:    workers,
-		mtr:        metrics.Default(),
+		mtr:        metrics.New(prometheus.NewRegistry()),
+		archives: archive.NewWriters(archive.WritersParams{
+			Database:  db,
+			DBManager: dbMgr,
+			Logger:    log,
+		}),
 	}
 	e.initTargets(client)
 
 	return e
 }
 
+// ExportArchives returns the engine's archive writers.
+func (e *Engine) ExportArchives() *archive.Writers {
+	return e.archives
+}
+
 // ExportSetMetrics substitutes the engine's metric set, so a test can
-// assert on collectors registered on a private registry instead of
-// the process-wide ones every other test is also moving.
+// assert on collectors registered on a registry it holds.
 func (e *Engine) ExportSetMetrics(mtr *metrics.Set) {
 	e.mtr = mtr
 }
@@ -457,252 +472,3 @@ func NewTestCircuitBreaker(
 		cooldown:  cooldown,
 	}
 }
-
-// ExportArchivedEvent aliases the archive row type so black-box
-// tests can construct and read archive rows.
-type ExportArchivedEvent = archivedEvent
-
-// ExportArchiveWriter wraps an archiveWriter so black-box tests
-// can exercise the per-webhook archive file mechanics.
-type ExportArchiveWriter struct {
-	w *archiveWriter
-}
-
-// NewExportArchiveWriter builds an archive writer for tests,
-// optionally overriding the reopen debounce (a non-positive
-// debounce keeps the production default).
-func NewExportArchiveWriter(
-	path string, log *slog.Logger, debounce time.Duration,
-) *ExportArchiveWriter {
-	w := newArchiveWriter(path, log)
-	if debounce > 0 {
-		w.debounce = debounce
-	}
-
-	return &ExportArchiveWriter{w: w}
-}
-
-// Write archives a row through the writer.
-func (e *ExportArchiveWriter) Write(
-	row ExportArchivedEvent, expiry time.Duration,
-) error {
-	return e.w.write(row, expiry)
-}
-
-// Open opens the archive file, pruning when expiry is positive.
-func (e *ExportArchiveWriter) Open(expiry time.Duration) error {
-	return e.w.open(expiry)
-}
-
-// Reopen closes and reopens the archive file.
-func (e *ExportArchiveWriter) Reopen(
-	expiry time.Duration,
-) error {
-	return e.w.reopen(expiry)
-}
-
-// Reopens reports how many times the file has been opened.
-func (e *ExportArchiveWriter) Reopens() int {
-	return e.w.reopens
-}
-
-// DB returns the writer's current open handle for row
-// inspection in tests.
-func (e *ExportArchiveWriter) DB() *gorm.DB {
-	return e.w.db
-}
-
-// Path returns the archive file the writer owns.
-func (e *ExportArchiveWriter) Path() string {
-	return e.w.path
-}
-
-// OpenExisting opens the archive without permitting creation,
-// the way the idle sweep does.
-func (e *ExportArchiveWriter) OpenExisting(
-	expiry time.Duration,
-) error {
-	return e.w.openMode(archiveModeExisting, expiry)
-}
-
-// SweepExpired runs an idle sweep of the archive.
-func (e *ExportArchiveWriter) SweepExpired(
-	expiry time.Duration,
-) error {
-	return e.w.sweepExpired(expiry)
-}
-
-// Evict marks the writer evicted and closes its handle, exactly
-// as leaving the registry does.
-func (e *ExportArchiveWriter) Evict() {
-	e.w.evict()
-}
-
-// HandleOpen reports whether the writer currently holds an open
-// archive handle.
-func (e *ExportArchiveWriter) HandleOpen() bool {
-	e.w.mu.Lock()
-	defer e.w.mu.Unlock()
-
-	return e.w.db != nil
-}
-
-// Same reports whether both wrappers refer to the very same
-// underlying archive writer, so a test can prove a registry entry
-// is the writer it was handed rather than a replacement.
-func (e *ExportArchiveWriter) Same(
-	other *ExportArchiveWriter,
-) bool {
-	return other != nil && e.w == other.w
-}
-
-// ExportArchiveWriterFor returns the archive writer the registry
-// currently caches for a webhook, or nil when none is cached. It
-// never creates one, so a test can hold a reference to the very
-// writer an eviction is about to detach.
-func (e *Engine) ExportArchiveWriterFor(
-	webhookID string,
-) *ExportArchiveWriter {
-	e.dbTarget.mu.Lock()
-	defer e.dbTarget.mu.Unlock()
-
-	w, ok := e.dbTarget.writers[webhookID]
-	if !ok {
-		return nil
-	}
-
-	return &ExportArchiveWriter{w: w}
-}
-
-// ExportHasArchiveWriter reports whether the database target
-// currently caches an archive writer for a webhook.
-func (e *Engine) ExportHasArchiveWriter(
-	webhookID string,
-) bool {
-	e.dbTarget.mu.Lock()
-	defer e.dbTarget.mu.Unlock()
-
-	_, ok := e.dbTarget.writers[webhookID]
-
-	return ok
-}
-
-// ExportArchiveHandleOpen reports whether the cached archive
-// writer for a webhook holds an open database handle. It
-// returns false when no writer is cached.
-func (e *Engine) ExportArchiveHandleOpen(
-	webhookID string,
-) bool {
-	e.dbTarget.mu.Lock()
-	w, ok := e.dbTarget.writers[webhookID]
-	e.dbTarget.mu.Unlock()
-
-	if !ok {
-		return false
-	}
-
-	w.mu.Lock()
-	defer w.mu.Unlock()
-
-	return w.db != nil
-}
-
-// ExportEnsureArchiveWriter creates (if needed) and returns the
-// archive file path of the cached writer for a webhook, so a
-// test can prime the registry the way a delivery would.
-func (e *Engine) ExportEnsureArchiveWriter(
-	webhookID string,
-) (string, error) {
-	w, err := e.dbTarget.writerFor(webhookID)
-	if err != nil {
-		return "", err
-	}
-
-	return w.path, nil
-}
-
-// ExportSweepWriterFor takes a webhook's registry writer exactly
-// as the idle sweep does, reporting whether the sweep had to
-// create the entry. It lets a test drive the registry through the
-// sweep's own entry point instead of choreographing goroutines.
-func (e *Engine) ExportSweepWriterFor(
-	webhookID string,
-) (*ExportArchiveWriter, bool, error) {
-	w, created, err := e.dbTarget.sweepWriterFor(webhookID)
-	if err != nil {
-		return nil, false, err
-	}
-
-	return &ExportArchiveWriter{w: w}, created, nil
-}
-
-// ExportReleaseSweepWriter releases a sweep-created registry entry
-// exactly as a finished sweep does.
-func (e *Engine) ExportReleaseSweepWriter(
-	webhookID string, w *ExportArchiveWriter,
-) {
-	e.dbTarget.releaseSweepWriter(webhookID, w.w)
-}
-
-// NewTestArchiveSweeper builds an ArchiveSweeper backed by the
-// given main database and engine, without the fx lifecycle.
-// Intended for tests.
-func NewTestArchiveSweeper(
-	db *database.Database,
-	eng *Engine,
-	log *slog.Logger,
-) *ArchiveSweeper {
-	return &ArchiveSweeper{
-		db:       db,
-		eng:      eng,
-		log:      log,
-		interval: time.Hour,
-	}
-}
-
-// ExportSweep runs a single archive sweep synchronously for
-// tests.
-func (s *ArchiveSweeper) ExportSweep(ctx context.Context) {
-	s.sweep(ctx)
-}
-
-// ExportStart starts the sweeper's background loop for tests.
-func (s *ArchiveSweeper) ExportStart() {
-	s.start()
-}
-
-// ExportRegisterHooks registers the sweeper's real fx lifecycle
-// hooks on a lifecycle supplied by a test, so a test can drive
-// the exact OnStart/OnStop functions the application runs and
-// hand OnStart the kind of context fx actually supplies.
-func (s *ArchiveSweeper) ExportRegisterHooks(lc fx.Lifecycle) {
-	s.registerHooks(lc)
-}
-
-// ExportStop stops the sweeper's background loop for tests.
-func (s *ArchiveSweeper) ExportStop(ctx context.Context) error {
-	return s.stop(ctx)
-}
-
-// ExportWedgeLoop adds a goroutine to the sweeper's WaitGroup
-// that never observes cancellation and returns only when release
-// is closed. It stands in for a prune stuck on a locked archive.
-func (s *ArchiveSweeper) ExportWedgeLoop(
-	release <-chan struct{},
-) {
-	s.wg.Go(func() {
-		<-release
-	})
-}
-
-// ExportSetInterval overrides the sweep interval for tests.
-func (s *ArchiveSweeper) ExportSetInterval(d time.Duration) {
-	s.interval = d
-}
-
-// ExportParseArchiveExpiry exposes parseArchiveExpiry.
-func ExportParseArchiveExpiry(
-	configJSON string,
-) (time.Duration, error) {
-	return parseArchiveExpiry(configJSON)
-}

internal/delivery/inflight.go

@@ -6,10 +6,10 @@ import "sync"
 //
 // A delivery is owned from the moment a task for it is handed to a
 // channel or to a retry timer until the engine has no further plan for
-// it in memory. Restart recovery and both arms of the periodic sweep
-// re-dispatch only deliveries the set does not hold, which is what
-// makes them exact rather than a guess about how long a row has sat at
-// pending.
+// it in memory. The recovery routine, at start and on every tick of the
+// sweep, re-dispatches only deliveries the set does not hold, which is
+// what makes it exact rather than a guess about how long a row has sat
+// at pending.
 //
 // This replaces reasoning from timestamps. A delivery's row says
 // pending from creation until its outcome is written, which covers
@@ -25,8 +25,8 @@ import "sync"
 // In-memory state is sufficient because a data directory admits one
 // process: internal/datadir takes an flock on it at startup and a
 // second instance refuses to run. Deliveries owned by a process that
-// died are not in any successor's set, and restart recovery is what
-// picks those up.
+// died are not in any successor's set, and the recovery routine's run
+// at start is what picks those up.
 //
 // References are counted rather than held as a plain set because
 // ownership outlives the worker that took it. A target that schedules
@@ -61,9 +61,9 @@ func (s *inflightSet) retain(deliveryID string) {
 
 // retainIdle takes the first reference on a delivery, and reports
 // whether it got it. It fails when the engine already owns the
-// delivery, which is what makes two claimants — restart recovery and
-// the sweep run concurrently, or two sweep arms — mutually exclusive
-// rather than merely atomic.
+// delivery, which is what makes two claimants — notify and the
+// recovery routine, say — mutually exclusive rather than merely
+// atomic.
 func (s *inflightSet) retainIdle(deliveryID string) bool {
 	s.mu.Lock()
 	defer s.mu.Unlock()

internal/delivery/inflight_test.go

@@ -2,8 +2,6 @@ package delivery_test
 
 import (
 	"context"
-	"path/filepath"
-	"strings"
 	"sync"
 	"testing"
 	"time"
@@ -32,7 +30,7 @@ func fSweepSetup(
 
 	iCreateTarget(t, s.MainDB, targetID,
 		s.WebhookID, name,
-		database.TargetTypeLog, "", 0,
+		database.TargetTypeLog, "", 1,
 	)
 
 	require.NoError(t, s.MainDB.Create(&database.Webhook{
@@ -48,8 +46,9 @@ func fSweepSetup(
 //
 // Every caller drives the dispatch paths synchronously and has already
 // waited for them to return, so anything they queued is in the channel
-// by now. The short grace covers nothing but scheduler jitter, and is
-// kept small because one of these tests runs the drain forty times.
+// by now, and nothing is waited for. A timer here would race the queued
+// tasks: on a busy host it can be due by the time select looks, and
+// select picks at random among the cases that are ready.
 func fDrain(e *delivery.Engine) []delivery.Task {
 	var out []delivery.Task
 
@@ -59,39 +58,12 @@ func fDrain(e *delivery.Engine) []delivery.Task {
 			out = append(out, task)
 		case task := <-e.ExportRetryCh():
 			out = append(out, task)
-		case <-time.After(25 * time.Millisecond):
+		default:
 			return out
 		}
 	}
 }
 
-// TestArchiveHandleIsWAL closes the last gap in the durability
-// evidence: the main and per-webhook tiers each assert their journal
-// mode on a live handle, and the archive tier gets its settings from
-// the same code path but nothing checked the running file.
-func TestArchiveHandleIsWAL(t *testing.T) {
-	t.Parallel()
-
-	w := delivery.NewExportArchiveWriter(
-		filepath.Join(t.TempDir(), "archive-wal.db"),
-		archiveTestLogger(), 0,
-	)
-
-	require.NoError(t, w.Open(0))
-
-	var mode string
-
-	row := w.DB().Raw("pragma journal_mode").Row()
-	require.NoError(t, row.Scan(&mode))
-	assert.Equal(t, "wal", strings.ToLower(mode))
-
-	var busy string
-
-	row = w.DB().Raw("pragma busy_timeout").Row()
-	require.NoError(t, row.Scan(&busy))
-	assert.Equal(t, "10000", busy)
-}
-
 // TestSweepLeavesAQueuedDeliveryAlone is the case the age bound cannot
 // see. The delivery is queued and untouched, so its row is arbitrarily
 // old and still perfectly healthy; only ownership distinguishes it
@@ -112,9 +84,9 @@ func TestSweepLeavesAQueuedDeliveryAlone(t *testing.T) {
 	)
 	rAgePending(t, s.WebhookDB, d.ID)
 
-	// Queued exactly as the receiver queues it, and never dequeued:
+	// Queued exactly as StoreEvent queues it, and never dequeued:
 	// no workers are running in this engine.
-	s.Engine.Notify([]delivery.Task{{
+	s.Engine.ExportNotify([]delivery.Task{{
 		DeliveryID: d.ID,
 		EventID:    event.ID,
 		WebhookID:  s.WebhookID,
@@ -123,8 +95,8 @@ func TestSweepLeavesAQueuedDeliveryAlone(t *testing.T) {
 
 	require.Equal(t, 1, s.Engine.ExportInflightHeld())
 
-	s.Engine.ExportSweepWebhookRetries(
-		context.Background(), s.WebhookID,
+	s.Engine.ExportRecoverWebhookDeliveries(
+		context.Background(), s.WebhookID, onTick,
 	)
 
 	tasks := fDrain(s.Engine)
@@ -135,9 +107,11 @@ func TestSweepLeavesAQueuedDeliveryAlone(t *testing.T) {
 	)
 }
 
-// TestRecoveryAndSweepDoNotDoubleDispatch drives the two entry points
-// the engine starts concurrently against one aged pending row. Before
-// ownership they both dispatched it.
+// TestRecoveryAndSweepDoNotDoubleDispatch drives the recovery routine's
+// run at start and a tick of the sweep at once against one aged pending
+// row. The engine runs them one after the other, but notify can race
+// either, and ownership is what keeps any two claimants from both
+// sending. Before ownership the two runs both dispatched the row.
 func TestRecoveryAndSweepDoNotDoubleDispatch(t *testing.T) {
 	t.Parallel()
 
@@ -161,12 +135,12 @@ func TestRecoveryAndSweepDoNotDoubleDispatch(t *testing.T) {
 
 		wg.Go(func() {
 			s.Engine.ExportRecoverPendingDeliveries(
-				ctx, s.WebhookDB, s.WebhookID,
+				ctx, s.WebhookDB, s.WebhookID, atStart,
 			)
 		})
 		wg.Go(func() {
-			s.Engine.ExportSweepWebhookRetries(
-				ctx, s.WebhookID,
+			s.Engine.ExportRecoverWebhookDeliveries(
+				ctx, s.WebhookID, onTick,
 			)
 		})
 		wg.Wait()
@@ -228,7 +202,7 @@ func TestOwnershipIsReleasedAfterDelivery(t *testing.T) {
 
 	iCreateTarget(t, s.MainDB, targetID,
 		s.WebhookID, "released",
-		database.TargetTypeLog, "", 0,
+		database.TargetTypeLog, "", 1,
 	)
 
 	event := iSeedEvent(
@@ -250,7 +224,7 @@ func TestOwnershipIsReleasedAfterDelivery(t *testing.T) {
 
 	body := `{"released":true}`
 
-	s.Engine.Notify([]delivery.Task{{
+	s.Engine.ExportNotify([]delivery.Task{{
 		DeliveryID:   d.ID,
 		EventID:      event.ID,
 		WebhookID:    s.WebhookID,
@@ -274,10 +248,11 @@ func TestOwnershipIsReleasedAfterDelivery(t *testing.T) {
 }
 
 // TestNotifyAfterRecoveryDoesNotSendAgain is the startup race of
-// https://git.eeqj.de/sneak/webhooker/issues/299. The receiver has
-// written a delivery, restart recovery finds it pending, sends it and
-// releases it, and only then does the receiver's Notify for it arrive.
-// Nothing owns the delivery by then, so Notify takes it.
+// https://git.eeqj.de/sneak/webhooker/issues/299. StoreEvent has
+// written a delivery, the recovery routine's run at start finds it
+// pending, sends it and releases it, and only then does StoreEvent's
+// notify for it arrive. Nothing owns the delivery by then, so notify
+// takes it.
 func TestNotifyAfterRecoveryDoesNotSendAgain(t *testing.T) {
 	t.Parallel()
 
@@ -301,7 +276,8 @@ func TestNotifyAfterRecoveryDoesNotSendAgain(t *testing.T) {
 		)
 	}()
 
-	// Restart recovery sends the delivery and lets it go.
+	// The recovery routine's run at start sends the delivery and lets
+	// it go.
 	iWaitForDelivered(t, s.WebhookDB, d.ID)
 	require.Eventually(
 		t,
@@ -313,7 +289,7 @@ func TestNotifyAfterRecoveryDoesNotSendAgain(t *testing.T) {
 
 	body := event.Body
 
-	s.Engine.Notify([]delivery.Task{{
+	s.Engine.ExportNotify([]delivery.Task{{
 		DeliveryID:   d.ID,
 		EventID:      event.ID,
 		WebhookID:    s.WebhookID,
@@ -324,7 +300,7 @@ func TestNotifyAfterRecoveryDoesNotSendAgain(t *testing.T) {
 		EntrypointID: event.EntrypointID,
 	}})
 
-	// Notify took the delivery, and a worker releases it once it has
+	// notify took the delivery, and a worker releases it once it has
 	// run the task.
 	require.Eventually(
 		t,
@@ -362,7 +338,7 @@ func TestRetryingRecoverySkipsASuccessfulResult(t *testing.T) {
 	rSeedResult(t, s.WebhookDB, d.ID, 2, true)
 
 	s.Engine.ExportRecoverRetryingDeliveries(
-		s.WebhookDB, s.WebhookID,
+		context.Background(), s.WebhookDB, s.WebhookID,
 	)
 
 	assert.Empty(
@@ -377,8 +353,8 @@ func TestRetryingRecoverySkipsASuccessfulResult(t *testing.T) {
 	)
 }
 
-// TestRetryingSweepSkipsASuccessfulResult is the same rule on the
-// periodic sweep's retrying arm.
+// TestRetryingSweepSkipsASuccessfulResult is the same rule on a tick of
+// the sweep.
 func TestRetryingSweepSkipsASuccessfulResult(t *testing.T) {
 	t.Parallel()
 
@@ -396,8 +372,8 @@ func TestRetryingSweepSkipsASuccessfulResult(t *testing.T) {
 	rSeedResult(t, s.WebhookDB, d.ID, 1, false)
 	rSeedResult(t, s.WebhookDB, d.ID, 2, true)
 
-	s.Engine.ExportSweepWebhookRetries(
-		context.Background(), s.WebhookID,
+	s.Engine.ExportRecoverWebhookDeliveries(
+		context.Background(), s.WebhookID, onTick,
 	)
 
 	assert.Empty(t, fDrain(s.Engine))
@@ -448,8 +424,8 @@ func TestScheduledRetryIsNotSweptDuringBackoff(t *testing.T) {
 
 	require.Equal(t, 1, s.Engine.ExportInflightHeld())
 
-	s.Engine.ExportSweepWebhookRetries(
-		context.Background(), s.WebhookID,
+	s.Engine.ExportRecoverWebhookDeliveries(
+		context.Background(), s.WebhookID, onTick,
 	)
 
 	assert.Empty(
@@ -461,7 +437,8 @@ func TestScheduledRetryIsNotSweptDuringBackoff(t *testing.T) {
 
 // TestRedispatchStampsTheRow pins the cadence control: a stranded
 // delivery that has just been handed out is not selected again by the
-// next tick a minute later.
+// next tick a minute later. The stamp is stored in the same form as
+// created_at.
 func TestRedispatchStampsTheRow(t *testing.T) {
 	t.Parallel()
 
@@ -480,7 +457,7 @@ func TestRedispatchStampsTheRow(t *testing.T) {
 
 	ctx := context.Background()
 
-	s.Engine.ExportSweepWebhookRetries(ctx, s.WebhookID)
+	s.Engine.ExportRecoverWebhookDeliveries(ctx, s.WebhookID, onTick)
 	require.Len(t, fDrain(s.Engine), 1)
 
 	var row database.Delivery
@@ -492,4 +469,13 @@ func TestRedispatchStampsTheRow(t *testing.T) {
 		"a re-dispatched delivery must be stamped so the "+
 			"next tick does not select it again",
 	)
+
+	var createdAt, updatedAt string
+
+	require.NoError(t, s.WebhookDB.Raw(
+		`SELECT CAST(created_at AS TEXT), CAST(updated_at AS TEXT)
+		FROM deliveries WHERE id = ?`, d.ID,
+	).Row().Scan(&createdAt, &updatedAt))
+	assertStoredTime(t, createdAt)
+	assertStoredTime(t, updatedAt)
 }

internal/delivery/metrics_test.go

@@ -35,9 +35,8 @@ const (
 )
 
 // mIsolate gives the setup's engine a metric set registered on a
-// private registry. The process-wide collectors are moved by every
-// other delivery test running in parallel, so exact assertions are
-// only possible against a registry this test owns.
+// registry this test holds, so its exact assertions can gather from
+// it.
 func mIsolate(
 	t *testing.T, s iSetup,
 ) *prometheus.Registry {
@@ -193,7 +192,7 @@ func mDeliverOK(t *testing.T, s iSetup) {
 	body := event.Body
 	task := iTask(
 		d, event, s.WebhookID, targetID,
-		"metrics-ok", iHTTPConfig(ts.URL), 3, 1, &body,
+		"metrics-ok", ts.URL, 3, 1, &body,
 	)
 
 	s.Engine.ExportProcessNewTask(context.TODO(), &task)
@@ -227,18 +226,17 @@ func mExhaustRetries(t *testing.T, s iSetup) {
 	)
 
 	body := event.Body
-	cfg := iHTTPConfig(ts.URL)
 
 	// The retry below is only run if its target still exists; see
 	// https://git.eeqj.de/sneak/webhooker/issues/107.
 	iCreateTarget(
 		t, s.MainDB, targetID, s.WebhookID, "metrics-fail",
-		database.TargetTypeHTTP, cfg, 2,
+		database.TargetTypeHTTP, ts.URL, 2,
 	)
 
 	first := iTask(
 		d, event, s.WebhookID, targetID,
-		"metrics-fail", cfg, 2, 1, &body,
+		"metrics-fail", ts.URL, 2, 1, &body,
 	)
 
 	s.Engine.ExportProcessNewTask(context.TODO(), &first)
@@ -252,7 +250,7 @@ func mExhaustRetries(t *testing.T, s iSetup) {
 	// deterministic and off the wall clock.
 	second := iTask(
 		d, event, s.WebhookID, targetID,
-		"metrics-fail", cfg, 2, 2, &body,
+		"metrics-fail", ts.URL, 2, 2, &body,
 	)
 
 	s.Engine.ExportProcessRetryTask(
@@ -290,22 +288,21 @@ func TestDeliveryMetrics_CircuitBreakerGauge(t *testing.T) {
 	)
 
 	body := event.Body
-	cfg := iHTTPConfig(ts.URL)
 
-	// A retry budget above the failure threshold, so the breaker
+	// An attempt budget above the failure threshold, so the breaker
 	// rather than the budget is what stops the delivery.
-	maxRetries := delivery.ExportDefaultFailureThreshold + 5
+	maxAttempts := delivery.ExportDefaultFailureThreshold + 5
 
 	// The retries below are only run if their target still exists;
 	// see https://git.eeqj.de/sneak/webhooker/issues/107.
 	iCreateTarget(
 		t, s.MainDB, targetID, s.WebhookID, "metrics-trip",
-		database.TargetTypeHTTP, cfg, maxRetries,
+		database.TargetTypeHTTP, ts.URL, maxAttempts,
 	)
 
 	first := iTask(
 		d, event, s.WebhookID, targetID,
-		"metrics-trip", cfg, maxRetries, 1, &body,
+		"metrics-trip", ts.URL, maxAttempts, 1, &body,
 	)
 
 	s.Engine.ExportProcessNewTask(context.TODO(), &first)
@@ -317,7 +314,7 @@ func TestDeliveryMetrics_CircuitBreakerGauge(t *testing.T) {
 		ExportDefaultFailureThreshold; attempt++ {
 		task := iTask(
 			d, event, s.WebhookID, targetID,
-			"metrics-trip", cfg, maxRetries, attempt, &body,
+			"metrics-trip", ts.URL, maxAttempts, attempt, &body,
 		)
 
 		s.Engine.ExportProcessRetryTask(
@@ -364,17 +361,16 @@ func TestDeliveryMetrics_BreakerBlockedIsNotAnAttempt(
 	)
 
 	body := event.Body
-	cfg := iHTTPConfig(ts.URL)
-	maxRetries := delivery.ExportDefaultFailureThreshold + 5
+	maxAttempts := delivery.ExportDefaultFailureThreshold + 5
 
 	iCreateTarget(
 		t, s.MainDB, targetID, s.WebhookID, "metrics-blocked",
-		database.TargetTypeHTTP, cfg, maxRetries,
+		database.TargetTypeHTTP, ts.URL, maxAttempts,
 	)
 
 	first := iTask(
 		d, event, s.WebhookID, targetID,
-		"metrics-blocked", cfg, maxRetries, 1, &body,
+		"metrics-blocked", ts.URL, maxAttempts, 1, &body,
 	)
 
 	s.Engine.ExportProcessNewTask(context.TODO(), &first)
@@ -383,7 +379,7 @@ func TestDeliveryMetrics_BreakerBlockedIsNotAnAttempt(
 		ExportDefaultFailureThreshold; attempt++ {
 		task := iTask(
 			d, event, s.WebhookID, targetID,
-			"metrics-blocked", cfg, maxRetries, attempt, &body,
+			"metrics-blocked", ts.URL, maxAttempts, attempt, &body,
 		)
 
 		s.Engine.ExportProcessRetryTask(context.TODO(), &task)
@@ -406,7 +402,7 @@ func TestDeliveryMetrics_BreakerBlockedIsNotAnAttempt(
 
 	blocked := iTask(
 		d, event, s.WebhookID, targetID,
-		"metrics-blocked", cfg, maxRetries,
+		"metrics-blocked", ts.URL, maxAttempts,
 		delivery.ExportDefaultFailureThreshold+1, &body,
 	)
 
@@ -445,8 +441,8 @@ func TestDeliveryMetrics_OrphanedRetryFailureLabelled(
 		t, s, database.TargetTypeLog,
 	)
 
-	s.Engine.ExportSweepWebhookRetries(
-		context.Background(), s.WebhookID,
+	s.Engine.ExportRecoverWebhookDeliveries(
+		context.Background(), s.WebhookID, onTick,
 	)
 
 	iAssertStatus(t, s.WebhookDB, deliveryID,
@@ -475,7 +471,7 @@ func TestDeliveryMetrics_QueueDepthGauges(t *testing.T) {
 
 	iCreateTarget(t, s.MainDB, targetID, s.WebhookID,
 		"queue-depth-target", database.TargetTypeHTTP,
-		iHTTPConfig("https://example.com/hook"), 3,
+		"https://example.com/hook", 3,
 	)
 
 	event := iSeedEvent(

internal/delivery/queue_depth.go

@@ -20,7 +20,8 @@ const queueDepthSampleInterval = 30 * time.Second
 // to be seeded correctly at startup from rows written by a previous
 // process, and would drift permanently on any transition that failed
 // to persist. Counting is the measurement that cannot go wrong, and
-// it is the same whole-database walk the retry sweep already makes.
+// it is the same whole-database walk each tick of the sweep already
+// makes.
 func (e *Engine) queueDepthSampler(ctx context.Context) {
 	defer e.wg.Done()
 

internal/delivery/queue_depth_gormlog_test.go

@@ -5,7 +5,6 @@ import (
 	"context"
 	"log/slog"
 	"net/http"
-	"path/filepath"
 	"strings"
 	"sync"
 	"testing"
@@ -14,11 +13,9 @@ import (
 	"github.com/google/uuid"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
-	"gorm.io/driver/sqlite"
-	"gorm.io/gorm"
 	"sneak.berlin/go/webhooker/internal/database"
+	"sneak.berlin/go/webhooker/internal/database/databasetest"
 	"sneak.berlin/go/webhooker/internal/delivery"
-	"sneak.berlin/go/webhooker/internal/gormlog"
 )
 
 // qdAggregateMarker identifies the queue-depth aggregate in the
@@ -49,27 +46,13 @@ func (q *qdSyncBuf) String() string {
 
 // qdMainDB opens a main database whose GORM logger is the service's
 // adapter, writing through log.
-func qdMainDB(t *testing.T, log *slog.Logger) *gorm.DB {
+func qdMainDB(t *testing.T, log *slog.Logger) *database.Database {
 	t.Helper()
 
-	sqlDB, err := database.OpenSQLite(
-		filepath.Join(t.TempDir(), "main-gormlog.db"),
-		database.SQLiteModeCreate,
-	)
+	db, err := database.Open(t.TempDir(), log)
 	require.NoError(t, err)
 
-	t.Cleanup(func() { _ = sqlDB.Close() })
-
-	db, err := gorm.Open(
-		sqlite.Dialector{Conn: sqlDB},
-		&gorm.Config{Logger: gormlog.New(log)},
-	)
-	require.NoError(t, err)
-
-	require.NoError(t, db.AutoMigrate(
-		&database.Webhook{},
-		&database.Target{},
-	))
+	t.Cleanup(func() { _ = db.Close() })
 
 	return db
 }
@@ -106,20 +89,20 @@ func TestQueueDepthSample_LogsNoBoundValue(t *testing.T) {
 	))
 
 	mainDB := qdMainDB(t, log)
-	dbMgr := database.NewTestWebhookDBManagerWithLogger(
-		t.TempDir(), log,
+	dbMgr := databasetest.NewWebhookDBManagerWithLogger(
+		t, t.TempDir(), log,
 	)
 
 	webhookID := uuid.New().String()
 	webhookDB := iSeedWebhookDB(t, dbMgr, webhookID)
 
-	iCreateWebhook(t, mainDB, webhookID, "queue-depth-gormlog")
+	iCreateWebhook(t, mainDB.DB(), webhookID, "queue-depth-gormlog")
 
 	targetID := uuid.New().String()
 
-	iCreateTarget(t, mainDB, targetID, webhookID,
+	iCreateTarget(t, mainDB.DB(), targetID, webhookID,
 		"queue-depth-gormlog-target", database.TargetTypeHTTP,
-		iHTTPConfig("https://example.com/hook"), 3,
+		"https://example.com/hook", 3,
 	)
 
 	event := iSeedEvent(
@@ -136,7 +119,7 @@ func TestQueueDepthSample_LogsNoBoundValue(t *testing.T) {
 	)
 
 	engine := delivery.NewTestEngineWithDB(
-		database.NewTestDatabase(mainDB),
+		mainDB,
 		dbMgr,
 		log,
 		&http.Client{Timeout: 5 * time.Second},

internal/delivery/recovery_durability_test.go

@@ -66,7 +66,7 @@ func TestRecoverySkipsPendingWithSuccessfulResult(
 
 	iCreateTarget(t, s.MainDB, targetID,
 		s.WebhookID, "already-delivered",
-		database.TargetTypeLog, "", 0,
+		database.TargetTypeLog, "", 1,
 	)
 
 	event := iSeedEvent(
@@ -88,7 +88,7 @@ func TestRecoverySkipsPendingWithSuccessfulResult(
 	)
 
 	s.Engine.ExportRecoverPendingDeliveries(
-		context.Background(), s.WebhookDB, s.WebhookID,
+		context.Background(), s.WebhookDB, s.WebhookID, atStart,
 	)
 
 	select {
@@ -129,7 +129,7 @@ func TestRecoveryContinuesTheAttemptNumbering(t *testing.T) {
 
 	iCreateTarget(t, s.MainDB, targetID,
 		s.WebhookID, "numbering",
-		database.TargetTypeLog, "", 0,
+		database.TargetTypeLog, "", 1,
 	)
 
 	event := iSeedEvent(
@@ -145,7 +145,7 @@ func TestRecoveryContinuesTheAttemptNumbering(t *testing.T) {
 	rSeedResult(t, s.WebhookDB, d.ID, 2, false)
 
 	s.Engine.ExportRecoverPendingDeliveries(
-		context.Background(), s.WebhookDB, s.WebhookID,
+		context.Background(), s.WebhookDB, s.WebhookID, atStart,
 	)
 
 	select {
@@ -183,8 +183,8 @@ func TestSweepRecoversStrandedPending(t *testing.T) {
 		database.DeliveryStatusPending,
 	)
 
-	s.Engine.ExportSweepWebhookRetries(
-		context.Background(), s.WebhookID,
+	s.Engine.ExportRecoverWebhookDeliveries(
+		context.Background(), s.WebhookID, onTick,
 	)
 
 	select {
@@ -230,7 +230,7 @@ func TestSweepClaimsAStrandedDeliveryOnlyOnce(t *testing.T) {
 
 	ctx := context.Background()
 
-	s.Engine.ExportSweepWebhookRetries(ctx, s.WebhookID)
+	s.Engine.ExportRecoverWebhookDeliveries(ctx, s.WebhookID, onTick)
 
 	select {
 	case task := <-s.Engine.ExportDeliveryCh():
@@ -246,7 +246,7 @@ func TestSweepClaimsAStrandedDeliveryOnlyOnce(t *testing.T) {
 		database.DeliveryStatusPending,
 	)
 
-	s.Engine.ExportSweepWebhookRetries(ctx, s.WebhookID)
+	s.Engine.ExportRecoverWebhookDeliveries(ctx, s.WebhookID, onTick)
 
 	select {
 	case task := <-s.Engine.ExportDeliveryCh():
@@ -258,9 +258,9 @@ func TestSweepClaimsAStrandedDeliveryOnlyOnce(t *testing.T) {
 	}
 }
 
-// TestSweepSettlesStrandedPendingWithoutResending is the sweep's own
-// version of the reconcile: a stranded delivery holding a successful
-// result is settled where it stands, and the receiver hears nothing.
+// TestSweepSettlesStrandedPendingWithoutResending is the reconcile on a
+// tick of the sweep: a stranded delivery holding a successful result is
+// settled where it stands, and the receiver hears nothing.
 func TestSweepSettlesStrandedPendingWithoutResending(
 	t *testing.T,
 ) {
@@ -280,8 +280,8 @@ func TestSweepSettlesStrandedPendingWithoutResending(
 	rSeedResult(t, s.WebhookDB, d.ID, 1, true)
 	rAgePending(t, s.WebhookDB, d.ID)
 
-	s.Engine.ExportSweepWebhookRetries(
-		context.Background(), s.WebhookID,
+	s.Engine.ExportRecoverWebhookDeliveries(
+		context.Background(), s.WebhookID, onTick,
 	)
 
 	select {
@@ -312,8 +312,9 @@ func TestSweepSettlesStrandedPendingWithoutResending(
 
 // TestFailedResultWriteLeavesDeliveryRecoverable is the rule the
 // targets now follow: a bookkeeping write that fails must not advance
-// the status, because pending and retrying are the states the sweeps
-// recover and delivered is a claim the database refused to record.
+// the status, because pending and retrying are the states the recovery
+// routine recovers and delivered is a claim the database refused to
+// record.
 func TestFailedResultWriteLeavesDeliveryRecoverable(
 	t *testing.T,
 ) {
@@ -354,16 +355,17 @@ func TestFailedResultWriteLeavesDeliveryRecoverable(
 		Status:   database.DeliveryStatusPending,
 		Event:    event,
 		Target: database.Target{
-			Name:   "unwritable",
-			Type:   database.TargetTypeHTTP,
-			Config: iHTTPConfig(ts.URL),
+			Name:        "unwritable",
+			Type:        database.TargetTypeHTTP,
+			URL:         ts.URL,
+			MaxAttempts: 1,
 		},
 	}
 	full.ID = d.ID
 
 	s.Engine.ExportDeliverHTTP(
 		context.Background(), s.WebhookDB, full,
-		&delivery.Task{DeliveryID: d.ID, AttemptNum: 1},
+		&delivery.Task{DeliveryID: d.ID, MaxAttempts: 1, AttemptNum: 1},
 	)
 
 	assert.Equal(
@@ -376,3 +378,96 @@ func TestFailedResultWriteLeavesDeliveryRecoverable(
 		database.DeliveryStatusPending,
 	)
 }
+
+// TestFailedResultWriteWithRetriesLeavesDeliveryRecoverable is the same
+// rule for a target with retries: whatever the receiver answered, the
+// delivery stays pending and no retry is scheduled. The circuit breaker
+// still learns the answer, because it describes the target's health,
+// not the database's.
+func TestFailedResultWriteWithRetriesLeavesDeliveryRecoverable(
+	t *testing.T,
+) {
+	t.Parallel()
+
+	// The "send succeeded" case starts with the breaker tripped open,
+	// so the delivery goes out as its probe and only a recorded
+	// success closes it again.
+	tests := []struct {
+		name        string
+		answer      int
+		tripped     bool
+		wantBreaker delivery.CircuitState
+	}{
+		{"send succeeded", http.StatusOK, true, delivery.CircuitClosed},
+		{"send failed", http.StatusBadGateway, false, delivery.CircuitOpen},
+	}
+
+	for _, tc := range tests {
+		t.Run(tc.name, func(t *testing.T) {
+			t.Parallel()
+
+			s := newISetup(t)
+			targetID := uuid.New().String()
+
+			ts := httptest.NewServer(http.HandlerFunc(
+				func(w http.ResponseWriter, _ *http.Request) {
+					w.WriteHeader(tc.answer)
+				},
+			))
+			defer ts.Close()
+
+			event := iSeedEvent(
+				t, s.WebhookDB, s.WebhookID, `{"unwritable":true}`,
+			)
+
+			d := iSeedDelivery(
+				t, s.WebhookDB, event.ID, targetID,
+				database.DeliveryStatusPending,
+			)
+
+			require.NoError(
+				t,
+				s.WebhookDB.Exec("drop table delivery_results").Error,
+			)
+
+			// A single failure opens this breaker, and with no
+			// cooldown an open breaker lets the next delivery
+			// through as a probe.
+			cb := delivery.NewTestCircuitBreaker(1, 0)
+			if tc.tripped {
+				cb.RecordFailure()
+			}
+
+			s.Engine.ExportSetCircuitBreaker(targetID, cb)
+
+			full := &database.Delivery{
+				EventID:  event.ID,
+				TargetID: targetID,
+				Status:   database.DeliveryStatusPending,
+				Event:    event,
+				Target: database.Target{
+					Name:        "unwritable",
+					Type:        database.TargetTypeHTTP,
+					URL:         ts.URL,
+					MaxAttempts: 3,
+				},
+			}
+			full.ID = d.ID
+
+			sched := &recordingScheduler{}
+
+			s.Engine.ExportDeliverHTTPWithScheduler(
+				context.Background(), s.WebhookDB, full,
+				&delivery.Task{
+					DeliveryID: d.ID, TargetID: targetID,
+					MaxAttempts: 3, AttemptNum: 1,
+				},
+				sched,
+			)
+
+			iAssertStatus(t, s.WebhookDB, d.ID, database.DeliveryStatusPending)
+			assert.Empty(t, sched.delays, "no retry may be scheduled")
+			assert.Equal(t, tc.wantBreaker, cb.State())
+		})
+	}
+}

internal/delivery/recovery_test.go

@@ -0,0 +1,389 @@
+package delivery_test
+
+import (
+	"context"
+	"log/slog"
+	"net/http"
+	"testing"
+	"time"
+
+	"github.com/google/uuid"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"sneak.berlin/go/webhooker/internal/database"
+	"sneak.berlin/go/webhooker/internal/database/databasetest"
+	"sneak.berlin/go/webhooker/internal/delivery"
+)
+
+// These tests cover the recovery routine, which the engine runs once
+// when it starts and then on every tick of the sweep
+// (https://git.eeqj.de/sneak/webhooker/issues/542). Every case runs it
+// both ways, each on a webhook of its own.
+
+// atStart and onTick are the two values of the recovery routine's
+// atStart parameter: its run when the engine starts, and a tick of the
+// sweep.
+const (
+	atStart = true
+	onTick  = false
+)
+
+// recoveryRun names one of the two runs of the recovery routine.
+type recoveryRun struct {
+	name    string
+	atStart bool
+}
+
+// recoveryRuns returns the routine's run at start and a tick.
+func recoveryRuns() []recoveryRun {
+	return []recoveryRun{
+		{"at start", atStart},
+		{"on a tick", onTick},
+	}
+}
+
+// recoverySetup gives a fresh webhook its main-database row and an http
+// target with retries, and returns the setup and the target's ID. No
+// worker runs, so whatever the routine queues stays in the channels for
+// the test to read, and nothing is sent to the target.
+func recoverySetup(t *testing.T) (iSetup, string) {
+	t.Helper()
+
+	s := newISetup(t)
+	targetID := uuid.New().String()
+
+	iCreateWebhook(t, s.MainDB, s.WebhookID, "recovery")
+	iCreateTarget(
+		t, s.MainDB, targetID, s.WebhookID, "recovery",
+		database.TargetTypeHTTP,
+		"http://example.com/hook", 20,
+	)
+
+	return s, targetID
+}
+
+// seedRecoveryDelivery seeds a delivery at status with the given
+// recorded attempts, failed but for the last when lastSucceeded is set,
+// all recorded now.
+func seedRecoveryDelivery(
+	t *testing.T,
+	s iSetup,
+	targetID string,
+	status database.DeliveryStatus,
+	attempts int,
+	lastSucceeded bool,
+) string {
+	t.Helper()
+
+	event := iSeedEvent(t, s.WebhookDB, s.WebhookID, `{"recovery":true}`)
+	d := iSeedDelivery(t, s.WebhookDB, event.ID, targetID, status)
+
+	for n := 1; n <= attempts; n++ {
+		rSeedResult(
+			t, s.WebhookDB, d.ID, n, lastSucceeded && n == attempts,
+		)
+	}
+
+	return d.ID
+}
+
+// backdateAttempts moves every recorded attempt of a delivery an hour
+// into the past, long past the backoff after its first attempt.
+func backdateAttempts(t *testing.T, s iSetup, deliveryID string) {
+	t.Helper()
+
+	require.NoError(t, s.WebhookDB.Model(&database.DeliveryResult{}).
+		Where("delivery_id = ?", deliveryID).
+		UpdateColumn("created_at", s.WebhookDB.NowFunc().Add(-time.Hour)).
+		Error)
+}
+
+// requireQueued waits for a task on ch. A retrying delivery reaches the
+// retry channel through a timer, even one due now, so it is waited for.
+func requireQueued(
+	t *testing.T, ch <-chan delivery.Task,
+) delivery.Task {
+	t.Helper()
+
+	select {
+	case task := <-ch:
+		return task
+	case <-time.After(5 * time.Second):
+		t.Fatal("the recovery routine queued nothing")
+
+		return delivery.Task{}
+	}
+}
+
+// assertNothingQueued asserts the engine queues nothing, giving a retry
+// timer that is due now the moment it needs to fire.
+func assertNothingQueued(t *testing.T, e *delivery.Engine) {
+	t.Helper()
+
+	select {
+	case task := <-e.ExportDeliveryCh():
+		t.Errorf("queued pending delivery %s", task.DeliveryID)
+	case task := <-e.ExportRetryCh():
+		t.Errorf("queued retrying delivery %s", task.DeliveryID)
+	case <-time.After(200 * time.Millisecond):
+	}
+}
+
+// TestRecovery_RetryingBackoffPassed: a retrying delivery whose backoff
+// is over is queued for its next attempt at once.
+func TestRecovery_RetryingBackoffPassed(t *testing.T) {
+	t.Parallel()
+
+	for _, run := range recoveryRuns() {
+		t.Run(run.name, func(t *testing.T) {
+			t.Parallel()
+
+			s, targetID := recoverySetup(t)
+			id := seedRecoveryDelivery(
+				t, s, targetID, database.DeliveryStatusRetrying, 1, false,
+			)
+			backdateAttempts(t, s, id)
+
+			s.Engine.ExportRecoverDeliveries(context.Background(), run.atStart)
+
+			task := requireQueued(t, s.Engine.ExportRetryCh())
+			assert.Equal(t, id, task.DeliveryID)
+			assert.Equal(t, 2, task.AttemptNum)
+			iAssertStatus(t, s.WebhookDB, id, database.DeliveryStatusRetrying)
+		})
+	}
+}
+
+// TestRecovery_RetryingBackoffNotPassed: a retrying delivery whose last
+// attempt was just now waits out the rest of its backoff, ten attempts
+// in, eight and a half minutes. It is not sent now, and the engine holds
+// it, so a later tick leaves it to the timer.
+func TestRecovery_RetryingBackoffNotPassed(t *testing.T) {
+	t.Parallel()
+
+	for _, run := range recoveryRuns() {
+		t.Run(run.name, func(t *testing.T) {
+			t.Parallel()
+
+			s, targetID := recoverySetup(t)
+			id := seedRecoveryDelivery(
+				t, s, targetID, database.DeliveryStatusRetrying, 10, false,
+			)
+
+			s.Engine.ExportRecoverDeliveries(context.Background(), run.atStart)
+
+			assertNothingQueued(t, s.Engine)
+			iAssertStatus(t, s.WebhookDB, id, database.DeliveryStatusRetrying)
+			assert.Equal(t, 1, s.Engine.ExportInflightHeld(),
+				"no retry timer holds the delivery",
+			)
+		})
+	}
+}
+
+// TestRecovery_PendingOlderThanTheAgeBound: a pending delivery untouched
+// for longer than the sweep's age bound is sent by either run.
+func TestRecovery_PendingOlderThanTheAgeBound(t *testing.T) {
+	t.Parallel()
+
+	for _, run := range recoveryRuns() {
+		t.Run(run.name, func(t *testing.T) {
+			t.Parallel()
+
+			s, targetID := recoverySetup(t)
+			id := seedRecoveryDelivery(
+				t, s, targetID, database.DeliveryStatusPending, 0, false,
+			)
+			rAgePending(t, s.WebhookDB, id)
+
+			s.Engine.ExportRecoverDeliveries(context.Background(), run.atStart)
+
+			task := requireQueued(t, s.Engine.ExportDeliveryCh())
+			assert.Equal(t, id, task.DeliveryID)
+			assert.Equal(t, 1, task.AttemptNum)
+		})
+	}
+}
+
+// TestRecovery_TaskCarriesEveryTargetSetting: the task the recovery
+// routine queues carries every one of the target's settings, all six
+// set here.
+// They are copied into the task one field at a time, and a field left
+// out is sent empty without any error.
+func TestRecovery_TaskCarriesEveryTargetSetting(t *testing.T) {
+	t.Parallel()
+
+	for _, run := range recoveryRuns() {
+		t.Run(run.name, func(t *testing.T) {
+			t.Parallel()
+
+			s := newISetup(t)
+			iCreateWebhook(t, s.MainDB, s.WebhookID, "recovery")
+
+			target := database.Target{
+				WebhookID:       s.WebhookID,
+				Name:            "recovery",
+				Type:            database.TargetTypeHTTP,
+				Active:          true,
+				URL:             "http://example.com/hook",
+				Headers:         map[string]string{headerAuthorization: "Bearer t"},
+				TimeoutSeconds:  7,
+				ForwardQuery:    true,
+				ArchiveExpiry:   time.Hour,
+				ArchiveRotation: "daily",
+				MaxAttempts:     1,
+			}
+			require.NoError(t, s.MainDB.Create(&target).Error)
+
+			id := seedRecoveryDelivery(
+				t, s, target.ID, database.DeliveryStatusPending, 0, false,
+			)
+			rAgePending(t, s.WebhookDB, id)
+
+			s.Engine.ExportRecoverDeliveries(context.Background(), run.atStart)
+
+			task := requireQueued(t, s.Engine.ExportDeliveryCh())
+			assert.Equal(t, target.ID, task.TargetID)
+			assert.Equal(t, target.URL, task.TargetURL)
+			assert.Equal(t, target.Headers, task.TargetHeaders)
+			assert.Equal(t, target.TimeoutSeconds, task.TimeoutSeconds)
+			assert.Equal(t, target.ForwardQuery, task.ForwardQuery)
+			assert.Equal(t, target.ArchiveExpiry, task.ArchiveExpiry)
+			assert.Equal(t, target.ArchiveRotation, task.ArchiveRotation)
+		})
+	}
+}
+
+// TestRecovery_PendingYoungerThanTheAgeBound: a pending delivery touched
+// a moment ago, as one a stop cut off is, is sent at start, which is how
+// it reaches its target on the next start
+// (https://git.eeqj.de/sneak/webhooker/issues/527). A tick leaves it.
+func TestRecovery_PendingYoungerThanTheAgeBound(t *testing.T) {
+	t.Parallel()
+
+	for _, run := range recoveryRuns() {
+		t.Run(run.name, func(t *testing.T) {
+			t.Parallel()
+
+			s, targetID := recoverySetup(t)
+			id := seedRecoveryDelivery(
+				t, s, targetID, database.DeliveryStatusPending, 0, false,
+			)
+
+			s.Engine.ExportRecoverDeliveries(context.Background(), run.atStart)
+
+			if run.atStart {
+				task := requireQueued(t, s.Engine.ExportDeliveryCh())
+				assert.Equal(t, id, task.DeliveryID)
+
+				return
+			}
+
+			assertNothingQueued(t, s.Engine)
+			iAssertStatus(t, s.WebhookDB, id, database.DeliveryStatusPending)
+			assert.Zero(t, s.Engine.ExportInflightHeld())
+		})
+	}
+}
+
+// TestRecovery_AlreadySucceeded: a pending or retrying delivery whose
+// success is recorded but whose status write was lost is marked
+// delivered where it stands, and not sent again.
+func TestRecovery_AlreadySucceeded(t *testing.T) {
+	t.Parallel()
+
+	for _, run := range recoveryRuns() {
+		t.Run(run.name, func(t *testing.T) {
+			t.Parallel()
+
+			s, targetID := recoverySetup(t)
+			pending := seedRecoveryDelivery(
+				t, s, targetID, database.DeliveryStatusPending, 1, true,
+			)
+			rAgePending(t, s.WebhookDB, pending)
+
+			retrying := seedRecoveryDelivery(
+				t, s, targetID, database.DeliveryStatusRetrying, 2, true,
+			)
+			backdateAttempts(t, s, retrying)
+
+			s.Engine.ExportRecoverDeliveries(context.Background(), run.atStart)
+
+			assertNothingQueued(t, s.Engine)
+
+			for id, attempts := range map[string]int{pending: 1, retrying: 2} {
+				iAssertStatus(
+					t, s.WebhookDB, id, database.DeliveryStatusDelivered,
+				)
+				assert.Len(t, iResults(t, s.WebhookDB, id), attempts,
+					"marking the delivery delivered recorded an attempt",
+				)
+			}
+		})
+	}
+}
+
+// TestRecovery_MissingDatabase: a tick leaves a webhook whose database
+// file is missing alone, and the run at start opens it, which creates an
+// empty one and reports the loss (see
+// TestRecoverDeliveries_ReportsAMissingWebhookDatabase).
+func TestRecovery_MissingDatabase(t *testing.T) {
+	t.Parallel()
+
+	mainDB := iMainDB(t)
+	webhookID := uuid.New().String()
+	iCreateWebhook(t, mainDB.DB(), webhookID, "missing-database")
+
+	dbMgr := databasetest.NewWebhookDBManager(t, t.TempDir())
+	t.Cleanup(func() { _ = dbMgr.CloseAll() })
+
+	engine := delivery.NewTestEngineWithDB(
+		mainDB, dbMgr,
+		slog.New(slog.DiscardHandler),
+		&http.Client{Timeout: 5 * time.Second}, 1,
+	)
+
+	engine.ExportRecoverDeliveries(context.Background(), onTick)
+	assert.False(t, dbMgr.DBExists(webhookID),
+		"a tick created the missing database",
+	)
+
+	engine.ExportRecoverDeliveries(context.Background(), atStart)
+	assert.True(t, dbMgr.DBExists(webhookID),
+		"the run at start did not open the missing database",
+	)
+}
+
+// TestRecovery_LeavesADeliveryTheEngineHolds: a delivery the engine is
+// working on, has queued, or holds a retry timer for is left alone by
+// either run, pending and retrying alike, however old.
+func TestRecovery_LeavesADeliveryTheEngineHolds(t *testing.T) {
+	t.Parallel()
+
+	for _, run := range recoveryRuns() {
+		t.Run(run.name, func(t *testing.T) {
+			t.Parallel()
+
+			s, targetID := recoverySetup(t)
+			pending := seedRecoveryDelivery(
+				t, s, targetID, database.DeliveryStatusPending, 0, false,
+			)
+			rAgePending(t, s.WebhookDB, pending)
+
+			retrying := seedRecoveryDelivery(
+				t, s, targetID, database.DeliveryStatusRetrying, 1, false,
+			)
+			backdateAttempts(t, s, retrying)
+
+			require.True(t, s.Engine.ExportRetainDelivery(pending))
+			require.True(t, s.Engine.ExportRetainDelivery(retrying))
+
+			s.Engine.ExportRecoverDeliveries(context.Background(), run.atStart)
+
+			assertNothingQueued(t, s.Engine)
+			iAssertStatus(t, s.WebhookDB, pending, database.DeliveryStatusPending)
+			iAssertStatus(t, s.WebhookDB, retrying, database.DeliveryStatusRetrying)
+			assert.Equal(t, 2, s.Engine.ExportInflightHeld())
+		})
+	}
+}

internal/delivery/redirect_test.go

@@ -85,19 +85,14 @@ func deliverWithProbeHeaders(
 		database.DeliveryStatusPending,
 	)
 
-	cfg, err := json.Marshal(delivery.HTTPTargetConfig{
-		URL: targetURL,
-		Headers: map[string]string{
-			probeHeaderName: probeHeaderValue,
-		},
-	})
-	require.NoError(t, err)
-
 	body := event.Body
 	task := iTask(
 		d, event, s.WebhookID, targetID,
-		"redirect-target", string(cfg), 0, 1, &body,
+		"redirect-target", targetURL, 1, 1, &body,
 	)
+	task.TargetHeaders = map[string]string{
+		probeHeaderName: probeHeaderValue,
+	}
 
 	s.Engine.ExportProcessNewTask(context.TODO(), &task)
 
@@ -309,8 +304,7 @@ func TestRedirectPolicy_StopsAtHopCap(t *testing.T) {
 	)
 
 	client := engine.ExportClientForRequest(
-		&delivery.HTTPTargetConfig{URL: srv.URL},
-		[]string{probeHeaderName},
+		0, []string{probeHeaderName},
 	)
 	require.NotNil(t, client.CheckRedirect)
 
@@ -350,7 +344,7 @@ func TestApplyRequestHeaders_ReportsOriginScopedNames(t *testing.T) {
 	inbound, err := json.Marshal(map[string][]string{
 		inboundHeaderName: {inboundHeaderValue},
 		"Content-Type":    {testContentType},
-		"User-Agent":      {"curl/8.7.1"},
+		headerUserAgent:   {"curl/8.7.1"},
 		"Host":            {"inbound.example.com"},
 	})
 	require.NoError(t, err)
@@ -369,12 +363,11 @@ func TestApplyRequestHeaders_ReportsOriginScopedNames(t *testing.T) {
 			Headers:     string(inbound),
 			ContentType: testContentType,
 		},
-		&delivery.HTTPTargetConfig{
-			Headers: map[string]string{
-				probeHeaderName: probeHeaderValue,
-				"Content-Type":  testContentType,
-			},
+		map[string]string{
+			probeHeaderName: probeHeaderValue,
+			"Content-Type":  testContentType,
 		},
+		"webhooker/dev",
 	)
 
 	assert.Equal(t,

internal/delivery/ssrf.go

@@ -25,36 +25,64 @@ var (
 	errNoIPs      = errors.New(
 		"hostname resolved to no IP addresses",
 	)
-	errBlockedIP = errors.New(
-		"blocked private, reserved or cloud metadata address",
+	// ErrBlockedPrivateOrReservedIP reports an address in the
+	// default blocklist's private and reserved ranges,
+	// blockedNetworks.
+	ErrBlockedPrivateOrReservedIP = errors.New(
+		"blocked private or reserved address",
+	)
+	// errBlockedPublicMetadata reports a public address on the
+	// default blocklist, one in blockedPublicNetworks.
+	errBlockedPublicMetadata = errors.New(
+		"blocked cloud metadata address",
 	)
 	errBlockedMetadata = errors.New(
-		"blocked link-local or cloud instance metadata " +
-			"address: ALLOWED_EGRESS_CIDRS cannot open it",
+		"blocked link-local, cloud instance metadata or " +
+			"unspecified address: ALLOWED_EGRESS_CIDRS cannot open it",
 	)
 	errInvalidScheme = errors.New(
 		"only http and https are allowed",
 	)
 )
 
-// blockedNetworks is the default blocklist: the private and
-// reserved IP ranges, plus the public cloud metadata addresses,
-// that are blocked to prevent SSRF attacks. An operator can
-// permit specific blocks out of this set with
-// ALLOWED_EGRESS_CIDRS; see Guard.
+// blockedNetworks and blockedPublicNetworks together are the
+// default blocklist: the private and reserved IP ranges, plus
+// the public cloud metadata addresses, that are blocked to
+// prevent SSRF attacks. An operator can permit specific blocks
+// out of this set with ALLOWED_EGRESS_CIDRS; see Guard.
+//
+// blockedNetworks holds the private and reserved IP ranges.
 //
 //nolint:gochecknoglobals // package-level network list is appropriate here
 var blockedNetworks []*net.IPNet
 
-// alwaysBlockedNetworks are the ranges no configuration can
-// open: the link-local blocks and the cloud instance metadata
-// endpoints that live outside them. Reaching one is credential
-// or user-data theft rather than delivery to an internal
-// service, so a supplied CIDR that covers such an address still
-// leaves it blocked.
+// blockedPublicNetworks holds the default blocklist's public
+// addresses, kept apart from blockedNetworks so that they are
+// refused as cloud metadata addresses, never as private or
+// reserved ones.
 //
-// Inclusion criterion — an address belongs here only if BOTH
-// hold, and every entry below satisfies both:
+// A public address belongs on the default blocklist only if it
+// hands credentials, user data or bootstrap material to whatever
+// can reach it, without the caller presenting anything; it goes
+// in this list. A provider's other public addresses are not
+// refused, since reaching them can be legitimate and no list of
+// them could be complete.
+//
+//nolint:gochecknoglobals // package-level network list is appropriate here
+var blockedPublicNetworks []*net.IPNet
+
+// alwaysBlockedNetworks are the ranges no configuration can
+// open, so a supplied CIDR that covers one still leaves it
+// blocked. An entry is here for one of two reasons: it is a
+// metadata endpoint (the link-local blocks and the cloud
+// instance metadata endpoints that live outside them), or it is
+// an unspecified address. Reaching a metadata endpoint is
+// credential or user-data theft rather than delivery to an
+// internal service.
+//
+// Inclusion criterion for metadata endpoints — one belongs here
+// only if BOTH hold, and every metadata entry below satisfies
+// both:
 //
 //  1. It is a fixed address assigned by the provider, or a
 //     range reserved by IANA — never one the operator chose.
@@ -65,8 +93,8 @@ var blockedNetworks []*net.IPNet
 //     not cheaply rotated.
 //
 // Both halves are load-bearing, so use them to refuse a
-// candidate and say why. An endpoint disclosing only the
-// operator's own inventory (instance id, region, disks, NICs)
+// metadata candidate and say why. An endpoint disclosing only
+// the operator's own inventory (instance id, region, disks, NICs)
 // fails (2): letting a delivery target reach the operator's own
 // infrastructure is the feature ALLOWED_EGRESS_CIDRS exists to
 // provide. But (2) is not "IAM credentials only" either —
@@ -81,12 +109,21 @@ var blockedNetworks []*net.IPNet
 // when it clears both halves. Nothing in this list can be
 // reopened, so putting a public address here leaves the operator
 // no escape hatch at all — the condition ALLOWED_EGRESS_CIDRS
-// exists to remove. Default-block it in blockedNetworks instead,
-// which an allowlist can override.
+// exists to remove. Default-block it in blockedPublicNetworks
+// instead, which an allowlist can override.
 //
 // This is a criterion, not an enumeration of every metadata
 // address in existence.
 //
+// The unspecified addresses 0.0.0.0 and :: are here for a
+// separate reason: they disclose nothing, but no host can have
+// either, and on Linux a connection to one reaches this host's
+// own loopback. Listing them means an allowlist reaches loopback
+// only through an entry that covers a loopback address
+// (127.0.0.0/8, ::1/128, 0.0.0.0/0), never through one that
+// covers only 0.0.0.0 or :: (0.0.0.0/8, for example). Nothing
+// else lives at either address, so refusing them costs nothing.
+//
 // Every entry is either already in blockedNetworks — this list is
 // what makes it unconditional — or an alternate encoding of
 // 169.254.169.254 that Contains does not match against
@@ -106,23 +143,49 @@ var alwaysBlockedNetworks []*net.IPNet
 //nolint:gochecknoinits // init is the idiomatic way to parse CIDRs once at startup
 func init() {
 	blockedNetworks = mustParseCIDRs([]string{
+		// IPv4 loopback.
 		"127.0.0.0/8",
+		// RFC 1918 private network.
 		"10.0.0.0/8",
+		// RFC 1918 private network.
 		"172.16.0.0/12",
+		// RFC 1918 private network.
 		"192.168.0.0/16",
+		// IPv4 link-local.
 		"169.254.0.0/16",
+		// "This network", holding the IPv4 unspecified address 0.0.0.0.
 		"0.0.0.0/8",
+		// Carrier-grade NAT shared address space.
 		"100.64.0.0/10",
+		// IETF protocol assignments.
 		"192.0.0.0/24",
+		// IPv4 documentation (TEST-NET-1).
 		"192.0.2.0/24",
+		// Benchmarking.
 		"198.18.0.0/15",
+		// IPv4 documentation (TEST-NET-2).
 		"198.51.100.0/24",
+		// IPv4 documentation (TEST-NET-3).
 		"203.0.113.0/24",
+		// IPv4 multicast.
 		"224.0.0.0/4",
+		// Reserved, including the broadcast address.
 		"240.0.0.0/4",
+		// IPv6 loopback.
 		"::1/128",
+		// IPv6 unspecified address.
+		"::/128",
+		// IPv6 unique local addresses.
 		"fc00::/7",
+		// IPv6 link-local.
 		"fe80::/10",
+		// IPv6 multicast.
+		"ff00::/8",
+		// IPv6 documentation.
+		"2001:db8::/32",
+	})
+
+	blockedPublicNetworks = mustParseCIDRs([]string{
 		// Azure WireServer, a public address that serves VM credentials.
 		"168.63.129.16/32",
 	})
@@ -179,6 +242,14 @@ func init() {
 		// allowlist from opening it.
 		"192.0.0.192/32",
 
+		// The unspecified addresses, each of which reaches this
+		// host's loopback on Linux.
+		//
+		// IPv4 unspecified address, inside the blocked 0.0.0.0/8.
+		"0.0.0.0/32",
+		// IPv6 unspecified address.
+		"::/128",
+
 		// 169.254.169.254 as an IPv4-compatible IPv6 address.
 		"::a9fe:a9fe/128",
 		// 169.254.169.254 behind the NAT64 well-known prefix.
@@ -218,13 +289,6 @@ func matchesAny(networks []*net.IPNet, ip net.IP) bool {
 	return false
 }
 
-// isBlockedIP checks whether an IP address falls within
-// the default blocklist, before any operator allowlist is
-// considered.
-func isBlockedIP(ip net.IP) bool {
-	return matchesAny(blockedNetworks, ip)
-}
-
 // Guard makes every SSRF decision in the process.
 //
 // It holds the operator's ALLOWED_EGRESS_CIDRS allowlist and
@@ -322,10 +386,12 @@ func (g *Guard) allows(ip net.IP) bool {
 // The order is the policy:
 //
 //  1. alwaysBlockedNetworks is refused before the allowlist is
-//     consulted, so no configured CIDR reaches link-local or a
-//     cloud metadata endpoint at a non-public address.
+//     consulted, so no configured CIDR reaches link-local, a
+//     cloud metadata endpoint at a non-public address, or an
+//     unspecified address.
 //  2. The allowlist is consulted next, so a listed private
-//     network becomes reachable.
+//     network, or a listed public address on the default
+//     blocklist, becomes reachable.
 //  3. Everything else keeps the default blocklist's answer.
 func (g *Guard) checkIP(ip net.IP) error {
 	if matchesAny(alwaysBlockedNetworks, ip) {
@@ -338,9 +404,15 @@ func (g *Guard) checkIP(ip net.IP) error {
 		return nil
 	}
 
-	if isBlockedIP(ip) {
+	if matchesAny(blockedNetworks, ip) {
 		return fmt.Errorf(
-			"target IP %s: %w", ip, errBlockedIP,
+			"target IP %s: %w", ip, ErrBlockedPrivateOrReservedIP,
+		)
+	}
+
+	if matchesAny(blockedPublicNetworks, ip) {
+		return fmt.Errorf(
+			"target IP %s: %w", ip, errBlockedPublicMetadata,
 		)
 	}
 

internal/delivery/ssrf_allowlist_test.go

@@ -23,6 +23,10 @@ const (
 	metadataIP  = "169.254.169.254"
 	metadataURL = "http://" + metadataIP + "/latest/meta-data/"
 
+	// linkLocalIPv4 is the IPv4 link-local block, which holds
+	// metadataIP.
+	linkLocalIPv4 = "169.254.0.0/16"
+
 	// loopbackHookURL is a target on this host: blocked by
 	// default, reachable only once an operator allowlists
 	// loopback.
@@ -164,12 +168,13 @@ func TestGuardAllowlist_UnlistedPrivateStillRefused(t *testing.T) {
 
 // TestGuardAllowlist_MetadataAlwaysRefused is the load-bearing
 // case: cloud instance metadata endpoints are credential theft
-// rather than delivery to an internal service, so no allowlist
-// reaches one. Every guard below names a CIDR that covers its
-// target — including 0.0.0.0/0, ::/0, and the ordinary ULA and
-// CGNAT blocks an operator would really list — and the address
-// must stay refused anyway, on both the validation and the
-// delivery path.
+// rather than delivery to an internal service, and the
+// unspecified addresses 0.0.0.0 and :: reach this host's loopback
+// on Linux, so no allowlist reaches any of them. Every guard
+// below names a CIDR that covers its target — including
+// 0.0.0.0/0, ::/0, and the ordinary ULA and CGNAT blocks an
+// operator would really list — and the address must stay
+// refused anyway, on both the validation and the delivery path.
 func TestGuardAllowlist_MetadataAlwaysRefused(t *testing.T) {
 	t.Parallel()
 
@@ -215,15 +220,17 @@ type metadataAlwaysRefusedCase struct {
 }
 
 // metadataAlwaysRefusedCases enumerates every unconditionally
-// blocked address together with an allowlist entry that would
-// otherwise reach it. Split by family of address only to stay
-// under the function-length limit.
+// blocked address (link-local, the cloud metadata endpoints and
+// the unspecified addresses) together with an allowlist entry
+// that would otherwise reach it. Split by family of address only
+// to stay under the function-length limit.
 func metadataAlwaysRefusedCases() []metadataAlwaysRefusedCase {
 	cases := linkLocalRefusedCases()
 	cases = append(cases, ulaMetadataRefusedCases()...)
 	cases = append(cases, ipv4MetadataRefusedCases()...)
+	cases = append(cases, encodedMetadataRefusedCases()...)
 
-	return append(cases, encodedMetadataRefusedCases()...)
+	return append(cases, unspecifiedRefusedCases()...)
 }
 
 // linkLocalRefusedCases covers the link-local blocks, including
@@ -237,7 +244,7 @@ func linkLocalRefusedCases() []metadataAlwaysRefusedCase {
 		},
 		{
 			name:   "whole link-local block",
-			allow:  "169.254.0.0/16",
+			allow:  linkLocalIPv4,
 			target: metadataURL,
 		},
 		{
@@ -363,6 +370,23 @@ func encodedMetadataRefusedCases() []metadataAlwaysRefusedCase {
 	}
 }
 
+// unspecifiedRefusedCases covers the unspecified addresses, each
+// of which reaches this host's loopback on Linux.
+func unspecifiedRefusedCases() []metadataAlwaysRefusedCase {
+	return []metadataAlwaysRefusedCase{
+		{
+			name:   "IPv4 unspecified address under 0.0.0.0/0",
+			allow:  allowAllIPv4,
+			target: "http://0.0.0.0:8080/hook",
+		},
+		{
+			name:   "IPv6 unspecified address under ::/0",
+			allow:  allowAllIPv6,
+			target: "http://[::]:8080/hook",
+		},
+	}
+}
+
 // TestGuardAllowlist_PublicUnaffected asserts the allowlist does
 // not narrow anything: public addresses were reachable before it
 // existed and stay reachable, whether or not a list is set.
@@ -412,6 +436,9 @@ func TestGuardAllowlist_AzureWireServerReopenable(t *testing.T) {
 		"WireServer must be refused by the default blocklist, "+
 			"which an allowlist can override",
 	)
+	require.NotErrorIs(t, err, delivery.ErrBlockedPrivateOrReservedIP,
+		"WireServer is public, not private or reserved",
+	)
 
 	assertDialRefused(t, defaultGuard, target)
 
@@ -496,7 +523,7 @@ func TestAlwaysBlockedNetworks_PinnedSet(t *testing.T) {
 	want := []string{
 		// IPv4 link-local: the 169.254.169.254 metadata
 		// service on AWS, Azure and others.
-		"169.254.0.0/16",
+		linkLocalIPv4,
 		// IPv6 link-local.
 		"fe80::/10",
 		// AWS IPv6 IMDS, inside the ULA space an operator may
@@ -517,6 +544,10 @@ func TestAlwaysBlockedNetworks_PinnedSet(t *testing.T) {
 		// Oracle Cloud Classic metadata, inside the blocked
 		// 192.0.0.0/24.
 		"192.0.0.192/32",
+		// The IPv4 and IPv6 unspecified addresses, each of
+		// which reaches this host's loopback on Linux.
+		"0.0.0.0/32",
+		"::/128",
 		// 169.254.169.254 as an IPv4-compatible IPv6 address.
 		"::a9fe:a9fe/128",
 		// 169.254.169.254 behind the NAT64 well-known prefix.
@@ -526,6 +557,94 @@ func TestAlwaysBlockedNetworks_PinnedSet(t *testing.T) {
 	assert.Equal(t, want, got)
 }
 
+// TestDefaultBlocklist_PinnedSet pins each list of the default
+// blocklist on its own, the private and reserved ranges in
+// blockedNetworks and the public addresses in
+// blockedPublicNetworks, so moving an entry from one list to the
+// other fails it. For the first address of each entry it then
+// checks that the default guard refuses it, and that listing the
+// entry in ALLOWED_EGRESS_CIDRS opens it unless the unconditional
+// set holds that address.
+func TestDefaultBlocklist_PinnedSet(t *testing.T) {
+	t.Parallel()
+
+	// public marks an entry of blockedPublicNetworks; every other
+	// entry belongs in blockedNetworks.
+	tests := []struct {
+		cidr       string
+		public     bool
+		reopenable bool
+	}{
+		{cidr: "127.0.0.0/8", reopenable: true},
+		{cidr: "10.0.0.0/8", reopenable: true},
+		{cidr: "172.16.0.0/12", reopenable: true},
+		{cidr: "192.168.0.0/16", reopenable: true},
+		{cidr: linkLocalIPv4, reopenable: false},
+		// Its first address, 0.0.0.0, is in the unconditional set.
+		{cidr: "0.0.0.0/8", reopenable: false},
+		{cidr: "100.64.0.0/10", reopenable: true},
+		{cidr: "192.0.0.0/24", reopenable: true},
+		{cidr: "192.0.2.0/24", reopenable: true},
+		{cidr: "198.18.0.0/15", reopenable: true},
+		{cidr: "198.51.100.0/24", reopenable: true},
+		{cidr: "203.0.113.0/24", reopenable: true},
+		{cidr: "224.0.0.0/4", reopenable: true},
+		{cidr: "240.0.0.0/4", reopenable: true},
+		{cidr: "::1/128", reopenable: true},
+		{cidr: "::/128", reopenable: false},
+		{cidr: "fc00::/7", reopenable: true},
+		{cidr: "fe80::/10", reopenable: false},
+		{cidr: "ff00::/8", reopenable: true},
+		{cidr: "2001:db8::/32", reopenable: true},
+		{cidr: "168.63.129.16/32", public: true, reopenable: true},
+	}
+
+	wantPrivate := make([]string, 0, len(tests))
+	wantPublic := make([]string, 0, len(tests))
+
+	for _, tt := range tests {
+		if tt.public {
+			wantPublic = append(wantPublic, tt.cidr)
+		} else {
+			wantPrivate = append(wantPrivate, tt.cidr)
+		}
+	}
+
+	gotPrivate := make([]string, 0, len(tests))
+	for _, n := range delivery.ExportBlockedNetworks() {
+		gotPrivate = append(gotPrivate, n.String())
+	}
+
+	gotPublic := make([]string, 0, len(tests))
+	for _, n := range delivery.ExportBlockedPublicNetworks() {
+		gotPublic = append(gotPublic, n.String())
+	}
+
+	assert.ElementsMatch(t, wantPrivate, gotPrivate, "blockedNetworks")
+	assert.ElementsMatch(t, wantPublic, gotPublic, "blockedPublicNetworks")
+
+	for _, tt := range tests {
+		t.Run(tt.cidr, func(t *testing.T) {
+			t.Parallel()
+
+			prefix := netip.MustParsePrefix(tt.cidr)
+			ip := net.IP(prefix.Addr().AsSlice())
+
+			require.Error(t,
+				delivery.NewTestGuard().ExportCheckIP(ip),
+				"the default guard must refuse %s", ip,
+			)
+
+			err := delivery.NewTestGuard(prefix).ExportCheckIP(ip)
+			if tt.reopenable {
+				assert.NoError(t, err, "listing %s must open it", tt.cidr)
+			} else {
+				assert.Error(t, err, "listing %s must not open it", tt.cidr)
+			}
+		})
+	}
+}
+
 // requireLoopback fails the test unless rawURL's host is a
 // loopback address, so the allowlist test cannot silently stop
 // exercising a blocked range.

internal/delivery/ssrf_test.go

@@ -10,7 +10,7 @@ import (
 	"sneak.berlin/go/webhooker/internal/delivery"
 )
 
-func TestIsBlockedIP_PrivateRanges(t *testing.T) {
+func TestGuardCheckIP_PrivateRanges(t *testing.T) {
 	t.Parallel()
 
 	tests := []struct {
@@ -56,12 +56,14 @@ func TestIsBlockedIP_PrivateRanges(t *testing.T) {
 				"failed to parse IP %s", tt.ip,
 			)
 
+			refused := delivery.NewTestGuard().ExportCheckIP(ip) != nil
+
 			assert.Equal(t,
 				tt.blocked,
-				delivery.ExportIsBlockedIP(ip),
-				"isBlockedIP(%s) = %v, want %v",
+				refused,
+				"default guard refuses %s = %v, want %v",
 				tt.ip,
-				delivery.ExportIsBlockedIP(ip),
+				refused,
 				tt.blocked,
 			)
 		})
@@ -99,6 +101,42 @@ func TestValidateTargetURL_Blocked(t *testing.T) {
 	}
 }
 
+// TestDefaultGuard_RefusesUnspecifiedMulticastAndDocumentation
+// covers the unspecified addresses and the IPv6 multicast and
+// documentation ranges: with no allowlist set, each is refused
+// both when a target is created and when a delivery dials it.
+func TestDefaultGuard_RefusesUnspecifiedMulticastAndDocumentation(
+	t *testing.T,
+) {
+	t.Parallel()
+
+	guard := delivery.NewTestGuard()
+
+	targets := []string{
+		// The unspecified addresses. On Linux a connection to
+		// either reaches this host's loopback.
+		"http://0.0.0.0:8080/hook",
+		"http://[::]:8080/hook",
+		// IPv6 multicast, all nodes.
+		"http://[ff02::1]/hook",
+		// IPv6 documentation.
+		"http://[2001:db8::1]/hook",
+	}
+
+	for _, target := range targets {
+		t.Run(target, func(t *testing.T) {
+			t.Parallel()
+
+			require.Error(t,
+				guard.ValidateTargetURL(context.Background(), target),
+				"%s must be refused at target creation", target,
+			)
+
+			assertDialRefused(t, guard, target)
+		})
+	}
+}
+
 func TestValidateTargetURL_Allowed(t *testing.T) {
 	t.Parallel()
 

internal/delivery/store.go

@@ -0,0 +1,164 @@
+package delivery
+
+import (
+	"fmt"
+
+	"gorm.io/gorm"
+	"sneak.berlin/go/webhooker/internal/database"
+)
+
+// StoreEvent stores event with one pending delivery for each of its
+// webhook's active targets, and adds them to the totals, in one
+// transaction, then queues the deliveries. It returns how many
+// deliveries it created.
+//
+// The receiver stores every event it accepts through here, and a
+// resubmit stores its copy of a stored event, so every event is
+// stored, retried, SSRF-guarded and circuit-broken the same way however
+// it entered the system. CreateReplay is the only other place a
+// delivery is created.
+//
+// The targets are the webhook's active ones as they stand now: a
+// target created after a resubmitted event first arrived is included,
+// and an inactive one is skipped. An event with no active target is
+// stored with no deliveries.
+func (e *Engine) StoreEvent(event *database.Event) (int, error) {
+	var targets []database.Target
+
+	err := e.database.DB().Where(
+		"webhook_id = ? AND active = ?", event.WebhookID, true,
+	).Find(&targets).Error
+	if err != nil {
+		return 0, fmt.Errorf("loading active targets: %w", err)
+	}
+
+	webhookDB, err := e.dbManager.GetDB(event.WebhookID)
+	if err != nil {
+		return 0, fmt.Errorf("getting webhook database: %w", err)
+	}
+
+	event.BodyBytes = int64(len(event.Body))
+	tasks := make([]Task, 0, len(targets))
+
+	err = webhookDB.Transaction(func(tx *gorm.DB) error {
+		err := tx.Create(event).Error
+		if err != nil {
+			return fmt.Errorf("creating event: %w", err)
+		}
+
+		for i := range targets {
+			dlv, err := createDelivery(tx, event.ID, targets[i].ID, false)
+			if err != nil {
+				return err
+			}
+
+			tasks = append(tasks, buildTask(
+				dlv, event.WebhookID, event, &targets[i], 1,
+			))
+		}
+
+		err = database.AddEventTotals(tx, database.EventTotals{
+			Events: 1, LastEventAt: &event.CreatedAt,
+		})
+		if err != nil {
+			return err
+		}
+
+		// A resubmitted copy did not arrive on its entrypoint's URL, so
+		// it leaves the entrypoint's last event as it is.
+		if event.ResubmittedFromID != nil {
+			return nil
+		}
+
+		return database.AddEntrypointTotals(tx, database.EntrypointTotals{
+			EntrypointID: event.EntrypointID, LastEventAt: event.CreatedAt,
+		})
+	})
+	if err != nil {
+		return 0, err
+	}
+
+	// Counted here, after the commit: an event exists once it is
+	// durably stored, which is what the delivery counters are compared
+	// against on a dashboard. A resubmitted event counts too, because
+	// it produces deliveries that the delivery side counts; the
+	// resubmit counter is what separates the two.
+	e.mtr.EventReceived()
+
+	e.notify(tasks)
+
+	return len(tasks), nil
+}
+
+// CreateReplay creates one more pending delivery of the stored event
+// eventID to target, marked as a replay, adds it to the target's totals
+// in the same transaction, and queues it. It returns the new
+// delivery's id.
+//
+// The caller passes the target as it stands now and has already
+// decided the replay may go ahead. The delivery being replayed is not
+// touched.
+func (e *Engine) CreateReplay(
+	webhookID, eventID string, target *database.Target,
+) (string, error) {
+	webhookDB, err := e.dbManager.GetDB(webhookID)
+	if err != nil {
+		return "", fmt.Errorf("getting webhook database: %w", err)
+	}
+
+	event, err := e.loadEvent(webhookDB, eventID)
+	if err != nil {
+		return "", err
+	}
+
+	var dlv *database.Delivery
+
+	err = webhookDB.Transaction(func(tx *gorm.DB) error {
+		var err error
+
+		dlv, err = createDelivery(tx, event.ID, target.ID, true)
+
+		return err
+	})
+	if err != nil {
+		return "", err
+	}
+
+	e.notify([]Task{buildTask(dlv, webhookID, &event, target, 1)})
+
+	return dlv.ID, nil
+}
+
+// createDelivery writes a pending delivery of the event to the target
+// on the caller's transaction, and adds it to the target's totals.
+//
+// Neither Event nor Target is set on the row, and the per-webhook
+// database omits associations on every write in any case (see
+// internal/database/event_db_isolation.go), so the target's settings
+// are never copied into the event database.
+func createDelivery(
+	tx *gorm.DB, eventID, targetID string, replay bool,
+) (*database.Delivery, error) {
+	dlv := &database.Delivery{
+		EventID:  eventID,
+		TargetID: targetID,
+		Status:   database.DeliveryStatusPending,
+		Replay:   replay,
+	}
+
+	err := tx.Create(dlv).Error
+	if err != nil {
+		return nil, fmt.Errorf(
+			"creating delivery for target %s: %w", targetID, err,
+		)
+	}
+
+	err = database.AddTargetTotals(tx, database.TargetTotals{
+		TargetID: targetID, Deliveries: 1,
+	})
+	if err != nil {
+		return nil, err
+	}
+
+	return dlv, nil
+}

internal/delivery/store_test.go

@@ -0,0 +1,386 @@
+package delivery_test
+
+import (
+	"net/http"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/google/uuid"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"gorm.io/gorm"
+	"sneak.berlin/go/webhooker/internal/database"
+	"sneak.berlin/go/webhooker/internal/delivery"
+)
+
+// storeTestTarget creates an active http target of the setup's webhook
+// with every one of a target's settings set, so a task that drops one
+// of them differs from the target.
+func storeTestTarget(
+	t *testing.T, s iSetup, name string,
+) database.Target {
+	t.Helper()
+
+	target := database.Target{
+		WebhookID:       s.WebhookID,
+		Name:            name,
+		Type:            database.TargetTypeHTTP,
+		Active:          true,
+		URL:             "http://93.184.216.34/" + name,
+		Headers:         map[string]string{"X-Api-Key": "k"},
+		TimeoutSeconds:  7,
+		ForwardQuery:    true,
+		ArchiveExpiry:   time.Hour,
+		ArchiveRotation: rotationDaily,
+		MaxAttempts:     3,
+	}
+
+	require.NoError(t, s.MainDB.Create(&target).Error)
+
+	return target
+}
+
+// newStoreTestEvent returns an event of the setup's webhook as the
+// receiver builds one, not yet stored.
+func newStoreTestEvent(s iSetup, body string) *database.Event {
+	return &database.Event{
+		WebhookID:    s.WebhookID,
+		EntrypointID: uuid.New().String(),
+		Method:       http.MethodPost,
+		RawQuery:     "a=1&b=2",
+		Headers:      `{"X-Test":["yes"]}`,
+		ContentType:  testContentType,
+		Body:         body,
+	}
+}
+
+// queuedTasks takes every task the engine has queued so far. The
+// engine in these tests is never started, so nothing else takes them.
+func queuedTasks(e *delivery.Engine) []delivery.Task {
+	var tasks []delivery.Task
+
+	for {
+		select {
+		case task := <-e.ExportDeliveryCh():
+			tasks = append(tasks, task)
+		default:
+			return tasks
+		}
+	}
+}
+
+// assertTaskFor proves task carries delivery deliveryID of event to
+// target: every one of the target's settings and every event field.
+// They are copied into the task one field at a time, and a field left
+// out is sent empty without any error.
+func assertTaskFor(
+	t *testing.T,
+	task delivery.Task,
+	deliveryID string,
+	event *database.Event,
+	target *database.Target,
+) {
+	t.Helper()
+
+	assert.Equal(t, deliveryID, task.DeliveryID)
+	assert.Equal(t, event.ID, task.EventID)
+	assert.Equal(t, event.WebhookID, task.WebhookID)
+	assert.Equal(t, event.EntrypointID, task.EntrypointID)
+
+	assert.Equal(t, target.ID, task.TargetID)
+	assert.Equal(t, target.Name, task.TargetName)
+	assert.Equal(t, target.Type, task.TargetType)
+	assert.Equal(t, target.URL, task.TargetURL)
+	assert.Equal(t, target.Headers, task.TargetHeaders)
+	assert.Equal(t, target.TimeoutSeconds, task.TimeoutSeconds)
+	assert.Equal(t, target.ForwardQuery, task.ForwardQuery)
+	assert.Equal(t, target.ArchiveExpiry, task.ArchiveExpiry)
+	assert.Equal(t, target.ArchiveRotation, task.ArchiveRotation)
+	assert.Equal(t, target.MaxAttempts, task.MaxAttempts)
+
+	assert.Equal(t, event.Method, task.Method)
+	assert.Equal(t, event.RawQuery, task.RawQuery)
+	assert.Equal(t, event.Headers, task.Headers)
+	assert.Equal(t, event.ContentType, task.ContentType)
+	require.NotNil(t, task.Body)
+	assert.Equal(t, event.Body, *task.Body)
+
+	assert.Equal(t, 1, task.AttemptNum)
+}
+
+// storedDeliveries reads every delivery of an event.
+func storedDeliveries(
+	t *testing.T, db *gorm.DB, eventID string,
+) []database.Delivery {
+	t.Helper()
+
+	var deliveries []database.Delivery
+
+	require.NoError(t, db.Where("event_id = ?", eventID).
+		Find(&deliveries).Error)
+
+	return deliveries
+}
+
+// storedEventTotals reads the webhook's event totals.
+func storedEventTotals(t *testing.T, db *gorm.DB) database.EventTotals {
+	t.Helper()
+
+	var totals database.EventTotals
+
+	require.NoError(t, db.First(&totals).Error)
+
+	return totals
+}
+
+// countRows counts the rows of model in db.
+func countRows(t *testing.T, db *gorm.DB, model any) int64 {
+	t.Helper()
+
+	var n int64
+
+	require.NoError(t, db.Model(model).Count(&n).Error)
+
+	return n
+}
+
+// TestStoreEvent_StoresDeliveriesToActiveTargets proves StoreEvent
+// stores the event with one pending delivery to each active target and
+// none to an inactive one, adds them to the totals, and queues one task
+// per delivery.
+func TestStoreEvent_StoresDeliveriesToActiveTargets(t *testing.T) {
+	t.Parallel()
+
+	s := newISetup(t)
+	targets := []database.Target{
+		storeTestTarget(t, s, "first"),
+		storeTestTarget(t, s, "second"),
+	}
+	off := storeTestTarget(t, s, "off")
+
+	require.NoError(t, s.MainDB.Model(&database.Target{}).
+		Where("id = ?", off.ID).Update("active", false).Error)
+
+	event := newStoreTestEvent(s, `{"hello":"world"}`)
+
+	created, err := s.Engine.StoreEvent(event)
+	require.NoError(t, err)
+	assert.Equal(t, 2, created)
+
+	var stored database.Event
+
+	require.NoError(t, s.WebhookDB.First(&stored, "id = ?", event.ID).Error)
+	assert.Equal(t, event.Body, stored.Body)
+	assert.Equal(t, int64(len(event.Body)), stored.BodyBytes)
+
+	rows := storedDeliveries(t, s.WebhookDB, event.ID)
+	queued := queuedTasks(s.Engine)
+
+	require.Len(t, rows, 2)
+	require.Len(t, queued, 2)
+
+	deliveries := map[string]database.Delivery{}
+	for _, dlv := range rows {
+		deliveries[dlv.TargetID] = dlv
+	}
+
+	tasks := map[string]delivery.Task{}
+	for _, task := range queued {
+		tasks[task.TargetID] = task
+	}
+
+	for i := range targets {
+		dlv, ok := deliveries[targets[i].ID]
+		require.True(t, ok, "no delivery to %s", targets[i].Name)
+		assert.Equal(t, database.DeliveryStatusPending, dlv.Status)
+		assert.False(t, dlv.Replay)
+		assert.Equal(t, int64(1),
+			targetTotals(t, s.WebhookDB, targets[i].ID).Deliveries)
+
+		assertTaskFor(t, tasks[targets[i].ID], dlv.ID, event, &targets[i])
+	}
+
+	totals := storedEventTotals(t, s.WebhookDB)
+	assert.Equal(t, int64(1), totals.Events)
+	require.NotNil(t, totals.LastEventAt)
+	assert.True(t, totals.LastEventAt.Equal(stored.CreatedAt))
+
+	var entrypoint database.EntrypointTotals
+
+	require.NoError(t, s.WebhookDB.First(
+		&entrypoint, "entrypoint_id = ?", event.EntrypointID,
+	).Error)
+	assert.True(t, entrypoint.LastEventAt.Equal(stored.CreatedAt))
+}
+
+// TestStoreEvent_ResubmittedCopyLeavesTheEntrypoint proves a
+// resubmitted copy is counted among the webhook's events but leaves its
+// entrypoint's last event as it is: it did not arrive on that URL.
+func TestStoreEvent_ResubmittedCopyLeavesTheEntrypoint(t *testing.T) {
+	t.Parallel()
+
+	s := newISetup(t)
+	storeTestTarget(t, s, "only")
+
+	sourceID := uuid.New().String()
+	event := newStoreTestEvent(s, `{"copy":true}`)
+	event.ResubmittedFromID = &sourceID
+
+	created, err := s.Engine.StoreEvent(event)
+	require.NoError(t, err)
+	assert.Equal(t, 1, created)
+	assert.Len(t, queuedTasks(s.Engine), 1)
+
+	assert.Equal(t, int64(1), storedEventTotals(t, s.WebhookDB).Events)
+	assert.Zero(t, countRows(t, s.WebhookDB, &database.EntrypointTotals{}))
+}
+
+// TestStoreEvent_NoActiveTarget proves an event of a webhook with no
+// active target is stored with no delivery and nothing queued.
+func TestStoreEvent_NoActiveTarget(t *testing.T) {
+	t.Parallel()
+
+	s := newISetup(t)
+	event := newStoreTestEvent(s, `{"to":"nobody"}`)
+
+	created, err := s.Engine.StoreEvent(event)
+	require.NoError(t, err)
+	assert.Zero(t, created)
+
+	assert.Equal(t, int64(1), countRows(t, s.WebhookDB, &database.Event{}))
+	assert.Empty(t, storedDeliveries(t, s.WebhookDB, event.ID))
+	assert.Empty(t, queuedTasks(s.Engine))
+}
+
+// TestStoreEvent_LargeBodyIsNotCarried proves a body at the inline
+// limit is stored whole but left off the task, for the attempt to read
+// from the event row.
+func TestStoreEvent_LargeBodyIsNotCarried(t *testing.T) {
+	t.Parallel()
+
+	s := newISetup(t)
+	storeTestTarget(t, s, "only")
+
+	event := newStoreTestEvent(
+		s, strings.Repeat("x", delivery.MaxInlineBodySize),
+	)
+
+	_, err := s.Engine.StoreEvent(event)
+	require.NoError(t, err)
+
+	tasks := queuedTasks(s.Engine)
+	require.Len(t, tasks, 1)
+	assert.Nil(t, tasks[0].Body)
+
+	var stored database.Event
+
+	require.NoError(t, s.WebhookDB.First(&stored, "id = ?", event.ID).Error)
+	assert.Equal(t, event.Body, stored.Body)
+}
+
+// TestStoreEvent_RollsBackWhenAWriteFails proves the event, its
+// deliveries and its totals are one transaction: when the entrypoint
+// totals write fails, the last one, after the event, its delivery, the
+// target totals and the event totals were written, none of them is left
+// and nothing is queued.
+func TestStoreEvent_RollsBackWhenAWriteFails(t *testing.T) {
+	t.Parallel()
+
+	s := newISetup(t)
+	storeTestTarget(t, s, "only")
+
+	require.NoError(t,
+		s.WebhookDB.Migrator().DropTable(&database.EntrypointTotals{}))
+
+	_, err := s.Engine.StoreEvent(newStoreTestEvent(s, `{"lost":true}`))
+	require.Error(t, err)
+
+	assert.Zero(t, countRows(t, s.WebhookDB, &database.Event{}))
+	assert.Zero(t, countRows(t, s.WebhookDB, &database.Delivery{}))
+	assert.Zero(t, countRows(t, s.WebhookDB, &database.TargetTotals{}))
+
+	totals := storedEventTotals(t, s.WebhookDB)
+	assert.Zero(t, totals.Events)
+	assert.Nil(t, totals.LastEventAt)
+
+	assert.Empty(t, queuedTasks(s.Engine))
+	assert.Zero(t, s.Engine.ExportInflightHeld())
+}
+
+// TestCreateReplay_CreatesAndQueuesAReplay proves CreateReplay adds a
+// new pending delivery marked as a replay, counts it in the target's
+// totals, queues its task built from the target it was given and the
+// stored event, and leaves the delivery it repeats as it was. The
+// stored event has every event field set, so a task that drops one of
+// them differs from the event.
+func TestCreateReplay_CreatesAndQueuesAReplay(t *testing.T) {
+	t.Parallel()
+
+	s := newISetup(t)
+	target := storeTestTarget(t, s, "replayed")
+	event := newStoreTestEvent(s, `{"replay":"me"}`)
+	require.NoError(t, s.WebhookDB.Create(event).Error)
+
+	original := iSeedDelivery(
+		t, s.WebhookDB, event.ID, target.ID,
+		database.DeliveryStatusFailed,
+	)
+
+	deliveryID, err := s.Engine.CreateReplay(s.WebhookID, event.ID, &target)
+	require.NoError(t, err)
+
+	replay := storedDelivery(t, s.WebhookDB, deliveryID)
+	assert.Equal(t, event.ID, replay.EventID)
+	assert.Equal(t, target.ID, replay.TargetID)
+	assert.Equal(t, database.DeliveryStatusPending, replay.Status)
+	assert.True(t, replay.Replay)
+
+	assert.Equal(t, database.DeliveryStatusFailed,
+		storedDelivery(t, s.WebhookDB, original.ID).Status)
+	assert.Equal(t, int64(1),
+		targetTotals(t, s.WebhookDB, target.ID).Deliveries)
+
+	tasks := queuedTasks(s.Engine)
+	require.Len(t, tasks, 1)
+	assertTaskFor(t, tasks[0], deliveryID, event, &target)
+}
+
+// TestCreateReplay_RollsBackWhenAWriteFails proves the replay delivery
+// and its target totals are one transaction: when the totals write
+// fails, after the delivery was written, no new delivery is left and
+// nothing is queued.
+func TestCreateReplay_RollsBackWhenAWriteFails(t *testing.T) {
+	t.Parallel()
+
+	s := newISetup(t)
+	target := storeTestTarget(t, s, "replayed")
+	event := iSeedEvent(t, s.WebhookDB, s.WebhookID, `{"replay":"me"}`)
+	iSeedDelivery(
+		t, s.WebhookDB, event.ID, target.ID,
+		database.DeliveryStatusFailed,
+	)
+
+	require.NoError(t,
+		s.WebhookDB.Migrator().DropTable(&database.TargetTotals{}))
+
+	_, err := s.Engine.CreateReplay(s.WebhookID, event.ID, &target)
+	require.Error(t, err)
+
+	assert.Len(t, storedDeliveries(t, s.WebhookDB, event.ID), 1)
+	assert.Empty(t, queuedTasks(s.Engine))
+	assert.Zero(t, s.Engine.ExportInflightHeld())
+}
+
+// storedDelivery reads one delivery back.
+func storedDelivery(
+	t *testing.T, db *gorm.DB, deliveryID string,
+) database.Delivery {
+	t.Helper()
+
+	var dlv database.Delivery
+
+	require.NoError(t, db.First(&dlv, "id = ?", deliveryID).Error)
+
+	return dlv
+}

internal/delivery/target.go

@@ -13,8 +13,8 @@ import (
 // The engine provides one to each target so a target can own
 // its retries durably: it records the attempt, marks the
 // delivery retrying, and asks the Scheduler to deliver the
-// next attempt after delay — exactly what the engine does for
-// its own restart recovery.
+// next attempt after delay — exactly what the engine's
+// recovery routine does for a retrying delivery.
 type Scheduler interface {
 	ScheduleRetry(task Task, delay time.Duration)
 }
@@ -32,7 +32,8 @@ type Scheduler interface {
 // Engine.observeAttempt, alongside the DeliveryResult it records for
 // it. Deliver is also entered for attempts that never happen — an
 // open circuit breaker refuses one — so the count cannot be taken
-// from around this call.
+// from around this call. An attempt cut off by a stop is neither
+// counted nor recorded.
 type Target interface {
 	Deliver(
 		ctx context.Context,
@@ -44,29 +45,20 @@ type Target interface {
 }
 
 // rescheduler is implemented by targets that own durable
-// retries. The engine's restart recovery and periodic sweep
-// use it to let the target recompute the schedule for an
-// orphaned retrying delivery, keeping the retry schedule
-// target-owned. Fire-and-forget targets do not implement it
-// and their (never-occurring) retrying deliveries are
-// skipped.
+// retries. The engine's recovery routine uses it to let the
+// target recompute the schedule for an orphaned retrying
+// delivery, keeping the retry schedule target-owned.
+// Fire-and-forget targets do not implement it, and a retrying
+// delivery found for one is terminally failed.
 type rescheduler interface {
 	// remainingBackoff returns how long to wait before the
-	// next attempt of a recovered retrying delivery.
+	// next attempt of a recovered retrying delivery: zero once
+	// its backoff has passed.
 	remainingBackoff(
 		webhookDB *gorm.DB,
 		deliveryID string,
 		attemptNum int,
 	) time.Duration
-
-	// backoffElapsed reports whether the backoff window for
-	// the last attempt has already passed, so the periodic
-	// sweep can re-enqueue the delivery now.
-	backoffElapsed(
-		webhookDB *gorm.DB,
-		deliveryID string,
-		attemptNum int,
-	) bool
 }
 
 // attemptResult is the outcome of a single delivery attempt,
@@ -102,15 +94,13 @@ func (e *Engine) initTargets(client *http.Client) {
 		client:   client,
 	}
 
-	dbT := &databaseTarget{eng: e}
-
 	e.httpTarget = httpT
-	e.dbTarget = dbT
+	e.slackTarget = slackT
 
 	e.targets = map[database.TargetType]Target{
 		database.TargetTypeHTTP:     httpT,
 		database.TargetTypeSlack:    slackT,
-		database.TargetTypeDatabase: dbT,
+		database.TargetTypeDatabase: &databaseTarget{eng: e},
 		database.TargetTypeLog:      &logTarget{eng: e},
 	}
 }

internal/delivery/target_config_edit.go

@@ -1,119 +0,0 @@
-package delivery
-
-import (
-	"encoding/json"
-	"errors"
-	"fmt"
-
-	"sneak.berlin/go/webhooker/internal/database"
-)
-
-// errUnknownTargetTypeForEdit is returned when a stored target has a
-// type the edit form has no field set for.
-var errUnknownTargetTypeForEdit = errors.New(
-	"unknown target type",
-)
-
-// TargetConfigForm is the UNMASKED projection of a target's stored
-// configuration, for pre-filling the target edit form.
-//
-// It is the deliberate exception to the rule TargetView enforces
-// everywhere else: TargetView exists so that no template can render
-// a target's stored blob, because a destination URL's path segments
-// and a header value are both routinely the credential. An operator
-// cannot correct a value they cannot see, so the edit form — and
-// only the edit form — is shown the full value.
-//
-// Everything that keeps that exception narrow lives at the call
-// site: the route is behind RequireAuth and the webhook's ownership
-// check, and its group sets NoCache so the rendered secret is not
-// written to a shared cache. Do not reach for this type from any
-// other page.
-type TargetConfigForm struct {
-	// URL is the destination for an HTTP target and the webhook
-	// URL for a Slack target.
-	URL string
-	// Headers is the HTTP target's configured headers in the
-	// textarea representation, one "Name: value" per line.
-	Headers string
-	// Timeout is the HTTP target's per-request timeout in seconds,
-	// empty when unset.
-	Timeout string
-	// Expiry is the database (archive) target's row expiry.
-	Expiry string
-}
-
-// NewTargetConfigForm parses a target's stored configuration into
-// the edit form's fields.
-//
-// A configuration that does not parse is an error rather than a
-// zero-valued form that silently looks like a target with no
-// settings. The caller shows the operator that the stored value
-// could not be read, so that saving the form is understood as
-// replacing it rather than preserving it.
-func NewTargetConfigForm(
-	t *database.Target,
-) (TargetConfigForm, error) {
-	switch t.Type {
-	case database.TargetTypeHTTP:
-		cfg, err := parseHTTPConfig(t.Config)
-		if err != nil {
-			return TargetConfigForm{}, err
-		}
-
-		return TargetConfigForm{
-			URL:     cfg.URL,
-			Headers: FormatTargetHeaders(cfg.Headers),
-			Timeout: FormatTargetTimeout(cfg.Timeout),
-		}, nil
-	case database.TargetTypeSlack:
-		cfg, err := parseSlackConfig(t.Config)
-		if err != nil {
-			return TargetConfigForm{}, err
-		}
-
-		return TargetConfigForm{URL: cfg.WebhookURL}, nil
-	case database.TargetTypeDatabase:
-		return databaseConfigForm(t.Config)
-	case database.TargetTypeLog:
-		// The log target takes no configuration.
-		return TargetConfigForm{}, nil
-	default:
-		return TargetConfigForm{}, fmt.Errorf(
-			"%w: %q", errUnknownTargetTypeForEdit, t.Type,
-		)
-	}
-}
-
-// databaseConfigForm parses an archive target's optional expiry.
-// An absent or empty configuration is the keep-forever default and
-// yields an empty field, so re-saving the form unchanged stores the
-// same empty configuration it started with. An expiry that is set
-// but not a valid duration is an error, not a blank field.
-func databaseConfigForm(
-	configJSON string,
-) (TargetConfigForm, error) {
-	if configJSON == "" {
-		return TargetConfigForm{}, nil
-	}
-
-	var cfg databaseTargetConfig
-
-	err := json.Unmarshal([]byte(configJSON), &cfg)
-	if err != nil {
-		return TargetConfigForm{}, fmt.Errorf(
-			"parsing config JSON: %w", err,
-		)
-	}
-
-	if cfg.Expiry == "" || cfg.Expiry == archiveExpiryNever {
-		return TargetConfigForm{}, nil
-	}
-
-	err = ValidateArchiveExpiry(cfg.Expiry)
-	if err != nil {
-		return TargetConfigForm{}, err
-	}
-
-	return TargetConfigForm{Expiry: cfg.Expiry}, nil
-}

internal/delivery/target_config_view.go

@@ -1,23 +1,25 @@
 package delivery
 
 import (
-	"encoding/json"
 	"fmt"
 	"strconv"
+	"time"
 
+	"sneak.berlin/go/webhooker/internal/archive"
 	"sneak.berlin/go/webhooker/internal/database"
 )
 
-// configUnavailable is what a target's configuration renders
-// as when it is absent, of an unknown type, or does not
-// parse. The stored blob is never shown as a fallback: it can
-// hold a credential (a Slack incoming webhook URL is a bearer
-// token) and a UI that prints it leaks that credential into
-// browser history, screenshots and screen shares.
+// configUnavailable is what a target's settings render as when
+// the target is of an unknown type, and what its URL renders as
+// when it does not parse into a scheme and host. The stored URL is
+// never shown as a fallback: it can be a credential (a Slack
+// incoming webhook URL is a bearer token) and a UI that prints it
+// leaks that credential into browser history, screenshots and
+// screen shares.
 const configUnavailable = "(unavailable)"
 
 // ConfigField is one labelled, display-safe value derived
-// from a target's stored configuration.
+// from a target's settings.
 type ConfigField struct {
 	Label string
 	Value string
@@ -31,9 +33,9 @@ type ConfigField struct {
 const deletedNameSuffix = " (deleted)"
 
 // TargetView is the display-safe projection of a target for
-// the UI. It deliberately has no raw configuration field, so
-// no template — present or future — can render the stored
-// blob.
+// the UI. It deliberately has no URL or header field, so no
+// template — present or future — can render the stored
+// credential.
 type TargetView struct {
 	ID   string
 	Name string
@@ -60,8 +62,7 @@ func (v TargetView) DisplayName() string {
 }
 
 // NewTargetViews projects targets for rendering, replacing
-// each stored configuration blob with named, display-safe
-// fields.
+// each target's settings with named, display-safe fields.
 //
 // A soft-deleted row projects exactly as a live one does, minus
 // the deleted marker on its name: masking is a property of the
@@ -90,47 +91,37 @@ func NewTargetViews(
 }
 
 // targetConfigFields returns the display-safe fields for a
-// target's configuration. Anything it cannot parse becomes
-// the neutral placeholder.
+// target's settings. A target of an unknown type gets the
+// neutral placeholder.
 func targetConfigFields(
 	t *database.Target,
 ) []ConfigField {
 	switch t.Type {
 	case database.TargetTypeSlack:
-		return slackConfigFields(t.Config)
+		return slackConfigFields(t)
 	case database.TargetTypeHTTP:
 		return httpConfigFields(t)
 	case database.TargetTypeDatabase:
-		return databaseConfigFields(t.Config)
+		return databaseConfigFields(t)
 	case database.TargetTypeLog:
-		// The log target takes no configuration.
+		// The log target takes no settings.
 		return nil
 	default:
-		return unavailableConfigFields()
+		return []ConfigField{{
+			Label: "Configuration",
+			Value: configUnavailable,
+		}}
 	}
 }
 
-// unavailableConfigFields is the neutral placeholder shown
-// for a configuration that could not be presented.
-func unavailableConfigFields() []ConfigField {
-	return []ConfigField{{
-		Label: "Configuration",
-		Value: configUnavailable,
-	}}
-}
-
-// slackConfigFields describes a Slack target. Only the masked
-// webhook URL is shown; the full URL is the credential.
-func slackConfigFields(configJSON string) []ConfigField {
-	cfg, err := parseSlackConfig(configJSON)
-	if err != nil {
-		return unavailableConfigFields()
-	}
-
+// slackConfigFields describes a Slack target: its masked
+// webhook URL and its number of delivery attempts. Only the
+// masked URL is shown; the full URL is the credential.
+func slackConfigFields(t *database.Target) []ConfigField {
 	return []ConfigField{{
 		Label: "Webhook URL",
-		Value: cfg.MaskedWebhookURL(),
-	}}
+		Value: MaskURL(t.URL),
+	}, maxAttemptsField(t)}
 }
 
 // httpConfigFields describes an HTTP target: its destination
@@ -144,96 +135,95 @@ func slackConfigFields(configJSON string) []ConfigField {
 // whose path segments are the credential, and the field takes
 // an arbitrary URL, so no segment can be assumed non-secret.
 func httpConfigFields(t *database.Target) []ConfigField {
-	cfg, err := parseHTTPConfig(t.Config)
-	if err != nil {
-		return unavailableConfigFields()
-	}
-
 	fields := []ConfigField{{
 		Label: "Destination URL",
-		Value: MaskURL(cfg.URL),
+		Value: MaskURL(t.URL),
 	}}
 
-	if cfg.Timeout > 0 {
+	if t.TimeoutSeconds > 0 {
 		fields = append(fields, ConfigField{
 			Label: "Timeout",
-			Value: strconv.Itoa(cfg.Timeout) + "s",
+			Value: strconv.Itoa(t.TimeoutSeconds) + "s",
 		})
 	}
 
-	if len(cfg.Headers) > 0 {
+	if len(t.Headers) > 0 {
 		fields = append(fields, ConfigField{
 			Label: "Headers",
 			Value: fmt.Sprintf(
-				"%d configured", len(cfg.Headers),
+				"%d configured", len(t.Headers),
 			),
 		})
 	}
 
-	return append(fields, retryFields(t)...)
-}
-
-// retryFields describes a target's retry settings, which live
-// on the target row rather than in its configuration blob.
-func retryFields(t *database.Target) []ConfigField {
-	retries := strconv.Itoa(t.MaxRetries)
-	if t.MaxRetries == 0 {
-		retries += " (fire-and-forget)"
-	}
-
-	fields := []ConfigField{{
-		Label: "Max Retries",
-		Value: retries,
-	}}
-
-	if t.MaxQueueSize > 0 {
+	if t.ForwardQuery {
 		fields = append(fields, ConfigField{
-			Label: "Max Queue Size",
-			Value: strconv.Itoa(t.MaxQueueSize),
+			Label: "Query string",
+			Value: "passed on to this target",
 		})
 	}
 
+	fields = append(fields, maxAttemptsField(t))
+
 	return fields
 }
 
-// databaseConfigFields describes an archive target. Its
-// configuration is optional, and an absent or empty expiry
-// means the archive is kept forever. An expiry that is set
-// but not a valid duration is reported as unavailable rather
-// than echoed back.
-func databaseConfigFields(configJSON string) []ConfigField {
-	expiry := archiveExpiryNever
+// maxAttemptsField describes a target's number of delivery
+// attempts.
+func maxAttemptsField(t *database.Target) ConfigField {
+	return ConfigField{
+		Label: "Delivery attempts",
+		Value: strconv.Itoa(t.MaxAttempts),
+	}
+}
 
-	if configJSON != "" {
-		var cfg databaseTargetConfig
-
-		err := json.Unmarshal([]byte(configJSON), &cfg)
-		if err != nil {
-			return unavailableConfigFields()
-		}
-
-		if cfg.Expiry != "" {
-			if ValidateArchiveExpiry(cfg.Expiry) != nil {
-				return unavailableConfigFields()
-			}
-
-			expiry = cfg.Expiry
-		}
+// databaseConfigFields describes an archive target by its
+// expiry in plain units, such as "30 days", or "never" when
+// the archive is kept forever, and by its rotation.
+func databaseConfigFields(t *database.Target) []ConfigField {
+	value := archive.ExpiryNever
+	if t.ArchiveExpiry > 0 {
+		value = plainDuration(t.ArchiveExpiry)
 	}
 
 	return []ConfigField{{
-		Label: "Archive Expiry",
-		Value: expiry,
+		Label: "Archive expiry",
+		Value: value,
+	}, {
+		Label: "Archive rotation",
+		Value: t.ArchiveRotation,
 	}}
 }
 
-// MaskedWebhookURL returns the Slack webhook URL reduced to
-// its scheme and host, with the path, query and any userinfo
-// elided. The path segments are the credential, so none of
-// them is shown: the field accepts an arbitrary URL, so no
-// segment can be assumed non-secret. A URL that does not
-// parse into a scheme and host yields the neutral
-// placeholder, never the raw string.
-func (c *SlackTargetConfig) MaskedWebhookURL() string {
-	return MaskURL(c.WebhookURL)
+// plainDuration writes a positive duration as a count of the
+// largest whole unit it divides into: "30 days", "12 hours",
+// "1 minute". A duration with a fraction of a second is
+// written as Go writes it.
+func plainDuration(d time.Duration) string {
+	const day = 24 * time.Hour
+
+	units := []struct {
+		size time.Duration
+		name string
+	}{
+		{day, "day"},
+		{time.Hour, "hour"},
+		{time.Minute, "minute"},
+		{time.Second, "second"},
+	}
+
+	for _, unit := range units {
+		if d%unit.size != 0 {
+			continue
+		}
+
+		count := int64(d / unit.size)
+		if count == 1 {
+			return "1 " + unit.name
+		}
+
+		return fmt.Sprintf("%d %ss", count, unit.name)
+	}
+
+	return d.String()
 }

internal/delivery/target_config_view_test.go

@@ -32,9 +32,20 @@ const (
 	viewMaskedOrigin  = viewExampleOrigin + "/..."
 	viewUnavailable   = "(unavailable)"
 	viewExpiryNever   = "never"
+	viewMaxAttempts   = "Delivery attempts"
 )
 
-func TestMaskedWebhookURL(t *testing.T) {
+// The archive rotations a database target's settings can name.
+const (
+	rotationNone    = "none"
+	rotationMonthly = "monthly"
+	rotationDaily   = "daily"
+	rotationHourly  = "hourly"
+)
+
+// TestNewTargetViews_SlackMasksWebhookURL shows what a Slack target's
+// URL renders as on the target list.
+func TestNewTargetViews_SlackMasksWebhookURL(t *testing.T) {
 	t.Parallel()
 
 	tests := map[string]struct {
@@ -78,28 +89,24 @@ func TestMaskedWebhookURL(t *testing.T) {
 		t.Run(name, func(t *testing.T) {
 			t.Parallel()
 
-			cfg := &delivery.SlackTargetConfig{
-				WebhookURL: tc.url,
-			}
+			target := slackTarget()
+			target.URL = tc.url
 
 			assert.Equal(
-				t, tc.want, cfg.MaskedWebhookURL(),
+				t, tc.want,
+				fieldMap(viewFor(t, target).Config)["Webhook URL"],
 			)
 		})
 	}
 }
 
-// TestMaskedWebhookURL_NeverLeaksPath is the direct
+// TestNewTargetViews_SlackNeverLeaksPath is the direct
 // expression of the rule: whatever the input, the masked
 // value never contains a path segment of it.
-func TestMaskedWebhookURL_NeverLeaksPath(t *testing.T) {
+func TestNewTargetViews_SlackNeverLeaksPath(t *testing.T) {
 	t.Parallel()
 
-	cfg := &delivery.SlackTargetConfig{
-		WebhookURL: slackWebhookURL,
-	}
-
-	masked := cfg.MaskedWebhookURL()
+	masked := fieldMap(viewFor(t, slackTarget()).Config)["Webhook URL"]
 
 	assert.NotContains(t, masked, "T00000000")
 	assert.NotContains(t, masked, "B00000000")
@@ -157,9 +164,7 @@ func TestNewTargetViews_DeletedTarget(t *testing.T) {
 		t, slackTargetName+" (deleted)", view.DisplayName(),
 	)
 	assert.Equal(
-		t,
-		map[string]string{"Webhook URL": slackMaskedURL},
-		fieldMap(view.Config),
+		t, viewFor(t, slackTarget()).Config, view.Config,
 	)
 }
 
@@ -167,11 +172,11 @@ func TestNewTargetViews_DeletedTarget(t *testing.T) {
 // share.
 func slackTarget() database.Target {
 	return database.Target{
-		Name:   slackTargetName,
-		Type:   database.TargetTypeSlack,
-		Active: true,
-		Config: `{"webhookUrl":"` +
-			slackWebhookURL + `"}`,
+		Name:        slackTargetName,
+		Type:        database.TargetTypeSlack,
+		Active:      true,
+		URL:         slackWebhookURL,
+		MaxAttempts: 1,
 	}
 }
 
@@ -189,7 +194,31 @@ func TestNewTargetViews_Slack(t *testing.T) {
 
 	assert.Equal(
 		t,
-		map[string]string{"Webhook URL": slackMaskedURL},
+		map[string]string{
+			"Webhook URL":   slackMaskedURL,
+			viewMaxAttempts: "1",
+		},
+		fieldMap(view.Config),
+	)
+}
+
+// TestNewTargetViews_SlackAttempts proves a Slack target shows
+// its number of delivery attempts the same way an HTTP target
+// does.
+func TestNewTargetViews_SlackAttempts(t *testing.T) {
+	t.Parallel()
+
+	target := slackTarget()
+	target.MaxAttempts = 2
+
+	view := viewFor(t, target)
+
+	assert.Equal(
+		t,
+		map[string]string{
+			"Webhook URL":   slackMaskedURL,
+			viewMaxAttempts: "2",
+		},
 		fieldMap(view.Config),
 	)
 }
@@ -198,12 +227,12 @@ func TestNewTargetViews_HTTP(t *testing.T) {
 	t.Parallel()
 
 	view := viewFor(t, database.Target{
-		Type: database.TargetTypeHTTP,
-		Config: `{"url":"` + viewExampleHook + `",` +
-			`"timeout":30,` +
-			`"headers":{"Authorization":"Bearer sekrit"}}`,
-		MaxRetries:   5,
-		MaxQueueSize: 100,
+		Type:           database.TargetTypeHTTP,
+		URL:            viewExampleHook,
+		TimeoutSeconds: 30,
+		Headers:        map[string]string{headerAuthorization: "Bearer sekrit"},
+		ForwardQuery:   true,
+		MaxAttempts:    5,
 	})
 
 	fields := fieldMap(view.Config)
@@ -214,8 +243,8 @@ func TestNewTargetViews_HTTP(t *testing.T) {
 			"Destination URL": viewMaskedOrigin,
 			"Timeout":         "30s",
 			"Headers":         "1 configured",
-			"Max Retries":     "5",
-			"Max Queue Size":  "100",
+			"Query string":    "passed on to this target",
+			viewMaxAttempts:   "5",
 		},
 		fields,
 	)
@@ -226,19 +255,22 @@ func TestNewTargetViews_HTTP(t *testing.T) {
 	}
 }
 
-func TestNewTargetViews_HTTPFireAndForget(t *testing.T) {
+// TestNewTargetViews_HTTPSingleAttempt proves a single attempt is
+// shown as the plain number, like any other.
+func TestNewTargetViews_HTTPSingleAttempt(t *testing.T) {
 	t.Parallel()
 
 	view := viewFor(t, database.Target{
-		Type:   database.TargetTypeHTTP,
-		Config: `{"url":"` + viewExampleHook + `"}`,
+		Type:        database.TargetTypeHTTP,
+		URL:         viewExampleHook,
+		MaxAttempts: 1,
 	})
 
 	assert.Equal(
 		t,
 		map[string]string{
 			"Destination URL": viewMaskedOrigin,
-			"Max Retries":     "0 (fire-and-forget)",
+			viewMaxAttempts:   "1",
 		},
 		fieldMap(view.Config),
 	)
@@ -252,8 +284,9 @@ func TestNewTargetViews_HTTPMasksDestinationURL(t *testing.T) {
 	t.Parallel()
 
 	view := viewFor(t, database.Target{
-		Type:   database.TargetTypeHTTP,
-		Config: `{"url":"` + slackWebhookURL + `"}`,
+		Type:        database.TargetTypeHTTP,
+		URL:         slackWebhookURL,
+		MaxAttempts: 1,
 	})
 
 	fields := fieldMap(view.Config)
@@ -276,19 +309,20 @@ func TestNewTargetViews_Database(t *testing.T) {
 	t.Parallel()
 
 	tests := map[string]struct {
-		config string
+		expiry time.Duration
 		want   string
 	}{
-		"empty config": {config: "", want: viewExpiryNever},
-		"empty expiry": {config: `{}`, want: viewExpiryNever},
-		"explicit": {
-			config: `{"expiry":"720h"}`,
-			want:   "720h",
-		},
-		"never literal": {
-			config: `{"expiry":"` + viewExpiryNever + `"}`,
-			want:   viewExpiryNever,
-		},
+		"never": {expiry: 0, want: viewExpiryNever},
+		"1h":    {expiry: time.Hour, want: "1 hour"},
+		"12h":   {expiry: 12 * time.Hour, want: "12 hours"},
+		"24h":   {expiry: 24 * time.Hour, want: "1 day"},
+		"720h":  {expiry: 720 * time.Hour, want: "30 days"},
+		"2160h": {expiry: 2160 * time.Hour, want: "90 days"},
+		"8760h": {expiry: 8760 * time.Hour, want: "365 days"},
+		"36h":   {expiry: 36 * time.Hour, want: "36 hours"},
+		"1h30m": {expiry: 90 * time.Minute, want: "90 minutes"},
+		"45s":   {expiry: 45 * time.Second, want: "45 seconds"},
+		"1.5s":  {expiry: 1500 * time.Millisecond, want: "1.5s"},
 	}
 
 	for name, tc := range tests {
@@ -296,81 +330,72 @@ func TestNewTargetViews_Database(t *testing.T) {
 			t.Parallel()
 
 			view := viewFor(t, database.Target{
-				Type:   database.TargetTypeDatabase,
-				Config: tc.config,
+				Type:            database.TargetTypeDatabase,
+				ArchiveExpiry:   tc.expiry,
+				ArchiveRotation: rotationNone,
 			})
 
 			assert.Equal(
 				t,
-				map[string]string{"Archive Expiry": tc.want},
+				map[string]string{
+					"Archive expiry":   tc.want,
+					"Archive rotation": rotationNone,
+				},
 				fieldMap(view.Config),
 			)
 		})
 	}
 }
 
+// TestNewTargetViews_DatabaseRotation proves the target list shows a
+// database target's rotation.
+func TestNewTargetViews_DatabaseRotation(t *testing.T) {
+	t.Parallel()
+
+	for _, rotation := range []string{
+		rotationNone, rotationMonthly, rotationDaily, rotationHourly,
+	} {
+		t.Run(rotation, func(t *testing.T) {
+			t.Parallel()
+
+			view := viewFor(t, database.Target{
+				Type:            database.TargetTypeDatabase,
+				ArchiveRotation: rotation,
+			})
+
+			assert.Equal(
+				t, rotation, fieldMap(view.Config)["Archive rotation"],
+			)
+		})
+	}
+}
+
 func TestNewTargetViews_Log(t *testing.T) {
 	t.Parallel()
 
 	view := viewFor(t, database.Target{
-		Type:   database.TargetTypeLog,
-		Config: "",
+		Type: database.TargetTypeLog,
 	})
 
 	assert.Empty(t, view.Config)
 }
 
-// TestNewTargetViews_Unpresentable proves that no config the
-// view cannot present falls back to the stored blob.
-func TestNewTargetViews_Unpresentable(t *testing.T) {
+// TestNewTargetViews_UnknownType proves that a target of a type the
+// view does not know shows the neutral placeholder, and never its
+// URL.
+func TestNewTargetViews_UnknownType(t *testing.T) {
 	t.Parallel()
 
-	const blob = `{"webhookUrl":"https://hooks.slack.com` +
-		slackSecretPath + `"`
+	view := viewFor(t, database.Target{
+		Type: database.TargetType("carrier-pigeon"),
+		URL:  slackWebhookURL,
+	})
 
-	tests := map[string]database.Target{
-		"unknown target type": {
-			Type:   database.TargetType("carrier-pigeon"),
-			Config: blob,
+	assert.Equal(
+		t,
+		map[string]string{
+			"Configuration": viewUnavailable,
 		},
-		"unparseable json": {
-			Type:   database.TargetTypeSlack,
-			Config: blob,
-		},
-		"empty slack config": {
-			Type: database.TargetTypeSlack,
-		},
-		"slack config without url": {
-			Type:   database.TargetTypeSlack,
-			Config: `{}`,
-		},
-		"unparseable http json": {
-			Type:   database.TargetTypeHTTP,
-			Config: `{"url":`,
-		},
-		"unparseable archive json": {
-			Type:   database.TargetTypeDatabase,
-			Config: `{"expiry":`,
-		},
-		"invalid archive expiry": {
-			Type:   database.TargetTypeDatabase,
-			Config: `{"expiry":"a fortnight"}`,
-		},
-	}
-
-	for name, target := range tests {
-		t.Run(name, func(t *testing.T) {
-			t.Parallel()
-
-			view := viewFor(t, target)
-
-			assert.Equal(
-				t,
-				map[string]string{
-					"Configuration": viewUnavailable,
-				},
-				fieldMap(view.Config),
-			)
-		})
-	}
+		fieldMap(view.Config),
+	)
 }

internal/delivery/target_database.go

@@ -2,29 +2,23 @@ package delivery
 
 import (
 	"context"
-	"fmt"
-	"path/filepath"
-	"sync"
 	"time"
 
 	"gorm.io/gorm"
 	"sneak.berlin/go/webhooker/internal/database"
 )
 
-// databaseTarget is a no-retry target that archives the
-// full inbound event into a per-webhook archive SQLite file,
-// separate from the per-webhook event database. The event is
-// already persisted in the per-webhook event DB by the time
-// delivery runs; the database target additionally writes a
-// durable long-term copy into archive-{webhookID}.db and then
-// records a single attempt whose outcome reflects whether the
-// archive write succeeded. See archiveWriter for the
-// close/reopen, auto-recreate, and expiry semantics.
+// databaseTarget is a no-retry target that archives the full
+// inbound event into the target's own archive SQLite file, separate
+// from the per-webhook event database. The event is already
+// persisted in the per-webhook event DB by the time delivery runs;
+// the database target additionally writes a durable long-term copy
+// through the engine's archive.Writers, and then records a single
+// attempt whose outcome reflects whether the archive write
+// succeeded. Package archive holds everything about the files
+// themselves.
 type databaseTarget struct {
 	eng *Engine
-
-	mu      sync.Mutex
-	writers map[string]*archiveWriter
 }
 
 // Deliver implements Target. It archives the event, then
@@ -44,7 +38,7 @@ func (t *databaseTarget) Deliver(
 ) {
 	start := time.Now()
 
-	err := t.archive(d)
+	err := t.eng.archives.Write(d)
 
 	elapsed := time.Since(start)
 
@@ -91,243 +85,3 @@ func (t *databaseTarget) Deliver(
 		database.DeliveryStatusDelivered,
 	)
 }
-
-// archive writes the full event as a row into the webhook's
-// archive database, honouring the optional per-target expiry
-// parsed from the target config JSON.
-func (t *databaseTarget) archive(d *database.Delivery) error {
-	webhookID := d.Event.WebhookID
-	if webhookID == "" {
-		return errArchiveMissingWebhookID
-	}
-
-	expiry, err := parseArchiveExpiry(d.Target.Config)
-	if err != nil {
-		return err
-	}
-
-	w, err := t.writerFor(webhookID)
-	if err != nil {
-		return err
-	}
-
-	row := archivedEvent{
-		EventID:      d.Event.ID,
-		WebhookID:    webhookID,
-		EntrypointID: d.Event.EntrypointID,
-		Method:       d.Event.Method,
-		Headers:      d.Event.Headers,
-		Body:         d.Event.Body,
-		ContentType:  d.Event.ContentType,
-	}
-
-	return w.write(row, expiry)
-}
-
-// writerFor returns the archiveWriter for a webhook, creating
-// and caching it on first use. Each webhook has one writer so
-// its close/reopen debounce state is shared across concurrent
-// deliveries. The archive file lives beside the per-webhook
-// event database in the data directory.
-func (t *databaseTarget) writerFor(
-	webhookID string,
-) (*archiveWriter, error) {
-	path, err := t.archivePath(webhookID)
-	if err != nil {
-		return nil, err
-	}
-
-	t.mu.Lock()
-	defer t.mu.Unlock()
-
-	if t.writers == nil {
-		t.writers = make(map[string]*archiveWriter)
-	}
-
-	w, ok := t.writers[webhookID]
-	if !ok {
-		w = newArchiveWriter(path, t.eng.log)
-		t.writers[webhookID] = w
-	}
-
-	// A delivery claims the entry: even if the idle sweep created
-	// it moments ago, it now belongs to the registry proper and
-	// the sweep must leave it in place when it finishes.
-	w.sweepOwned = false
-
-	return w, nil
-}
-
-// sweepWriterFor returns the archive writer the idle sweep should
-// prune a webhook through, together with whether the sweep itself
-// created the registry entry.
-//
-// The sweep must route its prune through the registered writer so
-// the writer's mutex orders it against concurrent writes, but it
-// must never leave a registry entry behind: a sweep that ran
-// concurrently with the webhook's deletion would otherwise
-// re-create an entry that nothing will ever evict again, which is
-// exactly the leak eviction exists to prevent. An entry the sweep
-// creates is therefore marked sweep-owned and handed back to
-// releaseSweepWriter when the sweep is done.
-func (t *databaseTarget) sweepWriterFor(
-	webhookID string,
-) (*archiveWriter, bool, error) {
-	path, err := t.archivePath(webhookID)
-	if err != nil {
-		return nil, false, err
-	}
-
-	t.mu.Lock()
-	defer t.mu.Unlock()
-
-	if t.writers == nil {
-		t.writers = make(map[string]*archiveWriter)
-	}
-
-	w, ok := t.writers[webhookID]
-	if ok {
-		return w, false, nil
-	}
-
-	w = newArchiveWriter(path, t.eng.log)
-	w.sweepOwned = true
-	t.writers[webhookID] = w
-
-	return w, true, nil
-}
-
-// releaseSweepWriter drops a registry entry that the idle sweep
-// created, so a sweep leaves the registry exactly as it found it.
-//
-// The entry is removed only if it is still the very writer the
-// sweep installed and no delivery has claimed it in the meantime
-// (writerFor clears sweepOwned when it hands a writer to the
-// write path). Both conditions are evaluated under the registry
-// lock, so an eviction that raced the sweep — which removes the
-// entry outright — simply finds nothing left to do here, and a
-// delivery that adopted the writer keeps a registered, evictable
-// one.
-func (t *databaseTarget) releaseSweepWriter(
-	webhookID string, w *archiveWriter,
-) {
-	t.mu.Lock()
-	defer t.mu.Unlock()
-
-	cur, ok := t.writers[webhookID]
-	if !ok || cur != w || !cur.sweepOwned {
-		return
-	}
-
-	delete(t.writers, webhookID)
-}
-
-// archivePath returns the archive file path for a webhook: it
-// lives beside the per-webhook event database in the data
-// directory. It does not touch the filesystem.
-func (t *databaseTarget) archivePath(
-	webhookID string,
-) (string, error) {
-	if t.eng.dbManager == nil {
-		return "", errArchiveNoDataDir
-	}
-
-	dir := filepath.Dir(t.eng.dbManager.DBPath(webhookID))
-
-	return filepath.Join(
-		dir, fmt.Sprintf("archive-%s.db", webhookID),
-	), nil
-}
-
-// evict drops a webhook's archive writer from the registry and
-// closes its handle, so a deleted webhook does not leave a
-// writer (and an open archive handle within its debounce
-// window) alive for the process lifetime.
-//
-// The map entry is removed under the registry lock, which is
-// then released before the handle is closed under the writer's
-// own lock: that ordering keeps the registry available to other
-// webhooks while an in-flight write on this one drains, and
-// closing under the writer's lock means eviction can never race
-// a write.
-//
-// Eviction is idempotent and silent for a webhook with no
-// writer, which is the common case: a webhook with no database
-// target never creates one. It never deletes the archive file.
-func (t *databaseTarget) evict(webhookID string) {
-	t.mu.Lock()
-
-	w, ok := t.writers[webhookID]
-	if ok {
-		delete(t.writers, webhookID)
-	}
-
-	t.mu.Unlock()
-
-	if !ok {
-		return
-	}
-
-	w.evict()
-
-	t.eng.log.Info(
-		"evicted archive writer",
-		"webhook_id", webhookID,
-		"path", w.path,
-	)
-}
-
-// evictAll evicts every cached archive writer, exactly as evict
-// does for one webhook. The engine calls it at shutdown, once its
-// workers have returned. Closing the last handle on an archive
-// moves the contents of its -wal into the .db and removes the
-// -wal, so a clean stop leaves each archive as a single file.
-func (t *databaseTarget) evictAll() {
-	t.mu.Lock()
-
-	writers := t.writers
-	t.writers = nil
-
-	t.mu.Unlock()
-
-	for _, w := range writers {
-		w.evict()
-	}
-}
-
-// sweepWebhook prunes one webhook's archive of rows older than
-// expiry, without requiring a write. It returns nil (nothing to
-// do) when the archive file does not exist, so a sweep never
-// creates an archive for a webhook that has a database target
-// but has never received an event.
-//
-// It also never leaves a registry entry behind: an entry it had
-// to create to reach the writer's mutex is released again once
-// the prune is done, so a sweep racing a webhook deletion cannot
-// resurrect the writer the eviction just dropped.
-func (t *databaseTarget) sweepWebhook(
-	webhookID string, expiry time.Duration,
-) error {
-	path, err := t.archivePath(webhookID)
-	if err != nil {
-		return err
-	}
-
-	// Check before taking a writer at all: a webhook whose
-	// archive has never been created gets no writer, no handle,
-	// and no file.
-	if !fileExists(path) {
-		return nil
-	}
-
-	w, created, err := t.sweepWriterFor(webhookID)
-	if err != nil {
-		return err
-	}
-
-	if created {
-		defer t.releaseSweepWriter(webhookID, w)
-	}
-
-	return w.sweepExpired(expiry)
-}

internal/delivery/target_database_archive.go

@@ -1,438 +0,0 @@
-package delivery
-
-import (
-	"encoding/json"
-	"errors"
-	"fmt"
-	"log/slog"
-	"os"
-	"sync"
-	"time"
-
-	"gorm.io/driver/sqlite"
-	"gorm.io/gorm"
-	"sneak.berlin/go/webhooker/internal/database"
-	"sneak.berlin/go/webhooker/internal/gormlog"
-)
-
-// archiveExpiryNever is the expiry sentinel (and default) that
-// disables pruning so archived rows are kept forever.
-const archiveExpiryNever = "never"
-
-// archiveReopenDebounce bounds how often an archive file is
-// closed and reopened. After each write the handle is closed
-// and reopened so an operator can move the file away for
-// offline archiving, but never more than once per this window.
-const archiveReopenDebounce = time.Second
-
-const (
-	// archiveModeCreate is the SQLite URI mode used by the write
-	// path: open the archive file, creating it if missing, so a
-	// first write (or a write after the operator moved the file
-	// away) recreates it.
-	archiveModeCreate = database.SQLiteModeCreate
-
-	// archiveModeExisting is the SQLite URI mode used by the idle
-	// sweep: open read-write but never create. A sweep must never
-	// conjure an empty archive file for a webhook that has a
-	// database target but has never received an event.
-	archiveModeExisting = database.SQLiteModeExisting
-)
-
-var (
-	// errArchiveMissingWebhookID is returned when an event to
-	// archive has no webhook id to key its archive file on.
-	errArchiveMissingWebhookID = errors.New(
-		"cannot archive event without a webhook id",
-	)
-
-	// errArchiveNoDataDir is returned when the database target
-	// has no webhook database manager and so cannot locate the
-	// data directory for archive files.
-	errArchiveNoDataDir = errors.New(
-		"database target has no data directory",
-	)
-
-	// errArchiveExpiryNotPositive is returned when a
-	// user-supplied archive expiry parses as a duration but is
-	// zero or negative; "never" is the way to disable pruning.
-	errArchiveExpiryNotPositive = errors.New(
-		"expiry must be a positive duration or \"never\"",
-	)
-
-	// errArchiveWriterEvicted is returned when a writer that has
-	// been evicted (its webhook was deleted, or its last database
-	// target was removed) is used again. An evicted writer is no
-	// longer in the registry, so reopening its file would leak a
-	// handle nothing owns.
-	errArchiveWriterEvicted = errors.New(
-		"archive writer has been evicted",
-	)
-)
-
-// databaseTargetConfig is the optional per-target JSON config
-// for a database (archive) target.
-type databaseTargetConfig struct {
-	// Expiry is a Go duration (e.g. "720h") after which
-	// archived rows are pruned, or "never" (the default) to
-	// keep them forever.
-	Expiry string `json:"expiry"`
-}
-
-// archivedEvent is one fully captured webhook event stored in a
-// per-webhook archive database for long-term retention. It is a
-// self-contained copy — independent of the per-webhook event
-// database, which may prune events under its own retention.
-type archivedEvent struct {
-	ID           uint   `gorm:"primaryKey;autoIncrement"`
-	EventID      string `gorm:"index"`
-	WebhookID    string
-	EntrypointID string
-	Method       string
-	Headers      string
-	Body         string
-	ContentType  string
-
-	// ArchivedAt is when the row was archived and is the age
-	// basis for expiry pruning.
-	ArchivedAt time.Time `gorm:"index"`
-}
-
-// parseArchiveExpiry reads the optional expiry from a database
-// target's config JSON. An empty config, an empty expiry, or
-// the literal "never" all mean keep forever, returned as a zero
-// duration. Any other value must parse as a positive Go
-// duration; a set-but-invalid value (unparseable, zero, or
-// negative) is an error rather than a silent default, matching
-// ValidateArchiveExpiry at target creation.
-func parseArchiveExpiry(
-	configJSON string,
-) (time.Duration, error) {
-	if configJSON == "" {
-		return 0, nil
-	}
-
-	var cfg databaseTargetConfig
-
-	err := json.Unmarshal([]byte(configJSON), &cfg)
-	if err != nil {
-		return 0, fmt.Errorf(
-			"parsing database target config: %w", err,
-		)
-	}
-
-	if cfg.Expiry == "" || cfg.Expiry == archiveExpiryNever {
-		return 0, nil
-	}
-
-	dur, err := time.ParseDuration(cfg.Expiry)
-	if err != nil {
-		return 0, fmt.Errorf(
-			"parsing archive expiry %q: %w", cfg.Expiry, err,
-		)
-	}
-
-	if dur <= 0 {
-		return 0, fmt.Errorf(
-			"%w: %q", errArchiveExpiryNotPositive, cfg.Expiry,
-		)
-	}
-
-	return dur, nil
-}
-
-// ValidateArchiveExpiry checks a user-supplied archive expiry
-// for a database target at configuration time. Valid values are
-// empty, "never" (both meaning keep forever), or a positive Go
-// duration such as "720h". Anything else is an error, so a bad
-// expiry is rejected when the target is created rather than
-// failing every subsequent delivery.
-func ValidateArchiveExpiry(expiry string) error {
-	if expiry == "" || expiry == archiveExpiryNever {
-		return nil
-	}
-
-	dur, err := time.ParseDuration(expiry)
-	if err != nil {
-		return fmt.Errorf(
-			"expiry must be %q or a Go duration "+
-				"such as \"720h\": %w",
-			archiveExpiryNever, err,
-		)
-	}
-
-	if dur <= 0 {
-		return fmt.Errorf(
-			"%w: %q", errArchiveExpiryNotPositive, expiry,
-		)
-	}
-
-	return nil
-}
-
-// archiveWriter owns one per-webhook archive SQLite file. It
-// serialises writes, and after each write closes and reopens
-// the file (debounced to at most once per debounce window) so
-// an operator can move the file away for offline archiving. The
-// next write recreates a moved or removed file, because the
-// file is opened create-if-missing and its schema is migrated
-// on every open.
-type archiveWriter struct {
-	mu         sync.Mutex
-	path       string
-	log        *slog.Logger
-	debounce   time.Duration
-	db         *gorm.DB
-	lastReopen time.Time
-	reopens    int
-
-	// evicted marks a writer that has been removed from the
-	// per-webhook registry. Its handle is closed and it must
-	// never open the file again: nothing holds it any more, so a
-	// reopen would leak the handle for the process lifetime.
-	evicted bool
-
-	// sweepOwned marks a registry entry that the idle sweep
-	// created because no writer was cached for the webhook. The
-	// sweep removes such an entry again when it is done, so a
-	// sweep can never leave — or resurrect — a registry entry
-	// for a webhook that has been deleted. A delivery that adopts
-	// the writer clears the flag, handing the entry to the
-	// registry proper.
-	//
-	// Unlike every other field here it is guarded by
-	// databaseTarget.mu, not by this writer's mu: it describes the
-	// registry entry rather than the file.
-	sweepOwned bool
-}
-
-// newArchiveWriter builds an archiveWriter for a file path with
-// the default reopen debounce.
-func newArchiveWriter(
-	path string, log *slog.Logger,
-) *archiveWriter {
-	return &archiveWriter{
-		path:     path,
-		log:      log,
-		debounce: archiveReopenDebounce,
-	}
-}
-
-// write appends the event as a row, then applies the debounced
-// close/reopen. It recreates the archive file if it was moved
-// or removed since the last open. A positive expiry prunes rows
-// older than it on each (re)open.
-func (w *archiveWriter) write(
-	row archivedEvent, expiry time.Duration,
-) error {
-	w.mu.Lock()
-	defer w.mu.Unlock()
-
-	if w.evicted {
-		return fmt.Errorf(
-			"%w: %s", errArchiveWriterEvicted, w.path,
-		)
-	}
-
-	if w.db == nil || !fileExists(w.path) {
-		err := w.reopen(expiry)
-		if err != nil {
-			return err
-		}
-	}
-
-	row.ArchivedAt = time.Now()
-
-	err := w.db.Create(&row).Error
-	if err != nil {
-		return fmt.Errorf(
-			"archiving event to %s: %w", w.path, err,
-		)
-	}
-
-	if time.Since(w.lastReopen) >= w.debounce {
-		return w.reopen(expiry)
-	}
-
-	return nil
-}
-
-// open opens (creating if missing) the archive file, migrates
-// its schema, records the reopen time, and prunes expired rows
-// when expiry is positive.
-func (w *archiveWriter) open(expiry time.Duration) error {
-	return w.openMode(archiveModeCreate, expiry)
-}
-
-// openMode opens the archive file with the given SQLite URI
-// mode, migrates its schema, records the reopen time, and
-// prunes expired rows when expiry is positive. The write path
-// passes archiveModeCreate so a missing file is recreated; the
-// idle sweep passes archiveModeExisting so a missing file is an
-// error rather than a newly conjured empty archive.
-func (w *archiveWriter) openMode(
-	mode string, expiry time.Duration,
-) error {
-	// Opened through database.OpenSQLite so an archive file carries
-	// the same WAL journaling, busy timeout, immediate-transaction
-	// locking, and pool bounds as every other database file. See
-	// internal/database/sqlite_open.go.
-	sqlDB, err := database.OpenSQLite(w.path, mode)
-	if err != nil {
-		return fmt.Errorf(
-			"opening archive database %s: %w", w.path, err,
-		)
-	}
-
-	gdb, err := gorm.Open(
-		sqlite.Dialector{Conn: sqlDB}, &gorm.Config{
-			// Never leave this at GORM's default. See
-			// internal/gormlog.
-			Logger: gormlog.New(w.log),
-		},
-	)
-	if err != nil {
-		_ = sqlDB.Close()
-
-		return fmt.Errorf(
-			"connecting to archive database %s: %w",
-			w.path, err,
-		)
-	}
-
-	err = gdb.AutoMigrate(&archivedEvent{})
-	if err != nil {
-		_ = sqlDB.Close()
-
-		return fmt.Errorf(
-			"migrating archive database %s: %w", w.path, err,
-		)
-	}
-
-	w.db = gdb
-	w.lastReopen = time.Now()
-	w.reopens++
-
-	if expiry > 0 {
-		w.prune(expiry)
-	}
-
-	return nil
-}
-
-// reopen closes any open handle and opens the file afresh. The
-// fresh open recreates the file if it was moved away.
-func (w *archiveWriter) reopen(expiry time.Duration) error {
-	w.close()
-
-	return w.open(expiry)
-}
-
-// close closes the underlying handle, if any.
-func (w *archiveWriter) close() {
-	if w.db == nil {
-		return
-	}
-
-	sqlDB, err := w.db.DB()
-	if err == nil {
-		_ = sqlDB.Close()
-	}
-
-	w.db = nil
-}
-
-// sweepExpired prunes an archive that may have gone idle, with
-// no write to trigger the usual on-reopen prune. It takes the
-// writer's own mutex for the whole operation, so a sweep is
-// ordered against concurrent writes rather than reaching around
-// them to the file.
-//
-// It never creates the archive file: a missing file is skipped,
-// and the reopen uses archiveModeExisting so SQLite itself
-// refuses to create one if the file disappears between the
-// check and the open.
-//
-// The archive is left CLOSED afterwards. An idle archive holding
-// no handle is what keeps the operator's move-the-file-away
-// workflow working; the next write reopens (and recreates) the
-// file as it always has.
-func (w *archiveWriter) sweepExpired(expiry time.Duration) error {
-	w.mu.Lock()
-	defer w.mu.Unlock()
-
-	if w.evicted {
-		return fmt.Errorf(
-			"%w: %s", errArchiveWriterEvicted, w.path,
-		)
-	}
-
-	if !fileExists(w.path) {
-		return nil
-	}
-
-	// Drop any live handle first so the prune runs against a
-	// freshly opened file, matching the write path's semantics.
-	w.close()
-
-	err := w.openMode(archiveModeExisting, expiry)
-	if err != nil {
-		return err
-	}
-
-	w.close()
-
-	return nil
-}
-
-// evict closes the writer's handle and marks it unusable. It is
-// called when the writer leaves the registry, either because the
-// webhook was deleted or because its last database target was
-// removed. The archive FILE is deliberately left on disk: it is
-// long-term storage an operator may still want.
-func (w *archiveWriter) evict() {
-	w.mu.Lock()
-	defer w.mu.Unlock()
-
-	w.evicted = true
-
-	w.close()
-}
-
-// prune deletes archived rows older than expiry, measured from
-// each row's archived time. It runs on every (re)open, so a
-// steadily written archive is swept by its own write traffic. An
-// archive that goes idle receives no further reopens, which is
-// why ArchiveSweeper exists to drive sweepExpired on a timer.
-// Failures are logged, not fatal: a prune error must not stop
-// archiving.
-func (w *archiveWriter) prune(expiry time.Duration) {
-	cutoff := time.Now().Add(-expiry)
-
-	res := w.db.Where("archived_at < ?", cutoff).
-		Delete(&archivedEvent{})
-	if res.Error != nil {
-		w.log.Error(
-			"failed to prune expired archive rows",
-			"path", w.path,
-			"error", res.Error,
-		)
-
-		return
-	}
-
-	if res.RowsAffected > 0 {
-		w.log.Info(
-			"pruned expired archive rows",
-			"path", w.path,
-			"rows_deleted", res.RowsAffected,
-		)
-	}
-}
-
-// fileExists reports whether a path currently exists.
-func fileExists(path string) bool {
-	_, err := os.Stat(path)
-
-	return err == nil
-}

internal/delivery/target_database_test.go

@@ -1,6 +1,7 @@
 package delivery_test
 
 import (
+	"context"
 	"database/sql"
 	"fmt"
 	"log/slog"
@@ -15,11 +16,54 @@ import (
 	"github.com/stretchr/testify/require"
 	"gorm.io/driver/sqlite"
 	"gorm.io/gorm"
+	"gorm.io/gorm/clause"
 	_ "modernc.org/sqlite" // Pure Go SQLite driver.
+	"sneak.berlin/go/webhooker/internal/archive"
 	"sneak.berlin/go/webhooker/internal/database"
+	"sneak.berlin/go/webhooker/internal/database/databasetest"
+	"sneak.berlin/go/webhooker/internal/db/migrations"
 	"sneak.berlin/go/webhooker/internal/delivery"
+	"sneak.berlin/go/webhooker/internal/gormlog"
 )
 
+// archiveTestWebhookName is the name of every webhook
+// seedDatabaseTarget creates. It is not safe in a file name as it
+// stands, so every archive file name made from it is made safe first.
+const archiveTestWebhookName = "Sweep Test!"
+
+// archiveEnv bundles the pieces a database target test drives: a main
+// configuration database holding webhooks and targets, a delivery
+// engine whose archive writers write into the data directory, and that
+// directory.
+type archiveEnv struct {
+	eng     *delivery.Engine
+	mainDB  *database.Database
+	dataDir string
+}
+
+func setupArchiveTest(t *testing.T) *archiveEnv {
+	t.Helper()
+
+	dataDir := t.TempDir()
+
+	mainDB, err := database.Open(dataDir, slog.New(slog.DiscardHandler))
+	require.NoError(t, err)
+
+	t.Cleanup(func() { _ = mainDB.Close() })
+
+	return &archiveEnv{
+		eng: delivery.NewTestEngineWithDB(
+			mainDB,
+			databasetest.NewWebhookDBManager(t, dataDir),
+			archiveTestLogger(),
+			&http.Client{Timeout: 5 * time.Second},
+			1,
+		),
+		mainDB:  mainDB,
+		dataDir: dataDir,
+	}
+}
+
 func archiveTestLogger() *slog.Logger {
 	return slog.New(slog.NewTextHandler(
 		os.Stderr,
@@ -27,8 +71,87 @@ func archiveTestLogger() *slog.Logger {
 	))
 }
 
+// archivePath returns where the engine keeps a database target's
+// archive file, for the names seedDatabaseTarget gave it.
+func (env *archiveEnv) archivePath(tgt *database.Target) string {
+	return filepath.Join(
+		env.dataDir,
+		archive.FileName(archiveTestWebhookName, tgt.Name, tgt.ID),
+	)
+}
+
+// seedDatabaseTarget creates a webhook with one database target,
+// which keeps its archive forever in one file, and returns the
+// target.
+func (env *archiveEnv) seedDatabaseTarget(
+	t *testing.T,
+) *database.Target {
+	t.Helper()
+
+	wh := &database.Webhook{
+		UserID: uuid.New().String(),
+		Name:   archiveTestWebhookName,
+	}
+	require.NoError(
+		t,
+		env.mainDB.DB().
+			Omit(clause.Associations).
+			Create(wh).Error,
+	)
+
+	tgt := &database.Target{
+		WebhookID:       wh.ID,
+		Name:            "Archive",
+		Type:            database.TargetTypeDatabase,
+		Active:          true,
+		ArchiveRotation: "none",
+		MaxAttempts:     1,
+	}
+	require.NoError(
+		t,
+		env.mainDB.DB().
+			Omit(clause.Associations).
+			Create(tgt).Error,
+	)
+
+	return tgt
+}
+
+// seedDatabaseTargetDelivery seeds a pending delivery of an event
+// to a database target and returns the in-memory delivery the
+// target handler is invoked with.
+func seedDatabaseTargetDelivery(
+	t *testing.T,
+	webhookDB *gorm.DB,
+	event database.Event,
+	tgt *database.Target,
+) *database.Delivery {
+	t.Helper()
+
+	dlv := seedDelivery(
+		t, webhookDB, event.ID, tgt.ID,
+		database.DeliveryStatusPending,
+	)
+
+	d := &database.Delivery{
+		EventID:  event.ID,
+		TargetID: tgt.ID,
+		Status:   database.DeliveryStatusPending,
+		Event:    event,
+		Target: database.Target{
+			Name:            tgt.Name,
+			Type:            database.TargetTypeDatabase,
+			ArchiveExpiry:   tgt.ArchiveExpiry,
+			ArchiveRotation: tgt.ArchiveRotation,
+		},
+	}
+	d.ID = dlv.ID
+
+	return d
+}
+
 // openArchiveDBForRead opens an archive file read-only so a
-// test can inspect the rows the writer persisted.
+// test can inspect the rows the database target archived.
 func openArchiveDBForRead(
 	t *testing.T, path string,
 ) *gorm.DB {
@@ -43,56 +166,70 @@ func openArchiveDBForRead(
 	t.Cleanup(func() { _ = sqlDB.Close() })
 
 	gdb, err := gorm.Open(
-		sqlite.Dialector{Conn: sqlDB}, &gorm.Config{},
+		sqlite.Dialector{Conn: sqlDB},
+		&gorm.Config{Logger: gormlog.New(slog.New(slog.DiscardHandler))},
 	)
 	require.NoError(t, err)
 
 	return gdb
 }
 
-// archiveFileSuffixes returns the archive file itself and the
-// SQLite sidecars that accompany an open database. A test that
-// asserts no archive was created has to check all of them.
-func archiveFileSuffixes() []string {
-	return []string{"", "-wal", "-shm"}
+// countArchivedRows counts the rows in an archive file without
+// asserting anything, so it is safe to poll from an
+// assert.Eventually condition (which runs off the test
+// goroutine, where testify assertions must not be used).
+func countArchivedRows(path string) (int64, error) {
+	sqlDB, err := sql.Open(
+		"sqlite", fmt.Sprintf("file:%s?mode=ro", path),
+	)
+	if err != nil {
+		return 0, err
+	}
+
+	defer func() { _ = sqlDB.Close() }()
+
+	gdb, err := gorm.Open(
+		sqlite.Dialector{Conn: sqlDB},
+		&gorm.Config{Logger: gormlog.New(slog.New(slog.DiscardHandler))},
+	)
+	if err != nil {
+		return 0, err
+	}
+
+	var count int64
+
+	err = gdb.Table("archived_events").Count(&count).Error
+	if err != nil {
+		return 0, err
+	}
+
+	return count, nil
 }
 
-// removeArchiveFiles simulates an operator moving the archive
-// away by deleting the SQLite file and its sidecar files.
-func removeArchiveFiles(t *testing.T, path string) {
-	t.Helper()
-
-	for _, suffix := range []string{
-		"", "-wal", "-shm", "-journal",
-	} {
-		err := os.Remove(path + suffix)
-		if err != nil && !os.IsNotExist(err) {
-			t.Fatalf("removing %s%s: %v", path, suffix, err)
-		}
-	}
+// archivedRow is the columns of an archive row these tests read.
+type archivedRow struct {
+	EventID   string
+	WebhookID string
+	Method    string
+	RawQuery  string
+	Body      string
 }
 
 // TestDeliverDatabase_ArchivesEvent verifies that delivering to
 // a database target marks the delivery delivered and archives
-// the full event into a separate per-webhook archive file.
+// the full event into the target's own archive file.
 func TestDeliverDatabase_ArchivesEvent(t *testing.T) {
 	t.Parallel()
 
-	dataDir := t.TempDir()
-	dbMgr := database.NewTestWebhookDBManager(dataDir)
-
-	e := delivery.NewTestEngineWithDB(
-		nil, dbMgr,
-		archiveTestLogger(),
-		&http.Client{Timeout: 5 * time.Second},
-		1,
-	)
+	env := setupArchiveTest(t)
+	tgt := env.seedDatabaseTarget(t)
 
 	webhookDB := testWebhookDB(t)
 	event := seedEvent(t, webhookDB, `{"archived":true}`)
-	d := seedDatabaseTargetDelivery(t, webhookDB, event, "")
+	event.RawQuery = eventQuery
+	d := seedDatabaseTargetDelivery(t, webhookDB, event, tgt)
 
-	e.ExportDeliverDatabase(webhookDB, d)
+	env.eng.ExportDeliverDatabase(webhookDB, d)
 
 	var updated database.Delivery
 
@@ -105,247 +242,42 @@ func TestDeliverDatabase_ArchivesEvent(t *testing.T) {
 	)
 
 	archivePath := filepath.Join(
-		dataDir,
-		fmt.Sprintf("archive-%s.db", event.WebhookID),
+		env.dataDir, "archive-sweep-test-archive-"+tgt.ID+".db",
 	)
 	assert.FileExists(t, archivePath)
 
 	rdb := openArchiveDBForRead(t, archivePath)
 
-	var rows []delivery.ExportArchivedEvent
+	var rows []archivedRow
 
-	require.NoError(t, rdb.Find(&rows).Error)
+	require.NoError(t, rdb.Table("archived_events").Find(&rows).Error)
 	require.Len(t, rows, 1)
 	assert.Equal(t, event.ID, rows[0].EventID)
 	assert.Equal(t, event.WebhookID, rows[0].WebhookID)
 	assert.Equal(t, event.Method, rows[0].Method)
+	assert.Equal(t, eventQuery, rows[0].RawQuery)
 	assert.JSONEq(t, `{"archived":true}`, rows[0].Body)
 }
 
-func TestArchiveWriter_WritesRow(t *testing.T) {
-	t.Parallel()
-
-	path := filepath.Join(t.TempDir(), "archive-wh.db")
-	w := delivery.NewExportArchiveWriter(
-		path, archiveTestLogger(), 0,
-	)
-
-	row := delivery.ExportArchivedEvent{
-		EventID:      "ev-1",
-		WebhookID:    "wh-1",
-		EntrypointID: "ep-1",
-		Method:       "POST",
-		Headers:      `{"X":"Y"}`,
-		Body:         `{"hello":"world"}`,
-		ContentType:  "application/json",
-	}
-
-	require.NoError(t, w.Write(row, 0))
-	assert.FileExists(t, path)
-
-	var got []delivery.ExportArchivedEvent
-
-	require.NoError(t, w.DB().Find(&got).Error)
-	require.Len(t, got, 1)
-	assert.Equal(t, "ev-1", got[0].EventID)
-	assert.Equal(t, "wh-1", got[0].WebhookID)
-	assert.Equal(t, "ep-1", got[0].EntrypointID)
-	assert.Equal(t, row.Method, got[0].Method)
-	assert.Equal(t, row.ContentType, got[0].ContentType)
-	assert.JSONEq(t, `{"hello":"world"}`, got[0].Body)
-	assert.False(t, got[0].ArchivedAt.IsZero())
-}
-
-func TestArchiveWriter_RecreatesAfterRemoval(
-	t *testing.T,
-) {
-	t.Parallel()
-
-	path := filepath.Join(t.TempDir(), "archive-wh.db")
-	w := delivery.NewExportArchiveWriter(
-		path, archiveTestLogger(), 0,
-	)
-
-	require.NoError(t, w.Write(
-		delivery.ExportArchivedEvent{EventID: "a"}, 0,
-	))
-	assert.FileExists(t, path)
-
-	// The operator moves the archive away while the handle is
-	// still open.
-	removeArchiveFiles(t, path)
-	require.NoFileExists(t, path)
-
-	// The next write recreates the file with a fresh schema and
-	// only the new row.
-	require.NoError(t, w.Write(
-		delivery.ExportArchivedEvent{EventID: "b"}, 0,
-	))
-	assert.FileExists(t, path)
-
-	var got []delivery.ExportArchivedEvent
-
-	require.NoError(t, w.DB().Find(&got).Error)
-	require.Len(t, got, 1)
-	assert.Equal(t, "b", got[0].EventID)
-}
-
-func TestArchiveWriter_ReopenDebounce(t *testing.T) {
-	t.Parallel()
-
-	// A generous debounce keeps the two rapid writes inside
-	// the window even on a heavily loaded test machine.
-	path := filepath.Join(t.TempDir(), "archive-wh.db")
-	w := delivery.NewExportArchiveWriter(
-		path, archiveTestLogger(), 2*time.Second,
-	)
-
-	require.NoError(t, w.Write(
-		delivery.ExportArchivedEvent{EventID: "a"}, 0,
-	))
-	require.NoError(t, w.Write(
-		delivery.ExportArchivedEvent{EventID: "b"}, 0,
-	))
-
-	// Two writes inside the debounce window trigger only the
-	// initial open — no extra close/reopen.
-	assert.Equal(t, 1, w.Reopens())
-
-	time.Sleep(2100 * time.Millisecond)
-
-	require.NoError(t, w.Write(
-		delivery.ExportArchivedEvent{EventID: "c"}, 0,
-	))
-
-	// A write after the window elapses closes and reopens once.
-	assert.Equal(t, 2, w.Reopens())
-}
-
-func TestArchiveWriter_ExpiryPrune(t *testing.T) {
-	t.Parallel()
-
-	path := filepath.Join(t.TempDir(), "archive-wh.db")
-	w := delivery.NewExportArchiveWriter(
-		path, archiveTestLogger(), 0,
-	)
-
-	require.NoError(t, w.Open(0))
-
-	old := delivery.ExportArchivedEvent{
-		EventID:    "old",
-		ArchivedAt: time.Now().Add(-2 * time.Hour),
-	}
-	fresh := delivery.ExportArchivedEvent{
-		EventID:    "fresh",
-		ArchivedAt: time.Now(),
-	}
-
-	require.NoError(t, w.DB().Create(&old).Error)
-	require.NoError(t, w.DB().Create(&fresh).Error)
-
-	// Reopening with a one-hour expiry prunes the old row.
-	require.NoError(t, w.Reopen(time.Hour))
-
-	var got []delivery.ExportArchivedEvent
-
-	require.NoError(t, w.DB().Find(&got).Error)
-	require.Len(t, got, 1)
-	assert.Equal(t, "fresh", got[0].EventID)
-}
-
-func TestParseArchiveExpiry(t *testing.T) {
-	t.Parallel()
-
-	cases := []struct {
-		name    string
-		in      string
-		want    time.Duration
-		wantErr bool
-	}{
-		{"empty config", "", 0, false},
-		{"explicit never", `{"expiry":"never"}`, 0, false},
-		{"empty expiry", `{"expiry":""}`, 0, false},
-		{"duration", `{"expiry":"1h"}`, time.Hour, false},
-		{"unparseable", `{"expiry":"nonsense"}`, 0, true},
-		{"zero duration", `{"expiry":"0s"}`, 0, true},
-		{"negative duration", `{"expiry":"-5h"}`, 0, true},
-	}
-
-	for _, tc := range cases {
-		t.Run(tc.name, func(t *testing.T) {
-			t.Parallel()
-
-			got, err := delivery.ExportParseArchiveExpiry(tc.in)
-			if tc.wantErr {
-				require.Error(t, err)
-
-				return
-			}
-
-			require.NoError(t, err)
-			assert.Equal(t, tc.want, got)
-		})
-	}
-}
-
-// seedDatabaseTargetDelivery seeds a pending delivery for a
-// database target with the given config JSON and returns the
-// in-memory delivery the target handler is invoked with.
-func seedDatabaseTargetDelivery(
-	t *testing.T,
-	webhookDB *gorm.DB,
-	event database.Event,
-	config string,
-) *database.Delivery {
-	t.Helper()
-
-	dlv := seedDelivery(
-		t, webhookDB, event.ID, uuid.New().String(),
-		database.DeliveryStatusPending,
-	)
-
-	d := &database.Delivery{
-		EventID:  event.ID,
-		TargetID: dlv.TargetID,
-		Status:   database.DeliveryStatusPending,
-		Event:    event,
-		Target: database.Target{
-			Name:   "test-db",
-			Type:   database.TargetTypeDatabase,
-			Config: config,
-		},
-	}
-	d.ID = dlv.ID
-
-	return d
-}
-
 // TestDeliverDatabase_ArchiveFailureFailsDelivery verifies that
-// an archive error (here: an unparseable expiry in the target
-// config) fails the delivery loudly: the attempt is recorded as
-// failed with the error and the delivery is marked failed, not
+// an archive error (here: an event with no webhook id to record)
+// fails the delivery loudly: the attempt is recorded as failed
+// with the error and the delivery is marked failed, not
 // delivered.
 func TestDeliverDatabase_ArchiveFailureFailsDelivery(
 	t *testing.T,
 ) {
 	t.Parallel()
 
-	dataDir := t.TempDir()
-
-	e := delivery.NewTestEngineWithDB(
-		nil, database.NewTestWebhookDBManager(dataDir),
-		archiveTestLogger(),
-		&http.Client{Timeout: 5 * time.Second},
-		1,
-	)
+	env := setupArchiveTest(t)
+	tgt := env.seedDatabaseTarget(t)
 
 	webhookDB := testWebhookDB(t)
 	event := seedEvent(t, webhookDB, `{"archived":false}`)
-	d := seedDatabaseTargetDelivery(
-		t, webhookDB, event, `{"expiry":"nonsense"}`,
-	)
+	d := seedDatabaseTargetDelivery(t, webhookDB, event, tgt)
+	d.Event.WebhookID = ""
 
-	e.ExportDeliverDatabase(webhookDB, d)
+	env.eng.ExportDeliverDatabase(webhookDB, d)
 
 	var updated database.Delivery
 
@@ -368,35 +300,96 @@ func TestDeliverDatabase_ArchiveFailureFailsDelivery(
 		"the attempt must be recorded as failed",
 	)
 	assert.Contains(t,
-		results[0].Error, "nonsense",
+		results[0].Error, "without a webhook id",
 		"the archive error must be recorded on the attempt",
 	)
 
 	assert.NoFileExists(t,
-		filepath.Join(
-			dataDir,
-			fmt.Sprintf("archive-%s.db", event.WebhookID),
-		),
-		"no archive file should exist for a failed config",
+		env.archivePath(tgt),
+		"no archive file should exist for a failed write",
 	)
 }
 
-func TestValidateArchiveExpiry(t *testing.T) {
+// seedArchivedRow creates the archive file at path holding one row, for
+// eventID, archived at archivedAt.
+func seedArchivedRow(
+	t *testing.T, path, eventID string, archivedAt time.Time,
+) {
+	t.Helper()
+
+	sqlDB, err := sql.Open(
+		"sqlite", fmt.Sprintf("file:%s?mode=rwc", path),
+	)
+	require.NoError(t, err)
+
+	defer func() { _ = sqlDB.Close() }()
+
+	gdb, err := gorm.Open(
+		sqlite.Dialector{Conn: sqlDB},
+		&gorm.Config{Logger: gormlog.New(slog.New(slog.DiscardHandler))},
+	)
+	require.NoError(t, err)
+
+	require.NoError(t, migrations.Apply(gdb, migrations.Archive))
+	require.NoError(t, gdb.Exec(
+		"INSERT INTO archived_events (event_id, archived_at) VALUES (?, ?)",
+		eventID, archivedAt,
+	).Error)
+}
+
+// TestDeliverDatabase_TaskArchiveSettings proves a task's ArchiveExpiry
+// and ArchiveRotation reach the archive through the engine. The
+// target's row has neither, so only the task can bring them: with daily
+// rotation the event goes to the file for its day, and opening that
+// file with a one-hour expiry prunes the row it already held, archived
+// two hours ago.
+func TestDeliverDatabase_TaskArchiveSettings(t *testing.T) {
 	t.Parallel()
 
-	valid := []string{"", "never", "1h", "720h", "30m"}
-	for _, in := range valid {
-		require.NoError(t,
-			delivery.ValidateArchiveExpiry(in),
-			"expiry %q should be accepted", in,
-		)
-	}
+	s := newISetup(t)
 
-	invalid := []string{"nonsense", "7d", "-5h", "0s", "0"}
-	for _, in := range invalid {
-		require.Error(t,
-			delivery.ValidateArchiveExpiry(in),
-			"expiry %q should be rejected", in,
-		)
+	webhook := database.Webhook{UserID: uuid.NewString(), Name: "settings"}
+	webhook.ID = s.WebhookID
+	require.NoError(t, s.MainDB.Create(&webhook).Error)
+
+	target := database.Target{
+		WebhookID:   s.WebhookID,
+		Name:        "archive",
+		Type:        database.TargetTypeDatabase,
+		Active:      true,
+		MaxAttempts: 1,
 	}
+	require.NoError(t, s.MainDB.Create(&target).Error)
+
+	event := iSeedEvent(t, s.WebhookDB, s.WebhookID, `{"archived":true}`)
+	d := iSeedDelivery(
+		t, s.WebhookDB, event.ID, target.ID,
+		database.DeliveryStatusPending,
+	)
+
+	task := iTask(
+		d, event, s.WebhookID, target.ID, target.Name, "", 1, 1,
+		&event.Body,
+	)
+	task.TargetType = database.TargetTypeDatabase
+	task.ArchiveExpiry = time.Hour
+	task.ArchiveRotation = "daily"
+
+	daily := target
+	daily.ArchiveRotation = task.ArchiveRotation
+	dailyFile := archive.PathAt(s.DBMgr, &webhook, &daily, event.CreatedAt)
+	seedArchivedRow(t, dailyFile, "expired", time.Now().Add(-2*time.Hour))
+
+	s.Engine.ExportProcessNewTask(context.TODO(), &task)
+
+	iAssertStatus(t, s.WebhookDB, d.ID, database.DeliveryStatusDelivered)
+
+	var rows []archivedRow
+
+	require.NoError(t, openArchiveDBForRead(t, dailyFile).
+		Table("archived_events").Find(&rows).Error)
+	require.Len(t, rows, 1)
+	assert.Equal(t, event.ID, rows[0].EventID,
+		"the event goes to its day's file and the expired row is pruned",
+	)
 }

internal/delivery/target_headers.go

@@ -17,7 +17,7 @@ import (
 const MaxTargetTimeoutSeconds = 300
 
 // Errors returned when a target's header or timeout form input
-// cannot be turned into a configuration.
+// cannot be turned into the target's setting.
 //
 // None of these ever quotes a header VALUE. A target header value
 // is routinely an authorization token, and these messages are shown
@@ -48,8 +48,8 @@ var (
 )
 
 // isReservedTargetHeader reports whether name (canonicalised) is a
-// header a target configuration may not set, because the delivery
-// path or net/http itself writes it regardless.
+// header a target may not set, because the delivery path or
+// net/http itself writes it regardless.
 //
 // These are rejected rather than accepted-and-ignored. Storing a
 // header that provably never reaches the wire tells the operator
@@ -77,13 +77,11 @@ func isReservedTargetHeader(name string) bool {
 
 // ParseTargetHeaders turns the target form's headers field — one
 // "Name: value" pair per line, blank lines ignored — into the map
-// stored in HTTPTargetConfig.Headers. Names are canonicalised, so a
+// stored in database.Target.Headers. Names are canonicalised, so a
 // name repeated in a different case is still a duplicate rather than
 // one pair silently overwriting the other.
 //
-// An input with no pairs yields an empty map, which omitempty drops
-// from the stored config: a target configured with no headers keeps
-// the same config JSON it had before this field existed.
+// An input with no pairs yields an empty map.
 func ParseTargetHeaders(raw string) (map[string]string, error) {
 	headers := make(map[string]string)
 
@@ -223,8 +221,8 @@ func FormatTargetHeaders(headers map[string]string) string {
 
 // ParseTargetTimeout interprets the target form's timeout field as
 // a whole number of seconds. An empty field means "unset" and yields
-// 0, which omitempty drops from the stored config and which the
-// delivery path reads as "use the shared client's timeout".
+// 0, which the delivery path reads as "use the shared client's
+// timeout".
 //
 // Anything else that is not a whole number in range is an error, not
 // a silently substituted default: a target whose timeout was typed

internal/delivery/target_headers_test.go

@@ -1,23 +1,21 @@
 package delivery_test
 
 import (
-	"encoding/json"
 	"strconv"
 	"testing"
 
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
-	"sneak.berlin/go/webhooker/internal/database"
 	"sneak.berlin/go/webhooker/internal/delivery"
 )
 
-// Literals these tests repeat, named so that the header names and the
-// keep-forever archive config each have one definition.
+// Literals these tests repeat, named so that each header name has one
+// definition.
 const (
 	headerAuthorization = "Authorization"
 	headerContentType   = "Content-Type"
+	headerUserAgent     = "User-Agent"
 	bearerValue         = "Bearer abc"
-	archiveConfigNever  = "{\"expiry\":\"never\"}"
 )
 
 func TestParseTargetHeaders_AcceptsPairs(t *testing.T) {
@@ -41,23 +39,13 @@ func TestParseTargetHeaders_AcceptsPairs(t *testing.T) {
 	)
 }
 
-// A configuration with no headers must stay indistinguishable from
-// one written before the field existed, so omitempty drops the key.
+// An input of blank lines is no headers, not an error.
 func TestParseTargetHeaders_EmptyInputYieldsNoHeaders(t *testing.T) {
 	t.Parallel()
 
 	got, err := delivery.ParseTargetHeaders("\n  \n")
 	require.NoError(t, err)
 	assert.Empty(t, got)
-
-	encoded, err := json.Marshal(delivery.HTTPTargetConfig{
-		URL:     "https://example.com/h",
-		Headers: got,
-	})
-	require.NoError(t, err)
-	assert.JSONEq(
-		t, `{"url":"https://example.com/h"}`, string(encoded),
-	)
 }
 
 func TestParseTargetHeaders_Rejects(t *testing.T) {
@@ -181,81 +169,6 @@ func TestFormatTargetTimeout(t *testing.T) {
 	assert.Empty(t, delivery.FormatTargetTimeout(-1))
 }
 
-func TestNewTargetConfigForm(t *testing.T) {
-	t.Parallel()
-
-	form, err := delivery.NewTargetConfigForm(&database.Target{
-		Type: database.TargetTypeHTTP,
-		Config: `{"url":"https://example.com/h",` +
-			`"headers":{"Authorization":"Bearer abc"},` +
-			`"timeout":9}`,
-	})
-	require.NoError(t, err)
-	assert.Equal(t, "https://example.com/h", form.URL)
-	assert.Equal(t, "Authorization: Bearer abc\n", form.Headers)
-	assert.Equal(t, "9", form.Timeout)
-
-	form, err = delivery.NewTargetConfigForm(&database.Target{
-		Type:   database.TargetTypeSlack,
-		Config: `{"webhookUrl":"https://hooks.example/s"}`,
-	})
-	require.NoError(t, err)
-	assert.Equal(t, "https://hooks.example/s", form.URL)
-
-	form, err = delivery.NewTargetConfigForm(&database.Target{
-		Type:   database.TargetTypeDatabase,
-		Config: `{"expiry":"720h"}`,
-	})
-	require.NoError(t, err)
-	assert.Equal(t, "720h", form.Expiry)
-
-	form, err = delivery.NewTargetConfigForm(&database.Target{
-		Type: database.TargetTypeLog,
-	})
-	require.NoError(t, err)
-	assert.Empty(t, form.URL)
-}
-
-// A keep-forever archive target must pre-fill as an empty field, so
-// saving the form back unchanged stores the same empty config.
-func TestNewTargetConfigForm_DatabaseNeverIsBlank(t *testing.T) {
-	t.Parallel()
-
-	for _, cfg := range []string{"", `{}`, archiveConfigNever} {
-		form, err := delivery.NewTargetConfigForm(
-			&database.Target{
-				Type:   database.TargetTypeDatabase,
-				Config: cfg,
-			},
-		)
-		require.NoError(t, err, cfg)
-		assert.Empty(t, form.Expiry, cfg)
-	}
-}
-
-// An unreadable stored config is an error rather than a blank form
-// that looks like a target with no settings, so the caller can tell
-// the operator that saving replaces the stored value.
-func TestNewTargetConfigForm_UnreadableConfigErrors(t *testing.T) {
-	t.Parallel()
-
-	cases := []*database.Target{
-		{Type: database.TargetTypeHTTP, Config: "not json"},
-		{Type: database.TargetTypeHTTP, Config: `{}`},
-		{Type: database.TargetTypeSlack, Config: ""},
-		{
-			Type:   database.TargetTypeDatabase,
-			Config: `{"expiry":"soon"}`,
-		},
-		{Type: database.TargetType("nope")},
-	}
-
-	for _, target := range cases {
-		_, err := delivery.NewTargetConfigForm(target)
-		require.Error(t, err, target.Type)
-	}
-}
-
 // The ceiling exists so one misconfigured target cannot hold a
 // delivery worker indefinitely, and it is inclusive.
 func TestParseTargetTimeout_CeilingIsInclusive(t *testing.T) {

internal/delivery/target_http.go

@@ -4,10 +4,10 @@ import (
 	"bytes"
 	"context"
 	"encoding/json"
-	"errors"
 	"fmt"
 	"io"
 	"net/http"
+	"net/url"
 	"sort"
 	"sync"
 	"time"
@@ -16,24 +16,6 @@ import (
 	"sneak.berlin/go/webhooker/internal/database"
 )
 
-// Sentinel errors returned by the config parsers.
-var (
-	errEmptyTargetConfig = errors.New(
-		"empty target config",
-	)
-	errMissingTargetURL = errors.New(
-		"target URL is required",
-	)
-)
-
-// HTTPTargetConfig holds configuration for http target
-// types.
-type HTTPTargetConfig struct {
-	URL     string            `json:"url"`
-	Headers map[string]string `json:"headers,omitempty"`
-	Timeout int               `json:"timeout,omitempty"`
-}
-
 // httpCore holds the retry, backoff, and circuit-breaker
 // machinery shared by the HTTP and Slack targets. Each of
 // those targets owns its own httpCore instance (and thus its
@@ -47,34 +29,72 @@ type httpCore struct {
 }
 
 // deliver runs one delivery attempt through the retry core.
-// A maxRetries of 0 is fire-and-forget: a single attempt is
-// recorded and no circuit breaker is consulted. A positive
-// maxRetries gates the attempt on the circuit breaker and
-// schedules a backed-off retry on failure.
+// A maxAttempts of 1 is a single attempt, recorded without
+// consulting a circuit breaker. A higher maxAttempts gates the
+// attempt on the circuit breaker and schedules a backed-off retry
+// on failure, until maxAttempts attempts have been made.
+//
+// ctx is the context attempt sends its request with. Stopping the
+// engine cancels it; see interruptedByStop.
 func (c *httpCore) deliver(
+	ctx context.Context,
 	webhookDB *gorm.DB,
 	d *database.Delivery,
 	task *Task,
 	sched Scheduler,
-	maxRetries int,
+	maxAttempts int,
 	attempt func() attemptResult,
 ) {
-	if maxRetries == 0 {
-		c.fireAndForget(webhookDB, d, attempt())
+	if maxAttempts == 1 {
+		c.fireAndForget(ctx, webhookDB, d, attempt())
 
 		return
 	}
 
 	c.withRetry(
-		webhookDB, d, task, sched, maxRetries, attempt,
+		ctx, webhookDB, d, task, sched, maxAttempts, attempt,
 	)
 }
 
+// interruptedByStop reports whether an attempt failed because the
+// engine is stopping, which cancels the context its request is made
+// with. Such an attempt is not recorded: no DeliveryResult, no circuit
+// breaker outcome, no status change, no count in the attempt metrics.
+// The delivery stays pending or retrying, and the recovery routine
+// sends it again on the next start.
+//
+// A target's own timeout leaves that context alone, so its attempt is
+// still recorded as the failure it is.
+func (c *httpCore) interruptedByStop(
+	ctx context.Context,
+	d *database.Delivery,
+	res attemptResult,
+) bool {
+	if res.success || ctx.Err() == nil {
+		return false
+	}
+
+	c.eng.log.Warn(
+		"delivery attempt interrupted by shutdown; not recorded, "+
+			"it is sent again on the next start",
+		"delivery_id", d.ID,
+		"event_id", d.EventID,
+		"target_id", d.TargetID,
+	)
+
+	return true
+}
+
 func (c *httpCore) fireAndForget(
+	ctx context.Context,
 	webhookDB *gorm.DB,
 	d *database.Delivery,
 	res attemptResult,
 ) {
+	if c.interruptedByStop(ctx, d, res) {
+		return
+	}
+
 	c.eng.observeAttempt(d.Target.Type, res.elapsed())
 
 	err := c.eng.recordResult(
@@ -104,11 +124,12 @@ func (c *httpCore) fireAndForget(
 }
 
 func (c *httpCore) withRetry(
+	ctx context.Context,
 	webhookDB *gorm.DB,
 	d *database.Delivery,
 	task *Task,
 	sched Scheduler,
-	maxRetries int,
+	maxAttempts int,
 	attempt func() attemptResult,
 ) {
 	cb := c.getCircuitBreaker(task.TargetID)
@@ -125,6 +146,10 @@ func (c *httpCore) withRetry(
 
 	res := attempt()
 
+	if c.interruptedByStop(ctx, d, res) {
+		return
+	}
+
 	c.eng.observeAttempt(d.Target.Type, res.elapsed())
 
 	err := c.eng.recordResult(
@@ -156,7 +181,7 @@ func (c *httpCore) withRetry(
 	cb.RecordFailure()
 
 	c.handleRetry(
-		webhookDB, d, task, sched, maxRetries, attemptNum,
+		webhookDB, d, task, sched, maxAttempts, attemptNum,
 	)
 }
 
@@ -217,10 +242,10 @@ func (c *httpCore) handleRetry(
 	d *database.Delivery,
 	task *Task,
 	sched Scheduler,
-	maxRetries int,
+	maxAttempts int,
 	attemptNum int,
 ) {
-	if attemptNum >= maxRetries {
+	if attemptNum >= maxAttempts {
 		c.eng.settleStatus(
 			webhookDB, d, d.Target.Type,
 			database.DeliveryStatusFailed,
@@ -234,7 +259,7 @@ func (c *httpCore) handleRetry(
 		database.DeliveryStatusRetrying,
 	)
 
-	backoff := calcBackoff(attemptNum)
+	backoff := Backoff(attemptNum)
 
 	retryTask := *task
 	retryTask.AttemptNum = attemptNum + 1
@@ -285,7 +310,8 @@ func (c *httpCore) publishCircuitState(
 
 // remainingBackoff returns how long remains of the backoff
 // window for the last attempt of a recovered retrying
-// delivery. It implements rescheduler.
+// delivery: zero once it has passed, or when the last attempt
+// cannot be read. It implements rescheduler.
 func (c *httpCore) remainingBackoff(
 	webhookDB *gorm.DB,
 	deliveryID string,
@@ -301,37 +327,16 @@ func (c *httpCore) remainingBackoff(
 		return 0
 	}
 
-	backoff := calcBackoff(attemptNum)
+	backoff := Backoff(attemptNum)
 	elapsed := time.Since(lastResult.CreatedAt)
 	remaining := backoff - elapsed
 
 	return max(remaining, 0)
 }
 
-// backoffElapsed reports whether the backoff window for the
-// last attempt of a retrying delivery has passed. It
-// implements rescheduler.
-func (c *httpCore) backoffElapsed(
-	webhookDB *gorm.DB,
-	deliveryID string,
-	attemptNum int,
-) bool {
-	var lastResult database.DeliveryResult
-
-	err := webhookDB.
-		Where("delivery_id = ?", deliveryID).
-		Order("created_at DESC").
-		First(&lastResult).Error
-	if err != nil {
-		return true
-	}
-
-	backoff := calcBackoff(attemptNum)
-
-	return time.Since(lastResult.CreatedAt) >= backoff
-}
-
-func calcBackoff(attemptNum int) time.Duration {
+// Backoff is how long an http or slack target with retries waits after
+// a delivery's failed attempt attemptNum before trying it again.
+func Backoff(attemptNum int) time.Duration {
 	shift := max(attemptNum-1, 0)
 	shift = min(shift, maxBackoffShift)
 
@@ -356,39 +361,13 @@ func (t *httpTarget) Deliver(
 	task *Task,
 	sched Scheduler,
 ) {
-	cfg, err := parseHTTPConfig(d.Target.Config)
-	if err != nil {
-		t.eng.log.Error(
-			"invalid HTTP target config",
-			"target_id", d.TargetID,
-			"error", err,
-		)
-
-		recErr := t.eng.recordResult(
-			webhookDB, d, task.AttemptNum,
-			false, 0, "", err.Error(), 0,
-		)
-		if recErr != nil {
-			t.eng.bookkeepingFailed(d, recErr)
-
-			return
-		}
-
-		t.eng.settleStatus(
-			webhookDB, d, d.Target.Type,
-			database.DeliveryStatusFailed,
-		)
-
-		return
-	}
-
 	attempt := func() attemptResult {
-		return t.attempt(ctx, cfg, &d.Event)
+		return t.attempt(ctx, &d.Target, &d.Event)
 	}
 
 	t.deliver(
-		webhookDB, d, task, sched,
-		d.Target.MaxRetries, attempt,
+		ctx, webhookDB, d, task, sched,
+		d.Target.MaxAttempts, attempt,
 	)
 }
 
@@ -398,11 +377,11 @@ func (t *httpTarget) Deliver(
 // string; only a transport-level error does.
 func (t *httpTarget) attempt(
 	ctx context.Context,
-	cfg *HTTPTargetConfig,
+	target *database.Target,
 	event *database.Event,
 ) attemptResult {
 	statusCode, respBody, duration, reqErr :=
-		t.doHTTPRequest(ctx, cfg, event)
+		t.doHTTPRequest(ctx, target, event)
 
 	success := reqErr == nil &&
 		statusCode >= httpSuccessMin &&
@@ -424,7 +403,7 @@ func (t *httpTarget) attempt(
 
 func (t *httpTarget) doHTTPRequest(
 	ctx context.Context,
-	cfg *HTTPTargetConfig,
+	target *database.Target,
 	event *database.Event,
 ) (int, string, int64, error) {
 	start := time.Now()
@@ -432,7 +411,7 @@ func (t *httpTarget) doHTTPRequest(
 	req, reqErr := http.NewRequestWithContext(
 		ctx,
 		http.MethodPost,
-		cfg.URL,
+		target.URL,
 		bytes.NewReader([]byte(event.Body)),
 	)
 	if reqErr != nil {
@@ -442,9 +421,15 @@ func (t *httpTarget) doHTTPRequest(
 		)
 	}
 
-	originScoped := applyRequestHeaders(req, event, cfg)
+	if target.ForwardQuery {
+		appendQuery(req.URL, event.RawQuery)
+	}
 
-	client := t.clientForRequest(cfg, originScoped)
+	originScoped := applyRequestHeaders(
+		req, event, target.Headers, t.eng.userAgent(),
+	)
+
+	client := t.clientForRequest(target.TimeoutSeconds, originScoped)
 
 	resp, doErr := executeHTTPRequest(client, req)
 
@@ -470,18 +455,31 @@ func (t *httpTarget) doHTTPRequest(
 	return resp.StatusCode, string(body), dur, nil
 }
 
+// appendQuery adds an event's query string to a delivery's URL, joined
+// with "&" to any query string the target URL already has.
+func appendQuery(u *url.URL, rawQuery string) {
+	switch {
+	case rawQuery == "":
+		return
+	case u.RawQuery == "":
+		u.RawQuery = rawQuery
+	default:
+		u.RawQuery += "&" + rawQuery
+	}
+}
+
 // clientForRequest returns the client for one delivery attempt.
-// originScoped is the header set applyRequestHeaders built for that
-// attempt; a request with neither a per-target timeout nor an
-// origin-scoped header gets the shared client, because there is
-// then nothing for the redirect policy to strip and net/http's
-// default policy already withholds Authorization and Cookie across
-// hosts.
+// timeoutSeconds is the target's TimeoutSeconds, and originScoped is
+// the header set applyRequestHeaders built for that attempt; a
+// request with neither a per-target timeout nor an origin-scoped
+// header gets the shared client, because there is then nothing for
+// the redirect policy to strip and net/http's default policy already
+// withholds Authorization and Cookie across hosts.
 func (t *httpTarget) clientForRequest(
-	cfg *HTTPTargetConfig,
+	timeoutSeconds int,
 	originScoped []string,
 ) *http.Client {
-	if cfg.Timeout <= 0 && len(originScoped) == 0 {
+	if timeoutSeconds <= 0 && len(originScoped) == 0 {
 		return t.client
 	}
 
@@ -494,9 +492,9 @@ func (t *httpTarget) clientForRequest(
 		Transport: t.client.Transport,
 	}
 
-	if cfg.Timeout > 0 {
+	if timeoutSeconds > 0 {
 		client.Timeout = time.Duration(
-			cfg.Timeout,
+			timeoutSeconds,
 		) * time.Second
 	}
 
@@ -507,31 +505,6 @@ func (t *httpTarget) clientForRequest(
 	return client
 }
 
-func parseHTTPConfig(
-	configJSON string,
-) (*HTTPTargetConfig, error) {
-	if configJSON == "" {
-		return nil, errEmptyTargetConfig
-	}
-
-	var cfg HTTPTargetConfig
-
-	err := json.Unmarshal(
-		[]byte(configJSON), &cfg,
-	)
-	if err != nil {
-		return nil, fmt.Errorf(
-			"parsing config JSON: %w", err,
-		)
-	}
-
-	if cfg.URL == "" {
-		return nil, errMissingTargetURL
-	}
-
-	return &cfg, nil
-}
-
 // isForwardableHeader returns true if the header should
 // be forwarded to targets.
 func isForwardableHeader(name string) bool {
@@ -562,10 +535,14 @@ func isForwardableHeader(name string) bool {
 // Content-Type goes out once: a Content-Type configured on the target
 // wins, otherwise the event's ContentType, otherwise none. The inbound
 // Content-Type in the event's headers is never forwarded.
+//
+// configured is the target's Headers. userAgent is set last, over
+// any configured or inbound User-Agent.
 func applyRequestHeaders(
 	req *http.Request,
 	event *database.Event,
-	cfg *HTTPTargetConfig,
+	configured map[string]string,
+	userAgent string,
 ) []string {
 	if event.ContentType != "" {
 		req.Header.Set(
@@ -575,12 +552,12 @@ func applyRequestHeaders(
 
 	originScoped := forwardEventHeaders(req, event)
 
-	for k, v := range cfg.Headers {
+	for k, v := range configured {
 		req.Header.Set(k, v)
 		originScoped[http.CanonicalHeaderKey(k)] = struct{}{}
 	}
 
-	req.Header.Set("User-Agent", "webhooker/1.0")
+	req.Header.Set("User-Agent", userAgent)
 
 	// A Content-Type configured on the target describes the body
 	// being sent rather than the sender. A 307/308 preserves the
@@ -640,7 +617,7 @@ func forwardEventHeaders(
 }
 
 // executeHTTPRequest sends an HTTP request using the provided
-// client. URLs are validated by the config parsers and the
+// client. URLs are validated by the target forms and the
 // SSRF-safe transport before reaching here.
 //
 // Transport failures are masked here, at the single point

internal/delivery/target_http_query_test.go

@@ -0,0 +1,163 @@
+package delivery_test
+
+import (
+	"context"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+
+	"github.com/google/uuid"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"sneak.berlin/go/webhooker/internal/database"
+	"sneak.berlin/go/webhooker/internal/delivery"
+)
+
+// eventQuery is the query string the events in these tests arrived
+// with.
+const eventQuery = "a=1&b=2"
+
+// deliverWithQuery sends one event that arrived with eventQuery to an
+// HTTP target at targetURL, with its ForwardQuery setting as given,
+// through the path a received event's delivery takes, and returns the
+// attempt it recorded.
+func deliverWithQuery(
+	t *testing.T, targetURL string, forwardQuery bool,
+) database.DeliveryResult {
+	t.Helper()
+
+	s := newISetup(t)
+
+	event := iSeedEvent(t, s.WebhookDB, s.WebhookID, "{}")
+	d := iSeedDelivery(
+		t, s.WebhookDB, event.ID, uuid.NewString(),
+		database.DeliveryStatusPending,
+	)
+	task := iTask(
+		d, event, s.WebhookID, d.TargetID, "query", targetURL, 1, 1,
+		&event.Body,
+	)
+	task.ForwardQuery = forwardQuery
+	task.RawQuery = eventQuery
+
+	s.Engine.ExportProcessNewTask(context.TODO(), &task)
+
+	var result database.DeliveryResult
+
+	require.NoError(t, s.WebhookDB.Where(
+		"delivery_id = ?", d.ID,
+	).First(&result).Error)
+
+	return result
+}
+
+// TestDeliverHTTP_ForwardQuery proves the URL a delivery is sent to:
+// with the target's setting off, the target URL exactly as configured;
+// with it on, the event's query string appended, joined with "&" to a
+// query string the target URL already has.
+func TestDeliverHTTP_ForwardQuery(t *testing.T) {
+	t.Parallel()
+
+	// The target URL's path, without and with a query string of its
+	// own.
+	const (
+		plain     = "/in"
+		withQuery = "/in?key=k"
+	)
+
+	tests := map[string]struct {
+		path         string
+		forwardQuery bool
+		want         string
+	}{
+		"off": {
+			path: plain, want: plain,
+		},
+		"off, the target URL has a query string": {
+			path: withQuery, want: withQuery,
+		},
+		"on": {
+			path: plain, forwardQuery: true, want: plain + "?" + eventQuery,
+		},
+		"on, the target URL has a query string": {
+			path: withQuery, forwardQuery: true,
+			want: withQuery + "&" + eventQuery,
+		},
+	}
+
+	for name, tc := range tests {
+		t.Run(name, func(t *testing.T) {
+			t.Parallel()
+
+			received := make(chan string, 1)
+
+			ts := httptest.NewServer(http.HandlerFunc(
+				func(w http.ResponseWriter, r *http.Request) {
+					received <- r.RequestURI
+
+					w.WriteHeader(http.StatusOK)
+				},
+			))
+			t.Cleanup(ts.Close)
+
+			result := deliverWithQuery(
+				t, ts.URL+tc.path, tc.forwardQuery,
+			)
+
+			assert.True(t, result.Success)
+			require.Len(t, received, 1)
+			assert.Equal(t, tc.want, <-received)
+		})
+	}
+}
+
+// TestDeliverHTTP_ForwardedQueryKeepsTheTargetURLMasked proves the
+// credential in a target URL's own query string stays masked once the
+// event's query string is appended to it: in a response or error that
+// echoes the URL the target was sent, as the event log's Redactor shows
+// it, and in the error a failed connection stores.
+func TestDeliverHTTP_ForwardedQueryKeepsTheTargetURLMasked(t *testing.T) {
+	t.Parallel()
+
+	const secret = "s3cr3t"
+
+	received := make(chan string, 1)
+
+	ts := httptest.NewServer(http.HandlerFunc(
+		func(w http.ResponseWriter, r *http.Request) {
+			received <- r.RequestURI
+
+			w.WriteHeader(http.StatusBadRequest)
+		},
+	))
+	t.Cleanup(ts.Close)
+
+	target := &database.Target{
+		Type:         database.TargetTypeHTTP,
+		URL:          ts.URL + "/in?token=" + secret,
+		ForwardQuery: true,
+		MaxAttempts:  1,
+	}
+
+	deliverWithQuery(t, target.URL, target.ForwardQuery)
+	require.Len(t, received, 1)
+
+	sent := <-received
+	require.Equal(t, "/in?token="+secret+"&"+eventQuery, sent)
+
+	redactor := delivery.NewRedactor(target)
+
+	for _, echoed := range []string{sent, ts.URL + sent} {
+		shown := redactor.Redact("rejected " + echoed)
+		assert.NotContains(t, shown, secret, echoed)
+		assert.Contains(t, shown, delivery.RedactionMarker, echoed)
+	}
+
+	// Nothing listens on port 1.
+	failed := deliverWithQuery(
+		t, "http://127.0.0.1:1/in?token="+secret, true,
+	)
+	require.NotEmpty(t, failed.Error)
+	assert.NotContains(t, failed.Error, secret)
+	assert.NotContains(t, failed.Error, eventQuery)
+}