MindsDB 25.9.2.0a1__py3-none-any.whl → 25.10.0rc1__py3-none-any.whl

mindsdb/__about__.py

@@ -1,6 +1,6 @@
 __title__ = "MindsDB"
 __package_name__ = "mindsdb"
-__version__ = "25.9.2.0a1"
+__version__ = "25.10.0rc1"
 __description__ = "MindsDB's AI SQL Server enables developers to build AI tools that need access to real-time data to perform their tasks"
 __email__ = "jorge@mindsdb.com"
 __author__ = "MindsDB Inc"

mindsdb/__main__.py

@@ -8,8 +8,8 @@ import atexit
 import signal
 import psutil
 import asyncio
-import traceback
 import threading
+import shutil
 from enum import Enum
 from dataclasses import dataclass, field
 from typing import Callable, Optional, Tuple, List
@@ -27,7 +27,6 @@ from mindsdb.utilities.config import config
 from mindsdb.utilities.starters import (
     start_http,
     start_mysql,
-    start_postgres,
     start_ml_task_queue,
     start_scheduler,
     start_tasks,
@@ -39,6 +38,7 @@ from mindsdb.utilities.fs import clean_process_marks, clean_unlinked_process_mar
 from mindsdb.utilities.context import context as ctx
 from mindsdb.utilities.auth import register_oauth_client, get_aws_meta_data
 from mindsdb.utilities.sentry import sentry_sdk  # noqa: F401
+from mindsdb.utilities.api_status import set_api_status
 
 try:
     import torch.multiprocessing as mp
@@ -57,7 +57,6 @@ _stop_event = threading.Event()
 class TrunkProcessEnum(Enum):
     HTTP = "http"
     MYSQL = "mysql"
-    POSTGRES = "postgres"
     JOBS = "jobs"
     TASKS = "tasks"
     ML_TASK_QUEUE = "ml_task_queue"
@@ -152,6 +151,16 @@ def close_api_gracefully(trunc_processes_struct):
         sys.exit(0)
 
 
+def clean_mindsdb_tmp_dir():
+    """Clean the MindsDB tmp dir at exit."""
+    temp_dir = config["paths"]["tmp"]
+    for file in temp_dir.iterdir():
+        if file.is_dir():
+            shutil.rmtree(file)
+        else:
+            file.unlink()
+
+
 def set_error_model_status_by_pids(unexisting_pids: List[int]):
     """Models have id of its traiing process in the 'training_metadata' field.
     If the pid does not exist, we should set the model status to "error".
@@ -217,19 +226,20 @@ def create_permanent_integrations():
     """
     integration_name = "files"
     existing = db.session.query(db.Integration).filter_by(name=integration_name, company_id=None).first()
-    if existing is None:
-        integration_record = db.Integration(
-            name=integration_name,
-            data={},
-            engine=integration_name,
-            company_id=None,
-        )
-        db.session.add(integration_record)
-        try:
-            db.session.commit()
-        except Exception as e:
-            logger.error(f"Failed to commit permanent integration {integration_name}: {e}")
-            db.session.rollback()
+    if existing is not None:
+        return
+    integration_record = db.Integration(
+        name=integration_name,
+        data={},
+        engine=integration_name,
+        company_id=None,
+    )
+    db.session.add(integration_record)
+    try:
+        db.session.commit()
+    except Exception:
+        logger.exception(f"Failed to create permanent integration '{integration_name}' in the internal database.")
+        db.session.rollback()
 
 
 def validate_default_project() -> None:
@@ -289,7 +299,7 @@ def start_process(trunc_process_data: TrunkProcessData) -> None:
         )
         trunc_process_data.process.start()
     except Exception as e:
-        logger.error(f"Failed to start {trunc_process_data.name} API with exception {e}\n{traceback.format_exc()}")
+        logger.exception(f"Failed to start '{trunc_process_data.name}' API process due to unexpected error:")
         close_api_gracefully(trunc_processes_struct)
         raise e
 
@@ -363,8 +373,8 @@ if __name__ == "__main__":
     if environment == "aws_marketplace":
         try:
             register_oauth_client()
-        except Exception as e:
-            logger.error(f"Something went wrong during client register: {e}")
+        except Exception:
+            logger.exception("Something went wrong during client register:")
     elif environment != "local":
         try:
             aws_meta_data = get_aws_meta_data()
