infrahub-server 1.1.7__py3-none-any.whl → 1.2.0b1__py3-none-any.whl

infrahub/services/adapters/message_bus/local.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 from collections import defaultdict
-from typing import TYPE_CHECKING, Optional, TypeVar
+from typing import TYPE_CHECKING, TypeVar
 
 import ujson
 from infrahub_sdk.uuidt import UUIDT
@@ -10,34 +10,36 @@ from infrahub.dependencies.registry import build_component_registry
 from infrahub.message_bus import InfrahubMessage, Meta
 from infrahub.message_bus.messages import ROUTING_KEY_MAP
 from infrahub.message_bus.operations import execute_message
-from infrahub.services import InfrahubServices
 from infrahub.services.adapters.message_bus import InfrahubMessageBus
 
 if TYPE_CHECKING:
-    from infrahub.database import InfrahubDatabase
     from infrahub.message_bus.types import MessageTTL
 
 ResponseClass = TypeVar("ResponseClass")
 
 
 class BusSimulator(InfrahubMessageBus):
-    def __init__(self, database: Optional[InfrahubDatabase] = None) -> None:
+    def __init__(self) -> None:
         self.messages: list[InfrahubMessage] = []
         self.messages_per_routing_key: dict[str, list[InfrahubMessage]] = {}
-        self.service: InfrahubServices = InfrahubServices(database=database, message_bus=self)
         self.replies: dict[str, list[InfrahubMessage]] = defaultdict(list)
         build_component_registry()
 
     async def publish(
-        self, message: InfrahubMessage, routing_key: str, delay: Optional[MessageTTL] = None, is_retry: bool = False
+        self,
+        message: InfrahubMessage,
+        routing_key: str,
+        delay: MessageTTL | None = None,  # noqa: ARG002
+        is_retry: bool = False,  # noqa: ARG002
     ) -> None:
         self.messages.append(message)
         if routing_key not in self.messages_per_routing_key:
             self.messages_per_routing_key[routing_key] = []
         self.messages_per_routing_key[routing_key].append(message)
+        assert self.service is not None
         await execute_message(routing_key=routing_key, message_body=message.body, service=self.service)
 
-    async def reply(self, message: InfrahubMessage, routing_key: str) -> None:
+    async def reply(self, message: InfrahubMessage, routing_key: str) -> None:  # noqa: ARG002
         correlation_id = message.meta.correlation_id or "default"
         self.replies[correlation_id].append(message)
 

infrahub/services/adapters/message_bus/nats.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 import asyncio
 import ssl
-from typing import TYPE_CHECKING, Awaitable, Callable, MutableMapping, Optional, TypeVar
+from typing import TYPE_CHECKING, Awaitable, Callable, MutableMapping, TypeVar
 
 import nats
 import ujson
@@ -33,7 +33,7 @@ async def _add_request_id(message: InfrahubMessage) -> None:
 
 
 class NATSMessageBus(InfrahubMessageBus):
-    def __init__(self, settings: Optional[BrokerSettings] = None) -> None:
+    def __init__(self, component_type: ComponentType, settings: BrokerSettings | None = None) -> None:
         self.settings = settings or config.SETTINGS.broker
 
         self.service: InfrahubServices
@@ -46,9 +46,15 @@ class NATSMessageBus(InfrahubMessageBus):
         self.loop = asyncio.get_running_loop()
         self.futures: MutableMapping[str, asyncio.Future] = {}
 
-    async def initialize(self, service: InfrahubServices) -> None:
-        self.service = service
+        self.component_type: ComponentType = component_type
 
+    @classmethod
+    async def new(cls, component_type: ComponentType, settings: BrokerSettings | None = None) -> NATSMessageBus:
+        message_bus = cls(component_type=component_type, settings=settings)
+        await message_bus._initialize()
+        return message_bus
+
+    async def _initialize(self) -> None:
         tls_context = None
         if self.settings.tls_enabled:
             tls_context = ssl.create_default_context(purpose=ssl.Purpose.SERVER_AUTH)
@@ -67,9 +73,9 @@ class NATSMessageBus(InfrahubMessageBus):
 
         self.jetstream = self.connection.jetstream()
 
-        if self.service.component_type == ComponentType.API_SERVER:
+        if self.component_type == ComponentType.API_SERVER:
             await self._initialize_api_server()
