refactor: instrument using new telemetry APIs

codegen/smithy-kotlin-codegen/src/main/kotlin/software/amazon/smithy/kotlin/codegen/core/KotlinDependency.kt

@@ -112,7 +112,7 @@ data class KotlinDependency(
         val AWS_CREDENTIALS = KotlinDependency(GradleConfiguration.Implementation, "$RUNTIME_ROOT_NS.auth.awscredentials", RUNTIME_GROUP, "aws-credentials", RUNTIME_VERSION)
         val AWS_SIGNING_COMMON = KotlinDependency(GradleConfiguration.Implementation, "$RUNTIME_ROOT_NS.auth.awssigning", RUNTIME_GROUP, "aws-signing-common", RUNTIME_VERSION)
         val AWS_SIGNING_DEFAULT = KotlinDependency(GradleConfiguration.Implementation, "$RUNTIME_ROOT_NS.auth.awssigning", RUNTIME_GROUP, "aws-signing-default", RUNTIME_VERSION)
-        val TRACING_CORE = KotlinDependency(GradleConfiguration.Api, "$RUNTIME_ROOT_NS.tracing", RUNTIME_GROUP, "tracing-core", RUNTIME_VERSION)
+        val TELEMETRY_API = KotlinDependency(GradleConfiguration.Api, "$RUNTIME_ROOT_NS.telemetry", RUNTIME_GROUP, "telemetry-api", RUNTIME_VERSION)
 
         val AWS_JSON_PROTOCOLS = KotlinDependency(GradleConfiguration.Implementation, "$RUNTIME_ROOT_NS.awsprotocol.json", RUNTIME_GROUP, "aws-json-protocols", RUNTIME_VERSION)
         val AWS_EVENT_STREAM = KotlinDependency(GradleConfiguration.Implementation, "$RUNTIME_ROOT_NS.awsprotocol.eventstream", RUNTIME_GROUP, "aws-event-stream", RUNTIME_VERSION)

codegen/smithy-kotlin-codegen/src/main/kotlin/software/amazon/smithy/kotlin/codegen/core/RuntimeTypes.kt

@@ -308,15 +308,15 @@ object RuntimeTypes {
         }
     }
 
