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

provide/foundation/crypto/certificates/trust.py

@@ -0,0 +1,107 @@
+"""Certificate trust chain and verification utilities."""
+
+try:
+    from cryptography import x509
+    from cryptography.hazmat.primitives.asymmetric import ec, rsa
+    
+    _HAS_CRYPTO = True
+except ImportError:
+    x509 = None
+    ec = None
+    rsa = None
+    _HAS_CRYPTO = False
+
+from provide.foundation import logger
+from provide.foundation.crypto.certificates.base import CertificateError
+from provide.foundation.crypto.certificates.operations import validate_signature
+
+
+def verify_trust(
+    cert: "Certificate",
+    other_cert: "Certificate",
+    trust_chain: list["Certificate"],
+) -> bool:
+    """
+    Verifies if the other_cert is trusted based on this certificate's trust chain.
+    
+    Args:
+        cert: The certificate doing the verification
+        other_cert: The certificate to verify
+        trust_chain: List of trusted certificates
+        
+    Returns:
+        True if the certificate is trusted, False otherwise
+    """
+    if other_cert is None:
+        raise CertificateError("Cannot verify trust: other_cert is None")
+    
+    logger.debug(
+        f"📜🔍🚀 Verifying trust for cert S/N {other_cert.serial_number} "
+        f"against chain of S/N {cert.serial_number}"
+    )
+    
+    if not other_cert.is_valid:
+        logger.debug(
+            "📜🔍⚠️ Trust verification failed: Other certificate is not valid"
+        )
+        return False
+    if not other_cert.public_key:
+        raise CertificateError(
+            "Cannot verify trust: Other certificate has no public key"
+        )
+    
+    if cert == other_cert:
+        logger.debug(
+            "📜🔍✅ Trust verified: Certificates are identical (based on subject/serial)"
+        )
+        return True
+    
+    if other_cert in trust_chain:
+        logger.debug(
+            "📜🔍✅ Trust verified: Other certificate found in trust chain"
+        )
+        return True
+    
+    for trusted_cert in trust_chain:
+        logger.debug(
+            f"📜🔍🔁 Checking signature against trusted cert S/N {trusted_cert.serial_number}"
+        )
+        if validate_signature_wrapper(
+            signed_cert=other_cert, signing_cert=trusted_cert
+        ):
+            logger.debug(
+                f"📜🔍✅ Trust verified: Other cert signed by trusted cert S/N "
+                f"{trusted_cert.serial_number}"
+            )
+            return True
+    
+    logger.debug(
+        "📜🔍❌ Trust verification failed: Other certificate not identical, "
+        "not in chain, and not signed by any cert in chain"
+    )
+    return False
+
+
+def validate_signature_wrapper(
+    signed_cert: "Certificate", 
+    signing_cert: "Certificate"
+) -> bool:
+    """
+    Internal helper: Validates signature and issuer/subject match.
+    
+    Args:
+        signed_cert: The certificate that was signed
+        signing_cert: The certificate that did the signing
+        
+    Returns:
+        True if signature is valid, False otherwise
+    """
+    if not hasattr(signed_cert, "_cert") or not hasattr(signing_cert, "_cert"):
+        logger.error(
+            "📜🔍❌ Cannot validate signature: Certificate object(s) not initialized"
+        )
+        return False
+    
+    return validate_signature(
+        signed_cert._cert, signing_cert._cert, signing_cert.public_key
+    )

provide/foundation/eventsets/display.py

