MindsDB 25.2.1.2__py3-none-any.whl → 25.2.2.0__py3-none-any.whl

mindsdb/interfaces/agents/langfuse_callback_handler.py

@@ -1,6 +1,7 @@
 from typing import Any, Dict, Union, Optional, List
 from uuid import uuid4
 import datetime
+import json
 
 from langchain_core.callbacks.base import BaseCallbackHandler
 
@@ -21,6 +22,10 @@ class LangfuseCallbackHandler(BaseCallbackHandler):
         # if these are not available, we generate some UUIDs
         self.trace_id = trace_id or uuid4().hex
         self.observation_id = observation_id or uuid4().hex
+        # Track metrics about tools and chains
+        self.tool_metrics = {}
+        self.chain_metrics = {}
+        self.current_chain = None
 
     def on_tool_start(
             self, serialized: Dict[str, Any], input_str: str, **kwargs: Any
@@ -30,9 +35,28 @@ class LangfuseCallbackHandler(BaseCallbackHandler):
         action_span = self.action_uuid_to_span.get(parent_run_uuid)
         if action_span is None:
             return
+
+        tool_name = serialized.get("name", "tool")
+        start_time = datetime.datetime.now()
+
+        # Initialize or update tool metrics
+        if tool_name not in self.tool_metrics:
+            self.tool_metrics[tool_name] = {
+                'count': 0,
+                'total_time': 0,
+                'errors': 0,
+                'last_error': None,
+                'inputs': []
+            }
+
+        self.tool_metrics[tool_name]['count'] += 1
+        self.tool_metrics[tool_name]['inputs'].append(input_str)
+
         metadata = {
-            'tool_name': serialized.get("name", "tool"),
-            'started': datetime.datetime.now().isoformat()
+            'tool_name': tool_name,
+            'started': start_time.isoformat(),
+            'start_timestamp': start_time.timestamp(),
+            'input_length': len(input_str) if input_str else 0
         }
         action_span.update(metadata=metadata)
 
@@ -42,9 +66,25 @@ class LangfuseCallbackHandler(BaseCallbackHandler):
         action_span = self.action_uuid_to_span.get(parent_run_uuid)
         if action_span is None:
             return
+
+        end_time = datetime.datetime.now()
+        tool_name = action_span.metadata.get('tool_name', 'unknown')
+        start_timestamp = action_span.metadata.get('start_timestamp')
+
+        if start_timestamp:
+            duration = end_time.timestamp() - start_timestamp
+            if tool_name in self.tool_metrics:
+                self.tool_metrics[tool_name]['total_time'] += duration
+
+        metadata = {
+            'finished': end_time.isoformat(),
+            'duration_seconds': duration if start_timestamp else None,
+            'output_length': len(output) if output else 0
+        }
+
         action_span.update(
             output=output,  # tool output is action output (unless superseded by a global action output)
-            metadata={'finished': datetime.datetime.now().isoformat()}
+            metadata=metadata
         )
 
     def on_tool_error(
@@ -55,75 +95,213 @@ class LangfuseCallbackHandler(BaseCallbackHandler):
         action_span = self.action_uuid_to_span.get(parent_run_uuid)
         if action_span is None:
             return
+
         try:
             error_str = str(error)
         except Exception:
             error_str = "Couldn't get error string."
-        action_span.update(metadata={'error_description': error_str})
+
+        tool_name = action_span.metadata.get('tool_name', 'unknown')
+        if tool_name in self.tool_metrics:
+            self.tool_metrics[tool_name]['errors'] += 1
+            self.tool_metrics[tool_name]['last_error'] = error_str
+
+        metadata = {
+            'error_description': error_str,
+            'error_type': error.__class__.__name__,
+            'error_time': datetime.datetime.now().isoformat()
+        }
+        action_span.update(metadata=metadata)
 
     def on_chain_start(
             self, serialized: Dict[str, Any], inputs: Dict[str, Any], **kwargs: Any
     ) -> Any:
         """Run when chain starts running."""
+        if self.langfuse is None:
+            return
+
         run_uuid = kwargs.get('run_id', uuid4()).hex
 
         if serialized is None:
             serialized = {}
 
-        chain_span = self.langfuse.span(
-            name=f'{serialized.get("name", "chain")}-{run_uuid}',
-            trace_id=self.trace_id,
-            parent_observation_id=self.observation_id,
-            input=str(inputs)
-        )
-        self.chain_uuid_to_span[run_uuid] = chain_span
+        chain_name = serialized.get("name", "chain")
+        start_time = datetime.datetime.now()
+
+        # Initialize or update chain metrics
+        if chain_name not in self.chain_metrics:
+            self.chain_metrics[chain_name] = {
+                'count': 0,
+                'total_time': 0,
+                'errors': 0,
+                'last_error': None
+            }
+
+        self.chain_metrics[chain_name]['count'] += 1
+        self.current_chain = chain_name
+
+        try:
+            chain_span = self.langfuse.span(
+                name=f'{chain_name}-{run_uuid}',
+                trace_id=self.trace_id,
+                parent_observation_id=self.observation_id,
+                input=json.dumps(inputs, indent=2)
+            )
+
+            metadata = {
+                'chain_name': chain_name,
+                'started': start_time.isoformat(),
+                'start_timestamp': start_time.timestamp(),
+                'input_keys': list(inputs.keys()) if isinstance(inputs, dict) else None,
+                'input_size': len(inputs) if isinstance(inputs, dict) else len(str(inputs))
+            }
+            chain_span.update(metadata=metadata)
+            self.chain_uuid_to_span[run_uuid] = chain_span
+        except Exception as e:
+            logger.warning(f"Error creating Langfuse span: {str(e)}")
 
     def on_chain_end(self, outputs: Dict[str, Any], **kwargs: Any) -> Any:
         """Run when chain ends running."""
+        if self.langfuse is None:
+            return
+
         chain_uuid = kwargs.get('run_id', uuid4()).hex
         if chain_uuid not in self.chain_uuid_to_span:
             return
         chain_span = self.chain_uuid_to_span.pop(chain_uuid)
         if chain_span is None:
             return
-        chain_span.update(output=str(outputs))
-        chain_span.end()
+
+        try:
+            end_time = datetime.datetime.now()
+            chain_name = chain_span.metadata.get('chain_name', 'unknown')
+            start_timestamp = chain_span.metadata.get('start_timestamp')
+
+            if start_timestamp and chain_name in self.chain_metrics:
+                duration = end_time.timestamp() - start_timestamp
+                self.chain_metrics[chain_name]['total_time'] += duration
+
+            metadata = {
+                'finished': end_time.isoformat(),
+                'duration_seconds': duration if start_timestamp else None,
+                'output_keys': list(outputs.keys()) if isinstance(outputs, dict) else None,
+                'output_size': len(outputs) if isinstance(outputs, dict) else len(str(outputs))
+            }
+            chain_span.update(output=json.dumps(outputs, indent=2), metadata=metadata)
+            chain_span.end()
+        except Exception as e:
+            logger.warning(f"Error updating Langfuse span: {str(e)}")
 
     def on_chain_error(self, error: Union[Exception, KeyboardInterrupt], **kwargs: Any) -> Any:
         """Run when chain errors."""
-        # Do nothing for now.
-        pass
+        chain_uuid = kwargs.get('run_id', uuid4()).hex
+        if chain_uuid not in self.chain_uuid_to_span:
+            return
+        chain_span = self.chain_uuid_to_span.get(chain_uuid)
+        if chain_span is None:
+            return
+
+        try:
+            error_str = str(error)
+        except Exception:
+            error_str = "Couldn't get error string."
+
+        chain_name = chain_span.metadata.get('chain_name', 'unknown')
+        if chain_name in self.chain_metrics:
+            self.chain_metrics[chain_name]['errors'] += 1
+            self.chain_metrics[chain_name]['last_error'] = error_str
+
+        metadata = {
+            'error_description': error_str,
+            'error_type': error.__class__.__name__,
+            'error_time': datetime.datetime.now().isoformat()
+        }
+        chain_span.update(metadata=metadata)
 
     def on_agent_action(self, action, **kwargs: Any) -> Any:
         """Run on agent action."""
-        # Do nothing for now.
+        if self.langfuse is None:
+            return
+
         run_uuid = kwargs.get('run_id', uuid4()).hex
-        action_span = self.langfuse.span(
-            name=f'{getattr(action, "type", "action")}-{getattr(action, "tool", "")}-{run_uuid}',
-            trace_id=self.trace_id,
-            parent_observation_id=self.observation_id,
-            input=str(action)
-        )
-        self.action_uuid_to_span[run_uuid] = action_span
+        try:
+            action_span = self.langfuse.span(
+                name=f'{getattr(action, "type", "action")}-{getattr(action, "tool", "")}-{run_uuid}',
+                trace_id=self.trace_id,
+                parent_observation_id=self.observation_id,
+                input=str(action)
+            )
+            self.action_uuid_to_span[run_uuid] = action_span
+        except Exception as e:
+            logger.warning(f"Error creating Langfuse span for agent action: {str(e)}")
 
     def on_agent_finish(self, finish, **kwargs: Any) -> Any:
         """Run on agent end."""
-        # Do nothing for now.
+        if self.langfuse is None:
+            return
+
         run_uuid = kwargs.get('run_id', uuid4()).hex
         if run_uuid not in self.action_uuid_to_span:
             return
         action_span = self.action_uuid_to_span.pop(run_uuid)
         if action_span is None:
             return
-        if finish is not None:
-            action_span.update(output=finish)  # supersedes tool output
-        action_span.end()
+
+        try:
+            if finish is not None:
+                action_span.update(output=finish)  # supersedes tool output
+            action_span.end()
+        except Exception as e:
+            logger.warning(f"Error updating Langfuse span: {str(e)}")
 
     def auth_check(self):
         if self.langfuse is not None:
             return self.langfuse.auth_check()
         return False
 
+    def get_metrics(self) -> Dict[str, Any]:
+        """Get collected metrics about tools and chains.
+
+        Returns:
+            Dict containing:
+            - tool_metrics: Statistics about tool usage, errors, and timing
+            - chain_metrics: Statistics about chain execution, errors, and timing
+            For each tool/chain, includes:
+                - count: Number of times used
+                - total_time: Total execution time
+                - errors: Number of errors
+                - last_error: Most recent error message
+                - avg_duration: Average execution time
+        """
+        metrics = {
+            'tool_metrics': {},
+            'chain_metrics': {}
+        }
+
+        # Process tool metrics
+        for tool_name, data in self.tool_metrics.items():
+            metrics['tool_metrics'][tool_name] = {
+                'count': data['count'],
+                'total_time': data['total_time'],
+                'avg_duration': data['total_time'] / data['count'] if data['count'] > 0 else 0,
+                'errors': data['errors'],
+                'last_error': data['last_error'],
+                'error_rate': data['errors'] / data['count'] if data['count'] > 0 else 0
+            }
+
+        # Process chain metrics
+        for chain_name, data in self.chain_metrics.items():
+            metrics['chain_metrics'][chain_name] = {
+                'count': data['count'],
+                'total_time': data['total_time'],
+                'avg_duration': data['total_time'] / data['count'] if data['count'] > 0 else 0,
+                'errors': data['errors'],
+                'last_error': data['last_error'],
+                'error_rate': data['errors'] / data['count'] if data['count'] > 0 else 0
+            }
+
+        return metrics
+
 
 def get_skills(agent: db.Agents) -> List:
     """ Retrieve skills from agent `skills` attribute. Specific to agent endpoints. """

mindsdb/interfaces/file/file_controller.py

@@ -82,7 +82,7 @@ class FileController:
 
         file_dir = None
         try:
-            df, _col_map = FileHandler._handle_source(file_path)
+            df = FileHandler.handle_source(file_path)
 
             ds_meta = {"row_count": len(df), "column_names": list(df.columns)}
 

mindsdb/utilities/config.py

@@ -142,7 +142,8 @@ class Config:
             },
             'auth': {
                 'http_auth_enabled': False,
-                "http_permanent_session_lifetime": datetime.timedelta(days=31)
+                "http_permanent_session_lifetime": datetime.timedelta(days=31),
+                "username": "mindsdb"
             },
             "logging": {
                 "handlers": {
@@ -183,7 +184,6 @@ class Config:
                 },
                 "mysql": {
                     "host": api_host,
-                    "password": "",
                     "port": "47335",
                     "database": "mindsdb",
                     "ssl": True,

mindsdb/utilities/render/sqlalchemy_render.py

@@ -54,6 +54,23 @@ def _compile_interval(element, compiler, **kw):
     return "INTERVAL " + args
 
 
+class AttributedStr(str):
+    """
+       Custom str-like object to pass it to `_requires_quotes` method with `is_quoted` flag
+    """
+    def __new__(cls, string, is_quoted: bool):
+        obj = str.__new__(cls, string)
+        obj.is_quoted = is_quoted
+        return obj
+
+
+def get_is_quoted(identifier: ast.Identifier):
+    quoted = getattr(identifier, 'is_quoted', [])
+    # len can be different
+    quoted = quoted + [None] * (len(identifier.parts) - len(quoted))
+    return quoted
+
+
 class SqlalchemyRender:
 
     def __init__(self, dialect_name):
@@ -72,6 +89,29 @@ class SqlalchemyRender:
         else:
             dialect = dialect_name
 
+        # override dialect's preparer
+        if hasattr(dialect, 'preparer'):
+            class Preparer(dialect.preparer):
+
+                def __init__(self, *args, **kwargs):
+                    super().__init__(*args, **kwargs)
+
+                def _requires_quotes(self, value: str) -> bool:
+                    # check force-quote flag
+                    if isinstance(value, AttributedStr):
+                        if value.is_quoted:
+                            return True
+
+                    lc_value = value.lower()
+                    return (
+                        lc_value in self.reserved_words
+                        or value[0] in self.illegal_initial_characters
+                        or not self.legal_characters.match(str(value))
+                        #  Override sqlalchemy behavior: don't require to quote mixed- or upper-case
+                        # or (lc_value != value)
+                    )
+            dialect.preparer = Preparer
+
         # remove double percent signs
         # https://docs.sqlalchemy.org/en/14/faq/sqlexpressions.html#why-are-percent-signs-being-doubled-up-when-stringifying-sql-statements
         self.dialect = dialect(paramstyle="named")
@@ -90,26 +130,16 @@ class SqlalchemyRender:
 
         parts2 = []
 
-        quoted = getattr(identifier, 'is_quoted', [])
-        # len can be different
-        quoted = quoted + [None] * (len(identifier.parts) - len(quoted))
-
+        quoted = get_is_quoted(identifier)
         for i, is_quoted in zip(identifier.parts, quoted):
             if isinstance(i, ast.Star):
                 part = '*'
-            elif is_quoted:
-                part = self.dialect.identifier_preparer.quote(i)
+            elif is_quoted or i.lower() in RESERVED_WORDS:
+                # quote anyway
+                part = self.dialect.identifier_preparer.quote_identifier(i)
             else:
-                part = str(sa.column(i).compile(dialect=self.dialect))
-
-                if not i.islower():
-                    # if lower value is not quoted
-                    #   then it is quoted only because of mixed case
-                    #   in that case use origin string
-
-                    part_lower = str(sa.column(i.lower()).compile(dialect=self.dialect))
-                    if part.lower() != part_lower and i.lower() not in RESERVED_WORDS:
-                        part = i
+                # quote if required
+                part = self.dialect.identifier_preparer.quote(i)
 
             parts2.append(part)
 
@@ -120,7 +150,9 @@ class SqlalchemyRender:
             return None
         if len(alias.parts) > 1:
             raise NotImplementedError(f'Multiple alias {alias.parts}')
-        return alias.parts[0]
+
+        is_quoted = get_is_quoted(alias)[0]
+        return AttributedStr(alias.parts[0], is_quoted)
 
     def to_expression(self, t):
 
@@ -435,15 +467,16 @@ class SqlalchemyRender:
         schema = None
         if isinstance(table_name, ast.Identifier):
             parts = table_name.parts
+            quoted = get_is_quoted(table_name)
 
             if len(parts) > 2:
                 # TODO tests is failing
                 raise NotImplementedError(f'Path to long: {table_name.parts}')
 
             if len(parts) == 2:
-                schema = parts[-2]
+                schema = AttributedStr(parts[-2], quoted[-2])
 
-            table_name = parts[-1]
+            table_name = AttributedStr(parts[-1], quoted[-1])
 
         return schema, table_name