Add a new parameter to distinguish initial runAlarm from retries.

src/workerd/io/worker-entrypoint.c++

@@ -60,7 +60,7 @@ public:
       kj::HttpConnectSettings settings) override;
   void prewarm(kj::StringPtr url) override;
   kj::Promise<ScheduledResult> runScheduled(kj::Date scheduledTime, kj::StringPtr cron) override;
-  kj::Promise<AlarmResult> runAlarm(kj::Date scheduledTime) override;
+  kj::Promise<AlarmResult> runAlarm(kj::Date scheduledTime, bool isActorAlarmRetry) override;
   kj::Promise<bool> test() override;
   kj::Promise<CustomEvent::Result> customEvent(kj::Own<CustomEvent> event) override;
 
@@ -601,7 +601,7 @@ kj::Promise<WorkerInterface::AlarmResult> WorkerEntrypoint::runAlarmImpl(
 }
 
 kj::Promise<WorkerInterface::AlarmResult> WorkerEntrypoint::runAlarm(
-    kj::Date scheduledTime) {
+    kj::Date scheduledTime, bool isActorAlarmRetry) {
   TRACE_EVENT("workerd", "WorkerEntrypoint::runAlarm()");
   auto incomingRequest = kj::mv(KJ_REQUIRE_NONNULL(this->incomingRequest,
                                 "runAlarm() can only be called once"));

src/workerd/io/worker-interface.c++

@@ -71,12 +71,12 @@ public:
     }
   }
 
-  kj::Promise<AlarmResult> runAlarm(kj::Date scheduledTime) override {
+  kj::Promise<AlarmResult> runAlarm(kj::Date scheduledTime, bool isActorAlarmRetry) override {
     KJ_IF_SOME(w, worker) {
-      co_return co_await w.get()->runAlarm(scheduledTime);
+      co_return co_await w.get()->runAlarm(scheduledTime, isActorAlarmRetry);
     } else {
       co_await promise;
-      co_return co_await KJ_ASSERT_NONNULL(worker)->runAlarm(scheduledTime);
+      co_return co_await KJ_ASSERT_NONNULL(worker)->runAlarm(scheduledTime, isActorAlarmRetry);
     }
   }
 
@@ -222,7 +222,7 @@ public:
       kj::HttpConnectSettings settings) override;
   void prewarm(kj::StringPtr url) override;
   kj::Promise<ScheduledResult> runScheduled(kj::Date scheduledTime, kj::StringPtr cron) override;
-  kj::Promise<AlarmResult> runAlarm(kj::Date scheduledTime) override;
+  kj::Promise<AlarmResult> runAlarm(kj::Date scheduledTime, bool isActorAlarmRetry) override;
   kj::Promise<CustomEvent::Result> customEvent(kj::Own<CustomEvent> event) override;
 
 private:
@@ -259,8 +259,8 @@ kj::Promise<WorkerInterface::ScheduledResult> RevocableWebSocketWorkerInterface:
   return worker.runScheduled(scheduledTime, cron);
 }
 
-kj::Promise<WorkerInterface::AlarmResult> RevocableWebSocketWorkerInterface::runAlarm(kj::Date scheduledTime) {
-  return worker.runAlarm(scheduledTime);
+kj::Promise<WorkerInterface::AlarmResult> RevocableWebSocketWorkerInterface::runAlarm(kj::Date scheduledTime, bool isActorAlarmRetry) {
+  return worker.runAlarm(scheduledTime, isActorAlarmRetry);
 }
 
 kj::Promise<WorkerInterface::CustomEvent::Result>
@@ -305,7 +305,7 @@ public:
     kj::throwFatalException(kj::mv(exception));
   }
 
-  kj::Promise<AlarmResult> runAlarm(kj::Date scheduledTime) override {
+  kj::Promise<AlarmResult> runAlarm(kj::Date scheduledTime, bool isActorAlarmRetry) override {
     kj::throwFatalException(kj::mv(exception));
   }
 
@@ -373,9 +373,10 @@ kj::Promise<WorkerInterface::ScheduledResult> RpcWorkerInterface::runScheduled(
   });
 }
 
