@temporalio/core-bridge 1.11.2 → 1.11.4

package/src/conversions/slot_supplier_bridge.rs

@@ -0,0 +1,287 @@
+use crate::helpers::{get_optional, js_getter};
+use log::{error, warn};
+use neon::types::JsNull;
+use neon::{
+    context::Context,
+    context::FunctionContext,
+    event::Channel,
+    handle::{Handle, Root},
+    object::Object,
+    prelude::{JsBuffer, JsFunction, JsObject, JsPromise, JsUndefined, JsValue, NeonResult, Value},
+};
+use prost::Message;
+use std::{cell::RefCell, marker::PhantomData, sync::Arc, time::Duration};
+use temporal_sdk_core::api::worker::{
+    SlotKind, SlotKindType, SlotMarkUsedContext, SlotReleaseContext, SlotReservationContext,
+    SlotSupplier, SlotSupplierPermit,
+};
+use tokio::sync::oneshot;
+
+pub struct SlotSupplierBridge<SK> {
+    inner: Arc<Root<JsObject>>,
+    reserve_cb: Arc<Root<JsFunction>>,
+    try_reserve_cb: Arc<Root<JsFunction>>,
+    mark_used_cb: Arc<Root<JsFunction>>,
+    release_cb: Arc<Root<JsFunction>>,
+    channel: Channel,
+    _kind: PhantomData<SK>,
+}
+
+impl<SK> SlotSupplierBridge<SK> {
+    pub(crate) fn new(cx: &mut FunctionContext, obj: Handle<'_, JsObject>) -> NeonResult<Self> {
+        Ok(Self {
+            inner: Arc::new(obj.root(cx)),
+            // Callbacks for each function are cached to reduce calling overhead
+            reserve_cb: Arc::new(js_getter!(cx, &obj, "reserveSlot", JsFunction).root(cx)),
+            try_reserve_cb: Arc::new(js_getter!(cx, &obj, "tryReserveSlot", JsFunction).root(cx)),
+            mark_used_cb: Arc::new(js_getter!(cx, &obj, "markSlotUsed", JsFunction).root(cx)),
+            release_cb: Arc::new(js_getter!(cx, &obj, "releaseSlot", JsFunction).root(cx)),
+            channel: cx.channel(),
+            _kind: PhantomData,
+        })
+    }
+}
+
+struct BridgePermitData {
+    permit: Arc<Root<JsObject>>,
+}
+
+struct CallAbortOnDrop {
+    chan: Channel,
+    aborter: oneshot::Receiver<Root<JsFunction>>,
+}
+
+impl Drop for CallAbortOnDrop {
+    fn drop(&mut self) {
+        if let Ok(aborter) = self.aborter.try_recv() {
+            let _ = self.chan.try_send(move |mut cx| {
+                let cb = aborter.to_inner(&mut cx);
+                let this = cx.undefined();
+                let _ = cb.call(&mut cx, this, []);
+                Ok(())
+            });
+        }
+    }
+}
+
+static PERMIT_DATA_FIELD: &str = "permit_data";
+
+#[async_trait::async_trait]
+impl<SK: SlotKind + Send + Sync> SlotSupplier for SlotSupplierBridge<SK> {
+    type SlotKind = SK;
+
+    async fn reserve_slot(&self, ctx: &dyn SlotReservationContext) -> SlotSupplierPermit {
+        loop {
+            let inner = self.inner.clone();
+            let rcb = self.reserve_cb.clone();
+            let task_queue = ctx.task_queue().to_string();
+            let worker_identity = ctx.worker_identity().to_string();
+            let worker_build_id = ctx.worker_build_id().to_string();
+            let is_sticky = ctx.is_sticky();
+
+            let (callback_fut, _abort_on_drop) = match self
+                .channel
+                .send(move |mut cx| {
+                    let context = Self::mk_reserve_ctx(
+                        task_queue,
+                        worker_identity,
+                        worker_build_id,
+                        is_sticky,
+                        &mut cx,
+                    )?;
+                    let (aborter_tx, aborter) = oneshot::channel();
+                    let abort_on_drop = CallAbortOnDrop {
+                        chan: cx.channel(),
+                        aborter,
+                    };
+                    let aborter_tx = RefCell::new(Some(aborter_tx));
+                    let abort_func = JsFunction::new(&mut cx, move |mut cx| {
+                        let func: Handle<JsFunction> = cx.argument(0)?;
+                        if let Some(aborter_tx) = aborter_tx.take() {
+                            let _ = aborter_tx.send(func.root(&mut cx));
+                        }
+                        Ok(cx.undefined())
+                    })?
+                    .upcast();
+
+                    let this = (*inner).clone(&mut cx).into_inner(&mut cx);
+                    let val = rcb
+                        .to_inner(&mut cx)
+                        .call(&mut cx, this, [context, abort_func])?;
+                    let as_prom = val.downcast_or_throw::<JsPromise, _>(&mut cx)?;
+                    let fut = as_prom.to_future(&mut cx, |mut cx, result| match result {
+                        Ok(value) => {
+                            let permit_obj = JsObject::new(&mut cx);
+                            permit_obj.set(&mut cx, PERMIT_DATA_FIELD, value)?;
+                            Ok(Ok(permit_obj.root(&mut cx)))
+                        }
+                        Err(_) => Ok(Err(())),
+                    })?;
+                    Ok((fut, abort_on_drop))
+                })
+                .await
+            {
+                Ok(v) => v,
+                Err(e) => {
+                    warn!("Error reserving slot: {:?}", e);
+                    continue;
+                }
+            };
+
+            match callback_fut.await {
+                Ok(Ok(res)) => {
+                    let permit = SlotSupplierPermit::with_user_data(BridgePermitData {
+                        permit: Arc::new(res),
+                    });
+                    return permit;
+                }
+                // Error in user function
+                Ok(Err(())) => {
+                    // Nothing to do here. Error in user's function (or an abort).
+                    // Logging handled on the JS side.
+                }
+                Err(e) => {
+                    error!(
+                        "There was an error in the rust/node bridge while reserving a slot: {}",
+                        e
+                    );
+                }
+            }
+            // Wait a beat to avoid spamming errors
+            tokio::time::sleep(Duration::from_millis(1000)).await;
+        }
+    }
+
+    fn try_reserve_slot(&self, ctx: &dyn SlotReservationContext) -> Option<SlotSupplierPermit> {
+        let inner = self.inner.clone();
+        let rcb = self.try_reserve_cb.clone();
+        let task_queue = ctx.task_queue().to_string();
+        let worker_identity = ctx.worker_identity().to_string();
+        let worker_build_id = ctx.worker_build_id().to_string();
+        let is_sticky = ctx.is_sticky();
+
+        // This is... unfortunate but since this method is called from an async context way up
+        // the stack, but is not async itself AND we need some way to get the result from the JS
+        // callback, we must use this roundabout way of blocking. Simply calling `join` on the
+        // channel send won't work - it'll panic because it calls block_on internally.
+        let runtime_handle = tokio::runtime::Handle::current();
+        let _entered = runtime_handle.enter();
+        let callback_res = futures::executor::block_on(self.channel.send(move |mut cx| {
+            let context = Self::mk_reserve_ctx(
+                task_queue,
+                worker_identity,
+                worker_build_id,
+                is_sticky,
+                &mut cx,
+            )?;
+
+            let this = (*inner).clone(&mut cx).into_inner(&mut cx);
+            let val = rcb.to_inner(&mut cx).call(&mut cx, this, [context])?;
+            if val.is_a::<JsUndefined, _>(&mut cx) || val.is_a::<JsNull, _>(&mut cx) {
+                return Ok(None);
+            }
+            let permit_obj = JsObject::new(&mut cx);
+            permit_obj.set(&mut cx, PERMIT_DATA_FIELD, val)?;
+            Ok(Some(permit_obj.root(&mut cx)))
+        }));
+
+        // Ignore errors, they'll be logged by JS
+        callback_res.ok().flatten().map(|res| {
+            SlotSupplierPermit::with_user_data(BridgePermitData {
+                permit: Arc::new(res),
+            })
+        })
+    }
+
+    fn mark_slot_used(&self, ctx: &dyn SlotMarkUsedContext<SlotKind = Self::SlotKind>) {
+        let inner = self.inner.clone();
+        let cb = self.mark_used_cb.clone();
+        let permit_data = ctx
+            .permit()
+            .user_data::<BridgePermitData>()
+            .map(|d| d.permit.clone());
+        // Get the slot info as bytes
+        let slot_info_bytes = ctx.info().encode_to_vec();
+
+        self.channel.send(move |mut cx| {
+            let context = JsObject::new(&mut cx);
+            if let Some(permit_obj) = permit_data {
+                let ph: Handle<JsObject> = permit_obj.to_inner(&mut cx);
+                let pd = ph.get_value(&mut cx, PERMIT_DATA_FIELD)?;
+                context.set(&mut cx, "permit", pd)?;
+            }
+            let slot_info = JsBuffer::from_slice(&mut cx, &slot_info_bytes)?;
+            context.set(&mut cx, "slotInfo", slot_info)?;
+            let context = context.as_value(&mut cx);
+
+            let this = (*inner).clone(&mut cx).into_inner(&mut cx);
+            let val = cb.to_inner(&mut cx).call(&mut cx, this, [context])?;
+            if val.is_a::<JsUndefined, _>(&mut cx) {
+                return Ok(None);
+            }
+            let as_obj = val.downcast_or_throw::<JsObject, _>(&mut cx)?;
+            Ok(Some(as_obj.root(&mut cx)))
+        });
+    }
+
+    fn release_slot(&self, ctx: &dyn SlotReleaseContext<SlotKind = Self::SlotKind>) {
+        let inner = self.inner.clone();
+        let cb = self.release_cb.clone();
+        let permit_data = ctx
+            .permit()
+            .user_data::<BridgePermitData>()
+            .map(|d| d.permit.clone());
+        // Get the slot info as bytes
+        let slot_info_bytes = ctx.info().map(|m| m.encode_to_vec());
+
+        self.channel.send(move |mut cx| {
+            let context = JsObject::new(&mut cx);
+            if let Some(permit_obj) = permit_data {
+                let ph: Handle<JsObject> = permit_obj.to_inner(&mut cx);
+                let pd = ph.get_value(&mut cx, PERMIT_DATA_FIELD)?;
+                context.set(&mut cx, "permit", pd)?;
+            }
+            if let Some(slot_info_bytes) = slot_info_bytes {
+                let slot_info = JsBuffer::from_slice(&mut cx, &slot_info_bytes)?;
+                context.set(&mut cx, "slotInfo", slot_info)?;
+            }
+            let context = context.as_value(&mut cx);
+
+            let this = (*inner).clone(&mut cx).into_inner(&mut cx);
+            let val = cb.to_inner(&mut cx).call(&mut cx, this, [context])?;
+            if val.is_a::<JsUndefined, _>(&mut cx) {
+                return Ok(None);
+            }
+            let as_obj = val.downcast_or_throw::<JsObject, _>(&mut cx)?;
+            Ok(Some(as_obj.root(&mut cx)))
+        });
+    }
+}
+
+impl<SK: SlotKind> SlotSupplierBridge<SK> {
+    fn mk_reserve_ctx<'a, C: Context<'a>>(
+        task_queue: String,
+        worker_identity: String,
+        worker_build_id: String,
+        is_sticky: bool,
+        cx: &mut C,
+    ) -> NeonResult<Handle<'a, JsValue>> {
+        let context = JsObject::new(cx);
+        let slottype = cx.string(match SK::kind() {
+            SlotKindType::Workflow => "workflow",
+            SlotKindType::Activity => "activity",
+            SlotKindType::LocalActivity => "local-activity",
+        });
+        context.set(cx, "slotType", slottype)?;
+        let tq = cx.string(task_queue);
+        context.set(cx, "taskQueue", tq)?;
+        let wid = cx.string(worker_identity);
+        context.set(cx, "workerIdentity", wid)?;
+        let bid = cx.string(worker_build_id);
+        context.set(cx, "workerBuildId", bid)?;
+        let is_sticky = cx.boolean(is_sticky);
+        context.set(cx, "isSticky", is_sticky)?;
+        let context = context.as_value(cx);
+        Ok(context)
+    }
+}

