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

provide/foundation/logger/config/telemetry.py

@@ -5,22 +5,39 @@
 TelemetryConfig class for Foundation telemetry configuration.
 """
 
-import os
-
 from attrs import define
 
-from provide.foundation.config import BaseConfig, field
+from provide.foundation.config.env import RuntimeConfig
+from provide.foundation.config.base import field
+from provide.foundation.config.defaults import (
+    DEFAULT_TELEMETRY_GLOBALLY_DISABLED,
+    DEFAULT_TRACING_ENABLED,
+    DEFAULT_METRICS_ENABLED,
+    DEFAULT_OTLP_PROTOCOL,
+    DEFAULT_TRACE_SAMPLE_RATE,
+)
+import os
+from provide.foundation.config.converters import (
+    parse_bool_extended,
+    parse_headers,
+    parse_sample_rate,
+    validate_sample_rate,
+)
 from provide.foundation.logger.config.logging import LoggingConfig
 
 
+def _get_service_name() -> str | None:
+    """Get service name from OTEL_SERVICE_NAME or PROVIDE_SERVICE_NAME (OTEL takes precedence)."""
+    return os.getenv("OTEL_SERVICE_NAME") or os.getenv("PROVIDE_SERVICE_NAME")
+
+
 @define(slots=True, repr=False)
-class TelemetryConfig(BaseConfig):
+class TelemetryConfig(RuntimeConfig):
     """Main configuration object for the Foundation Telemetry system."""
 
     service_name: str | None = field(
-        default=None,
-        env_var="PROVIDE_SERVICE_NAME",
-        description="Service name for telemetry",
+        factory=_get_service_name,
+        description="Service name for telemetry (from OTEL_SERVICE_NAME or PROVIDE_SERVICE_NAME)",
     )
     service_version: str | None = field(
         default=None,
@@ -28,23 +45,27 @@ class TelemetryConfig(BaseConfig):
         description="Service version for telemetry",
     )
     logging: LoggingConfig = field(
-        factory=LoggingConfig, description="Logging configuration"
+        factory=lambda: LoggingConfig.from_env(),
+        description="Logging configuration"
     )
     globally_disabled: bool = field(
-        default=False,
+        default=DEFAULT_TELEMETRY_GLOBALLY_DISABLED,
         env_var="PROVIDE_TELEMETRY_DISABLED",
+        converter=parse_bool_extended,
         description="Globally disable telemetry",
     )
 
     # OpenTelemetry configuration
     tracing_enabled: bool = field(
-        default=True,
+        default=DEFAULT_TRACING_ENABLED,
         env_var="OTEL_TRACING_ENABLED",
+        converter=parse_bool_extended,
         description="Enable OpenTelemetry tracing",
     )
     metrics_enabled: bool = field(
-        default=True,
+        default=DEFAULT_METRICS_ENABLED,
         env_var="OTEL_METRICS_ENABLED",
+        converter=parse_bool_extended,
         description="Enable OpenTelemetry metrics",
     )
     otlp_endpoint: str | None = field(
@@ -57,132 +78,31 @@ class TelemetryConfig(BaseConfig):
         env_var="OTEL_EXPORTER_OTLP_TRACES_ENDPOINT",
         description="OTLP endpoint specifically for traces",
     )
-    otlp_headers: str | None = field(
-        default=None,
+    otlp_headers: dict[str, str] = field(
+        factory=lambda: {},
         env_var="OTEL_EXPORTER_OTLP_HEADERS",
+        converter=parse_headers,
         description="Headers to send with OTLP requests (key1=value1,key2=value2)",
     )
     otlp_protocol: str = field(
-        default="http/protobuf",
+        default=DEFAULT_OTLP_PROTOCOL,
         env_var="OTEL_EXPORTER_OTLP_PROTOCOL",
         description="OTLP protocol (grpc, http/protobuf)",
     )
     trace_sample_rate: float = field(
-        default=1.0,
+        default=DEFAULT_TRACE_SAMPLE_RATE,
         env_var="OTEL_TRACE_SAMPLE_RATE",
+        converter=parse_sample_rate,
+        validator=validate_sample_rate,
         description="Sampling rate for traces (0.0 to 1.0)",
     )
 
-    # OpenObserve configuration
-    openobserve_url: str | None = field(
-        default=None,
-        env_var="OPENOBSERVE_URL",
-        description="OpenObserve API endpoint URL",
-    )
-    openobserve_org: str = field(
-        default="default",
-        env_var="OPENOBSERVE_ORG",
-        description="OpenObserve organization name",
-    )
-    openobserve_user: str | None = field(
-        default=None,
-        env_var="OPENOBSERVE_USER",
-        description="OpenObserve username for authentication",
-    )
-    openobserve_password: str | None = field(
-        default=None,
-        env_var="OPENOBSERVE_PASSWORD",
-        description="OpenObserve password for authentication",
-    )
-    openobserve_stream: str = field(
-        default="default",
-        env_var="OPENOBSERVE_STREAM",
-        description="Default OpenObserve stream name",
-    )
-
-    @classmethod
-    def from_env(cls, strict: bool = True) -> "TelemetryConfig":
-        """Creates a TelemetryConfig instance from environment variables."""
-        config_dict = {}
-
-        # Check OTEL_SERVICE_NAME first, then PROVIDE_SERVICE_NAME
-        service_name = os.getenv("OTEL_SERVICE_NAME") or os.getenv(
-            "PROVIDE_SERVICE_NAME"
-        )
-        if service_name:
-            config_dict["service_name"] = service_name
 
-        # Service version
-        service_version = os.getenv("OTEL_SERVICE_VERSION") or os.getenv(
-            "PROVIDE_SERVICE_VERSION"
-        )
-        if service_version:
-            config_dict["service_version"] = service_version
-
-        # Telemetry disable flag
-        if disabled := os.getenv("PROVIDE_TELEMETRY_DISABLED"):
-            config_dict["globally_disabled"] = disabled.lower() == "true"
-
-        # OpenTelemetry specific configuration
-        if tracing_enabled := os.getenv("OTEL_TRACING_ENABLED"):
-            config_dict["tracing_enabled"] = tracing_enabled.lower() == "true"
-
-        if metrics_enabled := os.getenv("OTEL_METRICS_ENABLED"):
-            config_dict["metrics_enabled"] = metrics_enabled.lower() == "true"
-
-        if otlp_endpoint := os.getenv("OTEL_EXPORTER_OTLP_ENDPOINT"):
-            config_dict["otlp_endpoint"] = otlp_endpoint
-
-        if otlp_traces_endpoint := os.getenv("OTEL_EXPORTER_OTLP_TRACES_ENDPOINT"):
-            config_dict["otlp_traces_endpoint"] = otlp_traces_endpoint
-
-        if otlp_headers := os.getenv("OTEL_EXPORTER_OTLP_HEADERS"):
-            config_dict["otlp_headers"] = otlp_headers
-
-        if otlp_protocol := os.getenv("OTEL_EXPORTER_OTLP_PROTOCOL"):
-            config_dict["otlp_protocol"] = otlp_protocol
-
-        if trace_sample_rate := os.getenv("OTEL_TRACE_SAMPLE_RATE"):
-            try:
-                config_dict["trace_sample_rate"] = float(trace_sample_rate)
-            except ValueError:
-                if strict:
-                    raise
-                # Use default value in non-strict mode
-
-        # OpenObserve configuration
-        if openobserve_url := os.getenv("OPENOBSERVE_URL"):
-            config_dict["openobserve_url"] = openobserve_url
-
-        if openobserve_org := os.getenv("OPENOBSERVE_ORG"):
-            config_dict["openobserve_org"] = openobserve_org
-
-        if openobserve_user := os.getenv("OPENOBSERVE_USER"):
-            config_dict["openobserve_user"] = openobserve_user
-
-        if openobserve_password := os.getenv("OPENOBSERVE_PASSWORD"):
-            config_dict["openobserve_password"] = openobserve_password
-
-        if openobserve_stream := os.getenv("OPENOBSERVE_STREAM"):
-            config_dict["openobserve_stream"] = openobserve_stream
-
-        # Load logging config from env
-        config_dict["logging"] = LoggingConfig.from_env(strict=strict)
-
-        return cls(**config_dict)
 
     def get_otlp_headers_dict(self) -> dict[str, str]:
-        """Parse OTLP headers string into dictionary.
+        """Get OTLP headers dictionary.
 
         Returns:
             Dictionary of header key-value pairs
         """
