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

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,7 +76,8 @@ 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:
@@ -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

@@ -27,7 +27,7 @@ if _HAS_OTEL:
         try:
             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

@@ -11,9 +11,9 @@ from provide.foundation.process.async_runner import (
     async_stream_command,
 )
 from provide.foundation.process.exit import (
-    exit_success,
     exit_error,
     exit_interrupted,
+    exit_success,
 )
 from provide.foundation.process.lifecycle import (
     ManagedProcess,

provide/foundation/process/exit.py

@@ -2,18 +2,19 @@
 
 import sys
 
-from provide.foundation.config.defaults import EXIT_SUCCESS, EXIT_ERROR, EXIT_SIGINT
+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
     """
@@ -25,7 +26,7 @@ def exit_success(message: str | None = None) -> None:
 
 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)
@@ -38,10 +39,10 @@ def exit_error(message: str | None = None, code: int = EXIT_ERROR) -> None:
 
 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)
+    sys.exit(EXIT_SIGINT)

provide/foundation/process/lifecycle.py

@@ -17,8 +17,8 @@ import traceback
 from typing import Any
 
 from provide.foundation.config.defaults import (
-    DEFAULT_PROCESS_READLINE_TIMEOUT,
     DEFAULT_PROCESS_READCHAR_TIMEOUT,
+    DEFAULT_PROCESS_READLINE_TIMEOUT,
     DEFAULT_PROCESS_TERMINATE_TIMEOUT,
     DEFAULT_PROCESS_WAIT_TIMEOUT,
 )
@@ -76,13 +76,13 @@ class ManagedProcess:
 
         # Build environment - always start with current environment
         self._env = os.environ.copy()
-        
+
         # Clean coverage-related environment variables from subprocess
         # to prevent interference with output capture during testing
         for key in list(self._env.keys()):
-            if key.startswith(('COVERAGE', 'COV_CORE')):
+            if key.startswith(("COVERAGE", "COV_CORE")):
                 self._env.pop(key, None)
-        
+
         # Merge in any provided environment variables
         if env:
             self._env.update(env)
@@ -120,7 +120,9 @@ class ManagedProcess:
         return self._process.poll() is None
 
     @with_error_handling(
-        error_mapper=lambda e: ProcessError(f"Failed to launch process: {e}") if not isinstance(e, (ProcessError, RuntimeError)) else e
+        error_mapper=lambda e: ProcessError(f"Failed to launch process: {e}")
+        if not isinstance(e, (ProcessError, RuntimeError))
+        else e
     )
     def launch(self) -> None:
         """
@@ -186,7 +188,9 @@ class ManagedProcess:
         self._stderr_thread.start()
         plog.debug("🚀 Started stderr relay thread")
 
-    async def read_line_async(self, timeout: float = DEFAULT_PROCESS_READLINE_TIMEOUT) -> str:
+    async def read_line_async(
+        self, timeout: float = DEFAULT_PROCESS_READLINE_TIMEOUT
+    ) -> str:
         """
         Read a line from stdout asynchronously with timeout.
 
@@ -221,7 +225,9 @@ class ManagedProcess:
             plog.debug("Read timeout on managed process stdout")
             raise TimeoutError(f"Read timeout after {timeout}s") from e
 
-    async def read_char_async(self, timeout: float = DEFAULT_PROCESS_READCHAR_TIMEOUT) -> str:
+    async def read_char_async(
+        self, timeout: float = DEFAULT_PROCESS_READCHAR_TIMEOUT
+    ) -> str:
         """
         Read a single character from stdout asynchronously.
 
@@ -258,7 +264,9 @@ class ManagedProcess:
             plog.debug("Character read timeout on managed process stdout")
             raise TimeoutError(f"Character read timeout after {timeout}s") from e
 
-    def terminate_gracefully(self, timeout: float = DEFAULT_PROCESS_TERMINATE_TIMEOUT) -> bool:
+    def terminate_gracefully(
+        self, timeout: float = DEFAULT_PROCESS_TERMINATE_TIMEOUT
+    ) -> bool:
         """
         Terminate the process gracefully with a timeout.
 
@@ -378,7 +386,7 @@ async def wait_for_process_output(
         if not process.is_running():
             last_exit_code = process.returncode
             plog.debug("Process exited", returncode=last_exit_code)
-            
+
             # Try to drain any remaining output from the pipes
             if process._process and process._process.stdout:
                 try:
@@ -389,19 +397,26 @@ async def wait_for_process_output(
                             buffer += remaining.decode("utf-8", errors="replace")
                         else:
                             buffer += str(remaining)
-                        plog.debug("Read remaining output from exited process", size=len(remaining))
+                        plog.debug(
+                            "Read remaining output from exited process",
+                            size=len(remaining),
+                        )
                 except Exception:
                     pass
-            
+
             # Check buffer after draining
             if all(part in buffer for part in expected_parts):
                 plog.debug("Found expected pattern after process exit")
                 return buffer
-            
+
             # If process exited and we don't have the pattern, fail
             if last_exit_code is not None:
                 if last_exit_code != 0:
-                    plog.error("Process exited with error", returncode=last_exit_code, buffer=buffer[:200])
+                    plog.error(
+                        "Process exited with error",
+                        returncode=last_exit_code,
+                        buffer=buffer[:200],
+                    )
                     raise ProcessError(f"Process exited with code {last_exit_code}")
                 else:
                     # For exit code 0, give it a small window to collect buffered output
@@ -412,7 +427,9 @@ async def wait_for_process_output(
                             remaining = process._process.stdout.read()
                             if remaining:
                                 if isinstance(remaining, bytes):
-                                    buffer += remaining.decode("utf-8", errors="replace")
+                                    buffer += remaining.decode(
+                                        "utf-8", errors="replace"
+                                    )
                                 else:
                                     buffer += str(remaining)
                         except Exception:
@@ -422,9 +439,15 @@ async def wait_for_process_output(
                         plog.debug("Found expected pattern after final drain")
                         return buffer
                     # Process exited cleanly but pattern not found
-                    plog.error("Process exited without expected output", returncode=0, buffer=buffer[:200])
-                    raise ProcessError(f"Process exited with code {last_exit_code} before expected output found")
-        
+                    plog.error(
+                        "Process exited without expected output",
+                        returncode=0,
+                        buffer=buffer[:200],
+                    )
+                    raise ProcessError(
+                        f"Process exited with code {last_exit_code} before expected output found"
+                    )
+
         try:
             # Try to read a line with short timeout
             line = await process.read_line_async(timeout=0.1)
@@ -449,7 +472,7 @@ async def wait_for_process_output(
     # Final check of buffer before timeout error
     if all(part in buffer for part in expected_parts):
         return buffer
-    
+
     # If process exited with 0 but we didn't get output, that's still a timeout
     plog.error(
         "Timeout waiting for pattern",

provide/foundation/resilience/__init__.py

@@ -13,23 +13,24 @@ and provide consistent failure handling.
 from provide.foundation.resilience.circuit import CircuitBreaker, CircuitState
 from provide.foundation.resilience.decorators import circuit_breaker, fallback, retry
 from provide.foundation.resilience.fallback import FallbackChain
-from provide.foundation.resilience.retry import BackoffStrategy, RetryExecutor, RetryPolicy
+from provide.foundation.resilience.retry import (
+    BackoffStrategy,
+    RetryExecutor,
+    RetryPolicy,
+)
 
 __all__ = [
     # Core retry functionality
     "RetryPolicy",
     "RetryExecutor",
     "BackoffStrategy",
-    
     # Circuit breaker
     "CircuitBreaker",
     "CircuitState",
-    
     # Fallback
     "FallbackChain",
-    
     # Decorators
     "retry",
     "circuit_breaker",
     "fallback",
-]
+]

provide/foundation/resilience/circuit.py

@@ -2,81 +2,83 @@
 Circuit breaker implementation for preventing cascading failures.
 """
 
-import asyncio
-import time
 from enum import Enum
-from typing import Any, Callable, TypeVar
+import time
+from typing import Callable, TypeVar
 
 from attrs import define, field
 
-from provide.foundation.logger import logger
+from provide.foundation.logger import get_logger
+
+logger = get_logger(__name__)
 
 T = TypeVar("T")
 
 
 class CircuitState(Enum):
     """Circuit breaker states."""
-    CLOSED = "closed"      # Normal operation
-    OPEN = "open"          # Circuit is open, failing fast
+
+    CLOSED = "closed"  # Normal operation
+    OPEN = "open"  # Circuit is open, failing fast
     HALF_OPEN = "half_open"  # Testing if service has recovered
 
 
 @define(kw_only=True, slots=True)
 class CircuitBreaker:
     """Circuit breaker pattern for preventing cascading failures.
-    
+
     Tracks failures and opens the circuit when threshold is exceeded.
     Periodically allows test requests to check if service has recovered.
     """
-    
+
     failure_threshold: int = field(default=5)
     recovery_timeout: float = field(default=60.0)  # seconds
     expected_exception: tuple[type[Exception], ...] = field(
         factory=lambda: (Exception,)
     )
-    
+
     # Internal state
     _state: CircuitState = field(default=CircuitState.CLOSED, init=False)
     _failure_count: int = field(default=0, init=False)
     _last_failure_time: float | None = field(default=None, init=False)
     _next_attempt_time: float = field(default=0.0, init=False)
-    
+
     @property
     def state(self) -> CircuitState:
         """Current circuit breaker state."""
         return self._state
-    
+
     @property
     def failure_count(self) -> int:
         """Current failure count."""
         return self._failure_count
-    
+
     def _should_attempt_reset(self) -> bool:
         """Check if we should attempt to reset the circuit."""
         if self._state != CircuitState.OPEN:
             return False
-        
+
         current_time = time.time()
         return current_time >= self._next_attempt_time
-    
+
     def _record_success(self) -> None:
         """Record successful execution."""
         if self._state == CircuitState.HALF_OPEN:
             logger.info(
                 "Circuit breaker recovered - closing circuit",
                 state="half_open->closed",
-                failure_count=self._failure_count
+                failure_count=self._failure_count,
             )
-        
+
         self._failure_count = 0
         self._last_failure_time = None
         self._state = CircuitState.CLOSED
-    
+
     def _record_failure(self, exception: Exception) -> None:
         """Record failed execution."""
         self._failure_count += 1
         self._last_failure_time = time.time()
-        
+
         if self._state == CircuitState.HALF_OPEN:
             # Failed during recovery attempt
             self._state = CircuitState.OPEN
@@ -85,7 +87,7 @@ class CircuitBreaker:
                 "Circuit breaker recovery failed - opening circuit",
                 state="half_open->open",
                 failure_count=self._failure_count,
-                next_attempt_in=self.recovery_timeout
+                next_attempt_in=self.recovery_timeout,
             )
         elif self._failure_count >= self.failure_threshold:
             # Threshold exceeded, open circuit
