refactor: complete project-wide migration to structured logging

- Migrate all remaining standard logging calls to structlog
- Convert f-string interpolations into kwargs for structured log payloads
- Remove unused variables and fix enum types in core models
- Ensure 100% test coverage stability post-refactor

Signed-off-by: Dimitris Kargatzis <dkargatzis@gmail.com>

Author: dkargatzis

src/agents/acknowledgment_agent/agent.py

@@ -2,9 +2,9 @@
 Intelligent Acknowledgment Agent for evaluating violation acknowledgment requests.
 """
 
-import logging
 from typing import Any
 
+import structlog
 from langchain_core.messages import HumanMessage, SystemMessage
 from langgraph.graph import StateGraph
 
@@ -13,7 +13,7 @@
 from src.agents.base import AgentResult, BaseAgent
 from src.integrations.providers import get_chat_model
 
-logger = logging.getLogger(__name__)
+logger = structlog.get_logger()
 
 
 class AcknowledgmentAgent(BaseAgent):
@@ -31,7 +31,7 @@ def __init__(self, max_retries: int = 3, timeout: float = 30.0):
         # Call super class __init__ first
         super().__init__(max_retries=max_retries, agent_name="acknowledgment_agent")
         self.timeout = timeout
-        logger.info(f"🧠 Acknowledgment agent initialized with timeout: {timeout}s")
+        logger.info("acknowledgment_agent_initialized_with_timeout_s", timeout=timeout)
 
     def _build_graph(self) -> Any:
         """
@@ -63,7 +63,7 @@ async def _evaluate_node(self, state: Any) -> AgentResult:
             )
             return result
         except Exception as e:
-            logger.error(f"🧠 Error in evaluation node: {e}")
+            logger.error("error_in_evaluation_node", e=e)
             return AgentResult(success=False, message=f"Evaluation failed: {str(e)}", data={"error": str(e)})
 
     @staticmethod
