@temporalio/core-bridge 1.14.2-canary-release-testing.0 → 1.16.0

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

@@ -57,10 +57,7 @@ pub extern "C" fn temporal_core_metric_attributes_new(
     size: libc::size_t,
 ) -> *mut MetricAttributes {
     let meter = unsafe { &*meter };
-    let orig = meter
-        .core
-        .inner
-        .new_attributes(meter.core.default_attribs.clone());
+    let orig = meter.core.get_default_attributes().clone();
     Box::into_raw(Box::new(metric_attributes_append(
         meter, &orig, attrs, size,
     )))
@@ -94,7 +91,7 @@ fn metric_attributes_append(
     size: libc::size_t,
 ) -> MetricAttributes {
     let attrs = unsafe { std::slice::from_raw_parts(attrs, size) };
-    let core = meter.core.inner.extend_attributes(
+    let core = meter.core.extend_attributes(
         orig.clone(),
         metrics::NewAttributes {
             attributes: attrs.iter().map(metric_attribute_to_key_value).collect(),
@@ -158,20 +155,18 @@ pub extern "C" fn temporal_core_metric_new(
     let meter = unsafe { &*meter };
     let options = unsafe { &*options };
     Box::into_raw(Box::new(match options.kind {
-        MetricKind::CounterInteger => {
-            Metric::CounterInteger(meter.core.inner.counter(options.into()))
-        }
+        MetricKind::CounterInteger => Metric::CounterInteger(meter.core.counter(options.into())),
         MetricKind::HistogramInteger => {
-            Metric::HistogramInteger(meter.core.inner.histogram(options.into()))
+            Metric::HistogramInteger(meter.core.histogram(options.into()))
         }
         MetricKind::HistogramFloat => {
-            Metric::HistogramFloat(meter.core.inner.histogram_f64(options.into()))
+            Metric::HistogramFloat(meter.core.histogram_f64(options.into()))
         }
         MetricKind::HistogramDuration => {
-            Metric::HistogramDuration(meter.core.inner.histogram_duration(options.into()))
+            Metric::HistogramDuration(meter.core.histogram_duration(options.into()))
         }
-        MetricKind::GaugeInteger => Metric::GaugeInteger(meter.core.inner.gauge(options.into())),
-        MetricKind::GaugeFloat => Metric::GaugeFloat(meter.core.inner.gauge_f64(options.into())),
+        MetricKind::GaugeInteger => Metric::GaugeInteger(meter.core.gauge(options.into())),
+        MetricKind::GaugeFloat => Metric::GaugeFloat(meter.core.gauge_f64(options.into())),
     }))
 }
 
@@ -231,12 +226,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()
     }
 }
 
@@ -484,7 +478,7 @@ struct CustomMetricAttributes {
 unsafe impl Send for CustomMetricAttributes {}
 unsafe impl Sync for CustomMetricAttributes {}
 
-impl metrics::CustomMetricAttributes for CustomMetricAttributes {
+impl metrics::core::CustomMetricAttributes for CustomMetricAttributes {
     fn as_any(self: Arc<Self>) -> Arc<dyn Any + Send + Sync> {
         self as Arc<dyn Any + Send + Sync>
     }

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,13 +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,
+    build_otlp_metric_exporter, metrics::CoreMeter, start_prometheus_metric_exporter,
 };
 use temporalio_sdk_core::{
-    CoreRuntime, RuntimeOptions as CoreRuntimeOptions,
-    RuntimeOptionsBuilder as CoreRuntimeOptionsBuilder, TokioRuntimeBuilder,
-    telemetry::{build_otlp_metric_exporter, start_prometheus_metric_exporter},
+    CoreRuntime, RuntimeOptions as CoreRuntimeOptions, TokioRuntimeBuilder as TokioRuntime,
 };
 use tracing::Level;
 use url::Url;
@@ -76,21 +74,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 +111,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 +141,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 +202,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 +224,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 +384,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 +413,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 +424,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 +435,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,
+        ClientHttpConnectProxyOptions, ClientKeepAliveOptions, ClientRetryOptions,
+        ClientTlsOptions, Connection, 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,19 +17,19 @@ 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},
     time::Duration,
 };
-use temporalio_client::ClientOptions;
+use temporalio_client::ConnectionOptions;
 use temporalio_sdk_core::ephemeral_server::{
     EphemeralExe, EphemeralExeVersion, TemporalDevServerConfig,
 };
@@ -48,7 +48,7 @@ struct InnerContext {
     runtime: *mut Runtime,
     ephemeral_server: *mut EphemeralServer,
     ephemeral_server_target: String,
-    client: *mut Client,
+    client: *mut Connection,
 }
 
 unsafe impl Send for InnerContext {}
@@ -104,7 +104,7 @@ impl Context {
     }
 
     #[allow(dead_code)]
-    pub fn client(&self) -> anyhow::Result<Option<NonNull<Client>>> {
+    pub fn client(&self) -> anyhow::Result<Option<NonNull<Connection>>> {
         Ok(NonNull::new(self.wait_for_available()?.client))
     }
 
@@ -279,20 +279,20 @@ impl Context {
         self.wait_for_operation()
     }
 
-    pub fn client_connect(self: &Arc<Self>, options: Box<ClientOptions>) -> anyhow::Result<()> {
+    pub fn client_connect(self: &Arc<Self>, options: Box<ConnectionOptions>) -> anyhow::Result<()> {
         Self::client_connect_with_override(self, options, None, std::ptr::null_mut())
     }
 
     pub fn client_connect_with_override(
         self: &Arc<Self>,
-        options: Box<ClientOptions>,
+        options: Box<ConnectionOptions>,
         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();
@@ -340,11 +340,12 @@ impl Context {
             })
         });
 
-        let client_options = Box::new(crate::client::ClientOptions {
-            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(),
+        let client_options = Box::new(crate::client::ConnectionOptions {
+            target_url: options.target.as_str().into(),
+            client_name: options.get_client_name().into(),
+            client_version: options.get_client_version().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
@@ -579,7 +582,7 @@ extern "C" fn ephemeral_server_shutdown_callback(
 
 extern "C" fn client_connect_callback(
     user_data: *mut libc::c_void,
-    mut client: *mut Client,
+    mut client: *mut Connection,
     mut fail: *const ByteArray,
 ) {
     let user_data = unsafe { Box::from_raw(user_data as *mut CallbackUserData<(), Context>) };
@@ -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,
+        }
+    }
+}