@temporalio/core-bridge 1.14.2-canary-release-testing.0 → 1.16.0

package/ts/native.ts

@@ -71,7 +71,11 @@ export type LogExporterOptions =
       receiver: (entries: JsonString<LogEntry>[]) => void;
     };
 
-export type MetricExporterOptions = PrometheusMetricsExporterOptions | OtelMetricsExporterOptions | null;
+export type MetricExporterOptions =
+  | PrometheusMetricsExporterOptions
+  | OtelMetricsExporterOptions
+  | BufferedMetricsExporterOptions
+  | null;
 
 export interface PrometheusMetricsExporterOptions {
   type: 'prometheus';
@@ -95,6 +99,12 @@ export interface OtelMetricsExporterOptions {
   protocol: 'http' | 'grpc';
 }
 
+export interface BufferedMetricsExporterOptions {
+  type: 'buffer';
+  maxBufferSize: number;
+  useSecondsForDurations: boolean;
+}
+
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 // Client
 ////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -168,7 +178,7 @@ export interface RpcCall {
 
 export declare function newWorker(client: Client, workerOptions: WorkerOptions): Worker;
 
-export declare function workerValidate(worker: Worker): Promise<void>;
+export declare function workerValidate(worker: Worker): Promise<Buffer>;
 
 export declare function workerPollWorkflowActivation(worker: Worker): Promise<Buffer>;
 
@@ -188,6 +198,8 @@ export declare function workerInitiateShutdown(worker: Worker): void;
 
 export declare function workerFinalizeShutdown(worker: Worker): Promise<void>;
 
+export declare function workerReplaceClient(worker: Worker, client: Client): void;
+
 export interface Worker {
   type: 'worker';
 }
@@ -245,7 +257,7 @@ export type PollerBehavior =
 export type WorkerDeploymentOptions = {
   version: WorkerDeploymentVersion;
   useWorkerVersioning: boolean;
-  defaultVersioningBehavior: VersioningBehavior;
+  defaultVersioningBehavior: Option<VersioningBehavior>;
 };
 
 export type WorkerDeploymentVersion = {
@@ -523,3 +535,27 @@ export declare function setMetricGaugeF64Value(
   value: number,
   attrs: JsonString<MetricAttributes>
 ): void;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+// Buffered Metrics
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
+export declare function runtimeRetrieveBufferedMetrics(runtime: Runtime): BufferedMetricUpdate[];
+
+export interface BufferedMetricUpdate {
+  metric: BufferedMetric;
+  value: number;
+  attributes: MetricAttributes;
+}
+
+export interface BufferedMetric {
+  name: string;
+  description: string;
+  unit: string;
+  kind: BufferedMetricKind;
+  valueType: BufferedMetricValueType;
+}
+
+export type BufferedMetricKind = 'counter' | 'histogram' | 'gauge';
+
+export type BufferedMetricValueType = 'int' | 'float';

package/sdk-core/crates/client/src/workflow_handle/mod.rs

@@ -1,212 +0,0 @@
-use crate::WorkflowService;
-use anyhow::{anyhow, bail};
-use std::{fmt::Debug, marker::PhantomData};
-use temporalio_common::protos::{
-    coresdk::FromPayloadsExt,
-    temporal::api::{
-        common::v1::{Payload, WorkflowExecution},
-        enums::v1::HistoryEventFilterType,
-        failure::v1::Failure,
-        history::v1::history_event::Attributes,
-        workflowservice::v1::GetWorkflowExecutionHistoryRequest,
-    },
-};
-use tonic::IntoRequest;
-
-/// Enumerates terminal states for a particular workflow execution
-// TODO: Add non-proto failure types, flesh out details, etc.
-#[derive(Debug)]
-#[allow(clippy::large_enum_variant)]
-pub enum WorkflowExecutionResult<T> {
-    /// The workflow finished successfully
-    Succeeded(T),
-    /// The workflow finished in failure
-    Failed(Failure),
-    /// The workflow was cancelled
-    Cancelled(Vec<Payload>),
-    /// The workflow was terminated
-    Terminated(Vec<Payload>),
-    /// The workflow timed out
-    TimedOut,
-    /// The workflow continued as new
-    ContinuedAsNew,
-}
-
-impl<T> WorkflowExecutionResult<T>
-where
-    T: Debug,
-{
-    /// Unwrap the result, panicking if it was not a success
-    pub fn unwrap_success(self) -> T {
-        match self {
-            Self::Succeeded(t) => t,
-            o => panic!("Expected success, got {o:?}"),
-        }
-    }
-}
-
-/// Options for fetching workflow results
-#[derive(Debug, Clone, Copy)]
-pub struct GetWorkflowResultOptions {
-    /// If true (the default), follows to the next workflow run in the execution chain while
-    /// retrieving results.
-    pub follow_runs: bool,
-}
-impl Default for GetWorkflowResultOptions {
-    fn default() -> Self {
-        Self { follow_runs: true }
-    }
-}
-
-/// A workflow handle which can refer to a specific workflow run, or a chain of workflow runs with
-/// the same workflow id.
-pub struct WorkflowHandle<ClientT, ResultT> {
-    client: ClientT,
-    info: WorkflowExecutionInfo,
-
-    _res_type: PhantomData<ResultT>,
-}
-
-/// Holds needed information to refer to a specific workflow run, or workflow execution chain
-#[derive(Debug)]
-pub struct WorkflowExecutionInfo {
-    /// Namespace the workflow lives in
-    pub namespace: String,
-    /// The workflow's id
-    pub workflow_id: String,
-    /// If set, target this specific run of the workflow
-    pub run_id: Option<String>,
-}
-
-impl WorkflowExecutionInfo {
-    /// Bind the workflow info to a specific client, turning it into a workflow handle
-    pub fn bind_untyped<CT>(self, client: CT) -> UntypedWorkflowHandle<CT>
-    where
-        CT: WorkflowService + Clone,
-    {
-        UntypedWorkflowHandle::new(client, self)
-    }
-}
-
-/// A workflow handle to a workflow with unknown types. Uses raw payloads.
-pub(crate) type UntypedWorkflowHandle<CT> = WorkflowHandle<CT, Vec<Payload>>;
-
-impl<CT, RT> WorkflowHandle<CT, RT>
-where
-    CT: WorkflowService + Clone,
-    // TODO: Make more generic, capable of (de)serialization w/ serde
-    RT: FromPayloadsExt,
-{
-    pub(crate) fn new(client: CT, info: WorkflowExecutionInfo) -> Self {
-        Self {
-            client,
-            info,
-            _res_type: PhantomData::<RT>,
-        }
-    }
-
-    /// Get the workflow execution info
-    pub fn info(&self) -> &WorkflowExecutionInfo {
-        &self.info
-    }
-
-    /// Get the client attached to this handle
-    pub fn client(&self) -> &CT {
-        &self.client
-    }
-
-    /// Await the result of the workflow execution
-    pub async fn get_workflow_result(
-        &self,
-        opts: GetWorkflowResultOptions,
-    ) -> Result<WorkflowExecutionResult<RT>, anyhow::Error> {
-        let mut next_page_tok = vec![];
-        let mut run_id = self.info.run_id.clone().unwrap_or_default();
-        loop {
-            let server_res = self
-                .client
-                .clone()
-                .get_workflow_execution_history(
-                    GetWorkflowExecutionHistoryRequest {
-                        namespace: self.info.namespace.to_string(),
-                        execution: Some(WorkflowExecution {
-                            workflow_id: self.info.workflow_id.clone(),
-                            run_id: run_id.clone(),
-                        }),
-                        skip_archival: true,
-                        wait_new_event: true,
-                        history_event_filter_type: HistoryEventFilterType::CloseEvent as i32,
-                        next_page_token: next_page_tok.clone(),
-                        ..Default::default()
-                    }
-                    .into_request(),
-                )
-                .await?
-                .into_inner();
-
-            let mut history = server_res
-                .history
-                .ok_or_else(|| anyhow!("Server returned an empty history!"))?;
-
-            if history.events.is_empty() {
-                next_page_tok = server_res.next_page_token;
-                continue;
-            }
-            // If page token was previously set, clear it.
-            next_page_tok = vec![];
-
-            let event_attrs = history.events.pop().and_then(|ev| ev.attributes);
-
-            macro_rules! follow {
-                ($attrs:ident) => {
-                    if opts.follow_runs && $attrs.new_execution_run_id != "" {
-                        run_id = $attrs.new_execution_run_id;
-                        continue;
-                    }
-                };
-            }
-
-            break match event_attrs {
-                Some(Attributes::WorkflowExecutionCompletedEventAttributes(attrs)) => {
-                    follow!(attrs);
-                    Ok(WorkflowExecutionResult::Succeeded(RT::from_payloads(
-                        attrs.result,
-                    )))
-                }
-                Some(Attributes::WorkflowExecutionFailedEventAttributes(attrs)) => {
-                    follow!(attrs);
-                    Ok(WorkflowExecutionResult::Failed(
-                        attrs.failure.unwrap_or_default(),
-                    ))
-                }
-                Some(Attributes::WorkflowExecutionCanceledEventAttributes(attrs)) => Ok(
-                    WorkflowExecutionResult::Cancelled(Vec::from_payloads(attrs.details)),
-                ),
-                Some(Attributes::WorkflowExecutionTimedOutEventAttributes(attrs)) => {
-                    follow!(attrs);
-                    Ok(WorkflowExecutionResult::TimedOut)
-                }
-                Some(Attributes::WorkflowExecutionTerminatedEventAttributes(attrs)) => Ok(
-                    WorkflowExecutionResult::Terminated(Vec::from_payloads(attrs.details)),
-                ),
-                Some(Attributes::WorkflowExecutionContinuedAsNewEventAttributes(attrs)) => {
-                    if opts.follow_runs {
-                        if !attrs.new_execution_run_id.is_empty() {
-                            run_id = attrs.new_execution_run_id;
-                            continue;
-                        } else {
-                            bail!("New execution run id was empty in continue as new event!");
-                        }
-                    } else {
-                        Ok(WorkflowExecutionResult::ContinuedAsNew)
-                    }
-                }
-                o => Err(anyhow!(
-                    "Server returned an event that didn't match the CloseEvent filter. \
-                     This is either a server bug or a new event the SDK does not understand. \
-                     Event details: {o:?}"
-                )),
-            };
-        }
-    }
-}

package/sdk-core/crates/common/src/errors.rs

@@ -1,85 +0,0 @@
-//! Error types exposed by public APIs
-
-use crate::protos::coresdk::activity_result::ActivityExecutionResult;
-
-/// Errors thrown by [crate::Worker::validate]
-#[derive(thiserror::Error, Debug)]
-pub enum WorkerValidationError {
-    /// The namespace provided to the worker does not exist on the server.
-    #[error("Namespace {namespace} was not found or otherwise could not be described: {source:?}")]
-    NamespaceDescribeError {
-        source: tonic::Status,
-        namespace: String,
-    },
-}
-
-/// Errors thrown by [crate::Worker] polling methods
-#[derive(thiserror::Error, Debug)]
-pub enum PollError {
-    /// [crate::Worker::shutdown] was called, and there are no more tasks to be handled from this
-    /// poll function. Lang must call [crate::Worker::complete_workflow_activation],
-    /// [crate::Worker::complete_activity_task], or
-    /// [crate::Worker::complete_nexus_task] for any remaining tasks, and then may exit.
-    #[error("Core is shut down and there are no more tasks of this kind")]
-    ShutDown,
-    /// Unhandled error when calling the temporal server. Core will attempt to retry any non-fatal
-    /// errors, so lang should consider this fatal.
-    #[error("Unhandled grpc error when polling: {0:?}")]
-    TonicError(#[from] tonic::Status),
-}
-
-/// Errors thrown by [crate::Worker::complete_workflow_activation]
-#[derive(thiserror::Error, Debug)]
-#[allow(clippy::large_enum_variant)]
-pub enum CompleteWfError {
-    /// Lang SDK sent us a malformed workflow completion. This likely means a bug in the lang sdk.
-    #[error("Lang SDK sent us a malformed workflow completion for run ({run_id}): {reason}")]
-    MalformedWorkflowCompletion {
-        /// Reason the completion was malformed
-        reason: String,
-        /// The run associated with the completion
-        run_id: String,
-    },
-    /// Workflows have not been enabled on this worker.
-    #[error("Workflows are not enabled on this worker")]
-    WorkflowNotEnabled,
-}
-
-/// Errors thrown by [crate::Worker::complete_activity_task]
-#[derive(thiserror::Error, Debug)]
-#[allow(clippy::large_enum_variant)]
-pub enum CompleteActivityError {
-    /// Lang SDK sent us a malformed activity completion. This likely means a bug in the lang sdk.
-    #[error("Lang SDK sent us a malformed activity completion ({reason}): {completion:?}")]
-    MalformedActivityCompletion {
-        /// Reason the completion was malformed
-        reason: String,
-        /// The completion, which may not be included to avoid unnecessary copies.
-        completion: Option<ActivityExecutionResult>,
-    },
-    /// Activities have not been enabled on this worker.
-    #[error("Activities are not enabled on this worker")]
-    ActivityNotEnabled,
-}
-
-/// Errors thrown by [crate::Worker::complete_nexus_task]
-#[derive(thiserror::Error, Debug)]
-pub enum CompleteNexusError {
-    /// Lang SDK sent us a malformed nexus completion. This likely means a bug in the lang sdk.
-    #[error("Lang SDK sent us a malformed nexus completion: {reason}")]
-    MalformedNexusCompletion {
-        /// Reason the completion was malformed
-        reason: String,
-    },
-    /// Nexus has not been enabled on this worker. If a user registers any Nexus handlers, the
-    #[error("Nexus is not enabled on this worker")]
-    NexusNotEnabled,
-}
-
-/// Errors we can encounter during workflow processing which we may treat as either WFT failures
-/// or whole-workflow failures depending on user preference.
-#[derive(Clone, Debug, Eq, PartialEq, Hash)]
-pub enum WorkflowErrorType {
-    /// A nondeterminism error
-    Nondeterminism,
-}

package/sdk-core/crates/common/tests/worker_task_types_test.rs

@@ -1,129 +0,0 @@
-use temporalio_common::worker::{WorkerConfigBuilder, WorkerTaskTypes, WorkerVersioningStrategy};
-
-fn default_versioning_strategy() -> WorkerVersioningStrategy {
-    WorkerVersioningStrategy::None {
-        build_id: String::new(),
-    }
-}
-
-#[test]
-fn test_default_configuration_polls_all_types() {
-    let config = WorkerConfigBuilder::default()
-        .namespace("default")
-        .task_queue("test-queue")
-        .versioning_strategy(default_versioning_strategy())
-        .task_types(WorkerTaskTypes::all())
-        .build()
-        .expect("Failed to build default config");
-
-    let effective = &config.task_types;
-    assert!(
-        effective.enable_workflows,
-        "Should poll workflows by default"
-    );
-    assert!(
-        effective.enable_local_activities,
-        "should poll local activities by default"
-    );
-    assert!(
-        effective.enable_remote_activities,
-        "Should poll remote activities by default"
-    );
-    assert!(effective.enable_nexus, "Should poll nexus by default");
-}
-
-#[test]
-fn test_invalid_task_types_fails_validation() {
-    // empty task types
-    let result = WorkerConfigBuilder::default()
-        .namespace("default")
-        .task_queue("test-queue")
-        .versioning_strategy(default_versioning_strategy())
-        .task_types(WorkerTaskTypes {
-            enable_workflows: false,
-            enable_local_activities: false,
-            enable_remote_activities: false,
-            enable_nexus: false,
-        })
-        .build();
-
-    assert!(result.is_err(), "Empty task_types should fail validation");
-    let err = result.err().unwrap().to_string();
-    assert!(
-        err.contains("At least one task type"),
-        "Error should mention task types: {err}",
-    );
-
-    // local activities with no workflows
-    let result = WorkerConfigBuilder::default()
-        .namespace("default")
-        .task_queue("test-queue")
-        .versioning_strategy(default_versioning_strategy())
-        .task_types(WorkerTaskTypes {
-            enable_workflows: false,
-            enable_local_activities: true,
-            enable_remote_activities: false,
-            enable_nexus: false,
-        })
-        .build();
-
-    assert!(result.is_err(), "Empty task_types should fail validation");
-    let err = result.err().unwrap().to_string();
-    assert!(
-        err.contains("cannot enable local activities without workflows"),
-        "Error should mention task types: {err}",
-    );
-}
-
-#[test]
-fn test_all_combinations() {
-    let combinations = [
-        (WorkerTaskTypes::workflow_only(), "workflows only"),
-        (WorkerTaskTypes::activity_only(), "activities only"),
-        (WorkerTaskTypes::nexus_only(), "nexus only"),
-        (
-            WorkerTaskTypes {
-                enable_workflows: true,
-                enable_local_activities: true,
-                enable_remote_activities: true,
-                enable_nexus: false,
-            },
-            "workflows + activities",
-        ),
-        (
-            WorkerTaskTypes {
-                enable_workflows: true,
-                enable_local_activities: true,
-                enable_remote_activities: false,
-                enable_nexus: true,
-            },
-            "workflows + nexus",
-        ),
-        (
-            WorkerTaskTypes {
-                enable_workflows: false,
-                enable_local_activities: false,
-                enable_remote_activities: true,
-                enable_nexus: true,
-            },
-            "activities + nexus",
-        ),
-        (WorkerTaskTypes::all(), "all types"),
-    ];
-
-    for (task_types, description) in combinations {
-        let config = WorkerConfigBuilder::default()
-            .namespace("default")
-            .task_queue("test-queue")
-            .versioning_strategy(default_versioning_strategy())
-            .task_types(task_types)
-            .build()
-            .unwrap_or_else(|e| panic!("Failed to build config for {description}: {e:?}"));
-
-        let effective = config.task_types;
-        assert_eq!(
-            effective, task_types,
-            "Effective types should match for {description}",
-        );
-    }
-}

package/sdk-core/crates/macros/LICENSE.txt

@@ -1,21 +0,0 @@
-The MIT License
-
-Copyright (c) 2021 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.