feat(fitness): add timing instrumentation to fitness checks

Implements timing instrumentation for fitness checks as requested in review feedback.
Timing information provides visibility into check execution performance.

Changes:
- Add time.perf_counter() measurements for individual checks
- Log individual check timing in debug output (e.g., '(42.5ms)')
- Log total fitness check execution time in final info message
- Use 2-decimal precision for millisecond formatting
- Add 5 comprehensive tests for timing functionality:
  * test_logs_individual_check_timing: Verify individual timings logged
  * test_logs_total_check_timing: Verify total time in summary
  * test_timing_is_reasonable: Ensure timings are positive and realistic
  * test_timing_with_multiple_checks: Verify all checks have timing logged
  * test_timing_format_consistency: Ensure format follows (X.XXms) pattern

Author: deanq

runpod/serverless/modules/rp_fitness.py

@@ -10,6 +10,7 @@
 
 import inspect
 import sys
+import time
 import traceback
 from typing import Callable, List
 
@@ -149,19 +150,20 @@ async def run_fitness_checks() -> None:
     3. Log start of fitness check phase
     4. For each registered check:
        - Auto-detect sync vs async using inspect.iscoroutinefunction()
-       - Execute check (await if async, call if sync)
-       - Log success or failure with check name
+       - Execute check with timing instrumentation (await if async, call if sync)
+       - Log success or failure with check name and execution time
     5. On any exception:
        - Log detailed error with check name, exception type, and message
        - Log traceback at DEBUG level
        - Call sys.exit(1) immediately (fail-fast)
     6. On successful completion of all checks:
-       - Log completion message
+       - Log completion message with total execution time
 
     Note:
         Checks run in registration order (list preserves order).
         Sequential execution (not parallel) ensures clear error reporting
         and handles checks with dependencies correctly.
+        Timing uses high-precision perf_counter for accurate measurements.
 
     Raises:
         SystemExit: Calls sys.exit(1) if any check fails.
@@ -179,19 +181,23 @@ async def run_fitness_checks() -> None:
 
     log.info(f"Running {len(_fitness_checks)} fitness check(s)...")
 
+    total_start_time = time.perf_counter()
+
     for check_func in _fitness_checks:
         check_name = check_func.__name__
 
         try:
             log.debug(f"Executing fitness check: {check_name}")
+            check_start_time = time.perf_counter()
 
             # Auto-detect async vs sync using inspect
             if inspect.iscoroutinefunction(check_func):
                 await check_func()
             else:
                 check_func()
 
-            log.debug(f"Fitness check passed: {check_name}")
+            check_elapsed_ms = (time.perf_counter() - check_start_time) * 1000
+            log.debug(f"Fitness check passed: {check_name} ({check_elapsed_ms:.2f}ms)")
 
         except Exception as exc:
             # Log detailed error information
@@ -209,4 +215,5 @@ async def run_fitness_checks() -> None:
             log.error("Worker is unhealthy, exiting.")
             sys.exit(1)
 
-    log.info("All fitness checks passed.")
+    total_elapsed_ms = (time.perf_counter() - total_start_time) * 1000
+    log.info(f"All fitness checks passed. ({total_elapsed_ms:.2f}ms)")

tests/test_serverless/test_modules/test_fitness/test_registration.py

@@ -452,3 +452,120 @@ def check_three():
 
         # Only first check should have run
         assert results == ["one"]
+
+
+# ============================================================================
+# Timing Instrumentation Tests
+# ============================================================================
+
+class TestFitnessCheckTiming:
+    """Tests for fitness check timing instrumentation."""
+
+    @pytest.mark.asyncio
+    @patch("runpod.serverless.modules.rp_fitness.log")
+    async def test_logs_individual_check_timing(self, mock_log):
+        """Test that individual check timings are logged."""
+        @register_fitness_check
+        def check():
+            pass
+
+        await run_fitness_checks()
+
+        # Verify timing is logged in debug output for the check
+        debug_calls = [str(call) for call in mock_log.debug.call_args_list]
+        # Should contain timing info like "(X.XXms)"
+        assert any("ms)" in call for call in debug_calls)
+
+    @pytest.mark.asyncio
+    @patch("runpod.serverless.modules.rp_fitness.log")
+    async def test_logs_total_check_timing(self, mock_log):
+        """Test that total execution time is logged."""
+        @register_fitness_check
+        def check():
+            pass
+
+        await run_fitness_checks()
+
+        # Verify total timing is logged in final info message
+        info_calls = [str(call) for call in mock_log.info.call_args_list]
+        # Final message should be "All fitness checks passed. (X.XXms)"
+        assert any(
+            "All fitness checks passed" in call and "ms)" in call
+            for call in info_calls
+        )
+
+    @pytest.mark.asyncio
+    async def test_timing_is_reasonable(self):
+        """Test that check timing is reasonable (not negative, < 100ms for no-op)."""
+        timings = []
+
+        @register_fitness_check
+        def check():
+            pass
+
+        with patch("runpod.serverless.modules.rp_fitness.log") as mock_log:
+            await run_fitness_checks()
+
+            # Extract timing from debug logs
+            debug_calls = mock_log.debug.call_args_list
+            for call in debug_calls:
+                call_str = str(call)
+                # Look for format like "passed: check_name (X.XXms)"
+                if "passed:" in call_str and "ms)" in call_str:
+                    # Extract the timing value
+                    import re
+                    match = re.search(r"\((\d+\.\d+)ms\)", call_str)
+                    if match:
+                        timing_ms = float(match.group(1))
+                        timings.append(timing_ms)
+
+            # Should have at least one timing
+            assert len(timings) > 0
+            # Timings should be positive and reasonable
+            for timing in timings:
+                assert timing >= 0
+                assert timing < 100  # No-op should be < 100ms
+
+    @pytest.mark.asyncio
+    @patch("runpod.serverless.modules.rp_fitness.log")
+    async def test_timing_with_multiple_checks(self, mock_log):
+        """Test that timing is logged for multiple checks."""
+        @register_fitness_check
+        def check_one():
+            pass
+
+        @register_fitness_check
+        def check_two():
+            pass
+
+        await run_fitness_checks()
+
+        # Should log timing for both checks
+        debug_calls = [str(call) for call in mock_log.debug.call_args_list]
+        timing_logs = [call for call in debug_calls if "ms)" in call]
+        # Should have at least 2 timing logs (one for each check)
+        assert len(timing_logs) >= 2
+
+    @pytest.mark.asyncio
+    @patch("runpod.serverless.modules.rp_fitness.log")
+    async def test_timing_format_consistency(self, mock_log):
+        """Test that timing format is consistent (X.XXms)."""
+        import re
+
+        @register_fitness_check
+        def check():
+            pass
+
+        await run_fitness_checks()
+
+        # Check all timing messages follow the format pattern
+        all_calls = (
+            [str(call) for call in mock_log.debug.call_args_list]
+            + [str(call) for call in mock_log.info.call_args_list]
+        )
+        timing_calls = [call for call in all_calls if "ms)" in call]
+
+        # All timing entries should match format (X.XXms)
+        pattern = r"\(\d+\.\d{2}ms\)"
+        for call in timing_calls:
+            assert re.search(pattern, call), f"Timing format mismatch in: {call}"