@temporalio/core-bridge 1.4.4 → 1.5.1

package/sdk-core/bridge-ffi/Cargo.toml

@@ -13,12 +13,12 @@ crate-type = ["staticlib"]
 [dependencies]
 lazy_static = "1.4"
 libc = "0.2"
-log = "0.4"
 prost = "0.11"
 temporal-sdk-core = { version = "0.1", path = "../core" }
 temporal-sdk-core-api = { version = "0.1", path = "../core-api" }
 temporal-sdk-core-protos = { version = "0.1", path = "../sdk-core-protos" }
 tokio = "1"
+tracing = "0.1"
 
 [build-dependencies]
 cbindgen = "0.24"

package/sdk-core/bridge-ffi/include/sdk-core-bridge.h

@@ -121,18 +121,6 @@ void tmprl_worker_shutdown(struct tmprl_worker_t *worker,
                            void *user_data,
                            tmprl_callback callback);
 
-/**
- * Initialize process-wide telemetry. Should only be called once, subsequent calls will be ignored
- * by core.
- *
- * Unlike the other functions in this bridge, this blocks until initting is complete, as telemetry
- * should typically be initialized before doing other work.
- *
- * Returns a byte array for a [InitResponse] protobuf message which must be freed via
- * tmprl_bytes_free.
- */
-const struct tmprl_bytes_t *tmprl_telemetry_init(const uint8_t *req_proto, size_t req_proto_len);
-
 /**
  * Initialize a client connection to the Temporal service.
  *
@@ -234,16 +222,3 @@ void tmprl_request_workflow_eviction(struct tmprl_worker_t *worker,
                                      size_t req_proto_len,
                                      void *user_data,
                                      tmprl_callback callback);
-
-/**
- * Fetch buffered logs. Blocks until complete. This is still using the callback since we might
- * reasonably change log fetching to be async in the future.
- *
- * The `req_proto` and `req_proto_len` represent a byte array for a
- * [bridge::FetchBufferedLogsRequest] protobuf message. The callback is invoked on completion with
- * a [bridge::FetchBufferedLogsResponse] protobuf message.
- */
-void tmprl_fetch_buffered_logs(const uint8_t *req_proto,
-                               size_t req_proto_len,
-                               void *user_data,
-                               tmprl_callback callback);

package/sdk-core/bridge-ffi/src/lib.rs

@@ -17,14 +17,9 @@ mod wrappers;
 use bridge::{init_response, CreateWorkerRequest, InitResponse};
 use prost::Message;
 use std::sync::Arc;
-use temporal_sdk_core::{
-    fetch_global_buffered_logs, telemetry_init, Client, ClientOptions, RetryClient,
-};
-use temporal_sdk_core_api::Worker;
-use temporal_sdk_core_protos::coresdk::{
-    bridge,
-    bridge::{CreateClientRequest, InitTelemetryRequest},
-};
+use temporal_sdk_core::{Client, ClientOptions, CoreRuntime, RetryClient};
+use temporal_sdk_core_api::{telemetry::TelemetryOptions, Worker};
+use temporal_sdk_core_protos::coresdk::{bridge, bridge::CreateClientRequest};
 
 /// A set of bytes owned by Core. No fields within nor any bytes references must
 /// ever be mutated outside of Core. This must always be passed to
