snowflake-cli-labs 2.6.1__py3-none-any.whl → 2.7.0rc0__py3-none-any.whl

snowflake/cli/plugins/nativeapp/constants.py

@@ -25,9 +25,3 @@ PATCH_COL = "patch"
 
 INTERNAL_DISTRIBUTION = "internal"
 EXTERNAL_DISTRIBUTION = "external"
-
-ERROR_MESSAGE_2003 = "does not exist or not authorized"
-ERROR_MESSAGE_2043 = "Object does not exist, or operation cannot be performed."
-ERROR_MESSAGE_606 = "No active warehouse selected in the current session."
-ERROR_MESSAGE_093079 = "Application is no longer available for use"
-ERROR_MESSAGE_093128 = "The application owns one or more objects within the account"

snowflake/cli/plugins/nativeapp/exceptions.py

@@ -12,7 +12,10 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 from textwrap import dedent
+from typing import Optional
 
 import jinja2
 from click.exceptions import ClickException
@@ -36,12 +39,12 @@ class ApplicationPackageDoesNotExistError(ClickException):
         )
 
 
-class ApplicationAlreadyExistsError(ClickException):
+class ApplicationCreatedExternallyError(ClickException):
     """An application object not created by Snowflake CLI exists with the same name."""
 
     def __init__(self, name: str):
         super().__init__(
-            f'A application object "{name}" not created in development mode using files on a named stage already exists in the account.'
+            f'An application object "{name}" not created by Snowflake CLI already exists in the account.'
         )
 
 
@@ -54,18 +57,23 @@ class UnexpectedOwnerError(ClickException):
         )
 
 
-class MissingPackageScriptError(ClickException):
-    """A referenced package script was not found."""
+class MissingScriptError(ClickException):
+    """A referenced script was not found."""
 
     def __init__(self, relpath: str):
-        super().__init__(f'Package script "{relpath}" does not exist')
+        super().__init__(f'Script "{relpath}" does not exist')
 
 
-class InvalidPackageScriptError(ClickException):
-    """A referenced package script had syntax error(s)."""
+class InvalidScriptError(ClickException):
+    """A referenced script had syntax error(s)."""
 
-    def __init__(self, relpath: str, err: jinja2.TemplateError):
-        super().__init__(f'Package script "{relpath}" is not a valid jinja2 template')
+    def __init__(
+        self, relpath: str, err: jinja2.TemplateError, lineno: Optional[int] = None
+    ):
+        lineno_str = f":{lineno}" if lineno is not None else ""
+        super().__init__(
+            f'Script "{relpath}{lineno_str}" does not contain a valid template: {err.message}'
+        )
         self.err = err
 
 
@@ -79,14 +87,14 @@ class MissingSchemaError(ClickException):
 class CouldNotDropApplicationPackageWithVersions(ClickException):
     """Application package could not be dropped as it has versions associated with it."""
 
-    def __init__(self):
+    def __init__(self, additional_msg: str = ""):
         super().__init__(
             dedent(
                 f"""
             {self.__doc__}
-            Versions must be dropped first using “snow app version drop”.
+            {additional_msg}
             """
-            )
+            ).strip()
         )
 
 
@@ -95,3 +103,20 @@ class SetupScriptFailedValidation(ClickException):
 
     def __init__(self):
         super().__init__(self.__doc__)
+
+
+class NoEventTableForAccount(ClickException):
+    """No event table was found for this Snowflake account."""
+
+    INSTRUCTIONS = dedent(
+        """\
+        Ask your Snowflake administrator to set up an event table for your account by following the docs at
+        https://docs.snowflake.com/en/developer-guide/logging-tracing/event-table-setting-up.
+
+        If your account is configured to send events to an organization event account, create a new
+        connection to this account using `snow connection add` and re-run this command using the new connection.
+        More information on event accounts is available at https://docs.snowflake.com/en/developer-guide/native-apps/setting-up-logging-and-events#configure-an-account-to-store-shared-events."""
+    )
+
+    def __init__(self):
+        super().__init__(f"{self.__doc__}\n\n{self.INSTRUCTIONS}")

