feat: add thread dumps and queue stats to heartbeat for deadlock diagnosis

When the heartbeat detects a stall (message count frozen for 90s), it now:
- Dumps all thread stack traces via sys._current_frames() to show exactly
  what each worker thread is doing (blocked on HTTP, queue.put, lock, etc.)
- Reports queue_size and queue_full on every heartbeat line
- Re-dumps thread stacks every ~5 min during ongoing stalls

The queue stats instantly reveal the deadlock type:
- queue_size=0 + msgs frozen → workers stuck on HTTP/IO (Scenario B)
- queue_size=10000 + print_blocked=YES → classic pipe deadlock (Scenario A)
- queue_size=10000 + print_blocked=NO → main thread not consuming (bug)

Adds a lightweight queue_registry module so the heartbeat thread in
entrypoint.py can access the ConcurrentSource queue without threading
it through the call chain.

Co-Authored-By: gl_anatolii.yatsuk <gl_anatolii.yatsuk@airbyte.io>

Author: devin-ai-integration[bot]

airbyte_cdk/entrypoint.py

@@ -14,6 +14,7 @@
 import tempfile
 import threading
 import time
+import traceback
 from collections import defaultdict
 from functools import wraps
 from typing import Any, DefaultDict, Iterable, List, Mapping, Optional
@@ -387,25 +388,69 @@ def launch(source: Source, args: List[str]) -> None:
     heartbeat_stop = threading.Event()
 
     def _heartbeat() -> None:
-        """Emit periodic status to stderr to diagnose stdout pipe blocking.
+        """Emit periodic status to stderr to diagnose stdout pipe blocking and deadlocks.
 
         Writes directly to fd 2 (stderr) which the Kubernetes container
         runtime collects independently of the orchestrator reading stdout.
