@temporalio/core-bridge 1.9.0 → 1.9.2

package/sdk-core/sdk/src/lib.rs

@@ -25,6 +25,7 @@
 //!     let worker_config = WorkerConfigBuilder::default()
 //!         .namespace("default")
 //!         .task_queue("task_queue")
+//!         .worker_build_id("rust-sdk")
 //!         .build()?;
 //!
 //!     let core_worker = init_worker(&runtime, worker_config, client)?;
@@ -710,7 +711,7 @@ impl<F, Fut, O> From<F> for WorkflowFunction
 where
     F: Fn(WfContext) -> Fut + Send + Sync + 'static,
     Fut: Future<Output = Result<WfExitValue<O>, anyhow::Error>> + Send + 'static,
-    O: Serialize + Debug,
+    O: Serialize,
 {
     fn from(wf_func: F) -> Self {
         Self::new(wf_func)
@@ -723,7 +724,7 @@ impl WorkflowFunction {
     where
         F: Fn(WfContext) -> Fut + Send + Sync + 'static,
         Fut: Future<Output = Result<WfExitValue<O>, anyhow::Error>> + Send + 'static,
-        O: Serialize + Debug,
+        O: Serialize,
     {
         Self {
             wf_func: Box::new(move |ctx: WfContext| {
@@ -749,7 +750,7 @@ pub type WorkflowResult<T> = Result<WfExitValue<T>, anyhow::Error>;
 
 /// Workflow functions may return these values when exiting
 #[derive(Debug, derive_more::From)]
-pub enum WfExitValue<T: Debug> {
+pub enum WfExitValue<T> {
     /// Continue the workflow as a new execution
     #[from(ignore)]
     ContinueAsNew(Box<ContinueAsNewWorkflowExecution>),
@@ -763,7 +764,7 @@ pub enum WfExitValue<T: Debug> {
     Normal(T),
 }
 
-impl<T: Debug> WfExitValue<T> {
+impl<T> WfExitValue<T> {
     /// Construct a [WfExitValue::ContinueAsNew] variant (handles boxing)
     pub fn continue_as_new(can: ContinueAsNewWorkflowExecution) -> Self {
         Self::ContinueAsNew(Box::new(can))
@@ -771,15 +772,19 @@ impl<T: Debug> WfExitValue<T> {
 }
 
 /// Activity functions may return these values when exiting
-#[derive(derive_more::From)]
-pub enum ActExitValue<T: Debug> {
+pub enum ActExitValue<T> {
     /// Completion requires an asynchronous callback
-    #[from(ignore)]
     WillCompleteAsync,
     /// Finish with a result
     Normal(T),
 }
 
+impl<T: AsJsonPayloadExt> From<T> for ActExitValue<T> {
+    fn from(t: T) -> Self {
+        Self::Normal(t)
+    }
+}
+
 type BoxActFn = Arc<
     dyn Fn(ActContext, Payload) -> BoxFuture<'static, Result<ActExitValue<Payload>, anyhow::Error>>
         + Send
@@ -834,7 +839,7 @@ where
     A: FromJsonPayloadExt + Send,
     Rf: Future<Output = Result<R, anyhow::Error>> + Send + 'static,
     R: Into<ActExitValue<O>>,
-    O: AsJsonPayloadExt + Debug,
+    O: AsJsonPayloadExt,
 {
     fn into_activity_fn(self) -> BoxActFn {
         let wrapper = move |ctx: ActContext, input: Payload| {

package/sdk-core/sdk/src/workflow_context.rs

@@ -11,7 +11,7 @@ use crate::{
     IntoUpdateValidatorFunc, RustWfCmd, SignalExternalWfResult, TimerResult, UnblockEvent,
     Unblockable, UpdateFunctions,
 };
-use crossbeam::channel::{Receiver, Sender};
+use crossbeam_channel::{Receiver, Sender};
 use futures::{task::Context, FutureExt, Stream, StreamExt};
 use parking_lot::RwLock;
 use std::{
@@ -117,7 +117,7 @@ impl WfContext {
         am_cancelled: watch::Receiver<bool>,
     ) -> (Self, Receiver<RustWfCmd>) {
         // We need to use a normal std channel since our receiving side is non-async
-        let (chan, rx) = crossbeam::channel::unbounded();
+        let (chan, rx) = crossbeam_channel::unbounded();
         (
             Self {
                 namespace,

package/sdk-core/sdk/src/workflow_future.rs

@@ -4,7 +4,7 @@ use crate::{
     WorkflowResult,
 };
 use anyhow::{anyhow, bail, Context as AnyhowContext, Error};
-use crossbeam::channel::Receiver;
+use crossbeam_channel::Receiver;
 use futures::{future::BoxFuture, FutureExt};
 use std::{
     collections::{hash_map::Entry, HashMap},

package/sdk-core/sdk-core-protos/Cargo.toml

@@ -17,7 +17,7 @@ serde_serialize = []
 [dependencies]
 anyhow = "1.0"
 base64 = "0.21"
-derive_more = "0.99"
+derive_more = { workspace = true }
 prost = "0.11"
 prost-wkt = "0.4"
 prost-wkt-types = "0.4"

package/sdk-core/sdk-core-protos/protos/api_upstream/temporal/api/enums/v1/event_type.proto

@@ -167,4 +167,8 @@ enum EventType {
     EVENT_TYPE_ACTIVITY_PROPERTIES_MODIFIED_EXTERNALLY = 45;
     // Workflow properties modified by user workflow code
     EVENT_TYPE_WORKFLOW_PROPERTIES_MODIFIED = 46;
+    // An update was requested. Note that not all update requests result in this
+    // event. See UpdateRequestedEventOrigin for situations in which this event
+    // is created.
+    EVENT_TYPE_WORKFLOW_EXECUTION_UPDATE_REQUESTED = 47;
 }

package/sdk-core/sdk-core-protos/protos/api_upstream/temporal/api/enums/v1/reset.proto

@@ -31,13 +31,26 @@ option java_outer_classname = "ResetProto";
 option ruby_package = "Temporalio::Api::Enums::V1";
 option csharp_namespace = "Temporalio.Api.Enums.V1";
 
-// Reset reapply (replay) options
-// * RESET_REAPPLY_TYPE_SIGNAL (default) - Signals are reapplied when workflow is reset
-// * RESET_REAPPLY_TYPE_NONE - nothing is reapplied
+// Event types to exclude when reapplying events.
+enum ResetReapplyExcludeType {
+    RESET_REAPPLY_EXCLUDE_TYPE_UNSPECIFIED = 0;
+    // Exclude signals when reapplying events.
+    RESET_REAPPLY_EXCLUDE_TYPE_SIGNAL = 1;
+    // Exclude updates when reapplying events.
+    RESET_REAPPLY_EXCLUDE_TYPE_UPDATE = 2;
+}
+
+// Event types to include when reapplying events. Deprecated: applications
+// should use ResetReapplyExcludeType to specify exclusions from this set, and
+// new event types should be added to ResetReapplyExcludeType instead of here.
 enum ResetReapplyType {
     RESET_REAPPLY_TYPE_UNSPECIFIED = 0;
+    // Signals are reapplied when workflow is reset.
     RESET_REAPPLY_TYPE_SIGNAL = 1;
+    // No events are reapplied when workflow is reset.
     RESET_REAPPLY_TYPE_NONE = 2;
+    // All eligible events are reapplied when workflow is reset.
+    RESET_REAPPLY_TYPE_ALL_ELIGIBLE = 3;
 }
 
 // Reset type options. Deprecated, see temporal.api.common.v1.ResetOptions.

package/sdk-core/sdk-core-protos/protos/api_upstream/temporal/api/enums/v1/update.proto

@@ -54,3 +54,14 @@ enum UpdateWorkflowExecutionLifecycleStage {
     // on a worker and has either been rejected or returned a value or an error.
     UPDATE_WORKFLOW_EXECUTION_LIFECYCLE_STAGE_COMPLETED = 3;
 }
+
+// UpdateRequestedEventOrigin records why an
+// WorkflowExecutionUpdateRequestedEvent was written to history. Note that not
+// all update requests result in a WorkflowExecutionUpdateRequestedEvent.
+enum UpdateRequestedEventOrigin {
+    UPDATE_REQUESTED_EVENT_ORIGIN_UNSPECIFIED = 0;
+    // The UpdateRequested event was created when reapplying events during reset
+    // or replication. I.e. an accepted update on one branch of workflow history
+    // was converted into a requested update on a different branch.
+    UPDATE_REQUESTED_EVENT_ORIGIN_REAPPLY = 1;
+}

package/sdk-core/sdk-core-protos/protos/api_upstream/temporal/api/history/v1/message.proto

@@ -36,6 +36,7 @@ import "google/protobuf/timestamp.proto";
 
 import "temporal/api/enums/v1/event_type.proto";
 import "temporal/api/enums/v1/failed_cause.proto";
+import "temporal/api/enums/v1/update.proto";
 import "temporal/api/enums/v1/workflow.proto";
 import "temporal/api/common/v1/message.proto";
 import "temporal/api/failure/v1/message.proto";
@@ -434,6 +435,8 @@ message WorkflowExecutionSignaledEventAttributes {
     temporal.api.common.v1.Header header = 4;
     // Indicates the signal did not generate a new workflow task when received.
     bool skip_generate_workflow_task = 5;
+    // When signal origin is a workflow execution, this field is set.
+    temporal.api.common.v1.WorkflowExecution external_workflow_execution = 6;
 }
 
 message WorkflowExecutionTerminatedEventAttributes {
@@ -747,6 +750,12 @@ message WorkflowExecutionUpdateRejectedEventAttributes {
     temporal.api.failure.v1.Failure failure = 5;
 }
 
+message WorkflowExecutionUpdateRequestedEventAttributes {
+    // The update request associated with this event.
+    temporal.api.update.v1.Request request = 1;
+    // A record of why this event was written to history.
+    temporal.api.enums.v1.UpdateRequestedEventOrigin origin = 2;
+}
 
 // History events are the method by which Temporal SDKs advance (or recreate) workflow state.
 // See the `EventType` enum for more info about what each event is for.
@@ -812,6 +821,7 @@ message HistoryEvent {
         WorkflowPropertiesModifiedExternallyEventAttributes workflow_properties_modified_externally_event_attributes = 49;
         ActivityPropertiesModifiedExternallyEventAttributes activity_properties_modified_externally_event_attributes = 50;
         WorkflowPropertiesModifiedEventAttributes workflow_properties_modified_event_attributes = 51;
+        WorkflowExecutionUpdateRequestedEventAttributes workflow_execution_update_requested_event_attributes = 52;
     }
 }
 

package/sdk-core/sdk-core-protos/protos/api_upstream/temporal/api/workflowservice/v1/request_response.proto

@@ -669,8 +669,11 @@ message ResetWorkflowExecutionRequest {
     int64 workflow_task_finish_event_id = 4;
     // Used to de-dupe reset requests
     string request_id = 5;
-    // Reset reapply (replay) options.
+    // Event types to be reapplied (deprecated)
+    // Default: RESET_REAPPLY_TYPE_ALL_ELIGIBLE
     temporal.api.enums.v1.ResetReapplyType reset_reapply_type = 6;
+    // Event types not to be reapplied
+    repeated temporal.api.enums.v1.ResetReapplyExcludeType reset_reapply_exclude_types = 7;
 }
 
 message ResetWorkflowExecutionResponse {

package/sdk-core/sdk-core-protos/protos/testsrv_upstream/Makefile

@@ -23,33 +23,26 @@ PROTO_ROOT := .
 PROTO_FILES = $(shell find $(PROTO_ROOT) -name "*.proto")
 PROTO_DIRS = $(sort $(dir $(PROTO_FILES)))
 PROTO_OUT := .gen
-PROTO_IMPORTS := -I=$(PROTO_ROOT) -I=$(GOPATH)/src/github.com/temporalio/gogo-protobuf/protobuf
+PROTO_IMPORTS := -I=$(PROTO_ROOT)
 
 $(PROTO_OUT):
 	mkdir $(PROTO_OUT)
 
 ##### Compile proto files for go #####
-grpc: buf-lint api-linter buf-breaking gogo-grpc fix-path
+grpc: buf-lint api-linter buf-breaking fix-path
 
 go-grpc: clean $(PROTO_OUT)
 	printf $(COLOR) "Compile for go-gRPC..."
 	$(foreach PROTO_DIR,$(PROTO_DIRS),protoc $(PROTO_IMPORTS) --go_out=plugins=grpc,paths=source_relative:$(PROTO_OUT) $(PROTO_DIR)*.proto;)
 
-gogo-grpc: clean $(PROTO_OUT)
-	printf $(COLOR) "Compile for gogo-gRPC..."
-	$(foreach PROTO_DIR,$(PROTO_DIRS),protoc $(PROTO_IMPORTS) --gogoslick_out=Mgoogle/protobuf/wrappers.proto=github.com/gogo/protobuf/types,Mgoogle/protobuf/duration.proto=github.com/gogo/protobuf/types,Mgoogle/protobuf/descriptor.proto=github.com/golang/protobuf/protoc-gen-go/descriptor,Mgoogle/protobuf/timestamp.proto=github.com/gogo/protobuf/types,plugins=grpc,paths=source_relative:$(PROTO_OUT) $(PROTO_DIR)*.proto;)
-
 fix-path:
 	mv -f $(PROTO_OUT)/temporal/api/* $(PROTO_OUT) && rm -rf $(PROTO_OUT)/temporal
 
 ##### Plugins & tools #####
-grpc-install: gogo-protobuf-install
+grpc-install:
 	printf $(COLOR) "Install/update gRPC plugins..."
 	go install google.golang.org/grpc/cmd/protoc-gen-go-grpc@v1.1.0
 
-gogo-protobuf-install: go-protobuf-install
-	GO111MODULE=off go get github.com/temporalio/gogo-protobuf/protoc-gen-gogoslick
-
 go-protobuf-install:
 	go install github.com/golang/protobuf/protoc-gen-go@v1.4.3
 

package/sdk-core/sdk-core-protos/protos/testsrv_upstream/api-linter.yaml

@@ -31,8 +31,3 @@
     - 'core::0127::http-annotation'
     - 'core::0131::method-signature'
     - 'core::0131::response-message-name'
-
-- included_paths:
-    - 'dependencies/gogoproto/gogo.proto'
-  disabled_rules:
-    - 'all'

package/sdk-core/sdk-core-protos/protos/testsrv_upstream/temporal/api/testservice/v1/request_response.proto

@@ -33,7 +33,6 @@ option csharp_namespace = "Temporalio.Api.TestService.V1";
 
 import "google/protobuf/duration.proto";
 import "google/protobuf/timestamp.proto";
-import "dependencies/gogoproto/gogo.proto";
 
 message LockTimeSkippingRequest {
 }
@@ -48,16 +47,16 @@ message UnlockTimeSkippingResponse {
 }
 
 message SleepUntilRequest {
-    google.protobuf.Timestamp timestamp = 1 [(gogoproto.stdtime) = true];
+    google.protobuf.Timestamp timestamp = 1;
 }
 
 message SleepRequest {
-    google.protobuf.Duration duration = 1 [(gogoproto.stdduration) = true];
+    google.protobuf.Duration duration = 1;
 }
 
 message SleepResponse {
 }
 
 message GetCurrentTimeResponse {
-    google.protobuf.Timestamp time = 1 [(gogoproto.stdtime) = true];
+    google.protobuf.Timestamp time = 1;
 }

package/sdk-core/sdk-core-protos/src/history_info.rs

@@ -6,7 +6,7 @@ use crate::temporal::api::{
     workflowservice::v1::{GetWorkflowExecutionHistoryResponse, PollWorkflowTaskQueueResponse},
 };
 use anyhow::{anyhow, bail};
-use rand::{thread_rng, Rng};
+use rand::random;
 
 /// Contains information about a validated history. Used for replay and other testing.
 #[derive(Clone, Debug, PartialEq)]
@@ -154,7 +154,7 @@ impl HistoryInfo {
     /// randomly generated task token. Caller should attach a meaningful `workflow_execution` if
     /// needed.
     pub fn as_poll_wft_response(&self) -> PollWorkflowTaskQueueResponse {
-        let task_token: [u8; 16] = thread_rng().gen();
+        let task_token: [u8; 16] = random();
         PollWorkflowTaskQueueResponse {
             history: Some(History {
                 events: self.events.clone(),

package/sdk-core/sdk-core-protos/src/lib.rs

@@ -1981,6 +1981,7 @@ pub mod temporal {
                             Attributes::WorkflowExecutionUpdateRejectedEventAttributes(_) => {EventType::WorkflowExecutionUpdateRejected}
                             Attributes::WorkflowExecutionUpdateAcceptedEventAttributes(_) => {EventType::WorkflowExecutionUpdateAccepted}
                             Attributes::WorkflowExecutionUpdateCompletedEventAttributes(_) => {EventType::WorkflowExecutionUpdateCompleted}
+                            Attributes::WorkflowExecutionUpdateRequestedEventAttributes(_) => {EventType::WorkflowExecutionUpdateRequested}
                             Attributes::WorkflowPropertiesModifiedExternallyEventAttributes(_) => {EventType::WorkflowPropertiesModifiedExternally}
                             Attributes::ActivityPropertiesModifiedExternallyEventAttributes(_) => {EventType::ActivityPropertiesModifiedExternally}
                             Attributes::WorkflowPropertiesModifiedEventAttributes(_) => {EventType::WorkflowPropertiesModified}

package/sdk-core/tests/integ_tests/queries_tests.rs

@@ -384,8 +384,8 @@ async fn multiple_concurrent_queries_no_new_history() {
 }
 
 #[tokio::test]
-async fn query_superseded_by_newer_wft_is_discarded() {
-    let mut starter = init_core_and_create_wf("query_superseded_by_newer_wft_is_discarded").await;
+async fn queries_handled_before_next_wft() {
+    let mut starter = init_core_and_create_wf("queries_handled_before_next_wft").await;
     let core = starter.get_worker().await;
     let workflow_id = starter.get_task_queue().to_string();
     let task = core.poll_workflow_activation().await.unwrap();
@@ -447,16 +447,7 @@ async fn query_superseded_by_newer_wft_is_discarded() {
         ))
         .await
         .unwrap();
-        // We should get the signal activation since the in-buffer query should've been failed
-        let task = core.poll_workflow_activation().await.unwrap();
-        assert_matches!(
-            task.jobs.as_slice(),
-            [WorkflowActivationJob {
-                variant: Some(workflow_activation_job::Variant::SignalWorkflow(_)),
-            }]
-        );
-        core.complete_execution(&task.run_id).await;
-        // Query will get retried by server since we fail the task w/ the stale query
+        // We now get the second query
         let task = core.poll_workflow_activation().await.unwrap();
         let query = assert_matches!(
             task.jobs.as_slice(),
@@ -479,6 +470,15 @@ async fn query_superseded_by_newer_wft_is_discarded() {
         ))
         .await
         .unwrap();
+        // Then the signal afterward
+        let task = core.poll_workflow_activation().await.unwrap();
+        assert_matches!(
+            task.jobs.as_slice(),
+            [WorkflowActivationJob {
+                variant: Some(workflow_activation_job::Variant::SignalWorkflow(_)),
+            }]
+        );
+        core.complete_execution(&task.run_id).await;
     };
     join!(join_all(query_futs), complete_fut);
     drain_pollers_and_shutdown(&core).await;

package/sdk-core/tests/integ_tests/workflow_tests/patches.rs

@@ -5,6 +5,9 @@ use std::{
     },
     time::Duration,
 };
+use temporal_client::WorkflowClientTrait;
+use tokio::{join, sync::Notify};
+use tokio_stream::StreamExt;
 
 use temporal_sdk::{WfContext, WorkflowResult};
 use temporal_sdk_core_test_utils::CoreWfStarter;
@@ -151,3 +154,48 @@ async fn can_remove_deprecated_patch_near_other_patch() {
     starter.start_with_worker(wf_name, &mut worker).await;
     worker.run_until_done().await.unwrap();
 }
+
+#[tokio::test]
+async fn deprecated_patch_removal() {
+    let wf_name = "deprecated_patch_removal";
+    let mut starter = CoreWfStarter::new(wf_name);
+    starter.no_remote_activities();
+    let mut worker = starter.worker().await;
+    let client = starter.get_client().await;
+    let wf_id = starter.get_task_queue().to_string();
+    let did_die = Arc::new(AtomicBool::new(false));
+    let send_sig = Arc::new(Notify::new());
+    let send_sig_c = send_sig.clone();
+    worker.register_wf(wf_name, move |ctx: WfContext| {
+        let did_die = did_die.clone();
+        let send_sig_c = send_sig_c.clone();
+        async move {
+            if !did_die.load(Ordering::Acquire) {
+                assert!(ctx.deprecate_patch("getting-deprecated"));
+            }
+            send_sig_c.notify_one();
+            ctx.make_signal_channel("sig").next().await;
+
+            ctx.timer(Duration::from_millis(1)).await;
+
+            if !did_die.load(Ordering::Acquire) {
+                did_die.store(true, Ordering::Release);
+                ctx.force_task_fail(anyhow::anyhow!("i'm ded"));
+            }
+            Ok(().into())
+        }
+    });
+
+    starter.start_with_worker(wf_name, &mut worker).await;
+    let sig_fut = async {
+        send_sig.notified().await;
+        client
+            .signal_workflow_execution(wf_id, "".to_string(), "sig".to_string(), None, None)
+            .await
+            .unwrap()
+    };
+    let run_fut = async {
+        worker.run_until_done().await.unwrap();
+    };
+    join!(sig_fut, run_fut);
+}

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 })))
 }