kollabor 0.4.9__py3-none-any.whl → 0.4.15__py3-none-any.whl

plugins/hook_monitoring_plugin.py

@@ -15,11 +15,14 @@ demonstrating:
 Perfect for developers learning the plugin system!
 """
 
+import asyncio
 import datetime
 import logging
 import time
 from typing import Any, Dict, List, Optional
 
+from core.io.visual_effects import AgnosterSegment
+
 # Import event system components
 import sys
 from pathlib import Path
@@ -42,7 +45,7 @@ logger = logging.getLogger(__name__)
 class HookMonitoringPlugin:
     """[SHOWCASE] SHOWCASE: A comprehensive hook monitoring system demonstrating ALL plugin ecosystem features!"""
 
-    def __init__(self, name: str, state_manager, event_bus, renderer, config) -> None:
+    def __init__(self, name: str, event_bus, renderer, config) -> None:
         """Initialize the hook monitoring plugin with full ecosystem integration.
 
         This initialization showcases:
@@ -53,14 +56,12 @@ class HookMonitoringPlugin:
 
         Args:
             name: Plugin name.
-            state_manager: State management system.
             event_bus: Event bus for hook registration.
             renderer: Terminal renderer.
             config: Configuration manager.
         """
         # [DATA] BASIC PLUGIN SETUP
         self.name = name
-        self.state_manager = state_manager
         self.event_bus = event_bus
         self.renderer = renderer
         self.config = config
@@ -75,6 +76,11 @@ class HookMonitoringPlugin:
         self.error_log = []  # Recent errors for debugging
         self.hook_health_status = "Starting"
 
+        # [DATA] ENHANCED PERFORMANCE TRACKING - Detailed metrics and degradation detection
+        self.detailed_metrics = {}  # event_type -> detailed metrics (history, percentiles)
+        self.performance_baseline = {}  # event_type -> baseline avg_time (set after 10 executions)
+        self.degradation_detected = False  # Flag for performance degradation
+
         # [FIND] PLUGIN ECOSYSTEM STATE - Showcasing service discovery
         self.discovered_plugins = {}  # plugin_name -> plugin_instance
         self.available_services = {}  # service_name -> plugin_info
@@ -85,11 +91,14 @@ class HookMonitoringPlugin:
         # This shows how plugins can discover and communicate with each other
         self.plugin_factory: Optional[PluginFactory] = None
         self.plugin_discovery_enabled = config.get("plugins.hook_monitoring.enable_plugin_discovery", True)
+        self.discovery_task = None  # Background task for periodic discovery
+        self.last_discovery_time = None  # Timestamp of last discovery
 
         # [TOOL] SDK INITIALIZATION - Demonstrating service registration
         # This shows how plugins can register services for other plugins to use
         self.sdk: Optional[KollaborPluginSDK] = None
         self.service_registration_enabled = config.get("plugins.hook_monitoring.enable_service_registration", True)
+        self.registered_services = []  # Track which services are actually registered
 
         if SDK_AVAILABLE and self.service_registration_enabled:
             self.sdk = KollaborPluginSDK()
@@ -99,6 +108,19 @@ class HookMonitoringPlugin:
         self.enable_cross_plugin_comm = config.get("plugins.hook_monitoring.enable_cross_plugin_communication", True)
         self.message_history_limit = config.get("plugins.hook_monitoring.message_history_limit", 20)
 
+        # [METRICS] METRICS COLLECTION AND RETENTION - Timestamped metrics storage
+        self.collected_metrics = []  # List of timestamped metric snapshots
+        self.service_usage_stats = {  # Track SDK service call counts
+            "monitor_performance": {"calls": 0, "last_called": None},
+            "check_plugin_health": {"calls": 0, "last_called": None},
+            "collect_system_metrics": {"calls": 0, "last_called": None}
+        }
+        self.metrics_collection_task = None  # Background task for metrics collection
+
+        # [TARGET] DASHBOARD STATE - Dashboard update throttling and caching
+        self.last_dashboard_update = datetime.datetime.now()
+        self.cached_dashboard_content = []
+
         # [TARGET] CREATE HOOKS - Standard hook creation for monitoring
         self.hooks = self._create_all_hooks()
 
@@ -131,7 +153,7 @@ class HookMonitoringPlugin:
         discovered_count = len(getattr(self, 'discovered_plugins', {}))
 
         # [TOOL] SHOWCASE: Service Registration Status
-        registered_services = 3 if (self.service_registration_enabled and SDK_AVAILABLE) else 0
+        registered_services = len(getattr(self, 'registered_services', []))
 
         # [COMM] SHOWCASE: Cross-Plugin Communication Status
         recent_messages = len(getattr(self, 'cross_plugin_messages', []))
@@ -149,8 +171,8 @@ class HookMonitoringPlugin:
             "C": [    # Detailed ecosystem info in area C
                 f"SHOWCASE: Plugin Ecosystem Demo",
                 f"Last Event: {self.last_hook_event[:20]}",
-                f"Discovery: {'[OK]' if self.plugin_discovery_enabled else '[X]'}",
-                f"SDK: {'[OK]' if SDK_AVAILABLE else '[X]'}",
+                f"Discovery: {'[ok]' if self.plugin_discovery_enabled else '[X]'}",
+                f"SDK: {'[ok]' if SDK_AVAILABLE else '[X]'}",
                 f"Debug: {'On' if debug_mode else 'Off'}"
             ]
         }
@@ -163,6 +185,7 @@ class HookMonitoringPlugin:
         2. SDK service registration for providing monitoring services
         3. Cross-plugin communication setup
         4. Dynamic service discovery patterns
+        5. Background task management for periodic operations
         """
         logger.info("Starting HookMonitoringPlugin initialization...")
 
