fastapi-factory-utilities 0.2.0__py3-none-any.whl → 0.7.1__py3-none-any.whl

fastapi_factory_utilities/core/plugins/opentelemetry_plugin/__init__.py

@@ -1,124 +1,17 @@
 """OpenTelemetry Plugin Module."""
 
-import asyncio
-from typing import cast
-
-from opentelemetry.instrumentation.fastapi import (  # pyright: ignore[reportMissingTypeStubs]
-    FastAPIInstrumentor,
-)
-from opentelemetry.sdk.metrics import MeterProvider
-from opentelemetry.sdk.trace import TracerProvider
-from structlog.stdlib import BoundLogger, get_logger
-
-from fastapi_factory_utilities.core.protocols import ApplicationAbstractProtocol
-
-from .builder import OpenTelemetryPluginBuilder
-from .configs import OpenTelemetryConfig
+from .configs import OpenTelemetryConfig, OpenTelemetryMeterConfig, OpenTelemetryTracerConfig
 from .exceptions import OpenTelemetryPluginBaseException, OpenTelemetryPluginConfigError
+from .plugins import OpenTelemetryPlugin, depends_meter_provider, depends_otel_config, depends_tracer_provider
 
 __all__: list[str] = [
     "OpenTelemetryConfig",
+    "OpenTelemetryMeterConfig",
+    "OpenTelemetryPlugin",
     "OpenTelemetryPluginBaseException",
     "OpenTelemetryPluginConfigError",
-    "OpenTelemetryPluginBuilder",
+    "OpenTelemetryTracerConfig",
+    "depends_meter_provider",
+    "depends_otel_config",
+    "depends_tracer_provider",
 ]
-
-_logger: BoundLogger = get_logger()
-
-
-def pre_conditions_check(application: ApplicationAbstractProtocol) -> bool:
-    """Check the pre-conditions for the OpenTelemetry plugin.
-
-    Args:
-        application (BaseApplicationProtocol): The application.
-
-    Returns:
-        bool: True if the pre-conditions are met, False otherwise.
-    """
-    del application
-    return True
-
-
-def on_load(
-    application: ApplicationAbstractProtocol,
-) -> None:
-    """Actions to perform on load for the OpenTelemetry plugin.
-
-    Args:
-        application (BaseApplicationProtocol): The application.
-    """
-    # Build the OpenTelemetry Resources, TracerProvider and MeterProvider
-    try:
-        otel_builder: OpenTelemetryPluginBuilder = OpenTelemetryPluginBuilder(application=application).build_all()
-    except OpenTelemetryPluginBaseException as exception:
-        _logger.error(f"OpenTelemetry plugin failed to start. {exception}")
-        return
-    # Configuration is never None at this point (checked in the builder and raises an exception)
-    otel_config: OpenTelemetryConfig = cast(OpenTelemetryConfig, otel_builder.config)
-    # Save as state in the FastAPI application
-    application.get_asgi_app().state.tracer_provider = otel_builder.tracer_provider
-    application.get_asgi_app().state.meter_provider = otel_builder.meter_provider
-    application.get_asgi_app().state.otel_config = otel_config
-    # Instrument the FastAPI application
-    FastAPIInstrumentor.instrument_app(  # pyright: ignore[reportUnknownMemberType]
-        app=application.get_asgi_app(),
-        tracer_provider=otel_builder.tracer_provider,
-        meter_provider=otel_builder.meter_provider,
-        excluded_urls=otel_config.excluded_urls,
-    )
-
-    _logger.debug(f"OpenTelemetry plugin loaded. {otel_config.activate=}")
-
-
-async def on_startup(
-    application: ApplicationAbstractProtocol,
-) -> None:
-    """Actions to perform on startup for the OpenTelemetry plugin.
-
-    Args:
-        application (BaseApplicationProtocol): The application.
-
-    Returns:
-        None
-    """
-    del application
-    _logger.debug("OpenTelemetry plugin started.")
-
-
-async def on_shutdown(application: ApplicationAbstractProtocol) -> None:
-    """Actions to perform on shutdown for the OpenTelemetry plugin.
-
-    Args:
-        application (BaseApplicationProtocol): The application.
-
-    Returns:
-        None
-    """
-    tracer_provider: TracerProvider = application.get_asgi_app().state.tracer_provider
-    meter_provider: MeterProvider = application.get_asgi_app().state.meter_provider
-    otel_config: OpenTelemetryConfig = application.get_asgi_app().state.otel_config
-
-    seconds_to_ms_multiplier: int = 1000
-
-    async def close_tracer_provider() -> None:
-        """Close the tracer provider."""
-        tracer_provider.force_flush(timeout_millis=otel_config.closing_timeout * seconds_to_ms_multiplier)
-        # No Delay for the shutdown of the tracer provider
-        tracer_provider.shutdown()
-
-    async def close_meter_provider() -> None:
-        """Close the meter provider.
-
-        Split the timeout in half for the flush and shutdown.
-        """
-        meter_provider.force_flush(timeout_millis=int(otel_config.closing_timeout / 2) * seconds_to_ms_multiplier)
-        meter_provider.shutdown(timeout_millis=int(otel_config.closing_timeout / 2) * seconds_to_ms_multiplier)
-
-    _logger.debug("OpenTelemetry plugin stop requested. Flushing and closing...")
-
-    await asyncio.gather(
-        close_tracer_provider(),
-        close_meter_provider(),
-    )
-
-    _logger.debug("OpenTelemetry plugin closed.")

