@temporalio/core-bridge 1.7.0 → 1.7.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@temporalio/core-bridge",
-  "version": "1.7.0",
+  "version": "1.7.1",
   "description": "Temporal.io SDK Core<>Node bridge",
   "main": "index.js",
   "types": "lib/index.d.ts",
@@ -23,7 +23,7 @@
   "license": "MIT",
   "dependencies": {
     "@opentelemetry/api": "^1.3.0",
-    "@temporalio/common": "1.7.0",
+    "@temporalio/common": "1.7.1",
     "arg": "^5.0.2",
     "cargo-cp-artifact": "^0.1.6",
     "which": "^2.0.2"
@@ -53,5 +53,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "2b32bac62f879b35238b487d3aaed093a1e449a7"
+  "gitHead": "368aa83c631555fc31cff25f4af8817d069878d8"
 }

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

@@ -33,7 +33,7 @@ use crate::{
     workflow_handle::UntypedWorkflowHandle,
 };
 use backoff::{exponential, ExponentialBackoff, SystemClock};
-use http::uri::InvalidUri;
+use http::{uri::InvalidUri, Uri};
 use once_cell::sync::OnceCell;
 use parking_lot::RwLock;
 use std::{
@@ -114,6 +114,14 @@ pub struct ClientOptions {
     /// Retry configuration for the server client. Default is [RetryConfig::default]
     #[builder(default)]
     pub retry_config: RetryConfig,
+
+    /// If set, override the origin used when connecting. May be useful in rare situations where tls
+    /// verification needs to use a different name from what should be set as the `:authority`
+    /// header. If [TlsConfig::domain] is set, and this is not, this will be set to
+    /// `https://<domain>`, effectively making the `:authority` header consistent with the domain
+    /// override.
+    #[builder(default)]
+    pub override_origin: Option<Uri>,
 }
 
 /// Configuration options for TLS
@@ -310,6 +318,11 @@ impl ClientOptions {
     {
         let channel = Channel::from_shared(self.target_url.to_string())?;
         let channel = self.add_tls_to_channel(channel).await?;
+        let channel = if let Some(origin) = self.override_origin.clone() {
+            channel.origin(origin)
+        } else {
+            channel
+        };
         let channel = channel.connect().await?;
         let service = ServiceBuilder::new()
             .layer_fn(|channel| GrpcMetricSvc {
@@ -347,10 +360,7 @@ impl ClientOptions {
 
     /// If TLS is configured, set the appropriate options on the provided channel and return it.
     /// Passes it through if TLS options not set.
-    async fn add_tls_to_channel(
-        &self,
-        channel: Endpoint,
-    ) -> Result<Endpoint, tonic::transport::Error> {
+    async fn add_tls_to_channel(&self, mut channel: Endpoint) -> Result<Endpoint, ClientInitError> {
         if let Some(tls_cfg) = &self.tls_cfg {
             let mut tls = tonic::transport::ClientTlsConfig::new();
 
@@ -361,6 +371,13 @@ impl ClientOptions {
 
             if let Some(domain) = &tls_cfg.domain {
                 tls = tls.domain_name(domain);
+
+                // This song and dance ultimately is just to make sure the `:authority` header ends
+                // up correct on requests while we use TLS. Setting the header directly in our
+                // interceptor doesn't work since seemingly it is overridden at some point by
+                // something lower level.
+                let uri: Uri = format!("https://{}", domain).parse()?;
+                channel = channel.origin(uri);
             }
 
             if let Some(client_opts) = &tls_cfg.client_tls_config {
@@ -369,7 +386,7 @@ impl ClientOptions {
                 tls = tls.identity(client_identity);
             }
 
-            return channel.tls_config(tls);
+            return channel.tls_config(tls).map_err(Into::into);
         }
         Ok(channel)
     }

package/sdk-core/core/src/core_tests/determinism.rs

@@ -13,8 +13,11 @@ use temporal_sdk::{
     ActivityOptions, ChildWorkflowOptions, LocalActivityOptions, WfContext, WorkflowResult,
 };
 use temporal_sdk_core_protos::{
-    temporal::api::{enums::v1::WorkflowTaskFailedCause, failure::v1::Failure},
-    DEFAULT_ACTIVITY_TYPE,
+    temporal::api::{
+        enums::v1::{EventType, WorkflowTaskFailedCause},
+        failure::v1::Failure,
+    },
+    TestHistoryBuilder, DEFAULT_ACTIVITY_TYPE,
 };
 
 static DID_FAIL: AtomicBool = AtomicBool::new(false);
@@ -268,3 +271,47 @@ async fn child_wf_id_or_type_change_is_nondeterministic(
         .unwrap();
     worker.run_until_done().await.unwrap();
 }
+
+/// Repros a situation where if, upon completing a task there is some internal error which causes
+/// us to want to auto-fail the workflow task while there is also an outstanding eviction, the wf
+/// would get evicted but then try to send some info down the completion channel afterward, causing
+/// a panic.
+#[tokio::test]
+async fn repro_channel_missing_because_nondeterminism() {
+    for _ in 1..50 {
+        let wf_id = "fakeid";
+        let wf_type = DEFAULT_WORKFLOW_TYPE;
+        let mut t = TestHistoryBuilder::default();
+        t.add_by_type(EventType::WorkflowExecutionStarted);
+        t.add_full_wf_task();
+        t.add_has_change_marker("patch-1", false);
+        let _ts = t.add_by_type(EventType::TimerStarted);
+        t.add_workflow_task_scheduled_and_started();
+
+        let mock = mock_workflow_client();
+        let mut mh =
+            MockPollCfg::from_resp_batches(wf_id, t, [1.into(), ResponseType::AllHistory], mock);
+        mh.num_expected_fails = 1;
+        let mut worker = mock_sdk_cfg(mh, |cfg| {
+            cfg.max_cached_workflows = 2;
+            cfg.ignore_evicts_on_shutdown = false;
+        });
+
+        worker.register_wf(wf_type.to_owned(), move |ctx: WfContext| async move {
+            ctx.patched("wrongid");
+            ctx.timer(Duration::from_secs(1)).await;
+            Ok(().into())
+        });
+
+        worker
+            .submit_wf(
+                wf_id.to_owned(),
+                wf_type.to_owned(),
+                vec![],
+                WorkflowOptions::default(),
+            )
+            .await
+            .unwrap();
+        worker.run_until_done().await.unwrap();
+    }
+}

package/sdk-core/core/src/internal_flags.rs

@@ -47,20 +47,6 @@ impl InternalFlags {
         }
     }
 
-    #[cfg(test)]
-    pub fn all_core_enabled() -> Self {
-        Self {
-            enabled: true,
-            core: BTreeSet::from([
-                CoreInternalFlags::IdAndTypeDeterminismChecks,
-                CoreInternalFlags::UpsertSearchAttributeOnPatch,
-            ]),
-            lang: Default::default(),
-            core_since_last_complete: Default::default(),
-            lang_since_last_complete: Default::default(),
-        }
-    }
-
     pub fn add_from_complete(&mut self, e: &WorkflowTaskCompletedEventAttributes) {
         if !self.enabled {
             return;

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

@@ -538,6 +538,7 @@ impl Worker {
         self.workflows
             .activation_completed(
                 completion,
+                false,
                 self.post_activate_hook
                     .as_ref()
                     .map(|h| |data: PostActivateHookData| h(self, data)),

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

@@ -38,7 +38,7 @@ fsm! {
     // upon observing a history event indicating that the command has been recorded. Note that this
     // does not imply that the command has been _executed_, only that it _will be_ executed at some
     // point in the future.
-    CommandIssued --(CommandRecorded(CmdRecDat), shared on_command_recorded) --> Done;
+    CommandIssued --(CommandRecorded, on_command_recorded) --> Done;
 }
 
 /// Instantiates an UpsertSearchAttributesMachine and packs it together with an initial command
@@ -62,37 +62,21 @@ pub(super) fn upsert_search_attrs(
         );
         // We must still create the command to preserve compatability with anyone previously doing
         // this.
-        create_new(Default::default(), true, internal_flags)
+        create_new(Default::default())
     } else {
-        create_new(attribs.search_attributes.into(), false, internal_flags)
+        create_new(attribs.search_attributes.into())
     }
 }
 
 /// May be used by other state machines / internal needs which desire upserting search attributes.
 pub(super) fn upsert_search_attrs_internal(
     attribs: UpsertWorkflowSearchAttributesCommandAttributes,
-    internal_flags: InternalFlagsRef,
 ) -> NewMachineWithCommand {
-    create_new(
-        attribs.search_attributes.unwrap_or_default(),
-        true,
-        internal_flags,
-    )
+    create_new(attribs.search_attributes.unwrap_or_default())
 }
 
-fn create_new(
-    sa_map: SearchAttributes,
-    should_skip_determinism: bool,
-    internal_flags: InternalFlagsRef,
-) -> NewMachineWithCommand {
-    let sm = UpsertSearchAttributesMachine::from_parts(
-        Created {}.into(),
-        SharedState {
-            sa_map: sa_map.clone(),
-            should_skip_determinism,
-            internal_flags,
-        },
-    );
+fn create_new(sa_map: SearchAttributes) -> NewMachineWithCommand {
+    let sm = UpsertSearchAttributesMachine::from_parts(Created {}.into(), SharedState {});
     let cmd = Command {
         command_type: CommandType::UpsertWorkflowSearchAttributes as i32,
         attributes: Some(
@@ -110,11 +94,7 @@ fn create_new(
 }
 
 #[derive(Clone)]
-pub(super) struct SharedState {
-    should_skip_determinism: bool,
-    sa_map: SearchAttributes,
-    internal_flags: InternalFlagsRef,
-}
+pub(super) struct SharedState {}
 
 /// The state-machine-specific set of commands that are the results of state transition in the
 /// UpsertSearchAttributesMachine. There are none of these because this state machine emits the
@@ -131,30 +111,9 @@ pub(super) struct Created {}
 /// higher-level machinery, it transitions into this state.
 #[derive(Debug, Default, Clone, derive_more::Display)]
 pub(super) struct CommandIssued {}
-pub(super) struct CmdRecDat {
-    sa_map: Option<SearchAttributes>,
-    replaying: bool,
-}
 
 impl CommandIssued {
-    pub(super) fn on_command_recorded(
-        self,
-        shared: &mut SharedState,
-        dat: CmdRecDat,
-    ) -> UpsertSearchAttributesMachineTransition<Done> {
-        if shared.internal_flags.borrow_mut().try_use(
-            CoreInternalFlags::UpsertSearchAttributeOnPatch,
-            !dat.replaying,
-        ) {
-            let sa = dat.sa_map.unwrap_or_default();
-            if !shared.should_skip_determinism && shared.sa_map != sa {
-                return TransitionResult::Err(WFMachinesError::Nondeterminism(format!(
-                    "Search attribute upsert calls must remain deterministic, but {:?} does not \
-                 match the attributes from history: {:?}",
-                    shared.sa_map, sa
-                )));
-            }
-        }
+    pub(super) fn on_command_recorded(self) -> UpsertSearchAttributesMachineTransition<Done> {
         TransitionResult::default()
     }
 }
@@ -198,14 +157,9 @@ impl TryFrom<HistEventData> for UpsertSearchAttributesMachineEvents {
 
     fn try_from(e: HistEventData) -> Result<Self, Self::Error> {
         match e.event.attributes {
-            Some(history_event::Attributes::UpsertWorkflowSearchAttributesEventAttributes(
-                attrs,
-            )) => Ok(UpsertSearchAttributesMachineEvents::CommandRecorded(
-                CmdRecDat {
-                    sa_map: attrs.search_attributes,
-                    replaying: e.replaying,
-                },
-            )),
+            Some(history_event::Attributes::UpsertWorkflowSearchAttributesEventAttributes(_)) => {
+                Ok(UpsertSearchAttributesMachineEvents::CommandRecorded)
+            }
             _ => Err(Self::Error::Nondeterminism(format!(
                 "UpsertWorkflowSearchAttributesMachine does not handle {e}"
             ))),
@@ -241,7 +195,6 @@ impl From<Created> for CommandIssued {
 mod tests {
     use super::{super::OnEventWrapper, *};
     use crate::{
-        internal_flags::InternalFlags,
         replay::TestHistoryBuilder,
         test_help::{build_mock_pollers, mock_worker, MockPollCfg, ResponseType},
         worker::{
@@ -249,8 +202,8 @@ mod tests {
             workflow::{machines::patch_state_machine::VERSION_SEARCH_ATTR_KEY, ManagedWFFunc},
         },
     };
-    use rustfsm::{MachineError, StateMachine};
-    use std::{cell::RefCell, collections::HashMap, rc::Rc};
+    use rustfsm::StateMachine;
+    use std::collections::HashMap;
     use temporal_sdk::{WfContext, WorkflowFunction};
     use temporal_sdk_core_api::Worker;
     use temporal_sdk_core_protos::{
@@ -317,25 +270,14 @@ mod tests {
     }
 
     #[rstest::rstest]
-    fn upsert_search_attrs_sm(#[values(true, false)] nondetermistic: bool) {
-        let mut sm = UpsertSearchAttributesMachine::from_parts(
-            Created {}.into(),
-            SharedState {
-                sa_map: Default::default(),
-                should_skip_determinism: false,
-                internal_flags: Rc::new(RefCell::new(InternalFlags::all_core_enabled())),
-            },
-        );
-
-        let sa_attribs = if nondetermistic {
-            UpsertWorkflowSearchAttributesEventAttributes {
-                workflow_task_completed_event_id: 0,
-                search_attributes: Some(SearchAttributes {
-                    indexed_fields: HashMap::from([("Yo".to_string(), Payload::default())]),
-                }),
-            }
-        } else {
-            Default::default()
+    fn upsert_search_attrs_sm() {
+        let mut sm = UpsertSearchAttributesMachine::from_parts(Created {}.into(), SharedState {});
+
+        let sa_attribs = UpsertWorkflowSearchAttributesEventAttributes {
+            workflow_task_completed_event_id: 0,
+            search_attributes: Some(SearchAttributes {
+                indexed_fields: HashMap::from([("Yo".to_string(), Payload::default())]),
+            }),
         };
         let recorded_history_event = HistoryEvent {
             event_type: EventType::UpsertWorkflowSearchAttributes as i32,
@@ -365,15 +307,8 @@ mod tests {
         assert_eq!(CommandIssued {}.to_string(), sm.state().to_string());
 
         let recorded_res = OnEventWrapper::on_event_mut(&mut sm, cmd_recorded_sm_event);
-        if nondetermistic {
-            assert_matches!(
-                recorded_res.unwrap_err(),
-                MachineError::Underlying(WFMachinesError::Nondeterminism(_))
-            );
-        } else {
-            recorded_res.expect("CommandRecorded should transition CommandIssued -> Done");
-            assert_eq!(Done {}.to_string(), sm.state().to_string());
-        }
+        recorded_res.expect("CommandRecorded should transition CommandIssued -> Done");
+        assert_eq!(Done {}.to_string(), sm.state().to_string());
     }
 
     #[rstest::rstest]

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

@@ -924,10 +924,7 @@ impl WorkflowMachines {
                     }
                     ProtoCmdAttrs::UpsertWorkflowSearchAttributesCommandAttributes(attrs) => {
                         self.add_cmd_to_wf_task(
-                            upsert_search_attrs_internal(
-                                attrs,
-                                self.observed_internal_flags.clone(),
-                            ),
+                            upsert_search_attrs_internal(attrs),
                             CommandIdKind::NeverResolves,
                         );
                     }

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

@@ -550,8 +550,15 @@ impl ManagedRun {
 
     /// Delete the currently tracked workflow activation and return it, if any. Should be called
     /// after the processing of the activation completion, and WFT reporting.
-    pub(super) fn delete_activation(&mut self) -> Option<OutstandingActivation> {
-        self.activation.take()
+    pub(super) fn delete_activation(
+        &mut self,
+        pred: impl FnOnce(&OutstandingActivation) -> bool,
+    ) -> Option<OutstandingActivation> {
+        if self.activation().map(pred).unwrap_or_default() {
+            self.activation.take()
+        } else {
+            None
+        }
     }
 
     /// Called when local activities resolve
@@ -929,6 +936,7 @@ impl ManagedRun {
     }
 
     fn insert_outstanding_activation(&mut self, act: &ActivationOrAuto) {
+        warn!("Inserting {:?}", act);
         let act_type = match &act {
             ActivationOrAuto::LangActivation(act) | ActivationOrAuto::ReadyForQueries(act) => {
                 if act.is_legacy_query() {

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

@@ -23,8 +23,8 @@ pub(crate) use managed_run::ManagedWFFunc;
 
 use crate::{
     abstractions::{
-        stream_when_allowed, take_cell::TakeCell, MeteredSemaphore, TrackedOwnedMeteredSemPermit,
-        UsedMeteredSemPermit,
+        dbg_panic, stream_when_allowed, take_cell::TakeCell, MeteredSemaphore,
+        TrackedOwnedMeteredSemPermit, UsedMeteredSemPermit,
     },
     internal_flags::InternalFlags,
     protosext::{legacy_query_failure, ValidPollWFTQResponse},
@@ -294,6 +294,7 @@ impl Workflows {
                                 workflow_completion::Success::from_variants(vec![]).into(),
                             ),
                         },
+                        true,
                         // We need to say a type, but the type is irrelevant, so imagine some
                         // boxed function we'll never call.
                         Option::<Box<dyn Fn(PostActivateHookData) + Send>>::None,
@@ -309,6 +310,7 @@ impl Workflows {
                             run_id,
                             status: Some(auto_fail_to_complete_status(machines_err)),
                         },
+                        true,
                         Option::<Box<dyn Fn(PostActivateHookData) + Send>>::None,
                     )
                     .await?;
@@ -324,8 +326,9 @@ impl Workflows {
     pub(super) async fn activation_completed(
         &self,
         completion: WorkflowActivationCompletion,
+        is_autocomplete: bool,
         post_activate_hook: Option<impl Fn(PostActivateHookData)>,
-    ) -> Result<usize, CompleteWfError> {
+    ) -> Result<(), CompleteWfError> {
         let is_empty_completion = completion.is_empty();
         let completion = validate_completion(completion)?;
         let run_id = completion.run_id().to_string();
@@ -337,7 +340,7 @@ impl Workflows {
         if !was_sent {
             if is_empty_completion {
                 // Empty complete which is likely an evict reply, we can just ignore.
-                return Ok(0);
+                return Ok(());
             }
             panic!(
                 "A non-empty completion was not processed. Workflow processing may have \
@@ -345,9 +348,18 @@ impl Workflows {
             );
         }
 
-        let completion_outcome = rx
-            .await
-            .expect("Send half of activation complete response not dropped");
+        let completion_outcome = if let Ok(c) = rx.await {
+            c
+        } else {
+            dbg_panic!("Send half of activation complete response channel went missing");
+            self.request_eviction(
+                run_id,
+                "Send half of activation complete response channel went missing",
+                EvictionReason::Fatal,
+            );
+            return Ok(());
+        };
+
         let mut wft_from_complete = None;
         let wft_report_status = match completion_outcome.outcome {
             ActivationCompleteOutcome::ReportWFTSuccess(report) => match report {
@@ -460,9 +472,10 @@ impl Workflows {
             run_id,
             wft_report_status,
             wft_from_complete: maybe_pwft,
+            is_autocomplete,
         });
 
-        Ok(completion_outcome.most_recently_processed_event)
+        Ok(())
     }
 
     /// Tell workflow that a local activity has finished with the provided result
@@ -932,6 +945,7 @@ struct PostActivationMsg {
     run_id: String,
     wft_report_status: WFTReportStatus,
     wft_from_complete: Option<(PreparedWFT, HistoryPaginator)>,
+    is_autocomplete: bool,
 }
 #[derive(Debug, Clone)]
 #[cfg_attr(

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

@@ -338,37 +338,39 @@ impl WFStream {
 
         // If we reported to server, we always want to mark it complete.
         let maybe_t = self.complete_wft(run_id, report.wft_report_status);
-        // Delete the activation
-        let activation = self
-            .runs
-            .get_mut(run_id)
-            .and_then(|rh| rh.delete_activation());
-
-        // Evict the run if the activation contained an eviction
-        let mut applied_buffered_poll_for_this_run = false;
-        if activation.map(|a| a.has_eviction()).unwrap_or_default() {
-            debug!(run_id=%run_id, "Evicting run");
-
-            if let Some(mut rh) = self.runs.remove(run_id) {
-                if let Some(buff) = rh.take_buffered_wft() {
-                    // Don't try to apply a buffered poll for this run if we just got a new WFT
-                    // from completing, because by definition that buffered poll is now an
-                    // out-of-date WFT.
-                    if wft_from_complete.is_none() {
-                        res = self.instantiate_or_update(buff);
-                        applied_buffered_poll_for_this_run = true;
+        // Delete the activation, but only if the report came from lang, or we know the outstanding
+        // activation is expected to be completed internally.
+        if let Some(activation) = self.runs.get_mut(run_id).and_then(|rh| {
+            rh.delete_activation(|act| {
+                !report.is_autocomplete || matches!(act, OutstandingActivation::Autocomplete)
+            })
+        }) {
+            // Evict the run if the activation contained an eviction
+            let mut applied_buffered_poll_for_this_run = false;
+            if activation.has_eviction() {
+                debug!(run_id=%run_id, "Evicting run");
+
+                if let Some(mut rh) = self.runs.remove(run_id) {
+                    if let Some(buff) = rh.take_buffered_wft() {
+                        // Don't try to apply a buffered poll for this run if we just got a new WFT
+                        // from completing, because by definition that buffered poll is now an
+                        // out-of-date WFT.
+                        if wft_from_complete.is_none() {
+                            res = self.instantiate_or_update(buff);
+                            applied_buffered_poll_for_this_run = true;
+                        }
                     }
                 }
-            }
 
-            // Attempt to apply a buffered poll for some *other* run, if we didn't have a wft
-            // from complete or a buffered poll for *this* run.
-            if wft_from_complete.is_none() && !applied_buffered_poll_for_this_run {
-                if let Some(buff) = self.buffered_polls_need_cache_slot.pop_front() {
-                    res = self.instantiate_or_update(buff);
+                // Attempt to apply a buffered poll for some *other* run, if we didn't have a wft
+                // from complete or a buffered poll for *this* run.
+                if wft_from_complete.is_none() && !applied_buffered_poll_for_this_run {
+                    if let Some(buff) = self.buffered_polls_need_cache_slot.pop_front() {
+                        res = self.instantiate_or_update(buff);
+                    }
                 }
-            }
-        };
+            };
+        }
 
         if let Some((wft, pag)) = wft_from_complete {
             debug!(run_id=%wft.execution.run_id, "New WFT from completion");

package/sdk-core/tests/main.rs

@@ -25,7 +25,7 @@ mod integ_tests {
     use temporal_sdk_core_api::worker::WorkerConfigBuilder;
     use temporal_sdk_core_protos::temporal::api::workflowservice::v1::ListNamespacesRequest;
     use temporal_sdk_core_test_utils::{
-        get_integ_server_options, get_integ_telem_options, NAMESPACE,
+        get_integ_server_options, get_integ_telem_options, init_integ_telem,
     };
     use url::Url;
 
@@ -58,35 +58,23 @@ mod integ_tests {
             .await;
     }
 
-    // TODO: Currently ignored because starting up the docker image with TLS requires some hoop
-    //  jumping. We should upgrade CI to be able to do that but this was manually run against
-    //  https://github.com/temporalio/customization-samples/tree/master/tls/tls-simple
+    // Manually run to verify tls works against cloud. You will need certs in place in the
+    // indicated directory.
     #[tokio::test]
     #[ignore]
     async fn tls_test() {
-        // Load certs/keys
-        let root = tokio::fs::read(
-            "/home/sushi/dev/temporal/customization-samples/tls/tls-simple/certs/ca.cert",
-        )
-        .await
-        .unwrap();
-        let client_cert = tokio::fs::read(
-            "/home/sushi/dev/temporal/customization-samples/tls/tls-simple/certs/client.pem",
-        )
-        .await
-        .unwrap();
-        let client_private_key = tokio::fs::read(
-            "/home/sushi/dev/temporal/customization-samples/tls/tls-simple/certs/client.key",
-        )
-        .await
-        .unwrap();
+        init_integ_telem();
+        let root = tokio::fs::read("../.cloud_certs/ca.pem").await.unwrap();
+        let client_cert = tokio::fs::read("../.cloud_certs/client.pem").await.unwrap();
+        let client_private_key = tokio::fs::read("../.cloud_certs/client.key").await.unwrap();
         let sgo = ClientOptionsBuilder::default()
-            .target_url(Url::from_str("https://localhost:7233").unwrap())
+            .target_url(Url::from_str("https://spencer.temporal-dev.tmprl.cloud:7233").unwrap())
             .client_name("tls_tester")
             .client_version("clientver")
             .tls_cfg(TlsConfig {
                 server_root_ca_cert: Some(root),
-                domain: Some("tls-sample".to_string()),
+                // Not necessary, but illustrates functionality for people using proxies, etc.
+                domain: Some("spencer.temporal-dev.tmprl.cloud".to_string()),
                 client_tls_config: Some(ClientTlsConfig {
                     client_cert,
                     client_private_key,
@@ -95,9 +83,12 @@ mod integ_tests {
             .build()
             .unwrap();
         let con = sgo
-            .connect(NAMESPACE.to_string(), None, None)
+            .connect("spencer.temporal-dev".to_string(), None, None)
             .await
             .unwrap();
-        con.list_namespaces().await.unwrap();
+        dbg!(con
+            .list_workflow_executions(100, vec![], "".to_string())
+            .await
+            .unwrap());
     }
 }