@temporalio/core-bridge 1.14.2-canary-release-testing.0 → 1.16.0

package/src/helpers/try_into_js.rs

@@ -1,11 +1,11 @@
 use std::{
-    sync::Arc,
+    sync::{Arc, Mutex},
     time::{Duration, SystemTime, UNIX_EPOCH},
 };
 
 use neon::{
     object::Object,
-    prelude::Context,
+    prelude::{Context, Root},
     result::JsResult,
     types::{
         JsArray, JsBigInt, JsBoolean, JsBuffer, JsNumber, JsString, JsUndefined, JsValue, Value,
@@ -36,6 +36,13 @@ impl TryIntoJs for u32 {
     }
 }
 
+impl TryIntoJs for f64 {
+    type Output = JsNumber;
+    fn try_into_js<'a>(self, cx: &mut impl Context<'a>) -> JsResult<'a, JsNumber> {
+        Ok(cx.number(self))
+    }
+}
+
 impl TryIntoJs for String {
     type Output = JsString;
     fn try_into_js<'a>(self, cx: &mut impl Context<'a>) -> JsResult<'a, JsString> {
@@ -127,3 +134,82 @@ impl<T0: TryIntoJs, T1: TryIntoJs> TryIntoJs for (T0, T1) {
         Ok(array)
     }
 }
+
+/// A handle that wraps another `TryIntoJs` type, memoizing the converted JavaScript value.
+/// That is, the value is converted to JavaScript only once, and then the same JavaScript value
+/// is returned for subsequent calls. This notably ensures that the value sent to the JS side
+/// is exactly the same object every time (i.e. `===` comparison is true).
+#[derive(Clone, Debug)]
+pub struct MemoizedHandle<T: TryIntoJs + Clone + std::fmt::Debug>
+where
+    T::Output: std::fmt::Debug,
+{
+    internal: Arc<Mutex<MemoizedInternal<T>>>,
+}
+
+#[derive(Debug)]
+enum MemoizedInternal<T: TryIntoJs + Clone + std::fmt::Debug> {
+    Pending(T),
+    Rooted(Root<T::Output>),
+}
+
+impl<T: TryIntoJs + Clone + std::fmt::Debug> MemoizedHandle<T>
+where
+    T::Output: Object + std::fmt::Debug,
+{
+    pub fn new(value: T) -> Self {
+        Self {
+            internal: Arc::new(Mutex::new(MemoizedInternal::Pending(value))),
+        }
+    }
+}
+
+impl<T: TryIntoJs + Clone + std::fmt::Debug> TryIntoJs for MemoizedHandle<T>
+where
+    T::Output: Object + std::fmt::Debug,
+{
+    type Output = T::Output;
+    fn try_into_js<'cx>(self, cx: &mut impl Context<'cx>) -> JsResult<'cx, T::Output> {
+        let mut guard = self.internal.lock().expect("MemoizedHandle lock");
+        match *guard {
+            MemoizedInternal::Pending(ref value) => {
+                let rooted_value = value.clone().try_into_js(cx)?.root(cx);
+                let js_value = rooted_value.to_inner(cx);
+                *guard = MemoizedInternal::Rooted(rooted_value);
+                Ok(js_value)
+            }
+            MemoizedInternal::Rooted(ref handle) => Ok(handle.to_inner(cx)),
+        }
+    }
+}
+
+/// To avoid some recurring error patterns when crossing the JS bridge, we normally translate
+/// `Option<T>` to `T | null` on the JS side. This however implies extra code on the JS side
+/// to check for `null` and convert to `undefined` as appropriate. This generally poses no
+/// problem, as manipulation of objects on the JS side is anyway desirable for other reasons.
+///
+/// In rare cases, however, this extra manipulation may not be desirable. For example, when
+/// passing buffered metrics to the JS Side, we want to preserve object identity. Modifying
+/// objects on the JS side would either break object identity or introduce unnecessary overhead.
+///
+/// For those rare cases, this newtype wrapper to indicate that an option property should be
+/// translated to `undefined` on the JS side, rather than `null`.
+#[derive(Clone, Debug)]
+pub struct OptionAsUndefined<T: TryIntoJs + Clone + std::fmt::Debug>(Option<T>);
+
+impl<T: TryIntoJs + Clone + std::fmt::Debug> From<Option<T>> for OptionAsUndefined<T> {
+    fn from(value: Option<T>) -> Self {
+        Self(value)
+    }
+}
+
+impl<T: TryIntoJs + Clone + std::fmt::Debug> TryIntoJs for OptionAsUndefined<T> {
+    type Output = JsValue;
+    fn try_into_js<'a>(self, cx: &mut impl Context<'a>) -> JsResult<'a, JsValue> {
+        if let Some(value) = self.0 {
+            Ok(value.try_into_js(cx)?.upcast())
+        } else {
+            Ok(cx.undefined().upcast())
+        }
+    }
+}

