fix(sync): discard pending delayed tasks on shutdown

Move delayed task cleanup from the shutdown pre-prune pass into the
worker thread itself. When the worker encounters a delayed task that
is not yet ready and shutdown has been signaled, it discards all
remaining tasks. This catches tasks submitted during execution that
the one-time pre-prune in shutdown could not see.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: jpnurmi

src/sentry_sync.c

@@ -265,6 +265,16 @@ worker_thread(void *data)
         {
             uint64_t now = sentry__monotonic_time();
             if (now < task->execute_after) {
+                // discard delayed tasks submitted after shutdown pruning
+                if (!sentry__atomic_fetch(&bgw->running)) {
+                    while (bgw->first_task) {
+                        sentry_bgworker_task_t *t = bgw->first_task;
+                        bgw->first_task = t->next_task;
+                        sentry__task_decref(t);
+                    }
+                    bgw->last_task = NULL;
+                    continue;
+                }
                 sentry__cond_wait_timeout(&bgw->submit_signal, &bgw->task_lock,
                     (uint32_t)(task->execute_after - now));
                 continue;
@@ -419,30 +429,6 @@ sentry__bgworker_shutdown(sentry_bgworker_t *bgw, uint64_t timeout)
 
     uint64_t started = sentry__monotonic_time();
     sentry__mutex_lock(&bgw->task_lock);
-
-    // prune delayed tasks that exceed the shutdown timeout
-    sentry_bgworker_task_t *prev = NULL;
-    sentry_bgworker_task_t *cur = bgw->first_task;
-    while (cur) {
-        if (cur->execute_after > started + timeout) {
-            if (prev) {
-                prev->next_task = NULL;
-                bgw->last_task = prev;
-            } else {
-                bgw->first_task = NULL;
-                bgw->last_task = NULL;
-            }
-            while (cur) {
-                sentry_bgworker_task_t *next = cur->next_task;
-                sentry__task_decref(cur);
-                cur = next;
-            }
-            break;
-        }
-        prev = cur;
-        cur = cur->next_task;
-    }
-
     while (true) {
         if (sentry__bgworker_is_done(bgw)) {
             sentry__mutex_unlock(&bgw->task_lock);

tests/unit/test_sync.c

@@ -344,11 +344,9 @@ SENTRY_TEST(bgworker_delayed_shutdown)
     sentry__bgworker_submit(bgw, record_order_task, NULL, (void *)2);
     sentry__bgworker_submit(bgw, record_order_task, NULL, (void *)3);
 
-    // short delay fits within shutdown deadline
+    // delayed tasks are discarded on shutdown unless already ready
     sentry__bgworker_submit_delayed(
         bgw, record_order_task, NULL, (void *)4, 50);
-
-    // long delay exceeds shutdown deadline and should be pruned
     sentry__bgworker_submit_delayed(
         bgw, record_order_task, NULL, (void *)5, 5000);
     sentry__bgworker_submit_delayed(
@@ -357,11 +355,10 @@ SENTRY_TEST(bgworker_delayed_shutdown)
     sentry__bgworker_start(bgw);
     TEST_CHECK_INT_EQUAL(sentry__bgworker_shutdown(bgw, 1000), 0);
 
-    TEST_CHECK_INT_EQUAL(os.count, 4);
+    TEST_CHECK_INT_EQUAL(os.count, 3);
     TEST_CHECK_INT_EQUAL(os.order[0], 1);
     TEST_CHECK_INT_EQUAL(os.order[1], 2);
     TEST_CHECK_INT_EQUAL(os.order[2], 3);
-    TEST_CHECK_INT_EQUAL(os.order[3], 4);
 
     sentry__bgworker_decref(bgw);
 }