chore: update Rust docs to reflect 0.7.0 release (#5132)

* chore: update Rust docs to reflect 0.7.0 release

* self review

---------

Co-authored-by: Milecia McG <47196133+flippedcoder@users.noreply.github.com>

Author: chris-olszewski

docs/develop/rust/activities/basics.mdx

@@ -72,7 +72,7 @@ struct SleeperActivities {
 #[activities]
 impl SleeperActivities {
     #[activity]
-    async fn sleeper(
+    pub async fn sleeper(
         self: Arc<Self>,
         ctx: ActivityContext,
         _: String,
@@ -144,7 +144,9 @@ impl MyActivities {
 
         // If an error should not be retried
         if input.len() > 1000000 {
-            return Err(ApplicationFailure::non_retryable("Input too large").into());
+            return Err(
+                ApplicationFailure::non_retryable("Input too large").into(),
+            );
         }
 
         let result = ProcessedData {

docs/develop/rust/activities/execution.mdx

@@ -26,7 +26,7 @@ Be mindful of the size of data passed to and from Activities. Otherwise, there a
 
 To spawn an Activity Execution, use the Workflow context’s Activity execution APIs within your Workflow code.
 
-In Rust, Activities are typically executed using `ctx.start_activity(...)`, which returns a `Future` that can be awaited.
+In Rust, Activities are typically executed using `ctx.execute_activity(...)`, which returns a `Future` that can be awaited.
 
 ```rust
 #[workflow_methods]
@@ -35,11 +35,13 @@ impl GreetingWorkflow {
     pub async fn run(ctx: &mut WorkflowContext<Self>) -> WorkflowResult<String> {
         let name = ctx.state(|s| s.name.clone());
         // Execute an activity
-        let greeting = ctx.start_activity(
-            MyActivities::greet,
-            name,
-            ActivityOptions::start_to_close_timeout(Duration::from_secs(30)),
-        ).await?;
+        let greeting = ctx
+            .execute_activity(
+                MyActivities::greet,
+                name,
+                ActivityOptions::start_to_close_timeout(Duration::from_secs(30)),
+            )
+            .await?;
 
         println!("{}", greeting);
 
@@ -74,11 +76,13 @@ impl GreetingWorkflow {
     pub async fn run(ctx: &mut WorkflowContext<Self>) -> WorkflowResult<String> {
         let name = ctx.state(|s| s.name.clone());
         // Execute an activity
-        let greeting = ctx.start_activity(
-            MyActivities::greet,
-            name,
-            ActivityOptions::schedule_to_close_timeout(Duration::from_secs(30))
-        ).await?;
+        let greeting = ctx
+            .execute_activity(
+                MyActivities::greet,
+                name,
+                ActivityOptions::schedule_to_close_timeout(Duration::from_secs(30)),
+            )
+            .await?;
 
         println!("{}", greeting);
         Ok(greeting)
@@ -106,11 +110,13 @@ impl GreetingWorkflow {
     pub async fn run(ctx: &mut WorkflowContext<Self>) -> WorkflowResult<String> {
         let name = ctx.state(|s| s.name.clone());
         // Execute an activity
-        let greeting = ctx.start_activity(
-            MyActivities::greet,
-            name,
-            ActivityOptions::start_to_close_timeout(Duration::from_secs(30))
-        ).await?;
+        let greeting = ctx
+            .execute_activity(
+                MyActivities::greet,
+                name,
+                ActivityOptions::start_to_close_timeout(Duration::from_secs(30)),
+            )
+            .await?;
 
         println!("{}", greeting);
         Ok(greeting)
@@ -127,20 +133,22 @@ use temporalio_sdk::workflows::join;
 pub async fn run(ctx: &mut WorkflowContext<Self>) -> WorkflowResult<String> {
     let name = ctx.state(|s| s.name.clone());
     // Execute an activity
-    let greeting = ctx.start_activity(
+    let greeting = ctx.execute_activity(
         MyActivities::greet,
         name,
-        ActivityOptions::start_to_close_timeout(Duration::from_secs(30))
+        ActivityOptions::start_to_close_timeout(Duration::from_secs(30)),
     );
 
-    let language = ctx.start_activity(
+    let language = ctx.execute_activity(
         MyActivities::call_greeting_service,
         ActivityLanguages::English,
-        ActivityOptions::start_to_close_timeout(Duration::from_secs(30))
+        ActivityOptions::start_to_close_timeout(Duration::from_secs(30)),
     );
 
     // Run in parallel
     let (greeting_res, language_res) = join!(greeting, language);
+
+    Ok(format!("{} ({})", greeting_res?, language_res?))
 }
 ```
 

docs/develop/rust/activities/timeouts.mdx

@@ -38,12 +38,12 @@ Available timeout fields include:
 - `start_to_close_timeout`
 
 ```rust
-let greeting = ctx.start_activity(
+let greeting = ctx.execute_activity(
     MyActivities::greet,
     name,
-    ActivityOptions::start_to_close_timeout(Duration::from_secs(30))
-);
-````
+    ActivityOptions::start_to_close_timeout(Duration::from_secs(30)),
+).await?;
+```
 
 ### Set an Activity Retry Policy {/* #activity-retries */}
 
@@ -52,20 +52,21 @@ A Retry Policy works together with timeouts to provide fine-grained control over
 In Rust, configure the Retry Policy as part of the Activity options when scheduling the Activity from Workflow code. Because the Rust SDK API is still evolving, treat the following as representative of the current style rather than a guaranteed stable surface.
 
 ```rust
-let language = ctx.start_activity(
+let language = ctx.execute_activity(
     MyActivities::call_greeting_service,
     ActivityLanguages::English,
     ActivityOptions::with_start_to_close_timeout(Duration::from_secs(30))
         .retry_policy(
-            RetryPolicy {
-                initial_interval: Some(prost_dur!(from_secs(10))), 
-                backoff_coefficient: 2.0, 
-                maximum_interval: Some(prost_dur!(from_secs(100))), 
-                maximum_attempts: 5, 
-                non_retryable_error_types: vec!["NonRetryableError".to_string()]
-            }
-        ).build()
-    );
+            RetryPolicy::builder()
+                .initial_interval(Duration::from_secs(10))
+                .backoff_coefficient(2.0)
+                .maximum_interval(Duration::from_secs(100))
+                .maximum_attempts(5)
+                .non_retryable_error_types(["NonRetryableError"])
+                .build(),
+        )
+        .build(),
+).await?;
 ```
 
 ### Override the retry interval with `explicit_delay` {/* #next-retry-delay */}
@@ -75,12 +76,12 @@ To override the next retry interval set by the current policy, return a failure
 For example, you can increase the delay linearly with each attempt instead of using the exponential backoff defined by a backoff coefficient:
 
 ```rust
-use temporalio_macros::{activities};
+use temporalio_macros::activities;
 use temporalio_sdk::{
     ApplicationFailure,
     activities::{ActivityContext, ActivityError},
 };
-use std::sync::{Arc, atomic::{AtomicUsize, Ordering}};
+use std::sync::atomic::AtomicUsize;
 
 struct TestGreetActivities {
     counter: AtomicUsize,
@@ -114,7 +115,8 @@ To heartbeat an Activity in Rust, call the heartbeat API from inside the Activit
 
 ```rust
 pub async fn greet(ctx: ActivityContext, name: String) -> Result<String, ActivityError> {
-    ctx.record_heartbeat(vec!["greet activity started".into()]);
+    ctx.record_heartbeat("greet activity started".to_string())
+        .await?;
 
     if name == "ziggy" {
         return Err(ApplicationFailure::new("Ziggy is not a valid name").into());
@@ -129,11 +131,11 @@ pub async fn greet(ctx: ActivityContext, name: String) -> Result<String, Activit
 A [Heartbeat Timeout](/encyclopedia/detecting-activity-failures#heartbeat-timeout) works together with Activity heartbeats and sets the maximum time allowed between heartbeats. Configure it as part of the Activity options when scheduling the Activity.
 
 ```rust
-let language = ctx.start_activity(
+let language = ctx.execute_activity(
     MyActivities::call_greeting_service,
     ActivityLanguages::English,
     ActivityOptions::with_start_to_close_timeout(Duration::from_secs(30))
         .heartbeat_timeout(Duration::from_secs(5))
-        .build()
-    );
+        .build(),
+);
 ```