temporalio 0.0.1 → 0.1.0

data/bridge/sdk-core/core/src/ephemeral_server/mod.rs

@@ -23,6 +23,9 @@ use std::os::unix::fs::OpenOptionsExt;
 use std::process::Stdio;
 
 /// Configuration for Temporalite.
+/// Will be removed eventually as its successor, Temporal CLI matures.
+/// We don't care for the duplication between this struct and [TemporalDevServerConfig] and prefer that over another
+/// abstraction since the existence of this struct is temporary.
 #[derive(Debug, Clone, derive_builder::Builder)]
 pub struct TemporaliteConfig {
     /// Required path to executable or download info.
@@ -59,7 +62,10 @@ impl TemporaliteConfig {
     /// Start a Temporalite server with configurable stdout destination.
     pub async fn start_server_with_output(&self, output: Stdio) -> anyhow::Result<EphemeralServer> {
         // Get exe path
-        let exe_path = self.exe.get_or_download("temporalite").await?;
+        let exe_path = self
+            .exe
+            .get_or_download("temporalite", "temporalite")
+            .await?;
 
         // Get free port if not already given
         let port = self.port.unwrap_or_else(|| get_free_port(&self.ip));
@@ -77,6 +83,8 @@ impl TemporaliteConfig {
             self.log.0.clone(),
             "--log-level".to_owned(),
             self.log.1.clone(),
+            "--dynamic-config-value".to_owned(),
+            "frontend.enableServerVersionCheck=false".to_owned(),
         ];
         if let Some(db_filename) = &self.db_filename {
             args.push("--filename".to_owned());
@@ -101,6 +109,86 @@ impl TemporaliteConfig {
     }
 }
 
+/// Configuration for Temporal CLI dev server.
+#[derive(Debug, Clone, derive_builder::Builder)]
+pub struct TemporalDevServerConfig {
+    /// Required path to executable or download info.
+    pub exe: EphemeralExe,
+    /// Namespace to use.
+    #[builder(default = "\"default\".to_owned()")]
+    pub namespace: String,
+    /// IP to bind to.
+    #[builder(default = "\"127.0.0.1\".to_owned()")]
+    pub ip: String,
+    /// Port to use or obtains a free one if none given.
+    #[builder(default)]
+    pub port: Option<u16>,
+    /// Sqlite DB filename if persisting or non-persistent if none.
+    #[builder(default)]
+    pub db_filename: Option<String>,
+    /// Whether to enable the UI.
+    #[builder(default)]
+    pub ui: bool,
+    /// Log format and level
+    #[builder(default = "(\"pretty\".to_owned(), \"warn\".to_owned())")]
+    pub log: (String, String),
+    /// Additional arguments to Temporalite.
+    #[builder(default)]
+    pub extra_args: Vec<String>,
+}
+
+impl TemporalDevServerConfig {
+    /// Start a Temporal CLI dev server.
+    pub async fn start_server(&self) -> anyhow::Result<EphemeralServer> {
+        self.start_server_with_output(Stdio::inherit()).await
+    }
+
+    /// Start a Temporal CLI dev server with configurable stdout destination.
+    pub async fn start_server_with_output(&self, output: Stdio) -> anyhow::Result<EphemeralServer> {
+        // Get exe path
+        let exe_path = self.exe.get_or_download("cli", "temporal").await?;
+
+        // Get free port if not already given
+        let port = self.port.unwrap_or_else(|| get_free_port(&self.ip));
+
+        // Build arg set
+        let mut args = vec![
+            "server".to_owned(),
+            "start-dev".to_owned(),
+            "--port".to_owned(),
+            port.to_string(),
+            "--namespace".to_owned(),
+            self.namespace.clone(),
+            "--ip".to_owned(),
+            self.ip.clone(),
+            "--log-format".to_owned(),
+            self.log.0.clone(),
+            "--log-level".to_owned(),
+            self.log.1.clone(),
+            "--dynamic-config-value".to_owned(),
+            "frontend.enableServerVersionCheck=false".to_owned(),
+        ];
+        if let Some(db_filename) = &self.db_filename {
+            args.push("--filename".to_owned());
+            args.push(db_filename.clone());
+        }
+        if !self.ui {
+            args.push("--headless".to_owned());
+        }
+        args.extend(self.extra_args.clone());
+
+        // Start
+        EphemeralServer::start(EphemeralServerConfig {
+            exe_path,
+            port,
+            args,
+            has_test_service: false,
+            output,
+        })
+        .await
+    }
+}
+
 /// Configuration for the test server.
 #[derive(Debug, Clone, derive_builder::Builder)]
 pub struct TestServerConfig {
@@ -123,7 +211,10 @@ impl TestServerConfig {
     /// Start a test server with configurable stdout.
     pub async fn start_server_with_output(&self, output: Stdio) -> anyhow::Result<EphemeralServer> {
         // Get exe path
-        let exe_path = self.exe.get_or_download("temporal-test-server").await?;
+        let exe_path = self
+            .exe
+            .get_or_download("temporal-test-server", "temporal-test-server")
+            .await?;
 
         // Get free port if not already given
         let port = self.port.unwrap_or_else(|| get_free_port("0.0.0.0"));
@@ -172,7 +263,7 @@ impl EphemeralServer {
             .stdout(config.output)
             .spawn()?;
         let target = format!("127.0.0.1:{}", config.port);
-        let target_url = format!("http://{}", target);
+        let target_url = format!("http://{target}");
         let success = Ok(EphemeralServer {
             target,
             has_test_service: config.has_test_service,
@@ -262,7 +353,7 @@ pub enum EphemeralExe {
 #[derive(Debug, Clone)]
 pub enum EphemeralExeVersion {
     /// Use a default version for the given SDK name and version.
-    Default {
+    SDKDefault {
         /// Name of the SDK to get the default for.
         sdk_name: String,
         /// Version of the SDK to get the default for.
@@ -280,7 +371,11 @@ struct DownloadInfo {
 }
 
 impl EphemeralExe {
-    async fn get_or_download(&self, artifact_name: &str) -> anyhow::Result<PathBuf> {
+    async fn get_or_download(
+        &self,
+        artifact_name: &str,
+        downloaded_name_prefix: &str,
+    ) -> anyhow::Result<PathBuf> {
         match self {
             EphemeralExe::ExistingPath(exe_path) => {
                 let path = PathBuf::from(exe_path);
@@ -301,12 +396,12 @@ impl EphemeralExe {
                 };
                 // Create dest file based on SDK name/version or fixed version
                 let dest = dest_dir.join(match version {
-                    EphemeralExeVersion::Default {
+                    EphemeralExeVersion::SDKDefault {
                         sdk_name,
                         sdk_version,
-                    } => format!("{}-{}-{}{}", artifact_name, sdk_name, sdk_version, out_ext),
+                    } => format!("{downloaded_name_prefix}-{sdk_name}-{sdk_version}{out_ext}"),
                     EphemeralExeVersion::Fixed(version) => {
-                        format!("{}-{}{}", artifact_name, version, out_ext)
+                        format!("{downloaded_name_prefix}-{version}{out_ext}")
                     }
                 });
                 debug!(
@@ -327,7 +422,7 @@ impl EphemeralExe {
                 };
                 let mut get_info_params = vec![("arch", arch), ("platform", platform)];
                 let version_name = match version {
-                    EphemeralExeVersion::Default {
+                    EphemeralExeVersion::SDKDefault {
                         sdk_name,
                         sdk_version,
                     } => {
@@ -340,8 +435,7 @@ impl EphemeralExe {
                 let client = reqwest::Client::new();
                 let info: DownloadInfo = client
                     .get(format!(
-                        "https://temporal.download/{}/{}",
-                        artifact_name, version_name
+                        "https://temporal.download/{artifact_name}/{version_name}"
                     ))
                     .query(&get_info_params)
                     .send()
@@ -371,7 +465,7 @@ impl EphemeralExe {
 fn get_free_port(bind_ip: &str) -> u16 {
     // Can just ask OS to give us a port then close socket. OS's don't give that
     // port back to anyone else anytime soon.
-    std::net::TcpListener::bind(format!("{}:0", bind_ip))
+    std::net::TcpListener::bind(format!("{bind_ip}:0"))
         .unwrap()
         .local_addr()
         .unwrap()

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

@@ -0,0 +1,136 @@
+//! Utilities for and tracking of internal versions which alter history in incompatible ways
+//! so that we can use older code paths for workflows executed on older core versions.
+
+use std::collections::{BTreeSet, HashSet};
+use temporal_sdk_core_protos::temporal::api::{
+    history::v1::WorkflowTaskCompletedEventAttributes, sdk::v1::WorkflowTaskCompletedMetadata,
+    workflowservice::v1::get_system_info_response,
+};
+
+/// This enumeration contains internal flags that may result in incompatible history changes with
+/// older workflows, or other breaking changes.
+///
+/// When a flag has existed long enough the version it was introduced in is no longer supported, it
+/// may be removed from the enum. *Importantly*, all variants must be given explicit values, such
+/// that removing older variants does not create any change in existing values. Removed flag
+/// variants must be reserved forever (a-la protobuf), and should be called out in a comment.
+#[repr(u32)]
+#[derive(PartialEq, Eq, PartialOrd, Ord, Hash, Copy, Clone, Debug)]
+pub(crate) enum CoreInternalFlags {
+    /// In this flag, additional checks were added to a number of state machines to ensure that
+    /// the ID and type of activities, local activities, and child workflows match during replay.
+    IdAndTypeDeterminismChecks = 1,
+    /// We received a value higher than this code can understand.
+    TooHigh = u32::MAX,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub(crate) struct InternalFlags {
+    enabled: bool,
+    core: BTreeSet<CoreInternalFlags>,
+    lang: BTreeSet<u32>,
+    core_since_last_complete: HashSet<CoreInternalFlags>,
+    lang_since_last_complete: HashSet<u32>,
+}
+
+impl InternalFlags {
+    pub fn new(server_capabilities: &get_system_info_response::Capabilities) -> Self {
+        Self {
+            enabled: server_capabilities.sdk_metadata,
+            core: Default::default(),
+            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;
+        }
+
+        if let Some(metadata) = e.sdk_metadata.as_ref() {
+            self.core.extend(
+                metadata
+                    .core_used_flags
+                    .iter()
+                    .map(|u| CoreInternalFlags::from_u32(*u)),
+            );
+            self.lang.extend(metadata.lang_used_flags.iter());
+        }
+    }
+
+    pub fn add_lang_used(&mut self, flags: impl IntoIterator<Item = u32>) {
+        if !self.enabled {
+            return;
+        }
+
+        self.lang_since_last_complete.extend(flags.into_iter());
+    }
+
+    /// Returns true if this flag may currently be used. If `should_record` is true, always returns
+    /// true and records the flag as being used, for taking later via
+    /// [Self::gather_for_wft_complete].
+    pub fn try_use(&mut self, core_patch: CoreInternalFlags, should_record: bool) -> bool {
+        if !self.enabled {
+            // If the server does not support the metadata field, we must assume
+            return false;
+        }
+
+        if should_record {
+            self.core_since_last_complete.insert(core_patch);
+            true
+        } else {
+            self.core.contains(&core_patch)
+        }
+    }
+
+    /// Wipes the recorded flags used during the current WFT and returns a partially filled
+    /// sdk metadata message that can be combined with any existing data before sending the WFT
+    /// complete
+    pub fn gather_for_wft_complete(&mut self) -> WorkflowTaskCompletedMetadata {
+        WorkflowTaskCompletedMetadata {
+            core_used_flags: self
+                .core_since_last_complete
+                .drain()
+                .map(|p| p as u32)
+                .collect(),
+            lang_used_flags: self.lang_since_last_complete.drain().collect(),
+        }
+    }
+
+    pub fn all_lang(&self) -> &BTreeSet<u32> {
+        &self.lang
+    }
+}
+
+impl CoreInternalFlags {
+    fn from_u32(v: u32) -> Self {
+        match v {
+            1 => Self::IdAndTypeDeterminismChecks,
+            _ => Self::TooHigh,
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use temporal_sdk_core_protos::temporal::api::workflowservice::v1::get_system_info_response::Capabilities;
+
+    #[test]
+    fn disabled_in_capabilities_disables() {
+        let mut f = InternalFlags::new(&Capabilities::default());
+        f.add_lang_used([1]);
+        f.add_from_complete(&WorkflowTaskCompletedEventAttributes {
+            sdk_metadata: Some(WorkflowTaskCompletedMetadata {
+                core_used_flags: vec![1],
+                lang_used_flags: vec![],
+            }),
+            ..Default::default()
+        });
+        let gathered = f.gather_for_wft_complete();
+        assert_matches!(gathered.core_used_flags.as_slice(), &[]);
+        assert_matches!(gathered.lang_used_flags.as_slice(), &[]);
+    }
+}

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

@@ -13,12 +13,12 @@ extern crate core;
 
 mod abstractions;
 pub mod ephemeral_server;
-mod log_export;
+mod internal_flags;
 mod pollers;
 mod protosext;
 pub mod replay;
 pub(crate) mod retry_logic;
-pub(crate) mod telemetry;
+pub mod telemetry;
 mod worker;
 
 #[cfg(test)]
@@ -33,44 +33,49 @@ pub use pollers::{
     Client, ClientOptions, ClientOptionsBuilder, ClientTlsConfig, RetryClient, RetryConfig,
     TlsConfig, WorkflowClientTrait,
 };
-pub use telemetry::{
-    fetch_global_buffered_logs, telemetry_init, Logger, MetricTemporality, MetricsExporter,
-    OtelCollectorOptions, TelemetryOptions, TelemetryOptionsBuilder, TraceExporter,
-};
 pub use temporal_sdk_core_api as api;
 pub use temporal_sdk_core_protos as protos;
 pub use temporal_sdk_core_protos::TaskToken;
 pub use url::Url;
+#[cfg(feature = "save_wf_inputs")]
+pub use worker::replay_wf_state_inputs;
 pub use worker::{Worker, WorkerConfig, WorkerConfigBuilder};
 
 use crate::{
-    replay::mock_client_from_history,
-    telemetry::metrics::{MetricsContext, METRIC_METER},
+    replay::{mock_client_from_histories, Historator, HistoryForReplay},
+    telemetry::{
+        metrics::{MetricsContext, TemporalMeter},
+        remove_trace_subscriber_for_current_thread, set_trace_subscriber_for_current_thread,
+        telemetry_init, TelemetryInstance,
+    },
     worker::client::WorkerClientBag,
 };
+use futures::Stream;
 use std::sync::Arc;
 use temporal_client::{ConfiguredClient, TemporalServiceClientWithMetrics};
 use temporal_sdk_core_api::{
     errors::{CompleteActivityError, PollActivityError, PollWfError},
-    CoreLog, Worker as WorkerTrait,
+    telemetry::TelemetryOptions,
+    Worker as WorkerTrait,
 };
-use temporal_sdk_core_protos::{coresdk::ActivityHeartbeat, temporal::api::history::v1::History};
-
-lazy_static::lazy_static! {
-    /// A process-wide unique string, which will be different on every startup
-    static ref PROCCESS_UNIQ_ID: String = {
-        uuid::Uuid::new_v4().simple().to_string()
-    };
-}
+use temporal_sdk_core_protos::coresdk::ActivityHeartbeat;
 
 /// Initialize a worker bound to a task queue.
 ///
-/// Lang implementations may pass in a [temporal_client::ConfiguredClient] directly (or a
+/// You will need to have already initialized a [CoreRuntime] which will be used for this worker.
+/// After the worker is initialized, you should use [CoreRuntime::tokio_handle] to run the worker's
+/// async functions.
+///
+/// Lang implementations may pass in a [ConfiguredClient] directly (or a
 /// [RetryClient] wrapping one, or a handful of other variants of the same idea). When they do so,
 /// this function will always overwrite the client retry configuration, force the client to use the
 /// namespace defined in the worker config, and set the client identity appropriately. IE: Use
 /// [ClientOptions::connect_no_namespace], not [ClientOptions::connect].
-pub fn init_worker<CT>(worker_config: WorkerConfig, client: CT) -> Worker
+pub fn init_worker<CT>(
+    runtime: &CoreRuntime,
+    worker_config: WorkerConfig,
+    client: CT,
+) -> Result<Worker, anyhow::Error>
 where
     CT: Into<sealed::AnyClient>,
 {
@@ -96,18 +101,27 @@ where
         worker_config.use_worker_versioning,
     ));
 
-    let metrics = MetricsContext::top_level(worker_config.namespace.clone())
-        .with_task_q(worker_config.task_queue.clone());
-    Worker::new(worker_config, sticky_q, client_bag, metrics)
+    Ok(Worker::new(
+        worker_config,
+        sticky_q,
+        client_bag,
+        Some(&runtime.telemetry),
+    ))
 }
 
 /// Create a worker for replaying a specific history. It will auto-shutdown as soon as the history
-/// has finished being replayed. The provided client should be a mock, and this should only be used
-/// for workflow testing purposes.
-pub fn init_replay_worker(
+/// has finished being replayed.
+///
+/// You do not necessarily need a [CoreRuntime] for replay workers, but it's advisable to create
+/// one and use it to run the replay worker's async functions the same way you would for a normal
+/// worker.
+pub fn init_replay_worker<I>(
     mut config: WorkerConfig,
-    history: &History,
-) -> Result<Worker, anyhow::Error> {
+    histories: I,
+) -> Result<Worker, anyhow::Error>
+where
+    I: Stream<Item = HistoryForReplay> + Send + 'static,
+{
     info!(
         task_queue = config.task_queue.as_str(),
         "Registering replay worker"
@@ -115,15 +129,18 @@ pub fn init_replay_worker(
     config.max_cached_workflows = 1;
     config.max_concurrent_wft_polls = 1;
     config.no_remote_activities = true;
-    // Could possibly just use mocked pollers here?
-    let client = mock_client_from_history(history, config.task_queue.clone());
-    let run_id = history.extract_run_id_from_start()?.to_string();
-    let last_event = history.last_event_id();
-    let mut worker = Worker::new(config, None, Arc::new(client), MetricsContext::default());
-    worker.set_shutdown_on_run_reaches_event(run_id, last_event);
+    let historator = Historator::new(histories);
+    let post_activate = historator.get_post_activate_hook();
+    let shutdown_tok = historator.get_shutdown_setter();
+    let client = mock_client_from_histories(historator);
+    let mut worker = Worker::new(config, None, Arc::new(client), None);
+    worker.set_post_activate_hook(post_activate);
+    shutdown_tok(worker.shutdown_token());
     Ok(worker)
 }
 
+/// Creates a unique sticky queue name for a worker, iff the config allows for 1 or more cached
+/// workflows.
 pub(crate) fn sticky_q_name_for_worker(
     process_identity: &str,
     config: &WorkerConfig,
@@ -131,7 +148,9 @@ pub(crate) fn sticky_q_name_for_worker(
     if config.max_cached_workflows > 0 {
         Some(format!(
             "{}-{}-{}",
-            &process_identity, &config.task_queue, *PROCCESS_UNIQ_ID
+            &process_identity,
+            &config.task_queue,
+            uuid::Uuid::new_v4().simple()
         ))
     } else {
         None
@@ -173,3 +192,98 @@ mod sealed {
         }
     }
 }
+
+/// Holds shared state/components needed to back instances of workers and clients. More than one
+/// may be instantiated, but typically only one is needed. More than one runtime instance may be
+/// useful if multiple different telemetry settings are required.
+pub struct CoreRuntime {
+    telemetry: TelemetryInstance,
+    runtime: Option<tokio::runtime::Runtime>,
+    runtime_handle: tokio::runtime::Handle,
+}
+
+impl CoreRuntime {
+    /// Create a new core runtime with the provided telemetry options and tokio runtime builder.
+    /// Also initialize telemetry for the thread this is being called on.
+    ///
+    /// Note that this function will call the [tokio::runtime::Builder::enable_all] builder option
+    /// on the Tokio runtime builder, and will call [tokio::runtime::Builder::on_thread_start] to
+    /// ensure telemetry subscribers are set on every tokio thread.
+    ///
+    /// **Important**: You need to call this *before* calling any async functions on workers or
+    /// clients, otherwise the tracing subscribers will not be properly attached.
+    ///
+    /// # Panics
+    /// If a tokio runtime has already been initialized. To re-use an existing runtime, call
+    /// [CoreRuntime::new_assume_tokio].
+    pub fn new(
+        telemetry_options: TelemetryOptions,
+        mut tokio_builder: tokio::runtime::Builder,
+    ) -> Result<Self, anyhow::Error> {
+        let telemetry = telemetry_init(telemetry_options)?;
+        let subscriber = telemetry.trace_subscriber();
+        let runtime = tokio_builder
+            .enable_all()
+            .on_thread_start(move || {
+                set_trace_subscriber_for_current_thread(subscriber.clone());
+            })
+            .build()?;
+        let _rg = runtime.enter();
+        let mut me = Self::new_assume_tokio_initialized_telem(telemetry);
+        me.runtime = Some(runtime);
+        Ok(me)
+    }
+
+    /// Initialize telemetry for the thread this is being called on, assuming a tokio runtime is
+    /// already active and this call exists in its context. See [Self::new] for more.
+    ///
+    /// # Panics
+    /// If there is no currently active Tokio runtime
+    pub fn new_assume_tokio(telemetry_options: TelemetryOptions) -> Result<Self, anyhow::Error> {
+        let telemetry = telemetry_init(telemetry_options)?;
+        Ok(Self::new_assume_tokio_initialized_telem(telemetry))
+    }
+
+    /// Construct a runtime from an already-initialized telemetry instance, assuming a tokio runtime
+    /// is already active and this call exists in its context. See [Self::new] for more.
+    ///
+    /// # Panics
+    /// If there is no currently active Tokio runtime
+    pub fn new_assume_tokio_initialized_telem(telemetry: TelemetryInstance) -> Self {
+        let runtime_handle = tokio::runtime::Handle::current();
+        set_trace_subscriber_for_current_thread(telemetry.trace_subscriber());
+        Self {
+            telemetry,
+            runtime: None,
+            runtime_handle,
+        }
+    }
+
+    /// Get a handle to the tokio runtime used by this Core runtime.
+    pub fn tokio_handle(&self) -> tokio::runtime::Handle {
+        self.runtime_handle.clone()
+    }
+
+    /// Returns the metric meter used for recording metrics, if they were enabled.
+    pub fn metric_meter(&self) -> Option<TemporalMeter> {
+        self.telemetry.get_metric_meter()
+    }
+
+    /// Return the trace subscriber associated with the telemetry options/instance. Can be used
+    /// to manually set the default for a thread or globally using the `tracing` crate, or with
+    /// [set_trace_subscriber_for_current_thread]
+    pub fn trace_subscriber(&self) -> Arc<dyn tracing::Subscriber + Send + Sync> {
+        self.telemetry.trace_subscriber()
+    }
+
+    /// Return a reference to the owned [TelemetryInstance]
+    pub fn telemetry(&self) -> &TelemetryInstance {
+        &self.telemetry
+    }
+}
+
+impl Drop for CoreRuntime {
+    fn drop(&mut self) {
+        remove_trace_subscriber_for_current_thread();
+    }
+}

data/bridge/sdk-core/core/src/protosext/mod.rs

@@ -274,7 +274,7 @@ impl TryFrom<activity_execution_result::Status> for LocalActivityExecutionResult
             Status::Failed(f)
                 if f.failure
                     .as_ref()
-                    .map(|fail| fail.is_timeout())
+                    .map(|fail| fail.is_timeout().is_some())
                     .unwrap_or_default() =>
             {
                 Ok(LocalActivityExecutionResult::TimedOut(f))