snowflake/cli/plugins/nativeapp/init.py

@@ -28,8 +28,8 @@ from snowflake.cli.api.project.util import (
     is_valid_unquoted_identifier,
     to_identifier,
 )
+from snowflake.cli.api.rendering.jinja import jinja_render_from_file
 from snowflake.cli.api.secure_path import SecurePath
-from snowflake.cli.api.utils.rendering import jinja_render_from_file
 from yaml import dump, safe_dump, safe_load
 
 log = logging.getLogger(__name__)

snowflake/cli/plugins/nativeapp/manager.py

@@ -17,14 +17,20 @@ from __future__ import annotations
 import json
 import os
 from abc import ABC, abstractmethod
+from contextlib import contextmanager
 from functools import cached_property
 from pathlib import Path
 from textwrap import dedent
-from typing import List, Optional, TypedDict
+from typing import Any, List, NoReturn, Optional, TypedDict
 
 import jinja2
 from click import ClickException
 from snowflake.cli.api.console import cli_console as cc
+from snowflake.cli.api.errno import (
+    DOES_NOT_EXIST_OR_CANNOT_BE_PERFORMED,
+    DOES_NOT_EXIST_OR_NOT_AUTHORIZED,
+    NO_WAREHOUSE_SELECTED_IN_SESSION,
+)
 from snowflake.cli.api.exceptions import SnowflakeSQLExecutionError
 from snowflake.cli.api.project.schemas.native_app.application import (
     ApplicationPostDeployHook,
@@ -48,9 +54,6 @@ from snowflake.cli.plugins.nativeapp.codegen.compiler import (
 from snowflake.cli.plugins.nativeapp.constants import (
     ALLOWED_SPECIAL_COMMENTS,
     COMMENT_COL,
-    ERROR_MESSAGE_606,
-    ERROR_MESSAGE_2003,
-    ERROR_MESSAGE_2043,
     INTERNAL_DISTRIBUTION,
     NAME_COL,
     OWNER_COL,
@@ -59,8 +62,9 @@ from snowflake.cli.plugins.nativeapp.constants import (
 from snowflake.cli.plugins.nativeapp.exceptions import (
     ApplicationPackageAlreadyExistsError,
     ApplicationPackageDoesNotExistError,
-    InvalidPackageScriptError,
-    MissingPackageScriptError,
+    InvalidScriptError,
+    MissingScriptError,
+    NoEventTableForAccount,
     SetupScriptFailedValidation,
     UnexpectedOwnerError,
 )
@@ -78,16 +82,16 @@ from snowflake.cli.plugins.stage.diff import (
     to_stage_path,
 )
 from snowflake.cli.plugins.stage.manager import StageManager
-from snowflake.connector import ProgrammingError
+from snowflake.connector import DictCursor, ProgrammingError
 
 ApplicationOwnedObject = TypedDict("ApplicationOwnedObject", {"name": str, "type": str})
 
 
 def generic_sql_error_handler(
     err: ProgrammingError, role: Optional[str] = None, warehouse: Optional[str] = None
-):
+) -> NoReturn:
     # Potential refactor: If moving away from Python 3.8 and 3.9 to >= 3.10, use match ... case
-    if err.errno == 2043 or err.msg.__contains__(ERROR_MESSAGE_2043):
+    if err.errno == DOES_NOT_EXIST_OR_CANNOT_BE_PERFORMED:
         raise ProgrammingError(
             msg=dedent(
                 f"""\
@@ -98,7 +102,7 @@ def generic_sql_error_handler(
             ),
             errno=err.errno,
         )
-    elif err.errno == 606 or err.msg.__contains__(ERROR_MESSAGE_606):
+    elif err.errno == NO_WAREHOUSE_SELECTED_IN_SESSION:
         raise ProgrammingError(
             msg=dedent(
                 f"""\
@@ -108,7 +112,7 @@ def generic_sql_error_handler(
             ),
             errno=err.errno,
         )
-    elif err.msg.__contains__("does not exist or not authorized"):
+    elif "does not exist or not authorized" in err.msg:
         raise ProgrammingError(
             msg=dedent(
                 f"""\
@@ -216,10 +220,40 @@ class NativeAppManager(SqlExecutionMixin):
     def package_warehouse(self) -> Optional[str]:
         return self.na_project.package_warehouse
 
+    @contextmanager
+    def use_package_warehouse(self):
+        if self.package_warehouse:
+            with self.use_warehouse(self.package_warehouse):
+                yield
+        else:
+            raise ClickException(
+                dedent(
+                    f"""\
+                Application package warehouse cannot be empty.
+                Please provide a value for it in your connection information or your project definition file.
+                """
+                )
+            )
+
     @property
     def application_warehouse(self) -> Optional[str]:
         return self.na_project.application_warehouse
 
+    @contextmanager
+    def use_application_warehouse(self):
+        if self.application_warehouse:
+            with self.use_warehouse(self.application_warehouse):
+                yield
+        else:
+            raise ClickException(
+                dedent(
+                    f"""\
+                Application warehouse cannot be empty.
+                Please provide a value for it in your connection information or your project definition file.
+                """
+                )
+            )
+
     @property
     def project_identifier(self) -> str:
         return self.na_project.project_identifier
@@ -280,6 +314,12 @@ class NativeAppManager(SqlExecutionMixin):
             )
         )
 
+    @cached_property
+    def account_event_table(self) -> str:
+        query = "show parameters like 'event_table' in account"
+        results = self._execute_query(query, cursor_class=DictCursor)
+        return next((r["value"] for r in results if r["key"] == "EVENT_TABLE"), "")
+
     def verify_project_distribution(
         self, expected_distribution: Optional[str] = None
     ) -> bool:
@@ -482,7 +522,8 @@ class NativeAppManager(SqlExecutionMixin):
     def get_snowsight_url(self) -> str:
         """Returns the URL that can be used to visit this app via Snowsight."""
         name = identifier_for_url(self.app_name)
-        return make_snowsight_url(self._conn, f"/#/apps/application/{name}")
+        with self.use_application_warehouse():
+            return make_snowsight_url(self._conn, f"/#/apps/application/{name}")
 
     def create_app_package(self) -> None:
         """
@@ -527,6 +568,36 @@ class NativeAppManager(SqlExecutionMixin):
                 )
             )
 
+    def _expand_script_templates(
+        self, env: jinja2.Environment, jinja_context: dict[str, Any], scripts: List[str]
+    ) -> List[str]:
+        """
+        Input:
+        - env: Jinja2 environment
+        - jinja_context: a dictionary with the jinja context
+        - scripts: list of scripts that need to be expanded with Jinja
+        Returns:
+        - List of expanded scripts content.
+        Size of the return list is the same as the size of the input scripts list.
+        """
+        scripts_contents = []
+        for relpath in scripts:
+            try:
+                template = env.get_template(relpath)
+                result = template.render(**jinja_context)
+                scripts_contents.append(result)
+
+            except jinja2.TemplateNotFound as e:
+                raise MissingScriptError(e.name) from e
+
+            except jinja2.TemplateSyntaxError as e:
+                raise InvalidScriptError(e.name, e, e.lineno) from e
+
+            except jinja2.UndefinedError as e:
+                raise InvalidScriptError(relpath, e) from e
+
+        return scripts_contents
+
     def _apply_package_scripts(self) -> None:
         """
         Assuming the application package exists and we are using the correct role,
@@ -538,34 +609,20 @@ class NativeAppManager(SqlExecutionMixin):
             undefined=jinja2.StrictUndefined,
         )
 
-        queued_queries = []
-        for relpath in self.package_scripts:
-            try:
-                template = env.get_template(relpath)
-                result = template.render(dict(package_name=self.package_name))
-                queued_queries.append(result)
-
-            except jinja2.TemplateNotFound as e:
-                raise MissingPackageScriptError(e.name)
-
-            except jinja2.TemplateSyntaxError as e:
-                raise InvalidPackageScriptError(e.name, e)
-
-            except jinja2.UndefinedError as e:
-                raise InvalidPackageScriptError(relpath, e)
+        queued_queries = self._expand_script_templates(
+            env, dict(package_name=self.package_name), self.package_scripts
+        )
 
         # once we're sure all the templates expanded correctly, execute all of them
-        try:
-            if self.package_warehouse:
-                self._execute_query(f"use warehouse {self.package_warehouse}")
-
-            for i, queries in enumerate(queued_queries):
-                cc.step(f"Applying package script: {self.package_scripts[i]}")
-                self._execute_queries(queries)
-        except ProgrammingError as err:
-            generic_sql_error_handler(
-                err, role=self.package_role, warehouse=self.package_warehouse
-            )
+        with self.use_package_warehouse():
+            try:
+                for i, queries in enumerate(queued_queries):
+                    cc.step(f"Applying package script: {self.package_scripts[i]}")
+                    self._execute_queries(queries)
+            except ProgrammingError as err:
+                generic_sql_error_handler(
+                    err, role=self.package_role, warehouse=self.package_warehouse
+                )
 
     def deploy(
         self,
@@ -642,7 +699,7 @@ class NativeAppManager(SqlExecutionMixin):
                 f"call system$validate_native_app_setup('{prefixed_stage_fqn}')"
             )
         except ProgrammingError as err:
-            if err.errno == 2003 and ERROR_MESSAGE_2003 in err.msg:
+            if err.errno == DOES_NOT_EXIST_OR_NOT_AUTHORIZED:
                 raise ApplicationPackageDoesNotExistError(self.package_name)
             generic_sql_error_handler(err)
         else:
@@ -657,6 +714,24 @@ class NativeAppManager(SqlExecutionMixin):
                         f"drop stage if exists {self.scratch_stage_fqn}"
                     )
 
+    def get_events(self) -> list[dict]:
+        if not self.account_event_table:
+            raise NoEventTableForAccount()
+
+        # resource_attributes:"snow.database.name" uses the unquoted/uppercase app name
+        app_name = unquote_identifier(self.app_name)
+        query = dedent(
+            f"""\
+            select timestamp, value::varchar value
+            from {self.account_event_table}
+            where resource_attributes:"snow.database.name" = '{app_name}'
+            order by timestamp asc;"""
+        )
+        try:
+            return self._execute_query(query, cursor_class=DictCursor).fetchall()
+        except ProgrammingError as err:
+            generic_sql_error_handler(err)
+
 
 def _validation_item_to_str(item: dict[str, str | int]):
     s = item["message"]

snowflake/cli/plugins/nativeapp/project_model.py

@@ -105,16 +105,20 @@ class NativeAppProjectModel:
     @cached_property
     def package_warehouse(self) -> Optional[str]:
         if self.definition.package and self.definition.package.warehouse:
-            return self.definition.package.warehouse
+            return to_identifier(self.definition.package.warehouse)
         else:
-            return cli_context.connection.warehouse
+            if cli_context.connection.warehouse:
+                return to_identifier(cli_context.connection.warehouse)
+            return None
 
     @cached_property
     def application_warehouse(self) -> Optional[str]:
         if self.definition.application and self.definition.application.warehouse:
-            return self.definition.application.warehouse
+            return to_identifier(self.definition.application.warehouse)
         else:
-            return cli_context.connection.warehouse
+            if cli_context.connection.warehouse:
+                return to_identifier(cli_context.connection.warehouse)
+            return None
 
     @cached_property
     def project_identifier(self) -> str: