Amazon Q Code Transform: Failure Build Log (#4570)

Author: tincheng

.changes/next-release/feature-33667a31-ebc2-4f65-a42e-927b3cab4357.json

@@ -0,0 +1,4 @@
+{
+  "type" : "feature",
+  "description" : "Amazon Q Code Transform: Allow user to view transformation build log"
+}

plugins/amazonq/codetransform/jetbrains-community/src/software/aws/toolkits/jetbrains/services/codemodernizer/ArtifactHandler.kt

@@ -16,6 +16,7 @@ import com.intellij.openapi.vfs.LocalFileSystem
 import com.intellij.openapi.vfs.VirtualFile
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.withContext
+import software.amazon.awssdk.services.codewhispererstreaming.model.TransformationDownloadArtifactType
 import software.aws.toolkits.core.utils.error
 import software.aws.toolkits.core.utils.exists
 import software.aws.toolkits.core.utils.getLogger
@@ -26,6 +27,8 @@ import software.aws.toolkits.jetbrains.services.amazonq.CODE_TRANSFORM_TROUBLESH
 import software.aws.toolkits.jetbrains.services.codemodernizer.client.GumbyClient
 import software.aws.toolkits.jetbrains.services.codemodernizer.commands.CodeTransformMessageListener
 import software.aws.toolkits.jetbrains.services.codemodernizer.model.CodeModernizerArtifact
+import software.aws.toolkits.jetbrains.services.codemodernizer.model.CodeTransformDownloadArtifact
+import software.aws.toolkits.jetbrains.services.codemodernizer.model.CodeTransformFailureBuildLog
 import software.aws.toolkits.jetbrains.services.codemodernizer.model.CodeTransformHilDownloadArtifact
 import software.aws.toolkits.jetbrains.services.codemodernizer.model.DownloadFailureReason
 import software.aws.toolkits.jetbrains.services.codemodernizer.model.JobId
@@ -40,36 +43,31 @@ import java.nio.file.Path
 import java.time.Instant
 import java.util.concurrent.atomic.AtomicBoolean
 
-data class DownloadArtifactResult(val artifact: CodeModernizerArtifact?, val zipPath: String, val errorMessage: String = "")
+data class DownloadArtifactResult(val artifact: CodeTransformDownloadArtifact?, val zipPath: String, val errorMessage: String = "")
 
 const val DOWNLOAD_PROXY_WILDCARD_ERROR: String = "Dangling meta character '*' near index 0"
 const val DOWNLOAD_SSL_HANDSHAKE_ERROR: String = "Unable to execute HTTP request: javax.net.ssl.SSLHandshakeException"
+const val INVALID_ARTIFACT_ERROR: String = "Invalid artifact"
 
 class ArtifactHandler(private val project: Project, private val clientAdaptor: GumbyClient) {
     private val telemetry = CodeTransformTelemetryManager.getInstance(project)
     private val downloadedArtifacts = mutableMapOf<JobId, Path>()
     private val downloadedSummaries = mutableMapOf<JobId, TransformationSummary>()
-
+    private val downloadedBuildLogPath = mutableMapOf<JobId, Path>()
     private var isCurrentlyDownloading = AtomicBoolean(false)
+
     internal suspend fun displayDiff(job: JobId) {
         if (isCurrentlyDownloading.get()) return
-        val result = downloadArtifact(job)
+        val result = downloadArtifact(job, TransformationDownloadArtifactType.CLIENT_INSTRUCTIONS)
         if (result.artifact == null) {
             notifyUnableToApplyPatch(result.zipPath, result.errorMessage)
         } else {
+            result.artifact as CodeModernizerArtifact
             displayDiffUsingPatch(result.artifact.patch, job)
         }
     }
 
-    private fun notifyDownloadStart() {
-        notifyStickyInfo(
-            message("codemodernizer.notification.info.download.started.title"),
-            message("codemodernizer.notification.info.download.started.content"),
-            project,
-        )
-    }
-
-    private suspend fun unzipToPath(byteArrayList: List<ByteArray>, outputDirPath: Path? = null): Pair<Path, Int> {
+    suspend fun unzipToPath(byteArrayList: List<ByteArray>, outputDirPath: Path? = null): Pair<Path, Int> {
         val zipFilePath = withContext(getCoroutineBgContext()) {
             if (outputDirPath == null) {
                 Files.createTempFile(null, ".zip")
@@ -106,28 +104,47 @@ class ArtifactHandler(private val project: Project, private val clientAdaptor: G
         }
     }
 
-    suspend fun downloadArtifact(job: JobId): DownloadArtifactResult {
+    suspend fun downloadArtifact(
+        job: JobId,
+        artifactType: TransformationDownloadArtifactType,
+        isPreFetch: Boolean = false
+    ): DownloadArtifactResult {
         isCurrentlyDownloading.set(true)
         val downloadStartTime = Instant.now()
         try {
             // 1. Attempt reusing previously downloaded artifact for job
-            val previousArtifact = downloadedArtifacts.getOrDefault(job, null)
+            val previousArtifact = if (artifactType == TransformationDownloadArtifactType.LOGS) {
+                downloadedBuildLogPath.getOrDefault(job, null)
+            } else {
+                downloadedArtifacts.getOrDefault(job, null)
+            }
             if (previousArtifact != null && previousArtifact.exists()) {
                 val zipPath = previousArtifact.toAbsolutePath().toString()
                 return try {
-                    val artifact = CodeModernizerArtifact.create(zipPath)
-                    downloadedSummaries[job] = artifact.summary
-                    DownloadArtifactResult(artifact, zipPath)
+                    if (artifactType == TransformationDownloadArtifactType.LOGS) {
+                        DownloadArtifactResult(CodeTransformFailureBuildLog.create(zipPath), zipPath)
+                    } else {
+                        val artifact = CodeModernizerArtifact.create(zipPath)
+                        downloadedSummaries[job] = artifact.summary
+                        DownloadArtifactResult(artifact, zipPath)
+                    }
                 } catch (e: RuntimeException) {
                     LOG.error { e.message.toString() }
                     DownloadArtifactResult(null, zipPath, e.message.orEmpty())
                 }
             }
 
             // 2. Download the data
-            notifyDownloadStart()
             LOG.info { "About to download the export result archive" }
-            val downloadResultsResponse = clientAdaptor.downloadExportResultArchive(job)
+            // only notify if downloading client instructions (upgraded code)
+            if (artifactType == TransformationDownloadArtifactType.CLIENT_INSTRUCTIONS) {
+                notifyDownloadStart()
+            }
+            val downloadResultsResponse = if (artifactType == TransformationDownloadArtifactType.LOGS) {
+                clientAdaptor.downloadExportResultArchive(job, null, TransformationDownloadArtifactType.LOGS)
+            } else {
+                clientAdaptor.downloadExportResultArchive(job)
+            }
 
             // 3. Convert to zip
             LOG.info { "Downloaded the export result archive, about to transform to zip" }
@@ -136,17 +153,26 @@ class ArtifactHandler(private val project: Project, private val clientAdaptor: G
             val zipPath = path.toAbsolutePath().toString()
             LOG.info { "Successfully converted the download to a zip at $zipPath." }
 
-            // 4. Deserialize zip to CodeModernizerArtifact
+            // 4. Deserialize zip
             var telemetryErrorMessage: String? = null
             return try {
-                val output = DownloadArtifactResult(CodeModernizerArtifact.create(zipPath), zipPath)
-                downloadedArtifacts[job] = path
+                val output = if (artifactType == TransformationDownloadArtifactType.LOGS) {
+                    DownloadArtifactResult(CodeTransformFailureBuildLog.create(zipPath), zipPath)
+                } else {
+                    DownloadArtifactResult(CodeModernizerArtifact.create(zipPath), zipPath)
+                }
+                if (artifactType == TransformationDownloadArtifactType.LOGS) {
+                    downloadedBuildLogPath[job] = path
+                } else {
+                    downloadedArtifacts[job] = path
+                }
                 output
             } catch (e: RuntimeException) {
                 LOG.error { e.message.toString() }
                 telemetryErrorMessage = "Unexpected error when downloading result ${e.localizedMessage}"
                 DownloadArtifactResult(null, zipPath, e.message.orEmpty())
             } finally {
+                // TODO: add artifact type to telemetry to differentiate downloads for client instructions vs logs
                 telemetry.jobArtifactDownloadAndDeserializeTime(
                     downloadStartTime,
                     job,
@@ -157,14 +183,19 @@ class ArtifactHandler(private val project: Project, private val clientAdaptor: G
         } catch (e: Exception) {
             var errorMessage: String = e.message.orEmpty()
             // SdkClientException will be thrown, masking actual issues like SSLHandshakeException underneath
-            if (e.message.toString().contains(DOWNLOAD_PROXY_WILDCARD_ERROR)) {
-                errorMessage = message("codemodernizer.notification.warn.download_failed_wildcard.content")
-                CodeTransformMessageListener.instance.onDownloadFailure(DownloadFailureReason.PROXY_WILDCARD_ERROR)
-            } else if (e.message.toString().contains(DOWNLOAD_SSL_HANDSHAKE_ERROR)) {
-                errorMessage = message("codemodernizer.notification.warn.download_failed_ssl.content")
-                CodeTransformMessageListener.instance.onDownloadFailure(DownloadFailureReason.SSL_HANDSHAKE_ERROR)
-            } else {
-                CodeTransformMessageListener.instance.onDownloadFailure(DownloadFailureReason.OTHER(e.message.toString()))
+            // TODO: remove this check once we are no longer pre-fetching for build log, as the check will no longer be needed
+            if (!isPreFetch) {
+                if (e.message.toString().contains(DOWNLOAD_PROXY_WILDCARD_ERROR)) {
+                    errorMessage = message("codemodernizer.notification.warn.download_failed_wildcard.content")
+                    CodeTransformMessageListener.instance.onDownloadFailure(DownloadFailureReason.PROXY_WILDCARD_ERROR(artifactType))
+                } else if (e.message.toString().contains(DOWNLOAD_SSL_HANDSHAKE_ERROR)) {
+                    errorMessage = message("codemodernizer.notification.warn.download_failed_ssl.content")
+                    CodeTransformMessageListener.instance.onDownloadFailure(DownloadFailureReason.SSL_HANDSHAKE_ERROR(artifactType))
+                } else if (e.message.toString().contains(INVALID_ARTIFACT_ERROR)) {
+                    CodeTransformMessageListener.instance.onDownloadFailure(DownloadFailureReason.INVALID_ARTIFACT(artifactType))
+                } else {
+                    CodeTransformMessageListener.instance.onDownloadFailure(DownloadFailureReason.OTHER(artifactType, e.message.toString()))
+                }
             }
             return DownloadArtifactResult(null, "", errorMessage)
         } finally {
@@ -202,6 +233,14 @@ class ArtifactHandler(private val project: Project, private val clientAdaptor: G
         }
     }
 
+    private fun notifyDownloadStart() {
+        notifyStickyInfo(
+            message("codemodernizer.notification.info.download.started.title"),
+            message("codemodernizer.notification.info.download.started.content"),
+            project,
+        )
+    }
+
     fun notifyUnableToApplyPatch(patchPath: String, errorMessage: String) {
         LOG.error { "Unable to find patch for file: $patchPath" }
         notifyStickyWarn(
@@ -230,6 +269,20 @@ class ArtifactHandler(private val project: Project, private val clientAdaptor: G
         )
     }
 
+    fun notifyUnableToShowBuildLog() {
+        LOG.error { "Unable to display build log" }
+        notifyStickyWarn(
+            message("codemodernizer.notification.warn.view_build_log_failed.title"),
+            message("codemodernizer.notification.warn.view_build_log_failed.content"),
+            project,
+            listOf(
+                openTroubleshootingGuideNotificationAction(
+                    CODE_TRANSFORM_TROUBLESHOOT_DOC_ARTIFACT
+                )
+            ),
+        )
+    }
+
     fun displayDiffAction(jobId: JobId) = runReadAction {
         telemetry.vcsViewerClicked(jobId)
         projectCoroutineScope(project).launch {
@@ -243,8 +296,9 @@ class ArtifactHandler(private val project: Project, private val clientAdaptor: G
         if (isCurrentlyDownloading.get()) return
         runReadAction {
             projectCoroutineScope(project).launch {
-                val result = downloadArtifact(job)
-                val summary = result.artifact?.summaryMarkdownFile ?: return@launch notifyUnableToShowSummary()
+                val result = downloadArtifact(job, TransformationDownloadArtifactType.CLIENT_INSTRUCTIONS)
+                val artifact = result.artifact as? CodeModernizerArtifact ?: return@launch notifyUnableToShowSummary()
+                val summary = artifact.summaryMarkdownFile
                 val summaryMarkdownVirtualFile = LocalFileSystem.getInstance().refreshAndFindFileByIoFile(summary)
                 if (summaryMarkdownVirtualFile != null) {
                     runInEdt {
@@ -255,6 +309,23 @@ class ArtifactHandler(private val project: Project, private val clientAdaptor: G
         }
     }
 
+    fun showBuildLog(job: JobId) {
+        if (isCurrentlyDownloading.get()) return
+        runReadAction {
+            projectCoroutineScope(project).launch {
+                val result = downloadArtifact(job, TransformationDownloadArtifactType.LOGS)
+                val artifact = result.artifact as? CodeTransformFailureBuildLog ?: return@launch notifyUnableToShowBuildLog()
+                val buildLog = artifact.logFile
+                val buildLogVirtualFile = LocalFileSystem.getInstance().refreshAndFindFileByIoFile(buildLog)
+                if (buildLogVirtualFile != null) {
+                    runInEdt {
+                        FileEditorManager.getInstance(project).openFile(buildLogVirtualFile, true)
+                    }
+                }
+            }
+        }
+    }
+
     companion object {
         val LOG = getLogger<ArtifactHandler>()
     }

plugins/amazonq/codetransform/jetbrains-community/src/software/aws/toolkits/jetbrains/services/codemodernizer/CodeModernizerSession.kt

@@ -18,6 +18,7 @@ import software.amazon.awssdk.services.codewhispererruntime.model.Transformation
 import software.amazon.awssdk.services.codewhispererruntime.model.TransformationProgressUpdateStatus
 import software.amazon.awssdk.services.codewhispererruntime.model.TransformationStatus
 import software.amazon.awssdk.services.codewhispererruntime.model.TransformationUserActionStatus
+import software.amazon.awssdk.services.codewhispererstreaming.model.TransformationDownloadArtifactType
 import software.aws.toolkits.core.utils.error
 import software.aws.toolkits.core.utils.exists
 import software.aws.toolkits.core.utils.getLogger
@@ -78,6 +79,7 @@ class CodeModernizerSession(
     private val isDisposed = AtomicBoolean(false)
     private val shouldStop = AtomicBoolean(false)
     private val telemetry = CodeTransformTelemetryManager.getInstance(sessionContext.project)
+    private val artifactHandler = ArtifactHandler(sessionContext.project, GumbyClient.getInstance(sessionContext.project))
 
     private var mvnBuildResult: MavenCopyCommandsResult? = null
     private var transformResult: CodeModernizerJobCompletedResult? = null
@@ -481,8 +483,16 @@ class CodeModernizerSession(
                         val failureReason = result.jobDetails?.reason() ?: message("codemodernizer.notification.warn.unknown_start_failure")
                         return CodeModernizerJobCompletedResult.JobFailed(jobId, failureReason)
                     } else if (!passedBuild) {
-                        val failureReason = result.jobDetails?.reason() ?: message("codemodernizer.notification.warn.maven_failed.content")
-                        return CodeModernizerJobCompletedResult.JobFailedInitialBuild(jobId, failureReason)
+                        // This is a short term solution to check if build log is available by attempting to download it.
+                        // In the long term, we should check if build log is available from transformation metadata.
+                        val downloadArtifactResult = artifactHandler.downloadArtifact(jobId, TransformationDownloadArtifactType.LOGS, true)
+                        if (downloadArtifactResult.artifact != null) {
+                            val failureReason = result.jobDetails?.reason() ?: message("codemodernizer.notification.warn.maven_failed.content")
+                            return CodeModernizerJobCompletedResult.JobFailedInitialBuild(jobId, failureReason, true)
+                        } else {
+                            val failureReason = result.jobDetails?.reason() ?: message("codemodernizer.notification.warn.maven_failed.content")
+                            return CodeModernizerJobCompletedResult.JobFailedInitialBuild(jobId, failureReason, false)
+                        }
                     } else {
                         val failureReason = result.jobDetails?.reason() ?: message("codemodernizer.notification.warn.unknown_status_response")
                         return CodeModernizerJobCompletedResult.JobFailed(jobId, failureReason)

plugins/amazonq/codetransform/jetbrains-community/src/software/aws/toolkits/jetbrains/services/codemodernizer/CodeTransformChatApp.kt

@@ -36,6 +36,7 @@ private enum class CodeTransformMessageTypes(val type: String) {
     CodeTransformOpenMvnBuild("codetransform-open-mvn-build"),
     ViewDiff("codetransform-view-diff"),
     ViewSummary("codetransform-view-summary"),
+    ViewBuildLog("codetransform-view-build-log"),
     AuthFollowUpWasClicked("auth-follow-up-was-clicked"),
     BodyLinkClicked("response-body-link-click"),
     ConfirmHilSelection("codetransform-confirm-hil-selection"),
@@ -64,6 +65,7 @@ class CodeTransformChatApp : AmazonQApp {
             CodeTransformMessageTypes.CodeTransformOpenMvnBuild.type to IncomingCodeTransformMessage.CodeTransformOpenMvnBuild::class,
             CodeTransformMessageTypes.ViewDiff.type to IncomingCodeTransformMessage.CodeTransformViewDiff::class,
             CodeTransformMessageTypes.ViewSummary.type to IncomingCodeTransformMessage.CodeTransformViewSummary::class,
+            CodeTransformMessageTypes.ViewBuildLog.type to IncomingCodeTransformMessage.CodeTransformViewBuildLog::class,
             CodeTransformMessageTypes.AuthFollowUpWasClicked.type to IncomingCodeTransformMessage.AuthFollowUpWasClicked::class,
             CodeTransformMessageTypes.BodyLinkClicked.type to IncomingCodeTransformMessage.BodyLinkClicked::class,
             CodeTransformMessageTypes.ConfirmHilSelection.type to IncomingCodeTransformMessage.ConfirmHilSelection::class,
@@ -132,6 +134,7 @@ class CodeTransformChatApp : AmazonQApp {
             is IncomingCodeTransformMessage.CodeTransformOpenMvnBuild -> inboundAppMessagesHandler.processCodeTransformOpenMvnBuild(message)
             is IncomingCodeTransformMessage.CodeTransformViewDiff -> inboundAppMessagesHandler.processCodeTransformViewDiff(message)
             is IncomingCodeTransformMessage.CodeTransformViewSummary -> inboundAppMessagesHandler.processCodeTransformViewSummary(message)
+            is IncomingCodeTransformMessage.CodeTransformViewBuildLog -> inboundAppMessagesHandler.processCodeTransformViewBuildLog(message)
             is IncomingCodeTransformMessage.TabCreated -> inboundAppMessagesHandler.processTabCreated(message)
             is IncomingCodeTransformMessage.TabRemoved -> inboundAppMessagesHandler.processTabRemoved(message)
             is IncomingCodeTransformMessage.AuthFollowUpWasClicked -> inboundAppMessagesHandler.processAuthFollowUpClick(message)

plugins/amazonq/codetransform/jetbrains-community/src/software/aws/toolkits/jetbrains/services/codemodernizer/InboundAppMessagesHandler.kt

@@ -23,6 +23,8 @@ interface InboundAppMessagesHandler {
 
     suspend fun processCodeTransformViewSummary(message: IncomingCodeTransformMessage.CodeTransformViewSummary)
 
+    suspend fun processCodeTransformViewBuildLog(message: IncomingCodeTransformMessage.CodeTransformViewBuildLog)
+
     suspend fun processCodeTransformNewAction(message: IncomingCodeTransformMessage.CodeTransformNew)
 
     suspend fun processCodeTransformCommand(message: CodeTransformActionMessage)