@temporalio/core-bridge 1.12.0 → 1.12.2

package/sdk-core/sdk-core-protos/src/lib.rs

@@ -1810,6 +1810,7 @@ pub mod temporal {
                     )
                 }
 
+                #[allow(deprecated)]
                 pub fn start_child_workflow_cmd_to_api(
                     s: workflow_commands::StartChildWorkflowExecution,
                     inherit_build_id: bool,
@@ -1860,6 +1861,7 @@ pub mod temporal {
                     }
                 }
 
+                #[allow(deprecated)]
                 pub fn continue_as_new_cmd_to_api(
                     c: workflow_commands::ContinueAsNewWorkflowExecution,
                     inherit_build_id: bool,
@@ -2261,6 +2263,78 @@ pub mod temporal {
                             _ => false,
                         }
                     }
+
+                    pub fn is_ignorable(&self) -> bool {
+                        if !self.worker_may_ignore {
+                            return false;
+                        }
+                        // Never add a catch-all case to this match statement. We need to explicitly
+                        // mark any new event types as ignorable or not.
+                        if let Some(a) = self.attributes.as_ref() {
+                            match a {
+                                Attributes::WorkflowExecutionStartedEventAttributes(_) => false,
+                                Attributes::WorkflowExecutionCompletedEventAttributes(_) => false,
+                                Attributes::WorkflowExecutionFailedEventAttributes(_) => false,
+                                Attributes::WorkflowExecutionTimedOutEventAttributes(_) => false,
+                                Attributes::WorkflowTaskScheduledEventAttributes(_) => false,
+                                Attributes::WorkflowTaskStartedEventAttributes(_) => false,
+                                Attributes::WorkflowTaskCompletedEventAttributes(_) => false,
+                                Attributes::WorkflowTaskTimedOutEventAttributes(_) => false,
+                                Attributes::WorkflowTaskFailedEventAttributes(_) => false,
+                                Attributes::ActivityTaskScheduledEventAttributes(_) => false,
+                                Attributes::ActivityTaskStartedEventAttributes(_) => false,
+                                Attributes::ActivityTaskCompletedEventAttributes(_) => false,
+                                Attributes::ActivityTaskFailedEventAttributes(_) => false,
+                                Attributes::ActivityTaskTimedOutEventAttributes(_) => false,
+                                Attributes::TimerStartedEventAttributes(_) => false,
+                                Attributes::TimerFiredEventAttributes(_) => false,
+                                Attributes::ActivityTaskCancelRequestedEventAttributes(_) => false,
+                                Attributes::ActivityTaskCanceledEventAttributes(_) => false,
+                                Attributes::TimerCanceledEventAttributes(_) => false,
+                                Attributes::MarkerRecordedEventAttributes(_) => false,
+                                Attributes::WorkflowExecutionSignaledEventAttributes(_) => false,
+                                Attributes::WorkflowExecutionTerminatedEventAttributes(_) => false,
+                                Attributes::WorkflowExecutionCancelRequestedEventAttributes(_) => false,
+                                Attributes::WorkflowExecutionCanceledEventAttributes(_) => false,
+                                Attributes::RequestCancelExternalWorkflowExecutionInitiatedEventAttributes(_) => false,
+                                Attributes::RequestCancelExternalWorkflowExecutionFailedEventAttributes(_) => false,
+                                Attributes::ExternalWorkflowExecutionCancelRequestedEventAttributes(_) => false,
+                                Attributes::WorkflowExecutionContinuedAsNewEventAttributes(_) => false,
+                                Attributes::StartChildWorkflowExecutionInitiatedEventAttributes(_) => false,
+                                Attributes::StartChildWorkflowExecutionFailedEventAttributes(_) => false,
+                                Attributes::ChildWorkflowExecutionStartedEventAttributes(_) => false,
+                                Attributes::ChildWorkflowExecutionCompletedEventAttributes(_) => false,
+                                Attributes::ChildWorkflowExecutionFailedEventAttributes(_) => false,
+                                Attributes::ChildWorkflowExecutionCanceledEventAttributes(_) => false,
+                                Attributes::ChildWorkflowExecutionTimedOutEventAttributes(_) => false,
+                                Attributes::ChildWorkflowExecutionTerminatedEventAttributes(_) => false,
+                                Attributes::SignalExternalWorkflowExecutionInitiatedEventAttributes(_) => false,
+                                Attributes::SignalExternalWorkflowExecutionFailedEventAttributes(_) => false,
+                                Attributes::ExternalWorkflowExecutionSignaledEventAttributes(_) => false,
+                                Attributes::UpsertWorkflowSearchAttributesEventAttributes(_) => false,
+                                Attributes::WorkflowExecutionUpdateAcceptedEventAttributes(_) => false,
+                                Attributes::WorkflowExecutionUpdateRejectedEventAttributes(_) => false,
+                                Attributes::WorkflowExecutionUpdateCompletedEventAttributes(_) => false,
+                                Attributes::WorkflowPropertiesModifiedExternallyEventAttributes(_) => false,
+                                Attributes::ActivityPropertiesModifiedExternallyEventAttributes(_) => false,
+                                Attributes::WorkflowPropertiesModifiedEventAttributes(_) => false,
+                                Attributes::WorkflowExecutionUpdateAdmittedEventAttributes(_) => false,
+                                Attributes::NexusOperationScheduledEventAttributes(_) => false,
+                                Attributes::NexusOperationStartedEventAttributes(_) => false,
+                                Attributes::NexusOperationCompletedEventAttributes(_) => false,
+                                Attributes::NexusOperationFailedEventAttributes(_) => false,
+                                Attributes::NexusOperationCanceledEventAttributes(_) => false,
+                                Attributes::NexusOperationTimedOutEventAttributes(_) => false,
+                                Attributes::NexusOperationCancelRequestedEventAttributes(_) => false,
+                                // !! Ignorable !!
+                                Attributes::WorkflowExecutionOptionsUpdatedEventAttributes(_) => true,
+                                Attributes::NexusOperationCancelRequestCompletedEventAttributes(_) => false,
+                                Attributes::NexusOperationCancelRequestFailedEventAttributes(_) => false,
+                            }
+                        } else {
+                            false
+                        }
+                    }
                 }
 
                 impl Display for HistoryEvent {
@@ -2429,6 +2503,11 @@ pub mod temporal {
                 tonic::include_proto!("temporal.api.version.v1");
             }
         }
