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

mlrun/model_monitoring/helpers.py

@@ -12,232 +12,44 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 #
-import pathlib
-import typing
-
-import sqlalchemy.orm
-from fastapi import Depends
-
-import mlrun
-import mlrun.api.api.utils
-import mlrun.api.crud.secrets
-import mlrun.api.utils.singletons.db
-import mlrun.api.utils.singletons.k8s
-import mlrun.common.model_monitoring as model_monitoring_constants
-import mlrun.common.schemas
-import mlrun.config
-import mlrun.feature_store as fstore
-import mlrun.model_monitoring.stream_processing_fs
-import mlrun.runtimes
-import mlrun.utils.helpers
-import mlrun.utils.model_monitoring
-from mlrun.api.api import deps
-
-_CURRENT_FILE_PATH = pathlib.Path(__file__)
-_STREAM_PROCESSING_FUNCTION_PATH = _CURRENT_FILE_PATH.parent / "stream_processing_fs.py"
-_MONIOTINRG_BATCH_FUNCTION_PATH = (
-    _CURRENT_FILE_PATH.parent / "model_monitoring_batch.py"
-)
-
 
-def initial_model_monitoring_stream_processing_function(
-    project: str,
-    model_monitoring_access_key: str,
-    tracking_policy: mlrun.utils.model_monitoring.TrackingPolicy,
-    auth_info: mlrun.common.schemas.AuthInfo,
-    parquet_target: str,
-):
-    """
-    Initialize model monitoring stream processing function.
-
-    :param project:                     Project name.
-    :param model_monitoring_access_key: Access key to apply the model monitoring process. Please note that in CE
-                                        deployments this parameter will be None.
-    :param tracking_policy:             Model monitoring configurations.
-    :param auth_info:                   The auth info of the request.
-    :parquet_target:                    Path to model monitoring parquet file that will be generated by the monitoring
-                                        stream nuclio function.
-
-    :return:                            A function object from a mlrun runtime class
-
-    """
 
-    # Initialize Stream Processor object
-    stream_processor = mlrun.model_monitoring.stream_processing_fs.EventStreamProcessor(
-        project=project,
-        parquet_batching_max_events=mlrun.mlconf.model_endpoint_monitoring.parquet_batching_max_events,
-        parquet_target=parquet_target,
-        model_monitoring_access_key=model_monitoring_access_key,
-    )
+import typing
 
-    # Create a new serving function for the streaming process
-    function = mlrun.code_to_function(
-        name="model-monitoring-stream",
-        project=project,
-        filename=str(_STREAM_PROCESSING_FUNCTION_PATH),
-        kind="serving",
-        image=tracking_policy.stream_image,
-    )
+import mlrun.common.model_monitoring.helpers
+import mlrun.common.schemas
 
-    # Create monitoring serving graph
-    stream_processor.apply_monitoring_serving_graph(function)
 
-    # Set the project to the serving function
-    function.metadata.project = project
+def get_stream_path(project: str = None):
+    """Get stream path from the project secret. If wasn't set, take it from the system configurations"""
 
