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

mlrun/projects/project.py

@@ -29,7 +29,6 @@ import zipfile
 from copy import deepcopy
 from os import environ, makedirs, path
 from typing import Callable, Optional, Union, cast
-from urllib.parse import urlparse
 
 import deprecated
 import dotenv
@@ -71,6 +70,7 @@ from mlrun.datastore.datastore_profile import (
 from mlrun.datastore.vectorstore import VectorStoreCollection
 from mlrun.model_monitoring.helpers import (
     filter_results_by_regex,
+    get_alert_name_from_result_fqn,
     get_result_instance_fqn,
 )
 from mlrun.runtimes.nuclio.function import RemoteRuntime
@@ -2142,7 +2142,8 @@ class MlrunProject(ModelObj):
         reset_policy: mlrun.common.schemas.alert.ResetPolicy = mlrun.common.schemas.alert.ResetPolicy.AUTO,
     ) -> list[mlrun.alerts.alert.AlertConfig]:
         """
-        :param name:                   AlertConfig name.
+        :param name:                   The name of the AlertConfig template. It will be combined with mep_id, app-name
+                                       and result name to generate a unique name.
         :param summary:                Summary of the alert, will be sent in the generated notifications
         :param endpoints:              The endpoints from which metrics will be retrieved to configure the alerts.
                                        This `ModelEndpointList` object obtained via the `list_model_endpoints`
@@ -2154,7 +2155,7 @@ class MlrunProject(ModelObj):
 
                                        For example:
                                        [`app1.result-*`, `*.result1`]
-                                       will match "mep1.app1.result.result-1" and "mep1.app2.result.result1".
+                                       will match "mep_uid1.app1.result.result-1" and "mep_uid1.app2.result.result1".
                                        A specific result_name (not a wildcard) will always create a new alert
                                        config, regardless of whether the result name exists.
         :param severity:               Severity of the alert.
@@ -2203,10 +2204,11 @@ class MlrunProject(ModelObj):
                 )
         alert_result_names = list(set(specific_result_names + matching_results))
         for result_fqn in alert_result_names:
+            result_fqn_name = get_alert_name_from_result_fqn(result_fqn)
             alerts.append(
                 mlrun.alerts.alert.AlertConfig(
                     project=self.name,
-                    name=name,
+                    name=f"{name}--{result_fqn_name}",
                     summary=summary,
                     severity=severity,
                     entities=alert_constants.EventEntities(
@@ -3671,50 +3673,77 @@ class MlrunProject(ModelObj):
 
     def set_model_monitoring_credentials(
         self,
-        access_key: Optional[str] = None,
-        stream_path: Optional[str] = None,  # Deprecated
-        tsdb_connection: Optional[str] = None,  # Deprecated
-        replace_creds: bool = False,
         *,
-        stream_profile_name: Optional[str] = None,
-        tsdb_profile_name: Optional[str] = None,
-    ):
+        tsdb_profile_name: str,
+        stream_profile_name: str,
+        replace_creds: bool = False,
+    ) -> None:
         """
-        Set the credentials that will be used by the project's model monitoring
-        infrastructure functions. Important to note that you have to set the credentials before deploying any
-        model monitoring or serving function.
-
-        :param access_key:                Model monitoring access key for managing user permissions.
-
-                                          * None - will be set from the system configuration.
-                                          * v3io - for v3io endpoint store, pass `v3io` and the system will generate the
-                                            exact path.
-        :param stream_path:               (Deprecated) This argument is deprecated. Use ``stream_profile_name`` instead.
-                                          Path to the model monitoring stream. By default, None. Options:
-
-                                          * ``"v3io"`` - for v3io stream, pass ``"v3io"`` and the system will generate
-                                            the exact path.
-                                          * Kafka - for Kafka stream, provide the full connection string without acustom
-                                            topic, for example ``"kafka://<some_kafka_broker>:<port>"``.
-        :param tsdb_connection:           (Deprecated) Connection string to the time series database. By default, None.
-                                          Options:
-
-                                          * v3io - for v3io stream, pass ``"v3io"`` and the system will generate the
-                                            exact path.
-                                          * TDEngine - for TDEngine tsdb, provide the full websocket connection URL,
-                                            for example ``"taosws://<username>:<password>@<host>:<port>"``.
-        :param replace_creds:             If True, will override the existing credentials.
-                                          Please keep in mind that if you already enabled model monitoring on
-                                          your project this action can cause data loose and will require redeploying
-                                          all model monitoring functions & model monitoring infra
-                                          & tracked model server.
-        :param stream_profile_name:       The datastore profile name of the stream to be used in model monitoring.
-                                          The supported profiles are:
+        Set the credentials that will be used by the project's model monitoring infrastructure functions.
+        Please note that you have to set the credentials before deploying any model monitoring application
+        or a tracked serving function.
 