+        pub mod worker {
+            pub mod v1 {
+                tonic::include_proto!("temporal.api.worker.v1");
+            }
+        }
         pub mod workflow {
             pub mod v1 {
                 tonic::include_proto!("temporal.api.workflow.v1");
@@ -2436,10 +2515,13 @@ pub mod temporal {
         }
         pub mod nexus {
             pub mod v1 {
-                use crate::temporal::api::{
-                    common,
-                    common::v1::link::{WorkflowEvent, workflow_event},
-                    enums::v1::EventType,
+                use crate::{
+                    camel_case_to_screaming_snake,
+                    temporal::api::{
+                        common,
+                        common::v1::link::{WorkflowEvent, workflow_event},
+                        enums::v1::EventType,
+                    },
                 };
                 use anyhow::{anyhow, bail};
                 use std::fmt::{Display, Formatter};
@@ -2533,12 +2615,20 @@ pub mod temporal {
                                     })?;
                                 }
                                 "eventType" => {
-                                    eventref.event_type =
-                                        EventType::from_str_name(val).unwrap_or_default().into()
+                                    eventref.event_type = EventType::from_str_name(val)
+                                        .unwrap_or_else(|| {
+                                            EventType::from_str_name(
+                                                &("EVENT_TYPE_".to_string()
+                                                    + &camel_case_to_screaming_snake(val)),
+                                            )
+                                            .unwrap_or_default()
+                                        })
+                                        .into()
                                 }
                                 _ => continue,
                             }
                         }
+                        dbg!(&eventref);
                         Some(workflow_event::Reference::EventRef(eventref))
                     } else {
                         None

package/sdk-core/test-utils/src/lib.rs

@@ -18,6 +18,7 @@ use parking_lot::Mutex;
 use prost::Message;
 use rand::Rng;
 use std::{
+    cell::Cell,
     convert::TryFrom,
     env,
     future::Future,
@@ -171,9 +172,16 @@ pub async fn history_from_proto_binary(path_from_root: &str) -> Result<History,
     Ok(History::decode(&*bytes)?)
 }
 
+thread_local! {
+    /// Can be set true to disable auto-initialization of integ-test telemetry.
+    pub static DONT_AUTO_INIT_INTEG_TELEM: Cell<bool> = const { Cell::new(false) };
+}
 static INTEG_TESTS_RT: std::sync::OnceLock<CoreRuntime> = std::sync::OnceLock::new();
-pub fn init_integ_telem() -> &'static CoreRuntime {
-    INTEG_TESTS_RT.get_or_init(|| {
+pub fn init_integ_telem() -> Option<&'static CoreRuntime> {
+    if DONT_AUTO_INIT_INTEG_TELEM.get() {
+        return None;
+    }
+    Some(INTEG_TESTS_RT.get_or_init(|| {
         let telemetry_options = get_integ_telem_options();
         let rt =
             CoreRuntime::new_assume_tokio(telemetry_options).expect("Core runtime inits cleanly");
@@ -181,7 +189,7 @@ pub fn init_integ_telem() -> &'static CoreRuntime {
             let _ = tracing::subscriber::set_global_default(sub);
         }
         rt
-    })
+    }))
 }
 
 /// Implements a builder pattern to help integ tests initialize core and create workflows