-        elif self.service.component_type == ComponentType.GIT_AGENT:
+        elif self.component_type == ComponentType.GIT_AGENT:
             await self._initialize_git_worker()
 
     async def shutdown(self) -> None:
@@ -207,7 +213,7 @@ class NATSMessageBus(InfrahubMessageBus):
         await self.publish(message, routing_key)
 
     async def publish(
-        self, message: InfrahubMessage, routing_key: str, delay: Optional[MessageTTL] = None, is_retry: bool = False
+        self, message: InfrahubMessage, routing_key: str, delay: MessageTTL | None = None, is_retry: bool = False
     ) -> None:
         with trace.get_tracer(__name__).start_as_current_span("publish_message") as span:
             span.set_attribute("routing_key", routing_key)
@@ -282,7 +288,7 @@ class NATSMessageBus(InfrahubMessageBus):
             request_id=request_id, correlation_id=correlation_id, reply_to=self.callback_queue.config.name
         )
 
-        await self.service.send(message=message)
+        await self.service.message_bus.send(message=message)
 
         response: nats.aio.msg.Msg = await future
         data = ujson.loads(response.data)

infrahub/services/adapters/message_bus/rabbitmq.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 import asyncio
-from typing import TYPE_CHECKING, Awaitable, Callable, MutableMapping, Optional, TypeVar
+from typing import TYPE_CHECKING, Awaitable, Callable, MutableMapping, TypeVar
 
 import aio_pika
 import opentelemetry.instrumentation.aio_pika.span_builder
@@ -65,12 +65,14 @@ async def _add_request_id(message: InfrahubMessage) -> None:
 
 
 class RabbitMQMessageBus(InfrahubMessageBus):
-    def __init__(self, settings: Optional[BrokerSettings] = None) -> None:
+    def __init__(
+        self, component_type: ComponentType = ComponentType.NONE, settings: BrokerSettings | None = None
+    ) -> None:
         self.settings = settings or config.SETTINGS.broker
         self.channel: AbstractChannel
         self.exchange: AbstractExchange
         self.delayed_exchange: AbstractExchange
-        self.service: InfrahubServices
+        self.service: InfrahubServices  # Needed because we inject `service` while sending messages.
         self.connection: AbstractRobustConnection
         self.callback_queue: AbstractQueue
         self.events_queue: AbstractQueue
@@ -80,10 +82,17 @@ class RabbitMQMessageBus(InfrahubMessageBus):
         self.loop = asyncio.get_running_loop()
         self.futures: MutableMapping[str, asyncio.Future] = {}
 
-    async def initialize(self, service: InfrahubServices) -> None:
+        self.component_type: ComponentType = component_type
+
+    @classmethod
+    async def new(cls, component_type: ComponentType, settings: BrokerSettings | None = None) -> RabbitMQMessageBus:
+        message_bus = cls(component_type=component_type, settings=settings)
+        await message_bus._initialize()
+        return message_bus
+
+    async def _initialize(self) -> None:
         patch_spanbuilder_set_channel()
 
