mlrun 1.7.0rc26__py3-none-any.whl → 1.7.0rc29__py3-none-any.whl

mlrun/model_monitoring/applications/histogram_data_drift.py

@@ -195,7 +195,10 @@ class HistogramDataDriftApplication(ModelMonitoringApplicationBaseV2):
                 EventFieldType.CURRENT_STATS: json.dumps(
                     monitoring_context.sample_df_stats
                 ),
-                EventFieldType.DRIFT_MEASURES: metrics_per_feature.T.to_json(),
+                EventFieldType.DRIFT_MEASURES: json.dumps(
+                    metrics_per_feature.T.to_dict()
+                    | {metric.name: metric.value for metric in metrics}
+                ),
                 EventFieldType.DRIFT_STATUS: status.value,
             },
         )

mlrun/model_monitoring/db/stores/__init__.py

@@ -63,7 +63,7 @@ class ObjectStoreFactory(enum.Enum):
         :param value: Provided enum (invalid) value.
         """
         valid_values = list(cls.__members__.keys())
-        raise mlrun.errors.MLRunInvalidArgumentError(
+        raise mlrun.errors.MLRunInvalidMMStoreType(
             f"{value} is not a valid endpoint store, please choose a valid value: %{valid_values}."
         )
 
@@ -88,21 +88,28 @@ def get_model_endpoint_store(
 def get_store_object(
     project: str,
     secret_provider: typing.Optional[typing.Callable[[str], str]] = None,
+    store_connection_string: typing.Optional[str] = None,
     **kwargs,
 ) -> StoreBase:
     """
     Generate a store object. If a connection string is provided, the store type will be updated according to the
     connection string. Currently, the supported store types are SQL and v3io-nosql.
 
-    :param project:         The name of the project.
-    :param secret_provider: An optional secret provider to get the connection string secret.
+    :param project:                 The name of the project.
+    :param secret_provider:         An optional secret provider to get the connection string secret.
+    :param store_connection_string: Optional explicit connection string of the store.
 
     :return: `StoreBase` object. Using this object, the user can apply different operations such as write, update, get
-    and delete a model endpoint record.
+             and delete a model endpoint record.
+    :raise: `MLRunInvalidMMStoreType` if the user didn't provide store connection
+             or the provided store connection is invalid.
     """
 
-    store_connection_string = mlrun.model_monitoring.helpers.get_connection_string(
-        secret_provider=secret_provider
+    store_connection_string = (
+        store_connection_string
+        or mlrun.model_monitoring.helpers.get_connection_string(
+            secret_provider=secret_provider
+        )
     )
 
     if store_connection_string and (
@@ -111,10 +118,15 @@ def get_store_object(
     ):
         store_type = mlrun.common.schemas.model_monitoring.ModelEndpointTarget.SQL
         kwargs["store_connection_string"] = store_connection_string
+    elif store_connection_string and store_connection_string == "v3io":
+        store_type = (
+            mlrun.common.schemas.model_monitoring.ModelEndpointTarget.V3IO_NOSQL
+        )
     else:
-        # Set the default store type if no connection has been set
-        store_type = mlrun.mlconf.model_endpoint_monitoring.store_type
-
+        raise mlrun.errors.MLRunInvalidMMStoreType(
+            "You must provide a valid store connection by using "
+            "set_model_monitoring_credentials API."
+        )
     # Get store type value from ObjectStoreFactory enum class
     store_type_fact = ObjectStoreFactory(store_type)
 

mlrun/model_monitoring/db/stores/base/store.py

@@ -11,7 +11,7 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
-
+import json
 import typing
 from abc import ABC, abstractmethod
 
@@ -170,3 +170,41 @@ class StoreBase(ABC):
 
         :return:             A list of the available metrics.
         """
