Skip to content

Automate browser based workflows with AI

fix(SKY-11008): stop sending pooler-incompatible startup params to the DB (#6785)

Aaron Perez94038ebf0340
diff --git a/skyvern/forge/sdk/db/agent_db.py b/skyvern/forge/sdk/db/agent_db.py
index 33bea4a8c..d623d82d3 100644
--- a/skyvern/forge/sdk/db/agent_db.py
+++ b/skyvern/forge/sdk/db/agent_db.py
@@ -1,11 +1,15 @@
import asyncio
+import shlex
+from collections.abc import Mapping
from typing import Any
+from uuid import uuid4
import structlog
from sqlalchemy import (
event,
pool,
)
+from sqlalchemy.engine import make_url
from sqlalchemy.exc import (
SQLAlchemyError,
)
@@ -39,6 +43,253 @@ from skyvern.forge.sdk.trace import traced
LOG = structlog.get_logger()
+# Transaction-pooler compatibility is intentionally scoped to standard :6543 deployments.
+TRANSACTION_POOLER_PORT = 6543
+_ENFORCING_SSL_MODES = frozenset({"require", "verify-ca", "verify-full"})
+
+
+def _query_values(query: Mapping[str, "str | tuple[str, ...]"], key: str) -> tuple[str, ...]:
+ value = query.get(key)
+ if value is None:
+ return ()
+ values = value if isinstance(value, tuple) else (value,)
+ return tuple(part for item in values for part in item.split(",") if part)
+
+
+def _parse_port(port: str) -> int | None:
+ try:
+ return int(port)
+ except ValueError:
+ return None
+
+
+def _query_host_port(host: str) -> int | None:
+ if host.startswith("["):
+ _, separator, port = host.rpartition("]:")
+ if not separator:
+ return None
+ return _parse_port(port)
+
+ _, separator, port = host.rpartition(":")
+ if not separator:
+ return None
+ return _parse_port(port)
+
+
+def _query_targets_transaction_pooler(query: Mapping[str, "str | tuple[str, ...]"]) -> bool:
+ # Startup args cannot vary by fallback target, so use pooler-safe args if any
+ # query-level fallback host may connect through the transaction pooler.
+ host_ports = (_query_host_port(host) for host in _query_values(query, "host"))
+ query_ports = (_parse_port(port) for port in _query_values(query, "port"))
+ return TRANSACTION_POOLER_PORT in host_ports or TRANSACTION_POOLER_PORT in query_ports
+
+
+def _query_pins_every_host_port(query: Mapping[str, "str | tuple[str, ...]"]) -> bool:
+ # A query host without its own port inherits the authority port, so the authority
+ # port only stops being a target when every query host names a port itself.
+ hosts = _query_values(query, "host")
+ if not hosts:
+ return False
+ if _query_values(query, "port"):
+ return True
+ return all(_query_host_port(host) is not None for host in hosts)
+
+
+def _is_transaction_pooler(database_string: str) -> bool:
+ try:
+ database_url = make_url(database_string)
+ except Exception:
+ return False
+ if _query_targets_transaction_pooler(database_url.query):
+ return True
+ if _query_pins_every_host_port(database_url.query):
+ return False
+ return database_url.port == TRANSACTION_POOLER_PORT
+
+
+def _query_last_value(query: Mapping[str, "str | tuple[str, ...]"], key: str) -> str | None:
+ value = query.get(key)
+ if isinstance(value, tuple):
+ value = value[-1] if value else None
+ return value
+
+
+def _has_enforcing_ssl(query: Mapping[str, "str | tuple[str, ...]"], key: str) -> bool:
+ value = _query_last_value(query, key)
+ return value in _ENFORCING_SSL_MODES
+
+
+def _require_pooler_ssl(
+ connect_args: dict[str, Any],
+ query: Mapping[str, "str | tuple[str, ...]"],
+ key: str,
+ query_keys: tuple[str, ...] | None = None,
+) -> None:
+ query_keys = query_keys or (key,)
+ if any(_has_enforcing_ssl(query, query_key) for query_key in query_keys):
+ return
+
+ connect_args[key] = "require"
+ overridden_key = None
+ overridden_value = None
+ for query_key in query_keys:
+ overridden_value = _query_last_value(query, query_key)
+ if overridden_value is not None:
+ overridden_key = query_key
+ break
+
+ if overridden_key is not None and overridden_value is not None:
+ LOG.debug(
+ "Overriding non-enforcing Postgres pooler SSL mode",
+ ssl_key=overridden_key,
+ ssl_mode=overridden_value,
+ required_ssl_mode="require",
+ )
+
+
+def _postgres_options(query: Mapping[str, "str | tuple[str, ...]"]) -> str | None:
+ existing_options = query.get("options")
+ if isinstance(existing_options, tuple):
+ existing_options = " ".join(existing_options)
+ return existing_options
+
+
+def _direct_psycopg_options(query: Mapping[str, "str | tuple[str, ...]"]) -> str:
+ timeout_option = f"-c statement_timeout={settings.DATABASE_STATEMENT_TIMEOUT_MS}"
+ existing_options = _postgres_options(query)
+ if existing_options:
+ return f"{existing_options} {timeout_option}"
+ return timeout_option
+
+
+def _postgres_options_server_settings(query: Mapping[str, "str | tuple[str, ...]"]) -> dict[str, str]:
+ options = _postgres_options(query)
+ if not options:
+ return {}
+
+ try:
+ option_parts = shlex.split(options)
+ except ValueError:
+ return {}
+
+ server_settings: dict[str, str] = {}
+ index = 0
+ while index < len(option_parts):
+ option = option_parts[index]
+ setting = None
+ if option == "-c" and index + 1 < len(option_parts):
+ index += 1
+ setting = option_parts[index]
+ elif option.startswith("-c") and len(option) > 2:
+ setting = option[2:]
+
+ if setting and "=" in setting:
+ key, value = setting.split("=", 1)
+ if key:
+ server_settings[key] = value
+ index += 1
+
+ return server_settings
+
+
+def _direct_asyncpg_server_settings(query: Mapping[str, "str | tuple[str, ...]"]) -> dict[str, str]:
+ server_settings = _postgres_options_server_settings(query)
+ server_settings["statement_timeout"] = str(settings.DATABASE_STATEMENT_TIMEOUT_MS)
+ return server_settings
+
+
+def _asyncpg_prepared_statement_name() -> str:
+ return f"__asyncpg_{uuid4()}__"
+
+
+def _postgres_connect_args(database_string: str) -> dict[str, Any]:
+ connect_args: dict[str, Any] = {}
+ try:
+ database_url = make_url(database_string)
+ except Exception:
+ database_url = None
+
+ drivername = database_url.drivername if database_url else ""
+ is_psycopg = drivername in {"postgresql+psycopg", "postgresql+psycopg_async"}
+ is_asyncpg = drivername == "postgresql+asyncpg"
+
+ if not _is_transaction_pooler(database_string):
+ if is_psycopg:
+ connect_args["options"] = _direct_psycopg_options(database_url.query if database_url else {})
+ if is_asyncpg:
+ connect_args["server_settings"] = _direct_asyncpg_server_settings(
+ database_url.query if database_url else {}
+ )
+ return connect_args
+
+ existing_query = database_url.query if database_url else {}
+ if is_psycopg:
+ connect_args["prepare_threshold"] = None
+ _require_pooler_ssl(connect_args, existing_query, "sslmode")
+ if is_asyncpg:
+ # Disable both asyncpg's native prepared-statement cache and SQLAlchemy's
+ # own per-connection cache; either one reuses prepared statements across
+ # pooled server connections, which the transaction pooler can't honor.
+ connect_args["statement_cache_size"] = 0
+ connect_args["prepared_statement_cache_size"] = 0
+ # SQLAlchemy/asyncpg call this zero-arg hook for each prepared statement.
+ connect_args["prepared_statement_name_func"] = _asyncpg_prepared_statement_name
+ _require_pooler_ssl(connect_args, existing_query, "ssl", query_keys=("ssl", "sslmode"))
+ return connect_args
+
+
+def _normalize_asyncpg_ssl_query(database_string: str, connect_args: dict[str, Any]) -> str:
+ try:
+ database_url = make_url(database_string)
+ except Exception:
+ return database_string
+
+ if database_url.drivername != "postgresql+asyncpg":
+ return database_string
+
+ query = dict(database_url.query)
+ sslmode = _query_last_value(query, "sslmode")
+ if sslmode is None and "ssl" not in query:
+ return database_string
+
+ if sslmode is not None:
+ query.pop("sslmode", None)
+
+ if "ssl" in connect_args:
+ query.pop("ssl", None)
+ elif sslmode in _ENFORCING_SSL_MODES:
+ connect_args["ssl"] = sslmode
+ query.pop("ssl", None)
+ elif sslmode is not None and "ssl" not in query:
+ connect_args["ssl"] = sslmode
+
+ return database_url.set(query=query).render_as_string(hide_password=False)
+
+
+def _strip_postgres_options_query(database_string: str) -> str:
+ try:
+ database_url = make_url(database_string)
+ except Exception:
+ return database_string
+
+ if "options" not in database_url.query:
+ return database_string
+
+ is_psycopg = database_url.drivername in {"postgresql+psycopg", "postgresql+psycopg_async"}
+ is_asyncpg = database_url.drivername == "postgresql+asyncpg"
+ if not _is_transaction_pooler(database_string) and not (is_psycopg or is_asyncpg):
+ return database_string
+
+ query = dict(database_url.query)
+ query.pop("options", None)
+ return database_url.set(query=query).render_as_string(hide_password=False)
+
+
+def _postgres_engine_config(database_string: str) -> tuple[str, dict[str, Any]]:
+ connect_args = _postgres_connect_args(database_string)
+ database_string = _strip_postgres_options_query(database_string)
+ return _normalize_asyncpg_ssl_query(database_string, connect_args), connect_args
+
def _build_engine(database_string: str) -> AsyncEngine:
"""
@@ -47,11 +298,10 @@ def _build_engine(database_string: str) -> AsyncEngine:
Supports both PostgreSQL and SQLite (via aiosqlite) dialects.
PostgreSQL behaviour:
- When DISABLE_CONNECTION_POOL=True (NullPool): enforce statement_timeout
- and allow prepared statements.
- When DISABLE_CONNECTION_POOL=False (QueuePool): disable prepared statements
- and do not set statement_timeout - set at role level in the database,
- since the transaction pooler does not maintain session-level settings.
+ Connect args are chosen by the connection target (see _postgres_connect_args):
+ transaction poolers get SSL + no prepared statements + no startup options,
+ direct connections get a session statement_timeout. DISABLE_CONNECTION_POOL
+ independently selects NullPool (True) vs QueuePool (False).
SQLite behaviour:
For :memory: databases, uses StaticPool to keep the single connection alive.
@@ -81,12 +331,8 @@ def _build_engine(database_string: str) -> AsyncEngine:
return engine
- connect_args: dict[str, Any] = {}
+ database_string, connect_args = _postgres_engine_config(database_string)
if settings.DISABLE_CONNECTION_POOL:
- if "postgresql+psycopg" in database_string:
- connect_args["options"] = f"-c statement_timeout={settings.DATABASE_STATEMENT_TIMEOUT_MS}"
- if "postgresql+asyncpg" in database_string:
- connect_args["server_settings"] = {"statement_timeout": str(settings.DATABASE_STATEMENT_TIMEOUT_MS)}
return create_async_engine(
database_string,
json_serializer=_custom_json_serializer,
@@ -94,19 +340,14 @@ def _build_engine(database_string: str) -> AsyncEngine:
poolclass=pool.NullPool,
)
- else:
- if "postgresql+psycopg" in database_string:
- connect_args["prepare_threshold"] = None
- if "postgresql+asyncpg" in database_string:
- connect_args["statement_cache_size"] = 0
- return create_async_engine(
- database_string,
- json_serializer=_custom_json_serializer,
- connect_args=connect_args,
- pool_pre_ping=True,
- pool_size=settings.DATABASE_POOL_SIZE,
- max_overflow=settings.DATABASE_POOL_MAX_OVERFLOW,
- )
+ return create_async_engine(
+ database_string,
+ json_serializer=_custom_json_serializer,
+ connect_args=connect_args,
+ pool_pre_ping=True,
+ pool_size=settings.DATABASE_POOL_SIZE,
+ max_overflow=settings.DATABASE_POOL_MAX_OVERFLOW,
+ )
__all__ = ["AgentDB", "ScheduleLimitExceededError"]
diff --git a/tests/unit/test_db_engine_connect_args.py b/tests/unit/test_db_engine_connect_args.py
new file mode 100644
index 000000000..02f2af3ae
--- /dev/null
+++ b/tests/unit/test_db_engine_connect_args.py
@@ -0,0 +1,429 @@
+"""Postgres engine connect-arg selection.
+
+The args that a Postgres transaction pooler on :6543 tolerates are determined
+by the connection *target*, not by SQLAlchemy's pool class. Regression cover for
+the pooler `unsupported startup parameter: options` and `SSL required` failures.
+"""
+
+from collections.abc import Callable
+from typing import Any, cast
+
+import pytest
+from sqlalchemy import pool
+from sqlalchemy.engine import make_url
+
+from skyvern.config import settings
+from skyvern.forge.sdk.db import agent_db
+from skyvern.forge.sdk.db.agent_db import _is_transaction_pooler, _postgres_connect_args
+
+POOLER_PSYCOPG = "postgresql+psycopg://user:[email protected]:6543/postgres"
+DIRECT_PSYCOPG = "postgresql+psycopg://user:[email protected]:5432/postgres"
+POOLER_ASYNCPG = "postgresql+asyncpg://user:[email protected]:6543/postgres"
+DIRECT_ASYNCPG = "postgresql+asyncpg://user:[email protected]:5432/postgres"
+POOLER_PSYCOPG2 = "postgresql+psycopg2://user:[email protected]:6543/postgres"
+MULTI_HOST_POOLER_PSYCOPG = "postgresql+psycopg://user:pass@/postgres?host=pooler-a:6543&host=pooler-b:6543"
+MULTI_HOST_POOLER_ASYNCPG = "postgresql+asyncpg://user:pass@/postgres?host=pooler-a:6543&host=pooler-b:6543"
+MULTI_HOST_DIRECT_ASYNCPG = "postgresql+asyncpg://user:pass@/postgres?host=db-a:5432&host=db-b:5432"
+COMMA_MULTI_HOST_POOLER_ASYNCPG = "postgresql+asyncpg://user:pass@/postgres?host=pooler-a,pooler-b&port=6543,6543"
+COMMA_MULTI_HOST_DIRECT_ASYNCPG = "postgresql+asyncpg://user:pass@/postgres?host=db-a,db-b&port=5432,5432"
+AUTHORITY_POOLER_QUERY_DIRECT_PSYCOPG = (
+ "postgresql+psycopg://user:[email protected]:6543/postgres?host=db-a:5432&host=db-b:5432"
+)
+AUTHORITY_POOLER_QUERY_DIRECT_ASYNCPG = (
+ "postgresql+asyncpg://user:[email protected]:6543/postgres?host=db-a:5432&host=db-b:5432"
+)
+POOLER_PSYCOPG_ASYNC = "postgresql+psycopg_async://user:[email protected]:6543/postgres"
+DIRECT_PSYCOPG_ASYNC = "postgresql+psycopg_async://user:[email protected]:5432/postgres"
+
+
+ "url, expected",
+ [
+ (POOLER_PSYCOPG, True),
+ (POOLER_ASYNCPG, True),
+ (MULTI_HOST_POOLER_PSYCOPG, True),
+ (MULTI_HOST_POOLER_ASYNCPG, True),
+ ("postgresql+asyncpg://user:pass@/postgres?host=pooler-a&host=pooler-b&port=6543", True),
+ (COMMA_MULTI_HOST_POOLER_ASYNCPG, True),
+ (POOLER_PSYCOPG_ASYNC, True),
+ (DIRECT_PSYCOPG, False),
+ (DIRECT_ASYNCPG, False),
+ (MULTI_HOST_DIRECT_ASYNCPG, False),
+ (COMMA_MULTI_HOST_DIRECT_ASYNCPG, False),
+ (AUTHORITY_POOLER_QUERY_DIRECT_PSYCOPG, False),
+ (AUTHORITY_POOLER_QUERY_DIRECT_ASYNCPG, False),
+ ("postgresql+psycopg://user:pass@h:6543/postgres?host=pooler", True),
+ ("postgresql+asyncpg://user:pass@h:6543/postgres?host=pooler", True),
+ ("postgresql+asyncpg://user:pass@h:6543/postgres?host=db-a:5432&host=pooler-b", True),
+ ("postgresql+asyncpg://user:pass@h:5432/postgres?host=pooler", False),
+ (DIRECT_PSYCOPG_ASYNC, False),
+ ("postgresql+psycopg://user:pass@host/postgres", False),
+ ("sqlite+aiosqlite:///:memory:", False),
+ ("not a url", False),
+ ],
+)
+def test_is_transaction_pooler(url: str, expected: bool) -> None:
+ assert _is_transaction_pooler(url) is expected
+
+
+def test_pooler_psycopg_never_sends_options() -> None:
+ """The pooler rejects the `options` startup parameter."""
+ args = _postgres_connect_args(POOLER_PSYCOPG)
+ assert "options" not in args
+ assert args["prepare_threshold"] is None
+ assert args["sslmode"] == "require"
+
+
+def test_multi_host_pooler_psycopg_never_sends_options() -> None:
+ args = _postgres_connect_args(MULTI_HOST_POOLER_PSYCOPG)
+ assert "options" not in args
+ assert args["prepare_threshold"] is None
+ assert args["sslmode"] == "require"
+
+
+def test_pooler_psycopg_async_never_sends_options() -> None:
+ args = _postgres_connect_args(POOLER_PSYCOPG_ASYNC)
+ assert "options" not in args
+ assert args["prepare_threshold"] is None
+ assert args["sslmode"] == "require"
+
+
+def test_direct_psycopg_sets_statement_timeout() -> None:
+ args = _postgres_connect_args(DIRECT_PSYCOPG)
+ assert args["options"] == f"-c statement_timeout={settings.DATABASE_STATEMENT_TIMEOUT_MS}"
+ assert "sslmode" not in args
+ assert "prepare_threshold" not in args
+
+
+def test_query_host_direct_psycopg_sets_statement_timeout_when_authority_port_is_pooler() -> None:
+ args = _postgres_connect_args(AUTHORITY_POOLER_QUERY_DIRECT_PSYCOPG)
+ assert args["options"] == f"-c statement_timeout={settings.DATABASE_STATEMENT_TIMEOUT_MS}"
+ assert "sslmode" not in args
+ assert "prepare_threshold" not in args
+
+
+def test_query_host_pooler_psycopg_never_sends_options_when_authority_port_is_pooler() -> None:
+ args = _postgres_connect_args("postgresql+psycopg://user:pass@h:6543/postgres?host=pooler")
+ assert "options" not in args
+ assert args["prepare_threshold"] is None
+ assert args["sslmode"] == "require"
+
+
+def test_direct_psycopg_preserves_existing_options() -> None:
+ args = _postgres_connect_args(f"{DIRECT_PSYCOPG}?options=-c%20search_path%3Dtenant")
+ assert args["options"] == f"-c search_path=tenant -c statement_timeout={settings.DATABASE_STATEMENT_TIMEOUT_MS}"
+ assert "sslmode" not in args
+ assert "prepare_threshold" not in args
+
+
+def test_direct_psycopg_async_sets_statement_timeout() -> None:
+ args = _postgres_connect_args(DIRECT_PSYCOPG_ASYNC)
+ assert args["options"] == f"-c statement_timeout={settings.DATABASE_STATEMENT_TIMEOUT_MS}"
+ assert "sslmode" not in args
+ assert "prepare_threshold" not in args
+
+
+def test_psycopg2_url_does_not_receive_psycopg_v3_connect_args() -> None:
+ args = _postgres_connect_args(POOLER_PSYCOPG2)
+ assert args == {}
+
+
+def test_pooler_asyncpg_disables_prepared_statements_and_requires_ssl() -> None:
+ args = _postgres_connect_args(POOLER_ASYNCPG)
+ assert "server_settings" not in args
+ assert args["statement_cache_size"] == 0
+ assert args["prepared_statement_cache_size"] == 0
+ name_func = cast(Callable[[], str], args["prepared_statement_name_func"])
+ first_name = name_func()
+ second_name = name_func()
+ assert first_name != second_name
+ assert first_name.startswith("__asyncpg_")
+ assert first_name.endswith("__")
+ assert args["ssl"] == "require"
+
+
+def test_multi_host_pooler_asyncpg_uses_pooler_safe_args() -> None:
+ args = _postgres_connect_args(MULTI_HOST_POOLER_ASYNCPG)
+ assert "server_settings" not in args
+ assert args["statement_cache_size"] == 0
+ assert args["prepared_statement_cache_size"] == 0
+ assert "prepared_statement_name_func" in args
+ assert args["ssl"] == "require"
+
+
+def test_comma_multi_host_pooler_asyncpg_uses_pooler_safe_args() -> None:
+ args = _postgres_connect_args(COMMA_MULTI_HOST_POOLER_ASYNCPG)
+ assert "server_settings" not in args
+ assert args["statement_cache_size"] == 0
+ assert args["prepared_statement_cache_size"] == 0
+ assert "prepared_statement_name_func" in args
+ assert args["ssl"] == "require"
+
+
+def test_direct_asyncpg_sets_statement_timeout() -> None:
+ args = _postgres_connect_args(DIRECT_ASYNCPG)
+ assert args["server_settings"] == {"statement_timeout": str(settings.DATABASE_STATEMENT_TIMEOUT_MS)}
+ assert "ssl" not in args
+ assert "prepared_statement_name_func" not in args
+
+
+def test_query_host_direct_asyncpg_sets_statement_timeout_when_authority_port_is_pooler() -> None:
+ args = _postgres_connect_args(AUTHORITY_POOLER_QUERY_DIRECT_ASYNCPG)
+ assert args["server_settings"] == {"statement_timeout": str(settings.DATABASE_STATEMENT_TIMEOUT_MS)}
+ assert "ssl" not in args
+ assert "prepared_statement_name_func" not in args
+
+
+def test_build_engine_keeps_pool_class_selection_independent_of_connect_args(monkeypatch: pytest.MonkeyPatch) -> None:
+ calls: list[dict[str, Any]] = []
+
+ def fake_create_async_engine(database_string: str, **kwargs: Any) -> object:
+ calls.append({"database_string": database_string, "kwargs": kwargs})
+ return object()
+
+ monkeypatch.setattr(agent_db, "create_async_engine", fake_create_async_engine)
+
+ monkeypatch.setattr(settings, "DISABLE_CONNECTION_POOL", True)
+ agent_db._build_engine(POOLER_ASYNCPG)
+ disabled_kwargs = calls[-1]["kwargs"]
+
+ monkeypatch.setattr(settings, "DISABLE_CONNECTION_POOL", False)
+ agent_db._build_engine(POOLER_ASYNCPG)
+ enabled_kwargs = calls[-1]["kwargs"]
+
+ assert disabled_kwargs["poolclass"] is pool.NullPool
+ assert "poolclass" not in enabled_kwargs
+ assert disabled_kwargs["connect_args"] == enabled_kwargs["connect_args"]
+ assert disabled_kwargs["connect_args"]["prepared_statement_name_func"] is agent_db._asyncpg_prepared_statement_name
+
+
+def test_build_engine_strips_asyncpg_weak_sslmode_when_requiring_pooler_ssl(monkeypatch: pytest.MonkeyPatch) -> None:
+ calls: list[dict[str, Any]] = []
+
+ def fake_create_async_engine(database_string: str, **kwargs: Any) -> object:
+ calls.append({"database_string": database_string, "kwargs": kwargs})
+ return object()
+
+ monkeypatch.setattr(agent_db, "create_async_engine", fake_create_async_engine)
+ monkeypatch.setattr(settings, "DISABLE_CONNECTION_POOL", False)
+
+ agent_db._build_engine(f"{POOLER_ASYNCPG}?sslmode=prefer")
+
+ assert "sslmode" not in calls[-1]["database_string"]
+ assert calls[-1]["kwargs"]["connect_args"]["ssl"] == "require"
+
+
+def test_build_engine_converts_asyncpg_enforcing_sslmode_to_ssl_connect_arg(
+ monkeypatch: pytest.MonkeyPatch,
+) -> None:
+ calls: list[dict[str, Any]] = []
+
+ def fake_create_async_engine(database_string: str, **kwargs: Any) -> object:
+ calls.append({"database_string": database_string, "kwargs": kwargs})
+ return object()
+
+ monkeypatch.setattr(agent_db, "create_async_engine", fake_create_async_engine)
+ monkeypatch.setattr(settings, "DISABLE_CONNECTION_POOL", False)
+
+ agent_db._build_engine(f"{POOLER_ASYNCPG}?sslmode=verify-full")
+
+ assert "sslmode" not in calls[-1]["database_string"]
+ assert calls[-1]["kwargs"]["connect_args"]["ssl"] == "verify-full"
+
+
+def test_build_engine_removes_pooler_asyncpg_weak_ssl_and_sslmode(
+ monkeypatch: pytest.MonkeyPatch,
+) -> None:
+ calls: list[dict[str, Any]] = []
+
+ def fake_create_async_engine(database_string: str, **kwargs: Any) -> object:
+ calls.append({"database_string": database_string, "kwargs": kwargs})
+ return object()
+
+ monkeypatch.setattr(agent_db, "create_async_engine", fake_create_async_engine)
+ monkeypatch.setattr(settings, "DISABLE_CONNECTION_POOL", False)
+
+ agent_db._build_engine(f"{POOLER_ASYNCPG}?ssl=prefer&sslmode=prefer")
+
+ engine_query = make_url(calls[-1]["database_string"]).query
+ assert "ssl" not in engine_query
+ assert "sslmode" not in engine_query
+ assert calls[-1]["kwargs"]["connect_args"]["ssl"] == "require"
+
+
[email protected]("database_string", [POOLER_ASYNCPG, DIRECT_ASYNCPG])
[email protected]("strong_mode", ["require", "verify-full"])
+def test_build_engine_prefers_enforcing_asyncpg_sslmode_over_weak_ssl(
+ monkeypatch: pytest.MonkeyPatch,
+ database_string: str,
+ strong_mode: str,
+) -> None:
+ calls: list[dict[str, Any]] = []
+
+ def fake_create_async_engine(database_string: str, **kwargs: Any) -> object:
+ calls.append({"database_string": database_string, "kwargs": kwargs})
+ return object()
+
+ monkeypatch.setattr(agent_db, "create_async_engine", fake_create_async_engine)
+ monkeypatch.setattr(settings, "DISABLE_CONNECTION_POOL", False)
+
+ agent_db._build_engine(f"{database_string}?ssl=prefer&sslmode={strong_mode}")
+
+ engine_query = make_url(calls[-1]["database_string"]).query
+ connect_args = calls[-1]["kwargs"]["connect_args"]
+ assert "ssl" not in engine_query
+ assert "sslmode" not in engine_query
+ assert connect_args["ssl"] == strong_mode
+ if database_string == DIRECT_ASYNCPG:
+ assert connect_args["server_settings"] == {"statement_timeout": str(settings.DATABASE_STATEMENT_TIMEOUT_MS)}
+ else:
+ assert "server_settings" not in connect_args
+ assert connect_args["statement_cache_size"] == 0
+
+
[email protected]("sslmode", ["prefer", "verify-full"])
+def test_build_engine_converts_direct_asyncpg_sslmode_to_ssl_connect_arg(
+ monkeypatch: pytest.MonkeyPatch,
+ sslmode: str,
+) -> None:
+ calls: list[dict[str, Any]] = []
+
+ def fake_create_async_engine(database_string: str, **kwargs: Any) -> object:
+ calls.append({"database_string": database_string, "kwargs": kwargs})
+ return object()
+
+ monkeypatch.setattr(agent_db, "create_async_engine", fake_create_async_engine)
+ monkeypatch.setattr(settings, "DISABLE_CONNECTION_POOL", False)
+
+ agent_db._build_engine(f"{DIRECT_ASYNCPG}?sslmode={sslmode}")
+
+ assert "sslmode" not in make_url(calls[-1]["database_string"]).query
+ assert calls[-1]["kwargs"]["connect_args"]["ssl"] == sslmode
+ assert calls[-1]["kwargs"]["connect_args"]["server_settings"] == {
+ "statement_timeout": str(settings.DATABASE_STATEMENT_TIMEOUT_MS)
+ }
+
+
+def test_build_engine_strips_pooler_psycopg_options_from_url(monkeypatch: pytest.MonkeyPatch) -> None:
+ calls: list[dict[str, Any]] = []
+
+ def fake_create_async_engine(database_string: str, **kwargs: Any) -> object:
+ calls.append({"database_string": database_string, "kwargs": kwargs})
+ return object()
+
+ monkeypatch.setattr(agent_db, "create_async_engine", fake_create_async_engine)
+ monkeypatch.setattr(settings, "DISABLE_CONNECTION_POOL", False)
+
+ agent_db._build_engine(f"{POOLER_PSYCOPG}?options=-c%20search_path%3Dtenant")
+
+ assert "options" not in make_url(calls[-1]["database_string"]).query
+ assert "options" not in calls[-1]["kwargs"]["connect_args"]
+ assert calls[-1]["kwargs"]["connect_args"]["sslmode"] == "require"
+
+
+def test_build_engine_moves_direct_psycopg_options_to_connect_args(monkeypatch: pytest.MonkeyPatch) -> None:
+ calls: list[dict[str, Any]] = []
+
+ def fake_create_async_engine(database_string: str, **kwargs: Any) -> object:
+ calls.append({"database_string": database_string, "kwargs": kwargs})
+ return object()
+
+ monkeypatch.setattr(agent_db, "create_async_engine", fake_create_async_engine)
+ monkeypatch.setattr(settings, "DISABLE_CONNECTION_POOL", False)
+
+ agent_db._build_engine(f"{DIRECT_PSYCOPG}?options=-c%20search_path%3Dtenant")
+
+ assert "options" not in make_url(calls[-1]["database_string"]).query
+ assert (
+ calls[-1]["kwargs"]["connect_args"]["options"]
+ == f"-c search_path=tenant -c statement_timeout={settings.DATABASE_STATEMENT_TIMEOUT_MS}"
+ )
+
+
+def test_build_engine_moves_direct_asyncpg_options_to_server_settings(monkeypatch: pytest.MonkeyPatch) -> None:
+ calls: list[dict[str, Any]] = []
+
+ def fake_create_async_engine(database_string: str, **kwargs: Any) -> object:
+ calls.append({"database_string": database_string, "kwargs": kwargs})
+ return object()
+
+ monkeypatch.setattr(agent_db, "create_async_engine", fake_create_async_engine)
+ monkeypatch.setattr(settings, "DISABLE_CONNECTION_POOL", False)
+
+ agent_db._build_engine(f"{DIRECT_ASYNCPG}?options=-c%20search_path%3Dtenant")
+
+ assert "options" not in make_url(calls[-1]["database_string"]).query
+ assert calls[-1]["kwargs"]["connect_args"]["server_settings"] == {
+ "search_path": "tenant",
+ "statement_timeout": str(settings.DATABASE_STATEMENT_TIMEOUT_MS),
+ }
+
+
[email protected]("strong_mode", ["require", "verify-ca", "verify-full"])
+def test_pooler_psycopg_preserves_enforcing_sslmode(strong_mode: str) -> None:
+ args = _postgres_connect_args(f"{POOLER_PSYCOPG}?sslmode={strong_mode}")
+ assert "sslmode" not in args
+ assert args["prepare_threshold"] is None
+
+
[email protected]("ssl_query_key", ["ssl", "sslmode"])
[email protected]("strong_mode", ["require", "verify-ca", "verify-full"])
+def test_pooler_asyncpg_preserves_enforcing_ssl_modes(ssl_query_key: str, strong_mode: str) -> None:
+ args = _postgres_connect_args(f"{POOLER_ASYNCPG}?{ssl_query_key}={strong_mode}")
+ assert "ssl" not in args
+ assert args["statement_cache_size"] == 0
+ assert args["prepared_statement_cache_size"] == 0
+
+
[email protected]("weak_mode", ["disable", "allow", "prefer"])
+def test_pooler_psycopg_overrides_non_enforcing_sslmode(weak_mode: str) -> None:
+ """A non-enforcing sslmode in the URL must still be forced to require."""
+ args = _postgres_connect_args(f"{POOLER_PSYCOPG}?sslmode={weak_mode}")
+ assert args["sslmode"] == "require"
+
+
[email protected]("weak_mode", ["disable", "allow", "prefer"])
+def test_pooler_asyncpg_overrides_non_enforcing_sslmode(weak_mode: str) -> None:
+ args = _postgres_connect_args(f"{POOLER_ASYNCPG}?sslmode={weak_mode}")
+ assert args["ssl"] == "require"
+
+
[email protected]("weak_mode", ["disable", "allow", "prefer"])
+def test_pooler_asyncpg_overrides_non_enforcing_ssl(weak_mode: str) -> None:
+ args = _postgres_connect_args(f"{POOLER_ASYNCPG}?ssl={weak_mode}")
+ assert args["ssl"] == "require"
+
+
+ "url, connect_arg_key, log_ssl_key",
+ [
+ (f"{POOLER_PSYCOPG}?sslmode=prefer", "sslmode", "sslmode"),
+ (f"{POOLER_ASYNCPG}?ssl=prefer", "ssl", "ssl"),
+ (f"{POOLER_ASYNCPG}?sslmode=prefer", "ssl", "sslmode"),
+ ],
+)
+def test_pooler_logs_when_overriding_non_enforcing_ssl(
+ monkeypatch: pytest.MonkeyPatch,
+ url: str,
+ connect_arg_key: str,
+ log_ssl_key: str,
+) -> None:
+ logs: list[dict[str, Any]] = []
+
+ class FakeLogger:
+ def debug(self, message: str, **kwargs: Any) -> None:
+ logs.append({"message": message, **kwargs})
+
+ monkeypatch.setattr(agent_db, "LOG", FakeLogger())
+
+ args = _postgres_connect_args(url)
+
+ assert args[connect_arg_key] == "require"
+ assert logs == [
+ {
+ "message": "Overriding non-enforcing Postgres pooler SSL mode",
+ "ssl_key": log_ssl_key,
+ "ssl_mode": "prefer",
+ "required_ssl_mode": "require",
+ }
+ ]