-        if not self.otlp_headers:
-            return {}
-
-        headers = {}
-        for pair in self.otlp_headers.split(","):
-            if "=" in pair:
-                key, value = pair.split("=", 1)
-                headers[key.strip()] = value.strip()
-        return headers
+        return self.otlp_headers

provide/foundation/logger/core.py

@@ -16,7 +16,6 @@ from provide.foundation.types import TRACE_LEVEL_NAME
 
 if TYPE_CHECKING:
     from provide.foundation.logger.config import TelemetryConfig
-    from provide.foundation.logger.setup.emoji_resolver import ResolvedEmojiConfig
 
 _LAZY_SETUP_LOCK = threading.Lock()
 _LAZY_SETUP_STATE: dict[str, Any] = {"done": False, "error": None, "in_progress": False}
@@ -31,7 +30,6 @@ class FoundationLogger:
         )
         self._is_configured_by_setup: bool = False
         self._active_config: TelemetryConfig | None = None
-        self._active_resolved_emoji_config: ResolvedEmojiConfig | None = None
 
     def _check_structlog_already_disabled(self) -> bool:
         try:

provide/foundation/logger/custom_processors.py

@@ -131,6 +131,7 @@ _EMOJI_CACHE_SIZE_LIMIT: int = 1000
 
 
 def _compute_emoji_for_logger_name(logger_name: str) -> str:
+    # Original keyword-based system
     for keyword in _SORTED_LOGGER_NAME_EMOJI_KEYWORDS:
         if keyword == "default":
             continue

provide/foundation/logger/factories.py

@@ -10,18 +10,27 @@ from typing import Any
 from provide.foundation.logger.core import logger
 
 
-def get_logger(name: str | None = None) -> Any:
+def get_logger(
+    name: str | None = None,
+    emoji: str | None = None,
+    emoji_hierarchy: dict[str, str] | None = None
+) -> Any:
     """
-    Get a logger instance with the given name.
+    Get a logger instance with the given name and optional emoji customization.
 
     This is a convenience function that uses the global FoundationLogger.
 
     Args:
         name: Logger name (e.g., __name__ from a module)
+        emoji: Override emoji for this specific logger instance
+        emoji_hierarchy: Define emoji mapping for module hierarchy patterns
 
     Returns:
         Configured structlog logger instance
     """
+    # 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

@@ -26,8 +26,6 @@ from provide.foundation.types import (
     LogLevelStr,
 )
 
-if TYPE_CHECKING:
-    from provide.foundation.logger.setup.emoji_resolver import ResolvedEmojiConfig
 
 _LEVEL_TO_NUMERIC: dict[LogLevelStr, int] = {
     "CRITICAL": stdlib_logging.CRITICAL,
@@ -71,96 +69,34 @@ def _config_create_timestamp_processors(
     return processors
 
 
-def _config_create_emoji_processors(
-    logging_config: LoggingConfig, resolved_emoji_config: "ResolvedEmojiConfig"
+def _config_create_event_enrichment_processors(
+    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:
-        # FIX: Create the processor as a closure with the resolved config
-        resolved_field_definitions, resolved_emoji_sets_lookup = resolved_emoji_config
-
-        def add_das_emoji_prefix_closure(
+        def add_event_enrichment_processor(
             _logger: Any, _method_name: str, event_dict: structlog.types.EventDict
         ) -> structlog.types.EventDict:
-            # This inner function now has access to the resolved config from its closure scope
-            from provide.foundation.logger.emoji.matrix import (
-                PRIMARY_EMOJI,
-                SECONDARY_EMOJI,
-                TERTIARY_EMOJI,
-            )
-
-            final_das_prefix_parts: list[str] = []
-
-            if resolved_field_definitions:  # New Layered Emoji System is active
-                for field_def in resolved_field_definitions:
-                    value_from_event = event_dict.get(field_def.log_key)
-                    if value_from_event is not None and field_def.emoji_set_name:
-                        event_dict.pop(field_def.log_key, None)
-                        emoji_set = resolved_emoji_sets_lookup.get(
-                            field_def.emoji_set_name
-                        )
-                        if emoji_set:
-                            value_str_lower = str(value_from_event).lower()
-                            specific_emoji = emoji_set.emojis.get(value_str_lower)
-                            default_key = (
-                                field_def.default_emoji_override_key
-                                or emoji_set.default_emoji_key
-                            )
-                            default_emoji = emoji_set.emojis.get(default_key, "❓")
-                            chosen_emoji = (
-                                specific_emoji
-                                if specific_emoji is not None
-                                else default_emoji
-                            )
-                            final_das_prefix_parts.append(f"[{chosen_emoji}]")
-                        else:
-                            final_das_prefix_parts.append("[❓]")
-            else:  # Fallback to Core DAS System
-                domain = event_dict.pop("domain", None)
-                action = event_dict.pop("action", None)
-                status = event_dict.pop("status", None)
-                if domain or action or status:
-                    domain_emoji = (
-                        PRIMARY_EMOJI.get(str(domain).lower(), PRIMARY_EMOJI["default"])
-                        if domain
-                        else PRIMARY_EMOJI["default"]
-                    )
-                    action_emoji = (
-                        SECONDARY_EMOJI.get(
-                            str(action).lower(), SECONDARY_EMOJI["default"]
-                        )
-                        if action
-                        else SECONDARY_EMOJI["default"]
-                    )
-                    status_emoji = (
-                        TERTIARY_EMOJI.get(
-                            str(status).lower(), TERTIARY_EMOJI["default"]
-                        )
-                        if status
-                        else TERTIARY_EMOJI["default"]
-                    )
-                    final_das_prefix_parts.extend(
-                        [f"[{domain_emoji}]", f"[{action_emoji}]", f"[{status_emoji}]"]
-                    )
-
-            if final_das_prefix_parts:
-                final_das_prefix_str = "".join(final_das_prefix_parts)
-                event_msg = event_dict.get("event")
-                event_dict["event"] = (
-                    f"{final_das_prefix_str} {event_msg}"
-                    if event_msg is not None
-                    else final_das_prefix_str
-                )
-            return event_dict
-
-        processors.append(cast(StructlogProcessor, add_das_emoji_prefix_closure))
+            # Lazy import to avoid circular dependency
+            from provide.foundation.eventsets.resolver import get_resolver
+            from provide.foundation.eventsets.registry import discover_event_sets
+            
+            # Initialize on first use
+            if not hasattr(add_event_enrichment_processor, '_initialized'):
+                discover_event_sets()
+                add_event_enrichment_processor._initialized = True
+            
+            resolver = get_resolver()
+            return resolver.enrich_event(event_dict)
+
+        processors.append(cast(StructlogProcessor, add_event_enrichment_processor))
     return processors
 
 
 def _build_core_processors_list(
-    config: TelemetryConfig, resolved_emoji_config: "ResolvedEmojiConfig"
+    config: TelemetryConfig
 ) -> list[StructlogProcessor]:
     log_cfg = config.logging
     processors: list[StructlogProcessor] = [
@@ -202,7 +138,7 @@ def _build_core_processors_list(
     if config.tracing_enabled and not config.globally_disabled:
         processors.append(cast(StructlogProcessor, inject_trace_context))
 
-    processors.extend(_config_create_emoji_processors(log_cfg, resolved_emoji_config))
+    processors.extend(_config_create_event_enrichment_processors(log_cfg))
     return processors
 
 
@@ -243,10 +179,10 @@ def _build_formatter_processors_list(
             # Unknown formatter, warn and default to key_value
             # Use setup coordinator logger
             from provide.foundation.logger.setup.coordinator import (
-                create_core_setup_logger,
+                create_foundation_internal_logger,
             )
 
-            setup_logger = create_core_setup_logger()
+            setup_logger = create_foundation_internal_logger()
             setup_logger.warning(
                 f"Unknown formatter '{logging_config.console_formatter}', using default 'key_value'. "
                 f"Valid formatters: ['json', 'key_value']"

provide/foundation/logger/setup/__init__.py

@@ -8,7 +8,10 @@ Handles structured logging configuration, processor setup, and emoji resolution.
 Provides the core setup functionality for the Foundation logging system.
 """
 
-from provide.foundation.logger.setup.coordinator import internal_setup
+from provide.foundation.logger.setup.coordinator import (
+    get_vanilla_logger,
+    internal_setup,
+)
 
 # Import testing utilities conditionally
 try:
@@ -22,6 +25,7 @@ except ImportError:
     reset_for_testing = None
 
 __all__ = [
+    "get_vanilla_logger",
     "internal_setup",
 ]
 

provide/foundation/logger/setup/coordinator.py

@@ -17,8 +17,6 @@ from provide.foundation.logger.core import (
     _LAZY_SETUP_STATE,
     logger as foundation_logger,
 )
-from provide.foundation.logger.emoji.sets import BUILTIN_EMOJI_SETS
-from provide.foundation.logger.setup.emoji_resolver import resolve_active_emoji_config
 from provide.foundation.logger.setup.processors import (
     configure_structlog_output,
     handle_globally_disabled_setup,
@@ -33,22 +31,35 @@ _FOUNDATION_LOG_LEVEL: int | None = None
 
 
 def get_foundation_log_level() -> int:
-    """Get the Foundation log level from LoggingConfig, checking only once."""
+    """Get Foundation log level for setup phase, safely."""
     global _FOUNDATION_LOG_LEVEL
     if _FOUNDATION_LOG_LEVEL is None:
-        # Use the proper config system to get the Foundation setup log level
-        logging_config = LoggingConfig.from_env(strict=False)
-        level_str = logging_config.foundation_setup_log_level.upper()
-        _FOUNDATION_LOG_LEVEL = getattr(
-            stdlib_logging,
-            level_str,
-            stdlib_logging.INFO,  # Default fallback
-        )
+        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,
+            "ERROR": stdlib_logging.ERROR,
+            "WARNING": stdlib_logging.WARNING,
+            "INFO": stdlib_logging.INFO,
+            "DEBUG": stdlib_logging.DEBUG,
+            "NOTSET": stdlib_logging.NOTSET,
+        }
+        
+        _FOUNDATION_LOG_LEVEL = valid_levels.get(level_str, stdlib_logging.INFO)
     return _FOUNDATION_LOG_LEVEL
 
 
-def create_core_setup_logger(globally_disabled: bool = False) -> Any:
-    """Create a structlog logger for core setup messages."""
+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.
+    """
     if globally_disabled:
         # Configure structlog to be a no-op for core setup logger
         structlog.configure(
@@ -61,7 +72,7 @@ def create_core_setup_logger(globally_disabled: bool = False) -> Any:
     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
             )
@@ -84,6 +95,55 @@ def create_core_setup_logger(globally_disabled: bool = False) -> Any:
         return structlog.get_logger(_CORE_SETUP_LOGGER_NAME)
 
 
+def get_vanilla_logger(name: str):
+    """
+    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
+    
+    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'
+        )
+        handler.setFormatter(formatter)
+        slog.addHandler(handler)
+        
+        # Don't propagate to avoid duplicate messages
+        slog.propagate = False
+    
+    return slog
+
+
 def internal_setup(
     config: TelemetryConfig | None = None, is_explicit_call: bool = False
 ) -> None:
@@ -95,11 +155,10 @@ def internal_setup(
     structlog.reset_defaults()
     foundation_logger._is_configured_by_setup = False
     foundation_logger._active_config = None
-    foundation_logger._active_resolved_emoji_config = None
     _LAZY_SETUP_STATE.update({"done": False, "error": None, "in_progress": False})
 
     current_config = config if config is not None else TelemetryConfig.from_env()
-    core_setup_logger = create_core_setup_logger(
+    core_setup_logger = create_foundation_internal_logger(
         globally_disabled=current_config.globally_disabled
     )
 
@@ -111,28 +170,21 @@ def internal_setup(
             formatter=current_config.logging.console_formatter,
         )
 
-    resolved_emoji_config = resolve_active_emoji_config(
-        current_config.logging, BUILTIN_EMOJI_SETS
-    )
 
     if current_config.globally_disabled:
         handle_globally_disabled_setup()
     else:
         configure_structlog_output(
-            current_config, resolved_emoji_config, get_log_stream()
+            current_config, get_log_stream()
         )
 
     foundation_logger._is_configured_by_setup = is_explicit_call
     foundation_logger._active_config = current_config
-    foundation_logger._active_resolved_emoji_config = resolved_emoji_config
     _LAZY_SETUP_STATE["done"] = True
 
     if not current_config.globally_disabled:
-        field_definitions, emoji_sets = resolved_emoji_config
         core_setup_logger.debug(
             "⚙️➡️✅ Foundation (structlog) setup completed",
-            emoji_sets_enabled=len(field_definitions) > 0,
-            emoji_sets_count=len(emoji_sets),
             processors_configured=True,
             log_file_enabled=current_config.logging.log_file is not None,
         )

provide/foundation/logger/setup/processors.py

@@ -15,12 +15,8 @@ from provide.foundation.logger.processors import (
     _build_core_processors_list,
     _build_formatter_processors_list,
 )
-from provide.foundation.logger.setup.emoji_resolver import ResolvedEmojiConfig
-
-
 def build_complete_processor_chain(
     config: TelemetryConfig,
-    resolved_emoji_config: ResolvedEmojiConfig,
     log_stream: TextIO,
 ) -> list[Any]:
     """
@@ -28,13 +24,12 @@ def build_complete_processor_chain(
 
     Args:
         config: Telemetry configuration
-        resolved_emoji_config: Resolved emoji configuration
         log_stream: Output stream for logging
 
     Returns:
         List of processors for structlog
     """
-    core_processors = _build_core_processors_list(config, resolved_emoji_config)
+    core_processors = _build_core_processors_list(config)
     formatter_processors = _build_formatter_processors_list(config.logging, log_stream)
     return cast(list[Any], core_processors + formatter_processors)
 
@@ -57,7 +52,6 @@ def apply_structlog_configuration(processors: list[Any], log_stream: TextIO) ->
 
 def configure_structlog_output(
     config: TelemetryConfig,
-    resolved_emoji_config: ResolvedEmojiConfig,
     log_stream: TextIO,
 ) -> None:
     """
@@ -65,11 +59,10 @@ def configure_structlog_output(
 
     Args:
         config: Telemetry configuration
-        resolved_emoji_config: Resolved emoji configuration
         log_stream: Output stream for logging
     """
     processors = build_complete_processor_chain(
-        config, resolved_emoji_config, log_stream
+        config, log_stream
     )
     apply_structlog_configuration(processors, log_stream)
 

provide/foundation/logger/trace.py

@@ -36,3 +36,30 @@ if not hasattr(stdlib_logging, TRACE_LEVEL_NAME):  # pragma: no cover
         (cast(Any, stdlib_logging.root)).trace = trace.__get__(
             stdlib_logging.root, stdlib_logging.Logger
         )
+
+# 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
+            # PrintLogger doesn't have level checking, so just format and print like other methods
+            if args:
+                try:
+                    formatted_msg = str(msg) % args
+                except (TypeError, ValueError):
+                    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