+
+    @staticmethod
+    def _validate_labels(
+        endpoint_dict: dict,
+        labels: list,
+    ) -> bool:
+        """Validate that the model endpoint dictionary has the provided labels. There are 2 possible cases:
+        1 - Labels were provided as a list of key-values pairs (e.g. ['label_1=value_1', 'label_2=value_2']): Validate
+            that each pair exist in the endpoint dictionary.
+        2 - Labels were provided as a list of key labels (e.g. ['label_1', 'label_2']): Validate that each key exist in
+            the endpoint labels dictionary.
+
+        :param endpoint_dict: Dictionary of the model endpoint records.
+        :param labels:        List of dictionary of required labels.
+
+        :return: True if the labels exist in the endpoint labels dictionary, otherwise False.
+        """
+
+        # Convert endpoint labels into dictionary
+        endpoint_labels = json.loads(
+            endpoint_dict.get(mm_schemas.EventFieldType.LABELS)
+        )
+
+        for label in labels:
+            # Case 1 - label is a key=value pair
+            if "=" in label:
+                lbl, value = list(map(lambda x: x.strip(), label.split("=")))
+                if lbl not in endpoint_labels or str(endpoint_labels[lbl]) != value:
+                    return False
+            # Case 2 - label is just a key
+            else:
+                if label not in endpoint_labels:
+                    return False
+
+        return True
+
+    def create_tables(self):
+        pass

mlrun/model_monitoring/db/stores/sqldb/models/base.py