package/src/conversions.rs

@@ -5,8 +5,10 @@ use neon::{
     prelude::*,
     types::{JsBoolean, JsNumber, JsString},
 };
+use slot_supplier_bridge::SlotSupplierBridge;
 use std::{collections::HashMap, net::SocketAddr, sync::Arc, time::Duration};
 use temporal_client::HttpConnectProxyOptions;
+use temporal_sdk_core::api::worker::SlotKind;
 use temporal_sdk_core::{
     api::telemetry::{Logger, MetricTemporality, TelemetryOptions, TelemetryOptionsBuilder},
     api::{
@@ -25,6 +27,8 @@ use temporal_sdk_core::{
     TlsConfig, TunerHolderOptionsBuilder, Url,
 };
 
+mod slot_supplier_bridge;
+
 pub enum EphemeralServerConfig {
     TestServer(TestServerConfig),
     DevServer(TemporalDevServerConfig),
@@ -65,11 +69,11 @@ pub(crate) trait ObjectHandleConversionsExt {
         &self,
         cx: &mut FunctionContext,
     ) -> NeonResult<HashMap<String, String>>;
-    fn as_slot_supplier(
-        &self,
+    fn into_slot_supplier<SK: SlotKind + Send + Sync + 'static>(
+        self,
         cx: &mut FunctionContext,
         rbo: &mut Option<ResourceBasedSlotsOptions>,
-    ) -> NeonResult<SlotSupplierOptions>;
+    ) -> NeonResult<SlotSupplierOptions<SK>>;
 }
 
 impl ObjectHandleConversionsExt for Handle<'_, JsObject> {
@@ -409,18 +413,18 @@ impl ObjectHandleConversionsExt for Handle<'_, JsObject> {
             if let Some(wf_slot_supp) =
                 js_optional_getter!(cx, &tuner, "workflowTaskSlotSupplier", JsObject)
             {
-                tuner_holder.workflow_slot_options(wf_slot_supp.as_slot_supplier(cx, &mut rbo)?);
+                tuner_holder.workflow_slot_options(wf_slot_supp.into_slot_supplier(cx, &mut rbo)?);
             }
             if let Some(act_slot_supp) =
                 js_optional_getter!(cx, &tuner, "activityTaskSlotSupplier", JsObject)
             {
-                tuner_holder.activity_slot_options(act_slot_supp.as_slot_supplier(cx, &mut rbo)?);
+                tuner_holder.activity_slot_options(act_slot_supp.into_slot_supplier(cx, &mut rbo)?);
             }
             if let Some(local_act_slot_supp) =
                 js_optional_getter!(cx, &tuner, "localActivityTaskSlotSupplier", JsObject)
             {
                 tuner_holder.local_activity_slot_options(
-                    local_act_slot_supp.as_slot_supplier(cx, &mut rbo)?,
+                    local_act_slot_supp.into_slot_supplier(cx, &mut rbo)?,
                 );
             }
             if let Some(rbo) = rbo {
@@ -567,20 +571,20 @@ impl ObjectHandleConversionsExt for Handle<'_, JsObject> {
         }
     }
 
