@temporalio/core-bridge 1.13.2 → 1.14.0

package/sdk-core/{core → crates/sdk-core}/src/pollers/poll_buffer.rs

@@ -6,6 +6,7 @@ use crate::{
         client::{PollActivityOptions, PollOptions, PollWorkflowOptions, WorkerClient},
     },
 };
+use crossbeam_utils::atomic::AtomicCell;
 use futures_util::{FutureExt, StreamExt, future::BoxFuture};
 use governor::{Quota, RateLimiter};
 use std::{
@@ -16,17 +17,20 @@ use std::{
         Arc,
         atomic::{AtomicBool, AtomicUsize, Ordering},
     },
-    time::Duration,
+    time::{Duration, SystemTime},
 };
-use temporal_client::{ERROR_RETURNED_DUE_TO_SHORT_CIRCUIT, NoRetryOnMatching};
-use temporal_sdk_core_api::worker::{
-    ActivitySlotKind, NexusSlotKind, PollerBehavior, SlotKind, WorkflowSlotKind,
+use temporalio_client::{
+    ERROR_RETURNED_DUE_TO_SHORT_CIRCUIT, request_extensions::NoRetryOnMatching,
 };
-use temporal_sdk_core_protos::temporal::api::{
-    taskqueue::v1::PollerScalingDecision,
-    workflowservice::v1::{
-        PollActivityTaskQueueResponse, PollNexusTaskQueueResponse, PollWorkflowTaskQueueResponse,
+use temporalio_common::{
+    protos::temporal::api::{
+        taskqueue::v1::PollerScalingDecision,
+        workflowservice::v1::{
+            PollActivityTaskQueueResponse, PollNexusTaskQueueResponse,
+            PollWorkflowTaskQueueResponse,
+        },
     },
+    worker::{ActivitySlotKind, NexusSlotKind, PollerBehavior, SlotKind, WorkflowSlotKind},
 };
 use tokio::{
     sync::{
@@ -74,9 +78,15 @@ impl LongPollBuffer<PollWorkflowTaskQueueResponse, WorkflowSlotKind> {
         shutdown: CancellationToken,
         num_pollers_handler: Option<impl Fn(usize) + Send + Sync + 'static>,
         options: WorkflowTaskOptions,
+        last_successful_poll_time: Arc<AtomicCell<Option<SystemTime>>>,
     ) -> Self {
         let is_sticky = sticky_queue.is_some();
-        let poll_scaler = PollScaler::new(poller_behavior, num_pollers_handler, shutdown.clone());
+        let poll_scaler = PollScaler::new(
+            poller_behavior,
+            num_pollers_handler,
+            shutdown.clone(),
+            last_successful_poll_time,
+        );
         if let Some(wftps) = options.wft_poller_shared.as_ref() {
             if is_sticky {
                 wftps.set_sticky_active(poll_scaler.active_rx.clone());
@@ -136,6 +146,7 @@ impl LongPollBuffer<PollWorkflowTaskQueueResponse, WorkflowSlotKind> {
 }
 
 impl LongPollBuffer<PollActivityTaskQueueResponse, ActivitySlotKind> {
+    #[allow(clippy::too_many_arguments)]
     pub(crate) fn new_activity_task(
         client: Arc<dyn WorkerClient>,
         task_queue: String,
@@ -144,6 +155,7 @@ impl LongPollBuffer<PollActivityTaskQueueResponse, ActivitySlotKind> {
         shutdown: CancellationToken,
         num_pollers_handler: Option<impl Fn(usize) + Send + Sync + 'static>,
         options: ActivityTaskOptions,
+        last_successful_poll_time: Arc<AtomicCell<Option<SystemTime>>>,
     ) -> Self {
         let pre_permit_delay = options
             .max_worker_acts_per_second
@@ -183,7 +195,12 @@ impl LongPollBuffer<PollActivityTaskQueueResponse, ActivitySlotKind> {
             }
         };
 
-        let poll_scaler = PollScaler::new(poller_behavior, num_pollers_handler, shutdown.clone());
+        let poll_scaler = PollScaler::new(
+            poller_behavior,
+            num_pollers_handler,
+            shutdown.clone(),
+            last_successful_poll_time,
+        );
         Self::new(
             poll_fn,
             permit_dealer,
@@ -196,6 +213,7 @@ impl LongPollBuffer<PollActivityTaskQueueResponse, ActivitySlotKind> {
 }
 
 impl LongPollBuffer<PollNexusTaskQueueResponse, NexusSlotKind> {
+    #[allow(clippy::too_many_arguments)]
     pub(crate) fn new_nexus_task(
         client: Arc<dyn WorkerClient>,
         task_queue: String,
@@ -203,6 +221,8 @@ impl LongPollBuffer<PollNexusTaskQueueResponse, NexusSlotKind> {
         permit_dealer: MeteredPermitDealer<NexusSlotKind>,
         shutdown: CancellationToken,
         num_pollers_handler: Option<impl Fn(usize) + Send + Sync + 'static>,
+        last_successful_poll_time: Arc<AtomicCell<Option<SystemTime>>>,
+        send_heartbeat: bool,
     ) -> Self {
         let no_retry = if matches!(poller_behavior, PollerBehavior::Autoscaling { .. }) {
             Some(NoRetryOnMatching {
@@ -216,11 +236,14 @@ impl LongPollBuffer<PollNexusTaskQueueResponse, NexusSlotKind> {
             let task_queue = task_queue.clone();
             async move {
                 client
-                    .poll_nexus_task(PollOptions {
-                        task_queue,
-                        no_retry,
-                        timeout_override,
-                    })
+                    .poll_nexus_task(
+                        PollOptions {
+                            task_queue,
+                            no_retry,
+                            timeout_override,
+                        },
+                        send_heartbeat,
+                    )
                     .await
             }
         };
@@ -228,7 +251,12 @@ impl LongPollBuffer<PollNexusTaskQueueResponse, NexusSlotKind> {
             poll_fn,
             permit_dealer,
             shutdown.clone(),
-            PollScaler::new(poller_behavior, num_pollers_handler, shutdown),
+            PollScaler::new(
+                poller_behavior,
+                num_pollers_handler,
+                shutdown,
+                last_successful_poll_time,
+            ),
             None::<fn() -> BoxFuture<'static, ()>>,
             None::<fn(&PollNexusTaskQueueResponse)>,
         )
@@ -413,6 +441,7 @@ where
         behavior: PollerBehavior,
         num_pollers_handler: Option<F>,
         shutdown: CancellationToken,
+        last_successful_poll_time: Arc<AtomicCell<Option<SystemTime>>>,
     ) -> Self {
         let (active_tx, active_rx) = watch::channel(0);
         let num_pollers_handler = num_pollers_handler.map(Arc::new);
@@ -433,6 +462,7 @@ where
             ingested_this_period: Default::default(),
             ingested_last_period: Default::default(),
             scale_up_allowed: AtomicBool::new(true),
+            last_successful_poll_time,
         });
         let rhc = report_handle.clone();
         let ingestor_task = if behavior.is_autoscaling() {
@@ -495,6 +525,7 @@ struct PollScalerReportHandle {
     ingested_this_period: AtomicUsize,
     ingested_last_period: AtomicUsize,
     scale_up_allowed: AtomicBool,
+    last_successful_poll_time: Arc<AtomicCell<Option<SystemTime>>>,
 }
 
 impl PollScalerReportHandle {
@@ -502,6 +533,8 @@ impl PollScalerReportHandle {
     fn poll_result(&self, res: &Result<impl TaskPollerResult, tonic::Status>) -> bool {
         match res {
             Ok(res) => {
+                self.last_successful_poll_time
+                    .store(Some(SystemTime::now()));
                 if let PollerBehavior::SimpleMaximum(_) = self.behavior {
                     // We don't do auto-scaling with the simple max
                     return true;
@@ -735,6 +768,7 @@ mod tests {
             WorkflowTaskOptions {
                 wft_poller_shared: Some(Arc::new(WFTPollerShared::new(Some(10)))),
             },
+            Arc::new(AtomicCell::new(None)),
         );
 
         // Poll a bunch of times, "interrupting" it each time, we should only actually have polled
@@ -790,6 +824,7 @@ mod tests {
             WorkflowTaskOptions {
                 wft_poller_shared: Some(Arc::new(WFTPollerShared::new(Some(1)))),
             },
+            Arc::new(AtomicCell::new(None)),
         );
 
         // Should not see error, unwraps should get empty response

package/sdk-core/{core → crates/sdk-core}/src/protosext/mod.rs

@@ -14,7 +14,7 @@ use std::{
     fmt::{Debug, Display, Formatter},
     time::{Duration, SystemTime},
 };
-use temporal_sdk_core_protos::{
+use temporalio_common::protos::{
     constants::{LOCAL_ACTIVITY_MARKER_NAME, PATCH_MARKER_NAME},
     coresdk::{
         activity_result::{activity_execution_result, activity_execution_result::Status},

package/sdk-core/{core → crates/sdk-core}/src/protosext/protocol_messages.rs

@@ -1,6 +1,6 @@
 use anyhow::anyhow;
 use std::collections::HashMap;
-use temporal_sdk_core_protos::temporal::api::{
+use temporalio_common::protos::temporal::api::{
     common::v1::Payload,
     history::v1::{HistoryEvent, history_event},
     protocol::v1::{Message, message::SequencingId},

package/sdk-core/{core → crates/sdk-core}/src/replay/mod.rs

@@ -16,19 +16,21 @@ use std::{
     sync::{Arc, OnceLock},
     task::{Context, Poll},
 };
-use temporal_sdk_core_api::worker::{PollerBehavior, WorkerConfig};
-pub use temporal_sdk_core_protos::{
+pub use temporalio_common::protos::{
     DEFAULT_WORKFLOW_TYPE, HistoryInfo, TestHistoryBuilder, default_wes_attribs,
 };
-use temporal_sdk_core_protos::{
-    coresdk::workflow_activation::remove_from_cache::EvictionReason,
-    temporal::api::{
-        common::v1::WorkflowExecution,
-        history::v1::History,
-        workflowservice::v1::{
-            RespondWorkflowTaskCompletedResponse, RespondWorkflowTaskFailedResponse,
+use temporalio_common::{
+    protos::{
+        coresdk::workflow_activation::remove_from_cache::EvictionReason,
+        temporal::api::{
+            common::v1::WorkflowExecution,
+            history::v1::History,
+            workflowservice::v1::{
+                RespondWorkflowTaskCompletedResponse, RespondWorkflowTaskFailedResponse,
+            },
         },
     },
+    worker::{PollerBehavior, WorkerConfig, WorkerTaskTypes},
 };
 use tokio::sync::{Mutex as TokioMutex, mpsc, mpsc::UnboundedSender};
 use tokio_stream::wrappers::UnboundedReceiverStream;
@@ -60,7 +62,8 @@ where
     pub(crate) fn into_core_worker(mut self) -> Result<Worker, anyhow::Error> {
         self.config.max_cached_workflows = 1;
         self.config.workflow_task_poller_behavior = PollerBehavior::SimpleMaximum(1);
-        self.config.no_remote_activities = true;
+        self.config.task_types = WorkerTaskTypes::workflow_only();
+        self.config.skip_client_worker_set_check = true;
         let historator = Historator::new(self.history_stream);
         let post_activate = historator.get_post_activate_hook();
         let shutdown_tok = historator.get_shutdown_setter();
@@ -114,7 +117,7 @@ where
                 hist_allow_tx.send("Failed".to_string()).unwrap();
                 async move { Ok(RespondWorkflowTaskFailedResponse::default()) }.boxed()
             });
-        let mut worker = Worker::new(self.config, None, Arc::new(client), None, None);
+        let mut worker = Worker::new(self.config, None, Arc::new(client), None, None)?;
         worker.set_post_activate_hook(post_activate);
         shutdown_tok(worker.shutdown_token());
         Ok(worker)

package/sdk-core/{core → crates/sdk-core}/src/retry_logic.rs

@@ -1,5 +1,5 @@
 use std::{num::NonZero, time::Duration};
-use temporal_sdk_core_protos::temporal::api::{
+use temporalio_common::protos::temporal::api::{
     common::v1::RetryPolicy, failure::v1::ApplicationFailureInfo,
 };
 
@@ -71,6 +71,15 @@ impl ValidatedRetryPolicy {
         application_failure: Option<&ApplicationFailureInfo>,
     ) -> Option<Duration> {
         if self.maximum_attempts > 0 && attempt_number.get() >= self.maximum_attempts {
+            #[cfg(feature = "antithesis_assertions")]
+            crate::antithesis::assert_sometimes!(
+                true,
+                "Retry maximum_attempts limit reached",
+                ::serde_json::json!({
+                    "attempt": attempt_number.get(),
+                    "maximum_attempts": self.maximum_attempts
+                })
+            );
             return None;
         }
 
@@ -78,6 +87,15 @@ impl ValidatedRetryPolicy {
             .map(|f| f.non_retryable)
             .unwrap_or_default();
         if non_retryable {
+            #[cfg(feature = "antithesis_assertions")]
+            crate::antithesis::assert_sometimes!(
+                true,
+                "Non-retryable application failure encountered",
+                ::serde_json::json!({
+                    "attempt": attempt_number.get(),
+                    "error_type": application_failure.map(|f| &f.r#type)
+                })
+            );
             return None;
         }
 

package/sdk-core/{core → crates/sdk-core}/src/telemetry/log_export.rs

@@ -2,7 +2,7 @@ use futures_channel::mpsc::{Receiver, Sender, channel};
 use parking_lot::Mutex;
 use ringbuf::{HeapRb, consumer::Consumer, producer::Producer, traits::Split};
 use std::{collections::HashMap, fmt, sync::Arc, time::SystemTime};
-use temporal_sdk_core_api::telemetry::{CoreLog, CoreLogConsumer};
+use temporalio_common::telemetry::{CoreLog, CoreLogConsumer};
 use tracing_subscriber::Layer;
 
 #[derive(Debug)]
@@ -224,7 +224,7 @@ mod tests {
         fmt,
         sync::{Arc, Mutex},
     };
-    use temporal_sdk_core_api::telemetry::{
+    use temporalio_common::telemetry::{
         CoreLog, CoreLogConsumer, CoreTelemetry, Logger, TelemetryOptionsBuilder,
     };
     use tracing::Level;

package/sdk-core/{core → crates/sdk-core}/src/telemetry/metrics.rs

@@ -1,4 +1,6 @@
-use crate::{abstractions::dbg_panic, telemetry::TelemetryInstance};
+#[cfg(test)]
+use crate::TelemetryInstance;
+use crate::abstractions::dbg_panic;
 
 use std::{
     fmt::{Debug, Display},
@@ -6,15 +8,15 @@ use std::{
     sync::Arc,
     time::Duration,
 };
-use temporal_sdk_core_api::telemetry::metrics::{
-    BufferAttributes, BufferInstrumentRef, CoreMeter, Counter, CounterBase, Gauge, GaugeBase,
-    GaugeF64, GaugeF64Base, Histogram, HistogramBase, HistogramDuration, HistogramDurationBase,
-    HistogramF64, HistogramF64Base, LazyBufferInstrument, MetricAttributable, MetricAttributes,
-    MetricCallBufferer, MetricEvent, MetricKeyValue, MetricKind, MetricParameters, MetricUpdateVal,
-    NewAttributes, NoOpCoreMeter,
-};
-use temporal_sdk_core_protos::temporal::api::{
-    enums::v1::WorkflowTaskFailedCause, failure::v1::Failure,
+use temporalio_common::{
+    protos::temporal::api::{enums::v1::WorkflowTaskFailedCause, failure::v1::Failure},
+    telemetry::metrics::{
+        BufferAttributes, BufferInstrumentRef, CoreMeter, Counter, CounterBase, Gauge, GaugeBase,
+        GaugeF64, GaugeF64Base, Histogram, HistogramBase, HistogramDuration, HistogramDurationBase,
+        HistogramF64, HistogramF64Base, LazyBufferInstrument, MetricAttributable, MetricAttributes,
+        MetricCallBufferer, MetricEvent, MetricKeyValue, MetricKind, MetricParameters,
+        MetricUpdateVal, NewAttributes, NoOpCoreMeter, TemporalMeter, WorkerHeartbeatMetrics,
+    },
 };
 
 /// Used to track context associated with metrics, and record/update them
@@ -23,6 +25,7 @@ pub(crate) struct MetricsContext {
     meter: Arc<dyn CoreMeter>,
     kvs: MetricAttributes,
     instruments: Arc<Instruments>,
+    in_memory_metrics: Option<Arc<WorkerHeartbeatMetrics>>,
 }
 
 #[derive(Clone)]
@@ -68,28 +71,41 @@ impl MetricsContext {
     pub(crate) fn no_op() -> Self {
         let meter = Arc::new(NoOpCoreMeter);
         let kvs = meter.new_attributes(Default::default());
-        let instruments = Arc::new(Instruments::new(meter.as_ref()));
+        let in_memory_metrics = Some(Arc::new(WorkerHeartbeatMetrics::default()));
+        let instruments = Arc::new(Instruments::new(meter.as_ref(), in_memory_metrics.clone()));
         Self {
             kvs,
             instruments,
             meter,
+            in_memory_metrics,
         }
     }
 
+    #[cfg(test)]
     pub(crate) fn top_level(namespace: String, tq: String, telemetry: &TelemetryInstance) -> Self {
-        if let Some(mut meter) = telemetry.get_temporal_metric_meter() {
+        MetricsContext::top_level_with_meter(namespace, tq, telemetry.get_temporal_metric_meter())
+    }
+
+    pub(crate) fn top_level_with_meter(
+        namespace: String,
+        tq: String,
+        temporal_meter: Option<TemporalMeter>,
+    ) -> Self {
+        if let Some(mut meter) = temporal_meter {
             meter
                 .default_attribs
                 .attributes
                 .push(MetricKeyValue::new(KEY_NAMESPACE, namespace));
             meter.default_attribs.attributes.push(task_queue(tq));
             let kvs = meter.inner.new_attributes(meter.default_attribs);
-            let mut instruments = Instruments::new(meter.inner.as_ref());
+            let in_memory_metrics = Some(Arc::new(WorkerHeartbeatMetrics::default()));
+            let mut instruments = Instruments::new(meter.inner.as_ref(), in_memory_metrics.clone());
             instruments.update_attributes(&kvs);
             Self {
                 kvs,
                 instruments: Arc::new(instruments),
                 meter: meter.inner,
+                in_memory_metrics,
             }
         } else {
             Self::no_op()
@@ -110,9 +126,14 @@ impl MetricsContext {
             instruments: Arc::new(instruments),
             kvs,
             meter: self.meter.clone(),
+            in_memory_metrics: self.in_memory_metrics.clone(),
         }
     }
 
+    pub(crate) fn in_memory_meter(&self) -> Option<Arc<WorkerHeartbeatMetrics>> {
+        self.in_memory_metrics.clone()
+    }
+
     /// A workflow task queue poll succeeded
     pub(crate) fn wf_tq_poll_ok(&self) {
         self.instruments.wf_task_queue_poll_succeed_counter.adds(1);
@@ -288,7 +309,31 @@ impl MetricsContext {
 }
 
 impl Instruments {
-    fn new(meter: &dyn CoreMeter) -> Self {
+    fn new(meter: &dyn CoreMeter, in_memory: Option<Arc<WorkerHeartbeatMetrics>>) -> Self {
+        let counter_with_in_mem = |params: MetricParameters| -> Counter {
+            in_memory
+                .clone()
+                .and_then(|in_mem| in_mem.get_metric(&params.name))
+                .map(|metric| meter.counter_with_in_memory(params.clone(), metric))
+                .unwrap_or_else(|| meter.counter(params))
+        };
+
+        let gauge_with_in_mem = |params: MetricParameters| -> Gauge {
+            in_memory
+                .clone()
+                .and_then(|in_mem| in_mem.get_metric(&params.name))
+                .map(|metric| meter.gauge_with_in_memory(params.clone(), metric))
+                .unwrap_or_else(|| meter.gauge(params))
+        };
+
+        let histogram_with_in_mem = |params: MetricParameters| -> HistogramDuration {
+            in_memory
+                .clone()
+                .and_then(|in_mem| in_mem.get_metric(&params.name))
+                .map(|metric| meter.histogram_duration_with_in_memory(params.clone(), metric))
+                .unwrap_or_else(|| meter.histogram_duration(params))
+        };
+
         Self {
             wf_completed_counter: meter.counter(MetricParameters {
                 name: "workflow_completed".into(),
@@ -320,12 +365,12 @@ impl Instruments {
                 description: "Count of workflow task queue poll timeouts (no new task)".into(),
                 unit: "".into(),
             }),
-            wf_task_queue_poll_succeed_counter: meter.counter(MetricParameters {
+            wf_task_queue_poll_succeed_counter: counter_with_in_mem(MetricParameters {
                 name: "workflow_task_queue_poll_succeed".into(),
                 description: "Count of workflow task queue poll successes".into(),
                 unit: "".into(),
             }),
-            wf_task_execution_failure_counter: meter.counter(MetricParameters {
+            wf_task_execution_failure_counter: counter_with_in_mem(MetricParameters {
                 name: "workflow_task_execution_failed".into(),
                 description: "Count of workflow task execution failures".into(),
                 unit: "".into(),
@@ -340,7 +385,7 @@ impl Instruments {
                 unit: "duration".into(),
                 description: "Histogram of workflow task replay latencies".into(),
             }),
-            wf_task_execution_latency: meter.histogram_duration(MetricParameters {
+            wf_task_execution_latency: histogram_with_in_mem(MetricParameters {
                 name: WORKFLOW_TASK_EXECUTION_LATENCY_HISTOGRAM_NAME.into(),
                 unit: "duration".into(),
                 description: "Histogram of workflow task execution (not replay) latencies".into(),
@@ -350,12 +395,12 @@ impl Instruments {
                 description: "Count of activity task queue poll timeouts (no new task)".into(),
                 unit: "".into(),
             }),
-            act_task_received_counter: meter.counter(MetricParameters {
+            act_task_received_counter: counter_with_in_mem(MetricParameters {
                 name: "activity_task_received".into(),
                 description: "Count of activity task queue poll successes".into(),
                 unit: "".into(),
             }),
-            act_execution_failed: meter.counter(MetricParameters {
+            act_execution_failed: counter_with_in_mem(MetricParameters {
                 name: "activity_execution_failed".into(),
                 description: "Count of activity task execution failures".into(),
                 unit: "".into(),
@@ -365,7 +410,7 @@ impl Instruments {
                 unit: "duration".into(),
                 description: "Histogram of activity schedule-to-start latencies".into(),
             }),
-            act_exec_latency: meter.histogram_duration(MetricParameters {
+            act_exec_latency: histogram_with_in_mem(MetricParameters {
                 name: ACTIVITY_EXEC_LATENCY_HISTOGRAM_NAME.into(),
                 unit: "duration".into(),
                 description: "Histogram of activity execution latencies".into(),
@@ -386,7 +431,7 @@ impl Instruments {
                 description: "Count of local activity executions that failed".into(),
                 unit: "".into(),
             }),
-            la_exec_latency: meter.histogram_duration(MetricParameters {
+            la_exec_latency: histogram_with_in_mem(MetricParameters {
                 name: "local_activity_execution_latency".into(),
                 unit: "duration".into(),
                 description: "Histogram of local activity execution latencies".into(),
@@ -398,7 +443,7 @@ impl Instruments {
                     "Histogram of local activity execution latencies for successful local activities"
                         .into(),
             }),
-            la_total: meter.counter(MetricParameters {
+            la_total: counter_with_in_mem(MetricParameters {
                 name: "local_activity_total".into(),
                 description: "Count of local activities executed".into(),
                 unit: "".into(),
@@ -418,12 +463,12 @@ impl Instruments {
                 unit: "duration".into(),
                 description: "Histogram of nexus task end-to-end latencies".into(),
             }),
-            nexus_task_execution_latency: meter.histogram_duration(MetricParameters {
+            nexus_task_execution_latency: histogram_with_in_mem(MetricParameters {
                 name: "nexus_task_execution_latency".into(),
                 unit: "duration".into(),
                 description: "Histogram of nexus task execution latencies".into(),
             }),
-            nexus_task_execution_failed: meter.counter(MetricParameters {
+            nexus_task_execution_failed: counter_with_in_mem(MetricParameters {
                 name: "nexus_task_execution_failed".into(),
                 description: "Count of nexus task execution failures".into(),
                 unit: "".into(),
@@ -434,35 +479,34 @@ impl Instruments {
                 description: "Count of the number of initialized workers".into(),
                 unit: "".into(),
             }),
-            num_pollers: meter.gauge(MetricParameters {
+            num_pollers: gauge_with_in_mem(MetricParameters {
                 name: NUM_POLLERS_NAME.into(),
                 description: "Current number of active pollers per queue type".into(),
                 unit: "".into(),
             }),
-            task_slots_available: meter.gauge(MetricParameters {
+            task_slots_available: gauge_with_in_mem(MetricParameters {
                 name: TASK_SLOTS_AVAILABLE_NAME.into(),
                 description: "Current number of available slots per task type".into(),
                 unit: "".into(),
             }),
-            task_slots_used: meter.gauge(MetricParameters {
+            task_slots_used: gauge_with_in_mem(MetricParameters {
                 name: TASK_SLOTS_USED_NAME.into(),
                 description: "Current number of used slots per task type".into(),
                 unit: "".into(),
             }),
-            sticky_cache_hit: meter.counter(MetricParameters {
+            sticky_cache_hit: counter_with_in_mem(MetricParameters {
                 name: "sticky_cache_hit".into(),
                 description: "Count of times the workflow cache was used for a new workflow task"
                     .into(),
                 unit: "".into(),
             }),
-            sticky_cache_miss: meter.counter(MetricParameters {
+            sticky_cache_miss: counter_with_in_mem(MetricParameters {
                 name: "sticky_cache_miss".into(),
                 description:
-                    "Count of times the workflow cache was missing a workflow for a sticky task"
-                        .into(),
+                "Count of times the workflow cache was missing a workflow for a sticky task".into(),
                 unit: "".into(),
             }),
-            sticky_cache_size: meter.gauge(MetricParameters {
+            sticky_cache_size: gauge_with_in_mem(MetricParameters {
                 name: STICKY_CACHE_SIZE_NAME.into(),
                 description: "Current number of cached workflows".into(),
                 unit: "".into(),
@@ -598,6 +642,7 @@ pub(crate) enum FailureReason {
     Timeout,
     NexusOperation(String),
     NexusHandlerError(String),
+    GrpcMessageTooLarge,
 }
 impl Display for FailureReason {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
@@ -607,6 +652,7 @@ impl Display for FailureReason {
             FailureReason::Timeout => "timeout".to_owned(),
             FailureReason::NexusOperation(op) => format!("operation_{op}"),
             FailureReason::NexusHandlerError(op) => format!("handler_error_{op}"),
+            FailureReason::GrpcMessageTooLarge => "GrpcMessageTooLarge".to_owned(),
         };
         write!(f, "{str}")
     }
@@ -1065,7 +1111,7 @@ impl<CM: CoreMeter> CoreMeter for PrefixedMetricsMeter<CM> {
 mod tests {
     use super::*;
     use std::any::Any;
-    use temporal_sdk_core_api::telemetry::{
+    use temporalio_common::telemetry::{
         METRIC_PREFIX,
         metrics::{BufferInstrumentRef, CustomMetricAttributes},
     };
@@ -1104,7 +1150,7 @@ mod tests {
             METRIC_PREFIX.to_string(),
             Some(call_buffer.clone()),
             true,
-            temporal_sdk_core_api::telemetry::TaskQueueLabelStrategy::UseNormal,
+            temporalio_common::telemetry::TaskQueueLabelStrategy::UseNormal,
         );
         let mc = MetricsContext::top_level("foo".to_string(), "q".to_string(), &telem_instance);
         mc.forced_cache_eviction();

package/sdk-core/{core → crates/sdk-core}/src/telemetry/mod.rs

@@ -39,7 +39,7 @@ use std::{
         atomic::{AtomicBool, Ordering},
     },
 };
-use temporal_sdk_core_api::telemetry::{
+use temporalio_common::telemetry::{
     CoreLog, CoreTelemetry, Logger, TaskQueueLabelStrategy, TelemetryOptions,
     TelemetryOptionsBuilder,
     metrics::{CoreMeter, MetricKeyValue, NewAttributes, TemporalMeter},
@@ -55,7 +55,7 @@ const FORWARD_LOG_BUFFER_SIZE: usize = 2048;
 /// traces at `core_level` and all others (from 3rd party modules, etc) at `other_level`.
 pub fn construct_filter_string(core_level: Level, other_level: Level) -> String {
     format!(
-        "{other_level},temporal_sdk_core={core_level},temporal_client={core_level},temporal_sdk={core_level}"
+        "{other_level},temporalio_sdk_core={core_level},temporalio_client={core_level},temporalio_sdk={core_level}"
     )
 }
 
@@ -249,7 +249,7 @@ pub fn telemetry_init(opts: TelemetryOptions) -> Result<TelemetryInstance, anyho
     ))
 }
 
-/// WARNING: Calling can cause panics because of https://github.com/tokio-rs/tracing/issues/1656
+/// WARNING: Calling can cause panics because of <https://github.com/tokio-rs/tracing/issues/1656>
 /// Lang must not start using until resolved
 ///
 /// Initialize telemetry/tracing globally. Useful for testing. Only takes affect when called
@@ -268,7 +268,7 @@ pub fn telemetry_init_global(opts: TelemetryOptions) -> Result<(), anyhow::Error
     Ok(())
 }
 
-/// WARNING: Calling can cause panics because of https://github.com/tokio-rs/tracing/issues/1656
+/// WARNING: Calling can cause panics because of <https://github.com/tokio-rs/tracing/issues/1656>
 /// Lang must not start using until resolved
 ///
 /// Initialize the fallback global handler. All lang SDKs should call this somewhere, once, at

package/sdk-core/{core → crates/sdk-core}/src/telemetry/otel.rs

@@ -22,7 +22,7 @@ use opentelemetry_sdk::{
     },
 };
 use std::{collections::HashMap, sync::Arc, time::Duration};
-use temporal_sdk_core_api::telemetry::{
+use temporalio_common::telemetry::{
     HistogramBucketOverrides, MetricTemporality, OtelCollectorOptions, OtlpProtocol,
     metrics::{
         CoreMeter, Counter, Gauge, GaugeF64, Histogram, HistogramBase, HistogramDuration,