telemetry(amazonqFeatureDev): generateApproach api error metrics, minor fixes #4149

Problem
featureDev errors return a generic failure. Understanding the specific error (403 or 409) with telemetry is hard.

Solution
Add status code to api errors to track in telemetry.

Author: sannicm

src/amazonqFeatureDev/client/featureDev.ts

@@ -9,14 +9,14 @@ import { ConfiguredRetryStrategy } from '@aws-sdk/util-retry'
 import { omit } from 'lodash'
 import { AuthUtil } from '../../codewhisperer/util/authUtil'
 import { ServiceOptions } from '../../shared/awsClientBuilder'
-import { ToolkitError } from '../../shared/errors'
 import globals from '../../shared/extensionGlobals'
 import { getLogger } from '../../shared/logger'
 import * as FeatureDevProxyClient from './featuredevproxyclient'
 import apiConfig = require('./codewhispererruntime-2022-11-11.json')
 import { featureName } from '../constants'
-import { ContentLengthError } from '../errors'
+import { ApiError, ContentLengthError, UnknownApiError } from '../errors'
 import { endpoint, region } from '../../codewhisperer/models/constants'
+import { isAwsError, isCodeWhispererStreamingServiceException } from '../../shared/errors'
 
 // Create a client for featureDev proxy client based off of aws sdk v2
 export async function createFeatureDevProxyClient(): Promise<FeatureDevProxyClient> {
@@ -53,6 +53,15 @@ async function createFeatureDevStreamingClient(): Promise<CodeWhispererStreaming
     return streamingClient
 }
 
+const streamResponseErrors: Record<string, number> = {
+    ValidationException: 400,
+    AccessDeniedException: 403,
+    ResourceNotFoundException: 404,
+    ConflictException: 409,
+    ThrottlingException: 429,
+    InternalServerException: 500,
+}
+
 export class FeatureDevClient {
     private async getClient() {
         // Should not be stored for the whole session.
@@ -77,12 +86,14 @@ export class FeatureDevClient {
             })
             return conversationId
         } catch (e) {
-            getLogger().error(
-                `${featureName}: failed to start conversation: ${(e as Error).message} RequestId: ${
-                    (e as any).requestId
-                }`
-            )
-            throw new ToolkitError((e as Error).message, { code: 'CreateConversationFailed' })
+            if (isAwsError(e)) {
+                getLogger().error(
+                    `${featureName}: failed to start conversation: ${e.message} RequestId: ${e.requestId}`
+                )
+                throw new ApiError(e.message, 'CreateConversation', e.code, e.statusCode ?? 400)
+            }
+
+            throw new UnknownApiError(e instanceof Error ? e.message : 'Unknown error', 'CreateConversation')
         }
     }
 
@@ -108,16 +119,18 @@ export class FeatureDevClient {
                 requestId: response.$response.requestId,
             })
             return response
-        } catch (e: any) {
-            getLogger().error(
-                `${featureName}: failed to generate presigned url: ${(e as Error).message} RequestId: ${
-                    (e as any).requestId
-                }`
-            )
-            if (e.code === 'ValidationException' && e.message.includes('Invalid contentLength')) {
-                throw new ContentLengthError()
+        } catch (e) {
+            if (isAwsError(e)) {
+                getLogger().error(
+                    `${featureName}: failed to generate presigned url: ${e.message} RequestId: ${e.requestId}`
+                )
+                if (e.code === 'ValidationException' && e.message.includes('Invalid contentLength')) {
+                    throw new ContentLengthError()
+                }
+                throw new ApiError(e.message, 'CreateUploadUrl', e.code, e.statusCode ?? 400)
             }
-            throw new ToolkitError((e as Error).message, { code: 'CreateUploadUrlFailed' })
+
+            throw new UnknownApiError(e instanceof Error ? e.message : 'Unknown error', 'CreateUploadUrl')
         }
     }
 
