mlrun 1.7.2rc3__py3-none-any.whl → 1.8.0__py3-none-any.whl

mlrun/model_monitoring/applications/context.py

@@ -12,84 +12,92 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-import json
 import socket
-from typing import Any, Optional, cast
+from typing import Any, Optional, Protocol, cast
 
+import nuclio.request
 import numpy as np
 import pandas as pd
 
 import mlrun.common.constants as mlrun_constants
 import mlrun.common.schemas.model_monitoring.constants as mm_constants
+import mlrun.errors
 import mlrun.feature_store as fstore
+import mlrun.feature_store.feature_set as fs
 import mlrun.features
 import mlrun.serving
 import mlrun.utils
 from mlrun.artifacts import Artifact, DatasetArtifact, ModelArtifact, get_model
-from mlrun.common.model_monitoring.helpers import FeatureStats, pad_features_hist
+from mlrun.common.model_monitoring.helpers import FeatureStats
+from mlrun.common.schemas import ModelEndpoint
 from mlrun.model_monitoring.helpers import (
     calculate_inputs_statistics,
-    get_endpoint_record,
 )
-from mlrun.model_monitoring.model_endpoint import ModelEndpoint
 
 
-class MonitoringApplicationContext:
+class _ArtifactsLogger(Protocol):
     """
-    The monitoring context holds all the relevant information for the monitoring application,
-    and also it can be used for logging artifacts and results.
-    The monitoring context has the following attributes:
-
-    :param application_name:        (str) The model monitoring application name.
-    :param project_name:            (str) The project name.
-    :param project:                 (MlrunProject) The project object.
-    :param logger:                  (mlrun.utils.Logger) MLRun logger.
-    :param nuclio_logger:           (nuclio.request.Logger) Nuclio logger.
-    :param sample_df_stats:         (FeatureStats) The new sample distribution dictionary.
-    :param feature_stats:           (FeatureStats) The train sample distribution dictionary.
-    :param sample_df:               (pd.DataFrame) The new sample DataFrame.
-    :param start_infer_time:        (pd.Timestamp) Start time of the monitoring schedule.
-    :param end_infer_time:          (pd.Timestamp) End time of the monitoring schedule.
-    :param latest_request:          (pd.Timestamp) Timestamp of the latest request on this endpoint_id.
-    :param endpoint_id:             (str) ID of the monitored model endpoint
-    :param output_stream_uri:       (str) URI of the output stream for results
-    :param model_endpoint:          (ModelEndpoint) The model endpoint object.
-    :param feature_names:           (list[str]) List of models feature names.
-    :param label_names:             (list[str]) List of models label names.
-    :param model:                   (tuple[str, ModelArtifact, dict]) The model file, model spec object,
-                                    and a list of extra data items.
+    Classes that implement this protocol are :code:`MlrunProject` and :code:`MLClientCtx`.
     """
 
