nvidia-nat 1.3.0a20250827__py3-none-any.whl → 1.3.0a20250829__py3-none-any.whl

nat/llm/utils/thinking.py

@@ -0,0 +1,215 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import functools
+import inspect
+import logging
+import types
+from abc import abstractmethod
+from collections.abc import AsyncGenerator
+from collections.abc import Iterable
+from dataclasses import dataclass
+from typing import Any
+from typing import Callable
+from typing import TypeVar
+
+ModelType = TypeVar("ModelType")
+MessagesType = TypeVar("MessagesType")
+
+logger = logging.getLogger(__name__)
+
+
+class FunctionArgumentWrapper:
+    """
+    Wrapper for the arguments and keyword arguments of a function.
+
+    The arguments and keyword arguments are stored in the args and kwargs attributes, respectively.
+    """
+
+    def __init__(self, *args: Any, **kwargs: Any):
+        """
+        Initialize the FunctionArgumentWrapper.
+
+        Args:
+            args: The arguments to the function.
+            kwargs: The keyword arguments to the function.
+        """
+        self.args = args
+        self.kwargs = kwargs
+
+    def __repr__(self) -> str:
+        return f"FunctionArgumentWrapper(args={self.args}, kwargs={self.kwargs})"
+
+
+@dataclass
+class BaseThinkingInjector:
+    """
+    Base class for thinking injectors.
+
+    Args:
+        system_prompt: The system prompt to inject.
+        function_names: The function names to inject the system prompt into.
+    """
+
+    system_prompt: str
+    function_names: list[str]
+
+    @abstractmethod
+    def inject(self, *args, **kwargs) -> FunctionArgumentWrapper:
+        """
+        Inject the system prompt into the arguments.
+
+        Args:
+            args: The arguments to inject the system prompt into.
+            kwargs: The keyword arguments to inject the system prompt into.
+
+        Returns:
+            FunctionArgumentWrapper: An object that contains the transformed args and kwargs.
+        """
+        pass
+
+
+def _make_thinking_decorator(injector: BaseThinkingInjector):
+
+    def decorate(fn: Callable[..., Any]) -> Callable[..., Any]:
+
+        async def _call_async(obj: object, *call_args, **call_kwargs) -> Any:
+            new_args = injector.inject(*call_args, **call_kwargs)
+            return await fn(obj, *new_args.args, **new_args.kwargs)
+
+        async def _agen(obj: object, *call_args, **call_kwargs) -> AsyncGenerator[Any, None]:
+            new_args = injector.inject(*call_args, **call_kwargs)
+            async for item in fn(obj, *new_args.args, **new_args.kwargs):
+                yield item
+
+        def _gen(obj: object, *call_args, **call_kwargs) -> Iterable[Any]:
+            new_args = injector.inject(*call_args, **call_kwargs)
+            yield from fn(obj, *new_args.args, **new_args.kwargs)
+            return
+
+        def _sync(obj: object, *call_args, **call_kwargs) -> Any:
+            new_args = injector.inject(*call_args, **call_kwargs)
+            return fn(obj, *new_args.args, **new_args.kwargs)
+
+        # Decide which wrapper to return
+        if inspect.iscoroutinefunction(fn):
+            wrapper = _call_async
+        elif inspect.isasyncgenfunction(fn):
+            wrapper = _agen
+        elif inspect.isgeneratorfunction(fn):
+            wrapper = _gen
+        else:
+            wrapper = _sync
+
+        return functools.wraps(fn)(wrapper)
+
+    return decorate
+
+
+def patch_with_thinking(obj: ModelType, injector: BaseThinkingInjector) -> ModelType:
+    """
+    Patch the given object with a decorator that injects a system prompt into the supplied messages.
+    There is an assumption that the first non-object argument is the messages.
+
+    Args:
+        obj: The object to patch.
+        injector: The injector to use.
+
+    Returns:
+        The patched object.
+
+    Examples:
+        >>> from nat.llm.utils.thinking import BaseThinkingInjector
+        >>> from nat.llm.utils.thinking import FunctionArgumentWrapper
+        >>> from nat.llm.utils.thinking import patch_with_thinking
+        >>>
+        >>> class MockClass:
+        ...     def sync_method(self, *args, **kwargs):
+        ...         return (args, kwargs)
+        ...
+        >>> mock_obj_1 = MockClass()
+        >>> class AddThinking(BaseThinkingInjector):
+        ...     def inject(self, x: str, *args, **kwargs) -> FunctionArgumentWrapper:
+        ...         return FunctionArgumentWrapper(("thinking " + x), *args, **kwargs)
+        >>>
+        >>> patched_obj = patch_with_thinking(mock_obj_1, AddThinking(
+        ...     system_prompt="thinking",
+        ...     function_names=["sync_method"],
+        ... ))
+        >>> patched_obj.sync_method("test", 1, 2, 3, foo="bar")
+        (('thinking test', 1, 2, 3), {'foo': 'bar'})
+        >>>
+        >>> mock_obj_2 = MockClass()
+        >>> class AddThinkingWithArgs(BaseThinkingInjector):
+        ...     def inject(self, *args, **kwargs) -> FunctionArgumentWrapper:
+        ...         return FunctionArgumentWrapper("thinking", *args, **kwargs)
+        >>>
+        >>> patched_obj = patch_with_thinking(mock_obj_2, AddThinkingWithArgs(
+        ...     system_prompt="thinking",
+        ...     function_names=["sync_method"],
+        ... ))
+        >>> patched_obj.sync_method("test", 1, 2, 3, foo="bar")
+        (('thinking', 'test', 1, 2, 3), {'foo': 'bar'})
+        >>>
+        >>> mock_obj_3 = MockClass()
+        >>> class AddThinkingWithKwargs(BaseThinkingInjector):
+        ...     def inject(self, *args, **kwargs) -> FunctionArgumentWrapper:
+        ...         return FunctionArgumentWrapper(*args, thinking=True, **kwargs)
+        >>>
+        >>> patched_obj = patch_with_thinking(mock_obj_3, AddThinkingWithKwargs(
+        ...     system_prompt="thinking",
+        ...     function_names=["sync_method"],
+        ... ))
+        >>> patched_obj.sync_method("test", 1, 2, 3, foo="bar")
+        (('test', 1, 2, 3), {'thinking': True, 'foo': 'bar'})
+    """
+
+    decorator = _make_thinking_decorator(injector)
+
+    cls = obj if inspect.isclass(obj) else type(obj)
+    cls_name = getattr(cls, "__name__", str(cls))
+
+    for name, _ in inspect.getmembers(cls, callable):
+        if name not in injector.function_names:
+            continue
+
+        descriptor = inspect.getattr_static(cls, name)
+        original = descriptor.__func__ if isinstance(descriptor, types.MethodType) else descriptor
+        wrapped = decorator(original)
+
+        try:  # instance‑level first
+            if not inspect.isclass(obj):
+                object.__setattr__(obj, name, types.MethodType(wrapped, obj))
+                continue
+        except Exception as exc:
+            logger.info(
+                "Instance‑level patch failed for %s.%s (%s); "
+                "falling back to class‑level patch.",
+                cls_name,
+                name,
+                exc,
+            )
+
+        try:  # class‑level fallback
+            setattr(cls, name, wrapped)
+        except Exception as exc:
+            logger.info(
+                "Cannot patch method %s.%s with thinking: %s",
+                cls_name,
+                name,
+                exc,
+            )
+
+    return obj

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))