-    # Add stream triggers
-    function = _apply_stream_trigger(
+    stream_uri = mlrun.get_secret_or_env(
+        mlrun.common.schemas.model_monitoring.ProjectSecretKeys.STREAM_PATH
+    ) or mlrun.mlconf.get_model_monitoring_file_target_path(
         project=project,
-        function=function,
-        model_monitoring_access_key=model_monitoring_access_key,
-        auth_info=auth_info,
+        kind=mlrun.common.schemas.model_monitoring.FileTargetKind.STREAM,
+        target="online",
     )
 
-    # Apply feature store run configurations on the serving function
-    run_config = fstore.RunConfig(function=function, local=False)
-    function.spec.parameters = run_config.parameters
-
-    return function
-
-
-def get_model_monitoring_batch_function(
-    project: str,
-    model_monitoring_access_key: str,
-    db_session: sqlalchemy.orm.Session,
-    auth_info: mlrun.common.schemas.AuthInfo,
-    tracking_policy: mlrun.utils.model_monitoring.TrackingPolicy,
-):
-    """
-    Initialize model monitoring batch function.
-
-    :param project:                     project name.
-    :param model_monitoring_access_key: access key to apply the model monitoring process. Please note that in CE
-                                        deployments this parameter will be None.
-    :param db_session:                  A session that manages the current dialog with the database.
-    :param auth_info:                   The auth info of the request.
-    :param tracking_policy:             Model monitoring configurations.
-
-    :return:                            A function object from a mlrun runtime class
-
-    """
-
-    # Create job function runtime for the model monitoring batch
-    function: mlrun.runtimes.KubejobRuntime = mlrun.code_to_function(
-        name="model-monitoring-batch",
-        project=project,
-        filename=str(_MONIOTINRG_BATCH_FUNCTION_PATH),
-        kind="job",
-        image=tracking_policy.default_batch_image,
-        handler="handler",
+    return mlrun.common.model_monitoring.helpers.parse_monitoring_stream_path(
+        stream_uri=stream_uri, project=project
     )
-    function.set_db_connection(mlrun.api.api.utils.get_run_db_instance(db_session))
 
-    # Set the project to the job function
-    function.metadata.project = project
 
-    if not mlrun.mlconf.is_ce_mode():
-        function = _apply_access_key_and_mount_function(
-            project=project,
-            function=function,
-            model_monitoring_access_key=model_monitoring_access_key,
-            auth_info=auth_info,
-        )
+def get_connection_string(secret_provider: typing.Callable = None) -> str:
+    """Get endpoint store connection string from the project secret. If wasn't set, take it from the system
+    configurations.
 
-    # Enrich runtime with the required configurations
-    mlrun.api.api.utils.apply_enrichment_and_validation_on_function(function, auth_info)
+    :param secret_provider: An optional secret provider to get the connection string secret.
 
-    return function
+    :return:                Valid SQL connection string.
 
-
-def _apply_stream_trigger(
-    project: str,
-    function: mlrun.runtimes.ServingRuntime,
-    model_monitoring_access_key: str = None,
-    auth_info: mlrun.common.schemas.AuthInfo = Depends(deps.authenticate_request),
-) -> mlrun.runtimes.ServingRuntime:
-    """Adding stream source for the nuclio serving function. By default, the function has HTTP stream trigger along
-    with another supported stream source that can be either Kafka or V3IO, depends on the stream path schema that is
-    defined under mlrun.mlconf.model_endpoint_monitoring.store_prefixes. Note that if no valid stream path has been
-    provided then the function will have a single HTTP stream source.
-
-    :param project:                     Project name.
-    :param function:                    The serving function object that will be applied with the stream trigger.
-    :param model_monitoring_access_key: Access key to apply the model monitoring stream function when the stream is
-                                        schema is V3IO.
-    :param auth_info:                   The auth info of the request.
-
-    :return: ServingRuntime object with stream trigger.
     """
 
-    # Get the stream path from the configuration
-    # stream_path = mlrun.mlconf.get_file_target_path(project=project, kind="stream", target="stream")
-    stream_path = mlrun.utils.model_monitoring.get_stream_path(project=project)
-
-    if stream_path.startswith("kafka://"):
-
-        topic, brokers = mlrun.datastore.utils.parse_kafka_url(url=stream_path)
-        # Generate Kafka stream source
-        stream_source = mlrun.datastore.sources.KafkaSource(
-            brokers=brokers,
-            topics=[topic],
+    return (
+        mlrun.get_secret_or_env(
+            key=mlrun.common.schemas.model_monitoring.ProjectSecretKeys.ENDPOINT_STORE_CONNECTION,
+            secret_provider=secret_provider,
         )
-        function = stream_source.add_nuclio_trigger(function)
-
-    if not mlrun.mlconf.is_ce_mode():
-        function = _apply_access_key_and_mount_function(
-            project=project,
-            function=function,
-            model_monitoring_access_key=model_monitoring_access_key,
-            auth_info=auth_info,
-        )
-        if stream_path.startswith("v3io://"):
-            # Generate V3IO stream trigger
-            function.add_v3io_stream_trigger(
-                stream_path=stream_path, name="monitoring_stream_trigger"
-            )
-    # Add the default HTTP source
-    http_source = mlrun.datastore.sources.HttpSource()
-    function = http_source.add_nuclio_trigger(function)
-
-    return function
-
-
-def _apply_access_key_and_mount_function(
-    project: str,
-    function: typing.Union[
-        mlrun.runtimes.KubejobRuntime, mlrun.runtimes.ServingRuntime
-    ],
-    model_monitoring_access_key: str,
-    auth_info: mlrun.common.schemas.AuthInfo,
-) -> typing.Union[mlrun.runtimes.KubejobRuntime, mlrun.runtimes.ServingRuntime]:
-    """Applying model monitoring access key on the provided function when using V3IO path. In addition, this method
-    mount the V3IO path for the provided function to configure the access to the system files.
-
-    :param project:                     Project name.
-    :param function:                    Model monitoring function object that will be filled with the access key and
-                                        the access to the system files.
-    :param model_monitoring_access_key: Access key to apply the model monitoring stream function when the stream is
-                                        schema is V3IO.
-    :param auth_info:                   The auth info of the request.
-
-    :return: function runtime object with access key and access to system files.
-    """
-
-    # Set model monitoring access key for managing permissions
-    function.set_env_from_secret(
-        model_monitoring_constants.ProjectSecretKeys.ACCESS_KEY,
-        mlrun.api.utils.singletons.k8s.get_k8s_helper().get_project_secret_name(
-            project
-        ),
-        mlrun.api.crud.secrets.Secrets().generate_client_project_secret_key(
-            mlrun.api.crud.secrets.SecretsClientType.model_monitoring,
-            model_monitoring_constants.ProjectSecretKeys.ACCESS_KEY,
-        ),
+        or mlrun.mlconf.model_endpoint_monitoring.endpoint_store_connection
     )
-    function.metadata.credentials.access_key = model_monitoring_access_key
-    function.apply(mlrun.mount_v3io())
-
-    # Ensure that the auth env vars are set
-    mlrun.api.api.utils.ensure_function_has_auth_set(function, auth_info)
-
-    return function

mlrun/model_monitoring/model_endpoint.py

@@ -16,7 +16,7 @@
 from typing import Any, Dict, List, Optional
 
 import mlrun.model
-from mlrun.common.model_monitoring import (
+from mlrun.common.schemas.model_monitoring.constants import (
     EndpointType,
     EventKeyMetrics,
     EventLiveStats,

mlrun/model_monitoring/model_monitoring_batch.py

@@ -27,16 +27,11 @@ import v3io
 import v3io.dataplane
 import v3io_frames
 
-import mlrun
-import mlrun.common.model_monitoring
-import mlrun.common.schemas
+import mlrun.common.helpers
+import mlrun.common.model_monitoring.helpers
+import mlrun.common.schemas.model_monitoring
 import mlrun.data_types.infer
 import mlrun.feature_store as fstore
-import mlrun.model_monitoring
-import mlrun.model_monitoring.stores
-import mlrun.run
-import mlrun.utils.helpers
-import mlrun.utils.model_monitoring
 import mlrun.utils.v3io_clients
 from mlrun.utils import logger
 
@@ -497,7 +492,6 @@ class BatchProcessor:
         context: mlrun.run.MLClientCtx,
         project: str,
     ):
-
         """
         Initialize Batch Processor object.
 
@@ -525,9 +519,7 @@ class BatchProcessor:
 
         # Get a runtime database
 
-        self.db = mlrun.model_monitoring.stores.get_model_endpoint_store(
-            project=project
-        )
+        self.db = mlrun.model_monitoring.get_model_endpoint_store(project=project)
 
         if not mlrun.mlconf.is_ce_mode():
             # TODO: Once there is a time series DB alternative in a non-CE deployment, we need to update this if
@@ -539,7 +531,7 @@ class BatchProcessor:
 
         # Get the batch interval range
         self.batch_dict = context.parameters[
-            mlrun.common.model_monitoring.EventFieldType.BATCH_INTERVALS_DICT
+            mlrun.common.schemas.model_monitoring.EventFieldType.BATCH_INTERVALS_DICT
         ]
 
         # TODO: This will be removed in 1.5.0 once the job params can be parsed with different types
@@ -556,23 +548,27 @@ class BatchProcessor:
         # Define the required paths for the project objects
         tsdb_path = mlrun.mlconf.get_model_monitoring_file_target_path(
             project=self.project,
-            kind=mlrun.common.model_monitoring.FileTargetKind.EVENTS,
+            kind=mlrun.common.schemas.model_monitoring.FileTargetKind.EVENTS,
         )
         (
             _,
             self.tsdb_container,
             self.tsdb_path,
-        ) = mlrun.utils.model_monitoring.parse_model_endpoint_store_prefix(tsdb_path)
+        ) = mlrun.common.model_monitoring.helpers.parse_model_endpoint_store_prefix(
+            tsdb_path
+        )
         # stream_path = template.format(project=self.project, kind="log_stream")
         stream_path = mlrun.mlconf.get_model_monitoring_file_target_path(
             project=self.project,
-            kind=mlrun.common.model_monitoring.FileTargetKind.LOG_STREAM,
+            kind=mlrun.common.schemas.model_monitoring.FileTargetKind.LOG_STREAM,
         )
         (
             _,
             self.stream_container,
             self.stream_path,
-        ) = mlrun.utils.model_monitoring.parse_model_endpoint_store_prefix(stream_path)
+        ) = mlrun.common.model_monitoring.helpers.parse_model_endpoint_store_prefix(
+            stream_path
+        )
 
         # Get the frames clients based on the v3io configuration
         # it will be used later for writing the results into the tsdb
