mostlyright-data 0.17.8__tar.gz → 0.18.0__tar.gz

{mostlyright_data-0.17.8 → mostlyright_data-0.18.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mostlyright-data
-Version: 0.17.8
+Version: 0.18.0
 Summary: Mostly Right CLI for reproducible, reviewed Parquet datasets
 Project-URL: Homepage, https://mostlyright.md/
 Project-URL: Documentation, https://mostlyright.md/docs/guides/cli/

{mostlyright_data-0.17.8 → mostlyright_data-0.18.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "mostlyright-data"
-version = "0.17.8"
+version = "0.18.0"
 description = "Mostly Right CLI for reproducible, reviewed Parquet datasets"
 readme = "README.md"
 requires-python = ">=3.13,<3.14"

{mostlyright_data-0.17.8 → mostlyright_data-0.18.0}/src/mostlyright/data_harness/hosted_stream_recorder_job.py

@@ -284,7 +284,10 @@ _JOB_OPTIONAL_KEYS = frozenset(
 )
 
 _MODES = frozenset({"probe", "capture"})
-_MAX_MEMBERS = 32
+# The most members one bounded recorder Job may name.  The thin client restates it and a
+# cross-repo test holds the two equal, because a client that admits more than the worker
+# does is a round trip spent on a refusal the caller could have been told about at once.
+_MAX_MEMBERS = 256
 
 # The hard ceilings keep a malformed or compromised dispatch from turning a sample into an
 # unbounded process.  They are deliberately separate from ``until``: a completion may claim only
@@ -299,7 +302,7 @@ _BUCKET = re.compile(r"[a-z0-9][a-z0-9._-]{1,61}[a-z0-9]\Z")
 _OBJECT_PREFIX = re.compile(r"[a-z0-9][A-Za-z0-9._/-]{0,255}\Z")
 _CONNECTOR_ID = re.compile(r"[a-z][a-z0-9.-]{0,127}\Z")
 _SERIES_ID = re.compile(r"[a-z][a-z0-9-]{0,63}\Z")
-_MEMBER_ID = re.compile(r"[A-Za-z0-9][A-Za-z0-9._:-]{0,255}\Z")
+_MEMBER_ID = re.compile(r"[A-Za-z0-9][A-Za-z0-9._:@/-]{0,255}\Z")
 _RFC3339 = re.compile(r"[0-9]{4}-[0-9]{2}-[0-9]{2}T[0-9]{2}:[0-9]{2}:[0-9]{2}(?:\.[0-9]{1,6})?Z\Z")
 
 #: The two message classes a probe report counts as admitted, and the one it counts as ignored.

{mostlyright_data-0.17.8 → mostlyright_data-0.18.0}/src/mostlyright/data_harness/hosted_stream_subscription_worker.py

@@ -25,6 +25,7 @@ import sys
 import tempfile
 import time
 from collections.abc import Callable, Mapping, Sequence
+from concurrent.futures import ThreadPoolExecutor
 from dataclasses import dataclass
 from pathlib import Path
 from typing import Any, Protocol
@@ -77,6 +78,7 @@ from mostlyright.data_harness.stream_subscription_feed import (
 )
 from mostlyright.data_harness.stream_subscription_sealer import GCSSubscriptionSealer
 from mostlyright.data_harness.stream_subscription_worker import (
+    DISCOVERY_TOTAL_TIMEOUT_SECONDS,
     MAX_ACTIVE_SUBSCRIPTIONS,
     ClaimedSubscription,
     ContinuousSubscriptionWorker,
@@ -86,11 +88,14 @@ from mostlyright.data_harness.stream_subscription_worker import (
     SubscriptionFeed,
     install_shutdown_handlers,
     require_policy_serviceable,
+    subscription_executor_workers,
     utc_now,
 )
 from mostlyright.data_harness.stream_venue import StreamVenueError, materialize_connector_registry
 from mostlyright.data_harness.studio_subscription_control import StudioSubscriptionControl
 
+LOGGER = logging.getLogger(__name__)
+
 WORK_ROOT_ENV = "MOSTLYRIGHT_STREAM_SUBSCRIPTION_WORK_ROOT"
 MAX_ACTIVE_ENV = "MOSTLYRIGHT_STREAM_SUBSCRIPTION_MAX_ACTIVE"
 HEARTBEAT_SECONDS_ENV = "MOSTLYRIGHT_STREAM_SUBSCRIPTION_HEARTBEAT_SECONDS"
@@ -115,6 +120,15 @@ MAX_HEARTBEAT_SECONDS = 300.0
 MAX_IDLE_POLL_SECONDS = 60.0
 MAX_CONTROL_RESPONSE_BYTES = 768 * 1024
 
+#: What this executable exits with when the worker asked to be REPLACED rather than stopped.
+#:
+#: 75, ``EX_TEMPFAIL``: the condition is temporary in the only sense that matters here -- a fresh
+#: process does not have this one's abandoned threads -- and the value is non-zero, which is the
+#: part Cloud Run reads. A clean SIGTERM drain still exits 0; only a worker that called
+#: ``ContinuousSubscriptionWorker.request_restart`` reaches this, and today exactly one refusal
+#: calls it: ``STREAM_SUBSCRIPTION_REGISTRY_POOL_EXHAUSTED``.
+RESTART_EXIT_CODE = 75
+
 
 class HostedStreamSubscriptionWorkerError(RuntimeError):
     """A safe front-door refusal for the long-lived Worker Pool process."""
@@ -236,7 +250,7 @@ class ProductionSubscriptionFeedResolver:
             )
             return _CredentialClosingConnection(current.connection, credential)
 
-        def subscribe(cursor: str | None) -> str:
+        def subscribe(cursor: str | None) -> tuple[str, ...]:
             if current is None:
                 raise StreamSubscriptionError(
                     "STREAM_SUBSCRIPTION_FEED_INVALID",
@@ -254,6 +268,7 @@ class ProductionSubscriptionFeedResolver:
             open_connection=open_connection,
             subscribe=subscribe,
             reconnect_due=reconnect_due,
+            subscription_id=claim.stream_subscription_id,
         )
 
 
@@ -489,7 +504,7 @@ def _production_discovery_transport(config: StreamSeriesConfig) -> DiscoveryTran
             max_ranges=1,
             connect_timeout_seconds=5.0,
             read_timeout_seconds=30.0,
-            total_timeout_seconds=45.0,
+            total_timeout_seconds=DISCOVERY_TOTAL_TIMEOUT_SECONDS,
             max_concurrency=1,
             allowed_media_types=("application/json",),
         ),
@@ -641,18 +656,64 @@ def build_worker(
     )
 
 
+def size_default_executor(max_active_subscriptions: int) -> int:
+    """Give this process an executor sized for the claims it may hold, and say how big.
+
+    **THE DEFAULT IS SIX THREADS ON THIS CONTAINER AND NOTHING IN THE PROCESS SAID SO.** Every
+    ``asyncio.to_thread`` in the recorder -- the roster read, the roster tick, materializing the
+    registry that opens a feed -- draws from the loop's default executor, which Python sizes at
+    ``min(32, cpu_count + 4)`` regardless of how many subscriptions this pool admits. A burst of
+    claims filled it, and the leases that could not get a thread heartbeated healthily for
+    twenty minutes while sealing nothing. Sizing it from the declared capacity is the arithmetic
+    the shipped code was missing; the returned count is logged so the number this instance is
+    actually running on can be read off its own log rather than inferred from its vCPU.
+
+    ``asyncio.run`` shuts this executor down with the loop, so it is owned for exactly as long as
+    the worker it was sized for.
+    """
+
+    workers = subscription_executor_workers(max_active_subscriptions)
+    asyncio.get_running_loop().set_default_executor(
+        ThreadPoolExecutor(max_workers=workers, thread_name_prefix="mr-stream-subscription")
+    )
+    LOGGER.info(
+        "stream_subscription_executor_sized max_active_subscriptions=%s executor_threads=%s",
+        max_active_subscriptions,
+        workers,
+    )
+    return workers
+
+
 async def run_subscription_worker(
     config: SubscriptionWorkerRuntimeConfig,
     **dependencies: object,
-) -> None:
-    """Run until SIGTERM/SIGINT and give the worker its bounded drain window."""
+) -> int:
+    """Run until SIGTERM/SIGINT and give the worker its bounded drain window.
+
+    The return value is this executable's exit status. A SIGTERM drain is a clean stop and
+    answers ``0``; a worker that asked to be REPLACED rather than merely stopped answers
+    :data:`RESTART_EXIT_CODE`, because Cloud Run reads a non-zero exit as an instance to start
+    again and a zero one as a job that finished.
+    """
 