@@ -384,6 +394,7 @@ if __name__ == "__main__":
     logger.info(f"Version: {mindsdb_version}")
     logger.info(f"Configuration file: {config.config_path or 'absent'}")
     logger.info(f"Storage path: {config.paths['root']}")
+    log.log_system_info(logger)
     logger.debug(f"User config: {config.user_config}")
     logger.debug(f"System config: {config.auto_config}")
     logger.debug(f"Env config: {config.env_config}")
@@ -391,13 +402,12 @@ if __name__ == "__main__":
     is_cloud = config.is_cloud
     unexisting_pids = clean_unlinked_process_marks()
     if not is_cloud:
-        logger.debug("Applying database migrations")
         try:
             from mindsdb.migrations import migrate
 
             migrate.migrate_to_head()
-        except Exception as e:
-            logger.error(f"Error! Something went wrong during DB migrations: {e}")
+        except Exception:
+            logger.exception("Failed to apply database migrations. This may prevent MindsDB from operating correctly:")
 
         validate_default_project()
 
@@ -435,12 +445,6 @@ if __name__ == "__main__":
                 "max_restart_interval_seconds", TrunkProcessData.max_restart_interval_seconds
             ),
         ),
-        TrunkProcessEnum.POSTGRES: TrunkProcessData(
-            name=TrunkProcessEnum.POSTGRES.value,
-            entrypoint=start_postgres,
-            port=config["api"]["postgres"]["port"],
-            args=(config.cmd_args.verbose,),
-        ),
         TrunkProcessEnum.JOBS: TrunkProcessData(
             name=TrunkProcessEnum.JOBS.value, entrypoint=start_scheduler, args=(config.cmd_args.verbose,)
         ),
@@ -484,8 +488,12 @@ if __name__ == "__main__":
         if trunc_process_data.started is True or trunc_process_data.need_to_run is False:
             continue
         start_process(trunc_process_data)
+        # Set status for APIs without ports (they don't go through wait_api_start)
+        if trunc_process_data.port is None:
+            set_api_status(trunc_process_data.name, True)
 
     atexit.register(close_api_gracefully, trunc_processes_struct=trunc_processes_struct)
+    atexit.register(clean_mindsdb_tmp_dir)
 
     async def wait_api_start(api_name, pid, port):
         timeout = 60
@@ -494,6 +502,9 @@ if __name__ == "__main__":
         while (time.time() - start_time) < timeout and started is False:
             await asyncio.sleep(0.5)
             started = is_pid_listen_port(pid, port)
+
+        set_api_status(api_name, started)
+
         return api_name, port, started
 
     async def wait_apis_start():
@@ -531,7 +542,7 @@ if __name__ == "__main__":
                         trunc_process_data.process = None
                         if trunc_process_data.name == TrunkProcessEnum.HTTP.value:
                             # do not open GUI on HTTP API restart
