map all errors (#6389)

* add explicit and auto error mapping

* split deployment from validate and preview errors

Author: weikanglim

cli/azd/internal/cmd/errors.go

@@ -9,33 +9,51 @@ import (
 	"fmt"
 	"log"
 	"path/filepath"
+	"reflect"
 	"strings"
 
 	"github.com/AlecAivazis/survey/v2/terminal"
 	"github.com/Azure/azure-sdk-for-go/sdk/azcore"
+	"github.com/azure/azure-dev/cli/azd/internal"
 	"github.com/azure/azure-dev/cli/azd/internal/tracing"
 	"github.com/azure/azure-dev/cli/azd/internal/tracing/fields"
 	"github.com/azure/azure-dev/cli/azd/pkg/auth"
 	"github.com/azure/azure-dev/cli/azd/pkg/azapi"
 	"github.com/azure/azure-dev/cli/azd/pkg/azdext"
 	"github.com/azure/azure-dev/cli/azd/pkg/exec"
 	"github.com/azure/azure-dev/cli/azd/pkg/extensions"
+	"github.com/azure/azure-dev/cli/azd/pkg/tools"
 	"go.opentelemetry.io/otel/attribute"
 	"go.opentelemetry.io/otel/codes"
 )
 
 // MapError maps the given error to a telemetry span, setting relevant status and attributes.
 func MapError(err error, span tracing.Span) {
-	errCode := "UnknownError"
+	var errCode string
 	var errDetails []attribute.KeyValue
 
+	// external service errors
 	var respErr *azcore.ResponseError
 	var armDeployErr *azapi.AzureDeploymentError
-	var toolExecErr *exec.ExitError
 	var authFailedErr *auth.AuthFailedError
-	var extensionRunErr *extensions.ExtensionRunError
 	var extServiceErr *azdext.ServiceError
-	if errors.As(err, &respErr) {
+
+	// external tool errors
+	var toolExecErr *exec.ExitError
+	var toolCheckErr *tools.MissingToolErrors
+	var extensionRunErr *extensions.ExtensionRunError
+
+	// internal errors
+	var errWithSuggestion *internal.ErrorWithSuggestion
+	var loginErr *auth.ReLoginRequiredError
+
+	if errors.As(err, &loginErr) {
+		errCode = "auth.login_required"
+	} else if errors.As(err, &errWithSuggestion) {
+		errCode = "error.suggestion"
+		errType := errorType(errWithSuggestion.Unwrap())
+		span.SetAttributes(fields.ErrType.String(errType))
+	} else if errors.As(err, &respErr) {
 		serviceName := "other"
 		statusCode := -1
 		errDetails = append(errDetails, fields.ServiceErrorCode.String(respErr.ErrorCode))
@@ -83,7 +101,13 @@ func MapError(err error, span tracing.Span) {
 			}
 		}
 
-		errCode = "service.arm.deployment.failed"
+		// Use operation-specific error code if available
+		operation := armDeployErr.Operation
+		if operation == azapi.DeploymentOperationDeploy {
+			// use 'deployment' instead of 'deploy' for consistency with prior naming
+			operation = "deployment"
+		}
+		errCode = fmt.Sprintf("service.arm.%s.failed", operation)
 	} else if errors.As(err, &extensionRunErr) {
 		errCode = "ext.run.failed"
 	} else if errors.As(err, &extServiceErr) {
@@ -114,6 +138,15 @@ func MapError(err error, span tracing.Span) {
 			fields.ToolName.String(toolName))
 
 		errCode = fmt.Sprintf("tool.%s.failed", toolName)
+	} else if errors.As(err, &toolCheckErr) {
+		if len(toolCheckErr.ToolNames) == 1 {
+			toolName := toolCheckErr.ToolNames[0]
+			errCode = fmt.Sprintf("tool.%s.missing", toolName)
+			errDetails = append(errDetails, fields.ToolName.String(toolName))
+		} else {
+			errCode = "tool.multiple.missing"
+			errDetails = append(errDetails, fields.ToolName.String(strings.Join(toolCheckErr.ToolNames, ",")))
+		}
 	} else if errors.As(err, &authFailedErr) {
 		errDetails = append(errDetails, fields.ServiceName.String("aad"))
 		if authFailedErr.Parsed != nil {
@@ -130,6 +163,11 @@ func MapError(err error, span tracing.Span) {
 		errCode = "service.aad.failed"
 	} else if errors.Is(err, terminal.InterruptErr) {
 		errCode = "user.canceled"
+	} else {
+		errType := errorType(err)
+		span.SetAttributes(fields.ErrType.String(errType))
+		errCode = fmt.Sprintf("internal.%s",
+			strings.ReplaceAll(strings.ReplaceAll(errType, ".", "_"), "*", ""))
 	}
 
 	if len(errDetails) > 0 {
@@ -143,6 +181,39 @@ func MapError(err error, span tracing.Span) {
 	span.SetStatus(codes.Error, errCode)
 }
 
+// errorType returns the type name of the given error, unwrapping as needed to find the root cause(s).
+func errorType(err error) string {
+	if err == nil {
+		return "<nil>"
+	}
+
+	//nolint:errorlint // Type switch is intentionally used to check for Unwrap() methods
+	for {
+		switch x := err.(type) {
+		case interface{ Unwrap() error }:
+			err = x.Unwrap()
+			if err == nil {
+				return reflect.TypeOf(x).String()
+			}
+		case interface{ Unwrap() []error }:
+			result := ""
+			for _, err := range x.Unwrap() {
+				if err == nil {
+					continue
+				}
+				if result != "" {
+					result += ","
+				}
+
+				result += reflect.TypeOf(err).String()
+			}
+			return result
+		default:
+			return reflect.TypeOf(x).String()
+		}
+	}
+}
+
 type deploymentErrorCode struct {
 	Code  string `json:"error.code"`
 	Frame int    `json:"error.frame"`

cli/azd/internal/cmd/errors_test.go

@@ -28,16 +28,20 @@ func Test_MapError(t *testing.T) {
 		wantErrDetails []attribute.KeyValue
 	}{
 		{
-			name:           "WithNilError",
-			err:            nil,
-			wantErrReason:  "UnknownError",
-			wantErrDetails: nil,
+			name:          "WithNilError",
+			err:           nil,
+			wantErrReason: "internal.<nil>",
+			wantErrDetails: []attribute.KeyValue{
+				fields.ErrType.String("<nil>"),
+			},
 		},
 		{
-			name:           "WithOtherError",
-			err:            errors.New("something bad happened!"),
-			wantErrReason:  "UnknownError",
-			wantErrDetails: nil,
+			name:          "WithOtherError",
+			err:           errors.New("something bad happened!"),
+			wantErrReason: "internal.errors_errorString",
+			wantErrDetails: []attribute.KeyValue{
+				fields.ErrType.String("*errors.errorString"),
+			},
 		},
 		{
 			name: "WithToolExitError",
@@ -54,6 +58,7 @@ func Test_MapError(t *testing.T) {
 		{
 			name: "WithArmDeploymentError",
 			err: &azapi.AzureDeploymentError{
+				Operation: azapi.DeploymentOperationDeploy,
 				Details: &azapi.DeploymentErrorLine{
 					Code: "",
 					Inner: []*azapi.DeploymentErrorLine{
@@ -106,6 +111,33 @@ func Test_MapError(t *testing.T) {
 					})),
 			},
 		},
+		{
+			name: "WithArmValidationError",
+			err: &azapi.AzureDeploymentError{
+				Operation: azapi.DeploymentOperationValidate,
+				Details: &azapi.DeploymentErrorLine{
+					Code: "InvalidTemplate",
+					Inner: []*azapi.DeploymentErrorLine{
+						{Code: "TemplateValidationFailed"},
+					},
+				},
+			},
+			wantErrReason: "service.arm.validate.failed",
+			wantErrDetails: []attribute.KeyValue{
+				fields.ErrorKey(fields.ServiceName.Key).String("arm"),
+				fields.ErrorKey(fields.ServiceErrorCode.Key).String(mustMarshalJson(
+					[]map[string]interface{}{
+						{
+							string(fields.ErrCode.Key):  "InvalidTemplate",
+							string(fields.ErrFrame.Key): 0,
+						},
+						{
+							string(fields.ErrCode.Key):  "TemplateValidationFailed",
+							string(fields.ErrFrame.Key): 1,
+						},
+					})),
+			},
+		},
 		{
 			name: "WithResponseError",
 			err: &azcore.ResponseError{
@@ -198,6 +230,105 @@ func Test_cmdAsName(t *testing.T) {
 	}
 }
 
+func Test_errorType(t *testing.T) {
+	tests := []struct {
+		name string
+		err  error
+		want string
+	}{
+		{
+			name: "NilError",
+			err:  nil,
+			want: "<nil>",
+		},
+		{
+			name: "SimpleError",
+			err:  errors.New("simple error"),
+			want: "*errors.errorString",
+		},
+		{
+			name: "SingleUnwrapError",
+			err: &exec.ExitError{
+				Cmd:      "test",
+				ExitCode: 1,
+			},
+			want: "*exec.ExitError",
+		},
+		{
+			name: "NestedUnwrapError",
+			err: func() error {
+				inner := errors.New("inner error")
+				return &singleUnwrapError{
+					msg: "wrapped error",
+					err: inner,
+				}
+			}(),
+			want: "*errors.errorString",
+		},
+		{
+			name: "MultipleUnwrapErrors",
+			err: func() error {
+				err1 := errors.New("error 1")
+				err2 := errors.New("error 2")
+				return &multiUnwrapError{
+					errs: []error{err1, err2},
+				}
+			}(),
+			want: "*errors.errorString,*errors.errorString",
+		},
+		{
+			name: "MultipleUnwrapErrorsWithNil",
+			err: func() error {
+				err1 := errors.New("error 1")
+				return &multiUnwrapError{
+					errs: []error{err1, nil, errors.New("error 2")},
+				}
+			}(),
+			want: "*errors.errorString,*errors.errorString",
+		},
+		{
+			name: "UnwrapReturnsNil",
+			err: &singleUnwrapError{
+				msg: "test error",
+				err: nil,
+			},
+			want: "*cmd.singleUnwrapError",
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got := errorType(tt.err)
+			require.Equal(t, tt.want, got)
+		})
+	}
+}
+
+// Test helper types for errorType tests
+type singleUnwrapError struct {
+	msg string
+	err error
+}
+
+func (e *singleUnwrapError) Error() string {
+	return e.msg
+}
+
+func (e *singleUnwrapError) Unwrap() error {
+	return e.err
+}
+
+type multiUnwrapError struct {
+	errs []error
+}
+
+func (e *multiUnwrapError) Error() string {
+	return "multiple errors"
+}
+
+func (e *multiUnwrapError) Unwrap() []error {
+	return e.errs
+}
+
 func mustMarshalJson(v interface{}) string {
 	b, err := json.Marshal(v)
 	if err != nil {

cli/azd/internal/tracing/fields/fields.go

@@ -320,6 +320,13 @@ var (
 		Purpose:        PerformanceAndHealth,
 	}
 
+	// Error type.
+	ErrType = AttributeKey{
+		Key:            attribute.Key("error.type"),
+		Classification: SystemMetadata,
+		Purpose:        PerformanceAndHealth,
+	}
+
 	// Inner error.
 	ErrInner = AttributeKey{
 		Key:            attribute.Key("error.inner"),

cli/azd/pkg/azapi/azure_deployment_error.go

@@ -29,15 +29,16 @@ func newErrorLine(code string, message string, inner []*DeploymentErrorLine) *De
 }
 
 type AzureDeploymentError struct {
-	Json  string
-	Inner error
-	Title string
+	Json      string
+	Inner     error
+	Title     string
+	Operation DeploymentOperation
 
 	Details *DeploymentErrorLine
 }
 
-func NewAzureDeploymentError(title string, jsonErrorResponse string) *AzureDeploymentError {
-	err := &AzureDeploymentError{Title: title, Json: jsonErrorResponse}
+func NewAzureDeploymentError(title string, jsonErrorResponse string, operation DeploymentOperation) *AzureDeploymentError {
+	err := &AzureDeploymentError{Title: title, Json: jsonErrorResponse, Operation: operation}
 	err.init()
 	return err
 }

cli/azd/pkg/azapi/azure_deployment_error_test.go

@@ -47,7 +47,7 @@ func assertOutputsMatch(t *testing.T, jsonPath string, expectedOutputPath string
 	}
 
 	errorJson := string(data)
-	deploymentError := NewAzureDeploymentError("Title", errorJson)
+	deploymentError := NewAzureDeploymentError("Title", errorJson, DeploymentOperationDeploy)
 	errorString := deploymentError.Error()
 
 	actualLines := strings.Split(errorString, "\n")