Internal event bus to decouple Task status from logging, #290

@status.setter
def status(self, value):
    self._status = value
    self.config.notify.hook_status_task(task=self)
    if value == FAILED:
        self.config.log.error(task=self)
        self.config.metrics.task_failed(task=self)
    elif value == RETRY:
        ...

# dotflow/core/events.py
from collections.abc import Callable
from dataclasses import dataclass
from typing import Any
from dotflow.logging import logger

@dataclass
class StatusChanged:
    task: "Task"
    old: "TypeStatus"
    new: "TypeStatus"

class EventBus:
    def __init__(self) -> None:
        self._subs: list[Callable[[Any], None]] = []

    def subscribe(self, handler: Callable[[Any], None]) -> None:
        self._subs.append(handler)

    def emit(self, event: Any) -> None:
        for handler in self._subs:
            try:
                handler(event)
            except Exception:
                logger.exception("event handler failed")

# dotflow/core/task.py
@status.setter
def status(self, value):
    old = self._status
    self._status = value
    self.config.events.emit(StatusChanged(task=self, old=old, new=value))

# dotflow/core/config.py
from dotflow.core.events import EventBus
from dotflow.core.subscribers import (
    LogSubscriber, NotifySubscriber, MetricsSubscriber,
)

class Config:
    def __init__(self, ...):
        ...
        self.events = EventBus()
        self.events.subscribe(LogSubscriber(self.log))
        self.events.subscribe(NotifySubscriber(self.notify))
        self.events.subscribe(MetricsSubscriber(self.metrics))

class LogSubscriber:
    def __init__(self, log): self.log = log

    def __call__(self, event):
        if not isinstance(event, StatusChanged):
            return
        if event.new == TypeStatus.FAILED:
            self.log.error(task=event.task)
        elif event.new == TypeStatus.RETRY:
            self.log.warning(task=event.task)
        else:
            self.log.info(task=event.task)