mlrun 1.4.0rc25__py3-none-any.whl → 1.5.0rc2__py3-none-any.whl

mlrun/model_monitoring/prometheus.py

@@ -0,0 +1,219 @@
+# Copyright 2023 Iguazio
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# 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 typing
+
+import prometheus_client
+
+from mlrun.common.schemas.model_monitoring import EventFieldType, PrometheusMetric
+
+# Memory path for Prometheus registry file
+_registry_path = "/tmp/prom-reg.txt"
+
+# Initializing Promethues metric collector registry
+_registry: prometheus_client.CollectorRegistry = prometheus_client.CollectorRegistry()
+
+# The following real-time metrics are being updated through the monitoring stream graph steps
+_prediction_counter: prometheus_client.Counter = prometheus_client.Counter(
+    name=PrometheusMetric.PREDICTIONS_TOTAL,
+    documentation="Counter for total predictions",
+    registry=_registry,
+    labelnames=[
+        EventFieldType.PROJECT,
+        EventFieldType.ENDPOINT_ID,
+        EventFieldType.MODEL,
+        EventFieldType.ENDPOINT_TYPE,
+    ],
+)
+_model_latency: prometheus_client.Summary = prometheus_client.Summary(
+    name=PrometheusMetric.MODEL_LATENCY_SECONDS,
+    documentation="Summary for for model latency",
+    registry=_registry,
+    labelnames=[
+        EventFieldType.PROJECT,
+        EventFieldType.ENDPOINT_ID,
+        EventFieldType.MODEL,
+        EventFieldType.ENDPOINT_TYPE,
+    ],
+)
+_income_features: prometheus_client.Gauge = prometheus_client.Gauge(
+    name=PrometheusMetric.INCOME_FEATURES,
+    documentation="Samples of features and predictions",
+    registry=_registry,
+    labelnames=[
+        EventFieldType.PROJECT,
+        EventFieldType.ENDPOINT_ID,
+        EventFieldType.METRIC,
+    ],
+)
+_error_counter: prometheus_client.Counter = prometheus_client.Counter(
+    name=PrometheusMetric.ERRORS_TOTAL,
+    documentation="Counter for total errors",
+    registry=_registry,
+    labelnames=[
+        EventFieldType.PROJECT,
+        EventFieldType.ENDPOINT_ID,
+        EventFieldType.MODEL,
+    ],
+)
+
+# The following metrics are being updated through the model monitoring batch job
+_batch_metrics: prometheus_client.Gauge = prometheus_client.Gauge(
+    name=PrometheusMetric.DRIFT_METRICS,
+    documentation="Results from the batch drift analysis",
+    registry=_registry,
+    labelnames=[
+        EventFieldType.PROJECT,
+        EventFieldType.ENDPOINT_ID,
+        EventFieldType.METRIC,
+    ],
+)
+_drift_status: prometheus_client.Enum = prometheus_client.Enum(
+    name=PrometheusMetric.DRIFT_STATUS,
+    documentation="Drift status of the model endpoint",
+    registry=_registry,
+    states=["NO_DRIFT", "DRIFT_DETECTED", "POSSIBLE_DRIFT"],
+    labelnames=[EventFieldType.PROJECT, EventFieldType.ENDPOINT_ID],
+)
+
+
+def _write_registry(func):
+    def wrapper(*args, **kwargs):
+        global _registry
+        """A wrapper function to update the registry file each time a metric has been updated"""
+        func(*args, **kwargs)
+        prometheus_client.write_to_textfile(path=_registry_path, registry=_registry)
+
+    return wrapper
+
+
+@_write_registry
+def write_predictions_and_latency_metrics(
+    project: str, endpoint_id: str, latency: int, model_name: str, endpoint_type: int
+):
+    """
+    Update the prediction counter and the latency value of the provided model endpoint within Prometheus registry.
+    Please note that while the prediction counter is ALWAYS increasing by 1,the latency summary metric is being
+    increased by the event latency time. Grafana dashboard will query the average latency time by dividing the total
+    latency value by the total amount of predictions.
+
+    :param project:       Project name.
+    :param endpoint_id:   Model endpoint unique id.
+    :param latency:       Latency time (microsecond) in which the event has been processed through the model server.
+    :param model_name:    Model name which will be used by Grafana for displaying the results by model.
+    :param endpoint_type: Endpoint type that is represented by an int (possible values: 1,2,3) corresponding to the
+                          Enum class :py:class:`~mlrun.common.schemas.model_monitoring.EndpointType`.
+    """
+
+    # Increase the prediction counter by 1
+    _prediction_counter.labels(
+        project=project,
+        endpoint_id=endpoint_id,
+        model=model_name,
+        endpoint_type=endpoint_type,
+    ).inc(1)
+
+    # Increase the latency value according to the provided latency of the current event
+    _model_latency.labels(
+        project=project,
+        endpoint_id=endpoint_id,
+        model=model_name,
+        endpoint_type=endpoint_type,
+    ).observe(latency)
+
+
+@_write_registry
+def write_income_features(
+    project: str, endpoint_id: str, features: typing.Dict[str, float]
+):
+    """Update a sample of features.
+
+    :param project:     Project name.
+    :param endpoint_id: Model endpoint unique id.
+    :param features:    Dictionary in which the key is a feature name and the value is a float number.
+
+
+    """
+
+    for metric in features:
+        _income_features.labels(
+            project=project, endpoint_id=endpoint_id, metric=metric
+        ).set(value=features[metric])
+
+
+@_write_registry
+def write_drift_metrics(project: str, endpoint_id: str, metric: str, value: float):
+    """Update drift metrics that have been calculated through the monitoring batch job
+
+    :param project:     Project name.
+    :param endpoint_id: Model endpoint unique id.
+    :param metric:      Metric name (e.g. TVD, Hellinger).
+    :param value:       Metric value as a float.
+
+    """
+
+    _batch_metrics.labels(project=project, endpoint_id=endpoint_id, metric=metric).set(
+        value=value
+    )
+
+
+@_write_registry
+def write_drift_status(project: str, endpoint_id: str, drift_status: str):
+    """
+    Update the drift status enum for a specific model endpoint.
+
+    :param project:      Project name.
+    :param endpoint_id:  Model endpoint unique id.
+    :param drift_status: Drift status value, can be one of the following: 'NO_DRIFT', 'DRIFT_DETECTED', or
+                         'POSSIBLE_DRIFT'.
+    """
+
+    _drift_status.labels(project=project, endpoint_id=endpoint_id).state(drift_status)
+
+
+@_write_registry
+def write_errors(project: str, endpoint_id: str, model_name: str):
+    """
+    Update the error counter for a specific model endpoint.
+
+    :param project:     Project name.
+    :param endpoint_id: Model endpoint unique id.
+    :param model_name:  Model name. Will be used by Grafana to show the amount of errors per model by time.
+    """
+
+    _error_counter.labels(
+        project=project, endpoint_id=endpoint_id, model=model_name
+    ).inc(1)
+
+
+def get_registry() -> str:
+    """Returns the parsed registry file according to the exposition format of Prometheus."""
+
+    # Read the registry file (note that the text is stored in UTF-8 format)
+    f = open(_registry_path)
+    lines = f.read()
+    f.close()
+
+    # Reset part of the metrics to avoid a repeating scraping of the same value
+    clean_metrics()
+
+    return lines
+
+
+@_write_registry
+def clean_metrics():
+    """Clean the income features values. As these results are relevant only for a certain timestamp, we will remove
+    them from the global registry after they have been scraped by Prometheus."""
+
+    _income_features.clear()