@@ -0,0 +1,84 @@
+"""
+Event set display utilities for Foundation.
+"""
+
+from provide.foundation.logger import get_logger
+
+from provide.foundation.eventsets.registry import get_registry, discover_event_sets
+from provide.foundation.eventsets.resolver import get_resolver
+
+logger = get_logger(__name__)
+
+
+def show_event_matrix() -> None:
+    """
+    Display the active event set configuration to the console.
+    Shows all registered event sets and their field mappings.
+    """
+    # Ensure event sets are discovered
+    discover_event_sets()
+    
+    registry = get_registry()
+    resolver = get_resolver()
+    
+    # Force resolution to ensure everything is loaded
+    resolver.resolve()
+    
+    lines: list[str] = ["Foundation Event Sets: Active Configuration"]
+    lines.append("=" * 70)
+    
+    # Show registered event sets
+    event_sets = registry.list_event_sets()
+    if event_sets:
+        lines.append(f"\nRegistered Event Sets ({len(event_sets)}):")
+        for config in event_sets:
+            lines.append(f"\n  {config.name} (priority: {config.priority})")
+            if config.description:
+                lines.append(f"    {config.description}")
+            
+            # Show field mappings
+            if config.field_mappings:
+                lines.append(f"    Field Mappings ({len(config.field_mappings)}):")
+                for mapping in config.field_mappings[:5]:  # Show first 5
+                    lines.append(f"      - {mapping.log_key}")
+                if len(config.field_mappings) > 5:
+                    lines.append(f"      ... and {len(config.field_mappings) - 5} more")
+            
+            # Show event sets
+            if config.event_sets:
+                lines.append(f"    Event Sets ({len(config.event_sets)}):")
+                for event_set in config.event_sets:
+                    marker_count = len(event_set.visual_markers)
+                    metadata_count = len(event_set.metadata_fields)
+                    transform_count = len(event_set.transformations)
+                    lines.append(
+                        f"      - {event_set.name}: "
+                        f"{marker_count} markers, "
+                        f"{metadata_count} metadata, "
+                        f"{transform_count} transforms"
+                    )
+    else:
+        lines.append("\n  (No event sets registered)")
+    
+    lines.append("\n" + "=" * 70)
+    
+    # Show resolved state
+    if resolver._resolved:
+        lines.append("\nResolver State:")
+        lines.append(f"  Total Field Mappings: {len(resolver._field_mappings)}")
+        lines.append(f"  Total Event Sets: {len(resolver._event_sets)}")
+        
+        # Show sample visual markers
+        if resolver._event_sets:
+            lines.append("\n  Sample Visual Markers:")
+            for name, event_set in list(resolver._event_sets.items())[:3]:
+                if event_set.visual_markers:
+                    sample_markers = list(event_set.visual_markers.items())[:3]
+                    lines.append(f"    {name}:")
+                    for key, marker in sample_markers:
+                        lines.append(f"      {marker} -> {key}")
+    else:
+        lines.append("\n  (Resolver not yet initialized)")
+    
+    # Log the complete display
+    logger.info("\n".join(lines))

provide/foundation/eventsets/registry.py