@@ -619,24 +615,24 @@ class BatchProcessor:
 
         for endpoint in endpoints:
             if (
-                endpoint[mlrun.common.model_monitoring.EventFieldType.ACTIVE]
+                endpoint[mlrun.common.schemas.model_monitoring.EventFieldType.ACTIVE]
                 and endpoint[
-                    mlrun.common.model_monitoring.EventFieldType.MONITORING_MODE
+                    mlrun.common.schemas.model_monitoring.EventFieldType.MONITORING_MODE
                 ]
-                == mlrun.common.model_monitoring.ModelMonitoringMode.enabled.value
+                == mlrun.common.schemas.model_monitoring.ModelMonitoringMode.enabled.value
             ):
                 # Skip router endpoint:
                 if (
                     int(
                         endpoint[
-                            mlrun.common.model_monitoring.EventFieldType.ENDPOINT_TYPE
+                            mlrun.common.schemas.model_monitoring.EventFieldType.ENDPOINT_TYPE
                         ]
                     )
-                    == mlrun.common.model_monitoring.EndpointType.ROUTER
+                    == mlrun.common.schemas.model_monitoring.EndpointType.ROUTER
                 ):
                     # Router endpoint has no feature stats
                     logger.info(
-                        f"{endpoint[mlrun.common.model_monitoring.EventFieldType.UID]} is router skipping"
+                        f"{endpoint[mlrun.common.schemas.model_monitoring.EventFieldType.UID]} is router skipping"
                     )
                     continue
                 self.update_drift_metrics(endpoint=endpoint)
