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

mindsdb/interfaces/agents/mcp_client_agent.py

@@ -54,8 +54,8 @@ class MCPQueryTool(BaseTool):
             return f"Query executed successfully: {json.dumps(result.content)}"
 
         except Exception as e:
-            logger.error(f"Error executing MCP query: {str(e)}")
-            return f"Error executing query: {str(e)}"
+            logger.error("Error executing MCP query:")
+            return f"Error executing query: {e}"
 
     def _run(self, query: str) -> str:
         """Synchronous wrapper for async query function"""
@@ -112,8 +112,8 @@ class MCPLangchainAgent(LangchainAgent):
                 )
 
             except Exception as e:
-                logger.error(f"Failed to connect to MCP server: {str(e)}")
-                raise ConnectionError(f"Failed to connect to MCP server: {str(e)}")
+                logger.exception("Failed to connect to MCP server:")
+                raise ConnectionError(f"Failed to connect to MCP server: {e}") from e
 
     def _langchain_tools_from_skills(self, llm):
         """Override to add MCP query tool along with other tools"""
@@ -131,8 +131,8 @@ class MCPLangchainAgent(LangchainAgent):
             if self.session:
                 tools.append(MCPQueryTool(self.session))
                 logger.info("Added MCP query tool to agent tools")
-        except Exception as e:
-            logger.error(f"Failed to add MCP query tool: {str(e)}")
+        except Exception:
+            logger.exception("Failed to add MCP query tool:")
 
         return tools
 
@@ -144,8 +144,8 @@ class MCPLangchainAgent(LangchainAgent):
                 # Using the event loop directly instead of asyncio.run()
                 loop = asyncio.get_event_loop()
                 loop.run_until_complete(self.connect_to_mcp())
-        except Exception as e:
-            logger.error(f"Failed to connect to MCP server: {str(e)}")
+        except Exception:
+            logger.exception("Failed to connect to MCP server:")
 
         # Call parent implementation to get completion
         response = super().get_completion(messages, stream)
@@ -224,8 +224,8 @@ class LiteLLMAgentWrapper:
                     }
                 # Allow async context switch
                 await asyncio.sleep(0)
-        except Exception as e:
-            logger.error(f"Streaming error: {str(e)}")
+        except Exception:
+            logger.exception("Streaming error:")
             raise
 
     async def cleanup(self):

mindsdb/interfaces/agents/mindsdb_database_agent.py

@@ -3,11 +3,11 @@ Wrapper around MindsDB's executor and integration controller following the imple
 langchain.sql_database.SQLDatabase class to partly replicate its behavior.
 """
 
-import traceback
 from typing import Any, Iterable, List, Optional
 
-from mindsdb.utilities import log
 from langchain_community.utilities import SQLDatabase
+
+from mindsdb.utilities import log
 from mindsdb.interfaces.skills.sql_agent import SQLAgent
 
 logger = log.getLogger(__name__)
@@ -99,7 +99,7 @@ class MindsDBSQL(SQLDatabase):
             return self._sql_agent.query(command)
 
         except Exception as e:
-            logger.error(f"Error executing SQL command: {str(e)}\n{traceback.format_exc()}")
+            logger.exception("Error executing SQL command:")
             # If this is a knowledge base query, provide a more helpful error message
             if "knowledge_base" in command.lower() or any(
                 kb in command for kb in self._sql_agent.get_usable_knowledge_base_names()
@@ -115,8 +115,8 @@ class MindsDBSQL(SQLDatabase):
         """
         try:
             return self._sql_agent.get_usable_knowledge_base_names()
-        except Exception as e:
-            logger.error(f"Error getting usable knowledge base names: {str(e)}")
+        except Exception:
+            logger.exception("Error getting usable knowledge base names:")
             return []
 
     def check_knowledge_base_permission(self, name):

mindsdb/interfaces/agents/run_mcp_agent.py