@@ -0,0 +1,160 @@
+"""
+Event set registry and discovery.
+"""
+
+import importlib
+import pkgutil
+from pathlib import Path
+
+from provide.foundation.errors.resources import AlreadyExistsError, NotFoundError
+from provide.foundation.hub.registry import Registry
+from provide.foundation.logger.setup.coordinator import create_foundation_internal_logger
+
+from provide.foundation.eventsets.types import EventSet
+
+# Bootstrap logger that doesn't trigger full logger setup
+logger = create_foundation_internal_logger()
+
+
+class EventSetRegistry(Registry):
+    """
+    Registry for event set definitions using foundation Registry.
+    
+    Extends the foundation Registry to provide specialized
+    methods for event set registration and discovery.
+    """
+    
+    def register_event_set(self, event_set: EventSet) -> None:
+        """
+        Register an event set definition.
+        
+        Args:
+            event_set: The EventSet to register
+            
+        Raises:
+            AlreadyExistsError: If an event set with this name already exists
+        """
+        try:
+            self.register(event_set.name, event_set, "eventset", metadata={"priority": event_set.priority})
+            logger.debug(
+                "Registered event set",
+                name=event_set.name,
+                priority=event_set.priority,
+                field_count=len(event_set.field_mappings),
+                mapping_count=len(event_set.mappings)
+            )
+        except AlreadyExistsError:
+            logger.warning("Event set already registered", name=event_set.name)
+            raise
+    
+    def get_event_set(self, name: str) -> EventSet:
+        """
+        Retrieve an event set by name.
+        
+        Args:
+            name: The name of the event set
+            
+        Returns:
+            The EventSet
+            
+        Raises:
+            NotFoundError: If no event set with this name exists
+        """
+        event_set = self.get(name, "eventset")
+        if event_set is None:
+            raise NotFoundError(f"Event set '{name}' not found")
+        return event_set
+    
+    def list_event_sets(self) -> list[EventSet]:
+        """
+        List all registered event sets sorted by priority.
+        
+        Returns:
+            List of EventSet objects sorted by descending priority
+        """
+        names = self.list_dimension("eventset")
+        entries = [self.get_entry(name, "eventset") for name in names]
+        entries = [entry for entry in entries if entry is not None]
+        entries.sort(key=lambda e: e.metadata.get("priority", 0), reverse=True)
+        return [entry.value for entry in entries]
+    
+    def discover_sets(self) -> None:
+        """
+        Auto-discover and register event sets from the sets/ directory.
+        
+        Imports all modules in the sets/ subdirectory and registers
+        any EVENT_SET constants found.
+        """
+        sets_path = Path(__file__).parent / "sets"
+        if not sets_path.exists():
+            logger.debug("No sets directory found for auto-discovery")
+            return
+        
+        for module_info in pkgutil.iter_modules([str(sets_path)]):
+            if module_info.ispkg:
+                continue
+                
+            module_name = f"provide.foundation.eventsets.sets.{module_info.name}"
+            try:
+                module = importlib.import_module(module_name)
+                
+                if hasattr(module, "EVENT_SET"):
+                    event_set = getattr(module, "EVENT_SET")
+                    if isinstance(event_set, EventSet):
+                        try:
+                            self.register_event_set(event_set)
+                            logger.debug(
+                                "Auto-discovered event set",
+                                module=module_name,
+                                name=event_set.name
+                            )
+                        except AlreadyExistsError:
+                            logger.debug(
+                                "Event set already registered during discovery",
+                                module=module_name,
+                                name=event_set.name
+                            )
+                    else:
+                        logger.warning(
+                            "EVENT_SET is not an EventSet",
+                            module=module_name,
+                            type=type(event_set).__name__
+                        )
+                        
+            except ImportError as e:
+                logger.debug(
+                    "Failed to import event set module",
+                    module=module_name,
+                    error=str(e)
+                )
+            except Exception as e:
+                logger.warning(
+                    "Error during event set discovery",
+                    module=module_name,
+                    error=str(e),
+                    error_type=type(e).__name__
+                )
+
+
+# Global registry instance
+_registry = EventSetRegistry()
+
+
+def get_registry() -> EventSetRegistry:
+    """Get the global event set registry instance."""
+    return _registry
+
+
+def register_event_set(event_set: EventSet) -> None:
+    """
+    Register an event set in the global registry.
+    
+    Args:
+        event_set: The EventSet to register
+    """
+    _registry.register_event_set(event_set)
+
+
+def discover_event_sets() -> None:
+    """Auto-discover and register all event sets."""
+    _registry.discover_sets()

provide/foundation/eventsets/resolver.py