-        self.service = service
         self.connection = await aio_pika.connect_robust(
             host=self.settings.address,
             login=self.settings.username,
@@ -103,9 +112,9 @@ class RabbitMQMessageBus(InfrahubMessageBus):
     async def _initialize_connection(self) -> None:
         self.channel = await self.connection.channel()
 
-        if self.service.component_type == ComponentType.API_SERVER:
+        if self.component_type == ComponentType.API_SERVER:
             await self._initialize_api_server()
-        elif self.service.component_type == ComponentType.GIT_AGENT:
+        elif self.component_type == ComponentType.GIT_AGENT:
             await self._initialize_git_worker()
 
     async def shutdown(self) -> None:
@@ -135,7 +144,7 @@ class RabbitMQMessageBus(InfrahubMessageBus):
 
     async def on_reconnect(
         self,
-        weak: bool = False,  # pylint: disable=unused-argument
+        weak: bool = False,  # noqa: ARG002
     ) -> None:
         self.service.log.info("Reconnected to RabbitMQ, reinitializing connection")
         await self._initialize_connection()
@@ -209,7 +218,11 @@ class RabbitMQMessageBus(InfrahubMessageBus):
         await queue.consume(callback=self.on_message, no_ack=False)
 
     async def publish(
-        self, message: InfrahubMessage, routing_key: str, delay: Optional[MessageTTL] = None, is_retry: bool = False
+        self,
+        message: InfrahubMessage,
+        routing_key: str,
+        delay: MessageTTL | None = None,
+        is_retry: bool = False,  # noqa: ARG002
     ) -> None:
         for enricher in self.message_enrichers:
             await enricher(message)
@@ -233,7 +246,7 @@ class RabbitMQMessageBus(InfrahubMessageBus):
         request_id = log_data.get("request_id", "")
         message.meta = Meta(request_id=request_id, correlation_id=correlation_id, reply_to=self.callback_queue.name)
 
-        await self.service.send(message=message)
+        await self.service.message_bus.send(message=message)
 
         response: AbstractIncomingMessage = await future
         data = ujson.loads(response.body)

infrahub/services/adapters/workflow/__init__.py

@@ -1,26 +1,24 @@
 from __future__ import annotations
 
+from abc import ABC, abstractmethod
 from typing import TYPE_CHECKING, Any, Callable, ParamSpec, TypeVar, overload
 
 if TYPE_CHECKING:
-    from infrahub.services import InfrahubServices
+    from infrahub.context import InfrahubContext
     from infrahub.workflows.models import WorkflowDefinition, WorkflowInfo
-
 Return = TypeVar("Return")
 Params = ParamSpec("Params")
 
 FuncType = Callable[Params, Return]
 
 
-class InfrahubWorkflow:
-    async def initialize(self, service: InfrahubServices) -> None:
-        """Initialize the Workflow engine"""
-
+class InfrahubWorkflow(ABC):
     @overload
     async def execute_workflow(
         self,
         workflow: WorkflowDefinition,
         expected_return: type[Return],
+        context: InfrahubContext | None = ...,
         parameters: dict[str, Any] | None = ...,
         tags: list[str] | None = ...,
     ) -> Return: ...
@@ -30,23 +28,28 @@ class InfrahubWorkflow:
         self,
         workflow: WorkflowDefinition,
         expected_return: None = ...,
+        context: InfrahubContext | None = ...,
         parameters: dict[str, Any] | None = ...,
         tags: list[str] | None = ...,
     ) -> Any: ...
 
+    @abstractmethod
     async def execute_workflow(
         self,
         workflow: WorkflowDefinition,
         expected_return: type[Return] | None = None,
+        context: InfrahubContext | None = None,
         parameters: dict[str, Any] | None = None,
         tags: list[str] | None = None,
     ) -> Any:
-        raise NotImplementedError("InfrahubWorkflow.execute_workflow is an abstract method")
+        raise NotImplementedError()
 
+    @abstractmethod
     async def submit_workflow(
         self,
         workflow: WorkflowDefinition,
+        context: InfrahubContext | None = None,
         parameters: dict[str, Any] | None = None,
         tags: list[str] | None = None,
     ) -> WorkflowInfo:
-        raise NotImplementedError("InfrahubWorkflow.submit_workflow is an abstract method")
+        raise NotImplementedError()

infrahub/services/adapters/workflow/local.py

@@ -1,27 +1,48 @@
+from __future__ import annotations
+
 import uuid
 from typing import Any
 
+from typing_extensions import TYPE_CHECKING
+
+from infrahub.workers.utils import inject_context_parameter, inject_service_parameter
 from infrahub.workflows.models import WorkflowDefinition, WorkflowInfo
 
 from . import InfrahubWorkflow, Return
 
+if TYPE_CHECKING:
+    from infrahub.context import InfrahubContext
+    from infrahub.services import InfrahubServices
+
 
 class WorkflowLocalExecution(InfrahubWorkflow):
+    service: InfrahubServices | None = None  # needed for local injections
+
     async def execute_workflow(
         self,
         workflow: WorkflowDefinition,
-        expected_return: type[Return] | None = None,
+        expected_return: type[Return] | None = None,  # noqa: ARG002
+        context: InfrahubContext | None = None,
         parameters: dict[str, Any] | None = None,
-        tags: list[str] | None = None,
+        tags: list[str] | None = None,  # noqa: ARG002
     ) -> Any:
