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

package/sdk-core/crates/sdk-core/src/worker/workflow/machines/patch_state_machine.rs

@@ -46,7 +46,7 @@ use temporalio_common::protos::{
             RecordMarkerCommandAttributes, UpsertWorkflowSearchAttributesCommandAttributes,
         },
         common::v1::SearchAttributes,
-        enums::v1::{CommandType, IndexedValueType},
+        enums::v1::CommandType,
     },
 };
 
@@ -141,13 +141,10 @@ pub(super) fn has_change<'a>(
             );
             vec![]
         } else {
-            serialized.metadata.insert(
-                "type".to_string(),
-                IndexedValueType::KeywordList
-                    .as_str_name()
-                    .as_bytes()
-                    .to_vec(),
-            );
+            // "KeywordList" is the expected type for this search attribute
+            serialized
+                .metadata
+                .insert("type".to_string(), "KeywordList".as_bytes().to_vec());
             let indexed_fields = {
                 let mut m = HashMap::new();
                 m.insert(VERSION_SEARCH_ATTR_KEY.to_string(), serialized);

package/sdk-core/crates/sdk-core/src/worker/workflow/machines/upsert_search_attributes_state_machine.rs

@@ -50,11 +50,11 @@ pub(super) fn upsert_search_attrs(
     let has_flag = internal_flags
         .borrow_mut()
         .try_use(CoreInternalFlags::UpsertSearchAttributeOnPatch, !replaying);
-    if has_flag
-        && attribs
-            .search_attributes
-            .contains_key(VERSION_SEARCH_ATTR_KEY)
-    {
+    let contains_version_key = attribs
+        .search_attributes
+        .as_ref()
+        .is_some_and(|sa| sa.indexed_fields.contains_key(VERSION_SEARCH_ATTR_KEY));
+    if has_flag && contains_version_key {
         warn!(
             "Upserting the {VERSION_SEARCH_ATTR_KEY} search attribute directly from workflow code \
              is not permitted and has no effect!"
@@ -63,7 +63,7 @@ pub(super) fn upsert_search_attrs(
         // this.
         create_new(Default::default())
     } else {
-        create_new(attribs.search_attributes.into())
+        create_new(attribs.search_attributes.unwrap_or_default())
     }
 }
 
@@ -186,21 +186,18 @@ mod tests {
         worker::client::mocks::mock_worker_client,
     };
     use std::collections::HashMap;
-    use temporalio_common::{
-        Worker,
-        protos::{
-            coresdk::{
-                AsJsonPayloadExt,
-                workflow_activation::{WorkflowActivationJob, workflow_activation_job},
-                workflow_commands::SetPatchMarker,
-                workflow_completion::WorkflowActivationCompletion,
-            },
-            temporal::api::{
-                command::v1::command::Attributes,
-                common::v1::Payload,
-                enums::v1::EventType,
-                history::v1::{HistoryEvent, UpsertWorkflowSearchAttributesEventAttributes},
-            },
+    use temporalio_common::protos::{
+        coresdk::{
+            AsJsonPayloadExt,
+            workflow_activation::{WorkflowActivationJob, workflow_activation_job},
+            workflow_commands::SetPatchMarker,
+            workflow_completion::WorkflowActivationCompletion,
+        },
+        temporal::api::{
+            command::v1::command::Attributes,
+            common::v1::Payload,
+            enums::v1::EventType,
+            history::v1::{HistoryEvent, UpsertWorkflowSearchAttributesEventAttributes},
         },
     };
 
@@ -318,7 +315,9 @@ mod tests {
         };
         cmds.push(
             UpsertWorkflowSearchAttributes {
-                search_attributes: ver_upsert,
+                search_attributes: Some(SearchAttributes {
+                    indexed_fields: ver_upsert,
+                }),
             }
             .into(),
         );

package/sdk-core/crates/sdk-core/src/worker/workflow/machines/workflow_machines.rs

@@ -13,6 +13,7 @@ use super::{
     workflow_task_state_machine::WorkflowTaskMachine,
 };
 use crate::{
+    WorkerConfig,
     abstractions::dbg_panic,
     internal_flags::{CoreInternalFlags, InternalFlags},
     protosext::{
@@ -66,13 +67,14 @@ use temporalio_common::{
             command::v1::{
                 Command as ProtoCommand, CommandAttributesExt, command::Attributes as ProtoCmdAttrs,
             },
+            common::v1::SearchAttributes,
             enums::v1::EventType,
             history::v1::{HistoryEvent, history_event},
             protocol::v1::{Message as ProtocolMessage, message::SequencingId},
             sdk::v1::{UserMetadata, WorkflowTaskCompletedMetadata},
         },
     },
-    worker::{WorkerConfig, WorkerDeploymentVersion},
+    worker::WorkerDeploymentVersion,
 };
 
 type Result<T, E = WFMachinesError> = std::result::Result<T, E>;
@@ -126,6 +128,10 @@ pub(crate) struct WorkflowMachines {
     history_size_bytes: u64,
     /// Set on each WFT started event
     continue_as_new_suggested: bool,
+    /// Set on each WFT started event
+    suggest_continue_as_new_reasons: Vec<i32>,
+    /// Set on each WFT started event
+    target_worker_deployment_version_changed: bool,
     /// Set if the current WFT is already complete and that completion event had legacy build-id
     /// or a deployment version in it. Will use an empty deployment name if it's legacy build-id.
     current_wft_deployment_info: Option<WorkerDeploymentVersion>,
@@ -290,6 +296,8 @@ impl WorkflowMachines {
             observed_internal_flags: Rc::new(RefCell::new(observed_internal_flags)),
             history_size_bytes: 0,
             continue_as_new_suggested: false,
+            suggest_continue_as_new_reasons: Default::default(),
+            target_worker_deployment_version_changed: false,
             current_wft_deployment_info: None,
             all_machines: Default::default(),
             machine_is_core_created: Default::default(),
@@ -471,6 +479,8 @@ impl WorkflowMachines {
                 .last_sdk_version()
                 .unwrap_or_default()
                 .to_owned(),
+            suggest_continue_as_new_reasons: self.suggest_continue_as_new_reasons.clone(),
+            target_worker_deployment_version_changed: self.target_worker_deployment_version_changed,
         }
     }
 
@@ -635,6 +645,9 @@ impl WorkflowMachines {
         if events.is_empty() {
             self.replaying = false;
         }
+        // Track if we were replaying before processing events. We only want to record replay
+        // latency if we actually did replay work (i.e., started with replaying=true).
+        let was_replaying = self.replaying;
         let replay_start = Instant::now();
 
         if let Some(last_event) = events.last()
@@ -821,7 +834,10 @@ impl WorkflowMachines {
             }
         }
 
-        if !self.replaying {
+        // Only record replay latency if we actually did replay work. This avoids recording
+        // near-zero latencies for the first workflow task (which has no history to replay) or
+        // when there were no events to process.
+        if was_replaying && !self.replaying {
             self.metrics.wf_task_replay_latency(replay_start.elapsed());
         }
 
@@ -885,6 +901,9 @@ impl WorkflowMachines {
         {
             self.history_size_bytes = u64::try_from(attrs.history_size_bytes).unwrap_or_default();
             self.continue_as_new_suggested = attrs.suggest_continue_as_new;
+            self.suggest_continue_as_new_reasons = attrs.suggest_continue_as_new_reasons.clone();
+            self.target_worker_deployment_version_changed =
+                attrs.target_worker_deployment_version_changed;
         }
 
         if let Some(initial_cmd_id) = event.get_initial_command_event_id() {
@@ -1637,8 +1656,13 @@ impl WorkflowMachines {
                 attrs.retry_policy.clone_from(&started_info.retry_policy);
             }
         }
-        if attrs.search_attributes.is_empty() {
-            attrs.search_attributes = self.drive_me.get_current_search_attributes();
+        if attrs.search_attributes.is_none() {
+            let current = self.drive_me.get_current_search_attributes();
+            if !current.is_empty() {
+                attrs.search_attributes = Some(SearchAttributes {
+                    indexed_fields: current,
+                });
+            }
         }
         attrs
     }

package/sdk-core/crates/sdk-core/src/worker/workflow/managed_run.rs

@@ -1,11 +1,11 @@
 use crate::{
-    MetricsContext,
+    MetricsContext, WorkerConfig,
     abstractions::dbg_panic,
     internal_flags::CoreInternalFlags,
     protosext::{WorkflowActivationExt, protocol_messages::IncomingProtocolMessage},
     telemetry::metrics,
     worker::{
-        LEGACY_QUERY_ID, LocalActRequest,
+        LEGACY_QUERY_ID, LocalActRequest, WorkflowErrorType,
         workflow::{
             ActivationAction, ActivationCompleteOutcome, ActivationCompleteResult,
             ActivationOrAuto, BufferedTasks, DrivenWorkflow, EvictionRequestResult,
@@ -28,25 +28,20 @@ use std::{
     sync::{Arc, mpsc::Sender},
     time::{Duration, Instant},
 };
-use temporalio_common::{
-    errors::WorkflowErrorType,
-    protos::{
-        TaskToken,
-        coresdk::{
-            workflow_activation::{
-                WorkflowActivation, create_evict_activation, query_to_job,
-                remove_from_cache::EvictionReason, workflow_activation_job,
-            },
-            workflow_commands::{FailWorkflowExecution, QueryResult},
-            workflow_completion,
-        },
-        temporal::api::{
-            command::v1::command::Attributes as CmdAttribs,
-            enums::v1::{VersioningBehavior, WorkflowTaskFailedCause},
-            failure::v1::Failure,
+use temporalio_common::protos::{
+    TaskToken,
+    coresdk::{
+        workflow_activation::{
+            WorkflowActivation, create_evict_activation, query_to_job,
+            remove_from_cache::EvictionReason, workflow_activation_job,
         },
+        workflow_commands::{FailWorkflowExecution, QueryResult},
+        workflow_completion,
+    },
+    temporal::api::{
+        enums::v1::{VersioningBehavior, WorkflowTaskFailedCause},
+        failure::v1::Failure,
     },
-    worker::WorkerConfig,
 };
 use tokio::sync::oneshot;
 use tracing::Span;
@@ -191,6 +186,7 @@ impl ManagedRun {
             attempt = %work.attempt,
             "Applying new workflow task from server"
         );
+        let is_incremental = work.is_incremental();
         let wft_info = WorkflowTaskInfo {
             attempt: work.attempt,
             task_token: work.task_token,
@@ -239,7 +235,9 @@ impl ManagedRun {
 
         // The update field is only populated in the event we hit the cache
         let activation = if work.update.is_real() {
-            self.metrics.sticky_cache_hit();
+            if is_incremental {
+                self.metrics.sticky_cache_hit();
+            }
             self.wfm.new_work_from_server(work.update, work.messages)?
         } else {
             let r = self.wfm.get_next_activation()?;
@@ -440,6 +438,7 @@ impl ManagedRun {
                     action: ActivationAction::RespondLegacyQuery {
                         result: Box::new(qr),
                     },
+                    metrics: self.metrics.clone(),
                 }),
                 resp_chan,
             );
@@ -1127,27 +1126,6 @@ impl ManagedRun {
                 )
             };
 
-            // Record metrics for any outgoing terminal commands
-            for cmd in commands.iter() {
-                match cmd.attributes.as_ref() {
-                    Some(CmdAttribs::CompleteWorkflowExecutionCommandAttributes(_)) => {
-                        self.metrics.wf_completed();
-                    }
-                    Some(CmdAttribs::FailWorkflowExecutionCommandAttributes(attrs)) => {
-                        if metrics::should_record_failure_metric(&attrs.failure) {
-                            self.metrics.wf_failed();
-                        }
-                    }
-                    Some(CmdAttribs::ContinueAsNewWorkflowExecutionCommandAttributes(_)) => {
-                        self.metrics.wf_continued_as_new();
-                    }
-                    Some(CmdAttribs::CancelWorkflowExecutionCommandAttributes(_)) => {
-                        self.metrics.wf_canceled();
-                    }
-                    _ => (),
-                }
-            }
-
             let attempt = self.wft.as_ref().map(|t| t.info.attempt).unwrap_or(1);
             ActivationCompleteOutcome::ReportWFTSuccess(ServerCommandsWithWorkflowInfo {
                 task_token: data.task_token,
@@ -1160,6 +1138,7 @@ impl ManagedRun {
                     versioning_behavior: data.versioning_behavior,
                     attempt,
                 },
+                metrics: self.metrics.clone(),
             })
         } else {
             ActivationCompleteOutcome::DoNothing

package/sdk-core/crates/sdk-core/src/worker/workflow/mod.rs

@@ -15,7 +15,7 @@ pub(crate) use driven_workflow::DrivenWorkflow;
 pub(crate) use history_update::HistoryUpdate;
 
 use crate::{
-    MetricsContext,
+    MetricsContext, WorkerConfig,
     abstractions::{
         MeteredPermitDealer, TrackedOwnedMeteredSemPermit, UsedMeteredSemPermit, dbg_panic,
         take_cell::TakeCell,
@@ -26,11 +26,10 @@ use crate::{
     telemetry::{
         VecDisplayer,
         metrics::{self, FailureReason},
-        set_trace_subscriber_for_current_thread,
     },
     worker::{
-        LocalActRequest, LocalActivityExecutionResult, LocalActivityResolution,
-        PostActivateHookData,
+        ActivitySlotKind, CompleteWfError, LocalActRequest, LocalActivityExecutionResult,
+        LocalActivityResolution, PollError, PostActivateHookData, WorkflowSlotKind,
         activities::{ActivitiesFromWFTsHandle, LocalActivityManager},
         client::{LegacyQueryResult, WorkerClient, WorkflowTaskCompletion},
         workflow::{
@@ -61,7 +60,6 @@ use std::{
 };
 use temporalio_client::MESSAGE_TOO_LARGE_KEY;
 use temporalio_common::{
-    errors::{CompleteWfError, PollError},
     protos::{
         TaskToken,
         coresdk::{
@@ -88,7 +86,7 @@ use temporalio_common::{
             workflowservice::v1::{PollActivityTaskQueueResponse, get_system_info_response},
         },
     },
-    worker::{ActivitySlotKind, WorkerConfig, WorkflowSlotKind},
+    telemetry::set_trace_subscriber_for_current_thread,
 };
 use tokio::{
     sync::{
@@ -98,8 +96,7 @@ use tokio::{
     task::{LocalSet, spawn_blocking},
 };
 use tokio_stream::wrappers::UnboundedReceiverStream;
-use tokio_util::either::Either;
-use tokio_util::sync::CancellationToken;
+use tokio_util::{either::Either, sync::CancellationToken};
 use tracing::{Span, Subscriber};
 
 /// Id used by server for "legacy" queries. IE: Queries that come in the `query` rather than
@@ -355,6 +352,7 @@ impl Workflows {
                         mut versioning_behavior,
                         attempt,
                     },
+                metrics: run_metrics,
             } => {
                 let reserved_act_permits =
                     self.reserve_activity_slots_for_outgoing_commands(commands.as_mut_slice());
@@ -372,6 +370,7 @@ impl Workflows {
                     } else {
                         0
                     };
+                let mut maybe_record_terminal_metric = detect_terminal_command(&commands);
                 let mut completion = WorkflowTaskCompletion {
                     task_token: task_token.clone(),
                     commands,
@@ -398,6 +397,9 @@ impl Workflows {
                 self.handle_wft_reporting_errs(run_id, || async {
                     match self.client.complete_workflow_task(completion).await {
                         Ok(response) => {
+                            if let Some(record) = maybe_record_terminal_metric.take() {
+                                record(&run_metrics);
+                            }
                             if response.reset_history_event_id > 0 {
                                 reset_last_started_to = Some(response.reset_history_event_id);
                             }
@@ -460,6 +462,7 @@ impl Workflows {
             ServerCommandsWithWorkflowInfo {
                 task_token,
                 action: ActivationAction::RespondLegacyQuery { result },
+                ..
             } => {
                 self.respond_legacy_query(task_token, LegacyQueryResult::Succeeded(*result))
                     .await;
@@ -1008,10 +1011,18 @@ enum FailedActivationWFTReport {
     ReportLegacyQueryFailure(TaskToken, Failure),
 }
 
-#[derive(Debug)]
 struct ServerCommandsWithWorkflowInfo {
     task_token: TaskToken,
     action: ActivationAction,
+    metrics: MetricsContext,
+}
+impl Debug for ServerCommandsWithWorkflowInfo {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("ServerCommandsWithWorkflowInfo")
+            .field("task_token", &self.task_token)
+            .field("action", &self.action)
+            .finish()
+    }
 }
 
 #[derive(Debug)]
@@ -1031,6 +1042,7 @@ pub(crate) enum ActivationAction {
 }
 
 #[derive(Debug)]
+#[allow(clippy::large_enum_variant)]
 enum EvictionRequestResult {
     EvictionRequested(Option<u32>, RunUpdateAct),
     NotFound,
@@ -1046,6 +1058,35 @@ impl EvictionRequestResult {
     }
 }
 
+#[allow(clippy::type_complexity)]
+fn detect_terminal_command(
+    commands: &[ProtoCommand],
+) -> Option<Box<dyn FnOnce(&MetricsContext) + Send>> {
+    for cmd in commands {
+        match cmd.attributes.as_ref() {
+            Some(Attributes::CompleteWorkflowExecutionCommandAttributes(_)) => {
+                return Some(Box::new(|m: &MetricsContext| m.wf_completed()));
+            }
+            Some(Attributes::FailWorkflowExecutionCommandAttributes(attrs)) => {
+                let should_record = metrics::should_record_failure_metric(&attrs.failure);
+                return Some(Box::new(move |m: &MetricsContext| {
+                    if should_record {
+                        m.wf_failed();
+                    }
+                }));
+            }
+            Some(Attributes::ContinueAsNewWorkflowExecutionCommandAttributes(_)) => {
+                return Some(Box::new(|m: &MetricsContext| m.wf_continued_as_new()));
+            }
+            Some(Attributes::CancelWorkflowExecutionCommandAttributes(_)) => {
+                return Some(Box::new(|m: &MetricsContext| m.wf_canceled()));
+            }
+            _ => {}
+        }
+    }
+    None
+}
+
 #[derive(Debug)]
 #[allow(dead_code)] // Not always used in non-test
 pub(crate) struct WorkflowStateInfo {

package/sdk-core/crates/sdk-core/src/worker/workflow/run_cache.rs

@@ -1,5 +1,5 @@
 use crate::{
-    MetricsContext,
+    MetricsContext, WorkerConfig,
     telemetry::metrics::workflow_type,
     worker::workflow::{
         HistoryUpdate, LocalActivityRequestSink, PermittedWFT, RequestEvictMsg, RunBasics,
@@ -8,12 +8,9 @@ use crate::{
 };
 use lru::LruCache;
 use std::{num::NonZeroUsize, rc::Rc, sync::Arc};
-use temporalio_common::{
-    protos::{
-        coresdk::workflow_activation::remove_from_cache::EvictionReason,
-        temporal::api::workflowservice::v1::get_system_info_response,
-    },
-    worker::WorkerConfig,
+use temporalio_common::protos::{
+    coresdk::workflow_activation::remove_from_cache::EvictionReason,
+    temporal::api::workflowservice::v1::get_system_info_response,
 };
 
 pub(super) struct RunCache {

package/sdk-core/crates/sdk-core/src/worker/workflow/wft_extraction.rs

@@ -2,6 +2,7 @@ use crate::{
     abstractions::OwnedMeteredSemPermit,
     protosext::ValidPollWFTQResponse,
     worker::{
+        WorkflowSlotKind,
         client::WorkerClient,
         workflow::{
             CacheMissFetchReq, HistoryUpdate, NextPageReq, PermittedWFT,
@@ -11,10 +12,7 @@ use crate::{
 };
 use futures_util::{FutureExt, Stream, StreamExt, stream, stream::PollNext};
 use std::{future, sync::Arc};
-use temporalio_common::{
-    protos::{TaskToken, coresdk::WorkflowSlotInfo},
-    worker::WorkflowSlotKind,
-};
+use temporalio_common::protos::{TaskToken, coresdk::WorkflowSlotInfo};
 use tracing::Span;
 
 /// Transforms incoming validated WFTs and history fetching requests into [PermittedWFT]s ready

package/sdk-core/crates/sdk-core/src/worker/workflow/wft_poller.rs

@@ -1,21 +1,18 @@
 use crate::{
-    MetricsContext,
+    MetricsContext, WorkerConfig,
     abstractions::{MeteredPermitDealer, OwnedMeteredSemPermit},
     pollers::{BoxedWFPoller, LongPollBuffer, Poller, WorkflowTaskOptions, WorkflowTaskPoller},
     protosext::ValidPollWFTQResponse,
     telemetry::metrics::{workflow_poller, workflow_sticky_poller},
-    worker::{client::WorkerClient, wft_poller_behavior},
+    worker::{WorkflowSlotKind, client::WorkerClient, wft_poller_behavior},
 };
 use crossbeam_utils::atomic::AtomicCell;
 use futures_util::{Stream, stream};
 use std::{
-    sync::{Arc, OnceLock},
+    sync::{Arc, OnceLock, atomic::AtomicBool},
     time::SystemTime,
 };
-use temporalio_common::{
-    protos::temporal::api::workflowservice::v1::PollWorkflowTaskQueueResponse,
-    worker::{WorkerConfig, WorkflowSlotKind},
-};
+use temporalio_common::protos::temporal::api::workflowservice::v1::PollWorkflowTaskQueueResponse;
 use tokio::sync::watch;
 use tokio_util::sync::CancellationToken;
 
@@ -29,6 +26,7 @@ pub(crate) fn make_wft_poller(
     wft_slots: &MeteredPermitDealer<WorkflowSlotKind>,
     last_successful_poll_time: Arc<AtomicCell<Option<SystemTime>>>,
     sticky_last_successful_poll_time: Arc<AtomicCell<Option<SystemTime>>>,
+    graceful_poll_shutdown: Arc<AtomicBool>,
 ) -> impl Stream<
     Item = Result<
         (
@@ -62,6 +60,7 @@ pub(crate) fn make_wft_poller(
             wft_poller_shared: wft_poller_shared.clone(),
         },
         last_successful_poll_time,
+        graceful_poll_shutdown.clone(),
     );
     let sticky_queue_poller = sticky_queue_name.as_ref().map(|sqn| {
         let sticky_metrics = metrics.with_new_attrs([workflow_sticky_poller()]);
@@ -77,6 +76,7 @@ pub(crate) fn make_wft_poller(
             }),
             WorkflowTaskOptions { wft_poller_shared },
             sticky_last_successful_poll_time,
+            graceful_poll_shutdown,
         )
     });
     let wf_task_poll_buffer = Box::new(WorkflowTaskPoller::new(
@@ -258,11 +258,10 @@ mod tests {
     use super::*;
     use crate::{
         abstractions::tests::fixed_size_permit_dealer, pollers::MockPermittedPollBuffer,
-        test_help::mock_poller,
+        test_help::mock_poller, worker::WorkflowSlotKind,
     };
     use futures_util::{StreamExt, pin_mut};
     use std::sync::Arc;
-    use temporalio_common::worker::WorkflowSlotKind;
 
     #[tokio::test]
     async fn poll_timeouts_do_not_produce_responses() {

package/sdk-core/crates/sdk-core/src/worker/workflow/workflow_stream.rs

@@ -10,9 +10,7 @@ use crate::{
 };
 use futures_util::{Stream, StreamExt, stream, stream::PollNext};
 use std::{collections::VecDeque, fmt::Debug, future, sync::Arc};
-use temporalio_common::{
-    errors::PollError, protos::coresdk::workflow_activation::remove_from_cache::EvictionReason,
-};
+use temporalio_common::protos::coresdk::workflow_activation::remove_from_cache::EvictionReason;
 use tokio_util::sync::CancellationToken;
 use tracing::{Level, Span};
 

package/sdk-core/crates/sdk-core/tests/activities_procmacro.rs

@@ -0,0 +1,6 @@
+#[test]
+fn activities_procmacro_build_tests() {
+    let t = trybuild::TestCases::new();
+    t.pass("tests/activities_trybuild/*_pass.rs");
+    t.compile_fail("tests/activities_trybuild/*_fail.rs");
+}

package/sdk-core/crates/sdk-core/tests/activities_trybuild/basic_pass.rs

@@ -0,0 +1,54 @@
+use std::sync::Arc;
+use temporalio_macros::activities;
+use temporalio_sdk::activities::{ActivityContext, ActivityError};
+
+pub struct MyActivities;
+
+#[activities]
+impl MyActivities {
+    #[activity]
+    pub async fn static_activity(
+        _ctx: ActivityContext,
+        _in: String,
+    ) -> Result<String, ActivityError> {
+        Ok("Can be static".to_string())
+    }
+
+    #[activity]
+    pub async fn activity(
+        self: Arc<Self>,
+        _ctx: ActivityContext,
+        _in: bool,
+    ) -> Result<String, ActivityError> {
+        Ok("I'm done!".to_string())
+    }
+
+    #[activity]
+    pub async fn activity_arc_fully_qualified(
+        self: std::sync::Arc<Self>,
+        _ctx: ActivityContext,
+        _in: bool,
+    ) -> Result<String, ActivityError> {
+        Ok("I'm done!".to_string())
+    }
+
+    #[activity]
+    pub fn sync_activity(_ctx: ActivityContext, _in: bool) -> Result<String, ActivityError> {
+        Ok("Sync activities are supported too".to_string())
+    }
+}
+
+pub struct MyActivitiesStatic;
+
+#[activities]
+impl MyActivitiesStatic {
+    #[activity]
+    pub async fn static_activity(
+        _ctx: ActivityContext,
+        _in: String,
+    ) -> Result<String, ActivityError> {
+        Ok("Can be static".to_string())
+    }
+}
+
+fn main() {}

package/sdk-core/crates/sdk-core/tests/activities_trybuild/invalid_self_type_fail.rs

@@ -0,0 +1,18 @@
+use temporalio_macros::activities;
+
+pub struct BadActivities;
+
+#[activities]
+impl BadActivities {
+    #[activity]
+    pub async fn no_context(
+        &self,
+        _ctx: ActivityContext,
+        _in: String,
+    ) -> Result<String, ActivityError> {
+        // This should fail because the self type is invalid.
+        Ok("bad".to_string())
+    }
+}
+
+fn main() {}

package/sdk-core/crates/sdk-core/tests/activities_trybuild/invalid_self_type_fail.stderr

@@ -0,0 +1,5 @@
+error: Activity methods with instance state must use `self: Arc<Self>` as the receiver, not `self`, `&self`, or `&mut self`
+ --> tests/activities_trybuild/invalid_self_type_fail.rs:9:9
+  |
+9 |         &self,
+  |         ^^^^^

package/sdk-core/crates/sdk-core/tests/activities_trybuild/missing_context_fail.rs

@@ -0,0 +1,14 @@
+use temporalio_macros::activities;
+
+pub struct BadActivities;
+
+#[activities]
+impl BadActivities {
+    #[activity]
+    pub async fn no_context(_in: String) -> Result<String, ActivityError> {
+        // This should fail because there's no ActivityContext parameter
+        Ok("bad".to_string())
+    }
+}
+
+fn main() {}