+    # BEFORE the worker, not after it. `build_worker` is what constructs the adapters this
+    # process runs on, and anything one of them dispatches off the loop while it is being built
+    # would land on the inherited default executor -- the six threads this call exists to
+    # replace -- and, worse, hold a thread in a pool the very next line discards.
+    size_default_executor(config.max_active_subscriptions)
     worker = build_worker(config, **dependencies)
     restore = install_shutdown_handlers(worker)
     try:
         await worker.run()
     finally:
         restore()
+    if worker.restart_requested:
+        LOGGER.error(
+            "stream_subscription_worker_restarting exit_code=%s",
+            RESTART_EXIT_CODE,
+        )
+        return RESTART_EXIT_CODE
+    return 0
 
 
 def stream_subscription_worker_main(argv: Sequence[str] | None = None) -> int:
@@ -666,8 +727,7 @@ def stream_subscription_worker_main(argv: Sequence[str] | None = None) -> int:
             "the Worker Pool executable accepts no arguments",
         )
     config = SubscriptionWorkerRuntimeConfig.from_environment()
-    asyncio.run(run_subscription_worker(config))
-    return 0
+    return asyncio.run(run_subscription_worker(config))
 
 
 def _configure_worker_logging() -> None:
@@ -768,6 +828,7 @@ def _bounded_float(
 
 __all__ = [
     "DEFAULT_WORK_ROOT",
+    "RESTART_EXIT_CODE",
     "HostedStreamSubscriptionWorkerError",
     "ProductionSubscriptionRosterResolver",
     "SubscriptionCredentialResolver",

{mostlyright_data-0.17.8 → mostlyright_data-0.18.0}/src/mostlyright/data_harness/run_execution_v4.py

@@ -435,7 +435,7 @@ _RECORDING_BATCH_FIELDS = frozenset(
 _RECORDING_BATCH_OPTIONAL_FIELDS = frozenset({"members"})
 
 #: The most members one batch's roster may name, equal to the series grammar's own ceiling.
-MAX_RECORDING_BATCH_MEMBERS = 256
+MAX_RECORDING_BATCH_MEMBERS = 2048
 
 
 class RunExecutionError(HostedWorkerError):

{mostlyright_data-0.17.8 → mostlyright_data-0.18.0}/src/mostlyright/data_harness/sources/stream.py

@@ -68,8 +68,11 @@ STREAM_STATE_VERSION_V1 = "harness-stream-watermark.v1"
 STREAM_BATCH_ADAPTER_ID = "user.stream-batch"
 STREAM_BATCH_ADAPTER_VERSION = "1.0.0"
 # The one grammar an event name has to be in to enter the ledger.  Named once, here, because the
-# Recorder that assigns names and the ledger that admits them must not drift apart.
-EVENT_ID_GRAMMAR = re.compile(r"^[A-Za-z0-9][A-Za-z0-9._:-]{0,255}$")
+# Recorder that assigns names and the ledger that admits them must not drift apart.  It holds
+# ``@`` and ``/`` because a venue-assigned name carries whatever the venue put in it, and an
+# event name addresses nothing on a disk: the ledger scope beneath it is a separate and
+# stricter single-component grammar, and it stays exactly as strict.
+EVENT_ID_GRAMMAR = re.compile(r"^[A-Za-z0-9][A-Za-z0-9._:@/-]{0,255}$")
 _EVENT_ID = EVENT_ID_GRAMMAR
 # ONE MILLION, RAISED FROM ONE HUNDRED THOUSAND WITH THE GRAMMAR THAT MIRRORS IT.
 #