@@ -170,6 +193,14 @@ class HookMonitoringPlugin:
         if self.plugin_discovery_enabled:
             await self._discover_other_plugins()
 
+            # Start periodic plugin discovery if interval is configured
+            interval = self.config.get("plugins.hook_monitoring.discovery_interval", 30)
+            if interval > 0:
+                self.discovery_task = asyncio.create_task(
+                    self._periodic_plugin_discovery()
+                )
+                logger.info(f"Started periodic plugin discovery task (interval: {interval}s)")
+
         # [TOOL] STEP 2: SERVICE REGISTRATION - Showcasing how to offer services to other plugins
         if self.service_registration_enabled and self.sdk:
             await self._register_monitoring_services()
@@ -181,6 +212,13 @@ class HookMonitoringPlugin:
         # [DATA] STEP 4: INITIALIZE PLUGIN HEALTH MONITORING
         await self._initialize_plugin_health_monitoring()
 
+        # [METRICS] STEP 5: START METRICS COLLECTION - Periodic metrics gathering
+        if self.config.get("plugins.hook_monitoring.collect_plugin_metrics", True):
+            self.metrics_collection_task = asyncio.create_task(
+                self._periodic_metrics_collection()
+            )
+            logger.info("Started periodic metrics collection task (interval: 60s)")
+
         logger.info("HookMonitoringPlugin initialization complete - all ecosystem features active!")
 
     async def _discover_other_plugins(self) -> None:
@@ -248,6 +286,114 @@ class HookMonitoringPlugin:
 
         logger.debug(f"Analyzed {plugin_name}: {capabilities}")
 
