mypy+ruff fixes

Author: HardMax71

backend/scripts/create_topics.py

@@ -11,11 +11,11 @@
 from app.core.logging import setup_logger
 from app.infrastructure.kafka.topics import get_all_topics, get_topic_configs
 from app.settings import get_settings
-
-logger = setup_logger(os.environ.get("LOG_LEVEL", "INFO"))
 from confluent_kafka import KafkaException
 from confluent_kafka.admin import AdminClient, NewTopic
 
+logger = setup_logger(os.environ.get("LOG_LEVEL", "INFO"))
+
 
 async def create_topics() -> None:
     """Create all required Kafka topics"""

backend/workers/dlq_processor.py

@@ -3,13 +3,12 @@
 import signal
 from typing import Optional
 
-from app.core.database_context import Database, DBClient
+from app.core.database_context import DBClient
 from app.core.logging import setup_logger
 from app.dlq import DLQMessage, RetryPolicy, RetryStrategy
 from app.dlq.manager import DLQManager, create_dlq_manager
 from app.domain.enums.kafka import KafkaTopic
 from app.events.schema.schema_registry import create_schema_registry_manager
-from app.infrastructure.mappers.dlq_mapper import DLQMapper
 from app.settings import get_settings
 from pymongo.asynchronous.mongo_client import AsyncMongoClient
 
@@ -111,15 +110,13 @@ async def main() -> None:
         serverSelectionTimeoutMS=5000,
     )
     db_name = settings.DATABASE_NAME
-    database: Database = db_client[db_name]
+    _ = db_client[db_name]  # Access database to verify connection
     await db_client.admin.command("ping")
     logger.info(f"Connected to database: {db_name}")
 
     schema_registry = create_schema_registry_manager(logger)
