@temporalio/core-bridge 1.13.0 → 1.13.2

package/sdk-core/client/src/lib.rs

@@ -9,8 +9,11 @@ extern crate tracing;
 
 pub mod callback_based;
 mod metrics;
-mod proxy;
+/// Visible only for tests
+#[doc(hidden)]
+pub mod proxy;
 mod raw;
+mod replaceable;
 mod retry;
 mod worker_registry;
 mod workflow_handle;
@@ -21,6 +24,7 @@ pub use crate::{
 };
 pub use metrics::{LONG_REQUEST_LATENCY_HISTOGRAM_NAME, REQUEST_LATENCY_HISTOGRAM_NAME};
 pub use raw::{CloudService, HealthService, OperatorService, TestService, WorkflowService};
+pub use replaceable::SharedReplaceableClient;
 pub use temporal_sdk_core_protos::temporal::api::{
     enums::v1::ArchivalState,
     filter::v1::{StartTimeFilter, StatusFilter, WorkflowExecutionFilter, WorkflowTypeFilter},
@@ -37,7 +41,7 @@ pub use workflow_handle::{
 
 use crate::{
     metrics::{ChannelOrGrpcOverride, GrpcMetricSvc, MetricsContext},
-    raw::{AttachMetricLabels, sealed::RawClientLike},
+    raw::AttachMetricLabels,
     sealed::WfHandleClient,
     workflow_handle::UntypedWorkflowHandle,
 };
@@ -72,11 +76,14 @@ use temporal_sdk_core_protos::{
     },
 };
 use tonic::{
-    Code,
+    Code, IntoRequest,
     body::Body,
     client::GrpcService,
     codegen::InterceptedService,
-    metadata::{MetadataKey, MetadataMap, MetadataValue},
+    metadata::{
+        AsciiMetadataKey, AsciiMetadataValue, BinaryMetadataKey, BinaryMetadataValue, MetadataMap,
+        MetadataValue,
+    },
     service::Interceptor,
     transport::{Certificate, Channel, Endpoint, Identity},
 };
@@ -144,9 +151,20 @@ pub struct ClientOptions {
     pub keep_alive: Option<ClientKeepAliveConfig>,
 
     /// 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 [ClientOptions::binary_headers]. Invalid header keys or
+    /// values will cause an error to be returned when connecting.
     #[builder(default)]
     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.
+    #[builder(default)]
+    pub binary_headers: Option<HashMap<String, Vec<u8>>>,
+
     /// API key which is set as the "Authorization" header with "Bearer " prepended. This will only
     /// be applied if the headers don't already have an "Authorization" header.
     #[builder(default)]
@@ -320,6 +338,9 @@ pub enum ClientInitError {
     /// Invalid URI. Configuration error, fatal.
     #[error("Invalid URI: {0:?}")]
     InvalidUri(#[from] InvalidUri),
+    /// Invalid gRPC metadata headers. Configuration error.
+    #[error("Invalid headers: {0}")]
+    InvalidHeaders(#[from] InvalidHeaderError),
     /// Server connection error. Crashing and restarting the worker is likely best.
     #[error("Server connection error: {0:?}")]
     TonicTransportError(#[from] tonic::transport::Error),
@@ -329,6 +350,37 @@ pub enum ClientInitError {
     SystemInfoCallError(tonic::Status),
 }
 
+/// Errors thrown when a gRPC metadata header is invalid.
+#[derive(thiserror::Error, Debug)]
+pub enum InvalidHeaderError {
+    /// A binary header key was invalid
+    #[error("Invalid binary header key '{key}': {source}")]
+    InvalidBinaryHeaderKey {
+        /// The invalid key
+        key: String,
+        /// The source error from tonic
+        source: tonic::metadata::errors::InvalidMetadataKey,
+    },
+    /// An ASCII header key was invalid
+    #[error("Invalid ASCII header key '{key}': {source}")]
+    InvalidAsciiHeaderKey {
+        /// The invalid key
+        key: String,
+        /// The source error from tonic
+        source: tonic::metadata::errors::InvalidMetadataKey,
+    },
+    /// An ASCII header value was invalid
+    #[error("Invalid ASCII header value for key '{key}': {source}")]
+    InvalidAsciiHeaderValue {
+        /// The key
+        key: String,
+        /// The invalid value
+        value: String,
+        /// The source error from tonic
+        source: tonic::metadata::errors::InvalidMetadataValue,
+    },
+}
+
 /// A client with [ClientOptions] attached, which can be passed to initialize workers,
 /// or can be used directly. Is cheap to clone.
 #[derive(Clone, Debug)]
@@ -342,9 +394,33 @@ pub struct ConfiguredClient<C> {
 }
 
 impl<C> ConfiguredClient<C> {
-    /// Set HTTP request headers overwriting previous headers
-    pub fn set_headers(&self, headers: HashMap<String, String>) {
-        self.headers.write().user_headers = headers;
+    /// Set HTTP request headers overwriting previous headers.
+    ///
+    /// This will not affect headers set via [ClientOptions::binary_headers].
+    ///
+    /// # Errors
+    ///
+    /// Will return an error if any of the provided keys or values are not valid gRPC metadata.
+    /// If an error is returned, the previous headers will remain unchanged.
+    pub fn set_headers(&self, headers: HashMap<String, String>) -> Result<(), InvalidHeaderError> {
+        self.headers.write().user_headers = parse_ascii_headers(headers)?;
+        Ok(())
+    }
+
+    /// Set binary HTTP request headers overwriting previous headers.
+    ///
+    /// This will not affect headers set via [ClientOptions::headers].
+    ///
+    /// # Errors
+    ///
+    /// Will return an error if any of the provided keys are not valid gRPC binary metadata keys.
+    /// If an error is returned, the previous headers will remain unchanged.
+    pub fn set_binary_headers(
+        &self,
+        binary_headers: HashMap<String, Vec<u8>>,
+    ) -> Result<(), InvalidHeaderError> {
+        self.headers.write().user_binary_headers = parse_binary_headers(binary_headers)?;
+        Ok(())
     }
 
     /// Set API key, overwriting previous
@@ -371,7 +447,8 @@ impl<C> ConfiguredClient<C> {
 
 #[derive(Debug)]
 struct ClientHeaders {
-    user_headers: HashMap<String, String>,
+    user_headers: HashMap<AsciiMetadataKey, AsciiMetadataValue>,
+    user_binary_headers: HashMap<BinaryMetadataKey, BinaryMetadataValue>,
     api_key: Option<String>,
 }
 
@@ -380,10 +457,13 @@ impl ClientHeaders {
         for (key, val) in self.user_headers.iter() {
             // Only if not already present
             if !metadata.contains_key(key) {
-                // Ignore invalid keys/values
-                if let (Ok(key), Ok(val)) = (MetadataKey::from_str(key), val.parse()) {
-                    metadata.insert(key, val);
-                }
+                metadata.insert(key, val.clone());
+            }
+        }
+        for (key, val) in self.user_binary_headers.iter() {
+            // Only if not already present
+            if !metadata.contains_key(key) {
+                metadata.insert_bin(key, val.clone());
             }
         }
         if let Some(api_key) = &self.api_key {
@@ -433,8 +513,7 @@ impl ClientOptions {
     pub async fn connect_no_namespace(
         &self,
         metrics_meter: Option<TemporalMeter>,
-    ) -> Result<RetryClient<ConfiguredClient<TemporalServiceClientWithMetrics>>, ClientInitError>
-    {
+    ) -> Result<RetryClient<ConfiguredClient<TemporalServiceClient>>, ClientInitError> {
         self.connect_no_namespace_with_service_override(metrics_meter, None)
             .await
     }
@@ -449,8 +528,7 @@ impl ClientOptions {
         &self,
         metrics_meter: Option<TemporalMeter>,
         service_override: Option<callback_based::CallbackBasedGrpcService>,
-    ) -> Result<RetryClient<ConfiguredClient<TemporalServiceClientWithMetrics>>, ClientInitError>
-    {
+    ) -> Result<RetryClient<ConfiguredClient<TemporalServiceClient>>, ClientInitError> {
         let service = if let Some(service_override) = service_override {
             GrpcMetricSvc {
                 inner: ChannelOrGrpcOverride::GrpcOverride(service_override),
@@ -489,7 +567,10 @@ impl ClientOptions {
         };
 
         let headers = Arc::new(RwLock::new(ClientHeaders {
-            user_headers: self.headers.clone().unwrap_or_default(),
+            user_headers: parse_ascii_headers(self.headers.clone().unwrap_or_default())?,
+            user_binary_headers: parse_binary_headers(
+                self.binary_headers.clone().unwrap_or_default(),
+            )?,
             api_key: self.api_key.clone(),
         }));
         let interceptor = ServiceCallInterceptor {
@@ -507,7 +588,7 @@ impl ClientOptions {
         };
         if !self.skip_get_system_info {
             match client
-                .get_system_info(GetSystemInfoRequest::default())
+                .get_system_info(GetSystemInfoRequest::default().into_request())
                 .await
             {
                 Ok(sysinfo) => {
@@ -526,11 +607,13 @@ impl ClientOptions {
     /// Passes it through if TLS options not set.
     async fn add_tls_to_channel(&self, mut channel: Endpoint) -> Result<Endpoint, ClientInitError> {
         if let Some(tls_cfg) = &self.tls_cfg {
-            let mut tls = tonic::transport::ClientTlsConfig::new().with_native_roots();
+            let mut tls = tonic::transport::ClientTlsConfig::new();
 
             if let Some(root_cert) = &tls_cfg.server_root_ca_cert {
                 let server_root_ca_cert = Certificate::from_pem(root_cert);
                 tls = tls.ca_certificate(server_root_ca_cert);
+            } else {
+                tls = tls.with_native_roots();
             }
 
             if let Some(domain) = &tls_cfg.domain {
@@ -556,6 +639,57 @@ impl ClientOptions {
     }
 }
 
+fn parse_ascii_headers(
+    headers: HashMap<String, String>,
+) -> Result<HashMap<AsciiMetadataKey, AsciiMetadataValue>, InvalidHeaderError> {
+    let mut parsed_headers = HashMap::with_capacity(headers.len());
+    for (k, v) in headers.into_iter() {
+        let key = match AsciiMetadataKey::from_str(&k) {
+            Ok(key) => key,
+            Err(err) => {
+                return Err(InvalidHeaderError::InvalidAsciiHeaderKey {
+                    key: k,
+                    source: err,
+                });
+            }
+        };
+        let value = match MetadataValue::from_str(&v) {
+            Ok(value) => value,
+            Err(err) => {
+                return Err(InvalidHeaderError::InvalidAsciiHeaderValue {
+                    key: k,
+                    value: v,
+                    source: err,
+                });
+            }
+        };
+        parsed_headers.insert(key, value);
+    }
+
+    Ok(parsed_headers)
+}
+
+fn parse_binary_headers(
+    headers: HashMap<String, Vec<u8>>,
+) -> Result<HashMap<BinaryMetadataKey, BinaryMetadataValue>, InvalidHeaderError> {
+    let mut parsed_headers = HashMap::with_capacity(headers.len());
+    for (k, v) in headers.into_iter() {
+        let key = match BinaryMetadataKey::from_str(&k) {
+            Ok(key) => key,
+            Err(err) => {
+                return Err(InvalidHeaderError::InvalidBinaryHeaderKey {
+                    key: k,
+                    source: err,
+                });
+            }
+        };
+        let value = BinaryMetadataValue::from_bytes(&v);
+        parsed_headers.insert(key, value);
+    }
+
+    Ok(parsed_headers)
+}
+
 /// Interceptor which attaches common metadata (like "client-name") to every outgoing call
 #[derive(Clone)]
 pub struct ServiceCallInterceptor {
@@ -598,14 +732,13 @@ impl Interceptor for ServiceCallInterceptor {
 }
 
 /// Aggregates various services exposed by the Temporal server
-#[derive(Debug, Clone)]
-pub struct TemporalServiceClient<T> {
-    svc: T,
-    workflow_svc_client: OnceLock<WorkflowServiceClient<T>>,
-    operator_svc_client: OnceLock<OperatorServiceClient<T>>,
-    cloud_svc_client: OnceLock<CloudServiceClient<T>>,
-    test_svc_client: OnceLock<TestServiceClient<T>>,
-    health_svc_client: OnceLock<HealthClient<T>>,
+#[derive(Clone)]
+pub struct TemporalServiceClient {
+    workflow_svc_client: Box<dyn WorkflowService>,
+    operator_svc_client: Box<dyn OperatorService>,
+    cloud_svc_client: Box<dyn CloudService>,
+    test_svc_client: Box<dyn TestService>,
+    health_svc_client: Box<dyn HealthService>,
 }
 
 /// We up the limit on incoming messages from server from the 4Mb default to 128Mb. If for
@@ -620,136 +753,100 @@ fn get_decode_max_size() -> usize {
     })
 }
 
-impl<T> TemporalServiceClient<T>
-where
-    T: Clone,
-    T: GrpcService<Body> + Send + Clone + 'static,
-    T::ResponseBody: tonic::codegen::Body<Data = tonic::codegen::Bytes> + Send + 'static,
-    T::Error: Into<tonic::codegen::StdError>,
-    <T::ResponseBody as tonic::codegen::Body>::Error: Into<tonic::codegen::StdError> + Send,
-{
-    fn new(svc: T) -> Self {
+impl TemporalServiceClient {
+    fn new<T>(svc: T) -> Self
+    where
+        T: GrpcService<Body> + Send + Sync + Clone + 'static,
+        T::ResponseBody: tonic::codegen::Body<Data = tonic::codegen::Bytes> + Send + 'static,
+        T::Error: Into<tonic::codegen::StdError>,
+        <T::ResponseBody as tonic::codegen::Body>::Error: Into<tonic::codegen::StdError> + Send,
+        <T as GrpcService<Body>>::Future: Send,
+    {
+        let workflow_svc_client = Box::new(
+            WorkflowServiceClient::new(svc.clone())
+                .max_decoding_message_size(get_decode_max_size()),
+        );
+        let operator_svc_client = Box::new(
+            OperatorServiceClient::new(svc.clone())
+                .max_decoding_message_size(get_decode_max_size()),
+        );
+        let cloud_svc_client = Box::new(
+            CloudServiceClient::new(svc.clone()).max_decoding_message_size(get_decode_max_size()),
+        );
+        let test_svc_client = Box::new(
+            TestServiceClient::new(svc.clone()).max_decoding_message_size(get_decode_max_size()),
+        );
+        let health_svc_client = Box::new(
+            HealthClient::new(svc.clone()).max_decoding_message_size(get_decode_max_size()),
+        );
+
+        Self {
+            workflow_svc_client,
+            operator_svc_client,
+            cloud_svc_client,
+            test_svc_client,
+            health_svc_client,
+        }
+    }
+
+    /// Create a service client from implementations of the individual underlying services. Useful
+    /// for mocking out service implementations.
+    pub fn from_services(
+        workflow: Box<dyn WorkflowService>,
+        operator: Box<dyn OperatorService>,
+        cloud: Box<dyn CloudService>,
+        test: Box<dyn TestService>,
+        health: Box<dyn HealthService>,
+    ) -> Self {
         Self {
-            svc,
-            workflow_svc_client: OnceLock::new(),
-            operator_svc_client: OnceLock::new(),
-            cloud_svc_client: OnceLock::new(),
-            test_svc_client: OnceLock::new(),
-            health_svc_client: OnceLock::new(),
+            workflow_svc_client: workflow,
+            operator_svc_client: operator,
+            cloud_svc_client: cloud,
+            test_svc_client: test,
+            health_svc_client: health,
         }
     }
+
     /// Get the underlying workflow service client
-    pub fn workflow_svc(&self) -> &WorkflowServiceClient<T> {
-        self.workflow_svc_client.get_or_init(|| {
-            WorkflowServiceClient::new(self.svc.clone())
-                .max_decoding_message_size(get_decode_max_size())
-        })
+    pub fn workflow_svc(&self) -> Box<dyn WorkflowService> {
+        self.workflow_svc_client.clone()
     }
     /// Get the underlying operator service client
-    pub fn operator_svc(&self) -> &OperatorServiceClient<T> {
-        self.operator_svc_client.get_or_init(|| {
-            OperatorServiceClient::new(self.svc.clone())
-                .max_decoding_message_size(get_decode_max_size())
-        })
+    pub fn operator_svc(&self) -> Box<dyn OperatorService> {
+        self.operator_svc_client.clone()
     }
     /// Get the underlying cloud service client
-    pub fn cloud_svc(&self) -> &CloudServiceClient<T> {
-        self.cloud_svc_client.get_or_init(|| {
-            CloudServiceClient::new(self.svc.clone())
-                .max_decoding_message_size(get_decode_max_size())
-        })
+    pub fn cloud_svc(&self) -> Box<dyn CloudService> {
+        self.cloud_svc_client.clone()
     }
     /// Get the underlying test service client
-    pub fn test_svc(&self) -> &TestServiceClient<T> {
-        self.test_svc_client.get_or_init(|| {
-            TestServiceClient::new(self.svc.clone())
-                .max_decoding_message_size(get_decode_max_size())
-        })
+    pub fn test_svc(&self) -> Box<dyn TestService> {
+        self.test_svc_client.clone()
     }
     /// Get the underlying health service client
-    pub fn health_svc(&self) -> &HealthClient<T> {
-        self.health_svc_client.get_or_init(|| {
-            HealthClient::new(self.svc.clone()).max_decoding_message_size(get_decode_max_size())
-        })
-    }
-    /// Get the underlying workflow service client mutably
-    pub fn workflow_svc_mut(&mut self) -> &mut WorkflowServiceClient<T> {
-        let _ = self.workflow_svc();
-        self.workflow_svc_client.get_mut().unwrap()
-    }
-    /// Get the underlying operator service client mutably
-    pub fn operator_svc_mut(&mut self) -> &mut OperatorServiceClient<T> {
-        let _ = self.operator_svc();
-        self.operator_svc_client.get_mut().unwrap()
-    }
-    /// Get the underlying cloud service client mutably
-    pub fn cloud_svc_mut(&mut self) -> &mut CloudServiceClient<T> {
-        let _ = self.cloud_svc();
-        self.cloud_svc_client.get_mut().unwrap()
-    }
-    /// Get the underlying test service client mutably
-    pub fn test_svc_mut(&mut self) -> &mut TestServiceClient<T> {
-        let _ = self.test_svc();
-        self.test_svc_client.get_mut().unwrap()
-    }
-    /// Get the underlying health service client mutably
-    pub fn health_svc_mut(&mut self) -> &mut HealthClient<T> {
-        let _ = self.health_svc();
-        self.health_svc_client.get_mut().unwrap()
+    pub fn health_svc(&self) -> Box<dyn HealthService> {
+        self.health_svc_client.clone()
     }
 }
 
-/// A [WorkflowServiceClient] with the default interceptors attached.
-pub type WorkflowServiceClientWithMetrics = WorkflowServiceClient<InterceptedMetricsSvc>;
-/// An [OperatorServiceClient] with the default interceptors attached.
-pub type OperatorServiceClientWithMetrics = OperatorServiceClient<InterceptedMetricsSvc>;
-/// An [TestServiceClient] with the default interceptors attached.
-pub type TestServiceClientWithMetrics = TestServiceClient<InterceptedMetricsSvc>;
-/// A [TemporalServiceClient] with the default interceptors attached.
-pub type TemporalServiceClientWithMetrics = TemporalServiceClient<InterceptedMetricsSvc>;
-type InterceptedMetricsSvc = InterceptedService<GrpcMetricSvc, ServiceCallInterceptor>;
-
 /// Contains an instance of a namespace-bound client for interacting with the Temporal server
-#[derive(Debug, Clone)]
+#[derive(Clone)]
 pub struct Client {
     /// Client for interacting with workflow service
-    inner: ConfiguredClient<TemporalServiceClientWithMetrics>,
+    inner: ConfiguredClient<TemporalServiceClient>,
     /// The namespace this client interacts with
     namespace: String,
 }
 
 impl Client {
     /// Create a new client from an existing configured lower level client and a namespace
-    pub fn new(
-        client: ConfiguredClient<TemporalServiceClientWithMetrics>,
-        namespace: String,
-    ) -> Self {
+    pub fn new(client: ConfiguredClient<TemporalServiceClient>, namespace: String) -> Self {
         Client {
             inner: client,
             namespace,
         }
     }
 
-    /// Return an auto-retrying version of the underling grpc client (instrumented with metrics
-    /// collection, if enabled).
-    ///
-    /// Note that it is reasonably cheap to clone the returned type if you need to own it. Such
-    /// clones will keep re-using the same channel.
-    pub fn raw_retry_client(&self) -> RetryClient<WorkflowServiceClientWithMetrics> {
-        RetryClient::new(
-            self.raw_client().clone(),
-            self.inner.options.retry_config.clone(),
-        )
-    }
-
-    /// Access the underling grpc client. This raw client is not bound to a specific namespace.
-    ///
-    /// Note that it is reasonably cheap to clone the returned type if you need to own it. Such
-    /// clones will keep re-using the same channel.
-    pub fn raw_client(&self) -> &WorkflowServiceClientWithMetrics {
-        self.inner.workflow_svc()
-    }
-
     /// Return the options this client was initialized with
     pub fn options(&self) -> &ClientOptions {
         &self.inner.options
@@ -761,23 +858,23 @@ impl Client {
     }
 
     /// Returns a reference to the underlying client
-    pub fn inner(&self) -> &ConfiguredClient<TemporalServiceClientWithMetrics> {
+    pub fn inner(&self) -> &ConfiguredClient<TemporalServiceClient> {
         &self.inner
     }
 
     /// Consumes self and returns the underlying client
-    pub fn into_inner(self) -> ConfiguredClient<TemporalServiceClientWithMetrics> {
+    pub fn into_inner(self) -> ConfiguredClient<TemporalServiceClient> {
         self.inner
     }
 }
 
 impl NamespacedClient for Client {
-    fn namespace(&self) -> &str {
-        &self.namespace
+    fn namespace(&self) -> String {
+        self.namespace.clone()
     }
 
-    fn get_identity(&self) -> &str {
-        &self.inner.options.identity
+    fn identity(&self) -> String {
+        self.inner.options.identity.clone()
     }
 }
 
@@ -1100,9 +1197,9 @@ pub trait WorkflowClientTrait: NamespacedClient {
 /// A client that is bound to a namespace
 pub trait NamespacedClient {
     /// Returns the namespace this client is bound to
-    fn namespace(&self) -> &str;
+    fn namespace(&self) -> String;
     /// Returns the client identity
-    fn get_identity(&self) -> &str;
+    fn identity(&self) -> String;
 }
 
 /// Optional fields supplied at the start of workflow execution
@@ -1242,15 +1339,7 @@ impl From<common::v1::Priority> for Priority {
 #[async_trait::async_trait]
 impl<T> WorkflowClientTrait for T
 where
-    T: RawClientLike + NamespacedClient + Clone + Send + Sync + 'static,
-    <Self as RawClientLike>::SvcType: GrpcService<Body> + Send + Clone + 'static,
-    <<Self as RawClientLike>::SvcType as GrpcService<Body>>::ResponseBody:
-    tonic::codegen::Body<Data = tonic::codegen::Bytes> + Send + 'static,
-    <<Self as RawClientLike>::SvcType as GrpcService<Body>>::Error:
-    Into<tonic::codegen::StdError>,
-    <<Self as RawClientLike>::SvcType as GrpcService<Body>>::Future: Send,
-    <<<Self as RawClientLike>::SvcType as GrpcService<Body>>::ResponseBody
-    as tonic::codegen::Body>::Error: Into<tonic::codegen::StdError> + Send,
+    T: WorkflowService + NamespacedClient + Clone + Send + Sync + 'static,
 {
     async fn start_workflow(
         &self,
@@ -1263,35 +1352,38 @@ where
     ) -> Result<StartWorkflowExecutionResponse> {
         Ok(self
             .clone()
-            .start_workflow_execution(StartWorkflowExecutionRequest {
-                namespace: self.namespace().to_owned(),
-                input: input.into_payloads(),
-                workflow_id,
-                workflow_type: Some(WorkflowType {
-                    name: workflow_type,
-                }),
-                task_queue: Some(TaskQueue {
-                    name: task_queue,
-                    kind: TaskQueueKind::Unspecified as i32,
-                    normal_name: "".to_string(),
-                }),
-                request_id: request_id.unwrap_or_else(|| Uuid::new_v4().to_string()),
-                workflow_id_reuse_policy: options.id_reuse_policy as i32,
-                workflow_id_conflict_policy: options.id_conflict_policy as i32,
-                workflow_execution_timeout: options
-                    .execution_timeout
-                    .and_then(|d| d.try_into().ok()),
-                workflow_run_timeout: options.run_timeout.and_then(|d| d.try_into().ok()),
-                workflow_task_timeout: options.task_timeout.and_then(|d| d.try_into().ok()),
-                search_attributes: options.search_attributes.map(|d| d.into()),
-                cron_schedule: options.cron_schedule.unwrap_or_default(),
-                request_eager_execution: options.enable_eager_workflow_start,
-                retry_policy: options.retry_policy,
-                links: options.links,
-                completion_callbacks: options.completion_callbacks,
-                priority: options.priority.map(Into::into),
-                ..Default::default()
-            })
+            .start_workflow_execution(
+                StartWorkflowExecutionRequest {
+                    namespace: self.namespace(),
+                    input: input.into_payloads(),
+                    workflow_id,
+                    workflow_type: Some(WorkflowType {
+                        name: workflow_type,
+                    }),
+                    task_queue: Some(TaskQueue {
+                        name: task_queue,
+                        kind: TaskQueueKind::Unspecified as i32,
+                        normal_name: "".to_string(),
+                    }),
+                    request_id: request_id.unwrap_or_else(|| Uuid::new_v4().to_string()),
+                    workflow_id_reuse_policy: options.id_reuse_policy as i32,
+                    workflow_id_conflict_policy: options.id_conflict_policy as i32,
+                    workflow_execution_timeout: options
+                        .execution_timeout
+                        .and_then(|d| d.try_into().ok()),
+                    workflow_run_timeout: options.run_timeout.and_then(|d| d.try_into().ok()),
+                    workflow_task_timeout: options.task_timeout.and_then(|d| d.try_into().ok()),
+                    search_attributes: options.search_attributes.map(|d| d.into()),
+                    cron_schedule: options.cron_schedule.unwrap_or_default(),
+                    request_eager_execution: options.enable_eager_workflow_start,
+                    retry_policy: options.retry_policy,
+                    links: options.links,
+                    completion_callbacks: options.completion_callbacks,
+                    priority: options.priority.map(Into::into),
+                    ..Default::default()
+                }
+                .into_request(),
+            )
             .await?
             .into_inner())
     }
@@ -1302,14 +1394,14 @@ where
         run_id: String,
     ) -> Result<ResetStickyTaskQueueResponse> {
         let request = ResetStickyTaskQueueRequest {
-            namespace: self.namespace().to_owned(),
+            namespace: self.namespace(),
             execution: Some(WorkflowExecution {
                 workflow_id,
                 run_id,
             }),
         };
         Ok(
-            WorkflowService::reset_sticky_task_queue(&mut self.clone(), request)
+            WorkflowService::reset_sticky_task_queue(&mut self.clone(), request.into_request())
                 .await?
                 .into_inner(),
         )
@@ -1320,17 +1412,20 @@ where
         task_token: TaskToken,
         result: Option<Payloads>,
     ) -> Result<RespondActivityTaskCompletedResponse> {
-        Ok(self.clone().respond_activity_task_completed(
-            RespondActivityTaskCompletedRequest {
-                task_token: task_token.0,
-                result,
-                identity: self.get_identity().to_owned(),
-                namespace: self.namespace().to_owned(),
-                ..Default::default()
-            },
-        )
-        .await?
-        .into_inner())
+        Ok(self
+            .clone()
+            .respond_activity_task_completed(
+                RespondActivityTaskCompletedRequest {
+                    task_token: task_token.0,
+                    result,
+                    identity: self.identity(),
+                    namespace: self.namespace(),
+                    ..Default::default()
+                }
+                .into_request(),
+            )
+            .await?
+            .into_inner())
     }
 
     async fn record_activity_heartbeat(
@@ -1338,16 +1433,19 @@ where
         task_token: TaskToken,
         details: Option<Payloads>,
     ) -> Result<RecordActivityTaskHeartbeatResponse> {
-        Ok(self.clone().record_activity_task_heartbeat(
-            RecordActivityTaskHeartbeatRequest {
-                task_token: task_token.0,
-                details,
-                identity: self.get_identity().to_owned(),
-                namespace: self.namespace().to_owned(),
-            },
-        )
-        .await?
-        .into_inner())
+        Ok(self
+            .clone()
+            .record_activity_task_heartbeat(
+                RecordActivityTaskHeartbeatRequest {
+                    task_token: task_token.0,
+                    details,
+                    identity: self.identity(),
+                    namespace: self.namespace(),
+                }
+                .into_request(),
+            )
+            .await?
+            .into_inner())
     }
 
     async fn cancel_activity_task(
@@ -1355,17 +1453,20 @@ where
         task_token: TaskToken,
         details: Option<Payloads>,
     ) -> Result<RespondActivityTaskCanceledResponse> {
-        Ok(self.clone().respond_activity_task_canceled(
-            RespondActivityTaskCanceledRequest {
-                task_token: task_token.0,
-                details,
-                identity: self.get_identity().to_owned(),
-                namespace: self.namespace().to_owned(),
-                ..Default::default()
-            },
-        )
-        .await?
-        .into_inner())
+        Ok(self
+            .clone()
+            .respond_activity_task_canceled(
+                RespondActivityTaskCanceledRequest {
+                    task_token: task_token.0,
+                    details,
+                    identity: self.identity(),
+                    namespace: self.namespace(),
+                    ..Default::default()
+                }
+                .into_request(),
+            )
+            .await?
+            .into_inner())
     }
 
     async fn signal_workflow_execution(
@@ -1376,19 +1477,21 @@ where
         payloads: Option<Payloads>,
         request_id: Option<String>,
     ) -> Result<SignalWorkflowExecutionResponse> {
-        Ok(WorkflowService::signal_workflow_execution(&mut self.clone(),
+        Ok(WorkflowService::signal_workflow_execution(
+            &mut self.clone(),
             SignalWorkflowExecutionRequest {
-                namespace: self.namespace().to_owned(),
+                namespace: self.namespace(),
                 workflow_execution: Some(WorkflowExecution {
                     workflow_id,
                     run_id,
                 }),
                 signal_name,
                 input: payloads,
-                identity: self.get_identity().to_owned(),
+                identity: self.identity(),
                 request_id: request_id.unwrap_or_else(|| Uuid::new_v4().to_string()),
                 ..Default::default()
-            },
+            }
+            .into_request(),
         )
         .await?
         .into_inner())
@@ -1399,9 +1502,10 @@ where
         options: SignalWithStartOptions,
         workflow_options: WorkflowOptions,
     ) -> Result<SignalWithStartWorkflowExecutionResponse> {
-        Ok(WorkflowService::signal_with_start_workflow_execution(&mut self.clone(),
+        Ok(WorkflowService::signal_with_start_workflow_execution(
+            &mut self.clone(),
             SignalWithStartWorkflowExecutionRequest {
-                namespace: self.namespace().to_owned(),
+                namespace: self.namespace(),
                 workflow_id: options.workflow_id,
                 workflow_type: Some(WorkflowType {
                     name: options.workflow_type,
@@ -1414,7 +1518,7 @@ where
                 input: options.input,
                 signal_name: options.signal_name,
                 signal_input: options.signal_input,
-                identity: self.get_identity().to_owned(),
+                identity: self.identity(),
                 request_id: options
                     .request_id
                     .unwrap_or_else(|| Uuid::new_v4().to_string()),
@@ -1431,7 +1535,8 @@ where
                 cron_schedule: workflow_options.cron_schedule.unwrap_or_default(),
                 header: options.signal_header,
                 ..Default::default()
-            },
+            }
+            .into_request(),
         )
         .await?
         .into_inner())
@@ -1443,19 +1548,22 @@ where
         run_id: String,
         query: WorkflowQuery,
     ) -> Result<QueryWorkflowResponse> {
-        Ok(self.clone().query_workflow(
-            QueryWorkflowRequest {
-                namespace: self.namespace().to_owned(),
-                execution: Some(WorkflowExecution {
-                    workflow_id,
-                    run_id,
-                }),
-                query: Some(query),
-                query_reject_condition: 1,
-            },
-        )
-        .await?
-        .into_inner())
+        Ok(self
+            .clone()
+            .query_workflow(
+                QueryWorkflowRequest {
+                    namespace: self.namespace(),
+                    execution: Some(WorkflowExecution {
+                        workflow_id,
+                        run_id,
+                    }),
+                    query: Some(query),
+                    query_reject_condition: 1,
+                }
+                .into_request(),
+            )
+            .await?
+            .into_inner())
     }
 
     async fn describe_workflow_execution(
@@ -1463,14 +1571,16 @@ where
         workflow_id: String,
         run_id: Option<String>,
     ) -> Result<DescribeWorkflowExecutionResponse> {
-        Ok(WorkflowService::describe_workflow_execution(&mut self.clone(),
+        Ok(WorkflowService::describe_workflow_execution(
+            &mut self.clone(),
             DescribeWorkflowExecutionRequest {
-                namespace: self.namespace().to_owned(),
+                namespace: self.namespace(),
                 execution: Some(WorkflowExecution {
                     workflow_id,
                     run_id: run_id.unwrap_or_default(),
                 }),
-            },
+            }
+            .into_request(),
         )
         .await?
         .into_inner())
@@ -1482,16 +1592,18 @@ where
         run_id: Option<String>,
         page_token: Vec<u8>,
     ) -> Result<GetWorkflowExecutionHistoryResponse> {
-        Ok(WorkflowService::get_workflow_execution_history(&mut self.clone(),
+        Ok(WorkflowService::get_workflow_execution_history(
+            &mut self.clone(),
             GetWorkflowExecutionHistoryRequest {
-                namespace: self.namespace().to_owned(),
+                namespace: self.namespace(),
                 execution: Some(WorkflowExecution {
                     workflow_id,
                     run_id: run_id.unwrap_or_default(),
                 }),
                 next_page_token: page_token,
                 ..Default::default()
-            },
+            }
+            .into_request(),
         )
         .await?
         .into_inner())
@@ -1504,22 +1616,25 @@ where
         reason: String,
         request_id: Option<String>,
     ) -> Result<RequestCancelWorkflowExecutionResponse> {
-        Ok(self.clone().request_cancel_workflow_execution(
-            RequestCancelWorkflowExecutionRequest {
-                namespace: self.namespace().to_owned(),
-                workflow_execution: Some(WorkflowExecution {
-                    workflow_id,
-                    run_id: run_id.unwrap_or_default(),
-                }),
-                identity: self.get_identity().to_owned(),
-                request_id: request_id.unwrap_or_else(|| Uuid::new_v4().to_string()),
-                first_execution_run_id: "".to_string(),
-                reason,
-                links: vec![],
-            },
-        )
-        .await?
-        .into_inner())
+        Ok(self
+            .clone()
+            .request_cancel_workflow_execution(
+                RequestCancelWorkflowExecutionRequest {
+                    namespace: self.namespace(),
+                    workflow_execution: Some(WorkflowExecution {
+                        workflow_id,
+                        run_id: run_id.unwrap_or_default(),
+                    }),
+                    identity: self.identity(),
+                    request_id: request_id.unwrap_or_else(|| Uuid::new_v4().to_string()),
+                    first_execution_run_id: "".to_string(),
+                    reason,
+                    links: vec![],
+                }
+                .into_request(),
+            )
+            .await?
+            .into_inner())
     }
 
     async fn terminate_workflow_execution(
@@ -1527,19 +1642,21 @@ where
         workflow_id: String,
         run_id: Option<String>,
     ) -> Result<TerminateWorkflowExecutionResponse> {
-        Ok(WorkflowService::terminate_workflow_execution(&mut self.clone(),
+        Ok(WorkflowService::terminate_workflow_execution(
+            &mut self.clone(),
             TerminateWorkflowExecutionRequest {
-                namespace: self.namespace().to_owned(),
+                namespace: self.namespace(),
                 workflow_execution: Some(WorkflowExecution {
                     workflow_id,
                     run_id: run_id.unwrap_or_default(),
                 }),
                 reason: "".to_string(),
                 details: None,
-                identity: self.get_identity().to_owned(),
+                identity: self.identity(),
                 first_execution_run_id: "".to_string(),
                 links: vec![],
-            },
+            }
+            .into_request(),
         )
         .await?
         .into_inner())
@@ -1551,23 +1668,25 @@ where
     ) -> Result<RegisterNamespaceResponse> {
         let req = Into::<RegisterNamespaceRequest>::into(options);
         Ok(
-            WorkflowService::register_namespace(&mut self.clone(),req)
+            WorkflowService::register_namespace(&mut self.clone(), req.into_request())
                 .await?
                 .into_inner(),
         )
     }
 
     async fn list_namespaces(&self) -> Result<ListNamespacesResponse> {
-        Ok(WorkflowService::list_namespaces(&mut self.clone(),
-            ListNamespacesRequest::default(),
+        Ok(WorkflowService::list_namespaces(
+            &mut self.clone(),
+            ListNamespacesRequest::default().into_request(),
         )
         .await?
         .into_inner())
     }
 
     async fn describe_namespace(&self, namespace: Namespace) -> Result<DescribeNamespaceResponse> {
-        Ok(WorkflowService::describe_namespace(&mut self.clone(),
-            namespace.into_describe_namespace_request(),
+        Ok(WorkflowService::describe_namespace(
+            &mut self.clone(),
+            namespace.into_describe_namespace_request().into_request(),
         )
         .await?
         .into_inner())
@@ -1580,14 +1699,16 @@ where
         start_time_filter: Option<StartTimeFilter>,
         filters: Option<ListOpenFilters>,
     ) -> Result<ListOpenWorkflowExecutionsResponse> {
-        Ok(WorkflowService::list_open_workflow_executions(&mut self.clone(),
+        Ok(WorkflowService::list_open_workflow_executions(
+            &mut self.clone(),
             ListOpenWorkflowExecutionsRequest {
-                namespace: self.namespace().to_owned(),
+                namespace: self.namespace(),
                 maximum_page_size,
                 next_page_token,
                 start_time_filter,
                 filters,
-            },
+            }
+            .into_request(),
         )
         .await?
         .into_inner())
@@ -1600,14 +1721,16 @@ where
         start_time_filter: Option<StartTimeFilter>,
         filters: Option<ListClosedFilters>,
     ) -> Result<ListClosedWorkflowExecutionsResponse> {
-        Ok(WorkflowService::list_closed_workflow_executions(&mut self.clone(),
+        Ok(WorkflowService::list_closed_workflow_executions(
+            &mut self.clone(),
             ListClosedWorkflowExecutionsRequest {
-                namespace: self.namespace().to_owned(),
+                namespace: self.namespace(),
                 maximum_page_size,
                 next_page_token,
                 start_time_filter,
                 filters,
-            },
+            }
+            .into_request(),
         )
         .await?
         .into_inner())
@@ -1619,13 +1742,15 @@ where
         next_page_token: Vec<u8>,
         query: String,
     ) -> Result<ListWorkflowExecutionsResponse> {
-        Ok(WorkflowService::list_workflow_executions(&mut self.clone(),
+        Ok(WorkflowService::list_workflow_executions(
+            &mut self.clone(),
             ListWorkflowExecutionsRequest {
-                namespace: self.namespace().to_owned(),
+                namespace: self.namespace(),
                 page_size,
                 next_page_token,
                 query,
-            },
+            }
+            .into_request(),
         )
         .await?
         .into_inner())
@@ -1637,21 +1762,24 @@ where
         next_page_token: Vec<u8>,
         query: String,
     ) -> Result<ListArchivedWorkflowExecutionsResponse> {
-        Ok(WorkflowService::list_archived_workflow_executions(&mut self.clone(),
+        Ok(WorkflowService::list_archived_workflow_executions(
+            &mut self.clone(),
             ListArchivedWorkflowExecutionsRequest {
-                namespace: self.namespace().to_owned(),
+                namespace: self.namespace(),
                 page_size,
                 next_page_token,
                 query,
-            },
+            }
+            .into_request(),
         )
         .await?
         .into_inner())
     }
 
     async fn get_search_attributes(&self) -> Result<GetSearchAttributesResponse> {
-        Ok(WorkflowService::get_search_attributes(&mut self.clone(),
-            GetSearchAttributesRequest {},
+        Ok(WorkflowService::get_search_attributes(
+            &mut self.clone(),
+            GetSearchAttributesRequest {}.into_request(),
         )
         .await?
         .into_inner())
@@ -1665,9 +1793,10 @@ where
         wait_policy: update::v1::WaitPolicy,
         args: Option<Payloads>,
     ) -> Result<UpdateWorkflowExecutionResponse> {
-        Ok(WorkflowService::update_workflow_execution(&mut self.clone(),
+        Ok(WorkflowService::update_workflow_execution(
+            &mut self.clone(),
             UpdateWorkflowExecutionRequest {
-                namespace: self.namespace().to_owned(),
+                namespace: self.namespace(),
                 workflow_execution: Some(WorkflowExecution {
                     workflow_id,
                     run_id,
@@ -1676,7 +1805,7 @@ where
                 request: Some(update::v1::Request {
                     meta: Some(update::v1::Meta {
                         update_id: "".into(),
-                        identity: self.get_identity().to_owned(),
+                        identity: self.identity(),
                     }),
                     input: Some(update::v1::Input {
                         header: None,
@@ -1685,7 +1814,8 @@ where
                     }),
                 }),
                 ..Default::default()
-            },
+            }
+            .into_request(),
         )
         .await?
         .into_inner())
@@ -1693,17 +1823,9 @@ where
 }
 
 mod sealed {
-    use crate::{InterceptedMetricsSvc, RawClientLike, WorkflowClientTrait};
-
-    pub trait WfHandleClient:
-        WorkflowClientTrait + RawClientLike<SvcType = InterceptedMetricsSvc>
-    {
-    }
-
-    impl<T> WfHandleClient for T where
-        T: WorkflowClientTrait + RawClientLike<SvcType = InterceptedMetricsSvc>
-    {
-    }
+    use crate::{WorkflowClientTrait, WorkflowService};
+    pub trait WfHandleClient: WorkflowClientTrait + WorkflowService {}
+    impl<T> WfHandleClient for T where T: WorkflowClientTrait + WorkflowService {}
 }
 
 /// Additional methods for workflow clients
@@ -1719,7 +1841,7 @@ pub trait WfClientExt: WfHandleClient + Sized + Clone {
         UntypedWorkflowHandle::new(
             self.clone(),
             WorkflowExecutionInfo {
-                namespace: self.namespace().to_string(),
+                namespace: self.namespace(),
                 workflow_id: workflow_id.into(),
                 run_id: if rid.is_empty() { None } else { Some(rid) },
             },
@@ -1768,13 +1890,17 @@ mod tests {
         // Initial header set
         let headers = Arc::new(RwLock::new(ClientHeaders {
             user_headers: HashMap::new(),
+            user_binary_headers: HashMap::new(),
             api_key: Some("my-api-key".to_owned()),
         }));
-        headers
-            .clone()
-            .write()
-            .user_headers
-            .insert("my-meta-key".to_owned(), "my-meta-val".to_owned());
+        headers.clone().write().user_headers.insert(
+            "my-meta-key".parse().unwrap(),
+            "my-meta-val".parse().unwrap(),
+        );
+        headers.clone().write().user_binary_headers.insert(
+            "my-bin-meta-key-bin".parse().unwrap(),
+            vec![1, 2, 3].try_into().unwrap(),
+        );
         let mut interceptor = ServiceCallInterceptor {
             opts,
             headers: headers.clone(),
@@ -1787,6 +1913,10 @@ mod tests {
             req.metadata().get("authorization").unwrap(),
             "Bearer my-api-key"
         );
+        assert_eq!(
+            req.metadata().get_bin("my-bin-meta-key-bin").unwrap(),
+            vec![1, 2, 3].as_slice()
+        );
 
         // Overwrite at request time
         let mut req = tonic::Request::new(());
@@ -1794,26 +1924,33 @@ mod tests {
             .insert("my-meta-key", "my-meta-val2".parse().unwrap());
         req.metadata_mut()
             .insert("authorization", "my-api-key2".parse().unwrap());
+        req.metadata_mut()
+            .insert_bin("my-bin-meta-key-bin", vec![4, 5, 6].try_into().unwrap());
         let req = interceptor.call(req).unwrap();
         assert_eq!(req.metadata().get("my-meta-key").unwrap(), "my-meta-val2");
         assert_eq!(req.metadata().get("authorization").unwrap(), "my-api-key2");
+        assert_eq!(
+            req.metadata().get_bin("my-bin-meta-key-bin").unwrap(),
+            vec![4, 5, 6].as_slice()
+        );
 
         // Overwrite auth on header
-        headers
-            .clone()
-            .write()
-            .user_headers
-            .insert("authorization".to_owned(), "my-api-key3".to_owned());
+        headers.clone().write().user_headers.insert(
+            "authorization".parse().unwrap(),
+            "my-api-key3".parse().unwrap(),
+        );
         let req = interceptor.call(tonic::Request::new(())).unwrap();
         assert_eq!(req.metadata().get("my-meta-key").unwrap(), "my-meta-val");
         assert_eq!(req.metadata().get("authorization").unwrap(), "my-api-key3");
 
         // Remove headers and auth and confirm gone
         headers.clone().write().user_headers.clear();
+        headers.clone().write().user_binary_headers.clear();
         headers.clone().write().api_key.take();
         let req = interceptor.call(tonic::Request::new(())).unwrap();
         assert!(!req.metadata().contains_key("my-meta-key"));
         assert!(!req.metadata().contains_key("authorization"));
+        assert!(!req.metadata().contains_key("my-bin-meta-key-bin"));
 
         // Timeout header not overriden
         let mut req = tonic::Request::new(());
@@ -1826,6 +1963,55 @@ mod tests {
         );
     }
 
+    #[test]
+    fn invalid_ascii_header_key() {
+        let invalid_headers = {
+            let mut h = HashMap::new();
+            h.insert("x-binary-key-bin".to_owned(), "value".to_owned());
+            h
+        };
+
+        let result = parse_ascii_headers(invalid_headers);
+        assert!(result.is_err());
+        assert_eq!(
+            result.err().unwrap().to_string(),
+            "Invalid ASCII header key 'x-binary-key-bin': invalid gRPC metadata key name"
+        );
+    }
+
+    #[test]
+    fn invalid_ascii_header_value() {
+        let invalid_headers = {
+            let mut h = HashMap::new();
+            // Nul bytes are valid UTF-8, but not valid ascii gRPC headers:
+            h.insert("x-ascii-key".to_owned(), "\x00value".to_owned());
+            h
+        };
+
+        let result = parse_ascii_headers(invalid_headers);
+        assert!(result.is_err());
+        assert_eq!(
+            result.err().unwrap().to_string(),
+            "Invalid ASCII header value for key 'x-ascii-key': failed to parse metadata value"
+        );
+    }
+
+    #[test]
+    fn invalid_binary_header_key() {
+        let invalid_headers = {
+            let mut h = HashMap::new();
+            h.insert("x-ascii-key".to_owned(), vec![1, 2, 3]);
+            h
+        };
+
+        let result = parse_binary_headers(invalid_headers);
+        assert!(result.is_err());
+        assert_eq!(
+            result.err().unwrap().to_string(),
+            "Invalid binary header key 'x-ascii-key': invalid gRPC metadata key name"
+        );
+    }
+
     #[test]
     fn keep_alive_defaults() {
         let mut builder = ClientOptionsBuilder::default();