fastapi_factory_utilities/core/plugins/opentelemetry_plugin/builder.py

@@ -1,9 +1,20 @@
 """Provides a factory function to build a objets for OpenTelemetry."""
 
 from typing import Any, Self
+from urllib.parse import ParseResult, urlparse
 
-from opentelemetry.exporter.otlp.proto.http.metric_exporter import OTLPMetricExporter
-from opentelemetry.exporter.otlp.proto.http.trace_exporter import OTLPSpanExporter
+from opentelemetry.exporter.otlp.proto.grpc.metric_exporter import (
+    OTLPMetricExporter as OTLPMetricExporterGRPC,
+)
+from opentelemetry.exporter.otlp.proto.grpc.trace_exporter import (
+    OTLPSpanExporter as OTLPSpanExporterGRPC,
+)
+from opentelemetry.exporter.otlp.proto.http.metric_exporter import (
+    OTLPMetricExporter as OTLPMetricExporterHTTP,
+)
+from opentelemetry.exporter.otlp.proto.http.trace_exporter import (
+    OTLPSpanExporter as OTLPSpanExporterHTTP,
+)
 from opentelemetry.metrics import set_meter_provider
 from opentelemetry.propagate import set_global_textmap
 from opentelemetry.propagators.b3 import B3MultiFormat
@@ -31,24 +42,30 @@ from fastapi_factory_utilities.core.utils.yaml_reader import (
     YamlFileReader,
 )
 
-from .configs import OpenTelemetryConfig
+from .configs import OpenTelemetryConfig, ProtocolEnum
 from .exceptions import OpenTelemetryPluginConfigError
 
+GRPC_PORT: int = 4317
+HTTP_PORT: int = 4318
+
 
 class OpenTelemetryPluginBuilder:
     """Configure the injection bindings for OpenTelemetryPlugin."""
 
-    def __init__(self, application: ApplicationAbstractProtocol) -> None:
+    def __init__(self, application: ApplicationAbstractProtocol, settings: OpenTelemetryConfig | None = None) -> None:
         """Instantiate the OpenTelemetryPluginFactory.
 
         Args:
             application (BaseApplicationProtocol): The application object.
+            settings (OpenTelemetryConfig | None): The OpenTelemetry configuration object.
         """
         self._application: ApplicationAbstractProtocol = application
         self._resource: Resource | None = None
-        self._config: OpenTelemetryConfig | None = None
+        self._config: OpenTelemetryConfig | None = settings
         self._meter_provider: MeterProvider | None = None
         self._tracer_provider: TracerProvider | None = None
+        self._trace_exporter: OTLPSpanExporterGRPC | OTLPSpanExporterHTTP | None = None
+        self._metric_exporter: OTLPMetricExporterGRPC | OTLPMetricExporterHTTP | None = None
 
     @property
     def resource(self) -> Resource | None:
@@ -161,11 +178,27 @@ class OpenTelemetryPluginBuilder:
 
             # TODO: Extract to a dedicated method for the exporter and period reader setup
 
+            url_parsed: ParseResult = urlparse(self._config.endpoint.unicode_string())
+
+            exporter: OTLPMetricExporterGRPC | OTLPMetricExporterHTTP
             # Setup the Exporter
-            exporter = OTLPMetricExporter(
-                endpoint=f"{self._config.endpoint.unicode_string()}v1/metrics",
-                timeout=self._config.timeout,
-            )
+            if url_parsed.port == GRPC_PORT or self._config.protocol == ProtocolEnum.OTLP_GRPC:
+                exporter = OTLPMetricExporterGRPC(
+                    endpoint=f"{self._config.endpoint.unicode_string()}",
+                    timeout=self._config.timeout,
+                    insecure=True if str(self._config.endpoint).startswith("http") else False,
+                )
+            elif url_parsed.port == HTTP_PORT or self._config.protocol == ProtocolEnum.OTLP_HTTP:
+                exporter = OTLPMetricExporterHTTP(
+                    endpoint=f"{self._config.endpoint.unicode_string()}/v1/metrics",
+                    timeout=self._config.timeout,
+                )
+            else:
+                raise OpenTelemetryPluginConfigError(
+                    "The endpoint port is not supported. Use 4317 for gRPC or 4318 for HTTP or set the protocol."
+                )
+
+            self._metric_exporter = exporter
 
             # Setup the Metric Reader
             meter_config: OpenTelemetryMeterConfig = self._config.meter_config
@@ -213,11 +246,28 @@ class OpenTelemetryPluginBuilder:
             if self._config.tracer_config is None:
                 raise OpenTelemetryPluginConfigError("The tracer configuration is missing.")
 
+            exporter: OTLPSpanExporterGRPC | OTLPSpanExporterHTTP
+            url_parsed: ParseResult = urlparse(self._config.endpoint.unicode_string())
             # Setup the Exporter
-            exporter = OTLPSpanExporter(
-                endpoint=f"{self._config.endpoint.unicode_string()}v1/traces",
-                timeout=self._config.timeout,
-            )
+            if url_parsed.port == GRPC_PORT or self._config.protocol == ProtocolEnum.OTLP_GRPC:
+                insecure: bool = False if str(self._config.endpoint).startswith("https") else True
+                endpoint: str = f"{self._config.endpoint.unicode_string()}"
+                exporter = OTLPSpanExporterGRPC(
+                    endpoint=endpoint,
+                    # timeout=self._config.timeout,
+                    insecure=insecure,
+                )
+            elif url_parsed.port == HTTP_PORT or self._config.protocol == ProtocolEnum.OTLP_HTTP:
+                exporter = OTLPSpanExporterHTTP(
+                    endpoint=f"{self._config.endpoint.unicode_string()}/v1/traces",
+                    # timeout=self._config.timeout,
+                )
+            else:
+                raise OpenTelemetryPluginConfigError(
+                    "The endpoint port is not supported. Use 4317 for gRPC or 4318 for HTTP or set the protocol."
+                )
+
+            self._trace_exporter = exporter
 
             # Setup the Span Processor
             tracer_config: OpenTelemetryTracerConfig = self._config.tracer_config
@@ -259,7 +309,8 @@ class OpenTelemetryPluginBuilder:
             Self: The OpenTelemetryPluginFactory object.
         """
         self.build_resource()
-        self.build_config()
+        if self._config is None:
+            self.build_config()
         self.build_meter_provider()
         self.build_tracer_provider()
 

fastapi_factory_utilities/core/plugins/opentelemetry_plugin/configs.py

@@ -1,11 +1,19 @@
 """Provides the configuration model for the OpenTelemetry plugin."""
 
+from enum import StrEnum
 from typing import Annotated
 
 from pydantic import BaseModel, ConfigDict, Field, UrlConstraints
 from pydantic_core import Url
 
 
+class ProtocolEnum(StrEnum):
+    """Defines the protocol enum for OpenTelemetry."""
+
+    OTLP_GRPC = "otlp_grpc"
+    OTLP_HTTP = "otlp_http"
+
+
 class OpenTelemetryMeterConfig(BaseModel):
     """Provides the configuration model for the OpenTelemetry meter as sub-model."""
 
@@ -77,6 +85,11 @@ class OpenTelemetryConfig(BaseModel):
         description="The collector endpoint.",
     )
 
+    protocol: ProtocolEnum | None = Field(
+        default=None,
+        description="The protocol to use for the collector.",
+    )
+
     timeout: int = Field(
         default=TEN_SECONDS_IN_SECONDS,
         description="The timeout in seconds for the collector.",

fastapi_factory_utilities/core/plugins/opentelemetry_plugin/instruments/__init__.py

@@ -0,0 +1,85 @@
+"""Instruments for the OpenTelemetry plugin."""
+
+# pyright: reportMissingTypeStubs=false
+
+from collections.abc import Callable
+from importlib.util import find_spec
+from typing import Any
+
+from opentelemetry.sdk.metrics import MeterProvider
+from opentelemetry.sdk.trace import TracerProvider
+
+from fastapi_factory_utilities.core.plugins.opentelemetry_plugin.configs import OpenTelemetryConfig
+from fastapi_factory_utilities.core.protocols import ApplicationAbstractProtocol
+
+
+def instrument_fastapi(
+    application: ApplicationAbstractProtocol,
+    config: OpenTelemetryConfig,
+    meter_provider: MeterProvider,
+    tracer_provider: TracerProvider,
+) -> None:
+    """Instrument the FastAPI application."""
+    if find_spec(name="fastapi") and find_spec(name="opentelemetry.instrumentation.fastapi"):
+        from opentelemetry.instrumentation.fastapi import (  # pylint: disable=import-outside-toplevel # noqa: PLC0415
+            FastAPIInstrumentor,
+        )
+
+        excluded_urls_str: str | None = None if len(config.excluded_urls) == 0 else ",".join(config.excluded_urls)
+        FastAPIInstrumentor.instrument_app(  # pyright: ignore[reportUnknownMemberType]
+            app=application.get_asgi_app(),
+            tracer_provider=tracer_provider,
+            meter_provider=meter_provider,
+            excluded_urls=excluded_urls_str,
+        )
+
+
+def instrument_aiohttp(
+    application: ApplicationAbstractProtocol,  # pylint: disable=unused-argument
+    config: OpenTelemetryConfig,  # pylint: disable=unused-argument
+    meter_provider: MeterProvider,
+    tracer_provider: TracerProvider,
+) -> None:
+    """Instrument the Aiohttp application.
+
+    Args:
+        application (ApplicationAbstractProtocol): The application.
+        config (OpenTelemetryConfig): The configuration.
+        meter_provider (MeterProvider): The meter provider.
+        tracer_provider (TracerProvider): The tracer provider.
+
+    Returns:
+        None
+    """
+    if find_spec(name="aiohttp") and find_spec(name="opentelemetry.instrumentation.aiohttp_client"):
+        from opentelemetry.instrumentation.aiohttp_client import (  # pylint: disable=import-outside-toplevel # noqa: PLC0415
+            AioHttpClientInstrumentor,
+        )
+
+        AioHttpClientInstrumentor().instrument(  # pyright: ignore[reportUnknownMemberType]
+            tracer_provider=tracer_provider,
+            meter_provider=meter_provider,
+        )
+
+
+def instrument_aio_pika(
+    application: ApplicationAbstractProtocol,  # pylint: disable=unused-argument
+    config: OpenTelemetryConfig,  # pylint: disable=unused-argument
+    meter_provider: MeterProvider,
+    tracer_provider: TracerProvider,
+) -> None:
+    """Instrument the AioPika application."""
+    if find_spec(name="aio_pika") and find_spec(name="opentelemetry.instrumentation.aio_pika"):
+        from opentelemetry.instrumentation.aio_pika import (  # pylint: disable=import-outside-toplevel # noqa: PLC0415
+            AioPikaInstrumentor,
+        )
+
+        AioPikaInstrumentor().instrument(  # pyright: ignore[reportUnknownMemberType]
+            tracer_provider=tracer_provider,
+            meter_provider=meter_provider,
+        )
+
+
+INSTRUMENTS: list[Callable[..., Any]] = [instrument_fastapi, instrument_aiohttp, instrument_aio_pika]
+
+__all__: list[str] = ["INSTRUMENTS"]

fastapi_factory_utilities/core/plugins/opentelemetry_plugin/plugins.py

@@ -0,0 +1,137 @@
+"""Provides the OpenTelemetry plugin."""
+
+import asyncio
+from typing import Self, cast
+
+from fastapi import Request
+from opentelemetry.sdk.metrics import MeterProvider
+from opentelemetry.sdk.trace import TracerProvider
+from structlog.stdlib import BoundLogger, get_logger
+
+from fastapi_factory_utilities.core.plugins.abstracts import PluginAbstract
+
+from .builder import OpenTelemetryPluginBuilder
+from .configs import OpenTelemetryConfig
+from .exceptions import OpenTelemetryPluginBaseException, OpenTelemetryPluginConfigError
+from .instruments import INSTRUMENTS
+
+__all__: list[str] = [
+    "OpenTelemetryConfig",
+    "OpenTelemetryPluginBaseException",
+    "OpenTelemetryPluginBuilder",
+    "OpenTelemetryPluginConfigError",
+]
+
+_logger: BoundLogger = get_logger()
+
+
+class OpenTelemetryPlugin(PluginAbstract):
+    """OpenTelemetry plugin."""
+
+    SECONDS_TO_MS_MULTIPLIER: int = 1000
+
+    def __init__(self) -> None:
+        """Initialize the OpenTelemetry plugin."""
+        super().__init__()
+        self._otel_config: OpenTelemetryConfig | None = None
+        self._tracer_provider: TracerProvider | None = None
+        self._meter_provider: MeterProvider | None = None
+
+    def _build(self) -> Self:
+        """Build the OpenTelemetry plugin."""
+        assert self._application is not None
+        # Build the OpenTelemetry Resources, TracerProvider and MeterProvider
+        try:
+            otel_builder: OpenTelemetryPluginBuilder = OpenTelemetryPluginBuilder(
+                application=self._application
+            ).build_all()
+        except OpenTelemetryPluginBaseException as exception:
+            _logger.error(f"OpenTelemetry plugin failed to start. {exception}")
+            raise
+        # Configuration is never None at this point (checked in the builder and raises an exception)
+        self._otel_config = cast(OpenTelemetryConfig, otel_builder.config)
+        self._tracer_provider = otel_builder.tracer_provider
+        self._meter_provider = otel_builder.meter_provider
+        return self
+
+    def _instrument(self) -> None:
+        """Instrument the FastAPI application."""
+        assert self._application is not None
+        assert self._tracer_provider is not None
+        assert self._meter_provider is not None
+        assert self._otel_config is not None
+
+        for instrument in INSTRUMENTS:
+            instrument(self._application, self._otel_config, self._meter_provider, self._tracer_provider)
+
+    def on_load(self) -> None:
+        """On load."""
+        assert self._application is not None
+        # Build the OpenTelemetry Resources, TracerProvider and MeterProvider
+        self._build()
+        assert self._tracer_provider is not None
+        assert self._meter_provider is not None
+        assert self._otel_config is not None
+        self._add_to_state(key="tracer_provider", value=self._tracer_provider)
+        self._add_to_state(key="meter_provider", value=self._meter_provider)
+        self._add_to_state(key="otel_config", value=self._otel_config)
+        # Instrument the FastAPI application and AioHttpClient, ...
+        self._instrument()
+        _logger.debug(f"OpenTelemetry plugin loaded. {self._otel_config.activate=}")
+
+    async def on_startup(self) -> None:
+        """On startup."""
+        pass
+
+    async def close_tracer_provider(self) -> None:
+        """Close the tracer provider."""
+        assert self._tracer_provider is not None
+        assert self._otel_config is not None
+        self._tracer_provider.force_flush(
+            timeout_millis=self._otel_config.closing_timeout * self.SECONDS_TO_MS_MULTIPLIER
+        )
+        # No Delay for the shutdown of the tracer provider
+        try:
+            self._tracer_provider.shutdown()
+        except Exception as exception:  # pylint: disable=broad-exception-caught
+            _logger.error("OpenTelemetry plugin failed to close the tracer provider.", error=exception)
+
+    async def close_meter_provider(self) -> None:
+        """Close the meter provider."""
+        assert self._meter_provider is not None
+        assert self._otel_config is not None
+        self._meter_provider.force_flush(
+            timeout_millis=self._otel_config.closing_timeout * self.SECONDS_TO_MS_MULTIPLIER
+        )
+        try:
+            self._meter_provider.shutdown(
+                timeout_millis=self._otel_config.closing_timeout * self.SECONDS_TO_MS_MULTIPLIER
+            )
+        except Exception as exception:  # pylint: disable=broad-exception-caught
+            _logger.error("OpenTelemetry plugin failed to close the meter provider.", error=exception)
+
+    async def on_shutdown(self) -> None:
+        """On shutdown."""
+        _logger.debug("OpenTelemetry plugin stop requested. Flushing and closing...")
+
+        await asyncio.gather(
+            self.close_tracer_provider(),
+            self.close_meter_provider(),
+        )
+
+        _logger.debug("OpenTelemetry plugin closed.")
+
+
+def depends_tracer_provider(request: Request) -> TracerProvider:
+    """Get the tracer provider."""
+    return request.app.state.tracer_provider
+
+
+def depends_meter_provider(request: Request) -> MeterProvider:
+    """Get the meter provider."""
+    return request.app.state.meter_provider
+
+
+def depends_otel_config(request: Request) -> OpenTelemetryConfig:
+    """Get the OpenTelemetry config."""
+    return request.app.state.otel_config

fastapi_factory_utilities/core/plugins/taskiq_plugins/__init__.py

@@ -0,0 +1,29 @@
+"""Taskiq Plugin Module."""
+
+from importlib.util import find_spec
+
+from .depends import depends_scheduler_component
+from .exceptions import TaskiqPluginBaseError
+from .plugin import TaskiqPlugin
+from .schedulers import SchedulerComponent
+
+__all__: list[str] = [  # pylint: disable=invalid-name
+    "SchedulerComponent",
+    "TaskiqPlugin",
+    "TaskiqPluginBaseError",
+    "depends_scheduler_component",
+]
+
+if find_spec("beanie") is not None:
+    from .depends import depends_odm_database
+
+    __all__ += [  # pylint: disable=invalid-name
+        "depends_odm_database",
+    ]
+
+if find_spec("aio_pika") is not None:
+    from .depends import depends_aiopika_robust_connection
+
+    __all__ += [  # pylint: disable=invalid-name
+        "depends_aiopika_robust_connection",
+    ]

fastapi_factory_utilities/core/plugins/taskiq_plugins/configs.py

@@ -0,0 +1,12 @@
+"""Provides the configurations for the Taskiq plugin."""
+
+from typing import ClassVar
+
+from pydantic import BaseModel, ConfigDict
+
+
+class RedisCredentialsConfig(BaseModel):
+    """Redis credentials config."""
+
+    model_config: ClassVar[ConfigDict] = ConfigDict(frozen=True, extra="forbid")
+    url: str

fastapi_factory_utilities/core/plugins/taskiq_plugins/depends.py

@@ -0,0 +1,51 @@
+"""Provides the dependencies for the Taskiq plugin."""
+
+from importlib.util import find_spec
+from typing import TYPE_CHECKING, Any
+
+from fastapi import Request
+from taskiq import TaskiqDepends
+
+if TYPE_CHECKING:
+    from .schedulers import SchedulerComponent
+
+DEPENDS_SCHEDULER_COMPONENT_KEY: str = "scheduler_component"
+
+
+def depends_scheduler_component(
+    request: Request = TaskiqDepends(),
+) -> "SchedulerComponent":
+    """Dependency injection for the scheduler component."""
+    return getattr(request.app.state, DEPENDS_SCHEDULER_COMPONENT_KEY)
+
+
+if find_spec("beanie") is not None:
+    from motor.motor_asyncio import AsyncIOMotorDatabase
+
+    def depends_odm_database(request: Request = TaskiqDepends()) -> AsyncIOMotorDatabase[Any]:
+        """Acquire the ODM database from the request.
+
+        Args:
+            request (Request): The request.
+
+        Returns:
+            AsyncIOMotorClient: The ODM database.
+        """
+        return request.app.state.odm_database
+
+
+if find_spec("aio_pika") is not None:
+    from aio_pika.abc import AbstractRobustConnection
+
+    from fastapi_factory_utilities.core.plugins.aiopika.depends import DEPENDS_AIOPIKA_ROBUST_CONNECTION_KEY
+
+    def depends_aiopika_robust_connection(request: Request = TaskiqDepends()) -> AbstractRobustConnection:
+        """Acquire the Aiopika robust connection from the request.
+
+        Args:
+            request (Request): The request.
+
+        Returns:
+            AbstractRobustConnection: The Aiopika robust connection.
+        """
+        return getattr(request.app.state, DEPENDS_AIOPIKA_ROBUST_CONNECTION_KEY)

fastapi_factory_utilities/core/plugins/taskiq_plugins/exceptions.py

@@ -0,0 +1,13 @@
+"""Provides the exceptions for the Taskiq plugin."""
+
+from typing import Any
+
+from fastapi_factory_utilities.core.exceptions import FastAPIFactoryUtilitiesError
+
+
+class TaskiqPluginBaseError(FastAPIFactoryUtilitiesError):
+    """Base class for all exceptions raised by the Taskiq plugin."""
+
+    def __init__(self, message: str, **kwargs: Any) -> None:
+        """Initialize the Taskiq plugin base exception."""
+        super().__init__(message, **kwargs)

fastapi_factory_utilities/core/plugins/taskiq_plugins/plugin.py

@@ -0,0 +1,41 @@
+"""Provides the Taskiq plugin."""
+
+from collections.abc import Callable
+
+from fastapi_factory_utilities.core.plugins.abstracts import PluginAbstract
+
+from .configs import RedisCredentialsConfig
+from .depends import DEPENDS_SCHEDULER_COMPONENT_KEY
+from .schedulers import SchedulerComponent
+
+
+class TaskiqPlugin(PluginAbstract):
+    """Taskiq plugin."""
+
+    def __init__(
+        self, redis_credentials_config: RedisCredentialsConfig, register_hook: Callable[[SchedulerComponent], None]
+    ) -> None:
+        """Initialize the Taskiq plugin."""
+        super().__init__()
+        self._redis_credentials_config: RedisCredentialsConfig = redis_credentials_config
+        self._register_hook: Callable[[SchedulerComponent], None] = register_hook
+        self._scheduler_component: SchedulerComponent = SchedulerComponent()
+
+    def on_load(self) -> None:
+        """On load."""
+        assert self._application is not None
+        self._scheduler_component.configure(
+            redis_connection_string=self._redis_credentials_config.url, app=self._application.get_asgi_app()
+        )
+        self._add_to_state(key=DEPENDS_SCHEDULER_COMPONENT_KEY, value=self._scheduler_component)
+        self._register_hook(self._scheduler_component)
+
+    async def on_startup(self) -> None:
+        """On startup."""
+        assert self._application is not None
+        await self._scheduler_component.startup(app=self._application.get_asgi_app())
+
+    async def on_shutdown(self) -> None:
+        """On shutdown."""
+        assert self._application is not None
+        await self._scheduler_component.shutdown()