mlrun/model_monitoring/stores/__init__.py

@@ -17,7 +17,8 @@
 import enum
 import typing
 
-import mlrun
+import mlrun.common.schemas.secret
+import mlrun.errors
 
 from .model_endpoint_store import ModelEndpointStore
 
@@ -33,6 +34,7 @@ class ModelEndpointStoreType(enum.Enum):
         project: str,
         access_key: str = None,
         endpoint_store_connection: str = None,
+        secret_provider: typing.Callable = None,
     ) -> ModelEndpointStore:
         """
         Return a ModelEndpointStore object based on the provided enum value.
@@ -46,13 +48,13 @@ class ModelEndpointStoreType(enum.Enum):
                                           e.g. A root user with password 1234, tries to connect a schema called
                                           mlrun within a local MySQL DB instance:
                                           'mysql+pymysql://root:1234@localhost:3306/mlrun'.
+        :param secret_provider:           An optional secret provider to get the connection string secret.
 
         :return: `ModelEndpointStore` object.
 
         """
 
         if self.value == ModelEndpointStoreType.v3io_nosql.value:
-
             from .kv_model_endpoint_store import KVModelEndpointStore
 
             # Get V3IO access key from env
@@ -62,15 +64,13 @@ class ModelEndpointStoreType(enum.Enum):
 
         # Assuming SQL store target if store type is not KV.
         # Update these lines once there are more than two store target types.