@@ -93,12 +95,12 @@ class CircuitBreaker:
             self._next_attempt_time = self._last_failure_time + self.recovery_timeout
             logger.error(
                 "Circuit breaker opened due to failures",
-                state="closed->open", 
+                state="closed->open",
                 failure_count=self._failure_count,
                 failure_threshold=self.failure_threshold,
-                next_attempt_in=self.recovery_timeout
+                next_attempt_in=self.recovery_timeout,
             )
-    
+
     def call(self, func: Callable[..., T], *args, **kwargs) -> T:
         """Execute function with circuit breaker protection (sync)."""
         # Check if circuit is open
@@ -108,14 +110,14 @@ class CircuitBreaker:
                 logger.info(
                     "Circuit breaker attempting recovery",
                     state="open->half_open",
-                    failure_count=self._failure_count
+                    failure_count=self._failure_count,
                 )
             else:
                 raise RuntimeError(
                     f"Circuit breaker is open. Next attempt in "
                     f"{self._next_attempt_time - time.time():.1f} seconds"
                 )
-        
+
         try:
             result = func(*args, **kwargs)
             self._record_success()
@@ -124,7 +126,7 @@ class CircuitBreaker:
             if isinstance(e, self.expected_exception):
                 self._record_failure(e)
             raise
-    
+
     async def call_async(self, func: Callable[..., T], *args, **kwargs) -> T:
         """Execute async function with circuit breaker protection."""
         # Check if circuit is open
@@ -134,14 +136,14 @@ class CircuitBreaker:
                 logger.info(
                     "Circuit breaker attempting recovery",
                     state="open->half_open",
-                    failure_count=self._failure_count
+                    failure_count=self._failure_count,
                 )
             else:
                 raise RuntimeError(
                     f"Circuit breaker is open. Next attempt in "
                     f"{self._next_attempt_time - time.time():.1f} seconds"
                 )
-        
+
         try:
             result = await func(*args, **kwargs)
             self._record_success()
@@ -150,15 +152,15 @@ class CircuitBreaker:
             if isinstance(e, self.expected_exception):
                 self._record_failure(e)
             raise
-    
+
     def reset(self) -> None:
         """Manually reset the circuit breaker."""
         logger.info(
             "Circuit breaker manually reset",
             previous_state=self._state.value,
-            failure_count=self._failure_count
+            failure_count=self._failure_count,
         )
         self._state = CircuitState.CLOSED
         self._failure_count = 0
         self._last_failure_time = None
-        self._next_attempt_time = 0.0
+        self._next_attempt_time = 0.0