package/src/metrics.rs

@@ -1,28 +1,36 @@
+use std::any::Any;
 use std::collections::HashMap;
+use std::sync::Arc;
 
-use anyhow::Context as _;
 use neon::prelude::*;
 use serde::Deserialize;
 
-use temporalio_common::telemetry::metrics::{
-    CoreMeter, Counter as CoreCounter, Gauge as CoreGauge, Histogram as CoreHistogram,
-    MetricParametersBuilder, NewAttributes, TemporalMeter,
-};
-use temporalio_common::telemetry::metrics::{
-    GaugeF64 as CoreGaugeF64, HistogramF64 as CoreHistogramF64,
+use temporalio_common::telemetry::metrics::core::{
+    BufferInstrumentRef as CoreBufferInstrumentRef, CustomMetricAttributes, MetricCallBufferer,
+    MetricEvent as CoreMetricEvent, MetricKind as CoreMetricKind, MetricUpdateVal,
 };
 use temporalio_common::telemetry::metrics::{
-    MetricKeyValue as CoreMetricKeyValue, MetricValue as CoreMetricValue,
+    Counter as CoreCounter, Gauge as CoreGauge, GaugeF64 as CoreGaugeF64,
+    Histogram as CoreHistogram, HistogramF64 as CoreHistogramF64,
+    MetricKeyValue as CoreMetricKeyValue, MetricParameters as CoreMetricParameters,
+    MetricValue as CoreMetricValue, NewAttributes, TemporalMeter,
 };
 
-use bridge_macros::js_function;
+use bridge_macros::{TryIntoJs, js_function};
+use temporalio_sdk_core::telemetry::MetricsCallBuffer as CoreMetricsCallBuffer;
 
+use crate::helpers::properties::ObjectExt as _;
+use crate::helpers::try_into_js::{MemoizedHandle, OptionAsUndefined};
 use crate::helpers::{
     BridgeError, BridgeResult, JsonString, MutableFinalize, OpaqueInboundHandle,
-    OpaqueOutboundHandle,
+    OpaqueOutboundHandle, TryIntoJs,
 };
 use crate::runtime::Runtime;
 
+////////////////////////////////////////////////////////////////////////////////////////////////////
+// Metric Meter (aka Custom Metrics)
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
 pub fn init(cx: &mut neon::prelude::ModuleContext) -> neon::prelude::NeonResult<()> {
     cx.export_function("newMetricCounter", new_metric_counter)?;
     cx.export_function("newMetricHistogram", new_metric_histogram)?;
@@ -115,13 +123,12 @@ pub fn new_metric_counter(
             "Failed to get metric meter".into(),
         ))?;
 
-    let counter = meter.inner.counter(
-        MetricParametersBuilder::default()
+    let counter = meter.counter(
+        CoreMetricParameters::builder()
             .name(name)
             .unit(unit)
             .description(description)
-            .build()
-            .context("Failed to build metric parameters")?,
+            .build(),
     );
 
     Ok(OpaqueOutboundHandle::new(Counter { meter, counter }))
@@ -142,13 +149,12 @@ pub fn new_metric_histogram(
             "Failed to get metric meter".into(),
         ))?;
 
-    let histogram = meter.inner.histogram(
-        MetricParametersBuilder::default()
+    let histogram = meter.histogram(
+        CoreMetricParameters::builder()
             .name(name)
             .unit(unit)
             .description(description)
-            .build()
-            .context("Failed to build metric parameters")?,
+            .build(),
     );
 
     Ok(OpaqueOutboundHandle::new(Histogram { meter, histogram }))
@@ -169,13 +175,12 @@ pub fn new_metric_histogram_f64(
             "Failed to get metric meter".into(),
         ))?;
 
-    let histogram = meter.inner.histogram_f64(
-        MetricParametersBuilder::default()
+    let histogram = meter.histogram_f64(
+        CoreMetricParameters::builder()
             .name(name)
             .unit(unit)
             .description(description)
-            .build()
-            .context("Failed to build metric parameters")?,
+            .build(),
     );
 
     Ok(OpaqueOutboundHandle::new(HistogramF64 { meter, histogram }))
@@ -196,13 +201,12 @@ pub fn new_metric_gauge(
             "Failed to get metric meter".into(),
         ))?;
 
-    let gauge = meter.inner.gauge(
-        MetricParametersBuilder::default()
+    let gauge = meter.gauge(
+        CoreMetricParameters::builder()
             .name(name)
             .unit(unit)
             .description(description)
-            .build()
-            .context("Failed to build metric parameters")?,
+            .build(),
     );
 
     Ok(OpaqueOutboundHandle::new(Gauge { meter, gauge }))
@@ -223,13 +227,12 @@ pub fn new_metric_gauge_f64(
             "Failed to get metric meter".into(),
         ))?;
 
-    let gauge = meter.inner.gauge_f64(
-        MetricParametersBuilder::default()
+    let gauge = meter.gauge_f64(
+        CoreMetricParameters::builder()
             .name(name)
             .unit(unit)
             .description(description)
-            .build()
-            .context("Failed to build metric parameters")?,
+            .build(),
     );
 
     Ok(OpaqueOutboundHandle::new(GaugeF64 { meter, gauge }))
@@ -245,10 +248,11 @@ pub fn add_metric_counter_value(
     attributes: JsonString<MetricAttributes>,
 ) -> BridgeResult<()> {
     let counter_handle = counter_handle.borrow()?;
+
     let attributes = counter_handle
         .meter
-        .inner
         .new_attributes(parse_metric_attributes(attributes.value));
+
     counter_handle.counter.add(value as u64, &attributes);
     Ok(())
 }
@@ -262,7 +266,6 @@ pub fn record_metric_histogram_value(
     let histogram_handle = histogram_handle.borrow()?;
     let attributes = histogram_handle
         .meter
-        .inner
         .new_attributes(parse_metric_attributes(attributes.value));
     histogram_handle.histogram.record(value, &attributes);
     Ok(())
@@ -277,7 +280,6 @@ pub fn record_metric_histogram_f64_value(
     let histogram_handle = histogram_handle.borrow()?;
     let attributes = histogram_handle
         .meter
-        .inner
         .new_attributes(parse_metric_attributes(attributes.value));
     histogram_handle.histogram.record(value, &attributes);
     Ok(())
@@ -292,7 +294,6 @@ pub fn set_metric_gauge_value(
     let gauge_handle = gauge_handle.borrow()?;
     let attributes = gauge_handle
         .meter
-        .inner
         .new_attributes(parse_metric_attributes(attributes.value));
     gauge_handle.gauge.record(value, &attributes);
     Ok(())
@@ -307,12 +308,240 @@ pub fn set_metric_gauge_f64_value(
     let gauge_handle = gauge_handle.borrow()?;
     let attributes = gauge_handle
         .meter
-        .inner
         .new_attributes(parse_metric_attributes(attributes.value));
     gauge_handle.gauge.record(value, &attributes);
     Ok(())
 }
 
+////////////////////////////////////////////////////////////////////////////////////////////////////
+// Buffered Metrics (aka lang-side metrics exporter)
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
+#[derive(Debug)]
+pub struct MetricsCallBuffer {
+    pub(crate) core_buffer: Arc<CoreMetricsCallBuffer<BufferedMetricRef>>,
+    use_seconds_for_durations: bool,
+}
+
+impl MetricsCallBuffer {
+    pub(crate) fn new(max_buffer_size: usize, use_seconds_for_durations: bool) -> Self {
+        Self {
+            core_buffer: Arc::new(CoreMetricsCallBuffer::new(max_buffer_size)),
+            use_seconds_for_durations,
+        }
+    }
+
+    pub(crate) fn retrieve(&self) -> Vec<BufferedMetricUpdate> {
+        self.core_buffer
+            .retrieve()
+            .iter()
+            .filter_map(|e| self.convert_metric_event(e))
+            .collect()
+    }
+
+    fn convert_metric_event(
+        &self,
+        event: &CoreMetricEvent<BufferedMetricRef>,
+    ) -> Option<BufferedMetricUpdate> {
+        match event {
+            CoreMetricEvent::Create {
+                params,
+                populate_into,
+                kind,
+            } => {
+                // Create the metric and put it on the lazy ref
+                let metric = BufferedMetric::new(params, *kind, self.use_seconds_for_durations);
+                populate_into
+                    .set(Arc::new(BufferedMetricRef(MemoizedHandle::new(metric))))
+                    .expect("Unable to set buffered metric on reference");
+
+                None
+            }
+
+            // Create the attributes and put it on the lazy ref
+            CoreMetricEvent::CreateAttributes {
+                populate_into,
+                append_from,
+                attributes,
+            } => {
+                let append_from = append_from.as_ref().map(|f| {
+                    f.get()
+                        .clone()
+                        .as_any()
+                        .downcast::<BufferedMetricAttributesRef>()
+                        .expect("Unable to downcast to expected buffered metric attributes")
+                });
+                let attributes = BufferedMetricAttributes {
+                    new_attributes: attributes.clone(),
+                    append_from: append_from.map(|f| f.as_ref().clone()),
+                };
+
+                let r = BufferedMetricAttributesRef(MemoizedHandle::new(attributes));
+                populate_into
+                    .set(Arc::new(r))
+                    .expect("Unable to set buffered metric attributes on reference");
+
+                None
+            }
+
+            CoreMetricEvent::Update {
+                instrument,
+                attributes,
+                update,
+            } => Some(BufferedMetricUpdate {
+                metric: instrument.get().as_ref().clone(),
+                #[allow(clippy::match_same_arms, clippy::cast_precision_loss)]
+                value: match update {
+                    MetricUpdateVal::Duration(v) if self.use_seconds_for_durations => {
+                        v.as_secs_f64()
+                    }
+                    MetricUpdateVal::Duration(v) => v.as_millis() as f64,
+                    MetricUpdateVal::Delta(v) => *v as f64,
+                    MetricUpdateVal::DeltaF64(v) => *v,
+                    MetricUpdateVal::Value(v) => *v as f64,
+                    MetricUpdateVal::ValueF64(v) => *v,
+                },
+                attributes: attributes
+                    .get()
+                    .clone()
+                    .as_any()
+                    .downcast::<BufferedMetricAttributesRef>()
+                    .expect("Unable to downcast to expected buffered metric attributes")
+                    .as_ref()
+                    .clone(),
+            }),
+        }
+    }
+}
+
+#[derive(TryIntoJs)]
+pub struct BufferedMetricUpdate {
+    metric: BufferedMetricRef,
+    value: f64,
+    attributes: BufferedMetricAttributesRef,
+}
+
+#[derive(TryIntoJs, Clone, Debug)]
+struct BufferedMetric {
+    name: String,
+    description: OptionAsUndefined<String>,
+    unit: OptionAsUndefined<String>,
+    kind: MetricKind,
+    value_type: MetricValueType,
+}
+
+impl BufferedMetric {
+    pub fn new(
+        params: &CoreMetricParameters,
+        kind: CoreMetricKind,
+        use_seconds_for_durations: bool,
+    ) -> Self {
+        let unit = match kind {
+            CoreMetricKind::HistogramDuration if params.unit == "duration" => {
+                Some((if use_seconds_for_durations { "s" } else { "ms" }).to_string())
+            }
+            _ => (!params.unit.is_empty()).then_some(params.unit.to_string()),
+        };
+
+        #[allow(clippy::match_same_arms)]
+        let (kind, value_type) = match kind {
+            CoreMetricKind::Counter => (MetricKind::Counter, MetricValueType::Int),
+            CoreMetricKind::Gauge => (MetricKind::Gauge, MetricValueType::Int),
+            CoreMetricKind::GaugeF64 => (MetricKind::Gauge, MetricValueType::Float),
+            CoreMetricKind::Histogram => (MetricKind::Histogram, MetricValueType::Int),
+            CoreMetricKind::HistogramF64 => (MetricKind::Histogram, MetricValueType::Float),
+            CoreMetricKind::HistogramDuration => (MetricKind::Histogram, MetricValueType::Int),
+        };
+
+        let description =
+            (!params.description.is_empty()).then_some(params.description.to_string());
+
+        Self {
+            name: params.name.to_string(),
+            description: description.into(),
+            unit: unit.into(),
+            kind,
+            value_type,
+        }
+    }
+}
+
+#[derive(Clone, Debug)]
+pub struct BufferedMetricRef(MemoizedHandle<BufferedMetric>);
+impl CoreBufferInstrumentRef for BufferedMetricRef {}
+
+impl TryIntoJs for BufferedMetricRef {
+    type Output = JsObject;
+    fn try_into_js<'cx>(self, cx: &mut impl Context<'cx>) -> JsResult<'cx, Self::Output> {
+        self.0.try_into_js(cx)
+    }
+}
+
+#[derive(Clone, Debug)]
+struct BufferedMetricAttributes {
+    new_attributes: Vec<CoreMetricKeyValue>,
+    append_from: Option<BufferedMetricAttributesRef>,
+}
+
+impl TryIntoJs for BufferedMetricAttributes {
+    type Output = JsObject;
+    fn try_into_js<'cx>(self, cx: &mut impl Context<'cx>) -> JsResult<'cx, Self::Output> {
+        let object = cx.empty_object();
+
+        // Copy existing attributes, if any
+        if let Some(existing) = self.append_from {
+            let existing_attrs = existing.try_into_js(cx)?;
+
+            object_assign(cx, object, existing_attrs)?;
+        }
+
+        // Assign new attributes
+        for kv in self.new_attributes {
+            let k = kv.key.as_str();
+            #[allow(clippy::cast_precision_loss)]
+            match &kv.value {
+                CoreMetricValue::String(v) => object.set_property_from(cx, k, v.as_str()),
+                CoreMetricValue::Int(v) => object.set_property_from(cx, k, *v as f64),
+                CoreMetricValue::Float(v) => object.set_property_from(cx, k, *v),
+                CoreMetricValue::Bool(v) => object.set_property_from(cx, k, *v),
+            }?;
+        }
+
+        Ok(object)
+    }
+}
+
+#[derive(Clone, Debug)]
+struct BufferedMetricAttributesRef(MemoizedHandle<BufferedMetricAttributes>);
+
+impl CustomMetricAttributes for BufferedMetricAttributesRef {
+    fn as_any(self: Arc<Self>) -> Arc<dyn Any + Send + Sync> {
+        self as Arc<dyn Any + Send + Sync>
+    }
+}
+
+impl TryIntoJs for BufferedMetricAttributesRef {
+    type Output = JsObject;
+    fn try_into_js<'cx>(self, cx: &mut impl Context<'cx>) -> JsResult<'cx, Self::Output> {
+        self.0.try_into_js(cx)
+    }
+}
+
+#[derive(TryIntoJs, Clone, Debug)]
+enum MetricKind {
+    Counter,
+    Gauge,
+    Histogram,
+}
+
+#[derive(TryIntoJs, Clone, Debug)]
+enum MetricValueType {
+    Int,
+    Float,
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+// Helpers
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
 fn parse_metric_attributes(attrs: MetricAttributes) -> NewAttributes {
@@ -326,3 +555,16 @@ fn parse_metric_attributes(attrs: MetricAttributes) -> NewAttributes {
         .collect();
     NewAttributes { attributes: attrs }
 }
+
+fn object_assign<'cx>(
+    cx: &mut impl Context<'cx>,
+    object: Handle<'cx, JsObject>,
+    source: Handle<'cx, JsObject>,
+) -> JsResult<'cx, JsObject> {
+    let object_class = cx.global::<JsFunction>("Object")?;
+    let assign_function = object_class.get::<JsFunction, _, _>(cx, "assign")?;
+    let null = cx.null();
+    assign_function.call(cx, null, vec![object.upcast(), source.upcast()])?;
+
+    Ok(object)
+}