-    dlq_mapper = DLQMapper(schema_registry)
     manager = create_dlq_manager(
-        database=database,
-        dlq_mapper=dlq_mapper,
+        schema_registry=schema_registry,
         logger=logger,
         dlq_topic=KafkaTopic.DEAD_LETTER_QUEUE,
         retry_topic_suffix="-retry",

backend/workers/run_coordinator.py

@@ -12,20 +12,21 @@
 
 def main() -> None:
     """Main entry point for coordinator worker"""
+    settings = get_settings()
+
     # Setup logging
-    setup_logger()
+    logger = setup_logger(settings.LOG_LEVEL)
 
     # Configure root logger for worker
     logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(name)s - %(levelname)s - %(message)s")
 
-    logger = logging.getLogger(__name__)
     logger.info("Starting ExecutionCoordinator worker...")
 
     # Initialize tracing
-    settings = get_settings()
     if settings.ENABLE_TRACING:
         init_tracing(
             service_name=GroupId.EXECUTION_COORDINATOR,
+            logger=logger,
             service_version=settings.TRACING_SERVICE_VERSION,
             enable_console_exporter=False,
             sampling_rate=settings.TRACING_SAMPLING_RATE,

backend/workers/run_event_replay.py

@@ -2,9 +2,6 @@
 import logging
 from contextlib import AsyncExitStack
 
-from beanie import init_beanie
-from pymongo.asynchronous.mongo_client import AsyncMongoClient
-
 from app.core.database_context import DBClient
 from app.core.logging import setup_logger
 from app.core.tracing import init_tracing
@@ -15,6 +12,8 @@
 from app.events.schema.schema_registry import SchemaRegistryManager
 from app.services.event_replay.replay_service import EventReplayService
 from app.settings import get_settings
+from beanie import init_beanie
+from pymongo.asynchronous.mongo_client import AsyncMongoClient
 
 
 async def cleanup_task(replay_service: EventReplayService, interval_hours: int = 6) -> None:
@@ -30,10 +29,8 @@ async def cleanup_task(replay_service: EventReplayService, interval_hours: int =
             logger.error(f"Error during cleanup: {e}")
 
 
-async def run_replay_service() -> None:
+async def run_replay_service(logger: logging.Logger) -> None:
     """Run the event replay service with cleanup task"""
-    logger = logging.getLogger(__name__)
-
     # Get settings
     settings = get_settings()
 
@@ -55,13 +52,15 @@ async def run_replay_service() -> None:
     producer = UnifiedProducer(producer_config, schema_registry, logger)
 
     # Create event store
-    event_store = create_event_store(db=database, schema_registry=schema_registry, logger=logger)
+    event_store = create_event_store(schema_registry=schema_registry, logger=logger)
 
     # Create repository
-    replay_repository = ReplayRepository(database, logger)
+    replay_repository = ReplayRepository(logger)
 
     # Create replay service
-    replay_service = EventReplayService(repository=replay_repository, producer=producer, event_store=event_store)
+    replay_service = EventReplayService(
+        repository=replay_repository, producer=producer, event_store=event_store, logger=logger
+    )
     logger.info("Event replay service initialized")
 
     async with AsyncExitStack() as stack:
@@ -84,27 +83,28 @@ async def _cancel_task() -> None:
 
 def main() -> None:
     """Main entry point for event replay service"""
+    settings = get_settings()
+
     # Setup logging
-    setup_logger()
+    logger = setup_logger(settings.LOG_LEVEL)
 
     # Configure root logger for worker
     logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(name)s - %(levelname)s - %(message)s")
 
-    logger = logging.getLogger(__name__)
     logger.info("Starting Event Replay Service...")
 
     # Initialize tracing
-    settings = get_settings()
     if settings.ENABLE_TRACING:
         init_tracing(
             service_name="event-replay",
+            logger=logger,
             service_version=settings.TRACING_SERVICE_VERSION,
             enable_console_exporter=False,
             sampling_rate=settings.TRACING_SAMPLING_RATE,
         )
         logger.info("Tracing initialized for Event Replay Service")
 
-    asyncio.run(run_replay_service())
+    asyncio.run(run_replay_service(logger))
 
 
 if __name__ == "__main__":

backend/workers/run_k8s_worker.py

@@ -12,20 +12,21 @@
 
 def main() -> None:
     """Main entry point for Kubernetes worker"""
+    settings = get_settings()
+
     # Setup logging
-    setup_logger()
+    logger = setup_logger(settings.LOG_LEVEL)
 
     # Configure root logger for worker
     logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(name)s - %(levelname)s - %(message)s")
 
-    logger = logging.getLogger(__name__)
     logger.info("Starting KubernetesWorker...")
 
     # Initialize tracing
-    settings = get_settings()
     if settings.ENABLE_TRACING:
         init_tracing(
             service_name=GroupId.K8S_WORKER,
+            logger=logger,
             service_version=settings.TRACING_SERVICE_VERSION,
             enable_console_exporter=False,
             sampling_rate=settings.TRACING_SAMPLING_RATE,

backend/workers/run_pod_monitor.py

@@ -12,20 +12,21 @@
 
 def main() -> None:
     """Main entry point for pod monitor worker"""
+    settings = get_settings()
+
     # Setup logging
-    setup_logger()
+    logger = setup_logger(settings.LOG_LEVEL)
 
     # Configure root logger for worker
     logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(name)s - %(levelname)s - %(message)s")
 
-    logger = logging.getLogger(__name__)
     logger.info("Starting PodMonitor worker...")
 
     # Initialize tracing
-    settings = get_settings()
     if settings.ENABLE_TRACING:
         init_tracing(
             service_name=GroupId.POD_MONITOR,
+            logger=logger,
             service_version=settings.TRACING_SERVICE_VERSION,
             enable_console_exporter=False,
             sampling_rate=settings.TRACING_SAMPLING_RATE,

backend/workers/run_result_processor.py

@@ -10,20 +10,21 @@
 
 def main() -> None:
     """Main entry point for result processor worker"""
+    settings = get_settings()
+
     # Setup logging
-    setup_logger()
+    logger = setup_logger(settings.LOG_LEVEL)
 
     # Configure root logger for worker
     logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(name)s - %(levelname)s - %(message)s")
 
-    logger = logging.getLogger(__name__)
     logger.info("Starting ResultProcessor worker...")
 
     # Initialize tracing
-    settings = get_settings()
     if settings.ENABLE_TRACING:
         init_tracing(
             service_name=GroupId.RESULT_PROCESSOR,
+            logger=logger,
             service_version=settings.TRACING_SERVICE_VERSION,
             enable_console_exporter=False,
             sampling_rate=settings.TRACING_SAMPLING_RATE,

backend/workers/run_saga_orchestrator.py

@@ -2,9 +2,6 @@
 import logging
 
 import redis.asyncio as redis
-from beanie import init_beanie
-from pymongo.asynchronous.mongo_client import AsyncMongoClient
-
 from app.core.database_context import DBClient
 from app.core.logging import setup_logger
 from app.core.tracing import init_tracing
@@ -20,6 +17,8 @@
 from app.services.idempotency.redis_repository import RedisIdempotencyRepository
 from app.services.saga import create_saga_orchestrator
 from app.settings import get_settings
+from beanie import init_beanie
+from pymongo.asynchronous.mongo_client import AsyncMongoClient
 
 
 async def run_saga_orchestrator() -> None:
@@ -53,10 +52,10 @@ async def run_saga_orchestrator() -> None:
 
     # Create event store (schema ensured separately)
     logger.info("Creating event store...")
-    event_store = create_event_store(db=database, schema_registry=schema_registry_manager, logger=logger, ttl_days=90)
+    event_store = create_event_store(schema_registry=schema_registry_manager, logger=logger, ttl_days=90)
 
     # Create repository and idempotency manager (Redis-backed)
-    saga_repository = SagaRepository(database)
+    saga_repository = SagaRepository()
     r = redis.Redis(
         host=settings.REDIS_HOST,
         port=settings.REDIS_PORT,
@@ -70,7 +69,7 @@ async def run_saga_orchestrator() -> None:
     )
     idem_repo = RedisIdempotencyRepository(r, key_prefix="idempotency")
     idempotency_manager = create_idempotency_manager(repository=idem_repo, config=IdempotencyConfig(), logger=logger)
-    resource_allocation_repository = ResourceAllocationRepository(database)
+    resource_allocation_repository = ResourceAllocationRepository()
 
     # Create saga orchestrator
     saga_config = SagaConfig(
@@ -119,20 +118,21 @@ async def run_saga_orchestrator() -> None:
 
 def main() -> None:
     """Main entry point for saga orchestrator worker"""
+    settings = get_settings()
+
     # Setup logging
-    setup_logger()
+    logger = setup_logger(settings.LOG_LEVEL)
 
     # Configure root logger for worker
     logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(name)s - %(levelname)s - %(message)s")
 
-    logger = logging.getLogger(__name__)
     logger.info("Starting Saga Orchestrator worker...")
 
     # Initialize tracing
-    settings = get_settings()
     if settings.ENABLE_TRACING:
         init_tracing(
             service_name=GroupId.SAGA_ORCHESTRATOR,
+            logger=logger,
             service_version=settings.TRACING_SERVICE_VERSION,
             enable_console_exporter=False,
             sampling_rate=settings.TRACING_SAMPLING_RATE,