+    def log_artifact(self, *args, **kwargs) -> Artifact: ...
+    def log_dataset(self, *args, **kwargs) -> DatasetArtifact: ...
+
+
+class MonitoringApplicationContext:
+    _logger_name = "monitoring-application"
+
     def __init__(
         self,
         *,
-        graph_context: mlrun.serving.GraphContext,
         application_name: str,
         event: dict[str, Any],
-        model_endpoint_dict: dict[str, ModelEndpoint],
+        project: "mlrun.MlrunProject",
+        artifacts_logger: _ArtifactsLogger,
+        logger: mlrun.utils.Logger,
+        nuclio_logger: nuclio.request.Logger,
+        model_endpoint_dict: Optional[dict[str, ModelEndpoint]] = None,
+        sample_df: Optional[pd.DataFrame] = None,
+        feature_stats: Optional[FeatureStats] = None,
+        feature_sets_dict: Optional[dict[str, fs.FeatureSet]] = None,
     ) -> None:
         """
-        Initialize a `MonitoringApplicationContext` object.
-        Note: this object should not be instantiated manually.
-
-        :param application_name:    The application name.
-        :param event:               The instance data dictionary.
-        :param model_endpoint_dict: Dictionary of model endpoints.
+        The :code:`MonitoringApplicationContext` object holds all the relevant information for the
+        model monitoring application, and can be used for logging artifacts and messages.
+        The monitoring context has the following attributes:
+
+        :param application_name:        (str) The model monitoring application name.
+        :param project:                 (:py:class:`~mlrun.projects.MlrunProject`) The current MLRun project object.
+        :param project_name:            (str) The project name.
+        :param logger:                  (:py:class:`~mlrun.utils.Logger`) MLRun logger.
+        :param nuclio_logger:           (nuclio.request.Logger) Nuclio logger.
+        :param sample_df_stats:         (FeatureStats) The new sample distribution dictionary.
+        :param feature_stats:           (FeatureStats) The train sample distribution dictionary.
+        :param sample_df:               (pd.DataFrame) The new sample DataFrame.
+        :param start_infer_time:        (pd.Timestamp) Start time of the monitoring schedule.
+        :param end_infer_time:          (pd.Timestamp) End time of the monitoring schedule.
+        :param endpoint_id:             (str) ID of the monitored model endpoint
+        :param feature_set:              (FeatureSet) the model endpoint feature set
+        :param endpoint_name:           (str) Name of the monitored model endpoint
+        :param output_stream_uri:       (str) URI of the output stream for results
+        :param model_endpoint:          (ModelEndpoint) The model endpoint object.
+        :param feature_names:           (list[str]) List of models feature names.
+        :param label_names:             (list[str]) List of models label names.
+        :param model:                   (tuple[str, ModelArtifact, dict]) The model file, model spec object,
+                                        and a list of extra data items.
         """
         self.application_name = application_name
 
-        self.project_name = graph_context.project
-        self.project = mlrun.load_project(url=self.project_name)
+        self.project = project
+        self.project_name = project.name
+
+        self._artifacts_logger = artifacts_logger
 
         # MLRun Logger
-        self.logger = mlrun.utils.create_logger(
-            level=mlrun.mlconf.log_level,
-            formatter_kind=mlrun.mlconf.log_formatter,
-            name="monitoring-application",
-        )
+        self.logger = logger
         # Nuclio logger - `nuclio.request.Logger`.
