@temporalio/core-bridge 1.11.7 → 1.11.8

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

@@ -1,5 +1,5 @@
-use crate::{AttachMetricLabels, LONG_POLL_METHOD_NAMES};
-use futures_util::{future::BoxFuture, FutureExt};
+use crate::{AttachMetricLabels, CallType};
+use futures_util::{FutureExt, future::BoxFuture};
 use std::{
     sync::Arc,
     task::{Context, Poll},
@@ -9,9 +9,14 @@ use temporal_sdk_core_api::telemetry::metrics::{
     CoreMeter, Counter, HistogramDuration, MetricAttributes, MetricKeyValue, MetricParameters,
     TemporalMeter,
 };
-use tonic::{body::BoxBody, transport::Channel, Code};
+use tonic::{Code, body::BoxBody, transport::Channel};
 use tower::Service;
 
+/// The string name (which may be prefixed) for this metric
+pub static REQUEST_LATENCY_HISTOGRAM_NAME: &str = "request_latency";
+/// The string name (which may be prefixed) for this metric
+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.
@@ -58,12 +63,12 @@ impl MetricsContext {
                 unit: "".into(),
             }),
             svc_request_latency: meter.histogram_duration(MetricParameters {
-                name: "request_latency".into(),
+                name: REQUEST_LATENCY_HISTOGRAM_NAME.into(),
                 unit: "duration".into(),
                 description: "Histogram of client request latencies".into(),
             }),
             long_svc_request_latency: meter.histogram_duration(MetricParameters {
-                name: "long_request_latency".into(),
+                name: LONG_REQUEST_LATENCY_HISTOGRAM_NAME.into(),
                 unit: "duration".into(),
                 description: "Histogram of client long-poll request latencies".into(),
             }),
