@temporalio/core-bridge 0.22.0 → 0.23.0

package/Cargo.lock

@@ -1577,6 +1577,7 @@ dependencies = [
  "futures-retry",
  "http",
  "opentelemetry 0.17.0",
+ "parking_lot 0.12.0",
  "prost-types",
  "temporal-sdk-core-protos",
  "thiserror",
@@ -1683,6 +1684,7 @@ dependencies = [
  "neon",
  "once_cell",
  "opentelemetry 0.16.0",
+ "parking_lot 0.12.0",
  "prost",
  "prost-types",
  "temporal-client",

package/Cargo.toml

@@ -19,8 +19,9 @@ incremental = false
 [dependencies]
 futures = { version = "0.3", features = ["executor"] }
 log = "0.4"
-neon = { version = "0.8.0", default-features = false, features = ["napi-4", "event-queue-api"] }
+neon = { version = "0.8", default-features = false, features = ["napi-6", "event-queue-api"] }
 opentelemetry = "0.16"
+parking_lot = "0.12"
 prost = "0.9"
 prost-types = "0.9"
 tokio = "1.13"

package/index.d.ts

@@ -53,34 +53,104 @@ export interface ClientOptions {
   retry?: RetryOptions;
 }
 
+/**
+ * Log directly to console
+ */
+export interface ConsoleLogger {
+  console: {};
+}
+
+/**
+ * Forward logs to {@link Runtime} logger
+ */
+export interface ForwardLogger {
+  forward: {
+    /**
+     * What level, if any, logs should be forwarded from core at
+     *
+     */
+    // These strings should match the log::LevelFilter enum in rust
+    level: LogLevel;
+  };
+}
+
+/**
+ * Logger types supported by Core
+ */
+export type Logger = ConsoleLogger | ForwardLogger;
+
+/**
+ * OpenTelemetry Collector options for exporting metrics or traces
+ */
+export interface OtelCollectorExporter {
+  otel: {
+    /**
+     * URL of a gRPC OpenTelemetry collector.
+     */
+    url: string;
+    /**
+     * Optional set of HTTP request headers to send to Collector (e.g. for authentication)
+     */
+    headers?: Record<string, string>;
+  };
+}
+
+/**
+ * Prometheus metrics exporter options
+ */
+export interface PrometheusMetricsExporter {
+  prometheus: {
+    /**
+     * Address to bind the Prometheus HTTP metrics exporter server
+     * (for example, `0.0.0.0:1234`).
+     *
+     * Metrics will be available for scraping under the standard `/metrics` route.
+     */
+    bindAddress: string;
+  };
+}
+
+/**
+ * Metrics exporters supported by Core
+ */
+export type MetricsExporter = PrometheusMetricsExporter | OtelCollectorExporter;
+
+/**
+ * Trace exporters supported by Core
+ */
+export type TraceExporter = OtelCollectorExporter;
+
 export interface TelemetryOptions {
-  /**
-   * If set, telemetry is turned on and this URL must be the URL of a gRPC
-   * OTel collector.
-   */
-  oTelCollectorUrl?: string;
   /**
    * A string in the env filter format specified here:
    * https://docs.rs/tracing-subscriber/0.2.20/tracing_subscriber/struct.EnvFilter.html
    *
    * Which determines what tracing data is collected in the Core SDK
+   *
+   * @default `temporal_sdk_core=WARN`
    */
   tracingFilter?: string;
+
   /**
-   * What level, if any, logs should be forwarded from core at
+   * Control where to send Rust Core logs
    *
-   * @default OFF
+   * @default log to console
    */
-  // These strings should match the log::LevelFilter enum in rust
-  logForwardingLevel?: 'OFF' | LogLevel;
-  /** If set, metrics will be exposed on an http server in this process for direct scraping by
-   *  prometheus. If used in conjunction with the OTel collector, metrics will *not* be exported
-   *  to the collector, but traces will be.
+  logging?: Logger;
+
+  /**
+   * Control where to send traces generated by Rust Core, optional and turned off by default.
    *
-   *  The string provided must be an address the server will bind to. For example, `0.0.0.0:1234`.
-   *  Metrics will be available for scraping under the standard `/metrics` route.
+   * This is typically used for profiling SDK internals.
    */
-  prometheusMetricsBindAddress?: string;
+  tracing?: TraceExporter;
+
+  /**
+   * Control exporting {@link NativeConnection} and {@link Worker} metrics.
+   *
+   * Turned off by default
+   */
+  metrics?: MetricsExporter;
 }
 
 export interface WorkerOptions {
@@ -166,6 +236,11 @@ export declare function newReplayWorker(
   callback: WorkerCallback
 ): void;
 export declare function workerShutdown(worker: Worker, callback: VoidCallback): void;
+export declare function clientUpdateHeaders(
+  client: Client,
+  headers: Record<string, string>,
+  callback: VoidCallback
+): void;
 export declare function clientClose(client: Client): void;
 export declare function runtimeShutdown(runtime: Runtime, callback: VoidCallback): void;
 export declare function pollLogs(runtime: Runtime, callback: LogsCallback): void;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@temporalio/core-bridge",
-  "version": "0.22.0",
+  "version": "0.23.0",
   "description": "Temporal.io SDK Core<>Node bridge",
   "main": "index.js",
   "types": "index.d.ts",
@@ -20,7 +20,7 @@
   "license": "MIT",
   "dependencies": {
     "@opentelemetry/api": "^1.0.3",
-    "@temporalio/internal-non-workflow-common": "^0.22.0",
+    "@temporalio/internal-non-workflow-common": "^0.23.0",
     "arg": "^5.0.1",
     "cargo-cp-artifact": "^0.1.4",
     "which": "^2.0.2"
@@ -43,5 +43,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "3aa1f14982bd170d21b728cbf016dc4f1b595a76"
+  "gitHead": "81ee3fd09c2fd866b31b1dbfabce7ef221e338ea"
 }

package/sdk-core/bridge-ffi/src/lib.rs

@@ -397,7 +397,7 @@ pub extern "C" fn tmprl_client_init(
 
     let user_data = UserDataHandle(user_data);
     runtime.tokio_runtime.spawn(async move {
-        match req.connect(namespace, None).await {
+        match req.connect(namespace, None, None).await {
             Ok(client) => unsafe {
                 callback(
                     user_data.into(),

package/sdk-core/bridge-ffi/src/wrappers.rs

@@ -1,6 +1,8 @@
 use log::LevelFilter;
 use std::{net::SocketAddr, str::FromStr};
-use temporal_sdk_core::{TelemetryOptionsBuilder, Url};
+use temporal_sdk_core::{
+    Logger, MetricsExporter, OtelCollectorOptions, TelemetryOptionsBuilder, TraceExporter, Url,
+};
 use temporal_sdk_core_protos::coresdk::bridge;
 
 // Present for try-from only
@@ -11,41 +13,68 @@ impl TryFrom<InitTelemetryRequest> for temporal_sdk_core::TelemetryOptions {
 
     fn try_from(InitTelemetryRequest(req): InitTelemetryRequest) -> Result<Self, Self::Error> {
         let mut telemetry_opts = TelemetryOptionsBuilder::default();
-        if !req.otel_collector_url.is_empty() {
-            telemetry_opts.otel_collector_url(
-                Url::parse(&req.otel_collector_url)
-                    .map_err(|err| format!("invalid OpenTelemetry collector URL: {}", err))?,
-            );
-        }
-        if !req.tracing_filter.is_empty() {
-            telemetry_opts.tracing_filter(req.tracing_filter.clone());
-        }
-        match req.log_forwarding_level() {
-            bridge::LogLevel::Unspecified => {}
-            bridge::LogLevel::Off => {
-                telemetry_opts.log_forwarding_level(LevelFilter::Off);
-            }
-            bridge::LogLevel::Error => {
-                telemetry_opts.log_forwarding_level(LevelFilter::Error);
-            }
-            bridge::LogLevel::Warn => {
-                telemetry_opts.log_forwarding_level(LevelFilter::Warn);
+        telemetry_opts.tracing_filter(req.tracing_filter.clone());
+        match req.logging {
+            None => {}
+            Some(bridge::init_telemetry_request::Logging::Console(_)) => {
+                telemetry_opts.logging(Logger::Console);
             }
-            bridge::LogLevel::Info => {
-                telemetry_opts.log_forwarding_level(LevelFilter::Info);
+            Some(bridge::init_telemetry_request::Logging::Forward(
+                bridge::init_telemetry_request::ForwardLoggerOptions { level },
+            )) => {
+                if let Some(level) = bridge::LogLevel::from_i32(level) {
+                    let level = match level {
+                        bridge::LogLevel::Unspecified => {
+                            return Err("Must specify log level".to_string())
+                        }
+                        bridge::LogLevel::Off => LevelFilter::Off,
+                        bridge::LogLevel::Error => LevelFilter::Error,
+                        bridge::LogLevel::Warn => LevelFilter::Warn,
+                        bridge::LogLevel::Info => LevelFilter::Info,
+                        bridge::LogLevel::Debug => LevelFilter::Debug,
+                        bridge::LogLevel::Trace => LevelFilter::Trace,
+                    };
+                    telemetry_opts.logging(Logger::Forward(level));
+                } else {
+                    return Err(format!("Unknown LogLevel: {}", level));
+                }
             }
-            bridge::LogLevel::Debug => {
-                telemetry_opts.log_forwarding_level(LevelFilter::Debug);
+        }
+        match req.metrics {
+            None => {}
+            Some(bridge::init_telemetry_request::Metrics::Prometheus(
+                bridge::init_telemetry_request::PrometheusOptions {
+                    export_bind_address,
+                },
+            )) => {
+                telemetry_opts.metrics(MetricsExporter::Prometheus(
+                    SocketAddr::from_str(&export_bind_address)
+                        .map_err(|err| format!("invalid Prometheus address: {}", err))?,
+                ));
             }
-            bridge::LogLevel::Trace => {
-                telemetry_opts.log_forwarding_level(LevelFilter::Trace);
+            Some(bridge::init_telemetry_request::Metrics::OtelMetrics(
+                bridge::init_telemetry_request::OtelCollectorOptions { url, headers },
+            )) => {
+                telemetry_opts.metrics(MetricsExporter::Otel(OtelCollectorOptions {
+                    url: Url::parse(&url).map_err(|err| {
+                        format!("invalid OpenTelemetry collector URL for metrics: {}", err)
+                    })?,
+                    headers,
+                }));
             }
         }
-        if !req.prometheus_export_bind_address.is_empty() {
-            telemetry_opts.prometheus_export_bind_address(
-                SocketAddr::from_str(&req.prometheus_export_bind_address)
-                    .map_err(|err| format!("invalid Prometheus address: {}", err))?,
-            );
+        match req.tracing {
+            None => {}
+            Some(bridge::init_telemetry_request::Tracing::OtelTracing(
+                bridge::init_telemetry_request::OtelCollectorOptions { url, headers },
+            )) => {
+                telemetry_opts.tracing(TraceExporter::Otel(OtelCollectorOptions {
+                    url: Url::parse(&url).map_err(|err| {
+                        format!("invalid OpenTelemetry collector URL for tracing: {}", err)
+                    })?,
+                    headers,
+                }));
+            }
         }
 
         telemetry_opts
@@ -73,9 +102,6 @@ impl TryFrom<ClientOptions> for temporal_sdk_core::ClientOptions {
         if !req.client_version.is_empty() {
             client_opts.client_version(req.client_version);
         }
-        if !req.static_headers.is_empty() {
-            client_opts.static_headers(req.static_headers);
-        }
         if !req.identity.is_empty() {
             client_opts.identity(req.identity);
         }

package/sdk-core/client/Cargo.toml

@@ -20,6 +20,7 @@ futures = "0.3"
 futures-retry = "0.6.0"
 http = "0.2"
 opentelemetry = { version = "0.17", features = ["metrics"] }
+parking_lot = "0.12"
 prost-types = "0.9"
 thiserror = "1.0"
 tokio = "1.1"

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

@@ -25,6 +25,7 @@ use crate::{
 use backoff::{ExponentialBackoff, SystemClock};
 use http::uri::InvalidUri;
 use opentelemetry::metrics::Meter;
+use parking_lot::RwLock;
 use std::{
     collections::HashMap,
     fmt::{Debug, Formatter},
@@ -80,10 +81,6 @@ pub struct ClientOptions {
     /// in all RPC calls. The server decides if the client is supported based on this.
     pub client_version: String,
 
-    /// Other non-required static headers which should be attached to every request
-    #[builder(default)]
-    pub static_headers: HashMap<String, String>,
-
     /// A human-readable string that can identify this process. Defaults to empty string.
     #[builder(default)]
     pub identity: String,
@@ -252,11 +249,18 @@ impl From<ConfiguredClient<WorkflowServiceClientWithMetrics>> for AnyClient {
 pub struct ConfiguredClient<C> {
     client: C,
     options: ClientOptions,
+    headers: Arc<RwLock<HashMap<String, String>>>,
     /// Capabilities as read from the `get_system_info` RPC call made on client connection
     capabilities: Option<get_system_info_response::Capabilities>,
 }
 
 impl<C> ConfiguredClient<C> {
+    /// Set HTTP request headers overwriting previous headers
+    pub fn set_headers(&self, headers: HashMap<String, String>) {
+        let mut guard = self.headers.write();
+        *guard = headers;
+    }
+
     /// Returns the options the client is configured with
     pub fn options(&self) -> &ClientOptions {
         &self.options
@@ -295,8 +299,12 @@ impl ClientOptions {
         &self,
         namespace: impl Into<String>,
         metrics_meter: Option<&Meter>,
+        headers: Option<Arc<RwLock<HashMap<String, String>>>>,
     ) -> Result<RetryClient<Client>, ClientInitError> {
-        let client = self.connect_no_namespace(metrics_meter).await?.into_inner();
+        let client = self
+            .connect_no_namespace(metrics_meter, headers)
+            .await?
+            .into_inner();
         let client = Client::new(client, namespace.into());
         let retry_client = RetryClient::new(client, self.retry_config.clone());
         Ok(retry_client)
@@ -309,6 +317,7 @@ impl ClientOptions {
     pub async fn connect_no_namespace(
         &self,
         metrics_meter: Option<&Meter>,
+        headers: Option<Arc<RwLock<HashMap<String, String>>>>,
     ) -> Result<RetryClient<ConfiguredClient<WorkflowServiceClientWithMetrics>>, ClientInitError>
     {
         let channel = Channel::from_shared(self.target_url.to_string())?;
@@ -320,9 +329,14 @@ impl ClientOptions {
                 metrics: metrics_meter.map(|mm| MetricsContext::new(vec![], mm)),
             })
             .service(channel);
-        let interceptor = ServiceCallInterceptor { opts: self.clone() };
+        let headers = headers.unwrap_or_default();
+        let interceptor = ServiceCallInterceptor {
+            opts: self.clone(),
+            headers: headers.clone(),
+        };
 
         let mut client = ConfiguredClient {
+            headers,
             client: WorkflowServiceClient::with_interceptor(service, interceptor),
             options: self.clone(),
             capabilities: None,
@@ -394,6 +408,8 @@ pub struct WorkflowTaskCompletion {
 #[derive(Clone)]
 pub struct ServiceCallInterceptor {
     opts: ClientOptions,
+    /// Only accessed as a reader
+    headers: Arc<RwLock<HashMap<String, String>>>,
 }
 
 impl Interceptor for ServiceCallInterceptor {
@@ -415,7 +431,8 @@ impl Interceptor for ServiceCallInterceptor {
                 .parse()
                 .unwrap_or_else(|_| MetadataValue::from_static("")),
         );
-        for (k, v) in &self.opts.static_headers {
+        let headers = &*self.headers.read();
+        for (k, v) in headers {
             if let (Ok(k), Ok(v)) = (MetadataKey::from_str(k), MetadataValue::from_str(v)) {
                 metadata.insert(k, v);
             }

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

@@ -558,7 +558,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).await.unwrap();
+        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();

package/sdk-core/core/benches/workflow_replay.rs

@@ -11,13 +11,7 @@ pub fn criterion_benchmark(c: &mut Criterion) {
         .enable_time()
         .build()
         .unwrap();
-    telemetry_init(
-        &TelemetryOptionsBuilder::default()
-            .totally_disable(true)
-            .build()
-            .unwrap(),
-    )
-    .unwrap();
+    telemetry_init(&TelemetryOptionsBuilder::default().build().unwrap()).unwrap();
     let _g = tokio_runtime.enter();
 
     let num_timers = 10;

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

@@ -34,7 +34,8 @@ pub use pollers::{
     TlsConfig, WorkflowClientTrait,
 };
 pub use telemetry::{
-    fetch_global_buffered_logs, telemetry_init, TelemetryOptions, TelemetryOptionsBuilder,
+    fetch_global_buffered_logs, telemetry_init, Logger, MetricsExporter, OtelCollectorOptions,
+    TelemetryOptions, TelemetryOptionsBuilder, TraceExporter,
 };
 pub use temporal_sdk_core_api as api;
 pub use temporal_sdk_core_protos as protos;

package/sdk-core/core/src/protosext/mod.rs

@@ -359,9 +359,7 @@ impl ValidScheduleLA {
                 ))
             }
         };
-        let retry_policy = v
-            .retry_policy
-            .ok_or_else(|| anyhow!("Retry policy must be defined!"))?;
+        let retry_policy = v.retry_policy.unwrap_or_default();
         let local_retry_threshold = v
             .local_retry_threshold
             .clone()

package/sdk-core/core/src/retry_logic.rs

@@ -1,5 +1,8 @@
 use std::time::Duration;
-use temporal_sdk_core_protos::{coresdk::common::RetryPolicy, utilities::TryIntoOrNone};
+use temporal_sdk_core_protos::{
+    coresdk::common::RetryPolicy, temporal::api::failure::v1::ApplicationFailureInfo,
+    utilities::TryIntoOrNone,
+};
 
 pub(crate) trait RetryPolicyExt {
     /// Ask this retry policy if a retry should be performed. Caller provides the current attempt
@@ -7,11 +10,31 @@ pub(crate) trait RetryPolicyExt {
     ///
     /// Returns `None` if it should not, otherwise a duration indicating how long to wait before
     /// performing the retry.
-    fn should_retry(&self, attempt_number: usize, err_type_str: &str) -> Option<Duration>;
+    ///
+    /// Applies defaults to missing fields:
+    /// `initial_interval` - 1 second
+    /// `maximum_interval` - 100 x initial_interval
+    /// `backoff_coefficient` - 2.0
+    fn should_retry(
+        &self,
+        attempt_number: usize,
+        application_failure: Option<&ApplicationFailureInfo>,
+    ) -> Option<Duration>;
 }
 
 impl RetryPolicyExt for RetryPolicy {
-    fn should_retry(&self, attempt_number: usize, err_type_str: &str) -> Option<Duration> {
+    fn should_retry(
+        &self,
+        attempt_number: usize,
+        application_failure: Option<&ApplicationFailureInfo>,
+    ) -> Option<Duration> {
+        let non_retryable = application_failure
+            .map(|f| f.non_retryable)
+            .unwrap_or_default();
+        if non_retryable {
+            return None;
+        }
+        let err_type_str = application_failure.map_or("", |f| &f.r#type);
         let realmax = self.maximum_attempts.max(0);
         if realmax > 0 && attempt_number >= realmax as usize {
             return None;
@@ -23,7 +46,11 @@ impl RetryPolicyExt for RetryPolicy {
             }
         }
 
-        let converted_interval = self.initial_interval.clone().try_into_or_none();
+        let converted_interval = self
+            .initial_interval
+            .clone()
+            .try_into_or_none()
+            .or(Some(Duration::from_secs(1)));
         if attempt_number == 1 {
             return converted_interval;
         }
@@ -74,32 +101,32 @@ mod tests {
             maximum_attempts: 10,
             non_retryable_error_types: vec![],
         };
-        let res = rp.should_retry(1, "").unwrap();
+        let res = rp.should_retry(1, None).unwrap();
         assert_eq!(res.as_millis(), 1_000);
-        let res = rp.should_retry(2, "").unwrap();
+        let res = rp.should_retry(2, None).unwrap();
         assert_eq!(res.as_millis(), 2_000);
-        let res = rp.should_retry(3, "").unwrap();
+        let res = rp.should_retry(3, None).unwrap();
         assert_eq!(res.as_millis(), 4_000);
-        let res = rp.should_retry(4, "").unwrap();
+        let res = rp.should_retry(4, None).unwrap();
         assert_eq!(res.as_millis(), 8_000);
-        let res = rp.should_retry(5, "").unwrap();
+        let res = rp.should_retry(5, None).unwrap();
         assert_eq!(res.as_millis(), 10_000);
-        let res = rp.should_retry(6, "").unwrap();
+        let res = rp.should_retry(6, None).unwrap();
         assert_eq!(res.as_millis(), 10_000);
         // Max attempts - no retry
-        assert!(rp.should_retry(10, "").is_none());
+        assert!(rp.should_retry(10, None).is_none());
     }
 
     #[test]
     fn no_interval_no_backoff() {
         let rp = RetryPolicy {
             initial_interval: None,
-            backoff_coefficient: 2.0,
+            backoff_coefficient: 0.,
             maximum_interval: None,
             maximum_attempts: 10,
             non_retryable_error_types: vec![],
         };
-        assert!(rp.should_retry(1, "").is_none());
+        assert!(rp.should_retry(1, None).is_some());
     }
 
     #[test]
@@ -112,7 +139,7 @@ mod tests {
             non_retryable_error_types: vec![],
         };
         for i in 0..50 {
-            assert!(rp.should_retry(i, "").is_some());
+            assert!(rp.should_retry(i, None).is_some());
         }
     }
 
@@ -126,7 +153,7 @@ mod tests {
             non_retryable_error_types: vec![],
         };
         for i in 0..50 {
-            assert!(rp.should_retry(i, "").is_some());
+            assert!(rp.should_retry(i, None).is_some());
         }
     }
 
@@ -139,6 +166,36 @@ mod tests {
             maximum_attempts: 10,
             non_retryable_error_types: vec!["no retry".to_string()],
         };
-        assert!(rp.should_retry(1, "no retry").is_none());
+        assert!(rp
+            .should_retry(
+                1,
+                Some(&ApplicationFailureInfo {
+                    r#type: "no retry".to_string(),
+                    non_retryable: false,
+                    details: None,
+                })
+            )
+            .is_none());
+    }
+
+    #[test]
+    fn no_non_retryable_application_failure() {
+        let rp = RetryPolicy {
+            initial_interval: Some(Duration::from_secs(1).into()),
+            backoff_coefficient: 2.0,
+            maximum_interval: Some(Duration::from_secs(10).into()),
+            maximum_attempts: 10,
+            non_retryable_error_types: vec![],
+        };
+        assert!(rp
+            .should_retry(
+                1,
+                Some(&ApplicationFailureInfo {
+                    r#type: "".to_string(),
+                    non_retryable: true,
+                    details: None,
+                })
+            )
+            .is_none());
     }
 }