-        from mlrun.utils.model_monitoring import get_connection_string
 
-        sql_connection_string = endpoint_store_connection or get_connection_string(
-            project=project
-        )
         from .sql_model_endpoint_store import SQLModelEndpointStore
 
         return SQLModelEndpointStore(
-            project=project, sql_connection_string=sql_connection_string
+            project=project,
+            sql_connection_string=endpoint_store_connection,
+            secret_provider=secret_provider,
         )
 
     @classmethod
@@ -85,13 +85,16 @@ class ModelEndpointStoreType(enum.Enum):
 
 
 def get_model_endpoint_store(
-    project: str, access_key: str = None
+    project: str,
+    access_key: str = None,
+    secret_provider: typing.Callable = None,
 ) -> ModelEndpointStore:
     """
     Getting the DB target type based on mlrun.config.model_endpoint_monitoring.store_type.
 
-    :param project:    The name of the project.
-    :param access_key: Access key with permission to the DB table.
+    :param project:         The name of the project.
+    :param access_key:      Access key with permission to the DB table.
+    :param secret_provider: An optional secret provider to get the connection string secret.
 
     :return: `ModelEndpointStore` object. Using this object, the user can apply different operations on the
              model endpoint record such as write, update, get and delete.
@@ -103,4 +106,6 @@ def get_model_endpoint_store(
     )
 
     # Convert into model endpoint store target object
-    return model_endpoint_store_type.to_endpoint_store(project, access_key)
+    return model_endpoint_store_type.to_endpoint_store(
+        project=project, access_key=access_key, secret_provider=secret_provider
+    )

mlrun/model_monitoring/stores/kv_model_endpoint_store.py

@@ -13,15 +13,16 @@
 # limitations under the License.
 #
 
+import json
 import os
 import typing
+import warnings
 
 import v3io.dataplane
 import v3io_frames
 
-import mlrun
-import mlrun.common.model_monitoring as model_monitoring_constants
-import mlrun.utils.model_monitoring
+import mlrun.common.model_monitoring.helpers
+import mlrun.common.schemas.model_monitoring
 import mlrun.utils.v3io_clients
 from mlrun.utils import logger
 
@@ -54,7 +55,7 @@ class KVModelEndpointStore(ModelEndpointStore):
         self.client.kv.put(
             container=self.container,
             table_path=self.path,
-            key=endpoint[model_monitoring_constants.EventFieldType.UID],
+            key=endpoint[mlrun.common.schemas.model_monitoring.EventFieldType.UID],
             attributes=endpoint,
         )
 
@@ -121,7 +122,7 @@ class KVModelEndpointStore(ModelEndpointStore):
             raise mlrun.errors.MLRunNotFoundError(f"Endpoint {endpoint_id} not found")
 
         # For backwards compatability: replace null values for `error_count` and `metrics`
-        mlrun.utils.model_monitoring.validate_old_schema_fields(endpoint=endpoint)
+        self.validate_old_schema_fields(endpoint=endpoint)
 
         return endpoint
 
@@ -129,13 +130,15 @@ class KVModelEndpointStore(ModelEndpointStore):
         """Getting path and container based on the model monitoring configurations"""
         path = mlrun.mlconf.model_endpoint_monitoring.store_prefixes.default.format(
             project=self.project,
-            kind=model_monitoring_constants.ModelMonitoringStoreKinds.ENDPOINTS,
+            kind=mlrun.common.schemas.ModelMonitoringStoreKinds.ENDPOINTS,
         )
         (
             _,
             container,
             path,
-        ) = mlrun.utils.model_monitoring.parse_model_endpoint_store_prefix(path)
+        ) = mlrun.common.model_monitoring.helpers.parse_model_endpoint_store_prefix(
+            path
+        )
         return path, container
 
     def list_model_endpoints(
@@ -190,13 +193,17 @@ class KVModelEndpointStore(ModelEndpointStore):
         if uids is None:
             uids = []
             for item in items:
-                if model_monitoring_constants.EventFieldType.UID not in item:
+                if mlrun.common.schemas.model_monitoring.EventFieldType.UID not in item:
                     # This is kept for backwards compatibility - in old versions the key column named endpoint_id
                     uids.append(
-                        item[model_monitoring_constants.EventFieldType.ENDPOINT_ID]
+                        item[
+                            mlrun.common.schemas.model_monitoring.EventFieldType.ENDPOINT_ID
+                        ]
                     )
                 else:
-                    uids.append(item[model_monitoring_constants.EventFieldType.UID])
+                    uids.append(
+                        item[mlrun.common.schemas.model_monitoring.EventFieldType.UID]
+                    )
 
         # Add each relevant model endpoint to the model endpoints list
         for endpoint_id in uids:
@@ -218,14 +225,17 @@ class KVModelEndpointStore(ModelEndpointStore):
 
         # Delete model endpoint record from KV table
         for endpoint_dict in endpoints:
-            if model_monitoring_constants.EventFieldType.UID not in endpoint_dict:
+            if (
+                mlrun.common.schemas.model_monitoring.EventFieldType.UID
+                not in endpoint_dict
+            ):
                 # This is kept for backwards compatibility - in old versions the key column named endpoint_id
                 endpoint_id = endpoint_dict[
-                    model_monitoring_constants.EventFieldType.ENDPOINT_ID
+                    mlrun.common.schemas.model_monitoring.EventFieldType.ENDPOINT_ID
                 ]
             else:
                 endpoint_id = endpoint_dict[
-                    model_monitoring_constants.EventFieldType.UID
+                    mlrun.common.schemas.model_monitoring.EventFieldType.UID
                 ]
             self.delete_model_endpoint(
                 endpoint_id,
@@ -262,7 +272,7 @@ class KVModelEndpointStore(ModelEndpointStore):
         # Delete time series DB resources
         try:
             frames.delete(
-                backend=model_monitoring_constants.TimeSeriesTarget.TSDB,
+                backend=mlrun.common.schemas.model_monitoring.TimeSeriesTarget.TSDB,
                 table=filtered_path,
             )
         except (v3io_frames.errors.DeleteError, v3io_frames.errors.CreateError) as e:
@@ -319,14 +329,16 @@ class KVModelEndpointStore(ModelEndpointStore):
         events_path = (
             mlrun.mlconf.model_endpoint_monitoring.store_prefixes.default.format(
                 project=self.project,
-                kind=model_monitoring_constants.ModelMonitoringStoreKinds.EVENTS,
+                kind=mlrun.common.schemas.ModelMonitoringStoreKinds.EVENTS,
             )
         )
         (
             _,
             container,
             events_path,
-        ) = mlrun.utils.model_monitoring.parse_model_endpoint_store_prefix(events_path)
+        ) = mlrun.common.model_monitoring.helpers.parse_model_endpoint_store_prefix(
+            events_path
+        )
 
         # Retrieve the raw data from the time series DB based on the provided metrics and time ranges
         frames_client = mlrun.utils.v3io_clients.get_frames_client(
@@ -337,7 +349,7 @@ class KVModelEndpointStore(ModelEndpointStore):
 
         try:
             data = frames_client.read(
-                backend=model_monitoring_constants.TimeSeriesTarget.TSDB,
+                backend=mlrun.common.schemas.model_monitoring.TimeSeriesTarget.TSDB,
                 table=events_path,
                 columns=["endpoint_id", *metrics],
                 filter=f"endpoint_id=='{endpoint_id}'",
@@ -372,13 +384,15 @@ class KVModelEndpointStore(ModelEndpointStore):
         full_path = (
             mlrun.mlconf.model_endpoint_monitoring.store_prefixes.default.format(
                 project=self.project,
-                kind=model_monitoring_constants.ModelMonitoringStoreKinds.EVENTS,
+                kind=mlrun.common.schemas.ModelMonitoringStoreKinds.EVENTS,
             )
         )
 
         # Generate the main directory with the TSDB resources
-        tsdb_path = mlrun.utils.model_monitoring.parse_model_endpoint_project_prefix(
-            full_path, self.project
+        tsdb_path = (
+            mlrun.common.model_monitoring.helpers.parse_model_endpoint_project_prefix(
+                full_path, self.project
+            )
         )
 
         # Generate filtered path without schema and container as required by the frames object
@@ -386,7 +400,9 @@ class KVModelEndpointStore(ModelEndpointStore):
             _,
             _,
             filtered_path,
-        ) = mlrun.utils.model_monitoring.parse_model_endpoint_store_prefix(full_path)
+        ) = mlrun.common.model_monitoring.helpers.parse_model_endpoint_store_prefix(
+            full_path
+        )
         return tsdb_path, filtered_path
 
     @staticmethod
@@ -441,8 +457,64 @@ class KVModelEndpointStore(ModelEndpointStore):
         # Apply top_level filter (remove endpoints that considered a child of a router)
         if top_level:
             filter_expression.append(
-                f"(endpoint_type=='{str(model_monitoring_constants.EndpointType.NODE_EP.value)}' "
-                f"OR  endpoint_type=='{str(model_monitoring_constants.EndpointType.ROUTER.value)}')"
+                f"(endpoint_type=='{str(mlrun.common.schemas.model_monitoring.EndpointType.NODE_EP.value)}' "
+                f"OR  endpoint_type=='{str(mlrun.common.schemas.model_monitoring.EndpointType.ROUTER.value)}')"
             )
 
         return " AND ".join(filter_expression)
+
+    @staticmethod
+    def validate_old_schema_fields(endpoint: dict):
+        """
+        Replace default null values for `error_count` and `metrics` for users that logged a model endpoint before 1.3.0.
+        In addition, this function also validates that the key name of the endpoint unique id is `uid` and not
+         `endpoint_id` that has been used before 1.3.0.
+
+        Leaving here for backwards compatibility which related to the model endpoint schema.
+
+        :param endpoint: An endpoint flattened dictionary.
+        """
+        warnings.warn(
+            "This will be deprecated in 1.3.0, and will be removed in 1.5.0",
+            # TODO: In 1.3.0 do changes in examples & demos In 1.5.0 remove
+            FutureWarning,
+        )
+
+        # Validate default value for `error_count`
+        # For backwards compatibility reasons, we validate that the model endpoint includes the `error_count` key
+        if (
+            mlrun.common.schemas.model_monitoring.EventFieldType.ERROR_COUNT in endpoint
+            and endpoint[
+                mlrun.common.schemas.model_monitoring.EventFieldType.ERROR_COUNT
+            ]
+            == "null"
+        ):
+            endpoint[
+                mlrun.common.schemas.model_monitoring.EventFieldType.ERROR_COUNT
+            ] = "0"
+
+        # Validate default value for `metrics`
+        # For backwards compatibility reasons, we validate that the model endpoint includes the `metrics` key
+        if (
+            mlrun.common.schemas.model_monitoring.EventFieldType.METRICS in endpoint
+            and endpoint[mlrun.common.schemas.model_monitoring.EventFieldType.METRICS]
+            == "null"
+        ):
+            endpoint[
+                mlrun.common.schemas.model_monitoring.EventFieldType.METRICS
+            ] = json.dumps(
+                {
+                    mlrun.common.schemas.model_monitoring.EventKeyMetrics.GENERIC: {
+                        mlrun.common.schemas.model_monitoring.EventLiveStats.LATENCY_AVG_1H: 0,
+                        mlrun.common.schemas.model_monitoring.EventLiveStats.PREDICTIONS_PER_SECOND: 0,
+                    }
+                }
+            )
+        # Validate key `uid` instead of `endpoint_id`
+        # For backwards compatibility reasons, we replace the `endpoint_id` with `uid` which is the updated key name
+        if mlrun.common.schemas.model_monitoring.EventFieldType.ENDPOINT_ID in endpoint:
+            endpoint[
+                mlrun.common.schemas.model_monitoring.EventFieldType.UID
+            ] = endpoint[
+                mlrun.common.schemas.model_monitoring.EventFieldType.ENDPOINT_ID
+            ]

mlrun/model_monitoring/stores/models/mysql.py

@@ -17,84 +17,102 @@
 import sqlalchemy.dialects
 from sqlalchemy import Boolean, Column, Integer, String, Text
 
-import mlrun.common.model_monitoring as model_monitoring_constants
+import mlrun.common.schemas.model_monitoring
 from mlrun.utils.db import BaseModel
 
 from .base import Base
 
 
 class ModelEndpointsTable(Base, BaseModel):
-    __tablename__ = model_monitoring_constants.EventFieldType.MODEL_ENDPOINTS
+    __tablename__ = mlrun.common.schemas.model_monitoring.EventFieldType.MODEL_ENDPOINTS
 
     uid = Column(
-        model_monitoring_constants.EventFieldType.UID,
+        mlrun.common.schemas.model_monitoring.EventFieldType.UID,
         String(40),
         primary_key=True,
     )
-    state = Column(model_monitoring_constants.EventFieldType.STATE, String(10))
-    project = Column(model_monitoring_constants.EventFieldType.PROJECT, String(40))
+    state = Column(
+        mlrun.common.schemas.model_monitoring.EventFieldType.STATE, String(10)
+    )
+    project = Column(
+        mlrun.common.schemas.model_monitoring.EventFieldType.PROJECT, String(40)
+    )
     function_uri = Column(
-        model_monitoring_constants.EventFieldType.FUNCTION_URI,
+        mlrun.common.schemas.model_monitoring.EventFieldType.FUNCTION_URI,
         String(255),
     )
-    model = Column(model_monitoring_constants.EventFieldType.MODEL, String(255))
+    model = Column(
+        mlrun.common.schemas.model_monitoring.EventFieldType.MODEL, String(255)
+    )
     model_class = Column(
-        model_monitoring_constants.EventFieldType.MODEL_CLASS,
+        mlrun.common.schemas.model_monitoring.EventFieldType.MODEL_CLASS,
         String(255),
     )
-    labels = Column(model_monitoring_constants.EventFieldType.LABELS, Text)
-    model_uri = Column(model_monitoring_constants.EventFieldType.MODEL_URI, String(255))
-    stream_path = Column(model_monitoring_constants.EventFieldType.STREAM_PATH, Text)
+    labels = Column(mlrun.common.schemas.model_monitoring.EventFieldType.LABELS, Text)
+    model_uri = Column(
+        mlrun.common.schemas.model_monitoring.EventFieldType.MODEL_URI, String(255)
+    )
+    stream_path = Column(
+        mlrun.common.schemas.model_monitoring.EventFieldType.STREAM_PATH, Text
+    )
     algorithm = Column(
-        model_monitoring_constants.EventFieldType.ALGORITHM,
+        mlrun.common.schemas.model_monitoring.EventFieldType.ALGORITHM,
         String(255),
     )
-    active = Column(model_monitoring_constants.EventFieldType.ACTIVE, Boolean)
+    active = Column(
+        mlrun.common.schemas.model_monitoring.EventFieldType.ACTIVE, Boolean
+    )
     monitoring_mode = Column(
-        model_monitoring_constants.EventFieldType.MONITORING_MODE,
+        mlrun.common.schemas.model_monitoring.EventFieldType.MONITORING_MODE,
         String(10),
     )
     feature_stats = Column(
-        model_monitoring_constants.EventFieldType.FEATURE_STATS, Text
+        mlrun.common.schemas.model_monitoring.EventFieldType.FEATURE_STATS, Text
     )
     current_stats = Column(
-        model_monitoring_constants.EventFieldType.CURRENT_STATS, Text
+        mlrun.common.schemas.model_monitoring.EventFieldType.CURRENT_STATS, Text
     )
     feature_names = Column(
-        model_monitoring_constants.EventFieldType.FEATURE_NAMES, Text
+        mlrun.common.schemas.model_monitoring.EventFieldType.FEATURE_NAMES, Text
+    )
+    children = Column(
+        mlrun.common.schemas.model_monitoring.EventFieldType.CHILDREN, Text
+    )
+    label_names = Column(
+        mlrun.common.schemas.model_monitoring.EventFieldType.LABEL_NAMES, Text
     )
-    children = Column(model_monitoring_constants.EventFieldType.CHILDREN, Text)
-    label_names = Column(model_monitoring_constants.EventFieldType.LABEL_NAMES, Text)
 
     endpoint_type = Column(
-        model_monitoring_constants.EventFieldType.ENDPOINT_TYPE,
+        mlrun.common.schemas.model_monitoring.EventFieldType.ENDPOINT_TYPE,
         String(10),
     )
     children_uids = Column(
-        model_monitoring_constants.EventFieldType.CHILDREN_UIDS, Text
+        mlrun.common.schemas.model_monitoring.EventFieldType.CHILDREN_UIDS, Text
     )
     drift_measures = Column(
-        model_monitoring_constants.EventFieldType.DRIFT_MEASURES, Text
+        mlrun.common.schemas.model_monitoring.EventFieldType.DRIFT_MEASURES, Text
     )
     drift_status = Column(
-        model_monitoring_constants.EventFieldType.DRIFT_STATUS,
+        mlrun.common.schemas.model_monitoring.EventFieldType.DRIFT_STATUS,
         String(40),
     )
     monitor_configuration = Column(
-        model_monitoring_constants.EventFieldType.MONITOR_CONFIGURATION,
+        mlrun.common.schemas.model_monitoring.EventFieldType.MONITOR_CONFIGURATION,
         Text,
     )
     monitoring_feature_set_uri = Column(
-        model_monitoring_constants.EventFieldType.FEATURE_SET_URI,
+        mlrun.common.schemas.model_monitoring.EventFieldType.FEATURE_SET_URI,
         String(255),
     )
     first_request = Column(
-        model_monitoring_constants.EventFieldType.FIRST_REQUEST,
+        mlrun.common.schemas.model_monitoring.EventFieldType.FIRST_REQUEST,
         sqlalchemy.dialects.mysql.TIMESTAMP(fsp=3),
     )
     last_request = Column(
-        model_monitoring_constants.EventFieldType.LAST_REQUEST,
+        mlrun.common.schemas.model_monitoring.EventFieldType.LAST_REQUEST,
         sqlalchemy.dialects.mysql.TIMESTAMP(fsp=3),
     )
-    error_count = Column(model_monitoring_constants.EventFieldType.ERROR_COUNT, Integer)
-    metrics = Column(model_monitoring_constants.EventFieldType.METRICS, Text)
+    error_count = Column(
+        mlrun.common.schemas.model_monitoring.EventFieldType.ERROR_COUNT, Integer
+    )
+    metrics = Column(mlrun.common.schemas.model_monitoring.EventFieldType.METRICS, Text)