-                                          * :py:class:`~mlrun.datastore.datastore_profile.DatastoreProfileV3io`
-                                          * :py:class:`~mlrun.datastore.datastore_profile.DatastoreProfileKafkaSource`
+        For example, the full flow for enabling model monitoring infrastructure with **TDEngine** and **Kafka**, is:
+
+        .. code-block:: python
+
+            import mlrun
+            from mlrun.datastore.datastore_profile import (
+                DatastoreProfileKafkaSource,
+                TDEngineDatastoreProfile,
+            )
+
+            project = mlrun.get_or_create_project("mm-infra-setup")
+
+            # Create and register TSDB profile
+            tsdb_profile = TDEngineDatastoreProfile(
+                name="my-tdengine",
+                host="<tdengine-server-ip-address>",
+                port=6041,
+                user="username",
+                password="<tdengine-password>",
+            )
+            project.register_datastore_profile(tsdb_profile)
+
+            # Create and register stream profile
+            stream_profile = DatastoreProfileKafkaSource(
+                name="my-kafka",
+                brokers=["<kafka-broker-ip-address>:9094"],
+                topics=[],  # Keep the topics list empty
+                ## SASL is supported
+                # sasl_user="user1",
+                # sasl_pass="<kafka-sasl-password>",
+            )
+            project.register_datastore_profile(stream_profile)
+
+            # Set model monitoring credentials and enable the infrastructure
+            project.set_model_monitoring_credentials(
+                tsdb_profile_name=tsdb_profile.name,
+                stream_profile_name=stream_profile.name,
+            )
+            project.enable_model_monitoring()
+
+        Note that you will need to change the profiles if you want to use **V3IO** TSDB and stream:
+
+        .. code-block:: python
+
+            from mlrun.datastore.datastore_profile import DatastoreProfileV3io
+
+            # Create and register TSDB profile
+            tsdb_profile = DatastoreProfileV3io(
+                name="my-v3io-tsdb",
+            )
+            project.register_datastore_profile(tsdb_profile)
+
+            # Create and register stream profile
+            stream_profile = DatastoreProfileV3io(
+                name="my-v3io-stream",
+                v3io_access_key=mlrun.mlconf.get_v3io_access_key(),
+            )
+            project.register_datastore_profile(stream_profile)
+
+        In the V3IO datastore, you must provide an explicit access key to the stream, but not to the TSDB.
 
-                                          You need to register one of them, and pass the profile's name.
         :param tsdb_profile_name:         The datastore profile name of the time-series database to be used in model
                                           monitoring. The supported profiles are:
 
@@ -3722,76 +3751,24 @@ class MlrunProject(ModelObj):
                                           * :py:class:`~mlrun.datastore.datastore_profile.TDEngineDatastoreProfile`
 
                                           You need to register one of them, and pass the profile's name.