@@ -190,6 +195,11 @@ impl Service<http::Request<BoxBody>> for GrpcMetricSvc {
                 if let Some(other_labels) = req.extensions_mut().remove::<AttachMetricLabels>() {
                     m.with_new_attrs(other_labels.labels)
                 }
+                if let Some(ct) = req.extensions().get::<CallType>() {
+                    if ct.is_long() {
+                        m.set_is_long_poll();
+                    }
+                }
                 m
             })
             .and_then(|mut metrics| {
@@ -197,9 +207,6 @@ impl Service<http::Request<BoxBody>> for GrpcMetricSvc {
                 req.uri().to_string().rsplit_once('/').map(|split_tup| {
                     let method_name = split_tup.1;
                     metrics.with_new_attrs([svc_operation(method_name.to_string())]);
-                    if LONG_POLL_METHOD_NAMES.contains(&method_name) {
-                        metrics.set_is_long_poll();
-                    }
                     metrics.svc_request();
                     metrics
                 })

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

@@ -12,7 +12,7 @@ use std::{
 };
 use tokio::net::TcpStream;
 use tonic::transport::{Channel, Endpoint};
-use tower::{service_fn, Service};
+use tower::{Service, service_fn};
 
 /// Options for HTTP CONNECT proxy.
 #[derive(Clone, Debug)]

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

@@ -3,13 +3,13 @@
 //! happen.
 
 use crate::{
+    Client, ConfiguredClient, InterceptedMetricsSvc, LONG_POLL_TIMEOUT, RequestExt, RetryClient,
+    TEMPORAL_NAMESPACE_HEADER_KEY, TemporalServiceClient,
     metrics::{namespace_kv, task_queue_kv},
     raw::sealed::RawClientLike,
     worker_registry::{Slot, SlotManager},
-    Client, ConfiguredClient, InterceptedMetricsSvc, RequestExt, RetryClient,
-    TemporalServiceClient, LONG_POLL_TIMEOUT, TEMPORAL_NAMESPACE_HEADER_KEY,
 };
-use futures_util::{future::BoxFuture, FutureExt, TryFutureExt};
+use futures_util::{FutureExt, TryFutureExt, future::BoxFuture};
 use std::sync::Arc;
 use temporal_sdk_core_api::telemetry::metrics::MetricKeyValue;
 use temporal_sdk_core_protos::{
@@ -23,10 +23,10 @@ use temporal_sdk_core_protos::{
     },
 };
 use tonic::{
+    Request, Response, Status,
     body::BoxBody,
     client::GrpcService,
     metadata::{AsciiMetadataValue, KeyAndValueRef},
-    Request, Response, Status,
 };
 
 pub(super) mod sealed {
@@ -142,7 +142,7 @@ where
         &mut self,
         call_name: &'static str,
         mut callfn: F,
-        req: Request<Req>,
+        mut req: Request<Req>,
     ) -> Result<Response<Resp>, Status>
     where
         Req: Clone + Unpin + Send + Sync + 'static,
@@ -150,6 +150,10 @@ where
         F: Send + Sync + Unpin + 'static,
     {
         let info = self.get_call_info(call_name, Some(&req));
+        req.extensions_mut().insert(info.call_type);
+        if info.call_type.is_long() {
+            req.set_default_timeout(LONG_POLL_TIMEOUT);
+        }
         let fact = || {
             let req_clone = req_cloner(&req);
             callfn(self, req_clone)
@@ -612,9 +616,6 @@ proxier! {
             if r.get_ref().wait_new_event {
                 r.extensions_mut().insert(IsUserLongPoll);
             }
-            if r.get_ref().wait_new_event {
-                r.set_default_timeout(LONG_POLL_TIMEOUT);
-            }
         }
     );
     (
@@ -634,7 +635,6 @@ proxier! {
             let mut labels = namespaced_request!(r);
             labels.task_q(r.get_ref().task_queue.clone());
             r.extensions_mut().insert(labels);
-            r.set_default_timeout(LONG_POLL_TIMEOUT);
         }
     );
     (
@@ -663,7 +663,6 @@ proxier! {
             let mut labels = namespaced_request!(r);
             labels.task_q(r.get_ref().task_queue.clone());
             r.extensions_mut().insert(labels);
-            r.set_default_timeout(LONG_POLL_TIMEOUT);
         }
     );
     (
@@ -1017,8 +1016,9 @@ proxier! {
         UpdateWorkflowExecutionResponse,
         |r| {
             let labels = namespaced_request!(r);
-            r.extensions_mut().insert(labels);
-            r.set_default_timeout(LONG_POLL_TIMEOUT);
+            let exts = r.extensions_mut();
+            exts.insert(labels);
+            exts.insert(IsUserLongPoll);
         }
     );
     (
@@ -1028,7 +1028,6 @@ proxier! {
         |r| {
             let labels = namespaced_request!(r);
             r.extensions_mut().insert(labels);
-            r.set_default_timeout(LONG_POLL_TIMEOUT);
         }
     );
     (
@@ -1058,6 +1057,15 @@ proxier! {
             r.extensions_mut().insert(labels);
         }
     );
+    (
+        describe_deployment,
+        DescribeDeploymentRequest,
+        DescribeDeploymentResponse,
+        |r| {
+            let labels = namespaced_request!(r);
+            r.extensions_mut().insert(labels);
+        }
+    );
     (
         list_batch_operations,
         ListBatchOperationsRequest,
@@ -1067,6 +1075,15 @@ proxier! {
             r.extensions_mut().insert(labels);
         }
     );
+    (
+        list_deployments,
+        ListDeploymentsRequest,
+        ListDeploymentsResponse,
+        |r| {
+            let labels = namespaced_request!(r);
+            r.extensions_mut().insert(labels);
+        }
+    );
     (
         execute_multi_operation,
         ExecuteMultiOperationRequest,
@@ -1076,6 +1093,24 @@ proxier! {
             r.extensions_mut().insert(labels);
         }
     );
+    (
+        get_current_deployment,
+        GetCurrentDeploymentRequest,
+        GetCurrentDeploymentResponse,
+        |r| {
+            let labels = namespaced_request!(r);
+            r.extensions_mut().insert(labels);
+        }
+    );
+    (
+        get_deployment_reachability,
+        GetDeploymentReachabilityRequest,
+        GetDeploymentReachabilityResponse,
+        |r| {
+            let labels = namespaced_request!(r);
+            r.extensions_mut().insert(labels);
+        }
+    );
     (
         get_worker_versioning_rules,
         GetWorkerVersioningRulesRequest,
@@ -1124,6 +1159,15 @@ proxier! {
             r.extensions_mut().insert(labels);
         }
     );
+    (
+        set_current_deployment,
+        SetCurrentDeploymentRequest,
+        SetCurrentDeploymentResponse,
+        |r| {
+            let labels = namespaced_request!(r);
+            r.extensions_mut().insert(labels);
+        }
+    );
     (
         shutdown_worker,
         ShutdownWorkerRequest,
@@ -1134,36 +1178,117 @@ proxier! {
         }
     );
     (
-        update_activity_options_by_id,
-        UpdateActivityOptionsByIdRequest,
-        UpdateActivityOptionsByIdResponse,
+        update_activity_options,
+        UpdateActivityOptionsRequest,
+        UpdateActivityOptionsResponse,
+        |r| {
+            let labels = namespaced_request!(r);
+            r.extensions_mut().insert(labels);
+        }
+    );
+    (
+        pause_activity,
+        PauseActivityRequest,
+        PauseActivityResponse,
+        |r| {
+            let labels = namespaced_request!(r);
+            r.extensions_mut().insert(labels);
+        }
+    );
+    (
+        unpause_activity,
+        UnpauseActivityRequest,
+        UnpauseActivityResponse,
+        |r| {
+            let labels = namespaced_request!(r);
+            r.extensions_mut().insert(labels);
+        }
+    );
+    (
+        update_workflow_execution_options,
+        UpdateWorkflowExecutionOptionsRequest,
+        UpdateWorkflowExecutionOptionsResponse,
+        |r| {
+            let labels = namespaced_request!(r);
+            r.extensions_mut().insert(labels);
+        }
+    );
+    (
+        reset_activity,
+        ResetActivityRequest,
+        ResetActivityResponse,
+        |r| {
+            let labels = namespaced_request!(r);
+            r.extensions_mut().insert(labels);
+        }
+    );
+    (
+        delete_worker_deployment,
+        DeleteWorkerDeploymentRequest,
+        DeleteWorkerDeploymentResponse,
         |r| {
             let labels = namespaced_request!(r);
             r.extensions_mut().insert(labels);
         }
     );
     (
-        pause_activity_by_id,
-        PauseActivityByIdRequest,
-        PauseActivityByIdResponse,
+        delete_worker_deployment_version,
+        DeleteWorkerDeploymentVersionRequest,
+        DeleteWorkerDeploymentVersionResponse,
         |r| {
             let labels = namespaced_request!(r);
             r.extensions_mut().insert(labels);
         }
     );
     (
-        unpause_activity_by_id,
-        UnpauseActivityByIdRequest,
-        UnpauseActivityByIdResponse,
+        describe_worker_deployment,
+        DescribeWorkerDeploymentRequest,
+        DescribeWorkerDeploymentResponse,
         |r| {
             let labels = namespaced_request!(r);
             r.extensions_mut().insert(labels);
         }
     );
     (
-        reset_activity_by_id,
-        ResetActivityByIdRequest,
-        ResetActivityByIdResponse,
+        describe_worker_deployment_version,
+        DescribeWorkerDeploymentVersionRequest,
+        DescribeWorkerDeploymentVersionResponse,
+        |r| {
+            let labels = namespaced_request!(r);
+            r.extensions_mut().insert(labels);
+        }
+    );
+    (
+        list_worker_deployments,
+        ListWorkerDeploymentsRequest,
+        ListWorkerDeploymentsResponse,
+        |r| {
+            let labels = namespaced_request!(r);
+            r.extensions_mut().insert(labels);
+        }
+    );
+    (
+        set_worker_deployment_current_version,
+        SetWorkerDeploymentCurrentVersionRequest,
+        SetWorkerDeploymentCurrentVersionResponse,
+        |r| {
+            let labels = namespaced_request!(r);
+            r.extensions_mut().insert(labels);
+        }
+    );
+    (
+        set_worker_deployment_ramping_version,
+        SetWorkerDeploymentRampingVersionRequest,
+        SetWorkerDeploymentRampingVersionResponse,
+        |r| {
+            let labels = namespaced_request!(r);
+            r.extensions_mut().insert(labels);
+        }
+    );
+    (
+        update_worker_deployment_version_metadata,
+        UpdateWorkerDeploymentVersionMetadataRequest,
+        UpdateWorkerDeploymentVersionMetadataResponse,
         |r| {
             let labels = namespaced_request!(r);
             r.extensions_mut().insert(labels);
@@ -1231,6 +1356,11 @@ proxier! {
     (create_api_key, cloudreq::CreateApiKeyRequest, cloudreq::CreateApiKeyResponse);
     (update_api_key, cloudreq::UpdateApiKeyRequest, cloudreq::UpdateApiKeyResponse);
     (delete_api_key, cloudreq::DeleteApiKeyRequest, cloudreq::DeleteApiKeyResponse);
+    (get_nexus_endpoints, cloudreq::GetNexusEndpointsRequest, cloudreq::GetNexusEndpointsResponse);
+    (get_nexus_endpoint, cloudreq::GetNexusEndpointRequest, cloudreq::GetNexusEndpointResponse);
+    (create_nexus_endpoint, cloudreq::CreateNexusEndpointRequest, cloudreq::CreateNexusEndpointResponse);
+    (update_nexus_endpoint, cloudreq::UpdateNexusEndpointRequest, cloudreq::UpdateNexusEndpointResponse);
+    (delete_nexus_endpoint, cloudreq::DeleteNexusEndpointRequest, cloudreq::DeleteNexusEndpointResponse);
     (get_user_groups, cloudreq::GetUserGroupsRequest, cloudreq::GetUserGroupsResponse);
     (get_user_group, cloudreq::GetUserGroupRequest, cloudreq::GetUserGroupResponse);
     (create_user_group, cloudreq::CreateUserGroupRequest, cloudreq::CreateUserGroupResponse);
@@ -1242,6 +1372,15 @@ proxier! {
     (get_service_accounts, cloudreq::GetServiceAccountsRequest, cloudreq::GetServiceAccountsResponse);
     (update_service_account, cloudreq::UpdateServiceAccountRequest, cloudreq::UpdateServiceAccountResponse);
     (delete_service_account, cloudreq::DeleteServiceAccountRequest, cloudreq::DeleteServiceAccountResponse);
+    (get_usage, cloudreq::GetUsageRequest, cloudreq::GetUsageResponse);
+    (get_account, cloudreq::GetAccountRequest, cloudreq::GetAccountResponse);
+    (update_account, cloudreq::UpdateAccountRequest, cloudreq::UpdateAccountResponse);
+    (create_namespace_export_sink, cloudreq::CreateNamespaceExportSinkRequest, cloudreq::CreateNamespaceExportSinkResponse);
+    (get_namespace_export_sink, cloudreq::GetNamespaceExportSinkRequest, cloudreq::GetNamespaceExportSinkResponse);
+    (get_namespace_export_sinks, cloudreq::GetNamespaceExportSinksRequest, cloudreq::GetNamespaceExportSinksResponse);
+    (update_namespace_export_sink, cloudreq::UpdateNamespaceExportSinkRequest, cloudreq::UpdateNamespaceExportSinkResponse);
+    (delete_namespace_export_sink, cloudreq::DeleteNamespaceExportSinkRequest, cloudreq::DeleteNamespaceExportSinkResponse);
+    (validate_namespace_export_sink, cloudreq::ValidateNamespaceExportSinkRequest, cloudreq::ValidateNamespaceExportSinkResponse);
 }
 
 proxier! {
@@ -1344,29 +1483,33 @@ mod tests {
     #[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!("../../sdk-core-protos/protos/api_upstream/temporal/api/workflowservice/v1/service.proto");
+        let proto_def = include_str!(
+            "../../sdk-core-protos/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!("../../sdk-core-protos/protos/api_upstream/temporal/api/operatorservice/v1/service.proto");
+        let proto_def = include_str!(
+            "../../sdk-core-protos/protos/api_upstream/temporal/api/operatorservice/v1/service.proto"
+        );
         verify_methods(proto_def, ALL_IMPLEMENTED_OPERATOR_SERVICE_RPCS);
     }
 
     #[test]
     fn verify_all_cloud_service_methods_implemented() {
-        let proto_def =
-            include_str!("../../sdk-core-protos/protos/api_cloud_upstream/temporal/api/cloud/cloudservice/v1/service.proto");
+        let proto_def = include_str!(
+            "../../sdk-core-protos/protos/api_cloud_upstream/temporal/api/cloud/cloudservice/v1/service.proto"
+        );
         verify_methods(proto_def, ALL_IMPLEMENTED_CLOUD_SERVICE_RPCS);
     }
 
     #[test]
     fn verify_all_test_service_methods_implemented() {
-        let proto_def =
-            include_str!("../../sdk-core-protos/protos/testsrv_upstream/temporal/api/testservice/v1/service.proto");
+        let proto_def = include_str!(
+            "../../sdk-core-protos/protos/testsrv_upstream/temporal/api/testservice/v1/service.proto"
+        );
         verify_methods(proto_def, ALL_IMPLEMENTED_TEST_SERVICE_RPCS);
     }