added enriched failure prompt for az webapp up

Author: Shikha Jha

src/azure-cli/azure/cli/command_modules/appservice/_deployment_context_engine.py

@@ -79,36 +79,51 @@ def _get_app_plan_sku(cmd, resource_group_name, webapp_name):
         return "Unknown"
 
 
-def _determine_deployment_type(params):
-    """Infer the deployment mechanism from the params."""
-    if params.src_url:
+def _determine_deployment_type(params=None, *, src_url=None, artifact_type=None):
+    """Infer the deployment mechanism from params object or explicit kwargs.
+
+    When *params* is supplied the values are read from it; explicit kwargs
+    override the params-derived values when both are provided.
+    """
+    _src_url = src_url if src_url is not None else (getattr(params, 'src_url', None) if params else None)
+    _artifact = artifact_type if artifact_type is not None else (getattr(params, 'artifact_type', None) if params else None)
+
+    if _src_url:
         return "OneDeploy (URL-based)"
-    artifact = getattr(params, 'artifact_type', None)
-    if artifact == 'zip':
+    if _artifact == 'zip':
         return "ZipDeploy"
-    if artifact == 'war':
+    if _artifact == 'war':
         return "WarDeploy"
-    if artifact == 'jar':
+    if _artifact == 'jar':
         return "JarDeploy"
-    if artifact == 'ear':
+    if _artifact == 'ear':
         return "EarDeploy"
-    if artifact == 'startup':
+    if _artifact == 'startup':
         return "StartupFile"
-    if artifact == 'static':
+    if _artifact == 'static':
         return "StaticDeploy"
     return "OneDeploy"
 
 
