Add the type of credentials to validate and setCredentials (#2128)

Author: abrooksv

core/src/software/aws/toolkits/core/credentials/ToolkitCredentialsProvider.kt

@@ -5,6 +5,15 @@ package software.aws.toolkits.core.credentials
 
 import software.amazon.awssdk.auth.credentials.AwsCredentialsProvider
 
+enum class CredentialType {
+    StaticProfile,
+    StaticSessionProfile,
+    CredentialProcessProfile,
+    AssumeRoleProfile,
+    AssumeMfaRoleProfile,
+    SsoProfile
+}
+
 /**
  * Represents a possible credential provider that can be used within the toolkit.
  *
@@ -33,13 +42,18 @@ interface CredentialIdentifier {
      */
     val factoryId: String
 
+    /**
+     * The type of credential
+     */
+    val credentialType: CredentialType?
+
     /**
      * Some ID types (e.g. Profile) have a concept of a default region, this is optional.
      */
     val defaultRegionId: String? get() = null
 }
 
-abstract class CredentialIdentifierBase : CredentialIdentifier {
+abstract class CredentialIdentifierBase(override val credentialType: CredentialType?) : CredentialIdentifier {
     final override fun equals(other: Any?): Boolean {
         if (this === other) return true
         if (javaClass != other?.javaClass) return false

core/tst/software/aws/toolkits/core/credentials/Mocks.kt

@@ -17,7 +17,7 @@ fun aCredentialsIdentifier(
     displayName: String = aString(),
     factoryId: String = aString(),
     defaultRegionId: String? = null
-) = object : CredentialIdentifierBase() {
+) = object : CredentialIdentifierBase(CredentialType.StaticProfile) {
     override val id: String = id
     override val displayName: String = displayName
     override val factoryId: String = factoryId

gradle.properties

@@ -16,7 +16,7 @@ coroutinesVersion=1.3.3
 ideaPluginVersion=0.4.20
 ktlintVersion=0.38.1
 jacksonVersion=2.9.8
-telemetryVersion=0.0.59
+telemetryVersion=0.0.70
 
 assertjVersion=3.15.0
 junitVersion=4.12

jetbrains-core/src/software/aws/toolkits/jetbrains/core/credentials/AwsConnectionManager.kt

@@ -172,7 +172,11 @@ abstract class AwsConnectionManager(private val project: Project) : SimpleModifi
                 LOGGER.warn(e) { message("credentials.profile.validation_error", credentialsIdentifier.displayName) }
             } finally {
                 incModificationCount()
-                AwsTelemetry.validateCredentials(project, success = isValidConnectionSettings())
+                AwsTelemetry.validateCredentials(
+                    project,
+                    success = isValidConnectionSettings(),
+                    credentialType = credentialsIdentifier.credentialType.toTelemetryType()
+                )
                 validationJob = null
             }
         }

jetbrains-core/src/software/aws/toolkits/jetbrains/core/credentials/ChangeConnectionSettingsMenu.kt

@@ -184,6 +184,9 @@ internal class ChangeCredentialsAction(private val credentialsProvider: Credenti
     override fun setSelected(e: AnActionEvent, state: Boolean) {
         if (state) {
             getAccountSetting(e).changeCredentialProvider(credentialsProvider)
+
+            // Set credentials is not considered passive, so only send it when they are actively changed
+            AwsTelemetry.setCredentials(e.project, credentialsProvider.credentialType.toTelemetryType())
         }
     }
 }

jetbrains-core/src/software/aws/toolkits/jetbrains/core/credentials/CredentialTypeUtil.kt

@@ -0,0 +1,17 @@
+// Copyright 2020 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+package software.aws.toolkits.jetbrains.core.credentials
+
+import software.aws.toolkits.core.credentials.CredentialType
+import software.aws.toolkits.telemetry.CredentialType as TelemetryCredentialType
+
+fun CredentialType?.toTelemetryType(): TelemetryCredentialType = when (this) {
+    CredentialType.StaticProfile -> TelemetryCredentialType.StaticProfile
+    CredentialType.StaticSessionProfile -> TelemetryCredentialType.StaticSessionProfile
+    CredentialType.CredentialProcessProfile -> TelemetryCredentialType.CredentialProcessProfile
+    CredentialType.AssumeRoleProfile -> TelemetryCredentialType.AssumeRoleProfile
+    CredentialType.AssumeMfaRoleProfile -> TelemetryCredentialType.AssumeMfaRoleProfile
+    CredentialType.SsoProfile -> TelemetryCredentialType.SsoProfile
+    null -> TelemetryCredentialType.Other
+}

jetbrains-core/src/software/aws/toolkits/jetbrains/core/credentials/profiles/ProfileCredentialProviderFactory.kt

@@ -22,6 +22,7 @@ import software.aws.toolkits.core.ToolkitClientManager
 import software.aws.toolkits.core.credentials.CredentialIdentifier
 import software.aws.toolkits.core.credentials.CredentialIdentifierBase
 import software.aws.toolkits.core.credentials.CredentialProviderFactory
+import software.aws.toolkits.core.credentials.CredentialType
 import software.aws.toolkits.core.credentials.CredentialsChangeEvent
 import software.aws.toolkits.core.credentials.CredentialsChangeListener
 import software.aws.toolkits.core.credentials.sso.SSO_ACCOUNT
@@ -51,22 +52,24 @@ const val DEFAULT_PROFILE_ID = "profile:default"
 
 private const val PROFILE_FACTORY_ID = "ProfileCredentialProviderFactory"
 
-private open class ProfileCredentialsIdentifier(val profileName: String, override val defaultRegionId: String?) : CredentialIdentifierBase() {
+private open class ProfileCredentialsIdentifier(val profileName: String, override val defaultRegionId: String?, credentialType: CredentialType?) :
+    CredentialIdentifierBase(credentialType) {
     override val id = "profile:$profileName"
     override val displayName = message("credentials.profile.name", profileName)
     override val factoryId = PROFILE_FACTORY_ID
     override val shortName: String = profileName
 }
 
-private class ProfileCredentialsIdentifierMfa(profileName: String, defaultRegionId: String?) :
-    ProfileCredentialsIdentifier(profileName, defaultRegionId), MfaRequiredInteractiveCredentials
+private class ProfileCredentialsIdentifierMfa(profileName: String, defaultRegionId: String?, credentialType: CredentialType?) :
+    ProfileCredentialsIdentifier(profileName, defaultRegionId, credentialType), MfaRequiredInteractiveCredentials
 
 private class ProfileCredentialsIdentifierSso(
     profileName: String,
     defaultRegionId: String?,
     override val ssoCache: SsoCache,
-    override val ssoUrl: String
-) : ProfileCredentialsIdentifier(profileName, defaultRegionId),
+    override val ssoUrl: String,
+    credentialType: CredentialType?
+) : ProfileCredentialsIdentifier(profileName, defaultRegionId, credentialType),
     SsoRequiredInteractiveCredentials
 
 class ProfileCredentialProviderFactory : CredentialProviderFactory {
@@ -317,16 +320,18 @@ class ProfileCredentialProviderFactory : CredentialProviderFactory {
     private fun Profile.asId(profiles: Map<String, Profile>): ProfileCredentialsIdentifier {
         val name = this.name()
         val defaultRegion = this.properties()[ProfileProperty.REGION]
+        val requestedProfileType = this.toCredentialType()
 
         return when {
-            this.requiresMfa(profiles) -> ProfileCredentialsIdentifierMfa(name, defaultRegion)
+            this.requiresMfa(profiles) -> ProfileCredentialsIdentifierMfa(name, defaultRegion, requestedProfileType)
             this.requiresSso(profiles) -> ProfileCredentialsIdentifierSso(
                 name,
                 defaultRegion,
                 diskCache,
-                this.requiredProperty(SSO_URL)
+                this.requiredProperty(SSO_URL),
+                requestedProfileType
             )
-            else -> ProfileCredentialsIdentifier(name, defaultRegion)
+            else -> ProfileCredentialsIdentifier(name, defaultRegion, requestedProfileType)
         }
     }
 
@@ -337,6 +342,20 @@ class ProfileCredentialProviderFactory : CredentialProviderFactory {
         .any { it.propertyExists(SSO_URL) }
 }
 
+private fun Profile.toCredentialType(): CredentialType? = when {
+    this.propertyExists(SSO_URL) -> CredentialType.SsoProfile
+    this.propertyExists(ProfileProperty.ROLE_ARN) -> {
+        if (this.propertyExists(ProfileProperty.MFA_SERIAL))
+            CredentialType.AssumeMfaRoleProfile
+        else
+            CredentialType.AssumeRoleProfile
+    }
+    this.propertyExists(ProfileProperty.AWS_SESSION_TOKEN) -> CredentialType.StaticSessionProfile
+    this.propertyExists(ProfileProperty.AWS_ACCESS_KEY_ID) -> CredentialType.StaticProfile
+    this.propertyExists(ProfileProperty.CREDENTIAL_PROCESS) -> CredentialType.CredentialProcessProfile
+    else -> null
+}
+
 private class ProfileHolder {
     private val profiles = mutableMapOf<String, Profile>()
 

jetbrains-core/src/software/aws/toolkits/jetbrains/services/cloudformation/stack/Stack.kt

@@ -42,7 +42,7 @@ class StackWindowManager(private val project: Project) {
     fun openStack(stackName: String, stackId: String) {
         assert(SwingUtilities.isEventDispatchThread())
         toolWindow.find(stackId)?.run { show() } ?: StackUI(project, stackName, stackId, toolWindow).start()
-        CloudformationTelemetry.open(project)
+        CloudformationTelemetry.open(project, success = true)
     }
 
     companion object {

jetbrains-core/tst/software/aws/toolkits/jetbrains/core/credentials/CredentialManagerTest.kt

@@ -277,7 +277,7 @@ class CredentialManagerTest {
         override val factoryId: String,
         override val defaultRegionId: String,
         val credentialsEchoField: String? = null
-    ) : CredentialIdentifierBase() {
+    ) : CredentialIdentifierBase(null) {
         override val displayName: String = "$factoryId:$id"
     }
 }

jetbrains-core/tst/software/aws/toolkits/jetbrains/core/credentials/MockCredentialsManager.kt

@@ -70,7 +70,7 @@ class MockCredentialsManager : CredentialManager() {
     }
 
     class MockCredentialIdentifier(override val displayName: String, val credentials: AwsCredentialsProvider, override val defaultRegionId: String?) :
-        CredentialIdentifierBase() {
+        CredentialIdentifierBase(null) {
         override val id: String = displayName
         override val factoryId: String = "mockCredentialProviderFactory"
     }