-    fn as_slot_supplier(
-        &self,
+    fn into_slot_supplier<SK: SlotKind + Send + Sync + 'static>(
+        self,
         cx: &mut FunctionContext,
         rbo: &mut Option<ResourceBasedSlotsOptions>,
-    ) -> NeonResult<SlotSupplierOptions> {
-        match js_value_getter!(cx, self, "type", JsString).as_str() {
+    ) -> NeonResult<SlotSupplierOptions<SK>> {
+        match js_value_getter!(cx, &self, "type", JsString).as_str() {
             "fixed-size" => Ok(SlotSupplierOptions::FixedSize {
-                slots: js_value_getter!(cx, self, "numSlots", JsNumber) as usize,
+                slots: js_value_getter!(cx, &self, "numSlots", JsNumber) as usize,
             }),
             "resource-based" => {
-                let min_slots = js_value_getter!(cx, self, "minimumSlots", JsNumber);
-                let max_slots = js_value_getter!(cx, self, "maximumSlots", JsNumber);
-                let ramp_throttle = js_value_getter!(cx, self, "rampThrottleMs", JsNumber) as u64;
-                if let Some(tuner_opts) = js_optional_getter!(cx, self, "tunerOptions", JsObject) {
+                let min_slots = js_value_getter!(cx, &self, "minimumSlots", JsNumber);
+                let max_slots = js_value_getter!(cx, &self, "maximumSlots", JsNumber);
+                let ramp_throttle = js_value_getter!(cx, &self, "rampThrottleMs", JsNumber) as u64;
+                if let Some(tuner_opts) = js_optional_getter!(cx, &self, "tunerOptions", JsObject) {
                     let target_mem =
                         js_value_getter!(cx, &tuner_opts, "targetMemoryUsage", JsNumber);
                     let target_cpu = js_value_getter!(cx, &tuner_opts, "targetCpuUsage", JsNumber);
@@ -603,6 +607,10 @@ impl ObjectHandleConversionsExt for Handle<'_, JsObject> {
                     ),
                 ))
             }
+            "custom" => {
+                let ssb = SlotSupplierBridge::new(cx, self)?;
+                Ok(SlotSupplierOptions::Custom(Arc::new(ssb)))
+            }
             _ => cx.throw_type_error("Invalid slot supplier type"),
         }
     }

