@temporalio/core-bridge 1.9.2 → 1.10.0

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

@@ -6,10 +6,10 @@ use std::{
     time::{Duration, Instant},
 };
 use temporal_sdk_core_api::telemetry::metrics::{
-    CoreMeter, Counter, Histogram, MetricAttributes, MetricKeyValue, MetricParameters,
+    CoreMeter, Counter, HistogramDuration, MetricAttributes, MetricKeyValue, MetricParameters,
     TemporalMeter,
 };
-use tonic::{body::BoxBody, transport::Channel};
+use tonic::{body::BoxBody, transport::Channel, Code};
 use tower::Service;
 
 /// Used to track context associated with metrics, and record/update them
@@ -17,7 +17,7 @@ use tower::Service;
 // appropriate k/vs have already been set.
 #[derive(Clone, derive_more::DebugCustom)]
 #[debug(fmt = "MetricsContext {{ attribs: {kvs:?}, poll_is_long: {poll_is_long} }}")]
-pub struct MetricsContext {
+pub(crate) struct MetricsContext {
     meter: Arc<dyn CoreMeter>,
     kvs: MetricAttributes,
     poll_is_long: bool,
@@ -27,8 +27,8 @@ pub struct MetricsContext {
     long_svc_request: Arc<dyn Counter>,
     long_svc_request_failed: Arc<dyn Counter>,
 
-    svc_request_latency: Arc<dyn Histogram>,
-    long_svc_request_latency: Arc<dyn Histogram>,
+    svc_request_latency: Arc<dyn HistogramDuration>,
+    long_svc_request_latency: Arc<dyn HistogramDuration>,
 }
 
 impl MetricsContext {
@@ -57,14 +57,14 @@ impl MetricsContext {
                 description: "Count of long-poll request failures by rpc name".into(),
                 unit: "".into(),
             }),
-            svc_request_latency: meter.histogram(MetricParameters {
+            svc_request_latency: meter.histogram_duration(MetricParameters {
                 name: "request_latency".into(),
-                unit: "ms".into(),
+                unit: "duration".into(),
                 description: "Histogram of client request latencies".into(),
             }),
-            long_svc_request_latency: meter.histogram(MetricParameters {
+            long_svc_request_latency: meter.histogram_duration(MetricParameters {
                 name: "long_request_latency".into(),
-                unit: "ms".into(),
+                unit: "duration".into(),
                 description: "Histogram of client long-poll request latencies".into(),
             }),
             meter,
@@ -92,22 +92,29 @@ impl MetricsContext {
     }
 
     /// A request to the temporal service failed
-    pub(crate) fn svc_request_failed(&self) {
+    pub(crate) fn svc_request_failed(&self, code: Option<Code>) {
+        let refme: MetricAttributes;
+        let kvs = if let Some(c) = code {
+            refme = self
+                .meter
+                .extend_attributes(self.kvs.clone(), [status_code_kv(c)].into());
+            &refme
+        } else {
+            &self.kvs
+        };
         if self.poll_is_long {
-            self.long_svc_request_failed.add(1, &self.kvs);
+            self.long_svc_request_failed.add(1, kvs);
         } else {
-            self.svc_request_failed.add(1, &self.kvs);
+            self.svc_request_failed.add(1, kvs);
         }
     }
 
     /// Record service request latency
     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);
+            self.long_svc_request_latency.record(dur, &self.kvs);
         } else {
-            self.svc_request_latency
-                .record(dur.as_millis() as u64, &self.kvs);
+            self.svc_request_latency.record(dur, &self.kvs);
         }
     }
 }
@@ -115,6 +122,7 @@ impl MetricsContext {
 const KEY_NAMESPACE: &str = "namespace";
 const KEY_SVC_METHOD: &str = "operation";
 const KEY_TASK_QUEUE: &str = "task_queue";
+const KEY_STATUS_CODE: &str = "status_code";
 
 pub(crate) fn namespace_kv(ns: String) -> MetricKeyValue {
     MetricKeyValue::new(KEY_NAMESPACE, ns)
@@ -128,12 +136,40 @@ pub(crate) fn svc_operation(op: String) -> MetricKeyValue {
     MetricKeyValue::new(KEY_SVC_METHOD, op)
 }
 
+pub(crate) fn status_code_kv(code: Code) -> MetricKeyValue {
+    MetricKeyValue::new(KEY_STATUS_CODE, code_as_screaming_snake(&code))
+}
+
+/// This is done to match the way Java sdk labels these codes (and also matches gRPC spec)
+fn code_as_screaming_snake(code: &Code) -> &'static str {
+    match code {
+        Code::Ok => "OK",
+        Code::Cancelled => "CANCELLED",
+        Code::Unknown => "UNKNOWN",
+        Code::InvalidArgument => "INVALID_ARGUMENT",
+        Code::DeadlineExceeded => "DEADLINE_EXCEEDED",
+        Code::NotFound => "NOT_FOUND",
+        Code::AlreadyExists => "ALREADY_EXISTS",
+        Code::PermissionDenied => "PERMISSION_DENIED",
+        Code::ResourceExhausted => "RESOURCE_EXHAUSTED",
+        Code::FailedPrecondition => "FAILED_PRECONDITION",
+        Code::Aborted => "ABORTED",
+        Code::OutOfRange => "OUT_OF_RANGE",
+        Code::Unimplemented => "UNIMPLEMENTED",
+        Code::Internal => "INTERNAL",
+        Code::Unavailable => "UNAVAILABLE",
+        Code::DataLoss => "DATA_LOSS",
+        Code::Unauthenticated => "UNAUTHENTICATED",
+    }
+}
+
 /// Implements metrics functionality for gRPC (really, any http) calls
 #[derive(Debug, Clone)]
 pub struct GrpcMetricSvc {
     pub(crate) inner: Channel,
     // If set to none, metrics are a no-op
     pub(crate) metrics: Option<MetricsContext>,
+    pub(crate) disable_errcode_label: bool,
 }
 
 impl Service<http::Request<BoxBody>> for GrpcMetricSvc {
@@ -169,13 +205,29 @@ impl Service<http::Request<BoxBody>> for GrpcMetricSvc {
                 })
             });
         let callfut = self.inner.call(req);
+        let errcode_label_disabled = self.disable_errcode_label;
         async move {
             let started = Instant::now();
             let res = callfut.await;
             if let Some(metrics) = metrics {
                 metrics.record_svc_req_latency(started.elapsed());
-                if res.is_err() {
-                    metrics.svc_request_failed();
+                if let Ok(ref ok_res) = res {
+                    if let Some(number) = ok_res
+                        .headers()
+                        .get("grpc-status")
+                        .and_then(|s| s.to_str().ok())
+                        .and_then(|s| s.parse::<i32>().ok())
+                    {
+                        let code = Code::from(number);
+                        if code != Code::Ok {
+                            let code = if errcode_label_disabled {
+                                None
+                            } else {
+                                Some(code)
+                            };
+                            metrics.svc_request_failed(code);
+                        }
+                    }
                 }
             }
             res

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

@@ -0,0 +1,85 @@
+use base64::prelude::*;
+use hyper::header;
+use std::future::Future;
+use std::pin::Pin;
+use std::task::Context;
+use std::task::Poll;
+use tokio::net::TcpStream;
+use tonic::transport::Channel;
+use tonic::transport::Endpoint;
+use tower::{service_fn, Service};
+
+/// Options for HTTP CONNECT proxy.
+#[derive(Clone, Debug)]
+pub struct HttpConnectProxyOptions {
+    /// The host:port to proxy through.
+    pub target_addr: String,
+    /// Optional HTTP basic auth for the proxy as user/pass tuple.
+    pub basic_auth: Option<(String, String)>,
+}
+
+impl HttpConnectProxyOptions {
+    /// Create a channel from the given endpoint that uses the HTTP CONNECT proxy.
+    pub async fn connect_endpoint(
+        &self,
+        endpoint: &Endpoint,
+    ) -> Result<Channel, tonic::transport::Error> {
+        let proxy_options = self.clone();
+        let svc_fn = service_fn(move |uri: tonic::transport::Uri| {
+            let proxy_options = proxy_options.clone();
+            async move { proxy_options.connect(uri).await }
+        });
+        endpoint.connect_with_connector(svc_fn).await
+    }
+
+    async fn connect(
+        &self,
+        uri: tonic::transport::Uri,
+    ) -> anyhow::Result<hyper::upgrade::Upgraded> {
+        debug!("Connecting to {} via proxy at {}", uri, self.target_addr);
+        // Create CONNECT request
+        let mut req_build = hyper::Request::builder().method("CONNECT").uri(uri);
+        if let Some((user, pass)) = &self.basic_auth {
+            let creds = BASE64_STANDARD.encode(format!("{}:{}", user, pass));
+            req_build = req_build.header(header::PROXY_AUTHORIZATION, format!("Basic {}", creds));
+        }
+        let req = req_build.body(hyper::Body::empty())?;
+
+        // We have to create a client with a specific connector because Hyper is
+        // not letting us change the HTTP/2 authority
+        let client =
+            hyper::Client::builder().build(OverrideAddrConnector(self.target_addr.clone()));
+
+        // Send request
+        let res = client.request(req).await?;
+        if res.status().is_success() {
+            Ok(hyper::upgrade::on(res).await?)
+        } else {
+            Err(anyhow::anyhow!(
+                "CONNECT call failed with status: {}",
+                res.status()
+            ))
+        }
+    }
+}
+
+#[derive(Clone)]
+struct OverrideAddrConnector(String);
+
+impl Service<hyper::Uri> for OverrideAddrConnector {
+    type Response = TcpStream;
+
+    type Error = anyhow::Error;
+
+    type Future = Pin<Box<dyn Future<Output = Result<Self::Response, Self::Error>> + Send>>;
+
+    fn poll_ready(&mut self, _ctx: &mut Context<'_>) -> Poll<anyhow::Result<()>> {
+        Poll::Ready(Ok(()))
+    }
+
+    fn call(&mut self, _uri: hyper::Uri) -> Self::Future {
+        let target_addr = self.0.clone();
+        let fut = async move { Ok(TcpStream::connect(target_addr).await?) };
+        Box::pin(fut)
+    }
+}

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

@@ -299,19 +299,19 @@ pub(super) struct AttachMetricLabels {
     pub(super) labels: Vec<MetricKeyValue>,
 }
 impl AttachMetricLabels {
-    pub fn new(kvs: impl Into<Vec<MetricKeyValue>>) -> Self {
+    pub(super) fn new(kvs: impl Into<Vec<MetricKeyValue>>) -> Self {
         Self { labels: kvs.into() }
     }
-    pub fn namespace(ns: impl Into<String>) -> Self {
+    pub(super) fn namespace(ns: impl Into<String>) -> Self {
         AttachMetricLabels::new(vec![namespace_kv(ns.into())])
     }
-    pub fn task_q(&mut self, tq: Option<TaskQueue>) -> &mut Self {
+    pub(super) fn task_q(&mut self, tq: Option<TaskQueue>) -> &mut Self {
         if let Some(tq) = tq {
             self.task_q_str(tq.name);
         }
         self
     }
-    pub fn task_q_str(&mut self, tq: impl Into<String>) -> &mut Self {
+    pub(super) fn task_q_str(&mut self, tq: impl Into<String>) -> &mut Self {
         self.labels.push(task_queue_kv(tq.into()));
         self
     }
@@ -968,6 +968,63 @@ proxier! {
             r.extensions_mut().insert(labels);
         }
     );
+    (
+        execute_multi_operation,
+        ExecuteMultiOperationRequest,
+        ExecuteMultiOperationResponse,
+        |r| {
+            let labels = AttachMetricLabels::namespace(r.get_ref().namespace.clone());
+            r.extensions_mut().insert(labels);
+        }
+    );
+    (
+        get_worker_versioning_rules,
+        GetWorkerVersioningRulesRequest,
+        GetWorkerVersioningRulesResponse,
+        |r| {
+            let mut labels = AttachMetricLabels::namespace(r.get_ref().namespace.clone());
+            labels.task_q_str(&r.get_ref().task_queue);
+            r.extensions_mut().insert(labels);
+        }
+    );
+    (
+        update_worker_versioning_rules,
+        UpdateWorkerVersioningRulesRequest,
+        UpdateWorkerVersioningRulesResponse,
+        |r| {
+            let mut labels = AttachMetricLabels::namespace(r.get_ref().namespace.clone());
+            labels.task_q_str(&r.get_ref().task_queue);
+            r.extensions_mut().insert(labels);
+        }
+    );
+    (
+        poll_nexus_task_queue,
+        PollNexusTaskQueueRequest,
+        PollNexusTaskQueueResponse,
+        |r| {
+            let mut labels = AttachMetricLabels::namespace(r.get_ref().namespace.clone());
+            labels.task_q(r.get_ref().task_queue.clone());
+            r.extensions_mut().insert(labels);
+        }
+    );
+    (
+        respond_nexus_task_completed,
+        RespondNexusTaskCompletedRequest,
+        RespondNexusTaskCompletedResponse,
+        |r| {
+            let mut labels = AttachMetricLabels::namespace(r.get_ref().namespace.clone());
+            r.extensions_mut().insert(labels);
+        }
+    );
+    (
+        respond_nexus_task_failed,
+        RespondNexusTaskFailedRequest,
+        RespondNexusTaskFailedResponse,
+        |r| {
+            let mut labels = AttachMetricLabels::namespace(r.get_ref().namespace.clone());
+            r.extensions_mut().insert(labels);
+        }
+    );
 }
 
 proxier! {
@@ -984,6 +1041,11 @@ proxier! {
     (add_or_update_remote_cluster, AddOrUpdateRemoteClusterRequest, AddOrUpdateRemoteClusterResponse);
     (remove_remote_cluster, RemoveRemoteClusterRequest, RemoveRemoteClusterResponse);
     (list_clusters, ListClustersRequest, ListClustersResponse);
+    (get_nexus_endpoint, GetNexusEndpointRequest, GetNexusEndpointResponse);
+    (create_nexus_endpoint, CreateNexusEndpointRequest, CreateNexusEndpointResponse);
+    (update_nexus_endpoint, UpdateNexusEndpointRequest, UpdateNexusEndpointResponse);
+    (delete_nexus_endpoint, DeleteNexusEndpointRequest, DeleteNexusEndpointResponse);
+    (list_nexus_endpoints, ListNexusEndpointsRequest, ListNexusEndpointsResponse);
 }
 
 proxier! {
@@ -1015,7 +1077,7 @@ mod tests {
     #[allow(dead_code)]
     async fn raw_client_retry_compiles() {
         let opts = ClientOptionsBuilder::default().build().unwrap();
-        let raw_client = opts.connect_no_namespace(None, None).await.unwrap();
+        let raw_client = opts.connect_no_namespace(None).await.unwrap();
         let mut retry_client = RetryClient::new(raw_client, opts.retry_config);
 
         let list_ns_req = ListNamespacesRequest::default();

package/sdk-core/client/src/worker_registry/mod.rs

@@ -95,9 +95,11 @@ impl SlotManagerImpl {
         }
     }
 
-    fn unregister(&mut self, id: WorkerKey) {
+    fn unregister(&mut self, id: WorkerKey) -> Option<Box<dyn SlotProvider + Send + Sync>> {
         if let Some(key) = self.index.remove(id) {
-            self.providers.remove(&key);
+            self.providers.remove(&key)
+        } else {
+            None
         }
     }
 
@@ -140,7 +142,7 @@ impl SlotManager {
     }
 
     /// Unregister a provider, typically when its worker starts shutdown.
-    pub fn unregister(&self, id: WorkerKey) {
+    pub fn unregister(&self, id: WorkerKey) -> Option<Box<dyn SlotProvider + Send + Sync>> {
         self.manager.write().unregister(id)
     }
 

package/sdk-core/client/src/workflow_handle/mod.rs

@@ -75,7 +75,7 @@ impl WorkflowExecutionInfo {
 }
 
 /// A workflow handle to a workflow with unknown types. Uses raw payloads.
-pub type UntypedWorkflowHandle<CT> = WorkflowHandle<CT, Vec<Payload>>;
+pub(crate) type UntypedWorkflowHandle<CT> = WorkflowHandle<CT, Vec<Payload>>;
 
 impl<CT, RT> WorkflowHandle<CT, RT>
 where
@@ -91,10 +91,12 @@ where
         }
     }
 
+    /// Get the workflow execution info
     pub fn info(&self) -> &WorkflowExecutionInfo {
         &self.info
     }
 
+    /// Await the result of the workflow execution
     pub async fn get_workflow_result(
         &self,
         opts: GetWorkflowResultOpts,

package/sdk-core/core/Cargo.toml

@@ -13,69 +13,65 @@ categories = ["development-tools"]
 [lib]
 
 [features]
-default = []
-# Do not enable this feature when building production SDKs. If we ever want a user in the field to
-# record WF input data, we can build them a custom SDK or they can build - it adds significant extra
-# code size in the form of [de]serializers.
-save_wf_inputs = ["rmp-serde", "temporal-sdk-core-protos/serde_serialize"]
+default = ["otel"]
+otel = ["dep:opentelemetry", "dep:opentelemetry_sdk", "dep:opentelemetry-otlp",
+    "dep:opentelemetry-prometheus", "dep:hyper", "dep:hyper-util", "dep:http-body-util"]
 tokio-console = ["console-subscriber"]
 ephemeral-server = ["dep:flate2", "dep:nix", "dep:reqwest", "dep:tar", "dep:zip"]
 
 [dependencies]
 anyhow = "1.0"
-arc-swap = "1.3"
 async-trait = "0.1"
-base64 = "0.21"
-console-subscriber = { version = "0.1", optional = true }
+console-subscriber = { version = "0.2", optional = true }
 crossbeam-channel = "0.5"
 crossbeam-queue = "0.3"
+crossbeam-utils = "0.8"
 dashmap = "5.5"
-derive_builder = "0.12"
+derive_builder = { workspace = true }
 derive_more = { workspace = true }
 enum_dispatch = "0.3"
-enum-iterator = "1.4"
+enum-iterator = "2"
 flate2 = { version = "1.0", optional = true }
 futures = "0.3"
 futures-util = "0.3"
 governor = "0.6"
-http = "0.2"
-hyper = "0.14"
-itertools = "0.11"
-lazy_static = "1.4"
-lru = "0.11"
-mockall = "0.11"
-nix = { version = "0.27", optional = true, features = ["process", "signal"] }
-once_cell = "1.5"
-opentelemetry = { workspace = true, features = ["metrics"] }
-opentelemetry_sdk = { version = "0.21", features = ["rt-tokio", "metrics"] }
-opentelemetry-otlp = { version = "0.14", features = ["tokio", "metrics"] }
-opentelemetry-prometheus = "0.14"
+http-body-util = { version = "0.1", optional = true }
+hyper = { version = "1.2", optional = true }
+hyper-util = { version = "0.1", features = ["server", "http1", "http2", "tokio"], optional = true }
+itertools = "0.12"
+lru = "0.12"
+mockall = "0.12"
+nix = { version = "0.28", optional = true, features = ["process", "signal"] }
+once_cell = { workspace = true }
+opentelemetry = { workspace = true, features = ["metrics"], optional = true }
+opentelemetry_sdk = { version = "0.22", features = ["rt-tokio", "metrics"], optional = true }
+opentelemetry-otlp = { version = "0.15", features = ["tokio", "metrics"], optional = true }
+opentelemetry-prometheus = { version = "0.15", optional = true }
 parking_lot = { version = "0.12", features = ["send_guard"] }
+pid = "4.0"
 pin-project = "1.0"
 prometheus = "0.13"
-prost = "0.11"
-prost-types = { version = "0.4", package = "prost-wkt-types" }
+prost = { workspace = true }
+prost-types = { version = "0.5", package = "prost-wkt-types" }
 rand = "0.8.3"
-reqwest = { version = "0.11", features = ["json", "stream", "rustls-tls", "tokio-rustls"], default-features = false, optional = true }
-ringbuf = "0.3"
-rmp-serde = { version = "1.1", optional = true }
+reqwest = { version = "0.11", features = ["json", "stream", "rustls-tls"], default-features = false, optional = true }
+ringbuf = "0.4"
 serde = "1.0"
 serde_json = "1.0"
 siphasher = "1.0"
 slotmap = "1.0"
+sysinfo = "0.30"
 tar = { version = "0.4", optional = true }
 thiserror = "1.0"
-tokio = { version = "1.26", features = ["rt", "rt-multi-thread", "parking_lot", "time", "fs", "process"] }
+tokio = { version = "1.37", features = ["rt", "rt-multi-thread", "parking_lot", "time", "fs", "process"] }
 tokio-util = { version = "0.7", features = ["io", "io-util"] }
 tokio-stream = "0.1"
 tonic = { workspace = true, features = ["tls", "tls-roots"] }
 tracing = "0.1"
-tracing-futures = "0.2"
 tracing-subscriber = { version = "0.3", features = ["parking_lot", "env-filter", "registry"] }
 url = "2.2"
 uuid = { version = "1.1", features = ["v4"] }
-zip = { version = "0.6.3", optional = true }
-log = "0.4.20"
+zip = { version = "1.2", optional = true }
 
 # 1st party local deps
 [dependencies.temporal-sdk-core-api]
@@ -97,7 +93,8 @@ assert_matches = "1.4"
 bimap = "0.6.1"
 clap = { version = "4.0", features = ["derive"] }
 criterion = "0.5"
-rstest = "0.18"
+rstest = "0.19.0"
+sysinfo = "0.30"
 temporal-sdk-core-test-utils = { path = "../test-utils" }
 temporal-sdk = { path = "../sdk" }
 
@@ -115,7 +112,6 @@ test = false
 name = "heavy_tests"
 path = "../tests/heavy_tests.rs"
 test = false
-required-features = ["save_wf_inputs"]
 
 [[bench]]
 name = "workflow_replay"
@@ -127,7 +123,5 @@ harness = false
 name = "integ_runner"
 path = "../tests/runner.rs"
 
-[[example]]
-name = "wf_input_replay"
-path = "../tests/wf_input_replay.rs"
-required-features = ["save_wf_inputs"]
+[lints]
+workspace = true

package/sdk-core/core/src/abstractions/take_cell.rs

@@ -4,13 +4,13 @@ use std::sync::atomic::{AtomicBool, Ordering};
 /// Implements something a bit like a `OnceCell`, but starts already initialized and allows you
 /// to take everything out of it only once in a thread-safe way. This isn't optimized for super
 /// fast-path usage.
-pub struct TakeCell<T> {
+pub(crate) struct TakeCell<T> {
     taken: AtomicBool,
     data: Mutex<Option<T>>,
 }
 
 impl<T> TakeCell<T> {
-    pub fn new(val: T) -> Self {
+    pub(crate) fn new(val: T) -> Self {
         Self {
             taken: AtomicBool::new(false),
             data: Mutex::new(Some(val)),
@@ -18,7 +18,7 @@ impl<T> TakeCell<T> {
     }
 
     /// If the cell has not already been taken from, takes the value and returns it
-    pub fn take_once(&self) -> Option<T> {
+    pub(crate) fn take_once(&self) -> Option<T> {
         if self.taken.load(Ordering::Acquire) {
             return None;
         }