Ketika sistem feed ingestion atau webhook syndication menerima konten dari upstream publisher, kesalahan umum dalam menyaring konten sintetis (AI-generated) tanpa provenance valid adalah mengembalikan HTTP 4xx atau 5xx. Upstream delivery broker menginterpretasikan respons non-2xx sebagai kegagalan transmisi. Broker menjadwalkan pengiriman ulang (retry) dengan exponential backoff, memicu retry loop tak terbatas yang membebani CPU, menghabiskan thread pool, dan menyumbat antrean worker downstream.

Akar Masalah: Ambiguitas Kontrak Kegagalan

Sistem pengirim feed (seperti Kafka HTTP sink, SNS, atau custom webhook engine) membedakan error ke dalam dua kategori:

  • Transient Failure (Infrastruktur): Jaringan terputus, timeout, atau database downstream terkunci. Memerlukan retry otomatis (HTTP 500, 502, 503, 504).
  • Permanent Failure (Protokol): Payload rusak secara sintaksis atau signature autentikasi tidak valid (HTTP 400, 401, 403).

Konten yang ditolak oleh aturan bisnis (misalnya tidak memiliki manifest C2PA atau teridentifikasi sebagai teks sintetis tanpa label provenance) bukanlah kegagalan transmisi. Payload tersebut valid secara sintaksis dan berhasil diterima. Mengembalikan HTTP 400 atau 403 memicu banyak webhook engine untuk terus mencoba mengirim ulang sesuai configured retry policy.

Spesifikasi Kontrak Status Code: ACK vs Reject

Untuk menghentikan siklus retry yang tidak perlu, kontrak API ingest harus memisahkan validasi transport dari validasi domain.

1. HTTP 200 OK / 202 Accepted (Business Drop / Acknowledged)

Gunakan 200 OK atau 202 Accepted ketika payload sukses diterima dan divalidasi skemanya, namun diputuskan untuk dibuang oleh filter AI provenance. Respons harus menyertakan status operasional pada payload:

{
  "status": "dropped",
  "reason": "unverified_synthetic_content",
  "item_id": "art_982341"
}

Upstream menganggap pengiriman selesai (ACK) dan menghapus pesan dari antrean retry.

2. HTTP 422 Unprocessable Entity (Schema Contract Violation)

Gunakan 422 hanya jika payload melanggar skema struktural yang telah disepakati, misalnya header wajib X-Provenance-Source tidak dikirim sama sekali atau metadata JSON tidak sesuai format tipe data.

3. HTTP 5xx (Downstream Transient Errors)

Gunakan hanya jika sistem verifikasi lokal gagal mengecek signature karena dependensi eksternal (misal KMS atau redis keystore) mengalami timeout. Ini memberi sinyal upstream yang sah untuk melakukan retry.

Idempotency Key Berbasis Hash Konten

Jika upstream tetap melakukan retry akibat network drop setelah server downstream mengirim response, evaluasi AI tidak boleh dieksekusi ulang. Hitung SHA-256 dari canonicalized payload body. Simpan hash tersebut dalam short-lived key-value store (TTL 24-72 jam) sebelum memproses aturan filtering.

Implementasi: Go Ingest Handler

Berikut implementasi minimal HTTP handler di Go dengan verifikasi metadata provenance dan idempotency berbasis SHA-256 tanpa dependensi pihak ketiga.

package main

import (
	"crypto/sha256"
	"encoding/hex"
	"encoding/json"
	"io"
	"net/http"
	"sync"
)

type IngestPayload struct {
	ID          string            `json:"id"`
	Content     string            `json:"content"`
	IsSynthetic bool              `json:"is_synthetic"`
	Metadata    map[string]string `json:"metadata"`
}

type IngestResponse struct {
	Status  string `json:"status"`
	Reason  string `json:"reason,omitempty"`
	ContentHash string `json:"content_hash"`
}

type FeedIngestServer struct {
	mu        sync.Mutex
	processed map[string]string // ponytail: in-memory dedup store; replace with Redis in distributed setup
}

func NewFeedIngestServer() *FeedIngestServer {
	return &FeedIngestServer{
		processed: make(map[string]string),
	}
}

