mlrun 1.8.0rc29__py3-none-any.whl → 1.8.0rc31__py3-none-any.whl

mlrun/__init__.py

@@ -214,40 +214,8 @@ def set_env_from_file(env_file: str, return_dict: bool = False) -> Optional[dict
     if None in env_vars.values():
         raise MLRunInvalidArgumentError("env file lines must be in the form key=value")
 
-    ordered_env_vars = order_env_vars(env_vars)
-    for key, value in ordered_env_vars.items():
+    for key, value in env_vars.items():
         environ[key] = value
 
     mlconf.reload()  # reload mlrun configuration
-    return ordered_env_vars if return_dict else None
-
-
-def order_env_vars(env_vars: dict[str, str]) -> dict[str, str]:
-    """
-    Order and process environment variables by first handling specific ordered keys,
-    then processing the remaining keys in the given dictionary.
-
-    The function ensures that environment variables defined in the `ordered_keys` list
-    are added to the result dictionary first. Any other environment variables from
-    `env_vars` are then added in the order they appear in the input dictionary.
-
-    :param env_vars: A dictionary where each key is the name of an environment variable (str),
-                      and each value is the corresponding environment variable value (str).
-    :return: A dictionary with the processed environment variables, ordered with the specific
-             keys first, followed by the rest in their original order.
-    """
-    ordered_keys = mlconf.get_ordered_keys()
-
-    ordered_env_vars: dict[str, str] = {}
-
-    # First, add the ordered keys to the dictionary
-    for key in ordered_keys:
-        if key in env_vars:
-            ordered_env_vars[key] = env_vars[key]
-
-    # Then, add the remaining keys (those not in ordered_keys)
-    for key, value in env_vars.items():
-        if key not in ordered_keys:
-            ordered_env_vars[key] = value
-
-    return ordered_env_vars
+    return env_vars if return_dict else None

mlrun/api/schemas/__init__.py

@@ -193,9 +193,7 @@ FeatureValues = DeprecationHelper(mlrun.common.schemas.FeatureValues)
 GrafanaColumn = DeprecationHelper(
     mlrun.common.schemas.model_monitoring.grafana.GrafanaColumn
 )
-GrafanaDataPoint = DeprecationHelper(
-    mlrun.common.schemas.model_monitoring.grafana.GrafanaDataPoint
-)
+
 GrafanaNumberColumn = DeprecationHelper(
     mlrun.common.schemas.model_monitoring.grafana.GrafanaNumberColumn
 )
@@ -205,9 +203,6 @@ GrafanaStringColumn = DeprecationHelper(
 GrafanaTable = DeprecationHelper(
     mlrun.common.schemas.model_monitoring.grafana.GrafanaTable
 )
-GrafanaTimeSeriesTarget = DeprecationHelper(
-    mlrun.common.schemas.model_monitoring.grafana.GrafanaTimeSeriesTarget
-)
 ModelEndpoint = DeprecationHelper(mlrun.common.schemas.ModelEndpoint)
 ModelEndpointList = DeprecationHelper(mlrun.common.schemas.ModelEndpointList)
 ModelEndpointMetadata = DeprecationHelper(mlrun.common.schemas.ModelEndpointMetadata)

mlrun/artifacts/document.py

@@ -97,9 +97,9 @@ class MLRunLoader:
     A factory class for creating instances of a dynamically defined document loader.
 
     Args:
-        artifact_key (str, optional): The key for the artifact to be logged. Special characters and symbols
-            not valid in artifact names will be encoded as their hexadecimal representation. The '%%' pattern
-            in the key will be replaced by the hex-encoded version of the source path. Defaults to "%%".
+        artifact_key (str, optional): The key for the artifact to be logged.
+            The '%%' pattern in the key will be replaced by the source path
+            with any unsupported characters converted to '_'. Defaults to "%%".
         local_path (str): The source path of the document to be loaded.
         loader_spec (DocumentLoaderSpec): Specification for the document loader.
         producer (Optional[Union[MlrunProject, str, MLClientCtx]], optional): The producer of the document.

mlrun/artifacts/manager.py

@@ -403,6 +403,7 @@ class ArtifactManager:
             project=item.project,
             tag=item.tag,
             tree=item.tree,
+            iter=item.iter,
             deletion_strategy=deletion_strategy,
             secrets=secrets,
         )

mlrun/artifacts/model.py

@@ -429,6 +429,9 @@ def get_model(model_dir, suffix=""):
     extra_dataitems = {}
     default_suffix = ".pkl"
 
+    if hasattr(model_dir, "artifact_url"):
+        model_dir = model_dir.artifact_url
+
     alternative_suffix = next(
         (
             optional_suffix
@@ -438,9 +441,6 @@ def get_model(model_dir, suffix=""):
         None,
     )
 
-    if hasattr(model_dir, "artifact_url"):
-        model_dir = model_dir.artifact_url
-
     if mlrun.datastore.is_store_uri(model_dir):
         model_spec, target = mlrun.datastore.store_manager.get_store_artifact(model_dir)
         if not model_spec or model_spec.kind != "model":

mlrun/common/model_monitoring/helpers.py

@@ -36,6 +36,20 @@ def parse_model_endpoint_store_prefix(store_prefix: str):
     return endpoint, container, path
 
 
+def get_kafka_topic(project: str, function_name: typing.Optional[str] = None) -> str:
+    if (
+        function_name is None
+        or function_name == mm_constants.MonitoringFunctionNames.STREAM
+    ):
+        function_specifier = ""
+    else:
+        function_specifier = f"_{function_name}"
+
+    return (
+        f"monitoring_stream_{mlrun.mlconf.system_id}_{project}{function_specifier}_v1"
+    )
+
+
 def parse_monitoring_stream_path(
     stream_uri: str, project: str, function_name: typing.Optional[str] = None
 ) -> str:
@@ -43,13 +57,8 @@ def parse_monitoring_stream_path(
         if "?topic" in stream_uri:
             raise mlrun.errors.MLRunValueError("Custom kafka topic is not allowed")
         # Add topic to stream kafka uri
-        if (
-            function_name is None
-            or function_name == mm_constants.MonitoringFunctionNames.STREAM
-        ):
-            stream_uri += f"?topic=monitoring_stream_{project}_v1"
-        else:
-            stream_uri += f"?topic=monitoring_stream_{project}_{function_name}_v1"
+        topic = get_kafka_topic(project=project, function_name=function_name)
+        stream_uri += f"?topic={topic}"
 
     return stream_uri
 

mlrun/common/runtimes/constants.py

@@ -194,6 +194,10 @@ class RunStates:
             # TODO: add aborting state once we have it
         ]
 
+    @staticmethod
+    def notification_states():
+        return RunStates.terminal_states() + [RunStates.running]
+
     @staticmethod
     def run_state_to_pipeline_run_status(run_state: str):
         if not run_state:
@@ -229,6 +233,7 @@ class RunStates:
             mlrun_pipelines.common.models.RunStatuses.runtime_state_unspecified: RunStates.unknown,
             mlrun_pipelines.common.models.RunStatuses.error: RunStates.error,
             mlrun_pipelines.common.models.RunStatuses.paused: RunStates.unknown,
+            mlrun_pipelines.common.models.RunStatuses.unknown: RunStates.unknown,
         }[pipeline_run_status]
 
 

mlrun/common/schemas/__init__.py

@@ -140,11 +140,9 @@ from .model_monitoring import (
     FeatureSetFeatures,
     FeatureValues,
     GrafanaColumn,
-    GrafanaDataPoint,
     GrafanaNumberColumn,
     GrafanaStringColumn,
     GrafanaTable,
-    GrafanaTimeSeriesTarget,
     ModelEndpoint,
     ModelEndpointCreationStrategy,
     ModelEndpointList,

mlrun/common/schemas/model_monitoring/__init__.py

@@ -51,11 +51,9 @@ from .constants import (
 from .grafana import (
     GrafanaColumn,
     GrafanaColumnType,
-    GrafanaDataPoint,
     GrafanaNumberColumn,
     GrafanaStringColumn,
     GrafanaTable,
-    GrafanaTimeSeriesTarget,
 )
 from .model_endpoints import (
     Features,

mlrun/common/schemas/model_monitoring/constants.py

@@ -163,7 +163,6 @@ class ApplicationEvent:
     END_INFER_TIME = "end_infer_time"
     ENDPOINT_ID = "endpoint_id"
     ENDPOINT_NAME = "endpoint_name"
-    OUTPUT_STREAM_URI = "output_stream_uri"
 
 
 class WriterEvent(MonitoringStrEnum):
@@ -251,11 +250,6 @@ class TSDBTarget(MonitoringStrEnum):
     TDEngine = "tdengine"
 
 
-class DefaultProfileName(StrEnum):
-    STREAM = "mm-infra-stream"
-    TSDB = "mm-infra-tsdb"
-
-
 class ProjectSecretKeys:
     ACCESS_KEY = "MODEL_MONITORING_ACCESS_KEY"
     TSDB_PROFILE_NAME = "TSDB_PROFILE_NAME"
@@ -474,10 +468,13 @@ FQN_REGEX = re.compile(FQN_PATTERN)
 
 # refer to `mlrun.utils.regex.project_name`
 PROJECT_PATTERN = r"^[a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?$"
-
 MODEL_ENDPOINT_ID_PATTERN = r"^[a-zA-Z0-9_-]+$"
+RESULT_NAME_PATTERN = r"[a-zA-Z_][a-zA-Z0-9_]*"
 
 INTERSECT_DICT_KEYS = {
     ModelEndpointMonitoringMetricType.METRIC: "intersect_metrics",
     ModelEndpointMonitoringMetricType.RESULT: "intersect_results",
 }
+
+CRON_TRIGGER_KINDS = ("http", "cron")
+STREAM_TRIGGER_KINDS = ("v3io-stream", "kafka-cluster")

mlrun/common/schemas/model_monitoring/grafana.py

@@ -46,14 +46,20 @@ class GrafanaTable(BaseModel):
         self.rows.append(list(args))
 
 
-class GrafanaDataPoint(BaseModel):
-    value: float
-    timestamp: int  # Unix timestamp in milliseconds
-
-
-class GrafanaTimeSeriesTarget(BaseModel):
-    target: str
-    datapoints: list[tuple[float, int]] = []
-
-    def add_data_point(self, data_point: GrafanaDataPoint):
-        self.datapoints.append((data_point.value, data_point.timestamp))
+class GrafanaModelEndpointsTable(GrafanaTable):
+    def __init__(self):
+        columns = self._init_columns()
+        super().__init__(columns=columns)
+
+    @staticmethod
+    def _init_columns():
+        return [
+            GrafanaColumn(text="endpoint_id", type=GrafanaColumnType.STRING),
+            GrafanaColumn(text="endpoint_name", type=GrafanaColumnType.STRING),
+            GrafanaColumn(text="endpoint_function", type=GrafanaColumnType.STRING),
+            GrafanaColumn(text="endpoint_model", type=GrafanaColumnType.STRING),
+            GrafanaColumn(text="endpoint_model_class", type=GrafanaColumnType.STRING),
+            GrafanaColumn(text="error_count", type=GrafanaColumnType.NUMBER),
+            GrafanaColumn(text="drift_status", type=GrafanaColumnType.NUMBER),
+            GrafanaColumn(text="sampling_percentage", type=GrafanaColumnType.NUMBER),
+        ]

mlrun/config.py

@@ -1366,35 +1366,6 @@ class Config:
             ver in mlrun.mlconf.ce.mode for ver in ["lite", "full"]
         )
 
-    def get_s3_storage_options(self) -> dict[str, typing.Any]:
-        """
-        Generate storage options dictionary as required for handling S3 path in fsspec. The model monitoring stream
-        graph uses this method for generating the storage options for S3 parquet target path.
-        :return: A storage options dictionary in which each key-value pair  represents a particular configuration,
-        such as endpoint_url or aws access key.
-        """
-        key = mlrun.get_secret_or_env("AWS_ACCESS_KEY_ID")
-        secret = mlrun.get_secret_or_env("AWS_SECRET_ACCESS_KEY")
-
-        force_non_anonymous = mlrun.get_secret_or_env("S3_NON_ANONYMOUS")
-        profile = mlrun.get_secret_or_env("AWS_PROFILE")
-
-        storage_options = dict(
-            anon=not (force_non_anonymous or (key and secret)),
-            key=key,
-            secret=secret,
-        )
-
-        endpoint_url = mlrun.get_secret_or_env("S3_ENDPOINT_URL")
-        if endpoint_url:
-            client_kwargs = {"endpoint_url": endpoint_url}
-            storage_options["client_kwargs"] = client_kwargs
-
-        if profile:
-            storage_options["profile"] = profile
-
-        return storage_options
-
     def is_explicit_ack_enabled(self) -> bool:
         return self.httpdb.nuclio.explicit_ack == "enabled" and (
             not self.nuclio_version
@@ -1402,13 +1373,6 @@ class Config:
             >= semver.VersionInfo.parse("1.12.10")
         )
 
-    @staticmethod
-    def get_ordered_keys():
-        # Define the keys to process first
-        return [
-            "MLRUN_HTTPDB__HTTP__VERIFY"  # Ensure this key is processed first for proper connection setup
-        ]
-
 
 # Global configuration
 config = Config.from_dict(default_config)
@@ -1626,6 +1590,15 @@ def read_env(env=None, prefix=env_prefix):
     # The default function pod resource values are of type str; however, when reading from environment variable numbers,
     # it converts them to type int if contains only number, so we want to convert them to str.
     _convert_resources_to_str(config)
+
+    # If the environment variable MLRUN_HTTPDB__HTTP__VERIFY is set, we ensure SSL verification settings take precedence
+    # by moving the 'httpdb' configuration to the beginning of the config dictionary.
+    # This ensures that SSL verification is applied before other settings.
+    if "MLRUN_HTTPDB__HTTP__VERIFY" in env:
+        httpdb = config.pop("httpdb", None)
+        if httpdb:
+            config = {"httpdb": httpdb, **config}
+
     return config
 
 

mlrun/datastore/datastore_profile.py

@@ -193,7 +193,7 @@ class DatastoreProfileKafkaSource(DatastoreProfile):
     kwargs_public: typing.Optional[dict]
     kwargs_private: typing.Optional[dict]
 
-    def attributes(self):
+    def attributes(self) -> dict[str, typing.Any]:
         attributes = {}
         if self.kwargs_public:
             attributes = merge(attributes, self.kwargs_public)

mlrun/datastore/sources.py

@@ -1200,19 +1200,20 @@ class KafkaSource(OnlineSource):
         new_topics = [
             NewTopic(topic, num_partitions, replication_factor) for topic in topics
         ]
-        kafka_admin = KafkaAdminClient(
-            bootstrap_servers=brokers,
-            sasl_mechanism=self.attributes.get("sasl", {}).get("sasl_mechanism"),
-            sasl_plain_username=self.attributes.get("sasl", {}).get("username"),
-            sasl_plain_password=self.attributes.get("sasl", {}).get("password"),
-            sasl_kerberos_service_name=self.attributes.get("sasl", {}).get(
-                "sasl_kerberos_service_name", "kafka"
-            ),
-            sasl_kerberos_domain_name=self.attributes.get("sasl", {}).get(
-                "sasl_kerberos_domain_name"
-            ),
-            sasl_oauth_token_provider=self.attributes.get("sasl", {}).get("mechanism"),
-        )
+
+        kafka_admin_kwargs = {}
+        if "sasl" in self.attributes:
+            sasl = self.attributes["sasl"]
+            kafka_admin_kwargs.update(
+                {
+                    "security_protocol": "SASL_PLAINTEXT",
+                    "sasl_mechanism": sasl["mechanism"],
+                    "sasl_plain_username": sasl["user"],
+                    "sasl_plain_password": sasl["password"],
+                }
+            )
+
+        kafka_admin = KafkaAdminClient(bootstrap_servers=brokers, **kafka_admin_kwargs)
         try:
             kafka_admin.create_topics(new_topics)
         finally:

mlrun/datastore/storeytargets.py

@@ -42,9 +42,21 @@ def get_url_and_storage_options(path, external_storage_options=None):
 
 
 class TDEngineStoreyTarget(storey.TDEngineTarget):
-    def __init__(self, *args, **kwargs):
-        kwargs["url"] = mlrun.model_monitoring.helpers.get_tsdb_connection_string()
-        super().__init__(*args, **kwargs)
+    def __init__(self, *args, url: str, **kwargs):
+        if url.startswith("ds://"):
+            datastore_profile = (
+                mlrun.datastore.datastore_profile.datastore_profile_read(url)
+            )
+            if not isinstance(
+                datastore_profile,
+                mlrun.datastore.datastore_profile.TDEngineDatastoreProfile,
+            ):
+                raise ValueError(
+                    f"Unexpected datastore profile type:{datastore_profile.type}."
+                    "Only TDEngineDatastoreProfile is supported"
+                )
+            url = datastore_profile.dsn()
+        super().__init__(*args, url=url, **kwargs)
 
 
 class StoreyTargetUtils:
@@ -69,7 +81,12 @@ class StoreyTargetUtils:
 
 class ParquetStoreyTarget(storey.ParquetTarget):
     def __init__(self, *args, **kwargs):
+        alt_key_name = kwargs.pop("alternative_v3io_access_key", None)
         args, kwargs = StoreyTargetUtils.process_args_and_kwargs(args, kwargs)
+        storage_options = kwargs.get("storage_options", {})
+        if storage_options and storage_options.get("v3io_access_key") and alt_key_name:
+            if alt_key := mlrun.get_secret_or_env(alt_key_name):
+                storage_options["v3io_access_key"] = alt_key
         super().__init__(*args, **kwargs)
 
 

mlrun/db/httpdb.py

@@ -1734,36 +1734,10 @@ class HTTPRunDB(RunDBInterface):
     def create_schedule(
         self, project: str, schedule: mlrun.common.schemas.ScheduleInput
     ):
-        """Create a new schedule on the given project. The details on the actual object to schedule as well as the
-        schedule itself are within the schedule object provided.
-        The :py:class:`~ScheduleCronTrigger` follows the guidelines in
-        https://apscheduler.readthedocs.io/en/3.x/modules/triggers/cron.html.
-        It also supports a :py:func:`~ScheduleCronTrigger.from_crontab` function that accepts a
-        crontab-formatted string (see https://en.wikipedia.org/wiki/Cron for more information on the format and
-        note that the 0 weekday is always monday).
-
-
-        Example::
-
-            from mlrun.common import schemas
-
-            # Execute the get_data_func function every Tuesday at 15:30
-            schedule = schemas.ScheduleInput(
-                name="run_func_on_tuesdays",
-                kind="job",
-                scheduled_object=get_data_func,
-                cron_trigger=schemas.ScheduleCronTrigger(
-                    day_of_week="tue", hour=15, minute=30
-                ),
-            )
-            db.create_schedule(project_name, schedule)
-        """
-
-        project = project or config.default_project
-        path = f"projects/{project}/schedules"
-
-        error_message = f"Failed creating schedule {project}/{schedule.name}"
-        self.api_call("POST", path, error_message, body=dict_to_json(schedule.dict()))
+        """The create_schedule functionality has been deprecated."""
+        raise mlrun.errors.MLRunBadRequestError(
+            "The create_schedule functionality has been deprecated."
+        )
 
     def update_schedule(
         self, project: str, name: str, schedule: mlrun.common.schemas.ScheduleUpdate

mlrun/k8s_utils.py

@@ -142,6 +142,7 @@ def verify_label_key(key: str, allow_k8s_prefix: bool = False):
     if not key:
         raise mlrun.errors.MLRunInvalidArgumentError("label key cannot be empty")
 
+    prefix = ""
     parts = key.split("/")
     if len(parts) == 1:
         name = parts[0]
@@ -180,11 +181,7 @@ def verify_label_key(key: str, allow_k8s_prefix: bool = False):
 
     # Allow the use of Kubernetes reserved prefixes ('k8s.io/' or 'kubernetes.io/')
     # only when setting node selectors, not when adding new labels.
-    if (
-        key.startswith("k8s.io/")
-        or key.startswith("kubernetes.io/")
-        and not allow_k8s_prefix
-    ):
+    if not allow_k8s_prefix and prefix in {"k8s.io", "kubernetes.io"}:
         raise mlrun.errors.MLRunInvalidArgumentError(
             "Labels cannot start with 'k8s.io/' or 'kubernetes.io/'"
         )

mlrun/launcher/base.py

@@ -401,6 +401,7 @@ class BaseLauncher(abc.ABC):
                 status=run.status.state,
                 name=run.metadata.name,
             )
+            self._update_end_time_if_terminal_state(runtime, run)
             if (
                 run.status.state
                 in mlrun.common.runtimes.constants.RunStates.error_and_abortion_states()
@@ -416,6 +417,21 @@ class BaseLauncher(abc.ABC):
 
         return None
 
+    @staticmethod
+    def _update_end_time_if_terminal_state(
+        runtime: "mlrun.runtimes.BaseRuntime", run: "mlrun.run.RunObject"
+    ):
+        if (
+            run.status.state
+            in mlrun.common.runtimes.constants.RunStates.terminal_states()
+            and not run.status.end_time
+        ):
+            end_time = mlrun.utils.now_date().isoformat()
+            updates = {"status.end_time": end_time}
+            runtime._get_db().update_run(
+                updates, run.metadata.uid, run.metadata.project
+            )
+
     @staticmethod
     def _refresh_function_metadata(runtime: "mlrun.runtimes.BaseRuntime"):
         pass

mlrun/model_monitoring/api.py

@@ -619,8 +619,8 @@ def _create_model_monitoring_function_base(
     app_step.__class__ = mlrun.serving.MonitoringApplicationStep
 
     app_step.error_handler(
-        name="ApplicationErrorHandler",
         class_name="mlrun.model_monitoring.applications._application_steps._ApplicationErrorHandler",
+        name="ApplicationErrorHandler",
         full_event=True,
         project=project,
     )
@@ -629,7 +629,6 @@ def _create_model_monitoring_function_base(
         class_name="mlrun.model_monitoring.applications._application_steps._PushToMonitoringWriter",
         name="PushToMonitoringWriter",
         project=project,
-        writer_application_name=mm_constants.MonitoringFunctionNames.WRITER,
     )
 
     def block_to_mock_server(*args, **kwargs) -> typing.NoReturn:

mlrun/model_monitoring/applications/_application_steps.py

@@ -18,10 +18,8 @@ from typing import Any, Optional, Union
 
 import mlrun.common.schemas
 import mlrun.common.schemas.alert as alert_objects
-import mlrun.common.schemas.model_monitoring.constants as mm_constant
-import mlrun.datastore
-import mlrun.model_monitoring
-from mlrun.model_monitoring.helpers import get_stream_path
+import mlrun.common.schemas.model_monitoring.constants as mm_constants
+import mlrun.model_monitoring.helpers
 from mlrun.serving import GraphContext
 from mlrun.serving.utils import StepToDict
 from mlrun.utils import logger
@@ -37,29 +35,14 @@ from .results import (
 class _PushToMonitoringWriter(StepToDict):
     kind = "monitoring_application_stream_pusher"
 
-    def __init__(
-        self,
-        project: str,
-        writer_application_name: str,
-        stream_uri: Optional[str] = None,
-        name: Optional[str] = None,
-    ):
+    def __init__(self, project: str) -> None:
         """
         Class for pushing application results to the monitoring writer stream.
 
-        :param project:                     Project name.
-        :param writer_application_name:     Writer application name.
-        :param stream_uri:                  Stream URI for pushing results.
-        :param name:                        Name of the PushToMonitoringWriter
-                                            instance default to PushToMonitoringWriter.
+        :param project: Project name.
         """
         self.project = project
-        self.application_name_to_push = writer_application_name
-        self.stream_uri = stream_uri or get_stream_path(
-            project=self.project, function_name=self.application_name_to_push
-        )
         self.output_stream = None
-        self.name = name or "PushToMonitoringWriter"
 
     def do(
         self,
@@ -82,40 +65,43 @@ class _PushToMonitoringWriter(StepToDict):
         self._lazy_init()
         application_results, application_context = event
         writer_event = {
-            mm_constant.WriterEvent.ENDPOINT_NAME: application_context.endpoint_name,
-            mm_constant.WriterEvent.APPLICATION_NAME: application_context.application_name,
-            mm_constant.WriterEvent.ENDPOINT_ID: application_context.endpoint_id,
-            mm_constant.WriterEvent.START_INFER_TIME: application_context.start_infer_time.isoformat(
+            mm_constants.WriterEvent.ENDPOINT_NAME: application_context.endpoint_name,
+            mm_constants.WriterEvent.APPLICATION_NAME: application_context.application_name,
+            mm_constants.WriterEvent.ENDPOINT_ID: application_context.endpoint_id,
+            mm_constants.WriterEvent.START_INFER_TIME: application_context.start_infer_time.isoformat(
                 sep=" ", timespec="microseconds"
             ),
-            mm_constant.WriterEvent.END_INFER_TIME: application_context.end_infer_time.isoformat(
+            mm_constants.WriterEvent.END_INFER_TIME: application_context.end_infer_time.isoformat(
                 sep=" ", timespec="microseconds"
             ),
         }
         for result in application_results:
             data = result.to_dict()
             if isinstance(result, ModelMonitoringApplicationResult):
-                writer_event[mm_constant.WriterEvent.EVENT_KIND] = (
-                    mm_constant.WriterEventKind.RESULT
+                writer_event[mm_constants.WriterEvent.EVENT_KIND] = (
+                    mm_constants.WriterEventKind.RESULT
                 )
             elif isinstance(result, _ModelMonitoringApplicationStats):
-                writer_event[mm_constant.WriterEvent.EVENT_KIND] = (
-                    mm_constant.WriterEventKind.STATS
+                writer_event[mm_constants.WriterEvent.EVENT_KIND] = (
+                    mm_constants.WriterEventKind.STATS
                 )
             else:
-                writer_event[mm_constant.WriterEvent.EVENT_KIND] = (
-                    mm_constant.WriterEventKind.METRIC
+                writer_event[mm_constants.WriterEvent.EVENT_KIND] = (
+                    mm_constants.WriterEventKind.METRIC
                 )
-            writer_event[mm_constant.WriterEvent.DATA] = json.dumps(data)
-            logger.info(
-                f"Pushing data = {writer_event} \n to stream = {self.stream_uri}"
+            writer_event[mm_constants.WriterEvent.DATA] = json.dumps(data)
+            logger.debug(
+                "Pushing data to output stream", writer_event=str(writer_event)
             )
             self.output_stream.push([writer_event])
-            logger.info(f"Pushed data to {self.stream_uri} successfully")
+            logger.debug("Pushed data to output stream successfully")
 
     def _lazy_init(self):
         if self.output_stream is None:
-            self.output_stream = mlrun.datastore.get_stream_pusher(self.stream_uri)
+            self.output_stream = mlrun.model_monitoring.helpers.get_output_stream(
+                project=self.project,
+                function_name=mm_constants.MonitoringFunctionNames.WRITER,
+            )
 
 
 class _PrepareMonitoringEvent(StepToDict):