aether-quant 0.0.1__py3-none-any.whl

audit/README.md

@@ -0,0 +1,47 @@
+# audit
+
+Owns the **tamper-evident audit log** — a hash-chained record of
+security-relevant events (credential loads, live-mode transitions, and the
+per-bar order-placement path), added in V2-18 (see
+`development/Problems.md` #42, hardened further in #48).
+
+This package is a deliberate structural mirror of `experience/`: same
+Redis-Stream → async-worker → PostgreSQL pipeline, same fire-and-forget
+publish contract, so audit events can be emitted from `main.py`'s hot path
+and from `execution/`'s credential/live-mode call sites without ever risking
+a real trade or blocking a live process on a Postgres round-trip. What makes
+it *audit* rather than *experience* is the hash chain: each row's hash covers
+its own content plus the previous row's hash, so altering or deleting any
+historical row breaks every hash after it (the same construction git commits
+and blockchains use, applied to one linear table).
+
+Members:
+
+- `hash_chain.py` — pure tamper-evidence logic, no I/O. `compute_entry_hash()`
+  (`sha256(prev_hash || event_type || created_at || canonical-JSON payload)`)
+  and `verify_chain()`. `GENESIS_HASH` is a fixed all-zero value so an empty
+  `prev_hash` can never be confused with "not yet verified".
+- `redis_queue.py` — the fire-and-forget Redis Stream publisher (`aether:audit`),
+  mirroring `experience/redis_queue.py`'s never-raises contract exactly.
+- `postgres_worker.py` — drains the Redis Stream via `XREADGROUP` consumer-group
+  semantics and batch-inserts into the `audit_log` table, computing each row's
+  hash-chain link **at durable-write order** (not push order), so out-of-order
+  Redis delivery can never produce a chain that disagrees with on-disk row
+  order. Idempotent embedded DDL (`ensure_schema()`), no Alembic — same design
+  as `experience/postgres_worker.py`. V5.4.7 (#120): a poison-row batch failure
+  persists the clean prefix and dead-letters the poison row PLUS every later
+  row (their hashes chain off a parent that never landed - inserting them
+  would fork the chain); a Postgres outage still re-raises with everything pending.
+- `postgres_audit.py` — read-only query helpers over `audit_log`, shared by the
+  `aq audit-log` CLI and `monitoring/api_server.py`'s `GET /api/audit-log`
+  route so the CLI and webui can never drift on row shape. Never inserts.
+- `status_export.py` — sole writer of `visualization/grafana/audit_log.json`,
+  refreshed by `postgres_worker.py` after every persisted batch (real-time-ish,
+  not a periodic cron export — a stale audit trail defeats its own purpose),
+  since `main.py` only ever connects to Redis, not Postgres.
+
+Verify the chain end-to-end with `aq audit-log --verify` (re-hashes every row
+and reports the first break, if any). See `development/infrastructure.md`'s
+audit section for the worker's Compose service and `development/Problems.md`
+#42/#48 for the full design rationale and the reconciliation/`init: true`
+hardening.

audit/__init__.py

@@ -0,0 +1,38 @@
+"""Tamper-evident audit trail for order placement, credential loads, and
+live-mode transitions (development/Problems.md #42's deferred item).
+
+Same three-piece shape as experience/ (the only other Redis-Stream-backed
+package here): redis_queue.py (pure event builder + fire-and-forget
+publisher, called from main.py/execution/ - never blocks trading),
+postgres_worker.py (drains the stream into a durable, hash-chained Postgres
+table), postgres_audit.py (read-only query helpers shared by the CLI and the
+webui API route). hash_chain.py is the one pure piece unique to this
+package - the tamper-evidence logic itself.
+"""
+
+from __future__ import annotations
+
+from .hash_chain import GENESIS_HASH, compute_entry_hash, verify_chain
+from .postgres_audit import fetch_all_events_ordered, fetch_recent_events
+from .postgres_worker import PostgresWorker, ensure_schema, event_to_row
+from .redis_queue import CREDENTIAL_LOAD, EVENT_TYPES, LIVE_MODE_TRANSITION, ORDER_PLACEMENT, AuditQueue, build_audit_event
+from .status_export import build_audit_status_view, write_status_file
+
+__all__ = [
+    "AuditQueue",
+    "build_audit_event",
+    "CREDENTIAL_LOAD",
+    "EVENT_TYPES",
+    "LIVE_MODE_TRANSITION",
+    "ORDER_PLACEMENT",
+    "compute_entry_hash",
+    "verify_chain",
+    "GENESIS_HASH",
+    "ensure_schema",
+    "event_to_row",
+    "PostgresWorker",
+    "fetch_recent_events",
+    "fetch_all_events_ordered",
+    "build_audit_status_view",
+    "write_status_file",
+]

audit/hash_chain.py

@@ -0,0 +1,52 @@
+"""Pure tamper-evidence logic for the audit log (development/Problems.md #42).
+
+Each row's hash covers its own content plus the previous row's hash, so
+altering or deleting any historical row breaks every hash after it - the
+same construction git commits / blockchains use, just for one linear table
+instead of a DAG. No I/O here on purpose: audit/postgres_worker.py computes
+each new row's hash at insert time (fetching the current chain tail first),
+and audit/postgres_audit.py's callers (the CLI's --verify, the API route)
+re-verify an already-fetched list of rows through verify_chain() below.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+
+# The hash of the very first entry in the chain (no predecessor to link to) -
+# a fixed, well-known genesis value rather than None/empty-string, so an
+# empty prev_hash column can never be confused with "chain not yet verified".
+GENESIS_HASH = "0" * 64
+
+
+def compute_entry_hash(prev_hash: str, event_type: str, created_at: str, payload: dict) -> str:
+    """sha256(prev_hash || event_type || created_at || canonical-JSON payload).
+
+    `created_at` must be a string (ISO 8601), not a datetime - callers own
+    formatting so this stays pure and independent of any particular
+    Postgres driver's timestamp type. `payload` is serialized with sorted
+    keys and no extra whitespace so the same logical event always hashes
+    identically regardless of dict insertion order.
+    """
+    canonical_payload = json.dumps(payload, sort_keys=True, separators=(",", ":"))
+    digest_input = "|".join([prev_hash, event_type, created_at, canonical_payload])
+    return hashlib.sha256(digest_input.encode("utf-8")).hexdigest()
+
+
+def verify_chain(rows: list[dict]) -> tuple[bool, int | None]:
+    """Walks `rows` (each needing prev_hash/hash/event_type/created_at/payload
+    keys, oldest-first) recomputing every hash and comparing. Returns
+    (all_valid, first_broken_index) - first_broken_index is None when
+    all_valid is True, else the 0-based index of the first row whose
+    prev_hash doesn't match the prior row's hash, or whose own hash doesn't
+    match its recomputed value. An empty list is trivially valid."""
+    expected_prev = GENESIS_HASH
+    for index, row in enumerate(rows):
+        if row["prev_hash"] != expected_prev:
+            return False, index
+        recomputed = compute_entry_hash(row["prev_hash"], row["event_type"], row["created_at"], row["payload"])
+        if recomputed != row["hash"]:
+            return False, index
+        expected_prev = row["hash"]
+    return True, None

audit/postgres_audit.py

@@ -0,0 +1,61 @@
+"""Read-only query helpers over the audit_log table (development/Problems.md #42).
+
+Shared by `aq audit-log` (aq_cli.py) and monitoring/api_server.py's
+`GET /api/audit-log` route - one place owns the SELECT shape so the CLI and
+the webui can never drift apart on what a row looks like. Write path lives
+in audit/postgres_worker.py (the Redis-Stream-draining worker); this module
+never inserts anything.
+"""
+
+from __future__ import annotations
+
+from datetime import datetime, timezone
+from typing import Any
+
+_COLUMNS = (
+    "event_id",
+    "created_at",
+    "event_type",
+    "actor",
+    "prev_hash",
+    "hash",
+    "payload",
+)
+
+
+def _row_to_dict(row: tuple) -> dict[str, Any]:
+    return dict(zip(_COLUMNS, row))
+
+
+def fetch_recent_events(
+    conn,
+    event_type: str | None = None,
+    since: datetime | None = None,
+    limit: int = 100,
+) -> list[dict]:
+    """Newest-first page of audit_log rows, optionally filtered. `since`
+    defaults to the Unix epoch (no filter) rather than requiring callers to
+    special-case None, matching retraining/postgres_registry.py's
+    fetch_recent_retraining_events() convention."""
+    if since is None:
+        since = datetime.fromtimestamp(0, tz=timezone.utc)
+    query = f"SELECT {', '.join(_COLUMNS)} FROM audit_log WHERE created_at > %(since)s"
+    params: dict[str, Any] = {"since": since, "limit": limit}
+    if event_type is not None:
+        query += " AND event_type = %(event_type)s"
+        params["event_type"] = event_type
+    query += " ORDER BY id DESC LIMIT %(limit)s;"
+    with conn.cursor() as cur:
+        cur.execute(query, params)
+        rows = cur.fetchall()
+    return [_row_to_dict(row) for row in rows]
+
+
+def fetch_all_events_ordered(conn) -> list[dict]:
+    """Every audit_log row, oldest-first - the shape audit.hash_chain.verify_chain()
+    expects. Only ever used by `aq audit-log --verify`; not paginated
+    (verification is meaningless over a partial chain)."""
+    with conn.cursor() as cur:
+        cur.execute(f"SELECT {', '.join(_COLUMNS)} FROM audit_log ORDER BY id ASC;")
+        rows = cur.fetchall()
+    return [_row_to_dict(row) for row in rows]

audit/postgres_worker.py

@@ -0,0 +1,402 @@
+"""PostgreSQL persistence worker for the audit log (development/Problems.md #42).
+
+Reads from the Redis Stream ``aether:audit`` via XREADGROUP consumer group
+semantics (identical mechanics to experience/postgres_worker.py) and
+batch-inserts each event into the ``audit_log`` table, computing each row's
+hash-chain link (audit/hash_chain.py) at insert time - chaining happens in
+durable-write order, not push order, so out-of-order Redis delivery can
+never produce a chain that doesn't match on-disk row order.
+
+Design decisions (mirrors experience/postgres_worker.py exactly):
+- Sync-only: no asyncio; event volume does not justify async complexity.
+- Embedded DDL: no Alembic; ensure_schema() is idempotent and called on startup.
+- ON CONFLICT (event_id) DO NOTHING: safe idempotent re-delivery.
+- Messages are NOT acked until PG commit succeeds — safe at-least-once delivery.
+- Malformed JSON → dead-letter stream, immediate XACK, log WARNING.
+- _redis_client and _pg_conn constructor params for test injection.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import logging
+import os
+import time
+from typing import Any
+
+from .hash_chain import GENESIS_HASH, compute_entry_hash
+from .status_export import build_audit_status_view, write_status_file
+
+logger = logging.getLogger(__name__)
+
+# ---------------------------------------------------------------------------
+# Schema DDL — embedded constant, no migration files
+# ---------------------------------------------------------------------------
+
+_CREATE_TABLE_SQL = """
+CREATE TABLE IF NOT EXISTS audit_log (
+    id            BIGSERIAL PRIMARY KEY,
+    event_id      UUID        UNIQUE NOT NULL,
+    created_at    TIMESTAMPTZ NOT NULL,
+    ingested_at   TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+    event_type    VARCHAR(30) NOT NULL,
+    actor         VARCHAR(30) NOT NULL,
+    prev_hash     CHAR(64)    NOT NULL,
+    hash          CHAR(64)    NOT NULL,
+    payload       JSONB       NOT NULL
+);
+"""
+
+_CREATE_INDEXES_SQL = [
+    "CREATE INDEX IF NOT EXISTS ix_audit_created_at ON audit_log (created_at);",
+    "CREATE INDEX IF NOT EXISTS ix_audit_event_type ON audit_log (event_type);",
+    "CREATE INDEX IF NOT EXISTS ix_audit_payload    ON audit_log USING GIN (payload);",
+]
+
+_INSERT_SQL = """
+INSERT INTO audit_log
+    (event_id, created_at, event_type, actor, prev_hash, hash, payload)
+VALUES
+    (%(event_id)s, %(created_at)s, %(event_type)s, %(actor)s,
+     %(prev_hash)s, %(hash)s, %(payload)s)
+ON CONFLICT (event_id) DO NOTHING;
+"""
+
+_LATEST_HASH_SQL = "SELECT hash FROM audit_log ORDER BY id DESC LIMIT 1;"
+
+# ---------------------------------------------------------------------------
+# Pure transformation — testable without any I/O
+# ---------------------------------------------------------------------------
+
+
+def event_to_row(event: dict, prev_hash: str) -> dict[str, Any]:
+    """Extract INSERT params from an audit event dict plus the chain-tail
+    hash it links to. Pure function - computes this row's own hash via
+    audit.hash_chain.compute_entry_hash(), never mutates `event`."""
+    entry_hash = compute_entry_hash(prev_hash, event["event_type"], event["created_at"], event["payload"])
+    return {
+        "event_id": event["event_id"],
+        "created_at": event["created_at"],
+        "event_type": event["event_type"],
+        "actor": event.get("actor", "system"),
+        "prev_hash": prev_hash,
+        "hash": entry_hash,
+        "payload": json.dumps(event["payload"]),
+    }
+
+
+# ---------------------------------------------------------------------------
+# Schema helper
+# ---------------------------------------------------------------------------
+
+
+def ensure_schema(conn) -> None:
+    """Create audit_log table and indexes if they do not exist. Idempotent."""
+    with conn.cursor() as cur:
+        cur.execute(_CREATE_TABLE_SQL)
+        for idx_sql in _CREATE_INDEXES_SQL:
+            cur.execute(idx_sql)
+    conn.commit()
+    logger.info("ensure_schema: audit_log ready.")
+
+
+def fetch_latest_hash(conn) -> str:
+    """The chain tail: the most recently inserted row's hash, or GENESIS_HASH
+    if the table is empty. Callers hold this fixed across one run_once()
+    batch and thread it forward row-by-row (see PostgresWorker.run_once())
+    so a batch of N events chains correctly among themselves before any of
+    them are committed."""
+    with conn.cursor() as cur:
+        cur.execute(_LATEST_HASH_SQL)
+        row = cur.fetchone()
+    return row[0] if row else GENESIS_HASH
+
+
+# ---------------------------------------------------------------------------
+# Worker
+# ---------------------------------------------------------------------------
+
+
+class PostgresWorker:
+    """Drains aether:audit Redis Stream into PostgreSQL audit_log.
+
+    Parameters — identical shape to experience.postgres_worker.PostgresWorker;
+    see that class's docstring for the full parameter list. Differs only in
+    stream_name/group_name defaults and in computing+persisting the
+    hash-chain link for every row (see event_to_row()/fetch_latest_hash()).
+    """
+
+    def __init__(
+        self,
+        *,
+        redis_url: str = "redis://localhost:6380/0",
+        postgres_dsn: str,
+        stream_name: str = "aether:audit",
+        group_name: str = "aether-audit-workers",
+        consumer_name: str = "worker-1",
+        batch_size: int = 100,
+        deadletter_stream: str = "aether:audit:deadletter",
+        backoff_max: int = 60,
+        _redis_client=None,
+        _pg_conn=None,
+    ) -> None:
+        self.stream_name = stream_name
+        self.group_name = group_name
+        self.consumer_name = consumer_name
+        self.batch_size = batch_size
+        self.deadletter_stream = deadletter_stream
+        self.backoff_max = backoff_max
+
+        if _redis_client is not None:
+            self._redis = _redis_client
+        else:
+            import redis as redis_lib
+            url = os.environ.get("AETHER_REDIS_URL", redis_url)
+            self._redis = redis_lib.from_url(url, socket_connect_timeout=5, socket_timeout=5)
+            # V5.4.7 (#120): warn instead of crash-looping when Redis is
+            # down at container start; run()'s backoff loop retries.
+            try:
+                self._redis.ping()
+                logger.info("AuditPostgresWorker: Redis connected at %s", url)
+            except Exception as exc:
+                logger.warning("AuditPostgresWorker: Redis not reachable yet (%s) - will retry in run loop.", exc)
+
+        if _pg_conn is not None:
+            self._conn = _pg_conn
+        else:
+            import psycopg
+            dsn = os.environ.get("AETHER_POSTGRES_DSN", postgres_dsn)
+            self._conn = psycopg.connect(dsn, autocommit=False)
+            logger.info("AuditPostgresWorker: PostgreSQL connected.")
+
+        ensure_schema(self._conn)
+        self._ensure_consumer_group()
+
+    def _ensure_consumer_group(self) -> None:
+        try:
+            self._redis.xgroup_create(
+                self.stream_name, self.group_name, id="0", mkstream=True
+            )
+            logger.info("Consumer group '%s' created on '%s'.", self.group_name, self.stream_name)
+        except Exception as exc:
+            if "BUSYGROUP" in str(exc):
+                logger.debug("Consumer group '%s' already exists.", self.group_name)
+            else:
+                raise
+
+    def _reconnect_pg(self, postgres_dsn: str) -> None:
+        import psycopg
+        try:
+            self._conn.close()
+        except Exception:
+            pass
+        dsn = os.environ.get("AETHER_POSTGRES_DSN", postgres_dsn)
+        self._conn = psycopg.connect(dsn, autocommit=False)
+        ensure_schema(self._conn)
+        logger.info("AuditPostgresWorker: PostgreSQL reconnected.")
+
+    def run_once(self) -> int:
+        """Read one batch, hash-chain it, persist, ack. Returns count of
+        events persisted. Raises on PostgreSQL failure — messages stay
+        pending for re-delivery."""
+        results = self._redis.xreadgroup(
+            self.group_name,
+            self.consumer_name,
+            {self.stream_name: ">"},
+            count=self.batch_size,
+            # block omitted (not 0 - that means "block forever" in Redis,
+            # not "don't block") so this returns immediately; run() provides
+            # the idle sleep.
+        )
+        if not results:
+            return 0
+
+        _, messages = results[0]
+        rows: list[dict] = []
+        ids_good: list = []
+        ids_deadletter: list = []
+        raw_by_id: dict = {}
+        running_hash = fetch_latest_hash(self._conn)
+
+        for msg_id, fields in messages:
+            raw = fields.get(b"payload") or fields.get("payload", b"")
+            raw_by_id[msg_id] = raw if isinstance(raw, (bytes, bytearray)) else str(raw).encode("utf-8")
+            try:
+                event = json.loads(raw)
+                row = event_to_row(event, running_hash)
+                rows.append(row)
+                running_hash = row["hash"]  # chain the NEXT event in this batch to THIS one
+                ids_good.append(msg_id)
+            except Exception as exc:
+                logger.warning("Malformed message %s → dead-letter. Error: %s", msg_id, exc)
+                self._redis.xadd(
+                    self.deadletter_stream,
+                    {"payload": raw, "error": str(exc), "original_id": str(msg_id)},
+                )
+                ids_deadletter.append(msg_id)
+
+        if ids_deadletter:
+            self._redis.xack(self.stream_name, self.group_name, *ids_deadletter)
+
+        # V5.4.7 (Problems.md #120): a single poison row used to fail the
+        # whole executemany, roll back every good row, and leave the batch
+        # pending forever (xreadgroup(">") never re-delivers) - wedging
+        # the pipeline on one bad payload. Unlike the experience worker,
+        # this chain CANNOT skip a failed middle row: every row's hash
+        # chains to its predecessor's, so once one row cannot be inserted
+        # every LATER row in the batch would fork the tamper-evident chain.
+        # Fallback therefore inserts per-row IN ORDER and stops at the
+        # first failure - that row and everything after it dead-letters
+        # (payloads preserved verbatim), everything before it commits.
+        if rows:
+            try:
+                with self._conn.cursor() as cur:
+                    cur.executemany(_INSERT_SQL, rows)
+                self._conn.commit()
+                self._redis.xack(self.stream_name, self.group_name, *ids_good)
+                logger.info("AuditPostgresWorker: persisted %d events.", len(rows))
+            except Exception as batch_exc:
+                # V5.4.7 (#120) - poison row vs postgres down: first-row
+                # failure means the connection/statement, not the data -
+                # re-raise so everything stays pending (old contract). A
+                # batch whose head inserts fine takes the per-row path,
+                # which for this hash-chained stream STOPS at the first
+                # poison row and dead-letters it plus every LATER row
+                # (their hashes chain off a parent that never landed -
+                # inserting them would fork the tamper-evident chain).
+                try:
+                    with self._conn.cursor() as cur:
+                        cur.execute(_INSERT_SQL, rows[0])
+                    self._conn.commit()
+                except Exception:
+                    self._conn.rollback()
+                    raise
+                self._redis.xack(self.stream_name, self.group_name, ids_good[0])
+                persisted = 1
+                for msg_id, row in zip(ids_good[1:], rows[1:]):
+                    try:
+                        with self._conn.cursor() as cur:
+                            cur.execute(_INSERT_SQL, row)
+                        self._conn.commit()
+                        self._redis.xack(self.stream_name, self.group_name, msg_id)
+                        persisted += 1
+                    except Exception as row_exc:
+                        self._conn.rollback()
+                        logger.warning(
+                            "Poison row %s → dead-letter; stopping - later rows "
+                            "chain off this one's hash. Error: %s", msg_id, row_exc
+                        )
+                        break
+                for msg_id in ids_good[persisted:]:
+                    raw = raw_by_id.get(msg_id)
+                    self._redis.xadd(
+                        self.deadletter_stream,
+                        {
+                            "payload": raw if raw is not None else b"",
+                            "error": f"chained after poison row: {batch_exc}",
+                            "original_id": str(msg_id),
+                        },
+                    )
+                    self._redis.xack(self.stream_name, self.group_name, msg_id)
+                logger.info(
+                    "AuditPostgresWorker: per-row fallback persisted %d/%d events.",
+                    persisted, len(rows),
+                )
+                return persisted
+            # Refresh the webui/API dashboard snapshot right after a real
+            # persist (not on every idle poll) - a stale audit trail
+            # defeats its own purpose, so this stays close to real-time
+            # rather than a periodic cron export. Best-effort: a dashboard
+            # export failure must never lose already-committed audit rows.
+            try:
+                write_status_file(build_audit_status_view(self._conn))
+            except Exception as exc:
+                logger.warning("AuditPostgresWorker: dashboard export failed: %s", exc)
+
+        return len(rows)
+
+    def run(self, postgres_dsn: str = "") -> None:
+        """Continuous loop with exponential backoff on errors."""
+        backoff = 1
+        logger.info("AuditPostgresWorker: entering run loop.")
+        while True:
+            try:
+                count = self.run_once()
+                if count == 0:
+                    time.sleep(1)  # idle poll interval
+                else:
+                    backoff = 1
+            except KeyboardInterrupt:
+                logger.info("AuditPostgresWorker: shutdown requested.")
+                break
+            except Exception as exc:
+                logger.error("Worker error — %s. Retrying in %ds.", exc, backoff)
+                time.sleep(backoff)
+                backoff = min(backoff * 2, self.backoff_max)
+                if postgres_dsn and "connection" in str(exc).lower():
+                    try:
+                        self._reconnect_pg(postgres_dsn)
+                    except Exception as reconn_exc:
+                        logger.error("Reconnect failed: %s", reconn_exc)
+
+    def close(self) -> None:
+        try:
+            self._redis.close()
+        except Exception:
+            pass
+        try:
+            self._conn.close()
+        except Exception:
+            pass
+
+
+# ---------------------------------------------------------------------------
+# Entry point
+# ---------------------------------------------------------------------------
+
+
+def main() -> None:
+    logging.basicConfig(
+        level=logging.INFO,
+        format="%(asctime)s [%(levelname)s] %(name)s — %(message)s",
+    )
+    parser = argparse.ArgumentParser(description="Aether Quant audit-log persistence worker")
+    parser.add_argument("--once", action="store_true", help="Read one batch and exit")
+    parser.add_argument(
+        "--stream",
+        default=os.environ.get("AETHER_AUDIT_STREAM", "aether:audit"),
+    )
+    parser.add_argument(
+        "--group",
+        default=os.environ.get("AETHER_AUDIT_GROUP", "aether-audit-workers"),
+    )
+    parser.add_argument(
+        "--batch-size",
+        type=int,
+        default=int(os.environ.get("AETHER_AUDIT_BATCH_SIZE", "100")),
+    )
+    args = parser.parse_args()
+
+    redis_url = os.environ.get("AETHER_REDIS_URL", "redis://localhost:6380/0")
+    postgres_dsn = os.environ.get("AETHER_POSTGRES_DSN", "")
+
+    worker = PostgresWorker(
+        redis_url=redis_url,
+        postgres_dsn=postgres_dsn,
+        stream_name=args.stream,
+        group_name=args.group,
+        batch_size=args.batch_size,
+    )
+    try:
+        if args.once:
+            count = worker.run_once()
+            logger.info("--once: persisted %d events.", count)
+        else:
+            worker.run(postgres_dsn=postgres_dsn)
+    finally:
+        worker.close()
+
+
+if __name__ == "__main__":
+    main()