func (s *FeedIngestServer)
ServeHTTP(w http.ResponseWriter, r *http.Request) {
	if r.Method != http.MethodPost {
		w.WriteHeader(http.StatusMethodNotAllowed)
		return
	}

	body, err := io.ReadAll(r.Body)
	if err != nil {
		w.WriteHeader(http.StatusBadRequest)
		return
	}
	defer r.Body.Close()

	hashBytes := sha256.Sum256(body)
	contentHash := hex.EncodeToString(hashBytes[:])

	s.mu.Lock()
	if status, exists := s.processed[contentHash]; exists {
		s.mu.Unlock()
		w.Header().Set("Content-Type", "application/json")
		w.WriteHeader(http.StatusOK)
		json.NewEncoder(w).Encode(IngestResponse{
			Status:      "acknowledged_duplicate",
			Reason:      status,
			ContentHash: contentHash,
		})
		return
	}
	s.mu.Unlock()

	var payload IngestPayload
	if err := json.Unmarshal(body, &payload); err != nil {
		w.WriteHeader(http.StatusBadRequest)
		return
	}

	// Schema enforcement
	if payload.ID == "" {
		w.Header().Set("Content-Type", "application/json")
		w.WriteHeader(http.StatusUnprocessableEntity)
		json.NewEncoder(w).Encode(map[string]string{"error": "missing payload id"})
		return
	}

	w.Header().Set("Content-Type", "application/json")

	// AI Provenance Validation: reject unverified synthetic text without 4xx/5xx
	provenanceSig := r.Header.Get("X-Provenance-Signature")
	if payload.IsSynthetic && provenanceSig == "" {
		s.recordDecision(contentHash, "dropped_unverified_ai")
		w.WriteHeader(http.StatusOK)
		json.NewEncoder(w).Encode(IngestResponse{
			Status:      "dropped",
			Reason:      "synthetic_content_lacks_provenance_signature",
			ContentHash: contentHash,
		})
		return
	}

	s.recordDecision(contentHash, "ingested")
	w.WriteHeader(http.StatusAccepted)
	json.NewEncoder(w).Encode(IngestResponse{
		Status:      "accepted",
		ContentHash: contentHash,
	})
}

func (s *FeedIngestServer) recordDecision(hash, decision string) {
	s.mu.Lock()
	defer s.mu.Unlock()
	s.processed[hash] = decision
}

Disederhanakan: In-memory map untuk deduplikasi. Tambahkan Redis saat instans berjalan di multi-pod horizontal pod autoscaler.

Uji Verifikasi Deduplikasi & Terminasi Loop

Kode uji berikut membuktikan bahwa payload AI sintetis tanpa signature segera menerima status dropped via HTTP 200, dan pengiriman duplikat langsung mengembalikan status tanpa memproses ulang komputasi.

package main

import (
	"bytes"
	"encoding/json"
	"net/http"
	"net/http/httptest"
	"testing"
)

func TestIngestFilterAndDeduplication(t *testing.T) {
	server := NewFeedIngestServer()

	payload := IngestPayload{
		ID:          "item-101",
		Content:     "Teks dibuat oleh generator LLM.",
		IsSynthetic: true,
	}
	body, _ := json.Marshal(payload)

	// Call 1: Unverified synthetic payload must receive HTTP 200 OK (Drop ACK)
	req1 := httptest.NewRequest(http.MethodPost, "/ingest", bytes.NewReader(body))
	rec1 := httptest.NewRecorder()
	server.ServeHTTP(rec1, req1)

	if rec1.Code != http.StatusOK {
		t.Fatalf("expected status 200 on filter drop, got: %d", rec1.Code)
	}

	var res1 IngestResponse
	json.NewDecoder(rec1.Body).Decode(&res1)
	if res1.Status != "dropped" {
		t.Fatalf("expected status 'dropped', got: %s", res1.Status)
	}

	// Call 2: Retry with exact same content must short-circuit deduplication
	req2 := httptest.NewRequest(http.MethodPost, "/ingest", bytes.NewReader(body))
	rec2 := httptest.NewRecorder()
	server.ServeHTTP(rec2, req2)

	if rec2.Code != http.StatusOK {
		t.Fatalf("expected status 200 on duplicate retry, got: %d", rec2.Code)
	}

	var res2 IngestResponse
	json.NewDecoder(rec2.Body).Decode(&res2)
	if res2.Status != "acknowledged_duplicate" {
		t.Fatalf("expected status 'acknowledged_duplicate', got: %s", res2.Status)
	}
}

Panduan Operasional Webhook Syndication

  1. Sertakan Header Telemetri: Kirim balik header X-Ingest-Action: drop pada HTTP 200 agar log aggregator upstream bisa membedakan metrik drop tanpa memicu alarm alerting 5xx.
  2. Dead Letter Queue Downstream: Jika format metadata provenance salah namun pengirim adalah publisher terverifikasi, masukkan ke DLQ internal untuk audit alih-alih melempar 500.
  3. Batas Ukuran Payload: Bungkus `io.LimitReader` pada handler ingest untuk mencegah denial-of-service hash calculation dari payload berukuran raksasa.