-                            trunc_process_data.args = (config.cmd_args.verbose, True)
+                            trunc_process_data.args = (config.cmd_args.verbose, None, True)
                         start_process(trunc_process_data)
                         api_name, port, started = await wait_api_start(
                             trunc_process_data.name,

mindsdb/api/a2a/__init__.py

@@ -33,7 +33,7 @@ def get_a2a_app(
     agent_card = AgentCard(
         name="MindsDB Agent Connector",
         description=(f"A2A connector that proxies requests to MindsDB agents in project '{project_name}'."),
-        url=f"http://127.0.0.1:{mindsdb_port}",
+        url=f"http://127.0.0.1:{mindsdb_port}/a2a/",
         version="1.0.0",
         defaultInputModes=MindsDBAgent.SUPPORTED_CONTENT_TYPES,
         defaultOutputModes=MindsDBAgent.SUPPORTED_CONTENT_TYPES,

mindsdb/api/a2a/agent.py

@@ -24,7 +24,15 @@ class MindsDBAgent:
         self.agent_name = agent_name
         self.project_name = project_name
         port = config.get("api", {}).get("http", {}).get("port", 47334)
-        self.base_url = f"http://localhost:{port}"
+        host = config.get("api", {}).get("http", {}).get("host", "127.0.0.1")
+
+        # Use 127.0.0.1 instead of localhost for better compatibility
+        if host in ("0.0.0.0", ""):
+            url = f"http://127.0.0.1:{port}/"
+        else:
+            url = f"http://{host}:{port}/"
+
+        self.base_url = url
         self.agent_url = f"{self.base_url}/api/projects/{project_name}/agents/{agent_name}"
         self.sql_url = f"{self.base_url}/api/sql/query"
         self.headers = {k: v for k, v in user_info.items() if v is not None} or {}
@@ -73,17 +81,15 @@ class MindsDBAgent:
                     "parts": [{"type": "text", "text": error_msg}],
                 }
         except requests.exceptions.RequestException as e:
-            error_msg = f"Error connecting to MindsDB: {str(e)}"
-            logger.error(error_msg)
+            logger.exception("Error connecting to MindsDB:")
             return {
-                "content": error_msg,
+                "content": f"Error connecting to MindsDB: {e}",
                 "parts": [{"type": "text", "text": error_msg}],
             }
         except Exception as e:
-            error_msg = f"Error: {str(e)}"
-            logger.error(error_msg)
+            logger.exception("Error: ")
             return {
-                "content": error_msg,
+                "content": f"Error: {e}",
                 "parts": [{"type": "text", "text": error_msg}],
             }
 
@@ -102,7 +108,7 @@ class MindsDBAgent:
                         try:
                             yield json.loads(payload)
                         except Exception as e:
-                            logger.error(f"Failed to parse SSE JSON payload: {e}; line: {payload}")
+                            logger.exception(f"Failed to parse SSE JSON payload: {e}; line: {payload}")
                     # Ignore comments or control lines
                 # Signal the end of the stream
                 yield {"is_task_complete": True}
@@ -129,13 +135,13 @@ class MindsDBAgent:
                 wrapped_chunk = {"is_task_complete": False, "content": content_value, "metadata": {}}
                 yield wrapped_chunk
         except Exception as e:
-            logger.error(f"Error in streaming: {str(e)}")
+            logger.exception(f"Error in streaming: {e}")
             yield {
                 "is_task_complete": True,
                 "parts": [
                     {
                         "type": "text",
-                        "text": f"Error: {str(e)}",
+                        "text": f"Error: {e}",
                     }
                 ],
                 "metadata": {

mindsdb/api/a2a/common/server/server.py

@@ -22,6 +22,7 @@ from ...common.types import (
     AgentCard,
     TaskResubscriptionRequest,
     SendTaskStreamingRequest,
+    MessageStreamRequest,
 )
 from pydantic import ValidationError
 from ...common.server.task_manager import TaskManager
@@ -43,6 +44,7 @@ class A2AServer:
             routes=[
                 Route("/", self._process_request, methods=["POST"]),
                 Route("/.well-known/agent.json", self._get_agent_card, methods=["GET"]),
+                Route("/.well-known/agent-card.json", self._get_agent_card, methods=["GET"]),
                 Route("/status", self._get_status, methods=["GET"]),
             ]
         )
@@ -103,6 +105,8 @@ class A2AServer:
                 result = await self.task_manager.on_get_task_push_notification(json_rpc_request)
             elif isinstance(json_rpc_request, TaskResubscriptionRequest):
                 result = await self.task_manager.on_resubscribe_to_task(json_rpc_request)
+            elif isinstance(json_rpc_request, MessageStreamRequest):
+                result = await self.task_manager.on_message_stream(json_rpc_request, user_info)
             else:
                 logger.warning(f"Unexpected request type: {type(json_rpc_request)}")
                 raise ValueError(f"Unexpected request type: {type(request)}")
@@ -118,7 +122,7 @@ class A2AServer:
         elif isinstance(e, ValidationError):
             json_rpc_error = InvalidRequestError(data=json.loads(e.json()))
         else:
-            logger.error(f"Unhandled exception: {e}")
+            logger.exception("Unhandled exception:")
             json_rpc_error = InternalError()
 
         response = JSONRPCResponse(id=None, error=json_rpc_error)
@@ -137,8 +141,8 @@ class A2AServer:
                         else:
                             data = json.dumps(item)
                     except Exception as e:
-                        logger.error(f"Serialization error in SSE stream: {e}")
-                        data = json.dumps({"error": f"Serialization error: {str(e)}"})
+                        logger.exception("Serialization error in SSE stream:")
+                        data = json.dumps({"error": f"Serialization error: {e}"})
                     yield {"data": data}
 
             # Add robust SSE headers for compatibility

mindsdb/api/a2a/common/server/task_manager.py

@@ -1,7 +1,7 @@
 from abc import ABC, abstractmethod
 from typing import Union, AsyncIterable, List, Dict
-from ...common.types import Task
 from ...common.types import (
+    Task,
     JSONRPCResponse,
     TaskIdParams,
     TaskQueryParams,
@@ -29,6 +29,7 @@ from ...common.types import (
     JSONRPCError,
     TaskPushNotificationConfig,
     InternalError,
+    MessageStreamRequest,
 )
 from ...common.server.utils import new_not_implemented_error
 from mindsdb.utilities import log
@@ -74,6 +75,12 @@ class TaskManager(ABC):
     ) -> Union[AsyncIterable[SendTaskResponse], JSONRPCResponse]:
         pass
 
+    @abstractmethod
+    async def on_message_stream(
+        self, request: MessageStreamRequest, user_info: Dict
+    ) -> Union[AsyncIterable[SendTaskStreamingResponse], JSONRPCResponse]:
+        pass
+
 
 class InMemoryTaskManager(TaskManager):
     def __init__(self):
@@ -152,8 +159,8 @@ class InMemoryTaskManager(TaskManager):
                 task_notification_params.id,
                 task_notification_params.pushNotificationConfig,
             )
-        except Exception as e:
-            logger.error(f"Error while setting push notification info: {e}")
+        except Exception:
+            logger.exception("Error while setting push notification info:")
             return JSONRPCResponse(
                 id=request.id,
                 error=InternalError(message="An error occurred while setting push notification info"),
@@ -169,8 +176,8 @@ class InMemoryTaskManager(TaskManager):
 
         try:
             notification_info = await self.get_push_notification_info(task_params.id)
-        except Exception as e:
-            logger.error(f"Error while getting push notification info: {e}")
+        except Exception:
+            logger.exception("Error while getting push notification info:")
             return GetTaskPushNotificationResponse(
                 id=request.id,
                 error=InternalError(message="An error occurred while getting push notification info"),

mindsdb/api/a2a/common/types.py

@@ -59,6 +59,47 @@ class Message(BaseModel):
     parts: List[Part]
     metadata: dict[str, Any] | None = None
     history: Optional[List["Message"]] = None
+    messageId: str | None = None
+
+
+class FlexibleMessage(BaseModel):
+    """Message that can handle both 'type' and 'kind' in parts."""
+
+    role: Literal["user", "agent", "assistant"]
+    parts: List[dict[str, Any]]  # Raw parts that we'll process manually
+    metadata: dict[str, Any] | None = None
+    history: Optional[List["FlexibleMessage"]] = None
+
+    @model_validator(mode="after")
+    def normalize_parts(self):
+        """Convert parts with 'kind' to parts with 'type'."""
+        normalized_parts = []
+        for part in self.parts:
+            if isinstance(part, dict):
+                # Convert 'kind' to 'type' if needed
+                if "kind" in part and "type" not in part:
+                    normalized_part = part.copy()
+                    normalized_part["type"] = normalized_part.pop("kind")
+                else:
+                    normalized_part = part
+
+                # Validate the normalized part
+                try:
+                    if normalized_part.get("type") == "text":
+                        normalized_parts.append(TextPart.model_validate(normalized_part))
+                    elif normalized_part.get("type") == "file":
+                        normalized_parts.append(FilePart.model_validate(normalized_part))
+                    elif normalized_part.get("type") == "data":
+                        normalized_parts.append(DataPart.model_validate(normalized_part))
+                    else:
+                        raise ValueError(f"Unknown part type: {normalized_part.get('type')}")
+                except Exception as e:
+                    raise ValueError(f"Invalid part: {normalized_part}, error: {e}")
+            else:
+                normalized_parts.append(part)
+
+        self.parts = normalized_parts
+        return self
 
 
 class TaskStatus(BaseModel):
@@ -88,6 +129,7 @@ class Task(BaseModel):
     artifacts: List[Artifact] | None = None
     history: List[Message] | None = None
     metadata: dict[str, Any] | None = None
+    contextId: str | None = None
 
 
 class TaskStatusUpdateEvent(BaseModel):
@@ -95,12 +137,16 @@ class TaskStatusUpdateEvent(BaseModel):
     status: TaskStatus
     final: bool = False
     metadata: dict[str, Any] | None = None
+    contextId: str | None = None
+    taskId: str | None = None
 
 
 class TaskArtifactUpdateEvent(BaseModel):
     id: str
     artifact: Artifact
     metadata: dict[str, Any] | None = None
+    contextId: str | None = None
+    taskId: str | None = None
 
 
 class AuthenticationInfo(BaseModel):
@@ -182,6 +228,25 @@ class SendTaskStreamingResponse(JSONRPCResponse):
     result: TaskStatusUpdateEvent | TaskArtifactUpdateEvent | None = None
 
 
+class MessageStreamParams(BaseModel):
+    sessionId: str = Field(default_factory=lambda: uuid4().hex)
+    message: FlexibleMessage
+    metadata: dict[str, Any] | None = None
+
+
+class MessageStreamRequest(JSONRPCRequest):
+    method: Literal["message/stream"] = "message/stream"
+    params: MessageStreamParams
+
+
+class MessageStreamResponse(JSONRPCResponse):
+    result: Message | None = None
+
+
+class SendStreamingMessageSuccessResponse(JSONRPCResponse):
+    result: Union[Task, TaskStatusUpdateEvent, TaskArtifactUpdateEvent] | None = None
+
+
 class GetTaskRequest(JSONRPCRequest):
     method: Literal["tasks/get"] = "tasks/get"
     params: TaskQueryParams
@@ -233,6 +298,7 @@ A2ARequest = TypeAdapter(
             GetTaskPushNotificationRequest,
             TaskResubscriptionRequest,
             SendTaskStreamingRequest,
+            MessageStreamRequest,
         ],
         Field(discriminator="method"),
     ]

mindsdb/api/a2a/task_manager.py

@@ -1,4 +1,8 @@
-from typing import AsyncIterable, Dict
+import time
+import logging
+import asyncio
+from typing import AsyncIterable, Dict, Union
+
 from mindsdb.api.a2a.common.types import (
     SendTaskRequest,
     TaskSendParams,
@@ -15,16 +19,14 @@ from mindsdb.api.a2a.common.types import (
     SendTaskStreamingRequest,
     SendTaskStreamingResponse,
     InvalidRequestError,
+    MessageStreamRequest,
+    SendStreamingMessageSuccessResponse,
 )
 from mindsdb.api.a2a.common.server.task_manager import InMemoryTaskManager
 from mindsdb.api.a2a.agent import MindsDBAgent
 from mindsdb.api.a2a.utils import to_serializable, convert_a2a_message_to_qa_format
+from mindsdb.interfaces.agents.agents_controller import AgentsController
 
-from typing import Union
-import logging
-import asyncio
-import time
-import traceback
 
 logger = logging.getLogger(__name__)
 
@@ -80,11 +82,11 @@ class AgentTaskManager(InMemoryTaskManager):
             task = await self.upsert_task(task_send_params)
             logger.info(f"Task created/updated with history length: {len(task.history) if task.history else 0}")
         except Exception as e:
-            logger.error(f"Error creating task: {str(e)}")
+            logger.exception("Error creating task:")
             error_result = to_serializable(
                 {
                     "id": request.id,
-                    "error": to_serializable(InternalError(message=f"Error creating task: {str(e)}")),
+                    "error": to_serializable(InternalError(message=f"Error creating task: {e}")),
                 }
             )
             yield error_result
@@ -149,14 +151,14 @@ class AgentTaskManager(InMemoryTaskManager):
                 return
 
             except Exception as e:
-                logger.error(f"Error invoking agent: {e}")
+                logger.exception("Error invoking agent:")
                 error_result = to_serializable(
                     {
                         "id": request.id,
                         "error": to_serializable(
                             JSONRPCResponse(
                                 id=request.id,
-                                error=to_serializable(InternalError(message=f"Error invoking agent: {str(e)}")),
+                                error=to_serializable(InternalError(message=f"Error invoking agent: {e}")),
                             )
                         ),
                     }
@@ -182,11 +184,10 @@ class AgentTaskManager(InMemoryTaskManager):
                     item["artifact"]["parts"] = [to_serializable(p) for p in item["artifact"]["parts"]]
                 yield to_serializable(item)
         except Exception as e:
-            logger.error(f"An error occurred while streaming the response: {e}")
-            logger.error(traceback.format_exc())
-            error_text = f"An error occurred while streaming the response: {str(e)}"
+            error_text = "An error occurred while streaming the response:"
+            logger.exception(error_text)
             # Ensure all parts are plain dicts
-            parts = [{"type": "text", "text": error_text}]
+            parts = [{"type": "text", "text": f"{error_text} {e}"}]
             parts = [to_serializable(part) for part in parts]
             artifact = {
                 "parts": parts,
@@ -333,11 +334,11 @@ class AgentTaskManager(InMemoryTaskManager):
                 yield response
         except Exception as e:
             # If an error occurs, yield an error response
-            logger.error(f"Error in on_send_task_subscribe: {str(e)}")
+            logger.exception(f"Error in on_send_task_subscribe: {e}")
             error_result = to_serializable(
                 {
                     "id": request.id,
-                    "error": to_serializable(InternalError(message=f"Error processing streaming request: {str(e)}")),
+                    "error": to_serializable(InternalError(message=f"Error processing streaming request: {e}")),
                 }
             )
             yield error_result
@@ -463,7 +464,7 @@ class AgentTaskManager(InMemoryTaskManager):
                 )
                 return to_serializable(SendTaskResponse(id=request.id, result=task))
         except Exception as e:
-            logger.error(f"Error invoking agent: {e}")
+            logger.exception("Error invoking agent:")
             result_text = f"Error invoking agent: {e}"
             parts = [{"type": "text", "text": result_text}]
 
@@ -474,3 +475,50 @@ class AgentTaskManager(InMemoryTaskManager):
                 [Artifact(parts=parts)],
             )
             return to_serializable(SendTaskResponse(id=request.id, result=task))
+
+    async def on_message_stream(
+        self, request: MessageStreamRequest, user_info: Dict
+    ) -> Union[AsyncIterable[SendStreamingMessageSuccessResponse], JSONRPCResponse]:
+        """
+        Handle message streaming requests.
+        """
+        logger.info(f"Processing message stream request for session {request.params.sessionId}")
+
+        query = self._get_user_query(request.params)
+        params = self._get_task_params(request.params)
+
+        try:
+            task_id = f"msg_stream_{request.params.sessionId}_{request.id}"
+            context_id = f"ctx_{request.params.sessionId}"
+            message_id = f"msg_{request.id}"
+
+            agents_controller = AgentsController()
+            existing_agent = agents_controller.get_agent(params["agent_name"])
+            resp = agents_controller.get_completion(existing_agent, [{"question": query}])
+            response_message = resp["answer"][0]
+
+            response_message = Message(
+                role="agent", parts=[{"type": "text", "text": response_message}], metadata={}, messageId=message_id
+            )
+
+            task_status = TaskStatus(state=TaskState.COMPLETED, message=response_message)
+
+            task_status_update = TaskStatusUpdateEvent(
+                id=task_id,
+                status=task_status,
+                final=True,
+                metadata={"message_stream": True},
+                contextId=context_id,
+                taskId=task_id,
+            )
+
+            async def message_stream_generator():
+                yield to_serializable(SendStreamingMessageSuccessResponse(id=request.id, result=task_status_update))
+
+            return message_stream_generator()
+
+        except Exception as e:
+            logger.error(f"Error processing message stream: {e}")
+            return SendStreamingMessageSuccessResponse(
+                id=request.id, error=InternalError(message=f"Error processing message stream: {str(e)}")
+            )

mindsdb/api/common/middleware.py

@@ -1,13 +1,13 @@
+import os
+import hmac
+import secrets
+import hashlib
+from http import HTTPStatus
+from typing import Optional
+
 from starlette.middleware.base import BaseHTTPMiddleware
 from starlette.responses import JSONResponse
 from starlette.requests import Request
-from http import HTTPStatus
-from typing import Optional
-import secrets
-import hmac
-import hashlib
-import os
-import traceback
 
 from mindsdb.utilities import log
 from mindsdb.utilities.config import config
@@ -75,7 +75,7 @@ class PATAuthMiddleware(BaseHTTPMiddleware):
         return await call_next(request)
 
 
-# Used by mysql and postgres protocols
+# Used by mysql protocol
 def check_auth(username, password, scramble_func, salt, company_id, config):
     try:
         hardcoded_user = config["auth"].get("username")
@@ -100,7 +100,5 @@ def check_auth(username, password, scramble_func, salt, company_id, config):
 
         logger.info(f"Check auth, user={username}: Ok")
         return {"success": True, "username": username}
-    except Exception as e:
-        logger.error(f"Check auth, user={username}: ERROR")
-        logger.error(e)
-        logger.error(traceback.format_exc())
+    except Exception:
+        logger.exception(f"Check auth, user={username}: ERROR")