fix: max concurrency for pg

Signed-off-by: Umberto Sgueglia <usgueglia@contractor.linuxfoundation.org>

Author: ulemons

services/apps/packages_worker/src/bin/blast-radius-worker.ts

@@ -1,4 +1,25 @@
-import { svc } from '../service'
+import { Config } from '@crowd/archetype-standard'
+import { Options, ServiceWorker } from '@crowd/archetype-worker'
+
+// Own ServiceWorker instance rather than the shared one in ../service (used by every
+// other packages_worker entry point) — its activities are CPU/IO-heavy (tarball
+// downloads+extraction, agent subprocesses), so it needs a concurrency cap that would
+// otherwise throttle unrelated, lightweight ingestion workers if set on the shared
+// instance. Left uncapped, the SDK default lets dozens run at once in this one process,
+// starving the event loop and missing heartbeat deadlines.
+const config: Config = {
+  envvars: [],
+  producer: { enabled: false },
+  temporal: { enabled: true },
+  redis: { enabled: false },
+}
+
+const options: Options = {
+  postgres: { enabled: false }, // packages-db is managed via getPackagesDb()
+  maxConcurrentActivityTaskExecutions: 8,
+}
+
+const svc = new ServiceWorker(config, options)
 
 // On-demand only — analyzeBlastRadius is triggered per request from the backend's
 // submitBlastRadiusJob handler (workflow.start), not on a schedule.

services/apps/packages_worker/src/blast-radius/dependentsScan.ts

@@ -279,6 +279,10 @@ export async function scanDependents(input: {
   for (const name of ranked) {
     if (analyzed.length >= topN) break
 
+    // Phase 1 heartbeats every 200 candidates via mapWithConcurrency; this walk is
+    // sequential (one packument fetch at a time), so it needs its own heartbeat too.
+    onProgress?.()
+
     const packument = await fetchPackument(name)
     if (isFetchError(packument)) continue
 

services/apps/packages_worker/src/blast-radius/stages/reachability.ts

@@ -176,9 +176,13 @@ export async function runReachabilityStage(
               return
             }
 
-            // Backoff before retry
+            // Backoff before retry. Heartbeat partway through — the longest backoff
+            // (attempt 2, 30s) is still well under the stage's 5-minute heartbeatTimeout
+            // on its own, but 4 dependents processing concurrently can each be mid-backoff
+            // at once with nothing else heartbeating in between.
             const delayMs = RETRY_BACKOFF_BASE * attempt
             await new Promise((resolve) => setTimeout(resolve, delayMs))
+            onProgress?.()
           }
         }
       } finally {

services/apps/packages_worker/src/blast-radius/workflows.ts

@@ -38,6 +38,7 @@ const { blastRadiusReachability } = proxyActivities<typeof activities>({
 
 const { blastRadiusReport } = proxyActivities<typeof activities>({
   startToCloseTimeout: '2 minutes',
+  heartbeatTimeout: '1 minute',
   retry: { maximumAttempts: 3 },
 })