nvidia-nat 1.3.0a20250828__py3-none-any.whl → 1.3.0a20250830__py3-none-any.whl

nat/eval/intermediate_step_adapter.py

@@ -40,7 +40,7 @@ class IntermediateStepAdapter:
             try:
                 validated_steps.append(IntermediateStep.model_validate(step_data))
             except Exception as e:
-                logger.exception("Validation failed for step: %r, Error: %s", step_data, e, exc_info=True)
+                logger.exception("Validation failed for step: %r, Error: %s", step_data, e)
         return validated_steps
 
     def serialize_intermediate_steps(self, intermediate_steps: list[IntermediateStep]) -> list[dict]:

nat/eval/rag_evaluator/evaluate.py

@@ -102,7 +102,7 @@ class RAGEvaluator:
         """Converts the ragas EvaluationResult to nat EvalOutput"""
 
         if not results_dataset:
-            logger.error("Ragas evaluation failed with no results")
+            logger.error("Ragas evaluation failed with no results", exc_info=True)
             return EvalOutput(average_score=0.0, eval_output_items=[])
 
         scores: list[dict[str, float]] = results_dataset.scores
@@ -169,7 +169,7 @@ class RAGEvaluator:
                                              _pbar=pbar)
         except Exception as e:
             # On exception we still continue with other evaluators. Log and return an avg_score of 0.0
-            logger.exception("Error evaluating ragas metric, Error: %s", e, exc_info=True)
+            logger.exception("Error evaluating ragas metric, Error: %s", e)
             results_dataset = None
         finally:
             pbar.close()

nat/eval/rag_evaluator/register.py

@@ -104,7 +104,7 @@ async def register_ragas_evaluator(config: RagasEvaluatorConfig, builder: EvalBu
             raise ValueError(message) from e
         except AttributeError as e:
             message = f"Ragas metric {metric_name} not found {e}."
-            logger.error(message)
+            logger.exception(message)
             return None
 
     async def evaluate_fn(eval_input: EvalInput) -> EvalOutput:

nat/eval/remote_workflow.py

@@ -74,7 +74,7 @@ class EvaluationRemoteWorkflowHandler:
                             if chunk_data.get("value"):
                                 final_response = chunk_data.get("value")
                         except json.JSONDecodeError as e:
-                            logger.error("Failed to parse generate response chunk: %s", e)
+                            logger.exception("Failed to parse generate response chunk: %s", e)
                             continue
                     elif line.startswith(INTERMEDIATE_DATA_PREFIX):
                         # This is an intermediate step
@@ -90,12 +90,12 @@ class EvaluationRemoteWorkflowHandler:
                                                                  payload=payload)
                             intermediate_steps.append(intermediate_step)
                         except (json.JSONDecodeError, ValidationError) as e:
-                            logger.error("Failed to parse intermediate step: %s", e)
+                            logger.exception("Failed to parse intermediate step: %s", e)
                             continue
 
         except aiohttp.ClientError as e:
             # Handle connection or HTTP-related errors
-            logger.error("Request failed for question %s: %s", question, e)
+            logger.exception("Request failed for question %s: %s", question, e)
             item.output_obj = None
             item.trajectory = []
             return

nat/eval/swe_bench_evaluator/evaluate.py

@@ -69,13 +69,13 @@ class SweBenchEvaluator:
         try:
             shutil.move(swe_bench_report_file, report_dir)
         except Exception as e:
-            logger.exception("Error moving report file: %s", e, exc_info=True)
+            logger.exception("Error moving report file: %s", e)
 
         try:
             dest_logs_dir = os.path.join(report_dir, 'logs')
             shutil.move(logs_dir, dest_logs_dir)
         except Exception as e:
-            logger.exception("Error moving logs directory: %s", e, exc_info=True)
+            logger.exception("Error moving logs directory: %s", e)
 
     def is_repo_supported(self, repo: str, version: str) -> bool:
         """Check if the repo is supported by swebench"""
@@ -106,7 +106,7 @@ class SweBenchEvaluator:
                     self._model_name_or_path = swebench_output.model_name_or_path
 
             except Exception as e:
-                logger.exception("Failed to parse EvalInputItem %s: %s", item.id, e, exc_info=True)
+                logger.exception("Failed to parse EvalInputItem %s: %s", item.id, e)
 
         # Filter out repos/version not supported by SWEBench
         supported_inputs = [
@@ -114,7 +114,7 @@ class SweBenchEvaluator:
         ]
 
         if not supported_inputs:
