@temporalio/core-bridge 1.9.0 → 1.9.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@temporalio/core-bridge",
-  "version": "1.9.0",
+  "version": "1.9.1",
   "description": "Temporal.io SDK Core<>Node bridge",
   "main": "index.js",
   "types": "lib/index.d.ts",
@@ -22,7 +22,7 @@
   "author": "Temporal Technologies Inc. <sdk@temporal.io>",
   "license": "MIT",
   "dependencies": {
-    "@temporalio/common": "1.9.0",
+    "@temporalio/common": "1.9.1",
     "arg": "^5.0.2",
     "cargo-cp-artifact": "^0.1.8",
     "which": "^4.0.0"
@@ -52,5 +52,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "5096976287616207edcd3e4281a2a5e1f7393e33"
+  "gitHead": "05f22004a0d877d8a128768016d5719adbc67de8"
 }

package/src/conversions.rs

@@ -44,10 +44,9 @@ impl ArrayHandleConversionsExt for Handle<'_, JsArray> {
     }
 }
 
-pub(crate) type TelemOptsRes = (
-    TelemetryOptions,
-    Option<Box<dyn FnOnce() -> Arc<dyn CoreMeter> + Send>>,
-);
+type BoxedMeterMaker = Box<dyn FnOnce() -> Result<Arc<dyn CoreMeter>, String> + Send + Sync>;
+
+pub(crate) type TelemOptsRes = (TelemetryOptions, Option<BoxedMeterMaker>);
 
 pub trait ObjectHandleConversionsExt {
     fn set_default(&self, cx: &mut FunctionContext, key: &str, value: &str) -> NeonResult<()>;
@@ -220,20 +219,24 @@ impl ObjectHandleConversionsExt for Handle<'_, JsObject> {
                     .unwrap_err()
                 })?;
 
-                meter_maker = Some(Box::new(move || {
-                    let prom_info = start_prometheus_metric_exporter(options)
-                        .expect("Failed creating prometheus exporter");
-                    prom_info.meter as Arc<dyn CoreMeter>
-                })
-                    as Box<dyn FnOnce() -> Arc<dyn CoreMeter> + Send>);
+                meter_maker =
+                    Some(
+                        Box::new(move || match start_prometheus_metric_exporter(options) {
+                            Ok(prom_info) => Ok(prom_info.meter as Arc<dyn CoreMeter>),
+                            Err(e) => Err(format!("Failed to start prometheus exporter: {}", e)),
+                        }) as BoxedMeterMaker,
+                    );
             } else if let Some(ref otel) = js_optional_getter!(cx, metrics, "otel", JsObject) {
                 let mut options = OtelCollectorOptionsBuilder::default();
 
                 let url = js_value_getter!(cx, otel, "url", JsString);
                 match Url::parse(&url) {
                     Ok(url) => options.url(url),
-                    Err(_) => {
-                        return cx.throw_type_error("Invalid telemetryOptions.metrics.otel.url");
+                    Err(e) => {
+                        return cx.throw_type_error(format!(
+                            "Invalid telemetryOptions.metrics.otel.url: {}",
+                            e
+                        ))?;
                     }
                 };
 
@@ -269,11 +272,10 @@ impl ObjectHandleConversionsExt for Handle<'_, JsObject> {
                     .unwrap_err()
                 })?;
 
-                meter_maker = Some(Box::new(move || {
-                    let otlp_exporter =
-                        build_otlp_metric_exporter(options).expect("Failed to build otlp exporter");
-                    Arc::new(otlp_exporter) as Arc<dyn CoreMeter>
-                }));
+                meter_maker = Some(Box::new(move || match build_otlp_metric_exporter(options) {
+                    Ok(otlp_exporter) => Ok(Arc::new(otlp_exporter) as Arc<dyn CoreMeter>),
+                    Err(e) => Err(format!("Failed to start otlp exporter: {}", e)),
+                }) as BoxedMeterMaker);
             } else {
                 cx.throw_type_error(
                     "Invalid telemetryOptions.metrics, missing `prometheus` or `otel` option",

package/src/runtime.rs

@@ -19,6 +19,7 @@ use temporal_sdk_core::{
     replay::{HistoryForReplay, ReplayWorkerInput},
     ClientOptions, RetryClient, WorkerConfig,
 };
+use tokio::sync::oneshot;
 use tokio::sync::{
     mpsc::{channel, unbounded_channel, Sender, UnboundedReceiver, UnboundedSender},
     Mutex,
@@ -119,6 +120,7 @@ pub fn start_bridge_loop(
     telemetry_options: TelemOptsRes,
     channel: Arc<Channel>,
     receiver: &mut UnboundedReceiver<RuntimeRequest>,
+    result_sender: oneshot::Sender<Result<(), String>>,
 ) {
     let mut tokio_builder = tokio::runtime::Builder::new_multi_thread();
     tokio_builder.enable_all().thread_name("core");
@@ -129,10 +131,24 @@ pub fn start_bridge_loop(
 
     core_runtime.tokio_handle().block_on(async {
         if let Some(meter_maker) = meter_maker {
-            core_runtime
-                .telemetry_mut()
-                .attach_late_init_metrics(meter_maker());
+            match meter_maker() {
+                Ok(meter) => {
+                    core_runtime.telemetry_mut().attach_late_init_metrics(meter);
+                }
+                Err(err) => {
+                    result_sender
+                        .send(Err(format!("Failed to create meter: {}", err)))
+                        .unwrap_or_else(|_| {
+                            panic!("Failed to report runtime start error: {}", err)
+                        });
+                    return;
+                }
+            }
         }
+        result_sender
+            .send(Ok(()))
+            .expect("Failed to report runtime start success");
+
         loop {
             let request_option = receiver.recv().await;
             let request = match request_option {
@@ -386,7 +402,19 @@ pub fn runtime_new(mut cx: FunctionContext) -> JsResult<BoxedRuntime> {
     let channel = Arc::new(cx.channel());
     let (sender, mut receiver) = unbounded_channel::<RuntimeRequest>();
 
-    std::thread::spawn(move || start_bridge_loop(telemetry_options, channel, &mut receiver));
+    // FIXME: This is a temporary fix to get sync notifications of errors while initializing the runtime.
+    //        The proper fix would be to avoid spawning a new thread here, so that start_bridge_loop
+    //        can simply yeild back a Result. But early attempts to do just that caused panics
+    //        on runtime shutdown, so let's use this hack until we can dig deeper.
+    let (result_sender, result_receiver) = oneshot::channel::<Result<(), String>>();
+
+    std::thread::spawn(move || {
+        start_bridge_loop(telemetry_options, channel, &mut receiver, result_sender)
+    });
+
+    if let Ok(Err(e)) = result_receiver.blocking_recv() {
+        Err(cx.throw_error::<_, String>(e).unwrap_err())?;
+    }
 
     Ok(cx.boxed(Arc::new(RuntimeHandle { sender })))
 }