impl

Author: THardy98

packages/activity/src/index.ts

@@ -48,7 +48,7 @@
  *
  * 1. `await` on {@link Context.cancelled | `Context.current().cancelled`} or
  *    {@link Context.sleep | `Context.current().sleep()`}, which each throw a {@link CancelledFailure}.
- * 1. Pass the context's {@link https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal | `AbortSignal`} at
+ * 2. Pass the context's {@link https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal | `AbortSignal`} at
  *    {@link Context.cancellationSignal | `Context.current().cancellationSignal`} to a library that supports it.
  *
  * ### Examples
@@ -70,7 +70,16 @@
  */
 
 import { AsyncLocalStorage } from 'node:async_hooks';
-import { Logger, Duration, LogLevel, LogMetadata, MetricMeter, Priority } from '@temporalio/common';
+import {
+  Logger,
+  Duration,
+  LogLevel,
+  LogMetadata,
+  MetricMeter,
+  Priority,
+  ActivityCancellationDetailsHolder,
+  ActivityCancellationDetails,
+} from '@temporalio/common';
 import { msToNumber } from '@temporalio/common/lib/time';
 import { SymbolBasedInstanceOfError } from '@temporalio/common/lib/type-helpers';
 
@@ -289,6 +298,11 @@ export class Context {
    */
   public readonly metricMeter: MetricMeter;
 
+  /**
+   * Holder object for activity cancellation details
+   */
+  public readonly cancellationDetails: ActivityCancellationDetailsHolder;
+
   /**
    * **Not** meant to instantiated by Activity code, used by the worker.
    *
@@ -300,14 +314,16 @@ export class Context {
     cancellationSignal: AbortSignal,
     heartbeat: (details?: any) => void,
     log: Logger,
-    metricMeter: MetricMeter
+    metricMeter: MetricMeter,
+    details: ActivityCancellationDetailsHolder
   ) {
     this.info = info;
     this.cancelled = cancelled;
     this.cancellationSignal = cancellationSignal;
     this.heartbeatFn = heartbeat;
     this.log = log;
     this.metricMeter = metricMeter;
+    this.cancellationDetails = details;
   }
 
   /**
@@ -427,6 +443,13 @@ export function cancelled(): Promise<never> {
   return Context.current().cancelled;
 }
 
+/**
+ * Returns the cancellation details for this activity, if any.
+ */
+export function cancellationDetails(): ActivityCancellationDetails | undefined {
+  return Context.current().cancellationDetails.details;
+}
+
 /**
  * Return an {@link https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal | `AbortSignal`} that can be used to
  * react to Activity cancellation.

packages/common/src/activity-cancellation-details.ts

@@ -0,0 +1,45 @@
+import type { coresdk } from '@temporalio/proto';
+
+export interface ActivityCancellationDetailsHolder {
+  details?: ActivityCancellationDetails;
+}
+
+/**
+ * Provides the reasons for the activity's cancellation. Cancellation details are set once and do not change once set.
+ */
+export class ActivityCancellationDetails {
+  readonly notFound: boolean;
+  readonly cancelRequested: boolean;
+  readonly paused: boolean;
+  readonly timedOut: boolean;
+  readonly workerShutdown: boolean;
+
+  private constructor(
+    notFound: boolean = false,
+    cancelRequested: boolean = false,
+    paused: boolean = false,
+    timedOut: boolean = false,
+    workerShutdown: boolean = false
+  ) {
+    this.notFound = notFound;
+    this.cancelRequested = cancelRequested;
+    this.paused = paused;
+    this.timedOut = timedOut;
+    this.workerShutdown = workerShutdown;
+  }
+
+  static fromProto(
+    proto: coresdk.activity_task.IActivityCancellationDetails | null | undefined
+  ): ActivityCancellationDetails {
+    if (proto == null) {
+      return new ActivityCancellationDetails();
+    }
+    return new ActivityCancellationDetails(
+      proto.isNotFound ?? false,
+      proto.isCancelled ?? false,
+      proto.isPaused ?? false,
+      proto.isTimedOut ?? false,
+      proto.isWorkerShutdown ?? false
+    );
+  }
+}

packages/common/src/index.ts

@@ -8,6 +8,7 @@ import * as encoding from './encoding';
 import * as helpers from './type-helpers';
 
 export * from './activity-options';
+export * from './activity-cancellation-details';
 export * from './converter/data-converter';
 export * from './converter/failure-converter';
 export * from './converter/payload-codec';

packages/core-bridge/src/worker.rs

@@ -520,9 +520,7 @@ mod config {
     impl From<PollerBehavior> for CorePollerBehavior {
         fn from(val: PollerBehavior) -> Self {
             match val {
-                PollerBehavior::SimpleMaximum { maximum } => {
-                    Self::SimpleMaximum(maximum)
-                }
+                PollerBehavior::SimpleMaximum { maximum } => Self::SimpleMaximum(maximum),
                 PollerBehavior::Autoscaling {
                     minimum,
                     maximum,
@@ -771,10 +769,7 @@ mod custom_slot_supplier {
                 slot_type: SK::kind().into(),
                 task_queue: ctx.task_queue().to_string(),
                 worker_identity: ctx.worker_identity().to_string(),
-                worker_deployment_version: ctx
-                    .worker_deployment_version()
-                    .clone()
-                    .map(Into::into),
+                worker_deployment_version: ctx.worker_deployment_version().clone().map(Into::into),
                 is_sticky: ctx.is_sticky(),
             };
 

packages/worker/src/activity.ts

@@ -1,6 +1,8 @@
 import 'abort-controller/polyfill'; // eslint-disable-line import/no-unassigned-import
 import { asyncLocalStorage, CompleteAsyncError, Context, Info } from '@temporalio/activity';
 import {
+  ActivityCancellationDetails,
+  ActivityCancellationDetailsHolder,
   ActivityFunction,
   ApplicationFailure,
   CancelledFailure,
@@ -34,8 +36,9 @@ export type CancelReason =
 
 export class Activity {
   protected cancelReason?: CancelReason;
+  protected cancellationDetails: ActivityCancellationDetailsHolder;
   public readonly context: Context;
-  public cancel: (reason: CancelReason) => void = () => undefined;
+  public cancel: (reason: CancelReason, details: ActivityCancellationDetails) => void = () => undefined;
   public readonly abortController: AbortController = new AbortController();
   public readonly interceptors: {
     inbound: ActivityInboundCallsInterceptor[];
@@ -65,10 +68,11 @@ export class Activity {
   ) {
     this.workerLogger = LoggerWithComposedMetadata.compose(workerLogger, this.getLogAttributes.bind(this));
     this.metricMeter = MetricMeterWithComposedTags.compose(workerMetricMeter, this.getMetricTags.bind(this));
-
+    this.cancellationDetails = {};
     const promise = new Promise<never>((_, reject) => {
-      this.cancel = (reason: CancelReason) => {
+      this.cancel = (reason: CancelReason, details: ActivityCancellationDetails) => {
         this.cancelReason = reason;
+        this.cancellationDetails.details = details;
         const err = new CancelledFailure(reason);
         this.abortController.abort(err);
         reject(err);
@@ -81,7 +85,8 @@ export class Activity {
       this.heartbeatCallback,
       // This is the activity context logger, to be used exclusively from user code
       LoggerWithComposedMetadata.compose(this.workerLogger, { sdkComponent: SdkComponent.activity }),
-      this.metricMeter
+      this.metricMeter,
+      this.cancellationDetails
     );
     // Prevent unhandled rejection
     promise.catch(() => undefined);

packages/worker/src/worker.ts

@@ -33,6 +33,7 @@ import {
   TypedSearchAttributes,
   decodePriority,
   MetricMeter,
+  ActivityCancellationDetails,
 } from '@temporalio/common';
 import {
   decodeArrayFromPayloads,
@@ -988,7 +989,12 @@ export class Worker {
                           base64TaskToken,
                           details,
                           onError() {
-                            activity?.cancel('HEARTBEAT_DETAILS_CONVERSION_FAILED'); // activity must be defined
+                            // activity must be defined
+                            // empty cancellation details, not corresponding detail for heartbeat detail conversion failure
+                            activity?.cancel(
+                              'HEARTBEAT_DETAILS_CONVERSION_FAILED',
+                              ActivityCancellationDetails.fromProto(undefined)
+                            );
                           },
                         }),
                       this.logger,
@@ -1027,11 +1033,15 @@ export class Worker {
                   // NOTE: activity will not be considered cancelled until it confirms cancellation (by throwing a CancelledFailure)
                   this.logger.trace('Cancelling activity', activityLogAttributes(activity.info));
                   const reason = task.cancel?.reason;
+                  const cancellationDetails = task.cancel?.details;
                   if (reason === undefined || reason === null) {
                     // Special case of Lang side cancellation during shutdown (see `activity.shutdown.evict` above)
-                    activity.cancel('WORKER_SHUTDOWN');
+                    activity.cancel('WORKER_SHUTDOWN', ActivityCancellationDetails.fromProto(cancellationDetails));
                   } else {
-                    activity.cancel(coresdk.activity_task.ActivityCancelReason[reason] as CancelReason);
+                    activity.cancel(
+                      coresdk.activity_task.ActivityCancelReason[reason] as CancelReason,
+                      ActivityCancellationDetails.fromProto(cancellationDetails)
+                    );
                   }
                   break;
                 }