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

langflow/main.py

@@ -17,7 +17,6 @@ from fastapi.middleware.cors import CORSMiddleware
 from fastapi.responses import FileResponse, JSONResponse
 from fastapi.staticfiles import StaticFiles
 from fastapi_pagination import add_pagination
-from loguru import logger
 from opentelemetry.instrumentation.fastapi import FastAPIInstrumentor
 from pydantic import PydanticDeprecatedSince20
 from pydantic_core import PydanticSerializationError
@@ -34,13 +33,9 @@ from langflow.initial_setup.setup import (
 )
 from langflow.interface.components import get_and_cache_all_types_dict
 from langflow.interface.utils import setup_llm_caching
-from langflow.logging.logger import configure
+from langflow.logging.logger import configure, logger
 from langflow.middleware import ContentSizeLimitMiddleware
-from langflow.services.deps import (
-    get_queue_service,
-    get_settings_service,
-    get_telemetry_service,
-)
+from langflow.services.deps import get_queue_service, get_settings_service, get_telemetry_service
 from langflow.services.utils import initialize_services, teardown_services
 
 if TYPE_CHECKING:
@@ -60,7 +55,7 @@ async def log_exception_to_telemetry(exc: Exception, context: str) -> None:
         telemetry_service = get_telemetry_service()
         await telemetry_service.log_exception(exc, context)
     except (httpx.HTTPError, asyncio.QueueFull):
-        logger.warning(f"Failed to log {context} exception to telemetry")
+        await logger.awarning(f"Failed to log {context} exception to telemetry")
 
 
 class RequestCancelledMiddleware(BaseHTTPMiddleware):
@@ -115,7 +110,7 @@ async def load_bundles_with_error_handling():
     try:
         return await load_bundles_from_urls()
     except (httpx.TimeoutException, httpx.HTTPError, httpx.RequestError) as exc:
-        logger.error(f"Error loading bundles from URLs: {exc}")
+        await logger.aerror(f"Error loading bundles from URLs: {exc}")
         return [], []
 
 
@@ -123,13 +118,13 @@ def get_lifespan(*, fix_migration=False, version=None):
     @asynccontextmanager
     async def lifespan(_app: FastAPI):
         telemetry_service = get_telemetry_service()
-        configure(async_file=True)
+        configure()
 
         # Startup message
         if version:
-            logger.debug(f"Starting Langflow v{version}...")
+            await logger.adebug(f"Starting Langflow v{version}...")
         else:
-            logger.debug("Starting Langflow...")
+            await logger.adebug("Starting Langflow...")
 
         temp_dirs: list[TemporaryDirectory] = []
         sync_flows_from_fs_task = None
@@ -137,37 +132,37 @@ def get_lifespan(*, fix_migration=False, version=None):
         try:
             start_time = asyncio.get_event_loop().time()
 
-            logger.debug("Initializing services")
+            await logger.adebug("Initializing services")
             await initialize_services(fix_migration=fix_migration)
-            logger.debug(f"Services initialized in {asyncio.get_event_loop().time() - start_time:.2f}s")
+            await logger.adebug(f"Services initialized in {asyncio.get_event_loop().time() - start_time:.2f}s")
 
             current_time = asyncio.get_event_loop().time()
-            logger.debug("Setting up LLM caching")
+            await logger.adebug("Setting up LLM caching")
             setup_llm_caching()
-            logger.debug(f"LLM caching setup in {asyncio.get_event_loop().time() - current_time:.2f}s")
+            await logger.adebug(f"LLM caching setup in {asyncio.get_event_loop().time() - current_time:.2f}s")
 
             current_time = asyncio.get_event_loop().time()
-            logger.debug("Initializing super user")
+            await logger.adebug("Initializing super user")
             await initialize_super_user_if_needed()
-            logger.debug(f"Super user initialized in {asyncio.get_event_loop().time() - current_time:.2f}s")
+            await logger.adebug(f"Super user initialized in {asyncio.get_event_loop().time() - current_time:.2f}s")
 
             current_time = asyncio.get_event_loop().time()
