Security scans: Improving telemetry error messages (#4600)

laileni-aws · web-flow · commit 83ead2f9a87c · 2024-06-25T18:31:12.000-07:00
* Improving telemetry error messages

* Adding reasonDesc param to telemetry error messages
diff --git a/.changes/next-release/bugfix-95a98e96-ceb3-4a13-b05a-5a135a805ac0.json b/.changes/next-release/bugfix-95a98e96-ceb3-4a13-b05a-5a135a805ac0.json
@@ -0,0 +1,4 @@
+{
+  "type" : "bugfix",
+  "description" : "Security Scan: Improved telemetry error messages"
+}
diff --git a/plugins/amazonq/codewhisperer/jetbrains-community/src/software/aws/toolkits/jetbrains/services/codewhisperer/codescan/CodeWhispererCodeScanException.kt b/plugins/amazonq/codewhisperer/jetbrains-community/src/software/aws/toolkits/jetbrains/services/codewhisperer/codescan/CodeWhispererCodeScanException.kt
@@ -5,33 +5,35 @@ package software.aws.toolkits.jetbrains.services.codewhisperer.codescan
 
 import software.aws.toolkits.resources.message
 
-open class CodeWhispererCodeScanException(override val message: String?) : RuntimeException()
+open class CodeScanException(override val message: String, open val code: String?) : RuntimeException(message)
 
-open class CodeWhispererCodeScanServerException(override val message: String?) : RuntimeException()
+open class CodeWhispererCodeScanException(override val message: String, override val code: String?) : CodeScanException(message, code)
+
+open class CodeWhispererCodeScanServerException(override val message: String, override val code: String?) : CodeScanException(message, code)
 
 internal fun noFileOpenError(): Nothing =
-    throw CodeWhispererCodeScanException(message("codewhisperer.codescan.no_file_open"))
+    throw CodeWhispererCodeScanException(message("codewhisperer.codescan.no_file_open"), "NoSourceFilesError")
 
-internal fun codeScanFailed(errorMessage: String): Nothing =
-    throw Exception(errorMessage)
+internal fun codeScanFailed(errorMessage: String, code: String?): Nothing =
+    throw CodeScanException(errorMessage, code)
 
 internal fun cannotFindFile(errorMessage: String, filepath: String): Nothing =
     error(message("codewhisperer.codescan.file_not_found", filepath, errorMessage))
 
 internal fun cannotFindBuildArtifacts(): Nothing =
-    throw CodeWhispererCodeScanException(message("codewhisperer.codescan.build_artifacts_not_found"))
+    throw CodeWhispererCodeScanException(message("codewhisperer.codescan.build_artifacts_not_found"), "NoSourceFilesError")
 
 internal fun fileFormatNotSupported(format: String): Nothing =
-    throw CodeWhispererCodeScanException(message("codewhisperer.codescan.file_ext_not_supported", format))
+    throw CodeWhispererCodeScanException(message("codewhisperer.codescan.file_ext_not_supported", format), "FileFormatNotSupportedError")
 
 internal fun fileTooLarge(): Nothing =
-    throw CodeWhispererCodeScanException(message("codewhisperer.codescan.file_too_large"))
+    throw CodeWhispererCodeScanException(message("codewhisperer.codescan.file_too_large"), "ProjectSizeExceeded")
 
-internal fun codeScanServerException(errorMessage: String): Nothing =
-    throw CodeWhispererCodeScanServerException(errorMessage)
+internal fun codeScanServerException(errorMessage: String, code: String?): Nothing =
+    throw CodeWhispererCodeScanServerException(errorMessage, code)
 
 internal fun invalidSourceZipError(): Nothing =
-    throw CodeWhispererCodeScanException(message("codewhisperer.codescan.invalid_source_zip_telemetry"))
+    throw CodeWhispererCodeScanException(message("codewhisperer.codescan.invalid_source_zip_telemetry"), "InvalidSourceZip")
 
 internal fun noSupportedFilesError(): Nothing =
-    throw CodeWhispererCodeScanException(message("codewhisperer.codescan.unsupported_language_error"))
+    throw CodeWhispererCodeScanException(message("codewhisperer.codescan.unsupported_language_error"), "NoSourceFilesError")
diff --git a/plugins/amazonq/codewhisperer/jetbrains-community/src/software/aws/toolkits/jetbrains/services/codewhisperer/codescan/CodeWhispererCodeScanManager.kt b/plugins/amazonq/codewhisperer/jetbrains-community/src/software/aws/toolkits/jetbrains/services/codewhisperer/codescan/CodeWhispererCodeScanManager.kt
@@ -282,13 +282,14 @@ class CodeWhispererCodeScanManager(val project: Project) {
                 isProjectScanInProgress.set(false)
             }
             val errorMessage = handleError(coroutineContext, e, scope)
-            codeScanResponseContext = codeScanResponseContext.copy(reason = errorMessage)
-        } catch (e: Exception) {
+            codeScanResponseContext = codeScanResponseContext.copy(reasonDesc = errorMessage)
+            codeScanResponseContext = codeScanResponseContext.copy(reason = "DefaultError")
+        } catch (e: CodeScanException) {
             if (scope == CodeWhispererConstants.CodeAnalysisScope.PROJECT) {
                 isProjectScanInProgress.set(false)
             }
-            val errorMessage = handleException(coroutineContext, e, scope)
-            codeScanResponseContext = codeScanResponseContext.copy(reason = errorMessage)
+            codeScanResponseContext = codeScanResponseContext.copy(reasonDesc = handleException(coroutineContext, e, scope))
+            codeScanResponseContext = codeScanResponseContext.copy(reason = e.code ?: "DefaultError")
         } finally {
             // After code scan
             afterCodeScan(scope)
@@ -337,7 +338,7 @@ class CodeWhispererCodeScanManager(val project: Project) {
     private fun getCodeScanExceptionMessage(e: CodeWhispererCodeScanException): String? {
         val message = e.message
         return when {
-            message.isNullOrBlank() -> null
+            message.isBlank() -> null
             message == message("codewhisperer.codescan.invalid_source_zip_telemetry") -> {
                 message("codewhisperer.codescan.run_scan_error")
             }
@@ -346,8 +347,12 @@ class CodeWhispererCodeScanManager(val project: Project) {
     }
 
     private fun getCodeScanServerExceptionMessage(e: CodeWhispererCodeScanServerException): String? =
-        e.message?.takeIf { it.startsWith("UploadArtifactToS3Exception:") }
-            ?.let { message("codewhisperer.codescan.upload_to_s3_failed") }
+        e.code?.let {
+            when (it) {
+                "UploadArtifactToS3Error" -> message("codewhisperer.codescan.upload_to_s3_failed")
+                else -> null
+            }
+        }
 
     fun handleException(coroutineContext: CoroutineContext, e: Exception, scope: CodeWhispererConstants.CodeAnalysisScope): String {
         val errorMessage = when (e) {
diff --git a/plugins/amazonq/codewhisperer/jetbrains-community/src/software/aws/toolkits/jetbrains/services/codewhisperer/codescan/CodeWhispererCodeScanSession.kt b/plugins/amazonq/codewhisperer/jetbrains-community/src/software/aws/toolkits/jetbrains/services/codewhisperer/codescan/CodeWhispererCodeScanSession.kt
@@ -154,7 +154,7 @@ class CodeWhispererCodeScanSession(val sessionContext: CodeScanSessionContext) {
                     }
                 }
                 val errorMessage = createCodeScanResponse.errorMessage()?.let { it } ?: message("codewhisperer.codescan.run_scan_error_telemetry")
-                codeScanFailed(errorMessage)
+                codeScanFailed(errorMessage, "CreateCodeScanFailedError")
             }
             val jobId = createCodeScanResponse.jobId()
             codeScanResponseContext = codeScanResponseContext.copy(codeScanJobId = jobId)
@@ -191,7 +191,7 @@ class CodeWhispererCodeScanSession(val sessionContext: CodeScanSessionContext) {
                         }
                     }
                     val errorMessage = getCodeScanResponse.errorMessage()?.let { it } ?: message("codewhisperer.codescan.run_scan_error_telemetry")
-                    codeScanFailed(errorMessage)
+                    codeScanFailed(errorMessage, "DefaultError")
                 }
             }
 
@@ -286,13 +286,8 @@ class CodeWhispererCodeScanSession(val sessionContext: CodeScanSessionContext) {
         )
     } catch (e: Exception) {
         LOG.debug { "Create Upload URL failed: ${e.message}" }
-
-        val errorMessage = when {
-            e.message?.contains("Your account is not authorized to make this call.") == true -> "Your account is not authorized to make this call."
-            e.message?.contains("Service returned HTTP status code 407") == true -> "Service returned HTTP status code 407"
-            else -> e.message ?: message("codewhisperer.codescan.run_scan_error_telemetry")
-        }
-        throw codeScanServerException("CreateUploadUrlException: $errorMessage")
+        val errorMessage = getTelemetryErrorMessage(e)
+        throw codeScanServerException(errorMessage, "CreateUploadUrlError")
     }
 
     private fun getUploadIntent(scope: CodeWhispererConstants.CodeAnalysisScope): UploadIntent = when (scope) {
@@ -325,7 +320,8 @@ class CodeWhispererCodeScanSession(val sessionContext: CodeScanSessionContext) {
             }
         } catch (e: Exception) {
             LOG.debug { "Artifact failed to upload in the S3 bucket: ${e.message}" }
-            throw codeScanServerException("UploadArtifactToS3Exception: " + e.message?.let { it } ?: message("codewhisperer.codescan.run_scan_error_telemetry"))
+            val errorMessage = getTelemetryErrorMessage(e)
+            throw codeScanServerException(errorMessage, "UploadArtifactToS3Error")
         }
     }
 
