provide-foundation 0.0.0.dev1__py3-none-any.whl → 0.0.0.dev3__py3-none-any.whl

provide/foundation/logger/factories.py

@@ -13,7 +13,7 @@ from provide.foundation.logger.core import logger
 def get_logger(
     name: str | None = None,
     emoji: str | None = None,
-    emoji_hierarchy: dict[str, str] | None = None
+    emoji_hierarchy: dict[str, str] | None = None,
 ) -> Any:
     """
     Get a logger instance with the given name and optional emoji customization.
@@ -30,7 +30,7 @@ def get_logger(
     """
     # Emoji hierarchy removed - using event sets now
     # emoji and emoji_hierarchy parameters are deprecated
-    
+
     return logger.get_logger(name)
 
 

provide/foundation/logger/processors/main.py

@@ -7,7 +7,7 @@ Structlog processors for Foundation Telemetry.
 
 import json
 import logging as stdlib_logging
-from typing import TYPE_CHECKING, Any, TextIO, cast
+from typing import Any, TextIO, cast
 
 import structlog
 
@@ -26,7 +26,6 @@ from provide.foundation.types import (
     LogLevelStr,
 )
 
-
 _LEVEL_TO_NUMERIC: dict[LogLevelStr, int] = {
     "CRITICAL": stdlib_logging.CRITICAL,
     "ERROR": stdlib_logging.ERROR,
@@ -70,24 +69,29 @@ def _config_create_timestamp_processors(
 
 
 def _config_create_event_enrichment_processors(
-    logging_config: LoggingConfig
+    logging_config: LoggingConfig,
 ) -> list[StructlogProcessor]:
     processors: list[StructlogProcessor] = []
     if logging_config.logger_name_emoji_prefix_enabled:
         processors.append(cast(StructlogProcessor, add_logger_name_emoji_prefix))
     if logging_config.das_emoji_prefix_enabled:
+
         def add_event_enrichment_processor(
             _logger: Any, _method_name: str, event_dict: structlog.types.EventDict
         ) -> structlog.types.EventDict:
             # Lazy import to avoid circular dependency
-            from provide.foundation.eventsets.resolver import get_resolver
             from provide.foundation.eventsets.registry import discover_event_sets
-            
+            from provide.foundation.eventsets.resolver import get_resolver
+
             # Initialize on first use
-            if not hasattr(add_event_enrichment_processor, '_initialized'):
+            if not hasattr(add_event_enrichment_processor, "_initialized"):
+                from provide.foundation.logger.setup.coordinator import create_foundation_internal_logger
+                setup_logger = create_foundation_internal_logger()
+                setup_logger.trace("Initializing event enrichment processor")
                 discover_event_sets()
                 add_event_enrichment_processor._initialized = True
-            
+                setup_logger.trace("Event enrichment processor initialized")
+
             resolver = get_resolver()
             return resolver.enrich_event(event_dict)
 
@@ -95,9 +99,7 @@ def _config_create_event_enrichment_processors(
     return processors
 
 
-def _build_core_processors_list(
-    config: TelemetryConfig
-) -> list[StructlogProcessor]:
+def _build_core_processors_list(config: TelemetryConfig) -> list[StructlogProcessor]:
     log_cfg = config.logging
     processors: list[StructlogProcessor] = [
         structlog.contextvars.merge_contextvars,

provide/foundation/logger/ratelimit/limiters.py

@@ -17,7 +17,7 @@ class SyncRateLimiter:
     Thread-safe implementation suitable for synchronous logging operations.
     """
 
-    def __init__(self, capacity: float, refill_rate: float):
+    def __init__(self, capacity: float, refill_rate: float) -> None:
         """
         Initialize the rate limiter.
 
@@ -87,7 +87,7 @@ class AsyncRateLimiter:
     Uses asyncio.Lock for thread safety in async contexts.
     """
 
-    def __init__(self, capacity: float, refill_rate: float):
+    def __init__(self, capacity: float, refill_rate: float) -> None:
         """
         Initialize the async rate limiter.
 
@@ -160,7 +160,7 @@ class GlobalRateLimiter:
     _instance = None
     _lock = threading.Lock()
 
-    def __new__(cls):
+    def __new__(cls) -> "GlobalRateLimiter":
         if cls._instance is None:
             with cls._lock:
                 if cls._instance is None:
@@ -168,7 +168,7 @@ class GlobalRateLimiter:
                     cls._instance._initialized = False
         return cls._instance
 
-    def __init__(self):
+    def __init__(self) -> None:
         if self._initialized:
             return
 

provide/foundation/logger/ratelimit/processor.py

@@ -107,7 +107,7 @@ class RateLimiterProcessor:
         stats = self.rate_limiter.get_stats()
 
         # Check if there's been any rate limiting activity
-        global_stats = stats.get("global", {})
+        global_stats = stats.get("global") or {}
         total_denied = global_stats.get("total_denied", 0)
 
         if not self.suppressed_counts and total_denied == 0:

provide/foundation/logger/setup/coordinator.py

@@ -28,6 +28,7 @@ _PROVIDE_SETUP_LOCK = threading.Lock()
 _CORE_SETUP_LOGGER_NAME = "provide.foundation.core_setup"
 _EXPLICIT_SETUP_DONE = False
 _FOUNDATION_LOG_LEVEL: int | None = None
+_CACHED_SETUP_LOGGER: Any | None = None
 
 
 def get_foundation_log_level() -> int:
@@ -35,10 +36,10 @@ def get_foundation_log_level() -> int:
     global _FOUNDATION_LOG_LEVEL
     if _FOUNDATION_LOG_LEVEL is None:
         import os
-        
+
         # Direct env read - avoid config imports that cause circular deps
         level_str = os.environ.get("FOUNDATION_LOG_LEVEL", "INFO").upper()
-        
+
         # Validate and map to numeric level
         valid_levels = {
             "CRITICAL": stdlib_logging.CRITICAL,
@@ -48,7 +49,7 @@ def get_foundation_log_level() -> int:
             "DEBUG": stdlib_logging.DEBUG,
             "NOTSET": stdlib_logging.NOTSET,
         }
-        
+
         _FOUNDATION_LOG_LEVEL = valid_levels.get(level_str, stdlib_logging.INFO)
     return _FOUNDATION_LOG_LEVEL
 
@@ -56,10 +57,17 @@ def get_foundation_log_level() -> int:
 def create_foundation_internal_logger(globally_disabled: bool = False) -> Any:
     """
     Create Foundation's internal setup logger (structlog).
-    
+
     This is used internally by Foundation during its own initialization.
     Components should use get_vanilla_logger() instead.
+    
+    Returns the same logger instance when called multiple times (singleton pattern).
     """
+    global _CACHED_SETUP_LOGGER
+    
+    # Return cached logger if already created
+    if _CACHED_SETUP_LOGGER is not None:
+        return _CACHED_SETUP_LOGGER
     if globally_disabled:
         # Configure structlog to be a no-op for core setup logger
         structlog.configure(
@@ -68,11 +76,12 @@ def create_foundation_internal_logger(globally_disabled: bool = False) -> Any:
             wrapper_class=structlog.BoundLogger,
             cache_logger_on_first_use=True,
         )
-        return structlog.get_logger(_CORE_SETUP_LOGGER_NAME)
+        _CACHED_SETUP_LOGGER = structlog.get_logger(_CORE_SETUP_LOGGER_NAME)
+        return _CACHED_SETUP_LOGGER
     else:
         # Get the foundation log output stream
         try:
-            logging_config = LoggingConfig.from_env(strict=False)
+            logging_config = LoggingConfig.from_env()
             foundation_stream = get_foundation_log_stream(
                 logging_config.foundation_log_output
             )
@@ -92,55 +101,61 @@ def create_foundation_internal_logger(globally_disabled: bool = False) -> Any:
             cache_logger_on_first_use=True,
         )
 
-        return structlog.get_logger(_CORE_SETUP_LOGGER_NAME)
+        _CACHED_SETUP_LOGGER = structlog.get_logger(_CORE_SETUP_LOGGER_NAME) 
+        return _CACHED_SETUP_LOGGER
+
 
+def reset_setup_logger_cache() -> None:
+    """Reset the cached setup logger for testing."""
+    global _CACHED_SETUP_LOGGER
+    _CACHED_SETUP_LOGGER = None
 
-def get_vanilla_logger(name: str):
+
+def get_vanilla_logger(name: str) -> object:
     """
     Get a vanilla Python logger without Foundation enhancements.
-    
+
     This provides a plain Python logger that respects FOUNDATION_LOG_LEVEL
     but doesn't trigger Foundation's initialization. Use this for logging
     during Foundation's setup phase or when you need to avoid circular
     dependencies.
-    
+
     Args:
         name: Logger name (e.g., "provide.foundation.otel.setup")
-    
+
     Returns:
         A standard Python logging.Logger instance
-        
+
     Note:
         "Vanilla" means plain/unmodified Python logging, without
         Foundation's features like emoji prefixes or structured logging.
     """
     import logging
-    import sys
     import os
-    
+    import sys
+
     slog = logging.getLogger(name)
-    
+
     # Configure only once per logger
     if not slog.handlers:
         log_level = get_foundation_log_level()
         slog.setLevel(log_level)
-        
+
         # Respect FOUNDATION_LOG_OUTPUT setting
         output = os.environ.get("FOUNDATION_LOG_OUTPUT", "stderr").lower()
         stream = sys.stderr if output != "stdout" else sys.stdout
-        
+
         handler = logging.StreamHandler(stream)
         handler.setLevel(log_level)
         formatter = logging.Formatter(
-            '%(asctime)s [%(levelname)-5s] %(message)s',
-            datefmt='%Y-%m-%dT%H:%M:%S'
+            "%(asctime)s [%(levelname)-5s] %(message)s", datefmt="%Y-%m-%dT%H:%M:%S"
         )
         handler.setFormatter(formatter)
         slog.addHandler(handler)
-        
+
         # Don't propagate to avoid duplicate messages
         slog.propagate = False
-    
+
     return slog
 
 
@@ -170,13 +185,12 @@ def internal_setup(
             formatter=current_config.logging.console_formatter,
         )
 
-
     if current_config.globally_disabled:
+        core_setup_logger.trace("Setting up globally disabled telemetry")
         handle_globally_disabled_setup()
     else:
-        configure_structlog_output(
-            current_config, get_log_stream()
-        )
+        core_setup_logger.trace("Configuring structlog output processors")
+        configure_structlog_output(current_config, get_log_stream())
 
     foundation_logger._is_configured_by_setup = is_explicit_call
     foundation_logger._active_config = current_config

provide/foundation/logger/setup/processors.py

@@ -15,6 +15,8 @@ from provide.foundation.logger.processors import (
     _build_core_processors_list,
     _build_formatter_processors_list,
 )
+
+
 def build_complete_processor_chain(
     config: TelemetryConfig,
     log_stream: TextIO,
@@ -61,9 +63,7 @@ def configure_structlog_output(
         config: Telemetry configuration
         log_stream: Output stream for logging
     """
-    processors = build_complete_processor_chain(
-        config, log_stream
-    )
+    processors = build_complete_processor_chain(config, log_stream)
     apply_structlog_configuration(processors, log_stream)
 
 

provide/foundation/logger/setup/testing.py

@@ -30,6 +30,20 @@ def reset_foundation_state() -> None:
     foundation_logger._active_config = None
     foundation_logger._active_resolved_emoji_config = None
     _LAZY_SETUP_STATE.update({"done": False, "error": None, "in_progress": False})
+    
+    # Reset event set registry and discovery state
+    try:
+        from provide.foundation.eventsets.registry import clear_registry
+        clear_registry()
+    except ImportError:
+        pass  # Event sets may not be available in all test environments
+    
+    # Reset setup logger cache
+    try:
+        from provide.foundation.logger.setup.coordinator import reset_setup_logger_cache
+        reset_setup_logger_cache()
+    except ImportError:
+        pass
 
 
 def reset_foundation_setup_for_testing() -> None:

provide/foundation/logger/trace.py

@@ -39,10 +39,10 @@ if not hasattr(stdlib_logging, TRACE_LEVEL_NAME):  # pragma: no cover
 
 # Also patch PrintLogger from structlog to support trace method
 try:
-    import structlog
     from structlog import PrintLogger
-    
+
     if not hasattr(PrintLogger, "trace"):  # pragma: no cover
+
         def trace_for_print_logger(
             self: PrintLogger, msg: object, *args: object, **kwargs: object
         ) -> None:  # pragma: no cover
@@ -54,12 +54,12 @@ try:
                     formatted_msg = f"{msg} {args}"
             else:
                 formatted_msg = str(msg)
-            
+
             # Use the same output mechanism as other PrintLogger methods
             self._file.write(formatted_msg + "\n")
             self._file.flush()
-        
+
         PrintLogger.trace = trace_for_print_logger  # type: ignore[attr-defined]
-        
+
 except ImportError:  # pragma: no cover
     pass

provide/foundation/metrics/__init__.py

@@ -113,7 +113,7 @@ def histogram(name: str, description: str = "", unit: str = "") -> "SimpleHistog
     return SimpleHistogram(name)
 
 
-def _set_meter(meter) -> None:
+def _set_meter(meter: object) -> None:
     """Set the global meter instance (internal use only)."""
     global _meter
     _meter = meter

provide/foundation/metrics/otel.py

@@ -52,7 +52,9 @@ def setup_opentelemetry_metrics(config: TelemetryConfig) -> None:
 
     # Check if OpenTelemetry metrics are available
     if not _HAS_OTEL_METRICS:
-        slog.debug("📊 OpenTelemetry metrics not available (dependencies not installed)")
+        slog.debug(
+            "📊 OpenTelemetry metrics not available (dependencies not installed)"
+        )
         return
 
     slog.debug("📊🚀 Setting up OpenTelemetry metrics")

provide/foundation/observability/__init__.py

@@ -17,7 +17,7 @@ except ImportError:
 # Only import OpenObserve if OpenTelemetry is available
 if _HAS_OTEL:
     try:
-        from provide.foundation.observability.openobserve import (
+        from provide.foundation.integrations.openobserve import (
             OpenObserveClient,
             search_logs,
             stream_logs,
@@ -25,9 +25,9 @@ if _HAS_OTEL:
 
         # Commands will auto-register if click is available
         try:
-            from provide.foundation.observability.openobserve.commands import (
+            from provide.foundation.integrations.openobserve.commands import (
                 openobserve_group,
-            )
+            )  # noqa: F401
         except ImportError:
             # Click not available, skip command registration
             pass

provide/foundation/process/__init__.py

@@ -10,6 +10,11 @@ from provide.foundation.process.async_runner import (
     async_run_shell,
     async_stream_command,
 )
+from provide.foundation.process.exit import (
+    exit_error,
+    exit_interrupted,
+    exit_success,
+)
 from provide.foundation.process.lifecycle import (
     ManagedProcess,
     wait_for_process_output,
@@ -36,4 +41,8 @@ __all__ = [
     # Process lifecycle management
     "ManagedProcess",
     "wait_for_process_output",
+    # Exit utilities
+    "exit_success",
+    "exit_error",
+    "exit_interrupted",
 ]

provide/foundation/process/exit.py

@@ -0,0 +1,48 @@
+"""Process exit utilities for standardized exit handling."""
+
+import sys
+
+from provide.foundation.config.defaults import EXIT_ERROR, EXIT_SIGINT, EXIT_SUCCESS
+
+
+def _get_logger():
+    """Get logger instance lazily to avoid circular imports."""
+    from provide.foundation.logger import logger
+
+    return logger
+
+
+def exit_success(message: str | None = None) -> None:
+    """Exit with success status.
+
+    Args:
+        message: Optional message to log before exiting
+    """
+    if message:
+        logger = _get_logger()
+        logger.info(f"Exiting successfully: {message}")
+    sys.exit(EXIT_SUCCESS)
+
+
+def exit_error(message: str | None = None, code: int = EXIT_ERROR) -> None:
+    """Exit with error status.
+
+    Args:
+        message: Optional error message to log before exiting
+        code: Exit code to use (defaults to EXIT_ERROR)
+    """
+    if message:
+        logger = _get_logger()
+        logger.error(f"Exiting with error: {message}", exit_code=code)
+    sys.exit(code)
+
+
+def exit_interrupted(message: str = "Process interrupted") -> None:
+    """Exit due to interrupt signal (SIGINT).
+
+    Args:
+        message: Message to log before exiting
+    """
+    logger = _get_logger()
+    logger.warning(f"Exiting due to interrupt: {message}")
+    sys.exit(EXIT_SIGINT)