fix(stats): Complete PR review fixes for statistics implementation

- Fixed all Python < 3.10 union syntax issues (using tuple syntax instead of | operator)
- Fixed percentile calculation with proper bounds checking
- Made _calculate_memory_usage async with proper locking for thread safety
- Updated all components to use EnhancedStatsTrackingMixin:
  - PositionManager: Added operation timing tracking
  - RealtimeDataManager: Added tick processing tracking
  - RiskManager: Added operation timing and error tracking
  - OrderManager: Already properly integrated
- Renamed get_memory_stats to get_enhanced_memory_stats to avoid conflicts
- Added proper error tracking in all critical operations
- Fixed all type conflicts between mixins

All critical issues from PR review have been addressed.

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <[email protected]>

Author: TexasCoding

src/project_x_py/risk_manager/core.py

@@ -22,7 +22,7 @@
     ProjectXClientProtocol,
     RealtimeDataManagerProtocol,
 )
-from project_x_py.utils.stats_tracking import StatsTrackingMixin
+from project_x_py.utils.enhanced_stats_tracking import EnhancedStatsTrackingMixin
 
 from .config import RiskConfig
 
@@ -33,7 +33,7 @@
 logger = logging.getLogger(__name__)
 
 
-class RiskManager(StatsTrackingMixin):
+class RiskManager(EnhancedStatsTrackingMixin):
     """Comprehensive risk management system for trading.
 
     Handles position sizing, risk validation, stop-loss management,
@@ -68,7 +68,13 @@ def __init__(
         self.event_bus = event_bus
         self.config = config or RiskConfig()
         self.data_manager = data_manager
-        StatsTrackingMixin._init_stats_tracking(self)
+        # Initialize enhanced stats tracking
+        self._init_enhanced_stats(
+            max_errors=100,
+            max_timings=1000,
+            retention_hours=24,
+            enable_profiling=False,
+        )
 
         # Track daily losses and trades
         self._daily_loss = Decimal("0")
@@ -112,6 +118,9 @@ async def calculate_position_size(
         Returns:
             PositionSizingResponse with calculated size and risk metrics
         """
+        import time
+
+        start_time = time.time()
         try:
             # Get account info
             account = await self._get_account_info()
