Tweak otelbase classes slightly to meet requirements from generator (#5027)

* Depends on #4982
* Depends on aws/aws-toolkit-common#899
* Rename Unit -> MetricUnit directly in SDK codegen
* Use newer provider convention syntax for input/output in generator task
* expose `passive`/`unit`/`value` as special fields
* add smoke test for `validateRequiredAttributes`

Author: rli

gradle/libs.versions.toml

@@ -27,7 +27,7 @@ mockitoKotlin = "5.4.0"
 mockk = "1.13.10"
 nimbus-jose-jwt = "9.40"
 node-gradle = "7.0.2"
-telemetryGenerator = "1.0.272"
+telemetryGenerator = "1.0.278"
 testLogger = "4.0.0"
 testRetry = "1.5.10"
 # test-only; platform provides slf4j transitively at runtime

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

@@ -4,11 +4,11 @@
 package software.aws.toolkits.core.telemetry
 
 import software.amazon.awssdk.services.toolkittelemetry.model.AWSProduct
+import software.amazon.awssdk.services.toolkittelemetry.model.MetricUnit
 import software.aws.toolkits.core.telemetry.MetricEvent.Companion.illegalCharsRegex
 import software.aws.toolkits.core.utils.getLogger
 import software.aws.toolkits.core.utils.warn
 import java.time.Instant
-import software.amazon.awssdk.services.toolkittelemetry.model.Unit as MetricUnit
 
 interface MetricEvent {
     val createTime: Instant

plugins/core/jetbrains-community/build.gradle.kts

@@ -32,11 +32,11 @@ idea {
 }
 
 val generateTelemetry = tasks.register<GenerateTelemetry>("generateTelemetry") {
-    inputFiles = listOf(file("${project.projectDir}/resources/telemetryOverride.json"))
-    outputDirectory = generatedSrcDir.get().asFile
+    inputFiles.setFrom(file("${project.projectDir}/resources/telemetryOverride.json"))
+    outputDirectory.set(generatedSrcDir)
 
     doFirst {
-        outputDirectory.deleteRecursively()
+        outputDirectory.get().asFile.deleteRecursively()
     }
 }
 

plugins/core/jetbrains-community/src/software/aws/toolkits/jetbrains/core/credentials/ToolkitAuthManager.kt

@@ -10,6 +10,7 @@ import com.intellij.openapi.progress.ProcessCanceledException
 import com.intellij.openapi.project.Project
 import migration.software.aws.toolkits.jetbrains.services.telemetry.TelemetryService
 import software.amazon.awssdk.services.ssooidc.model.SsoOidcException
+import software.amazon.awssdk.services.toolkittelemetry.model.MetricUnit
 import software.aws.toolkits.core.ClientConnectionSettings
 import software.aws.toolkits.core.ConnectionSettings
 import software.aws.toolkits.core.TokenConnectionSettings
@@ -374,7 +375,7 @@ private fun recordLoginWithBrowser(
     TelemetryService.getInstance().record(null as Project?) {
         datum("aws_loginWithBrowser") {
             createTime(Instant.now())
-            unit(software.amazon.awssdk.services.toolkittelemetry.model.Unit.NONE)
+            unit(MetricUnit.NONE)
             value(1.0)
             passive(false)
             credentialSourceId?.let { metadata("credentialSourceId", it.toString()) }
@@ -398,7 +399,7 @@ private fun recordAddConnection(
     TelemetryService.getInstance().record(null as Project?) {
         datum("auth_addConnection") {
             createTime(Instant.now())
-            unit(software.amazon.awssdk.services.toolkittelemetry.model.Unit.NONE)
+            unit(MetricUnit.NONE)
             value(1.0)
             passive(false)
             credentialSourceId?.let { metadata("credentialSourceId", it.toString()) }

plugins/core/jetbrains-community/src/software/aws/toolkits/jetbrains/services/telemetry/otel/OtelBase.kt

@@ -18,11 +18,13 @@ import io.opentelemetry.context.Scope
 import io.opentelemetry.sdk.trace.ReadWriteSpan
 import kotlinx.coroutines.CoroutineScope
 import software.amazon.awssdk.services.toolkittelemetry.model.AWSProduct
+import software.amazon.awssdk.services.toolkittelemetry.model.MetricUnit
 import software.aws.toolkits.core.utils.error
 import software.aws.toolkits.core.utils.getLogger
 import software.aws.toolkits.core.utils.warn
 import software.aws.toolkits.jetbrains.isDeveloperMode
 import software.aws.toolkits.jetbrains.services.telemetry.PluginResolver
+import software.aws.toolkits.telemetry.impl.BaseSpan
 import java.time.Instant
 import java.util.concurrent.TimeUnit
 import kotlin.coroutines.CoroutineContext
@@ -39,12 +41,6 @@ class DefaultSpanBuilder(delegate: SpanBuilder) : AbstractSpanBuilder<DefaultSpa
     override fun doStartSpan() = DefaultSpan(parent, delegate.startSpan())
 }
 
-// temporary; will be generated
-abstract class BaseSpan<SpanType : AbstractBaseSpan<SpanType>>(
-    context: Context?,
-    delegate: Span,
-) : AbstractBaseSpan<SpanType>(context, delegate as ReadWriteSpan)
-
 abstract class AbstractSpanBuilder<
     BuilderType : AbstractSpanBuilder<BuilderType, SpanType>,
     SpanType : AbstractBaseSpan<SpanType>,
@@ -195,6 +191,9 @@ abstract class AbstractSpanBuilder<
 
 abstract class AbstractBaseSpan<SpanType : AbstractBaseSpan<SpanType>>(internal val context: Context?, private val delegate: ReadWriteSpan) : Span by delegate {
     protected open val requiredFields: Collection<String> = emptySet()
+    private var passive: Boolean = false
+    private var unit: MetricUnit = MetricUnit.NONE
+    private var value: Double = 0.0
 
     /**
      * Same as [com.intellij.platform.diagnostic.telemetry.helpers.use] except downcasts to specific subclass of [BaseSpan]
@@ -221,6 +220,21 @@ abstract class AbstractBaseSpan<SpanType : AbstractBaseSpan<SpanType>>(internal
         delegate.end()
     }
 
+    fun passive(passive: Boolean): SpanType {
+        this.passive = passive
+        return this as SpanType
+    }
+
+    fun unit(unit: MetricUnit): SpanType {
+        this.unit = unit
+        return this as SpanType
+    }
+
+    fun value(value: Number): SpanType {
+        this.value = value.toDouble()
+        return this as SpanType
+    }
+
     private fun validateRequiredAttributes() {
         val missingFields = requiredFields.filter { delegate.getAttribute(AttributeKey.stringKey(it)) == null }
         val message = { "${delegate.name} is missing required fields: ${missingFields.joinToString(", ")}" }

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

@@ -5,6 +5,7 @@ package software.aws.toolkits.jetbrains.services.telemetry.otel
 
 import com.intellij.openapi.application.ApplicationManager
 import com.intellij.testFramework.ApplicationExtension
+import io.opentelemetry.api.trace.Span
 import io.opentelemetry.api.trace.TraceId
 import io.opentelemetry.context.Context
 import io.opentelemetry.extension.kotlin.asContextElement
@@ -17,25 +18,46 @@ import kotlinx.coroutines.runBlocking
 import kotlinx.coroutines.test.runTest
 import org.assertj.core.api.Assertions.assertThat
 import org.junit.jupiter.api.Test
+import org.junit.jupiter.api.assertDoesNotThrow
+import org.junit.jupiter.api.assertThrows
 import org.junit.jupiter.api.extension.AfterAllCallback
 import org.junit.jupiter.api.extension.AfterEachCallback
 import org.junit.jupiter.api.extension.ExtendWith
 import org.junit.jupiter.api.extension.ExtensionContext
 import org.junit.jupiter.api.extension.RegisterExtension
+import org.junit.jupiter.params.ParameterizedTest
+import org.junit.jupiter.params.provider.Arguments
+import org.junit.jupiter.params.provider.MethodSource
 import software.amazon.awssdk.services.toolkittelemetry.model.AWSProduct
 import software.aws.toolkits.core.utils.getLogger
 import software.aws.toolkits.core.utils.warn
 import software.aws.toolkits.jetbrains.core.coroutines.getCoroutineBgContext
 import software.aws.toolkits.jetbrains.utils.pluginAwareExecuteOnPooledThread
 import software.aws.toolkits.jetbrains.utils.satisfiesKt
 import software.aws.toolkits.jetbrains.utils.spinUntil
+import software.aws.toolkits.telemetry.MetricResult
+import software.aws.toolkits.telemetry.Telemetry
+import java.time.Instant
 import java.util.concurrent.TimeUnit
+import java.util.stream.Stream
 
 @ExtendWith(ApplicationExtension::class)
 class OtelBaseTest {
     private companion object {
         @RegisterExtension
         val otelExtension = OtelExtension()
+
+        private fun spanEndArgs() = Stream.of(
+            Arguments.of("end()", { span: Span -> span.end() }),
+            Arguments.of("end(long, TimeUnit)", { span: Span -> span.end(1, TimeUnit.SECONDS) }),
+            Arguments.of("end(Instant)", { span: Span -> span.end(Instant.now()) }),
+        )
+
+        @JvmStatic
+        fun `AbstractBaseSpan#end() throws if attributes are missing`() = spanEndArgs()
+
+        @JvmStatic
+        fun `AbstractBaseSpan#end() does not throw if all required attributes are present`() = spanEndArgs()
     }
 
     @Test
@@ -268,6 +290,22 @@ class OtelBaseTest {
         }
     }
 
+    @ParameterizedTest(name = "{0}")
+    @MethodSource
+    fun `AbstractBaseSpan#end() throws if attributes are missing`(ignored: String, block: Span.() -> Unit) {
+        val span = Telemetry.aws.openUrl.startSpan()
+        val e = assertThrows<Exception> { block(span) }
+        assertThat(e.message).contains("aws_openUrl is missing required fields: result")
+    }
+
+    @ParameterizedTest(name = "{0}")
+    @MethodSource
+    fun `AbstractBaseSpan#end() does not throw if all required attributes are present`(ignored: String, block: Span.() -> Unit) {
+        val span = Telemetry.aws.openUrl.startSpan()
+        span.result(MetricResult.Succeeded)
+        assertDoesNotThrow { block(span) }
+    }
+
     private fun spanBuilder(tracer: String, spanName: String) = DefaultSpanBuilder(otelExtension.sdk.sdk.getTracer(tracer).spanBuilder(spanName))
 }
 

plugins/core/sdk-codegen/codegen-resources/telemetry/customization.config

@@ -0,0 +1,6 @@
+{
+  "renameShapes": {
+    // "Unit" conflicts with Kotlin stdlib [kotlin.Unit]
+    "Unit" : "MetricUnit"
+  }
+}