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

provide/foundation/hub/components.py

@@ -16,7 +16,7 @@ from attrs import define, field
 
 from provide.foundation.hub.registry import Registry, RegistryEntry
 from provide.foundation.logger import get_logger
-from provide.foundation.logger.emoji.types import EmojiSet
+from provide.foundation.eventsets.types import EventMapping
 
 log = get_logger(__name__)
 
@@ -40,12 +40,16 @@ class ComponentInfo:
 class ComponentCategory(Enum):
     """Predefined component categories for Foundation."""
 
-    EMOJI_SET = "emoji_set"
     CONFIG_SOURCE = "config_source"
     PROCESSOR = "processor"
     ERROR_HANDLER = "error_handler"
     FORMATTER = "formatter"
     FILTER = "filter"
+    TRANSPORT = "transport"
+    TRANSPORT_MIDDLEWARE = "transport.middleware"
+    TRANSPORT_AUTH = "transport.auth"
+    TRANSPORT_CACHE = "transport.cache"
+    EVENT_SET = "eventset"
 
 
 class ComponentLifecycle(Protocol):
@@ -71,119 +75,6 @@ def get_component_registry() -> Registry:
     return _component_registry
 
 
-def find_emoji_set_for_domain(domain: str) -> EmojiSet | None:
-    """Find the best emoji set for a given domain."""
-    with _registry_lock:
-        registry = get_component_registry()
-
-        # Get all emoji sets for this domain
-        all_entries = list(registry)
-        domain_sets = [
-            entry
-            for entry in all_entries
-            if (
-                entry.dimension == ComponentCategory.EMOJI_SET.value
-                and entry.metadata.get("domain") == domain
-            )
-        ]
-
-        if not domain_sets:
-            return get_default_emoji_set()
-
-        # Sort by priority (highest first)
-        domain_sets.sort(key=lambda e: e.metadata.get("priority", 0), reverse=True)
-        return domain_sets[0].value
-
-
-def get_default_emoji_set() -> EmojiSet:
-    """Get the default emoji set for unknown domains."""
-    with _registry_lock:
-        registry = get_component_registry()
-
-        # Look for default emoji set
-        all_entries = list(registry)
-        default_sets = [
-            entry
-            for entry in all_entries
-            if (
-                entry.dimension == ComponentCategory.EMOJI_SET.value
-                and entry.metadata.get("default", False)
-            )
-        ]
-
-        if default_sets:
-            return default_sets[0].value
-
-        # Return built-in default
-        return EmojiSet(
-            name="default",
-            emojis={
-                "success": "✅",
-                "error": "❌",
-                "info": "ℹ️",
-                "warning": "⚠️",
-                "debug": "🔍",
-            },
-        )
-
-
-def resolve_emoji_for_domain(domain: str, action: str) -> str:
-    """Resolve emoji for domain and action with priority ordering."""
-    with _registry_lock:
-        registry = get_component_registry()
-
-        # Get all emoji sets for this domain
-        all_entries = list(registry)
-        domain_sets = [
-            entry
-            for entry in all_entries
-            if (
-                entry.dimension == ComponentCategory.EMOJI_SET.value
-                and entry.metadata.get("domain") == domain
-            )
-        ]
-
-        # Sort by priority (highest first)
-        domain_sets.sort(key=lambda e: e.metadata.get("priority", 0), reverse=True)
-
-        # Try each set in priority order
-        for entry in domain_sets:
-            emoji_set = entry.value
-            if action in emoji_set.emojis:
-                return emoji_set.emojis[action]
-
-        # Fall back to default
-        default_set = get_default_emoji_set()
-        return default_set.emojis.get(action, "📝")
-
-
-def get_composed_emoji_set(domain: str) -> EmojiSet:
-    """Get composed emoji set combining all sets for a domain."""
-    with _registry_lock:
-        registry = get_component_registry()
-
-        # Get all emoji sets for this domain
-        all_entries = list(registry)
-        domain_sets = [
-            entry
-            for entry in all_entries
-            if (
-                entry.dimension == ComponentCategory.EMOJI_SET.value
-                and entry.metadata.get("domain") == domain
-            )
-        ]
-
-        # Sort by priority (lowest first for composition)
-        domain_sets.sort(key=lambda e: e.metadata.get("priority", 0))
-
-        # Compose emojis
-        composed_emojis = {}
-        for entry in domain_sets:
-            emoji_set = entry.value
-            composed_emojis.update(emoji_set.emojis)
-
-        return EmojiSet(name=f"composed_{domain}", emojis=composed_emojis)
-
 
 def resolve_config_value(key: str) -> Any:
     """Resolve configuration value using priority-ordered sources."""
