feat(amazonq): LSP telemetry/event messages trigger client side telemetry service calls

plugins/amazonq/shared/jetbrains-community/src/software/aws/toolkits/jetbrains/services/amazonq/lsp/AmazonQLanguageClientImpl.kt

@@ -11,20 +11,55 @@
 import org.eclipse.lsp4j.MessageType
 import org.eclipse.lsp4j.PublishDiagnosticsParams
 import org.eclipse.lsp4j.ShowMessageRequestParams
+import software.amazon.awssdk.services.toolkittelemetry.model.MetricUnit
+import software.aws.toolkits.core.utils.getLogger
+import software.aws.toolkits.core.utils.warn
 import software.aws.toolkits.jetbrains.core.credentials.AwsBearerTokenConnection
 import software.aws.toolkits.jetbrains.core.credentials.ToolkitConnectionManager
 import software.aws.toolkits.jetbrains.core.credentials.pinning.QConnection
 import software.aws.toolkits.jetbrains.services.amazonq.lsp.model.aws.credentials.ConnectionMetadata
 import software.aws.toolkits.jetbrains.services.amazonq.lsp.model.aws.credentials.SsoProfileData
+import software.aws.toolkits.jetbrains.services.telemetry.TelemetryService
 import software.aws.toolkits.jetbrains.settings.CodeWhispererSettings
+import java.time.Instant
 import java.util.concurrent.CompletableFuture
 
 /**
  * Concrete implementation of [AmazonQLanguageClient] to handle messages sent from server
  */
 class AmazonQLanguageClientImpl(private val project: Project) : AmazonQLanguageClient {
     override fun telemetryEvent(`object`: Any) {
-        println(`object`)
+        when (`object`) {
+            is MutableMap<*, *> -> handleTelemetryMap(`object`)
+        }
+    }
+
+    private fun handleTelemetryMap(telemetryMap: MutableMap<*, *>) {
+        try {
+            val name = telemetryMap["name"] as? String ?: return
+
+            @Suppress("UNCHECKED_CAST")
+            val data = telemetryMap["data"] as? MutableMap<String, Any> ?: return
+
+            TelemetryService.getInstance().record(project) {
+                datum(name) {
+                    createTime(Instant.now())
+                    unit(telemetryMap["unit"] as? MetricUnit ?: MetricUnit.NONE)
+                    value(telemetryMap["value"] as? Double ?: 1.0)
+                    passive(telemetryMap["passive"] as? Boolean ?: false)
+
+                    telemetryMap["result"]?.let { result ->
+                        metadata("result", result.toString())
+                    }
+
+                    data.forEach { (key, value) ->
+                        metadata(key, value.toString())
+                    }
+                }
+            }
+        } catch (e: Exception) {
+            LOG.warn(e) { "Failed to process telemetry event: $telemetryMap" }
+        }
     }
 
     override fun publishDiagnostics(diagnostics: PublishDiagnosticsParams) {
@@ -92,4 +127,8 @@
             }
         )
     }
+
+    companion object {
+        private val LOG = getLogger<AmazonQLanguageClientImpl>()
+    }
 }

plugins/amazonq/shared/jetbrains-community/tst/software/aws/toolkits/jetbrains/services/amazonq/lsp/AmazonQLanguageClientImplTest.kt

@@ -10,23 +10,248 @@ import com.intellij.openapi.project.Project
 import com.intellij.testFramework.ApplicationExtension
 import io.mockk.every
 import io.mockk.mockk
+import io.mockk.mockkObject
+import io.mockk.slot
+import io.mockk.verify
 import org.assertj.core.api.Assertions.assertThat
+import org.assertj.core.api.Assertions.entry
 import org.eclipse.lsp4j.ConfigurationItem
 import org.eclipse.lsp4j.ConfigurationParams
 import org.junit.jupiter.api.Test
 import org.junit.jupiter.api.extension.ExtendWith
