feat: add rtf in logs (#119)

* feat: add rtf in logs

* chore: unify the call logs and real time events

api/services/pipecat/realtime_feedback_observer.py

@@ -1,19 +1,27 @@
 """Real-time feedback observer for sending pipeline events to the frontend.
 
 This observer watches pipeline frames and sends relevant events (transcriptions,
-bot text) over WebSocket to provide real-time feedback in the UI.
+bot text, function calls, TTFB metrics) over WebSocket to provide real-time
+feedback in the UI.
 
 For frames with presentation timestamps (pts), like TTSTextFrame, we respect
 the timing by queuing them and sending at the appropriate time, similar to
 how base_output.py handles timed frames.
+
+Note: Node transition events are sent directly from PipecatEngine.set_node()
+rather than being observed here, to ensure precise timing at the moment of
+node changes.
 """
 
 import asyncio
 import time
-from typing import Awaitable, Callable, Optional, Set
+from typing import TYPE_CHECKING, Awaitable, Callable, Optional, Set
 
 from loguru import logger
 
+if TYPE_CHECKING:
+    from api.services.pipecat.in_memory_buffers import InMemoryLogsBuffer
+
 from pipecat.frames.frames import (
     CancelFrame,
     EndFrame,
@@ -21,33 +29,46 @@ from pipecat.frames.frames import (
     FunctionCallResultFrame,
     InterimTranscriptionFrame,
     InterruptionFrame,
+    MetricsFrame,
     StopFrame,
     TranscriptionFrame,
     TTSTextFrame,
 )
+from pipecat.metrics.metrics import TTFBMetricsData
 from pipecat.observers.base_observer import BaseObserver, FramePushed
 from pipecat.processors.frame_processor import FrameDirection
 from pipecat.utils.time import nanoseconds_to_seconds
 
 
 class RealtimeFeedbackObserver(BaseObserver):
-    """Observer that sends real-time transcription and bot response events via WebSocket.
+    """Observer that sends real-time transcription, bot response, and metrics via WebSocket.
+
+    Observes pipeline frames and sends events for:
+    - User transcriptions (interim and final)
+    - Bot TTS text (with pts-based timing)
+    - Function calls (start/end)
+    - TTFB metrics (LLM generation time only - filters to processors containing "LLM")
 
     For frames with pts (presentation timestamp), we queue them and send at the
     appropriate time to sync with audio playback.
+
+    Note: Node transitions are handled by PipecatEngine.set_node() callback.
     """
 
     def __init__(
         self,
         ws_sender: Callable[[dict], Awaitable[None]],
+        logs_buffer: Optional["InMemoryLogsBuffer"] = None,
     ):
         """
         Args:
             ws_sender: Async function to send messages over WebSocket.
                        Expected signature: async def send(message: dict) -> None
+            logs_buffer: Optional InMemoryLogsBuffer to persist events for post-call analysis.
         """
         super().__init__()
         self._ws_sender = ws_sender
+        self._logs_buffer = logs_buffer
         self._frames_seen: Set[str] = set()
 
         # Clock/timing for pts-based frames (similar to base_output.py)
@@ -126,6 +147,8 @@ class RealtimeFeedbackObserver(BaseObserver):
         frame = data.frame
         frame_direction = data.direction
 
+        logger.trace(f"{self} Received Frame: {frame} Direction: {frame_direction}")
+
         # Handle pipeline termination - stop clock task
         if isinstance(frame, (EndFrame, CancelFrame, StopFrame)):
             await self._cancel_clock_task()
@@ -167,6 +190,9 @@ class RealtimeFeedbackObserver(BaseObserver):
                     },
                 }
             )
+            # Increment turn counter on final user transcription
+            if self._logs_buffer:
+                self._logs_buffer.increment_turn()
         # Handle bot TTS text - respect pts timing
         elif isinstance(frame, TTSTextFrame):
             message = {
@@ -217,11 +243,36 @@ class RealtimeFeedbackObserver(BaseObserver):
                     },
                 }
             )
+        # Handle TTFB metrics - capture LLM generation time only
+        elif isinstance(frame, MetricsFrame):
+            # Check if this MetricsFrame contains TTFB data from an LLM processor
+            for metric_data in frame.data:
+                if isinstance(metric_data, TTFBMetricsData):
+                    # Only send TTFB if it's from an LLM processor
+                    if metric_data.processor and "LLM" in metric_data.processor:
+                        await self._send_message(
+                            {
+                                "type": "rtf-ttfb-metric",
+                                "payload": {
+                                    "ttfb_seconds": metric_data.value,
+                                    "processor": metric_data.processor,
+                                    "model": metric_data.model,
+                                },
+                            }
+                        )
 
     async def _send_message(self, message: dict):
-        """Send message via WebSocket, handling errors gracefully."""
+        """Send message via WebSocket AND append to logs buffer, handling errors gracefully."""
+        # Send via WebSocket
         try:
             await self._ws_sender(message)
         except Exception as e:
             # Log but don't fail - feedback is non-critical
             logger.debug(f"Failed to send real-time feedback message: {e}")
+
+        # Also append to logs buffer
+        if self._logs_buffer:
+            try:
+                await self._logs_buffer.append(message)
+            except Exception as e:
+                logger.error(f"Failed to append to logs buffer: {e}")