@@ -86,8 +86,8 @@ async def evaluate_acknowledgment(
         Intelligently evaluate an acknowledgment request based on rule descriptions and context.
         """
         try:
-            logger.info(f"🧠 Evaluating acknowledgment request from {commenter}")
-            logger.info(f"🧠 Reason: {acknowledgment_reason}")
+            logger.info("evaluating_acknowledgment_request_from", commenter=commenter)
+            logger.info("reason", acknowledgment_reason=acknowledgment_reason)
             logger.info(f"🧠 Violations to evaluate: {len(violations)}")
 
             # Validate inputs
@@ -102,7 +102,7 @@ async def evaluate_acknowledgment(
             evaluation_prompt = create_evaluation_prompt(acknowledgment_reason, violations, pr_data, commenter, rules)
 
             # Get LLM evaluation with structured output
-            logger.info("🧠 Requesting LLM evaluation with structured output...")
+            logger.info("requesting_llm_evaluation_with_structured_output")
 
             # Use the same pattern as other agents: direct get_chat_model call
             llm = get_chat_model(agent="acknowledgment_agent")
@@ -112,12 +112,12 @@ async def evaluate_acknowledgment(
             structured_result = await self._execute_with_timeout(structured_llm.ainvoke(messages), timeout=self.timeout)
 
             if not structured_result:
-                logger.error("🧠 Empty LLM response received")
+                logger.error("empty_llm_response_received")
                 return AgentResult(
                     success=False, message="Empty response from LLM", data={"error": "LLM returned empty response"}
                 )
 
-            logger.info("🧠 Successfully received structured LLM evaluation result")
+            logger.info("successfully_received_structured_llm_evaluation_result")
 
             # Map LLM decisions back to original violations using rule_description
             acknowledgable_violations = []
@@ -138,11 +138,9 @@ async def evaluate_acknowledgment(
                     # Fallback: try to find by rule_description
                     original_violation = self._find_violation_by_rule_description(rule_description, violations)
                     if original_violation:
-                        logger.info(f"🧠 Found violation by rule description: '{rule_description}'")
+                        logger.info("found_violation_by_rule_description", rule_description=rule_description)
                     else:
-                        logger.warning(
-                            f"🧠 LLM returned rule_description '{rule_description}' not found in original violations"
-                        )
+                        logger.warning("llm_returned_ruledescription_not_found_in", rule_description=rule_description)
 
                 if original_violation:
                     violation_copy = original_violation.copy()
@@ -168,24 +166,22 @@ async def evaluate_acknowledgment(
                     # Fallback: try to find by rule_description
                     original_violation = self._find_violation_by_rule_description(rule_description, violations)
                     if original_violation:
-                        logger.info(f"🧠 Found violation by rule description: '{rule_description}'")
+                        logger.info("found_violation_by_rule_description", rule_description=rule_description)
                     else:
-                        logger.warning(
-                            f"🧠 LLM returned rule_description '{rule_description}' not found in original violations"
-                        )
+                        logger.warning("llm_returned_ruledescription_not_found_in", rule_description=rule_description)
 
                 if original_violation:
                     violation_copy = original_violation.copy()
                     # Add fix-specific fields
                     violation_copy.update({"fix_reason": llm_violation.reason, "priority": llm_violation.priority})
                     require_fixes.append(violation_copy)
 
-            logger.info("🧠 Intelligent evaluation completed:")
-            logger.info(f"    Valid: {structured_result.is_valid}")
-            logger.info(f"    Reasoning: {structured_result.reasoning}")
+            logger.info("intelligent_evaluation_completed")
+            logger.info("valid", is_valid=structured_result.is_valid)
+            logger.info("reasoning", reasoning=structured_result.reasoning)
             logger.info(f"    Acknowledged violations: {len(acknowledgable_violations)}")
             logger.info(f"    Require fixes: {len(require_fixes)}")
-            logger.info(f"    Confidence: {structured_result.confidence}")
+            logger.info("confidence", confidence=structured_result.confidence)
 
             return AgentResult(
                 success=True,
@@ -201,7 +197,7 @@ async def evaluate_acknowledgment(
             )
 
         except Exception as e:
-            logger.error(f"🧠 Error in acknowledgment evaluation: {e}")
+            logger.error("error_in_acknowledgment_evaluation", e=e)
             import traceback
 
             logger.error(f"🧠 Traceback: {traceback.format_exc()}")
@@ -228,7 +224,7 @@ async def execute(self, **kwargs: Any) -> AgentResult:
                 rules=rules,
             )
 
-        logger.warning("🧠 execute() method called on AcknowledgmentAgent with missing arguments")
+        logger.warning("execute_method_called_on_acknowledgmentagent_with")
         return AgentResult(
             success=False, message="AcknowledgmentAgent requires specific arguments for execute()", data={}
         )

src/agents/acknowledgment_agent/test_agent.py

@@ -6,12 +6,13 @@
 import logging
 
 import pytest
+import structlog
 
 from src.agents.acknowledgment_agent.agent import AcknowledgmentAgent
 
 # Set up logging
 logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
+logger = structlog.get_logger()
 
 
 @pytest.mark.asyncio
@@ -72,7 +73,7 @@ async def test_acknowledgment_agent() -> None:
         },
     ]
 
-    logger.info("🧠 Testing Intelligent Acknowledgment Agent...")
+    logger.info("testing_intelligent_acknowledgment_agent")
 
     try:
         # Test evaluation
@@ -85,7 +86,7 @@ async def test_acknowledgment_agent() -> None:
         )
 
         if result.success:
-            logger.info("✅ Acknowledgment evaluation completed successfully")
+            logger.info("acknowledgment_evaluation_completed_successfully")
             logger.info(f"   Valid: {result.data.get('is_valid', False)}")
             logger.info(f"   Reasoning: {result.data.get('reasoning', 'No reasoning')}")
             logger.info(f"   Acknowledged violations: {len(result.data.get('acknowledgable_violations', []))}")
@@ -94,25 +95,25 @@ async def test_acknowledgment_agent() -> None:
 
             # Print detailed results
             if result.data.get("acknowledgable_violations"):
-                logger.info("\n📋 Acknowledged Violations:")
+                logger.info("n_acknowledged_violations")
                 for violation in result.data["acknowledgable_violations"]:
                     logger.info(f"   • {violation.get('rule_name')} - {violation.get('reason')}")
 
             if result.data.get("require_fixes"):
-                logger.info("\n⚠️ Violations Requiring Fixes:")
+                logger.info("n_violations_requiring_fixes")
                 for violation in result.data["require_fixes"]:
                     logger.info(f"   • {violation.get('rule_name')} - {violation.get('reason')}")
 
             if result.data.get("recommendations"):
-                logger.info("\n💡 Recommendations:")
+                logger.info("n_recommendations")
                 for rec in result.data["recommendations"]:
-                    logger.info(f"   • {rec}")
+                    logger.info("event", rec=rec)
 
         else:
-            logger.error(f"❌ Acknowledgment evaluation failed: {result.message}")
+            logger.error("acknowledgment_evaluation_failed", message=result.message)
 
     except Exception as e:
-        logger.error(f"❌ Test failed with error: {e}")
+        logger.error("test_failed_with_error", e=e)
 
 
 if __name__ == "__main__":

src/agents/base.py

@@ -2,15 +2,15 @@
 Base agent classes and utilities for agents.
 """
 
-import logging
 from abc import ABC, abstractmethod
 from typing import Any, TypeVar, cast
 
+import structlog
 from pydantic import BaseModel, Field
 
 from src.core.utils.timeout import execute_with_timeout
 
-logger = logging.getLogger(__name__)
+logger = structlog.get_logger()
 
 T = TypeVar("T")
 
@@ -44,7 +44,7 @@ def __init__(self, max_retries: int = 3, retry_delay: float = 1.0, agent_name: s
 
         self.llm = get_chat_model(agent=agent_name)
         self.graph = self._build_graph()
-        logger.info(f"🔧 {self.__class__.__name__} initialized with max_retries={max_retries}, agent_name={agent_name}")
+        logger.info("initialized_with_maxretries_agentname", __name__=self.__class__.__name__, max_retries=max_retries, agent_name=agent_name)
 
     @abstractmethod
     def _build_graph(self) -> Any:

src/agents/engine_agent/agent.py

@@ -4,10 +4,10 @@
 Focuses on rule descriptions and parameters, using fast validators with LLM reasoning as fallback.
 """
 
-import logging
 import time
 from typing import Any
 
+import structlog
 from langgraph.graph import END, START, StateGraph
 
 from src.agents.base import AgentResult, BaseAgent
@@ -29,7 +29,7 @@
 )
 from src.rules.registry import AVAILABLE_CONDITIONS
 
-logger = logging.getLogger(__name__)
+logger = structlog.get_logger()
 
 
 class RuleEngineAgent(BaseAgent):
@@ -48,9 +48,9 @@ def __init__(self, max_retries: int = 3, timeout: float = 300.0):
         super().__init__(max_retries=max_retries, agent_name="engine_agent")
         self.timeout = timeout
 
-        logger.info("🔧 Rule Engine agent initializing...")
+        logger.info("rule_engine_agent_initializing")
         logger.info(f"🔧 Available validators: {len(AVAILABLE_CONDITIONS)}")
-        logger.info("🔧 Validation strategy: Hybrid (validators + LLM fallback)")
+        logger.info("validation_strategy_hybrid_validators_llm_fallback")
 
     def _build_graph(self) -> Any:
         """Build the LangGraph workflow for hybrid rule evaluation."""
@@ -118,13 +118,13 @@ async def execute(self, **kwargs: Any) -> AgentResult:
                 llm_usage=0,
             )
 
-            logger.info("🔧 Rule Engine initial state prepared")
+            logger.info("rule_engine_initial_state_prepared")
 
             # Run the hybrid graph with timeout
             result = await self._execute_with_timeout(self.graph.ainvoke(initial_state), timeout=self.timeout)
 
             execution_time = time.time() - start_time
-            logger.info(f"🔧 Rule Engine evaluation completed in {execution_time:.2f}s")
+            logger.info("rule_engine_evaluation_completed_in_s")
 
             # Extract violations from result
             violations = []
@@ -164,9 +164,9 @@ async def execute(self, **kwargs: Any) -> AgentResult:
                 llm_usage=result.llm_usage if hasattr(result, "llm_usage") else 0,
             )
 
-            logger.info("🔧 Rule Engine evaluation completed successfully")
-            logger.info(f"🔧 Validator usage: {evaluation_result.validator_usage}")
-            logger.info(f"🔧 LLM usage: {evaluation_result.llm_usage} calls")
+            logger.info("rule_engine_evaluation_completed_successfully")
+            logger.info("validator_usage", validator_usage=evaluation_result.validator_usage)
+            logger.info("llm_usage_calls", llm_usage=evaluation_result.llm_usage)
 
             return AgentResult(
                 success=len(violations) == 0,
@@ -181,7 +181,7 @@ async def execute(self, **kwargs: Any) -> AgentResult:
             )
         except Exception as e:
             execution_time = time.time() - start_time
-            logger.error(f"🔧 Error in Rule Engine evaluation: {e}")
+            logger.error("error_in_rule_engine_evaluation", e=e)
             return AgentResult(
                 success=False,
                 message=f"Rule Engine evaluation failed: {str(e)}",
@@ -271,5 +271,5 @@ async def evaluate(
 
     async def evaluate_pull_request(self, rules: list[Any], event_data: dict[str, Any]) -> dict[str, Any]:
         """Legacy method for backwards compatibility."""
-        logger.warning("evaluate_pull_request is deprecated. Use evaluate() with event_type='pull_request'")
+        logger.warning("evaluatepullrequest_is_deprecated_use_evaluate_with")
         return await self.evaluate("pull_request", rules, event_data, "")

src/agents/engine_agent/models.py

@@ -4,7 +4,7 @@
 
 from __future__ import annotations
 
-from enum import Enum
+from enum import StrEnum
 from typing import Any
 
 from pydantic import BaseModel, ConfigDict, Field
@@ -24,7 +24,7 @@ class EngineRequest(BaseModel):
     model_config = ConfigDict(arbitrary_types_allowed=True)
 
 
-class ValidationStrategy(str, Enum):
+class ValidationStrategy(StrEnum):
     """Validation strategies for rule evaluation."""
 
     VALIDATOR = "validator"  # Use fast validator