@temporalio/core-bridge 1.1.0 → 1.4.0

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

@@ -1,7 +1,7 @@
 use crate::{AttachMetricLabels, LONG_POLL_METHOD_NAMES};
 use futures::{future::BoxFuture, FutureExt};
 use opentelemetry::{
-    metrics::{Counter, Meter, ValueRecorder},
+    metrics::{Counter, Histogram, Meter},
     KeyValue,
 };
 use std::{
@@ -17,6 +17,7 @@ use tower::Service;
 // appropriate k/vs have already been set.
 #[derive(Clone, Debug)]
 pub struct MetricsContext {
+    ctx: opentelemetry::Context,
     kvs: Arc<Vec<KeyValue>>,
     poll_is_long: bool,
 
@@ -25,21 +26,22 @@ pub struct MetricsContext {
     long_svc_request: Counter<u64>,
     long_svc_request_failed: Counter<u64>,
 
-    svc_request_latency: ValueRecorder<u64>,
-    long_svc_request_latency: ValueRecorder<u64>,
+    svc_request_latency: Histogram<u64>,
+    long_svc_request_latency: Histogram<u64>,
 }
 
 impl MetricsContext {
     pub(crate) fn new(kvs: Vec<KeyValue>, meter: &Meter) -> Self {
         Self {
+            ctx: opentelemetry::Context::current(),
             kvs: Arc::new(kvs),
             poll_is_long: false,
             svc_request: meter.u64_counter("request").init(),
             svc_request_failed: meter.u64_counter("request_failure").init(),
             long_svc_request: meter.u64_counter("long_request").init(),
             long_svc_request_failed: meter.u64_counter("long_request_failure").init(),
-            svc_request_latency: meter.u64_value_recorder("request_latency").init(),
-            long_svc_request_latency: meter.u64_value_recorder("long_request_latency").init(),
+            svc_request_latency: meter.u64_histogram("request_latency").init(),
+            long_svc_request_latency: meter.u64_histogram("long_request_latency").init(),
         }
     }
 
@@ -62,18 +64,18 @@ impl MetricsContext {
     /// A request to the temporal service was made
     pub(crate) fn svc_request(&self) {
         if self.poll_is_long {
-            self.long_svc_request.add(1, &self.kvs);
+            self.long_svc_request.add(&self.ctx, 1, &self.kvs);
         } else {
-            self.svc_request.add(1, &self.kvs);
+            self.svc_request.add(&self.ctx, 1, &self.kvs);
         }
     }
 
     /// A request to the temporal service failed
     pub(crate) fn svc_request_failed(&self) {
         if self.poll_is_long {
-            self.long_svc_request_failed.add(1, &self.kvs);
+            self.long_svc_request_failed.add(&self.ctx, 1, &self.kvs);
         } else {
-            self.svc_request_failed.add(1, &self.kvs);
+            self.svc_request_failed.add(&self.ctx, 1, &self.kvs);
         }
     }
 
@@ -81,10 +83,10 @@ impl MetricsContext {
     pub(crate) fn record_svc_req_latency(&self, dur: Duration) {
         if self.poll_is_long {
             self.long_svc_request_latency
-                .record(dur.as_millis() as u64, &self.kvs);
+                .record(&self.ctx, dur.as_millis() as u64, &self.kvs);
         } else {
             self.svc_request_latency
-                .record(dur.as_millis() as u64, &self.kvs);
+                .record(&self.ctx, dur.as_millis() as u64, &self.kvs);
         }
     }
 }

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

@@ -5,29 +5,44 @@
 use crate::{
     metrics::{namespace_kv, task_queue_kv},
     raw::sealed::RawClientLike,
+    Client, ConfiguredClient, InterceptedMetricsSvc, RetryClient, TemporalServiceClient,
     LONG_POLL_TIMEOUT,
 };
-use futures::{future::BoxFuture, FutureExt};
-use temporal_sdk_core_protos::temporal::api::{
-    taskqueue::v1::TaskQueue, workflowservice::v1::workflow_service_client::WorkflowServiceClient,
+use futures::{future::BoxFuture, FutureExt, TryFutureExt};
+use temporal_sdk_core_protos::{
+    grpc::health::v1::{health_client::HealthClient, *},
+    temporal::api::{
+        operatorservice::v1::{operator_service_client::OperatorServiceClient, *},
+        taskqueue::v1::TaskQueue,
+        testservice::v1::{test_service_client::TestServiceClient, *},
+        workflowservice::v1::{workflow_service_client::WorkflowServiceClient, *},
+    },
+};
+use tonic::{
+    body::BoxBody, client::GrpcService, metadata::KeyAndValueRef, Request, Response, Status,
 };
-use tonic::{body::BoxBody, client::GrpcService, metadata::KeyAndValueRef};
 
 pub(super) mod sealed {
     use super::*;
-    use crate::{Client, ConfiguredClient, InterceptedMetricsSvc, RetryClient};
-    use futures::TryFutureExt;
-    use tonic::{Request, Response, Status};
 
     /// Something that has a workflow service client
     #[async_trait::async_trait]
     pub trait RawClientLike: Send {
         type SvcType: Send + Sync + Clone + 'static;
 
-        /// Return the actual client instance
-        fn client(&mut self) -> &mut WorkflowServiceClient<Self::SvcType>;
+        /// Return the workflow service client instance
+        fn workflow_client(&mut self) -> &mut WorkflowServiceClient<Self::SvcType>;
+
+        /// Return the operator service client instance
+        fn operator_client(&mut self) -> &mut OperatorServiceClient<Self::SvcType>;
+
+        /// Return the test service client instance
+        fn test_client(&mut self) -> &mut TestServiceClient<Self::SvcType>;
 
-        async fn do_call<F, Req, Resp>(
+        /// Return the health service client instance
+        fn health_client(&mut self) -> &mut HealthClient<Self::SvcType>;
+
+        async fn call<F, Req, Resp>(
             &mut self,
             _call_name: &'static str,
             mut callfn: F,
@@ -35,90 +50,139 @@ pub(super) mod sealed {
         ) -> Result<Response<Resp>, Status>
         where
             Req: Clone + Unpin + Send + Sync + 'static,
-            F: FnMut(
-                &mut WorkflowServiceClient<Self::SvcType>,
-                Request<Req>,
-            ) -> BoxFuture<'static, Result<Response<Resp>, Status>>,
+            F: FnMut(&mut Self, Request<Req>) -> BoxFuture<'static, Result<Response<Resp>, Status>>,
             F: Send + Sync + Unpin + 'static,
         {
-            callfn(self.client(), req).await
+            callfn(self, req).await
         }
     }
+}
 
-    // Here we implement retry on anything that is already RawClientLike
-    #[async_trait::async_trait]
-    impl<RC, T> RawClientLike for RetryClient<RC>
-    where
-        RC: RawClientLike<SvcType = T> + 'static,
-        T: Send + Sync + Clone + 'static,
-    {
-        type SvcType = T;
+// Here we implement retry on anything that is already RawClientLike
+#[async_trait::async_trait]
+impl<RC, T> RawClientLike for RetryClient<RC>
+where
+    RC: RawClientLike<SvcType = T> + 'static,
+    T: Send + Sync + Clone + 'static,
+{
+    type SvcType = T;
 
-        fn client(&mut self) -> &mut WorkflowServiceClient<Self::SvcType> {
-            self.get_client_mut().client()
-        }
+    fn workflow_client(&mut self) -> &mut WorkflowServiceClient<Self::SvcType> {
+        self.get_client_mut().workflow_client()
+    }
 
-        async fn do_call<F, Req, Resp>(
-            &mut self,
-            call_name: &'static str,
-            mut callfn: F,
-            req: Request<Req>,
-        ) -> Result<Response<Resp>, Status>
-        where
-            Req: Clone + Unpin + Send + Sync + 'static,
-            F: FnMut(
-                &mut WorkflowServiceClient<Self::SvcType>,
-                Request<Req>,
-            ) -> BoxFuture<'static, Result<Response<Resp>, Status>>,
-            F: Send + Sync + Unpin + 'static,
-        {
-            let rtc = self.get_retry_config(call_name);
-            let req = req_cloner(&req);
-            let fact = || {
-                let req_clone = req_cloner(&req);
-                callfn(self.client(), req_clone)
-            };
-            let res = Self::make_future_retry(rtc, fact, call_name);
-            res.map_err(|(e, _attempt)| e).map_ok(|x| x.0).await
-        }
+    fn operator_client(&mut self) -> &mut OperatorServiceClient<Self::SvcType> {
+        self.get_client_mut().operator_client()
     }
 
-    impl<T> RawClientLike for WorkflowServiceClient<T>
-    where
-        T: Send + Sync + Clone + 'static,
-    {
-        type SvcType = T;
+    fn test_client(&mut self) -> &mut TestServiceClient<Self::SvcType> {
+        self.get_client_mut().test_client()
+    }
 
-        fn client(&mut self) -> &mut WorkflowServiceClient<Self::SvcType> {
-            self
-        }
+    fn health_client(&mut self) -> &mut HealthClient<Self::SvcType> {
+        self.get_client_mut().health_client()
     }
 
-    impl<T> RawClientLike for ConfiguredClient<WorkflowServiceClient<T>>
+    async fn call<F, Req, Resp>(
+        &mut self,
+        call_name: &'static str,
+        mut callfn: F,
+        req: Request<Req>,
+    ) -> Result<Response<Resp>, Status>
     where
-        T: Send + Sync + Clone + 'static,
+        Req: Clone + Unpin + Send + Sync + 'static,
+        F: FnMut(&mut Self, Request<Req>) -> BoxFuture<'static, Result<Response<Resp>, Status>>,
+        F: Send + Sync + Unpin + 'static,
     {
-        type SvcType = T;
+        let rtc = self.get_retry_config(call_name);
+        let fact = || {
+            let req_clone = req_cloner(&req);
+            callfn(self, req_clone)
+        };
+        let res = Self::make_future_retry(rtc, fact, call_name);
+        res.map_err(|(e, _attempt)| e).map_ok(|x| x.0).await
+    }
+}
 
-        fn client(&mut self) -> &mut WorkflowServiceClient<Self::SvcType> {
-            &mut self.client
-        }
+impl<T> RawClientLike for TemporalServiceClient<T>
+where
+    T: Send + Sync + Clone + 'static,
+    T: GrpcService<BoxBody> + 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,
+{
+    type SvcType = T;
+
+    fn workflow_client(&mut self) -> &mut WorkflowServiceClient<Self::SvcType> {
+        self.workflow_svc_mut()
     }
 
-    impl RawClientLike for Client {
-        type SvcType = InterceptedMetricsSvc;
+    fn operator_client(&mut self) -> &mut OperatorServiceClient<Self::SvcType> {
+        self.operator_svc_mut()
+    }
 
-        fn client(&mut self) -> &mut WorkflowServiceClient<Self::SvcType> {
-            &mut self.inner
-        }
+    fn test_client(&mut self) -> &mut TestServiceClient<Self::SvcType> {
+        self.test_svc_mut()
+    }
+
+    fn health_client(&mut self) -> &mut HealthClient<Self::SvcType> {
+        self.health_svc_mut()
+    }
+}
+
+impl<T> RawClientLike for ConfiguredClient<TemporalServiceClient<T>>
+where
+    T: Send + Sync + Clone + 'static,
+    T: GrpcService<BoxBody> + 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,
+{
+    type SvcType = T;
+
+    fn workflow_client(&mut self) -> &mut WorkflowServiceClient<Self::SvcType> {
+        self.client.workflow_client()
+    }
+
+    fn operator_client(&mut self) -> &mut OperatorServiceClient<Self::SvcType> {
+        self.client.operator_client()
+    }
+
+    fn test_client(&mut self) -> &mut TestServiceClient<Self::SvcType> {
+        self.client.test_client()
+    }
+
+    fn health_client(&mut self) -> &mut HealthClient<Self::SvcType> {
+        self.client.health_client()
+    }
+}
+
+impl RawClientLike for Client {
+    type SvcType = InterceptedMetricsSvc;
+
+    fn workflow_client(&mut self) -> &mut WorkflowServiceClient<Self::SvcType> {
+        self.inner.workflow_client()
+    }
+
+    fn operator_client(&mut self) -> &mut OperatorServiceClient<Self::SvcType> {
+        self.inner.operator_client()
+    }
+
+    fn test_client(&mut self) -> &mut TestServiceClient<Self::SvcType> {
+        self.inner.test_client()
+    }
+
+    fn health_client(&mut self) -> &mut HealthClient<Self::SvcType> {
+        self.inner.health_client()
     }
 }
 
 /// Helper for cloning a tonic request as long as the inner message may be cloned.
 /// We drop extensions, so, lang bridges can't pass those in :shrug:
-fn req_cloner<T: Clone>(cloneme: &tonic::Request<T>) -> tonic::Request<T> {
+fn req_cloner<T: Clone>(cloneme: &Request<T>) -> Request<T> {
     let msg = cloneme.get_ref().clone();
-    let mut new_req = tonic::Request::new(msg);
+    let mut new_req = Request::new(msg);
     let new_met = new_req.metadata_mut();
     for kv in cloneme.metadata().iter() {
         match kv {
@@ -146,10 +210,14 @@ impl AttachMetricLabels {
     }
     pub fn task_q(&mut self, tq: Option<TaskQueue>) -> &mut Self {
         if let Some(tq) = tq {
-            self.labels.push(task_queue_kv(tq.name));
+            self.task_q_str(tq.name);
         }
         self
     }
+    pub fn task_q_str(&mut self, tq: impl Into<String>) -> &mut Self {
+        self.labels.push(task_queue_kv(tq.into()));
+        self
+    }
 }
 
 // Blanket impl the trait for all raw-client-like things. Since the trait default-implements
@@ -158,7 +226,37 @@ impl<RC, T> WorkflowService for RC
 where
     RC: RawClientLike<SvcType = T>,
     T: GrpcService<BoxBody> + Send + Clone + 'static,
-    T::ResponseBody: tonic::codegen::Body + Send + 'static,
+    T::ResponseBody: tonic::codegen::Body<Data = tonic::codegen::Bytes> + Send + 'static,
+    T::Error: Into<tonic::codegen::StdError>,
+    T::Future: Send,
+    <T::ResponseBody as tonic::codegen::Body>::Error: Into<tonic::codegen::StdError> + Send,
+{
+}
+impl<RC, T> OperatorService for RC
+where
+    RC: RawClientLike<SvcType = T>,
+    T: GrpcService<BoxBody> + Send + Clone + 'static,
+    T::ResponseBody: tonic::codegen::Body<Data = tonic::codegen::Bytes> + Send + 'static,
+    T::Error: Into<tonic::codegen::StdError>,
+    T::Future: Send,
+    <T::ResponseBody as tonic::codegen::Body>::Error: Into<tonic::codegen::StdError> + Send,
+{
+}
+impl<RC, T> TestService for RC
+where
+    RC: RawClientLike<SvcType = T>,
+    T: GrpcService<BoxBody> + Send + Clone + 'static,
+    T::ResponseBody: tonic::codegen::Body<Data = tonic::codegen::Bytes> + Send + 'static,
+    T::Error: Into<tonic::codegen::StdError>,
+    T::Future: Send,
+    <T::ResponseBody as tonic::codegen::Body>::Error: Into<tonic::codegen::StdError> + Send,
+{
+}
+impl<RC, T> HealthService for RC
+where
+    RC: RawClientLike<SvcType = T>,
+    T: GrpcService<BoxBody> + Send + Clone + 'static,
+    T::ResponseBody: tonic::codegen::Body<Data = tonic::codegen::Bytes> + Send + 'static,
     T::Error: Into<tonic::codegen::StdError>,
     T::Future: Send,
     <T::ResponseBody as tonic::codegen::Body>::Error: Into<tonic::codegen::StdError> + Send,
@@ -167,34 +265,35 @@ where
 
 /// Helps re-declare gRPC client methods
 macro_rules! proxy {
-    ($method:ident, $req:ident, $resp:ident $(, $closure:expr)?) => {
-        #[doc = concat!("See [WorkflowServiceClient::", stringify!($method), "]")]
+    ($client_type:tt, $client_meth:ident, $method:ident, $req:ty, $resp:ty $(, $closure:expr)?) => {
+        #[doc = concat!("See [", stringify!($client_type), "::", stringify!($method), "]")]
         fn $method(
             &mut self,
-            request: impl tonic::IntoRequest<super::$req>,
-        ) -> BoxFuture<Result<tonic::Response<super::$resp>, tonic::Status>> {
+            request: impl tonic::IntoRequest<$req>,
+        ) -> BoxFuture<Result<tonic::Response<$resp>, tonic::Status>> {
             #[allow(unused_mut)]
-            let fact = |c: &mut WorkflowServiceClient<Self::SvcType>, mut req: tonic::Request<super::$req>| {
+            let fact = |c: &mut Self, mut req: tonic::Request<$req>| {
                 $( type_closure_arg(&mut req, $closure); )*
-                let mut c = c.clone();
+                let mut c = c.$client_meth().clone();
                 async move { c.$method(req).await }.boxed()
             };
-            self.do_call(stringify!($method), fact, request.into_request())
+            self.call(stringify!($method), fact, request.into_request())
         }
     };
 }
 macro_rules! proxier {
-    ( $(($method:ident, $req:ident, $resp:ident $(, $closure:expr)?  );)* ) => {
+    ( $trait_name:ident; $impl_list_name:ident; $client_type:tt; $client_meth:ident;
+      $(($method:ident, $req:ty, $resp:ty $(, $closure:expr)?  );)* ) => {
         #[cfg(test)]
-        const ALL_IMPLEMENTED_RPCS: &'static [&'static str] = &[$(stringify!($method)),*];
-        /// Trait version of the generated workflow service client with modifications to attach appropriate
-        /// metric labels or whatever else to requests
-        pub trait WorkflowService: RawClientLike
+        const $impl_list_name: &'static [&'static str] = &[$(stringify!($method)),*];
+        /// Trait version of the generated client with modifications to attach appropriate metric
+        /// labels or whatever else to requests
+        pub trait $trait_name: RawClientLike
         where
             // Yo this is wild
             <Self as RawClientLike>::SvcType: GrpcService<BoxBody> + Send + Clone + 'static,
             <<Self as RawClientLike>::SvcType as GrpcService<BoxBody>>::ResponseBody:
-                tonic::codegen::Body + Send + 'static,
+                tonic::codegen::Body<Data = tonic::codegen::Bytes> + Send + 'static,
             <<Self as RawClientLike>::SvcType as GrpcService<BoxBody>>::Error:
                 Into<tonic::codegen::StdError>,
             <<Self as RawClientLike>::SvcType as GrpcService<BoxBody>>::Future: Send,
@@ -202,17 +301,19 @@ macro_rules! proxier {
                 as tonic::codegen::Body>::Error: Into<tonic::codegen::StdError> + Send,
         {
             $(
-               proxy!($method, $req, $resp $(,$closure)*);
+               proxy!($client_type, $client_meth, $method, $req, $resp $(,$closure)*);
             )*
         }
     };
 }
+
 // Nice little trick to avoid the callsite asking to type the closure parameter
 fn type_closure_arg<T, R>(arg: T, f: impl FnOnce(T) -> R) -> R {
     f(arg)
 }
 
 proxier! {
+    WorkflowService; ALL_IMPLEMENTED_WORKFLOW_SERVICE_RPCS; WorkflowServiceClient; workflow_client;
     (
         register_namespace,
         RegisterNamespaceRequest,
@@ -629,14 +730,121 @@ proxier! {
             r.extensions_mut().insert(labels);
         }
     );
+    (
+        update_worker_build_id_ordering,
+        UpdateWorkerBuildIdOrderingRequest,
+        UpdateWorkerBuildIdOrderingResponse,
+        |r| {
+            let mut labels = AttachMetricLabels::namespace(r.get_ref().namespace.clone());
+            labels.task_q_str(r.get_ref().task_queue.clone());
+            r.extensions_mut().insert(labels);
+        }
+    );
+    (
+        get_worker_build_id_ordering,
+        GetWorkerBuildIdOrderingRequest,
+        GetWorkerBuildIdOrderingResponse,
+        |r| {
+            let mut labels = AttachMetricLabels::namespace(r.get_ref().namespace.clone());
+            labels.task_q_str(r.get_ref().task_queue.clone());
+            r.extensions_mut().insert(labels);
+        }
+    );
+    (
+        update_workflow,
+        UpdateWorkflowRequest,
+        UpdateWorkflowResponse,
+        |r| {
+            let labels = AttachMetricLabels::namespace(r.get_ref().namespace.clone());
+            r.extensions_mut().insert(labels);
+        }
+    );
+    (
+        start_batch_operation,
+        StartBatchOperationRequest,
+        StartBatchOperationResponse,
+        |r| {
+            let labels = AttachMetricLabels::namespace(r.get_ref().namespace.clone());
+            r.extensions_mut().insert(labels);
+        }
+    );
+    (
+        stop_batch_operation,
+        StopBatchOperationRequest,
+        StopBatchOperationResponse,
+        |r| {
+            let labels = AttachMetricLabels::namespace(r.get_ref().namespace.clone());
+            r.extensions_mut().insert(labels);
+        }
+    );
+    (
+        describe_batch_operation,
+        DescribeBatchOperationRequest,
+        DescribeBatchOperationResponse,
+        |r| {
+            let labels = AttachMetricLabels::namespace(r.get_ref().namespace.clone());
+            r.extensions_mut().insert(labels);
+        }
+    );
+    (
+        list_batch_operations,
+        ListBatchOperationsRequest,
+        ListBatchOperationsResponse,
+        |r| {
+            let labels = AttachMetricLabels::namespace(r.get_ref().namespace.clone());
+            r.extensions_mut().insert(labels);
+        }
+    );
+}
+
+proxier! {
+    OperatorService; ALL_IMPLEMENTED_OPERATOR_SERVICE_RPCS; OperatorServiceClient; operator_client;
+    (add_search_attributes, AddSearchAttributesRequest, AddSearchAttributesResponse);
+    (remove_search_attributes, RemoveSearchAttributesRequest, RemoveSearchAttributesResponse);
+    (list_search_attributes, ListSearchAttributesRequest, ListSearchAttributesResponse);
+    (delete_namespace, DeleteNamespaceRequest, DeleteNamespaceResponse,
+        |r| {
+            let labels = AttachMetricLabels::namespace(r.get_ref().namespace.clone());
+            r.extensions_mut().insert(labels);
+        }
+    );
+    (delete_workflow_execution, DeleteWorkflowExecutionRequest, DeleteWorkflowExecutionResponse,
+        |r| {
+            let labels = AttachMetricLabels::namespace(r.get_ref().namespace.clone());
+            r.extensions_mut().insert(labels);
+        }
+    );
+    (add_or_update_remote_cluster, AddOrUpdateRemoteClusterRequest, AddOrUpdateRemoteClusterResponse);
+    (remove_remote_cluster, RemoveRemoteClusterRequest, RemoveRemoteClusterResponse);
+    (describe_cluster, DescribeClusterRequest, DescribeClusterResponse);
+    (list_clusters, ListClustersRequest, ListClustersResponse);
+    (list_cluster_members, ListClusterMembersRequest, ListClusterMembersResponse);
+}
+
+proxier! {
+    TestService; ALL_IMPLEMENTED_TEST_SERVICE_RPCS; TestServiceClient; test_client;
+    (lock_time_skipping, LockTimeSkippingRequest, LockTimeSkippingResponse);
+    (unlock_time_skipping, UnlockTimeSkippingRequest, UnlockTimeSkippingResponse);
+    (sleep, SleepRequest, SleepResponse);
+    (sleep_until, SleepUntilRequest, SleepResponse);
+    (unlock_time_skipping_with_sleep, SleepRequest, SleepResponse);
+    (get_current_time, (), GetCurrentTimeResponse);
+}
+
+proxier! {
+    HealthService; ALL_IMPLEMENTED_HEALTH_SERVICE_RPCS; HealthClient; health_client;
+    (check, HealthCheckRequest, HealthCheckResponse);
+    (watch, HealthCheckRequest, tonic::codec::Streaming<HealthCheckResponse>);
 }
 
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::{ClientOptionsBuilder, RetryClient, WorkflowServiceClientWithMetrics};
+    use crate::{ClientOptionsBuilder, RetryClient};
     use std::collections::HashSet;
-    use temporal_sdk_core_protos::temporal::api::workflowservice::v1::ListNamespacesRequest;
+    use temporal_sdk_core_protos::temporal::api::{
+        operatorservice::v1::DeleteNamespaceRequest, workflowservice::v1::ListNamespacesRequest,
+    };
 
     // Just to help make sure some stuff compiles. Not run.
     #[allow(dead_code)]
@@ -645,42 +853,79 @@ mod tests {
         let raw_client = opts.connect_no_namespace(None, None).await.unwrap();
         let mut retry_client = RetryClient::new(raw_client, opts.retry_config);
 
-        let the_request = ListNamespacesRequest::default();
-        let fact = |c: &mut WorkflowServiceClientWithMetrics, req| {
-            let mut c = c.clone();
+        let list_ns_req = ListNamespacesRequest::default();
+        let fact = |c: &mut RetryClient<_>, req| {
+            let mut c = c.workflow_client().clone();
             async move { c.list_namespaces(req).await }.boxed()
         };
         retry_client
-            .do_call("whatever", fact, tonic::Request::new(the_request))
+            .call("whatever", fact, Request::new(list_ns_req.clone()))
+            .await
+            .unwrap();
+
+        // Operator svc method
+        let del_ns_req = DeleteNamespaceRequest::default();
+        let fact = |c: &mut RetryClient<_>, req| {
+            let mut c = c.operator_client().clone();
+            async move { c.delete_namespace(req).await }.boxed()
+        };
+        retry_client
+            .call("whatever", fact, Request::new(del_ns_req.clone()))
+            .await
+            .unwrap();
+
+        // Verify calling through traits works
+        retry_client.list_namespaces(list_ns_req).await.unwrap();
+        retry_client.delete_namespace(del_ns_req).await.unwrap();
+        retry_client.get_current_time(()).await.unwrap();
+        retry_client
+            .check(HealthCheckRequest::default())
             .await
             .unwrap();
     }
 
-    #[test]
-    fn verify_all_methods_implemented() {
-        // This is less work than trying to hook into the codegen process
-        let proto_def =
-            include_str!("../../protos/api_upstream/temporal/api/workflowservice/v1/service.proto");
-        let methods: Vec<_> = proto_def
+    fn verify_methods(proto_def_str: &str, impl_list: &[&str]) {
+        let methods: Vec<_> = proto_def_str
             .lines()
             .map(|l| l.trim())
             .filter(|l| l.starts_with("rpc"))
             .map(|l| {
                 let stripped = l.strip_prefix("rpc ").unwrap();
-                (&stripped[..stripped.find('(').unwrap()]).trim()
+                (stripped[..stripped.find('(').unwrap()]).trim()
             })
             .collect();
-        let no_underscores: HashSet<_> = ALL_IMPLEMENTED_RPCS
-            .iter()
-            .map(|x| x.replace('_', ""))
-            .collect();
+        let no_underscores: HashSet<_> = impl_list.iter().map(|x| x.replace('_', "")).collect();
         for method in methods {
             if !no_underscores.contains(&method.to_lowercase()) {
-                panic!(
-                    "WorkflowService RPC method {} is not implemented by raw client",
-                    method
-                )
+                panic!("RPC method {} is not implemented by raw client", method)
             }
         }
     }
+    #[test]
+    fn verify_all_workflow_service_methods_implemented() {
+        // This is less work than trying to hook into the codegen process
+        let proto_def =
+            include_str!("../../protos/api_upstream/temporal/api/workflowservice/v1/service.proto");
+        verify_methods(proto_def, ALL_IMPLEMENTED_WORKFLOW_SERVICE_RPCS);
+    }
+
+    #[test]
+    fn verify_all_operator_service_methods_implemented() {
+        let proto_def =
+            include_str!("../../protos/api_upstream/temporal/api/operatorservice/v1/service.proto");
+        verify_methods(proto_def, ALL_IMPLEMENTED_OPERATOR_SERVICE_RPCS);
+    }
+
+    #[test]
+    fn verify_all_test_service_methods_implemented() {
+        let proto_def =
+            include_str!("../../protos/testsrv_upstream/temporal/api/testservice/v1/service.proto");
+        verify_methods(proto_def, ALL_IMPLEMENTED_TEST_SERVICE_RPCS);
+    }
+
+    #[test]
+    fn verify_all_health_service_methods_implemented() {
+        let proto_def = include_str!("../../protos/grpc/health/v1/health.proto");
+        verify_methods(proto_def, ALL_IMPLEMENTED_HEALTH_SERVICE_RPCS);
+    }
 }