+    async def _periodic_plugin_discovery(self) -> None:
+        """[FIND] SHOWCASE: Periodically discover plugins at configured interval.
+
+        This demonstrates background task patterns for plugin ecosystem monitoring:
+        - Periodic task execution with configurable interval
+        - Auto-capability analysis based on configuration
+        - Proper exception handling and cleanup
+        - Task cancellation support
+        """
+        interval = self.config.get("plugins.hook_monitoring.discovery_interval", 30)
+        auto_analyze = self.config.get("plugins.hook_monitoring.auto_analyze_capabilities", True)
+
+        logger.info(f"Starting periodic plugin discovery (interval: {interval}s, auto_analyze: {auto_analyze})")
+
+        while True:
+            try:
+                await asyncio.sleep(interval)
+
+                # Discover plugins
+                if hasattr(self.renderer, 'plugin_instances'):
+                    plugin_instances = getattr(self.renderer, 'plugin_instances', {})
+                    self.discovered_plugins = plugin_instances
+
+                    # Auto-analyze capabilities if enabled
+                    if auto_analyze:
+                        for plugin_name, plugin_instance in plugin_instances.items():
+                            if plugin_name != self.name:
+                                await self._analyze_plugin_capabilities(plugin_name, plugin_instance)
+
+                self.last_discovery_time = datetime.datetime.now()
+                logger.debug(f"Plugin discovery complete: {len(self.discovered_plugins)} plugins found")
+
+            except asyncio.CancelledError:
+                logger.info("Plugin discovery task cancelled")
+                break
+            except Exception as e:
+                logger.error(f"Plugin discovery error: {e}")
+                await asyncio.sleep(interval)
+
+    async def _periodic_metrics_collection(self) -> None:
+        """[METRICS] SHOWCASE: Periodically collect and store metrics.
+
+        This demonstrates:
+        - Periodic metrics gathering with retention policies
+        - Time-series data collection patterns
+        - Memory-efficient metrics storage with automatic cleanup
+        - Configuration-driven collection intervals
+        """
+        logger.info("Starting periodic metrics collection")
+
+        while True:
+            try:
+                await asyncio.sleep(60)  # Collect every 60 seconds
+
+                # Gather metrics snapshot
+                snapshot = {
+                    "timestamp": datetime.datetime.now(),
+                    "hook_executions": self.hook_executions,
+                    "failed_hooks": self.failed_hooks,
+                    "timeout_hooks": self.timeout_hooks,
+                    "health_status": self.hook_health_status,
+                    "discovered_plugins": len(self.discovered_plugins),
+                    "service_usage": dict(self.service_usage_stats),
+                    "performance_summary": {
+                        event: {
+                            "count": metrics["count"],
+                            "avg_time": metrics["avg_time"]
+                        }
+                        for event, metrics in self.hook_performance.items()
+                    }
+                }
+
+                self.collected_metrics.append(snapshot)
+
+                # Cleanup old metrics
+                self._cleanup_old_metrics()
+
+                logger.debug(f"Metrics collected: {len(self.collected_metrics)} snapshots retained")
+
+            except asyncio.CancelledError:
+                logger.info("Metrics collection task cancelled")
+                break
+            except Exception as e:
+                logger.error(f"Metrics collection error: {e}")
+                await asyncio.sleep(60)
+
+    def _cleanup_old_metrics(self) -> None:
+        """[METRICS] SHOWCASE: Remove metrics older than retention period.
+
+        This demonstrates memory management for time-series data:
+        - Configuration-driven retention policies
+        - Efficient list comprehension for cleanup
+        - Automatic old data removal
+        """
+        retention_hours = self.config.get("plugins.hook_monitoring.metrics_retention_hours", 24)
+        cutoff_time = datetime.datetime.now() - datetime.timedelta(hours=retention_hours)
+
+        # Remove old metrics
+        original_count = len(self.collected_metrics)
+        self.collected_metrics = [
+            m for m in self.collected_metrics
+            if m["timestamp"] > cutoff_time
+        ]
+
+        removed_count = original_count - len(self.collected_metrics)
+        if removed_count > 0:
+            logger.debug(f"Cleaned up {removed_count} old metrics (retention: {retention_hours}h)")
+
     async def _register_monitoring_services(self) -> None:
         """[TOOL] SHOWCASE: Register monitoring services for other plugins to use.
 
@@ -262,50 +408,62 @@ class HookMonitoringPlugin:
             logger.warning("SDK not available - cannot register services")
             return
 
+        # Reset registered services list
+        self.registered_services = []
+
         try:
             # [DATA] SERVICE 1: Performance Monitoring
-            self.sdk.register_custom_tool({
-                "name": "monitor_performance",
-                "description": "Monitor plugin performance and hook execution times",
-                "handler": self._provide_performance_monitoring,
-                "parameters": {
-                    "plugin_name": {"type": "string", "description": "Plugin to monitor"},
-                    "metric_type": {"type": "string", "description": "Type of metric to collect"}
-                },
-                "plugin": self.name,
-                "enabled": True,
-                "category": "monitoring"
-            })
+            if self.config.get("plugins.hook_monitoring.register_performance_service", True):
+                self.sdk.register_custom_tool({
+                    "name": "monitor_performance",
+                    "description": "Monitor plugin performance and hook execution times",
+                    "handler": self._provide_performance_monitoring,
+                    "parameters": {
+                        "plugin_name": {"type": "string", "description": "Plugin to monitor"},
+                        "metric_type": {"type": "string", "description": "Type of metric to collect"}
+                    },
+                    "plugin": self.name,
+                    "enabled": True,
+                    "category": "monitoring"
+                })
+                self.registered_services.append("monitor_performance")
+                logger.debug("Registered performance monitoring service")
 
             # [HEALTH] SERVICE 2: Health Checking
-            self.sdk.register_custom_tool({
-                "name": "check_plugin_health",
-                "description": "Check the health status of any plugin in the system",
-                "handler": self._provide_health_check,
-                "parameters": {
-                    "plugin_name": {"type": "string", "description": "Plugin to check"},
-                    "detailed": {"type": "boolean", "description": "Return detailed health info"}
-                },
-                "plugin": self.name,
-                "enabled": True,
-                "category": "health"
-            })
+            if self.config.get("plugins.hook_monitoring.register_health_service", True):
+                self.sdk.register_custom_tool({
+                    "name": "check_plugin_health",
+                    "description": "Check the health status of any plugin in the system",
+                    "handler": self._provide_health_check,
+                    "parameters": {
+                        "plugin_name": {"type": "string", "description": "Plugin to check"},
+                        "detailed": {"type": "boolean", "description": "Return detailed health info"}
+                    },
+                    "plugin": self.name,
+                    "enabled": True,
+                    "category": "health"
+                })
+                self.registered_services.append("check_plugin_health")
+                logger.debug("Registered health check service")
 
             # [METRICS] SERVICE 3: Metrics Collection
-            self.sdk.register_custom_tool({
-                "name": "collect_system_metrics",
-                "description": "Collect comprehensive system and plugin metrics",
-                "handler": self._provide_metrics_collection,
-                "parameters": {
-                    "time_range": {"type": "string", "description": "Time range for metrics"},
-                    "include_performance": {"type": "boolean", "description": "Include performance data"}
-                },
-                "plugin": self.name,
-                "enabled": True,
-                "category": "analytics"
-            })
+            if self.config.get("plugins.hook_monitoring.register_metrics_service", True):
+                self.sdk.register_custom_tool({
+                    "name": "collect_system_metrics",
+                    "description": "Collect comprehensive system and plugin metrics",
+                    "handler": self._provide_metrics_collection,
+                    "parameters": {
+                        "time_range": {"type": "string", "description": "Time range for metrics"},
+                        "include_performance": {"type": "boolean", "description": "Include performance data"}
+                    },
+                    "plugin": self.name,
+                    "enabled": True,
+                    "category": "analytics"
+                })
+                self.registered_services.append("collect_system_metrics")
+                logger.debug("Registered metrics collection service")
 
-            logger.debug("Registered 3 monitoring services - other plugins can now use our services!")
+            logger.info(f"Registered {len(self.registered_services)} monitoring services: {', '.join(self.registered_services)}")
 
         except Exception as e:
             logger.error(f"Service registration failed: {e}")
@@ -407,7 +565,7 @@ class HookMonitoringPlugin:
 
                 registry = self.renderer.status_renderer.status_registry
                 registry.register_status_view("hook_monitoring", developer_view)
-                logger.info("[OK] Registered 'Developer Metrics' status view")
+                logger.info("[ok] Registered 'Developer Metrics' status view")
 
             else:
                 logger.warning("Status registry not available - cannot register status view")
@@ -416,38 +574,136 @@ class HookMonitoringPlugin:
             logger.error(f"Failed to register status view: {e}")
 
     def _get_developer_metrics_content(self) -> List[str]:
-        """Get developer metrics content for status view."""
+        """[TARGET] SHOWCASE: Get developer metrics with conditional display and throttling.
+
+        This demonstrates:
+        - Configuration-driven dashboard visibility
+        - Update throttling for performance optimization
+        - Multi-line dashboard with plugin interactions and service usage
+        - Content caching with configurable refresh intervals
+        """
         try:
+            # Check if dashboard is enabled
+            dashboard_enabled = self.config.get('plugins.hook_monitoring.enable_health_dashboard', True)
+            if not dashboard_enabled:
+                return []  # Don't show anything when disabled
+
+            # Check if plugin is enabled
             enabled = self.config.get('plugins.hook_monitoring.enabled', False)
             if not enabled:
-                return ["Hook Monitor: - Off"]
+                seg = AgnosterSegment()
+                seg.add_neutral("Hooks: Off", "dark")
+                return [seg.render()]
+
+            # Check dashboard update interval (throttling)
+            update_interval = self.config.get('plugins.hook_monitoring.dashboard_update_interval', 10)
+            now = datetime.datetime.now()
+            seconds_since_update = (now - self.last_dashboard_update).total_seconds()
+
+            if seconds_since_update < update_interval and self.cached_dashboard_content:
+                return self.cached_dashboard_content  # Return cached content
+
+            # Regenerate dashboard content
+            self.last_dashboard_update = now
 
-            # Calculate failure rate for health display
+            # Build main metrics line
+            seg = AgnosterSegment()
+
+            # Calculate failure rate
             failure_rate = 0
             if self.hook_executions > 0:
                 failure_rate = (self.failed_hooks + self.timeout_hooks) / self.hook_executions
 
-            # Plugin discovery status
+            # Plugin discovery
             discovered_count = len(getattr(self, 'discovered_plugins', {}))
 
-            # Service registration status
-            registered_services = 3 if (self.service_registration_enabled and SDK_AVAILABLE) else 0
+            # Services
+            registered_services = len(getattr(self, 'registered_services', []))
 
-            # Cross-plugin communication status
-            recent_messages = len(getattr(self, 'cross_plugin_messages', []))
+            # Build agnoster bar
+            seg.add_lime(f"Hooks: {self.hook_health_status}", "dark")
+            seg.add_cyan(f"Exec: {self.hook_executions}", "dark")
+            seg.add_lime(f"Plugins: {discovered_count}")
 
-            return [
-                f"√ Monitor: {self.hook_health_status} ··· Executions: {self.hook_executions}",
-                f"+ Plugins: {discovered_count} ··· × Services: {registered_services} ··· Rate: {failure_rate:.1%}" if self.hook_executions > 0 else f"+ Plugins: {discovered_count} ··· × Services: {registered_services} ··· Rate: N/A"
-            ]
+            if self.hook_executions > 0:
+                seg.add_cyan(f"Fail: {failure_rate:.1%}")
+            else:
+                seg.add_cyan("Fail: N/A")
+
+            seg.add_neutral(f"Services: {registered_services}", "mid")
+
+            result = [seg.render()]
+
+            # Add plugin interactions line if enabled
+            show_interactions = self.config.get('plugins.hook_monitoring.show_plugin_interactions', True)
+            if show_interactions and hasattr(self, 'cross_plugin_messages'):
+                recent_messages = len(self.cross_plugin_messages)
+                if recent_messages > 0:
+                    int_seg = AgnosterSegment()
+                    int_seg.add_neutral(f"Interactions: {recent_messages}", "dark")
+
+                    # Show top communicators
+                    senders = {}
+                    for msg in self.cross_plugin_messages:
+                        sender = msg.get("sender", "unknown")
+                        senders[sender] = senders.get(sender, 0) + 1
+
+                    for sender, count in list(senders.items())[:3]:  # Top 3
+                        int_seg.add_cyan(f"{sender}: {count}")
+
+                    result.append(int_seg.render())
+
+            # Add service usage line if enabled
+            show_service_usage = self.config.get('plugins.hook_monitoring.show_service_usage', True)
+            if show_service_usage and hasattr(self, 'service_usage_stats'):
+                svc_seg = AgnosterSegment()
+
+                total_calls = sum(s["calls"] for s in self.service_usage_stats.values())
+                svc_seg.add_neutral(f"Service Calls: {total_calls}", "dark")
+
+                for service_name, stats in self.service_usage_stats.items():
+                    if stats["calls"] > 0:
+                        # Shorten service names for display
+                        short_name = service_name.replace("monitor_", "").replace("check_plugin_", "").replace("collect_system_", "")
+                        svc_seg.add_lime(f"{short_name}: {stats['calls']}")
+
+                if total_calls > 0:  # Only show if there are service calls
+                    result.append(svc_seg.render())
+
+            # Cache the result
+            self.cached_dashboard_content = result
+            return result
 
         except Exception as e:
             logger.error(f"Error getting developer metrics content: {e}")
-            return ["Developer Metrics: Error"]
+            seg = AgnosterSegment()
+            seg.add_neutral("Hooks: Error", "dark")
+            return [seg.render()]
 
     async def shutdown(self) -> None:
-        """Shutdown the hook monitoring plugin."""
+        """Shutdown the hook monitoring plugin with proper task cleanup."""
         logger.info(f"Hook Monitor: Shutting down - processed {self.hook_executions} events, {self.failed_hooks} failures")
+
+        # Cancel discovery task if running
+        if self.discovery_task and not self.discovery_task.done():
+            self.discovery_task.cancel()
+            try:
+                await asyncio.wait_for(self.discovery_task, timeout=2.0)
+            except (asyncio.TimeoutError, asyncio.CancelledError):
+                logger.debug("Discovery task cancelled during shutdown")
+            except Exception as e:
+                logger.warning(f"Error cancelling discovery task: {e}")
+
+        # Cancel metrics collection task if running
+        if self.metrics_collection_task and not self.metrics_collection_task.done():
+            self.metrics_collection_task.cancel()
+            try:
+                await asyncio.wait_for(self.metrics_collection_task, timeout=2.0)
+            except (asyncio.TimeoutError, asyncio.CancelledError):
+                logger.debug("Metrics collection task cancelled during shutdown")
+            except Exception as e:
+                logger.warning(f"Error cancelling metrics collection task: {e}")
+
         self._log_final_report()
         # Only show shutdown message if not in pipe mode
         # if not getattr(self.renderer, 'pipe_mode', False):
@@ -859,6 +1115,10 @@ class HookMonitoringPlugin:
             "metric_type": "execution_time"
         })
         """