@@ -347,15 +343,8 @@ class CodeWhispererCodeScanSession(val sessionContext: CodeScanSessionContext) {
             )
         } catch (e: Exception) {
             LOG.debug { "Creating security scan failed: ${e.message}" }
-            val errorMessage = when {
-                e.message?.contains("Too many requests, please wait before trying again.") == true -> "Too many requests, please wait before trying again."
-                e.message?.contains("Improperly formed request.") == true -> "Improperly formed request."
-                e.message?.contains("Service returned HTTP status code 407") == true -> "Service returned HTTP status code 407"
-                e.message?.contains("Encountered an unexpected error when processing the request, please try again.") == true ->
-                    "Encountered an unexpected error when processing the request, please try again."
-                else -> e.message ?: message("codewhisperer.codescan.run_scan_error_telemetry")
-            }
-            throw codeScanServerException("CreateCodeScanException: $errorMessage")
+            val errorMessage = getTelemetryErrorMessage(e)
+            throw codeScanServerException(errorMessage, "CreateCodeScanError")
         }
     }
 
@@ -367,7 +356,8 @@ class CodeWhispererCodeScanSession(val sessionContext: CodeScanSessionContext) {
         )
     } catch (e: Exception) {
         LOG.debug { "Getting security scan failed: ${e.message}" }
-        throw codeScanServerException("GetCodeScanException: " + e.message?.let { it } ?: message("codewhisperer.codescan.run_scan_error_telemetry"))
+        val errorMessage = getTelemetryErrorMessage(e)
+        throw codeScanServerException(errorMessage, "GetCodeScanError")
     }
 
     fun listCodeScanFindings(jobId: String, nextToken: String?): ListCodeScanFindingsResponse = try {
@@ -380,7 +370,8 @@ class CodeWhispererCodeScanSession(val sessionContext: CodeScanSessionContext) {
         )
     } catch (e: Exception) {
         LOG.debug { "Listing security scan failed: ${e.message}" }
-        throw codeScanServerException("ListCodeScanFindingsException: " + e.message?.let { it } ?: message("codewhisperer.codescan.run_scan_error_telemetry"))
+        val errorMessage = getTelemetryErrorMessage(e)
+        throw codeScanServerException(errorMessage, "ListCodeScanFindingsError")
     }
 
     fun mapToCodeScanIssues(recommendations: List<String>): List<CodeWhispererCodeScanIssue> {
@@ -441,6 +432,17 @@ class CodeWhispererCodeScanSession(val sessionContext: CodeScanSessionContext) {
         sleep(CODE_SCAN_POLLING_INTERVAL_IN_SECONDS * TOTAL_MILLIS_IN_SECOND)
     }
 
+    fun getTelemetryErrorMessage(e: Exception): String = when {
+        e.message?.contains("Resource not found.") == true -> "Resource not found."
+        e.message?.contains("Service returned HTTP status code 407") == true -> "Service returned HTTP status code 407"
+        e.message?.contains("Service returned HTTP status code 403") == true -> "Service returned HTTP status code 403"
+        e.message?.contains("invalid_grant: Invalid token provided") == true -> "invalid_grant: Invalid token provided"
+        e.message?.contains("Connect timed out") == true -> "Unable to execute HTTP request: Connect timed out" // Error: Connect to host failed
+        e.message?.contains("Encountered an unexpected error when processing the request, please try again.") == true ->
+            "Encountered an unexpected error when processing the request, please try again."
+        else -> e.message ?: message("codewhisperer.codescan.run_scan_error_telemetry")
+    }
+
     private fun isProjectScope(): Boolean = sessionContext.codeAnalysisScope == CodeWhispererConstants.CodeAnalysisScope.PROJECT
 
     companion object {
diff --git a/plugins/amazonq/codewhisperer/jetbrains-community/src/software/aws/toolkits/jetbrains/services/codewhisperer/model/CodeWhispererModel.kt b/plugins/amazonq/codewhisperer/jetbrains-community/src/software/aws/toolkits/jetbrains/services/codewhisperer/model/CodeWhispererModel.kt
@@ -155,7 +155,8 @@ data class CodeScanResponseContext(
     val codeScanJobId: String? = null,
     val codeScanTotalIssues: Int = 0,
     val codeScanIssuesWithFixes: Int = 0,
-    val reason: String? = null
+    val reason: String? = null,
+    val reasonDesc: String? = null
 )
 
 data class LatencyContext(
diff --git a/plugins/amazonq/codewhisperer/jetbrains-community/tst/software/aws/toolkits/jetbrains/services/codewhisperer/codescan/CodeWhispererCodeScanTest.kt b/plugins/amazonq/codewhisperer/jetbrains-community/tst/software/aws/toolkits/jetbrains/services/codewhisperer/codescan/CodeWhispererCodeScanTest.kt
@@ -154,6 +154,34 @@ class CodeWhispererCodeScanTest : CodeWhispererCodeScanTestBase(PythonCodeInsigh
         assertThat(res).hasSize(1)
     }
 
+    @Test
+    fun `test getTelemetryErrorMessage should return the correct error message`() {
+        val exceptions = listOf(
+            Exception("Resource not found."),
+            Exception("Service returned HTTP status code 407"),
+            Exception("Service returned HTTP status code 403"),
+            Exception("invalid_grant: Invalid token provided"),
+            Exception("Connect timed out"),
+            Exception("Encountered an unexpected error when processing the request, please try again."),
+            Exception("Some other error message")
+        )
+
+        val expectedMessages = listOf(
+            "Resource not found.",
+            "Service returned HTTP status code 407",
+            "Service returned HTTP status code 403",
+            "invalid_grant: Invalid token provided",
+            "Unable to execute HTTP request: Connect timed out",
+            "Encountered an unexpected error when processing the request, please try again.",
+            "Some other error message"
+        )
+
+        exceptions.forEachIndexed { index, exception ->
+            val actualMessage = codeScanSessionSpy.getTelemetryErrorMessage(exception)
+            assertThat(expectedMessages[index]).isEqualTo(actualMessage)
+        }
+    }
+
     @Test
     fun `test run() - happypath`() {
         assertNotNull(sessionConfigSpy)
diff --git a/plugins/core/resources/resources/software/aws/toolkits/resources/MessagesBundle.properties b/plugins/core/resources/resources/software/aws/toolkits/resources/MessagesBundle.properties
@@ -763,7 +763,7 @@ codewhisperer.codescan.file_ext_not_supported=File extension {0} is not supporte
 codewhisperer.codescan.file_name_issues_count=<html><body> {0} <font color="{3}">  {1} {2, choice, 1#1 issue|2#{2,number} issues}</font></body></html>
 codewhisperer.codescan.file_not_found=For file path {0} with error message: {0}
 codewhisperer.codescan.file_too_large=Amazon Q: The selected file exceeds the input artifact limit. Try again with a smaller file. For more information about scan limits, see the Amazon Q documentation. 
-codewhisperer.codescan.file_too_large_telemetry=Payload size limit reached.
+codewhisperer.codescan.file_too_large_telemetry=Payload size limit reached
 codewhisperer.codescan.fix_applied_fail=Apply fix command failed. {0}
 codewhisperer.codescan.fix_available_label=Code fix available
 codewhisperer.codescan.fix_button_label=Fix with Q

-Original file line number
+Diff line change
@@ @@ -0,0 +1,4 @@ @@
 +{
 +  "type" : "bugfix",
 +  "description" : "Security Scan: Improved telemetry error messages"
 +}
Original file line number	Diff line number	Diff line change
`@@ -154,7 +154,7 @@ class CodeWhispererCodeScanSession(val sessionContext: CodeScanSessionContext) {`
`154`	`154`	`}`
`155`	`155`	`}`
`156`	`156`	`val errorMessage = createCodeScanResponse.errorMessage()?.let { it } ?: message("codewhisperer.codescan.run_scan_error_telemetry")`
`157`		`- codeScanFailed(errorMessage)`
	`157`	`+ codeScanFailed(errorMessage, "CreateCodeScanFailedError")`
`158`	`158`	`}`
`159`	`159`	`val jobId = createCodeScanResponse.jobId()`
`160`	`160`	`codeScanResponseContext = codeScanResponseContext.copy(codeScanJobId = jobId)`
`@@ -191,7 +191,7 @@ class CodeWhispererCodeScanSession(val sessionContext: CodeScanSessionContext) {`
`191`	`191`	`}`
`192`	`192`	`}`
`193`	`193`	`val errorMessage = getCodeScanResponse.errorMessage()?.let { it } ?: message("codewhisperer.codescan.run_scan_error_telemetry")`
`194`		`- codeScanFailed(errorMessage)`
	`194`	`+ codeScanFailed(errorMessage, "DefaultError")`
`195`	`195`	`}`
`196`	`196`	`}`
`197`	`197`
`@@ -286,13 +286,8 @@ class CodeWhispererCodeScanSession(val sessionContext: CodeScanSessionContext) {`
`286`	`286`	`)`
`287`	`287`	`} catch (e: Exception) {`
`288`	`288`	`LOG.debug { "Create Upload URL failed: ${e.message}" }`
`289`		`-`
`290`		`- val errorMessage = when {`
`291`		`- e.message?.contains("Your account is not authorized to make this call.") == true -> "Your account is not authorized to make this call."`
`292`		`- e.message?.contains("Service returned HTTP status code 407") == true -> "Service returned HTTP status code 407"`
`293`		`- else -> e.message ?: message("codewhisperer.codescan.run_scan_error_telemetry")`
`294`		`- }`
`295`		`- throw codeScanServerException("CreateUploadUrlException: $errorMessage")`
	`289`	`+ val errorMessage = getTelemetryErrorMessage(e)`
	`290`	`+ throw codeScanServerException(errorMessage, "CreateUploadUrlError")`
`296`	`291`	`}`
`297`	`292`
`298`	`293`	`private fun getUploadIntent(scope: CodeWhispererConstants.CodeAnalysisScope): UploadIntent = when (scope) {`
`@@ -325,7 +320,8 @@ class CodeWhispererCodeScanSession(val sessionContext: CodeScanSessionContext) {`
`325`	`320`	`}`
`326`	`321`	`} catch (e: Exception) {`
`327`	`322`	`LOG.debug { "Artifact failed to upload in the S3 bucket: ${e.message}" }`
`328`		`- throw codeScanServerException("UploadArtifactToS3Exception: " + e.message?.let { it } ?: message("codewhisperer.codescan.run_scan_error_telemetry"))`
	`323`	`+ val errorMessage = getTelemetryErrorMessage(e)`
	`324`	`+ throw codeScanServerException(errorMessage, "UploadArtifactToS3Error")`
`329`	`325`	`}`
`330`	`326`	`}`
`331`	`327`
`@@ -347,15 +343,8 @@ class CodeWhispererCodeScanSession(val sessionContext: CodeScanSessionContext) {`
`347`	`343`	`)`
`348`	`344`	`} catch (e: Exception) {`
`349`	`345`	`LOG.debug { "Creating security scan failed: ${e.message}" }`
`350`		`- val errorMessage = when {`
`351`		`- e.message?.contains("Too many requests, please wait before trying again.") == true -> "Too many requests, please wait before trying again."`
`352`		`- e.message?.contains("Improperly formed request.") == true -> "Improperly formed request."`
`353`		`- e.message?.contains("Service returned HTTP status code 407") == true -> "Service returned HTTP status code 407"`
`354`		`- e.message?.contains("Encountered an unexpected error when processing the request, please try again.") == true ->`
`355`		`- "Encountered an unexpected error when processing the request, please try again."`
`356`		`- else -> e.message ?: message("codewhisperer.codescan.run_scan_error_telemetry")`
`357`		`- }`
`358`		`- throw codeScanServerException("CreateCodeScanException: $errorMessage")`
	`346`	`+ val errorMessage = getTelemetryErrorMessage(e)`
	`347`	`+ throw codeScanServerException(errorMessage, "CreateCodeScanError")`
`359`	`348`	`}`
`360`	`349`	`}`
`361`	`350`
`@@ -367,7 +356,8 @@ class CodeWhispererCodeScanSession(val sessionContext: CodeScanSessionContext) {`
`367`	`356`	`)`
`368`	`357`	`} catch (e: Exception) {`
`369`	`358`	`LOG.debug { "Getting security scan failed: ${e.message}" }`
`370`		`- throw codeScanServerException("GetCodeScanException: " + e.message?.let { it } ?: message("codewhisperer.codescan.run_scan_error_telemetry"))`
	`359`	`+ val errorMessage = getTelemetryErrorMessage(e)`
	`360`	`+ throw codeScanServerException(errorMessage, "GetCodeScanError")`
`371`	`361`	`}`
`372`	`362`
`373`	`363`	`fun listCodeScanFindings(jobId: String, nextToken: String?): ListCodeScanFindingsResponse = try {`
`@@ -380,7 +370,8 @@ class CodeWhispererCodeScanSession(val sessionContext: CodeScanSessionContext) {`
`380`	`370`	`)`
`381`	`371`	`} catch (e: Exception) {`
`382`	`372`	`LOG.debug { "Listing security scan failed: ${e.message}" }`
`383`		`- throw codeScanServerException("ListCodeScanFindingsException: " + e.message?.let { it } ?: message("codewhisperer.codescan.run_scan_error_telemetry"))`
	`373`	`+ val errorMessage = getTelemetryErrorMessage(e)`
	`374`	`+ throw codeScanServerException(errorMessage, "ListCodeScanFindingsError")`
`384`	`375`	`}`
`385`	`376`
`386`	`377`	`fun mapToCodeScanIssues(recommendations: List<String>): List<CodeWhispererCodeScanIssue> {`
`@@ -441,6 +432,17 @@ class CodeWhispererCodeScanSession(val sessionContext: CodeScanSessionContext) {`
`441`	`432`	`sleep(CODE_SCAN_POLLING_INTERVAL_IN_SECONDS * TOTAL_MILLIS_IN_SECOND)`
`442`	`433`	`}`
`443`	`434`
	`435`	`+ fun getTelemetryErrorMessage(e: Exception): String = when {`
	`436`	`+ e.message?.contains("Resource not found.") == true -> "Resource not found."`
	`437`	`+ e.message?.contains("Service returned HTTP status code 407") == true -> "Service returned HTTP status code 407"`
	`438`	`+ e.message?.contains("Service returned HTTP status code 403") == true -> "Service returned HTTP status code 403"`
	`439`	`+ e.message?.contains("invalid_grant: Invalid token provided") == true -> "invalid_grant: Invalid token provided"`
	`440`	`+ e.message?.contains("Connect timed out") == true -> "Unable to execute HTTP request: Connect timed out" // Error: Connect to host failed`
	`441`	`+ e.message?.contains("Encountered an unexpected error when processing the request, please try again.") == true ->`
	`442`	`+ "Encountered an unexpected error when processing the request, please try again."`
	`443`	`+ else -> e.message ?: message("codewhisperer.codescan.run_scan_error_telemetry")`
	`444`	`+ }`
	`445`	`+`
`444`	`446`	`private fun isProjectScope(): Boolean = sessionContext.codeAnalysisScope == CodeWhispererConstants.CodeAnalysisScope.PROJECT`
`445`	`447`
`446`	`448`	`companion object {`
Original file line number	Diff line number	Diff line change
`@@ -155,7 +155,8 @@ data class CodeScanResponseContext(`
`155`	`155`	`val codeScanJobId: String? = null,`
`156`	`156`	`val codeScanTotalIssues: Int = 0,`
`157`	`157`	`val codeScanIssuesWithFixes: Int = 0,`
`158`		`- val reason: String? = null`
	`158`	`+ val reason: String? = null,`
	`159`	`+ val reasonDesc: String? = null`
`159`	`160`	`)`
`160`	`161`
`161`	`162`	`data class LatencyContext(`