@temporalio/core-bridge 1.14.1 → 1.15.0

package/src/metrics.rs

@@ -1,28 +1,39 @@
+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,
+    BufferInstrumentRef as CoreBufferInstrumentRef, CoreMeter, Counter as CoreCounter,
+    CustomMetricAttributes, Gauge as CoreGauge, Histogram as CoreHistogram, MetricCallBufferer,
+    MetricEvent as CoreMetricEvent, MetricKind as CoreMetricKind,
+    MetricParameters as CoreMetricParameters, NewAttributes, TemporalMeter,
 };
 use temporalio_common::telemetry::metrics::{
     GaugeF64 as CoreGaugeF64, HistogramF64 as CoreHistogramF64,
 };
-use temporalio_common::telemetry::metrics::{
-    MetricKeyValue as CoreMetricKeyValue, MetricValue as CoreMetricValue,
+use temporalio_common::telemetry::{
+    metrics,
+    metrics::{MetricKeyValue as CoreMetricKeyValue, MetricValue as CoreMetricValue},
 };
 
-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)?;
@@ -116,12 +127,11 @@ pub fn new_metric_counter(
         ))?;
 
     let counter = meter.inner.counter(
-        MetricParametersBuilder::default()
+        CoreMetricParameters::builder()
             .name(name)
             .unit(unit)
             .description(description)
-            .build()
-            .context("Failed to build metric parameters")?,
+            .build(),
     );
 
     Ok(OpaqueOutboundHandle::new(Counter { meter, counter }))
@@ -143,12 +153,11 @@ pub fn new_metric_histogram(
         ))?;
 
     let histogram = meter.inner.histogram(
-        MetricParametersBuilder::default()
+        CoreMetricParameters::builder()
             .name(name)
             .unit(unit)
             .description(description)
-            .build()
-            .context("Failed to build metric parameters")?,
+            .build(),
     );
 
     Ok(OpaqueOutboundHandle::new(Histogram { meter, histogram }))
@@ -170,12 +179,11 @@ pub fn new_metric_histogram_f64(
         ))?;
 
     let histogram = meter.inner.histogram_f64(
-        MetricParametersBuilder::default()
+        CoreMetricParameters::builder()
             .name(name)
             .unit(unit)
             .description(description)
-            .build()
-            .context("Failed to build metric parameters")?,
+            .build(),
     );
 
     Ok(OpaqueOutboundHandle::new(HistogramF64 { meter, histogram }))
@@ -197,12 +205,11 @@ pub fn new_metric_gauge(
         ))?;
 
     let gauge = meter.inner.gauge(
-        MetricParametersBuilder::default()
+        CoreMetricParameters::builder()
             .name(name)
             .unit(unit)
             .description(description)
-            .build()
-            .context("Failed to build metric parameters")?,
+            .build(),
     );
 
     Ok(OpaqueOutboundHandle::new(Gauge { meter, gauge }))
@@ -224,12 +231,11 @@ pub fn new_metric_gauge_f64(
         ))?;
 
     let gauge = meter.inner.gauge_f64(
-        MetricParametersBuilder::default()
+        CoreMetricParameters::builder()
             .name(name)
             .unit(unit)
             .description(description)
-            .build()
-            .context("Failed to build metric parameters")?,
+            .build(),
     );
 
     Ok(OpaqueOutboundHandle::new(GaugeF64 { meter, gauge }))
@@ -245,10 +251,12 @@ 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(())
 }
