logging cleanup

Author: prassanna-ravishankar

examples/tutorials/10_async/10_temporal/090_claude_agents_sdk_mvp/project/workflow.py

@@ -148,8 +148,6 @@ async def on_task_event_send(self, params: SendEventParams):
 
                 # Run Claude via activity (manual wrapper for MVP)
                 # ContextInterceptor reads _task_id, _trace_id, _parent_span_id and threads to activity!
-                logger.info(f"[WORKFLOW] About to call activity with resume_session_id={self._state.claude_session_id}")
-
                 result = await workflow.execute_activity(
                 run_claude_agent_activity,
                 args=[
@@ -170,15 +168,6 @@ async def on_task_event_send(self, params: SendEventParams):
                 ),
                 )
 
-                logger.info(f"[WORKFLOW] ✅ Claude activity returned successfully!")
-                logger.info(f"[WORKFLOW] Result type: {type(result)}")
-                logger.info(f"[WORKFLOW] Result: {result}")
-                logger.info(f"[WORKFLOW] Claude activity completed: {len(result.get('messages', []))} messages")
-
-                # DEBUG: Check what we got back
-                logger.info(f"DEBUG: result keys = {result.keys()}")
-                logger.info(f"DEBUG: session_id from result = {result.get('session_id')}")
-
                 # Update session_id for next turn (maintains conversation context)
                 new_session_id = result.get("session_id")
                 if new_session_id:
@@ -189,7 +178,7 @@ async def on_task_event_send(self, params: SendEventParams):
                         f"({new_session_id[:16]}...)"
                     )
                 else:
-                    logger.error(f"DEBUG: NO session_id in result! Current state session_id={self._state.claude_session_id}")
+                    logger.warning(f"No session_id returned - context may not persist")
 
                 # Send Claude's response back to user
                 # Note: Activity should have streamed the response in real-time
@@ -230,7 +219,7 @@ async def on_task_event_send(self, params: SendEventParams):
                     )
 
             except Exception as e:
-                logger.error(f"[WORKFLOW] Error running Claude agent: {e}", exc_info=True)
+                logger.error(f"Error running Claude agent: {e}", exc_info=True)
                 # Send error message to user
                 await adk.messages.create(
                     task_id=params.task.id,
@@ -239,7 +228,7 @@ async def on_task_event_send(self, params: SendEventParams):
                         content=f"❌ Error: {str(e)}",
                     )
                 )
-                raise  # Re-raise to see in Temporal UI
+                raise
 
     @workflow.run
     async def on_task_create(self, params: CreateTaskParams):

src/agentex/lib/core/temporal/plugins/claude_agents/activities.py