nat/observability/mixin/file_mixin.py

@@ -103,7 +103,7 @@ class FileExportMixin(ResourceConflictMixin):
                     self._current_file_path.unlink()
                     logger.info("Cleaned up existing file: %s", self._current_file_path)
                 except OSError as e:
-                    logger.error("Error removing existing file %s: %s", self._current_file_path, e)
+                    logger.exception("Error removing existing file %s: %s", self._current_file_path, e)
 
     def _get_resource_identifiers(self) -> dict[str, Any]:
         """Return the file resources this instance will use.
@@ -154,10 +154,10 @@ class FileExportMixin(ResourceConflictMixin):
                     old_file.unlink()
                     logger.info("Cleaned up old log file during init: %s", old_file)
                 except OSError as e:
-                    logger.error("Error removing old file %s: %s", old_file, e)
+                    logger.exception("Error removing old file %s: %s", old_file, e)
 
         except Exception as e:
-            logger.error("Error during initialization cleanup: %s", e)
+            logger.exception("Error during initialization cleanup: %s", e)
 
     async def _should_roll_file(self) -> bool:
         """Check if the current file should be rolled based on size."""
@@ -191,7 +191,7 @@ class FileExportMixin(ResourceConflictMixin):
             await self._cleanup_old_files()
 
         except OSError as e:
-            logger.error("Error rolling file %s: %s", self._current_file_path, e)
+            logger.exception("Error rolling file %s: %s", self._current_file_path, e)
 
     async def _cleanup_old_files(self) -> None:
         """Remove old rolled files beyond the maximum count."""
@@ -209,10 +209,10 @@ class FileExportMixin(ResourceConflictMixin):
                     old_file.unlink()
                     logger.info("Cleaned up old log file: %s", old_file)
                 except OSError as e:
-                    logger.error("Error removing old file %s: %s", old_file, e)
+                    logger.exception("Error removing old file %s: %s", old_file, e)
 
         except Exception as e:
-            logger.error("Error during cleanup: %s", e)
+            logger.exception("Error during cleanup: %s", e)
 
     async def export_processed(self, item: str | list[str]) -> None:
         """Export a processed string or list of strings.