@@ -37,8 +37,8 @@ async def run_conversation(agent_wrapper, messages: List[Dict[str, str]], stream
             # We still need to display the response to the user
             sys.stdout.write(f"{content}\n")
             sys.stdout.flush()
-    except Exception as e:
-        logger.error(f"Error during agent conversation: {str(e)}")
+    except Exception:
+        logger.exception("Error during agent conversation:")
 
 
 async def execute_direct_query(query):
@@ -48,11 +48,7 @@ async def execute_direct_query(query):
     # Set up MCP client to connect to the running server
     async with AsyncExitStack() as stack:
         # Connect to MCP server
-        server_params = StdioServerParameters(
-            command="python",
-            args=["-m", "mindsdb", "--api=mcp"],
-            env=None
-        )
+        server_params = StdioServerParameters(command="python", args=["-m", "mindsdb", "--api=mcp"], env=None)
 
         try:
             stdio_transport = await stack.enter_async_context(stdio_client(server_params))
@@ -80,9 +76,9 @@ async def execute_direct_query(query):
             # Execute query
             result = await session.call_tool("query", {"query": query})
             logger.info(f"Query result: {result.content}")
-        except Exception as e:
-            logger.error(f"Error executing query: {str(e)}")
-            logger.info("Make sure the MindsDB server is running with MCP enabled: python -m mindsdb --api=mysql,mcp,http")
+        except Exception:
+            logger.exception("Error executing query:")
+            logger.info("Make sure the MindsDB server is running with HTTP enabled: python -m mindsdb --api=http")
 
 
 async def main():
@@ -100,6 +96,7 @@ async def main():
     try:
         # Initialize database connection
         from mindsdb.interfaces.storage import db
+
         db.init()
 
         # Direct SQL execution mode (for testing MCP connection)
@@ -117,10 +114,7 @@ async def main():
         logger.info("Make sure MindsDB server is running with MCP enabled: python -m mindsdb --api=mysql,mcp,http")
 
         agent_wrapper = create_mcp_agent(
-            agent_name=args.agent,
-            project_name=args.project,
-            mcp_host=args.host,
-            mcp_port=args.port
+            agent_name=args.agent, project_name=args.project, mcp_host=args.host, mcp_port=args.port
         )
 
         # Run an example query if provided
@@ -173,7 +167,7 @@ async def main():
                             sys.stdout.write("Error: No active MCP session\n")
                             sys.stdout.flush()
                     except Exception as e:
-                        logger.error(f"SQL Error: {str(e)}")
+                        logger.exception("SQL Error:")
                         sys.stdout.write(f"SQL Error: {str(e)}\n")
                         sys.stdout.flush()
                     continue
@@ -184,17 +178,14 @@ async def main():
                 # Add assistant's response to the conversation history
                 if not args.stream:
                     response = await agent_wrapper.acompletion(messages)
-                    messages.append({
-                        "role": "assistant",
-                        "content": response["choices"][0]["message"]["content"]
-                    })
+                    messages.append({"role": "assistant", "content": response["choices"][0]["message"]["content"]})
 
         # Clean up resources
         logger.info("Cleaning up resources")
         await agent_wrapper.cleanup()
 
-    except Exception as e:
-        logger.error(f"Error running MCP agent: {str(e)}")
+    except Exception:
+        logger.exception("Error running MCP agent:")
         logger.info("Make sure the MindsDB server is running with MCP enabled: python -m mindsdb --api=mysql,mcp,http")
         return 1
 

mindsdb/interfaces/chatbot/chatbot_task.py

@@ -21,7 +21,6 @@ HOLDING_MESSAGE = "Bot is typing..."
 
 
 class ChatBotTask(BaseTask):
-
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
         self.bot_id = self.object_id
@@ -40,7 +39,7 @@ class ChatBotTask(BaseTask):
         self.agent_id = bot_record.agent_id
         if self.agent_id is not None:
             self.bot_executor_cls = AgentExecutor
-        elif self.bot_params.get('modes') is None:
+        elif self.bot_params.get("modes") is None:
             self.bot_executor_cls = BotExecutor
         else:
             self.bot_executor_cls = MultiModeBotExecutor
@@ -52,36 +51,35 @@ class ChatBotTask(BaseTask):
             raise Exception(f"Can't use chat database: {database_name}")
 
         chat_params = self.chat_handler.get_chat_config()
-        polling = chat_params['polling']['type']
+        polling = chat_params["polling"]["type"]
 
-        memory = chat_params['memory']['type'] if 'memory' in chat_params else None
+        memory = chat_params["memory"]["type"] if "memory" in chat_params else None
         memory_cls = None
         if memory:
-            memory_cls = DBMemory if memory == 'db' else HandlerMemory
+            memory_cls = DBMemory if memory == "db" else HandlerMemory
 
-        if polling == 'message_count':
-            chat_params = chat_params['tables'] if 'tables' in chat_params else [chat_params]
+        if polling == "message_count":
+            chat_params = chat_params["tables"] if "tables" in chat_params else [chat_params]
             self.chat_pooling = MessageCountPolling(self, chat_params)
             # The default type for message count polling is HandlerMemory if not specified.
             self.memory = HandlerMemory(self, chat_params) if memory_cls is None else memory_cls(self, chat_params)
 
-        elif polling == 'realtime':
-            chat_params = chat_params['tables'] if 'tables' in chat_params else [chat_params]
+        elif polling == "realtime":
+            chat_params = chat_params["tables"] if "tables" in chat_params else [chat_params]
             self.chat_pooling = RealtimePolling(self, chat_params)
             # The default type for real-time polling is DBMemory if not specified.
             self.memory = DBMemory(self, chat_params) if memory_cls is None else memory_cls(self, chat_params)
 
-        elif polling == 'webhook':
+        elif polling == "webhook":
             self.chat_pooling = WebhookPolling(self, chat_params)
             self.memory = DBMemory(self, chat_params)
 
         else:
             raise Exception(f"Not supported polling: {polling}")
 
-        self.bot_params['bot_username'] = self.chat_handler.get_my_user_name()
+        self.bot_params["bot_username"] = self.chat_handler.get_my_user_name()
 
     def run(self, stop_event):
-
         # TODO check deleted, raise errors
         # TODO checks on delete predictor / project/ integration
 
@@ -89,7 +87,7 @@ class ChatBotTask(BaseTask):
 
     def on_message(self, message: ChatBotMessage, chat_id=None, chat_memory=None, table_name=None):
         if not chat_id and not chat_memory:
-            raise Exception('chat_id or chat_memory should be provided')
+            raise Exception("chat_id or chat_memory should be provided")
 
         try:
             self._on_holding_message(chat_id, chat_memory, table_name)
@@ -97,9 +95,8 @@ class ChatBotTask(BaseTask):
         except (SystemExit, KeyboardInterrupt):
             raise
         except Exception:
-            error = traceback.format_exc()
-            logger.error(error)
-            self.set_error(str(error))
+            logger.exception("Error during chatbot message processing:")
+            self.set_error(traceback.format_exc())
 
     def _on_holding_message(self, chat_id: str = None, chat_memory: BaseMemory = None, table_name: str = None):
         """
@@ -117,14 +114,14 @@ class ChatBotTask(BaseTask):
             ChatBotMessage.Type.DIRECT,
             HOLDING_MESSAGE,
             # In Slack direct messages are treated as channels themselves.
-            user=self.bot_params['bot_username'],
+            user=self.bot_params["bot_username"],
             destination=chat_id,
-            sent_at=dt.datetime.now()
+            sent_at=dt.datetime.now(),
         )
 
         # send to chat adapter
         self.chat_pooling.send_message(response_message, table_name=table_name)
-        logger.debug(f'>>chatbot {chat_id} out (holding message): {response_message.text}')
+        logger.debug(f">>chatbot {chat_id} out (holding message): {response_message.text}")
 
     def _on_message(self, message: ChatBotMessage, chat_id, chat_memory, table_name=None):
         # add question to history
@@ -132,26 +129,26 @@ class ChatBotTask(BaseTask):
         chat_memory = chat_memory if chat_memory else self.memory.get_chat(chat_id, table_name=table_name)
         chat_memory.add_to_history(message)
 
-        logger.debug(f'>>chatbot {chat_memory.chat_id} in: {message.text}')
+        logger.debug(f">>chatbot {chat_memory.chat_id} in: {message.text}")
 
         # process
         bot_executor = self.bot_executor_cls(self, chat_memory)
         response_text = bot_executor.process()
 
         chat_id = chat_memory.chat_id
-        bot_username = self.bot_params['bot_username']
+        bot_username = self.bot_params["bot_username"]
         response_message = ChatBotMessage(
             ChatBotMessage.Type.DIRECT,
             response_text,
             # In Slack direct messages are treated as channels themselves.
             user=bot_username,
             destination=chat_id,
-            sent_at=dt.datetime.now()
+            sent_at=dt.datetime.now(),
         )
 
         # send to chat adapter
         self.chat_pooling.send_message(response_message, table_name=table_name)
-        logger.debug(f'>>chatbot {chat_id} out: {response_message.text}')
+        logger.debug(f">>chatbot {chat_id} out: {response_message.text}")
 
         # send to history
         chat_memory.add_to_history(response_message)

mindsdb/interfaces/chatbot/polling.py

@@ -24,10 +24,14 @@ class BasePolling:
         chat_id = message.destination if isinstance(message.destination, tuple) else (message.destination,)
         text = message.text
 
-        t_params = self.params["chat_table"] if table_name is None else next(
-            (t["chat_table"] for t in self.params if t["chat_table"]["name"] == table_name)
+        t_params = (
+            self.params["chat_table"]
+            if table_name is None
+            else next((t["chat_table"] for t in self.params if t["chat_table"]["name"] == table_name))
+        )
+        chat_id_cols = (
+            t_params["chat_id_col"] if isinstance(t_params["chat_id_col"], list) else [t_params["chat_id_col"]]
         )
-        chat_id_cols = t_params["chat_id_col"] if isinstance(t_params["chat_id_col"], list) else [t_params["chat_id_col"]]
 
         ast_query = Insert(
             table=Identifier(t_params["name"]),
@@ -60,20 +64,22 @@ class MessageCountPolling(BasePolling):
                                 chat_id,
                                 table_name=chat_params["chat_table"]["name"],
                             )
-                        except Exception as e:
-                            logger.error(f"Problem retrieving chat memory: {e}")
+                        except Exception:
+                            logger.exception("Problem retrieving chat memory:")
 
                         try:
                             message = self.get_last_message(chat_memory)
-                        except Exception as e:
-                            logger.error(f"Problem getting last message: {e}")
+                        except Exception:
+                            logger.exception("Problem getting last message:")
                             message = None
 
                         if message:
-                            self.chat_task.on_message(message, chat_memory=chat_memory, table_name=chat_params["chat_table"]["name"])
+                            self.chat_task.on_message(
+                                message, chat_memory=chat_memory, table_name=chat_params["chat_table"]["name"]
+                            )
 
-            except Exception as e:
-                logger.error(e)
+            except Exception:
+                logger.exception("Unexpected error")
 
             if stop_event.is_set():
                 return
@@ -84,8 +90,8 @@ class MessageCountPolling(BasePolling):
         # retrive from history
         try:
             history = chat_memory.get_history()
-        except Exception as e:
-            logger.error(f"Problem retrieving history: {e}")
+        except Exception:
+            logger.exception("Problem retrieving history:")
             history = []
         last_message = history[-1]
         if last_message.user == self.chat_task.bot_params["bot_username"]:
@@ -151,7 +157,11 @@ class RealtimePolling(BasePolling):
             # Identify the table relevant to this event based on the key.
             event_keys = list(key.keys())
             for param in self.params:
-                table_keys = [param["chat_table"]["chat_id_col"]] if isinstance(param["chat_table"]["chat_id_col"], str) else param["chat_table"]["chat_id_col"]
+                table_keys = (
+                    [param["chat_table"]["chat_id_col"]]
+                    if isinstance(param["chat_table"]["chat_id_col"], str)
+                    else param["chat_table"]["chat_id_col"]
+                )
 
                 if sorted(event_keys) == sorted(table_keys):
                     t_params = param["chat_table"]
@@ -162,7 +172,11 @@ class RealtimePolling(BasePolling):
             t_params = self.params[0]
 
         # Get the chat ID from the row based on the chat ID column(s).
-        chat_id = tuple(row[key] for key in t_params["chat_id_col"]) if isinstance(t_params["chat_id_col"], list) else row[t_params["chat_id_col"]]
+        chat_id = (
+            tuple(row[key] for key in t_params["chat_id_col"])
+            if isinstance(t_params["chat_id_col"], list)
+            else row[t_params["chat_id_col"]]
+        )
 
         message = ChatBotMessage(
             ChatBotMessage.Type.DIRECT,
@@ -179,10 +193,7 @@ class RealtimePolling(BasePolling):
         )
 
     def run(self, stop_event):
-        self.chat_task.chat_handler.subscribe(
-            stop_event,
-            self._callback
-        )
+        self.chat_task.chat_handler.subscribe(stop_event, self._callback)
 
     # def send_message(self, message: ChatBotMessage):
     #
@@ -193,6 +204,7 @@ class WebhookPolling(BasePolling):
     """
     Polling class for handling webhooks.
     """
+
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
 

mindsdb/interfaces/data_catalog/data_catalog_loader.py

@@ -109,8 +109,8 @@ class DataCatalogLoader(BaseDataCatalog):
 
             db.session.add_all(tables)
             db.session.commit()
-        except Exception as e:
-            self.logger.error(f"Failed to add tables: {e}")
+        except Exception:
+            self.logger.exception("Failed to add tables:")
             db.session.rollback()
             raise
         return tables
@@ -157,8 +157,8 @@ class DataCatalogLoader(BaseDataCatalog):
 
             db.session.add_all(columns)
             db.session.commit()
-        except Exception as e:
-            self.logger.error(f"Failed to add columns: {e}")
+        except Exception:
+            self.logger.exception("Failed to add columns:")
             db.session.rollback()
             raise
         return columns
@@ -223,8 +223,8 @@ class DataCatalogLoader(BaseDataCatalog):
 
             db.session.add_all(column_statistics)
             db.session.commit()
-        except Exception as e:
-            self.logger.error(f"Failed to add column statistics: {e}")
+        except Exception:
+            self.logger.exception("Failed to add column statistics:")
             db.session.rollback()
             raise
 
@@ -275,8 +275,8 @@ class DataCatalogLoader(BaseDataCatalog):
 
             db.session.add_all(primary_keys)
             db.session.commit()
-        except Exception as e:
-            self.logger.error(f"Failed to add primary keys: {e}")
+        except Exception:
+            self.logger.exception("Failed to add primary keys:")
             db.session.rollback()
             raise
 
@@ -344,8 +344,8 @@ class DataCatalogLoader(BaseDataCatalog):
 
             db.session.add_all(foreign_keys)
             db.session.commit()
-        except Exception as e:
-            self.logger.error(f"Failed to add foreign keys: {e}")
+        except Exception:
+            self.logger.exception("Failed to add foreign keys:")
             db.session.rollback()
             raise
 

mindsdb/interfaces/database/integrations.py

@@ -71,22 +71,33 @@ class HandlersCache:
     def set(self, handler: DatabaseHandler):
         """add (or replace) handler in cache
 
+        NOTE: If the handler is not thread-safe, then use a lock when making connection. Otherwise, make connection in
+        the same thread without using a lock to speed up parallel queries. (They don't need to wait for a connection in
+        another thread.)
+
         Args:
             handler (DatabaseHandler)
         """
+        thread_safe = getattr(handler, "thread_safe", False)
         with self._lock:
             try:
                 # If the handler is defined to be thread safe, set 0 as the last element of the key, otherwise set the thrad ID.
                 key = (
                     handler.name,
                     ctx.company_id,
-                    0 if getattr(handler, "thread_safe", False) else threading.get_native_id(),
+                    0 if thread_safe else threading.get_native_id(),
                 )
-                handler.connect()
                 self.handlers[key] = {"handler": handler, "expired_at": time.time() + self.ttl}
+                if thread_safe:
+                    handler.connect()
             except Exception:
                 pass
             self._start_clean()
+        try:
+            if not thread_safe:
+                handler.connect()
+        except Exception:
+            pass
 
     def get(self, name: str) -> Optional[DatabaseHandler]:
         """get handler from cache by name
@@ -866,6 +877,8 @@ class IntegrationController:
 
     def import_handler(self, handler_name: str, base_import: str = None):
         with self._import_lock:
+            time_before_import = time.perf_counter()
+            logger.debug(f"Importing handler '{handler_name}'")
             handler_meta = self.handlers_import_status[handler_name]
             handler_dir = handler_meta["path"]
 
@@ -877,9 +890,13 @@ class IntegrationController:
                 handler_module = importlib.import_module(f"{base_import}{handler_folder_name}")
                 self.handler_modules[handler_name] = handler_module
                 handler_meta = self._get_handler_meta(handler_name)
+                logger.debug(
+                    f"Handler '{handler_name}' imported successfully in {(time.perf_counter() - time_before_import):.3f} seconds"
+                )
             except Exception as e:
                 handler_meta["import"]["success"] = False
                 handler_meta["import"]["error_message"] = str(e)
+                logger.debug(f"Failed to import handler '{handler_name}': {e}")
 
             self.handlers_import_status[handler_meta["name"]] = handler_meta
             return handler_meta

mindsdb/interfaces/file/file_controller.py

@@ -107,8 +107,8 @@ class FileController:
             self.fs_store.put(store_file_path, base_dir=self.dir)
             db.session.commit()
 
-        except Exception as e:
-            logger.error(e)
+        except Exception:
+            logger.exception("An error occurred while saving the file:")
             if file_dir is not None:
                 shutil.rmtree(file_dir)
             raise
@@ -151,7 +151,7 @@ class FileController:
     def delete_file(self, name):
         file_record = db.session.query(db.File).filter_by(company_id=ctx.company_id, name=name).first()
         if file_record is None:
-            return None
+            raise FileNotFoundError(f"File '{name}' does not exists")
         file_id = file_record.id
         db.session.delete(file_record)
         db.session.commit()
@@ -161,7 +161,7 @@ class FileController:
     def get_file_path(self, name):
         file_record = db.session.query(db.File).filter_by(company_id=ctx.company_id, name=name).first()
         if file_record is None:
-            raise Exception(f"File '{name}' does not exists")
+            raise FileNotFoundError(f"File '{name}' does not exists")
         file_dir = f"file_{ctx.company_id}_{file_record.id}"
         self.fs_store.get(file_dir, base_dir=self.dir)
         return str(Path(self.dir).joinpath(file_dir).joinpath(Path(file_record.source_file_path).name))
@@ -176,7 +176,7 @@ class FileController:
         """
         file_record = db.session.query(db.File).filter_by(company_id=ctx.company_id, name=name).first()
         if file_record is None:
-            raise Exception(f"File '{name}' does not exists")
+            raise FileNotFoundError(f"File '{name}' does not exists")
 
         file_dir = f"file_{ctx.company_id}_{file_record.id}"
         self.fs_store.get(file_dir, base_dir=self.dir)
@@ -217,7 +217,7 @@ class FileController:
 
         file_record = db.session.query(db.File).filter_by(company_id=ctx.company_id, name=name).first()
         if file_record is None:
-            raise Exception(f"File '{name}' does not exists")
+            raise FileNotFoundError(f"File '{name}' does not exists")
 
         file_dir = f"file_{ctx.company_id}_{file_record.id}"
         self.fs_store.get(file_dir, base_dir=self.dir)

mindsdb/interfaces/functions/controller.py

@@ -140,7 +140,7 @@ class FunctionController(BYOMFunctionsController):
 
             llm = create_chat_model(chat_model_params)
         except Exception as e:
-            raise RuntimeError(f"Unable to use LLM function, check ENV variables: {e}")
+            raise RuntimeError(f"Unable to use LLM function, check ENV variables: {e}") from e
 
         def callback(question):
             resp = llm([HumanMessage(question)])

mindsdb/interfaces/functions/to_markdown.py

@@ -69,8 +69,8 @@ class ToMarkdown:
                 ext = os.path.splitext(parsed_url.path)[1]
                 if ext:
                     return ext
-            except requests.RequestException:
-                raise RuntimeError(f"Unable to retrieve file extension from URL: {file_path_or_url}")
+            except requests.RequestException as e:
+                raise RuntimeError(f"Unable to retrieve file extension from URL: {file_path_or_url}") from e
         else:
             return os.path.splitext(file_path_or_url)[1]
 

mindsdb/interfaces/jobs/jobs_controller.py

@@ -152,7 +152,7 @@ class JobsController:
 
                 parse_sql(sql)
             except ParsingException as e:
-                raise ParsingException(f"Unable to parse: {sql}: {e}")
+                raise ParsingException(f"Unable to parse: {sql}: {e}") from e
 
         if if_query is not None:
             for sql in split_sql(if_query):
@@ -162,7 +162,7 @@ class JobsController:
 
                     parse_sql(sql)
                 except ParsingException as e:
-                    raise ParsingException(f"Unable to parse: {sql}: {e}")
+                    raise ParsingException(f"Unable to parse: {sql}: {e}") from e
 
         # plan next run
         next_run_at = start_at
@@ -494,7 +494,7 @@ class JobsExecutor:
 
                     data = ret.data
                 except Exception as e:
-                    logger.error(e)
+                    logger.exception("Error to execute job`s condition query")
                     error = str(e)
                     break
 
@@ -518,7 +518,7 @@ class JobsExecutor:
                         error = ret.error_message
                         break
                 except Exception as e:
-                    logger.error(e)
+                    logger.exception("Error to execute job`s query")
                     error = str(e)
                     break
 
@@ -526,7 +526,7 @@ class JobsExecutor:
             self.update_task_schedule(record)
         except Exception as e:
             db.session.rollback()
-            logger.error(f"Error to update schedule: {e}")
+            logger.exception("Error to update schedule:")
             error += f"Error to update schedule: {e}"
 
             # stop scheduling