-            logger.error("No supported instances; nothing to evaluate")
+            logger.exception("No supported instances; nothing to evaluate")
             return None, None
 
         if len(supported_inputs) < len(swebench_inputs):
@@ -135,7 +135,7 @@ class SweBenchEvaluator:
         filtered_outputs = [output for output in swebench_outputs if output.instance_id in valid_instance_ids]
 
         if not filtered_outputs:
-            logger.error("No supported outputs; nothing to evaluate")
+            logger.error("No supported outputs; nothing to evaluate", exc_info=True)
             return None, None
 
         # Write SWEBenchOutput to file

nat/eval/trajectory_evaluator/evaluate.py

@@ -65,7 +65,7 @@ class TrajectoryEvaluator(BaseEvaluator):
                 prediction=generated_answer,
             )
         except Exception as e:
-            logger.exception("Error evaluating trajectory for question: %s, Error: %s", question, e, exc_info=True)
+            logger.exception("Error evaluating trajectory for question: %s, Error: %s", question, e)
             return EvalOutputItem(id=item.id, score=0.0, reasoning=f"Error evaluating trajectory: {e}")
 
         reasoning = {

nat/eval/tunable_rag_evaluator/evaluate.py

@@ -182,8 +182,8 @@ class TunableRagEvaluator(BaseEvaluator):
                     relevance_score = parsed_response["relevance_score"]
                     reasoning = parsed_response["reasoning"]
                 except KeyError as e:
-                    logger.error("Missing required keys in default scoring response: %s",
-                                 ", ".join(str(arg) for arg in e.args))
+                    logger.exception("Missing required keys in default scoring response: %s",
+                                     ", ".join(str(arg) for arg in e.args))
                     reasoning = f"Error in evaluator from parsing judge LLM response. Missing required key(s): {', '.join(str(arg) for arg in e.args)}"
 
                 coverage_weight = self.default_score_weights.get("coverage", 1 / 3)
@@ -215,7 +215,7 @@ class TunableRagEvaluator(BaseEvaluator):
                     reasoning = f"Error in evaluator from parsing judge LLM response. Missing required key(s): {', '.join(str(arg) for arg in e.args)}"
                     raise
         except (KeyError, ValueError) as e:
-            logger.error("Error parsing judge LLM response: %s", e)
+            logger.exception("Error parsing judge LLM response: %s", e)
             score = 0.0
             reasoning = "Error in evaluator from parsing judge LLM response."
 

nat/experimental/test_time_compute/functions/ttc_tool_orchestration_function.py

@@ -148,13 +148,13 @@ async def register_ttc_tool_orchestration_function(
                 result = await fn.acall_invoke(item.output)
                 return item, result, None
             except Exception as e:
-                logger.error(f"Error invoking function '{item.name}': {e}")
+                logger.exception(f"Error invoking function '{item.name}': {e}")
                 return item, None, str(e)
 
         tasks = []
         for item in ttc_items:
             if item.name not in function_map:
-                logger.error(f"Function '{item.name}' not found in function map.")
+                logger.error(f"Function '{item.name}' not found in function map.", exc_info=True)
                 item.output = f"Error: Function '{item.name}' not found in function map. Check your input"
             else:
                 fn = function_map[item.name]

nat/front_ends/fastapi/fastapi_front_end_controller.py

@@ -47,11 +47,11 @@ class _FastApiFrontEndController:
             self._server_background_task = asyncio.create_task(self._server.serve())
         except asyncio.CancelledError as e:
             error_message = f"Task error occurred while starting API server: {str(e)}"
-            logger.error(error_message, exc_info=True)
+            logger.error(error_message)
             raise RuntimeError(error_message) from e
         except Exception as e:
             error_message = f"Unexpected error occurred while starting API server: {str(e)}"
-            logger.error(error_message, exc_info=True)
+            logger.exception(error_message)
             raise RuntimeError(error_message) from e
 
     async def stop_server(self) -> None:
@@ -63,6 +63,6 @@ class _FastApiFrontEndController:
             self._server.should_exit = True
             await self._server_background_task
         except asyncio.CancelledError as e:
-            logger.error("Server shutdown failed: %s", str(e), exc_info=True)
+            logger.exception("Server shutdown failed: %s", str(e))
         except Exception as e:
-            logger.error("Unexpected error occurred: %s", str(e), exc_info=True)
+            logger.exception("Unexpected error occurred: %s", str(e))

nat/front_ends/fastapi/fastapi_front_end_plugin.py

@@ -113,4 +113,4 @@ class FastApiFrontEndPlugin(FrontEndBase[FastApiFrontEndConfig]):
             try:
                 os.remove(config_file_name)
             except OSError as e:
-                logger.error(f"Warning: Failed to delete temp file {config_file_name}: {e}")
+                logger.exception(f"Warning: Failed to delete temp file {config_file_name}: {e}")

nat/front_ends/fastapi/fastapi_front_end_plugin_worker.py

@@ -215,7 +215,7 @@ class FastApiFrontEndPluginWorker(FastApiFrontEndPluginWorkerBase):
                 job_store.cleanup_expired_jobs()
                 logger.debug("Expired %s jobs cleaned up", name)
             except Exception as e:
-                logger.error("Error during %s job cleanup: %s", name, e)
+                logger.exception("Error during %s job cleanup: %s", name, e)
             await asyncio.sleep(sleep_time_sec)
 
     async def create_cleanup_task(self, app: FastAPI, name: str, job_store: JobStore, sleep_time_sec: int = 300):
@@ -301,7 +301,7 @@ class FastApiFrontEndPluginWorker(FastApiFrontEndPluginWorkerBase):
 
                         job_store.update_status(job_id, "success", output_path=str(parent_dir))
                 except Exception as e:
-                    logger.error("Error in evaluation job %s: %s", job_id, str(e))
+                    logger.exception("Error in evaluation job %s: %s", job_id, str(e))
                     job_store.update_status(job_id, "failure", error=str(e))
 
         async def start_evaluation(request: EvaluateRequest, background_tasks: BackgroundTasks, http_request: Request):
@@ -735,7 +735,7 @@ class FastApiFrontEndPluginWorker(FastApiFrontEndPluginWorkerBase):
                                                             result_type=result_type)
                     job_store.update_status(job_id, "success", output=result)
                 except Exception as e:
-                    logger.error("Error in evaluation job %s: %s", job_id, e)
+                    logger.exception("Error in evaluation job %s: %s", job_id, e)
                     job_store.update_status(job_id, "failure", error=str(e))
 
         def _job_status_to_response(job: JobInfo) -> AsyncGenerationStatusResponse:

nat/front_ends/fastapi/message_handler.py

@@ -170,7 +170,7 @@ class WebSocketMessageHandler:
                                            self._workflow_schema_type])).add_done_callback(_done_callback)
 
         except ValueError as e:
