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,58 @@
 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.amazonq.lsp.util.TelemetryParsingUtil
+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 {
+
+    private fun handleTelemetryMap(telemetryMap: Map<*, *>) {
+        try {
+            val name = telemetryMap["name"] as? String ?: return
+
+            @Suppress("UNCHECKED_CAST")
+            val data = telemetryMap["data"] as? Map<String, Any> ?: return
+
+            TelemetryService.getInstance().record(project) {
+                datum(name) {
+                    createTime(Instant.now())
+                    unit(TelemetryParsingUtil.parseMetricUnit(telemetryMap["unit"]))
+                    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 telemetryEvent(`object`: Any) {
-        println(`object`)
+        when (`object`) {
+            is Map<*, *> -> handleTelemetryMap(`object`)
+            else -> LOG.warn { "Unexpected telemetry event: $`object`" }
+        }
     }
 
     override fun publishDiagnostics(diagnostics: PublishDiagnosticsParams) {
@@ -92,4 +130,8 @@
             }
         )
     }
+
+    companion object {
+        private val LOG = getLogger<AmazonQLanguageClientImpl>()
+    }
 }

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

@@ -0,0 +1,17 @@
+// Copyright 2025 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+package software.aws.toolkits.jetbrains.services.amazonq.lsp.util
+
+import software.amazon.awssdk.services.toolkittelemetry.model.MetricUnit
+
+object TelemetryParsingUtil {
+
+    fun parseMetricUnit(value: Any?): MetricUnit {
+        return when (value) {
+            is String -> MetricUnit.fromValue(value) ?: MetricUnit.NONE
+            is MetricUnit -> value
+            else -> MetricUnit.NONE
+        }
+    }
+}

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

@@ -5,28 +5,296 @@
 package software.aws.toolkits.jetbrains.services.amazonq.lsp
 
 import com.google.gson.Gson
+import com.google.gson.GsonBuilder
+import com.google.gson.ToNumberPolicy
 import com.intellij.openapi.components.service
 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 "Bytes",
+            "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.BYTES)
+        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 `test GSON deserialization behavior for telemetryEvent`() {
+        val gson = GsonBuilder()
+            .setObjectToNumberStrategy(ToNumberPolicy.LONG_OR_DOUBLE)
+            .create()
+
+        val jsonString = """
+        {
+            "name": "test_event",
+            "value": 3.0,
+            "passive": true,
+            "unit": "Milliseconds",
+            "data": {
+                "key1": "value1"
+            }
+        }
+        """.trimIndent()
+
+        val result = gson.fromJson(jsonString, Map::class.java)
+
+        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
+
+        sut.telemetryEvent(result)
+
+        val builder = DefaultMetricEvent.builder()
+        builderCaptor.captured.invoke(builder)
+
+        val metricEvent = builder.build()
+        val datum = metricEvent.data.first()
+
+        assertThat(datum.passive).isTrue()
+        assertThat(datum.unit).isEqualTo(MetricUnit.MILLISECONDS)
+        assertThat(datum.value).isEqualTo(3.0)
+        assertThat(datum.metadata).contains(entry("key1", "value1"))
+    }
+
     @Test
     fun `getConnectionMetadata returns connection metadata with start URL for bearer token connection`() {
         val mockConnectionManager = mockk<ToolkitConnectionManager>()