@temporalio/core-bridge 1.15.0 → 1.16.1

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

@@ -14,17 +14,15 @@ use std::{
     time::Duration,
 };
 use temporalio_client::{
-    ClientKeepAliveOptions as CoreClientKeepAliveOptions, ClientOptions as CoreClientOptions,
-    ClientTlsOptions as CoreClientTlsOptions, CloudService, ConfiguredClient, HealthService,
-    OperatorService, RetryClient, RetryOptions, TemporalServiceClient, TestService,
-    TlsOptions as CoreTlsOptions, WorkflowService, callback_based, proxy::HttpConnectProxyOptions,
+    ClientKeepAliveOptions as CoreClientKeepAliveOptions, RetryOptions, callback_based,
+    grpc::{CloudService, HealthService, OperatorService, TestService, WorkflowService},
 };
 use tokio::sync::oneshot;
 use tonic::metadata::{MetadataKey, MetadataValue};
 use url::Url;
 
 #[repr(C)]
-pub struct ClientOptions {
+pub struct ConnectionOptions {
     pub target_url: ByteArrayRef,
     pub client_name: ByteArrayRef,
     pub client_version: ByteArrayRef,
@@ -80,21 +78,21 @@ pub struct ClientHttpConnectProxyOptions {
     pub password: ByteArrayRef,
 }
 
-type CoreClient = RetryClient<ConfiguredClient<TemporalServiceClient>>;
+type CoreConnection = temporalio_client::Connection;
 
-pub struct Client {
+pub struct Connection {
     pub(crate) runtime: Runtime,
-    pub(crate) core: CoreClient,
+    pub(crate) core: CoreConnection,
 }
 
 // Expected to outlive all async calls that use it
-unsafe impl Send for Client {}
-unsafe impl Sync for Client {}
+unsafe impl Send for Connection {}
+unsafe impl Sync for Connection {}
 
 /// If success or fail are not null, they must be manually freed when done.
 pub type ClientConnectCallback = unsafe extern "C" fn(
     user_data: *mut libc::c_void,
-    success: *mut Client,
+    success: *mut Connection,
     fail: *const ByteArray,
 );
 
@@ -103,14 +101,14 @@ pub type ClientConnectCallback = unsafe extern "C" fn(
 #[unsafe(no_mangle)]
 pub extern "C" fn temporal_core_client_connect(
     runtime: *mut Runtime,
-    options: *const ClientOptions,
+    options: *const ConnectionOptions,
     user_data: *mut libc::c_void,
     callback: ClientConnectCallback,
 ) {
     let runtime = unsafe { &mut *runtime };
     // Convert opts
     let options = unsafe { &*options };
-    let core_options: CoreClientOptions = match options.try_into() {
+    let mut connection_options: temporalio_client::ConnectionOptions = match options.try_into() {
         Ok(v) => v,
         Err(err) => {
             unsafe {
@@ -126,24 +124,22 @@ pub extern "C" fn temporal_core_client_connect(
         }
     };
     // Create override if present
-    let service_override = options.grpc_override_callback.map(|cb| {
-        create_callback_based_grpc_service(runtime, cb, options.grpc_override_callback_user_data)
-    });
+    if let Some(cb) = options.grpc_override_callback {
+        connection_options.service_override = Some(create_callback_based_grpc_service(
+            runtime,
+            cb,
+            options.grpc_override_callback_user_data,
+        ));
+    }
     // Spawn async call
     let user_data = UserDataHandle(user_data);
-    let core = runtime.core.clone();
+    connection_options.metrics_meter = runtime.core.telemetry().get_metric_meter();
     runtime.core.tokio_handle().spawn(async move {
-        match core_options
-            .connect_no_namespace_with_service_override(
-                core.telemetry().get_temporal_metric_meter(),
-                service_override,
-            )
-            .await
-        {
-            Ok(core) => {
-                let owned_client = Box::into_raw(Box::new(Client {
+        match temporalio_client::Connection::connect(connection_options).await {
+            Ok(connection) => {
+                let owned_client = Box::into_raw(Box::new(Connection {
                     runtime: runtime.clone(),
-                    core,
+                    core: connection,
                 }));
                 unsafe {
                     callback(user_data.into(), owned_client, std::ptr::null());
@@ -232,40 +228,41 @@ fn create_callback_based_grpc_service(
 }
 
 #[unsafe(no_mangle)]
-pub extern "C" fn temporal_core_client_free(client: *mut Client) {
+pub extern "C" fn temporal_core_client_free(client: *mut Connection) {
     unsafe {
         let _ = Box::from_raw(client);
     }
 }
 
 #[unsafe(no_mangle)]
-pub extern "C" fn temporal_core_client_update_metadata(client: *mut Client, metadata: MetadataRef) {
+pub extern "C" fn temporal_core_client_update_metadata(
+    client: *mut Connection,
+    metadata: MetadataRef,
+) {
     let client = unsafe { &*client };
     let _result = client
         .core
-        .get_client()
         .set_headers(metadata.to_string_map_on_newlines());
 }
 
 #[unsafe(no_mangle)]
 pub extern "C" fn temporal_core_client_update_binary_metadata(
-    client: *mut Client,
+    client: *mut Connection,
     metadata: MetadataRef,
 ) {
     let client = unsafe { &*client };
     let _result = client
         .core
-        .get_client()
         .set_binary_headers(metadata.to_vec_map_on_newlines());
 }
 
 #[unsafe(no_mangle)]
-pub extern "C" fn temporal_core_client_update_api_key(client: *mut Client, api_key: ByteArrayRef) {
+pub extern "C" fn temporal_core_client_update_api_key(
+    client: *mut Connection,
+    api_key: ByteArrayRef,
+) {
     let client = unsafe { &*client };
-    client
-        .core
-        .get_client()
-        .set_api_key(api_key.to_option_string());
+    client.core.set_api_key(api_key.to_option_string());
 }
 
 /// Callback that is invoked for every gRPC call if set on the client options.
@@ -496,7 +493,7 @@ macro_rules! service_call {
 /// Client, options, and user data must live through callback.
 #[unsafe(no_mangle)]
 pub extern "C" fn temporal_core_client_rpc_call(
-    client: *mut Client,
+    client: *mut Connection,
     options: *const RpcCallOptions,
     user_data: *mut libc::c_void,
     callback: ClientRpcCallCallback,
@@ -558,13 +555,15 @@ macro_rules! rpc_call_on_trait {
         if $call.retry {
             rpc_resp($trait::$call_name(&mut $client, rpc_req($call)?).await)
         } else {
-            rpc_resp($trait::$call_name(&mut $client.into_inner(), rpc_req($call)?).await)
+            // Disable retries for this call
+            *$client.retry_options_mut() = RetryOptions::no_retries();
+            rpc_resp($trait::$call_name(&mut $client, rpc_req($call)?).await)
         }
     };
 }
 
 async fn call_workflow_service(
-    client: &CoreClient,
+    client: &CoreConnection,
     call: &RpcCallOptions,
 ) -> anyhow::Result<Vec<u8>> {
     let rpc = call.rpc.to_str();
@@ -573,6 +572,7 @@ async fn call_workflow_service(
         "CountActivityExecutions" => {
             rpc_call_on_trait!(client, call, WorkflowService, count_activity_executions)
         }
+        "CountSchedules" => rpc_call_on_trait!(client, call, WorkflowService, count_schedules),
         "CountWorkflowExecutions" => {
             rpc_call_on_trait!(client, call, WorkflowService, count_workflow_executions)
         }
@@ -964,7 +964,7 @@ async fn call_workflow_service(
 }
 
 async fn call_operator_service(
-    client: &CoreClient,
+    client: &CoreConnection,
     call: &RpcCallOptions,
 ) -> anyhow::Result<Vec<u8>> {
     let rpc = call.rpc.to_str();
@@ -1004,7 +1004,10 @@ async fn call_operator_service(
     }
 }
 
-async fn call_cloud_service(client: &CoreClient, call: &RpcCallOptions) -> anyhow::Result<Vec<u8>> {
+async fn call_cloud_service(
+    client: &CoreConnection,
+    call: &RpcCallOptions,
+) -> anyhow::Result<Vec<u8>> {
     let rpc = call.rpc.to_str();
     let mut client = client.clone();
     match rpc {
@@ -1133,7 +1136,10 @@ async fn call_cloud_service(client: &CoreClient, call: &RpcCallOptions) -> anyho
     }
 }
 
-async fn call_test_service(client: &CoreClient, call: &RpcCallOptions) -> anyhow::Result<Vec<u8>> {
+async fn call_test_service(
+    client: &CoreConnection,
+    call: &RpcCallOptions,
+) -> anyhow::Result<Vec<u8>> {
     let rpc = call.rpc.to_str();
     let mut client = client.clone();
     match rpc {
@@ -1150,7 +1156,7 @@ async fn call_test_service(client: &CoreClient, call: &RpcCallOptions) -> anyhow
 }
 
 async fn call_health_service(
-    client: &CoreClient,
+    client: &CoreConnection,
     call: &RpcCallOptions,
 ) -> anyhow::Result<Vec<u8>> {
     let rpc = call.rpc.to_str();
@@ -1197,10 +1203,10 @@ where
     Ok(res?.get_ref().encode_to_vec())
 }
 
-impl TryFrom<&ClientOptions> for CoreClientOptions {
+impl TryFrom<&ConnectionOptions> for temporalio_client::ConnectionOptions {
     type Error = anyhow::Error;
 
-    fn try_from(opts: &ClientOptions) -> anyhow::Result<Self> {
+    fn try_from(opts: &ConnectionOptions) -> anyhow::Result<Self> {
         let tls_cfg = unsafe { opts.tls_options.as_ref() }
             .map(|c| c.try_into())
             .transpose()?;
@@ -1227,30 +1233,31 @@ impl TryFrom<&ClientOptions> for CoreClientOptions {
         let http_connect_proxy =
             unsafe { opts.http_connect_proxy_options.as_ref() }.map(Into::into);
 
-        Ok(CoreClientOptions::builder()
-            .target_url(Url::parse(opts.target_url.to_str())?)
-            .client_name(opts.client_name.to_string())
-            .client_version(opts.client_version.to_string())
-            .identity(opts.identity.to_string())
-            .retry_options(
-                unsafe { opts.retry_options.as_ref() }
-                    .map_or(RetryOptions::default(), |c| c.into()),
-            )
-            .maybe_keep_alive(keep_alive.map(Some))
-            .maybe_headers(headers)
-            .maybe_binary_headers(binary_headers)
-            .maybe_api_key(api_key)
-            .maybe_http_connect_proxy(http_connect_proxy)
-            .maybe_tls_options(tls_cfg)
-            .build())
+        Ok(
+            temporalio_client::ConnectionOptions::new(Url::parse(opts.target_url.to_str())?)
+                .client_name(opts.client_name.to_string())
+                .client_version(opts.client_version.to_string())
+                .identity(opts.identity.to_string())
+                .retry_options(
+                    unsafe { opts.retry_options.as_ref() }
+                        .map_or(RetryOptions::default(), |c| c.into()),
+                )
+                .keep_alive(keep_alive)
+                .maybe_headers(headers)
+                .maybe_binary_headers(binary_headers)
+                .maybe_api_key(api_key)
+                .maybe_http_connect_proxy(http_connect_proxy)
+                .maybe_tls_options(tls_cfg)
+                .build(),
+        )
     }
 }
 
-impl TryFrom<&ClientTlsOptions> for CoreTlsOptions {
+impl TryFrom<&ClientTlsOptions> for temporalio_client::TlsOptions {
     type Error = anyhow::Error;
 
     fn try_from(opts: &ClientTlsOptions) -> anyhow::Result<Self> {
-        Ok(CoreTlsOptions {
+        Ok(temporalio_client::TlsOptions {
             server_root_ca_cert: opts.server_root_ca_cert.to_option_vec(),
             domain: opts.domain.to_option_string(),
             client_tls_options: match (
@@ -1258,10 +1265,12 @@ impl TryFrom<&ClientTlsOptions> for CoreTlsOptions {
                 opts.client_private_key.to_option_vec(),
             ) {
                 (None, None) => None,
-                (Some(client_cert), Some(client_private_key)) => Some(CoreClientTlsOptions {
-                    client_cert,
-                    client_private_key,
-                }),
+                (Some(client_cert), Some(client_private_key)) => {
+                    Some(temporalio_client::ClientTlsOptions {
+                        client_cert,
+                        client_private_key,
+                    })
+                }
                 _ => {
                     return Err(anyhow::anyhow!(
                         "Must have both client cert and private key or neither"
@@ -1272,9 +1281,9 @@ impl TryFrom<&ClientTlsOptions> for CoreTlsOptions {
     }
 }
 
-impl From<&ClientRetryOptions> for RetryOptions {
+impl From<&ClientRetryOptions> for temporalio_client::RetryOptions {
     fn from(opts: &ClientRetryOptions) -> Self {
-        RetryOptions {
+        temporalio_client::RetryOptions {
             initial_interval: Duration::from_millis(opts.initial_interval_millis),
             randomization_factor: opts.randomization_factor,
             multiplier: opts.multiplier,
@@ -1289,18 +1298,18 @@ impl From<&ClientRetryOptions> for RetryOptions {
     }
 }
 
-impl From<&ClientKeepAliveOptions> for CoreClientKeepAliveOptions {
+impl From<&ClientKeepAliveOptions> for temporalio_client::ClientKeepAliveOptions {
     fn from(opts: &ClientKeepAliveOptions) -> Self {
-        CoreClientKeepAliveOptions {
+        temporalio_client::ClientKeepAliveOptions {
             interval: Duration::from_millis(opts.interval_millis),
             timeout: Duration::from_millis(opts.timeout_millis),
         }
     }
 }
 
-impl From<&ClientHttpConnectProxyOptions> for HttpConnectProxyOptions {
+impl From<&ClientHttpConnectProxyOptions> for temporalio_client::proxy::HttpConnectProxyOptions {
     fn from(opts: &ClientHttpConnectProxyOptions) -> Self {
-        HttpConnectProxyOptions {
+        temporalio_client::proxy::HttpConnectProxyOptions {
             target_addr: opts.target_host.to_string(),
             basic_auth: if opts.username.size != 0 && opts.password.size != 0 {
                 Some((opts.username.to_string(), opts.password.to_string()))

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())),
     }))
 }
 
@@ -483,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

@@ -18,11 +18,10 @@ use std::{
 use temporalio_common::telemetry::{
     CoreLog, CoreLogConsumer, HistogramBucketOverrides, Logger, MetricTemporality,
     OtelCollectorOptions, PrometheusExporterOptions, TelemetryOptions as CoreTelemetryOptions,
-    metrics::CoreMeter,
+    build_otlp_metric_exporter, metrics::CoreMeter, start_prometheus_metric_exporter,
 };
 use temporalio_sdk_core::{
     CoreRuntime, RuntimeOptions as CoreRuntimeOptions, TokioRuntimeBuilder as TokioRuntime,
-    telemetry::{build_otlp_metric_exporter, start_prometheus_metric_exporter},
 };
 use tracing::Level;
 use url::Url;

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

@@ -1,8 +1,8 @@
 use crate::{
     client::{
-        Client, ClientHttpConnectProxyOptions, ClientKeepAliveOptions, ClientRetryOptions,
-        ClientTlsOptions, GrpcMetadataHolder, 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,
@@ -29,7 +29,7 @@ use std::{
     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,13 +279,13 @@ 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<()> {
@@ -340,10 +340,10 @@ 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(),
+        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(),
@@ -582,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>) };

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

@@ -9,7 +9,7 @@ use crate::{
         temporal_core_client_grpc_override_request_service,
     },
     tests::utils::{
-        OwnedRpcCallOptions, RpcCallError, default_client_options, default_server_config,
+        OwnedRpcCallOptions, RpcCallError, default_connection_options, default_server_config,
     },
 };
 use base64::{Engine, engine::general_purpose::STANDARD_NO_PAD};
@@ -38,7 +38,7 @@ fn test_get_system_info() {
             .start_dev_server(Box::new(default_server_config()))
             .unwrap();
         context
-            .client_connect(Box::new(default_client_options(
+            .client_connect(Box::new(default_connection_options(
                 &context.ephemeral_server_target().unwrap().unwrap(),
             )))
             .unwrap();
@@ -88,7 +88,7 @@ fn test_missing_rpc_call_has_expected_error_message() {
             .start_dev_server(Box::new(default_server_config()))
             .unwrap();
         context
-            .client_connect(Box::new(default_client_options(
+            .client_connect(Box::new(default_connection_options(
                 &context.ephemeral_server_target().unwrap().unwrap(),
             )))
             .unwrap();
@@ -152,7 +152,7 @@ fn test_all_rpc_calls_exist() {
             .start_dev_server(Box::new(default_server_config()))
             .unwrap();
         context
-            .client_connect(Box::new(default_client_options(
+            .client_connect(Box::new(default_connection_options(
                 &context.ephemeral_server_target().unwrap().unwrap(),
             )))
             .unwrap();
@@ -299,7 +299,7 @@ fn test_simple_callback_override() {
         // Create client which will invoke GetSystemInfo
         context
             .client_connect_with_override(
-                Box::new(default_client_options("127.0.0.1:4567")),
+                Box::new(default_connection_options("127.0.0.1:4567")),
                 Some(callback_override),
                 &mut user_data as *mut String as *mut libc::c_void,
             )
@@ -392,7 +392,7 @@ fn test_callback_override_with_headers() {
         context.runtime_new().unwrap();
 
         // Prepare client options with headers
-        let mut client_options = default_client_options("127.0.0.1:4567");
+        let mut client_options = default_connection_options("127.0.0.1:4567");
         client_options.headers = Some(HashMap::from([(
             "x-test".to_owned(),
             "client-ascii".to_owned(),

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

@@ -4,7 +4,7 @@ use crate::{
     runtime::{Runtime, temporal_core_byte_array_free},
 };
 use std::ops::Deref;
-use temporalio_client::ClientOptions;
+use temporalio_client::ConnectionOptions;
 use temporalio_sdk_core::ephemeral_server::{TemporalDevServerConfig, default_cached_download};
 use url::Url;
 
@@ -34,9 +34,8 @@ pub fn default_server_config() -> TemporalDevServerConfig {
         .build()
 }
 
-pub fn default_client_options(target: &str) -> ClientOptions {
-    ClientOptions::builder()
-        .target_url(Url::parse(&format!("http://{target}")).unwrap())
+pub fn default_connection_options(target: &str) -> ConnectionOptions {
+    ConnectionOptions::new(Url::parse(&format!("http://{target}")).unwrap())
         .client_name("core-c-bridge-tests".to_owned())
         .client_version("0.1.0".to_owned())
         .build()