@@ -649,12 +645,14 @@ class BatchProcessor:
                 serving_function_name,
                 _,
                 _,
-            ) = mlrun.utils.helpers.parse_versioned_object_uri(
-                endpoint[mlrun.common.model_monitoring.EventFieldType.FUNCTION_URI]
+            ) = mlrun.common.helpers.parse_versioned_object_uri(
+                endpoint[
+                    mlrun.common.schemas.model_monitoring.EventFieldType.FUNCTION_URI
+                ]
             )
 
             model_name = endpoint[
-                mlrun.common.model_monitoring.EventFieldType.MODEL
+                mlrun.common.schemas.model_monitoring.EventFieldType.MODEL
             ].replace(":", "-")
 
             m_fs = fstore.get_feature_set(
@@ -668,7 +666,7 @@ class BatchProcessor:
                 df = m_fs.to_dataframe(
                     start_time=start_time,
                     end_time=end_time,
-                    time_column=mlrun.common.model_monitoring.EventFieldType.TIMESTAMP,
+                    time_column=mlrun.common.schemas.model_monitoring.EventFieldType.TIMESTAMP,
                 )
 
                 if len(df) == 0:
@@ -676,7 +674,7 @@ class BatchProcessor:
                         "Not enough model events since the beginning of the batch interval",
                         parquet_target=m_fs.status.targets[0].path,
                         endpoint=endpoint[
-                            mlrun.common.model_monitoring.EventFieldType.UID
+                            mlrun.common.schemas.model_monitoring.EventFieldType.UID
                         ],
                         min_rqeuired_events=mlrun.mlconf.model_endpoint_monitoring.parquet_batching_max_events,
                         start_time=str(
@@ -694,7 +692,9 @@ class BatchProcessor:
                 logger.warn(
                     "Parquet not found, probably due to not enough model events",
                     parquet_target=m_fs.status.targets[0].path,
-                    endpoint=endpoint[mlrun.common.model_monitoring.EventFieldType.UID],
+                    endpoint=endpoint[
+                        mlrun.common.schemas.model_monitoring.EventFieldType.UID
+                    ],
                     min_rqeuired_events=mlrun.mlconf.model_endpoint_monitoring.parquet_batching_max_events,
                 )
                 return
@@ -706,14 +706,16 @@ class BatchProcessor:
 
             # Create DataFrame based on the input features
             stats_columns = [
-                mlrun.common.model_monitoring.EventFieldType.TIMESTAMP,
+                mlrun.common.schemas.model_monitoring.EventFieldType.TIMESTAMP,
                 *feature_names,
             ]
 
             # Add label names if provided
-            if endpoint[mlrun.common.model_monitoring.EventFieldType.LABEL_NAMES]:
+            if endpoint[
+                mlrun.common.schemas.model_monitoring.EventFieldType.LABEL_NAMES
+            ]:
                 labels = endpoint[
-                    mlrun.common.model_monitoring.EventFieldType.LABEL_NAMES
+                    mlrun.common.schemas.model_monitoring.EventFieldType.LABEL_NAMES
                 ]
                 if isinstance(labels, str):
                     labels = json.loads(labels)
@@ -731,13 +733,15 @@ class BatchProcessor:
             m_fs.save()
 
             # Get the timestamp of the latest request:
-            timestamp = df[mlrun.common.model_monitoring.EventFieldType.TIMESTAMP].iloc[
-                -1
-            ]
+            timestamp = df[
+                mlrun.common.schemas.model_monitoring.EventFieldType.TIMESTAMP
+            ].iloc[-1]
 
             # Get the feature stats from the model endpoint for reference data
             feature_stats = json.loads(
-                endpoint[mlrun.common.model_monitoring.EventFieldType.FEATURE_STATS]
+                endpoint[
+                    mlrun.common.schemas.model_monitoring.EventFieldType.FEATURE_STATS
+                ]
             )
 
             # Get the current stats:
@@ -758,7 +762,7 @@ class BatchProcessor:
             monitor_configuration = (
                 json.loads(
                     endpoint[
-                        mlrun.common.model_monitoring.EventFieldType.MONITOR_CONFIGURATION
+                        mlrun.common.schemas.model_monitoring.EventFieldType.MONITOR_CONFIGURATION
                     ]
                 )
                 or {}
@@ -778,7 +782,9 @@ class BatchProcessor:
             )
             logger.info(
                 "Drift status",
-                endpoint_id=endpoint[mlrun.common.model_monitoring.EventFieldType.UID],
+                endpoint_id=endpoint[
+                    mlrun.common.schemas.model_monitoring.EventFieldType.UID
+                ],
                 drift_status=drift_status.value,
                 drift_measure=drift_measure,
             )
@@ -790,40 +796,54 @@ class BatchProcessor:
             }
 
             self.db.update_model_endpoint(
-                endpoint_id=endpoint[mlrun.common.model_monitoring.EventFieldType.UID],
+                endpoint_id=endpoint[
+                    mlrun.common.schemas.model_monitoring.EventFieldType.UID
+                ],
                 attributes=attributes,
             )
 
             if not mlrun.mlconf.is_ce_mode():
                 # Update drift results in TSDB
-                self._update_drift_in_input_stream(
+                self._update_drift_in_v3io_tsdb(
                     endpoint_id=endpoint[
-                        mlrun.common.model_monitoring.EventFieldType.UID
+                        mlrun.common.schemas.model_monitoring.EventFieldType.UID
                     ],
                     drift_status=drift_status,
                     drift_measure=drift_measure,
                     drift_result=drift_result,
                     timestamp=timestamp,
                 )
-                logger.info(
-                    "Done updating drift measures",
+
+            else:
+                # Update drift results in Prometheus
+                self._update_drift_in_prometheus(
                     endpoint_id=endpoint[
-                        mlrun.common.model_monitoring.EventFieldType.UID
+                        mlrun.common.schemas.model_monitoring.EventFieldType.UID
                     ],
+                    drift_status=drift_status,
+                    drift_result=drift_result,
                 )
 
         except Exception as e:
             logger.error(
-                f"Exception for endpoint {endpoint[mlrun.common.model_monitoring.EventFieldType.UID]}"
+                f"Exception for endpoint {endpoint[mlrun.common.schemas.model_monitoring.EventFieldType.UID]}"
             )
             self.exception = e
+        logger.info(
+            "Done updating drift measures",
+            endpoint_id=endpoint[
+                mlrun.common.schemas.model_monitoring.EventFieldType.UID
+            ],
+        )
 
     def _get_interval_range(self) -> Tuple[datetime.datetime, datetime.datetime]:
         """Getting batch interval time range"""
         minutes, hours, days = (
-            self.batch_dict[mlrun.common.model_monitoring.EventFieldType.MINUTES],
-            self.batch_dict[mlrun.common.model_monitoring.EventFieldType.HOURS],
-            self.batch_dict[mlrun.common.model_monitoring.EventFieldType.DAYS],
+            self.batch_dict[
+                mlrun.common.schemas.model_monitoring.EventFieldType.MINUTES
+            ],
+            self.batch_dict[mlrun.common.schemas.model_monitoring.EventFieldType.HOURS],
+            self.batch_dict[mlrun.common.schemas.model_monitoring.EventFieldType.DAYS],
         )
         start_time = datetime.datetime.now() - datetime.timedelta(
             minutes=minutes, hours=hours, days=days
@@ -843,7 +863,7 @@ class BatchProcessor:
             pair_list = pair.split(":")
             self.batch_dict[pair_list[0]] = float(pair_list[1])
 
-    def _update_drift_in_input_stream(
+    def _update_drift_in_v3io_tsdb(
         self,
         endpoint_id: str,
         drift_status: DriftStatus,
@@ -888,7 +908,7 @@ class BatchProcessor:
             "endpoint_id": endpoint_id,
             "timestamp": pd.to_datetime(
                 timestamp,
-                format=mlrun.common.model_monitoring.EventFieldType.TIME_FORMAT,
+                format=mlrun.common.schemas.model_monitoring.EventFieldType.TIME_FORMAT,
             ),
             "record_type": "drift_measures",
             "tvd_mean": drift_result["tvd_mean"],
@@ -911,6 +931,63 @@ class BatchProcessor:
                 endpoint=endpoint_id,
             )
 
+    def _update_drift_in_prometheus(
+        self,
+        endpoint_id: str,
+        drift_status: DriftStatus,
+        drift_result: Dict[str, Dict[str, Any]],
+    ):
+        """Push drift metrics to Prometheus registry. Please note that the metrics are being pushed through HTTP
+        to the monitoring stream pod that writes them into a local registry. Afterwards, Prometheus wil scrape these
+        metrics that will be available in the Grafana charts.
+
+        :param endpoint_id:   The unique id of the model endpoint.
+        :param drift_status:  Drift status result. Possible values can be found under DriftStatus enum class.
+        :param drift_result:  A dictionary that includes the drift results for each feature.
+
+
+        """
+        stream_http_path = (
+            mlrun.mlconf.model_endpoint_monitoring.default_http_sink.format(
+                project=self.project
+            )
+        )
+
+        statistical_metrics = ["hellinger_mean", "tvd_mean", "kld_mean"]
+        metrics = []
+        for metric in statistical_metrics:
+            metrics.append(
+                {
+                    mlrun.common.schemas.model_monitoring.EventFieldType.ENDPOINT_ID: endpoint_id,
+                    mlrun.common.schemas.model_monitoring.EventFieldType.METRIC: metric,
+                    mlrun.common.schemas.model_monitoring.EventFieldType.VALUE: drift_result[
+                        metric
+                    ],
+                }
+            )
+
+        http_session = mlrun.utils.HTTPSessionWithRetry(
+            retry_on_post=True,
+            verbose=True,
+        )
+
+        http_session.request(
+            method="POST",
+            url=stream_http_path + "/monitoring-batch-metrics",
+            data=json.dumps(metrics),
+        )
+
+        drift_status_dict = {
+            mlrun.common.schemas.model_monitoring.EventFieldType.ENDPOINT_ID: endpoint_id,
+            mlrun.common.schemas.model_monitoring.EventFieldType.DRIFT_STATUS: drift_status.value,
+        }
+
+        http_session.request(
+            method="POST",
+            url=stream_http_path + "/monitoring-drift-status",
+            data=json.dumps(drift_status_dict),
+        )
+
 
 def handler(context: mlrun.run.MLClientCtx):
     batch_processor = BatchProcessor(