crewplus 0.2.67__tar.gz → 0.2.70__tar.gz

{crewplus-0.2.67 → crewplus-0.2.70}/PKG-INFO

@@ -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 → crewplus-0.2.70}/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 → crewplus-0.2.70}/pyproject.toml

@@ -6,7 +6,7 @@ build-backend = "pdm.backend"
 
 [project]
 name = "crewplus"
-version = "0.2.67"
+version = "0.2.70"
 description = "Base services for CrewPlus AI applications"
 authors = [
     { name = "Tim Liu", email = "tim@opsmateai.com" },

crewplus-0.2.67/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