Emit metric event on telemetry opt-in/opt-out (#4622)

Author: breedloj

plugins/core/core/src/software/aws/toolkits/core/telemetry/TelemetryBatcher.kt

@@ -19,7 +19,7 @@ interface TelemetryBatcher {
 
     fun flush(retry: Boolean)
 
-    fun onTelemetryEnabledChanged(isEnabled: Boolean)
+    fun onTelemetryEnabledChanged(isEnabled: Boolean, onChangeEvent: (Boolean) -> Unit = {})
 
     fun shutdown()
 }
@@ -111,11 +111,19 @@ class DefaultTelemetryBatcher(
         }
     }
 
-    override fun onTelemetryEnabledChanged(isEnabled: Boolean) {
-        isTelemetryEnabled.set(isEnabled)
-        if (!isEnabled) {
+    override fun onTelemetryEnabledChanged(isEnabled: Boolean, onChangeEvent: (Boolean) -> Unit) {
+        if (isEnabled) {
+            isTelemetryEnabled.set(true)
+        } else {
             eventQueue.clear()
         }
+
+        onChangeEvent(isEnabled)
+        flush(isEnabled)
+
+        if (!isEnabled) {
+            isTelemetryEnabled.set(false)
+        }
     }
 
     companion object {

plugins/core/core/tst/software/aws/toolkits/core/telemetry/TelemetryBatcherTest.kt

@@ -13,10 +13,12 @@ import org.mockito.kotlin.doThrow
 import org.mockito.kotlin.mock
 import org.mockito.kotlin.stub
 import org.mockito.kotlin.times
+import org.mockito.kotlin.verify
 import org.mockito.kotlin.verifyBlocking
 import org.mockito.kotlin.verifyNoMoreInteractions
 import org.mockito.stubbing.Answer
 import software.amazon.awssdk.core.exception.SdkServiceException
+import java.time.Instant
 import java.util.concurrent.CountDownLatch
 import java.util.concurrent.TimeUnit
 
@@ -144,6 +146,45 @@ class TelemetryBatcherTest {
         assertThat(batcher.eventQueue).isEmpty()
     }
 
+    @Test
+    fun verifyEnablementCallbackTrue() {
+        val mockCallback: (Boolean) -> Unit = mock()
+
+        batcher.onTelemetryEnabledChanged(true, mockCallback)
+        verify(mockCallback, times(1)).invoke(true)
+    }
+
+    @Test
+    fun verifyEnablementCallbackFalse() {
+        val mockCallback: (Boolean) -> Unit = mock()
+
+        batcher.onTelemetryEnabledChanged(false, mockCallback)
+        verify(mockCallback, times(1)).invoke(false)
+    }
+
+    @Test
+    fun verifyCallbackMetricPublished() {
+        batcher.enqueue(createEmptyMetricEvent())
+        val publishCountDown = CountDownLatch(1)
+        val publishCaptor = argumentCaptor<Collection<MetricEvent>>()
+
+        publisher.stub {
+            onBlocking { publisher.publish(publishCaptor.capture()) }
+                .doAnswer(createPublishAnswer(publishCountDown))
+        }
+
+        val fooMetricEvent = DefaultMetricEvent.builder()
+            .createTime(Instant.now())
+            .build()
+        batcher.onTelemetryEnabledChanged(false) { batcher.enqueue(createEmptyMetricEvent()) }
+        waitForPublish(publishCountDown)
+
+        verifyBlocking(publisher) { publish(anyCollection()) }
+
+        assertThat(publishCaptor.firstValue).hasSize(1)
+        assertThat(publishCaptor.firstValue.contains(fooMetricEvent))
+    }
+
     private fun createEmptyMetricEvent(): MetricEvent = DefaultMetricEvent.builder().build()
 
     private fun waitForPublish(publishCountDown: CountDownLatch) {

plugins/core/jetbrains-community/src/migration/software/aws/toolkits/jetbrains/services/telemetry/TelemetryService.kt

@@ -71,8 +71,8 @@ abstract class TelemetryService(private val publisher: TelemetryPublisher, priva
     private fun ConnectionSettings.activeAwsAccountIfKnown(): String? = tryOrNull { this.getResourceIfPresent(StsResources.ACCOUNT) }
 
     @Synchronized
-    fun setTelemetryEnabled(isEnabled: Boolean) {
-        batcher.onTelemetryEnabledChanged(isEnabled and TELEMETRY_ENABLED)
+    fun setTelemetryEnabled(isEnabled: Boolean, onChangeEvent: (Boolean) -> Unit = {}) {
+        batcher.onTelemetryEnabledChanged(isEnabled and TELEMETRY_ENABLED, onChangeEvent)
     }
 
     fun addListener(listener: TelemetryListener) {

plugins/core/jetbrains-community/src/software/aws/toolkits/jetbrains/settings/AwsSettings.kt

@@ -7,9 +7,11 @@ import com.intellij.openapi.application.ApplicationManager
 import com.intellij.openapi.components.PersistentStateComponent
 import com.intellij.openapi.components.State
 import com.intellij.openapi.components.Storage
+import com.intellij.openapi.project.Project
 import software.aws.toolkits.jetbrains.services.telemetry.TelemetryService
 import software.aws.toolkits.resources.message
 import software.aws.toolkits.telemetry.AwsTelemetry
+import software.aws.toolkits.telemetry.UiTelemetry
 import java.util.UUID
 import java.util.prefs.Preferences
 
@@ -46,7 +48,10 @@ class DefaultAwsSettings : PersistentStateComponent<AwsConfiguration>, AwsSettin
         get() = state.isTelemetryEnabled ?: true
         set(value) {
             state.isTelemetryEnabled = value
-            TelemetryService.getInstance().setTelemetryEnabled(value)
+            val enablementElement = if (value) "aws_enabledTelemetry" else "aws_disabledTelemetry"
+            TelemetryService.getInstance().setTelemetryEnabled(value) {
+                UiTelemetry.click(null as Project?, enablementElement)
+            }
         }
 
     override var promptedForTelemetry: Boolean

plugins/core/jetbrains-community/tst/software/aws/toolkits/jetbrains/services/telemetry/TelemetryServiceTest.kt

@@ -79,9 +79,10 @@ class TelemetryServiceTest {
 
         val changeCountDown = CountDownLatch(1)
         val changeCaptor = argumentCaptor<Boolean>()
+        val onChangeEventCaptor = argumentCaptor<(Boolean) -> Unit>()
 
         val batcher = mock<TelemetryBatcher> {
-            on { onTelemetryEnabledChanged(changeCaptor.capture()) }
+            on { onTelemetryEnabledChanged(changeCaptor.capture(), onChangeEventCaptor.capture()) }
                 .doAnswer {
                     changeCountDown.countDown()
                 }
@@ -90,7 +91,8 @@ class TelemetryServiceTest {
         TestTelemetryService(batcher = batcher)
 
         changeCountDown.await(5, TimeUnit.SECONDS)
-        verify(batcher).onTelemetryEnabledChanged(true)
+        assertThat(onChangeEventCaptor.allValues).hasSize(1)
+        verify(batcher).onTelemetryEnabledChanged(true, onChangeEventCaptor.firstValue)
         assertThat(changeCaptor.allValues).hasSize(1)
         assertThat(changeCaptor.firstValue).isEqualTo(true)
     }
@@ -101,24 +103,33 @@ class TelemetryServiceTest {
 
         val changeCountDown = CountDownLatch(3)
         val changeCaptor = argumentCaptor<Boolean>()
+        val onChangeEventCaptor = argumentCaptor<(Boolean) -> Unit>()
 
         val batcher = mock<TelemetryBatcher>()
 
         batcher.stub {
-            on(batcher.onTelemetryEnabledChanged(changeCaptor.capture()))
+            on(batcher.onTelemetryEnabledChanged(changeCaptor.capture(), onChangeEventCaptor.capture()))
                 .doAnswer {
                     changeCountDown.countDown()
                 }
         }
 
+        val dummyEnabledEvent: (Boolean) -> Unit = {
+            assertThat(it).isTrue()
+        }
+        val dummyDisabledEvent: (Boolean) -> Unit = {
+            assertThat(it).isFalse()
+        }
         val telemetryService = TestTelemetryService(batcher = batcher)
 
-        telemetryService.setTelemetryEnabled(false)
-        telemetryService.setTelemetryEnabled(true)
+        telemetryService.setTelemetryEnabled(false, dummyDisabledEvent)
+        telemetryService.setTelemetryEnabled(true, dummyEnabledEvent)
 
         changeCountDown.await(5, TimeUnit.SECONDS)
-        verify(batcher, times(2)).onTelemetryEnabledChanged(true)
-        verify(batcher).onTelemetryEnabledChanged(false)
+        assertThat(onChangeEventCaptor.allValues).hasSize(3)
+        verify(batcher).onTelemetryEnabledChanged(true, onChangeEventCaptor.firstValue)
+        verify(batcher).onTelemetryEnabledChanged(true, dummyEnabledEvent)
+        verify(batcher).onTelemetryEnabledChanged(false, dummyDisabledEvent)
         assertThat(changeCaptor.allValues).hasSize(3)
         assertThat(changeCaptor.firstValue).isEqualTo(true)
         assertThat(changeCaptor.secondValue).isEqualTo(false)