@temporalio/core-bridge 1.14.1 → 1.15.0

package/sdk-core/crates/sdk-core-c-bridge/src/lib.rs

@@ -27,6 +27,8 @@ pub struct ByteArrayRef {
     pub size: libc::size_t,
 }
 
+unsafe impl Sync for ByteArrayRef {}
+
 impl ByteArrayRef {
     pub fn empty() -> ByteArrayRef {
         static EMPTY: &str = "";
@@ -98,6 +100,24 @@ impl ByteArrayRef {
             .map(|(k, v)| (k.to_string(), v.to_string()))
             .collect()
     }
+
+    pub fn to_option_str_key_value_pair(&self) -> Option<(&str, ByteArrayRef)> {
+        if let Some(index) = self.to_slice().iter().position(|&x| x == b'\n') {
+            let key_str = unsafe {
+                std::str::from_utf8_unchecked(std::slice::from_raw_parts(self.data, index))
+            };
+            let value = ByteArrayRef {
+                data: unsafe { self.data.add(index + 1) },
+                size: self.size - index - 1,
+            };
+            let _value_str = unsafe {
+                std::str::from_utf8_unchecked(std::slice::from_raw_parts(value.data, value.size))
+            };
+            Some((key_str, value))
+        } else {
+            None
+        }
+    }
 }
 
 impl From<&str> for ByteArrayRef {
@@ -118,6 +138,15 @@ impl From<&[u8]> for ByteArrayRef {
     }
 }
 
+impl From<&Vec<u8>> for ByteArrayRef {
+    fn from(value: &Vec<u8>) -> ByteArrayRef {
+        ByteArrayRef {
+            data: value.as_ptr(),
+            size: value.len(),
+        }
+    }
+}
+
 impl<T> From<Option<T>> for ByteArrayRef
 where
     T: Into<ByteArrayRef>,
@@ -134,19 +163,74 @@ pub struct ByteArrayRefArray {
 }
 
 impl ByteArrayRefArray {
+    pub fn empty() -> ByteArrayRefArray {
+        static EMPTY: &[ByteArrayRef] = &[];
+        EMPTY.into()
+    }
+
+    pub fn to_slice(&self) -> &[ByteArrayRef] {
+        unsafe { std::slice::from_raw_parts(self.data, self.size) }
+    }
+
     pub fn to_str_vec(&self) -> Vec<&str> {
         if self.size == 0 {
             vec![]
         } else {
-            let raw = unsafe { std::slice::from_raw_parts(self.data, self.size) };
-            raw.iter().map(ByteArrayRef::to_str).collect()
+            self.to_slice().iter().map(ByteArrayRef::to_str).collect()
+        }
+    }
+
+    fn to_bytearrayref_map_on_newlines(&self) -> HashMap<&str, ByteArrayRef> {
+        if self.size == 0 {
+            HashMap::new()
+        } else {
+            self.to_slice()
+                .iter()
+                .filter_map(ByteArrayRef::to_option_str_key_value_pair)
+                .collect()
         }
     }
+
+    pub fn to_string_map_on_newlines(&self) -> HashMap<String, String> {
+        self.to_bytearrayref_map_on_newlines()
+            .iter()
+            .map(|(k, v)| (k.to_string(), v.to_string()))
+            .collect()
+    }
+
+    pub fn to_vec_map_on_newlines(&self) -> HashMap<String, Vec<u8>> {
+        self.to_bytearrayref_map_on_newlines()
+            .iter()
+            .map(|(k, v)| (k.to_string(), v.to_vec()))
+            .collect()
+    }
 }
 
-/// Metadata is `<key1>\n<value1>\n<key2>\n<value2>`. Metadata keys or
-/// values cannot contain a newline within.
-pub type MetadataRef = ByteArrayRef;
+impl From<&[ByteArrayRef]> for ByteArrayRefArray {
+    fn from(value: &[ByteArrayRef]) -> ByteArrayRefArray {
+        ByteArrayRefArray {
+            data: value.as_ptr(),
+            size: value.len(),
+        }
+    }
+}
+
+impl<T> From<Option<T>> for ByteArrayRefArray
+where
+    T: Into<ByteArrayRefArray>,
+{
+    fn from(value: Option<T>) -> ByteArrayRefArray {
+        value.map(Into::into).unwrap_or(ByteArrayRefArray::empty())
+    }
+}
+
+/// Each ByteArrayRef is `<key>\n<value>`.
+/// Keys cannot contain a newline.
+pub type MetadataRef = ByteArrayRefArray;
+
+/// Data is `<key1>\n<value1>\n<key2>\n<value2>`.
+/// Keys and values cannot contain a newline within.
+pub type NewlineDelimitedMapRef = ByteArrayRef;
 
 #[repr(C)]
 pub struct ByteArray {

package/sdk-core/crates/sdk-core-c-bridge/src/metric.rs

@@ -231,12 +231,11 @@ pub extern "C" fn temporal_core_metric_record_duration(
 
 impl From<&MetricOptions> for metrics::MetricParameters {
     fn from(options: &MetricOptions) -> Self {
-        metrics::MetricParametersBuilder::default()
+        metrics::MetricParameters::builder()
             .name(options.name.to_string())
             .description(options.description.to_string())
             .unit(options.unit.to_string())
             .build()
-            .unwrap()
     }
 }
 

package/sdk-core/crates/sdk-core-c-bridge/src/runtime.rs

@@ -1,5 +1,5 @@
 use crate::{
-    ByteArray, ByteArrayRef, MetadataRef,
+    ByteArray, ByteArrayRef, NewlineDelimitedMapRef,
     metric::{CustomMetricMeter, CustomMetricMeterRef},
 };
 
@@ -17,12 +17,11 @@ use std::{
 };
 use temporalio_common::telemetry::{
     CoreLog, CoreLogConsumer, HistogramBucketOverrides, Logger, MetricTemporality,
-    OtelCollectorOptionsBuilder, PrometheusExporterOptionsBuilder,
-    TelemetryOptions as CoreTelemetryOptions, TelemetryOptionsBuilder, metrics::CoreMeter,
+    OtelCollectorOptions, PrometheusExporterOptions, TelemetryOptions as CoreTelemetryOptions,
+    metrics::CoreMeter,
 };
 use temporalio_sdk_core::{
-    CoreRuntime, RuntimeOptions as CoreRuntimeOptions,
-    RuntimeOptionsBuilder as CoreRuntimeOptionsBuilder, TokioRuntimeBuilder,
+    CoreRuntime, RuntimeOptions as CoreRuntimeOptions, TokioRuntimeBuilder as TokioRuntime,
     telemetry::{build_otlp_metric_exporter, start_prometheus_metric_exporter},
 };
 use tracing::Level;
@@ -76,21 +75,21 @@ pub struct MetricsOptions {
     pub custom_meter: *const CustomMetricMeter,
 
     pub attach_service_name: bool,
-    pub global_tags: MetadataRef,
+    pub global_tags: NewlineDelimitedMapRef,
     pub metric_prefix: ByteArrayRef,
 }
 
 #[repr(C)]
 pub struct OpenTelemetryOptions {
     pub url: ByteArrayRef,
-    pub headers: MetadataRef,
+    pub headers: NewlineDelimitedMapRef,
     pub metric_periodicity_millis: u32,
     pub metric_temporality: OpenTelemetryMetricTemporality,
     pub durations_as_seconds: bool,
     pub protocol: OpenTelemetryProtocol,
     /// Histogram bucket overrides in form of
     /// `<metric1>\n<float>,<float>,<float>\n<metric2>\n<float>,<float>,<float>`
-    pub histogram_bucket_overrides: MetadataRef,
+    pub histogram_bucket_overrides: NewlineDelimitedMapRef,
 }
 
 #[repr(C)]
@@ -113,7 +112,7 @@ pub struct PrometheusOptions {
     pub durations_as_seconds: bool,
     /// Histogram bucket overrides in form of
     /// `<metric1>\n<float>,<float>,<float>\n<metric2>\n<float>,<float>,<float>`
-    pub histogram_bucket_overrides: MetadataRef,
+    pub histogram_bucket_overrides: NewlineDelimitedMapRef,
 }
 
 #[derive(Clone)]
@@ -143,11 +142,8 @@ pub extern "C" fn temporal_core_runtime_new(options: *const RuntimeOptions) -> R
             // freeable
             let mut runtime = Runtime {
                 core: Arc::new(
-                    CoreRuntime::new(
-                        CoreRuntimeOptions::default(),
-                        TokioRuntimeBuilder::default(),
-                    )
-                    .unwrap(),
+                    CoreRuntime::new(CoreRuntimeOptions::default(), TokioRuntime::default())
+                        .unwrap(),
                 ),
                 log_forwarder: None,
             };
@@ -207,19 +203,15 @@ impl Runtime {
         // Build telemetry options
         let mut log_forwarder = None;
         let telemetry_options = if let Some(v) = unsafe { options.telemetry.as_ref() } {
-            let mut build = TelemetryOptionsBuilder::default();
-
-            // Metrics options (note, metrics meter is late-bound later)
-            if let Some(v) = unsafe { v.metrics.as_ref() } {
-                build.attach_service_name(v.attach_service_name);
-                if let Some(metric_prefix) = v.metric_prefix.to_option_string() {
-                    build.metric_prefix(metric_prefix);
-                }
-            }
+            let (attach_service_name, metric_prefix) =
+                if let Some(v) = unsafe { v.metrics.as_ref() } {
+                    (v.attach_service_name, v.metric_prefix.to_option_string())
+                } else {
+                    (true, None)
+                };
 
-            // Logging options
-            if let Some(v) = unsafe { v.logging.as_ref() } {
-                build.logging(if let Some(callback) = v.forward_to {
+            let logging = unsafe { v.logging.as_ref() }.map(|v| {
+                if let Some(callback) = v.forward_to {
                     let consumer = Arc::new(LogForwarder {
                         callback,
                         active: AtomicBool::new(false),
@@ -233,28 +225,29 @@ impl Runtime {
                     Logger::Console {
                         filter: v.filter.to_string(),
                     }
-                });
-            }
-            build.build()?
-        } else {
-            CoreTelemetryOptions::default()
-        };
+                }
+            });
 
-        let heartbeat_interval = if options.worker_heartbeat_interval_millis == 0 {
-            None
+            CoreTelemetryOptions::builder()
+                .attach_service_name(attach_service_name)
+                .maybe_metric_prefix(metric_prefix)
+                .maybe_logging(logging)
+                .build()
         } else {
-            Some(Duration::from_millis(
-                options.worker_heartbeat_interval_millis,
-            ))
+            CoreTelemetryOptions::default()
         };
 
-        let core_runtime_options = CoreRuntimeOptionsBuilder::default()
+        let core_runtime_options = CoreRuntimeOptions::builder()
             .telemetry_options(telemetry_options)
-            .heartbeat_interval(heartbeat_interval)
-            .build()?;
+            .heartbeat_interval(
+                (options.worker_heartbeat_interval_millis != 0)
+                    .then(|| Duration::from_millis(options.worker_heartbeat_interval_millis)),
+            )
+            .build()
+            .map_err(|e| anyhow::anyhow!(e))?;
 
         // Build core runtime
-        let mut core = CoreRuntime::new(core_runtime_options, TokioRuntimeBuilder::default())?;
+        let mut core = CoreRuntime::new(core_runtime_options, TokioRuntime::default())?;
 
         // We late-bind the metrics after core runtime is created since it needs
         // the Tokio handle
@@ -392,27 +385,28 @@ fn create_meter(
             ));
         }
         // Build OTel exporter
-        let mut build = OtelCollectorOptionsBuilder::default();
-        build
-            .url(Url::parse(otel_options.url.to_str())?)
-            .headers(otel_options.headers.to_string_map_on_newlines())
-            .metric_temporality(match otel_options.metric_temporality {
-                OpenTelemetryMetricTemporality::Cumulative => MetricTemporality::Cumulative,
-                OpenTelemetryMetricTemporality::Delta => MetricTemporality::Delta,
-            })
-            .global_tags(options.global_tags.to_string_map_on_newlines())
-            .use_seconds_for_durations(otel_options.durations_as_seconds)
-            .histogram_bucket_overrides(HistogramBucketOverrides {
-                overrides: parse_histogram_bucket_overrides(
-                    &otel_options.histogram_bucket_overrides,
-                )?,
-            });
-        if otel_options.metric_periodicity_millis > 0 {
-            build.metric_periodicity(Duration::from_millis(
-                otel_options.metric_periodicity_millis.into(),
-            ));
-        }
-        Ok(Arc::new(build_otlp_metric_exporter(build.build()?)?))
+        Ok(Arc::new(build_otlp_metric_exporter(
+            OtelCollectorOptions::builder()
+                .url(Url::parse(otel_options.url.to_str())?)
+                .headers(otel_options.headers.to_string_map_on_newlines())
+                .metric_temporality(match otel_options.metric_temporality {
+                    OpenTelemetryMetricTemporality::Cumulative => MetricTemporality::Cumulative,
+                    OpenTelemetryMetricTemporality::Delta => MetricTemporality::Delta,
+                })
+                .global_tags(options.global_tags.to_string_map_on_newlines())
+                .use_seconds_for_durations(otel_options.durations_as_seconds)
+                .histogram_bucket_overrides(HistogramBucketOverrides {
+                    overrides: parse_histogram_bucket_overrides(
+                        &otel_options.histogram_bucket_overrides,
+                    )?,
+                })
+                .maybe_metric_periodicity(
+                    (otel_options.metric_periodicity_millis > 0).then(|| {
+                        Duration::from_millis(otel_options.metric_periodicity_millis.into())
+                    }),
+                )
+                .build(),
+        )?))
     } else if let Some(prom_options) = unsafe { options.prometheus.as_ref() } {
         if custom_meter.is_some() {
             return Err(anyhow::anyhow!(
@@ -420,8 +414,7 @@ fn create_meter(
             ));
         }
         // Start prom exporter
-        let mut build = PrometheusExporterOptionsBuilder::default();
-        build
+        let build = PrometheusExporterOptions::builder()
             .socket_addr(SocketAddr::from_str(prom_options.bind_address.to_str())?)
             .global_tags(options.global_tags.to_string_map_on_newlines())
             .counters_total_suffix(prom_options.counters_total_suffix)
@@ -432,7 +425,7 @@ fn create_meter(
                     &prom_options.histogram_bucket_overrides,
                 )?,
             });
-        Ok(start_prometheus_metric_exporter(build.build()?)?.meter)
+        Ok(start_prometheus_metric_exporter(build.build())?.meter)
     } else if let Some(custom_meter) = custom_meter {
         Ok(Arc::new(custom_meter))
     } else {
@@ -443,7 +436,7 @@ fn create_meter(
 }
 
 fn parse_histogram_bucket_overrides(
-    raw: &MetadataRef,
+    raw: &NewlineDelimitedMapRef,
 ) -> anyhow::Result<HashMap<String, Vec<f64>>> {
     raw.to_string_map_on_newlines()
         .into_iter()

package/sdk-core/crates/sdk-core-c-bridge/src/testing.rs

@@ -203,24 +203,24 @@ impl TryFrom<&DevServerOptions> for ephemeral_server::TemporalDevServerConfig {
 
     fn try_from(options: &DevServerOptions) -> anyhow::Result<Self> {
         let test_server_options = unsafe { &*options.test_server };
-        Ok(ephemeral_server::TemporalDevServerConfigBuilder::default()
+        Ok(ephemeral_server::TemporalDevServerConfig::builder()
             .exe(test_server_options.exe())
             .namespace(options.namespace.to_string())
             .ip(options.ip.to_string())
-            .port(test_server_options.port())
-            .db_filename(options.database_filename.to_option_string())
+            .maybe_port(test_server_options.port())
+            .maybe_db_filename(options.database_filename.to_option_string())
             .ui(options.ui)
-            .ui_port(if options.ui_port == 0 || !options.ui {
-                None
-            } else {
+            .maybe_ui_port(if options.ui_port != 0 && options.ui {
                 Some(options.ui_port)
+            } else {
+                None
             })
             .log((
                 options.log_format.to_string(),
                 options.log_level.to_string(),
             ))
             .extra_args(test_server_options.extra_args())
-            .build()?)
+            .build())
     }
 }
 
@@ -228,11 +228,11 @@ impl TryFrom<&TestServerOptions> for ephemeral_server::TestServerConfig {
     type Error = anyhow::Error;
 
     fn try_from(options: &TestServerOptions) -> anyhow::Result<Self> {
-        Ok(ephemeral_server::TestServerConfigBuilder::default()
+        Ok(ephemeral_server::TestServerConfig::builder()
             .exe(options.exe())
-            .port(options.port())
+            .maybe_port(options.port())
             .extra_args(options.extra_args())
-            .build()?)
+            .build())
     }
 }
 

package/sdk-core/crates/sdk-core-c-bridge/src/tests/context.rs

@@ -1,8 +1,8 @@
 use crate::{
     client::{
         Client, ClientHttpConnectProxyOptions, ClientKeepAliveOptions, ClientRetryOptions,
-        ClientTlsOptions, RpcCallOptions, temporal_core_client_connect, temporal_core_client_free,
-        temporal_core_client_rpc_call,
+        ClientTlsOptions, GrpcMetadataHolder, RpcCallOptions, temporal_core_client_connect,
+        temporal_core_client_free, temporal_core_client_rpc_call,
     },
     runtime::{
         Runtime, RuntimeOptions, RuntimeOrFail, temporal_core_byte_array_free,
@@ -17,13 +17,13 @@ use crate::{
 use crate::{
     ByteArray, ByteArrayRef,
     tests::utils::{
-        MetadataMap, OwnedRpcCallOptions, RpcCallError, byte_array_to_string, byte_array_to_vec,
-        pointer_or_null,
+        OwnedRpcCallOptions, RpcCallError, byte_array_to_string, byte_array_to_vec, pointer_or_null,
     },
 };
 use anyhow::anyhow;
 use std::{
     any::Any,
+    collections::HashMap,
     panic::{AssertUnwindSafe, UnwindSafe},
     ptr::NonNull,
     sync::{Arc, Condvar, Mutex, MutexGuard, PoisonError, Weak},
@@ -289,10 +289,10 @@ impl Context {
         grpc_override_callback: crate::client::ClientGrpcOverrideCallback,
         grpc_override_callback_user_data: *mut libc::c_void,
     ) -> anyhow::Result<()> {
-        let metadata = options
-            .headers
-            .as_ref()
-            .map(MetadataMap::serialize_from_map);
+        let metadata: Option<GrpcMetadataHolder> = options.headers.as_ref().map(Into::into);
+
+        let binary_metadata: Option<GrpcMetadataHolder> =
+            options.binary_headers.as_ref().map(Into::into);
 
         let tls_options = options.tls_options.as_ref().map(|tls_cfg| {
             let client_tls_cfg = tls_cfg.client_tls_options.as_ref();
@@ -344,7 +344,8 @@ impl Context {
             target_url: options.target_url.as_str().into(),
             client_name: options.client_name.as_str().into(),
             client_version: options.client_version.as_str().into(),
-            metadata: metadata.as_deref().into(),
+            metadata: metadata.as_ref().into(),
+            binary_metadata: binary_metadata.as_ref().into(),
             api_key: options.api_key.as_deref().into(),
             identity: options.identity.as_str().into(),
             tls_options: pointer_or_null(tls_options.as_deref()),
@@ -362,6 +363,7 @@ impl Context {
             _allocations: Box::new((
                 options,
                 metadata,
+                binary_metadata,
                 tls_options,
                 retry_options,
                 keep_alive_options,
@@ -390,14 +392,15 @@ impl Context {
 
     pub fn rpc_call(
         self: &Arc<Self>,
-        mut options: Box<OwnedRpcCallOptions>,
+        options: Box<OwnedRpcCallOptions>,
     ) -> anyhow::Result<Vec<u8>> {
         let c_options = Box::new(RpcCallOptions {
             service: options.service,
             rpc: options.rpc.as_str().into(),
             req: options.req.as_slice().into(),
             retry: options.retry,
-            metadata: options.metadata.as_mut().map(MetadataMap::as_str).into(),
+            metadata: options.metadata.as_ref().into(),
+            binary_metadata: options.binary_metadata.as_ref().into(),
             timeout_millis: options.timeout_millis,
             cancellation_token: options
                 .cancellation_token
@@ -654,3 +657,35 @@ extern "C" fn rpc_call_callback(
         temporal_core_byte_array_free(std::ptr::null_mut(), failure_details);
     }
 }
+
+impl From<&HashMap<String, String>> for GrpcMetadataHolder {
+    fn from(value: &HashMap<String, String>) -> GrpcMetadataHolder {
+        let refs: Vec<Vec<u8>> = value
+            .iter()
+            .map(|(k, v)| format!("{k}\n{v}").into_bytes())
+            .collect();
+
+        GrpcMetadataHolder {
+            data: refs.iter().map(ByteArrayRef::from).collect(),
+            _allocations: refs,
+        }
+    }
+}
+
+impl From<&HashMap<String, Vec<u8>>> for GrpcMetadataHolder {
+    fn from(value: &HashMap<String, Vec<u8>>) -> GrpcMetadataHolder {
+        let refs: Vec<Vec<u8>> = value
+            .iter()
+            .map(|(k, v)| {
+                let mut nv = format!("{k}\n").into_bytes();
+                nv.extend(v);
+                nv
+            })
+            .collect();
+
+        GrpcMetadataHolder {
+            data: refs.iter().map(ByteArrayRef::from).collect(),
+            _allocations: refs,
+        }
+    }
+}