snowflake-cli 3.0.2__py3-none-any.whl → 3.2.0__py3-none-any.whl

snowflake/cli/_plugins/nativeapp/entities/application.py

@@ -1,16 +1,24 @@
 from __future__ import annotations
 
+import logging
 import time
 from contextlib import contextmanager
 from datetime import datetime
 from pathlib import Path
 from textwrap import dedent
-from typing import Callable, Generator, List, Literal, Optional, TypedDict
+from typing import Dict, Generator, List, Literal, Optional, TypedDict
 
 import typer
 from click import ClickException, UsageError
 from pydantic import Field, field_validator
-from snowflake.cli._plugins.connection.util import make_snowsight_url
+from snowflake.cli._plugins.connection.util import (
+    UIParameter,
+    get_ui_parameter,
+    make_snowsight_url,
+)
+from snowflake.cli._plugins.nativeapp.artifacts import (
+    find_events_definitions_in_manifest_file,
+)
 from snowflake.cli._plugins.nativeapp.common_flags import (
     ForceOption,
     InteractiveOption,
@@ -18,6 +26,7 @@ from snowflake.cli._plugins.nativeapp.common_flags import (
 )
 from snowflake.cli._plugins.nativeapp.constants import (
     ALLOWED_SPECIAL_COMMENTS,
+    AUTHORIZE_TELEMETRY_COL,
     COMMENT_COL,
     NAME_COL,
     OWNER_COL,
@@ -27,6 +36,9 @@ from snowflake.cli._plugins.nativeapp.entities.application_package import (
     ApplicationPackageEntity,
     ApplicationPackageEntityModel,
 )
+from snowflake.cli._plugins.nativeapp.entities.models.event_sharing_telemetry import (
+    EventSharingTelemetry,
+)
 from snowflake.cli._plugins.nativeapp.exceptions import (
     ApplicationPackageDoesNotExistError,
     NoEventTableForAccount,
@@ -40,8 +52,9 @@ from snowflake.cli._plugins.nativeapp.policy import (
 from snowflake.cli._plugins.nativeapp.same_account_install_method import (
     SameAccountInstallMethod,
 )
+from snowflake.cli._plugins.nativeapp.sf_facade import get_snowflake_facade
 from snowflake.cli._plugins.nativeapp.utils import needs_confirmation
-from snowflake.cli._plugins.workspace.action_context import ActionContext
+from snowflake.cli._plugins.workspace.context import ActionContext
 from snowflake.cli.api.cli_global_context import get_cli_context
 from snowflake.cli.api.console.abc import AbstractConsole
 from snowflake.cli.api.entities.common import EntityBase, get_sql_executor
@@ -53,8 +66,12 @@ from snowflake.cli.api.entities.utils import (
 )
 from snowflake.cli.api.errno import (
     APPLICATION_NO_LONGER_AVAILABLE,
+    APPLICATION_OWNS_EXTERNAL_OBJECTS,
+    APPLICATION_REQUIRES_TELEMETRY_SHARING,
+    CANNOT_DISABLE_MANDATORY_TELEMETRY,
     CANNOT_UPGRADE_FROM_LOOSE_FILES_TO_VERSION,
     CANNOT_UPGRADE_FROM_VERSION_TO_LOOSE_FILES,
+    DOES_NOT_EXIST_OR_NOT_AUTHORIZED,
     NOT_SUPPORTED_ON_DEV_MODE_APPLICATIONS,
     ONLY_SUPPORTED_ON_DEV_MODE_APPLICATIONS,
 )
@@ -70,10 +87,13 @@ from snowflake.cli.api.project.util import (
     append_test_resource_suffix,
     extract_schema,
     identifier_for_url,
+    to_identifier,
     unquote_identifier,
 )
 from snowflake.connector import DictCursor, ProgrammingError
 
+log = logging.getLogger(__name__)
+
 # Reasons why an `alter application ... upgrade` might fail
 UPGRADE_RESTRICTION_CODES = {
     CANNOT_UPGRADE_FROM_LOOSE_FILES_TO_VERSION,
@@ -86,6 +106,192 @@ UPGRADE_RESTRICTION_CODES = {
 ApplicationOwnedObject = TypedDict("ApplicationOwnedObject", {"name": str, "type": str})
 
 
+class EventSharingHandler:
+    """
+    Handles the logic around event sharing for applications.
+    This class is used to determine whether event sharing should be authorized or not, and which events should be shared.
+    """
+
+    def __init__(
+        self,
+        *,
+        telemetry_definition: Optional[EventSharingTelemetry],
+        deploy_root: Path,
+        install_method: SameAccountInstallMethod,
+        console: AbstractConsole,
+    ):
+        """
+        Initializes the event sharing handler.
+        If telemetry_definition is not present or share_mandatory_events is not set,
+        we will default to sharing events if mandatory events are present in the manifest file and we are in dev mode.
+
+        :param telemetry_definition: The telemetry configuration for this application from the PDF if present.
+        :param deploy_root: The root directory of the application package.
+        :param install_method: The install method of the application.
+        :param console: The console to use for logging.
+        """
+
+        self._is_dev_mode = install_method.is_dev_mode
+        self._metrics = get_cli_context().metrics
+        self._console = console
+        connection = get_sql_executor()._conn  # noqa: SLF001
+        self._event_sharing_enabled = (
+            get_ui_parameter(
+                connection, UIParameter.NA_EVENT_SHARING_V2, "true"
+            ).lower()
+            == "true"
+        )
+        self._event_sharing_enforced = (
+            get_ui_parameter(
+                connection, UIParameter.NA_ENFORCE_MANDATORY_FILTERS, "true"
+            ).lower()
+            == "true"
+        )
+
+        self._share_mandatory_events = (
+            telemetry_definition and telemetry_definition.share_mandatory_events
+        )
+        self._optional_shared_events = (
+            telemetry_definition and telemetry_definition.optional_shared_events
+        ) or []
+
+        self._metrics.set_counter(
+            CLICounterField.EVENT_SHARING, int(self._share_mandatory_events or False)
+        )
+        self._metrics.set_counter(CLICounterField.EVENT_SHARING_WARNING, 0)
+        self._metrics.set_counter(CLICounterField.EVENT_SHARING_ERROR, 0)
+
+        if not self._event_sharing_enabled:
+            # We cannot set AUTHORIZE_TELEMETRY_EVENT_SHARING to True or False if event sharing is not enabled,
+            # so we will ignore the field in both cases, but warn only if it is set to True
+            if self._share_mandatory_events or self._optional_shared_events:
+                self.event_sharing_warning(
+                    "Same-account event sharing is not enabled in your account, therefore, application telemetry section will be ignored."
+                )
+            self._share_mandatory_events = None
+            self._optional_shared_events = []
+            return
+
+        if install_method.is_dev_mode:
+            mandatory_events_in_manifest = self._contains_mandatory_events(
+                find_events_definitions_in_manifest_file(deploy_root)
+            )
+
+            if mandatory_events_in_manifest and self._event_sharing_enforced:
+                if self._share_mandatory_events is None:
+                    self.event_sharing_warning(
+                        "Mandatory events are present in the manifest file. Automatically authorizing event sharing in dev mode. To suppress this warning, please add 'share_mandatory_events: true' in the application telemetry section."
+                    )
+                    self._share_mandatory_events = True
+
+    def _contains_mandatory_events(self, events_definitions: List[Dict[str, str]]):
+        return any(event["sharing"] == "MANDATORY" for event in events_definitions)
+
+    def should_authorize_event_sharing_during_create(
+        self,
+    ) -> Optional[bool]:
+        """
+        Determines whether event sharing should be authorized during the creation of the application object.
+
+        Outputs:
+        - None: Event sharing should not be updated or explicitly set.
+        - True: Event sharing should be authorized.
+        - False: Event sharing should be disabled.
+        """
+
+        if not self._event_sharing_enabled:
+            return None
+
+        return self._share_mandatory_events
+
+    def should_authorize_event_sharing_after_upgrade(
+        self,
+        upgraded_app_properties: Dict[str, str],
+    ) -> Optional[bool]:
+        """
+        Determines whether event sharing should be authorized after upgrading the application object.
+
+        :param upgraded_app_properties: The properties of the application after upgrading.
+
+        Outputs:
+        - None: Event sharing should not be updated or explicitly set.
+        - True: Event sharing should be authorized.
+        - False: Event sharing should be disabled.
+        """
+
+        if not self._event_sharing_enabled:
+            return None
+
+        current_app_authorization = (
+            upgraded_app_properties.get(AUTHORIZE_TELEMETRY_COL, "false").lower()
+            == "true"
+        )
+
+        # Skip the update if the current value is the same as the one we want to set
+        if current_app_authorization == self._share_mandatory_events:
+            return None
+
+        return self._share_mandatory_events
+
+    def event_sharing_warning(self, message: str):
+        """
+        Logs a warning message about event sharing, and emits an event sharing warning metric.
+        """
+
+        self._metrics.set_counter(CLICounterField.EVENT_SHARING_WARNING, 1)
+        self._console.warning(f"WARNING: {message}")
+
+    def event_sharing_error(self, message: str, err: Exception):
+        """
+        Raises an error about event sharing, and emits an event sharing error metric.
+        """
+
+        self._metrics.set_counter(CLICounterField.EVENT_SHARING_ERROR, 1)
+        raise ClickException(message) from err
+
+    def events_to_share(
+        self, events_definitions: List[Dict[str, str]]
+    ) -> Optional[List[str]]:
+        """
+        Determines which events should be shared based on the application events definitions.
+        It also combines the mandatory events with the optional shared events.
+
+        :param events_definitions: The events definitions of the application.
+
+        Outputs:
+        - None: No events should be updated.
+        - List[str]: The names of the events that should be shared.
+        """
+
+        # events definition has this format: [{'name': 'SNOWFLAKE$ERRORS_AND_WARNINGS', 'type': 'ERRORS_AND_WARNINGS', 'sharing': 'MANDATORY'...}]
+        events_map = {event["type"]: event for event in events_definitions}
+        events_names = []
+        for event_type in self._optional_shared_events:
+            if event_type not in events_map:
+                raise ClickException(
+                    f"Event '{event_type}' from application 'telemetry' section in the project definition file could not be found in the application."
+                )
+            else:
+                events_names.append(events_map[event_type]["name"])
+
+        # add mandatory events to event_names list:
+        for event in events_definitions:
+            if event["sharing"] == "MANDATORY":
+                events_names.append(event["name"])
+
+        if not self._share_mandatory_events:
+            if (
+                self._contains_mandatory_events(events_definitions)
+                and not self._event_sharing_enforced
+            ):
+                self.event_sharing_warning(
+                    "Mandatory events are present in the application, but event sharing is not authorized in the application telemetry field. This will soon be required to set in order to deploy this application."
+                )
+            return None
+
+        return sorted(list(set(events_names)))
+
+
 class ApplicationEntityModel(EntityModelBase):
     type: Literal["application"] = DiscriminatorField()  # noqa A003
     from_: TargetField[ApplicationPackageEntityModel] = Field(
@@ -96,6 +302,10 @@ class ApplicationEntityModel(EntityModelBase):
         title="Whether to enable debug mode when using a named stage to create an application object",
         default=None,
     )
+    telemetry: Optional[EventSharingTelemetry] = Field(
+        title="Telemetry configuration for the application",
+        default=None,
+    )
 
     @field_validator("identifier")
     @classmethod
@@ -116,9 +326,38 @@ class ApplicationEntity(EntityBase[ApplicationEntityModel]):
     A Native App application object, created from an application package.
     """
 
+    @property
+    def project_root(self) -> Path:
+        return self._workspace_ctx.project_root
+
+    @property
+    def package_entity_id(self) -> str:
+        return self._entity_model.from_.target
+
+    @property
+    def name(self) -> str:
+        return to_identifier(self._entity_model.fqn.name)
+
+    @property
+    def role(self) -> str:
+        model = self._entity_model
+        return (model.meta and model.meta.role) or self._workspace_ctx.default_role
+
+    @property
+    def warehouse(self) -> str:
+        model = self._entity_model
+        return (
+            model.meta and model.meta.warehouse and to_identifier(model.meta.warehouse)
+        ) or to_identifier(self._workspace_ctx.default_warehouse)
+
+    @property
+    def post_deploy_hooks(self) -> list[PostDeployHook] | None:
+        model = self._entity_model
+        return model.meta and model.meta.post_deploy
+
     def action_deploy(
         self,
-        ctx: ActionContext,
+        action_ctx: ActionContext,
         from_release_directive: bool,
         prune: bool,
         recursive: bool,
@@ -132,136 +371,109 @@ class ApplicationEntity(EntityBase[ApplicationEntityModel]):
         *args,
         **kwargs,
     ):
-        model = self._entity_model
-        app_name = model.fqn.identifier
-        debug_mode = model.debug
-        if model.meta:
-            app_role = model.meta.role or ctx.default_role
-            app_warehouse = model.meta.warehouse or ctx.default_warehouse
-            post_deploy_hooks = model.meta.post_deploy
-        else:
-            app_role = ctx.default_role
-            app_warehouse = ctx.default_warehouse
-            post_deploy_hooks = None
-
-        package_entity: ApplicationPackageEntity = ctx.get_entity(model.from_.target)
-        package_model: ApplicationPackageEntityModel = (
-            package_entity._entity_model  # noqa: SLF001
+        """
+        Create or upgrade the application object using the given strategy
+        (unversioned dev, versioned dev, or same-account release directive).
+        """
+        package_entity: ApplicationPackageEntity = action_ctx.get_entity(
+            self.package_entity_id
         )
-        package_name = package_model.fqn.identifier
-        if package_model.meta and package_model.meta.role:
-            package_role = package_model.meta.role
-        else:
-            package_role = ctx.default_role
+        stage_fqn = stage_fqn or package_entity.stage_fqn
 
-        if not stage_fqn:
-            stage_fqn = f"{package_name}.{package_model.stage}"
-        stage_schema = extract_schema(stage_fqn)
-
-        is_interactive = False
         if force:
             policy = AllowAlwaysPolicy()
         elif interactive:
-            is_interactive = True
             policy = AskAlwaysPolicy()
         else:
             policy = DenyAlwaysPolicy()
 
-        def deploy_package():
-            package_entity.action_deploy(
-                ctx=ctx,
-                prune=True,
-                recursive=True,
-                paths=[],
-                validate=validate,
+        # same-account release directive
+        if from_release_directive:
+            self.create_or_upgrade_app(
+                package=package_entity,
                 stage_fqn=stage_fqn,
+                install_method=SameAccountInstallMethod.release_directive(),
+                policy=policy,
                 interactive=interactive,
-                force=force,
             )
+            return
 
-        self.deploy(
-            console=ctx.console,
-            project_root=ctx.project_root,
-            app_name=app_name,
-            app_role=app_role,
-            app_warehouse=app_warehouse,
-            package_name=package_name,
-            package_role=package_role,
-            stage_schema=stage_schema,
-            stage_fqn=stage_fqn,
-            debug_mode=debug_mode,
+        # versioned dev
+        if version:
+            try:
+                version_exists = package_entity.get_existing_version_info(version)
+                if not version_exists:
+                    raise UsageError(
+                        f"Application package {package_entity.name} does not have any version {version} defined. Use 'snow app version create' to define a version in the application package first."
+                    )
+            except ApplicationPackageDoesNotExistError as app_err:
+                raise UsageError(
+                    f"Application package {package_entity.name} does not exist. Use 'snow app version create' to first create an application package and then define a version in it."
+                )
+
+            self.create_or_upgrade_app(
+                package=package_entity,
+                stage_fqn=stage_fqn,
+                install_method=SameAccountInstallMethod.versioned_dev(version, patch),
+                policy=policy,
+                interactive=interactive,
+            )
+            return
+
+        # unversioned dev
+        package_entity.action_deploy(
+            action_ctx=action_ctx,
+            prune=True,
+            recursive=True,
+            paths=[],
             validate=validate,
-            from_release_directive=from_release_directive,
-            is_interactive=is_interactive,
+            stage_fqn=stage_fqn,
+            interactive=interactive,
+            force=force,
+        )
+        self.create_or_upgrade_app(
+            package=package_entity,
+            stage_fqn=stage_fqn,
+            install_method=SameAccountInstallMethod.unversioned_dev(),
             policy=policy,
-            version=version,
-            patch=patch,
-            post_deploy_hooks=post_deploy_hooks,
-            deploy_package=deploy_package,
+            interactive=interactive,
         )
 
     def action_drop(
         self,
-        ctx: ActionContext,
+        action_ctx: ActionContext,
         interactive: bool,
         force_drop: bool = False,
         cascade: Optional[bool] = None,
         *args,
         **kwargs,
-    ):
-        model = self._entity_model
-        app_name = model.fqn.identifier
-        if model.meta and model.meta.role:
-            app_role = model.meta.role
-        else:
-            app_role = ctx.default_role
-        self.drop(
-            console=ctx.console,
-            app_name=app_name,
-            app_role=app_role,
-            auto_yes=force_drop,
-            interactive=interactive,
-            cascade=cascade,
-        )
-
-    @classmethod
-    def drop(
-        cls,
-        console: AbstractConsole,
-        app_name: str,
-        app_role: str,
-        auto_yes: bool,
-        interactive: bool = False,
-        cascade: Optional[bool] = None,
     ):
         """
         Attempts to drop the application object if all validations and user prompts allow so.
         """
+        console = self._workspace_ctx.console
 
         needs_confirm = True
 
         # 1. If existing application is not found, exit gracefully
-        show_obj_row = cls.get_existing_app_info(
-            app_name=app_name,
-            app_role=app_role,
-        )
+        show_obj_row = self.get_existing_app_info()
         if show_obj_row is None:
             console.warning(
-                f"Role {app_role} does not own any application object with the name {app_name}, or the application object does not exist."
+                f"Role {self.role} does not own any application object with the name {self.name}, or the application object does not exist."
             )
             return
 
         # 2. Check if created by the Snowflake CLI
         row_comment = show_obj_row[COMMENT_COL]
         if row_comment not in ALLOWED_SPECIAL_COMMENTS and needs_confirmation(
-            needs_confirm, auto_yes
+            needs_confirm, force_drop
         ):
             should_drop_object = typer.confirm(
                 dedent(
                     f"""\
-                        Application object {app_name} was not created by Snowflake CLI.
+                        Application object {self.name} was not created by Snowflake CLI.
                         Application object details:
-                        Name: {app_name}
+                        Name: {self.name}
                         Created on: {show_obj_row["created_on"]}
                         Source: {show_obj_row["source"]}
                         Owner: {show_obj_row[OWNER_COL]}
@@ -273,7 +485,7 @@ class ApplicationEntity(EntityBase[ApplicationEntityModel]):
                 )
             )
             if not should_drop_object:
-                console.message(f"Did not drop application object {app_name}.")
+                console.message(f"Did not drop application object {self.name}.")
                 # The user desires to keep the app, therefore we can't proceed since it would
                 # leave behind an orphan app when we get to dropping the package
                 raise typer.Abort()
@@ -287,13 +499,10 @@ class ApplicationEntity(EntityBase[ApplicationEntityModel]):
         interactive_prompt = ""
         non_interactive_abort = ""
         try:
-            if application_objects := cls.get_objects_owned_by_application(
-                app_name=app_name,
-                app_role=app_role,
-            ):
+            if application_objects := self.get_objects_owned_by_application():
                 has_objects_to_drop = True
                 message_prefix = (
-                    f"The following objects are owned by application {app_name}"
+                    f"The following objects are owned by application {self.name}"
                 )
                 cascade_true_message = f"{message_prefix} and will be dropped:"
                 cascade_false_message = f"{message_prefix} and will NOT be dropped:"
@@ -303,9 +512,7 @@ class ApplicationEntity(EntityBase[ApplicationEntityModel]):
             if e.errno != APPLICATION_NO_LONGER_AVAILABLE:
                 raise
             application_objects = []
-            message_prefix = (
-                f"Could not determine which objects are owned by application {app_name}"
-            )
+            message_prefix = f"Could not determine which objects are owned by application {self.name}"
             has_objects_to_drop = True  # potentially, but we don't know what they are
             cascade_true_message = (
                 f"{message_prefix}, an unknown number of objects will be dropped."
@@ -320,19 +527,19 @@ class ApplicationEntity(EntityBase[ApplicationEntityModel]):
                 console.message(cascade_true_message)
                 with console.indented():
                     for obj in application_objects:
-                        console.message(cls.application_object_to_str(obj))
+                        console.message(_application_object_to_str(obj))
             elif cascade is False:
                 # If the user explicitly passed the --no-cascade flag
                 console.message(cascade_false_message)
                 with console.indented():
                     for obj in application_objects:
-                        console.message(cls.application_object_to_str(obj))
+                        console.message(_application_object_to_str(obj))
             elif interactive:
                 # If the user didn't pass any cascade flag and the session is interactive
                 console.message(message_prefix)
                 with console.indented():
                     for obj in application_objects:
-                        console.message(cls.application_object_to_str(obj))
+                        console.message(_application_object_to_str(obj))
                 user_response = typer.prompt(
                     interactive_prompt,
                     show_default=False,
@@ -349,7 +556,7 @@ class ApplicationEntity(EntityBase[ApplicationEntityModel]):
                 console.message(message_prefix)
                 with console.indented():
                     for obj in application_objects:
-                        console.message(cls.application_object_to_str(obj))
+                        console.message(_application_object_to_str(obj))
                 console.message(non_interactive_abort)
                 raise typer.Abort()
         elif cascade is None:
@@ -360,243 +567,185 @@ class ApplicationEntity(EntityBase[ApplicationEntityModel]):
         drop_generic_object(
             console=console,
             object_type="application",
-            object_name=app_name,
-            role=app_role,
+            object_name=self.name,
+            role=self.role,
             cascade=cascade,
         )
-        return  # The application object was successfully dropped, therefore exit gracefully
 
-    @staticmethod
-    def get_objects_owned_by_application(
-        app_name: str,
-        app_role: str,
-    ) -> List[ApplicationOwnedObject]:
+    def action_events(
+        self,
+        action_ctx: ActionContext,
+        since: str | datetime | None = None,
+        until: str | datetime | None = None,
+        record_types: list[str] | None = None,
+        scopes: list[str] | None = None,
+        consumer_org: str = "",
+        consumer_account: str = "",
+        consumer_app_hash: str = "",
+        first: int = -1,
+        last: int = -1,
+        follow: bool = False,
+        interval_seconds: int = 10,
+        *args,
+        **kwargs,
+    ):
+        package_entity: ApplicationPackageEntity = action_ctx.get_entity(
+            self.package_entity_id
+        )
+        if follow:
+            return self.stream_events(
+                package_name=package_entity.name,
+                interval_seconds=interval_seconds,
+                since=since,
+                record_types=record_types,
+                scopes=scopes,
+                consumer_org=consumer_org,
+                consumer_account=consumer_account,
+                consumer_app_hash=consumer_app_hash,
+                last=last,
+            )
+        else:
+            return self.get_events(
+                package_name=package_entity.name,
+                since=since,
+                until=until,
+                record_types=record_types,
+                scopes=scopes,
+                consumer_org=consumer_org,
+                consumer_account=consumer_account,
+                consumer_app_hash=consumer_app_hash,
+                first=first,
+                last=last,
+            )
+
+    def get_objects_owned_by_application(self) -> List[ApplicationOwnedObject]:
         """
         Returns all application objects owned by this application.
         """
         sql_executor = get_sql_executor()
-        with sql_executor.use_role(app_role):
+        with sql_executor.use_role(self.role):
             results = sql_executor.execute_query(
-                f"show objects owned by application {app_name}"
+                f"show objects owned by application {self.name}"
             ).fetchall()
             return [{"name": row[1], "type": row[2]} for row in results]
 
-    @classmethod
-    def application_objects_to_str(
-        cls, application_objects: list[ApplicationOwnedObject]
-    ) -> str:
-        """
-        Returns a list in an "(Object Type) Object Name" format. Database-level and schema-level object names are fully qualified:
-        (COMPUTE_POOL) POOL_NAME
-        (DATABASE) DB_NAME
-        (SCHEMA) DB_NAME.PUBLIC
-        ...
-        """
-        return "\n".join(
-            [cls.application_object_to_str(obj) for obj in application_objects]
-        )
-
-    @staticmethod
-    def application_object_to_str(obj: ApplicationOwnedObject) -> str:
-        return f"({obj['type']}) {obj['name']}"
-
-    @classmethod
-    def deploy(
-        cls,
-        console: AbstractConsole,
-        project_root: Path,
-        app_name: str,
-        app_role: str,
-        app_warehouse: str,
-        package_name: str,
-        package_role: str,
-        stage_schema: str,
+    def create_or_upgrade_app(
+        self,
+        package: ApplicationPackageEntity,
         stage_fqn: str,
-        debug_mode: bool,
-        validate: bool,
-        from_release_directive: bool,
-        is_interactive: bool,
+        install_method: SameAccountInstallMethod,
         policy: PolicyBase,
-        deploy_package: Callable,
-        version: Optional[str] = None,
-        patch: Optional[int] = None,
-        post_deploy_hooks: Optional[List[PostDeployHook]] = None,
-        drop_application_before_upgrade: Optional[Callable] = None,
+        interactive: bool,
     ):
-        """
-        Create or upgrade the application object using the given strategy
-        (unversioned dev, versioned dev, or same-account release directive).
-        """
-
-        # same-account release directive
-        if from_release_directive:
-            cls.create_or_upgrade_app(
-                console=console,
-                project_root=project_root,
-                package_name=package_name,
-                package_role=package_role,
-                app_name=app_name,
-                app_role=app_role,
-                app_warehouse=app_warehouse,
-                stage_schema=stage_schema,
-                stage_fqn=stage_fqn,
-                debug_mode=debug_mode,
-                policy=policy,
-                install_method=SameAccountInstallMethod.release_directive(),
-                is_interactive=is_interactive,
-                post_deploy_hooks=post_deploy_hooks,
-                drop_application_before_upgrade=drop_application_before_upgrade,
-            )
-            return
+        model = self._entity_model
+        console = self._workspace_ctx.console
+        debug_mode = model.debug
 
-        # versioned dev
-        if version:
-            try:
-                version_exists = ApplicationPackageEntity.get_existing_version_info(
-                    version=version,
-                    package_name=package_name,
-                    package_role=package_role,
-                )
-                if not version_exists:
-                    raise UsageError(
-                        f"Application package {package_name} does not have any version {version} defined. Use 'snow app version create' to define a version in the application package first."
-                    )
-            except ApplicationPackageDoesNotExistError as app_err:
-                raise UsageError(
-                    f"Application package {package_name} does not exist. Use 'snow app version create' to first create an application package and then define a version in it."
-                )
+        stage_fqn = stage_fqn or package.stage_fqn
+        stage_schema = extract_schema(stage_fqn)
 
-            cls.create_or_upgrade_app(
+        sql_executor = get_sql_executor()
+        with sql_executor.use_role(self.role):
+            event_sharing = EventSharingHandler(
+                telemetry_definition=model.telemetry,
+                deploy_root=package.deploy_root,
+                install_method=install_method,
                 console=console,
-                project_root=project_root,
-                package_name=package_name,
-                package_role=package_role,
-                app_name=app_name,
-                app_role=app_role,
-                app_warehouse=app_warehouse,
-                stage_schema=stage_schema,
-                stage_fqn=stage_fqn,
-                debug_mode=debug_mode,
-                policy=policy,
-                install_method=SameAccountInstallMethod.versioned_dev(version, patch),
-                is_interactive=is_interactive,
-                post_deploy_hooks=post_deploy_hooks,
-                drop_application_before_upgrade=drop_application_before_upgrade,
             )
-            return
-
-        # unversioned dev
-        deploy_package()
-        cls.create_or_upgrade_app(
-            console=console,
-            project_root=project_root,
-            package_name=package_name,
-            package_role=package_role,
-            app_name=app_name,
-            app_role=app_role,
-            app_warehouse=app_warehouse,
-            stage_schema=stage_schema,
-            stage_fqn=stage_fqn,
-            debug_mode=debug_mode,
-            policy=policy,
-            install_method=SameAccountInstallMethod.unversioned_dev(),
-            is_interactive=is_interactive,
-            post_deploy_hooks=post_deploy_hooks,
-            drop_application_before_upgrade=drop_application_before_upgrade,
-        )
-
-    @classmethod
-    def create_or_upgrade_app(
-        cls,
-        console: AbstractConsole,
-        project_root: Path,
-        package_name: str,
-        package_role: str,
-        app_name: str,
-        app_role: str,
-        app_warehouse: Optional[str],
-        stage_schema: Optional[str],
-        stage_fqn: str,
-        debug_mode: bool,
-        policy: PolicyBase,
-        install_method: SameAccountInstallMethod,
-        is_interactive: bool = False,
-        post_deploy_hooks: Optional[List[PostDeployHook]] = None,
-        drop_application_before_upgrade: Optional[Callable] = None,
-    ):
-        sql_executor = get_sql_executor()
-        with sql_executor.use_role(app_role):
 
             # 1. Need to use a warehouse to create an application object
-            with sql_executor.use_warehouse(app_warehouse):
+            with sql_executor.use_warehouse(self.warehouse):
 
                 # 2. Check for an existing application by the same name
-                show_app_row = cls.get_existing_app_info(
-                    app_name=app_name,
-                    app_role=app_role,
-                )
+                show_app_row = self.get_existing_app_info()
 
                 # 3. If existing application is found, perform a few validations and upgrade the application object.
                 if show_app_row:
-
                     install_method.ensure_app_usable(
-                        app_name=app_name,
-                        app_role=app_role,
+                        app_name=self.name,
+                        app_role=self.role,
                         show_app_row=show_app_row,
                     )
 
                     # If all the above checks are in order, proceed to upgrade
                     try:
                         console.step(
-                            f"Upgrading existing application object {app_name}."
+                            f"Upgrading existing application object {self.name}."
                         )
                         using_clause = install_method.using_clause(stage_fqn)
                         upgrade_cursor = sql_executor.execute_query(
-                            f"alter application {app_name} upgrade {using_clause}",
+                            f"alter application {self.name} upgrade {using_clause}",
                         )
                         print_messages(console, upgrade_cursor)
 
+                        events_definitions = (
+                            get_snowflake_facade().get_event_definitions(
+                                self.name, self.role
+                            )
+                        )
+
+                        app_properties = get_snowflake_facade().get_app_properties(
+                            self.name, self.role
+                        )
+                        new_authorize_event_sharing_value = (
+                            event_sharing.should_authorize_event_sharing_after_upgrade(
+                                app_properties,
+                            )
+                        )
+                        if new_authorize_event_sharing_value is not None:
+                            log.info(
+                                "Setting telemetry sharing authorization to %s",
+                                new_authorize_event_sharing_value,
+                            )
+                            sql_executor.execute_query(
+                                f"alter application {self.name} set AUTHORIZE_TELEMETRY_EVENT_SHARING = {str(new_authorize_event_sharing_value).upper()}"
+                            )
+                        events_to_share = event_sharing.events_to_share(
+                            events_definitions
+                        )
+                        if events_to_share is not None:
+                            get_snowflake_facade().share_telemetry_events(
+                                self.name, events_to_share
+                            )
+
                         if install_method.is_dev_mode:
                             # if debug_mode is present (controlled), ensure it is up-to-date
                             if debug_mode is not None:
                                 sql_executor.execute_query(
-                                    f"alter application {app_name} set debug_mode = {debug_mode}"
+                                    f"alter application {self.name} set debug_mode = {debug_mode}"
                                 )
 
                         # hooks always executed after a create or upgrade
-                        cls.execute_post_deploy_hooks(
-                            console=console,
-                            project_root=project_root,
-                            post_deploy_hooks=post_deploy_hooks,
-                            app_name=app_name,
-                            app_warehouse=app_warehouse,
-                        )
+                        self.execute_post_deploy_hooks()
                         return
 
                     except ProgrammingError as err:
-                        if err.errno not in UPGRADE_RESTRICTION_CODES:
-                            generic_sql_error_handler(err=err)
-                        else:  # The existing application object was created from a different process.
+                        if err.errno == CANNOT_DISABLE_MANDATORY_TELEMETRY:
+                            event_sharing.event_sharing_error(
+                                "Could not disable telemetry event sharing for the application because it contains mandatory events. Please set 'share_mandatory_events' to true in the application telemetry section of the project definition file.",
+                                err,
+                            )
+                        elif err.errno in UPGRADE_RESTRICTION_CODES:
                             console.warning(err.msg)
-                            # TODO Drop the entity here instead of taking a callback once action_drop() is implemented
-                            if drop_application_before_upgrade:
-                                drop_application_before_upgrade()
-                            else:
-                                raise NotImplementedError
+                            self.drop_application_before_upgrade(
+                                policy=policy, interactive=interactive
+                            )
+                        else:
+                            generic_sql_error_handler(err=err)
 
                 # 4. With no (more) existing application objects, create an application object using the release directives
-                console.step(f"Creating new application object {app_name} in account.")
+                console.step(f"Creating new application object {self.name} in account.")
 
-                if app_role != package_role:
-                    with sql_executor.use_role(package_role):
+                if self.role != package.role:
+                    with sql_executor.use_role(package.role):
                         sql_executor.execute_query(
-                            f"grant install, develop on application package {package_name} to role {app_role}"
+                            f"grant install, develop on application package {package.name} to role {self.role}"
                         )
                         sql_executor.execute_query(
-                            f"grant usage on schema {package_name}.{stage_schema} to role {app_role}"
+                            f"grant usage on schema {package.name}.{stage_schema} to role {self.role}"
                         )
                         sql_executor.execute_query(
-                            f"grant read on stage {stage_fqn} to role {app_role}"
+                            f"grant read on stage {stage_fqn} to role {self.role}"
                         )
 
                 try:
@@ -609,60 +758,64 @@ class ApplicationEntity(EntityBase[ApplicationEntityModel]):
                         )
                         debug_mode_clause = f"debug_mode = {initial_debug_mode}"
 
+                    authorize_telemetry_clause = ""
+                    new_authorize_event_sharing_value = (
+                        event_sharing.should_authorize_event_sharing_during_create()
+                    )
+                    if new_authorize_event_sharing_value is not None:
+                        log.info(
+                            "Setting AUTHORIZE_TELEMETRY_EVENT_SHARING to %s",
+                            new_authorize_event_sharing_value,
+                        )
+                        authorize_telemetry_clause = f" AUTHORIZE_TELEMETRY_EVENT_SHARING = {str(new_authorize_event_sharing_value).upper()}"
+
                     using_clause = install_method.using_clause(stage_fqn)
                     create_cursor = sql_executor.execute_query(
                         dedent(
                             f"""\
-                        create application {app_name}
-                            from application package {package_name} {using_clause} {debug_mode_clause}
+                        create application {self.name}
+                            from application package {package.name} {using_clause} {debug_mode_clause}{authorize_telemetry_clause}
                             comment = {SPECIAL_COMMENT}
                         """
                         ),
                     )
                     print_messages(console, create_cursor)
+                    events_definitions = get_snowflake_facade().get_event_definitions(
+                        self.name, self.role
+                    )
+
+                    events_to_share = event_sharing.events_to_share(events_definitions)
+                    if events_to_share is not None:
+                        get_snowflake_facade().share_telemetry_events(
+                            self.name, events_to_share
+                        )
 
                     # hooks always executed after a create or upgrade
-                    cls.execute_post_deploy_hooks(
-                        console=console,
-                        project_root=project_root,
-                        post_deploy_hooks=post_deploy_hooks,
-                        app_name=app_name,
-                        app_warehouse=app_warehouse,
-                    )
+                    self.execute_post_deploy_hooks()
 
                 except ProgrammingError as err:
+                    if err.errno == APPLICATION_REQUIRES_TELEMETRY_SHARING:
+                        event_sharing.event_sharing_error(
+                            "The application package requires event sharing to be authorized. Please set 'share_mandatory_events' to true in the application telemetry section of the project definition file.",
+                            err,
+                        )
                     generic_sql_error_handler(err)
 
-    @classmethod
-    def execute_post_deploy_hooks(
-        cls,
-        console: AbstractConsole,
-        project_root: Path,
-        post_deploy_hooks: Optional[List[PostDeployHook]],
-        app_name: str,
-        app_warehouse: Optional[str],
-    ):
-        get_cli_context().metrics.set_counter_default(
-            CLICounterField.POST_DEPLOY_SCRIPTS, 0
+    def execute_post_deploy_hooks(self):
+        execute_post_deploy_hooks(
+            console=self._workspace_ctx.console,
+            project_root=self.project_root,
+            post_deploy_hooks=self.post_deploy_hooks,
+            deployed_object_type="application",
+            role_name=self.role,
+            warehouse_name=self.warehouse,
+            database_name=self.name,
         )
 
-        if post_deploy_hooks:
-            with cls.use_application_warehouse(app_warehouse):
-                execute_post_deploy_hooks(
-                    console=console,
-                    project_root=project_root,
-                    post_deploy_hooks=post_deploy_hooks,
-                    deployed_object_type="application",
-                    database_name=app_name,
-                )
-
-    @staticmethod
     @contextmanager
-    def use_application_warehouse(
-        app_warehouse: Optional[str],
-    ):
-        if app_warehouse:
-            with get_sql_executor().use_warehouse(app_warehouse):
+    def use_application_warehouse(self):
+        if self.warehouse:
+            with get_sql_executor().use_warehouse(self.warehouse):
                 yield
         else:
             raise ClickException(
@@ -674,25 +827,72 @@ class ApplicationEntity(EntityBase[ApplicationEntityModel]):
                 )
             )
 
-    @staticmethod
-    def get_existing_app_info(
-        app_name: str,
-        app_role: str,
-    ) -> Optional[dict]:
+    def get_existing_app_info(self) -> Optional[dict]:
         """
         Check for an existing application object by the same name as in project definition, in account.
         It executes a 'show applications like' query and returns the result as single row, if one exists.
         """
         sql_executor = get_sql_executor()
-        with sql_executor.use_role(app_role):
+        with sql_executor.use_role(self.role):
             return sql_executor.show_specific_object(
-                "applications", app_name, name_col=NAME_COL
+                "applications", self.name, name_col=NAME_COL
             )
 
-    @classmethod
+    def drop_application_before_upgrade(
+        self,
+        policy: PolicyBase,
+        interactive: bool,
+        cascade: bool = False,
+    ):
+        console = self._workspace_ctx.console
+
+        if cascade:
+            try:
+                if application_objects := self.get_objects_owned_by_application():
+                    application_objects_str = _application_objects_to_str(
+                        application_objects
+                    )
+                    console.message(
+                        f"The following objects are owned by application {self.name} and need to be dropped:\n{application_objects_str}"
+                    )
+            except ProgrammingError as err:
+                if err.errno != APPLICATION_NO_LONGER_AVAILABLE:
+                    generic_sql_error_handler(err)
+                console.warning(
+                    "The application owns other objects but they could not be determined."
+                )
+            user_prompt = "Do you want the Snowflake CLI to drop these objects, then drop the existing application object and recreate it?"
+        else:
+            user_prompt = "Do you want the Snowflake CLI to drop the existing application object and recreate it?"
+
+        if not policy.should_proceed(user_prompt):
+            if interactive:
+                console.message("Not upgrading the application object.")
+                raise typer.Exit(0)
+            else:
+                console.message(
+                    "Cannot upgrade the application object non-interactively without --force."
+                )
+                raise typer.Exit(1)
+        try:
+            cascade_msg = " (cascade)" if cascade else ""
+            console.step(f"Dropping application object {self.name}{cascade_msg}.")
+            cascade_sql = " cascade" if cascade else ""
+            sql_executor = get_sql_executor()
+            sql_executor.execute_query(f"drop application {self.name}{cascade_sql}")
+        except ProgrammingError as err:
+            if err.errno == APPLICATION_OWNS_EXTERNAL_OBJECTS and not cascade:
+                # We need to cascade the deletion, let's try again (only if we didn't try with cascade already)
+                return self.drop_application_before_upgrade(
+                    policy=policy,
+                    interactive=interactive,
+                    cascade=True,
+                )
+            else:
+                generic_sql_error_handler(err)
+
     def get_events(
-        cls,
-        app_name: str,
+        self,
         package_name: str,
         since: str | datetime | None = None,
         until: str | datetime | None = None,
@@ -704,19 +904,18 @@ class ApplicationEntity(EntityBase[ApplicationEntityModel]):
         first: int = -1,
         last: int = -1,
     ):
-
         record_types = record_types or []
         scopes = scopes or []
 
         if first >= 0 and last >= 0:
             raise ValueError("first and last cannot be used together")
 
-        account_event_table = cls.get_account_event_table()
-        if not account_event_table:
+        account_event_table = get_snowflake_facade().get_account_event_table()
+        if account_event_table is None:
             raise NoEventTableForAccount()
 
         # resource_attributes uses the unquoted/uppercase app and package name
-        app_name = unquote_identifier(app_name)
+        app_name = unquote_identifier(self.name)
         package_name = unquote_identifier(package_name)
         org_name = unquote_identifier(consumer_org)
         account_name = unquote_identifier(consumer_account)
@@ -787,12 +986,19 @@ class ApplicationEntity(EntityBase[ApplicationEntityModel]):
         try:
             return sql_executor.execute_query(query, cursor_class=DictCursor).fetchall()
         except ProgrammingError as err:
-            generic_sql_error_handler(err)
+            if err.errno == DOES_NOT_EXIST_OR_NOT_AUTHORIZED:
+                raise ClickException(
+                    dedent(
+                        f"""\
+                    Event table '{account_event_table}' does not exist or you are not authorized to perform this operation.
+                    Please check your EVENT_TABLE parameter to ensure that it is set to a valid event table."""
+                    )
+                ) from err
+            else:
+                generic_sql_error_handler(err)
 
-    @classmethod
     def stream_events(
-        cls,
-        app_name: str,
+        self,
         package_name: str,
         interval_seconds: int,
         since: str | datetime | None = None,
@@ -804,8 +1010,7 @@ class ApplicationEntity(EntityBase[ApplicationEntityModel]):
         last: int = -1,
     ) -> Generator[dict, None, None]:
         try:
-            events = cls.get_events(
-                app_name=app_name,
+            events = self.get_events(
                 package_name=package_name,
                 since=since,
                 record_types=record_types,
@@ -821,8 +1026,7 @@ class ApplicationEntity(EntityBase[ApplicationEntityModel]):
             while True:  # Then infinite poll for new events
                 time.sleep(interval_seconds)
                 previous_events = events
-                events = cls.get_events(
-                    app_name=app_name,
+                events = self.get_events(
                     package_name=package_name,
                     since=last_event_time,
                     record_types=record_types,
@@ -839,18 +1043,10 @@ class ApplicationEntity(EntityBase[ApplicationEntityModel]):
         except KeyboardInterrupt:
             return
 
-    @staticmethod
-    def get_account_event_table():
-        query = "show parameters like 'event_table' in account"
-        sql_executor = get_sql_executor()
-        results = sql_executor.execute_query(query, cursor_class=DictCursor)
-        return next((r["value"] for r in results if r["key"] == "EVENT_TABLE"), "")
-
-    @classmethod
-    def get_snowsight_url(cls, app_name: str, app_warehouse: str | None) -> str:
+    def get_snowsight_url(self) -> str:
         """Returns the URL that can be used to visit this app via Snowsight."""
-        name = identifier_for_url(app_name)
-        with cls.use_application_warehouse(app_warehouse):
+        name = identifier_for_url(self.name)
+        with self.use_application_warehouse():
             sql_executor = get_sql_executor()
             return make_snowsight_url(
                 sql_executor._conn, f"/#/apps/application/{name}"  # noqa: SLF001
@@ -876,3 +1072,20 @@ def _new_events_only(previous_events: list[dict], new_events: list[dict]) -> lis
         # either be in both lists or in new_events only
         new_events.remove(event)
     return new_events
+
+
+def _application_objects_to_str(
+    application_objects: list[ApplicationOwnedObject],
+) -> str:
+    """
+    Returns a list in an "(Object Type) Object Name" format. Database-level and schema-level object names are fully qualified:
+    (COMPUTE_POOL) POOL_NAME
+    (DATABASE) DB_NAME
+    (SCHEMA) DB_NAME.PUBLIC
+    ...
+    """
+    return "\n".join([_application_object_to_str(obj) for obj in application_objects])
+
+
+def _application_object_to_str(obj: ApplicationOwnedObject) -> str:
+    return f"({obj['type']}) {obj['name']}"