crewplus 0.2.67__py3-none-any.whl → 0.2.70__py3-none-any.whl

crewplus/services/tracing_manager.py

@@ -9,16 +9,11 @@ import logging
 try:
     from langfuse.langchain import CallbackHandler as LangfuseCallbackHandler
     from ..callbacks.async_langfuse_handler import AsyncLangfuseCallbackHandler
-    # Import the new custom handlers
-    from ..callbacks.run_id_handler import RunIdCallbackHandler, AsyncRunIdCallbackHandler
     LANGFUSE_AVAILABLE = True
 except ImportError:
     LANGFUSE_AVAILABLE = False
     LangfuseCallbackHandler = None
     AsyncLangfuseCallbackHandler = None
-    # Define dummy classes for the custom handlers to prevent errors if langfuse is not installed
-    class RunIdCallbackHandler: pass
-    class AsyncRunIdCallbackHandler: pass
 
 class TracingContext(Protocol):
     """
@@ -89,9 +84,12 @@ class TracingManager:
     
     def _initialize_langfuse(self):
         """Initializes the Langfuse handler if it's available and enabled."""
+        self.context.logger.debug("Attempting to initialize Langfuse handlers.")
         if not LANGFUSE_AVAILABLE:
             if self.context.enable_tracing is True:
                 self.context.logger.warning("Langfuse is not installed; tracing will be disabled. Install with: pip install langfuse")
+            else:
+                self.context.logger.debug("Langfuse is not installed, skipping handler initialization.")
             return
         
         # Determine if Langfuse should be enabled via an explicit flag or
@@ -103,36 +101,45 @@ class TracingManager:
         
         if enable_langfuse:
             try:
-                # Create and add both the standard and the run_id-capturing handlers.
-                # The standard handler creates the trace, and the custom one updates it.
-                self._sync_handlers.append(LangfuseCallbackHandler())
-                self._sync_handlers.append(RunIdCallbackHandler())
+                # Create both sync and async handlers. We'll pick one at runtime.
+                sync_handler = LangfuseCallbackHandler()
+                self._sync_handlers.append(sync_handler)
 
                 if AsyncLangfuseCallbackHandler:
-                    self._async_handlers.append(AsyncLangfuseCallbackHandler())
-                    self._async_handlers.append(AsyncRunIdCallbackHandler())
+                    async_handler = AsyncLangfuseCallbackHandler()
+                    self._async_handlers.append(async_handler)
                 
                 self.context.logger.info(f"Langfuse tracing enabled for {self.context.get_model_identifier()}")
             except Exception as e:
-                self.context.logger.warning(f"Failed to initialize Langfuse: {e}")
+                self.context.logger.warning(f"Failed to initialize Langfuse: {e}", exc_info=True)
+        else:
+            self.context.logger.info("Langfuse is not enabled, skipping handler initialization.")
     
     def _add_callbacks_to_config(self, config: Optional[dict], handlers: List[Any]) -> dict:
         """A generic helper to add a list of handlers to a config object."""
         if config is None:
             config = {}
         
+        self.context.logger.debug(f"Adding callbacks to config. Have {len(handlers)} handlers to add.")
+
         if not handlers or config.get("metadata", {}).get("tracing_disabled"):
+            self.context.logger.debug("No handlers to add or tracing is disabled for this run.")
             return config
         
         callbacks = config.get("callbacks")
         
         if hasattr(callbacks, 'add_handler') and hasattr(callbacks, 'handlers'):
+            # This block is for CallbackManager instances
+            self.context.logger.debug(f"Config has a CallbackManager with {len(callbacks.handlers)} existing handlers.")
             for handler in handlers:
                 if not any(isinstance(cb, type(handler)) for cb in callbacks.handlers):
                     callbacks.add_handler(handler, inherit=True)
+            self.context.logger.debug(f"CallbackManager now has {len(callbacks.handlers)} handlers.")
             return config
         
+        # This block is for simple lists of callbacks
         current_callbacks = callbacks or []
+        self.context.logger.debug(f"Config has a list with {len(current_callbacks)} existing callbacks.")
         new_callbacks = list(current_callbacks)
         
         for handler in handlers:

{crewplus-0.2.67.dist-info → crewplus-0.2.70.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: crewplus
-Version: 0.2.67
+Version: 0.2.70
 Summary: Base services for CrewPlus AI applications
 Author-Email: Tim Liu <tim@opsmateai.com>
 License: MIT

{crewplus-0.2.67.dist-info → crewplus-0.2.70.dist-info}/RECORD

@@ -1,17 +1,16 @@
-crewplus-0.2.67.dist-info/METADATA,sha256=4-Ff7Zq0GzeSYRJeAP0uy1A1UPSnOD2NzEy5U5245zg,5424
-crewplus-0.2.67.dist-info/WHEEL,sha256=9P2ygRxDrTJz3gsagc0Z96ukrxjr-LFBGOgv3AuKlCA,90
-crewplus-0.2.67.dist-info/entry_points.txt,sha256=6OYgBcLyFCUgeqLgnvMyOJxPCWzgy7se4rLPKtNonMs,34
-crewplus-0.2.67.dist-info/licenses/LICENSE,sha256=2_NHSHRTKB_cTcT_GXgcenOCtIZku8j343mOgAguTfc,1087
+crewplus-0.2.70.dist-info/METADATA,sha256=M2xMdWJbR5BsBLfIGxner83D2vLfE5ui-hmEmhcVMUQ,5424
+crewplus-0.2.70.dist-info/WHEEL,sha256=9P2ygRxDrTJz3gsagc0Z96ukrxjr-LFBGOgv3AuKlCA,90
+crewplus-0.2.70.dist-info/entry_points.txt,sha256=6OYgBcLyFCUgeqLgnvMyOJxPCWzgy7se4rLPKtNonMs,34
+crewplus-0.2.70.dist-info/licenses/LICENSE,sha256=2_NHSHRTKB_cTcT_GXgcenOCtIZku8j343mOgAguTfc,1087
 crewplus/__init__.py,sha256=m46HkZL1Y4toD619NL47Sn2Qe084WFFSFD7e6VoYKZc,284
 crewplus/callbacks/__init__.py,sha256=YG7ieeb91qEjp1zF0-inEN7mjZ7yT_D2yzdWFT8Z1Ws,63
 crewplus/callbacks/async_langfuse_handler.py,sha256=A4uFeLpvOUdc58M7sZoE65_C1V98u0QCvx5jUquM0pM,7006
-crewplus/callbacks/run_id_handler.py,sha256=ZAXGi6-gzOTZVl0xiCeNwjqYwwNd8tB9nocsnsbRSDQ,4371
 crewplus/services/__init__.py,sha256=V1CG8b2NOmRzNgQH7BPl4KVxWSYJH5vfEsW1wVErKNE,375
 crewplus/services/azure_chat_model.py,sha256=iWzJ2GQFSNmwJx-2O5_xKPSB6VVc-7T6bcfFI8_WezA,5521
 crewplus/services/gemini_chat_model.py,sha256=DYqz01H2TIHiCDQesSozVfOsMigno6QGwOtIweg7UHk,40103
 crewplus/services/init_services.py,sha256=tc1ti8Yufo2ixlJpwg8uH0KmoyQ4EqxCOe4uTEWnlRM,2413
 crewplus/services/model_load_balancer.py,sha256=Q9Gx3GrbKworU-Ytxeqp0ggHSgZ1Q6brtTk-nCl4sak,12095
-crewplus/services/tracing_manager.py,sha256=tTha3NGoQUvO0gwBrx_pJzQ3-2eEz2ZsJtICtI6OeiA,7033
+crewplus/services/tracing_manager.py,sha256=_C4zYj6o_k5mDWY7vM8UeaVaXp8SqrkvYOb0Jj-y3sY,7566
 crewplus/utils/__init__.py,sha256=2Gk1n5srFJQnFfBuYTxktdtKOVZyNrFcNaZKhXk35Pw,142
 crewplus/utils/schema_action.py,sha256=GDaBoVFQD1rXqrLVSMTfXYW1xcUu7eDcHsn57XBSnIg,422
 crewplus/utils/schema_document_updater.py,sha256=frvffxn2vbi71fHFPoGb9hq7gH2azmmdq17p-Fumnvg,7322
@@ -23,4 +22,4 @@ docs/GeminiChatModel.md,sha256=zZYyl6RmjZTUsKxxMiC9O4yV70MC4TD-IGUmWhIDBKA,8677
 docs/ModelLoadBalancer.md,sha256=aGHES1dcXPz4c7Y8kB5-vsCNJjriH2SWmjBkSGoYKiI,4398
 docs/VDBService.md,sha256=Dw286Rrf_fsi13jyD3Bo4Sy7nZ_G7tYm7d8MZ2j9hxk,9375
 docs/index.md,sha256=3tlc15uR8lzFNM5WjdoZLw0Y9o1P1gwgbEnOdIBspqc,1643
-crewplus-0.2.67.dist-info/RECORD,,
+crewplus-0.2.70.dist-info/RECORD,,

crewplus/callbacks/run_id_handler.py

@@ -1,99 +0,0 @@
-# File: crewplus/callbacks/run_id_handler.py
-
-from typing import Any, Dict
-from uuid import UUID
-import logging
-
-# Langfuse imports with graceful fallback
-from langfuse.langchain import CallbackHandler as LangfuseCallbackHandler
-from .async_langfuse_handler import AsyncLangfuseCallbackHandler
-from langfuse import get_client
-LANGFUSE_AVAILABLE = True
-
-# --- Custom Callback Handlers to capture the run_id ---
-
-class RunIdCallbackHandler(LangfuseCallbackHandler):
-    """
-    A custom synchronous callback handler that captures the Langchain run_id
-    and adds it to the Langfuse trace metadata. It also stores the mapping
-    between the run_id and the generated trace_id.
-    """
-    def __init__(self, *args, **kwargs):
-        super().__init__(*args, **kwargs)
-        self.run_trace_map = {}
-        # Use a named logger for better context
-        self.logger = logging.getLogger(__name__)
-        self.logger.info("RunIdCallbackHandler initialized.")
-
-    def on_chain_start(
-        self,
-        serialized: Dict[str, Any],
-        inputs: Dict[str, Any],
-        run_id: UUID,
-        **kwargs: Any,
-    ) -> Any:
-        self.logger.debug(f"on_chain_start triggered for run_id: {run_id}")
-        # First, let the base handler do its work, which includes creating the trace
-        run = super().on_chain_start(serialized, inputs, run_id, **kwargs)
-        self.logger.debug(f"Base handler's on_chain_start completed. Current trace_id: {self.last_trace_id}")
-
-        try:
-            # The base handler sets `self.last_trace_id` when a trace is created
-            if self.last_trace_id:
-                self.run_trace_map[str(run_id)] = self.last_trace_id
-                self.logger.info(f"Mapping run_id '{run_id}' to trace_id '{self.last_trace_id}'.")
-
-                # Then, update the created trace with the run_id as metadata
-                langfuse_client = get_client()
-                langfuse_client.update_current_trace(
-                    metadata={"langchain_run_id": str(run_id)}
-                )
-                self.logger.info(f"Successfully updated trace '{self.last_trace_id}' with metadata for run_id '{run_id}'.")
-            else:
-                self.logger.warning(f"Could not find 'last_trace_id' for run_id '{run_id}'. Metadata will not be updated.")
-
-        except Exception as e:
-            self.logger.error(f"Failed to process run_id '{run_id}' in RunIdCallbackHandler: {e}", exc_info=True)
-
-        return run
-
-class AsyncRunIdCallbackHandler(AsyncLangfuseCallbackHandler):
-    """
-    A custom asynchronous callback handler that captures the Langchain run_id
-    and adds it to the Langfuse trace metadata.
-    """
-    def __init__(self, *args, **kwargs):
-        super().__init__(*args, **kwargs)
-        self.run_trace_map = {}
-        self.logger = logging.getLogger(__name__)
-        self.logger.info("AsyncRunIdCallbackHandler initialized.")
-
-    async def on_chain_start(
-        self,
-        serialized: Dict[str, Any],
-        inputs: Dict[str, Any],
-        run_id: UUID,
-        **kwargs: Any,
-    ) -> Any:
-        self.logger.debug(f"Async on_chain_start triggered for run_id: {run_id}")
-        # First, let the base handler do its work
-        run = await super().on_chain_start(serialized, inputs, run_id, **kwargs)
-        self.logger.debug(f"Async base handler's on_chain_start completed. Current trace_id: {self.last_trace_id}")
-        
-        try:
-            if self.last_trace_id:
-                self.run_trace_map[str(run_id)] = self.last_trace_id
-                self.logger.info(f"Async: Mapping run_id '{run_id}' to trace_id '{self.last_trace_id}'.")
-
-                langfuse_client = get_client()
-                langfuse_client.update_current_trace(
-                    metadata={"langchain_run_id": str(run_id)}
-                )
-                self.logger.info(f"Async: Successfully updated trace '{self.last_trace_id}' with metadata for run_id '{run_id}'.")
-            else:
-                self.logger.warning(f"Async: Could not find 'last_trace_id' for run_id '{run_id}'. Metadata will not be updated.")
-
-        except Exception as e:
-            self.logger.error(f"Async: Failed to process run_id '{run_id}' in AsyncRunIdCallbackHandler: {e}", exc_info=True)
-
-        return run