reactor-runtime 2.7.0__tar.gz → 2.7.2__tar.gz

{reactor_runtime-2.7.0 → reactor_runtime-2.7.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: reactor_runtime
-Version: 2.7.0
+Version: 2.7.2
 Summary: Reactor runtime with public model API
 Author-email: Reactor <team@reactor.inc>
 Requires-Python: >=3.9

{reactor_runtime-2.7.0 → reactor_runtime-2.7.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "reactor_runtime"
-version = "2.7.0"
+version = "2.7.2"
 description = "Reactor runtime with public model API"
 authors = [
 	{ name = "Reactor", email = "team@reactor.inc" }

{reactor_runtime-2.7.0 → reactor_runtime-2.7.2}/src/reactor_runtime/recording/chunk_uploader.py

@@ -66,6 +66,13 @@ class ChunkUploader:
         # math (``chunk_idx * chunk_seconds``) and the ``/clips``
         # manifest endpoint already assume.  No translation needed.
         self._next_idx = 0
+        # Read by ``_run`` after the stop signal to decide whether the
+        # worker should drain leftover chunks before exiting.  Set by
+        # ``stop()`` *before* signalling stop so the worker reads it
+        # consistently on its way out.  See ``stop()`` docstring for
+        # why the drain has to happen on this thread rather than the
+        # caller's.
+        self._flush_on_exit = False
 
     def start(self) -> None:
         if self._thread is not None:
@@ -76,22 +83,38 @@ class ChunkUploader:
         )
         self._thread.start()
 
-    def stop(self, *, flush_remaining: bool = True, timeout: float = 5.0) -> None:
+    def stop(self, *, flush_remaining: bool = True, timeout: float = 30.0) -> bool:
         """Signal the watcher to exit; optionally drain final chunks.
 
-        Always invokes ``sink.close()`` after the drain so sinks that
-        own external resources (httpx clients, connection pools, file
-        handles) release them at the right point in the lifecycle.
-        ``close`` is invoked even when ``flush_remaining=False`` so a
-        caller that opts out of draining still releases the sink.
+        Returns ``True`` when the worker joined cleanly, ``False`` when
+        both join attempts timed out.  Always closes the sink before
+        returning.
+
+        The drain runs on the worker thread; see REA-2268.
         """
+        self._flush_on_exit = flush_remaining
         self._stop.set()
         thread = self._thread
         self._thread = None
+        clean = True
         if thread is not None:
             thread.join(timeout=timeout)
-        if flush_remaining:
-            self._drain_final()
+            if thread.is_alive():
+                # Close the sink to cancel any in-flight presign future,
+                # then give the worker a short grace window to exit.
+                self._safe_close_sink()
+                thread.join(timeout=2.0)
+                if thread.is_alive():
+                    clean = False
+                    logger.error(
+                        "ChunkUploader.stop join timed out; thread leaked",
+                        timeout_s=timeout,
+                        next_idx=self._next_idx,
+                    )
+        self._safe_close_sink()
+        return clean
+
+    def _safe_close_sink(self) -> None:
         try:
             self._sink.close()
         except Exception:
@@ -103,6 +126,12 @@ class ChunkUploader:
                 progress = self._tick()
                 if not progress:
                     self._stop.wait(self._poll_interval)
+            # Final drain happens here, in the worker thread, so the
+            # caller-side ``stop()`` doesn't accidentally drive
+            # ``run_coroutine_threadsafe(...).result()`` from the
+            # asyncio loop thread.  See ``stop()`` docstring.
+            if self._flush_on_exit:
+                self._drain_final()
         except Exception:
             logger.exception("ChunkUploader thread crashed")
 

{reactor_runtime-2.7.0 → reactor_runtime-2.7.2}/src/reactor_runtime/recording/config.py

@@ -91,6 +91,11 @@ class RecordingConfig:
     # ``reactor.yaml``.
     chunk_seconds: int = 4
     clip_max_seconds: int = 300
+    # Trim the session-start pre-roll from clip playlists by clamping
+    # ``start_marker`` forward to the first real (non-duplicate) frame
+    # the recorder observes.  Set to ``False`` to keep that pre-roll
+    # in clips.
+    skip_leading_black: bool = True
     video_track: Optional[str] = None
     audio_track: Optional[str] = None
     video: VideoEncoderConfig = field(default_factory=VideoEncoderConfig)
@@ -105,6 +110,9 @@ class RecordingConfig:
             enabled=bool(raw.get("enabled", cls.enabled)),
             chunk_seconds=int(raw.get("chunk_seconds", cls.chunk_seconds)),
             clip_max_seconds=int(raw.get("clip_max_seconds", cls.clip_max_seconds)),
+            skip_leading_black=bool(
+                raw.get("skip_leading_black", cls.skip_leading_black)
+            ),
             video_track=raw.get("video_track"),
             audio_track=raw.get("audio_track"),
             video=VideoEncoderConfig.from_dict(raw.get("video") or {}),

{reactor_runtime-2.7.0 → reactor_runtime-2.7.2}/src/reactor_runtime/recording/markers.py

@@ -12,7 +12,7 @@ from __future__ import annotations
 
 import threading
 import time
-from typing import Tuple
+from typing import Optional, Tuple
 
 
 class MarkerBookkeeper:
@@ -26,6 +26,10 @@ class MarkerBookkeeper:
     def __init__(self) -> None:
         self._session_start = time.monotonic()
         self._last_uploaded_chunk_idx: int = -1
+        # Sticky marker latched by :meth:`mark_first_real_frame`;
+        # ``None`` until the recorder sees its first non-duplicate
+        # bundle.
+        self._first_real_frame_marker: Optional[float] = None
         self._lock = threading.Lock()
 
     def now_marker(self) -> float:
@@ -38,6 +42,13 @@ class MarkerBookkeeper:
         with self._lock:
             return self._last_uploaded_chunk_idx
 
+    @property
+    def first_real_frame_marker(self) -> Optional[float]:
+        """Wall-clock of the first real (non-duplicate) bundle, or
+        ``None`` if no real frame has landed yet."""
+        with self._lock:
+            return self._first_real_frame_marker
+
     def mark_chunk_uploaded(self, idx: int) -> None:
         """Advance ``last_uploaded_chunk_idx`` monotonically.
 
@@ -48,7 +59,20 @@ class MarkerBookkeeper:
             if idx > self._last_uploaded_chunk_idx:
                 self._last_uploaded_chunk_idx = idx
 
-    def compute_clip_range(self, duration_seconds: float) -> Tuple[float, float]:
+    def mark_first_real_frame(self) -> None:
+        """Latch the wall-clock at which the first real frame was seen.
+
+        Idempotent and one-shot — only the first call has an effect,
+        so the marker pins the session-start pre-roll and is never
+        moved by later idle periods.
+        """
+        with self._lock:
+            if self._first_real_frame_marker is None:
+                self._first_real_frame_marker = time.monotonic() - self._session_start
+
+    def compute_clip_range(
+        self, duration_seconds: float, *, skip_leading_black: bool = False
+    ) -> Tuple[float, float]:
         """Resolve ``requestClip`` to a ``(start_marker, end_marker)`` pair.
 
         ``end_marker`` is the wall-clock at request time (``now_marker``),
@@ -59,11 +83,33 @@ class MarkerBookkeeper:
         polls until ``200``.  This keeps the runtime's response
         latency at one round-trip regardless of where in the chunk
         cycle the client asks.
+
+        When ``skip_leading_black`` is true and the first-real-frame
+        marker has been latched, ``start`` is clamped forward to that
+        marker.  Without the latch the clamp is skipped so callers
+        always receive a non-empty range.
         """
         end_marker = self.now_marker()
         start_marker = max(0.0, end_marker - duration_seconds)
+        if skip_leading_black:
+            with self._lock:
+                first_real = self._first_real_frame_marker
+            if first_real is not None:
+                start_marker = max(start_marker, first_real)
         return start_marker, end_marker
 
-    def compute_recording_range(self) -> Tuple[float, float]:
-        """``requestRecording`` is just a clip with ``start = 0``."""
-        return 0.0, self.now_marker()
+    def compute_recording_range(
+        self, *, skip_leading_black: bool = False
+    ) -> Tuple[float, float]:
+        """``requestRecording`` is just a clip from session start to
+        now.  Honours ``skip_leading_black`` with the same fallback
+        as :meth:`compute_clip_range`.
+        """
+        end_marker = self.now_marker()
+        start_marker = 0.0
+        if skip_leading_black:
+            with self._lock:
+                first_real = self._first_real_frame_marker
+            if first_real is not None:
+                start_marker = first_real
+        return start_marker, end_marker

{reactor_runtime-2.7.0 → reactor_runtime-2.7.2}/src/reactor_runtime/recording/session_recorder.py

@@ -86,6 +86,11 @@ class ClipResult:
     now_marker: float
     predicted_ready_at_ms: int
     playlist_url: str
+    # Wall-clock of the first real (non-duplicate) frame the recorder
+    # observed, or ``None`` if none has landed yet.  Surfaced for
+    # observability; ``start_marker`` already uses it when
+    # ``RecordingConfig.skip_leading_black`` is on.
+    first_real_frame_marker: Optional[float] = None
 
     def to_dict(self) -> dict:
         return {
@@ -96,6 +101,7 @@ class ClipResult:
             "now_marker": self.now_marker,
             "predicted_ready_at_ms": self.predicted_ready_at_ms,
             "playlist_url": self.playlist_url,
+            "first_real_frame_marker": self.first_real_frame_marker,
         }
 
 
@@ -215,9 +221,18 @@ class SessionRecorder:
         )
 
     def stop(self) -> None:
-        """Cleanly tear down feed worker, encoder, and uploader."""
+        """Tear down feed worker, encoder, and uploader.
+
+        Emits a structured ``SessionRecorder stopped`` log with
+        ``clean=…`` and per-thread leak flags so failed joins surface
+        in monitoring instead of leaking ffmpeg + uploader threads
+        silently.
+        """
         if not self._started:
             return
+        # Disable callbacks first so a racing _on_bundle_sync becomes
+        # a no-op even before its OutputBuffer subscription is removed.
+        self._disabled = True
         # Signal the feed loop to drain and exit; sentinel unblocks .get().
         self._feed_stop.set()
         try:
@@ -227,10 +242,14 @@ class SessionRecorder:
             pass
         feed_thread = self._feed_thread
         self._feed_thread = None
+        # Stop the encoder before joining the feed worker: the worker's
+        # blocking call is ``os.write()`` into the ffmpeg pipe and only
+        # unblocks when the pipe is closed.
+        self._encoder.stop()
         if feed_thread is not None:
             feed_thread.join(timeout=2.0)
-        self._encoder.stop()
-        self._uploader.stop(flush_remaining=True)
+        feed_leaked = feed_thread is not None and feed_thread.is_alive()
+        uploader_clean = self._uploader.stop(flush_remaining=True)
         self._started = False
         # Cleanup the encoder's transient working dir.  Chunks that
         # made it to the sink are already copied to the served dir;
@@ -244,11 +263,16 @@ class SessionRecorder:
                 "Failed to clean encoder work dir; leaking",
                 work_dir=str(self._work_dir),
             )
-        logger.info(
+        clean = not feed_leaked and uploader_clean
+        log = logger.info if clean else logger.error
+        log(
             "SessionRecorder stopped",
             session_id=self._session_id,
             last_uploaded_chunk_idx=self._markers.last_uploaded_chunk_idx,
             dropped=self._dropped_frames,
+            clean=clean,
+            feed_leaked=feed_leaked,
+            uploader_leaked=not uploader_clean,
         )
 
     # ------------------------------------------------------------------
@@ -276,6 +300,9 @@ class SessionRecorder:
         if self._disabled or not self._started:
             return
         now = time.monotonic()
+        if not duplicate:
+            # Idempotent latch; only the first call takes effect.
+            self._markers.mark_first_real_frame()
         if duplicate:
             if (
                 self._keepalive_interval <= 0.0
@@ -295,8 +322,17 @@ class SessionRecorder:
             audio_td = bundle.tracks.get(self._audio_track)
             if audio_td is not None:
                 audio_data = audio_td.data
+        # The OutputBuffer's cache is per-model, so the first
+        # duplicates of a new session can carry the previous session's
+        # last frame.  Black-fill them until a real frame lands so the
+        # leading pre-roll is genuinely black rather than stale content.
+        video_data = video_td.data
+        if duplicate and self._markers.first_real_frame_marker is None:
+            video_data = np.zeros_like(video_data)
+            if audio_data is not None:
+                audio_data = np.zeros_like(audio_data)
         try:
-            self._feed_queue.put_nowait((video_td.data, audio_data))
+            self._feed_queue.put_nowait((video_data, audio_data))
         except queue.Full:
             self._dropped_frames += 1
             # Cold-start can fill the queue for a few hundred frames;
@@ -428,23 +464,30 @@ class SessionRecorder:
         promise includes the chunk ffmpeg is currently writing.  The
         ``/clips`` manifest endpoint will ``202 Retry-After`` until
         that chunk lands; the SDK polls until ``200``.
+
+        Honours :attr:`RecordingConfig.skip_leading_black`.
         """
         if self.disabled:
             raise RecorderDisabledError("recorder disabled or encoder crashed")
         capped = min(float(duration_seconds), float(self._config.clip_max_seconds))
         if capped <= 0:
             raise ValueError("duration_seconds must be positive")
-        start, end = self._markers.compute_clip_range(capped)
+        start, end = self._markers.compute_clip_range(
+            capped, skip_leading_black=self._config.skip_leading_black
+        )
         return self._build_result(kind=kind, start=start, end=end)
 
     def request_recording(self) -> ClipResult:
-        """Resolve a full-recording request; ``start = 0``, ``end = now``.
+        """Resolve a full-recording request; ``end = now``.
 
-        Same promise-then-poll semantics as :meth:`request_clip`.
+        Same promise-then-poll semantics as :meth:`request_clip` and
+        honours :attr:`RecordingConfig.skip_leading_black`.
         """
         if self.disabled:
             raise RecorderDisabledError("recorder disabled or encoder crashed")
-        start, end = self._markers.compute_recording_range()
+        start, end = self._markers.compute_recording_range(
+            skip_leading_black=self._config.skip_leading_black
+        )
         return self._build_result(kind="recording", start=start, end=end)
 
     def _build_result(self, kind: str, start: float, end: float) -> ClipResult:
@@ -481,4 +524,5 @@ class SessionRecorder:
             now_marker=now,
             predicted_ready_at_ms=predicted_ready_at_ms,
             playlist_url=playlist_url,
+            first_real_frame_marker=self._markers.first_real_frame_marker,
         )

{reactor_runtime-2.7.0 → reactor_runtime-2.7.2}/src/reactor_runtime/utils/launch.py

@@ -42,6 +42,10 @@ def configure_logging(level: str, show_timestamps: bool = True) -> None:
     logging.getLogger("uvicorn").setLevel(logging.WARNING)
     logging.getLogger("uvicorn.error").setLevel(logging.WARNING)
     logging.getLogger("uvicorn.access").setLevel(logging.WARNING)
+    # Per-request httpx INFO logs would emit one line per recorded
+    # chunk and embed presigned credentials in the URL.
+    logging.getLogger("httpx").setLevel(logging.WARNING)
+    logging.getLogger("httpcore").setLevel(logging.WARNING)
 
 
 def _infer_runtime_name(serve_fn: Callable) -> str:

{reactor_runtime-2.7.0 → reactor_runtime-2.7.2}/src/reactor_runtime/utils/log.py

@@ -35,9 +35,19 @@ _LEVEL_COLORS: dict[int, str] = {
 }
 
 
-# `reactor_runtime.serve.*` is matched by the `reactor_runtime.` prefix, so
-# a single entry covers both the library and the serve entrypoint subpackage.
-_RUNTIME_PREFIXES = ("reactor_runtime.",)
+# Loggers under these prefixes are not model code and render without the
+# cyan ``MDL`` tag.  Update when adopting a new dependency that emits
+# through stdlib ``logging``.
+_NON_MODEL_PREFIXES = (
+    "reactor_runtime.",
+    "opentelemetry.",
+    "aiortc.",
+    "aioice.",
+    "av.",
+    "httpx",
+    "httpcore",
+    "uvicorn",
+)
 _MODEL_COLOR = "\033[36m"
 
 
@@ -50,7 +60,7 @@ class ColorFormatter(logging.Formatter):
         orig = record.levelname
         color = _LEVEL_COLORS.get(record.levelno, "")
 
-        if record.name.startswith(_RUNTIME_PREFIXES):
+        if record.name.startswith(_NON_MODEL_PREFIXES):
             pad = self._COL - len(orig)
             record.levelname = f"{color}{orig}{_RESET}{' ' * pad}"
         else:

{reactor_runtime-2.7.0 → reactor_runtime-2.7.2}/src/reactor_runtime.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: reactor_runtime
-Version: 2.7.0
+Version: 2.7.2
 Summary: Reactor runtime with public model API
 Author-email: Reactor <team@reactor.inc>
 Requires-Python: >=3.9