mlrun 1.8.0rc28__py3-none-any.whl → 1.8.0rc30__py3-none-any.whl

mlrun/__init__.py

@@ -26,6 +26,7 @@ __all__ = [
     "VolumeMount",
 ]
 
+import collections
 from os import environ, path
 from typing import Optional
 
@@ -238,7 +239,7 @@ def order_env_vars(env_vars: dict[str, str]) -> dict[str, str]:
     """
     ordered_keys = mlconf.get_ordered_keys()
 
-    ordered_env_vars: dict[str, str] = {}
+    ordered_env_vars = collections.OrderedDict()
 
     # First, add the ordered keys to the dictionary
     for key in ordered_keys:

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

@@ -229,6 +229,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/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):
@@ -481,3 +480,6 @@ INTERSECT_DICT_KEYS = {
     ModelEndpointMonitoringMetricType.METRIC: "intersect_metrics",
     ModelEndpointMonitoringMetricType.RESULT: "intersect_results",
 }
+
+CRON_TRIGGER_KINDS = ("http", "cron")
+STREAM_TRIGGER_KINDS = ("v3io-stream", "kafka-cluster")

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/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
@@ -3896,7 +3870,7 @@ class HTTPRunDB(RunDBInterface):
         function_name: Optional[str] = None,
         function_tag: Optional[str] = None,
         endpoint_id: Optional[str] = None,
-    ) -> mlrun.common.schemas.ModelEndpoint:
+    ) -> None:
         """
         Updates a model endpoint with the given attributes.
 
@@ -3906,7 +3880,6 @@ class HTTPRunDB(RunDBInterface):
         :param function_name:              The name of the function
         :param function_tag:               The tag of the function
         :param endpoint_id:                The id of the endpoint
-        :return:                          The updated `ModelEndpoint` object.
         """
         attributes_keys = list(attributes.keys())
         attributes["name"] = name
@@ -3929,8 +3902,11 @@ class HTTPRunDB(RunDBInterface):
             },
             body=model_endpoint.json(),
         )
-
-        return mlrun.common.schemas.ModelEndpoint(**response.json())
+        logger.info(
+            "Updating model endpoint done",
+            model_endpoint_uid=response.json(),
+            status_code=response.status_code,
+        )
 
     @staticmethod
     def _check_model_endpoint_representation(

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):

mlrun/model_monitoring/applications/context.py

@@ -111,9 +111,6 @@ class MonitoringApplicationContext:
         self.endpoint_name = cast(
             str, event.get(mm_constants.ApplicationEvent.ENDPOINT_NAME)
         )
-        self.output_stream_uri = cast(
-            str, event.get(mm_constants.ApplicationEvent.OUTPUT_STREAM_URI)
-        )
 
         self._feature_stats: Optional[FeatureStats] = feature_stats
         self._sample_df_stats: Optional[FeatureStats] = None

mlrun/model_monitoring/applications/results.py

@@ -22,7 +22,7 @@ from pydantic.v1.dataclasses import dataclass
 
 import mlrun.common.helpers
 import mlrun.common.model_monitoring.helpers
-import mlrun.common.schemas.model_monitoring.constants as mm_constant
+import mlrun.common.schemas.model_monitoring.constants as mm_constants
 import mlrun.utils.v3io_clients
 from mlrun.utils import logger
 
@@ -63,8 +63,8 @@ class ModelMonitoringApplicationResult(_ModelMonitoringApplicationDataRes):
 
     name: str
     value: float
-    kind: mm_constant.ResultKindApp
-    status: mm_constant.ResultStatusApp
+    kind: mm_constants.ResultKindApp
+    status: mm_constants.ResultStatusApp
     extra_data: dict = dataclasses.field(default_factory=dict)
 
     def to_dict(self):
@@ -74,11 +74,11 @@ class ModelMonitoringApplicationResult(_ModelMonitoringApplicationDataRes):
         :returns:    (dict) Dictionary representation of the result.
         """
         return {
-            mm_constant.ResultData.RESULT_NAME: self.name,
-            mm_constant.ResultData.RESULT_VALUE: self.value,
-            mm_constant.ResultData.RESULT_KIND: self.kind.value,
-            mm_constant.ResultData.RESULT_STATUS: self.status.value,
-            mm_constant.ResultData.RESULT_EXTRA_DATA: json.dumps(self.extra_data),
+            mm_constants.ResultData.RESULT_NAME: self.name,
+            mm_constants.ResultData.RESULT_VALUE: self.value,
+            mm_constants.ResultData.RESULT_KIND: self.kind.value,
+            mm_constants.ResultData.RESULT_STATUS: self.status.value,
+            mm_constants.ResultData.RESULT_EXTRA_DATA: json.dumps(self.extra_data),
         }
 
     @validator("extra_data")
