@temporalio/core-bridge 1.13.1 → 1.14.0

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

@@ -0,0 +1,314 @@
+use crate::{ByteArray, ByteArrayRef};
+use serde::Serialize;
+use std::collections::HashMap;
+use temporalio_common::envconfig::{
+    self, ClientConfig as CoreClientConfig, ClientConfigCodec as CoreClientConfigCodec,
+    ClientConfigProfile as CoreClientConfigProfile, ClientConfigTLS as CoreClientConfigTLS,
+    DataSource as CoreDataSource, LoadClientConfigOptions, LoadClientConfigProfileOptions,
+};
+
+/// OrFail result for client config loading operations.
+/// Either success or fail will be null, but never both.
+/// If success is not null, it contains JSON-serialized client configuration data.
+/// If fail is not null, it contains UTF-8 encoded error message.
+/// The returned ByteArrays must be freed by the caller.
+#[repr(C)]
+pub struct ClientEnvConfigOrFail {
+    pub success: *const ByteArray,
+    pub fail: *const ByteArray,
+}
+
+/// OrFail result for client config profile loading operations.
+/// Either success or fail will be null, but never both.
+/// If success is not null, it contains JSON-serialized client configuration profile data.
+/// If fail is not null, it contains UTF-8 encoded error message.
+/// The returned ByteArrays must be freed by the caller.
+#[repr(C)]
+pub struct ClientEnvConfigProfileOrFail {
+    pub success: *const ByteArray,
+    pub fail: *const ByteArray,
+}
+
+/// Options for loading client configuration.
+#[repr(C)]
+pub struct ClientEnvConfigLoadOptions {
+    pub path: ByteArrayRef,
+    pub data: ByteArrayRef,
+    pub config_file_strict: bool,
+    pub env_vars: ByteArrayRef,
+}
+
+/// Options for loading a specific client configuration profile.
+#[repr(C)]
+pub struct ClientEnvConfigProfileLoadOptions {
+    pub profile: ByteArrayRef,
+    pub path: ByteArrayRef,
+    pub data: ByteArrayRef,
+    pub disable_file: bool,
+    pub disable_env: bool,
+    pub config_file_strict: bool,
+    pub env_vars: ByteArrayRef,
+}
+
+// Wrapper types for JSON serialization
+#[derive(Serialize)]
+struct ClientEnvConfig {
+    profiles: HashMap<String, ClientEnvConfigProfile>,
+}
+
+impl From<CoreClientConfig> for ClientEnvConfig {
+    fn from(c: CoreClientConfig) -> Self {
+        Self {
+            profiles: c.profiles.into_iter().map(|(k, v)| (k, v.into())).collect(),
+        }
+    }
+}
+
+#[derive(Serialize)]
+struct ClientEnvConfigProfile {
+    #[serde(skip_serializing_if = "Option::is_none")]
+    address: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    namespace: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    api_key: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    tls: Option<ClientEnvConfigTLS>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    codec: Option<ClientEnvConfigCodec>,
+    #[serde(skip_serializing_if = "HashMap::is_empty")]
+    grpc_meta: HashMap<String, String>,
+}
+
+impl From<CoreClientConfigProfile> for ClientEnvConfigProfile {
+    fn from(c: CoreClientConfigProfile) -> Self {
+        Self {
+            address: c.address,
+            namespace: c.namespace,
+            api_key: c.api_key,
+            tls: c.tls.map(Into::into),
+            codec: c.codec.map(Into::into),
+            grpc_meta: c.grpc_meta,
+        }
+    }
+}
+
+#[derive(Serialize)]
+struct ClientEnvConfigTLS {
+    #[serde(skip_serializing_if = "Option::is_none")]
+    disabled: Option<bool>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    server_name: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    server_ca_cert: Option<DataSource>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    client_cert: Option<DataSource>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    client_key: Option<DataSource>,
+}
+
+impl From<CoreClientConfigTLS> for ClientEnvConfigTLS {
+    fn from(c: CoreClientConfigTLS) -> Self {
+        Self {
+            disabled: c.disabled,
+            server_name: c.server_name,
+            server_ca_cert: c.server_ca_cert.map(Into::into),
+            client_cert: c.client_cert.map(Into::into),
+            client_key: c.client_key.map(Into::into),
+        }
+    }
+}
+
+#[derive(Serialize)]
+struct ClientEnvConfigCodec {
+    #[serde(skip_serializing_if = "Option::is_none")]
+    endpoint: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    auth: Option<String>,
+}
+
+impl From<CoreClientConfigCodec> for ClientEnvConfigCodec {
+    fn from(c: CoreClientConfigCodec) -> Self {
+        Self {
+            endpoint: c.endpoint,
+            auth: c.auth,
+        }
+    }
+}
+
+#[derive(Serialize)]
+struct DataSource {
+    #[serde(skip_serializing_if = "Option::is_none")]
+    path: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    data: Option<Vec<u8>>,
+}
+
+impl From<CoreDataSource> for DataSource {
+    fn from(c: CoreDataSource) -> Self {
+        match c {
+            CoreDataSource::Path(p) => Self {
+                path: Some(p),
+                data: None,
+            },
+            CoreDataSource::Data(d) => Self {
+                path: None,
+                data: Some(d),
+            },
+        }
+    }
+}
+
+// Helper functions
+fn parse_config_source(
+    path: &ByteArrayRef,
+    data: &ByteArrayRef,
+) -> Result<Option<CoreDataSource>, String> {
+    if !path.data.is_null() && path.size > 0 {
+        Ok(Some(CoreDataSource::Path(path.to_string())))
+    } else if !data.data.is_null() && data.size > 0 {
+        Ok(Some(CoreDataSource::Data(data.to_vec())))
+    } else {
+        Ok(None)
+    }
+}
+
+fn parse_env_vars(env_vars: &ByteArrayRef) -> Result<Option<HashMap<String, String>>, String> {
+    if env_vars.data.is_null() || env_vars.size == 0 {
+        return Ok(None);
+    }
+
+    let env_json = std::str::from_utf8(env_vars.to_slice())
+        .map_err(|e| format!("Invalid env vars UTF-8: {e}"))?;
+
+    serde_json::from_str(env_json)
+        .map(Some)
+        .map_err(|e| format!("Invalid env vars JSON: {e}"))
+}
+
+// Simple helper to handle serialization errors consistently
+fn serialize_or_error<T: Serialize>(data: T) -> Result<*const ByteArray, *const ByteArray> {
+    match serde_json::to_vec(&data) {
+        Ok(json_bytes) => {
+            let result = ByteArray::from_vec(json_bytes);
+            Ok(result.into_raw())
+        }
+        Err(e) => {
+            let err = ByteArray::from_utf8(format!("Failed to serialize: {e}"));
+            Err(err.into_raw())
+        }
+    }
+}
+
+/// Load all client profiles from given sources.
+/// Returns ClientConfigOrFail with either success JSON or error message.
+/// The returned ByteArrays must be freed by the caller.
+#[unsafe(no_mangle)]
+pub extern "C" fn temporal_core_client_env_config_load(
+    options: *const ClientEnvConfigLoadOptions,
+) -> ClientEnvConfigOrFail {
+    if options.is_null() {
+        let err = ByteArray::from_utf8("Options cannot be null".to_string());
+        return ClientEnvConfigOrFail {
+            success: std::ptr::null(),
+            fail: err.into_raw(),
+        };
+    }
+
+    let result = || -> Result<ClientEnvConfig, String> {
+        let opts = unsafe { &*options };
+        let env_vars_map = parse_env_vars(&opts.env_vars)?;
+
+        let load_options = LoadClientConfigOptions {
+            config_source: parse_config_source(&opts.path, &opts.data)?,
+            config_file_strict: opts.config_file_strict,
+        };
+
+        let core_config = envconfig::load_client_config(load_options, env_vars_map.as_ref())
+            .map_err(|e| e.to_string())?;
+
+        Ok(core_config.into())
+    };
+
+    match result() {
+        Ok(data) => match serialize_or_error(data) {
+            Ok(success) => ClientEnvConfigOrFail {
+                success,
+                fail: std::ptr::null(),
+            },
+            Err(fail) => ClientEnvConfigOrFail {
+                success: std::ptr::null(),
+                fail,
+            },
+        },
+        Err(e) => {
+            let err = ByteArray::from_utf8(e);
+            ClientEnvConfigOrFail {
+                success: std::ptr::null(),
+                fail: err.into_raw(),
+            }
+        }
+    }
+}
+
+/// Load a single client profile from given sources with env overrides.
+/// Returns ClientConfigProfileOrFail with either success JSON or error message.
+/// The returned ByteArrays must be freed by the caller.
+#[unsafe(no_mangle)]
+pub extern "C" fn temporal_core_client_env_config_profile_load(
+    options: *const ClientEnvConfigProfileLoadOptions,
+) -> ClientEnvConfigProfileOrFail {
+    if options.is_null() {
+        let err = ByteArray::from_utf8("Options cannot be null".to_string());
+        return ClientEnvConfigProfileOrFail {
+            success: std::ptr::null(),
+            fail: err.into_raw(),
+        };
+    }
+
+    let result = || -> Result<ClientEnvConfigProfile, String> {
+        let opts = unsafe { &*options };
+
+        let profile_name = if !opts.profile.data.is_null() && opts.profile.size > 0 {
+            Some(opts.profile.to_string())
+        } else {
+            None
+        };
+
+        let config_source = parse_config_source(&opts.path, &opts.data)?;
+        let env_vars_map = parse_env_vars(&opts.env_vars)?;
+
+        let load_options = LoadClientConfigProfileOptions {
+            config_source,
+            config_file_profile: profile_name,
+            config_file_strict: opts.config_file_strict,
+            disable_file: opts.disable_file,
+            disable_env: opts.disable_env,
+        };
+
+        let profile = envconfig::load_client_config_profile(load_options, env_vars_map.as_ref())
+            .map_err(|e| e.to_string())?;
+
+        Ok(profile.into())
+    };
+
+    match result() {
+        Ok(data) => match serialize_or_error(data) {
+            Ok(success) => ClientEnvConfigProfileOrFail {
+                success,
+                fail: std::ptr::null(),
+            },
+            Err(fail) => ClientEnvConfigProfileOrFail {
+                success: std::ptr::null(),
+                fail,
+            },
+        },
+        Err(e) => {
+            let err = ByteArray::from_utf8(e);
+            ClientEnvConfigProfileOrFail {
+                success: std::ptr::null(),
+                fail: err.into_raw(),
+            }
+        }
+    }
+}

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