-            logger.error("User message content not found: %s", str(e), exc_info=True)
+            logger.exception("User message content not found: %s", str(e))
             await self.create_websocket_message(data_model=Error(code=ErrorTypes.INVALID_USER_MESSAGE_CONTENT,
                                                                  message="User message content could not be found",
                                                                  details=str(e)),
@@ -238,7 +238,7 @@ class WebSocketMessageHandler:
                     f"Message type could not be resolved by input data model: {data_model.model_dump_json()}")
 
         except (ValidationError, TypeError, ValueError) as e:
-            logger.error("A data vaidation error ocurred creating websocket message: %s", str(e), exc_info=True)
+            logger.exception("A data vaidation error ocurred creating websocket message: %s", str(e))
             message = await self._message_validator.create_system_response_token_message(
                 message_type=WebSocketMessageType.ERROR_MESSAGE,
                 conversation_id=self._conversation_id,

nat/front_ends/fastapi/message_validator.py

@@ -97,7 +97,7 @@ class MessageValidator:
             return validated_message
 
         except (ValidationError, TypeError, ValueError) as e:
-            logger.error("A data validation error %s occurred for message: %s", str(e), str(message), exc_info=True)
+            logger.exception("A data validation error %s occurred for message: %s", str(e), str(message))
             return await self.create_system_response_token_message(message_type=WebSocketMessageType.ERROR_MESSAGE,
                                                                    content=Error(code=ErrorTypes.INVALID_MESSAGE,
                                                                                  message="Error validating message.",
@@ -119,7 +119,7 @@ class MessageValidator:
             return schema
 
         except (TypeError, ValueError) as e:
-            logger.error("Error retrieving schema for message type '%s': %s", message_type, str(e), exc_info=True)
+            logger.exception("Error retrieving schema for message type '%s': %s", message_type, str(e))
             return Error
 
     async def convert_data_to_message_content(self, data_model: BaseModel) -> BaseModel:
@@ -156,7 +156,7 @@ class MessageValidator:
             return validated_message_content
 
         except ValueError as e:
-            logger.error("Input data could not be converted to validated message content: %s", str(e), exc_info=True)
+            logger.exception("Input data could not be converted to validated message content: %s", str(e))
             return Error(code=ErrorTypes.INVALID_DATA_CONTENT, message="Input data not supported.", details=str(e))
 
     async def convert_text_content_to_human_response(self, text_content: TextContent,
@@ -191,7 +191,7 @@ class MessageValidator:
             return human_response
 
         except ValueError as e:
-            logger.error("Error human response content not found: %s", str(e), exc_info=True)
+            logger.exception("Error human response content not found: %s", str(e))
             return HumanResponseText(text=str(e))
 
     async def resolve_message_type_by_data(self, data_model: BaseModel) -> str:
@@ -218,9 +218,7 @@ class MessageValidator:
             return validated_message_type
 
         except ValueError as e:
-            logger.error("Error type not found converting data to validated websocket message content: %s",
-                         str(e),
-                         exc_info=True)
+            logger.exception("Error type not found converting data to validated websocket message content: %s", str(e))
             return WebSocketMessageType.ERROR_MESSAGE
 
     async def get_intermediate_step_parent_id(self, data_model: ResponseIntermediateStep) -> str:
@@ -269,7 +267,7 @@ class MessageValidator:
                                                        timestamp=timestamp)
 
         except Exception as e:
-            logger.error("Error creating system response token message: %s", str(e), exc_info=True)
+            logger.exception("Error creating system response token message: %s", str(e))
             return None
 
     async def create_system_intermediate_step_message(
@@ -308,7 +306,7 @@ class MessageValidator:
                                                           timestamp=timestamp)
 
         except Exception as e:
-            logger.error("Error creating system intermediate step message: %s", str(e), exc_info=True)
+            logger.exception("Error creating system intermediate step message: %s", str(e))
             return None
 
     async def create_system_interaction_message(
@@ -348,5 +346,5 @@ class MessageValidator:
                                                      timestamp=timestamp)
 
         except Exception as e:
-            logger.error("Error creating system interaction message: %s", str(e), exc_info=True)
+            logger.exception("Error creating system interaction message: %s", str(e))
             return None

nat/front_ends/fastapi/response_helpers.py

@@ -98,9 +98,9 @@ async def generate_streaming_response(payload: typing.Any,
                     yield item
                 else:
                     yield ResponsePayloadOutput(payload=item)
-        except Exception as e:
+        except Exception:
             # Handle exceptions here
-            raise e
+            raise
         finally:
             await q.close()
 
@@ -165,9 +165,9 @@ async def generate_streaming_response_full(payload: typing.Any,
                         yield item
                 else:
                     yield ResponsePayloadOutput(payload=item)
-        except Exception as e:
+        except Exception:
             # Handle exceptions here
-            raise e
+            raise
         finally:
             await q.close()
 

nat/front_ends/fastapi/step_adaptor.py

@@ -314,6 +314,6 @@ class StepAdaptor:
                 return self._handle_custom(payload, ancestry)
 
         except Exception as e:
-            logger.error("Error processing intermediate step: %s", e, exc_info=True)
+            logger.exception("Error processing intermediate step: %s", e)
 
         return None

nat/front_ends/mcp/mcp_front_end_config.py

@@ -13,6 +13,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from typing import Literal
+
 from pydantic import Field
 
 from nat.data_models.front_end import FrontEndBaseConfig
@@ -32,5 +34,8 @@ class MCPFrontEndConfig(FrontEndBaseConfig, name="mcp"):
     log_level: str = Field(default="INFO", description="Log level for the MCP server (default: INFO)")
     tool_names: list[str] = Field(default_factory=list,
                                   description="The list of tools MCP server will expose (default: all tools)")
+    transport: Literal["sse", "streamable-http"] = Field(
+        default="streamable-http",
+        description="Transport type for the MCP server (default: streamable-http, backwards compatible with sse)")
     runner_class: str | None = Field(
         default=None, description="Custom worker class for handling MCP routes (default: built-in worker)")

nat/front_ends/mcp/mcp_front_end_plugin.py

@@ -77,5 +77,11 @@ class MCPFrontEndPlugin(FrontEndBase[MCPFrontEndConfig]):
             # Add routes through the worker (includes health endpoint and function registration)
             await worker.add_routes(mcp, builder)
 
-            # Start the MCP server
-            await mcp.run_sse_async()
+            # Start the MCP server with configurable transport
+            # streamable-http is the default, but users can choose sse if preferred
+            if self.front_end_config.transport == "sse":
+                logger.info("Starting MCP server with SSE endpoint at /sse")
+                await mcp.run_sse_async()
+            else:  # streamable-http
+                logger.info("Starting MCP server with streamable-http endpoint at /mcp/")
+                await mcp.run_streamable_http_async()

nat/front_ends/mcp/mcp_front_end_plugin_worker.py

@@ -134,9 +134,9 @@ class MCPFrontEndPluginWorker(MCPFrontEndPluginWorkerBase):
                     logger.debug("Skipping function %s as it's not in tool_names", function_name)
             functions = filtered_functions
 
-        # Register each function with MCP
+        # Register each function with MCP, passing workflow context for observability
         for function_name, function in functions.items():
-            register_function_with_mcp(mcp, function_name, function)
+            register_function_with_mcp(mcp, function_name, function, workflow)
 
         # Add a simple fallback function if no functions were found
         if not functions:

nat/front_ends/mcp/tool_converter.py

@@ -17,13 +17,17 @@ import json
 import logging
 from inspect import Parameter
 from inspect import Signature
+from typing import TYPE_CHECKING
 
 from mcp.server.fastmcp import FastMCP
 from pydantic import BaseModel
 
+from nat.builder.context import ContextState
 from nat.builder.function import Function
 from nat.builder.function_base import FunctionBase
-from nat.builder.workflow import Workflow
+
+if TYPE_CHECKING:
+    from nat.builder.workflow import Workflow
 
 logger = logging.getLogger(__name__)
 
@@ -33,14 +37,16 @@ def create_function_wrapper(
     function: FunctionBase,
     schema: type[BaseModel],
     is_workflow: bool = False,
+    workflow: 'Workflow | None' = None,
 ):
     """Create a wrapper function that exposes the actual parameters of a NAT Function as an MCP tool.
 
     Args:
-        function_name: The name of the function/tool
-        function: The NAT Function object
-        schema: The input schema of the function
-        is_workflow: Whether the function is a Workflow
+        function_name (str): The name of the function/tool
+        function (FunctionBase): The NAT Function object
+        schema (type[BaseModel]): The input schema of the function
+        is_workflow (bool): Whether the function is a Workflow
+        workflow (Workflow | None): The parent workflow for observability context
 
     Returns:
         A wrapper function suitable for registration with MCP
@@ -101,6 +107,19 @@ def create_function_wrapper(
                 await ctx.report_progress(0, 100)
 
             try:
+                # Helper function to wrap function calls with observability
+                async def call_with_observability(func_call):
+                    # Use workflow's observability context (workflow should always be available)
+                    if not workflow:
+                        logger.error("Missing workflow context for function %s - observability will not be available",
+                                     function_name)
+                        raise RuntimeError("Workflow context is required for observability")
+
+                    logger.debug("Starting observability context for function %s", function_name)
+                    context_state = ContextState.get()
+                    async with workflow.exporter_manager.start(context_state=context_state):
+                        return await func_call()
+
                 # Special handling for ChatRequest
                 if is_chat_request:
                     from nat.data_models.api_server import ChatRequest
@@ -118,7 +137,7 @@ def create_function_wrapper(
                             result = await runner.result(to_type=str)
                     else:
                         # Regular functions use ainvoke
-                        result = await function.ainvoke(chat_request, to_type=str)
+                        result = await call_with_observability(lambda: function.ainvoke(chat_request, to_type=str))
                 else:
                     # Regular handling
                     # Handle complex input schema - if we extracted fields from a nested schema,
@@ -129,7 +148,7 @@ def create_function_wrapper(
                         field_type = schema.model_fields[field_name].annotation
 
                         # If it's a pydantic model, we need to create an instance
-                        if hasattr(field_type, "model_validate"):
+                        if field_type and hasattr(field_type, "model_validate"):
                             # Create the nested object
                             nested_obj = field_type.model_validate(kwargs)
                             # Call with the nested object
@@ -147,7 +166,7 @@ def create_function_wrapper(
                             result = await runner.result(to_type=str)
                     else:
                         # Regular function call
-                        result = await function.acall_invoke(**kwargs)
+                        result = await call_with_observability(lambda: function.acall_invoke(**kwargs))
 
                 # Report completion
                 if ctx:
@@ -170,7 +189,7 @@ def create_function_wrapper(
     wrapper = create_wrapper()
 
     # Set the signature on the wrapper function (WITHOUT ctx)
-    wrapper.__signature__ = sig
+    wrapper.__signature__ = sig  # type: ignore
     wrapper.__name__ = function_name
 
     # Return the wrapper with proper signature
@@ -183,8 +202,8 @@ def get_function_description(function: FunctionBase) -> str:
 
     The description is determined using the following precedence:
        1. If the function is a Workflow and has a 'description' attribute, use it.
-       2. If the Workflow's config has a 'topic', use it.
-       3. If the Workflow's config has a 'description', use it.
+       2. If the Workflow's config has a 'description', use it.
+       3. If the Workflow's config has a 'topic', use it.
        4. If the function is a regular Function, use its 'description' attribute.
 
     Args:
@@ -195,6 +214,9 @@ def get_function_description(function: FunctionBase) -> str:
     """
     function_description = ""
 
+    # Import here to avoid circular imports
+    from nat.builder.workflow import Workflow
+
     if isinstance(function, Workflow):
         config = function.config
 
@@ -214,13 +236,17 @@ def get_function_description(function: FunctionBase) -> str:
     return function_description
 
 
-def register_function_with_mcp(mcp: FastMCP, function_name: str, function: FunctionBase) -> None:
+def register_function_with_mcp(mcp: FastMCP,
+                               function_name: str,
+                               function: FunctionBase,
+                               workflow: 'Workflow | None' = None) -> None:
     """Register a NAT Function as an MCP tool.
 
     Args:
         mcp: The FastMCP instance
         function_name: The name to register the function under
         function: The NAT Function to register
+        workflow: The parent workflow for observability context (if available)
     """
     logger.info("Registering function %s with MCP", function_name)
 
@@ -229,6 +255,7 @@ def register_function_with_mcp(mcp: FastMCP, function_name: str, function: Funct
     logger.info("Function %s has input schema: %s", function_name, input_schema)
 
     # Check if we're dealing with a Workflow
+    from nat.builder.workflow import Workflow
     is_workflow = isinstance(function, Workflow)
     if is_workflow:
         logger.info("Function %s is a Workflow", function_name)
@@ -237,5 +264,5 @@ def register_function_with_mcp(mcp: FastMCP, function_name: str, function: Funct
     function_description = get_function_description(function)
 
     # Create and register the wrapper function with MCP
-    wrapper_func = create_function_wrapper(function_name, function, input_schema, is_workflow)
+    wrapper_func = create_function_wrapper(function_name, function, input_schema, is_workflow, workflow)
     mcp.tool(name=function_name, description=function_description)(wrapper_func)

nat/observability/exporter/base_exporter.py

@@ -375,7 +375,7 @@ class BaseExporter(Exporter):
         except asyncio.TimeoutError:
             logger.warning("%s: Some tasks did not complete within %s seconds", self.name, timeout)
         except Exception as e:
-            logger.error("%s: Error while waiting for tasks: %s", self.name, e, exc_info=True)
+            logger.exception("%s: Error while waiting for tasks: %s", self.name, e)
 
     @override
     async def stop(self):

nat/observability/exporter/processing_exporter.py

@@ -175,7 +175,7 @@ class ProcessingExporter(Generic[PipelineInputT, PipelineOutputT], BaseExporter,
             try:
                 processed_item = await processor.process(processed_item)
             except Exception as e:
-                logger.error("Error in processor %s: %s", processor.__class__.__name__, e, exc_info=True)
+                logger.exception("Error in processor %s: %s", processor.__class__.__name__, e)
                 # Continue with unprocessed item rather than failing
         return processed_item
 
@@ -214,7 +214,7 @@ class ProcessingExporter(Generic[PipelineInputT, PipelineOutputT], BaseExporter,
             try:
                 source_index = self._processors.index(source_processor)
             except ValueError:
-                logger.error("Source processor %s not found in pipeline", source_processor.__class__.__name__)
+                logger.exception("Source processor %s not found in pipeline", source_processor.__class__.__name__)
                 return
 
             # Process through remaining processors (skip the source processor)
@@ -225,10 +225,9 @@ class ProcessingExporter(Generic[PipelineInputT, PipelineOutputT], BaseExporter,
             await self._export_final_item(processed_item)
 
         except Exception as e:
-            logger.error("Failed to continue pipeline processing after %s: %s",
-                         source_processor.__class__.__name__,
-                         e,
-                         exc_info=True)
+            logger.exception("Failed to continue pipeline processing after %s: %s",
+                             source_processor.__class__.__name__,
+                             e)
 
     async def _export_with_processing(self, item: PipelineInputT) -> None:
         """Export an item after processing it through the pipeline.
@@ -248,7 +247,7 @@ class ProcessingExporter(Generic[PipelineInputT, PipelineOutputT], BaseExporter,
             await self._export_final_item(final_item, raise_on_invalid=True)
 
         except Exception as e:
-            logger.error("Failed to export item '%s': %s", item, e, exc_info=True)
+            logger.error("Failed to export item '%s': %s", item, e)
             raise
 
     @override
@@ -293,7 +292,7 @@ class ProcessingExporter(Generic[PipelineInputT, PipelineOutputT], BaseExporter,
             task.add_done_callback(self._tasks.discard)
 
         except Exception as e:
-            logger.error("%s: Failed to create task: %s", self.name, e, exc_info=True)
+            logger.error("%s: Failed to create task: %s", self.name, e)
             raise
 
     @override
@@ -316,7 +315,7 @@ class ProcessingExporter(Generic[PipelineInputT, PipelineOutputT], BaseExporter,
                 await asyncio.gather(*shutdown_tasks, return_exceptions=True)
                 logger.debug("Successfully shut down %d processors", len(shutdown_tasks))
             except Exception as e:
-                logger.error("Error shutting down processors: %s", e, exc_info=True)
+                logger.exception("Error shutting down processors: %s", e)
 
         # Call parent cleanup
         await super()._cleanup()

nat/observability/exporter_manager.py

@@ -177,7 +177,7 @@ class ExporterManager:
                 else:
                     logger.debug("Skipping cleanup for non-isolated exporter '%s'", name)
             except Exception as e:
-                logger.error("Error preparing cleanup for isolated exporter '%s': %s", name, e)
+                logger.exception("Error preparing cleanup for isolated exporter '%s': %s", name, e)
 
         if cleanup_tasks:
             # Run cleanup tasks concurrently with timeout
@@ -195,7 +195,7 @@ class ExporterManager:
             logger.debug("Stopping isolated exporter '%s'", name)
             await exporter.stop()
         except Exception as e:
-            logger.error("Error stopping isolated exporter '%s': %s", name, e)
+            logger.exception("Error stopping isolated exporter '%s': %s", name, e)
 
     @asynccontextmanager
     async def start(self, context_state: ContextState | None = None):
@@ -251,7 +251,7 @@ class ExporterManager:
             try:
                 await self._cleanup_isolated_exporters()
             except Exception as e:
-                logger.error("Error during isolated exporter cleanup: %s", e)
+                logger.exception("Error during isolated exporter cleanup: %s", e)
 
             # Then stop the manager tasks
             await self.stop()
@@ -275,7 +275,7 @@ class ExporterManager:
             logger.info("Stopped exporter '%s'", name)
             raise
         except Exception as e:
-            logger.error("Failed to run exporter '%s': %s", name, str(e), exc_info=True)
+            logger.error("Failed to run exporter '%s': %s", name, str(e))
             # Re-raise the exception to ensure it's properly handled
             raise
 
@@ -307,7 +307,7 @@ class ExporterManager:
             except asyncio.CancelledError:
                 logger.debug("Exporter '%s' task cancelled", name)
             except Exception as e:
-                logger.error("Failed to stop exporter '%s': %s", name, str(e))
+                logger.exception("Failed to stop exporter '%s': %s", name, str(e))
 
         if stuck_tasks:
             logger.warning("Exporters did not shut down in time: %s", ", ".join(stuck_tasks))