@temporalio/core-bridge 1.15.0 → 1.16.1

package/sdk-core/crates/client/src/metrics.rs

@@ -5,15 +5,14 @@ use futures_util::{
 };
 use std::{
     fmt,
-    sync::Arc,
     task::{Context, Poll},
     time::{Duration, Instant},
 };
 use temporalio_common::telemetry::{
     TaskQueueLabelStrategy,
     metrics::{
-        CoreMeter, Counter, CounterBase, HistogramDuration, HistogramDurationBase,
-        MetricAttributable, MetricAttributes, MetricKeyValue, MetricParameters, TemporalMeter,
+        Counter, CounterBase, HistogramDuration, HistogramDurationBase, MetricAttributable,
+        MetricAttributes, MetricKeyValue, MetricParameters, TemporalMeter,
     },
 };
 use tonic::{Code, body::Body, transport::Channel};
@@ -25,16 +24,12 @@ pub static REQUEST_LATENCY_HISTOGRAM_NAME: &str = "request_latency";
 pub static LONG_REQUEST_LATENCY_HISTOGRAM_NAME: &str = "long_request_latency";
 
 /// Used to track context associated with metrics, and record/update them
-// Possible improvement: make generic over some type tag so that methods are only exposed if the
-// appropriate k/vs have already been set.
 #[derive(Clone, derive_more::Debug)]
