refactor: Remove redundant try/except around opentelemetry imports

Use module-level tracer instead of defensive inline imports in
knowledge_agent.py, runbook_generator.py, and knowledge_base.py.
Also update test for two ChatOpenAI instances in SRELangGraphAgent.

Author: abrookins

redis_sre_agent/agent/knowledge_agent.py

@@ -147,19 +147,10 @@ def _sanitize_messages_for_llm(msgs: list[BaseMessage]) -> list[BaseMessage]:
                 return clean
 
             # OTel: capture sanitize phase
-            try:
-                from opentelemetry import trace as _otel_trace  # type: ignore
-
-                _tr = _otel_trace.get_tracer(__name__)
-            except Exception:
-                _tr = None  # type: ignore
             _pre_count = len(messages)
-            if _tr:
-                with _tr.start_as_current_span(
-                    "knowledge.agent.sanitize", attributes={"messages.pre": _pre_count}
-                ):
-                    messages = _sanitize_messages_for_llm(messages)
-            else:
+            with tracer.start_as_current_span(
+                "knowledge.agent.sanitize", attributes={"messages.pre": _pre_count}
+            ):
                 messages = _sanitize_messages_for_llm(messages)
 
             try:

redis_sre_agent/agent/langgraph_agent.py

@@ -320,12 +320,18 @@ def __init__(self, progress_callback=None):
         """Initialize the SRE LangGraph agent."""
         self.settings = settings
         self.progress_callback = progress_callback
-        # Single LLM with both reasoning and function calling capabilities
+        # LLM with both reasoning and function calling capabilities
         self.llm = ChatOpenAI(
             model=self.settings.openai_model,
             openai_api_key=self.settings.openai_api_key,
             timeout=self.settings.llm_timeout,
         )
+        # Faster LLM for utility tasks
+        self.mini_llm = ChatOpenAI(
+            model=self.settings.openai_model_mini,
+            openai_api_key=self.settings.openai_api_key,
+            timeout=self.settings.llm_timeout,
+        )
 
         # Tools will be loaded per-query using ToolManager
         # No tools bound at initialization - they're bound per conversation
@@ -920,7 +926,9 @@ def _parse_tool_json_blocks(tool_msg_text: str) -> Optional[dict]:
             try:
                 from .models import TopicsList
 
