SystemMonitor

def __init__(self, period: int = 1, enabled: bool = True):
    self.period = max(1, int(period))
    self.enabled = enabled
    self.stop_event = asyncio.Event()
    self.task: Optional[asyncio.Task] = None
    self.cpu_percent: float = 0
    self.mem_total: int = 0
    self.mem_used: int = 0

    self.on_timer: Optional[Callable[[float], Awaitable[None]]] = None

def start(self) -> None:
    """Starts the sampling task; no-op when disabled."""
    if not self.enabled:
        return
    self.stop_event.clear()
    self.task = asyncio.create_task(self._monitor_loop())
    logger_system.info("System monitor started")

def _get_system_metrics(self) -> Tuple[float, int, int]:
    """Returns `(cpu_percent, mem_total_bytes, mem_used_bytes)`; blocking."""
    cpu = psutil.cpu_percent()
    mem = psutil.virtual_memory()
    return cpu, mem.total, mem.used

async def _monitor_loop(self) -> None:
    """Samples until stopped."""
    try:
        while not self.stop_event.is_set():
            self.cpu_percent, self.mem_total, self.mem_used = await asyncio.to_thread(
                self._get_system_metrics
            )
            if self.on_timer:
                await self.on_timer(time.time())

            try:
                await asyncio.wait_for(self.stop_event.wait(), timeout=self.period)
            except asyncio.TimeoutError:
                pass
    except asyncio.CancelledError:
        pass
    except Exception as e:
        logger_system.error(f"System monitor error: {e}", exc_info=True)
    finally:
        logger_system.debug("System monitor loop exited")

async def stop(self) -> None:
    """Signals the loop to exit and waits for the task to finish."""
    self.stop_event.set()
    if self.task:
        await self.task
    logger_system.info("System monitor stopped")