temporalio 0.0.2 → 0.1.1

data/bridge/sdk-core/protos/api_upstream/temporal/api/update/v1/message.proto

@@ -0,0 +1,111 @@
+// The MIT License
+//
+// Copyright (c) 2020 Temporal Technologies Inc.  All rights reserved.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+syntax = "proto3";
+
+package temporal.api.update.v1;
+
+option go_package = "go.temporal.io/api/update/v1;update";
+option java_package = "io.temporal.api.update.v1";
+option java_multiple_files = true;
+option java_outer_classname = "MessageProto";
+option ruby_package = "Temporalio::Api::Update::V1";
+option csharp_namespace = "Temporalio.Api.Update.V1";
+
+import "temporal/api/common/v1/message.proto";
+import "temporal/api/enums/v1/update.proto";
+import "temporal/api/failure/v1/message.proto";
+
+// Sepcifies to the gRPC server how the client wants the UpdateWorkflowExecution
+// call to wait before returning control to the caller.
+message WaitPolicy {
+
+    // Indicates the update lifecycle stage that the gRPC call should wait for
+    // before returning.
+    temporal.api.enums.v1.UpdateWorkflowExecutionLifecycleStage lifecycle_stage = 1;
+}
+
+// The data needed by a client to refer to an previously invoked workflow
+// execution update process.
+message UpdateRef {
+    temporal.api.common.v1.WorkflowExecution workflow_execution = 1;
+    string update_id = 2;
+}
+
+// The outcome of a workflow update - success or failure.
+message Outcome {
+    oneof value {
+        temporal.api.common.v1.Payloads success = 1;
+        temporal.api.failure.v1.Failure failure = 2;
+    }
+}
+
+// Metadata about a workflow execution update.
+message Meta {
+    // An ID with workflow-scoped uniqueness for this update
+    string update_id = 1;
+
+    // A string identifying the agent that requested this update.
+    string identity = 2;
+}
+
+message Input {
+    // Headers that are passed with the update from the requesting entity.
+    // These can include things like auth or tracing tokens.
+    temporal.api.common.v1.Header header = 1;
+
+    // The name of the input handler to invoke on the target workflow
+    string name = 2;
+
+    // The arguments to pass to the named handler.
+    temporal.api.common.v1.Payloads args = 3;
+}
+
+// The client request that triggers a workflow execution update
+message Request {
+    Meta meta = 1;
+    Input input = 2;
+}
+
+// An update protocol message indicating that a workflow execution update has
+// been rejected.
+message Rejection {
+    string rejected_request_message_id = 1;
+    int64 rejected_request_sequencing_event_id = 2;
+    Request rejected_request = 3;
+    temporal.api.failure.v1.Failure failure = 4;
+}
+
+// An update protocol message indicating that a workflow execution update has
+// been accepted (i.e. passed the worker-side validation phase).
+message Acceptance {
+    string accepted_request_message_id = 1;
+    int64 accepted_request_sequencing_event_id = 2;
+    Request accepted_request = 3;
+}
+
+// An update protocol message indicating that a workflow execution update has
+// completed with the contained outcome.
+message Response {
+    Meta meta = 1;
+    Outcome outcome = 2;
+}

data/bridge/sdk-core/protos/api_upstream/temporal/api/workflowservice/v1/request_response.proto

@@ -39,21 +39,22 @@ import "temporal/api/enums/v1/common.proto";
 import "temporal/api/enums/v1/query.proto";
 import "temporal/api/enums/v1/reset.proto";
 import "temporal/api/enums/v1/task_queue.proto";
-import "temporal/api/enums/v1/update.proto";
 import "temporal/api/common/v1/message.proto";
 import "temporal/api/history/v1/message.proto";
-import "temporal/api/interaction/v1/message.proto";
 import "temporal/api/workflow/v1/message.proto";
 import "temporal/api/command/v1/message.proto";
 import "temporal/api/failure/v1/message.proto";
 import "temporal/api/filter/v1/message.proto";