@@ -0,0 +1,192 @@
+"""
+Event set resolution and enrichment logic.
+"""
+
+from typing import Any
+
+from provide.foundation.eventsets.registry import get_registry
+from provide.foundation.eventsets.types import EventMapping, EventSet, FieldMapping
+
+
+class EventSetResolver:
+    """
+    Resolves and applies event set enrichments to log events.
+    """
+    
+    def __init__(self) -> None:
+        """Initialize the resolver with cached configurations."""
+        self._field_mappings: list[FieldMapping] = []
+        self._event_mappings_by_set: dict[str, list[EventMapping]] = {}
+        self._resolved = False
+    
+    def resolve(self) -> None:
+        """
+        Resolve all registered event sets into a unified configuration.
+        
+        This merges all registered event sets by priority, building
+        the field mapping and event mapping lookup tables.
+        """
+        registry = get_registry()
+        event_sets = registry.list_event_sets()  # Already sorted by priority
+        
+        # Clear existing state
+        self._field_mappings.clear()
+        self._event_mappings_by_set.clear()
+        
+        # Process each event set in priority order
+        for event_set in event_sets:
+            # Store event mappings by event set name
+            self._event_mappings_by_set[event_set.name] = event_set.mappings
+            
+            # Add field mappings
+            self._field_mappings.extend(event_set.field_mappings)
+        
+        self._resolved = True
+    
+    def enrich_event(self, event_dict: dict[str, Any]) -> dict[str, Any]:
+        """
+        Enrich a log event with event set data.
+        
+        Args:
+            event_dict: The event dictionary to enrich
+            
+        Returns:
+            The enriched event dictionary
+        """
+        if not self._resolved:
+            self.resolve()
+        
+        enrichments = []
+        
+        # Process each field in the event
+        for field_key, field_value in list(event_dict.items()):
+            if field_key == "event" or field_value is None:
+                continue
+                
+            # Find appropriate event mapping for this field
+            event_mapping = self._find_event_mapping_for_field(field_key, field_value)
+            if not event_mapping:
+                continue
+                
+            value_str = str(field_value).lower()
+            
+            # Apply transformations
+            if value_str in event_mapping.transformations:
+                field_value = event_mapping.transformations[value_str](field_value)
+                value_str = str(field_value).lower()
+            
+            # Get visual marker
+            visual_marker = event_mapping.visual_markers.get(
+                value_str,
+                event_mapping.visual_markers.get(event_mapping.default_key, "")
+            )
+            
+            if visual_marker:
+                enrichments.append(visual_marker)
+            
+            # Apply metadata fields
+            if value_str in event_mapping.metadata_fields:
+                for meta_key, meta_value in event_mapping.metadata_fields[value_str].items():
+                    if meta_key not in event_dict:
+                        event_dict[meta_key] = meta_value
+        
+        # Add visual enrichments to event message
+        if enrichments:
+            prefix = "".join(f"[{e}]" for e in enrichments)
+            event_msg = event_dict.get("event", "")
+            event_dict["event"] = f"{prefix} {event_msg}" if event_msg else prefix
+        
+        return event_dict
+    
+    def _find_event_mapping_for_field(self, field_key: str, field_value: Any) -> EventMapping | None:
+        """
+        Find the appropriate EventMapping for a given field.
+        
+        This method uses a heuristic approach to match field keys to EventMappings:
+        1. Direct field name mapping (e.g., "domain" -> "domain" mapping)
+        2. Field prefix mapping (e.g., "http.method" -> "http_method" mapping)
+        3. Field pattern matching
+        """
+        # First check for direct field name matches
+        simple_key = field_key.split('.')[-1]  # Get last part of dotted key
+        
+        for event_set_name, mappings in self._event_mappings_by_set.items():
+            for mapping in mappings:
+                # Direct name match
+                if mapping.name == simple_key or mapping.name == field_key:
+                    return mapping
+                
+                # Pattern matching for common cases
+                if field_key.startswith("http.") and mapping.name.startswith("http_"):
+                    if field_key.replace(".", "_") == mapping.name:
+                        return mapping
+                
+                if field_key.startswith("llm.") and mapping.name.startswith("llm_"):
+                    if field_key.replace(".", "_") == mapping.name:
+                        return mapping
+                
+                if field_key.startswith("db.") and mapping.name.startswith("db_"):
+                    if field_key.replace(".", "_") == mapping.name:
+                        return mapping
+                
+                if field_key.startswith("task.") and mapping.name.startswith("task_"):
+                    if field_key.replace(".", "_") == mapping.name:
+                        return mapping
+        
+        return None
+    
+    def get_visual_markers(self, event_dict: dict[str, Any]) -> list[str]:
+        """
+        Extract visual markers for an event without modifying it.
+        
+        Args:
+            event_dict: The event dictionary to analyze
+            
+        Returns:
+            List of visual markers that would be applied
+        """
+        if not self._resolved:
+            self.resolve()
+        
+        markers = []
+        
+        for field_key, field_value in event_dict.items():
+            if field_key == "event" or field_value is None:
+                continue
+                
+            event_mapping = self._find_event_mapping_for_field(field_key, field_value)
+            if not event_mapping:
+                continue
+                
+            value_str = str(field_value).lower()
+            marker = event_mapping.visual_markers.get(
+                value_str,
+                event_mapping.visual_markers.get(event_mapping.default_key, "")
+            )
+            
+            if marker:
+                markers.append(marker)
+        
+        return markers
+
+
+# Global resolver instance
+_resolver = EventSetResolver()
+
+
+def get_resolver() -> EventSetResolver:
+    """Get the global event set resolver instance."""
+    return _resolver
+
+
+def enrich_event(event_dict: dict[str, Any]) -> dict[str, Any]:
+    """
+    Enrich a log event with event set data.
+    
+    Args:
+        event_dict: The event dictionary to enrich
+        
+    Returns:
+        The enriched event dictionary
+    """
+    return _resolver.enrich_event(event_dict)

