nvidia-nat 1.3.0.dev2__py3-none-any.whl → 1.3.0rc2__py3-none-any.whl

nat/observability/exporter_manager.py

@@ -177,14 +177,14 @@ 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
             try:
                 await asyncio.wait_for(asyncio.gather(*cleanup_tasks, return_exceptions=True),
                                        timeout=self._shutdown_timeout)
-            except asyncio.TimeoutError:
+            except TimeoutError:
                 logger.warning("Some isolated exporters did not clean up within timeout")
 
         self._active_isolated_exporters.clear()
@@ -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
 
@@ -301,13 +301,13 @@ class ExporterManager:
             try:
                 task.cancel()
                 await asyncio.wait_for(task, timeout=self._shutdown_timeout)
-            except asyncio.TimeoutError:
+            except TimeoutError:
                 logger.warning("Exporter '%s' task did not shut down in time and may be stuck.", name)
                 stuck_tasks.append(name)
             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/mixin/redaction_config_mixin.py

@@ -0,0 +1,42 @@
+# 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 pydantic import BaseModel
+from pydantic import Field
+
+
+class RedactionConfigMixin(BaseModel):
+    """Mixin for basic redaction configuration.
+
+    Provides core redaction functionality that can be used standalone
+    or inherited by specialized redaction mixins.
+    """
+    redaction_enabled: bool = Field(default=False, description="Whether to enable redaction processing.")
+    redaction_value: str = Field(default="[REDACTED]", description="Value to replace redacted attributes with.")
+    redaction_attributes: list[str] = Field(default_factory=lambda: ["input.value", "output.value", "nat.metadata"],
+                                            description="Attributes to redact when redaction is triggered.")
+    force_redaction: bool = Field(default=False, description="Always redact regardless of other conditions.")
+    redaction_tag: str | None = Field(default=None, description="Tag to add to spans when redaction is triggered.")
+
+
+class HeaderRedactionConfigMixin(RedactionConfigMixin):
+    """Mixin for header-based redaction configuration.
+
+    Inherits core redaction fields (redaction_enabled, redaction_attributes, force_redaction)
+    and adds header-specific configuration for authentication-based redaction decisions.
+
+    Note: The callback function must be provided directly to the processor at runtime.
+    """
+    redaction_headers: list[str] = Field(default_factory=list, description="Headers to check for redaction decisions.")

nat/observability/mixin/tagging_config_mixin.py

@@ -0,0 +1,62 @@
+# 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 sys
+from collections.abc import Mapping
+from enum import Enum
+from typing import Generic
+from typing import TypeVar
+
+from pydantic import BaseModel
+from pydantic import Field
+
+if sys.version_info >= (3, 12):
+    from typing import TypedDict
+else:
+    from typing_extensions import TypedDict
+
+TagMappingT = TypeVar("TagMappingT", bound=Mapping)
+
+
+class BaseTaggingConfigMixin(BaseModel, Generic[TagMappingT]):
+    """Base mixin for tagging spans."""
+    tags: TagMappingT | None = Field(default=None, description="Tags to add to the span.")
+
+
+class PrivacyLevel(str, Enum):
+    """Privacy level for the traces."""
+    NONE = "none"
+    LOW = "low"
+    MEDIUM = "medium"
+    HIGH = "high"
+
+
+PrivacyTagSchema = TypedDict(
+    "PrivacyTagSchema",
+    {
+        "privacy.level": PrivacyLevel,
+    },
+    total=True,
+)
+
+
+class PrivacyTaggingConfigMixin(BaseTaggingConfigMixin[PrivacyTagSchema]):
+    """Mixin for privacy level tagging on spans."""
+    pass
+
+
+class CustomTaggingConfigMixin(BaseTaggingConfigMixin[dict[str, str]]):
+    """Mixin for string key-value tagging on spans."""
+    pass