-        fn = workflow.get_function()
-        return await fn(**parameters or {})
+        if self.service is None:
+            raise ValueError("WorkflowLocalExecution.service is not initialized")
+
+        flow_func = workflow.load_function()
+        parameters = dict(parameters) if parameters is not None else {}  # avoid mutating input parameters
+        inject_service_parameter(func=flow_func, parameters=parameters, service=self.service)
+        inject_context_parameter(func=flow_func, parameters=parameters, context=context)
+
+        parameters = flow_func.validate_parameters(parameters=parameters)
+        return await flow_func(**parameters)
 
     async def submit_workflow(
         self,
         workflow: WorkflowDefinition,
+        context: InfrahubContext | None = None,
         parameters: dict[str, Any] | None = None,
-        tags: list[str] | None = None,
+        tags: list[str] | None = None,  # noqa: ARG002
     ) -> WorkflowInfo:
-        await self.execute_workflow(workflow=workflow, parameters=parameters)
+        await self.execute_workflow(workflow=workflow, context=context, parameters=parameters)
         return WorkflowInfo(id=uuid.uuid4())

infrahub/services/adapters/workflow/worker.py

@@ -5,6 +5,7 @@ from typing import TYPE_CHECKING, Any, overload
 from prefect.client.schemas.objects import StateType
 from prefect.deployments import run_deployment
 
+from infrahub.workers.utils import inject_context_parameter
 from infrahub.workflows.initialization import setup_task_manager
 from infrahub.workflows.models import WorkflowInfo
 
@@ -13,15 +14,14 @@ from . import InfrahubWorkflow, Return
 if TYPE_CHECKING:
     from prefect.client.schemas.objects import FlowRun
 
-    from infrahub.services import InfrahubServices
+    from infrahub.context import InfrahubContext
     from infrahub.workflows.models import WorkflowDefinition
 
 
 class WorkflowWorkerExecution(InfrahubWorkflow):
-    async def initialize(self, service: InfrahubServices) -> None:
-        """Initialize the Workflow engine"""
-
-        if await service.component.is_primary_api():
+    @staticmethod
+    async def initialize(component_is_primary_server: bool) -> None:
+        if component_is_primary_server:
             await setup_task_manager()
 
     @overload
@@ -29,6 +29,7 @@ class WorkflowWorkerExecution(InfrahubWorkflow):
         self,
         workflow: WorkflowDefinition,
         expected_return: type[Return],
+        context: InfrahubContext | None = None,
         parameters: dict[str, Any] | None = ...,
         tags: list[str] | None = ...,
     ) -> Return: ...
@@ -38,17 +39,24 @@ class WorkflowWorkerExecution(InfrahubWorkflow):
         self,
         workflow: WorkflowDefinition,
         expected_return: None = ...,
+        context: InfrahubContext | None = ...,
         parameters: dict[str, Any] | None = ...,
         tags: list[str] | None = ...,
     ) -> Any: ...
 
+    # TODO Make expected_return mandatory and remove above overloads.
     async def execute_workflow(
         self,
         workflow: WorkflowDefinition,
-        expected_return: type[Return] | None = None,
+        expected_return: type[Return] | None = None,  # noqa: ARG002
+        context: InfrahubContext | None = None,
         parameters: dict[str, Any] | None = None,
         tags: list[str] | None = None,
     ) -> Any:
+        flow_func = workflow.load_function()
+        parameters = dict(parameters) if parameters is not None else {}
+        inject_context_parameter(func=flow_func, parameters=parameters, context=context)
+
         response: FlowRun = await run_deployment(
             name=workflow.full_name, poll_interval=1, parameters=parameters or {}, tags=tags
         )  # type: ignore[return-value, misc]
@@ -61,7 +69,15 @@ class WorkflowWorkerExecution(InfrahubWorkflow):
         return await response.state.result(raise_on_failure=True, fetch=True)  # type: ignore[call-overload]
 
     async def submit_workflow(
-        self, workflow: WorkflowDefinition, parameters: dict[str, Any] | None = None, tags: list[str] | None = None
+        self,
+        workflow: WorkflowDefinition,
+        context: InfrahubContext | None = None,
+        parameters: dict[str, Any] | None = None,
+        tags: list[str] | None = None,
     ) -> WorkflowInfo:
+        flow_func = workflow.load_function()
+        parameters = dict(parameters) if parameters is not None else {}
+        inject_context_parameter(func=flow_func, parameters=parameters, context=context)
+
         flow_run = await run_deployment(name=workflow.full_name, timeout=0, parameters=parameters or {}, tags=tags)  # type: ignore[return-value, misc]
         return WorkflowInfo.from_flow(flow_run=flow_run)

infrahub/services/component.py