+import software.amazon.awssdk.services.toolkittelemetry.model.MetricUnit
+import software.aws.toolkits.core.telemetry.DefaultMetricEvent
+import software.aws.toolkits.core.telemetry.MetricEvent
 import software.aws.toolkits.jetbrains.core.credentials.AwsBearerTokenConnection
 import software.aws.toolkits.jetbrains.core.credentials.ToolkitConnectionManager
 import software.aws.toolkits.jetbrains.core.credentials.pinning.QConnection
 import software.aws.toolkits.jetbrains.services.amazonq.lsp.model.aws.credentials.ConnectionMetadata
 import software.aws.toolkits.jetbrains.services.amazonq.lsp.model.aws.credentials.SsoProfileData
+import software.aws.toolkits.jetbrains.services.telemetry.TelemetryService
 import software.aws.toolkits.jetbrains.settings.CodeWhispererSettings
 
 @ExtendWith(ApplicationExtension::class)
 class AmazonQLanguageClientImplTest {
     private val project: Project = mockk(relaxed = true)
     private val sut = AmazonQLanguageClientImpl(project)
 
+    @Test
+    fun `telemetryEvent handles basic event with name and data`() {
+        val telemetryService = mockk<TelemetryService>(relaxed = true)
+        mockkObject(TelemetryService)
+        every { TelemetryService.getInstance() } returns telemetryService
+
+        val builderCaptor = slot<MetricEvent.Builder.() -> Unit>()
+        every { telemetryService.record(project, capture(builderCaptor)) } returns Unit
+
+        val event = mapOf(
+            "name" to "test_event",
+            "data" to mapOf(
+                "key1" to "value1",
+                "key2" to 42
+            )
+        )
+
+        sut.telemetryEvent(event)
+
+        val builder = DefaultMetricEvent.builder()
+        builderCaptor.captured.invoke(builder)
+
+        val metricEvent = builder.build()
+        val datum = metricEvent.data.first()
+
+        assertThat(datum.name).isEqualTo("test_event")
+        assertThat(datum.metadata).contains(
+            entry("key1", "value1"),
+            entry("key2", "42")
+        )
+    }
+
+    @Test
+    fun `telemetryEvent handles event with result field`() {
+        val telemetryService = mockk<TelemetryService>(relaxed = true)
+        mockkObject(TelemetryService)
+        every { TelemetryService.getInstance() } returns telemetryService
+
+        val builderCaptor = slot<MetricEvent.Builder.() -> Unit>()
+        every { telemetryService.record(project, capture(builderCaptor)) } returns Unit
+
+        val event = mapOf(
+            "name" to "test_event",
+            "result" to "success",
+            "data" to mapOf(
+                "key1" to "value1"
+            )
+        )
+
+        sut.telemetryEvent(event)
+
+        val builder = DefaultMetricEvent.builder()
+        builderCaptor.captured.invoke(builder)
+
+        val metricEvent = builder.build()
+        val datum = metricEvent.data.first()
+
+        assertThat(datum.name).isEqualTo("test_event")
+        assertThat(datum.metadata).contains(
+            entry("key1", "value1"),
+            entry("result", "success")
+        )
+    }
+
+    @Test
+    fun `telemetryEvent uses custom unit value when provided`() {
+        val telemetryService = mockk<TelemetryService>(relaxed = true)
+        mockkObject(TelemetryService)
+        every { TelemetryService.getInstance() } returns telemetryService
+
+        val builderCaptor = slot<MetricEvent.Builder.() -> Unit>()
+        every { telemetryService.record(project, capture(builderCaptor)) } returns Unit
+
+        val event = mapOf(
+            "name" to "test_event",
+            "unit" to MetricUnit.MILLISECONDS,
+            "data" to mapOf(
+                "key1" to "value1"
+            )
+        )
+
+        sut.telemetryEvent(event)
+
+        val builder = DefaultMetricEvent.builder()
+        builderCaptor.captured.invoke(builder)
+
+        val metricEvent = builder.build()
+        val datum = metricEvent.data.first()
+
+        assertThat(datum.unit).isEqualTo(MetricUnit.MILLISECONDS)
+        assertThat(datum.metadata).contains(entry("key1", "value1"))
+    }
+
+    @Test
+    fun `telemetryEvent uses custom value when provided`() {
+        val telemetryService = mockk<TelemetryService>(relaxed = true)
+        mockkObject(TelemetryService)
+        every { TelemetryService.getInstance() } returns telemetryService
+
+        val builderCaptor = slot<MetricEvent.Builder.() -> Unit>()
+        every { telemetryService.record(project, capture(builderCaptor)) } returns Unit
+
+        val event = mapOf(
+            "name" to "test_event",
+            "value" to 2.5,
+            "data" to mapOf(
+                "key1" to "value1"
+            )
+        )
+
+        sut.telemetryEvent(event)
+
+        val builder = DefaultMetricEvent.builder()
+        builderCaptor.captured.invoke(builder)
+
+        val metricEvent = builder.build()
+        val datum = metricEvent.data.first()
+
+        assertThat(datum.value).isEqualTo(2.5)
+        assertThat(datum.metadata).contains(entry("key1", "value1"))
+    }
+
+    @Test
+    fun `telemetryEvent uses custom passive value when provided`() {
+        val telemetryService = mockk<TelemetryService>(relaxed = true)
+        mockkObject(TelemetryService)
+        every { TelemetryService.getInstance() } returns telemetryService
+
+        val builderCaptor = slot<MetricEvent.Builder.() -> Unit>()
+        every { telemetryService.record(project, capture(builderCaptor)) } returns Unit
+
+        val event = mapOf(
+            "name" to "test_event",
+            "passive" to true,
+            "data" to mapOf(
+                "key1" to "value1"
+            )
+        )
+
+        sut.telemetryEvent(event)
+
+        val builder = DefaultMetricEvent.builder()
+        builderCaptor.captured.invoke(builder)
+
+        val metricEvent = builder.build()
+        val datum = metricEvent.data.first()
+
+        assertThat(datum.passive).isTrue()
+        assertThat(datum.metadata).contains(entry("key1", "value1"))
+    }
+
+    @Test
+    fun `telemetryEvent ignores event without name`() {
+        val telemetryService = mockk<TelemetryService>(relaxed = true)
+        mockkObject(TelemetryService)
+        every { TelemetryService.getInstance() } returns telemetryService
+
+        val event = mapOf(
+            "data" to mapOf(
+                "key1" to "value1"
+            )
+        )
+
+        sut.telemetryEvent(event)
+
+        verify(exactly = 0) {
+            telemetryService.record(project, any())
+        }
+    }
+
+    @Test
+    fun `telemetryEvent ignores event without data`() {
+        val telemetryService = mockk<TelemetryService>(relaxed = true)
+        mockkObject(TelemetryService)
+        every { TelemetryService.getInstance() } returns telemetryService
+
+        val event = mapOf(
+            "name" to "test_event"
+        )
+
+        sut.telemetryEvent(event)
+
+        verify(exactly = 0) {
+            telemetryService.record(project, any())
+        }
+    }
+
+    @Test
+    fun `telemetryEvent uses default values when not provided`() {
+        val telemetryService = mockk<TelemetryService>(relaxed = true)
+        mockkObject(TelemetryService)
+        every { TelemetryService.getInstance() } returns telemetryService
+
+        val builderCaptor = slot<MetricEvent.Builder.() -> Unit>()
+        every { telemetryService.record(project, capture(builderCaptor)) } returns Unit
+
+        val event = mapOf(
+            "name" to "test_event",
+            "data" to mapOf(
+                "key1" to "value1"
+            )
+        )
+
+        sut.telemetryEvent(event)
+
+        val builder = DefaultMetricEvent.builder()
+        builderCaptor.captured.invoke(builder)
+
+        val metricEvent = builder.build()
+        val datum = metricEvent.data.first()
+
+        assertThat(datum.unit).isEqualTo(MetricUnit.NONE)
+        assertThat(datum.value).isEqualTo(1.0)
+        assertThat(datum.passive).isFalse()
+        assertThat(datum.metadata).contains(entry("key1", "value1"))
+    }
+
     @Test
     fun `getConnectionMetadata returns connection metadata with start URL for bearer token connection`() {
         val mockConnectionManager = mockk<ToolkitConnectionManager>()