@@ -532,24 +423,7 @@ def bootstrap_foundation() -> None:
     """Bootstrap Foundation with core registry components."""
     registry = get_component_registry()
 
-    # Register default emoji set
-    default_emoji_set = EmojiSet(
-        name="foundation_default",
-        emojis={
-            "success": "✅",
-            "error": "❌",
-            "info": "ℹ️",
-            "warning": "⚠️",
-            "debug": "🔍",
-        },
-    )
-
-    registry.register(
-        name="default",
-        value=default_emoji_set,
-        dimension=ComponentCategory.EMOJI_SET.value,
-        metadata={"default": True, "priority": 1},
-    )
+    # Event sets are now managed by the eventsets module
 
     # Config sources would be registered here when implemented
 

provide/foundation/logger/__init__.py

@@ -6,6 +6,9 @@ Foundation Telemetry Logger Sub-package.
 Re-exports key components related to logging functionality.
 """
 
+# Import trace module early to ensure PrintLogger gets patched
+from provide.foundation.logger import trace  # noqa: F401
+
 from provide.foundation.logger.base import (
     FoundationLogger,  # Class definition
     get_logger,  # Factory function
@@ -17,17 +20,8 @@ from provide.foundation.logger.config import (
     LoggingConfig,
     TelemetryConfig,
 )
-from provide.foundation.logger.emoji.matrix import (
-    PRIMARY_EMOJI,  # Core domain emojis
-    SECONDARY_EMOJI,  # Core action emojis
-    TERTIARY_EMOJI,  # Core status emojis
-    show_emoji_matrix,  # Utility to display emoji configurations
-)
 
 __all__ = [
-    "PRIMARY_EMOJI",
-    "SECONDARY_EMOJI",
-    "TERTIARY_EMOJI",
     "FoundationLogger",
     "LoggingConfig",
     "TelemetryConfig",
@@ -35,7 +29,6 @@ __all__ = [
     "logger",
     "setup_logger",  # Consistent naming
     "setup_logging",  # Backward compatibility
-    "show_emoji_matrix",
 ]
 
 # 🐍📝

provide/foundation/logger/config/logging.py

@@ -14,7 +14,7 @@ from attrs import define
 from provide.foundation.config import BaseConfig, field
 from provide.foundation.config.types import ConfigSource
 from provide.foundation.logger.config.base import get_config_logger
-from provide.foundation.logger.emoji.types import EmojiSet, EmojiSetConfig
+from provide.foundation.eventsets.types import EventMapping, EventSet
 from provide.foundation.types import (
     _VALID_FORMATTER_TUPLE,
     _VALID_LOG_LEVEL_TUPLE,
@@ -28,7 +28,7 @@ class LoggingConfig(BaseConfig):
     """Configuration specific to logging behavior within Foundation Telemetry."""
 
     default_level: LogLevelStr = field(
-        default="DEBUG",
+        default="WARNING",
         env_var="PROVIDE_LOG_LEVEL",
         description="Default logging level",
     )
@@ -62,12 +62,12 @@ class LoggingConfig(BaseConfig):
         env_var="PROVIDE_LOG_ENABLED_EMOJI_SETS",
         description="Comma-separated list of emoji sets to enable",
     )
-    custom_emoji_sets: list[EmojiSetConfig] = field(
+    custom_emoji_sets: list[EventSet] = field(
         factory=lambda: [],
         env_var="PROVIDE_LOG_CUSTOM_EMOJI_SETS",
         description="JSON array of custom emoji set configurations",
     )
-    user_defined_emoji_sets: list[EmojiSet] = field(
+    user_defined_emoji_sets: list[EventMapping] = field(
         factory=lambda: [],
         env_var="PROVIDE_LOG_USER_DEFINED_EMOJI_SETS",
         description="JSON array of user-defined emoji sets",
@@ -342,7 +342,7 @@ class LoggingConfig(BaseConfig):
                 parsed = json.loads(custom_sets)
                 if isinstance(parsed, list):
                     config_dict["custom_emoji_sets"] = [
-                        EmojiSetConfig(**item) if isinstance(item, dict) else item
+                        EventSet(**item) if isinstance(item, dict) else item
                         for item in parsed
                     ]
             except json.JSONDecodeError as e:
@@ -369,7 +369,7 @@ class LoggingConfig(BaseConfig):
                 parsed = json.loads(user_sets)
                 if isinstance(parsed, list):
                     config_dict["user_defined_emoji_sets"] = [
-                        EmojiSet(**item) if isinstance(item, dict) else item
+                        EventMapping(**item) if isinstance(item, dict) else item
                         for item in parsed
                     ]
             except json.JSONDecodeError as e:

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