telemetry(amazonq): emit TransformEvent metric from download ZIP

Author: David Hasani

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

@@ -70,6 +70,7 @@ class ArtifactHandler(private val project: Project, private val clientAdaptor: G
             is DownloadArtifactResult.Success -> {
                 if (result.artifact !is CodeModernizerArtifact) return notifyUnableToApplyPatch("")
                 displayDiffUsingPatch(result.artifact.patch, job, source)
+                clientAdaptor.sendTransformTelemetryEvent(job, result.artifact.metrics)
             }
             is DownloadArtifactResult.ParseZipFailure -> notifyUnableToApplyPatch(result.failureReason.errorMessage)
             is DownloadArtifactResult.UnzipFailure -> notifyUnableToApplyPatch(result.failureReason.errorMessage)

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("JAVA") // TODO: figure out when/how to make this SQL
+                    }
+                    it.linesOfCodeChanged(metrics.linesOfCodeChanged)
+                    it.charsOfCodeChanged(metrics.charsOfCodeChanged)
+                    it.linesOfCodeSubmitted(0) // TODO: figure out how to get lines of code submitted from plan stage
+                }
+            }
+            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

@@ -29,15 +29,17 @@ 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()
 
@@ -53,36 +55,37 @@ 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}" }
                 }
                 val patches = extractPatches(manifest)
                 val summary = extractSummary(manifest)
                 val summaryMarkdownFile = getSummaryFile(manifest)
+                val metrics = loadMetrics()
                 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)
@@ -97,6 +100,17 @@ open class CodeModernizerArtifact(
             }
         }
 
+        private fun loadMetrics(): CodeModernizerMetrics {
+            try {
+                val metricsFile =
+                    tempDir.listFiles()
+                        ?.firstOrNull { it.name.endsWith(METRICS_FILE_NAME) }
+                return MAPPER.readValue(metricsFile, CodeModernizerMetrics::class.java)
+            } catch (exception: JsonProcessingException) {
+                throw RuntimeException("Unable to deserialize the metrics.json file")
+            }
+        }
+
         @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,9 @@
+// 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 charsOfCodeChanged: Int)

plugins/amazonq/codewhisperer/jetbrains-community/src/software/aws/toolkits/jetbrains/services/codewhisperer/credentials/CodeWhispererClientAdaptor.kt

@@ -630,7 +630,8 @@ open class CodeWhispererClientAdaptorImpl(override val project: Project) : CodeW
                 it.numSuggestionAddLines(numSuggestionAddLines)
                 it.numSuggestionDelChars(numSuggestionDelChars)
                 it.numSuggestionDelLines(numSuggestionDelLines)
-                if (programmingLanguage != null) it.programmingLanguage { langBuilder -> langBuilder.languageName(programmingLanguage) }
+                // TODO: looks like programmingLanguage was removed from InlineChatEvent in service-2.json?
+                // if (programmingLanguage != null) it.programmingLanguage { langBuilder -> langBuilder.languageName(programmingLanguage) }
                 it.timestamp(Instant.now())
             }
         }