-kj::Promise<WorkerInterface::AlarmResult> RpcWorkerInterface::runAlarm(kj::Date scheduledTime) {
+kj::Promise<WorkerInterface::AlarmResult> RpcWorkerInterface::runAlarm(kj::Date scheduledTime, bool isActorAlarmRetry) {
   auto req = dispatcher.runAlarmRequest();
   req.setScheduledTime((scheduledTime - kj::UNIX_EPOCH) / kj::MILLISECONDS);
+  req.setIsRetry(isActorAlarmRetry);
   return req.send().then([](auto resp) {
     auto respResult = resp.getResult();
     return WorkerInterface::AlarmResult {

src/workerd/io/worker-interface.capnp

@@ -214,9 +214,10 @@ interface EventDispatcher @0xf20697475ec1752d {
   # the outcome and whether the run should be retried. This does not complete immediately.
 
 
-  runAlarm @4 (scheduledTime :Int64) -> (result :AlarmRun);
+  runAlarm @4 (scheduledTime :Int64, isRetry :Bool) -> (result :AlarmRun);
   # Runs a worker's alarm.
   # scheduledTime is a unix timestamp in milliseconds for when the alarm should be run
+  # isRetry indicates wether this runAlarm is a retry or not.
   # Returns an AlarmRun, detailing information about the run such as
   # the outcome and whether the run should be retried. This does not complete immediately.
   #

src/workerd/io/worker-interface.h

@@ -80,7 +80,7 @@ class WorkerInterface: public kj::HttpService {
   virtual kj::Promise<ScheduledResult> runScheduled(kj::Date scheduledTime, kj::StringPtr cron) = 0;
 
   // Trigger an alarm event with the given scheduled (unix timestamp) time.
-  virtual kj::Promise<AlarmResult> runAlarm(kj::Date scheduledTime) = 0;
+  virtual kj::Promise<AlarmResult> runAlarm(kj::Date scheduledTime, bool isActorAlarmRetry) = 0;
 
   // Run the test handler. The returned promise resolves to true or false to indicate that the test
   // passed or failed. In the case of a failure, information should have already been written to
@@ -178,7 +178,7 @@ class RpcWorkerInterface: public WorkerInterface {
 
   void prewarm(kj::StringPtr url) override;
   kj::Promise<ScheduledResult> runScheduled(kj::Date scheduledTime, kj::StringPtr cron) override;
-  kj::Promise<AlarmResult> runAlarm(kj::Date scheduledTime) override;
+  kj::Promise<AlarmResult> runAlarm(kj::Date scheduledTime, bool isActorAlarmRetry) override;
   kj::Promise<CustomEvent::Result> customEvent(kj::Own<CustomEvent> event) override;
 
 private:

src/workerd/io/worker.c++

@@ -3105,8 +3105,9 @@ void Worker::Actor::Impl::HooksImpl::updateAlarmInMemory(kj::Maybe<kj::Date> new
 
     for (auto i : kj::zeroTo(WorkerInterface::ALARM_RETRY_MAX_TRIES)) {
       co_await timerChannel.atTime(scheduledTime);
+      // TODO(now): Set correct retry info here.
       auto result = co_await loopback->getWorker(IoChannelFactory::SubrequestMetadata{})
-          ->runAlarm(originalTime);
+          ->runAlarm(originalTime, false);
 
       if (result.outcome == EventOutcome::OK || !result.retry) {
         break;
@@ -3475,7 +3476,7 @@ public:
       kj::HttpConnectSettings settings) override;
   void prewarm(kj::StringPtr url) override;
   kj::Promise<ScheduledResult> runScheduled(kj::Date scheduledTime, kj::StringPtr cron) override;
-  kj::Promise<AlarmResult> runAlarm(kj::Date scheduledTime) override;
+  kj::Promise<AlarmResult> runAlarm(kj::Date scheduledTime, bool isActorAlarmRetry) override;
   kj::Promise<CustomEvent::Result> customEvent(kj::Own<CustomEvent> event) override;
 
 private:
@@ -3700,8 +3701,8 @@ kj::Promise<WorkerInterface::ScheduledResult> Worker::Isolate::SubrequestClient:
   return inner->runScheduled(scheduledTime, cron);
 }
 kj::Promise<WorkerInterface::AlarmResult> Worker::Isolate::SubrequestClient::runAlarm(
-    kj::Date scheduledTime) {
-  return inner->runAlarm(scheduledTime);
+    kj::Date scheduledTime, bool isActorAlarmRetry) {
+  return inner->runAlarm(scheduledTime, isActorAlarmRetry);
 }
 kj::Promise<WorkerInterface::CustomEvent::Result>
     Worker::Isolate::SubrequestClient::customEvent(kj::Own<CustomEvent> event) {

src/workerd/server/alarm-scheduler.c++

@@ -151,9 +151,9 @@ bool AlarmScheduler::deleteAlarm(ActorKey actor) {
 }
 
 kj::Promise<AlarmScheduler::RetryInfo> AlarmScheduler::runAlarm(
-    const ActorKey& actor, kj::Date scheduledTime) {
+    const ActorKey& actor, kj::Date scheduledTime, bool isRetry) {
   KJ_IF_SOME(ns, namespaces.find(actor.uniqueKey)) {
-    auto result = co_await ns.getActor(kj::str(actor.actorId))->runAlarm(scheduledTime);
+    auto result = co_await ns.getActor(kj::str(actor.actorId))->runAlarm(scheduledTime, isRetry);
 
     co_return RetryInfo {
       .retry = result.outcome != EventOutcome::OK && result.retry,
@@ -166,7 +166,7 @@ kj::Promise<AlarmScheduler::RetryInfo> AlarmScheduler::runAlarm(
 
 AlarmScheduler::ScheduledAlarm AlarmScheduler::scheduleAlarm(
     kj::Date now, kj::Own<ActorKey> actor, kj::Date scheduledTime) {
-  auto task = makeAlarmTask(scheduledTime - now, *actor, scheduledTime);
+  auto task = makeAlarmTask(scheduledTime - now, *actor, scheduledTime, false);
 
   return ScheduledAlarm { kj::mv(actor), scheduledTime, kj::mv(task) };
 }
@@ -187,7 +187,8 @@ kj::Promise<void> AlarmScheduler::checkTimestamp(kj::Duration delay, kj::Date sc
 
 kj::Promise<void> AlarmScheduler::makeAlarmTask(kj::Duration delay,
                                                 const ActorKey& actorRef,
-                                                kj::Date scheduledTime) {
+                                                kj::Date scheduledTime,
+                                                bool isRetry) {
   co_await checkTimestamp(delay, scheduledTime);
 
   {
@@ -197,7 +198,7 @@ kj::Promise<void> AlarmScheduler::makeAlarmTask(kj::Duration delay,
 
   auto retryInfo = co_await ([&]() -> kj::Promise<RetryInfo> {
     try {
-      co_return co_await runAlarm(actorRef, scheduledTime);
+      co_return co_await runAlarm(actorRef, scheduledTime, isRetry);
     } catch (...) {
       auto exception = kj::getCaughtExceptionAsKj();
       KJ_LOG(WARNING, exception);
@@ -265,7 +266,8 @@ kj::Promise<void> AlarmScheduler::makeAlarmTask(kj::Duration delay,
       entry.value.backoff++;
       entry.value.retry++;
 
-      entry.value.task = makeAlarmTask(delay, actorRef, scheduledTime);
+      // This alarm task is a retry. As such, we set isRetry to true.
+      entry.value.task = makeAlarmTask(delay, actorRef, scheduledTime, true);
     } else {
       KJ_ASSERT(entry.value.queuedAlarm == kj::none);
       deleteAlarm(actorRef);

src/workerd/server/alarm-scheduler.h

@@ -112,13 +112,13 @@ class AlarmScheduler final : kj::TaskSet::ErrorHandler {
     bool retry;
     bool retryCountsAgainstLimit;
   };
-  kj::Promise<RetryInfo> runAlarm(const ActorKey& actor, kj::Date scheduledTime);
+  kj::Promise<RetryInfo> runAlarm(const ActorKey& actor, kj::Date scheduledTime, bool isRetry);
 
   void setAlarmInMemory(kj::Own<ActorKey> actor, kj::Date scheduledTime);
 
   ScheduledAlarm scheduleAlarm(kj::Date now, kj::Own<ActorKey> actor, kj::Date scheduledTime);
 
-  kj::Promise<void> makeAlarmTask(kj::Duration delay, const ActorKey& actor, kj::Date scheduledTime);
+  kj::Promise<void> makeAlarmTask(kj::Duration delay, const ActorKey& actor, kj::Date scheduledTime, bool isRetry);
 
   kj::Promise<void> checkTimestamp(kj::Duration delay, kj::Date scheduledTime);