@@ -160,7 +169,7 @@ async def calculate_position_size(
             if instrument:
                 tick_size = float(instrument.tickSize)
 
-            return PositionSizingResponse(
+            result = PositionSizingResponse(
                 position_size=position_size,
                 risk_amount=actual_risk,
                 risk_percent=actual_risk_percent,
@@ -175,8 +184,22 @@ async def calculate_position_size(
                 sizing_method="kelly" if use_kelly else "fixed_risk",
             )
 
+            # Track successful operation
+            duration_ms = (time.time() - start_time) * 1000
+            await self.track_operation(
+                "calculate_position_size", duration_ms, success=True
+            )
+
+            return result
+
         except Exception as e:
             logger.error(f"Error calculating position size: {e}")
+            # Track failed operation
+            duration_ms = (time.time() - start_time) * 1000
+            await self.track_operation(
+                "calculate_position_size", duration_ms, success=False
+            )
+            await self.track_error(e, "calculate_position_size")
             raise
 
     async def validate_trade(
@@ -193,6 +216,9 @@ async def validate_trade(
         Returns:
             RiskValidationResponse with validation result and reasons
         """
+        import time
+
+        start_time = time.time()
         try:
             reasons = []
             warnings = []
@@ -269,7 +295,7 @@ async def validate_trade(
                     f"Multiple correlated positions ({correlated_count} positions)"
                 )
 
-            return RiskValidationResponse(
+            result = RiskValidationResponse(
                 is_valid=is_valid,
                 reasons=reasons,
                 warnings=warnings,
@@ -280,8 +306,18 @@ async def validate_trade(
                 portfolio_risk=total_risk,
             )
 
+            # Track successful operation
+            duration_ms = (time.time() - start_time) * 1000
+            await self.track_operation("validate_trade", duration_ms, success=True)
+
+            return result
+
         except Exception as e:
             logger.error(f"Error validating trade: {e}")
+            # Track failed operation
+            duration_ms = (time.time() - start_time) * 1000
+            await self.track_operation("validate_trade", duration_ms, success=False)
+            await self.track_error(e, "validate_trade")
             return RiskValidationResponse(
                 is_valid=False,
                 reasons=[f"Validation error: {e!s}"],

src/project_x_py/utils/enhanced_stats_tracking.py

@@ -349,7 +349,7 @@ async def get_enhanced_memory_stats(self) -> dict[str, Any]:
                 self._last_memory_check = current_time
 
                 # Calculate current memory usage
-                memory_mb = self._calculate_memory_usage()
+                memory_mb = await self._calculate_memory_usage()
 
                 # Store snapshot
                 self._memory_snapshots.append(
@@ -364,7 +364,7 @@ async def get_enhanced_memory_stats(self) -> dict[str, Any]:
                 )
 
             # Get latest stats
-            current_memory = self._calculate_memory_usage()
+            current_memory = await self._calculate_memory_usage()
             memory_trend = []
             if len(self._memory_snapshots) >= 2:
                 memory_trend = [
@@ -452,72 +452,75 @@ async def _cleanup_old_stats_if_needed(self) -> None:
             self._last_cleanup = current_time
             await self.cleanup_old_stats()
 
-    def _calculate_memory_usage(self) -> float:
+    async def _calculate_memory_usage(self) -> float:
         """
         Calculate current memory usage of this component.
 
+        Thread-safe memory calculation with async lock protection.
+
         Returns:
             Memory usage in MB
         """
-        size = 0
-        max_items_to_sample = 100  # Sample limit for large collections
-
-        # Priority attributes to always check
-        priority_attrs = [
-            "_error_history",
-            "_error_types",
-            "_api_timings",
-            "_operation_timings",
-            "_memory_snapshots",
-            "_network_stats",
-            "_data_quality",
-            "_component_stats",
-        ]
-
-        # Component-specific attributes (check only if they exist)
-        component_attrs = [
-            "tracked_orders",
-            "order_status_cache",
-            "position_orders",
-            "_orders",
-            "_positions",
-            "_trades",
-            "_bars",
-            "_ticks",
-            "stats",
-            "_data",
-            "_order_history",
-            "_position_history",
-        ]
-
-        # Check priority attributes fully
-        for attr_name in priority_attrs:
-            if hasattr(self, attr_name):
-                attr = getattr(self, attr_name)
-                size += sys.getsizeof(attr)
-
-                # For small collections, count all items
-                if isinstance(attr, list | dict | set | deque):
-                    try:
-                        items = attr.values() if isinstance(attr, dict) else attr
-                        item_count = len(items) if hasattr(items, "__len__") else 0
-
-                        if item_count <= max_items_to_sample:
-                            # Count all items for small collections
-                            for item in items:
-                                size += sys.getsizeof(item)
-                        else:
-                            # Sample for large collections
-                            sample_size = 0
-                            for i, item in enumerate(items):
-                                if i >= max_items_to_sample:
-                                    break
-                                sample_size += sys.getsizeof(item)
-                            # Estimate total size based on sample
-                            avg_item_size = sample_size / max_items_to_sample
-                            size += int(avg_item_size * item_count)
-                    except (AttributeError, TypeError):
-                        pass
+        async with self._stats_lock:
+            size = 0
+            max_items_to_sample = 100  # Sample limit for large collections
+
+            # Priority attributes to always check
+            priority_attrs = [
+                "_error_history",
+                "_error_types",
+                "_api_timings",
+                "_operation_timings",
+                "_memory_snapshots",
+                "_network_stats",
+                "_data_quality",
+                "_component_stats",
+            ]
+
+            # Component-specific attributes (check only if they exist)
+            component_attrs = [
+                "tracked_orders",
+                "order_status_cache",
+                "position_orders",
+                "_orders",
+                "_positions",
+                "_trades",
+                "_bars",
+                "_ticks",
+                "stats",
+                "_data",
+                "_order_history",
+                "_position_history",
+            ]
+
+            # Check priority attributes fully
+            for attr_name in priority_attrs:
+                if hasattr(self, attr_name):
+                    attr = getattr(self, attr_name)
+                    size += sys.getsizeof(attr)
+
+                    # For small collections, count all items
+                    if isinstance(attr, (list, dict, set, deque)):
+                        try:
+                            items = attr.values() if isinstance(attr, dict) else attr
+                            item_count = len(items) if hasattr(items, "__len__") else 0
+
+                            if item_count <= max_items_to_sample:
+                                # Count all items for small collections
+                                for item in items:
+                                    size += sys.getsizeof(item)
+                            else:
+                                # Sample for large collections
+                                sample_size = 0
+                                for i, item in enumerate(items):
+                                    if i >= max_items_to_sample:
+                                        break
+                                    sample_size += sys.getsizeof(item)
+                                # Estimate total size based on sample
+                                avg_item_size = sample_size / max_items_to_sample
+                                size += int(avg_item_size * item_count)
+                        except (AttributeError, TypeError):
+                            pass
 
         # For component-specific attributes, use sampling for performance
         for attr_name in component_attrs:
@@ -555,10 +558,10 @@ def _calculate_percentile(
             return 0.0
 
         sorted_data = sorted(data)
-        index = int(len(sorted_data) * percentile / 100)
-        if index >= len(sorted_data):
-            index = len(sorted_data) - 1
-
+        # Proper percentile calculation with bounds checking
+        index = max(
+            0, min(len(sorted_data) - 1, int((len(sorted_data) - 1) * percentile / 100))
+        )
         return sorted_data[index]
 
     def _sanitize_for_export(self, data: Any) -> Any:
@@ -624,7 +627,7 @@ def _sanitize_for_export(self, data: Any) -> Any:
                         for x in ["pnl", "profit", "loss", "balance", "equity"]
                     ):
                         # Show if positive/negative but not actual value
-                        if isinstance(value, int | float):
+                        if isinstance(value, (int, float)):
                             sanitized[key] = (
                                 "positive"
                                 if value > 0
@@ -640,7 +643,7 @@ def _sanitize_for_export(self, data: Any) -> Any:
                     sanitized[key] = self._sanitize_for_export(value)
 
             return sanitized
-        elif isinstance(data, list | tuple):
+        elif isinstance(data, (list, tuple)):
             return [self._sanitize_for_export(item) for item in data]
         elif isinstance(data, str):
             # Check for patterns that look like sensitive data