-            logger.debug("Loading bundles")
+            await logger.adebug("Loading bundles")
             temp_dirs, bundles_components_paths = await load_bundles_with_error_handling()
             get_settings_service().settings.components_path.extend(bundles_components_paths)
-            logger.debug(f"Bundles loaded in {asyncio.get_event_loop().time() - current_time:.2f}s")
+            await logger.adebug(f"Bundles loaded in {asyncio.get_event_loop().time() - current_time:.2f}s")
 
             current_time = asyncio.get_event_loop().time()
-            logger.debug("Caching types")
+            await logger.adebug("Caching types")
             all_types_dict = await get_and_cache_all_types_dict(get_settings_service())
-            logger.debug(f"Types cached in {asyncio.get_event_loop().time() - current_time:.2f}s")
+            await logger.adebug(f"Types cached in {asyncio.get_event_loop().time() - current_time:.2f}s")
 
             # Use file-based lock to prevent multiple workers from creating duplicate starter projects concurrently.
             # Note that it's still possible that one worker may complete this task, release the lock,
             # then another worker pick it up, but the operation is idempotent so worst case it duplicates
             # the initialization work.
             current_time = asyncio.get_event_loop().time()
-            logger.debug("Creating/updating starter projects")
+            await logger.adebug("Creating/updating starter projects")
             import tempfile
 
             from filelock import FileLock
@@ -177,42 +172,42 @@ def get_lifespan(*, fix_migration=False, version=None):
             try:
                 with lock:
                     await create_or_update_starter_projects(all_types_dict)