-#[debug("MetricsContext {{ attribs: {kvs:?}, poll_is_long: {poll_is_long} }}")]
+#[debug("MetricsContext {{ poll_is_long: {poll_is_long} }}")]
 pub(crate) struct MetricsContext {
-    meter: Arc<dyn CoreMeter>,
-    kvs: MetricAttributes,
+    meter: TemporalMeter,
     poll_is_long: bool,
     instruments: Instruments,
-    task_queue_label_strategy: TaskQueueLabelStrategy,
 }
 #[derive(Clone)]
 struct Instruments {
@@ -49,75 +44,70 @@ struct Instruments {
 
 impl MetricsContext {
     pub(crate) fn new(tm: TemporalMeter) -> Self {
-        let meter = tm.inner;
-        let task_queue_label_strategy = tm.task_queue_label_strategy;
-        let kvs = meter.new_attributes(tm.default_attribs);
         let instruments = Instruments {
-            svc_request: meter.counter(MetricParameters {
+            svc_request: tm.counter(MetricParameters {
                 name: "request".into(),
                 description: "Count of client request successes by rpc name".into(),
                 unit: "".into(),
             }),
-            svc_request_failed: meter.counter(MetricParameters {
+            svc_request_failed: tm.counter(MetricParameters {
                 name: "request_failure".into(),
                 description: "Count of client request failures by rpc name".into(),
                 unit: "".into(),
             }),
-            long_svc_request: meter.counter(MetricParameters {
+            long_svc_request: tm.counter(MetricParameters {
                 name: "long_request".into(),
                 description: "Count of long-poll request successes by rpc name".into(),
                 unit: "".into(),
             }),
-            long_svc_request_failed: meter.counter(MetricParameters {
+            long_svc_request_failed: tm.counter(MetricParameters {
                 name: "long_request_failure".into(),
                 description: "Count of long-poll request failures by rpc name".into(),
                 unit: "".into(),
             }),
-            svc_request_latency: meter.histogram_duration(MetricParameters {
+            svc_request_latency: tm.histogram_duration(MetricParameters {
                 name: REQUEST_LATENCY_HISTOGRAM_NAME.into(),
                 unit: "duration".into(),
                 description: "Histogram of client request latencies".into(),
             }),
-            long_svc_request_latency: meter.histogram_duration(MetricParameters {
+            long_svc_request_latency: tm.histogram_duration(MetricParameters {
                 name: LONG_REQUEST_LATENCY_HISTOGRAM_NAME.into(),
                 unit: "duration".into(),
                 description: "Histogram of client long-poll request latencies".into(),
             }),
         };
         Self {
-            kvs,
             poll_is_long: false,
             instruments,
-            meter,
-            task_queue_label_strategy,
+            meter: tm,
         }
     }
 
     /// Mutate this metrics context with new attributes
     pub(crate) fn with_new_attrs(&mut self, new_kvs: impl IntoIterator<Item = MetricKeyValue>) {
-        self.kvs = self
-            .meter
-            .extend_attributes(self.kvs.clone(), new_kvs.into());
+        self.meter.merge_attributes(new_kvs.into());
 
         let _ = self
             .instruments
             .svc_request
-            .with_attributes(&self.kvs)
+            .with_attributes(self.meter.get_default_attributes())
             .and_then(|v| {
                 self.instruments.svc_request = v;
-                self.instruments.long_svc_request.with_attributes(&self.kvs)
+                self.instruments
+                    .long_svc_request
+                    .with_attributes(self.meter.get_default_attributes())
             })
             .and_then(|v| {
                 self.instruments.long_svc_request = v;
                 self.instruments
                     .svc_request_latency
-                    .with_attributes(&self.kvs)
+                    .with_attributes(self.meter.get_default_attributes())
             })
             .and_then(|v| {
                 self.instruments.svc_request_latency = v;
                 self.instruments
                     .long_svc_request_latency
-                    .with_attributes(&self.kvs)
+                    .with_attributes(self.meter.get_default_attributes())
             })
             .map(|v| {
                 self.instruments.long_svc_request_latency = v;
@@ -144,12 +134,13 @@ impl MetricsContext {
     pub(crate) fn svc_request_failed(&self, code: Option<Code>) {
         let refme: MetricAttributes;
         let kvs = if let Some(c) = code {
-            refme = self
-                .meter
-                .extend_attributes(self.kvs.clone(), [status_code_kv(c)].into());
+            refme = self.meter.extend_attributes(
+                self.meter.get_default_attributes().clone(),
+                [status_code_kv(c)].into(),
+            );
             &refme
         } else {
-            &self.kvs
+            self.meter.get_default_attributes()
         };
         if self.poll_is_long {
             self.instruments.long_svc_request_failed.add(1, kvs);
@@ -261,7 +252,7 @@ impl Service<http::Request<Body>> for GrpcMetricSvc {
                     if other_labels.normal_task_queue.is_some()
                         || other_labels.sticky_task_queue.is_some()
                     {
-                        let task_queue_name = match m.task_queue_label_strategy {
+                        let task_queue_name = match m.meter.get_task_queue_label_strategy() {
                             TaskQueueLabelStrategy::UseNormal => other_labels.normal_task_queue,
                             TaskQueueLabelStrategy::UseNormalAndSticky => other_labels
                                 .sticky_task_queue

package/sdk-core/crates/client/src/options_structs.rs

@@ -0,0 +1,457 @@
+use crate::{HttpConnectProxyOptions, RetryOptions, VERSION, callback_based};
+use http::Uri;
+use std::{collections::HashMap, time::Duration};
+use temporalio_common::{
+    data_converters::DataConverter,
+    protos::temporal::api::{
+        common::{
+            self,
+            v1::{Header, Payload, Payloads},
+        },
+        enums::v1::{
+            ArchivalState, HistoryEventFilterType, QueryRejectCondition, WorkflowIdConflictPolicy,
+            WorkflowIdReusePolicy,
+        },
+        replication::v1::ClusterReplicationConfig,
+        workflowservice::v1::RegisterNamespaceRequest,
+    },
+    telemetry::metrics::TemporalMeter,
+};
+use url::Url;
+
+/// Options for [crate::Connection::connect].
+#[derive(bon::Builder, Clone, Debug)]
+#[non_exhaustive]
+#[builder(start_fn = new, on(String, into), state_mod(vis = "pub"))]
+pub struct ConnectionOptions {
+    /// The server to connect to.
+    #[builder(start_fn, into)]
+    pub target: Url,
+    /// A human-readable string that can identify this process. Defaults to empty string.
+    #[builder(default)]
+    pub identity: String,
+    /// When set, this client will record metrics using the provided meter. The meter can be
+    /// obtained from [temporalio_common::telemetry::TelemetryInstance::get_temporal_metric_meter].
+    pub metrics_meter: Option<TemporalMeter>,
+    /// If specified, use TLS as configured by the [TlsOptions] struct. If this is set core will
+    /// attempt to use TLS when connecting to the Temporal server. Lang SDK is expected to pass any
+    /// certs or keys as bytes, loading them from disk itself if needed.
+    pub tls_options: Option<TlsOptions>,
+    /// If set, override the origin used when connecting. May be useful in rare situations where tls
+    /// verification needs to use a different name from what should be set as the `:authority`
+    /// header. If [TlsOptions::domain] is set, and this is not, this will be set to
+    /// `https://<domain>`, effectively making the `:authority` header consistent with the domain
+    /// override.
+    pub override_origin: Option<Uri>,
+    /// An API key to use for auth. If set, TLS will be enabled by default, but without any mTLS
+    /// specific settings.
+    pub api_key: Option<String>,
+    /// Retry configuration for the server client. Default is [RetryOptions::default]
+    #[builder(default)]
+    pub retry_options: RetryOptions,
+    /// If set, HTTP2 gRPC keep alive will be enabled.
+    /// To enable with default settings, use `.keep_alive(Some(ClientKeepAliveConfig::default()))`.
+    #[builder(required, default = Some(ClientKeepAliveOptions::default()))]
+    pub keep_alive: Option<ClientKeepAliveOptions>,
+    /// HTTP headers to include on every RPC call.
+    ///
+    /// These must be valid gRPC metadata keys, and must not be binary metadata keys (ending in
+    /// `-bin). To set binary headers, use [ConnectionOptions::binary_headers]. Invalid header keys
+    /// or values will cause an error to be returned when connecting.
+    pub headers: Option<HashMap<String, String>>,
+    /// HTTP headers to include on every RPC call as binary gRPC metadata (encoded as base64).
+    ///
+    /// These must be valid binary gRPC metadata keys (and end with a `-bin` suffix). Invalid
+    /// header keys will cause an error to be returned when connecting.
+    pub binary_headers: Option<HashMap<String, Vec<u8>>>,
+    /// HTTP CONNECT proxy to use for this client.
+    pub http_connect_proxy: Option<HttpConnectProxyOptions>,
+    /// If set true, error code labels will not be included on request failure metrics.
+    #[builder(default)]
+    pub disable_error_code_metric_tags: bool,
+    /// If set, all gRPC calls will be routed through the provided service.
+    pub service_override: Option<callback_based::CallbackBasedGrpcService>,
+
+    // Internal / Core-based SDK only options below =============================================
+    /// If set true, get_system_info will not be called upon connection.
+    #[builder(default)]
+    #[cfg_attr(feature = "core-based-sdk", builder(setters(vis = "pub")))]
+    pub(crate) skip_get_system_info: bool,
+    /// The name of the SDK being implemented on top of core. Is set as `client-name` header in
+    /// all RPC calls
+    #[builder(default = "temporal-rust".to_owned())]
+    #[cfg_attr(feature = "core-based-sdk", builder(setters(vis = "pub")))]
+    pub(crate) client_name: String,
+    // TODO [rust-sdk-branch]: SDK should set this to its version. Doing that probably easiest
+    // after adding proper client interceptors.
+    /// The version of the SDK being implemented on top of core. Is set as `client-version` header
+    /// in all RPC calls. The server decides if the client is supported based on this.
+    #[builder(default = VERSION.to_owned())]
+    #[cfg_attr(feature = "core-based-sdk", builder(setters(vis = "pub")))]
+    pub(crate) client_version: String,
+}
+
+// Setters/getters for fields that should only be touched by SDK implementers.
+#[cfg(feature = "core-based-sdk")]
+impl ConnectionOptions {
+    /// Set whether or not get_system_info will be called upon connection.
+    pub fn set_skip_get_system_info(&mut self, skip: bool) {
+        self.skip_get_system_info = skip;
+    }
+    /// Get whether or not get_system_info will be called upon connection.
+    pub fn get_skip_get_system_info(&self) -> bool {
+        self.skip_get_system_info
+    }
+    /// Get the name of the SDK being implemented on top of core.
+    pub fn get_client_name(&self) -> &str {
+        &self.client_name
+    }
+    /// Get the version of the SDK being implemented on top of core.
+    pub fn get_client_version(&self) -> &str {
+        &self.client_version
+    }
+}
+
+/// Options for [crate::Client::new].
+#[derive(Clone, Debug, bon::Builder)]
+#[non_exhaustive]
+#[builder(start_fn = new, on(String, into), state_mod(vis = "pub"))]
+pub struct ClientOptions {
+    /// The namespace this client will be bound to.
+    #[builder(start_fn)]
+    pub namespace: String,
+    /// The data converter used for serializing/deserializing payloads.
+    #[builder(default)]
+    pub data_converter: DataConverter,
+}
+
+/// Configuration options for TLS
+#[derive(Clone, Debug, Default)]
+pub struct TlsOptions {
+    /// Bytes representing the root CA certificate used by the server. If not set, and the server's
+    /// cert is issued by someone the operating system trusts, verification will still work (ex:
+    /// Cloud offering).
+    pub server_root_ca_cert: Option<Vec<u8>>,
+    /// Sets the domain name against which to verify the server's TLS certificate. If not provided,
+    /// the domain name will be extracted from the URL used to connect.
+    pub domain: Option<String>,
+    /// TLS info for the client. If specified, core will attempt to use mTLS.
+    pub client_tls_options: Option<ClientTlsOptions>,
+}
+
+/// If using mTLS, both the client cert and private key must be specified, this contains them.
+#[derive(Clone)]
+pub struct ClientTlsOptions {
+    /// The certificate for this client, encoded as PEM
+    pub client_cert: Vec<u8>,
+    /// The private key for this client, encoded as PEM
+    pub client_private_key: Vec<u8>,
+}
+
+/// Client keep alive configuration.
+#[derive(Clone, Debug)]
+pub struct ClientKeepAliveOptions {
+    /// Interval to send HTTP2 keep alive pings.
+    pub interval: Duration,
+    /// Timeout that the keep alive must be responded to within or the connection will be closed.
+    pub timeout: Duration,
+}
+
+impl Default for ClientKeepAliveOptions {
+    fn default() -> Self {
+        Self {
+            interval: Duration::from_secs(30),
+            timeout: Duration::from_secs(15),
+        }
+    }
+}
+
+impl std::fmt::Debug for ClientTlsOptions {
+    // Intentionally omit details here since they could leak a key if ever printed
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "ClientTlsOptions(..)")
+    }
+}
+
+/// Options for starting a workflow execution.
+#[derive(Debug, Clone, bon::Builder)]
+#[builder(start_fn = new, on(String, into))]
+#[non_exhaustive]
+pub struct WorkflowStartOptions {
+    /// The task queue to run the workflow on.
+    #[builder(start_fn)]
+    pub task_queue: String,
+
+    /// The workflow ID.
+    #[builder(start_fn)]
+    pub workflow_id: String,
+
+    /// Set the policy for reusing the workflow id
+    #[builder(default)]
+    pub id_reuse_policy: WorkflowIdReusePolicy,
+
+    /// Set the policy for how to resolve conflicts with running policies.
+    /// NOTE: This is ignored for child workflows.
+    #[builder(default)]
+    pub id_conflict_policy: WorkflowIdConflictPolicy,
+
+    /// Optionally set the execution timeout for the workflow
+    /// <https://docs.temporal.io/workflows/#workflow-execution-timeout>
+    pub execution_timeout: Option<Duration>,
+
+    /// Optionally indicates the default run timeout for a workflow run
+    pub run_timeout: Option<Duration>,
+
+    /// Optionally indicates the default task timeout for a workflow run
+    pub task_timeout: Option<Duration>,
+
+    /// Optionally set a cron schedule for the workflow
+    pub cron_schedule: Option<String>,
+
+    /// Optionally associate extra search attributes with a workflow
+    pub search_attributes: Option<HashMap<String, Payload>>,
+
+    /// Optionally enable Eager Workflow Start, a latency optimization using local workers
+    /// NOTE: Experimental
+    #[builder(default)]
+    pub enable_eager_workflow_start: bool,
+
+    /// Optionally set a retry policy for the workflow
+    pub retry_policy: Option<common::v1::RetryPolicy>,
+
+    /// If set, send a signal to the workflow atomically with start.
+    /// The workflow will receive this signal before its first task.
+    pub start_signal: Option<WorkflowStartSignal>,
+
+    /// Links to associate with the workflow. Ex: References to a nexus operation.
+    #[builder(default)]
+    pub links: Vec<common::v1::Link>,
+
+    /// Callbacks that will be invoked upon workflow completion. For, ex, completing nexus
+    /// operations.
+    #[builder(default)]
+    pub completion_callbacks: Vec<common::v1::Callback>,
+
+    /// Priority for the workflow. Defaults to all-inherited (empty).
+    #[builder(default)]
+    pub priority: Priority,
+
+    /// Headers to include with the start request.
+    pub header: Option<Header>,
+}
+
+/// A signal to send atomically when starting a workflow.
+/// Use with `WorkflowStartOptions::start_signal` to achieve signal-with-start behavior.
+#[derive(Debug, Clone, bon::Builder)]
+#[builder(start_fn = new, on(String, into))]
+#[non_exhaustive]
+pub struct WorkflowStartSignal {
+    /// Name of the signal to send.
+    #[builder(start_fn)]
+    pub signal_name: String,
+    /// Payload for the signal.
+    pub input: Option<Payloads>,
+    /// Headers for the signal.
+    pub header: Option<Header>,
+}
+
+pub use temporalio_common::Priority;
+
+/// Options for fetching workflow results
+#[derive(Debug, Clone, Copy, bon::Builder)]
+#[non_exhaustive]
+pub struct WorkflowGetResultOptions {
+    /// If true (the default), follows to the next workflow run in the execution chain while
+    /// retrieving results.
+    #[builder(default = true)]
+    pub follow_runs: bool,
+}
+impl Default for WorkflowGetResultOptions {
+    fn default() -> Self {
+        Self { follow_runs: true }
+    }
+}
+
+/// Options for starting a workflow update.
+#[derive(Debug, Clone, Default, bon::Builder)]
+#[non_exhaustive]
+pub struct WorkflowExecuteUpdateOptions {
+    /// Update ID for idempotency.
+    pub update_id: Option<String>,
+    /// Headers to include.
+    pub header: Option<Header>,
+}
+
+/// Options for sending a signal to a workflow.
+#[derive(Debug, Clone, Default, bon::Builder)]
+#[non_exhaustive]
+pub struct WorkflowSignalOptions {
+    /// Request ID for idempotency. If not provided, a UUID will be generated.
+    pub request_id: Option<String>,
+    /// Headers to include with the signal.
+    pub header: Option<Header>,
+}
+
+/// Options for querying a workflow.
+#[derive(Debug, Clone, Default, bon::Builder)]
+#[non_exhaustive]
+pub struct WorkflowQueryOptions {
+    /// Query reject condition. Determines when the query should be rejected
+    /// based on workflow state.
+    pub reject_condition: Option<QueryRejectCondition>,
+    /// Headers to include with the query.
+    pub header: Option<Header>,
+}
+
+/// Options for cancelling a workflow.
+#[derive(Debug, Clone, Default, bon::Builder)]
+#[builder(on(String, into))]
+#[non_exhaustive]
+pub struct WorkflowCancelOptions {
+    /// Reason for cancellation.
+    #[builder(default)]
+    pub reason: String,
+    /// Request ID for idempotency. If not provided, a UUID will be generated.
+    pub request_id: Option<String>,
+}
+
+/// Options for terminating a workflow.
+#[derive(Debug, Clone, Default, bon::Builder)]
+#[builder(on(String, into))]
+#[non_exhaustive]
+pub struct WorkflowTerminateOptions {
+    /// Reason for termination.
+    #[builder(default)]
+    pub reason: String,
+    /// Additional details to include with the termination.
+    pub details: Option<Payloads>,
+}
+
+/// Options for describing a workflow.
+#[derive(Debug, Clone, Default, bon::Builder)]
+#[non_exhaustive]
+pub struct WorkflowDescribeOptions {}
+
+/// Default workflow execution retention for a Namespace is 3 days
+const DEFAULT_WORKFLOW_EXECUTION_RETENTION_PERIOD: Duration = Duration::from_secs(60 * 60 * 24 * 3);
+
+/// Helper struct for `register_namespace`.
+#[derive(Clone, Debug, bon::Builder)]
+#[builder(on(String, into))]
+pub struct RegisterNamespaceOptions {
+    /// Name (required)
+    pub namespace: String,
+    /// Description (required)
+    pub description: String,
+    /// Owner's email
+    #[builder(default)]
+    pub owner_email: String,
+    /// Workflow execution retention period
+    #[builder(default = DEFAULT_WORKFLOW_EXECUTION_RETENTION_PERIOD)]
+    pub workflow_execution_retention_period: Duration,
+    /// Cluster settings
+    #[builder(default)]
+    pub clusters: Vec<ClusterReplicationConfig>,
+    /// Active cluster name
+    #[builder(default)]
+    pub active_cluster_name: String,
+    /// Custom Data
+    #[builder(default)]
+    pub data: HashMap<String, String>,
+    /// Security Token
+    #[builder(default)]
+    pub security_token: String,
+    /// Global namespace
+    #[builder(default)]
+    pub is_global_namespace: bool,
+    /// History Archival setting
+    #[builder(default = ArchivalState::Unspecified)]
+    pub history_archival_state: ArchivalState,
+    /// History Archival uri
+    #[builder(default)]
+    pub history_archival_uri: String,
+    /// Visibility Archival setting
+    #[builder(default = ArchivalState::Unspecified)]
+    pub visibility_archival_state: ArchivalState,
+    /// Visibility Archival uri
+    #[builder(default)]
+    pub visibility_archival_uri: String,
+}
+
+impl From<RegisterNamespaceOptions> for RegisterNamespaceRequest {
+    fn from(val: RegisterNamespaceOptions) -> Self {
+        RegisterNamespaceRequest {
+            namespace: val.namespace,
+            description: val.description,
+            owner_email: val.owner_email,
+            workflow_execution_retention_period: val
+                .workflow_execution_retention_period
+                .try_into()
+                .ok(),
+            clusters: val.clusters,
+            active_cluster_name: val.active_cluster_name,
+            data: val.data,
+            security_token: val.security_token,
+            is_global_namespace: val.is_global_namespace,
+            history_archival_state: val.history_archival_state as i32,
+            history_archival_uri: val.history_archival_uri,
+            visibility_archival_state: val.visibility_archival_state as i32,
+            visibility_archival_uri: val.visibility_archival_uri,
+        }
+    }
+}
+
+/// Options for fetching workflow history.
+#[derive(Debug, Clone, Default, bon::Builder)]
+#[non_exhaustive]
+pub struct WorkflowFetchHistoryOptions {
+    /// Whether to skip archival.
+    #[builder(default)]
+    pub skip_archival: bool,
+    /// If set true, the fetch will wait for a new event before returning.
+    #[builder(default)]
+    pub wait_new_event: bool,
+    /// Specifies which kind of events will be retrieved. Defaults to all events.
+    #[builder(default = HistoryEventFilterType::AllEvent)]
+    pub event_filter_type: HistoryEventFilterType,
+}
+
+/// Which lifecycle stage to wait for when starting an update.
+#[derive(Debug, Clone, Copy, Default, PartialEq, Eq)]
+pub enum WorkflowUpdateWaitStage {
+    /// This stage is reached when the server receives the update to process.
+    /// This is currently an invalid value on start.
+    Admitted,
+    /// Wait until the update is accepted by the workflow (validator passed).
+    #[default]
+    Accepted,
+    /// Wait until the update has completed.
+    Completed,
+}
+
+/// Options for starting an update without waiting for completion.
+#[derive(Debug, Clone, Default, bon::Builder)]
+#[non_exhaustive]
+pub struct WorkflowStartUpdateOptions {
+    /// Update ID for idempotency. If not provided, a UUID will be generated.
+    pub update_id: Option<String>,
+    /// Headers to include with the update.
+    pub header: Option<Header>,
+    /// The lifecycle stage to wait for before returning the handle.
+    #[builder(default)]
+    pub wait_for_stage: WorkflowUpdateWaitStage,
+}
+
+/// Options for listing workflows.
+#[derive(Debug, Clone, Default, bon::Builder)]
+#[non_exhaustive]
+pub struct WorkflowListOptions {
+    /// Maximum number of workflows to return.
+    /// If not specified, returns all matching workflows.
+    pub limit: Option<usize>,
+}
+
+/// Options for counting workflows.
+#[derive(Debug, Clone, Default, bon::Builder)]
+#[non_exhaustive]
+pub struct WorkflowCountOptions {}

package/sdk-core/crates/client/src/replaceable.rs

@@ -20,8 +20,8 @@ where
     C: Clone + Send + Sync,
 {
     shared_data: Arc<SharedClientData<C>>,
-    cloned_client: C,
-    cloned_generation: u32,
+    pub(crate) cloned_client: C,
+    pub(crate) cloned_generation: u32,
 }
 
 #[derive(Debug)]
@@ -83,6 +83,7 @@ where
     }
 
     /// Returns a clone of the underlying client.
+    #[allow(dead_code)]
     pub fn inner_clone(&self) -> C {
         self.inner_cow().into_owned()
     }
@@ -105,7 +106,8 @@ where
     ///
     /// While this method allows mutable access to the underlying client, any configuration changes
     /// will not be shared with other instances, and will be lost if the client gets replaced from
-    /// anywhere. To make configuration changes, use [`replace_client()`](Self::replace_client) instead.
+    /// anywhere. To make configuration changes, use [`replace_client()`](Self::replace_client)
+    /// instead.
     pub fn inner_mut_refreshed(&mut self) -> &mut C {
         if let Some((client, generation)) =
             self.shared_data.fetch_newer_than(self.cloned_generation)
@@ -152,7 +154,6 @@ where
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::NamespacedClient;
     use std::borrow::Cow;
 
     #[derive(Debug, Clone)]

package/sdk-core/crates/client/src/request_extensions.rs

@@ -1,27 +1,26 @@
 //! Request extensions for tonic gRPC requests.
 //!
-//! These types can be inserted into tonic request extensions to modify behavior of the
-//! [RetryClient](crate::RetryClient) or other request handling logic.
+//! These types can be inserted into tonic request extensions to modify behavior of retires or other
+//! request handling logic.
 
 use crate::RetryOptions;
 use std::time::Duration;
 
-/// A request extension that, when set, should make the [RetryClient](crate::RetryClient) consider
-/// this call to be a [CallType::TaskLongPoll](crate::CallType::TaskLongPoll)
+/// A request extension that, when set, should make the retry behavior consider this call to be a
+/// [CallType::TaskLongPoll](crate::CallType::TaskLongPoll)
 #[derive(Copy, Clone, Debug)]
 pub struct IsWorkerTaskLongPoll;
 
-/// A request extension that, when set, and a call is being processed by a
-/// [RetryClient](crate::RetryClient), allows the caller to request certain matching errors to
-/// short-circuit-return immediately and not follow normal retry logic.
+/// A request extension that, when set, and a call is being processed by a retrying client, allows
+/// the caller to request certain matching errors to short-circuit-return immediately and not follow
+/// normal retry logic.
 #[derive(Copy, Clone, Debug)]
 pub struct NoRetryOnMatching {
     /// Return true if the passed-in gRPC error should be immediately returned to the caller
     pub predicate: fn(&tonic::Status) -> bool,
 }
 
-/// A request extension that forces overriding the current retry policy of the
-/// [RetryClient](crate::RetryClient).
+/// A request extension that forces overriding the current retry policy of the [crate::Connection].
 #[derive(Clone, Debug)]
 pub struct RetryConfigForCall(pub RetryOptions);