@temporalio/core-bridge 0.22.0 → 0.23.0

package/src/conversions.rs

@@ -6,11 +6,12 @@ use neon::{
     types::{JsNumber, JsString},
 };
 use opentelemetry::trace::{SpanContext, SpanId, TraceFlags, TraceId, TraceState};
-use std::{fmt::Display, net::SocketAddr, str::FromStr, time::Duration};
+use std::{collections::HashMap, fmt::Display, net::SocketAddr, str::FromStr, time::Duration};
 use temporal_sdk_core::{
     api::worker::{WorkerConfig, WorkerConfigBuilder},
-    ClientOptions, ClientOptionsBuilder, ClientTlsConfig, RetryConfig, TelemetryOptions,
-    TelemetryOptionsBuilder, TlsConfig, Url,
+    ClientOptions, ClientOptionsBuilder, ClientTlsConfig, Logger, MetricsExporter,
+    OtelCollectorOptions, RetryConfig, TelemetryOptions, TelemetryOptionsBuilder, TlsConfig,
+    TraceExporter, Url,
 };
 
 macro_rules! js_value_getter {
@@ -27,6 +28,7 @@ macro_rules! js_value_getter {
     };
 }
 
+#[macro_export]
 macro_rules! js_optional_getter {
     ($js_cx:expr, $js_obj:expr, $prop_name:expr, $js_type:ty) => {
         match get_optional($js_cx, $js_obj, $prop_name) {
@@ -42,7 +44,7 @@ macro_rules! js_optional_getter {
 
 /// Helper for extracting an optional attribute from [obj].
 /// If [obj].[attr] is undefined or not present, None is returned
-fn get_optional<'a, C, K>(
+pub fn get_optional<'a, C, K>(
     cx: &mut C,
     obj: &Handle<JsObject>,
     attr: K,
@@ -108,6 +110,10 @@ pub(crate) trait ObjectHandleConversionsExt {
     fn as_client_options(&self, ctx: &mut FunctionContext) -> NeonResult<ClientOptions>;
     fn as_telemetry_options(&self, cx: &mut FunctionContext) -> NeonResult<TelemetryOptions>;
     fn as_worker_config(&self, cx: &mut FunctionContext) -> NeonResult<WorkerConfig>;
+    fn as_hash_map_of_string_to_string(
+        &self,
+        cx: &mut FunctionContext,
+    ) -> NeonResult<HashMap<String, String>>;
 }
 
 impl ObjectHandleConversionsExt for Handle<'_, JsObject> {
@@ -124,6 +130,22 @@ impl ObjectHandleConversionsExt for Handle<'_, JsObject> {
         ))
     }
 
+    fn as_hash_map_of_string_to_string(
+        &self,
+        cx: &mut FunctionContext,
+    ) -> NeonResult<HashMap<String, String>> {
+        let props = self.get_own_property_names(cx)?;
+        let props = props.to_vec(cx)?;
+        let mut map = HashMap::new();
+        for k in props {
+            let k = k.to_string(cx)?;
+            let v = self.get(cx, k)?.to_string(cx)?.value(cx);
+            let k = k.value(cx);
+            map.insert(k, v);
+        }
+        Ok(map)
+    }
+
     fn as_client_options(&self, cx: &mut FunctionContext) -> NeonResult<ClientOptions> {
         let url = match Url::parse(&js_value_getter!(cx, self, "url", JsString)) {
             Ok(url) => url,
@@ -198,11 +220,12 @@ impl ObjectHandleConversionsExt for Handle<'_, JsObject> {
             },
         };
 
-        let mut gateway_opts = ClientOptionsBuilder::default();
+        let mut client_options = ClientOptionsBuilder::default();
         if let Some(tls_cfg) = tls_cfg {
-            gateway_opts.tls_cfg(tls_cfg);
+            client_options.tls_cfg(tls_cfg);
         }
-        Ok(gateway_opts
+
+        Ok(client_options
             .client_name("temporal-typescript".to_string())
             .client_version(js_value_getter!(cx, self, "sdkVersion", JsString))
             .target_url(url)
@@ -214,37 +237,85 @@ impl ObjectHandleConversionsExt for Handle<'_, JsObject> {
     }
 
     fn as_telemetry_options(&self, cx: &mut FunctionContext) -> NeonResult<TelemetryOptions> {
-        let log_forwarding_level_str =
-            js_value_getter!(cx, self, "logForwardingLevel", JsString).replace("WARNING", "WARN");
-        let log_forwarding_level =
-            LevelFilter::from_str(&log_forwarding_level_str).unwrap_or(LevelFilter::Off);
         let mut telemetry_opts = TelemetryOptionsBuilder::default();
-        if let Some(url) = js_optional_getter!(cx, self, "oTelCollectorUrl", JsString) {
-            let url = match Url::parse(&url.value(cx)) {
-                Ok(url) => url,
-                Err(_) => cx.throw_type_error("Invalid telemetryOptions.oTelCollectorUrl")?,
-            };
-            telemetry_opts.otel_collector_url(url);
+
+        if let Some(tf) = js_optional_getter!(cx, self, "tracingFilter", JsString) {
+            telemetry_opts.tracing_filter(tf.value(cx));
         }
-        if let Some(addr) = js_optional_getter!(cx, self, "prometheusMetricsBindAddress", JsString)
-        {
-            match addr.value(cx).parse::<SocketAddr>() {
-                Ok(address) => telemetry_opts.prometheus_export_bind_address(address),
-                Err(_) => {
-                    cx.throw_type_error("Invalid telemetryOptions.prometheusMetricsBindAddress")?
+        if let Some(ref logging) = js_optional_getter!(cx, self, "logging", JsObject) {
+            if let Some(_) = get_optional(cx, logging, "console") {
+                telemetry_opts.logging(Logger::Console);
+            } else if let Some(forward) = js_optional_getter!(cx, logging, "forward", JsObject) {
+                let level = js_value_getter!(cx, forward, "level", JsString);
+                match LevelFilter::from_str(&level) {
+                    Ok(level) => {
+                        telemetry_opts.logging(Logger::Forward(level));
+                    }
+                    Err(err) => cx.throw_type_error(format!(
+                        "Invalid telemetryOptions.logging.forward.level: {}",
+                        err
+                    ))?,
                 }
-            };
+            } else {
+                cx.throw_type_error(format!(
+                    "Invalid telemetryOptions.logging, missing `console` or `forward` option"
+                ))?
+            }
         }
-        if let Some(tf) = js_optional_getter!(cx, self, "tracingFilter", JsString) {
-            telemetry_opts.tracing_filter(tf.value(cx));
+        if let Some(metrics) = js_optional_getter!(cx, self, "metrics", JsObject) {
+            if let Some(ref prom) = js_optional_getter!(cx, &metrics, "prometheus", JsObject) {
+                let addr = js_value_getter!(cx, prom, "bindAddress", JsString);
+                match addr.parse::<SocketAddr>() {
+                    Ok(address) => telemetry_opts.metrics(MetricsExporter::Prometheus(address)),
+                    Err(_) => cx.throw_type_error(
+                        "Invalid telemetryOptions.metrics.prometheus.bindAddress",
+                    )?,
+                };
+            } else if let Some(ref otel) = js_optional_getter!(cx, &metrics, "otel", JsObject) {
+                let url = js_value_getter!(cx, otel, "url", JsString);
+                let url = match Url::parse(&url) {
+                    Ok(url) => url,
+                    Err(_) => cx.throw_type_error("Invalid telemetryOptions.metrics.otel.url")?,
+                };
+                let headers =
+                    if let Some(headers) = js_optional_getter!(cx, otel, "headers", JsObject) {
+                        headers.as_hash_map_of_string_to_string(cx)?
+                    } else {
+                        Default::default()
+                    };
+                telemetry_opts
+                    .metrics(MetricsExporter::Otel(OtelCollectorOptions { url, headers }));
+            } else {
+                cx.throw_type_error(format!(
+                    "Invalid telemetryOptions.metrics, missing `prometheus` or `otel` option"
+                ))?
+            }
         }
-        telemetry_opts
-            .log_forwarding_level(log_forwarding_level)
-            .build()
-            .map_err(|reason| {
-                cx.throw_type_error::<_, TelemetryOptions>(format!("{}", reason))
-                    .unwrap_err()
-            })
+
+        if let Some(tracing) = js_optional_getter!(cx, self, "tracing", JsObject) {
+            if let Some(ref otel) = js_optional_getter!(cx, &tracing, "otel", JsObject) {
+                let url = js_value_getter!(cx, otel, "url", JsString);
+                let url = match Url::parse(&url) {
+                    Ok(url) => url,
+                    Err(_) => cx.throw_type_error("Invalid telemetryOptions.tracing.otel.url")?,
+                };
+                let headers =
+                    if let Some(headers) = js_optional_getter!(cx, otel, "headers", JsObject) {
+                        headers.as_hash_map_of_string_to_string(cx)?
+                    } else {
+                        Default::default()
+                    };
+                telemetry_opts.tracing(TraceExporter::Otel(OtelCollectorOptions { url, headers }));
+            } else {
+                cx.throw_type_error(format!(
+                    "Invalid telemetryOptions.tracing, missing `otel` option"
+                ))?
+            }
+        }
+        telemetry_opts.build().map_err(|reason| {
+            cx.throw_type_error::<_, TelemetryOptions>(format!("{}", reason))
+                .unwrap_err()
+        })
     }
 
     fn as_worker_config(&self, cx: &mut FunctionContext) -> NeonResult<WorkerConfig> {

package/src/lib.rs

@@ -1,12 +1,14 @@
 mod conversions;
 mod errors;
 
-use crate::conversions::ObjectHandleConversionsExt;
+use crate::conversions::{get_optional, ObjectHandleConversionsExt};
 use errors::*;
 use neon::prelude::*;
 use once_cell::sync::OnceCell;
 use opentelemetry::trace::{FutureExt, SpanContext, TraceContextExt};
+use parking_lot::RwLock;
 use prost::Message;
+use std::collections::HashMap;
 use std::{
     cell::RefCell,
     fmt::Display,
@@ -50,6 +52,14 @@ enum Request {
     CreateClient {
         runtime: Arc<RuntimeHandle>,
         options: ClientOptions,
+        headers: Option<HashMap<String, String>>,
+        /// Used to send the result back into JS
+        callback: Root<JsFunction>,
+    },
+    /// A request to update a client's HTTP request headers
+    UpdateClientHeaders {
+        client: Arc<RawClient>,
+        headers: HashMap<String, String>,
         /// Used to send the result back into JS
         callback: Root<JsFunction>,
     },
@@ -271,13 +281,17 @@ fn start_bridge_loop(event_queue: Arc<EventQueue>, receiver: &mut UnboundedRecei
                 Request::CreateClient {
                     runtime,
                     options,
+                    headers,
                     callback,
                 } => {
                     // `metrics_meter` (second arg) can be None here since we don't use the
                     // returned client directly at the moment, when we repurpose the client to be
                     // used by a Worker, `init_worker` will attach the correct metrics meter for
                     // us.
-                    match options.connect_no_namespace(None).await {
+                    match options
+                        .connect_no_namespace(None, headers.map(|h| Arc::new(RwLock::new(h))))
+                        .await
+                    {
                         Err(err) => {
                             send_error(event_queue.clone(), callback, |cx| match err {
                                 ClientInitError::SystemInfoCallError(e) => TRANSPORT_ERROR
@@ -300,6 +314,14 @@ fn start_bridge_loop(event_queue: Arc<EventQueue>, receiver: &mut UnboundedRecei
                         }
                     }
                 }
+                Request::UpdateClientHeaders {
+                    client,
+                    headers,
+                    callback,
+                } => {
+                    client.get_client().set_headers(headers);
+                    send_result(event_queue.clone(), callback, |cx| Ok(cx.undefined()));
+                }
                 Request::PollLogs { callback } => {
                     let logs = fetch_global_buffered_logs();
                     send_result(event_queue.clone(), callback, |cx| {
@@ -568,12 +590,28 @@ fn runtime_new(mut cx: FunctionContext) -> JsResult<BoxedRuntime> {
 /// Client will be returned in the supplied `callback`.
 fn client_new(mut cx: FunctionContext) -> JsResult<JsUndefined> {
     let runtime = cx.argument::<BoxedRuntime>(0)?;
-    let client_options = cx.argument::<JsObject>(1)?.as_client_options(&mut cx)?;
+    let opts = cx.argument::<JsObject>(1)?;
     let callback = cx.argument::<JsFunction>(2)?;
 
+    let client_options = opts.as_client_options(&mut cx)?;
+    let headers = match js_optional_getter!(&mut cx, &opts, "headers", JsObject) {
+        None => None,
+        Some(h) => Some(
+            h.as_hash_map_of_string_to_string(&mut cx)
+                .map_err(|reason| {
+                    cx.throw_type_error::<_, HashMap<String, String>>(format!(
+                        "Invalid headers: {}",
+                        reason
+                    ))
+                    .unwrap_err()
+                })?,
+        ),
+    };
+
     let request = Request::CreateClient {
         runtime: (**runtime).clone(),
         options: client_options,
+        headers,
         callback: callback.root(&mut cx),
     };
     if let Err(err) = runtime.sender.send(request) {
@@ -583,6 +621,33 @@ fn client_new(mut cx: FunctionContext) -> JsResult<JsUndefined> {
     Ok(cx.undefined())
 }
 
+/// Update a Client's HTTP request headers
+fn client_update_headers(mut cx: FunctionContext) -> JsResult<JsUndefined> {
+    let client = cx.argument::<BoxedClient>(0)?;
+    let headers = cx
+        .argument::<JsObject>(1)?
+        .as_hash_map_of_string_to_string(&mut cx)?;
+    let callback = cx.argument::<JsFunction>(2)?;
+
+    match &*client.borrow() {
+        None => {
+            callback_with_unexpected_error(&mut cx, callback, "Tried to use closed Client")?;
+        }
+        Some(client) => {
+            let request = Request::UpdateClientHeaders {
+                client: client.core_client.clone(),
+                headers,
+                callback: callback.root(&mut cx),
+            };
+            if let Err(err) = client.runtime.sender.send(request) {
+                callback_with_unexpected_error(&mut cx, callback, err)?;
+            };
+        }
+    }
+
+    Ok(cx.undefined())
+}
+
 /// Create a new worker asynchronously.
 /// Worker uses the provided connection and returned to JS using supplied `callback`.
 fn worker_new(mut cx: FunctionContext) -> JsResult<JsUndefined> {
@@ -593,9 +658,7 @@ fn worker_new(mut cx: FunctionContext) -> JsResult<JsUndefined> {
     let config = worker_options.as_worker_config(&mut cx)?;
     match &*client.borrow() {
         None => {
-            callback_with_error(&mut cx, callback, move |cx| {
-                UNEXPECTED_ERROR.from_string(cx, "Tried to use closed Client".to_string())
-            })?;
+            callback_with_unexpected_error(&mut cx, callback, "Tried to use closed Client")?;
         }
         Some(client) => {
             let request = Request::InitWorker {
@@ -843,6 +906,7 @@ fn main(mut cx: ModuleContext) -> NeonResult<()> {
     cx.export_function("initTelemetry", init_telemetry)?;
     cx.export_function("newRuntime", runtime_new)?;
     cx.export_function("newClient", client_new)?;
+    cx.export_function("clientUpdateHeaders", client_update_headers)?;
     cx.export_function("newWorker", worker_new)?;
     cx.export_function("newReplayWorker", replay_worker_new)?;
     cx.export_function("workerShutdown", worker_shutdown)?;