From a5882482027f5bc9d4deaca3c71aa9e779436655 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Cl=C3=A9ment=20Charmet?= <ccharmet@gladia.io>
Date: Tue, 25 Nov 2025 17:51:45 +0100
Subject: [PATCH] feat(gladia): add Gladia session id to logs for easier debug

---
 src/pipecat/services/gladia/stt.py | 25 ++++++++++++++++---------
 1 file changed, 16 insertions(+), 9 deletions(-)

diff --git a/src/pipecat/services/gladia/stt.py b/src/pipecat/services/gladia/stt.py
index 6247452934..8e9a9b9dcf 100644
--- a/src/pipecat/services/gladia/stt.py
+++ b/src/pipecat/services/gladia/stt.py
@@ -266,6 +266,7 @@ def __init__(
         self._reconnection_delay = reconnection_delay
         self._reconnection_attempts = 0
         self._session_url = None
+        self._session_id = None
         self._connection_active = False
 
         # Audio buffer management
@@ -278,6 +279,9 @@ def __init__(
         self._connection_task = None
         self._should_reconnect = True
 
+    def __str__(self):
+        return f"GladiaSTTService [{self._session_id}]"
+
     def can_generate_metrics(self) -> bool:
         """Check if the service can generate performance metrics.
 
@@ -412,14 +416,14 @@ async def run_stt(self, audio: bytes) -> AsyncGenerator[Frame, None]:
                 trim_size = len(self._audio_buffer) - self._max_buffer_size
                 self._audio_buffer = self._audio_buffer[trim_size:]
                 self._bytes_sent = max(0, self._bytes_sent - trim_size)
-                logger.warning(f"Audio buffer exceeded max size, trimmed {trim_size} bytes")
+                logger.warning(f"{self} Audio buffer exceeded max size, trimmed {trim_size} bytes")
 
         # Send audio if connected
         if self._connection_active and self._websocket and self._websocket.state is State.OPEN:
             try:
                 await self._send_audio(audio)
             except websockets.exceptions.ConnectionClosed as e:
-                logger.warning(f"Websocket closed while sending audio chunk: {e}")
+                logger.warning(f"{self} Websocket closed while sending audio chunk: {e}")
                 self._connection_active = False
 
         yield None
@@ -433,8 +437,9 @@ async def _connection_handler(self):
                     settings = self._prepare_settings()
                     response = await self._setup_gladia(settings)
                     self._session_url = response["url"]
+                    self._session_id = response["id"]
                     self._reconnection_attempts = 0
-                    logger.info(f"Session URL : {self._session_url}")
+                    logger.info(f"{self} Session URL : {self._session_url}")
 
                 # Connect with automatic reconnection
                 async with websocket_connect(self._session_url) as websocket:
@@ -454,7 +459,7 @@ async def _connection_handler(self):
                         await asyncio.gather(self._receive_task, self._keepalive_task)
 
                     except websockets.exceptions.ConnectionClosed as e:
-                        logger.warning(f"WebSocket connection closed: {e}")
+                        logger.warning(f"{self} WebSocket connection closed: {e}")
                         self._connection_active = False
 
                         # Clean up tasks
@@ -511,10 +516,10 @@ async def _setup_gladia(self, settings: Dict[str, Any]):
                 else:
                     error_text = await response.text()
                     logger.error(
-                        f"Gladia error: {response.status}: {error_text or response.reason}"
+                        f"{self} Gladia error: {response.status}: {error_text or response.reason}"
                     )
                     raise Exception(
-                        f"Failed to initialize Gladia session: {response.status} - {error_text}"
+                        f"{self} Failed to initialize Gladia session: {response.status} - {error_text}"
                     )
 
     @traced_stt
@@ -554,10 +559,10 @@ async def _keepalive_task_handler(self):
                     empty_audio = b""
                     await self._send_audio(empty_audio)
                 else:
-                    logger.debug("Websocket closed, stopping keepalive")
+                    logger.debug(f"{self} Websocket closed, stopping keepalive")
                     break
         except websockets.exceptions.ConnectionClosed:
-            logger.debug("Connection closed during keepalive")
+            logger.debug(f"{self} Connection closed during keepalive")
         except Exception as e:
             logger.error(f"{self} exception: {e}")
             await self.push_error(ErrorFrame(error=f"{self} error: {e}"))
@@ -632,7 +637,9 @@ async def _maybe_reconnect(self) -> bool:
             return False
         self._reconnection_attempts += 1
         if self._reconnection_attempts > self._max_reconnection_attempts:
-            logger.error(f"Max reconnection attempts ({self._max_reconnection_attempts}) reached")
+            logger.error(
+                f"{self} Max reconnection attempts ({self._max_reconnection_attempts}) reached"
+            )
             self._should_reconnect = False
             return False
         delay = self._reconnection_delay * (2 ** (self._reconnection_attempts - 1))