Merge branch 'main' into auto-trigger-review

Author: andrewyuq

plugins/amazonq/chat/jetbrains-community/src/software/aws/toolkits/jetbrains/services/cwc/controller/ChatController.kt

@@ -36,6 +36,7 @@ import software.aws.toolkits.core.utils.getLogger
 import software.aws.toolkits.core.utils.info
 import software.aws.toolkits.core.utils.warn
 import software.aws.toolkits.jetbrains.core.coroutines.EDT
+import software.aws.toolkits.jetbrains.services.amazonq.CHAT_IMPLICIT_PROJECT_CONTEXT_TIMEOUT
 import software.aws.toolkits.jetbrains.services.amazonq.CodeWhispererFeatureConfigService
 import software.aws.toolkits.jetbrains.services.amazonq.apps.AmazonQAppInitContext
 import software.aws.toolkits.jetbrains.services.amazonq.auth.AuthController
@@ -137,15 +138,15 @@ class ChatController private constructor(
                 shouldUseWorkspaceContext = true
                 prompt = prompt.replace("@workspace", "")
                 val projectContextController = ProjectContextController.getInstance(context.project)
-                queryResult = projectContextController.query(prompt)
+                queryResult = projectContextController.query(prompt, timeout = null)
                 if (!projectContextController.getProjectContextIndexComplete()) shouldAddIndexInProgressMessage = true
                 logger.info { "project context relevant document count: ${queryResult.size}" }
             } else {
                 sendOpenSettingsMessage(message.tabId)
             }
         } else if (CodeWhispererSettings.getInstance().isProjectContextEnabled() && isDataCollectionGroup) {
             val projectContextController = ProjectContextController.getInstance(context.project)
-            queryResult = projectContextController.query(prompt)
+            queryResult = projectContextController.query(prompt, timeout = CHAT_IMPLICIT_PROJECT_CONTEXT_TIMEOUT)
         }
 
         handleChat(

plugins/amazonq/chat/jetbrains-community/src/software/aws/toolkits/jetbrains/services/cwc/inline/OpenChatInputAction.kt

@@ -3,15 +3,20 @@
 
 package software.aws.toolkits.jetbrains.services.cwc.inline
 
-import com.intellij.execution.impl.ConsoleViewImpl
 import com.intellij.openapi.actionSystem.AnAction
 import com.intellij.openapi.actionSystem.AnActionEvent
 import com.intellij.openapi.actionSystem.CommonDataKeys
+import com.intellij.openapi.util.Key
 
 class OpenChatInputAction : AnAction() {
     override fun actionPerformed(e: AnActionEvent) {
         val editor = e.getData(CommonDataKeys.EDITOR) ?: return
-        val isConsole = editor.document.getUserData(ConsoleViewImpl.IS_CONSOLE_DOCUMENT)
+        // FIX_WHEN_MIN_IS_241: change below to use ConsoleViewImpl.IS_CONSOLE_DOCUMENT
+        var isConsole: Any? = null
+        val key: Key<*>? = Key.findKeyByName("IS_CONSOLE_DOCUMENT")
+        if (key != null) {
+            isConsole = editor.document.getUserData(key)
+        }
         if (isConsole == true) return
         if (!editor.document.isWritable) return
         val project = editor.project ?: return

plugins/amazonq/chat/jetbrains-community/tst/software/aws/toolkits/jetbrains/services/amazonq/workspace/context/ProjectContextProviderTest.kt

@@ -214,8 +214,10 @@ class ProjectContextProviderTest {
     }
 
     @Test
-    fun `query should send correct encrypted request to lsp`() {
-        sut.query("foo")
+    fun `query should send correct encrypted request to lsp`() = runTest {
+        sut = ProjectContextProvider(project, encoderServer, this)
+        val r = sut.query("foo", null)
+        advanceUntilIdle()
 
         val request = QueryChatRequest("foo")
         val requestJson = mapper.writeValueAsString(request)
@@ -269,13 +271,15 @@ class ProjectContextProviderTest {
         )
 
         assertThrows<Exception> {
-            sut.query("foo")
+            sut.query("foo", null)
         }
     }
 
     @Test
     fun `query chat should return deserialized relevantDocument`() = runTest {
-        val r = sut.query("foo")
+        sut = ProjectContextProvider(project, encoderServer, this)
+        val r = sut.query("foo", null)
+        advanceUntilIdle()
         assertThat(r).hasSize(2)
         assertThat(r[0]).isEqualTo(
             RelevantDocument(
@@ -377,6 +381,29 @@ class ProjectContextProviderTest {
         }
     }
 
+    @Test
+    fun `queryChat should throw if time elapsed is greather than 500ms`() = runTest {
+        assertThrows<TimeoutCancellationException> {
+            sut = ProjectContextProvider(project, encoderServer, this)
+            stubFor(
+                any(urlPathEqualTo("/query")).willReturn(
+                    aResponse()
+                        .withStatus(200)
+                        .withResponseBody(
+                            Body(validQueryChatResponse)
+                        )
+                        .withFixedDelay(501)
+                )
+            )
+
+            withContext(getCoroutineBgContext()) {
+                sut.query("foo", timeout = 500L)
+            }
+
+            advanceUntilIdle()
+        }
+    }
+
     @Test
     fun `test index payload is encrypted`() = runTest {
         whenever(encoderServer.port).thenReturn(3000)
@@ -390,12 +417,9 @@ class ProjectContextProviderTest {
 
     @Test
     fun `test query payload is encrypted`() = runTest {
-        whenever(encoderServer.port).thenReturn(3000)
-        try {
-            sut.query("what does this project do")
-        } catch (e: ConnectException) {
-            // no-op
-        }
+        sut = ProjectContextProvider(project, encoderServer, this)
+        sut.query("what does this project do", null)
+        advanceUntilIdle()
         verify(encoderServer, times(1)).encrypt(any())
     }
 

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

@@ -39,6 +39,7 @@ import software.aws.toolkits.jetbrains.services.codemodernizer.model.DownloadFai
 import software.aws.toolkits.jetbrains.services.codemodernizer.model.JobId
 import software.aws.toolkits.jetbrains.services.codemodernizer.model.ParseZipFailureReason
 import software.aws.toolkits.jetbrains.services.codemodernizer.model.UnzipFailureReason
+import software.aws.toolkits.jetbrains.services.codemodernizer.state.CodeModernizerSessionState
 import software.aws.toolkits.jetbrains.services.codemodernizer.utils.getPathToHilArtifactDir
 import software.aws.toolkits.jetbrains.services.codemodernizer.utils.isValidCodeTransformConnection
 import software.aws.toolkits.jetbrains.services.codemodernizer.utils.openTroubleshootingGuideNotificationAction
@@ -199,6 +200,17 @@ class ArtifactHandler(private val project: Project, private val clientAdaptor: G
                     downloadedBuildLogPath[job] = path
                 } else {
                     downloadedArtifacts[job] = path
+                    if (output.artifact is CodeModernizerArtifact && output.artifact.metrics != null) {
+                        output.artifact.metrics.linesOfCodeSubmitted = CodeModernizerSessionState.getInstance(project).getLinesOfCodeSubmitted()
+                        output.artifact.metrics.programmingLanguage = CodeModernizerSessionState.getInstance(project).getTransformationLanguage()
+                        try {
+                            clientAdaptor.sendTransformTelemetryEvent(job, output.artifact.metrics)
+                        } catch (e: Exception) {
+                            // log error, but can still show diff.patch and summary.md
+                            LOG.error { e.message.toString() }
+                            telemetryErrorMessage = "Unexpected error when sending telemetry with metrics ${e.localizedMessage}"
+                        }
+                    }
                 }
                 output
             } catch (e: RuntimeException) {

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

@@ -16,6 +16,7 @@ import software.amazon.awssdk.services.codewhispererruntime.model.GetTransformat
 import software.amazon.awssdk.services.codewhispererruntime.model.GetTransformationPlanResponse
 import software.amazon.awssdk.services.codewhispererruntime.model.GetTransformationRequest
 import software.amazon.awssdk.services.codewhispererruntime.model.GetTransformationResponse
+import software.amazon.awssdk.services.codewhispererruntime.model.IdeCategory
 import software.amazon.awssdk.services.codewhispererruntime.model.ResumeTransformationRequest
 import software.amazon.awssdk.services.codewhispererruntime.model.ResumeTransformationResponse
 import software.amazon.awssdk.services.codewhispererruntime.model.StartTransformationRequest
@@ -46,8 +47,11 @@ import software.aws.toolkits.jetbrains.services.amazonq.CONTENT_SHA256
 import software.aws.toolkits.jetbrains.services.amazonq.SERVER_SIDE_ENCRYPTION
 import software.aws.toolkits.jetbrains.services.amazonq.SERVER_SIDE_ENCRYPTION_AWS_KMS_KEY_ID
 import software.aws.toolkits.jetbrains.services.amazonq.clients.AmazonQStreamingClient
+import software.aws.toolkits.jetbrains.services.amazonq.codeWhispererUserContext
+import software.aws.toolkits.jetbrains.services.codemodernizer.model.CodeModernizerMetrics
 import software.aws.toolkits.jetbrains.services.codemodernizer.model.JobId
 import software.aws.toolkits.jetbrains.services.codemodernizer.utils.calculateTotalLatency
+import software.aws.toolkits.jetbrains.services.codewhisperer.util.CodeWhispererUtil.getTelemetryOptOutPreference
 import java.io.File
 import java.net.HttpURLConnection
 import java.time.Instant
@@ -210,6 +214,26 @@ class GumbyClient(private val project: Project) {
             }
     }
 
+    fun sendTransformTelemetryEvent(job: JobId, metrics: CodeModernizerMetrics) {
+        bearerClient().sendTelemetryEvent { requestBuilder ->
+            requestBuilder.telemetryEvent { telemetryEventBuilder ->
+                telemetryEventBuilder.transformEvent {
+                    it.jobId(job.id)
+                    it.timestamp(Instant.now())
+                    it.ideCategory(IdeCategory.JETBRAINS)
+                    it.programmingLanguage { language ->
+                        language.languageName(metrics.programmingLanguage)
+                    }
+                    it.linesOfCodeChanged(metrics.linesOfCodeChanged)
+                    it.charsOfCodeChanged(metrics.charactersOfCodeChanged)
+                    it.linesOfCodeSubmitted(metrics.linesOfCodeSubmitted) // currently unavailable for SQL conversions
+                }
+            }
+            requestBuilder.optOutPreference(getTelemetryOptOutPreference())
+            requestBuilder.userContext(codeWhispererUserContext())
+        }
+    }
+
     companion object {
         private val LOG = getLogger<GumbyClient>()
 

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

@@ -5,6 +5,7 @@ package software.aws.toolkits.jetbrains.services.codemodernizer.model
 
 import com.fasterxml.jackson.core.JsonProcessingException
 import com.fasterxml.jackson.module.kotlin.jacksonObjectMapper
+import com.fasterxml.jackson.module.kotlin.readValue
 import com.intellij.openapi.util.io.FileUtil.createTempDirectory
 import com.intellij.openapi.vfs.LocalFileSystem
 import com.intellij.openapi.vfs.VirtualFile
@@ -29,17 +30,19 @@ open class CodeModernizerArtifact(
     private val patches: List<VirtualFile>,
     val summary: TransformationSummary,
     val summaryMarkdownFile: File,
+    val metrics: CodeModernizerMetrics?,
 ) : CodeTransformDownloadArtifact {
     val patch: VirtualFile
         get() = patches.first()
 
     companion object {
-        private const val maxSupportedVersion = 1.0
+        private const val MAX_SUPPORTED_VERSION = 1.0
         private val tempDir = createTempDirectory("codeTransformArtifacts", null)
-        private const val manifestPathInZip = "manifest.json"
-        private const val summaryNameInZip = "summary.md"
+        private const val MANIFEST_FILE_NAME = "manifest.json"
+        private const val SUMMARY_FILE_NAME = "summary.md"
+        private const val METRICS_FILE_NAME = "metrics.json"
         val LOG = getLogger<CodeModernizerArtifact>()
-        private val MAPPER = jacksonObjectMapper()
+        val MAPPER = jacksonObjectMapper()
 
         /**
          * Extracts the file at [zipPath] and uses its contents to produce a [CodeModernizerArtifact].
@@ -53,39 +56,40 @@ open class CodeModernizerArtifact(
                     throw RuntimeException("Could not unzip artifact")
                 }
                 val manifest = loadManifest()
-                if (manifest.version > maxSupportedVersion) {
+                if (manifest.version > MAX_SUPPORTED_VERSION) {
                     // If not supported we can still try to use it, i.e. the versions should largely be backwards compatible
-                    LOG.warn { "Unsupported version: ${manifest.version}" }
+                    LOG.warn { "Unsupported manifest.json version: ${manifest.version}" }
                 }
                 val patches = extractPatches(manifest)
                 val summary = extractSummary(manifest)
                 val summaryMarkdownFile = getSummaryFile(manifest)
+                val metrics = loadMetrics(manifest)
                 if (patches.size != 1) throw RuntimeException("Expected 1 patch, but found ${patches.size}")
-                return CodeModernizerArtifact(zipPath, manifest, patches, summary, summaryMarkdownFile)
+                return CodeModernizerArtifact(zipPath, manifest, patches, summary, summaryMarkdownFile, metrics)
             }
             throw RuntimeException("Could not find artifact")
         }
 
         private fun extractSummary(manifest: CodeModernizerManifest): TransformationSummary {
-            val summaryFile = tempDir.toPath().resolve(manifest.summaryRoot).resolve(summaryNameInZip).toFile()
+            val summaryFile = tempDir.toPath().resolve(manifest.summaryRoot).resolve(SUMMARY_FILE_NAME).toFile()
             if (!summaryFile.exists() || summaryFile.isDirectory) {
                 throw RuntimeException("The summary in the downloaded zip had an unknown format")
             }
             return TransformationSummary(summaryFile.readText())
         }
 
-        private fun getSummaryFile(manifest: CodeModernizerManifest) = tempDir.toPath().resolve(manifest.summaryRoot).resolve(summaryNameInZip).toFile()
+        private fun getSummaryFile(manifest: CodeModernizerManifest) = tempDir.toPath().resolve(manifest.summaryRoot).resolve(SUMMARY_FILE_NAME).toFile()
 
         /**
          * Attempts to load the manifest from the zip file. Throws an exception if the manifest is not found or cannot be serialized.
          */
         private fun loadManifest(): CodeModernizerManifest {
             val manifestFile =
                 tempDir.listFiles()
-                    ?.firstOrNull { it.name.endsWith(manifestPathInZip) }
+                    ?.firstOrNull { it.name.endsWith(MANIFEST_FILE_NAME) }
                     ?: throw RuntimeException("Could not find manifest")
             try {
-                val manifest = MAPPER.readValue(manifestFile, CodeModernizerManifest::class.java)
+                val manifest = MAPPER.readValue<CodeModernizerManifest>(manifestFile)
                 if (manifest.version == 0.0F) {
                     throw RuntimeException(
                         "Unable to deserialize the manifest",
@@ -97,6 +101,19 @@ open class CodeModernizerArtifact(
             }
         }
 
+        private fun loadMetrics(manifest: CodeModernizerManifest): CodeModernizerMetrics? {
+            try {
+                val metricsFile =
+                    tempDir.resolve(manifest.metricsRoot).listFiles()
+                        ?.firstOrNull { it.name.endsWith(METRICS_FILE_NAME) }
+                        ?: throw RuntimeException("Could not find metrics.json")
+                return MAPPER.readValue<CodeModernizerMetrics>(metricsFile)
+            } catch (exception: Exception) {
+                // if metrics.json not present or parsing fails, can still show diff.patch and summary.md
+                return null
+            }
+        }
+
         @OptIn(ExperimentalPathApi::class)
         private fun extractPatches(manifest: CodeModernizerManifest): List<VirtualFile> {
             val fileSystem = LocalFileSystem.getInstance()

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

@@ -6,4 +6,4 @@ package software.aws.toolkits.jetbrains.services.codemodernizer.model
 import com.fasterxml.jackson.annotation.JsonIgnoreProperties
 
 @JsonIgnoreProperties(ignoreUnknown = true)
-data class CodeModernizerManifest(val version: Float, val patchesRoot: String, val artifactsRoot: String, val summaryRoot: String)
+data class CodeModernizerManifest(val version: Float, val patchesRoot: String, val artifactsRoot: String, val summaryRoot: String, val metricsRoot: String)

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

@@ -0,0 +1,14 @@
+// Copyright 2023 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+package software.aws.toolkits.jetbrains.services.codemodernizer.model
+
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties
+
+@JsonIgnoreProperties(ignoreUnknown = true)
+data class CodeModernizerMetrics(
+    val linesOfCodeChanged: Int?,
+    val charactersOfCodeChanged: Int?,
+    var linesOfCodeSubmitted: Int?,
+    var programmingLanguage: String?,
+)