-                extractor_llm = self.llm.with_structured_output(TopicsList)  # return TopicsList
+                extractor_llm = self.mini_llm.with_structured_output(
+                    TopicsList
+                )  # return TopicsList
                 instance_ctx = {
                     "instance_type": target_instance.instance_type,
                     "name": target_instance.name,
@@ -990,12 +998,7 @@ def _sev_score(t: dict) -> int:
                 knowledge_tools = tool_mgr.get_tools_for_capability(_ToolCap.KNOWLEDGE)
                 knowledge_adapters = await _build_adapters(tool_mgr, knowledge_tools)
                 if knowledge_adapters:
-                    knowledge_llm_base = ChatOpenAI(
-                        model=self.settings.openai_model_mini,
-                        openai_api_key=self.settings.openai_api_key,
-                        timeout=self.settings.llm_timeout,
-                    )
-                    knowledge_llm = knowledge_llm_base.bind_tools(knowledge_adapters)
+                    knowledge_llm = self.mini_llm.bind_tools(knowledge_adapters)
 
                 if knowledge_adapters:
                     logger.info(

redis_sre_agent/tools/knowledge/knowledge_base.py

@@ -272,24 +272,16 @@ async def ingest(
             kwargs["product_labels"] = product_labels
 
         # OTel: instrument ingestion
-        try:
-            from opentelemetry import trace as _otel_trace  # type: ignore
-
-            _tr = _otel_trace.get_tracer(__name__)
-        except Exception:
-            _tr = None  # type: ignore
-        if _tr:
-            with _tr.start_as_current_span(
-                "tool.knowledge.ingest",
-                attributes={
-                    "title.len": len(title or ""),
-                    "category": str(category or ""),
-                    "has.labels": bool(product_labels),
-                    "has.severity": bool(severity),
-                },
-            ):
-                return await _ingest_sre_document(**kwargs)
-        return await _ingest_sre_document(**kwargs)
+        with tracer.start_as_current_span(
+            "tool.knowledge.ingest",
+            attributes={
+                "title.len": len(title or ""),
+                "category": str(category or ""),
+                "has.labels": bool(product_labels),
+                "has.severity": bool(severity),
+            },
+        ):
+            return await _ingest_sre_document(**kwargs)
 
     async def get_all_fragments(self, document_hash: str) -> Dict[str, Any]:
         """Get all fragments of a document.
@@ -301,19 +293,11 @@ async def get_all_fragments(self, document_hash: str) -> Dict[str, Any]:
             Dictionary with all document fragments
         """
         logger.info(f"Getting all fragments for document: {document_hash}")
-        try:
-            from opentelemetry import trace as _otel_trace  # type: ignore
-
-            _tr = _otel_trace.get_tracer(__name__)
-        except Exception:
-            _tr = None  # type: ignore
-        if _tr:
-            with _tr.start_as_current_span(
-                "tool.knowledge.get_all_fragments",
-                attributes={"document_hash": str(document_hash)[:16]},
-            ):
-                return await get_all_document_fragments(document_hash)
-        return await get_all_document_fragments(document_hash)
+        with tracer.start_as_current_span(
+            "tool.knowledge.get_all_fragments",
+            attributes={"document_hash": str(document_hash)[:16]},
+        ):
+            return await get_all_document_fragments(document_hash)
 
     async def get_related_fragments(
         self, document_hash: str, chunk_index: int, limit: int = 10
@@ -329,20 +313,12 @@ async def get_related_fragments(
             Dictionary with related fragments
         """
         logger.info(f"Getting related fragments for document {document_hash}, chunk {chunk_index}")
-        try:
-            from opentelemetry import trace as _otel_trace  # type: ignore
-
-            _tr = _otel_trace.get_tracer(__name__)
-        except Exception:
-            _tr = None  # type: ignore
-        if _tr:
-            with _tr.start_as_current_span(
-                "tool.knowledge.get_related_fragments",
-                attributes={
-                    "document_hash": str(document_hash)[:16],
-                    "chunk_index": int(chunk_index),
-                    "limit": int(limit),
-                },
-            ):
-                return await get_related_document_fragments(document_hash, chunk_index, limit)
-        return await get_related_document_fragments(document_hash, chunk_index, limit)
+        with tracer.start_as_current_span(
+            "tool.knowledge.get_related_fragments",
+            attributes={
+                "document_hash": str(document_hash)[:16],
+                "chunk_index": int(chunk_index),
+                "limit": int(limit),
+            },
+        ):
+            return await get_related_document_fragments(document_hash, chunk_index, limit)

tests/unit/agent/test_temperature_removal.py

@@ -43,16 +43,15 @@ def test_langgraph_agent_no_temperature(self, mock_chat_openai):
 
         SRELangGraphAgent()
 
-        # Verify ChatOpenAI was called without temperature
-        mock_chat_openai.assert_called_once()
-        call_args = mock_chat_openai.call_args
-
-        # Check that temperature is not in the arguments
-        assert "temperature" not in call_args.kwargs
-
-        # Verify required arguments are present
-        assert "model" in call_args.kwargs
-        assert "openai_api_key" in call_args.kwargs
+        # Verify ChatOpenAI was called twice (self.llm and self.mini_llm)
+        assert mock_chat_openai.call_count == 2
+
+        # Check all calls to ensure none use temperature
+        for call_args in mock_chat_openai.call_args_list:
+            assert "temperature" not in call_args.kwargs
+            # Verify required arguments are present
+            assert "model" in call_args.kwargs
+            assert "openai_api_key" in call_args.kwargs
 
     @patch("redis_sre_agent.evaluation.judge.ChatOpenAI")
     def test_judge_no_temperature(self, mock_chat_openai):