+        # Track service usage
+        self.service_usage_stats["monitor_performance"]["calls"] += 1
+        self.service_usage_stats["monitor_performance"]["last_called"] = datetime.datetime.now()
+
         plugin_name = params.get("plugin_name", "all")
         metric_type = params.get("metric_type", "summary")
 
@@ -896,6 +1156,10 @@ class HookMonitoringPlugin:
             "detailed": True
         })
         """
+        # Track service usage
+        self.service_usage_stats["check_plugin_health"]["calls"] += 1
+        self.service_usage_stats["check_plugin_health"]["last_called"] = datetime.datetime.now()
+
         plugin_name = params.get("plugin_name", "system")
         detailed = params.get("detailed", False)
 
@@ -936,6 +1200,10 @@ class HookMonitoringPlugin:
             "include_performance": True
         })
         """
+        # Track service usage
+        self.service_usage_stats["collect_system_metrics"]["calls"] += 1
+        self.service_usage_stats["collect_system_metrics"]["last_called"] = datetime.datetime.now()
+
         time_range = params.get("time_range", "current")
         include_performance = params.get("include_performance", True)
 
@@ -961,10 +1229,13 @@ class HookMonitoringPlugin:
 
     # [COMM] CROSS-PLUGIN COMMUNICATION HANDLERS
 
