Struct ActivityContext 

pub struct ActivityContext { /* private fields */ }

User-facing orchestration context for scheduling and replay-safe helpers. Context provided to activities for logging and metadata access.

Unlike OrchestrationContext, activities are leaf nodes that cannot schedule new work, but they often need to emit structured logs and inspect orchestration metadata. The ActivityContext exposes the parent orchestration information and trace helpers that log with full correlation fields.

Examples

let activities = ActivityRegistry::builder()
    .register("ProvisionVM", |ctx: ActivityContext, config: String| async move {
        ctx.trace_info(format!("Provisioning VM with config: {}", config));
         
        // Do actual work (can use sleep, HTTP, etc.)
        let vm_id = provision_vm_internal(config).await?;
         
        ctx.trace_info(format!("VM provisioned: {}", vm_id));
        Ok(vm_id)
    })
    .build();

Metadata Access

Activity context provides access to orchestration correlation metadata:

• instance_id() - Orchestration instance identifier
• execution_id() - Execution number (for ContinueAsNew scenarios)
• orchestration_name() - Parent orchestration name
• orchestration_version() - Parent orchestration version
• activity_name() - Current activity name

Cancellation Support

Activities can respond to cancellation when their parent orchestration reaches a terminal state:

• is_cancelled() - Check if cancellation has been requested
• cancelled() - Future that completes when cancellation is requested (for use with tokio::select!)
• cancellation_token() - Get a clone of the token for spawned tasks

Determinism

Activity trace helpers (trace_info, trace_warn, etc.) do not participate in deterministic replay. They emit logs directly using tracing and should only be used for diagnostic purposes.

Implementations

impl ActivityContext

pub fn instance_id(&self) -> &str

Returns the orchestration instance identifier.

pub fn execution_id(&self) -> u64

Returns the execution id within the orchestration instance.

pub fn orchestration_name(&self) -> &str

Returns the parent orchestration name.

pub fn orchestration_version(&self) -> &str

Returns the parent orchestration version.

pub fn activity_name(&self) -> &str

Returns the activity name being executed.

pub fn worker_id(&self) -> &str

Returns the worker dispatcher ID processing this activity.

pub fn trace_info(&self, message: impl Into<String>)

Emit an INFO level trace entry associated with this activity.

pub fn trace_warn(&self, message: impl Into<String>)

Emit a WARN level trace entry associated with this activity.

pub fn trace_error(&self, message: impl Into<String>)

Emit an ERROR level trace entry associated with this activity.

pub fn trace_debug(&self, message: impl Into<String>)

Emit a DEBUG level trace entry associated with this activity.

pub fn is_cancelled(&self) -> bool

Check if cancellation has been requested.

Returns true if the parent orchestration has completed, failed, or been cancelled. Activities can use this for cooperative cancellation.

Example

for item in items {
    if ctx.is_cancelled() {
        return Err("Activity cancelled".into());
    }
    process(item).await;
}

pub async fn cancelled(&self)

Returns a future that completes when cancellation is requested.

Use with tokio::select! for interruptible activities. This allows activities to respond promptly to cancellation without polling.

Example

tokio::select! {
    result = do_work() => return result,
    _ = ctx.cancelled() => return Err("Cancelled".into()),
}

pub fn cancellation_token(&self) -> CancellationToken

Get a clone of the cancellation token for use in spawned tasks.

If your activity spawns child tasks with tokio::spawn(), you should pass them this token so they can also respond to cancellation.

Important: If you spawn additional tasks/threads and do not pass them the cancellation token, they may outlive the activity’s cancellation/abort. This is user error - the runtime provides the signal but cannot guarantee termination of arbitrary spawned work.

Example

let token = ctx.cancellation_token();
let handle = tokio::spawn(async move {
    loop {
        tokio::select! {
            _ = do_work() => {}
            _ = token.cancelled() => break,
        }
    }
});

pub fn get_client(&self) -> Client

Get a Client for management operations.

This allows activities to perform management operations such as pruning old executions, deleting instances, or querying instance status.

Example: Self-Pruning Eternal Orchestration

// Activity that prunes old executions
async fn prune_self(ctx: ActivityContext, _input: String) -> Result<String, String> {
    let client = ctx.get_client();
    let instance_id = ctx.instance_id();

    let result = client.prune_executions(instance_id, PruneOptions {
        keep_last: Some(1), // Keep only current execution
        ..Default::default()
    }).await.map_err(|e| e.to_string())?;

    Ok(format!("Pruned {} executions", result.executions_deleted))
}

Trait Implementations

impl Clone for ActivityContext

fn clone(&self) -> ActivityContext

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for ActivityContext

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.