@@ -11,8 +11,10 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
+
 from sqlalchemy import (
-    TIMESTAMP,
+    DATETIME,
+    TIMESTAMP,  # TODO: migrate to DATETIME, see ML-6921
     Boolean,
     Column,
     Float,
@@ -90,11 +92,11 @@ class ModelEndpointsBaseTable(BaseModel):
     metrics = Column(EventFieldType.METRICS, Text)
     first_request = Column(
         EventFieldType.FIRST_REQUEST,
-        TIMESTAMP(timezone=True),
+        TIMESTAMP(timezone=True),  # TODO: migrate to DATETIME, see ML-6921
     )
     last_request = Column(
         EventFieldType.LAST_REQUEST,
-        TIMESTAMP(timezone=True),
+        TIMESTAMP(timezone=True),  # TODO: migrate to DATETIME, see ML-6921
     )
 
 
@@ -122,11 +124,11 @@ class ApplicationResultBaseTable(BaseModel):
 
     start_infer_time = Column(
         WriterEvent.START_INFER_TIME,
-        TIMESTAMP(timezone=True),
+        DATETIME(timezone=True),
     )
     end_infer_time = Column(
         WriterEvent.END_INFER_TIME,
-        TIMESTAMP(timezone=True),
+        DATETIME(timezone=True),
     )
 
     result_status = Column(ResultData.RESULT_STATUS, String(10))
@@ -152,11 +154,11 @@ class ApplicationMetricsBaseTable(BaseModel):
     )
     start_infer_time = Column(
         WriterEvent.START_INFER_TIME,
-        TIMESTAMP(timezone=True),
+        DATETIME(timezone=True),
     )
     end_infer_time = Column(
         WriterEvent.END_INFER_TIME,
-        TIMESTAMP(timezone=True),
+        DATETIME(timezone=True),
     )
     metric_name = Column(
         MetricData.METRIC_NAME,

mlrun/model_monitoring/db/stores/sqldb/models/mysql.py

@@ -34,10 +34,12 @@ Base = declarative_base()
 class ModelEndpointsTable(Base, ModelEndpointsBaseTable):
     first_request = Column(
         EventFieldType.FIRST_REQUEST,
+        # TODO: migrate to DATETIME, see ML-6921
         sqlalchemy.dialects.mysql.TIMESTAMP(fsp=3, timezone=True),
     )
     last_request = Column(
         EventFieldType.LAST_REQUEST,
+        # TODO: migrate to DATETIME, see ML-6921
         sqlalchemy.dialects.mysql.TIMESTAMP(fsp=3, timezone=True),
     )
 
@@ -52,11 +54,11 @@ class _ApplicationResultOrMetric:
 
     start_infer_time = Column(
         WriterEvent.START_INFER_TIME,
-        sqlalchemy.dialects.mysql.TIMESTAMP(fsp=3, timezone=True),
+        sqlalchemy.dialects.mysql.DATETIME(fsp=3, timezone=True),
     )
     end_infer_time = Column(
         WriterEvent.END_INFER_TIME,
-        sqlalchemy.dialects.mysql.TIMESTAMP(fsp=3, timezone=True),
+        sqlalchemy.dialects.mysql.DATETIME(fsp=3, timezone=True),
     )
 
     @declared_attr

mlrun/model_monitoring/db/stores/sqldb/sql_store.py

@@ -13,7 +13,6 @@
 # limitations under the License.
 
 import datetime
-import json
 import typing
 import uuid
 
@@ -21,6 +20,7 @@ import pandas as pd
 import sqlalchemy
 import sqlalchemy.exc
 import sqlalchemy.orm
+from sqlalchemy.engine import make_url
 from sqlalchemy.sql.elements import BinaryExpression
 
 import mlrun.common.model_monitoring.helpers
@@ -62,6 +62,10 @@ class SQLStoreBase(StoreBase):
 
         self._sql_connection_string = kwargs.get("store_connection_string")
         self._engine = get_engine(dsn=self._sql_connection_string)
+        self._init_tables()
+
+    def create_tables(self):
+        self._create_tables_if_not_exist()
 
     def _init_tables(self):
         self._init_model_endpoints_table()
@@ -70,13 +74,13 @@ class SQLStoreBase(StoreBase):
         self._init_monitoring_schedules_table()
 
     def _init_model_endpoints_table(self):
-        self.ModelEndpointsTable = (
+        self.model_endpoints_table = (
             mlrun.model_monitoring.db.stores.sqldb.models._get_model_endpoints_table(
                 connection_string=self._sql_connection_string
             )
         )
         self._tables[mm_schemas.EventFieldType.MODEL_ENDPOINTS] = (
-            self.ModelEndpointsTable
+            self.model_endpoints_table
         )
 
     def _init_application_results_table(self):
@@ -150,22 +154,17 @@ class SQLStoreBase(StoreBase):
         :param criteria: A list of binary expressions that filter the query.
         """
         with create_session(dsn=self._sql_connection_string) as session:
-            try:
-                logger.debug(
-                    "Querying the DB",
-                    table=table.__name__,
-                    criteria=[str(criterion) for criterion in criteria],
-                )
-                # Generate the get query
-                return (
-                    session.query(table)  # pyright: ignore[reportOptionalCall]
-                    .filter(*criteria)
-                    .one_or_none()
-                )
-            except sqlalchemy.exc.ProgrammingError:
-                # Probably table doesn't exist, try to create tables
-                self._create_tables_if_not_exist()
-                return
+            logger.debug(
+                "Querying the DB",
+                table=table.__name__,
+                criteria=[str(criterion) for criterion in criteria],
+            )
+            # Generate the get query
+            return (
+                session.query(table)  # pyright: ignore[reportOptionalCall]
+                .filter(*criteria)
+                .one_or_none()
+            )
 
     def _delete(
         self,
@@ -213,14 +212,13 @@ class SQLStoreBase(StoreBase):
                            of the attributes dictionary should exist in the SQL table.
 
         """
-        self._init_model_endpoints_table()
 
         attributes.pop(mm_schemas.EventFieldType.ENDPOINT_ID, None)
 
         self._update(
             attributes=attributes,
-            table=self.ModelEndpointsTable,
-            criteria=[self.ModelEndpointsTable.uid == endpoint_id],
+            table=self.model_endpoints_table,
+            criteria=[self.model_endpoints_table.uid == endpoint_id],
         )
 
     def delete_model_endpoint(self, endpoint_id: str) -> None:
@@ -229,11 +227,10 @@ class SQLStoreBase(StoreBase):
 
         :param endpoint_id: The unique id of the model endpoint.
         """
-        self._init_model_endpoints_table()
         # Delete the model endpoint record using sqlalchemy ORM
         self._delete(
-            table=self.ModelEndpointsTable,
-            criteria=[self.ModelEndpointsTable.uid == endpoint_id],
+            table=self.model_endpoints_table,
+            criteria=[self.model_endpoints_table.uid == endpoint_id],
         )
 
     def get_model_endpoint(
@@ -249,12 +246,11 @@ class SQLStoreBase(StoreBase):
 
         :raise MLRunNotFoundError: If the model endpoints table was not found or the model endpoint id was not found.
         """
-        self._init_model_endpoints_table()
 
         # Get the model endpoint record
         endpoint_record = self._get(
-            table=self.ModelEndpointsTable,
-            criteria=[self.ModelEndpointsTable.uid == endpoint_id],
+            table=self.model_endpoints_table,
+            criteria=[self.model_endpoints_table.uid == endpoint_id],
         )
 
         if not endpoint_record:
@@ -286,23 +282,22 @@ class SQLStoreBase(StoreBase):
 
         :return: A list of model endpoint dictionaries.
         """
-        self._init_model_endpoints_table()
         # Generate an empty model endpoints that will be filled afterwards with model endpoint dictionaries
         endpoint_list = []
 
         model_endpoints_table = (
-            self.ModelEndpointsTable.__table__  # pyright: ignore[reportAttributeAccessIssue]
+            self.model_endpoints_table.__table__  # pyright: ignore[reportAttributeAccessIssue]
         )
-
         # Get the model endpoints records using sqlalchemy ORM
         with create_session(dsn=self._sql_connection_string) as session:
             # Generate the list query
-            query = session.query(self.ModelEndpointsTable).filter_by(
+            query = session.query(self.model_endpoints_table).filter_by(
                 project=self.project
             )
 
             # Apply filters
             if model:
+                model = model if ":" in model else f"{model}:latest"
                 query = self._filter_values(
                     query=query,
                     model_endpoints_table=model_endpoints_table,
@@ -310,11 +305,12 @@ class SQLStoreBase(StoreBase):
                     filtered_values=[model],
                 )
             if function:
+                function_uri = f"{self.project}/{function}"
                 query = self._filter_values(
                     query=query,
                     model_endpoints_table=model_endpoints_table,
-                    key_filter=mm_schemas.EventFieldType.FUNCTION,
-                    filtered_values=[function],
+                    key_filter=mm_schemas.EventFieldType.FUNCTION_URI,
+                    filtered_values=[function_uri],
                 )
             if uids:
                 query = self._filter_values(
@@ -364,11 +360,9 @@ class SQLStoreBase(StoreBase):
         """
 
         if kind == mm_schemas.WriterEventKind.METRIC:
-            self._init_application_metrics_table()
             table = self.application_metrics_table
             table_name = mm_schemas.FileTargetKind.APP_METRICS
         elif kind == mm_schemas.WriterEventKind.RESULT:
-            self._init_application_results_table()
             table = self.application_results_table
             table_name = mm_schemas.FileTargetKind.APP_RESULTS
         else:
@@ -442,7 +436,6 @@ class SQLStoreBase(StoreBase):
         :return: Timestamp as a Unix time.
         :raise:  MLRunNotFoundError if last analyzed value is not found.
         """
-        self._init_monitoring_schedules_table()
         monitoring_schedule_record = self._get(
             table=self.MonitoringSchedulesTable,
             criteria=self._get_filter_criteria(
@@ -469,8 +462,6 @@ class SQLStoreBase(StoreBase):
         :param last_analyzed:    Timestamp as a Unix time that represents the last analyzed time of a certain
                                  application and model endpoint.
         """
-        self._init_monitoring_schedules_table()
-
         criteria = self._get_filter_criteria(
             table=self.MonitoringSchedulesTable,
             endpoint_id=endpoint_id,
@@ -500,7 +491,6 @@ class SQLStoreBase(StoreBase):
     def _delete_last_analyzed(
         self, endpoint_id: str, application_name: typing.Optional[str] = None
     ) -> None:
-        self._init_monitoring_schedules_table()
         criteria = self._get_filter_criteria(
             table=self.MonitoringSchedulesTable,
             endpoint_id=endpoint_id,
@@ -512,7 +502,6 @@ class SQLStoreBase(StoreBase):
     def _delete_application_result(
         self, endpoint_id: str, application_name: typing.Optional[str] = None
     ) -> None:
-        self._init_application_results_table()
         criteria = self._get_filter_criteria(
             table=self.application_results_table,
             endpoint_id=endpoint_id,
@@ -524,7 +513,6 @@ class SQLStoreBase(StoreBase):
     def _delete_application_metrics(
         self, endpoint_id: str, application_name: typing.Optional[str] = None
     ) -> None:
-        self._init_application_metrics_table()
         criteria = self._get_filter_criteria(
             table=self.application_metrics_table,
             endpoint_id=endpoint_id,
@@ -538,8 +526,12 @@ class SQLStoreBase(StoreBase):
 
         for table in self._tables:
             # Create table if not exist. The `metadata` contains the `ModelEndpointsTable`
+            db_name = make_url(self._sql_connection_string).database
             if not self._engine.has_table(table):
+                logger.info(f"Creating table {table} on {db_name} db.")
                 self._tables[table].metadata.create_all(bind=self._engine)
+            else:
+                logger.info(f"Table {table} already exists on {db_name} db.")
 
     @staticmethod
     def _filter_values(
@@ -581,41 +573,6 @@ class SQLStoreBase(StoreBase):
         # Apply AND operator on the SQL query object with the filters tuple
         return query.filter(sqlalchemy.and_(*filter_query))
 
-    @staticmethod
-    def _validate_labels(
-        endpoint_dict: dict,
-        labels: list,
-    ) -> bool:
-        """Validate that the model endpoint dictionary has the provided labels. There are 2 possible cases:
-        1 - Labels were provided as a list of key-values pairs (e.g. ['label_1=value_1', 'label_2=value_2']): Validate
-            that each pair exist in the endpoint dictionary.
-        2 - Labels were provided as a list of key labels (e.g. ['label_1', 'label_2']): Validate that each key exist in
-            the endpoint labels dictionary.
-
-        :param endpoint_dict: Dictionary of the model endpoint records.
-        :param labels:        List of dictionary of required labels.
-
-        :return: True if the labels exist in the endpoint labels dictionary, otherwise False.
-        """
-
-        # Convert endpoint labels into dictionary
-        endpoint_labels = json.loads(
-            endpoint_dict.get(mm_schemas.EventFieldType.LABELS)
-        )
-
-        for label in labels:
-            # Case 1 - label is a key=value pair
-            if "=" in label:
-                lbl, value = list(map(lambda x: x.strip(), label.split("=")))
-                if lbl not in endpoint_labels or str(endpoint_labels[lbl]) != value:
-                    return False
-            # Case 2 - label is just a key
-            else:
-                if label not in endpoint_labels:
-                    return False
-
-        return True
-
     def delete_model_endpoints_resources(self) -> None:
         """
         Delete all the model monitoring resources of the project in the SQL tables.
@@ -650,11 +607,9 @@ class SQLStoreBase(StoreBase):
             type=type,
         )
         if type == mm_schemas.ModelEndpointMonitoringMetricType.METRIC:
-            self._init_application_metrics_table()
             table = self.application_metrics_table
             name_col = mm_schemas.MetricData.METRIC_NAME
         else:
-            self._init_application_results_table()
             table = self.application_results_table
             name_col = mm_schemas.ResultData.RESULT_NAME
 

mlrun/model_monitoring/db/stores/v3io_kv/kv_store.py

@@ -256,7 +256,6 @@ class KVStoreBase(StoreBase):
                     self.project,
                     function,
                     model,
-                    labels,
                     top_level,
                 ),
                 raise_for_status=v3io.dataplane.RaiseForStatus.never,
@@ -269,7 +268,6 @@ class KVStoreBase(StoreBase):
                 exc=mlrun.errors.err_to_str(exc),
             )
             return endpoint_list
-
         # Create a list of model endpoints unique ids
         if uids is None:
             uids = []
@@ -282,10 +280,16 @@ class KVStoreBase(StoreBase):
 
         # Add each relevant model endpoint to the model endpoints list
         for endpoint_id in uids:
-            endpoint = self.get_model_endpoint(
+            endpoint_dict = self.get_model_endpoint(
                 endpoint_id=endpoint_id,
             )
-            endpoint_list.append(endpoint)
+
+            if labels and not self._validate_labels(
+                endpoint_dict=endpoint_dict, labels=labels
+            ):
+                continue
+
+            endpoint_list.append(endpoint_dict)
 
         return endpoint_list
 
@@ -509,20 +513,16 @@ class KVStoreBase(StoreBase):
         project: str,
         function: str = None,
         model: str = None,
-        labels: list[str] = None,
         top_level: bool = False,
     ) -> str:
         """
         Convert the provided filters into a valid filter expression. The expected filter expression includes different
         conditions, divided by ' AND '.
 
-        :param project:    The name of the project.
-        :param model:      The name of the model to filter by.
-        :param function:   The name of the function to filter by.
-        :param labels:     A list of labels to filter by. Label filters work by either filtering a specific value of
-                           a label (i.e. list("key=value")) or by looking for the existence of a given
-                           key (i.e. "key").
-        :param top_level:  If True will return only routers and endpoint that are NOT children of any router.
+        :param project:         The name of the project.
+        :param model:           The name of the model to filter by.
+        :param function:        The name of the function to filter by.
+        :param top_level:       If True will return only routers and endpoint that are NOT children of any router.
 
         :return: A valid filter expression as a string.
 
@@ -533,25 +533,17 @@ class KVStoreBase(StoreBase):
             raise mlrun.errors.MLRunInvalidArgumentError("project can't be empty")
 
         # Add project filter
-        filter_expression = [f"project=='{project}'"]
+        filter_expression = [f"{mm_schemas.EventFieldType.PROJECT}=='{project}'"]
 
         # Add function and model filters
         if function:
-            filter_expression.append(f"function=='{function}'")
+            function_uri = f"{project}/{function}" if function else None
+            filter_expression.append(
+                f"{mm_schemas.EventFieldType.FUNCTION_URI}=='{function_uri}'"
+            )
         if model:
-            filter_expression.append(f"model=='{model}'")
-
-        # Add labels filters
-        if labels:
-            for label in labels:
-                if not label.startswith("_"):
-                    label = f"_{label}"
-
-                if "=" in label:
-                    lbl, value = list(map(lambda x: x.strip(), label.split("=")))
-                    filter_expression.append(f"{lbl}=='{value}'")
-                else:
-                    filter_expression.append(f"exists({label})")
+            model = model if ":" in model else f"{model}:latest"
+            filter_expression.append(f"{mm_schemas.EventFieldType.MODEL}=='{model}'")
 
         # Apply top_level filter (remove endpoints that considered a child of a router)
         if top_level:

mlrun/model_monitoring/db/tsdb/__init__.py

@@ -57,41 +57,46 @@ class ObjectTSDBFactory(enum.Enum):
         :param value: Provided enum (invalid) value.
         """
         valid_values = list(cls.__members__.keys())
-        raise mlrun.errors.MLRunInvalidArgumentError(
+        raise mlrun.errors.MLRunInvalidMMStoreType(
             f"{value} is not a valid tsdb, please choose a valid value: %{valid_values}."
         )
 
 
 def get_tsdb_connector(
     project: str,
-    tsdb_connector_type: str = "",
     secret_provider: typing.Optional[typing.Callable[[str], str]] = None,
+    tsdb_connection_string: typing.Optional[str] = None,
     **kwargs,
 ) -> TSDBConnector:
     """
     Get TSDB connector object.
-    :param project: The name of the project.
-    :param tsdb_connector_type: The type of the TSDB connector. See mlrun.model_monitoring.db.tsdb.ObjectTSDBFactory
-                                for available options.
-    :param secret_provider: An optional secret provider to get the connection string secret.
+    :param project:                 The name of the project.
+    :param secret_provider:         An optional secret provider to get the connection string secret.
+    :param tsdb_connection_string:  An optional explicit connection string to the TSDB.
 
     :return: `TSDBConnector` object. The main goal of this object is to handle different operations on the
              TSDB connector such as updating drift metrics or write application record result.
+    :raise: `MLRunInvalidMMStoreType` if the user didn't provide TSDB connection
+            or the provided TSDB connection is invalid.
     """
 
-    tsdb_connection_string = mlrun.model_monitoring.helpers.get_tsdb_connection_string(
-        secret_provider=secret_provider
+    tsdb_connection_string = (
+        tsdb_connection_string
+        or mlrun.model_monitoring.helpers.get_tsdb_connection_string(
+            secret_provider=secret_provider
+        )
     )
 
     if tsdb_connection_string and tsdb_connection_string.startswith("taosws"):
         tsdb_connector_type = mlrun.common.schemas.model_monitoring.TSDBTarget.TDEngine
         kwargs["connection_string"] = tsdb_connection_string
-
-    # Set the default TSDB connector type if no connection has been set
-    tsdb_connector_type = (
-        tsdb_connector_type
-        or mlrun.mlconf.model_endpoint_monitoring.tsdb_connector_type
-    )
+    elif tsdb_connection_string and tsdb_connection_string == "v3io":
+        tsdb_connector_type = mlrun.common.schemas.model_monitoring.TSDBTarget.V3IO_TSDB
+    else:
+        raise mlrun.errors.MLRunInvalidMMStoreType(
+            "You must provide a valid tsdb store connection by using "
+            "set_model_monitoring_credentials API."
+        )
 
     # Get connector type value from ObjectTSDBFactory enum class
     tsdb_connector_factory = ObjectTSDBFactory(tsdb_connector_type)

mlrun/model_monitoring/db/tsdb/v3io/v3io_connector.py

@@ -38,7 +38,10 @@ def _is_no_schema_error(exc: v3io_frames.ReadError) -> bool:
     In case of a nonexistent TSDB table - a `v3io_frames.ReadError` error is raised.
     Check if the error message contains the relevant string to verify the cause.
     """
-    return "No TSDB schema file found" in str(exc)
+    msg = str(exc)
+    # https://github.com/v3io/v3io-tsdb/blob/v0.14.1/pkg/tsdb/v3iotsdb.go#L205
+    # https://github.com/v3io/v3io-tsdb/blob/v0.14.1/pkg/partmgr/partmgr.go#L238
+    return "No TSDB schema file found" in msg or "Failed to read schema at path" in msg
 
 
 class V3IOTSDBConnector(TSDBConnector):
@@ -596,7 +599,6 @@ class V3IOTSDBConnector(TSDBConnector):
             end=end,
             columns=[mm_schemas.EventFieldType.LATENCY],
             filter_query=f"endpoint_id=='{endpoint_id}'",
-            interval=aggregation_window,
             agg_funcs=agg_funcs,
             sliding_window_step=aggregation_window,
         )