@@ -9,6 +9,7 @@
 )]
 
 pub mod client;
+pub mod envconfig;
 pub mod metric;
 pub mod random;
 pub mod runtime;
@@ -143,7 +144,7 @@ impl ByteArrayRefArray {
     }
 }
 
-/// Metadata is <key1>\n<value1>\n<key2>\n<value2>. Metadata keys or
+/// Metadata is `<key1>\n<value1>\n<key2>\n<value2>`. Metadata keys or
 /// values cannot contain a newline within.
 pub type MetadataRef = ByteArrayRef;
 

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

@@ -1,6 +1,6 @@
 use crate::{ByteArrayRef, runtime::Runtime};
 use std::{any::Any, error::Error, sync::Arc, time::Duration};
-use temporal_sdk_core_api::telemetry::metrics;
+use temporalio_common::telemetry::metrics;
 
 pub struct MetricMeter {
     core: metrics::TemporalMeter,

package/sdk-core/{core-c-bridge → crates/sdk-core-c-bridge}/src/random.rs

@@ -32,9 +32,9 @@ pub extern "C" fn temporal_core_random_int32_range(
 ) -> i32 {
     let random = unsafe { &mut *random };
     if max_inclusive {
-        random.rand.gen_range(min..=max)
+        random.rand.random_range(min..=max)
     } else {
-        random.rand.gen_range(min..max)
+        random.rand.random_range(min..max)
     }
 }
 
@@ -47,9 +47,9 @@ pub extern "C" fn temporal_core_random_double_range(
 ) -> f64 {
     let random = unsafe { &mut *random };
     if max_inclusive {
-        random.rand.gen_range(min..=max)
+        random.rand.random_range(min..=max)
     } else {
-        random.rand.gen_range(min..max)
+        random.rand.random_range(min..max)
     }
 }
 

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

@@ -1,29 +1,29 @@
-use crate::ByteArray;
-use crate::ByteArrayRef;
-use crate::MetadataRef;
-use crate::metric::CustomMetricMeter;
-use crate::metric::CustomMetricMeterRef;
+use crate::{
+    ByteArray, ByteArrayRef, MetadataRef,
+    metric::{CustomMetricMeter, CustomMetricMeterRef},
+};
 
 use serde_json::json;
-use std::collections::HashMap;
-use std::fmt;
-use std::net::SocketAddr;
-use std::str::FromStr;
-use std::sync::atomic::AtomicBool;
-use std::sync::atomic::Ordering;
-use std::sync::{Arc, Mutex};
-use std::time::Duration;
-use std::time::UNIX_EPOCH;
-use temporal_sdk_core::CoreRuntime;
-use temporal_sdk_core::TokioRuntimeBuilder;
-use temporal_sdk_core::telemetry::{build_otlp_metric_exporter, start_prometheus_metric_exporter};
-use temporal_sdk_core_api::telemetry::HistogramBucketOverrides;
-use temporal_sdk_core_api::telemetry::MetricTemporality;
-use temporal_sdk_core_api::telemetry::metrics::CoreMeter;
-use temporal_sdk_core_api::telemetry::{CoreLog, CoreLogConsumer};
-use temporal_sdk_core_api::telemetry::{
-    Logger, OtelCollectorOptionsBuilder, PrometheusExporterOptionsBuilder,
-    TelemetryOptions as CoreTelemetryOptions, TelemetryOptionsBuilder,
+use std::{
+    collections::HashMap,
+    fmt,
+    net::SocketAddr,
+    str::FromStr,
+    sync::{
+        Arc, Mutex,
+        atomic::{AtomicBool, Ordering},
+    },
+    time::{Duration, UNIX_EPOCH},
+};
+use temporalio_common::telemetry::{
+    CoreLog, CoreLogConsumer, HistogramBucketOverrides, Logger, MetricTemporality,
+    OtelCollectorOptionsBuilder, PrometheusExporterOptionsBuilder,
+    TelemetryOptions as CoreTelemetryOptions, TelemetryOptionsBuilder, metrics::CoreMeter,
+};
+use temporalio_sdk_core::{
+    CoreRuntime, RuntimeOptions as CoreRuntimeOptions,
+    RuntimeOptionsBuilder as CoreRuntimeOptionsBuilder, TokioRuntimeBuilder,
+    telemetry::{build_otlp_metric_exporter, start_prometheus_metric_exporter},
 };
 use tracing::Level;
 use url::Url;
@@ -31,6 +31,7 @@ use url::Url;
 #[repr(C)]
 pub struct RuntimeOptions {
     pub telemetry: *const TelemetryOptions,
+    pub worker_heartbeat_interval_millis: u64,
 }
 
 #[repr(C)]
@@ -88,7 +89,7 @@ pub struct OpenTelemetryOptions {
     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>
+    /// `<metric1>\n<float>,<float>,<float>\n<metric2>\n<float>,<float>,<float>`
     pub histogram_bucket_overrides: MetadataRef,
 }
 
@@ -111,7 +112,7 @@ pub struct PrometheusOptions {
     pub unit_suffix: bool,
     pub durations_as_seconds: bool,
     /// Histogram bucket overrides in form of
-    /// <metric1>\n<float>,<float>,<float>\n<metric2>\n<float>,<float>,<float>
+    /// `<metric1>\n<float>,<float>,<float>\n<metric2>\n<float>,<float>,<float>`
     pub histogram_bucket_overrides: MetadataRef,
 }
 
@@ -143,7 +144,7 @@ pub extern "C" fn temporal_core_runtime_new(options: *const RuntimeOptions) -> R
             let mut runtime = Runtime {
                 core: Arc::new(
                     CoreRuntime::new(
-                        CoreTelemetryOptions::default(),
+                        CoreRuntimeOptions::default(),
                         TokioRuntimeBuilder::default(),
                     )
                     .unwrap(),
@@ -239,8 +240,21 @@ impl Runtime {
             CoreTelemetryOptions::default()
         };
 
+        let heartbeat_interval = if options.worker_heartbeat_interval_millis == 0 {
+            None
+        } else {
+            Some(Duration::from_millis(
+                options.worker_heartbeat_interval_millis,
+            ))
+        };
+
+        let core_runtime_options = CoreRuntimeOptionsBuilder::default()
+            .telemetry_options(telemetry_options)
+            .heartbeat_interval(heartbeat_interval)
+            .build()?;
+
         // Build core runtime
-        let mut core = CoreRuntime::new(telemetry_options, TokioRuntimeBuilder::default())?;
+        let mut core = CoreRuntime::new(core_runtime_options, TokioRuntimeBuilder::default())?;
 
         // We late-bind the metrics after core runtime is created since it needs
         // the Tokio handle

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

@@ -1,11 +1,8 @@
 use std::time::Duration;
 
-use crate::ByteArray;
-use crate::ByteArrayRef;
-use crate::UserDataHandle;
-use crate::runtime::Runtime;
+use crate::{ByteArray, ByteArrayRef, UserDataHandle, runtime::Runtime};
 
-use temporal_sdk_core::ephemeral_server;
+use temporalio_sdk_core::ephemeral_server;
 
 pub struct EphemeralServer {
     runtime: Runtime,

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

@@ -1,30 +1,36 @@
-use crate::client::{
-    Client, ClientHttpConnectProxyOptions, ClientKeepAliveOptions, ClientRetryOptions,
-    ClientTlsOptions, RpcCallOptions, temporal_core_client_connect, temporal_core_client_free,
-    temporal_core_client_rpc_call,
-};
-use crate::runtime::{
-    Runtime, RuntimeOptions, RuntimeOrFail, temporal_core_byte_array_free,
-    temporal_core_runtime_free, temporal_core_runtime_new,
-};
-use crate::testing::{
-    DevServerOptions, EphemeralServer, TestServerOptions, temporal_core_ephemeral_server_free,
-    temporal_core_ephemeral_server_shutdown, temporal_core_ephemeral_server_start_dev_server,
+use crate::{
+    client::{
+        Client, ClientHttpConnectProxyOptions, ClientKeepAliveOptions, ClientRetryOptions,
+        ClientTlsOptions, RpcCallOptions, temporal_core_client_connect, temporal_core_client_free,
+        temporal_core_client_rpc_call,
+    },
+    runtime::{
+        Runtime, RuntimeOptions, RuntimeOrFail, temporal_core_byte_array_free,
+        temporal_core_runtime_free, temporal_core_runtime_new,
+    },
+    testing::{
+        DevServerOptions, EphemeralServer, TestServerOptions, temporal_core_ephemeral_server_free,
+        temporal_core_ephemeral_server_shutdown, temporal_core_ephemeral_server_start_dev_server,
+    },
 };
 
-use crate::tests::utils::{
-    MetadataMap, OwnedRpcCallOptions, RpcCallError, byte_array_to_string, byte_array_to_vec,
-    pointer_or_null,
+use crate::{
+    ByteArray, ByteArrayRef,
+    tests::utils::{
+        MetadataMap, OwnedRpcCallOptions, RpcCallError, byte_array_to_string, byte_array_to_vec,
+        pointer_or_null,
+    },
 };
-use crate::{ByteArray, ByteArrayRef};
 use anyhow::anyhow;
-use std::any::Any;
-use std::panic::{AssertUnwindSafe, UnwindSafe};
-use std::ptr::NonNull;
-use std::sync::{Arc, Condvar, Mutex, MutexGuard, PoisonError, Weak};
-use std::time::Duration;
-use temporal_client::ClientOptions;
-use temporal_sdk_core::ephemeral_server::{
+use std::{
+    any::Any,
+    panic::{AssertUnwindSafe, UnwindSafe},
+    ptr::NonNull,
+    sync::{Arc, Condvar, Mutex, MutexGuard, PoisonError, Weak},
+    time::Duration,
+};
+use temporalio_client::ClientOptions;
+use temporalio_sdk_core::ephemeral_server::{
     EphemeralExe, EphemeralExeVersion, TemporalDevServerConfig,
 };
 
@@ -147,6 +153,7 @@ impl Context {
 
         let RuntimeOrFail { runtime, fail } = temporal_core_runtime_new(&RuntimeOptions {
             telemetry: std::ptr::null(),
+            worker_heartbeat_interval_millis: 0,
         });
 
         if let Some(fail) = byte_array_to_string(runtime, fail) {
@@ -156,11 +163,7 @@ impl Context {
                 temporal_core_runtime_free(runtime);
                 ""
             };
-            Err(anyhow!(
-                "Runtime creation failed: {}{}",
-                runtime_is_null,
-                fail
-            ))
+            Err(anyhow!("Runtime creation failed: {runtime_is_null}{fail}"))
         } else if runtime.is_null() {
             Err(anyhow!("Runtime creation failed: runtime is null"))
         } else {
@@ -291,8 +294,8 @@ impl Context {
             .as_ref()
             .map(MetadataMap::serialize_from_map);
 
-        let tls_options = options.tls_cfg.as_ref().map(|tls_cfg| {
-            let client_tls_cfg = tls_cfg.client_tls_config.as_ref();
+        let tls_options = options.tls_options.as_ref().map(|tls_cfg| {
+            let client_tls_cfg = tls_cfg.client_tls_options.as_ref();
             Box::new(ClientTlsOptions {
                 server_root_ca_cert: tls_cfg.server_root_ca_cert.as_deref().into(),
                 domain: tls_cfg.domain.as_deref().into(),
@@ -304,17 +307,17 @@ impl Context {
         });
 
         let retry_options = Box::new(ClientRetryOptions {
-            initial_interval_millis: options.retry_config.initial_interval.as_millis() as u64,
-            randomization_factor: options.retry_config.randomization_factor,
-            multiplier: options.retry_config.multiplier,
-            max_interval_millis: options.retry_config.max_interval.as_millis() as u64,
+            initial_interval_millis: options.retry_options.initial_interval.as_millis() as u64,
+            randomization_factor: options.retry_options.randomization_factor,
+            multiplier: options.retry_options.multiplier,
+            max_interval_millis: options.retry_options.max_interval.as_millis() as u64,
             max_elapsed_time_millis: options
-                .retry_config
+                .retry_options
                 .max_elapsed_time
                 .as_ref()
                 .map(Duration::as_millis)
                 .unwrap_or(0) as u64,
-            max_retries: options.retry_config.max_retries,
+            max_retries: options.retry_options.max_retries,
         });
 
         let keep_alive_options = options.keep_alive.as_ref().map(|keep_alive| {
@@ -516,8 +519,7 @@ extern "C" fn ephemeral_server_start_callback(
 
             if let Some(fail) = fail {
                 ContextOperationState::CallbackError(anyhow!(
-                    "Ephemeral server start failed: {}",
-                    fail
+                    "Ephemeral server start failed: {fail}"
                 ))
             } else if server.is_null() {
                 ContextOperationState::CallbackError(anyhow!(
@@ -562,8 +564,7 @@ extern "C" fn ephemeral_server_shutdown_callback(
         let _ = context.complete_operation_catch_unwind(|guard| {
             if let Some(fail) = byte_array_to_string(guard.runtime, std::mem::take(&mut fail)) {
                 ContextOperationState::CallbackError(anyhow!(
-                    "Ephemeral server shutdown failed: {}",
-                    fail
+                    "Ephemeral server shutdown failed: {fail}"
                 ))
             } else {
                 ContextOperationState::CallbackOk(None)
@@ -585,7 +586,7 @@ extern "C" fn client_connect_callback(
     if let Some(context) = user_data.context.upgrade() {
         let _ = context.complete_operation_catch_unwind(|guard| {
             if let Some(fail) = byte_array_to_string(guard.runtime, std::mem::take(&mut fail)) {
-                ContextOperationState::CallbackError(anyhow!("Client connect failed: {}", fail))
+                ContextOperationState::CallbackError(anyhow!("Client connect failed: {fail}"))
             } else {
                 guard.client = std::mem::take(&mut client);
                 ContextOperationState::CallbackOk(None)