-        # Note: this logger does not accept keyword arguments.
-        self.nuclio_logger = graph_context.logger
+        # Note: this logger accepts keyword arguments only in its `_with` methods, e.g. `info_with`.
+        self.nuclio_logger = nuclio_logger
 
         # event data
         self.start_infer_time = pd.Timestamp(
@@ -101,29 +109,101 @@ class MonitoringApplicationContext:
         self.endpoint_id = cast(
             str, event.get(mm_constants.ApplicationEvent.ENDPOINT_ID)
         )
-        self.output_stream_uri = cast(
-            str, event.get(mm_constants.ApplicationEvent.OUTPUT_STREAM_URI)
+        self.endpoint_name = cast(
+            str, event.get(mm_constants.ApplicationEvent.ENDPOINT_NAME)
         )
 
-        self._feature_stats: Optional[FeatureStats] = None
+        self._feature_stats: Optional[FeatureStats] = feature_stats
         self._sample_df_stats: Optional[FeatureStats] = None
 
         # Default labels for the artifacts
         self._default_labels = self._get_default_labels()
 
         # Persistent data - fetched when needed
-        self._sample_df: Optional[pd.DataFrame] = None
-        self._model_endpoint: Optional[ModelEndpoint] = model_endpoint_dict.get(
-            self.endpoint_id
+        self._sample_df: Optional[pd.DataFrame] = sample_df
+        self._model_endpoint: Optional[ModelEndpoint] = (
+            model_endpoint_dict.get(self.endpoint_id) if model_endpoint_dict else None
+        )
+        self._feature_set: Optional[fs.FeatureSet] = (
+            feature_sets_dict.get(self.endpoint_id) if feature_sets_dict else None
+        )
+        store, _, _ = mlrun.store_manager.get_or_create_store(
+            mlrun.mlconf.artifact_path
+        )
+        self.storage_options = store.get_storage_options()
+
+    @classmethod
+    def _from_ml_ctx(
+        cls,
+        context: "mlrun.MLClientCtx",
+        *,
+        application_name: str,
+        event: dict[str, Any],
+        model_endpoint_dict: Optional[dict[str, ModelEndpoint]] = None,
+        sample_df: Optional[pd.DataFrame] = None,
+        feature_stats: Optional[FeatureStats] = None,
+    ) -> "MonitoringApplicationContext":
+        project = context.get_project_object()
+        if not project:
+            raise mlrun.errors.MLRunValueError("Could not load project from context")
+        logger = context.logger
+        artifacts_logger = context
+        nuclio_logger = nuclio.request.Logger(
+            level=mlrun.mlconf.log_level, name=cls._logger_name
+        )
+        return cls(
+            application_name=application_name,
+            event=event,
+            model_endpoint_dict=model_endpoint_dict,
+            project=project,
+            logger=logger,
+            nuclio_logger=nuclio_logger,
+            artifacts_logger=artifacts_logger,
+            sample_df=sample_df,
+            feature_stats=feature_stats,
+        )
+
+    @classmethod
+    def _from_graph_ctx(
+        cls,
+        graph_context: mlrun.serving.GraphContext,
+        *,
+        application_name: str,
+        event: dict[str, Any],
+        model_endpoint_dict: Optional[dict[str, ModelEndpoint]] = None,
+        sample_df: Optional[pd.DataFrame] = None,
+        feature_stats: Optional[FeatureStats] = None,
+        feature_sets_dict: Optional[dict[str, fs.FeatureSet]] = None,
+    ) -> "MonitoringApplicationContext":
+        nuclio_logger = graph_context.logger
+        artifacts_logger = graph_context.project_obj
+        logger = mlrun.utils.create_logger(
+            level=mlrun.mlconf.log_level,
+            formatter_kind=mlrun.mlconf.log_formatter,
+            name=cls._logger_name,
+        )
+        return cls(
+            application_name=application_name,
+            event=event,
+            project=graph_context.project_obj,
+            model_endpoint_dict=model_endpoint_dict,
+            logger=logger,
+            nuclio_logger=nuclio_logger,
+            artifacts_logger=artifacts_logger,
+            sample_df=sample_df,
+            feature_stats=feature_stats,
+            feature_sets_dict=feature_sets_dict,
         )
 
     def _get_default_labels(self) -> dict[str, str]:
-        return {
+        labels = {
             mlrun_constants.MLRunInternalLabels.runner_pod: socket.gethostname(),
             mlrun_constants.MLRunInternalLabels.producer_type: "model-monitoring-app",
             mlrun_constants.MLRunInternalLabels.app_name: self.application_name,
             mlrun_constants.MLRunInternalLabels.endpoint_id: self.endpoint_id,
+            mlrun_constants.MLRunInternalLabels.endpoint_name: self.endpoint_name,
         }
+        return {key: value for key, value in labels.items() if value is not None}
 
     def _add_default_labels(self, labels: Optional[dict[str, str]]) -> dict[str, str]:
         """Add the default labels to logged artifacts labels"""
@@ -132,39 +212,60 @@ class MonitoringApplicationContext:
     @property
     def sample_df(self) -> pd.DataFrame:
         if self._sample_df is None:
-            feature_set = fstore.get_feature_set(
-                self.model_endpoint.status.monitoring_feature_set_uri
-            )
-            features = [f"{feature_set.metadata.name}.*"]
-            vector = fstore.FeatureVector(
-                name=f"{self.endpoint_id}_vector",
-                features=features,
-                with_indexes=True,
-            )
-            vector.metadata.tag = self.application_name
-            vector.feature_set_objects = {feature_set.metadata.name: feature_set}
-
-            offline_response = vector.get_offline_features(
+            if (
+                self.endpoint_name is None
+                or self.endpoint_id is None
+                or pd.isnull(self.start_infer_time)
+                or pd.isnull(self.end_infer_time)
+            ):
+                raise mlrun.errors.MLRunValueError(
+                    "You have tried to access `monitoring_context.sample_df`, but have not provided it directly "
+                    "through `sample_data`, nor have you provided the model endpoint's name, ID, and the start and "
+                    f"end times: `endpoint_name`={self.endpoint_name}, `endpoint_uid`={self.endpoint_id}, "
+                    f"`start`={self.start_infer_time}, and `end`={self.end_infer_time}. "
+                    "You can either provide the sample dataframe directly, the model endpoint's details and times, "
+                    "or adapt the application's logic to not access the sample dataframe."
+                )
+            df = self.feature_set.to_dataframe(
                 start_time=self.start_infer_time,
                 end_time=self.end_infer_time,
-                timestamp_for_filtering=mm_constants.FeatureSetFeatures.time_stamp(),
+                time_column=mm_constants.EventFieldType.TIMESTAMP,
+                storage_options=self.storage_options,
             )
-            self._sample_df = offline_response.to_dataframe().reset_index(drop=True)
+            self._sample_df = df.reset_index(drop=True)
         return self._sample_df
 
     @property
     def model_endpoint(self) -> ModelEndpoint:
         if not self._model_endpoint:
-            self._model_endpoint = ModelEndpoint.from_flat_dict(
-                get_endpoint_record(self.project_name, self.endpoint_id)
+            if self.endpoint_name is None or self.endpoint_id is None:
+                raise mlrun.errors.MLRunValueError(
+                    "You have NOT provided the model endpoint's name and ID: "
+                    f"`endpoint_name`={self.endpoint_name} and `endpoint_id`={self.endpoint_id}, "
+                    "but you have tried to access `monitoring_context.model_endpoint` "
+                    "directly or indirectly in your application. You can either provide them, "
+                    "or adapt the application's logic to not access the model endpoint."
+                )
+            self._model_endpoint = mlrun.db.get_run_db().get_model_endpoint(
+                name=self.endpoint_name,
+                project=self.project_name,
+                endpoint_id=self.endpoint_id,
+                feature_analysis=True,
             )
         return self._model_endpoint
 
+    @property
+    def feature_set(self) -> fs.FeatureSet:
+        if not self._feature_set and self.model_endpoint:
+            self._feature_set = fstore.get_feature_set(
+                self.model_endpoint.spec.monitoring_feature_set_uri
+            )
+        return self._feature_set
+
     @property
     def feature_stats(self) -> FeatureStats:
         if not self._feature_stats:
-            self._feature_stats = json.loads(self.model_endpoint.status.feature_stats)
-            pad_features_hist(self._feature_stats)
+            self._feature_stats = self.model_endpoint.spec.feature_stats
         return self._feature_stats
 
     @property
@@ -179,18 +280,12 @@ class MonitoringApplicationContext:
     @property
     def feature_names(self) -> list[str]:
         """The feature names of the model"""
-        feature_names = self.model_endpoint.spec.feature_names
-        return (
-            feature_names
-            if isinstance(feature_names, list)
-            else json.loads(feature_names)
-        )
+        return self.model_endpoint.spec.feature_names
 
     @property
     def label_names(self) -> list[str]:
         """The label names of the model"""
-        label_names = self.model_endpoint.spec.label_names
-        return label_names if isinstance(label_names, list) else json.loads(label_names)
+        return self.model_endpoint.spec.label_names
 
     @property
     def model(self) -> tuple[str, ModelArtifact, dict]:
@@ -230,14 +325,32 @@ class MonitoringApplicationContext:
         upload: Optional[bool] = None,
         labels: Optional[dict[str, str]] = None,
         target_path: Optional[str] = None,
+        unique_per_endpoint: bool = True,
         **kwargs,
     ) -> Artifact:
         """
         Log an artifact.
-        See :func:`~mlrun.projects.MlrunProject.log_artifact` for the documentation.
+
+        .. caution::
+
+            Logging artifacts in every model monitoring window may cause scale issues.
+            This method should be called on special occasions only.
+
+        See :func:`~mlrun.projects.MlrunProject.log_artifact` for the full documentation, except for one
+        new argument:
+
+        :param unique_per_endpoint: by default ``True``, we will log different artifact for each model endpoint,
+                                    set to ``False`` without changing item key will cause artifact override.
         """
         labels = self._add_default_labels(labels)
-        return self.project.log_artifact(
+        # By default, we want to log different artifact for each model endpoint
+        endpoint_id = labels.get(mlrun_constants.MLRunInternalLabels.endpoint_id, "")
+        if unique_per_endpoint and isinstance(item, str):
+            item = f"{item}-{endpoint_id}" if endpoint_id else item
+        elif unique_per_endpoint:  # isinstance(item, Artifact) is True
+            item.key = f"{item.key}-{endpoint_id}" if endpoint_id else item.key
+
+        return self._artifacts_logger.log_artifact(
             item,
             body=body,
             tag=tag,
@@ -265,14 +378,30 @@ class MonitoringApplicationContext:
         target_path="",
         extra_data=None,
         label_column: Optional[str] = None,
+        unique_per_endpoint: bool = True,
         **kwargs,
     ) -> DatasetArtifact:
         """
         Log a dataset artifact.
-        See :func:`~mlrun.projects.MlrunProject.log_dataset` for the documentation.
+
+        .. caution::
+
+            Logging datasets in every model monitoring window may cause scale issues.
+            This method should be called on special occasions only.
+
+        See :func:`~mlrun.projects.MlrunProject.log_dataset` for the full documentation, except for one
+        new argument:
+
+        :param unique_per_endpoint: by default ``True``, we will log different artifact for each model endpoint,
+                                    set to ``False`` without changing item key will cause artifact override.
         """
         labels = self._add_default_labels(labels)
-        return self.project.log_dataset(
+        # By default, we want to log different artifact for each model endpoint
+        endpoint_id = labels.get(mlrun_constants.MLRunInternalLabels.endpoint_id, "")
+        if unique_per_endpoint and isinstance(key, str):
+            key = f"{key}-{endpoint_id}" if endpoint_id else key
+
+        return self._artifacts_logger.log_dataset(
             key,
             df,
             tag=tag,
@@ -288,54 +417,3 @@ class MonitoringApplicationContext:
             label_column=label_column,
             **kwargs,
         )
-
-    def log_model(
-        self,
-        key,
-        body=None,
-        framework="",
-        tag="",
-        model_dir=None,
-        model_file=None,
-        algorithm=None,
-        metrics=None,
-        parameters=None,
-        artifact_path=None,
-        upload=None,
-        labels=None,
-        inputs: Optional[list[mlrun.features.Feature]] = None,
-        outputs: Optional[list[mlrun.features.Feature]] = None,
-        feature_vector: Optional[str] = None,
-        feature_weights: Optional[list] = None,
-        training_set=None,
-        label_column=None,
-        extra_data=None,
-        **kwargs,
-    ) -> ModelArtifact:
-        """
-        Log a model artifact.
-        See :func:`~mlrun.projects.MlrunProject.log_model` for the documentation.
-        """
-        labels = self._add_default_labels(labels)
-        return self.project.log_model(
-            key,
-            body=body,
-            framework=framework,
-            tag=tag,
-            model_dir=model_dir,
-            model_file=model_file,
-            algorithm=algorithm,
-            metrics=metrics,
-            parameters=parameters,
-            artifact_path=artifact_path,
-            upload=upload,
-            labels=labels,
-            inputs=inputs,
-            outputs=outputs,
-            feature_vector=feature_vector,
-            feature_weights=feature_weights,
-            training_set=training_set,
-            label_column=label_column,
-            extra_data=extra_data,
-            **kwargs,
-        )

mlrun/model_monitoring/{db/stores/base → applications/evidently}/__init__.py

@@ -1,4 +1,4 @@
-# Copyright 2024 Iguazio
+# Copyright 2025 Iguazio
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -12,4 +12,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from .store import StoreBase
+from .base import (
+    _HAS_EVIDENTLY,
+    SUPPORTED_EVIDENTLY_VERSION,
+    EvidentlyModelMonitoringApplicationBase,
+)

mlrun/model_monitoring/applications/evidently/base.py

@@ -0,0 +1,146 @@
+# 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 warnings
+from abc import ABC
+from tempfile import NamedTemporaryFile
+from typing import Optional
+
+import semver
+
+import mlrun.model_monitoring.applications.base as mm_base
+import mlrun.model_monitoring.applications.context as mm_context
+from mlrun.errors import MLRunIncompatibleVersionError, MLRunValueError
+
+SUPPORTED_EVIDENTLY_VERSION = semver.Version.parse("0.7.5")
+
+
+def _check_evidently_version(*, cur: semver.Version, ref: semver.Version) -> None:
+    if ref.is_compatible(cur) or (
+        cur.major == ref.major == 0 and cur.minor == ref.minor and cur.patch > ref.patch
+    ):
+        return
+    if cur.major == ref.major == 0 and cur.minor > ref.minor:
+        warnings.warn(
+            f"Evidently version {cur} is not compatible with the tested "
+            f"version {ref}, use at your own risk."
+        )
+    else:
+        raise MLRunIncompatibleVersionError(
+            f"Evidently version {cur} is not supported, please change to "
+            f"{ref} (or another compatible version)."
+        )
+
+
+_HAS_EVIDENTLY = False
+try:
+    import evidently  # noqa: F401
+
+    _check_evidently_version(
+        cur=semver.Version.parse(evidently.__version__),
+        ref=SUPPORTED_EVIDENTLY_VERSION,
+    )
+    _HAS_EVIDENTLY = True
+except ModuleNotFoundError:
+    pass
+
+
+if _HAS_EVIDENTLY:
+    from evidently.core.report import Snapshot
+    from evidently.ui.workspace import (
+        STR_UUID,
+        CloudWorkspace,
+        Project,
+        Workspace,
+        WorkspaceBase,
+    )
+
+
+class EvidentlyModelMonitoringApplicationBase(
+    mm_base.ModelMonitoringApplicationBase, ABC
+):
+    def __init__(
+        self,
+        evidently_project_id: "STR_UUID",
+        evidently_workspace_path: Optional[str] = None,
+        cloud_workspace: bool = False,
+    ) -> None:
+        """
+        A class for integrating Evidently for MLRun model monitoring within a monitoring application.
+
+        .. note::
+
+            The ``evidently`` package is not installed by default in the mlrun/mlrun image.
+            It must be installed separately to use this class.
+
+        :param evidently_project_id:        (str) The ID of the Evidently project.
+        :param evidently_workspace_path:    (str) The path to the Evidently workspace.
+        :param cloud_workspace:             (bool) Whether the workspace is an Evidently Cloud workspace.
+        """
+        if not _HAS_EVIDENTLY:
+            raise ModuleNotFoundError("Evidently is not installed - the app cannot run")
+        self.evidently_workspace_path = evidently_workspace_path
+        if cloud_workspace:
+            self.get_workspace = self.get_cloud_workspace
+        self.evidently_workspace = self.get_workspace()
+        self.evidently_project_id = evidently_project_id
+        self.evidently_project = self.load_project()
+
+    def load_project(self) -> "Project":
+        """Load the Evidently project."""
+        return self.evidently_workspace.get_project(self.evidently_project_id)
+
+    def get_workspace(self) -> "WorkspaceBase":
+        """Get the Evidently workspace. Override this method for customize access to the workspace."""
+        if self.evidently_workspace_path:
+            return Workspace.create(self.evidently_workspace_path)
+        else:
+            raise MLRunValueError(
+                "A local workspace could not be created as `evidently_workspace_path` is not set.\n"
+                "If you intend to use a cloud workspace, please use `cloud_workspace=True` and set the "
+                "`EVIDENTLY_API_KEY` environment variable. In other cases, override this method."
+            )
+
+    def get_cloud_workspace(self) -> "CloudWorkspace":
+        """Load the Evidently cloud workspace according to the `EVIDENTLY_API_KEY` environment variable."""
+        return CloudWorkspace()
+
+    @staticmethod
+    def log_evidently_object(
+        monitoring_context: mm_context.MonitoringApplicationContext,
+        evidently_object: "Snapshot",
+        artifact_name: str,
+        unique_per_endpoint: bool = True,
+    ) -> None:
+        """
+        Logs an Evidently report or suite as an artifact.
+
+        .. caution::
+
+            Logging Evidently objects in every model monitoring window may cause scale issues.
+            This method should be called on special occasions only.
+
+        :param monitoring_context:  (MonitoringApplicationContext) The monitoring context to process.
+        :param evidently_object:    (Snapshot) The Evidently run to log, e.g. a report run.
+        :param artifact_name:       (str) The name for the logged artifact.
+        :param unique_per_endpoint: by default ``True``, we will log different artifact for each model endpoint,
+                                    set to ``False`` without changing item key will cause artifact override.
+        """
+        with NamedTemporaryFile(suffix=".html") as file:
+            evidently_object.save_html(filename=file.name)
+            monitoring_context.log_artifact(
+                artifact_name,
+                local_path=file.name,
+                unique_per_endpoint=unique_per_endpoint,
+            )