@@ -133,11 +133,11 @@ async def run_claude_agent_activity(
             async for message in client.receive_response():
                 await handler.handle_message(message)
 
-        logger.info(f"[run_claude_agent_activity] ✅ Message loop completed, cleaning up...")
+        logger.debug(f"Message loop completed, cleaning up...")
         await handler.cleanup()
 
         results = handler.get_results()
-        logger.info(f"[run_claude_agent_activity] ✅ About to return results: {results.keys()}")
+        logger.debug(f"Returning results with keys: {results.keys()}")
         return results
 
     except Exception as e:

src/agentex/lib/core/temporal/plugins/claude_agents/message_handler.py

@@ -67,7 +67,7 @@ def __init__(
     async def initialize(self):
         """Initialize streaming context if task_id is available."""
         if self.task_id:
-            logger.info(f"[ClaudeMessageHandler] Creating streaming context for task: {self.task_id}")
+            logger.debug(f"Creating streaming context for task: {self.task_id}")
             self.streaming_ctx = await adk.streaming.streaming_task_message_context(
                 task_id=self.task_id,
                 initial_content=TextContent(
@@ -82,11 +82,11 @@ async def handle_message(self, message: Any):
         self.messages.append(message)
         msg_num = len(self.messages)
 
-        # Debug logging
-        logger.info(f"[ClaudeMessageHandler] 📨 [{msg_num}] Message type: {type(message).__name__}")
+        # Debug logging (verbose - only for troubleshooting)
+        logger.debug(f"📨 [{msg_num}] Message type: {type(message).__name__}")
         if isinstance(message, AssistantMessage):
             block_types = [type(b).__name__ for b in message.content]
-            logger.info(f"[ClaudeMessageHandler]    [{msg_num}] Content blocks: {block_types}")
+            logger.debug(f"   [{msg_num}] Content blocks: {block_types}")
 
         # Route to specific handlers
         if isinstance(message, UserMessage):
@@ -104,7 +104,7 @@ async def _handle_user_message(self, message: UserMessage, msg_num: int):
             return
 
         tool_name = self.tool_call_map.get(self.last_tool_call_id, "unknown")
-        logger.info(f"[ClaudeMessageHandler] ✅ [{msg_num}] STREAMING Tool result: {tool_name}")
+        logger.info(f"✅ Tool result: {tool_name}")
 
         # If this was a subagent (Task tool), close the subagent span
         if tool_name == "Task" and self.current_subagent_span and self.current_subagent_ctx:
@@ -114,7 +114,7 @@ async def _handle_user_message(self, message: UserMessage, msg_num: int):
 
             self.current_subagent_span.output = {"result": user_content}
             await self.current_subagent_ctx.__aexit__(None, None, None)
-            logger.info(f"[ClaudeMessageHandler] 🤖 Completed subagent execution")
+            logger.info(f"🤖 Subagent completed: {tool_name}")
             self.current_subagent_span = None
             self.current_subagent_ctx = None
 
@@ -178,7 +178,7 @@ async def _handle_tool_use(self, block: ToolUseBlock, msg_num: int):
         if not self.task_id:
             return
 
-        logger.info(f"[ClaudeMessageHandler] 🔧 [{msg_num}] STREAMING Tool request: {block.name}")
+        logger.info(f"🔧 Tool request: {block.name}")
 
         # Track tool_call_id → tool_name mapping
         self.tool_call_map[block.id] = block.name
@@ -187,7 +187,7 @@ async def _handle_tool_use(self, block: ToolUseBlock, msg_num: int):
         # Special handling for Task tool (subagents) - create nested span
         if block.name == "Task" and self.trace_id and self.parent_span_id:
             subagent_type = block.input.get("subagent_type", "unknown")
-            logger.info(f"[ClaudeMessageHandler] 🤖 Starting subagent: {subagent_type}")
+            logger.info(f"🤖 Subagent started: {subagent_type}")
 
             # Create nested trace span
             self.current_subagent_ctx = adk.tracing.span(
@@ -230,7 +230,7 @@ async def _handle_tool_result(self, block: ToolResultBlock):
             return
 
         tool_name = self.tool_call_map.get(block.tool_use_id, "unknown")
-        logger.info(f"[ClaudeMessageHandler] ✅ Tool result: {tool_name}")
+        logger.info(f"✅ Tool result: {tool_name}")
 
         tool_content = block.content if block.content is not None else ""
 
@@ -264,7 +264,7 @@ async def _handle_text_block(self, block: TextBlock, msg_num: int):
         if not block.text or not self.streaming_ctx:
             return
 
-        logger.info(f"[ClaudeMessageHandler] 💬 [{msg_num}] STREAMING Text: {block.text[:50]}...")
+        logger.debug(f"💬 Text block: {block.text[:50]}...")
 
         delta = TextDelta(type="text", text_delta=block.text)
 
@@ -283,11 +283,9 @@ async def _handle_system_message(self, message: SystemMessage):
         """Handle system message - extract session_id."""
         if message.subtype == "init":
             self.session_id = message.data.get("session_id")
-            logger.info(
-                f"[ClaudeMessageHandler] Session: "
-                f"{'STARTED' if self.session_id else 'unknown'} ({self.session_id[:16] if self.session_id else 'N/A'}...)"
-            )
-        logger.debug(f"[ClaudeMessageHandler] SystemMessage: {message.subtype}")
+            logger.debug(f"Session initialized: {self.session_id[:16] if self.session_id else 'unknown'}...")
+        else:
+            logger.debug(f"SystemMessage: {message.subtype}")
 
     async def _handle_result_message(self, message: ResultMessage):
         """Handle result message - extract usage and cost."""
@@ -298,17 +296,14 @@ async def _handle_result_message(self, message: ResultMessage):
         if message.session_id:
             self.session_id = message.session_id
 
-        logger.info(
-            f"[ClaudeMessageHandler] Result - "
-            f"cost=${self.cost_info:.4f}, duration={message.duration_ms}ms, turns={message.num_turns}"
-        )
+        logger.info(f"💰 Cost: ${self.cost_info:.4f}, Duration: {message.duration_ms}ms, Turns: {message.num_turns}")
 
     async def cleanup(self):
         """Clean up open streaming contexts."""
         if self.streaming_ctx:
             try:
                 await self.streaming_ctx.close()
-                logger.info(f"[ClaudeMessageHandler] Closed streaming context")
+                logger.debug(f"Closed streaming context")
             except Exception as e:
                 logger.warning(f"Failed to close streaming context: {e}")