@temporalio/core-bridge 1.6.0 → 1.7.1

package/sdk-core/core/src/ephemeral_server/mod.rs

@@ -23,6 +23,9 @@ use std::os::unix::fs::OpenOptionsExt;
 use std::process::Stdio;
 
 /// Configuration for Temporalite.
+/// Will be removed eventually as its successor, Temporal CLI matures.
+/// We don't care for the duplication between this struct and [TemporalDevServerConfig] and prefer that over another
+/// abstraction since the existence of this struct is temporary.
 #[derive(Debug, Clone, derive_builder::Builder)]
 pub struct TemporaliteConfig {
     /// Required path to executable or download info.
@@ -59,7 +62,10 @@ impl TemporaliteConfig {
     /// Start a Temporalite server with configurable stdout destination.
     pub async fn start_server_with_output(&self, output: Stdio) -> anyhow::Result<EphemeralServer> {
         // Get exe path
-        let exe_path = self.exe.get_or_download("temporalite").await?;
+        let exe_path = self
+            .exe
+            .get_or_download("temporalite", "temporalite", None)
+            .await?;
 
         // Get free port if not already given
         let port = self.port.unwrap_or_else(|| get_free_port(&self.ip));
@@ -77,6 +83,8 @@ impl TemporaliteConfig {
             self.log.0.clone(),
             "--log-level".to_owned(),
             self.log.1.clone(),
+            "--dynamic-config-value".to_owned(),
+            "frontend.enableServerVersionCheck=false".to_owned(),
         ];
         if let Some(db_filename) = &self.db_filename {
             args.push("--filename".to_owned());
@@ -101,6 +109,89 @@ impl TemporaliteConfig {
     }
 }
 
+/// Configuration for Temporal CLI dev server.
+#[derive(Debug, Clone, derive_builder::Builder)]
+pub struct TemporalDevServerConfig {
+    /// Required path to executable or download info.
+    pub exe: EphemeralExe,
+    /// Namespace to use.
+    #[builder(default = "\"default\".to_owned()")]
+    pub namespace: String,
+    /// IP to bind to.
+    #[builder(default = "\"127.0.0.1\".to_owned()")]
+    pub ip: String,
+    /// Port to use or obtains a free one if none given.
+    #[builder(default)]
+    pub port: Option<u16>,
+    /// Sqlite DB filename if persisting or non-persistent if none.
+    #[builder(default)]
+    pub db_filename: Option<String>,
+    /// Whether to enable the UI.
+    #[builder(default)]
+    pub ui: bool,
+    /// Log format and level
+    #[builder(default = "(\"pretty\".to_owned(), \"warn\".to_owned())")]
+    pub log: (String, String),
+    /// Additional arguments to Temporalite.
+    #[builder(default)]
+    pub extra_args: Vec<String>,
+}
+
+impl TemporalDevServerConfig {
+    /// Start a Temporal CLI dev server.
+    pub async fn start_server(&self) -> anyhow::Result<EphemeralServer> {
+        self.start_server_with_output(Stdio::inherit()).await
+    }
+
+    /// Start a Temporal CLI dev server with configurable stdout destination.
+    pub async fn start_server_with_output(&self, output: Stdio) -> anyhow::Result<EphemeralServer> {
+        // Get exe path
+        let exe_path = self
+            .exe
+            .get_or_download("cli", "temporal", Some("tar.gz"))
+            .await?;
+
+        // Get free port if not already given
+        let port = self.port.unwrap_or_else(|| get_free_port(&self.ip));
+
+        // Build arg set
+        let mut args = vec![
+            "server".to_owned(),
+            "start-dev".to_owned(),
+            "--port".to_owned(),
+            port.to_string(),
+            "--namespace".to_owned(),
+            self.namespace.clone(),
+            "--ip".to_owned(),
+            self.ip.clone(),
+            "--log-format".to_owned(),
+            self.log.0.clone(),
+            "--log-level".to_owned(),
+            self.log.1.clone(),
+            "--dynamic-config-value".to_owned(),
+            "frontend.enableServerVersionCheck=false".to_owned(),
+        ];
+        if let Some(db_filename) = &self.db_filename {
+            args.push("--filename".to_owned());
+            args.push(db_filename.clone());
+        }
+        if !self.ui {
+            args.push("--headless".to_owned());
+        }
+        args.extend(self.extra_args.clone());
+
+        // Start
+        EphemeralServer::start(EphemeralServerConfig {
+            exe_path,
+            port,
+            args,
+            has_test_service: false,
+            output,
+        })
+        .await
+    }
+}
+
 /// Configuration for the test server.
 #[derive(Debug, Clone, derive_builder::Builder)]
 pub struct TestServerConfig {
@@ -123,7 +214,10 @@ impl TestServerConfig {
     /// Start a test server with configurable stdout.
     pub async fn start_server_with_output(&self, output: Stdio) -> anyhow::Result<EphemeralServer> {
         // Get exe path
-        let exe_path = self.exe.get_or_download("temporal-test-server").await?;
+        let exe_path = self
+            .exe
+            .get_or_download("temporal-test-server", "temporal-test-server", None)
+            .await?;
 
         // Get free port if not already given
         let port = self.port.unwrap_or_else(|| get_free_port("0.0.0.0"));
@@ -262,7 +356,7 @@ pub enum EphemeralExe {
 #[derive(Debug, Clone)]
 pub enum EphemeralExeVersion {
     /// Use a default version for the given SDK name and version.
-    Default {
+    SDKDefault {
         /// Name of the SDK to get the default for.
         sdk_name: String,
         /// Version of the SDK to get the default for.
@@ -280,7 +374,12 @@ struct DownloadInfo {
 }
 
 impl EphemeralExe {
-    async fn get_or_download(&self, artifact_name: &str) -> anyhow::Result<PathBuf> {
+    async fn get_or_download(
+        &self,
+        artifact_name: &str,
+        downloaded_name_prefix: &str,
+        preferred_format: Option<&str>,
+    ) -> anyhow::Result<PathBuf> {
         match self {
             EphemeralExe::ExistingPath(exe_path) => {
                 let path = PathBuf::from(exe_path);
@@ -301,12 +400,12 @@ impl EphemeralExe {
                 };
                 // Create dest file based on SDK name/version or fixed version
                 let dest = dest_dir.join(match version {
-                    EphemeralExeVersion::Default {
+                    EphemeralExeVersion::SDKDefault {
                         sdk_name,
                         sdk_version,
-                    } => format!("{artifact_name}-{sdk_name}-{sdk_version}{out_ext}"),
+                    } => format!("{downloaded_name_prefix}-{sdk_name}-{sdk_version}{out_ext}"),
                     EphemeralExeVersion::Fixed(version) => {
-                        format!("{artifact_name}-{version}{out_ext}")
+                        format!("{downloaded_name_prefix}-{version}{out_ext}")
                     }
                 });
                 debug!(
@@ -326,8 +425,11 @@ impl EphemeralExe {
                     other => return Err(anyhow!("Unsupported arch: {}", other)),
                 };
                 let mut get_info_params = vec![("arch", arch), ("platform", platform)];
+                if let Some(format) = preferred_format {
+                    get_info_params.push(("format", format));
+                }
                 let version_name = match version {
-                    EphemeralExeVersion::Default {
+                    EphemeralExeVersion::SDKDefault {
                         sdk_name,
                         sdk_version,
                     } => {

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

@@ -0,0 +1,141 @@
+//! Utilities for and tracking of internal versions which alter history in incompatible ways
+//! so that we can use older code paths for workflows executed on older core versions.
+
+use std::collections::{BTreeSet, HashSet};
+use temporal_sdk_core_protos::temporal::api::{
+    history::v1::WorkflowTaskCompletedEventAttributes, sdk::v1::WorkflowTaskCompletedMetadata,
+    workflowservice::v1::get_system_info_response,
+};
+
+/// This enumeration contains internal flags that may result in incompatible history changes with
+/// older workflows, or other breaking changes.
+///
+/// When a flag has existed long enough the version it was introduced in is no longer supported, it
+/// may be removed from the enum. *Importantly*, all variants must be given explicit values, such
+/// that removing older variants does not create any change in existing values. Removed flag
+/// variants must be reserved forever (a-la protobuf), and should be called out in a comment.
+#[repr(u32)]
+#[derive(PartialEq, Eq, PartialOrd, Ord, Hash, Copy, Clone, Debug)]
+pub(crate) enum CoreInternalFlags {
+    /// In this flag additional checks were added to a number of state machines to ensure that
+    /// the ID and type of activities, local activities, and child workflows match during replay.
+    IdAndTypeDeterminismChecks = 1,
+    /// Introduced automatically upserting search attributes for each patched call, and
+    /// nondeterminism checks for upserts.
+    UpsertSearchAttributeOnPatch = 2,
+    /// We received a value higher than this code can understand.
+    TooHigh = u32::MAX,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub(crate) struct InternalFlags {
+    enabled: bool,
+    core: BTreeSet<CoreInternalFlags>,
+    lang: BTreeSet<u32>,
+    core_since_last_complete: HashSet<CoreInternalFlags>,
+    lang_since_last_complete: HashSet<u32>,
+}
+
+impl InternalFlags {
+    pub fn new(server_capabilities: &get_system_info_response::Capabilities) -> Self {
+        Self {
+            enabled: server_capabilities.sdk_metadata,
+            core: Default::default(),
+            lang: Default::default(),
+            core_since_last_complete: Default::default(),
+            lang_since_last_complete: Default::default(),
+        }
+    }
+
+    pub fn add_from_complete(&mut self, e: &WorkflowTaskCompletedEventAttributes) {
+        if !self.enabled {
+            return;
+        }
+
+        if let Some(metadata) = e.sdk_metadata.as_ref() {
+            self.core.extend(
+                metadata
+                    .core_used_flags
+                    .iter()
+                    .map(|u| CoreInternalFlags::from_u32(*u)),
+            );
+            self.lang.extend(metadata.lang_used_flags.iter());
+        }
+    }
+
+    pub fn add_lang_used(&mut self, flags: impl IntoIterator<Item = u32>) {
+        if !self.enabled {
+            return;
+        }
+
+        self.lang_since_last_complete.extend(flags.into_iter());
+    }
+
+    /// Returns true if this flag may currently be used. If `should_record` is true, always returns
+    /// true and records the flag as being used, for taking later via
+    /// [Self::gather_for_wft_complete].
+    pub fn try_use(&mut self, core_patch: CoreInternalFlags, should_record: bool) -> bool {
+        if !self.enabled {
+            // If the server does not support the metadata field, we must assume we can never use
+            // any internal flags since they can't be recorded for future use
+            return false;
+        }
+
+        if should_record {
+            self.core_since_last_complete.insert(core_patch);
+            true
+        } else {
+            self.core.contains(&core_patch)
+        }
+    }
+
+    /// Wipes the recorded flags used during the current WFT and returns a partially filled
+    /// sdk metadata message that can be combined with any existing data before sending the WFT
+    /// complete
+    pub fn gather_for_wft_complete(&mut self) -> WorkflowTaskCompletedMetadata {
+        WorkflowTaskCompletedMetadata {
+            core_used_flags: self
+                .core_since_last_complete
+                .drain()
+                .map(|p| p as u32)
+                .collect(),
+            lang_used_flags: self.lang_since_last_complete.drain().collect(),
+        }
+    }
+
+    pub fn all_lang(&self) -> &BTreeSet<u32> {
+        &self.lang
+    }
+}
+
+impl CoreInternalFlags {
+    fn from_u32(v: u32) -> Self {
+        match v {
+            1 => Self::IdAndTypeDeterminismChecks,
+            2 => Self::UpsertSearchAttributeOnPatch,
+            _ => Self::TooHigh,
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use temporal_sdk_core_protos::temporal::api::workflowservice::v1::get_system_info_response::Capabilities;
+
+    #[test]
+    fn disabled_in_capabilities_disables() {
+        let mut f = InternalFlags::new(&Capabilities::default());
+        f.add_lang_used([1]);
+        f.add_from_complete(&WorkflowTaskCompletedEventAttributes {
+            sdk_metadata: Some(WorkflowTaskCompletedMetadata {
+                core_used_flags: vec![1],
+                lang_used_flags: vec![],
+            }),
+            ..Default::default()
+        });
+        let gathered = f.gather_for_wft_complete();
+        assert_matches!(gathered.core_used_flags.as_slice(), &[]);
+        assert_matches!(gathered.lang_used_flags.as_slice(), &[]);
+    }
+}

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

@@ -13,6 +13,7 @@ extern crate core;
 
 mod abstractions;
 pub mod ephemeral_server;
+mod internal_flags;
 mod pollers;
 mod protosext;
 pub mod replay;
@@ -43,8 +44,9 @@ pub use worker::{Worker, WorkerConfig, WorkerConfigBuilder};
 use crate::{
     replay::{mock_client_from_histories, Historator, HistoryForReplay},
     telemetry::{
-        metrics::MetricsContext, remove_trace_subscriber_for_current_thread,
-        set_trace_subscriber_for_current_thread, telemetry_init, TelemetryInstance,
+        metrics::{MetricsContext, TemporalMeter},
+        remove_trace_subscriber_for_current_thread, set_trace_subscriber_for_current_thread,
+        telemetry_init, TelemetryInstance,
     },
     worker::client::WorkerClientBag,
 };
@@ -53,7 +55,7 @@ use std::sync::Arc;
 use temporal_client::{ConfiguredClient, TemporalServiceClientWithMetrics};
 use temporal_sdk_core_api::{
     errors::{CompleteActivityError, PollActivityError, PollWfError},
-    telemetry::{CoreTelemetry, TelemetryOptions},
+    telemetry::TelemetryOptions,
     Worker as WorkerTrait,
 };
 use temporal_sdk_core_protos::coresdk::ActivityHeartbeat;
@@ -64,7 +66,7 @@ use temporal_sdk_core_protos::coresdk::ActivityHeartbeat;
 /// After the worker is initialized, you should use [CoreRuntime::tokio_handle] to run the worker's
 /// async functions.
 ///
-/// Lang implementations may pass in a [temporal_client::ConfiguredClient] directly (or a
+/// Lang implementations may pass in a [ConfiguredClient] directly (or a
 /// [RetryClient] wrapping one, or a handful of other variants of the same idea). When they do so,
 /// this function will always overwrite the client retry configuration, force the client to use the
 /// namespace defined in the worker config, and set the client identity appropriately. IE: Use
@@ -99,9 +101,12 @@ where
         worker_config.use_worker_versioning,
     ));
 
-    let metrics = MetricsContext::top_level(worker_config.namespace.clone(), &runtime.telemetry)
-        .with_task_q(worker_config.task_queue.clone());
-    Ok(Worker::new(worker_config, sticky_q, client_bag, metrics))
+    Ok(Worker::new(
+        worker_config,
+        sticky_q,
+        client_bag,
+        Some(&runtime.telemetry),
+    ))
 }
 
 /// Create a worker for replaying a specific history. It will auto-shutdown as soon as the history
@@ -128,7 +133,7 @@ where
     let post_activate = historator.get_post_activate_hook();
     let shutdown_tok = historator.get_shutdown_setter();
     let client = mock_client_from_histories(historator);
-    let mut worker = Worker::new(config, None, Arc::new(client), MetricsContext::no_op());
+    let mut worker = Worker::new(config, None, Arc::new(client), None);
     worker.set_post_activate_hook(post_activate);
     shutdown_tok(worker.shutdown_token());
     Ok(worker)
@@ -260,7 +265,7 @@ impl CoreRuntime {
     }
 
     /// Returns the metric meter used for recording metrics, if they were enabled.
-    pub fn metric_meter(&self) -> Option<&opentelemetry::metrics::Meter> {
+    pub fn metric_meter(&self) -> Option<TemporalMeter> {
         self.telemetry.get_metric_meter()
     }
 

package/sdk-core/core/src/replay/mod.rs

@@ -3,14 +3,16 @@
 //! users during testing.
 
 use crate::{
-    worker::client::{mocks::mock_manual_workflow_client, WorkerClient},
+    worker::{
+        client::{mocks::mock_manual_workflow_client, WorkerClient},
+        PostActivateHookData,
+    },
     Worker,
 };
 use futures::{FutureExt, Stream, StreamExt};
 use once_cell::sync::OnceCell;
 use parking_lot::Mutex;
 use std::{
-    collections::HashMap,
     pin::Pin,
     sync::Arc,
     task::{Context, Poll},
@@ -147,25 +149,18 @@ impl Historator {
 
     /// Returns a callback that can be used as the post-activation hook for a worker to indicate
     /// we're ready to replay the next history, or whatever else.
-    pub(crate) fn get_post_activate_hook(&self) -> impl Fn(&Worker, &str, usize) + Send + Sync {
-        let dat = self.dat.clone();
+    pub(crate) fn get_post_activate_hook(
+        &self,
+    ) -> impl Fn(&Worker, PostActivateHookData) + Send + Sync {
         let done_tx = self.replay_done_tx.clone();
-        move |worker, activated_run_id, last_processed_event| {
-            // We can't hold the lock while evaluating the hook, or we'd deadlock.
-            let last_event_in_hist = dat
-                .lock()
-                .run_id_to_last_event_num
-                .get(activated_run_id)
-                .cloned();
-            if let Some(le) = last_event_in_hist {
-                if last_processed_event >= le {
-                    worker.request_wf_eviction(
-                        activated_run_id,
-                        "Always evict workflows after replay",
-                        EvictionReason::LangRequested,
-                    );
-                    done_tx.send(activated_run_id.to_string()).unwrap();
-                }
+        move |worker, data| {
+            if !data.replaying {
+                worker.request_wf_eviction(
+                    data.run_id,
+                    "Always evict workflows after replay",
+                    EvictionReason::LangRequested,
+                );
+                done_tx.send(data.run_id.to_string()).unwrap();
             }
         }
     }
@@ -184,7 +179,7 @@ impl Stream for Historator {
     fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
         match self.iter.poll_next_unpin(cx) {
             Poll::Ready(Some(history)) => {
-                let run_id = history
+                history
                     .hist
                     .extract_run_id_from_start()
                     .expect(
@@ -192,11 +187,6 @@ impl Stream for Historator {
                                  execution started events",
                     )
                     .to_string();
-                let last_event = history.hist.last_event_id();
-                self.dat
-                    .lock()
-                    .run_id_to_last_event_num
-                    .insert(run_id, last_event as usize);
                 Poll::Ready(Some(history))
             }
             Poll::Ready(None) => {
@@ -210,6 +200,5 @@ impl Stream for Historator {
 
 #[derive(Default)]
 struct HistoratorDat {
-    run_id_to_last_event_num: HashMap<String, usize>,
     all_dispatched: bool,
 }

package/sdk-core/core/src/telemetry/metrics.rs

@@ -10,8 +10,8 @@ use opentelemetry::{
     },
     Context, KeyValue,
 };
-use std::{sync::Arc, time::Duration};
-use temporal_sdk_core_api::telemetry::CoreTelemetry;
+use std::{ops::Deref, sync::Arc, time::Duration};
+use temporal_client::ClientMetricProvider;
 
 /// Used to track context associated with metrics, and record/update them
 ///
@@ -24,6 +24,46 @@ pub(crate) struct MetricsContext {
     instruments: Arc<Instruments>,
 }
 
+/// Wraps OTel's [Meter] to ensure we name our metrics properly, or any other temporal-specific
+/// metrics customizations
+#[derive(derive_more::Constructor)]
+pub struct TemporalMeter<'a> {
+    inner: &'a Meter,
+    metrics_prefix: &'static str,
+}
+
+impl<'a> TemporalMeter<'a> {
+    pub(crate) fn counter(&self, name: &'static str) -> Counter<u64> {
+        self.inner
+            .u64_counter(self.metrics_prefix.to_string() + name)
+            .init()
+    }
+
+    pub(crate) fn histogram(&self, name: &'static str) -> Histogram<u64> {
+        self.inner
+            .u64_histogram(self.metrics_prefix.to_string() + name)
+            .init()
+    }
+}
+
+impl<'a> ClientMetricProvider for TemporalMeter<'a> {
+    fn counter(&self, name: &'static str) -> Counter<u64> {
+        self.counter(name)
+    }
+
+    fn histogram(&self, name: &'static str) -> Histogram<u64> {
+        self.histogram(name)
+    }
+}
+
+impl<'a> Deref for TemporalMeter<'a> {
+    type Target = dyn ClientMetricProvider + 'a;
+
+    fn deref(&self) -> &Self::Target {
+        self as &Self::Target
+    }
+}
+
 struct Instruments {
     wf_completed_counter: Counter<u64>,
     wf_canceled_counter: Counter<u64>,
@@ -54,10 +94,10 @@ impl MetricsContext {
         Self {
             ctx: Default::default(),
             kvs: Default::default(),
-            instruments: Arc::new(Instruments::new_explicit(
+            instruments: Arc::new(Instruments::new_explicit(TemporalMeter::new(
                 &NoopMeterProvider::new().meter("fakemeter"),
                 "fakemetrics",
-            )),
+            ))),
         }
     }
 
@@ -257,42 +297,36 @@ impl Instruments {
             meter
         } else {
             no_op_meter = NoopMeterProvider::default().meter("no_op");
-            &no_op_meter
+            TemporalMeter::new(&no_op_meter, "fakemetrics")
         };
-        Self::new_explicit(meter, telem.metric_prefix)
+        Self::new_explicit(meter)
     }
 
-    fn new_explicit(meter: &Meter, metric_prefix: &'static str) -> Self {
-        let ctr = |name: &'static str| -> Counter<u64> {
-            meter.u64_counter(metric_prefix.to_string() + name).init()
-        };
-        let hst = |name: &'static str| -> Histogram<u64> {
-            meter.u64_histogram(metric_prefix.to_string() + name).init()
-        };
+    fn new_explicit(meter: TemporalMeter) -> Self {
         Self {
-            wf_completed_counter: ctr("workflow_completed"),
-            wf_canceled_counter: ctr("workflow_canceled"),
-            wf_failed_counter: ctr("workflow_failed"),
-            wf_cont_counter: ctr("workflow_continue_as_new"),
-            wf_e2e_latency: hst(WF_E2E_LATENCY_NAME),
-            wf_task_queue_poll_empty_counter: ctr("workflow_task_queue_poll_empty"),
-            wf_task_queue_poll_succeed_counter: ctr("workflow_task_queue_poll_succeed"),
-            wf_task_execution_failure_counter: ctr("workflow_task_queue_poll_failed"),
-            wf_task_sched_to_start_latency: hst(WF_TASK_SCHED_TO_START_LATENCY_NAME),
-            wf_task_replay_latency: hst(WF_TASK_REPLAY_LATENCY_NAME),
-            wf_task_execution_latency: hst(WF_TASK_EXECUTION_LATENCY_NAME),
-            act_poll_no_task: ctr("activity_poll_no_task"),
-            act_task_received_counter: ctr("activity_task_received"),
-            act_execution_failed: ctr("activity_execution_failed"),
-            act_sched_to_start_latency: hst(ACT_SCHED_TO_START_LATENCY_NAME),
-            act_exec_latency: hst(ACT_EXEC_LATENCY_NAME),
+            wf_completed_counter: meter.counter("workflow_completed"),
+            wf_canceled_counter: meter.counter("workflow_canceled"),
+            wf_failed_counter: meter.counter("workflow_failed"),
+            wf_cont_counter: meter.counter("workflow_continue_as_new"),
+            wf_e2e_latency: meter.histogram(WF_E2E_LATENCY_NAME),
+            wf_task_queue_poll_empty_counter: meter.counter("workflow_task_queue_poll_empty"),
+            wf_task_queue_poll_succeed_counter: meter.counter("workflow_task_queue_poll_succeed"),
+            wf_task_execution_failure_counter: meter.counter("workflow_task_execution_failed"),
+            wf_task_sched_to_start_latency: meter.histogram(WF_TASK_SCHED_TO_START_LATENCY_NAME),
+            wf_task_replay_latency: meter.histogram(WF_TASK_REPLAY_LATENCY_NAME),
+            wf_task_execution_latency: meter.histogram(WF_TASK_EXECUTION_LATENCY_NAME),
+            act_poll_no_task: meter.counter("activity_poll_no_task"),
+            act_task_received_counter: meter.counter("activity_task_received"),
+            act_execution_failed: meter.counter("activity_execution_failed"),
+            act_sched_to_start_latency: meter.histogram(ACT_SCHED_TO_START_LATENCY_NAME),
+            act_exec_latency: meter.histogram(ACT_EXEC_LATENCY_NAME),
             // name kept as worker start for compat with old sdk / what users expect
-            worker_registered: ctr("worker_start"),
-            num_pollers: hst(NUM_POLLERS_NAME),
-            task_slots_available: hst(TASK_SLOTS_AVAILABLE_NAME),
-            sticky_cache_hit: ctr("sticky_cache_hit"),
-            sticky_cache_miss: ctr("sticky_cache_miss"),
-            sticky_cache_size: hst(STICKY_CACHE_SIZE_NAME),
+            worker_registered: meter.counter("worker_start"),
+            num_pollers: meter.histogram(NUM_POLLERS_NAME),
+            task_slots_available: meter.histogram(TASK_SLOTS_AVAILABLE_NAME),
+            sticky_cache_hit: meter.counter("sticky_cache_hit"),
+            sticky_cache_miss: meter.counter("sticky_cache_miss"),
+            sticky_cache_size: meter.histogram(STICKY_CACHE_SIZE_NAME),
         }
     }
 }