-        """
-        db = mlrun.db.get_run_db(secrets=self._secrets)
-
-        if tsdb_connection:
-            warnings.warn(
-                "The `tsdb_connection` argument is deprecated and will be removed in MLRun version 1.8.0. "
-                "Use `tsdb_profile_name` instead.",
-                FutureWarning,
-            )
-            if tsdb_profile_name:
-                raise mlrun.errors.MLRunValueError(
-                    "If you set `tsdb_profile_name`, you must not pass `tsdb_connection`."
-                )
-            if tsdb_connection == "v3io":
-                tsdb_profile = mlrun.datastore.datastore_profile.DatastoreProfileV3io(
-                    name=mm_constants.DefaultProfileName.TSDB
-                )
-            else:
-                parsed_url = urlparse(tsdb_connection)
-                if parsed_url.scheme != "taosws":
-                    raise mlrun.errors.MLRunValueError(
-                        f"Unsupported `tsdb_connection`: '{tsdb_connection}'."
-                    )
-                tsdb_profile = (
-                    mlrun.datastore.datastore_profile.TDEngineDatastoreProfile(
-                        name=mm_constants.DefaultProfileName.TSDB,
-                        user=parsed_url.username,
-                        password=parsed_url.password,
-                        host=parsed_url.hostname,
-                        port=parsed_url.port,
-                    )
-                )
+        :param stream_profile_name:       The datastore profile name of the stream to be used in model monitoring.
+                                          The supported profiles are:
 
-            self.register_datastore_profile(tsdb_profile)
-            tsdb_profile_name = tsdb_profile.name
+                                          * :py:class:`~mlrun.datastore.datastore_profile.DatastoreProfileV3io`
+                                          * :py:class:`~mlrun.datastore.datastore_profile.DatastoreProfileKafkaSource`
 
-        if stream_path:
-            warnings.warn(
-                "The `stream_path` argument is deprecated and will be removed in MLRun version 1.8.0. "
-                "Use `stream_profile_name` instead.",
-                FutureWarning,
-            )
-            if stream_profile_name:
-                raise mlrun.errors.MLRunValueError(
-                    "If you set `stream_profile_name`, you must not pass `stream_path`."
-                )
-            if stream_path == "v3io":
-                stream_profile = mlrun.datastore.datastore_profile.DatastoreProfileV3io(
-                    name=mm_constants.DefaultProfileName.STREAM
-                )
-            else:
-                parsed_stream = urlparse(stream_path)
-                if parsed_stream.scheme != "kafka":
-                    raise mlrun.errors.MLRunValueError(
-                        f"Unsupported `stream_path`: '{stream_path}'."
-                    )
-                stream_profile = (
-                    mlrun.datastore.datastore_profile.DatastoreProfileKafkaSource(
-                        name=mm_constants.DefaultProfileName.STREAM,
-                        brokers=[parsed_stream.netloc],
-                        topics=[],
-                    )
-                )
-            self.register_datastore_profile(stream_profile)
-            stream_profile_name = stream_profile.name
+                                          You need to register one of them, and pass the profile's name.
+        :param replace_creds:             If ``True`` - override the existing credentials.
+                                          Please keep in mind that if you have already enabled model monitoring
+                                          on your project, replacing the credentials can cause data loss, and will
+                                          require redeploying all the model monitoring functions, model monitoring
+                                          infrastructure, and tracked model servers.
+        """
+        db = mlrun.db.get_run_db(secrets=self._secrets)
 
         db.set_model_monitoring_credentials(
             project=self.name,
             credentials={
-                "access_key": access_key,
                 "tsdb_profile_name": tsdb_profile_name,
                 "stream_profile_name": stream_profile_name,
             },
@@ -3809,7 +3786,7 @@ class MlrunProject(ModelObj):
 
     def list_model_endpoints(
         self,
-        name: Optional[str] = None,
+        names: Optional[Union[str, list[str]]] = None,
         model_name: Optional[str] = None,
         model_tag: Optional[str] = None,
         function_name: Optional[str] = None,
@@ -3839,7 +3816,7 @@ class MlrunProject(ModelObj):
         In addition, this functions provides a facade for listing endpoint related metrics. This facade is time-based
         and depends on the 'start' and 'end' parameters.
 
-        :param name: The name of the model to filter by
+        :param names: The name of the model to filter by
         :param model_name: The name of the model to filter by
         :param function_name: The name of the function to filter by
         :param function_tag: The tag of the function to filter by
@@ -3860,7 +3837,7 @@ class MlrunProject(ModelObj):
         db = mlrun.db.get_run_db(secrets=self._secrets)
         return db.list_model_endpoints(
             project=self.name,
-            name=name,
+            names=names,
             model_name=model_name,
             model_tag=model_tag,
             function_name=function_name,

mlrun/serving/states.py

@@ -812,8 +812,8 @@ class RouterStep(TaskStep):
             * **archive**:
             1. If model endpoints with the same name exist, preserve them.
             2. Create a new model endpoint with the same name and set it to `latest`.
-
         """
+
         if len(self.routes.keys()) >= MAX_MODELS_PER_ROUTER and key not in self.routes:
             raise mlrun.errors.MLRunModelLimitExceededError(
                 f"Router cannot support more than {MAX_MODELS_PER_ROUTER} model endpoints. "

mlrun/serving/v2_serving.py

@@ -115,6 +115,7 @@ class V2ModelServer(StepToDict):
         self.shard_by_endpoint = shard_by_endpoint
         self._model_logger = None
         self.initialized = False
+        self.output_schema = []
 
     def _load_and_update_state(self):
         try:
@@ -175,17 +176,15 @@ class V2ModelServer(StepToDict):
                     "Model endpoint creation task name not provided",
                 )
             try:
-                self.model_endpoint_uid = (
-                    mlrun.get_run_db()
-                    .get_model_endpoint(
-                        project=server.project,
-                        name=self.name,
-                        function_name=server.function_name,
-                        function_tag=server.function_tag or "latest",
-                        tsdb_metrics=False,
-                    )
-                    .metadata.uid
+                model_endpoint = mlrun.get_run_db().get_model_endpoint(
+                    project=server.project,
+                    name=self.name,
+                    function_name=server.function_name,
+                    function_tag=server.function_tag or "latest",
+                    tsdb_metrics=False,
                 )
+                self.model_endpoint_uid = model_endpoint.metadata.uid
+                self.output_schema = model_endpoint.spec.label_names
             except mlrun.errors.MLRunNotFoundError:
                 logger.info(
                     "Model endpoint not found for this step; monitoring for this model will not be performed",
@@ -566,6 +565,17 @@ class _ModelLogPusher:
                     resp["outputs"] = [
                         resp["outputs"][i] for i in sampled_requests_indices
                     ]
+                if self.model.output_schema and len(self.model.output_schema) != len(
+                    resp["outputs"][0]
+                ):
+                    logger.info(
+                        "The number of outputs returned by the model does not match the number of outputs "
+                        "specified in the model endpoint.",
+                        model_endpoint=self.model.name,
+                        model_endpoint_id=self.model.model_endpoint_uid,
+                        output_len=len(resp["outputs"][0]),
+                        schema_len=len(self.model.output_schema),
+                    )
 
             data = self.base_data()
             data["request"] = request

mlrun/utils/helpers.py

@@ -2037,7 +2037,7 @@ class Workflow:
                         pod_phase
                     )
                 function["status"] = {"state": state}
-                if isinstance(function["metadata"].get("updated"), datetime.datetime):
+                if isinstance(function["metadata"].get("updated"), datetime):
                     function["metadata"]["updated"] = function["metadata"][
                         "updated"
                     ].isoformat()

mlrun/utils/logger.py

@@ -11,6 +11,7 @@
 # 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 contextvars
 import datetime
 import logging
 import os
@@ -29,6 +30,8 @@ import pydantic.v1
 from mlrun import errors
 from mlrun.config import config
 
+context_id_var = contextvars.ContextVar("context_id", default=None)
+
 
 class _BaseFormatter(logging.Formatter):
     def _json_dump(self, json_object):
@@ -58,12 +61,19 @@ class _BaseFormatter(logging.Formatter):
             default=default,
         ).decode()
 
-
-class JSONFormatter(_BaseFormatter):
-    def format(self, record) -> str:
+    def _record_with(self, record):
         record_with = getattr(record, "with", {})
         if record.exc_info:
             record_with.update(exc_info=format_exception(*record.exc_info))
+        if "ctx" not in record_with:
+            if (ctx_id := context_id_var.get()) is not None:
+                record_with["ctx"] = ctx_id
+        return record_with
+
+
+class JSONFormatter(_BaseFormatter):
+    def format(self, record) -> str:
+        record_with = self._record_with(record)
         record_fields = {
             "datetime": self.formatTime(record, self.datefmt),
             "level": record.levelname.lower(),
@@ -90,12 +100,6 @@ class HumanReadableFormatter(_BaseFormatter):
         more = f": {record_with_encoded}" if record_with_encoded else ""
         return more
 
-    def _record_with(self, record):
-        record_with = getattr(record, "with", {})
-        if record.exc_info:
-            record_with.update(exc_info=format_exception(*record.exc_info))
-        return record_with
-
 
 class CustomFormatter(HumanReadableFormatter):
     """
@@ -354,7 +358,6 @@ class Logger:
         self, level, message, *args, exc_info=None, **kw_args
     ):
         kw_args.update(self._bound_variables)
-
         if kw_args:
             self._logger.log(
                 level, message, *args, exc_info=exc_info, extra={"with": kw_args}

mlrun/utils/notifications/notification_pusher.py

@@ -474,6 +474,7 @@ class CustomNotificationPusher(_NotificationPusherBase):
             for notification_type, notification in notifications.items()
             if notification.is_async
         }
+        self._server_notifications = []
 
     @property
     def notifications(self):
@@ -481,6 +482,10 @@ class CustomNotificationPusher(_NotificationPusherBase):
         notifications.update(self._async_notifications)
         return notifications
 
+    @property
+    def server_notifications(self):
+        return self._server_notifications
+
     def push(
         self,
         message: str,
@@ -511,6 +516,14 @@ class CustomNotificationPusher(_NotificationPusherBase):
         self,
         notification_type: str,
         params: typing.Optional[dict[str, str]] = None,
+        name: typing.Optional[str] = None,
+        message: typing.Optional[str] = None,
+        severity: mlrun.common.schemas.notification.NotificationSeverity = (
+            mlrun.common.schemas.notification.NotificationSeverity.INFO
+        ),
+        when: typing.Optional[list[str]] = None,
+        condition: typing.Optional[str] = None,
+        secret_params: typing.Optional[dict[str, str]] = None,
     ):
         if notification_type not in [
             notification_module.NotificationTypes.console,
@@ -518,6 +531,17 @@ class CustomNotificationPusher(_NotificationPusherBase):
         ]:
             # We want that only the console and ipython notifications will be notified by the client.
             # The rest of the notifications will be notified by the BE.
+            self._server_notifications.append(
+                mlrun.model.Notification(
+                    kind=notification_type,
+                    name=name,
+                    message=message,
+                    severity=severity,
+                    when=when or runtimes_constants.RunStates.notification_states(),
+                    params=params,
+                    secret_params=secret_params,
+                )
+            )
             return
 
         if notification_type in self._async_notifications:

mlrun/utils/regex.py

@@ -110,3 +110,4 @@ artifact_producer_uri_pattern = (
 )
 
 mail_regex = r"^[a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]+\.[a-zA-Z0-9-.]+$"
+alert_name_regex = r"^[a-zA-Z0-9-_]+$"

mlrun/utils/version/version.json

@@ -1,4 +1,4 @@
 {
-  "git_commit": "d77b75367fbca42653b1bcfcee75ff821848202b",
-  "version": "1.8.0-rc30"
+  "git_commit": "c816b6df64e933458e71286173355dc766e50e68",
+  "version": "1.8.0-rc32"
 }

{mlrun-1.8.0rc30.dist-info → mlrun-1.8.0rc32.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: mlrun
-Version: 1.8.0rc30
+Version: 1.8.0rc32
 Summary: Tracking and config of machine learning runs
 Home-page: https://github.com/mlrun/mlrun
 Author: Yaron Haviv
@@ -51,7 +51,7 @@ Requires-Dist: setuptools>=75.2
 Requires-Dist: deprecated~=1.2
 Requires-Dist: jinja2>=3.1.3,~=3.1
 Requires-Dist: orjson<4,>=3.9.15
-Requires-Dist: mlrun-pipelines-kfp-common~=0.3.7
+Requires-Dist: mlrun-pipelines-kfp-common~=0.3.9
 Requires-Dist: mlrun-pipelines-kfp-v1-8~=0.3.5; python_version < "3.11"
 Requires-Dist: docstring_parser~=0.16
 Requires-Dist: aiosmtplib~=3.0