-    async def _handle_health_check_request(self, message: Dict[str, Any], sender: str) -> None:
-        """[COMM] SHOWCASE: Handle health check requests from other plugins.
+    async def _handle_health_check_request(self, message: Dict[str, Any], sender: str) -> Dict[str, Any]:
+        """[COMM] SHOWCASE: Handle health check requests from other plugins with optional auto-response.
 
-        This demonstrates direct plugin-to-plugin communication.
+        This demonstrates:
+        - Direct plugin-to-plugin communication
+        - Automatic service response based on configuration
+        - Message tracking and statistics
         """
         logger.info(f"[COMM] Health check request received from {sender}")
 
@@ -985,6 +1256,18 @@ class HookMonitoringPlugin:
             self.plugin_health_stats[sender]["message_count"] += 1
             self.plugin_health_stats[sender]["last_seen"] = datetime.datetime.now()
 
+        # Auto-respond if configured
+        auto_respond = self.config.get("plugins.hook_monitoring.auto_respond_to_health_checks", True)
+        if auto_respond:
+            response = await self._provide_health_check({
+                "plugin_name": message.get("plugin_name", "system"),
+                "detailed": message.get("detailed", False)
+            })
+            logger.debug(f"[COMM] Auto-responded to {sender} with health check")
+            return response
+
+        return {"status": "acknowledged", "auto_respond": False}
+
     async def _handle_performance_data_request(self, message: Dict[str, Any], sender: str) -> Dict[str, Any]:
         """[COMM] SHOWCASE: Handle performance data requests from other plugins."""
         logger.info(f"[DATA] Performance data request from {sender}")
@@ -1063,7 +1346,7 @@ class HookMonitoringPlugin:
         }
 
     def _update_performance_metrics(self, event_type: str, start_time: float) -> None:
-        """Update performance metrics for hook monitoring.
+        """Update performance metrics with optional detailed tracking.
 
         Args:
             event_type: The event type being monitored.
@@ -1071,6 +1354,7 @@ class HookMonitoringPlugin:
         """
         execution_time = (time.time() - start_time) * 1000  # Convert to milliseconds
 