provide/foundation/eventsets/sets/das.py

@@ -0,0 +1,128 @@
+"""
+Domain-Action-Status (DAS) event set.
+"""
+
+from provide.foundation.eventsets.types import EventMapping, EventSet, FieldMapping
+
+EVENT_SET = EventSet(
+    name="default",
+    description="Core Domain-Action-Status event enrichment",
+    mappings=[
+        EventMapping(
+            name="domain",
+            visual_markers={
+                "system": "⚙️",
+                "server": "🛎️",
+                "client": "🙋",
+                "network": "🌐",
+                "security": "🔐",
+                "config": "🔩",
+                "database": "🗄️",
+                "cache": "💾",
+                "task": "🔄",
+                "plugin": "🔌",
+                "telemetry": "🛰️",
+                "di": "💉",
+                "protocol": "📡",
+                "file": "📄",
+                "user": "👤",
+                "test": "🧪",
+                "utils": "🧰",
+                "core": "🌟",
+                "auth": "🔑",
+                "entity": "🦎",
+                "report": "📈",
+                "payment": "💳",
+                "default": "❓",
+            },
+            default_key="default"
+        ),
+        EventMapping(
+            name="action",
+            visual_markers={
+                "init": "🌱",
+                "start": "🚀",
+                "stop": "🛑",
+                "connect": "🔗",
+                "disconnect": "💔",
+                "listen": "👂",
+                "send": "📤",
+                "receive": "📥",
+                "read": "📖",
+                "write": "📝",
+                "process": "⚙️",
+                "validate": "🛡️",
+                "execute": "▶️",
+                "query": "🔍",
+                "update": "🔄",
+                "delete": "🗑️",
+                "login": "➡️",
+                "logout": "⬅️",
+                "auth": "🔑",
+                "error": "🔥",
+                "encrypt": "🛡️",
+                "decrypt": "🔓",
+                "parse": "🧩",
+                "transmit": "📡",
+                "build": "🏗️",
+                "schedule": "📅",
+                "emit": "📢",
+                "load": "💡",
+                "observe": "🧐",
+                "request": "🗣️",
+                "interrupt": "🚦",
+                "register": "⚙️",
+                "default": "❓",
+            },
+            default_key="default"
+        ),
+        EventMapping(
+            name="status",
+            visual_markers={
+                "success": "✅",
+                "failure": "❌",
+                "error": "🔥",
+                "warning": "⚠️",
+                "info": "ℹ️",
+                "debug": "🐞",
+                "trace": "👣",
+                "attempt": "⏳",
+                "retry": "🔁",
+                "skip": "⏭️",
+                "complete": "🏁",
+                "timeout": "⏱️",
+                "notfound": "❓",
+                "unauthorized": "🚫",
+                "invalid": "💢",
+                "cached": "🎯",
+                "ongoing": "🏃",
+                "idle": "💤",
+                "ready": "👍",
+                "default": "➡️",
+            },
+            default_key="default"
+        ),
+    ],
+    field_mappings=[
+        FieldMapping(
+            log_key="domain",
+            event_set_name="default",
+            description="System domain or component"
+        ),
+        FieldMapping(
+            log_key="action",
+            event_set_name="default",
+            description="Action being performed"
+        ),
+        FieldMapping(
+            log_key="status",
+            event_set_name="default",
+            description="Status or outcome of the action"
+        ),
+    ],
+    priority=0
+)
+
+# Alias for backward compatibility
+das_event_set = EVENT_SET
+default_event_set = EVENT_SET