@@ -118,8 +118,8 @@ class ModelMonitoringApplicationMetric(_ModelMonitoringApplicationDataRes):
         :returns:    (dict) Dictionary representation of the result.
         """
         return {
-            mm_constant.MetricData.METRIC_NAME: self.name,
-            mm_constant.MetricData.METRIC_VALUE: self.value,
+            mm_constants.MetricData.METRIC_NAME: self.name,
+            mm_constants.MetricData.METRIC_VALUE: self.value,
         }
 
 
@@ -134,7 +134,7 @@ class _ModelMonitoringApplicationStats(_ModelMonitoringApplicationDataRes):
 
     """
 
-    name: mm_constant.StatsKind
+    name: mm_constants.StatsKind
     timestamp: str
     stats: dict = dataclasses.field(default_factory=dict)
 
@@ -145,7 +145,7 @@ class _ModelMonitoringApplicationStats(_ModelMonitoringApplicationDataRes):
         :returns:    (dict) Dictionary representation of the result.
         """
         return {
-            mm_constant.StatsData.STATS_NAME: self.name,
-            mm_constant.StatsData.STATS: self.stats,
-            mm_constant.StatsData.TIMESTAMP: self.timestamp,
+            mm_constants.StatsData.STATS_NAME: self.name,
+            mm_constants.StatsData.STATS: self.stats,
+            mm_constants.StatsData.TIMESTAMP: self.timestamp,
         }

mlrun/model_monitoring/controller.py

@@ -27,15 +27,15 @@ import mlrun
 import mlrun.common.schemas.model_monitoring.constants as mm_constants
 import mlrun.feature_store as fstore
 import mlrun.model_monitoring
+import mlrun.model_monitoring.helpers
 from mlrun.common.schemas import EndpointType
 from mlrun.common.schemas.model_monitoring.constants import (
     ControllerEvent,
     ControllerEventKind,
 )
-from mlrun.datastore import get_stream_pusher
 from mlrun.errors import err_to_str
 from mlrun.model_monitoring.db._schedules import ModelMonitoringSchedulesFile
-from mlrun.model_monitoring.helpers import batch_dict2timedelta, get_stream_path
+from mlrun.model_monitoring.helpers import batch_dict2timedelta
 from mlrun.utils import datetime_now, logger
 
 _SECONDS_IN_DAY = int(datetime.timedelta(days=1).total_seconds())
@@ -249,7 +249,7 @@ class MonitoringApplicationController:
         self._window_length = _get_window_length()
 
         self.model_monitoring_access_key = self._get_model_monitoring_access_key()
-        self.v3io_access_key = mlrun.get_secret_or_env("V3IO_ACCESS_KEY")
+        self.v3io_access_key = mlrun.mlconf.get_v3io_access_key()
         self.storage_options = None
         if mlrun.mlconf.artifact_path.startswith("s3://"):
             self.storage_options = mlrun.mlconf.get_s3_storage_options()
@@ -482,24 +482,23 @@ class MonitoringApplicationController:
             ),
             mm_constants.ApplicationEvent.ENDPOINT_ID: endpoint_id,
             mm_constants.ApplicationEvent.ENDPOINT_NAME: endpoint_name,
-            mm_constants.ApplicationEvent.OUTPUT_STREAM_URI: get_stream_path(
-                project=project,
-                function_name=mm_constants.MonitoringFunctionNames.WRITER,
-            ),
         }
         for app_name in applications_names:
             data.update({mm_constants.ApplicationEvent.APPLICATION_NAME: app_name})
-            stream_uri = get_stream_path(project=project, function_name=app_name)
+
+            app_stream = mlrun.model_monitoring.helpers.get_output_stream(
+                project=project,
+                function_name=app_name,
+                v3io_access_key=model_monitoring_access_key,
+            )
 
             logger.info(
                 "Pushing data to application stream",
                 endpoint_id=endpoint_id,
                 app_name=app_name,
-                stream_uri=stream_uri,
-            )
-            get_stream_pusher(stream_uri, access_key=model_monitoring_access_key).push(
-                [data]
+                app_stream_type=str(type(app_stream)),
             )
+            app_stream.push([data])
 
     def push_regular_event_to_controller_stream(self) -> None:
         """
