eventsourcing 9.3.4__py3-none-any.whl → 9.4.0__py3-none-any.whl

eventsourcing/postgres.py

@@ -1,14 +1,20 @@
 from __future__ import annotations
 
+import contextlib
 import logging
+from asyncio import CancelledError
 from contextlib import contextmanager
-from typing import TYPE_CHECKING, Any, Callable, Iterator, List, Sequence
+from threading import Thread
+from typing import TYPE_CHECKING, Any, Callable, cast
 
 import psycopg
 import psycopg.errors
 import psycopg_pool
-from psycopg import Connection, Cursor
+from psycopg import Connection, Cursor, Error
+from psycopg.generators import notifies
 from psycopg.rows import DictRow, dict_row
+from psycopg.sql import SQL, Composed, Identifier
+from typing_extensions import TypeVar
 
 from eventsourcing.persistence import (
     AggregateRecorder,
@@ -19,6 +25,7 @@ from eventsourcing.persistence import (
     IntegrityError,
     InterfaceError,
     InternalError,
+    ListenNotifySubscription,
     Notification,
     NotSupportedError,
     OperationalError,
@@ -26,18 +33,30 @@ from eventsourcing.persistence import (
     ProcessRecorder,
     ProgrammingError,
     StoredEvent,
+    Subscription,
     Tracking,
+    TrackingRecorder,
 )
 from eventsourcing.utils import Environment, resolve_topic, retry, strtobool
 
-if TYPE_CHECKING:  # pragma: nocover
+if TYPE_CHECKING:
+    from collections.abc import Iterator, Sequence
     from uuid import UUID
 
+    from psycopg.abc import Query
     from typing_extensions import Self
 
 logging.getLogger("psycopg.pool").setLevel(logging.CRITICAL)
 logging.getLogger("psycopg").setLevel(logging.CRITICAL)
 
+# Copy of "private" psycopg.errors._NO_TRACEBACK (in case it changes)
+# From psycopg: "Don't show a complete traceback upon raising these exception.
+# Usually the traceback starts from internal functions (for instance in the
+# server communication callbacks) but, for the end user, it's more important
+# to get the high level information about where the exception was raised, for
+# instance in a certain `Cursor.execute()`."
+NO_TRACEBACK = (Error, KeyboardInterrupt, CancelledError)
+
 
 class ConnectionPool(psycopg_pool.ConnectionPool[Any]):
     def __init__(
@@ -56,11 +75,11 @@ class ConnectionPool(psycopg_pool.ConnectionPool[Any]):
 
 
 class PostgresDatastore:
-    def __init__(
+    def __init__(  # noqa: PLR0913
         self,
         dbname: str,
         host: str,
-        port: str,
+        port: str | int,
         user: str,
         password: str,
         *,
@@ -95,22 +114,26 @@ class PostgresDatastore:
             min_size=pool_size,
             max_size=pool_size + max_overflow,
             open=False,
-            configure=self.after_connect,
+            configure=self.after_connect_func(),
             timeout=connect_timeout,
             max_waiting=max_waiting,
             max_lifetime=conn_max_age,
             check=check,
         )
         self.lock_timeout = lock_timeout
-        self.schema = schema.strip()
+        self.schema = schema.strip() or "public"
 
-    def after_connect(self, conn: Connection[DictRow]) -> None:
-        conn.autocommit = True
-        conn.cursor().execute(
-            "SET idle_in_transaction_session_timeout = "
-            f"'{self.idle_in_transaction_session_timeout}s'"
+    def after_connect_func(self) -> Callable[[Connection[Any]], None]:
+        statement = SQL("SET idle_in_transaction_session_timeout = '{0}s'").format(
+            self.idle_in_transaction_session_timeout
         )
 
+        def after_connect(conn: Connection[DictRow]) -> None:
+            conn.autocommit = True
+            conn.cursor().execute(statement)
+
+        return after_connect
+
     @contextmanager
     def get_connection(self) -> Iterator[Connection[DictRow]]:
         try:
@@ -147,86 +170,97 @@ class PostgresDatastore:
 
     @contextmanager
     def transaction(self, *, commit: bool = False) -> Iterator[Cursor[DictRow]]:
-        conn: Connection[DictRow]
         with self.get_connection() as conn, conn.transaction(force_rollback=not commit):
             yield conn.cursor()
 
     def close(self) -> None:
         self.pool.close()
 
-    def __del__(self) -> None:
-        self.close()
-
     def __enter__(self) -> Self:
         return self
 
     def __exit__(self, *args: object, **kwargs: Any) -> None:
         self.close()
 
+    def __del__(self) -> None:
+        self.close()
+
+
+class PostgresRecorder:
+    """Base class for recorders that use PostgreSQL."""
 
-class PostgresAggregateRecorder(AggregateRecorder):
     def __init__(
         self,
         datastore: PostgresDatastore,
-        events_table_name: str,
     ):
-        self.check_table_name_length(events_table_name, datastore.schema)
         self.datastore = datastore
+        self.create_table_statements = self.construct_create_table_statements()
+
+    def construct_create_table_statements(self) -> list[Composed]:
+        return []
+
+    def check_table_name_length(self, table_name: str) -> None:
+        if len(table_name) > 63:
+            msg = f"Table name too long: {table_name}"
+            raise ProgrammingError(msg)
+
+    def create_table(self) -> None:
+        with self.datastore.transaction(commit=True) as curs:
+            for statement in self.create_table_statements:
+                curs.execute(statement, prepare=False)
+
+
+class PostgresAggregateRecorder(PostgresRecorder, AggregateRecorder):
+    def __init__(
+        self,
+        datastore: PostgresDatastore,
+        *,
+        events_table_name: str = "stored_events",
+    ):
+        super().__init__(datastore)
+        self.check_table_name_length(events_table_name)
         self.events_table_name = events_table_name
         # Index names can't be qualified names, but
         # are created in the same schema as the table.
-        if "." in self.events_table_name:
-            unqualified_table_name = self.events_table_name.split(".")[-1]
-        else:
-            unqualified_table_name = self.events_table_name
         self.notification_id_index_name = (
-            f"{unqualified_table_name}_notification_id_idx "
+            f"{self.events_table_name}_notification_id_idx"
         )
-
-        self.create_table_statements = self.construct_create_table_statements()
-        self.insert_events_statement = (
-            f"INSERT INTO {self.events_table_name} VALUES (%s, %s, %s, %s)"
-        )
-        self.select_events_statement = (
-            f"SELECT * FROM {self.events_table_name} WHERE originator_id = %s"
+        self.create_table_statements.append(
+            SQL(
+                "CREATE TABLE IF NOT EXISTS {0}.{1} ("
+                "originator_id uuid NOT NULL, "
+                "originator_version bigint NOT NULL, "
+                "topic text, "
+                "state bytea, "
+                "PRIMARY KEY "
+                "(originator_id, originator_version)) "
+                "WITH (autovacuum_enabled=false)"
+            ).format(
+                Identifier(self.datastore.schema),
+                Identifier(self.events_table_name),
+            )
         )
-        self.lock_table_statements: List[str] = []
 
-    @staticmethod
-    def check_table_name_length(table_name: str, schema_name: str) -> None:
-        schema_prefix = schema_name + "."
-        if table_name.startswith(schema_prefix):
-            unqualified_table_name = table_name[len(schema_prefix) :]
-        else:
-            unqualified_table_name = table_name
-        if len(unqualified_table_name) > 63:
-            msg = f"Table name too long: {unqualified_table_name}"
-            raise ProgrammingError(msg)
+        self.insert_events_statement = SQL(
+            "INSERT INTO {0}.{1} VALUES (%s, %s, %s, %s)"
+        ).format(
+            Identifier(self.datastore.schema),
+            Identifier(self.events_table_name),
+        )
 
-    def construct_create_table_statements(self) -> List[str]:
-        statement = (
-            "CREATE TABLE IF NOT EXISTS "
-            f"{self.events_table_name} ("
-            "originator_id uuid NOT NULL, "
-            "originator_version bigint NOT NULL, "
-            "topic text, "
-            "state bytea, "
-            "PRIMARY KEY "
-            "(originator_id, originator_version)) "
-            "WITH (autovacuum_enabled=false)"
+        self.select_events_statement = SQL(
+            "SELECT * FROM {0}.{1} WHERE originator_id = %s"
+        ).format(
+            Identifier(self.datastore.schema),
+            Identifier(self.events_table_name),
         )
-        return [statement]
 
-    def create_table(self) -> None:
-        with self.datastore.transaction(commit=True) as curs:
-            for statement in self.create_table_statements:
-                curs.execute(statement, prepare=False)
+        self.lock_table_statements: list[Query] = []
 
     @retry((InterfaceError, OperationalError), max_attempts=10, wait=0.2)
     def insert_events(
-        self, stored_events: List[StoredEvent], **kwargs: Any
+        self, stored_events: list[StoredEvent], **kwargs: Any
     ) -> Sequence[int] | None:
-        conn: Connection[DictRow]
         exc: Exception | None = None
         notification_ids: Sequence[int] | None = None
         with self.datastore.get_connection() as conn:
@@ -255,24 +289,26 @@ class PostgresAggregateRecorder(AggregateRecorder):
 
     def _insert_events(
         self,
-        c: Cursor[DictRow],
-        stored_events: List[StoredEvent],
-        **kwargs: Any,
+        curs: Cursor[DictRow],
+        stored_events: list[StoredEvent],
+        **_: Any,
     ) -> None:
         pass
 
     def _insert_stored_events(
         self,
-        c: Cursor[DictRow],
-        stored_events: List[StoredEvent],
+        curs: Cursor[DictRow],
+        stored_events: list[StoredEvent],
         **_: Any,
     ) -> None:
         # Only do something if there is something to do.
         if len(stored_events) > 0:
-            self._lock_table(c)
+            self._lock_table(curs)
+
+            self._notify_channel(curs)
 
             # Insert events.
-            c.executemany(
+            curs.executemany(
                 query=self.insert_events_statement,
                 params_seq=[
                     (
@@ -283,16 +319,19 @@ class PostgresAggregateRecorder(AggregateRecorder):
                     )
                     for stored_event in stored_events
                 ],
-                returning="RETURNING" in self.insert_events_statement,
+                returning="RETURNING" in self.insert_events_statement.as_string(),
             )
 
-    def _lock_table(self, c: Cursor[DictRow]) -> None:
+    def _lock_table(self, curs: Cursor[DictRow]) -> None:
+        pass
+
+    def _notify_channel(self, curs: Cursor[DictRow]) -> None:
         pass
 
     def _fetch_ids_after_insert_events(
         self,
-        c: Cursor[DictRow],
-        stored_events: List[StoredEvent],
+        curs: Cursor[DictRow],
+        stored_events: list[StoredEvent],
         **kwargs: Any,
     ) -> Sequence[int] | None:
         return None
@@ -306,23 +345,23 @@ class PostgresAggregateRecorder(AggregateRecorder):
         lte: int | None = None,
         desc: bool = False,
         limit: int | None = None,
-    ) -> List[StoredEvent]:
+    ) -> list[StoredEvent]:
         statement = self.select_events_statement
-        params: List[Any] = [originator_id]
+        params: list[Any] = [originator_id]
         if gt is not None:
             params.append(gt)
-            statement += " AND originator_version > %s"
+            statement += SQL(" AND originator_version > %s")
         if lte is not None:
             params.append(lte)
-            statement += " AND originator_version <= %s"
-        statement += " ORDER BY originator_version"
+            statement += SQL(" AND originator_version <= %s")
+        statement += SQL(" ORDER BY originator_version")
         if desc is False:
-            statement += " ASC"
+            statement += SQL(" ASC")
         else:
-            statement += " DESC"
+            statement += SQL(" DESC")
         if limit is not None:
             params.append(limit)
-            statement += " LIMIT %s"
+            statement += SQL(" LIMIT %s")
 
         with self.datastore.get_connection() as conn, conn.cursor() as curs:
             curs.execute(statement, params, prepare=True)
@@ -341,65 +380,108 @@ class PostgresApplicationRecorder(PostgresAggregateRecorder, ApplicationRecorder
     def __init__(
         self,
         datastore: PostgresDatastore,
+        *,
         events_table_name: str = "stored_events",
     ):
-        super().__init__(datastore, events_table_name)
-        self.insert_events_statement += " RETURNING notification_id"
-        self.max_notification_id_statement = (
-            f"SELECT MAX(notification_id) FROM {self.events_table_name}"
+        super().__init__(datastore, events_table_name=events_table_name)
+        self.create_table_statements[-1] = SQL(
+            "CREATE TABLE IF NOT EXISTS {0}.{1} ("
+            "originator_id uuid NOT NULL, "
+            "originator_version bigint NOT NULL, "
+            "topic text, "
+            "state bytea, "
+            "notification_id bigserial, "
+            "PRIMARY KEY "
+            "(originator_id, originator_version)) "
+            "WITH (autovacuum_enabled=false)"
+        ).format(
+            Identifier(self.datastore.schema),
+            Identifier(self.events_table_name),
         )
-        self.lock_table_statements = [
-            f"SET LOCAL lock_timeout = '{self.datastore.lock_timeout}s'",
-            f"LOCK TABLE {self.events_table_name} IN EXCLUSIVE MODE",
-        ]
 
-    def construct_create_table_statements(self) -> List[str]:
-        return [
-            (
-                "CREATE TABLE IF NOT EXISTS "
-                f"{self.events_table_name} ("
-                "originator_id uuid NOT NULL, "
-                "originator_version bigint NOT NULL, "
-                "topic text, "
-                "state bytea, "
-                "notification_id bigserial, "
-                "PRIMARY KEY "
-                "(originator_id, originator_version)) "
-                "WITH (autovacuum_enabled=false)"
-            ),
-            (
-                "CREATE UNIQUE INDEX IF NOT EXISTS "
-                f"{self.notification_id_index_name}"
-                f"ON {self.events_table_name} (notification_id ASC);"
+        self.create_table_statements.append(
+            SQL(
+                "CREATE UNIQUE INDEX IF NOT EXISTS {0} "
+                "ON {1}.{2} (notification_id ASC);"
+            ).format(
+                Identifier(self.notification_id_index_name),
+                Identifier(self.datastore.schema),
+                Identifier(self.events_table_name),
+            )
+        )
+
+        self.channel_name = self.events_table_name.replace(".", "_")
+        self.insert_events_statement = self.insert_events_statement + SQL(
+            " RETURNING notification_id"
+        )
+
+        self.max_notification_id_statement = SQL(
+            "SELECT MAX(notification_id) FROM {0}.{1}"
+        ).format(
+            Identifier(self.datastore.schema),
+            Identifier(self.events_table_name),
+        )
+
+        self.lock_table_statements = [
+            SQL("SET LOCAL lock_timeout = '{0}s'").format(self.datastore.lock_timeout),
+            SQL("LOCK TABLE {0}.{1} IN EXCLUSIVE MODE").format(
+                Identifier(self.datastore.schema),
+                Identifier(self.events_table_name),
             ),
         ]
 
     @retry((InterfaceError, OperationalError), max_attempts=10, wait=0.2)
     def select_notifications(
         self,
-        start: int,
+        start: int | None,
         limit: int,
         stop: int | None = None,
         topics: Sequence[str] = (),
-    ) -> List[Notification]:
-        """
-        Returns a list of event notifications
+        *,
+        inclusive_of_start: bool = True,
+    ) -> list[Notification]:
+        """Returns a list of event notifications
         from 'start', limited by 'limit'.
         """
-
-        params: List[int | str | Sequence[str]] = [start]
-        statement = f"SELECT * FROM {self.events_table_name} WHERE notification_id>=%s"
+        params: list[int | str | Sequence[str]] = []
+        statement = SQL("SELECT * FROM {0}.{1}").format(
+            Identifier(self.datastore.schema),
+            Identifier(self.events_table_name),
+        )
+        has_where = False
+        if start is not None:
+            statement += SQL(" WHERE")
+            has_where = True
+            params.append(start)
+            if inclusive_of_start:
+                statement += SQL(" notification_id>=%s")
+            else:
+                statement += SQL(" notification_id>%s")
 
         if stop is not None:
+            if not has_where:
+                has_where = True
+                statement += SQL(" WHERE")
+            else:
+                statement += SQL(" AND")
+
             params.append(stop)
-            statement += " AND notification_id <= %s"
+            statement += SQL(" notification_id <= %s")
 
         if topics:
+            # Check sequence and ensure list of strings.
+            assert isinstance(topics, (tuple, list)), topics
+            topics = list(topics) if isinstance(topics, tuple) else topics
+            assert all(isinstance(t, str) for t in topics), topics
+            if not has_where:
+                statement += SQL(" WHERE")
+            else:
+                statement += SQL(" AND")
             params.append(topics)
-            statement += " AND topic = ANY(%s)"
+            statement += SQL(" topic = ANY(%s)")
 
         params.append(limit)
-        statement += " ORDER BY notification_id LIMIT %s"
+        statement += SQL(" ORDER BY notification_id LIMIT %s")
 
         connection = self.datastore.get_connection()
         with connection as conn, conn.cursor() as curs:
@@ -416,18 +498,15 @@ class PostgresApplicationRecorder(PostgresAggregateRecorder, ApplicationRecorder
             ]
 
     @retry((InterfaceError, OperationalError), max_attempts=10, wait=0.2)
-    def max_notification_id(self) -> int:
-        """
-        Returns the maximum notification ID.
-        """
-        conn: Connection[DictRow]
+    def max_notification_id(self) -> int | None:
+        """Returns the maximum notification ID."""
         with self.datastore.get_connection() as conn, conn.cursor() as curs:
             curs.execute(self.max_notification_id_statement)
             fetchone = curs.fetchone()
             assert fetchone is not None
-            return fetchone["max"] or 0
+            return fetchone["max"]
 
-    def _lock_table(self, c: Cursor[DictRow]) -> None:
+    def _lock_table(self, curs: Cursor[DictRow]) -> None:
         # Acquire "EXCLUSIVE" table lock, to serialize transactions that insert
         # stored events, so that readers don't pass over gaps that are filled in
         # later. We want each transaction that will be issued with notifications
@@ -449,70 +528,148 @@ class PostgresApplicationRecorder(PostgresAggregateRecorder, ApplicationRecorder
         # https://stackoverflow.com/questions/45866187/guarantee-monotonicity-of
         # -postgresql-serial-column-values-by-commit-order
         for lock_statement in self.lock_table_statements:
-            c.execute(lock_statement, prepare=True)
+            curs.execute(lock_statement, prepare=True)
+
+    def _notify_channel(self, curs: Cursor[DictRow]) -> None:
+        curs.execute(SQL("NOTIFY {0}").format(Identifier(self.channel_name)))
 
     def _fetch_ids_after_insert_events(
         self,
-        c: Cursor[DictRow],
-        stored_events: List[StoredEvent],
+        curs: Cursor[DictRow],
+        stored_events: list[StoredEvent],
         **kwargs: Any,
     ) -> Sequence[int] | None:
-        notification_ids: List[int] = []
+        notification_ids: list[int] = []
         len_events = len(stored_events)
         if len_events:
-            if (
-                (c.statusmessage == "SET")
-                and c.nextset()
-                and (c.statusmessage == "LOCK TABLE")
-            ):
-                while c.nextset() and len(notification_ids) != len_events:
-                    row = c.fetchone()
+            while curs.nextset() and len(notification_ids) != len_events:
+                if curs.statusmessage and curs.statusmessage.startswith("INSERT"):
+                    row = curs.fetchone()
                     assert row is not None
                     notification_ids.append(row["notification_id"])
             if len(notification_ids) != len(stored_events):
-                msg = "Couldn't get all notification IDs"
+                msg = "Couldn't get all notification IDs "
+                msg += f"(got {len(notification_ids)}, expected {len(stored_events)})"
                 raise ProgrammingError(msg)
         return notification_ids
 
+    def subscribe(
+        self, gt: int | None = None, topics: Sequence[str] = ()
+    ) -> Subscription[ApplicationRecorder]:
+        return PostgresSubscription(recorder=self, gt=gt, topics=topics)
+
+
+class PostgresSubscription(ListenNotifySubscription[PostgresApplicationRecorder]):
+    def __init__(
+        self,
+        recorder: PostgresApplicationRecorder,
+        gt: int | None = None,
+        topics: Sequence[str] = (),
+    ) -> None:
+        assert isinstance(recorder, PostgresApplicationRecorder)
+        super().__init__(recorder=recorder, gt=gt, topics=topics)
+        self._listen_thread = Thread(target=self._listen)
+        self._listen_thread.start()
 
-class PostgresProcessRecorder(PostgresApplicationRecorder, ProcessRecorder):
+    def __exit__(self, *args: object, **kwargs: Any) -> None:
+        super().__exit__(*args, **kwargs)
+        self._listen_thread.join()
+
+    def _listen(self) -> None:
+        try:
+            with self._recorder.datastore.get_connection() as conn:
+                conn.execute(
+                    SQL("LISTEN {0}").format(Identifier(self._recorder.channel_name))
+                )
+                while not self._has_been_stopped and not self._thread_error:
+                    # This block simplifies psycopg's conn.notifies(), because
+                    # we aren't interested in the actual notify messages, and
+                    # also we want to stop consuming notify messages when the
+                    # subscription has an error or is otherwise stopped.
+                    with conn.lock:
+                        try:
+                            if conn.wait(notifies(conn.pgconn), interval=0.1):
+                                self._has_been_notified.set()
+                        except NO_TRACEBACK as ex:  # pragma: no cover
+                            raise ex.with_traceback(None) from None
+
+        except BaseException as e:
+            if self._thread_error is None:
+                self._thread_error = e
+            self.stop()
+
+
+class PostgresTrackingRecorder(PostgresRecorder, TrackingRecorder):
     def __init__(
         self,
         datastore: PostgresDatastore,
-        events_table_name: str,
-        tracking_table_name: str,
+        *,
+        tracking_table_name: str = "notification_tracking",
+        **kwargs: Any,
     ):
-        self.check_table_name_length(tracking_table_name, datastore.schema)
+        super().__init__(datastore, **kwargs)
+        self.check_table_name_length(tracking_table_name)
         self.tracking_table_name = tracking_table_name
-        super().__init__(datastore, events_table_name)
-        self.insert_tracking_statement = (
-            f"INSERT INTO {self.tracking_table_name} VALUES (%s, %s)"
+        self.create_table_statements.append(
+            SQL(
+                "CREATE TABLE IF NOT EXISTS {0}.{1} ("
+                "application_name text, "
+                "notification_id bigint, "
+                "PRIMARY KEY "
+                "(application_name, notification_id))"
+            ).format(
+                Identifier(self.datastore.schema),
+                Identifier(self.tracking_table_name),
+            )
         )
-        self.max_tracking_id_statement = (
-            "SELECT MAX(notification_id) "
-            f"FROM {self.tracking_table_name} "
-            "WHERE application_name=%s"
+
+        self.insert_tracking_statement = SQL(
+            "INSERT INTO {0}.{1} VALUES (%s, %s)"
+        ).format(
+            Identifier(self.datastore.schema),
+            Identifier(self.tracking_table_name),
         )
-        self.count_tracking_id_statement = (
-            "SELECT COUNT(*) "
-            f"FROM {self.tracking_table_name} "
+
+        self.max_tracking_id_statement = SQL(
+            "SELECT MAX(notification_id) FROM {0}.{1} WHERE application_name=%s"
+        ).format(
+            Identifier(self.datastore.schema),
+            Identifier(self.tracking_table_name),
+        )
+
+        self.count_tracking_id_statement = SQL(
+            "SELECT COUNT(*) FROM {0}.{1} "
             "WHERE application_name=%s AND notification_id=%s"
+        ).format(
+            Identifier(self.datastore.schema),
+            Identifier(self.tracking_table_name),
         )
 
-    def construct_create_table_statements(self) -> List[str]:
-        statements = super().construct_create_table_statements()
-        statements.append(
-            "CREATE TABLE IF NOT EXISTS "
-            f"{self.tracking_table_name} ("
-            "application_name text, "
-            "notification_id bigint, "
-            "PRIMARY KEY "
-            "(application_name, notification_id))"
+    @retry((InterfaceError, OperationalError), max_attempts=10, wait=0.2)
+    def insert_tracking(self, tracking: Tracking) -> None:
+        with (
+            self.datastore.get_connection() as conn,
+            conn.transaction(),
+            conn.cursor() as curs,
+        ):
+            self._insert_tracking(curs, tracking)
+
+    def _insert_tracking(
+        self,
+        curs: Cursor[DictRow],
+        tracking: Tracking,
+    ) -> None:
+        curs.execute(
+            query=self.insert_tracking_statement,
+            params=(
+                tracking.application_name,
+                tracking.notification_id,
+            ),
+            prepare=True,
         )
-        return statements
 
     @retry((InterfaceError, OperationalError), max_attempts=10, wait=0.2)
-    def max_tracking_id(self, application_name: str) -> int:
+    def max_tracking_id(self, application_name: str) -> int | None:
         with self.datastore.get_connection() as conn, conn.cursor() as curs:
             curs.execute(
                 query=self.max_tracking_id_statement,
@@ -521,11 +678,14 @@ class PostgresProcessRecorder(PostgresApplicationRecorder, ProcessRecorder):
             )
             fetchone = curs.fetchone()
             assert fetchone is not None
-            return fetchone["max"] or 0
+            return fetchone["max"]
 
     @retry((InterfaceError, OperationalError), max_attempts=10, wait=0.2)
-    def has_tracking_id(self, application_name: str, notification_id: int) -> bool:
-        conn: Connection[DictRow]
+    def has_tracking_id(
+        self, application_name: str, notification_id: int | None
+    ) -> bool:
+        if notification_id is None:
+            return True
         with self.datastore.get_connection() as conn, conn.cursor() as curs:
             curs.execute(
                 query=self.count_tracking_id_statement,
@@ -536,26 +696,43 @@ class PostgresProcessRecorder(PostgresApplicationRecorder, ProcessRecorder):
             assert fetchone is not None
             return bool(fetchone["count"])
 
+
+TPostgresTrackingRecorder = TypeVar(
+    "TPostgresTrackingRecorder",
+    bound=PostgresTrackingRecorder,
+    default=PostgresTrackingRecorder,
+)
+
+
+class PostgresProcessRecorder(
+    PostgresTrackingRecorder, PostgresApplicationRecorder, ProcessRecorder
+):
+    def __init__(
+        self,
+        datastore: PostgresDatastore,
+        *,
+        events_table_name: str = "stored_events",
+        tracking_table_name: str = "notification_tracking",
+    ):
+        super().__init__(
+            datastore,
+            tracking_table_name=tracking_table_name,
+            events_table_name=events_table_name,
+        )
+
     def _insert_events(
         self,
-        c: Cursor[DictRow],
-        stored_events: List[StoredEvent],
+        curs: Cursor[DictRow],
+        stored_events: list[StoredEvent],
         **kwargs: Any,
     ) -> None:
-        tracking: Tracking | None = kwargs.get("tracking", None)
+        tracking: Tracking | None = kwargs.get("tracking")
         if tracking is not None:
-            c.execute(
-                query=self.insert_tracking_statement,
-                params=(
-                    tracking.application_name,
-                    tracking.notification_id,
-                ),
-                prepare=True,
-            )
-        super()._insert_events(c, stored_events, **kwargs)
+            self._insert_tracking(curs, tracking=tracking)
+        super()._insert_events(curs, stored_events, **kwargs)
 
 
-class Factory(InfrastructureFactory):
+class PostgresFactory(InfrastructureFactory[PostgresTrackingRecorder]):
     POSTGRES_DBNAME = "POSTGRES_DBNAME"
     POSTGRES_HOST = "POSTGRES_HOST"
     POSTGRES_PORT = "POSTGRES_PORT"
@@ -577,6 +754,7 @@ class Factory(InfrastructureFactory):
 
     aggregate_recorder_class = PostgresAggregateRecorder
     application_recorder_class = PostgresApplicationRecorder
+    tracking_recorder_class = PostgresTrackingRecorder
     process_recorder_class = PostgresProcessRecorder
 
     def __init__(self, env: Environment):
@@ -588,6 +766,10 @@ class Factory(InfrastructureFactory):
                 "in environment with key "
                 f"'{self.POSTGRES_DBNAME}'"
             )
+            # TODO: Indicate both keys here, also for other environment variables.
+            # ) + " or ".join(
+            #   [f"'{key}'" for key in self.env.create_keys(self.POSTGRES_DBNAME)]
+            # )
             raise OSError(msg)
 
         host = self.env.get(self.POSTGRES_HOST)
@@ -753,8 +935,6 @@ class Factory(InfrastructureFactory):
     def aggregate_recorder(self, purpose: str = "events") -> AggregateRecorder:
         prefix = self.env.name.lower() or "stored"
         events_table_name = prefix + "_" + purpose
-        if self.datastore.schema:
-            events_table_name = f"{self.datastore.schema}.{events_table_name}"
         recorder = type(self).aggregate_recorder_class(
             datastore=self.datastore,
             events_table_name=events_table_name,
@@ -766,9 +946,16 @@ class Factory(InfrastructureFactory):
     def application_recorder(self) -> ApplicationRecorder:
         prefix = self.env.name.lower() or "stored"
         events_table_name = prefix + "_events"
-        if self.datastore.schema:
-            events_table_name = f"{self.datastore.schema}.{events_table_name}"
-        recorder = type(self).application_recorder_class(
+        application_recorder_topic = self.env.get(self.APPLICATION_RECORDER_TOPIC)
+        if application_recorder_topic:
+            application_recorder_class: type[PostgresApplicationRecorder] = (
+                resolve_topic(application_recorder_topic)
+            )
+            assert issubclass(application_recorder_class, PostgresApplicationRecorder)
+        else:
+            application_recorder_class = type(self).application_recorder_class
+
+        recorder = application_recorder_class(
             datastore=self.datastore,
             events_table_name=events_table_name,
         )
@@ -776,15 +963,45 @@ class Factory(InfrastructureFactory):
             recorder.create_table()
         return recorder
 
+    def tracking_recorder(
+        self, tracking_recorder_class: type[TPostgresTrackingRecorder] | None = None
+    ) -> TPostgresTrackingRecorder:
+        prefix = self.env.name.lower() or "notification"
+        tracking_table_name = prefix + "_tracking"
+        if tracking_recorder_class is None:
+            tracking_recorder_topic = self.env.get(self.TRACKING_RECORDER_TOPIC)
+            if tracking_recorder_topic:
+                tracking_recorder_class = resolve_topic(tracking_recorder_topic)
+            else:
+                tracking_recorder_class = cast(
+                    "type[TPostgresTrackingRecorder]",
+                    type(self).tracking_recorder_class,
+                )
+        assert tracking_recorder_class is not None
+        assert issubclass(tracking_recorder_class, PostgresTrackingRecorder)
+        recorder = tracking_recorder_class(
+            datastore=self.datastore,
+            tracking_table_name=tracking_table_name,
+        )
+        if self.env_create_table():
+            recorder.create_table()
+        return recorder
+
     def process_recorder(self) -> ProcessRecorder:
         prefix = self.env.name.lower() or "stored"
         events_table_name = prefix + "_events"
         prefix = self.env.name.lower() or "notification"
         tracking_table_name = prefix + "_tracking"
-        if self.datastore.schema:
-            events_table_name = f"{self.datastore.schema}.{events_table_name}"
-            tracking_table_name = f"{self.datastore.schema}.{tracking_table_name}"
-        recorder = type(self).process_recorder_class(
+        process_recorder_topic = self.env.get(self.PROCESS_RECORDER_TOPIC)
+        if process_recorder_topic:
+            process_recorder_class: type[PostgresTrackingRecorder] = resolve_topic(
+                process_recorder_topic
+            )
+            assert issubclass(process_recorder_class, PostgresProcessRecorder)
+        else:
+            process_recorder_class = type(self).process_recorder_class
+
+        recorder = process_recorder_class(
             datastore=self.datastore,
             events_table_name=events_table_name,
             tracking_table_name=tracking_table_name,
@@ -794,8 +1011,8 @@ class Factory(InfrastructureFactory):
         return recorder
 
     def close(self) -> None:
-        if hasattr(self, "datastore"):
+        with contextlib.suppress(AttributeError):
             self.datastore.close()
 
-    def __del__(self) -> None:
-        self.close()
+
+Factory = PostgresFactory