-                    logger.debug(
+                    await logger.adebug(
                         f"Starter projects created/updated in {asyncio.get_event_loop().time() - current_time:.2f}s"
                     )
             except TimeoutError:
                 # Another process has the lock
-                logger.debug("Another worker is creating starter projects, skipping")
+                await logger.adebug("Another worker is creating starter projects, skipping")
             except Exception as e:  # noqa: BLE001
-                logger.warning(
+                await logger.awarning(
                     f"Failed to acquire lock for starter projects: {e}. Starter projects may not be created or updated."
                 )
 
             current_time = asyncio.get_event_loop().time()
-            logger.debug("Starting telemetry service")
+            await logger.adebug("Starting telemetry service")
             telemetry_service.start()
-            logger.debug(f"started telemetry service in {asyncio.get_event_loop().time() - current_time:.2f}s")
+            await logger.adebug(f"started telemetry service in {asyncio.get_event_loop().time() - current_time:.2f}s")
 
             current_time = asyncio.get_event_loop().time()
-            logger.debug("Loading flows")
+            await logger.adebug("Loading flows")
             await load_flows_from_directory()
             sync_flows_from_fs_task = asyncio.create_task(sync_flows_from_fs())
             queue_service = get_queue_service()
             if not queue_service.is_started():  # Start if not already started
                 queue_service.start()
-            logger.debug(f"Flows loaded in {asyncio.get_event_loop().time() - current_time:.2f}s")
+            await logger.adebug(f"Flows loaded in {asyncio.get_event_loop().time() - current_time:.2f}s")
 
             current_time = asyncio.get_event_loop().time()
-            logger.debug("Loading mcp servers for projects")
+            await logger.adebug("Loading mcp servers for projects")
             await init_mcp_servers()
-            logger.debug(f"mcp servers loaded in {asyncio.get_event_loop().time() - current_time:.2f}s")
+            await logger.adebug(f"mcp servers loaded in {asyncio.get_event_loop().time() - current_time:.2f}s")
 
             total_time = asyncio.get_event_loop().time() - start_time
-            logger.debug(f"Total initialization time: {total_time:.2f}s")
+            await logger.adebug(f"Total initialization time: {total_time:.2f}s")
             yield
 
         except asyncio.CancelledError:
-            logger.debug("Lifespan received cancellation signal")
+            await logger.adebug("Lifespan received cancellation signal")
         except Exception as exc:
             if "langflow migration --fix" not in str(exc):
                 logger.exception(exc)
@@ -234,7 +229,7 @@ def get_lifespan(*, fix_migration=False, version=None):
             try:
                 # Step 0: Stopping Server
                 with shutdown_progress.step(0):
-                    logger.debug("Stopping server gracefully...")
+                    await logger.adebug("Stopping server gracefully...")
                     # The actual server stopping is handled by the lifespan context
                     await asyncio.sleep(0.1)  # Brief pause for visual effect
 
@@ -249,7 +244,7 @@ def get_lifespan(*, fix_migration=False, version=None):
                     try:
                         await asyncio.wait_for(teardown_services(), timeout=10)
                     except asyncio.TimeoutError:
-                        logger.warning("Teardown services timed out.")
+                        await logger.awarning("Teardown services timed out.")
 
                 # Step 3: Clearing Temporary Files
                 with shutdown_progress.step(3):
@@ -258,31 +253,21 @@ def get_lifespan(*, fix_migration=False, version=None):
 
                 # Step 4: Finalizing Shutdown
                 with shutdown_progress.step(4):
-                    logger.debug("Langflow shutdown complete")
+                    await logger.adebug("Langflow shutdown complete")
 
                 # Show completion summary and farewell
                 shutdown_progress.print_shutdown_summary()
 
             except (sqlalchemy.exc.OperationalError, sqlalchemy.exc.DBAPIError) as e:
                 # Case where the database connection is closed during shutdown
-                logger.warning(f"Database teardown failed due to closed connection: {e}")
-                await log_exception_to_telemetry(e, "lifespan_database_teardown")
+                await logger.awarning(f"Database teardown failed due to closed connection: {e}")
             except asyncio.CancelledError:
                 # Swallow this - it's normal during shutdown
-                logger.debug("Teardown cancelled during shutdown.")
-                raise
+                await logger.adebug("Teardown cancelled during shutdown.")
             except Exception as e:  # noqa: BLE001
-                logger.exception(f"Unhandled error during cleanup: {e}")
-
+                await logger.aexception(f"Unhandled error during cleanup: {e}")
                 await log_exception_to_telemetry(e, "lifespan_cleanup")
 
-            try:
-                await asyncio.shield(asyncio.sleep(0.1))  # let logger flush async logs
-                await asyncio.shield(logger.complete())
-            except asyncio.CancelledError:
-                # Cancellation during logger flush is possible during shutdown, so we swallow it
-                pass
-
     return lifespan
 
 
@@ -388,12 +373,12 @@ def create_app():
     @app.exception_handler(Exception)
     async def exception_handler(_request: Request, exc: Exception):
         if isinstance(exc, HTTPException):
-            logger.error(f"HTTPException: {exc}", exc_info=exc)
+            await logger.aerror(f"HTTPException: {exc}", exc_info=exc)
             return JSONResponse(
                 status_code=exc.status_code,
                 content={"message": str(exc.detail)},
             )
-        logger.error(f"unhandled error: {exc}", exc_info=exc)
+        await logger.aerror(f"unhandled error: {exc}", exc_info=exc)
 
         await log_exception_to_telemetry(exc, "handler")
 

langflow/memory.py

@@ -5,11 +5,11 @@ from uuid import UUID
 
 from langchain_core.chat_history import BaseChatMessageHistory
 from langchain_core.messages import BaseMessage
-from loguru import logger
 from sqlalchemy import delete
 from sqlmodel import col, select
 from sqlmodel.ext.asyncio.session import AsyncSession
 
+from langflow.logging.logger import logger
 from langflow.schema.message import Message
 from langflow.services.database.models.message.model import MessageRead, MessageTable
 from langflow.services.deps import session_scope
@@ -123,7 +123,7 @@ async def aadd_messages(messages: Message | list[Message], flow_id: str | UUID |
             messages_models = await aadd_messagetables(messages_models, session)
         return [await Message.create(**message.model_dump()) for message in messages_models]
     except Exception as e:
-        logger.exception(e)
+        await logger.aexception(e)
         raise
 
 
@@ -146,7 +146,7 @@ async def aupdate_messages(messages: Message | list[Message]) -> list[Message]:
                 updated_messages.append(msg)
             else:
                 error_message = f"Message with id {message.id} not found"
-                logger.warning(error_message)
+                await logger.awarning(error_message)
                 raise ValueError(error_message)
         return [MessageRead.model_validate(message, from_attributes=True) for message in updated_messages]
 
@@ -166,11 +166,11 @@ async def aadd_messagetables(messages: list[MessageTable], session: AsyncSession
         for message in messages:
             await session.refresh(message)
     except asyncio.CancelledError as e:
-        logger.exception(e)
+        await logger.aexception(e)
         error_msg = "Operation cancelled"
         raise ValueError(error_msg) from e
     except Exception as e:
-        logger.exception(e)
+        await logger.aexception(e)
         raise
 
     new_messages = []
@@ -262,7 +262,7 @@ async def astore_message(
         ValueError: If any of the required parameters (session_id, sender, sender_name) is not provided.
     """
     if not message:
-        logger.warning("No message provided.")
+        await logger.awarning("No message provided.")
         return []
 
     if not message.session_id or not message.sender or not message.sender_name:
@@ -277,7 +277,7 @@ async def astore_message(
         try:
             return await aupdate_messages([message])
         except ValueError as e:
-            logger.error(e)
+            await logger.aerror(e)
     if flow_id and not isinstance(flow_id, UUID):
         flow_id = UUID(flow_id)
     return await aadd_messages([message], flow_id=flow_id)

langflow/middleware.py

@@ -1,6 +1,6 @@
 from fastapi import HTTPException
-from loguru import logger
 
+from langflow.logging.logger import logger
 from langflow.services.deps import get_settings_service
 
 

langflow/processing/process.py

@@ -2,10 +2,10 @@ from __future__ import annotations
 
 from typing import TYPE_CHECKING, Any, cast
 
-from loguru import logger
 from pydantic import BaseModel
 
 from langflow.graph.vertex.base import Vertex
+from langflow.logging.logger import logger
 from langflow.processing.utils import validate_and_repair_json
 from langflow.schema.graph import InputValue, Tweaks
 from langflow.schema.schema import INPUT_FIELD_NAME
@@ -41,7 +41,7 @@ async def run_graph_internal(
     types = []
     for input_value_request in inputs:
         if input_value_request.input_value is None:
-            logger.warning("InputValueRequest input_value cannot be None, defaulting to an empty string.")
+            await logger.awarning("InputValueRequest input_value cannot be None, defaulting to an empty string.")
             input_value_request.input_value = ""
         components.append(input_value_request.components or [])
         inputs_list.append({INPUT_FIELD_NAME: input_value_request.input_value})
@@ -105,7 +105,7 @@ async def run_graph(
     types = []
     for input_value_request in inputs:
         if input_value_request.input_value is None:
-            logger.warning("InputValueRequest input_value cannot be None, defaulting to an empty string.")
+            await logger.awarning("InputValueRequest input_value cannot be None, defaulting to an empty string.")
             input_value_request.input_value = ""
         components.append(input_value_request.components or [])
         inputs_list.append({INPUT_FIELD_NAME: input_value_request.input_value})

langflow/schema/artifact.py

@@ -2,9 +2,9 @@ from collections.abc import Generator
 from enum import Enum
 
 from fastapi.encoders import jsonable_encoder
-from loguru import logger
 from pydantic import BaseModel
 
+from langflow.logging.logger import logger
 from langflow.schema.data import Data
 from langflow.schema.dataframe import DataFrame
 from langflow.schema.encoders import CUSTOM_ENCODERS
@@ -75,7 +75,7 @@ def post_process_raw(raw, artifact_type: str):
                 raw = jsonable_encoder(raw, custom_encoder=CUSTOM_ENCODERS)
                 artifact_type = ArtifactType.OBJECT.value
             except Exception:  # noqa: BLE001
-                logger.opt(exception=True).debug(f"Error converting to json: {raw} ({type(raw)})")
+                logger.debug(f"Error converting to json: {raw} ({type(raw)})", exc_info=True)
                 raw = default_message
         else:
             raw = default_message

langflow/schema/data.py

@@ -9,9 +9,9 @@ from uuid import UUID
 
 from langchain_core.documents import Document
 from langchain_core.messages import AIMessage, BaseMessage, HumanMessage
-from loguru import logger
 from pydantic import BaseModel, ConfigDict, model_serializer, model_validator
 
+from langflow.logging.logger import logger
 from langflow.utils.constants import MESSAGE_SENDER_AI, MESSAGE_SENDER_USER
 from langflow.utils.image import create_image_content_dict
 
@@ -234,7 +234,7 @@ class Data(BaseModel):
             data = {k: v.to_json() if hasattr(v, "to_json") else v for k, v in self.data.items()}
             return serialize_data(data)  # use the custom serializer
         except Exception:  # noqa: BLE001
-            logger.opt(exception=True).debug("Error converting Data to JSON")
+            logger.debug("Error converting Data to JSON", exc_info=True)
             return str(self.data)
 
     def __contains__(self, key) -> bool:
@@ -276,6 +276,14 @@ class Data(BaseModel):
             return DataFrame(data=next(iter(data_dict.values())))
         return DataFrame(data=[self])
 
+    def __repr__(self) -> str:
+        """Return string representation of the Data object."""
+        return f"Data(text_key={self.text_key!r}, data={self.data!r}, default_value={self.default_value!r})"
+
+    def __hash__(self) -> int:
+        """Return hash of the Data object based on its string representation."""
+        return hash(self.__repr__())
+
 
 def custom_serializer(obj):
     if isinstance(obj, datetime):

langflow/schema/dataframe.py

@@ -8,7 +8,7 @@ from langflow.schema.data import Data
 from langflow.schema.message import Message
 
 
-class DataFrame(pandas_DataFrame):
+class DataFrame(pandas_DataFrame):  # noqa: PLW1641
     """A pandas DataFrame subclass specialized for handling collections of Data objects.
 
     This class extends pandas.DataFrame to provide seamless integration between

langflow/schema/message.py

@@ -14,10 +14,10 @@ from langchain_core.load import load
 from langchain_core.messages import AIMessage, BaseMessage, HumanMessage, SystemMessage
 from langchain_core.prompts.chat import BaseChatPromptTemplate, ChatPromptTemplate
 from langchain_core.prompts.prompt import PromptTemplate
-from loguru import logger
 from pydantic import BaseModel, ConfigDict, Field, ValidationError, field_serializer, field_validator
 
 from langflow.base.prompts.utils import dict_values_to_string
+from langflow.logging.logger import logger
 from langflow.schema.content_block import ContentBlock
 from langflow.schema.content_types import ErrorContent
 from langflow.schema.data import Data

langflow/serialization/serialization.py

@@ -8,10 +8,10 @@ from uuid import UUID
 import numpy as np
 import pandas as pd
 from langchain_core.documents import Document
-from loguru import logger
 from pydantic import BaseModel
 from pydantic.v1 import BaseModel as BaseModelV1
 
+from langflow.logging.logger import logger
 from langflow.serialization.constants import MAX_ITEMS_LENGTH, MAX_TEXT_LENGTH
 from langflow.services.deps import get_settings_service
 

langflow/services/auth/utils.py

@@ -10,11 +10,11 @@ from cryptography.fernet import Fernet
 from fastapi import Depends, HTTPException, Security, WebSocketException, status
 from fastapi.security import APIKeyHeader, APIKeyQuery, OAuth2PasswordBearer
 from jose import JWTError, jwt
-from loguru import logger
 from sqlalchemy.exc import IntegrityError
 from sqlmodel.ext.asyncio.session import AsyncSession
 from starlette.websockets import WebSocket
 
+from langflow.logging.logger import logger
 from langflow.services.database.models.api_key.crud import check_key
 from langflow.services.database.models.user.crud import get_user_by_id, get_user_by_username, update_user_last_login_at
 from langflow.services.database.models.user.model import User, UserRead
@@ -310,7 +310,7 @@ async def create_super_user(
             if not super_user:
                 raise  # Re-raise if it's not a race condition
         except Exception:  # noqa: BLE001
-            logger.opt(exception=True).debug("Error creating superuser.")
+            logger.debug("Error creating superuser.", exc_info=True)
 
     return super_user
 

langflow/services/cache/disk.py

@@ -4,8 +4,8 @@ import time
 from typing import Generic
 
 from diskcache import Cache
-from loguru import logger
 
+from langflow.logging.logger import logger
 from langflow.services.cache.base import AsyncBaseCacheService, AsyncLockType
 from langflow.services.cache.utils import CACHE_MISS
 

langflow/services/cache/service.py

@@ -6,9 +6,9 @@ from collections import OrderedDict
 from typing import Generic, Union
 
 import dill
-from loguru import logger
 from typing_extensions import override
 
+from langflow.logging.logger import logger
 from langflow.services.cache.base import (
     AsyncBaseCacheService,
     AsyncLockType,
@@ -228,7 +228,7 @@ class RedisCache(ExternalAsyncBaseCacheService, Generic[LockType]):
             await self._client.ping()
         except redis.exceptions.ConnectionError:
             msg = "RedisCache could not connect to the Redis server"
-            logger.exception(msg)
+            await logger.aexception(msg)
             return False
         return True
 
@@ -309,7 +309,7 @@ class AsyncInMemoryCache(AsyncBaseCacheService, Generic[AsyncLockType]):
             if time.time() - item["time"] < self.expiration_time:
                 self.cache.move_to_end(key)
                 return pickle.loads(item["value"]) if isinstance(item["value"], bytes) else item["value"]
-            logger.info(f"Cache item for key '{key}' has expired and will be deleted.")
+            await logger.ainfo(f"Cache item for key '{key}' has expired and will be deleted.")
             await self._delete(key)  # Log before deleting the expired item
         return CACHE_MISS
 

langflow/services/database/models/flow/model.py

@@ -9,17 +9,12 @@ from uuid import UUID, uuid4
 import emoji
 from emoji import purely_emoji
 from fastapi import HTTPException, status
-from loguru import logger
-from pydantic import (
-    BaseModel,
-    ValidationInfo,
-    field_serializer,
-    field_validator,
-)
+from pydantic import BaseModel, ValidationInfo, field_serializer, field_validator
 from sqlalchemy import Enum as SQLEnum
 from sqlalchemy import Text, UniqueConstraint, text
 from sqlmodel import JSON, Column, Field, Relationship, SQLModel
 
+from langflow.logging.logger import logger
 from langflow.schema.data import Data
 
 if TYPE_CHECKING:

langflow/services/database/models/transactions/crud.py

@@ -1,9 +1,9 @@
 from uuid import UUID
 
-from loguru import logger
 from sqlmodel import col, delete, select
 from sqlmodel.ext.asyncio.session import AsyncSession
 
+from langflow.logging.logger import logger
 from langflow.services.database.models.transactions.model import (
     TransactionBase,
     TransactionReadResponse,
@@ -44,7 +44,7 @@ async def log_transaction(db: AsyncSession, transaction: TransactionBase) -> Tra
         IntegrityError: If there is a database integrity error
     """
     if not transaction.flow_id:
-        logger.debug("Transaction flow_id is None")
+        await logger.adebug("Transaction flow_id is None")
         return None
     table = TransactionTable(**transaction.model_dump())
 

langflow/services/database/models/user/crud.py

@@ -2,12 +2,12 @@ from datetime import datetime, timezone
 from uuid import UUID
 
 from fastapi import HTTPException, status
-from loguru import logger
 from sqlalchemy.exc import IntegrityError
 from sqlalchemy.orm.attributes import flag_modified
 from sqlmodel import select
 from sqlmodel.ext.asyncio.session import AsyncSession
 
+from langflow.logging.logger import logger
 from langflow.services.database.models.user.model import User, UserUpdate
 
 
@@ -59,7 +59,7 @@ async def update_user_last_login_at(user_id: UUID, db: AsyncSession):
         user = await get_user_by_id(db, user_id)
         return await update_user(user, user_data, db)
     except Exception as e:  # noqa: BLE001
-        logger.error(f"Error updating user last login at: {e!s}")
+        await logger.aerror(f"Error updating user last login at: {e!s}")
 
 
 async def get_all_superusers(db: AsyncSession) -> list[User]:

langflow/services/database/service.py

@@ -13,7 +13,6 @@ import anyio
 import sqlalchemy as sa
 from alembic import command, util
 from alembic.config import Config
-from loguru import logger
 from sqlalchemy import event, exc, inspect
 from sqlalchemy.dialects import sqlite as dialect_sqlite
 from sqlalchemy.engine import Engine
@@ -24,6 +23,7 @@ from sqlmodel.ext.asyncio.session import AsyncSession
 from tenacity import retry, stop_after_attempt, wait_fixed
 
 from langflow.initial_setup.constants import STARTER_FOLDER_NAME
+from langflow.logging.logger import logger
 from langflow.services.base import Service
 from langflow.services.database import models
 from langflow.services.database.models.user.crud import get_user_by_username
@@ -193,7 +193,7 @@ class DatabaseService(Service):
                 try:
                     yield session
                 except exc.SQLAlchemyError as db_exc:
-                    logger.error(f"Database error during session scope: {db_exc}")
+                    await logger.aerror(f"Database error during session scope: {db_exc}")
                     await session.rollback()
                     raise
 
@@ -219,7 +219,7 @@ class DatabaseService(Service):
             if not orphaned_flows:
                 return
 
-            logger.debug("Assigning orphaned flows to the default superuser")
+            await logger.adebug("Assigning orphaned flows to the default superuser")
 
             # Retrieve superuser
             superuser_username = settings_service.auth_settings.SUPERUSER
@@ -227,7 +227,7 @@ class DatabaseService(Service):
 
             if not superuser:
                 error_message = "Default superuser not found"
-                logger.error(error_message)
+                await logger.aerror(error_message)
                 raise RuntimeError(error_message)
 
             # Get existing flow names for the superuser
@@ -244,7 +244,7 @@ class DatabaseService(Service):
 
             # Commit changes
             await session.commit()
-            logger.debug("Successfully assigned orphaned flows to the default superuser")
+            await logger.adebug("Successfully assigned orphaned flows to the default superuser")
 
     @staticmethod
     def _generate_unique_flow_name(original_name: str, existing_names: set[str]) -> str:
@@ -372,7 +372,7 @@ class DatabaseService(Service):
             try:
                 await session.exec(text("SELECT * FROM alembic_version"))
             except Exception:  # noqa: BLE001
-                logger.debug("Alembic not initialized")
+                await logger.adebug("Alembic not initialized")
                 should_initialize_alembic = True
         await asyncio.to_thread(self._run_migrations, should_initialize_alembic, fix)
 
@@ -473,7 +473,7 @@ class DatabaseService(Service):
             await conn.run_sync(self._create_db_and_tables)
 
     async def teardown(self) -> None:
-        logger.debug("Tearing down database")
+        await logger.adebug("Tearing down database")
         try:
             settings_service = get_settings_service()
             # remove the default superuser if auto_login is enabled
@@ -481,5 +481,5 @@ class DatabaseService(Service):
             async with self.with_session() as session:
                 await teardown_superuser(settings_service, session)
         except Exception:  # noqa: BLE001
-            logger.exception("Error tearing down database")
+            await logger.aexception("Error tearing down database")
         await self.engine.dispose()