@@ -313,6 +321,235 @@ pub fn set_metric_gauge_f64_value(
     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 {
+                    metrics::MetricUpdateVal::Duration(v) if self.use_seconds_for_durations => {
+                        v.as_secs_f64()
+                    }
+                    metrics::MetricUpdateVal::Duration(v) => v.as_millis() as f64,
+                    metrics::MetricUpdateVal::Delta(v) => *v as f64,
+                    metrics::MetricUpdateVal::DeltaF64(v) => *v,
+                    metrics::MetricUpdateVal::Value(v) => *v as f64,
+                    metrics::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 {
+                metrics::MetricValue::String(v) => object.set_property_from(cx, k, v.as_str()),
+                metrics::MetricValue::Int(v) => object.set_property_from(cx, k, *v as f64),
+                metrics::MetricValue::Float(v) => object.set_property_from(cx, k, *v),
+                metrics::MetricValue::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 +563,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)
+}

package/src/runtime.rs

@@ -10,7 +10,7 @@ use temporalio_common::telemetry::{
     PrometheusExporterOptions as CorePrometheusExporterOptions, metrics::CoreMeter,
 };
 use temporalio_sdk_core::{
-    CoreRuntime, RuntimeOptionsBuilder, TokioRuntimeBuilder,
+    CoreRuntime, TokioRuntimeBuilder,
     telemetry::{build_otlp_metric_exporter, start_prometheus_metric_exporter},
 };
 
@@ -20,6 +20,7 @@ use tokio_stream::StreamExt as _;
 use crate::{
     helpers::{handles::MutableFinalize, *},
     logs::LogEntry,
+    metrics::{BufferedMetricUpdate, MetricsCallBuffer},
 };
 
 #[macro_export]
@@ -36,6 +37,10 @@ macro_rules! enter_sync {
 pub fn init(cx: &mut neon::prelude::ModuleContext) -> neon::prelude::NeonResult<()> {
     cx.export_function("newRuntime", runtime_new)?;
     cx.export_function("runtimeShutdown", runtime_shutdown)?;
+    cx.export_function(
+        "runtimeRetrieveBufferedMetrics",
+        runtime_retrieve_buffered_metrics,
+    )?;
 
     Ok(())
 }
@@ -51,6 +56,9 @@ pub struct Runtime {
     // For some unknown reason, the otel metrics exporter will go crazy on shutdown in some
     // scenarios if we don't hold on to the `CoreOtelMeter` till the `Runtime` finally gets dropped.
     _otel_metrics_exporter: Option<Arc<dyn CoreMeter + 'static>>,
+
+    // Buffered metrics call buffer, if buffered metrics are enabled
+    pub(crate) metrics_call_buffer: Option<MetricsCallBuffer>,
 }
 
 /// Initialize Core global telemetry and create the tokio runtime required to run Core.
@@ -63,41 +71,58 @@ pub fn runtime_new(
         bridge_options.try_into()?;
 
     // Create core runtime which starts tokio multi-thread runtime
-    let runtime_options = RuntimeOptionsBuilder::default()
+    let runtime_options = temporalio_sdk_core::RuntimeOptions::builder()
         .telemetry_options(telemetry_options)
         .heartbeat_interval(worker_heartbeat_interval_millis.map(Duration::from_millis))
         .build()
-        .context("Failed to build runtime options")?;
+        .map_err(|err| BridgeError::TypeError {
+            message: format!("Failed to build runtime options: {err}"),
+            field: None,
+        })?;
     let mut core_runtime = CoreRuntime::new(runtime_options, TokioRuntimeBuilder::default())
         .context("Failed to initialize Core Runtime")?;
 
     enter_sync!(core_runtime);
 
     // Run the metrics exporter task, if needed. Created after Runtime since it needs Tokio handle
-    let (prom_metrics_exporter_task, otel_metrics_exporter) = match metrics_options {
-        Some(BridgeMetricsExporter::Prometheus(prom_opts)) => {
-            let exporter = start_prometheus_metric_exporter(prom_opts)
-                .context("Failed to start prometheus metrics exporter")?;
+    let (prom_metrics_exporter_task, otel_metrics_exporter, metrics_call_buffer) =
+        match metrics_options {
+            Some(BridgeMetricsExporter::Prometheus(prom_opts)) => {
+                let exporter = start_prometheus_metric_exporter(prom_opts)
+                    .context("Failed to start prometheus metrics exporter")?;
 
-            core_runtime
-                .telemetry_mut()
-                .attach_late_init_metrics(exporter.meter);
+                core_runtime
+                    .telemetry_mut()
+                    .attach_late_init_metrics(exporter.meter);
 
-            (Some(exporter.abort_handle), None)
-        }
-        Some(BridgeMetricsExporter::Otel(otel_opts)) => {
-            let exporter = build_otlp_metric_exporter(otel_opts)
-                .context("Failed to start OTel metrics exporter")?;
+                (Some(exporter.abort_handle), None, None)
+            }
+            Some(BridgeMetricsExporter::Otel(otel_opts)) => {
+                let exporter = build_otlp_metric_exporter(otel_opts)
+                    .context("Failed to start OTel metrics exporter")?;
 
-            let exporter: Arc<dyn CoreMeter + 'static> = Arc::new(exporter);
-            core_runtime
-                .telemetry_mut()
-                .attach_late_init_metrics(exporter.clone());
+                let exporter: Arc<dyn CoreMeter + 'static> = Arc::new(exporter);
+                core_runtime
+                    .telemetry_mut()
+                    .attach_late_init_metrics(exporter.clone());
 
-            (None, Some(exporter))
-        }
-        None => (None, None),
-    };
+                (None, Some(exporter), None)
+            }
+            Some(BridgeMetricsExporter::Buffer {
+                max_buffer_size,
+                use_seconds_for_durations,
+            }) => {
+                let metrics_call_buffer =
+                    MetricsCallBuffer::new(max_buffer_size, use_seconds_for_durations);
+
+                core_runtime
+                    .telemetry_mut()
+                    .attach_late_init_metrics(metrics_call_buffer.core_buffer.clone());
+
+                (None, None, Some(metrics_call_buffer))
+            }
+            None => (None, None, None),
+        };
 
     // Run the log exporter task, if needed. Created after Runtime since it needs Tokio handle.
     let log_exporter_task = if let BridgeLogExporter::Push { stream, receiver } = logging_options {
@@ -127,6 +152,7 @@ pub fn runtime_new(
         log_exporter_task,
         metrics_exporter_task: prom_metrics_exporter_task.map(Arc::new),
         _otel_metrics_exporter: otel_metrics_exporter,
+        metrics_call_buffer,
     }))
 }
 
@@ -140,6 +166,24 @@ pub fn runtime_shutdown(runtime: OpaqueInboundHandle<Runtime>) -> BridgeResult<(
     Ok(())
 }
 
+/// Retrieve buffered metrics from the runtime.
+///
+/// This function drains the metrics buffer and returns all metric updates that have been
+/// accumulated since the last call to this function.
+#[js_function]
+pub fn runtime_retrieve_buffered_metrics(
+    runtime: OpaqueInboundHandle<Runtime>,
+) -> BridgeResult<Vec<BufferedMetricUpdate>> {
+    let runtime = runtime.borrow()?;
+    let buffer = runtime.metrics_call_buffer.as_ref().ok_or_else(|| {
+        BridgeError::UnexpectedError(
+            "Attempting to retrieve buffered metrics of a runtime without buffer".into(),
+        )
+    })?;
+
+    Ok(buffer.retrieve())
+}
+
 /// Drop will handle the cleanup
 impl MutableFinalize for Runtime {}
 
@@ -223,6 +267,10 @@ impl RuntimeExt for Arc<CoreRuntime> {
 pub enum BridgeMetricsExporter {
     Prometheus(CorePrometheusExporterOptions),
     Otel(CoreOtelCollectorOptions),
+    Buffer {
+        max_buffer_size: usize,
+        use_seconds_for_durations: bool,
+    },
 }
 
 pub enum BridgeLogExporter {
@@ -238,15 +286,12 @@ pub enum BridgeLogExporter {
 mod config {
     use std::{collections::HashMap, net::SocketAddr, sync::Arc, time::Duration};
 
-    use anyhow::Context as _;
-
     use neon::prelude::*;
     use temporalio_common::telemetry::{
         HistogramBucketOverrides, Logger as CoreTelemetryLogger, MetricTemporality,
-        OtelCollectorOptions as CoreOtelCollectorOptions, OtelCollectorOptionsBuilder,
-        OtlpProtocol, PrometheusExporterOptions as CorePrometheusExporterOptions,
-        PrometheusExporterOptionsBuilder, TelemetryOptions as CoreTelemetryOptions,
-        TelemetryOptionsBuilder,
+        OtelCollectorOptions as CoreOtelCollectorOptions, OtlpProtocol,
+        PrometheusExporterOptions as CorePrometheusExporterOptions,
+        TelemetryOptions as CoreTelemetryOptions,
     };
     use temporalio_sdk_core::{Url, telemetry::CoreLogStreamConsumer};
 
@@ -291,6 +336,7 @@ mod config {
     pub(super) enum MetricsExporterOptions {
         Prometheus(PrometheusMetricsExporterConfig),
         Otel(OtelMetricsExporterConfig),
+        Buffer(BufferedMetricsExporterConfig),
     }
 
     #[derive(Debug, Clone, TryFromJs)]
@@ -315,6 +361,12 @@ mod config {
         protocol: StringEncoded<OtlpProtocol>,
     }
 
+    #[derive(Debug, Clone, TryFromJs)]
+    pub(super) struct BufferedMetricsExporterConfig {
+        max_buffer_size: usize,
+        use_seconds_for_durations: bool,
+    }
+
     /// A private newtype so that we can implement `TryFromJs` on simple externally defined enums
     #[derive(Debug, Clone)]
     struct StringEncoded<T>(T);
@@ -360,13 +412,11 @@ mod config {
                 }
             };
 
-            let mut telemetry_options = TelemetryOptionsBuilder::default();
-            let telemetry_options = telemetry_options
+            let telemetry_options = CoreTelemetryOptions::builder()
                 .logging(telemetry_logger)
                 .metric_prefix(telemetry.metric_prefix)
                 .attach_service_name(telemetry.attach_service_name)
-                .build()
-                .context("Failed to build telemetry options")?;
+                .build();
 
             let metrics_exporter = metrics_exporter
                 .map(std::convert::TryInto::try_into)
@@ -389,6 +439,10 @@ mod config {
                     Ok(super::BridgeMetricsExporter::Prometheus(prom.try_into()?))
                 }
                 Self::Otel(otel) => Ok(super::BridgeMetricsExporter::Otel(otel.try_into()?)),
+                Self::Buffer(buffered) => Ok(super::BridgeMetricsExporter::Buffer {
+                    max_buffer_size: buffered.max_buffer_size,
+                    use_seconds_for_durations: buffered.use_seconds_for_durations,
+                }),
             }
         }
     }
@@ -397,8 +451,7 @@ mod config {
         type Error = BridgeError;
 
         fn try_into(self) -> BridgeResult<CorePrometheusExporterOptions> {
-            let mut options = PrometheusExporterOptionsBuilder::default();
-            let options = options
+            let options = CorePrometheusExporterOptions::builder()
                 .socket_addr(self.socket_addr)
                 .counters_total_suffix(self.counters_total_suffix)
                 .unit_suffix(self.unit_suffix)
@@ -407,8 +460,7 @@ mod config {
                     overrides: self.histogram_bucket_overrides,
                 })
                 .global_tags(self.global_tags)
-                .build()
-                .context("Failed to build prometheus exporter options")?;
+                .build();
 
             Ok(options)
         }
@@ -418,8 +470,7 @@ mod config {
         type Error = BridgeError;
 
         fn try_into(self) -> BridgeResult<CoreOtelCollectorOptions> {
-            let mut options = OtelCollectorOptionsBuilder::default();
-            let options = options
+            let options = CoreOtelCollectorOptions::builder()
                 .url(self.url)
                 .protocol(*self.protocol)
                 .headers(self.headers)
@@ -430,8 +481,7 @@ mod config {
                     overrides: self.histogram_bucket_overrides,
                 })
                 .global_tags(self.global_tags)
-                .build()
-                .context("Failed to build otel exporter options")?;
+                .build();
 
             Ok(options)
         }