-    object Tracing {
-        object Core : RuntimeTypePackage(KotlinDependency.TRACING_CORE) {
-            val debug = symbol("debug")
-            val DefaultTracer = symbol("DefaultTracer")
-            val LoggingTraceProbe = symbol("LoggingTraceProbe")
-            val TraceProbe = symbol("TraceProbe")
-            val Tracer = symbol("Tracer")
-            val TracingClientConfig = symbol("TracingClientConfig")
-            val withRootTraceSpan = symbol("withRootTraceSpan")
+    object Observability {
+        object TelemetryApi : RuntimeTypePackage(KotlinDependency.TELEMETRY_API) {
+            val SpanKind = symbol("SpanKind", "trace")
+            val TelemetryConfig = symbol("TelemetryConfig")
+            val TelemetryProvider = symbol("TelemetryProvider")
+            val TelemetryProviderContext = symbol("TelemetryProviderContext")
+            val TelemetryContextElement = symbol("TelemetryContextElement", "context")
+            val TraceSpan = symbol("TraceSpan", "trace")
+            val withSpan = symbol("withSpan", "trace")
         }
     }
 

codegen/smithy-kotlin-codegen/src/main/kotlin/software/amazon/smithy/kotlin/codegen/lang/KotlinTypes.kt

@@ -7,6 +7,7 @@ package software.amazon.smithy.kotlin.codegen.lang
 
 import software.amazon.smithy.codegen.core.Symbol
 import software.amazon.smithy.kotlin.codegen.model.buildSymbol
+import software.amazon.smithy.kotlin.codegen.model.toSymbol
 
 /**
  * Builtin kotlin types
@@ -90,6 +91,10 @@ object KotlinTypes {
         val seconds = builtInSymbol("seconds", "kotlin.time.Duration.Companion")
     }
 
+    object Coroutines {
+        val CoroutineContext = "kotlin.coroutines.CoroutineContext".toSymbol()
+    }
+
     /**
      * A (non-exhaustive) set of builtin Kotlin symbols
      */

codegen/smithy-kotlin-codegen/src/main/kotlin/software/amazon/smithy/kotlin/codegen/rendering/ServiceClientConfigGenerator.kt

@@ -54,7 +54,7 @@ class ServiceClientConfigGenerator(
 
         add(RuntimeConfigProperty.RetryPolicy)
         add(RuntimeConfigProperty.RetryStrategy)
-        add(RuntimeConfigProperty.Tracer)
+        add(RuntimeConfigProperty.TelemetryProvider)
 
         if (shape.hasTrait<ClientContextParamsTrait>()) {
             addAll(clientContextConfigProps(shape.expectTrait()))

codegen/smithy-kotlin-codegen/src/main/kotlin/software/amazon/smithy/kotlin/codegen/rendering/ServiceClientGenerator.kt

@@ -64,6 +64,11 @@ class ServiceClientGenerator(private val ctx: RenderingContext<ServiceShape>) {
     private val writer = ctx.writer
 
     fun render() {
+        writer.write("\n\n")
+        writer.write("public const val ServiceId: String = #S", ctx.settings.sdkId)
+        writer.write("public const val SdkVersion: String = #S", ctx.settings.pkg.version)
+        writer.write("\n\n")
+
         writer.putContext("service.name", ctx.settings.sdkId)
 
         val topDownIndex = TopDownIndex.of(ctx.model)

codegen/smithy-kotlin-codegen/src/main/kotlin/software/amazon/smithy/kotlin/codegen/rendering/protocol/HttpProtocolClientGenerator.kt

@@ -37,6 +37,8 @@ abstract class HttpProtocolClientGenerator(
         val Operation: SectionKey<OperationShape> = SectionKey("Operation")
     }
 
+    object OperationSpanAttributes : SectionId
+
     /**
      * Render the implementation of the service client interface
      */
@@ -71,6 +73,8 @@ abstract class HttpProtocolClientGenerator(
             .write("")
             .call { renderClose(writer) }
             .write("")
+            .call { renderInstrumentOperation(writer) }
+            .write("")
             .call { renderAdditionalMethods(writer) }
             .closeBlock("}")
             .write("")
@@ -249,24 +253,45 @@ abstract class HttpProtocolClientGenerator(
         val hasOutputStream = outputShape.map { it.hasStreamingMember(ctx.model) }.orElse(false)
         val inputVariableName = if (inputShape.isPresent) "input" else KotlinTypes.Unit.fullName
 
-        writer
-            .write(
-                """val rootSpan = config.tracer.createRootSpan("#L-${'$'}{op.context.#T}")""",
-                op.id.name,
-                RuntimeTypes.HttpClient.Operation.sdkRequestId,
+        writer.write("val (span, telemetryCtx) = instrumentOperation(#S)", op.id.name)
+        writer.withBlock("return #T(span, telemetryCtx) {", "}", RuntimeTypes.Observability.TelemetryApi.withSpan) {
+            if (hasOutputStream) {
+                write("op.#T(client, #L, block)", RuntimeTypes.HttpClient.Operation.execute, inputVariableName)
+            } else {
+                write("op.#T(client, #L)", RuntimeTypes.HttpClient.Operation.roundTrip, inputVariableName)
+            }
+        }
+    }
+
+    private fun renderInstrumentOperation(writer: KotlinWriter) {
+        writer.withBlock(
+            "private fun instrumentOperation(operation: #T): Pair<#T, #T> {",
+            "}",
+            KotlinTypes.String,
+            RuntimeTypes.Observability.TelemetryApi.TraceSpan,
+            KotlinTypes.Coroutines.CoroutineContext,
+        ) {
+            write("val tracer = config.telemetryProvider.tracerProvider.getOrCreateTracer(config.clientName)")
+            write("val parentCtx = config.telemetryProvider.contextManager.current()")
+            write(
+                "val telemetryCtx = #T(config.telemetryProvider) + #T(parentCtx)",
+                RuntimeTypes.Observability.TelemetryApi.TelemetryProviderContext,
+                RuntimeTypes.Observability.TelemetryApi.TelemetryContextElement,
             )
-            .withBlock(
-                "return #T.#T(rootSpan) {",
-                "}",
-                RuntimeTypes.KotlinCoroutines.coroutineContext,
-                RuntimeTypes.Tracing.Core.withRootTraceSpan,
-            ) {
-                if (hasOutputStream) {
-                    write("op.#T(client, #L, block)", RuntimeTypes.HttpClient.Operation.execute, inputVariableName)
-                } else {
-                    write("op.#T(client, #L)", RuntimeTypes.HttpClient.Operation.roundTrip, inputVariableName)
+
+            withBlock("val span = tracer.createSpan(", ")") {
+                write("#S,", "\${ServiceId}.\${operation}")
+                withBlock("#T{", "},", RuntimeTypes.Core.Utils.attributesOf) {
+                    write("#S to ServiceId", "rpc.service")
+                    write("#S to operation", "rpc.method")
+                    writer.declareSection(OperationSpanAttributes)
                 }
+                write("#T.CLIENT,", RuntimeTypes.Observability.TelemetryApi.SpanKind)
+                write("parentCtx,")
             }
+
+            write("return span to telemetryCtx")
+        }
     }
 
     private fun ioSymbolNames(op: OperationShape): Pair<String, String> {

codegen/smithy-kotlin-codegen/src/main/kotlin/software/amazon/smithy/kotlin/codegen/rendering/util/RuntimeConfigProperty.kt

@@ -140,30 +140,17 @@ object RuntimeConfigProperty {
         """.trimIndent()
     }
 
-    // TODO support a nice DSL for this so that callers don't have to be aware of `DefaultTracer` if they don't want
-    // to, they can just call `SomeClient { tracer { clientName = "Foo" } }` in the simple case.
-    // We could do this as an extension in the runtime off TracingClientConfig.Builder type...
-    val Tracer = ConfigProperty {
-        symbol = RuntimeTypes.Tracing.Core.Tracer
-        baseClass = RuntimeTypes.Tracing.Core.TracingClientConfig
+    var TelemetryProvider = ConfigProperty {
+        symbol = RuntimeTypes.Observability.TelemetryApi.TelemetryProvider
+        baseClass = RuntimeTypes.Observability.TelemetryApi.TelemetryConfig
         useNestedBuilderBaseClass()
 
         documentation = """
-            The tracer that is responsible for creating trace spans and wiring them up to a tracing backend (e.g.,
-            a trace probe). By default, this will create a standard tracer that uses the service name for the root
-            trace span and delegates to a logging trace probe (i.e.,
-            `DefaultTracer(LoggingTraceProbe, "<service-name>")`).
+            The telemetry provider used to instrument the SDK operations with. By default this will be a no-op
+            implementation.
         """.trimIndent()
-        propertyType = ConfigPropertyType.Custom(
-            render = { prop, writer ->
-                writer.write(
-                    """override val #1L: Tracer = builder.#1L ?: #2T(#3T, clientName)""",
-                    prop.propertyName,
-                    RuntimeTypes.Tracing.Core.DefaultTracer,
-                    RuntimeTypes.Tracing.Core.LoggingTraceProbe,
-                )
-            },
-        )
+
+        propertyType = ConfigPropertyType.RequiredWithDefault("TelemetryProvider.None")
     }
 
     val HttpInterceptors = ConfigProperty {

codegen/smithy-kotlin-codegen/src/test/kotlin/software/amazon/smithy/kotlin/codegen/rendering/ServiceClientConfigGeneratorTest.kt

@@ -42,7 +42,7 @@ class ServiceClientConfigGeneratorTest {
         contents.assertBalancedBracesAndParens()
 
         val expectedCtor = """
-public class Config private constructor(builder: Builder) : HttpAuthConfig, HttpClientConfig, HttpEngineConfig by builder.buildHttpEngineConfig(), IdempotencyTokenConfig, SdkClientConfig, TracingClientConfig {
+public class Config private constructor(builder: Builder) : HttpAuthConfig, HttpClientConfig, HttpEngineConfig by builder.buildHttpEngineConfig(), IdempotencyTokenConfig, SdkClientConfig, TelemetryConfig {
 """
         contents.shouldContainWithDiff(expectedCtor)
 
@@ -55,12 +55,12 @@ public class Config private constructor(builder: Builder) : HttpAuthConfig, Http
     override val logMode: LogMode = builder.logMode ?: LogMode.Default
     override val retryPolicy: RetryPolicy<Any?> = builder.retryPolicy ?: StandardRetryPolicy.Default
     override val retryStrategy: RetryStrategy = builder.retryStrategy ?: StandardRetryStrategy()
-    override val tracer: Tracer = builder.tracer ?: DefaultTracer(LoggingTraceProbe, clientName)
+    override val telemetryProvider: TelemetryProvider = builder.telemetryProvider ?: TelemetryProvider.None
 """
         contents.shouldContainWithDiff(expectedProps)
 
         val expectedBuilder = """
-    public class Builder : HttpAuthConfig.Builder, HttpClientConfig.Builder, HttpEngineConfig.Builder by HttpEngineConfigImpl.BuilderImpl(), IdempotencyTokenConfig.Builder, SdkClientConfig.Builder<Config>, TracingClientConfig.Builder {
+    public class Builder : HttpAuthConfig.Builder, HttpClientConfig.Builder, HttpEngineConfig.Builder by HttpEngineConfigImpl.BuilderImpl(), IdempotencyTokenConfig.Builder, SdkClientConfig.Builder<Config>, TelemetryConfig.Builder {
         /**
          * A reader-friendly name for the client.
          */
@@ -122,12 +122,10 @@ public class Config private constructor(builder: Builder) : HttpAuthConfig, Http
         override var retryStrategy: RetryStrategy? = null
 
         /**
-         * The tracer that is responsible for creating trace spans and wiring them up to a tracing backend (e.g.,
-         * a trace probe). By default, this will create a standard tracer that uses the service name for the root
-         * trace span and delegates to a logging trace probe (i.e.,
-         * `DefaultTracer(LoggingTraceProbe, "<service-name>")`).
+         * The telemetry provider used to instrument the SDK operations with. By default this will be a no-op
+         * implementation.
          */
-        override var tracer: Tracer? = null
+        override var telemetryProvider: TelemetryProvider? = null
 
         override fun build(): Config = Config(this)
     }
@@ -256,7 +254,7 @@ public class Config private constructor(builder: Builder) {
     override val logMode: LogMode = builder.logMode ?: LogMode.LogRequest
     override val retryPolicy: RetryPolicy<Any?> = builder.retryPolicy ?: StandardRetryPolicy.Default
     override val retryStrategy: RetryStrategy = builder.retryStrategy ?: StandardRetryStrategy()
-    override val tracer: Tracer = builder.tracer ?: DefaultTracer(LoggingTraceProbe, clientName)"""
+    override val telemetryProvider: TelemetryProvider = builder.telemetryProvider ?: TelemetryProvider.None"""
         contents.shouldContainWithDiff(expectedConfigValues)
     }
 

codegen/smithy-kotlin-codegen/src/test/kotlin/software/amazon/smithy/kotlin/codegen/rendering/ServiceClientGeneratorTest.kt

@@ -73,7 +73,7 @@ class ServiceClientGeneratorTest {
 
     @Test
     fun `it generates config`() {
-        val expected = "public class Config private constructor(builder: Builder) : IdempotencyTokenConfig, SdkClientConfig, TracingClientConfig"
+        val expected = "public class Config private constructor(builder: Builder) : IdempotencyTokenConfig, SdkClientConfig, TelemetryConfig"
         commonTestContents.shouldContainOnlyOnce(expected)
     }
 

codegen/smithy-kotlin-codegen/src/test/kotlin/software/amazon/smithy/kotlin/codegen/rendering/protocol/HttpProtocolClientGeneratorTest.kt

@@ -40,8 +40,6 @@ class HttpProtocolClientGeneratorTest {
         commonTestContents.shouldContainOnlyOnceWithDiff("import ${KotlinDependency.HTTP.namespace}.operation.context")
         commonTestContents.shouldContainOnlyOnceWithDiff("import ${KotlinDependency.HTTP.namespace}.operation.execute")
         commonTestContents.shouldContainOnlyOnceWithDiff("import ${KotlinDependency.HTTP.namespace}.operation.roundTrip")
-        commonTestContents.shouldContainOnlyOnceWithDiff("import ${KotlinDependency.HTTP.namespace}.operation.sdkRequestId")
-        commonTestContents.shouldContainOnlyOnceWithDiff("import ${KotlinDependency.TRACING_CORE.namespace}.withRootTraceSpan")
     }
 
     @Test
@@ -89,8 +87,8 @@ class HttpProtocolClientGeneratorTest {
         }
         op.install(MockMiddleware(configurationField1 = "testing"))
         op.interceptors.addAll(config.interceptors)
-        val rootSpan = config.tracer.createRootSpan("GetFoo-${'$'}{op.context.sdkRequestId}")
-        return coroutineContext.withRootTraceSpan(rootSpan) {
+        val (span, telemetryCtx) = instrumentOperation("GetFoo")
+        return withSpan(span, telemetryCtx) {
             op.roundTrip(client, input)
         }
     }
@@ -110,8 +108,8 @@ class HttpProtocolClientGeneratorTest {
         }
         op.install(MockMiddleware(configurationField1 = "testing"))
         op.interceptors.addAll(config.interceptors)
-        val rootSpan = config.tracer.createRootSpan("GetFooNoInput-${'$'}{op.context.sdkRequestId}")
-        return coroutineContext.withRootTraceSpan(rootSpan) {
+        val (span, telemetryCtx) = instrumentOperation("GetFooNoInput")
+        return withSpan(span, telemetryCtx) {
             op.roundTrip(client, input)
         }
     }
@@ -131,8 +129,8 @@ class HttpProtocolClientGeneratorTest {
         }
         op.install(MockMiddleware(configurationField1 = "testing"))
         op.interceptors.addAll(config.interceptors)
-        val rootSpan = config.tracer.createRootSpan("GetFooNoOutput-${'$'}{op.context.sdkRequestId}")
-        return coroutineContext.withRootTraceSpan(rootSpan) {
+        val (span, telemetryCtx) = instrumentOperation("GetFooNoOutput")
+        return withSpan(span, telemetryCtx) {
             op.roundTrip(client, input)
         }
     }
@@ -152,8 +150,8 @@ class HttpProtocolClientGeneratorTest {
         }
         op.install(MockMiddleware(configurationField1 = "testing"))
         op.interceptors.addAll(config.interceptors)
-        val rootSpan = config.tracer.createRootSpan("GetFooStreamingInput-${'$'}{op.context.sdkRequestId}")
-        return coroutineContext.withRootTraceSpan(rootSpan) {
+        val (span, telemetryCtx) = instrumentOperation("GetFooStreamingInput")
+        return withSpan(span, telemetryCtx) {
             op.roundTrip(client, input)
         }
     }
@@ -173,8 +171,8 @@ class HttpProtocolClientGeneratorTest {
         }
         op.install(MockMiddleware(configurationField1 = "testing"))
         op.interceptors.addAll(config.interceptors)
-        val rootSpan = config.tracer.createRootSpan("GetFooStreamingOutput-${'$'}{op.context.sdkRequestId}")
-        return coroutineContext.withRootTraceSpan(rootSpan) {
+        val (span, telemetryCtx) = instrumentOperation("GetFooStreamingOutput")
+        return withSpan(span, telemetryCtx) {
             op.execute(client, input, block)
         }
     }
@@ -194,8 +192,8 @@ class HttpProtocolClientGeneratorTest {
         }
         op.install(MockMiddleware(configurationField1 = "testing"))
         op.interceptors.addAll(config.interceptors)
-        val rootSpan = config.tracer.createRootSpan("GetFooStreamingOutputNoInput-${'$'}{op.context.sdkRequestId}")
-        return coroutineContext.withRootTraceSpan(rootSpan) {
+        val (span, telemetryCtx) = instrumentOperation("GetFooStreamingOutputNoInput")
+        return withSpan(span, telemetryCtx) {
             op.execute(client, input, block)
         }
     }
@@ -215,8 +213,8 @@ class HttpProtocolClientGeneratorTest {
         }
         op.install(MockMiddleware(configurationField1 = "testing"))
         op.interceptors.addAll(config.interceptors)
-        val rootSpan = config.tracer.createRootSpan("GetFooStreamingInputNoOutput-${'$'}{op.context.sdkRequestId}")
-        return coroutineContext.withRootTraceSpan(rootSpan) {
+        val (span, telemetryCtx) = instrumentOperation("GetFooStreamingInputNoOutput")
+        return withSpan(span, telemetryCtx) {
             op.roundTrip(client, input)
         }
     }
@@ -236,8 +234,8 @@ class HttpProtocolClientGeneratorTest {
         }
         op.install(MockMiddleware(configurationField1 = "testing"))
         op.interceptors.addAll(config.interceptors)
-        val rootSpan = config.tracer.createRootSpan("GetFooNoRequired-${'$'}{op.context.sdkRequestId}")
-        return coroutineContext.withRootTraceSpan(rootSpan) {
+        val (span, telemetryCtx) = instrumentOperation("GetFooNoRequired")
+        return withSpan(span, telemetryCtx) {
             op.roundTrip(client, input)
         }
     }
@@ -257,8 +255,8 @@ class HttpProtocolClientGeneratorTest {
         }
         op.install(MockMiddleware(configurationField1 = "testing"))
         op.interceptors.addAll(config.interceptors)
-        val rootSpan = config.tracer.createRootSpan("GetFooSomeRequired-${'$'}{op.context.sdkRequestId}")
-        return coroutineContext.withRootTraceSpan(rootSpan) {
+        val (span, telemetryCtx) = instrumentOperation("GetFooSomeRequired")
+        return withSpan(span, telemetryCtx) {
             op.roundTrip(client, input)
         }
     }

gradle.properties

@@ -6,7 +6,7 @@ kotlin.native.ignoreDisabledTargets=true
 kotlin.mpp.enableCompatibilityMetadataVariant=true
 
 # SDK
-sdkVersion=0.21.2-SNAPSHOT
+sdkVersion=0.22.0-SNAPSHOT
 
 # kotlin
 kotlinVersion=1.8.10

runtime/auth/aws-credentials/build.gradle.kts

@@ -29,7 +29,7 @@ kotlin {
                 // For Instant
                 api(project(":runtime:runtime-core"))
                 api(project(":runtime:auth:identity-api"))
-                implementation(project(":runtime:tracing:tracing-core"))
+                implementation(project(":runtime:observability:telemetry-api"))
                 implementation("org.jetbrains.kotlinx:atomicfu:$atomicFuVersion")
             }
         }

runtime/auth/aws-credentials/common/src/aws/smithy/kotlin/runtime/auth/awscredentials/CachedCredentialsProvider.kt

@@ -6,8 +6,8 @@
 package aws.smithy.kotlin.runtime.auth.awscredentials
 
 import aws.smithy.kotlin.runtime.io.closeIfCloseable
+import aws.smithy.kotlin.runtime.telemetry.logging.trace
 import aws.smithy.kotlin.runtime.time.Clock
-import aws.smithy.kotlin.runtime.tracing.trace
 import aws.smithy.kotlin.runtime.util.Attributes
 import aws.smithy.kotlin.runtime.util.CachedValue
 import aws.smithy.kotlin.runtime.util.ExpiringValue