+
+        When a stall is detected (message count frozen for 3+ intervals = 90s),
+        a full thread dump is emitted to help diagnose deadlocks in the
+        concurrent source worker pool.
         """
+        from airbyte_cdk.sources.concurrent_source.queue_registry import get_queue
+
         start = time.monotonic()
         stderr_fd = 2
+        last_msgs = 0
+        stall_count = 0
+        _STALL_THRESHOLD = 3  # intervals before triggering thread dump (3 * 30s = 90s)
+        _DUMP_REPEAT_INTERVAL = 10  # re-dump every 10 intervals (~5 min) during ongoing stall
+
         while not heartbeat_stop.wait(timeout=_HEARTBEAT_INTERVAL_S):
             now = time.monotonic()
             elapsed = now - start
+
+            # Detect stall: same message count for multiple consecutive intervals
+            if messages_written == last_msgs and messages_written > 0:
+                stall_count += 1
+            else:
+                stall_count = 0
+            last_msgs = messages_written
+
             blocked_str = "YES" if print_blocked else "NO"
             blocked_dur = (
                 f" blocked_since={now - print_blocked_since:.0f}s" if print_blocked else ""
             )
+
+            # Include queue stats if concurrent source is active
+            queue_stats = ""
+            q = get_queue()
+            if q is not None:
+                try:
+                    queue_stats = f" queue_size={q.qsize()} queue_full={q.full()}"
+                except Exception:
+                    pass  # Queue methods are best-effort
+
             line = (
                 f"STDOUT_HEARTBEAT: t={elapsed:.0f}s "
                 f"msgs={messages_written} bytes={bytes_written} "
-                f"print_blocked={blocked_str}{blocked_dur}\n"
+                f"print_blocked={blocked_str}{blocked_dur}"
+                f"{queue_stats}\n"
             )
+
+            # Dump all thread stacks when stall is detected, then periodically during ongoing stall
+            if stall_count == _STALL_THRESHOLD or (
+                stall_count > _STALL_THRESHOLD
+                and (stall_count - _STALL_THRESHOLD) % _DUMP_REPEAT_INTERVAL == 0
+            ):
+                line += "=== THREAD DUMP (stall detected) ===\n"
+                thread_names = {t.ident: t.name for t in threading.enumerate()}
+                for thread_id, frame in sys._current_frames().items():
+                    thread_name = thread_names.get(thread_id, "unknown")
+                    line += f"\nThread {thread_name} ({thread_id}):\n"
+                    line += "".join(traceback.format_stack(frame))
+                line += "=== END THREAD DUMP ===\n"
+
             try:
                 os.write(stderr_fd, line.encode())
             except OSError:

airbyte_cdk/sources/concurrent_source/concurrent_source.py

@@ -12,6 +12,7 @@
 from airbyte_cdk.sources.concurrent_source.partition_generation_completed_sentinel import (
     PartitionGenerationCompletedSentinel,
 )
+from airbyte_cdk.sources.concurrent_source.queue_registry import register_queue, unregister_queue
 from airbyte_cdk.sources.concurrent_source.stream_thread_exception import StreamThreadException
 from airbyte_cdk.sources.concurrent_source.thread_pool_manager import ThreadPoolManager
 from airbyte_cdk.sources.message import InMemoryMessageRepository, MessageRepository
@@ -106,29 +107,34 @@ def read(
         streams: List[AbstractStream],
     ) -> Iterator[AirbyteMessage]:
         self._logger.info("Starting syncing")
-        concurrent_stream_processor = ConcurrentReadProcessor(
-            streams,
-            PartitionEnqueuer(self._queue, self._threadpool),
-            self._threadpool,
-            self._logger,
-            self._slice_logger,
-            self._message_repository,
-            PartitionReader(
-                self._queue,
-                PartitionLogger(self._slice_logger, self._logger, self._message_repository),
-            ),
-        )
+        # Register queue so the heartbeat thread can report queue stats for deadlock diagnosis
+        register_queue(self._queue)
+        try:
+            concurrent_stream_processor = ConcurrentReadProcessor(
+                streams,
+                PartitionEnqueuer(self._queue, self._threadpool),
+                self._threadpool,
+                self._logger,
+                self._slice_logger,
+                self._message_repository,
+                PartitionReader(
+                    self._queue,
+                    PartitionLogger(self._slice_logger, self._logger, self._message_repository),
+                ),
+            )
 
-        # Enqueue initial partition generation tasks
-        yield from self._submit_initial_partition_generators(concurrent_stream_processor)
+            # Enqueue initial partition generation tasks
+            yield from self._submit_initial_partition_generators(concurrent_stream_processor)
 
-        # Read from the queue until all partitions were generated and read
-        yield from self._consume_from_queue(
-            self._queue,
-            concurrent_stream_processor,
-        )
-        self._threadpool.check_for_errors_and_shutdown()
-        self._logger.info("Finished syncing")
+            # Read from the queue until all partitions were generated and read
+            yield from self._consume_from_queue(
+                self._queue,
+                concurrent_stream_processor,
+            )
+            self._threadpool.check_for_errors_and_shutdown()
+            self._logger.info("Finished syncing")
+        finally:
+            unregister_queue()
 
     def _submit_initial_partition_generators(
         self, concurrent_stream_processor: ConcurrentReadProcessor

airbyte_cdk/sources/concurrent_source/queue_registry.py

@@ -0,0 +1,41 @@
+# Copyright (c) 2025 Airbyte, Inc., all rights reserved.
+"""Module-level registry for the concurrent source queue.
+
+The heartbeat thread in entrypoint.py needs to report queue stats (size, full/empty)
+to help diagnose deadlocks. Since the queue is created deep inside ConcurrentSource,
+this registry provides a lightweight way to expose it without threading the queue
+object through the entire call chain.
+
+Usage:
+    # In ConcurrentSource.read():
+    register_queue(self._queue)
+
+    # In the heartbeat thread:
+    q = get_queue()
+    if q is not None:
+        print(f"queue_size={q.qsize()} queue_full={q.full()}")
+"""
+
+from queue import Queue
+from typing import Optional
+
+from airbyte_cdk.sources.streams.concurrent.partitions.types import QueueItem
+
+_queue: Optional[Queue[QueueItem]] = None
+
+
+def register_queue(queue: Queue[QueueItem]) -> None:
+    """Register the concurrent source queue for heartbeat monitoring."""
+    global _queue
+    _queue = queue
+
+
+def get_queue() -> Optional[Queue[QueueItem]]:
+    """Return the registered queue, or None if no concurrent source is active."""
+    return _queue
+
+
+def unregister_queue() -> None:
+    """Clear the registered queue."""
+    global _queue
+    _queue = None