Distributed Tracing integration with SDK builds.

sdk/core/azure_core/src/http/options/mod.rs

@@ -1,8 +1,10 @@
 // Copyright (c) Microsoft Corporation. All rights reserved.
 // Licensed under the MIT License.
 
+mod request_instrumentation;
 mod user_agent;
 
+pub use request_instrumentation::*;
 use std::sync::Arc;
 use typespec_client_core::http::policies::Policy;
 pub use typespec_client_core::http::{
@@ -27,6 +29,13 @@ pub struct ClientOptions {
 
     /// User-Agent telemetry options.
     pub user_agent: Option<UserAgentOptions>,
+
+    pub request_instrumentation: Option<RequestInstrumentationOptions>,
+}
+
+pub(crate) struct CoreClientOptions {
+    pub(crate) user_agent: UserAgentOptions,
+    pub(crate) request_instrumentation: RequestInstrumentationOptions,
 }
 
 impl ClientOptions {
@@ -35,14 +44,20 @@ impl ClientOptions {
     /// If instead we implemented [`Into`], we'd have to clone Azure-specific options instead of moving memory of [`Some`] values.
     pub(in crate::http) fn deconstruct(
         self,
-    ) -> (UserAgentOptions, typespec_client_core::http::ClientOptions) {
+    ) -> (CoreClientOptions, typespec_client_core::http::ClientOptions) {
         let options = typespec_client_core::http::ClientOptions {
             per_call_policies: self.per_call_policies,
             per_try_policies: self.per_try_policies,
             retry: self.retry,
             transport: self.transport,
         };
 
-        (self.user_agent.unwrap_or_default(), options)
+        (
+            CoreClientOptions {
+                user_agent: self.user_agent.unwrap_or_default(),
+                request_instrumentation: self.request_instrumentation.unwrap_or_default(),
+            },
+            options,
+        )
     }
 }

sdk/core/azure_core/src/http/options/request_instrumentation.rs

@@ -0,0 +1,11 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+use std::sync::Arc;
+
+/// Policy options to enable distributed tracing.
+#[derive(Clone, Debug, Default)]
+pub struct RequestInstrumentationOptions {
+    /// Set the tracing provider for distributed tracing.
+    pub tracing_provider: Option<Arc<dyn crate::tracing::TracerProvider>>,
+}

sdk/core/azure_core/src/http/pipeline.rs

@@ -3,7 +3,7 @@
 
 use super::policies::ClientRequestIdPolicy;
 use crate::http::{
-    policies::{Policy, UserAgentPolicy},
+    policies::{Policy, RequestInstrumentationPolicy, UserAgentPolicy},
     ClientOptions,
 };
 use std::{
@@ -51,9 +51,38 @@ impl Pipeline {
         let mut per_call_policies = per_call_policies.clone();
         push_unique(&mut per_call_policies, ClientRequestIdPolicy::default());
 
-        let (user_agent, options) = options.deconstruct();
-        let telemetry_policy = UserAgentPolicy::new(crate_name, crate_version, &user_agent);
-        push_unique(&mut per_call_policies, telemetry_policy);
+        let (core_client_options, options) = options.deconstruct();
+        let user_agent_policy =
+                UserAgentPolicy::new(crate_name, crate_version, &core_client_options.user_agent);
+        push_unique(&mut per_call_policies, user_agent_policy);
+
+
+        let mut per_try_policies = per_try_policies.clone();
+        if core_client_options
+            .request_instrumentation
+            .tracing_provider
+            .is_some()
+        {
+            // Note that the choice to use "None" as the namespace here
+            // is intentional.
+            // The `azure_namespace` parameter is used to populate the `az.namespace`
+            // span attribute, however that information is only known by the author of the
+            // client library, not the core library.
+            // It is also *not* a constant that can be derived from the crate information -
+            // it is a value that is determined from the list of resource providers
+            // listed [here](https://learn.microsoft.com/azure/azure-resource-manager/management/azure-services-resource-providers).
+            //
+            // This information can only come from the package owner. It doesn't make sense
+            // to burden all users of the azure_core pipeline with determining this
+            // information, so we use `None` here.
+            let request_instrumentation_policy = RequestInstrumentationPolicy::new(
+                None,
+                crate_name,
+                crate_version,
+                &core_client_options.request_instrumentation,
+            );
+            push_unique(&mut per_try_policies, request_instrumentation_policy);
+        }
 
         Self(http::Pipeline::new(
             options,

sdk/core/azure_core/src/http/policies/mod.rs

@@ -5,9 +5,11 @@
 
 mod bearer_token_policy;
 mod client_request_id;
+mod request_instrumentation;
 mod user_agent;
 
 pub use bearer_token_policy::BearerTokenCredentialPolicy;
 pub use client_request_id::*;
+pub use request_instrumentation::*;
 pub use typespec_client_core::http::policies::*;
 pub use user_agent::*;