Deploy main eacf1e7 to prod

Replaces #559, which conflicted.

Model: opus-5-5

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)