@@ -248,7 +248,7 @@ class FileExportMixin(ResourceConflictMixin):
                         await f.write("\n")
 
         except Exception as e:
-            logger.error("Error exporting event: %s", e, exc_info=True)
+            logger.exception("Error exporting event: %s", e)
 
     def get_current_file_path(self) -> Path:
         """Get the current file path being written to.

nat/observability/processor/batching_processor.py

@@ -193,14 +193,14 @@ class BatchingProcessor(CallbackProcessor[T, list[T]], Generic[T]):
                                 await self._done_callback(batch)
                                 logger.debug("Scheduled flush routed batch of %d items through pipeline", len(batch))
                             except Exception as e:
-                                logger.error("Error routing scheduled batch through pipeline: %s", e, exc_info=True)
+                                logger.exception("Error routing scheduled batch through pipeline: %s", e)
                         else:
                             logger.warning("Scheduled flush created batch of %d items but no pipeline callback set",
                                            len(batch))
         except asyncio.CancelledError:
             pass
         except Exception as e:
-            logger.error("Error in scheduled flush: %s", e, exc_info=True)
+            logger.exception("Error in scheduled flush: %s", e)
 
     async def _create_batch(self) -> list[T]:
         """Create a batch from the current queue."""
@@ -271,9 +271,7 @@ class BatchingProcessor(CallbackProcessor[T, list[T]], Generic[T]):
                                 "Successfully flushed final batch of %d items through pipeline during shutdown",
                                 len(final_batch))
                         except Exception as e:
-                            logger.error("Error routing final batch through pipeline during shutdown: %s",
-                                         e,
-                                         exc_info=True)
+                            logger.exception("Error routing final batch through pipeline during shutdown: %s", e)
                     else:
                         logger.warning("Final batch of %d items created during shutdown but no pipeline callback set",
                                        len(final_batch))
@@ -285,7 +283,7 @@ class BatchingProcessor(CallbackProcessor[T, list[T]], Generic[T]):
             logger.debug("BatchingProcessor shutdown completed successfully")
 
         except Exception as e:
-            logger.error("Error during BatchingProcessor shutdown: %s", e, exc_info=True)
+            logger.exception("Error during BatchingProcessor shutdown: %s", e)
             self._shutdown_complete = True
             self._shutdown_complete_event.set()
 

nat/observability/processor/falsy_batch_filter_processor.py

@@ -0,0 +1,55 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import logging
+from typing import TypeVar
+
+from nat.observability.processor.processor import Processor
+from nat.utils.type_utils import override
+
+logger = logging.getLogger(__name__)
+
+FalsyT = TypeVar("FalsyT")
+
+
+class FalsyBatchFilterProcessor(Processor[list[FalsyT], list[FalsyT]]):
+    """Processor that filters out falsy items from a batch."""
+
+    @override
+    async def process(self, item: list[FalsyT]) -> list[FalsyT]:
+        """Filter out falsy items from a batch.
+
+        Args:
+            item (list[FalsyT]): The batch of items to filter.
+
+        Returns:
+            list[FalsyT]: The filtered batch.
+        """
+        return [i for i in item if i]
+
+
+class DictBatchFilterProcessor(FalsyBatchFilterProcessor[dict]):
+    """Processor that filters out empty dict items from a batch."""
+    pass
+
+
+class ListBatchFilterProcessor(FalsyBatchFilterProcessor[list]):
+    """Processor that filters out empty list items from a batch."""
+    pass
+
+
+class SetBatchFilterProcessor(FalsyBatchFilterProcessor[set]):
+    """Processor that filters out empty set items from a batch."""
+    pass

nat/observability/processor/processor_factory.py

@@ -0,0 +1,70 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from typing import Any
+
+from nat.observability.processor.processor import Processor
+
+
+def processor_factory(processor_class: type, from_type: type[Any], to_type: type[Any]) -> type[Processor]:
+    """Create a concrete processor class from a processor class and types.
+
+    Args:
+        processor_class (type): The processor class to create a concrete instance of
+        from_type (type[Any]): The type of the input data
+        to_type (type[Any]): The type of the output data
+
+    Returns:
+        type[Processor]: The concrete processor class
+    """
+
+    class ConcreteProcessor(processor_class[from_type, to_type]):  # type: ignore
+        pass
+
+    return ConcreteProcessor
+
+
+def processor_factory_from_type(processor_class: type, from_type: type[Any]) -> type[Processor]:
+    """Create a concrete processor class from a processor class and input type.
+
+    Args:
+        processor_class (type): The processor class to create a concrete instance of
+        from_type (type[Any]): The type of the input data
+
+    Returns:
+        type[Processor]: The concrete processor class
+    """
+
+    class ConcreteProcessor(processor_class[from_type]):  # type: ignore
+        pass
+
+    return ConcreteProcessor
+
+
+def processor_factory_to_type(processor_class: type, to_type: type[Any]) -> type[Processor]:
+    """Create a concrete processor class from a processor class and output type.
+
+    Args:
+        processor_class (type): The processor class to create a concrete instance of
+        to_type (type[Any]): The type of the output data
+
+    Returns:
+        type[Processor]: The concrete processor class
+    """
+
+    class ConcreteProcessor(processor_class[to_type]):  # type: ignore
+        pass
+
+    return ConcreteProcessor

nat/profiler/calc/calc_runner.py

@@ -442,7 +442,7 @@ class CalcRunner:
                 runtime_fit=self.linear_analyzer.wf_runtime_fit  # May be None
             )
         except Exception as e:
-            logger.exception("Failed to plot concurrency vs. time metrics: %s", e, exc_info=True)
+            logger.exception("Failed to plot concurrency vs. time metrics: %s", e)
             logger.warning("Skipping plot of concurrency vs. time metrics")
 
     def write_output(self, output_dir: Path, calc_runner_output: CalcRunnerOutput):
@@ -506,11 +506,10 @@ class CalcRunner:
                 continue
             try:
                 calc_output = CalcRunnerOutput.model_validate_json(calc_runner_output_path.read_text())
-            except ValidationError as e:
+            except ValidationError:
                 logger.exception("Failed to validate calc runner output file %s. Skipping job %s.",
                                  calc_runner_output_path,
-                                 e,
-                                 exc_info=True)
+                                 job_dir.name)
                 continue
 
             # Extract sizing metrics from calc_data

nat/profiler/callbacks/agno_callback_handler.py

@@ -144,7 +144,7 @@ class AgnoProfilerHandler(BaseProfilerCallback):
                 return result
 
             except Exception as e:
-                logger.exception("Tool execution error: %s", e)
+                logger.error("Tool execution error: %s", e)
                 raise
 
         return wrapped_tool_execute

nat/profiler/callbacks/langchain_callback_handler.py

@@ -106,7 +106,7 @@ class LangchainProfilerHandler(AsyncCallbackHandler, BaseProfilerCallback):
         try:
             model_name = kwargs.get("metadata")["ls_model_name"]
         except Exception as e:
-            logger.exception("Error getting model name: %s", e, exc_info=True)
+            logger.exception("Error getting model name: %s", e)
 
         run_id = str(kwargs.get("run_id", str(uuid4())))
         self._run_id_to_model_name[run_id] = model_name
@@ -144,7 +144,7 @@ class LangchainProfilerHandler(AsyncCallbackHandler, BaseProfilerCallback):
         try:
             model_name = metadata["ls_model_name"] if metadata else kwargs.get("metadata")["ls_model_name"]
         except Exception as e:
-            logger.exception("Error getting model name: %s", e, exc_info=True)
+            logger.exception("Error getting model name: %s", e)
 
         run_id = str(run_id)
         self._run_id_to_model_name[run_id] = model_name
@@ -173,13 +173,13 @@ class LangchainProfilerHandler(AsyncCallbackHandler, BaseProfilerCallback):
         try:
             model_name = self._run_id_to_model_name.get(str(kwargs.get("run_id", "")), "")
         except Exception as e:
-            logger.exception("Error getting model name: %s", e, exc_info=True)
+            logger.exception("Error getting model name: %s", e)
 
         usage_metadata = {}
         try:
             usage_metadata = kwargs.get("chunk").message.usage_metadata if kwargs.get("chunk") else {}
         except Exception as e:
-            logger.exception("Error getting usage metadata: %s", e, exc_info=True)
+            logger.exception("Error getting usage metadata: %s", e)
 
         stats = IntermediateStepPayload(
             event_type=IntermediateStepType.LLM_NEW_TOKEN,
@@ -206,7 +206,7 @@ class LangchainProfilerHandler(AsyncCallbackHandler, BaseProfilerCallback):
             try:
                 model_name = self._run_id_to_model_name.get(str(kwargs.get("run_id", "")), "")
             except Exception as e_inner:
-                logger.exception("Error getting model name: %s from outer error %s", e_inner, e, exc_info=True)
+                logger.exception("Error getting model name: %s from outer error %s", e_inner, e)
 
         try:
             generation = response.generations[0][0]

nat/profiler/callbacks/llama_index_callback_handler.py

@@ -94,7 +94,7 @@ class LlamaIndexProfilerHandler(BaseCallbackHandler, BaseProfilerCallback):
             try:
                 model_name = payload.get(EventPayload.SERIALIZED)['model']
             except Exception as e:
-                logger.exception("Error getting model name: %s", e, exc_info=True)
+                logger.exception("Error getting model name: %s", e)
 
             llm_text_input = " ".join(prompts_or_messages) if prompts_or_messages else ""
 
@@ -159,13 +159,13 @@ class LlamaIndexProfilerHandler(BaseCallbackHandler, BaseProfilerCallback):
                     for block in response.message.blocks:
                         llm_text_output += block.text
                 except Exception as e:
-                    logger.exception("Error getting LLM text output: %s", e, exc_info=True)
+                    logger.exception("Error getting LLM text output: %s", e)
 
                 model_name = ""
                 try:
                     model_name = response.raw.model
                 except Exception as e:
-                    logger.exception("Error getting model name: %s", e, exc_info=True)
+                    logger.exception("Error getting model name: %s", e)
 
                 # Append usage data to NAT usage stats
                 with self._lock:

nat/profiler/callbacks/semantic_kernel_callback_handler.py

@@ -132,7 +132,7 @@ class SemanticKernelProfilerHandler(BaseProfilerCallback):
                         if "text" in item:
                             model_input += item["text"]
             except Exception as e:
-                logger.exception("Error in getting model input: %s", e, exc_info=True)
+                logger.exception("Error in getting model input: %s", e)
 
             input_stats = IntermediateStepPayload(event_type=IntermediateStepType.LLM_START,
                                                   framework=LLMFrameworkEnum.SEMANTIC_KERNEL,
@@ -232,7 +232,7 @@ class SemanticKernelProfilerHandler(BaseProfilerCallback):
                 return result
 
             except Exception as e:
-                logger.exception("ToolUsage._use error: %s", e)
+                logger.error("ToolUsage._use error: %s", e)
                 raise
 
         return patched_tool_call