@@ -1,56 +1,59 @@
 from __future__ import annotations
 
 import re
-from typing import TYPE_CHECKING, Any, Optional
+from typing import TYPE_CHECKING, Any
+
+from attr import dataclass
 
 from infrahub.components import ComponentType
 from infrahub.core.constants import GLOBAL_BRANCH_NAME
 from infrahub.core.registry import registry
 from infrahub.core.timestamp import Timestamp
-from infrahub.exceptions import InitializationError
+from infrahub.log import get_logger
 from infrahub.message_bus import messages
 from infrahub.message_bus.types import KVTTL
 from infrahub.worker import WORKER_IDENTITY
 
 if TYPE_CHECKING:
-    from infrahub.services import InfrahubServices
+    from infrahub.database import InfrahubDatabase
+    from infrahub.services import InfrahubCache, InfrahubMessageBus
 
 PRIMARY_API_SERVER = "workers:primary:api_server"
 WORKER_MATCH = re.compile(r":worker:([^:]+)")
 
+log = get_logger()
 
-class InfrahubComponent:
-    def __init__(self) -> None:
-        self._service: Optional[InfrahubServices] = None
-
-    @property
-    def service(self) -> InfrahubServices:
-        if not self._service:
-            raise InitializationError("Component has not been initialized")
 
-        return self._service
+@dataclass
+class InfrahubComponent:
+    cache: InfrahubCache
+    db: InfrahubDatabase
+    message_bus: InfrahubMessageBus
+    component_type: ComponentType
+
+    @classmethod
+    async def new(
+        cls, cache: InfrahubCache, db: InfrahubDatabase, message_bus: InfrahubMessageBus, component_type: ComponentType
+    ) -> InfrahubComponent:
+        component = cls(cache=cache, db=db, message_bus=message_bus, component_type=component_type)
+        await component.refresh_heartbeat()
+        return component
 
     @property
     def component_names(self) -> list[str]:
         names = []
-        if self.service.component_type == ComponentType.API_SERVER:
+        if self.component_type == ComponentType.API_SERVER:
             names.append("api_server")
-        elif self.service.component_type == ComponentType.GIT_AGENT:
+        elif self.component_type == ComponentType.GIT_AGENT:
             names.append("git_agent")
         return names
 
-    async def initialize(self, service: InfrahubServices) -> None:
-        """Initialize the Message bus"""
-        self._service = service
-
-        await self.refresh_heartbeat()
-
-    async def is_primary_api(self) -> bool:
-        primary_identity = await self.service.cache.get(PRIMARY_API_SERVER)
+    async def is_primary_gunicorn_worker(self) -> bool:
+        primary_identity = await self.cache.get(PRIMARY_API_SERVER)
         return primary_identity == WORKER_IDENTITY
 
     async def list_workers(self, branch: str, schema_hash: bool) -> list[WorkerInfo]:
-        keys = await self.service.cache.list_keys(filter_pattern="workers:*")
+        keys = await self.cache.list_keys(filter_pattern="workers:*")
 
         workers: dict[str, WorkerInfo] = {}
         for key in keys:
@@ -64,9 +67,9 @@ class InfrahubComponent:
         schema_hash_keys = []
         if schema_hash:
             schema_hash_keys = [key for key in keys if f":schema_hash:branch:{branch}" in key]
-            response = await self.service.cache.get_values(keys=schema_hash_keys)
+            response = await self.cache.get_values(keys=schema_hash_keys)
 
-        for key, value in zip(schema_hash_keys, response):
+        for key, value in zip(schema_hash_keys, response, strict=False):
             if match := WORKER_MATCH.search(key):
                 identity = match.group(1)
                 workers[identity].add_value(key=key, value=value)
@@ -81,15 +84,15 @@ class InfrahubComponent:
             hash_value = schema_branch.get_hash()
 
             # Use branch name if we cannot find branch id in cache
-            branch_id: Optional[str] = None
-            if branch_obj := await registry.get_branch(branch=branch, db=self.service.database):
+            branch_id: str | None = None
+            if branch_obj := await registry.get_branch(branch=branch, db=self.db):
                 branch_id = str(branch_obj.uuid)
 
             if not branch_id:
                 branch_id = branch
 
             for component in self.component_names:
-                await self.service.cache.set(
+                await self.cache.set(
                     key=f"workers:schema_hash:branch:{branch_id}:{component}:worker:{WORKER_IDENTITY}",
                     value=hash_value,
                     expires=KVTTL.TWO_HOURS,
@@ -97,39 +100,39 @@ class InfrahubComponent:
 
     async def refresh_heartbeat(self) -> None:
         for component in self.component_names:
-            await self.service.cache.set(
+            await self.cache.set(
                 key=f"workers:active:{component}:worker:{WORKER_IDENTITY}",
                 value=Timestamp().to_string(),
                 expires=KVTTL.FIFTEEN,
             )
-        if self.service.component_type == ComponentType.API_SERVER:
+        if self.component_type == ComponentType.API_SERVER:
             await self._set_primary_api_server()
-        await self.service.cache.set(
+        await self.cache.set(
             key=f"workers:worker:{WORKER_IDENTITY}", value=Timestamp().to_string(), expires=KVTTL.TWO_HOURS
         )
 
     async def _set_primary_api_server(self) -> None:
-        result = await self.service.cache.set(
+        result = await self.cache.set(
             key=PRIMARY_API_SERVER, value=WORKER_IDENTITY, expires=KVTTL.FIFTEEN, not_exists=True
         )
         if result:
-            await self.service.send(message=messages.EventWorkerNewPrimaryAPI(worker_id=WORKER_IDENTITY))
+            await self.message_bus.send(message=messages.EventWorkerNewPrimaryAPI(worker_id=WORKER_IDENTITY))
         else:
-            self.service.log.debug("Primary node already set")
-            primary_id = await self.service.cache.get(key=PRIMARY_API_SERVER)
+            log.debug("Primary node already set")
+            primary_id = await self.cache.get(key=PRIMARY_API_SERVER)
             if primary_id == WORKER_IDENTITY:
-                self.service.log.debug("Primary node set but same as ours, refreshing lifetime")
-                await self.service.cache.set(key=PRIMARY_API_SERVER, value=WORKER_IDENTITY, expires=KVTTL.FIFTEEN)
+                log.debug("Primary node set but same as ours, refreshing lifetime")
+                await self.cache.set(key=PRIMARY_API_SERVER, value=WORKER_IDENTITY, expires=KVTTL.FIFTEEN)
 
 
 class WorkerInfo:
     def __init__(self, identity: str) -> None:
         self.id = identity
         self.active = False
-        self._schema_hash: Optional[str] = None
+        self._schema_hash: str | None = None
 
     @property
-    def schema_hash(self) -> Optional[str]:
+    def schema_hash(self) -> str | None:
         """Return schema hash provided that the worker is active."""
         if self.active:
             return self._schema_hash
@@ -140,7 +143,7 @@ class WorkerInfo:
         if "workers:active:" in key:
             self.active = True
 
-    def add_value(self, key: str, value: Optional[str] = None) -> None:
+    def add_value(self, key: str, value: str | None = None) -> None:
         if ":schema_hash:" in key:
             self._schema_hash = value
 

infrahub/services/protocols.py

@@ -1,21 +1,21 @@
-from typing import Any, Optional, Protocol
+from typing import Any, Protocol
 
 
 class InfrahubLogger(Protocol):
-    def debug(self, event: Optional[str] = None, *args: Any, **kw: Any) -> Any:
+    def debug(self, event: str | None = None, *args: Any, **kw: Any) -> Any:
         """Send a debug event"""
 
-    def info(self, event: Optional[str] = None, *args: Any, **kw: Any) -> Any:
+    def info(self, event: str | None = None, *args: Any, **kw: Any) -> Any:
         """Send an info event"""
 
-    def warning(self, event: Optional[str] = None, *args: Any, **kw: Any) -> Any:
+    def warning(self, event: str | None = None, *args: Any, **kw: Any) -> Any:
         """Send a warning event"""
 
-    def error(self, event: Optional[str] = None, *args: Any, **kw: Any) -> Any:
+    def error(self, event: str | None = None, *args: Any, **kw: Any) -> Any:
         """Send an error event."""
 
-    def critical(self, event: Optional[str] = None, *args: Any, **kw: Any) -> Any:
+    def critical(self, event: str | None = None, *args: Any, **kw: Any) -> Any:
         """Send a critical event."""
 
-    def exception(self, event: Optional[str] = None, *args: Any, **kw: Any) -> Any:
+    def exception(self, event: str | None = None, *args: Any, **kw: Any) -> Any:
         """Send an exception event."""