package/src/helpers.rs

@@ -106,6 +106,23 @@ macro_rules! js_optional_getter {
 
 pub(crate) use js_optional_getter;
 
+macro_rules! js_getter {
+    ($js_cx:expr, $js_obj:expr, $prop_name:expr, $js_type:ty) => {
+        match get_optional($js_cx, $js_obj, $prop_name) {
+            None => $js_cx.throw_type_error(format!("{} must be defined", $prop_name))?,
+            Some(val) => {
+                if val.is_a::<$js_type, _>($js_cx) {
+                    val.downcast_or_throw::<$js_type, _>($js_cx)?
+                } else {
+                    $js_cx.throw_type_error(format!("Invalid {}", $prop_name))?
+                }
+            }
+        }
+    };
+}
+
+pub(crate) use js_getter;
+
 macro_rules! js_optional_value_getter {
     ($js_cx:expr, $js_obj:expr, $prop_name:expr, $js_type:ty) => {
         js_optional_getter!($js_cx, $js_obj, $prop_name, $js_type).map(|v| v.value($js_cx))
@@ -199,7 +216,7 @@ pub fn serde_value_to_js_value<'a>(
         serde_json::Value::Bool(b) => Ok(cx.boolean(b).upcast()),
         serde_json::Value::Null => Ok(cx.null().upcast()),
         serde_json::Value::Array(vec) => {
-            let arr: Handle<'a, JsArray> = JsArray::new(cx, vec.len() as u32);
+            let arr: Handle<'a, JsArray> = JsArray::new(cx, vec.len());
             for (i, v) in vec.into_iter().enumerate() {
                 let v = serde_value_to_js_value(cx, v)?;
                 arr.set(cx, i as u32, v)?;
@@ -247,6 +264,23 @@ fn snake_to_camel(input: String) -> String {
     }
 }
 
+#[allow(dead_code)]
+// Useful to help debug JSObject contents
+pub fn log_js_object<'a, 'b, C: Context<'b>>(cx: &mut C, js_object: &Handle<'a, JsObject>) {
+    let global = cx.global_object();
+    let console = global
+        .get::<JsObject, _, _>(cx, "console")
+        .expect("Failed to get console object");
+
+    let log = console
+        .get::<JsFunction, _, _>(cx, "log")
+        .expect("Failed to get log function");
+
+    let args = vec![js_object.upcast()]; // Upcast js_object to JsValue
+    log.call(cx, console, args)
+        .expect("Failed to call console.log");
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;

package/src/runtime.rs

@@ -14,7 +14,7 @@ use temporal_sdk_core::{
     ephemeral_server::EphemeralServer as CoreEphemeralServer,
     init_replay_worker, init_worker,
     replay::{HistoryForReplay, ReplayWorkerInput},
-    ClientOptions, CoreRuntime, RetryClient, WorkerConfig,
+    ClientOptions, CoreRuntime, RetryClient, TokioRuntimeBuilder, WorkerConfig,
 };
 use tokio::sync::{
     mpsc::{channel, unbounded_channel, Sender, UnboundedReceiver, UnboundedSender},
@@ -126,6 +126,10 @@ pub fn start_bridge_loop(
     tokio_builder.enable_all().thread_name("core");
     let telem_opts = telemetry_options.0;
     let meter_maker = telemetry_options.1;
+    let tokio_builder: TokioRuntimeBuilder<Box<dyn Fn() + Send + Sync>> = TokioRuntimeBuilder {
+        inner: tokio_builder,
+        lang_on_thread_start: None,
+    };
     let mut core_runtime =
         CoreRuntime::new(telem_opts, tokio_builder).expect("Failed to create CoreRuntime");
 
@@ -254,7 +258,7 @@ pub fn start_bridge_loop(
                                 worker,
                                 channel,
                                 callback,
-                                None
+                                None,
                             ));
                         }
                         Err(err) => send_error(channel.clone(), callback, move |cx| {
@@ -274,7 +278,7 @@ pub fn start_bridge_loop(
                                 worker,
                                 channel.clone(),
                                 callback,
-                                Some(tunnel)
+                                Some(tunnel),
                             ));
                         }
                         Err(err) => send_error(channel.clone(), callback, move |cx| {

package/src/worker.rs

@@ -226,12 +226,12 @@ pub fn worker_new(mut cx: FunctionContext) -> JsResult<JsUndefined> {
     let worker_options = cx.argument::<JsObject>(1)?;
     let callback = cx.argument::<JsFunction>(2)?;
 
-    let config = worker_options.as_worker_config(&mut cx)?;
     match client.borrow().as_ref() {
         None => {
             callback_with_unexpected_error(&mut cx, callback, "Tried to use closed Client")?;
         }
         Some(client) => {
+            let config = worker_options.as_worker_config(&mut cx)?;
             let request = RuntimeRequest::InitWorker {
                 client: client.core_client.clone(),
                 config,

package/ts/errors.ts

@@ -18,7 +18,14 @@ export class TransportError extends Error {}
  * Something unexpected happened, considered fatal
  */
 @SymbolBasedInstanceOfError('UnexpectedError')
-export class UnexpectedError extends Error {}
+export class UnexpectedError extends Error {
+  constructor(
+    message: string,
+    public cause?: unknown
+  ) {
+    super(message);
+  }
+}
 
 export { IllegalStateError };
 
@@ -47,7 +54,7 @@ export function convertFromNamedError(e: unknown, keepStackTrace: boolean): unkn
         return newerr;
 
       case 'UnexpectedError':
-        newerr = new UnexpectedError(e.message);
+        newerr = new UnexpectedError(e.message, e);
         newerr.stack = keepStackTrace ? e.stack : undefined;
         return newerr;
     }

package/ts/index.ts

@@ -8,6 +8,15 @@ export {
   ResourceBasedSlotOptions,
   ResourceBasedTunerOptions,
   FixedSizeSlotSupplier,
+  CustomSlotSupplier,
+  SlotInfo,
+  WorkflowSlotInfo,
+  ActivitySlotInfo,
+  LocalActivitySlotInfo,
+  SlotMarkUsedContext,
+  SlotPermit,
+  SlotReserveContext,
+  SlotReleaseContext,
 } from './worker-tuner';
 
 export type { TLSConfig, ProxyConfig, HttpConnectProxyConfig };
@@ -98,7 +107,7 @@ export interface ClientOptions {
  * @experimental
  */
 export interface ConsoleLogger {
-  console: {}; // eslint-disable-line @typescript-eslint/ban-types
+  console: {}; // eslint-disable-line @typescript-eslint/no-empty-object-type
 }
 
 /**
@@ -134,7 +143,13 @@ export interface OtelCollectorExporter {
     /**
      * URL of a gRPC OpenTelemetry collector.
      *
-     * @format Starts with "grpc://" or "http://" for an unsecured connection (typical), or "grpcs://" or "https://" for a TLS connection.
+     * Syntax should generally look like `http://server:4317` (the `grpc://` is also fine). Core's OTLP
+     * metric exporter does not support the 'OTLP/HTTP' protocol (e.g. `http://server:4318/v1/metrics`).
+     * For greater flexibility, you may setup an OTel collector running as a sidecar (e.g. to proxy
+     * OTLP/gRPC requests to a remote OTLP/HTTP endpoint).
+     *
+     * @format Starts with "grpc://" or "http://" for an unsecured connection (typical),
+     *         or "grpcs://" or "https://" for a TLS connection.
      * @note The `OTEL_EXPORTER_OTLP_ENDPOINT` environment variable, if set, will override this property.
      */
     url: string;
@@ -269,8 +284,8 @@ export type CompiledTelemetryOptions = {
   logging: {
     filter: string;
   } & (
-    | { console: {} /* eslint-disable-line @typescript-eslint/ban-types */ }
-    | { forward: {} /* eslint-disable-line @typescript-eslint/ban-types */ }
+    | { console: {} /* eslint-disable-line @typescript-eslint/no-empty-object-type */ }
+    | { forward: {} /* eslint-disable-line @typescript-eslint/no-empty-object-type */ }
   );
   metrics?: {
     temporality?: 'cumulative' | 'delta';