-def build_enriched_error_context(params, status_code=None, error_message=None,
+def build_enriched_error_context(params=None, *, cmd=None, resource_group_name=None,
+                                 webapp_name=None, slot=None, src_url=None,
+                                 artifact_type=None, status_code=None, error_message=None,
                                  deployment_status=None, deployment_properties=None,
                                  last_known_step=None, kudu_status=None):
     """
     Build a structured context-enriched error dict for a deployment failure.
 
+    Accepts either a *params* object (``OneDeployParams``) **or** individual
+    keyword arguments — callers that already have a params object can keep
+    passing it; callers in code-paths that don't (e.g. zipdeploy) can pass
+    the relevant values directly.  Explicit kwargs override params values.
+
     Parameters
     ----------
-    params : OneDeployParams
+    params : OneDeployParams, optional
         The deployment parameters object.
+    cmd, resource_group_name, webapp_name, slot, src_url, artifact_type :
+        Individual app-context values; used when *params* is not supplied.
     status_code : int, optional
         HTTP status code of the failed response.
     error_message : str, optional
@@ -127,6 +142,14 @@ def build_enriched_error_context(params, status_code=None, error_message=None,
     dict
         Structured error context ready for display.
     """
+    # Normalise — extract from params when available, explicit kwargs win
+    _cmd = cmd or (params.cmd if params else None)
+    _rg = resource_group_name or (params.resource_group_name if params else None)
+    _name = webapp_name or (params.webapp_name if params else None)
+    _slot = slot if slot is not None else (getattr(params, 'slot', None) if params else None)
+    _src_url = src_url if src_url is not None else (getattr(params, 'src_url', None) if params else None)
+    _artifact = artifact_type if artifact_type is not None else (getattr(params, 'artifact_type', None) if params else None)
+
     pattern = match_failure_pattern(
         status_code=status_code,
         error_message=error_message,
@@ -144,11 +167,18 @@ def build_enriched_error_context(params, status_code=None, error_message=None,
         context["stage"] = deployment_status or "Unknown"
 
     # App metadata (best-effort)
-    context["runtime"] = _get_app_runtime(params.cmd, params.resource_group_name,
-                                          params.webapp_name, params.slot)
-    context["deploymentType"] = _determine_deployment_type(params)
-    context["region"] = _get_app_region(params.cmd, params.resource_group_name, params.webapp_name)
-    context["planSku"] = _get_app_plan_sku(params.cmd, params.resource_group_name, params.webapp_name)
+    if _cmd and _rg and _name:
+        context["runtime"] = _get_app_runtime(_cmd, _rg, _name, _slot)
+        context["region"] = _get_app_region(_cmd, _rg, _name)
+        context["planSku"] = _get_app_plan_sku(_cmd, _rg, _name)
+    else:
+        context["runtime"] = "Unknown"
+        context["region"] = "Unknown"
+        context["planSku"] = "Unknown"
+
+    context["deploymentType"] = _determine_deployment_type(
+        params, src_url=_src_url, artifact_type=_artifact
+    )
 
     # Causes and fixes
     if pattern:
@@ -158,9 +188,9 @@ def build_enriched_error_context(params, status_code=None, error_message=None,
         context["commonCauses"] = ["Unrecognised failure — see error details below"]
         context["suggestedFixes"] = [
             "Check deployment logs: 'az webapp log deployment show -n {} -g {}'".format(
-                params.webapp_name, params.resource_group_name),
+                _name or '<app>', _rg or '<rg>'),
             "Check runtime logs: 'az webapp log tail -n {} -g {}'".format(
-                params.webapp_name, params.resource_group_name)
+                _name or '<app>', _rg or '<rg>')
         ]
 
     # Extra diagnostics
@@ -251,16 +281,25 @@ def format_enriched_error_message(context):
     return "\n".join(lines)
 
 
-def raise_enriched_deployment_error(params, status_code=None, error_message=None,
+def raise_enriched_deployment_error(params=None, *, cmd=None, resource_group_name=None,
+                                    webapp_name=None, slot=None, src_url=None,
+                                    artifact_type=None, status_code=None, error_message=None,
                                     deployment_status=None, deployment_properties=None,
                                     last_known_step=None, kudu_status=None):
     """
     Build context-enriched diagnostics and raise a CLIError.
 
     This is the main entry-point called from the deployment code paths.
+    Accepts either a *params* object or individual keyword arguments.
     """
     context = build_enriched_error_context(
         params=params,
+        cmd=cmd,
+        resource_group_name=resource_group_name,
+        webapp_name=webapp_name,
+        slot=slot,
+        src_url=src_url,
+        artifact_type=artifact_type,
         status_code=status_code,
         error_message=error_message,
         deployment_status=deployment_status,

src/azure-cli/azure/cli/command_modules/appservice/custom.py

@@ -881,6 +881,9 @@ def enable_zip_deploy(cmd, resource_group_name, name, src, timeout=None, slot=No
     app_is_linux_webapp = is_linux_webapp(app)
     app_is_function_app = is_functionapp(app)
 
+    # Should we enrich deployment errors with context? (webapp only, not functionapp)
+    _should_enrich_errors = not app_is_function_app
+
     # Read file content
     with open(os.path.realpath(os.path.expanduser(src)), 'rb') as fs:
         zip_content = fs.read()
@@ -913,13 +916,26 @@ def enable_zip_deploy(cmd, resource_group_name, name, src, timeout=None, slot=No
     # check the status of async deployment
     if res.status_code == 202:
         response_body = None
-        if track_status:
-            response_body = _check_runtimestatus_with_deploymentstatusapi(cmd, resource_group_name, name, slot,
-                                                                          deployment_status_url, is_async=True,
-                                                                          timeout=timeout)
-        else:
-            response_body = _check_zip_deployment_status(cmd, resource_group_name, name, deployment_status_url,
-                                                         slot, timeout)
+        try:
+            if track_status:
+                response_body = _check_runtimestatus_with_deploymentstatusapi(cmd, resource_group_name, name, slot,
+                                                                              deployment_status_url, is_async=True,
+                                                                              timeout=timeout)
+            else:
+                response_body = _check_zip_deployment_status(cmd, resource_group_name, name, deployment_status_url,
+                                                             slot, timeout)
+        except CLIError as deploy_err:
+            if _should_enrich_errors:
+                raise_enriched_deployment_error(
+                    cmd=cmd,
+                    resource_group_name=resource_group_name,
+                    webapp_name=name,
+                    slot=slot,
+                    artifact_type="zip",
+                    error_message=str(deploy_err),
+                    last_known_step="Zip deployment accepted (HTTP 202), tracking status"
+                )
+            raise
         return response_body
 
     # check if there's an ongoing process
@@ -934,6 +950,18 @@ def enable_zip_deploy(cmd, resource_group_name, name, src, timeout=None, slot=No
 
     # check if an error occured during deployment
     if res.status_code:
+        if _should_enrich_errors:
+            raise_enriched_deployment_error(
+                cmd=cmd,
+                resource_group_name=resource_group_name,
+                webapp_name=name,
+                slot=slot,
+                artifact_type="zip",
+                status_code=res.status_code,
+                error_message=res.text if res.text else None,
+                last_known_step="Zip deployment HTTP request",
+                kudu_status=str(res.status_code)
+            )
         raise AzureInternalError("An error occured during deployment. Status Code: {}, Details: {}"
                                  .format(res.status_code, res.text))
 
@@ -9852,12 +9880,14 @@ def _make_onedeploy_request(params):
                                                                  params.webapp_name,
                                                                  deployment_status_url, params.slot, params.timeout)
             except CLIError as deploy_err:
-                # Enrich the downstream deployment-tracking error with context
-                raise_enriched_deployment_error(
-                    params=params,
-                    error_message=str(deploy_err),
-                    last_known_step="Deployment accepted (HTTP 200/202), tracking status"
-                )
+                if not params.is_functionapp:
+                    # Enrich the downstream deployment-tracking error with context
+                    raise_enriched_deployment_error(
+                        params=params,
+                        error_message=str(deploy_err),
+                        last_known_step="Deployment accepted (HTTP 200/202), tracking status"
+                    )
+                raise
             logger.info('Server response: %s', response_body)
         else:
             if 'application/json' in response.headers.get('content-type', ""):
@@ -9880,15 +9910,22 @@ def _make_onedeploy_request(params):
                               "starting a new deployment. You can track the ongoing deployment at {}"
                               .format(deployment_status_url))
 
-    # check if an error occurred during deployment — raise context-enriched error
+    # check if an error occurred during deployment
     if response.status_code:
-        raise_enriched_deployment_error(
-            params=params,
-            status_code=response.status_code,
-            error_message=response.text if response.text else None,
-            last_known_step="HTTP request sent to deployment API",
-            kudu_status=str(response.status_code)
-        )
+        if not params.is_functionapp:
+            raise_enriched_deployment_error(
+                params=params,
+                status_code=response.status_code,
+                error_message=response.text if response.text else None,
+                last_known_step="HTTP request sent to deployment API",
+                kudu_status=str(response.status_code)
+            )
+        scm_url = _get_scm_url(params.cmd, params.resource_group_name, params.webapp_name, params.slot)
+        latest_deploymentinfo_url = scm_url + "/api/deployments/latest"
+        raise CLIError("An error occurred during deployment. Status Code: {}, {} Please visit {}"
+                       " to get more information about your deployment"
+                       .format(response.status_code, f"Details: {response.text}," if response.text else "",
+                               latest_deploymentinfo_url))
 
 
 # OneDeploy
@@ -9909,27 +9946,33 @@ def _perform_onedeploy_internal(params):
         # Check if this is already an enriched error (from raise_enriched_deployment_error)
         if "COPILOT CONTEXT" in str(ex):
             raise
-        # Raw CLIError from send_raw_request or other deployment calls — enrich it
-        raise_enriched_deployment_error(
-            params=params,
-            error_message=str(ex),
-            last_known_step="Deployment request"
-        )
+        if not params.is_functionapp:
+            # Raw CLIError from send_raw_request or other deployment calls — enrich it
+            raise_enriched_deployment_error(
+                params=params,
+                error_message=str(ex),
+                last_known_step="Deployment request"
+            )
+        raise
     except HttpResponseError as ex:
-        # Azure SDK errors (e.g. Bad Request from ARM)
-        raise_enriched_deployment_error(
-            params=params,
-            status_code=ex.status_code if hasattr(ex, 'status_code') else None,
-            error_message=str(ex),
-            last_known_step="ARM deployment request"
-        )
+        if not params.is_functionapp:
+            # Azure SDK errors (e.g. Bad Request from ARM)
+            raise_enriched_deployment_error(
+                params=params,
+                status_code=ex.status_code if hasattr(ex, 'status_code') else None,
+                error_message=str(ex),
+                last_known_step="ARM deployment request"
+            )
+        raise
     except Exception as ex:  # pylint: disable=broad-except
-        # Catch-all for unexpected errors (connection errors, timeouts, etc.)
-        raise_enriched_deployment_error(
-            params=params,
-            error_message=str(ex),
-            last_known_step="Deployment request"
-        )
+        if not params.is_functionapp:
+            # Catch-all for unexpected errors (connection errors, timeouts, etc.)
+            raise_enriched_deployment_error(
+                params=params,
+                error_message=str(ex),
+                last_known_step="Deployment request"
+            )
+        raise
 
 
 def _wait_for_webapp(tunnel_server):

src/azure-cli/azure/cli/command_modules/appservice/tests/latest/test_deployment_context_engine.py

@@ -189,6 +189,24 @@ def test_determine_deployment_type_war(self):
         params = _make_mock_params(artifact_type="war", src_url=None)
         self.assertEqual(_determine_deployment_type(params), "WarDeploy")
 
+    def test_determine_deployment_type_kwargs_zip(self):
+        """kwargs-only calling convention (no params object)."""
+        self.assertEqual(_determine_deployment_type(artifact_type="zip"), "ZipDeploy")
+
+    def test_determine_deployment_type_kwargs_url(self):
+        self.assertEqual(
+            _determine_deployment_type(src_url="https://example.com/app.zip"),
+            "OneDeploy (URL-based)"
+        )
+
+    def test_determine_deployment_type_kwargs_override(self):
+        """Explicit kwargs should override params values."""
+        params = _make_mock_params(artifact_type="war", src_url=None)
+        self.assertEqual(
+            _determine_deployment_type(params, artifact_type="jar"),
+            "JarDeploy"
+        )
+
     def test_build_context_with_known_pattern(self):
         self._patch_app_metadata()
         params = _make_mock_params()
@@ -289,6 +307,41 @@ def test_raise_enriched_deployment_error(self):
         self.assertIn("ZipDeployTimeout", str(cm.exception))
         self.assertIn("COPILOT CONTEXT", str(cm.exception))
 
+    def test_raise_enriched_deployment_error_kwargs_only(self):
+        """Call raise_enriched_deployment_error with kwargs instead of params."""
+        self._patch_app_metadata()
+        mock_cmd = MagicMock()
+        mock_cmd.cli_ctx = MagicMock()
+        from knack.util import CLIError
+        with self.assertRaises(CLIError) as cm:
+            raise_enriched_deployment_error(
+                cmd=mock_cmd,
+                resource_group_name="test-rg",
+                webapp_name="test-app",
+                artifact_type="zip",
+                status_code=504,
+                error_message="Gateway Timeout"
+            )
+        self.assertIn("ZipDeployTimeout", str(cm.exception))
+        self.assertIn("COPILOT CONTEXT", str(cm.exception))
+        self.assertIn("ZipDeploy", str(cm.exception))
+
+    def test_build_context_kwargs_only(self):
+        """Call build_enriched_error_context with kwargs instead of params."""
+        self._patch_app_metadata()
+        mock_cmd = MagicMock()
+        mock_cmd.cli_ctx = MagicMock()
+        ctx = build_enriched_error_context(
+            cmd=mock_cmd,
+            resource_group_name="test-rg",
+            webapp_name="test-app",
+            artifact_type="zip",
+            status_code=504,
+            error_message="Gateway Timeout"
+        )
+        self.assertEqual(ctx["errorCode"], "ZipDeployTimeout")
+        self.assertEqual(ctx["deploymentType"], "ZipDeploy")
+
 
 # ---------------------------------------------------------------------------
 # Integration-level test: verify the full error flow