langflow-base-nightly 0.5.0.dev37__py3-none-any.whl → 0.5.0.dev38__py3-none-any.whl

langflow/services/database/utils.py

@@ -5,16 +5,17 @@ from dataclasses import dataclass
 from typing import TYPE_CHECKING
 
 from alembic.util.exc import CommandError
-from loguru import logger
 from sqlmodel import text
 from sqlmodel.ext.asyncio.session import AsyncSession
 
+from langflow.logging.logger import logger
+
 if TYPE_CHECKING:
     from langflow.services.database.service import DatabaseService
 
 
 async def initialize_database(*, fix_migration: bool = False) -> None:
-    logger.debug("Initializing database")
+    await logger.adebug("Initializing database")
     from langflow.services.deps import get_db_service
 
     database_service: DatabaseService = get_db_service()
@@ -28,7 +29,7 @@ async def initialize_database(*, fix_migration: bool = False) -> None:
         # we can ignore it
         if "already exists" not in str(exc):
             msg = "Error creating DB and tables"
-            logger.exception(msg)
+            await logger.aexception(msg)
             raise RuntimeError(msg) from exc
     try:
         await database_service.check_schema_health()
@@ -58,7 +59,7 @@ async def initialize_database(*, fix_migration: bool = False) -> None:
         if "already exists" not in str(exc):
             logger.exception(exc)
         raise
-    logger.debug("Database initialized")
+    await logger.adebug("Database initialized")
 
 
 @asynccontextmanager
@@ -67,7 +68,7 @@ async def session_getter(db_service: DatabaseService):
         session = AsyncSession(db_service.engine, expire_on_commit=False)
         yield session
     except Exception:
-        logger.exception("Session rollback because of exception")
+        await logger.aexception("Session rollback because of exception")
         await session.rollback()
         raise
     finally:

langflow/services/deps.py

@@ -3,8 +3,7 @@ from __future__ import annotations
 from contextlib import asynccontextmanager
 from typing import TYPE_CHECKING
 
-from loguru import logger
-
+from langflow.logging.logger import logger
 from langflow.services.schema import ServiceType
 
 if TYPE_CHECKING:
@@ -174,7 +173,7 @@ async def session_scope() -> AsyncGenerator[AsyncSession, None]:
             yield session
             await session.commit()
         except Exception:
-            logger.exception("An error occurred during the session scope.")
+            await logger.aexception("An error occurred during the session scope.")
             await session.rollback()
             raise
 

langflow/services/factory.py

@@ -3,8 +3,8 @@ import inspect
 from typing import TYPE_CHECKING, get_type_hints
 
 from cachetools import LRUCache, cached
-from loguru import logger
 
+from langflow.logging.logger import logger
 from langflow.services.schema import ServiceType
 
 if TYPE_CHECKING:

langflow/services/flow/flow_runner.py

@@ -4,18 +4,15 @@ from pathlib import Path
 from uuid import UUID, uuid4
 
 from aiofile import async_open
-from loguru import logger
 from sqlmodel import delete, select, text
 
 from langflow.api.utils import cascade_delete_flow
 from langflow.graph import Graph
 from langflow.graph.vertex.param_handler import ParameterHandler
 from langflow.load.utils import replace_tweaks_with_env
-from langflow.logging.logger import configure
+from langflow.logging.logger import configure, logger
 from langflow.processing.process import process_tweaks, run_graph
-from langflow.services.auth.utils import (
-    get_password_hash,
-)
+from langflow.services.auth.utils import get_password_hash
 from langflow.services.cache.service import AsyncBaseCacheService
 from langflow.services.database.models import Flow, User, Variable
 from langflow.services.database.utils import initialize_database
@@ -48,7 +45,6 @@ class LangflowRunnerExperimental:
         log_file: str | None = None,
         log_rotation: str | None = None,
         disable_logs: bool = False,
-        async_log_file: bool = True,
     ):
         self.should_initialize_db = should_initialize_db
         log_file_path = Path(log_file) if log_file else None
@@ -57,7 +53,6 @@ class LangflowRunnerExperimental:
             log_file=log_file_path,
             log_rotation=log_rotation,
             disable=disable_logs,
-            async_file=async_log_file,
         )
 
     async def run(
@@ -76,7 +71,7 @@ class LangflowRunnerExperimental:
         tweaks_values: dict | None = None,
     ):
         try:
-            logger.info(f"Start Handling {session_id=}")
+            await logger.ainfo(f"Start Handling {session_id=}")
             await self.init_db_if_needed()
             # Update settings with cache and components path
             await update_settings(cache=cache)