package/sdk-core/tests/cloud_tests.rs

@@ -8,7 +8,7 @@ use temporal_client::{
 };
 use temporal_sdk::WfContext;
 use temporal_sdk_core_protos::temporal::api::{
-    enums::v1::{EventType, WorkflowTaskFailedCause::WorkflowWorkerUnhandledFailure},
+    enums::v1::{EventType, WorkflowTaskFailedCause::GrpcMessageTooLarge},
     history::v1::history_event::Attributes::WorkflowTaskFailedEventAttributes,
 };
 use temporal_sdk_core_test_utils::CoreWfStarter;
@@ -27,6 +27,7 @@ async fn get_client(client_name: &str) -> RetryClient<Client> {
         .target_url(Url::from_str(&cloud_addr).unwrap())
         .client_name(client_name)
         .client_version("clientver")
+        .identity("sdk-test-client")
         .tls_cfg(TlsConfig {
             client_tls_config: Some(ClientTlsConfig {
                 client_cert,
@@ -76,8 +77,7 @@ async fn grpc_message_too_large_test() {
     assert!(starter.get_history().await.events.iter().any(|e| {
         e.event_type == EventType::WorkflowTaskFailed as i32
             && if let WorkflowTaskFailedEventAttributes(attr) = e.attributes.as_ref().unwrap() {
-                // TODO tim: Change to custom cause
-                attr.cause == WorkflowWorkerUnhandledFailure as i32
+                attr.cause == GrpcMessageTooLarge as i32
                     && attr.failure.as_ref().unwrap().message == "GRPC Message too large"
             } else {
                 false

package/sdk-core/tests/heavy_tests.rs

@@ -12,13 +12,15 @@ use std::{
 };
 use temporal_client::{GetWorkflowResultOpts, WfClientExt, WorkflowClientTrait, WorkflowOptions};
 use temporal_sdk::{ActContext, ActivityOptions, WfContext, WorkflowResult};
-use temporal_sdk_core::{ResourceBasedTuner, ResourceSlotOptions};
+use temporal_sdk_core::{CoreRuntime, ResourceBasedTuner, ResourceSlotOptions};
 use temporal_sdk_core_api::worker::PollerBehavior;
 use temporal_sdk_core_protos::{
     coresdk::{AsJsonPayloadExt, workflow_commands::ActivityCancellationType},
     temporal::api::enums::v1::WorkflowIdReusePolicy,
 };
-use temporal_sdk_core_test_utils::{CoreWfStarter, rand_6_chars, workflows::la_problem_workflow};
+use temporal_sdk_core_test_utils::{
+    CoreWfStarter, init_integ_telem, prom_metrics, rand_6_chars, workflows::la_problem_workflow,
+};
 
 mod fuzzy_workflow;
 
@@ -183,7 +185,13 @@ async fn workflow_load() {
     const SIGNAME: &str = "signame";
     let num_workflows = 500;
     let wf_name = "workflow_load";
-    let mut starter = CoreWfStarter::new("workflow_load");
+    let (mut telemopts, _, _aborter) = prom_metrics(None);
+    // Avoid initting two logging systems, since when this test is run with others it can
+    // cause us to encounter the tracing span drop bug
+    telemopts.logging = None;
+    init_integ_telem();
+    let rt = CoreRuntime::new_assume_tokio(telemopts).unwrap();
+    let mut starter = CoreWfStarter::new_with_runtime("workflow_load", rt);
     starter
         .worker_config
         .max_outstanding_workflow_tasks(5_usize)

package/sdk-core/tests/integ_tests/client_tests.rs

@@ -1,6 +1,6 @@
 use assert_matches::assert_matches;
 use futures_util::{FutureExt, future::BoxFuture};
-use http_body_util::BodyExt;
+use http_body_util::Full;
 use prost::Message;
 use std::{
     collections::HashMap,
@@ -30,7 +30,7 @@ use tokio::{
 };
 use tonic::{
     Code, Request, Status,
-    body::BoxBody,
+    body::Body,
     codegen::{Service, http::Response},
     server::NamedService,
     transport::Server,
@@ -108,11 +108,11 @@ struct GenericService<F> {
     header_tx: UnboundedSender<String>,
     response_maker: F,
 }
-impl<F> Service<tonic::codegen::http::Request<BoxBody>> for GenericService<F>
+impl<F> Service<tonic::codegen::http::Request<Body>> for GenericService<F>
 where
-    F: FnMut() -> Response<BoxBody>,
+    F: FnMut() -> Response<Body>,
 {
-    type Response = Response<BoxBody>;
+    type Response = Response<Body>;
     type Error = Infallible;
     type Future = BoxFuture<'static, Result<Self::Response, Self::Error>>;
 
@@ -120,7 +120,7 @@ where
         Poll::Ready(Ok(()))
     }
 
-    fn call(&mut self, req: tonic::codegen::http::Request<BoxBody>) -> Self::Future {
+    fn call(&mut self, req: tonic::codegen::http::Request<Body>) -> Self::Future {
         self.header_tx
             .send(
                 String::from_utf8_lossy(
@@ -149,7 +149,7 @@ struct FakeServer {
 
 async fn fake_server<F>(response_maker: F) -> FakeServer
 where
-    F: FnMut() -> Response<BoxBody> + Clone + Send + 'static,
+    F: FnMut() -> Response<Body> + Clone + Send + Sync + 'static,
 {
     let (shutdown_tx, shutdown_rx) = oneshot::channel::<()>();
     let (header_tx, header_rx) = tokio::sync::mpsc::unbounded_channel();
@@ -191,7 +191,7 @@ impl FakeServer {
 
 #[tokio::test]
 async fn timeouts_respected_one_call_fake_server() {
-    let mut fs = fake_server(|| Response::new(tonic::codegen::empty_body())).await;
+    let mut fs = fake_server(|| Response::new(Body::empty())).await;
     let header_rx = &mut fs.header_rx;
 
     let mut opts = get_integ_server_options();
@@ -335,7 +335,7 @@ async fn namespace_header_attached_to_relevant_calls() {
             .add_service(GenericService {
                 header_to_parse: "Temporal-Namespace",
                 header_tx,
-                response_maker: || Response::new(tonic::codegen::empty_body()),
+                response_maker: || Response::new(Body::empty()),
             })
             .serve_with_incoming_shutdown(
                 tokio_stream::wrappers::TcpListenerStream::new(listener),
@@ -409,7 +409,7 @@ async fn cloud_ops_test() {
     assert_eq!(res.into_inner().namespace.unwrap().namespace, namespace);
 }
 
-fn make_ok_response<T>(message: T) -> Response<BoxBody>
+fn make_ok_response<T>(message: T) -> Response<Body>
 where
     T: Message,
 {
@@ -425,9 +425,8 @@ where
     let len = buf.len() as u32;
     frame.extend_from_slice(&len.to_be_bytes());
     frame.extend_from_slice(&buf);
-    let full_body = http_body_util::Full::from(frame)
-        .map_err(|e: Infallible| -> Status { unreachable!("Infallible error: {:?}", e) });
-    let body = BoxBody::new(full_body);
+    let full_body = Full::new(frame.into());
+    let body = Body::new(full_body);
 
     // Build the HTTP response with the required gRPC headers.
     Response::builder()

package/sdk-core/tests/integ_tests/ephemeral_server_tests.rs

@@ -3,7 +3,6 @@ use std::time::{SystemTime, UNIX_EPOCH};
 use temporal_client::{ClientOptionsBuilder, TestService, WorkflowService};
 use temporal_sdk_core::ephemeral_server::{
     EphemeralExe, EphemeralExeVersion, EphemeralServer, TemporalDevServerConfigBuilder,
-    TestServerConfigBuilder,
 };
 use temporal_sdk_core_protos::temporal::api::workflowservice::v1::DescribeNamespaceRequest;
 use temporal_sdk_core_test_utils::{NAMESPACE, default_cached_download};
@@ -84,6 +83,7 @@ async fn temporal_cli_concurrent_starts() -> Result<(), Box<dyn std::error::Erro
 #[cfg(not(all(target_os = "linux", any(target_arch = "arm", target_arch = "aarch64"))))]
 mod test_server {
     use super::*;
+    use temporal_sdk_core::ephemeral_server::TestServerConfigBuilder;
 
     #[tokio::test]
     async fn test_server_default() {