+import "temporal/api/protocol/v1/message.proto";
 import "temporal/api/namespace/v1/message.proto";
 import "temporal/api/query/v1/message.proto";
 import "temporal/api/replication/v1/message.proto";
 import "temporal/api/schedule/v1/message.proto";
 import "temporal/api/taskqueue/v1/message.proto";
+import "temporal/api/update/v1/message.proto";
 import "temporal/api/version/v1/message.proto";
 import "temporal/api/batch/v1/message.proto";
+import "temporal/api/sdk/v1/task_complete_metadata.proto";
 
 import "google/protobuf/duration.proto";
 import "google/protobuf/timestamp.proto";
@@ -168,10 +169,25 @@ message StartWorkflowExecutionRequest {
     temporal.api.common.v1.Memo memo = 14;
     temporal.api.common.v1.SearchAttributes search_attributes = 15;
     temporal.api.common.v1.Header header = 16;
+    // Request to get the first workflow task inline in the response bypassing matching service and worker polling.
+    // If set to `true` the caller is expected to have a worker available and capable of processing the task.
+    // The returned task will be marked as started and is expected to be completed by the specified
+    // `workflow_task_timeout`.
+    bool request_eager_execution = 17;
+    // These values will be available as ContinuedFailure and LastCompletionResult in the
+    // WorkflowExecutionStarted event and through SDKs. The are currently only used by the
+    // server itself (for the schedules feature) and are not intended to be exposed in
+    // StartWorkflowExecution.
+    temporal.api.failure.v1.Failure continued_failure = 18;
+    temporal.api.common.v1.Payloads last_completion_result = 19;
 }
 
 message StartWorkflowExecutionResponse {
     string run_id = 1;
+    // When `request_eager_execution` is set on the `StartWorkflowExecutionRequest`, the server - if supported - will
+    // return the first workflow task to be eagerly executed.
+    // The caller is expected to have a worker available to process the task.
+    PollWorkflowTaskQueueResponse eager_workflow_task = 2;
 }
 
 message GetWorkflowExecutionHistoryRequest {
@@ -267,8 +283,8 @@ message PollWorkflowTaskQueueResponse {
     // Queries that should be executed after applying the history in this task. Responses should be
     // attached to `RespondWorkflowTaskCompletedRequest::query_results`
     map<string, temporal.api.query.v1.WorkflowQuery> queries = 14;
-
-    repeated temporal.api.interaction.v1.Invocation interactions = 15;
+    // Protocol messages piggybacking on a WFT as a transport
+    repeated temporal.api.protocol.v1.Message messages = 15;
 }
 
 message RespondWorkflowTaskCompletedRequest {
@@ -299,6 +315,13 @@ message RespondWorkflowTaskCompletedRequest {
     // When `worker_versioning_id` has a `worker_build_id`, and `binary_checksum` is not
     // set, that value should also be considered as the `binary_checksum`.
     temporal.api.taskqueue.v1.VersionId worker_versioning_id = 10;
+    // Protocol messages piggybacking on a WFT as a transport
+    repeated temporal.api.protocol.v1.Message messages = 11;
+    // Data the SDK wishes to record for itself, but server need not interpret, and does not
+    // directly impact workflow state.
+    temporal.api.sdk.v1.WorkflowTaskCompletedMetadata sdk_metadata = 12;
+    // Local usage data collected for metering
+    temporal.api.common.v1.MeteringMetadata metering_metadata = 13;
 }
 
 message RespondWorkflowTaskCompletedResponse {
@@ -323,6 +346,8 @@ message RespondWorkflowTaskFailedRequest {
     // Worker process' unique binary id
     string binary_checksum = 5;
     string namespace = 6;
+    // Protocol messages piggybacking on a WFT as a transport
+    repeated temporal.api.protocol.v1.Message messages = 7;
 }
 
 message RespondWorkflowTaskFailedResponse {
@@ -851,6 +876,13 @@ message GetSystemInfoResponse {
 
         // True if server supports upserting workflow memo
         bool upsert_memo = 7;
+
+        // True if server supports eager workflow task dispatching for the StartWorkflowExecution API
+        bool eager_workflow_start = 8;
+
+        // True if the server knows about the sdk metadata field on WFT completions and will record
+        // it in history
+        bool sdk_metadata = 9;
     }
 }
 
@@ -1051,51 +1083,50 @@ message GetWorkerBuildIdOrderingResponse {
 
 // (-- api-linter: core::0134=disabled
 //     aip.dev/not-precedent: Update RPCs don't follow Google API format. --)
-message UpdateWorkflowRequest {
-    // A unique ID for this logical request
-    string request_id = 1;
-
-    // The manner in which the update result will be accessed.
-    // This field requires a non-default value; the default value of the enum
-    // will result in an error.
-    temporal.api.enums.v1.WorkflowUpdateResultAccessStyle result_access_style = 2;
-
+message UpdateWorkflowExecutionRequest {
     // The namespace name of the target workflow
-    string namespace = 3;
+    string namespace = 1;
     // The target workflow id and (optionally) a specific run thereof
     // (-- api-linter: core::0203::optional=disabled
     //     aip.dev/not-precedent: false positive triggered by the word "optional" --)
-    temporal.api.common.v1.WorkflowExecution workflow_execution = 4;
+    temporal.api.common.v1.WorkflowExecution workflow_execution = 2;
     // If set, this call will error if the most recent (if no run id is set on
     // `workflow_execution`), or specified (if it is) workflow execution is not
     // part of the same execution chain as this id.
-    string first_execution_run_id = 5;
+    string first_execution_run_id = 3;
 
-    // A string identifying the agent that requested this interaction.
-    string identity = 6;
+    // Describes when this request should return - basically whether the
+    // update is synchronous, asynchronous, or somewhere in between.
+    temporal.api.update.v1.WaitPolicy wait_policy = 4;
 
-    // The name under which the workflow update function is registered and the
-    // arguments to pass to said function.
-    temporal.api.interaction.v1.Input input = 7;
+    // The request information that will be delivered all the way down to the
+    // workflow execution.
+    temporal.api.update.v1.Request request = 5;
 }
 
-message UpdateWorkflowResponse {
-    // An opaque token that can be used to retrieve the update result via
-    // polling if it is not returned as part of the gRPC response
-    bytes update_token = 1;
-    // The success or failure status of the update
-    temporal.api.interaction.v1.Output output = 2;
+message UpdateWorkflowExecutionResponse {
+    // Enough information for subsequent poll calls if needed. Never null.
+    temporal.api.update.v1.UpdateRef update_ref = 1;
+
+    // The outcome of the update if and only if the workflow execution update
+    // has completed. If this response is being returned before the update has
+    // completed then this field will not be set.
+    temporal.api.update.v1.Outcome outcome = 2;
 }
 
 message StartBatchOperationRequest {
     // Namespace that contains the batch operation
     string namespace = 1;
-    // Visibility query defines the the group of workflow to do batch operation
+    // Visibility query defines the the group of workflow to apply the batch operation
+    // This field and Executions are mutually exclusive
     string visibility_query = 2;
     // Job ID defines the unique ID for the batch job
     string job_id = 3;
     // Reason to perform the batch operation
     string reason = 4;
+    // Executions to apply the batch operation
+    // This field and VisibilityQuery are mutually exclusive
+    repeated temporal.api.common.v1.WorkflowExecution executions = 5;
     // Operation input
     oneof operation {
         temporal.api.batch.v1.BatchOperationTermination termination_operation = 10;

data/bridge/sdk-core/protos/api_upstream/temporal/api/workflowservice/v1/service.proto

@@ -393,8 +393,8 @@ service WorkflowService {
 
     // Invokes the specified update function on user workflow code.
     // (-- api-linter: core::0134=disabled
-    //     aip.dev/not-precedent: UpdateWorkflow doesn't follow Google API format --)
-    rpc UpdateWorkflow(UpdateWorkflowRequest) returns (UpdateWorkflowResponse) {
+    //     aip.dev/not-precedent: UpdateWorkflowExecution doesn't follow Google API format --)
+    rpc UpdateWorkflowExecution(UpdateWorkflowExecutionRequest) returns (UpdateWorkflowExecutionResponse) {
     }
 
     // StartBatchOperation starts a new batch operation

data/bridge/sdk-core/protos/local/temporal/sdk/core/activity_result/activity_result.proto

@@ -1,6 +1,7 @@
 syntax = "proto3";
 
 package coresdk.activity_result;
+option ruby_package = "Temporalio::Bridge::Api::ActivityResult";
 
 import "google/protobuf/duration.proto";
 import "google/protobuf/timestamp.proto";

data/bridge/sdk-core/protos/local/temporal/sdk/core/activity_task/activity_task.proto

@@ -4,6 +4,7 @@ syntax = "proto3";
  * Definitions of the different activity tasks returned from [crate::Core::poll_task].
  */
 package coresdk.activity_task;
+option ruby_package = "Temporalio::Bridge::Api::ActivityTask";
 
 import "google/protobuf/duration.proto";
 import "google/protobuf/timestamp.proto";

data/bridge/sdk-core/protos/local/temporal/sdk/core/child_workflow/child_workflow.proto

@@ -1,6 +1,7 @@
 syntax = "proto3";
 
 package coresdk.child_workflow;
+option ruby_package = "Temporalio::Bridge::Api::ChildWorkflow";
 
 import "temporal/api/common/v1/message.proto";
 import "temporal/api/failure/v1/message.proto";

data/bridge/sdk-core/protos/local/temporal/sdk/core/common/common.proto

@@ -1,6 +1,7 @@
 syntax = "proto3";
 
 package coresdk.common;
+option ruby_package = "Temporalio::Bridge::Api::Common";
 
 import "google/protobuf/duration.proto";
 

data/bridge/sdk-core/protos/local/temporal/sdk/core/core_interface.proto

@@ -1,6 +1,7 @@
 syntax = "proto3";
 
 package coresdk;
+option ruby_package = "Temporalio::Bridge::Api::CoreInterface";
 
 // Note: Intellij will think the Google imports don't work because of the slightly odd nature of
 // the include paths. You can make it work by going to the "Protobuf Support" settings section

data/bridge/sdk-core/protos/local/temporal/sdk/core/external_data/external_data.proto

@@ -1,6 +1,7 @@
 syntax = "proto3";
 
 package coresdk.external_data;
+option ruby_package = "Temporalio::Bridge::Api::ExternalData";
 
 import "google/protobuf/duration.proto";
 import "google/protobuf/timestamp.proto";

data/bridge/sdk-core/protos/local/temporal/sdk/core/workflow_activation/workflow_activation.proto

@@ -5,6 +5,7 @@ syntax = "proto3";
  * lang SDK applies these activation jobs to drive workflows.
  */
 package coresdk.workflow_activation;
+option ruby_package = "Temporalio::Bridge::Api::WorkflowActivation";
 
 import "google/protobuf/timestamp.proto";
 import "google/protobuf/duration.proto";
@@ -30,6 +31,10 @@ message WorkflowActivation {
     uint32 history_length = 4;
     /// The things to do upon activating the workflow
     repeated WorkflowActivationJob jobs = 5;
+    // Internal flags which are available for use by lang. If `is_replaying` is false, all
+    // internal flags may be used. This is not a delta - all previously used flags always
+    // appear since this representation is cheap.
+    repeated uint32 available_internal_flags = 6;
 }
 
 message WorkflowActivationJob {
@@ -258,6 +263,8 @@ message RemoveFromCache {
         // There was some fatal error processing the workflow, typically an internal error, but
         // can also happen if then network drops out while paginating. Check message string.
         FATAL = 8;
+        // Something went wrong attempting to fetch more history events.
+        PAGINATION_OR_HISTORY_FETCH = 9;
     }
     EvictionReason reason = 2;
 }

data/bridge/sdk-core/protos/local/temporal/sdk/core/workflow_commands/workflow_commands.proto

@@ -6,6 +6,7 @@ syntax = "proto3";
  * activation.
  */
 package coresdk.workflow_commands;
+option ruby_package = "Temporalio::Bridge::Api::WorkflowCommands";
 
 import "google/protobuf/duration.proto";
 import "google/protobuf/timestamp.proto";

data/bridge/sdk-core/protos/local/temporal/sdk/core/workflow_completion/workflow_completion.proto

@@ -1,8 +1,10 @@
 syntax = "proto3";
 
 package coresdk.workflow_completion;
+option ruby_package = "Temporalio::Bridge::Api::WorkflowCompletion";
 
 import "temporal/api/failure/v1/message.proto";
+import "temporal/api/enums/v1/failed_cause.proto";
 import "temporal/sdk/core/common/common.proto";
 import "temporal/sdk/core/workflow_commands/workflow_commands.proto";
 
@@ -20,10 +22,14 @@ message WorkflowActivationCompletion {
 message Success {
     // A list of commands to send back to the temporal server
     repeated workflow_commands.WorkflowCommand commands = 1;
+    // Any internal flags which the lang SDK used in the processing of this activation
+    repeated uint32 used_internal_flags = 6;
 }
 
 /// Failure to activate or execute a workflow
 message Failure {
     temporal.api.failure.v1.Failure failure = 1;
+    // Forces overriding the WFT failure cause
+    temporal.api.enums.v1.WorkflowTaskFailedCause force_cause = 2;
 }
 

data/bridge/sdk-core/sdk/Cargo.toml

@@ -14,14 +14,15 @@ categories = ["development-tools"]
 
 [dependencies]
 async-trait = "0.1"
+thiserror = "1.0"
 anyhow = "1.0"
-base64 = "0.20"
+base64 = "0.21"
 crossbeam = "0.8"
 derive_more = "0.99"
 futures = "0.3"
 once_cell = "1.10"
 parking_lot = { version = "0.12", features = ["send_guard"] }
-prost-types = "0.11"
+prost-types = { version = "0.4", package = "prost-wkt-types" }
 sha2 = "0.10"
 serde = "1.0"
 tokio = { version = "1.1", features = ["rt", "rt-multi-thread", "parking_lot", "time", "fs"] }

data/bridge/sdk-core/sdk/src/lib.rs

@@ -66,10 +66,12 @@ use anyhow::{anyhow, bail, Context};
 use app_data::AppData;
 use futures::{future::BoxFuture, FutureExt, StreamExt, TryFutureExt, TryStreamExt};
 use std::{
+    any::{Any, TypeId},
     cell::RefCell,
     collections::HashMap,
     fmt::{Debug, Display, Formatter},
     future::Future,
+    panic::AssertUnwindSafe,
     sync::Arc,
 };
 use temporal_client::ClientOptionsBuilder;
@@ -306,22 +308,17 @@ impl Worker {
             // makes tests which use mocks dramatically more manageable.
             async {
                 if !act_half.activity_fns.is_empty() {
-                    let shutdown_token = shutdown_token.clone();
                     loop {
-                        tokio::select! {
-                            activity = common.worker.poll_activity_task() => {
-                                if matches!(activity, Err(PollActivityError::ShutDown)) {
-                                    break;
-                                }
-                                act_half.activity_task_handler(
-                                    common.worker.clone(),
-                                    safe_app_data.clone(),
-                                    common.task_queue.clone(),
-                                    activity?
-                                )?;
-                            },
-                            _ = shutdown_token.cancelled() => { break }
+                        let activity = common.worker.poll_activity_task().await;
+                        if matches!(activity, Err(PollActivityError::ShutDown)) {
+                            break;
                         }
+                        act_half.activity_task_handler(
+                            common.worker.clone(),
+                            safe_app_data.clone(),
+                            common.task_queue.clone(),
+                            activity?,
+                        )?;
                     }
                 };
                 Result::<_, anyhow::Error>::Ok(())
@@ -335,6 +332,7 @@ impl Worker {
             i.on_shutdown(self);
         }
         self.common.worker.shutdown().await;
+        debug!("Worker shutdown complete");
         self.app_data = Some(
             Arc::try_unwrap(safe_app_data)
                 .map_err(|_| anyhow!("some references of AppData exist on worker shutdown"))?,
@@ -412,7 +410,7 @@ impl WorkflowHalf {
             );
             let jh = tokio::spawn(async move {
                 tokio::select! {
-                    r = wff => r,
+                    r = wff.fuse() => r,
                     // TODO: This probably shouldn't abort early, as it could cause an in-progress
                     //  complete to abort. Send synthetic remove activation
                     _ = shutdown_token.cancelled() => {
@@ -485,15 +483,30 @@ impl ActivityHalf {
                     start,
                 );
                 tokio::spawn(async move {
-                    let output = (act_fn.act_func)(ctx, arg).await;
+                    let output = AssertUnwindSafe((act_fn.act_func)(ctx, arg))
+                        .catch_unwind()
+                        .await;
                     let result = match output {
-                        Ok(ActExitValue::Normal(p)) => ActivityExecutionResult::ok(p),
-                        Ok(ActExitValue::WillCompleteAsync) => {
+                        Err(e) => ActivityExecutionResult::fail(Failure::application_failure(
+                            format!("Activity function panicked: {}", panic_formatter(e)),
+                            true,
+                        )),
+                        Ok(Ok(ActExitValue::Normal(p))) => ActivityExecutionResult::ok(p),
+                        Ok(Ok(ActExitValue::WillCompleteAsync)) => {
                             ActivityExecutionResult::will_complete_async()
                         }
-                        Err(err) => match err.downcast::<ActivityCancelledError>() {
+                        Ok(Err(err)) => match err.downcast::<ActivityCancelledError>() {
                             Ok(ce) => ActivityExecutionResult::cancel_from_details(ce.details),
-                            Err(other_err) => ActivityExecutionResult::fail(other_err.into()),
+                            Err(other_err) => {
+                                match other_err.downcast::<NonRetryableActivityError>() {
+                                    Ok(nre) => ActivityExecutionResult::fail(
+                                        Failure::application_failure_from_error(nre.into(), true),
+                                    ),
+                                    Err(other_err) => ActivityExecutionResult::fail(
+                                        Failure::application_failure_from_error(other_err, false),
+                                    ),
+                                }
+                            }
                         },
                     };
                     worker
@@ -748,6 +761,14 @@ pub struct ActivityFunction {
 pub struct ActivityCancelledError {
     details: Option<Payload>,
 }
+impl ActivityCancelledError {
+    /// Include some details as part of concluding the activity as cancelled
+    pub fn with_details(payload: Payload) -> Self {
+        Self {
+            details: Some(payload),
+        }
+    }
+}
 impl std::error::Error for ActivityCancelledError {}
 impl Display for ActivityCancelledError {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
@@ -755,6 +776,16 @@ impl Display for ActivityCancelledError {
     }
 }
 
+/// Return this error to indicate that your activity non-retryable
+/// this is a transparent wrapper around anyhow Error so essentially any type of error
+/// could be used here.
+///
+/// In your activity function. Return something along the lines of:
+/// `Err(NonRetryableActivityError(anyhow::anyhow!("This should *not* be retried")).into())`
+#[derive(Debug, thiserror::Error)]
+#[error(transparent)]
+pub struct NonRetryableActivityError(pub anyhow::Error);
+
 /// Closures / functions which can be turned into activity functions implement this trait
 pub trait IntoActivityFunc<Args, Res, Out> {
     /// Consume the closure or fn pointer and turned it into a boxed activity function
@@ -792,3 +823,39 @@ where
         Arc::new(wrapper)
     }
 }
+
+/// Attempts to turn caught panics into something printable
+fn panic_formatter(panic: Box<dyn Any>) -> Box<dyn Display> {
+    _panic_formatter::<&str>(panic)
+}
+fn _panic_formatter<T: 'static + PrintablePanicType>(panic: Box<dyn Any>) -> Box<dyn Display> {
+    match panic.downcast::<T>() {
+        Ok(d) => d,
+        Err(orig) => {
+            if TypeId::of::<<T as PrintablePanicType>::NextType>()
+                == TypeId::of::<EndPrintingAttempts>()
+            {
+                return Box::new("Couldn't turn panic into a string");
+            }
+            _panic_formatter::<T::NextType>(orig)
+        }
+    }
+}
+trait PrintablePanicType: Display {
+    type NextType: PrintablePanicType;
+}
+impl PrintablePanicType for &str {
+    type NextType = String;
+}
+impl PrintablePanicType for String {
+    type NextType = EndPrintingAttempts;
+}
+struct EndPrintingAttempts {}
+impl Display for EndPrintingAttempts {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        write!(f, "Will never be printed")
+    }
+}
+impl PrintablePanicType for EndPrintingAttempts {
+    type NextType = EndPrintingAttempts;
+}

data/bridge/sdk-core/sdk/src/workflow_future.rs

@@ -1,6 +1,6 @@
 use crate::{
-    workflow_context::WfContextSharedData, CancellableID, RustWfCmd, SignalData, TimerResult,
-    UnblockEvent, WfContext, WfExitValue, WorkflowFunction, WorkflowResult,
+    panic_formatter, workflow_context::WfContextSharedData, CancellableID, RustWfCmd, SignalData,
+    TimerResult, UnblockEvent, WfContext, WfExitValue, WorkflowFunction, WorkflowResult,
 };
 use anyhow::{anyhow, bail, Context as AnyhowContext, Error};
 use crossbeam::channel::Receiver;
@@ -62,7 +62,9 @@ impl WorkflowFunction {
                 // We need to mark the workflow future as unconstrained, otherwise Tokio will impose
                 // an artificial limit on how many commands we can unblock in one poll round.
                 // TODO: Now we *need* deadlock detection or we could hose the whole system
-                inner: tokio::task::unconstrained((self.wf_func)(wf_context)).boxed(),
+                inner: tokio::task::unconstrained((self.wf_func)(wf_context))
+                    .fuse()
+                    .boxed(),
                 incoming_commands: cmd_receiver,
                 outgoing_completions,
                 incoming_activations,
@@ -214,6 +216,9 @@ impl WorkflowFuture {
                 }
 
                 Variant::RemoveFromCache(_) => {
+                    // TODO: Need to abort any spawned tasks, etc. See also cancel WF.
+                    //   How best to do this in executor agnostic way? Is that possible?
+                    //  -- tokio JoinSet does this in a nice way.
                     return Ok(true);
                 }
             }
@@ -279,11 +284,7 @@ impl Future for WorkflowFuture {
                 .poll_unpin(cx)
             {
                 Poll::Ready(Err(e)) => {
-                    let errmsg = format!(
-                        "Workflow function panicked: {:?}",
-                        // Panics are typically strings
-                        e.downcast::<String>()
-                    );
+                    let errmsg = format!("Workflow function panicked: {}", panic_formatter(e));
                     warn!("{}", errmsg);
                     self.outgoing_completions
                         .send(WorkflowActivationCompletion::fail(