+        # Standard metrics (always tracked)
         if event_type not in self.hook_performance:
             self.hook_performance[event_type] = {
                 "total_time": 0,
@@ -1087,8 +1371,82 @@ class HookMonitoringPlugin:
         metrics["max_time"] = max(metrics["max_time"], execution_time)
         metrics["min_time"] = min(metrics["min_time"], execution_time)
 
+        # Set baseline after 10 executions
+        if metrics["count"] == 10 and event_type not in self.performance_baseline:
+            self.performance_baseline[event_type] = metrics["avg_time"]
+            logger.debug(f"Set performance baseline for {event_type}: {metrics['avg_time']:.2f}ms")
+
+        # Detailed tracking (optional)
+        detailed_tracking = self.config.get("plugins.hook_monitoring.detailed_performance_tracking", True)
+        if detailed_tracking:
+            if event_type not in self.detailed_metrics:
+                self.detailed_metrics[event_type] = {
+                    "execution_history": [],  # Last 100 executions
+                    "percentile_95": 0,
+                    "percentile_99": 0,
+                }
+
+            detail = self.detailed_metrics[event_type]
+            detail["execution_history"].append(execution_time)
+
+            # Keep only last 100 executions
+            if len(detail["execution_history"]) > 100:
+                detail["execution_history"] = detail["execution_history"][-100:]
+
+            # Calculate percentiles (require at least 20 samples)
+            if len(detail["execution_history"]) >= 20:
+                sorted_times = sorted(detail["execution_history"])
+                p95_idx = int(len(sorted_times) * 0.95)
+                p99_idx = int(len(sorted_times) * 0.99)
+                detail["percentile_95"] = sorted_times[p95_idx]
+                detail["percentile_99"] = sorted_times[p99_idx]
+
+    def _check_performance_degradation(self) -> bool:
+        """[DATA] SHOWCASE: Check if performance has degraded beyond threshold.
+
+        This demonstrates:
+        - Performance baseline comparison
+        - Configuration-driven degradation thresholds
+        - Automatic performance degradation detection
+        - Warning logging for degraded performance
+
+        Returns:
+            True if degradation detected, False otherwise
+        """
+        threshold = self.config.get("plugins.hook_monitoring.performance_degradation_threshold", 0.15)
+        degraded_events = []
+
+        for event_type, baseline_time in self.performance_baseline.items():
+            if event_type in self.hook_performance:
+                current_time = self.hook_performance[event_type]["avg_time"]
+                # Only check degradation if baseline is meaningful (> 0.1ms)
+                # This avoids false positives from sub-millisecond execution times
+                if baseline_time > 0.1:
+                    degradation = (current_time - baseline_time) / baseline_time
+
+                    if degradation > threshold:
+                        degraded_events.append({
+                            "event_type": event_type,
+                            "baseline_ms": baseline_time,
+                            "current_ms": current_time,
+                            "degradation_pct": degradation * 100
+                        })
+
+        if degraded_events:
+            self.degradation_detected = True
+            for event in degraded_events:
+                logger.warning(
+                    f"Performance degradation detected: {event['event_type']} "
+                    f"baseline={event['baseline_ms']:.1f}ms current={event['current_ms']:.1f}ms "
+                    f"({event['degradation_pct']:.1f}% slower)"
+                )
+            return True
+
+        self.degradation_detected = False
+        return False
+
     def _update_health_status(self) -> None:
-        """Update the overall health status of the hook system."""
+        """Update health status including performance degradation check."""
         total_hooks = self.hook_executions
         if total_hooks == 0:
             self.hook_health_status = "Starting"
@@ -1096,11 +1454,15 @@ class HookMonitoringPlugin:
 
         failure_rate = (self.failed_hooks + self.timeout_hooks) / total_hooks
 
-        if failure_rate == 0:
+        # Check performance degradation
+        degraded = self._check_performance_degradation()
+
+        # Determine health status (degradation affects status)
+        if failure_rate == 0 and not degraded:
             self.hook_health_status = "Healthy"
-        elif failure_rate < self.config.get("performance.failure_rate_warning", 0.05):
+        elif failure_rate < self.config.get("performance.failure_rate_warning", 0.05) and not degraded:
             self.hook_health_status = "Good"
-        elif failure_rate < self.config.get("performance.failure_rate_critical", 0.15):
+        elif failure_rate < self.config.get("performance.failure_rate_critical", 0.15) or degraded:
             self.hook_health_status = "Warning"
         else:
             self.hook_health_status = "Critical"
@@ -1204,7 +1566,7 @@ class HookMonitoringPlugin:
             "summary": {
                 "total_plugins": total_plugins,
                 "active_plugins": active_plugins,
-                "registered_services": 3 if (self.service_registration_enabled and SDK_AVAILABLE) else 0,
+                "registered_services": len(getattr(self, 'registered_services', [])),
                 "system_health": self.hook_health_status,
                 "overall_failure_rate": failure_rate,
                 "last_updated": datetime.datetime.now().isoformat()
@@ -1226,11 +1588,7 @@ class HookMonitoringPlugin:
             "service_registration": {
                 "sdk_available": SDK_AVAILABLE,
                 "services_enabled": self.service_registration_enabled,
-                "available_services": [
-                    "monitor_performance",
-                    "check_plugin_health",
-                    "collect_system_metrics"
-                ] if (self.service_registration_enabled and SDK_AVAILABLE) else []
+                "available_services": getattr(self, 'registered_services', [])
             },
 
             "cross_plugin_communication": {
@@ -1241,12 +1599,12 @@ class HookMonitoringPlugin:
             },
 
             "showcase_features": {
-                "[FIND] Plugin Discovery": "[OK] Active" if self.plugin_discovery_enabled else "Disabled",
-                "[TOOL] Service Registration": "[OK] Active" if (self.service_registration_enabled and SDK_AVAILABLE) else "Disabled",
-                "[COMM] Cross-Plugin Comm": "[OK] Active" if self.enable_cross_plugin_comm else "Disabled",
-                "[DATA] Performance Monitoring": "[OK] Active",
-                "[HEALTH] Health Monitoring": "[OK] Active",
-                "[METRICS] Metrics Collection": "[OK] Active"
+                "[FIND] Plugin Discovery": "[ok] Active" if self.plugin_discovery_enabled else "Disabled",
+                "[TOOL] Service Registration": "[ok] Active" if (self.service_registration_enabled and SDK_AVAILABLE) else "Disabled",
+                "[COMM] Cross-Plugin Comm": "[ok] Active" if self.enable_cross_plugin_comm else "Disabled",
+                "[DATA] Performance Monitoring": "[ok] Active",
+                "[HEALTH] Health Monitoring": "[ok] Active",
+                "[METRICS] Metrics Collection": "[ok] Active"
             }
         }