@@ -628,10 +627,6 @@ class MonitoringApplicationController:
         :param feature_set_uri: the feature set uri string
         :param stream_access_key: access key to apply the model monitoring process.
         """
-        stream_uri = get_stream_path(
-            project=project,
-            function_name=mm_constants.MonitoringFunctionNames.APPLICATION_CONTROLLER,
-        )
         event = {
             ControllerEvent.KIND.value: kind,
             ControllerEvent.PROJECT.value: project,
@@ -643,15 +638,18 @@ class MonitoringApplicationController:
             ControllerEvent.FEATURE_SET_URI.value: feature_set_uri,
             ControllerEvent.ENDPOINT_POLICY.value: endpoint_policy,
         }
+        controller_stream = mlrun.model_monitoring.helpers.get_output_stream(
+            project=project,
+            function_name=mm_constants.MonitoringFunctionNames.APPLICATION_CONTROLLER,
+            v3io_access_key=stream_access_key,
+        )
         logger.info(
             "Pushing data to controller stream",
             event=event,
             endpoint_id=endpoint_id,
-            stream_uri=stream_uri,
-        )
-        get_stream_pusher(stream_uri, access_key=stream_access_key).push(
-            [event], partition_key=endpoint_id
+            controller_stream_type=str(type(controller_stream)),
         )
+        controller_stream.push([event], partition_key=endpoint_id)
 
     def _push_to_main_stream(self, event: dict, endpoint_id: str) -> None:
         """
@@ -659,17 +657,18 @@ class MonitoringApplicationController:
         :param event: event dictionary to push to stream
         :param endpoint_id: endpoint id string
         """
-        stream_uri = get_stream_path(project=event.get(ControllerEvent.PROJECT))
-
+        mm_stream = mlrun.model_monitoring.helpers.get_output_stream(
+            project=event.get(ControllerEvent.PROJECT),
+            function_name=mm_constants.MonitoringFunctionNames.APPLICATION_CONTROLLER,
+            v3io_access_key=self.v3io_access_key,
+        )
         logger.info(
             "Pushing data to main stream, NOP event is been generated",
             event=json.dumps(event),
             endpoint_id=endpoint_id,
-            stream_uri=stream_uri,
-        )
-        get_stream_pusher(stream_uri, access_key=self.model_monitoring_access_key).push(
-            [event], partition_key=endpoint_id
+            mm_stream_type=str(type(mm_stream)),
         )
+        mm_stream.push([event], partition_key=endpoint_id)
 
 
 def handler(context: nuclio_sdk.Context, event: nuclio_sdk.Event) -> None:
@@ -685,12 +684,16 @@ def handler(context: nuclio_sdk.Context, event: nuclio_sdk.Event) -> None:
         trigger_kind=event.trigger.kind,
     )
 
-    if event.trigger.kind == "http":
+    if event.trigger.kind in mm_constants.CRON_TRIGGER_KINDS:
         # Runs controller chief:
         context.user_data.monitor_app_controller.push_regular_event_to_controller_stream()
-    else:
+    elif event.trigger.kind in mm_constants.STREAM_TRIGGER_KINDS:
         # Runs controller worker:
         context.user_data.monitor_app_controller.run(event)
+    else:
+        raise mlrun.errors.MLRunInvalidArgumentError(
+            "Wrong trigger kind for model monitoring controller"
+        )
 
 
 def init_context(context):

mlrun/model_monitoring/db/tsdb/tdengine/tdengine_connector.py

@@ -40,7 +40,7 @@ class TDEngineConnector(TSDBConnector):
     def __init__(
         self,
         project: str,
-        database: str = tdengine_schemas._MODEL_MONITORING_DATABASE,
+        database: typing.Optional[str] = None,
         **kwargs,
     ):
         super().__init__(project=project)
@@ -48,8 +48,12 @@ class TDEngineConnector(TSDBConnector):
             raise mlrun.errors.MLRunInvalidArgumentError(
                 "connection_string is a required parameter for TDEngineConnector."
             )
+
         self._tdengine_connection_string = kwargs.get("connection_string")
-        self.database = database
+        self.database = (
+            database
+            or f"{tdengine_schemas._MODEL_MONITORING_DATABASE}_{mlrun.mlconf.system_id}"
+        )
 
         self._connection = None
         self._init_super_tables()