@@ -151,7 +146,7 @@ lazy_static::lazy_static! {
 /// currently OK, but that's an implementation detail.
 pub struct tmprl_runtime_t {
     // This is the same runtime shared with worker instances
-    tokio_runtime: Arc<tokio::runtime::Runtime>,
+    core_runtime: Arc<CoreRuntime>,
 }
 
 /// Create a new runtime. The result is never null and must be freed via
@@ -160,11 +155,12 @@ pub struct tmprl_runtime_t {
 pub extern "C" fn tmprl_runtime_new() -> *mut tmprl_runtime_t {
     Box::into_raw(Box::new(tmprl_runtime_t {
         // TODO(cretz): Options to configure thread pool?
-        tokio_runtime: Arc::new(
-            tokio::runtime::Builder::new_multi_thread()
-                .enable_all()
-                .build()
-                .unwrap(),
+        core_runtime: Arc::new(
+            CoreRuntime::new(
+                TelemetryOptions::default(),
+                tokio::runtime::Builder::new_multi_thread(),
+            )
+            .expect("Core runtime must initialize"),
         ),
     }))
 }
@@ -182,7 +178,7 @@ pub extern "C" fn tmprl_runtime_free(runtime: *mut tmprl_runtime_t) {
 /// A worker instance owned by Core. This must be passed to [tmprl_worker_shutdown]
 /// when no longer in use which will free the resources.
 pub struct tmprl_worker_t {
-    tokio_runtime: Arc<tokio::runtime::Runtime>,
+    core_runtime: Arc<CoreRuntime>,
     // We are not concerned with the overhead of dynamic dispatch at this time
     worker: Arc<dyn Worker>,
 }
@@ -240,7 +236,7 @@ pub extern "C" fn tmprl_worker_init(
     };
     let user_data = UserDataHandle(user_data);
     match tmprl_worker_t::new(
-        runtime.tokio_runtime.clone(),
+        runtime.core_runtime.clone(),
         client.client.clone(),
         wrappers::WorkerConfig(req),
     ) {
@@ -287,7 +283,7 @@ pub extern "C" fn tmprl_worker_shutdown(
 ) {
     let worker = unsafe { Box::from_raw(worker) };
     let user_data = UserDataHandle(user_data);
-    worker.tokio_runtime.clone().spawn(async move {
+    worker.core_runtime.tokio_handle().spawn(async move {
         worker.shutdown().await;
         unsafe {
             callback(user_data.into(), &*DEFAULT_SHUTDOWN_WORKER_RESPONSE_BYTES);
@@ -296,43 +292,6 @@ pub extern "C" fn tmprl_worker_shutdown(
     });
 }
 
-/// Initialize process-wide telemetry. Should only be called once, subsequent calls will be ignored
-/// by core.
-///
-/// Unlike the other functions in this bridge, this blocks until initting is complete, as telemetry
-/// should typically be initialized before doing other work.
-///
-/// Returns a byte array for a [InitResponse] protobuf message which must be freed via
-/// tmprl_bytes_free.
-#[no_mangle]
-pub extern "C" fn tmprl_telemetry_init(
-    req_proto: *const u8,
-    req_proto_len: libc::size_t,
-) -> *const tmprl_bytes_t {
-    let req = match tmprl_worker_t::decode_proto::<InitTelemetryRequest>(req_proto, req_proto_len) {
-        Ok(req) => req,
-        Err(message) => {
-            let resp = InitResponse {
-                error: Some(init_response::Error { message }),
-            };
-            return tmprl_bytes_t::from_vec(resp.encode_to_vec()).into_raw();
-        }
-    };
-
-    match wrappers::InitTelemetryRequest(req)
-        .try_into()
-        .map(|opts| telemetry_init(&opts))
-    {
-        Ok(_) => &*DEFAULT_INIT_RESPONSE_BYTES,
-        Err(message) => {
-            let resp = InitResponse {
-                error: Some(init_response::Error { message }),
-            };
-            tmprl_bytes_t::from_vec(resp.encode_to_vec()).into_raw()
-        }
-    }
-}
-
 /// A client instance owned by Core. This must be passed to [tmprl_client_free]
 /// when no longer in use which will free the resources.
 pub struct tmprl_client_t {
@@ -396,7 +355,7 @@ pub extern "C" fn tmprl_client_init(
         };
 
     let user_data = UserDataHandle(user_data);
-    runtime.tokio_runtime.spawn(async move {
+    runtime.core_runtime.tokio_handle().spawn(async move {
         match req.connect(namespace, None, None).await {
             Ok(client) => unsafe {
                 callback(
@@ -449,7 +408,7 @@ pub extern "C" fn tmprl_poll_workflow_activation(
 ) {
     let worker = unsafe { &mut *worker };
     let user_data = UserDataHandle(user_data);
-    worker.tokio_runtime.clone().spawn(async move {
+    worker.core_runtime.tokio_handle().spawn(async move {
         let resp = bridge::PollWorkflowActivationResponse {
             response: Some(match worker.poll_workflow_activation().await {
                 Ok(act) => bridge::poll_workflow_activation_response::Response::Activation(act),
@@ -480,7 +439,7 @@ pub extern "C" fn tmprl_poll_activity_task(
 ) {
     let worker = unsafe { &mut *worker };
     let user_data = UserDataHandle(user_data);
-    worker.tokio_runtime.clone().spawn(async move {
+    worker.core_runtime.tokio_handle().spawn(async move {
         let resp = bridge::PollActivityTaskResponse {
             response: Some(match worker.poll_activity_task().await {
                 Ok(task) => bridge::poll_activity_task_response::Response::Task(task),
@@ -521,7 +480,7 @@ pub extern "C" fn tmprl_complete_workflow_activation(
         }
     };
     let user_data = UserDataHandle(user_data);
-    worker.tokio_runtime.clone().spawn(async move {
+    worker.core_runtime.tokio_handle().spawn(async move {
         match worker.complete_workflow_activation(req).await {
             Ok(()) => unsafe {
                 callback(
@@ -567,7 +526,7 @@ pub extern "C" fn tmprl_complete_activity_task(
         }
     };
     let user_data = UserDataHandle(user_data);
-    worker.tokio_runtime.clone().spawn(async move {
+    worker.core_runtime.tokio_handle().spawn(async move {
         match worker.complete_activity_task(req).await {
             Ok(()) => unsafe {
                 callback(
@@ -615,7 +574,7 @@ pub extern "C" fn tmprl_record_activity_heartbeat(
     let user_data = UserDataHandle(user_data);
     // We intentionally spawn even though the core call is not async so the
     // callback can be made in the tokio runtime
-    worker.tokio_runtime.clone().spawn(async move {
+    worker.core_runtime.tokio_handle().spawn(async move {
         worker.record_activity_heartbeat(req);
         unsafe {
             callback(
@@ -658,7 +617,7 @@ pub extern "C" fn tmprl_request_workflow_eviction(
     let user_data = UserDataHandle(user_data);
     // We intentionally spawn even though the core call is not async so the
     // callback can be made in the tokio runtime
-    worker.tokio_runtime.clone().spawn(async move {
+    worker.core_runtime.tokio_handle().spawn(async move {
         worker.request_workflow_eviction(req);
         unsafe {
             callback(
@@ -669,59 +628,19 @@ pub extern "C" fn tmprl_request_workflow_eviction(
     });
 }
 
-/// Fetch buffered logs. Blocks until complete. This is still using the callback since we might
-/// reasonably change log fetching to be async in the future.
-///
-/// The `req_proto` and `req_proto_len` represent a byte array for a
-/// [bridge::FetchBufferedLogsRequest] protobuf message. The callback is invoked on completion with
-/// a [bridge::FetchBufferedLogsResponse] protobuf message.
-#[no_mangle]
-pub extern "C" fn tmprl_fetch_buffered_logs(
-    #[allow(unused_variables)] // We intentionally ignore the request
-    req_proto: *const u8,
-    #[allow(unused_variables)] req_proto_len: libc::size_t,
-    user_data: *mut libc::c_void,
-    callback: tmprl_callback,
-) {
-    let user_data = UserDataHandle(user_data);
-    // We intentionally spawn even though the core call is not async so the
-    // callback can be made in the tokio runtime
-    let resp = bridge::FetchBufferedLogsResponse {
-        entries: fetch_global_buffered_logs()
-            .into_iter()
-            .map(|log| bridge::fetch_buffered_logs_response::LogEntry {
-                message: log.message,
-                timestamp: Some(log.timestamp.into()),
-                level: match log.level {
-                    log::Level::Error => bridge::LogLevel::Error.into(),
-                    log::Level::Warn => bridge::LogLevel::Warn.into(),
-                    log::Level::Info => bridge::LogLevel::Info.into(),
-                    log::Level::Debug => bridge::LogLevel::Debug.into(),
-                    log::Level::Trace => bridge::LogLevel::Trace.into(),
-                },
-            })
-            .collect(),
-    };
-
-    unsafe {
-        callback(
-            user_data.into(),
-            // TODO: Creates vec every time since no worker/core instance. Can be fixed with a
-            //   pool if optimizations needed.
-            tmprl_bytes_t::from_vec(resp.encode_to_vec()).into_raw(),
-        )
-    };
-}
-
 impl tmprl_worker_t {
     fn new(
-        tokio_runtime: Arc<tokio::runtime::Runtime>,
+        core_runtime: Arc<CoreRuntime>,
         client: Arc<RetryClient<Client>>,
         opts: wrappers::WorkerConfig,
     ) -> Result<tmprl_worker_t, String> {
+        let worker = Arc::new(
+            temporal_sdk_core::init_worker(&core_runtime, opts.try_into()?, client)
+                .map_err(|e| e.to_string())?,
+        );
         Ok(tmprl_worker_t {
-            tokio_runtime,
-            worker: Arc::new(temporal_sdk_core::init_worker(opts.try_into()?, client)),
+            core_runtime,
+            worker,
         })
     }
 
@@ -793,6 +712,8 @@ impl tmprl_worker_t {
         self.worker.request_workflow_eviction(&req.run_id);
     }
 
+    // TODO: Fetch logs
+
     fn borrow_buf(&mut self) -> Vec<u8> {
         // We currently do not use a thread-safe byte pool, but if wanted, it
         // can be added here

package/sdk-core/bridge-ffi/src/wrappers.rs

@@ -1,40 +1,45 @@
-use log::LevelFilter;
 use std::{net::SocketAddr, str::FromStr};
-use temporal_sdk_core::{
-    Logger, MetricsExporter, OtelCollectorOptions, TelemetryOptionsBuilder, TraceExporter, Url,
+use temporal_sdk_core::Url;
+use temporal_sdk_core_api::telemetry::{
+    Logger, MetricsExporter, OtelCollectorOptions, TelemetryOptions, TelemetryOptionsBuilder,
+    TraceExportConfig, TraceExporter,
 };
 use temporal_sdk_core_protos::coresdk::bridge;
 
 // Present for try-from only
 pub struct InitTelemetryRequest(pub bridge::InitTelemetryRequest);
 
-impl TryFrom<InitTelemetryRequest> for temporal_sdk_core::TelemetryOptions {
+impl TryFrom<InitTelemetryRequest> for TelemetryOptions {
     type Error = String;
 
     fn try_from(InitTelemetryRequest(req): InitTelemetryRequest) -> Result<Self, Self::Error> {
         let mut telemetry_opts = TelemetryOptionsBuilder::default();
-        telemetry_opts.tracing_filter(req.tracing_filter.clone());
         match req.logging {
             None => {}
             Some(bridge::init_telemetry_request::Logging::Console(_)) => {
-                telemetry_opts.logging(Logger::Console);
+                telemetry_opts.logging(Logger::Console {
+                    filter: req.tracing_filter.clone(),
+                });
             }
             Some(bridge::init_telemetry_request::Logging::Forward(
                 bridge::init_telemetry_request::ForwardLoggerOptions { level },
             )) => {
-                if let Some(level) = bridge::LogLevel::from_i32(level) {
-                    let level = match level {
-                        bridge::LogLevel::Unspecified => {
-                            return Err("Must specify log level".to_string())
-                        }
-                        bridge::LogLevel::Off => LevelFilter::Off,
-                        bridge::LogLevel::Error => LevelFilter::Error,
-                        bridge::LogLevel::Warn => LevelFilter::Warn,
-                        bridge::LogLevel::Info => LevelFilter::Info,
-                        bridge::LogLevel::Debug => LevelFilter::Debug,
-                        bridge::LogLevel::Trace => LevelFilter::Trace,
-                    };
-                    telemetry_opts.logging(Logger::Forward(level));
+                if let Some(_level) = bridge::LogLevel::from_i32(level) {
+                    // TODO: This is ignored now, but I'm not fixing since we may never use this.
+                    // let level = match level {
+                    //     bridge::LogLevel::Unspecified => {
+                    //         return Err("Must specify log level".to_string())
+                    //     }
+                    //     bridge::LogLevel::Off => LevelFilter::OFF,
+                    //     bridge::LogLevel::Error => LevelFilter::ERROR,
+                    //     bridge::LogLevel::Warn => LevelFilter::WARN,
+                    //     bridge::LogLevel::Info => LevelFilter::INFO,
+                    //     bridge::LogLevel::Debug => LevelFilter::DEBUG,
+                    //     bridge::LogLevel::Trace => LevelFilter::TRACE,
+                    // };
+                    telemetry_opts.logging(Logger::Forward {
+                        filter: req.tracing_filter.clone(),
+                    });
                 } else {
                     return Err(format!("Unknown LogLevel: {}", level));
                 }
@@ -60,6 +65,7 @@ impl TryFrom<InitTelemetryRequest> for temporal_sdk_core::TelemetryOptions {
                         format!("invalid OpenTelemetry collector URL for metrics: {}", err)
                     })?,
                     headers,
+                    metric_periodicity: None,
                 }));
             }
         }
@@ -68,12 +74,16 @@ impl TryFrom<InitTelemetryRequest> for temporal_sdk_core::TelemetryOptions {
             Some(bridge::init_telemetry_request::Tracing::OtelTracing(
                 bridge::init_telemetry_request::OtelCollectorOptions { url, headers },
             )) => {
-                telemetry_opts.tracing(TraceExporter::Otel(OtelCollectorOptions {
-                    url: Url::parse(&url).map_err(|err| {
-                        format!("invalid OpenTelemetry collector URL for tracing: {}", err)
-                    })?,
-                    headers,
-                }));
+                telemetry_opts.tracing(TraceExportConfig {
+                    filter: req.tracing_filter.clone(),
+                    exporter: TraceExporter::Otel(OtelCollectorOptions {
+                        url: Url::parse(&url).map_err(|err| {
+                            format!("invalid OpenTelemetry collector URL for tracing: {}", err)
+                        })?,
+                        headers,
+                        metric_periodicity: None,
+                    }),
+                });
             }
         }
 

package/sdk-core/client/Cargo.toml

@@ -14,7 +14,7 @@ categories = ["development-tools"]
 anyhow = "1.0"
 async-trait = "0.1"
 backoff = "0.4"
-derive_builder = "0.11"
+derive_builder = "0.12"
 derive_more = "0.99"
 futures = "0.3"
 futures-retry = "0.6.0"

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

@@ -46,13 +46,12 @@ use temporal_sdk_core_protos::{
     coresdk::{workflow_commands::QueryResult, IntoPayloadsExt},
     grpc::health::v1::health_client::HealthClient,
     temporal::api::{
-        command::v1::Command,
         common::v1::{Header, Payload, Payloads, WorkflowExecution, WorkflowType},
         enums::v1::{TaskQueueKind, WorkflowIdReusePolicy, WorkflowTaskFailedCause},
         failure::v1::Failure,
         operatorservice::v1::operator_service_client::OperatorServiceClient,
         query::v1::WorkflowQuery,
-        taskqueue::v1::{StickyExecutionAttributes, TaskQueue},
+        taskqueue::v1::TaskQueue,
         testservice::v1::test_service_client::TestServiceClient,
         workflowservice::v1::{workflow_service_client::WorkflowServiceClient, *},
     },
@@ -181,6 +180,17 @@ impl RetryConfig {
         }
     }
 
+    pub(crate) const fn throttle_retry_policy() -> Self {
+        Self {
+            initial_interval: Duration::from_secs(1),
+            randomization_factor: 0.2,
+            multiplier: 2.0,
+            max_interval: Duration::from_secs(10),
+            max_elapsed_time: None,
+            max_retries: 0,
+        }
+    }
+
     pub(crate) fn into_exp_backoff<C>(self, clock: C) -> exponential::ExponentialBackoff<C> {
         exponential::ExponentialBackoff {
             current_interval: self.initial_interval,
@@ -362,24 +372,6 @@ impl ClientOptions {
     }
 }
 
-/// A version of [RespondWorkflowTaskCompletedRequest] that will finish being filled out by the
-/// server client
-#[derive(Debug, Clone, PartialEq)]
-pub struct WorkflowTaskCompletion {
-    /// The task token that would've been received from polling for a workflow activation
-    pub task_token: TaskToken,
-    /// A list of new commands to send to the server, such as starting a timer.
-    pub commands: Vec<Command>,
-    /// If set, indicate that next task should be queued on sticky queue with given attributes.
-    pub sticky_attributes: Option<StickyExecutionAttributes>,
-    /// Responses to queries in the `queries` field of the workflow task.
-    pub query_responses: Vec<QueryResult>,
-    /// Indicate that the task completion should return a new WFT if one is available
-    pub return_new_workflow_task: bool,
-    /// Force a new WFT to be created after this completion
-    pub force_create_new_workflow_task: bool,
-}
-
 /// Interceptor which attaches common metadata (like "client-name") to every outgoing call
 #[derive(Clone)]
 pub struct ServiceCallInterceptor {

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

@@ -542,6 +542,15 @@ proxier! {
             r.extensions_mut().insert(labels);
         }
     );
+    (
+        delete_workflow_execution,
+        DeleteWorkflowExecutionRequest,
+        DeleteWorkflowExecutionResponse,
+        |r| {
+            let labels = AttachMetricLabels::namespace(r.get_ref().namespace.clone());
+            r.extensions_mut().insert(labels);
+        }
+    );
     (
         list_open_workflow_executions,
         ListOpenWorkflowExecutionsRequest,
@@ -808,17 +817,9 @@ proxier! {
             r.extensions_mut().insert(labels);
         }
     );
-    (delete_workflow_execution, DeleteWorkflowExecutionRequest, DeleteWorkflowExecutionResponse,
-        |r| {
-            let labels = AttachMetricLabels::namespace(r.get_ref().namespace.clone());
-            r.extensions_mut().insert(labels);
-        }
-    );
     (add_or_update_remote_cluster, AddOrUpdateRemoteClusterRequest, AddOrUpdateRemoteClusterResponse);
     (remove_remote_cluster, RemoveRemoteClusterRequest, RemoveRemoteClusterResponse);
-    (describe_cluster, DescribeClusterRequest, DescribeClusterResponse);
     (list_clusters, ListClustersRequest, ListClustersResponse);
-    (list_cluster_members, ListClusterMembersRequest, ListClusterMembersResponse);
 }
 
 proxier! {