@@ -118,7 +113,7 @@ class LangflowRunnerExperimental:
             result = await self.run_graph(input_value, input_type, output_type, session_id, graph, stream=stream)
         finally:
             await self.clear_flow_state(flow_dict)
-        logger.info(f"Finish Handling {session_id=}")
+        await logger.ainfo(f"Finish Handling {session_id=}")
         return result
 
     async def prepare_flow_and_add_to_db(
@@ -242,10 +237,10 @@ class LangflowRunnerExperimental:
 
     async def init_db_if_needed(self):
         if not await self.database_exists_check() and self.should_initialize_db:
-            logger.info("Initializing database...")
+            await logger.ainfo("Initializing database...")
             await initialize_database(fix_migration=True)
             self.should_initialize_db = False
-            logger.info("Database initialized.")
+            await logger.ainfo("Database initialized.")
 
     @staticmethod
     async def database_exists_check():
@@ -254,7 +249,7 @@ class LangflowRunnerExperimental:
                 result = await session.exec(text("SELECT version_num FROM public.alembic_version"))
                 return result.first() is not None
             except Exception as e:  # noqa: BLE001
-                logger.debug(f"Database check failed: {e}")
+                await logger.adebug(f"Database check failed: {e}")
                 return False
 
     @staticmethod

langflow/services/job_queue/service.py

@@ -2,9 +2,8 @@ from __future__ import annotations
 
 import asyncio
 
-from loguru import logger
-
 from langflow.events.event_manager import EventManager
+from langflow.logging.logger import logger
 from langflow.services.base import Service
 
 
@@ -117,7 +116,7 @@ class JobQueueService(Service):
         # Clean up each registered job queue.
         for job_id in list(self._queues.keys()):
             await self.cleanup_job(job_id)
-        logger.debug("JobQueueService stopped: all job queues have been cleaned up.")
+        await logger.adebug("JobQueueService stopped: all job queues have been cleaned up.")
 
     async def teardown(self) -> None:
         await self.stop()
@@ -221,21 +220,21 @@ class JobQueueService(Service):
             job_id (str): Unique identifier for the job to be cleaned up.
         """
         if job_id not in self._queues:
-            logger.debug(f"No queue found for job_id {job_id} during cleanup.")
+            await logger.adebug(f"No queue found for job_id {job_id} during cleanup.")
             return
 
-        logger.debug(f"Commencing cleanup for job_id {job_id}")
+        await logger.adebug(f"Commencing cleanup for job_id {job_id}")
         main_queue, _event_manager, task, _ = self._queues[job_id]
 
         # Cancel the associated task if it is still running.
         if task and not task.done():
-            logger.debug(f"Cancelling active task for job_id {job_id}")
+            await logger.adebug(f"Cancelling active task for job_id {job_id}")
             task.cancel()
             await asyncio.wait([task])
             # Log any exceptions that occurred during the task's execution.
             if exc := task.exception():
-                logger.error(f"Error in task for job_id {job_id}: {exc}")
-            logger.debug(f"Task cancellation complete for job_id {job_id}")
+                await logger.aerror(f"Error in task for job_id {job_id}: {exc}")
+            await logger.adebug(f"Task cancellation complete for job_id {job_id}")
 
         # Clear the queue since we just cancelled the task or it has completed
         items_cleared = 0
@@ -246,10 +245,10 @@ class JobQueueService(Service):
             except asyncio.QueueEmpty:
                 break
 
-        logger.debug(f"Removed {items_cleared} items from queue for job_id {job_id}")
+        await logger.adebug(f"Removed {items_cleared} items from queue for job_id {job_id}")
         # Remove the job entry from the registry
         self._queues.pop(job_id, None)
-        logger.debug(f"Cleanup successful for job_id {job_id}: resources have been released.")
+        await logger.adebug(f"Cleanup successful for job_id {job_id}: resources have been released.")
 
     async def _periodic_cleanup(self) -> None:
         """Execute a periodic task that cleans up completed or cancelled job queues.
@@ -266,10 +265,10 @@ class JobQueueService(Service):
                 await asyncio.sleep(60)  # Sleep for 60 seconds before next cleanup attempt.
                 await self._cleanup_old_queues()
             except asyncio.CancelledError:
-                logger.debug("Periodic cleanup task received cancellation signal.")
+                await logger.adebug("Periodic cleanup task received cancellation signal.")
                 raise
             except Exception as exc:  # noqa: BLE001
-                logger.error(f"Exception encountered during periodic cleanup: {exc}")
+                await logger.aerror(f"Exception encountered during periodic cleanup: {exc}")
 
     async def _cleanup_old_queues(self) -> None:
         """Scan all registered job queues and clean up those with completed or failed tasks."""
@@ -278,7 +277,7 @@ class JobQueueService(Service):
         for job_id in list(self._queues.keys()):
             _, _, task, cleanup_time = self._queues[job_id]
             if task:
-                logger.debug(
+                await logger.adebug(
                     f"Queue {job_id} status - Done: {task.done()}, "
                     f"Cancelled: {task.cancelled()}, "
                     f"Has exception: {task.exception() is not None if task.done() else 'N/A'}"
@@ -294,10 +293,12 @@ class JobQueueService(Service):
                             self._queues[job_id][2],
                             current_time,
                         )
-                        logger.debug(f"Job queue for job_id {job_id} marked for cleanup - Task cancelled or failed")
+                        await logger.adebug(
+                            f"Job queue for job_id {job_id} marked for cleanup - Task cancelled or failed"
+                        )
                     elif current_time - cleanup_time >= self.CLEANUP_GRACE_PERIOD:
                         # Enough time has passed, perform the actual cleanup
-                        logger.debug(f"Cleaning up job_id {job_id} after grace period")
+                        await logger.adebug(f"Cleaning up job_id {job_id} after grace period")
                         await self.cleanup_job(job_id)
 
     def _create_default_event_manager(self, queue: asyncio.Queue) -> EventManager:

langflow/services/manager.py

@@ -4,8 +4,7 @@ import importlib
 import inspect
 from typing import TYPE_CHECKING
 
-from loguru import logger
-
+from langflow.logging.logger import logger
 from langflow.utils.concurrency import KeyedMemoryLockManager
 
 if TYPE_CHECKING:
@@ -92,11 +91,11 @@ class ServiceManager:
         for service in list(self.services.values()):
             if service is None:
                 continue
-            logger.debug(f"Teardown service {service.name}")
+            await logger.adebug(f"Teardown service {service.name}")
             try:
                 await service.teardown()
             except Exception as exc:  # noqa: BLE001
-                logger.exception(exc)
+                await logger.aexception(exc)
         self.services = {}
         self.factories = {}
 

langflow/services/settings/auth.py

@@ -2,11 +2,11 @@ import secrets
 from pathlib import Path
 from typing import Literal
 
-from loguru import logger
 from passlib.context import CryptContext
 from pydantic import Field, SecretStr, field_validator
 from pydantic_settings import BaseSettings, SettingsConfigDict
 
+from langflow.logging.logger import logger
 from langflow.services.settings.constants import DEFAULT_SUPERUSER, DEFAULT_SUPERUSER_PASSWORD
 from langflow.services.settings.utils import read_secret_from_file, write_secret_to_file
 

langflow/services/settings/base.py

@@ -9,17 +9,12 @@ from typing import Any, Literal
 import orjson
 import yaml
 from aiofile import async_open
-from loguru import logger
 from pydantic import Field, field_validator
 from pydantic.fields import FieldInfo
-from pydantic_settings import (
-    BaseSettings,
-    EnvSettingsSource,
-    PydanticBaseSettingsSource,
-    SettingsConfigDict,
-)
+from pydantic_settings import BaseSettings, EnvSettingsSource, PydanticBaseSettingsSource, SettingsConfigDict
 from typing_extensions import override
 
+from langflow.logging.logger import logger
 from langflow.serialization.constants import MAX_ITEMS_LENGTH, MAX_TEXT_LENGTH
 from langflow.services.settings.constants import VARIABLES_TO_GET_FROM_ENVIRONMENT
 from langflow.utils.util_strings import is_valid_database_url
@@ -549,6 +544,6 @@ async def load_settings_from_yaml(file_path: str) -> Settings:
             if key not in Settings.model_fields:
                 msg = f"Key {key} not found in settings"
                 raise KeyError(msg)
-            logger.debug(f"Loading {len(settings_dict[key])} {key} from {file_path}")
+            await logger.adebug(f"Loading {len(settings_dict[key])} {key} from {file_path}")
 
     return await asyncio.to_thread(Settings, **settings_dict)

langflow/services/settings/manager.py

@@ -3,8 +3,8 @@ from __future__ import annotations
 from pathlib import Path
 
 import yaml
-from loguru import logger
 
+from langflow.logging.logger import logger
 from langflow.services.base import Service
 from langflow.services.settings.auth import AuthSettings
 from langflow.services.settings.base import Settings

langflow/services/settings/utils.py

@@ -1,7 +1,7 @@
 import platform
 from pathlib import Path
 
-from loguru import logger
+from langflow.logging.logger import logger
 
 
 def set_secure_permissions(file_path: Path) -> None:

langflow/services/socket/__init__.py

@@ -1 +0,0 @@
-# noqa: A005

langflow/services/socket/service.py

@@ -1,8 +1,8 @@
 from typing import Any
 
 import socketio
-from loguru import logger
 
+from langflow.logging.logger import logger
 from langflow.services.base import Service
 from langflow.services.cache.base import AsyncBaseCacheService, CacheService
 from langflow.services.deps import get_chat_service
@@ -30,11 +30,11 @@ class SocketIOService(Service):
         await self.sio.emit("error", to=sid, data=error)
 
     async def connect(self, sid, environ) -> None:
-        logger.info(f"Socket connected: {sid}")
+        await logger.ainfo(f"Socket connected: {sid}")
         self.sessions[sid] = environ
 
     async def disconnect(self, sid) -> None:
-        logger.info(f"Socket disconnected: {sid}")
+        await logger.ainfo(f"Socket disconnected: {sid}")
         self.sessions.pop(sid, None)
 
     async def message(self, sid, data=None) -> None:

langflow/services/socket/utils.py

@@ -2,7 +2,6 @@ import time
 from collections.abc import Callable
 
 import socketio
-from loguru import logger
 from sqlmodel import select
 
 from langflow.api.utils import format_elapsed_time
@@ -11,6 +10,7 @@ from langflow.graph.graph.base import Graph
 from langflow.graph.graph.utils import layered_topological_sort
 from langflow.graph.utils import log_vertex_build
 from langflow.graph.vertex.base import Vertex
+from langflow.logging.logger import logger
 from langflow.services.database.models.flow.model import Flow
 from langflow.services.deps import get_session
 
@@ -44,7 +44,7 @@ async def get_vertices(sio, sid, flow_id, chat_service) -> None:
         await sio.emit("vertices_order", data=vertices, to=sid)
 
     except Exception as exc:  # noqa: BLE001
-        logger.opt(exception=True).debug("Error getting vertices")
+        logger.debug("Error getting vertices", exc_info=True)
         await sio.emit("error", data=str(exc), to=sid)
 
 
@@ -88,7 +88,7 @@ async def build_vertex(
                 timedelta=timedelta,
             )
         except Exception as exc:  # noqa: BLE001
-            logger.opt(exception=True).debug("Error building vertex")
+            logger.debug("Error building vertex", exc_info=True)
             params = str(exc)
             valid = False
             result_dict = ResultDataResponse(results={})
@@ -108,5 +108,5 @@ async def build_vertex(
         await sio.emit("vertex_build", data=response.model_dump(), to=sid)
 
     except Exception as exc:  # noqa: BLE001
-        logger.opt(exception=True).debug("Error building vertex")
+        logger.debug("Error building vertex", exc_info=True)
         await sio.emit("error", data=str(exc), to=sid)

langflow/services/state/service.py

@@ -2,8 +2,7 @@ from collections import defaultdict
 from collections.abc import Callable
 from threading import Lock
 
-from loguru import logger
-
+from langflow.logging.logger import logger
 from langflow.services.base import Service
 from langflow.services.settings.service import SettingsService
 

langflow/services/storage/factory.py

@@ -1,6 +1,6 @@
-from loguru import logger
 from typing_extensions import override
 
+from langflow.logging.logger import logger
 from langflow.services.factory import ServiceFactory
 from langflow.services.session.service import SessionService
 from langflow.services.settings.service import SettingsService

langflow/services/storage/local.py

@@ -1,6 +1,7 @@
 import anyio
 from aiofile import async_open
-from loguru import logger
+
+from langflow.logging.logger import logger
 
 from .service import StorageService
 
@@ -37,7 +38,7 @@ class LocalStorageService(StorageService):
         try:
             async with async_open(str(file_path), "wb") as f:
                 await f.write(data)
-            logger.info(f"File {file_name} saved successfully in flow {flow_id}.")
+            await logger.ainfo(f"File {file_name} saved successfully in flow {flow_id}.")
         except Exception:
             logger.exception(f"Error saving file {file_name} in flow {flow_id}")
             raise
@@ -57,7 +58,7 @@ class LocalStorageService(StorageService):
         """
         file_path = self.data_dir / flow_id / file_name
         if not await file_path.exists():
-            logger.warning(f"File {file_name} not found in flow {flow_id}.")
+            await logger.awarning(f"File {file_name} not found in flow {flow_id}.")
             msg = f"File {file_name} not found in flow {flow_id}"
             raise FileNotFoundError(msg)
 
@@ -83,7 +84,7 @@ class LocalStorageService(StorageService):
             flow_id = str(flow_id)
         folder_path = self.data_dir / flow_id
         if not await folder_path.exists() or not await folder_path.is_dir():
-            logger.warning(f"Flow {flow_id} directory does not exist.")
+            await logger.awarning(f"Flow {flow_id} directory does not exist.")
             msg = f"Flow {flow_id} directory does not exist."
             raise FileNotFoundError(msg)
 
@@ -93,7 +94,7 @@ class LocalStorageService(StorageService):
             if await anyio.Path(file).is_file()
         ]
 
-        logger.info(f"Listed {len(files)} files in flow {flow_id}.")
+        await logger.ainfo(f"Listed {len(files)} files in flow {flow_id}.")
         return files
 
     async def delete_file(self, flow_id: str, file_name: str) -> None:
@@ -105,9 +106,9 @@ class LocalStorageService(StorageService):
         file_path = self.data_dir / flow_id / file_name
         if await file_path.exists():
             await file_path.unlink()
-            logger.info(f"File {file_name} deleted successfully from flow {flow_id}.")
+            await logger.ainfo(f"File {file_name} deleted successfully from flow {flow_id}.")
         else:
-            logger.warning(f"Attempted to delete non-existent file {file_name} in flow {flow_id}.")
+            await logger.awarning(f"Attempted to delete non-existent file {file_name} in flow {flow_id}.")
 
     async def teardown(self) -> None:
         """Perform any cleanup operations when the service is being torn down."""
@@ -118,7 +119,7 @@ class LocalStorageService(StorageService):
         # Get the file size from the file path
         file_path = self.data_dir / flow_id / file_name
         if not await file_path.exists():
-            logger.warning(f"File {file_name} not found in flow {flow_id}.")
+            await logger.awarning(f"File {file_name} not found in flow {flow_id}.")
             msg = f"File {file_name} not found in flow {flow_id}"
             raise FileNotFoundError(msg)
 

langflow/services/storage/s3.py

@@ -1,6 +1,7 @@
 import boto3
 from botocore.exceptions import ClientError, NoCredentialsError
-from loguru import logger
+
+from langflow.logging.logger import logger
 
 from .service import StorageService
 
@@ -28,12 +29,12 @@ class S3StorageService(StorageService):
         """
         try:
             self.s3_client.put_object(Bucket=self.bucket, Key=f"{folder}/{file_name}", Body=data)
-            logger.info(f"File {file_name} saved successfully in folder {folder}.")
+            await logger.ainfo(f"File {file_name} saved successfully in folder {folder}.")
         except NoCredentialsError:
-            logger.exception("Credentials not available for AWS S3.")
+            await logger.aexception("Credentials not available for AWS S3.")
             raise
         except ClientError:
-            logger.exception(f"Error saving file {file_name} in folder {folder}")
+            await logger.aexception(f"Error saving file {file_name} in folder {folder}")
             raise
 
     async def get_file(self, folder: str, file_name: str):
@@ -51,10 +52,10 @@ class S3StorageService(StorageService):
         """
         try:
             response = self.s3_client.get_object(Bucket=self.bucket, Key=f"{folder}/{file_name}")
-            logger.info(f"File {file_name} retrieved successfully from folder {folder}.")
+            await logger.ainfo(f"File {file_name} retrieved successfully from folder {folder}.")
             return response["Body"].read()
         except ClientError:
-            logger.exception(f"Error retrieving file {file_name} from folder {folder}")
+            await logger.aexception(f"Error retrieving file {file_name} from folder {folder}")
             raise
 
     async def list_files(self, folder: str):
@@ -72,11 +73,11 @@ class S3StorageService(StorageService):
         try:
             response = self.s3_client.list_objects_v2(Bucket=self.bucket, Prefix=folder)
         except ClientError:
-            logger.exception(f"Error listing files in folder {folder}")
+            await logger.aexception(f"Error listing files in folder {folder}")
             raise
 
         files = [item["Key"] for item in response.get("Contents", []) if "/" not in item["Key"][len(folder) :]]
-        logger.info(f"{len(files)} files listed in folder {folder}.")
+        await logger.ainfo(f"{len(files)} files listed in folder {folder}.")
         return files
 
     async def delete_file(self, folder: str, file_name: str) -> None:
@@ -91,9 +92,9 @@ class S3StorageService(StorageService):
         """
         try:
             self.s3_client.delete_object(Bucket=self.bucket, Key=f"{folder}/{file_name}")
-            logger.info(f"File {file_name} deleted successfully from folder {folder}.")
+            await logger.ainfo(f"File {file_name} deleted successfully from folder {folder}.")
         except ClientError:
-            logger.exception(f"Error deleting file {file_name} from folder {folder}")
+            await logger.aexception(f"Error deleting file {file_name} from folder {folder}")
             raise
 
     async def teardown(self) -> None:

langflow/services/store/service.py

@@ -6,8 +6,8 @@ from uuid import UUID
 
 import httpx
 from httpx import HTTPError, HTTPStatusError
-from loguru import logger
 
+from langflow.logging.logger import logger
 from langflow.services.base import Service
 from langflow.services.store.exceptions import APIKeyError, FilterError, ForbiddenError
 from langflow.services.store.schema import (
@@ -162,7 +162,7 @@ class StoreService(Service):
         except HTTPError:
             raise
         except Exception:  # noqa: BLE001
-            logger.opt(exception=True).debug("Webhook failed")
+            logger.debug("Webhook failed", exc_info=True)
 
     @staticmethod
     def build_tags_filter(tags: list[str]):
@@ -594,7 +594,7 @@ class StoreService(Service):
                         authorized = True
                         result = updated_result
                     except Exception:  # noqa: BLE001
-                        logger.opt(exception=True).debug("Error updating components with user data")
+                        logger.debug("Error updating components with user data", exc_info=True)
                         # If we get an error here, it means the user is not authorized
                         authorized = False
         return ListComponentResponseModel(results=result, authorized=authorized, count=comp_count)

langflow/services/store/utils.py

@@ -1,7 +1,8 @@
 from typing import TYPE_CHECKING
 
 import httpx
-from loguru import logger
+
+from langflow.logging.logger import logger
 
 if TYPE_CHECKING:
     from langflow.services.store.schema import ListComponentResponse
@@ -49,7 +50,7 @@ async def get_lf_version_from_pypi():
             return None
         return response.json()["info"]["version"]
     except Exception:  # noqa: BLE001
-        logger.opt(exception=True).debug("Error getting the latest version of langflow from PyPI")
+        logger.debug("Error getting the latest version of langflow from PyPI", exc_info=True)
         return None
 
 

langflow/services/task/temp_flow_cleanup.py

@@ -4,9 +4,9 @@ import asyncio
 import contextlib
 from typing import TYPE_CHECKING
 
-from loguru import logger
 from sqlmodel import col, delete, select
 
+from langflow.logging.logger import logger
 from langflow.services.database.models.message.model import MessageTable
 from langflow.services.database.models.transactions.model import TransactionTable
 from langflow.services.database.models.vertex_builds.model import VertexBuildTable
@@ -79,23 +79,23 @@ class CleanupWorker:
     async def start(self):
         """Start the cleanup worker."""
         if self._task is not None:
-            logger.warning("Cleanup worker is already running")
+            await logger.awarning("Cleanup worker is already running")
             return
 
         self._task = asyncio.create_task(self._run())
-        logger.debug("Started database cleanup worker")
+        await logger.adebug("Started database cleanup worker")
 
     async def stop(self):
         """Stop the cleanup worker gracefully."""
         if self._task is None:
-            logger.warning("Cleanup worker is not running")
+            await logger.awarning("Cleanup worker is not running")
             return
 
-        logger.debug("Stopping database cleanup worker...")
+        await logger.adebug("Stopping database cleanup worker...")
         self._stop_event.set()
         await self._task
         self._task = None
-        logger.debug("Database cleanup worker stopped")
+        await logger.adebug("Database cleanup worker stopped")
 
     async def _run(self):
         """Run the cleanup worker until stopped."""
@@ -105,7 +105,7 @@ class CleanupWorker:
                 # Clean up any orphaned records
                 await cleanup_orphaned_records()
             except Exception as exc:  # noqa: BLE001
-                logger.error(f"Error in cleanup worker: {exc!s}")
+                await logger.aerror(f"Error in cleanup worker: {exc!s}")
 
             try:
                 # Create a task for the timeout