@hogsend/engine 0.3.0 → 0.5.0

package/src/worker.ts

@@ -3,9 +3,10 @@ import { selectBucketTasks } from "./buckets/registry.js";
 import type { HogsendClient } from "./container.js";
 import type { DefinedJourney } from "./journeys/define-journey.js";
 import { selectJourneyTasks } from "./journeys/registry.js";
+import { reportWorkerReady } from "./lib/boot.js";
 import { hatchet } from "./lib/hatchet.js";
-import { getPostHog } from "./lib/posthog.js";
 import { getRedisIfConnected } from "./lib/redis.js";
+import { startWorkerHeartbeat } from "./lib/worker-heartbeat.js";
 import {
   bucketBackfillTask,
   enqueueBucketBackfills,
@@ -63,21 +64,43 @@ export function createWorker(opts: CreateWorkerOptions): Worker {
   // Hatchet's worker is created lazily on start so signal wiring can own its
   // lifecycle. `_worker` is captured for stop().
   let _worker: Awaited<ReturnType<typeof hatchet.worker>> | undefined;
+  let _stopHeartbeat: (() => Promise<void>) | undefined;
 
   async function stop(): Promise<void> {
+    // Delete the heartbeat first (an immediate "worker down" signal) before the
+    // Redis connection is torn down below.
+    await _stopHeartbeat?.();
     await Promise.allSettled([
       _worker?.stop(),
-      getPostHog()?.shutdown(),
+      // Shut down the injected analytics instance (same object the worker's
+      // tasks use), not the module singleton. Undefined when no analytics is
+      // configured — the optional chain makes that a no-op.
+      container.analytics?.shutdown(),
       getRedisIfConnected()?.quit(),
     ]);
   }
 
   async function start(): Promise<void> {
+    // Emit BEFORE the Hatchet handshake: proves the process booted past init
+    // even while the connection is still establishing (the worker banner /
+    // "ready" line only fires once `hatchet.worker()` resolves).
+    container.logger.info("Hogsend worker starting", {
+      hatchet: container.env.HATCHET_CLIENT_HOST_PORT,
+    });
+
     _worker = await hatchet.worker("hogsend-worker", { workflows });
 
-    container.logger.info(
-      `Hogsend worker started with ${journeyTasks.length} journey task(s)`,
-    );
+    reportWorkerReady({
+      client: container,
+      journeyTasks: journeyTasks.length,
+      bucketTasks: bucketTasks.length,
+      builtinTasks:
+        baseWorkflows.length - journeyTasks.length - bucketTasks.length,
+    });
+
+    // Publish liveness so the API + Studio can show "worker connected"
+    // (read via GET /v1/health). Best-effort; never blocks the listener.
+    _stopHeartbeat = startWorkerHeartbeat(container.logger);
 
     // Boot-time backfill / criteria-change re-eval (Section 6.6 B): diff each
     // enabled bucket's criteriaHash against bucket_configs and trigger a

package/src/workflows/check-alerts.ts

@@ -16,7 +16,6 @@ export const checkAlertsTask = hatchet.task({
     await checkAlertRules({
       db,
       logger,
-      resendApiKey: process.env.RESEND_API_KEY,
     });
 
     return { checked: true };

package/src/workflows/send-email.ts

@@ -1,22 +1,16 @@
 import { NonRetryableError } from "@hatchet-dev/typescript-sdk/v1/index.js";
-import { createResendClient } from "@hogsend/plugin-resend";
+import { EmailSendError } from "@hogsend/email";
+import { getEmailService } from "../lib/email.js";
 import { hatchet } from "../lib/hatchet.js";
 
-const resend = createResendClient({
-  apiKey: process.env.RESEND_API_KEY ?? "",
-});
-
-const NON_RETRYABLE_CODES = new Set([
-  "validation_error",
-  "missing_required_field",
-  "invalid_api_key",
-  "not_found",
-  "restricted_api_key",
-]);
-
 export const sendEmailTask = hatchet.task({
   name: "send-email",
-  retries: 3,
+  // The EmailProvider owns transient-failure backoff internally (classified
+  // exponential retry in its `send`), and permanent failures fail fast below via
+  // NonRetryableError — so Hatchet's retry is just ONE durability re-attempt for a
+  // worker crash/timeout, not a second transient-retry loop layered on the
+  // provider's. (Previously 3, which multiplied with the provider's own retries.)
+  retries: 1,
   executionTimeout: "30s",
   backoff: { factor: 2, maxSeconds: 30 },
   fn: async (input: {
@@ -28,27 +22,35 @@ export const sendEmailTask = hatchet.task({
     tags?: Array<{ name: string; value: string }>;
     headers?: Record<string, string>;
   }) => {
-    const { data, error } = await resend.emails.send({
-      from:
-        input.from ??
-        process.env.RESEND_FROM_EMAIL ??
-        "Hogsend <noreply@hogsend.com>",
-      to: input.to,
-      subject: input.subject,
-      html: input.html,
-      replyTo: input.replyTo,
-      tags: input.tags,
-      headers: input.headers,
-    });
+    // Deliver through the injected, provider-backed mailer (set by
+    // createHogsendClient → setEmailService). `sendRaw` calls the swappable
+    // EmailProvider's `send`, resolving the default `from` from the mailer
+    // config — so a swapped provider is honored and this task no longer
+    // constructs a raw Resend client of its own. The provider already retries
+    // transient failures internally and surfaces a classified EmailSendError;
+    // map a non-retryable one to Hatchet's NonRetryableError so the task's own
+    // retry/backoff doesn't re-attempt a permanent failure.
+    const emailService = getEmailService();
 
-    if (error) {
-      const name = (error as { name?: string }).name ?? "";
-      if (NON_RETRYABLE_CODES.has(name)) {
-        throw new NonRetryableError(`${name}: ${error.message}`);
+    try {
+      // `from` is optional: when absent the mailer's `resolveFrom` falls back to
+      // its configured defaultFrom (env.RESEND_FROM_EMAIL).
+      const result = await emailService.sendRaw({
+        from: input.from,
+        to: input.to,
+        subject: input.subject,
+        html: input.html,
+        replyTo: input.replyTo,
+        tags: input.tags,
+        headers: input.headers,
+      });
+
+      return { emailId: result.id };
+    } catch (error) {
+      if (error instanceof EmailSendError && !error.retryable) {
+        throw new NonRetryableError(error.message);
       }
-      throw new Error(`Failed to send email: ${error.message}`);
+      throw error;
     }
-
-    return { emailId: data?.id ?? "" };
   },
 });