@@ -153,10 +166,21 @@ export class FeatureDevClient {
             }
             return assistantResponse.join(' ')
         } catch (e) {
-            getLogger().error(
-                `${featureName}: failed to execute planning: ${(e as Error).message} RequestId: ${(e as any).requestId}`
-            )
-            throw new ToolkitError((e as Error).message, { code: 'GeneratePlanFailed' })
+            if (isCodeWhispererStreamingServiceException(e)) {
+                getLogger().error(
+                    `${featureName}: failed to execute planning: ${e.message} RequestId: ${
+                        e.$metadata.requestId ?? 'unknown'
+                    }`
+                )
+                throw new ApiError(
+                    e.message,
+                    'GeneratePlan',
+                    e.name,
+                    e.$metadata?.httpStatusCode ?? streamResponseErrors[e.name] ?? 500
+                )
+            }
+
+            throw new UnknownApiError(e instanceof Error ? e.message : 'Unknown error', 'GeneratePlan')
         }
     }
 }

src/amazonqFeatureDev/errors.ts

@@ -55,6 +55,12 @@ export class PrepareRepoFailedError extends ToolkitError {
     }
 }
 
+export class IllegalStateTransition extends ToolkitError {
+    constructor() {
+        super('Illegal transition between states, restart the conversation', { code: 'IllegalStateTransition' })
+    }
+}
+
 export class ContentLengthError extends ToolkitError {
     constructor() {
         super(
@@ -64,6 +70,18 @@ export class ContentLengthError extends ToolkitError {
     }
 }
 
+export class UnknownApiError extends ToolkitError {
+    constructor(message: string, api: string) {
+        super(message, { code: `${api}-Unknown` })
+    }
+}
+
+export class ApiError extends ToolkitError {
+    constructor(message: string, api: string, errorName: string, errorCode: number) {
+        super(message, { code: `${api}-${errorName}-${errorCode}` })
+    }
+}
+
 const denyListedErrors: string[] = ['Deserialization error', 'Inaccessible host']
 
 export function createUserFacingErrorMessage(message: string) {

src/amazonqFeatureDev/session/sessionState.ts

@@ -8,7 +8,7 @@ import * as vscode from 'vscode'
 import { ToolkitError } from '../../shared/errors'
 import { getLogger } from '../../shared/logger'
 import { telemetry } from '../../shared/telemetry/telemetry'
-import { UserMessageNotFoundError } from '../errors'
+import { IllegalStateTransition, UserMessageNotFoundError } from '../errors'
 import { SessionState, SessionStateAction, SessionStateConfig, SessionStateInteraction } from '../types'
 import { prepareRepoData } from '../util/files'
 import { uploadCode } from '../util/upload'
@@ -23,9 +23,7 @@ export class ConversationNotStartedState implements Omit<SessionState, 'uploadId
     }
 
     async interact(_action: SessionStateAction): Promise<SessionStateInteraction> {
-        throw new ToolkitError('Illegal transition between states, restart the conversation', {
-            code: 'IllegalStateTransition',
-        })
+        throw new IllegalStateTransition()
     }
 }
 

src/shared/errors.ts

@@ -12,6 +12,7 @@ import { CancellationError } from './utilities/timeoutUtils'
 import { isNonNullable } from './utilities/tsUtils'
 import type * as fs from 'fs'
 import type * as os from 'os'
+import { CodeWhispererStreamingServiceException } from '@amzn/codewhisperer-streaming'
 
 export const errorCode = {
     invalidConnection: 'InvalidConnection',
@@ -370,6 +371,29 @@ export function findAwsErrorInCausalChain(error: unknown): AWSError | undefined
     return undefined
 }
 
+export function isCodeWhispererStreamingServiceException(
+    error: unknown
+): error is CodeWhispererStreamingServiceException {
+    if (error === undefined) {
+        return false
+    }
+
+    return error instanceof Error && hasFault(error) && hasMetadata(error) && hasName(error)
+}
+
+function hasFault<T>(error: T): error is T & { $fault: 'client' | 'server' } {
+    const fault = (error as { $fault?: unknown }).$fault
+    return typeof fault === 'string' && (fault === 'client' || fault === 'server')
+}
+
+function hasMetadata<T>(error: T): error is T & Pick<CodeWhispererStreamingServiceException, '$metadata'> {
+    return typeof (error as { $metadata?: unknown }).$metadata === 'object'
+}
+
+function hasName<T>(error: T): error is T & { name: string } {
+    return typeof (error as { name?: unknown }).name === 'string'
+}
+
 export function isAwsError(error: unknown): error is AWSError {
     if (error === undefined) {
         return false