Retries and Replays

app.post("/webhooks/autosend", async (req, res) => {
  try {
    // Verify signature first
    const signature = req.headers["x-webhook-signature"];
    const body = JSON.stringify(req.body);

    if (!verifySignature(signature, body, WEBHOOK_SECRET)) {
      // Return 401 for invalid signature (will retry)
      // Or return 200 to prevent retries for invalid signatures
      return res.status(401).json({ error: "Invalid signature" });
    }

    // Queue for background processing
    await queue.add("process-webhook", {
      deliveryId: req.headers["x-webhook-delivery-id"],
      event: req.body.type,
      data: req.body.data,
    });

    // Return 200 immediately - don't wait for processing
    res.status(200).json({ received: true });
  } catch (error) {
    console.error("Webhook processing error:", error);
    // Return 500 for temporary errors (will retry)
    res.status(500).json({ error: "Internal error" });
  }
});

// Using Redis for idempotency tracking
const redis = require("redis");
const client = redis.createClient();

app.post("/webhooks/autosend", async (req, res) => {
  const deliveryId = req.headers["x-webhook-delivery-id"];
  const ttl = 86400; // 24 hours

  // Check if already processed
  const exists = await client.exists(`webhook:${deliveryId}`);
  if (exists) {
    console.log(`Duplicate delivery ${deliveryId}, skipping`);
    return res.status(200).json({ received: true, duplicate: true });
  }

  try {
    // Process the webhook
    await processWebhook(req.body);

    // Mark as processed (with TTL to auto-cleanup)
    await client.setex(`webhook:${deliveryId}`, ttl, "processed");

    res.status(200).json({ received: true });
  } catch (error) {
    // Don't mark as processed on error so it can be retried
    console.error("Processing failed:", error);
    res.status(500).json({ error: "Processing failed" });
  }
});

app.post("/webhooks/autosend", async (req, res) => {
  const deliveryId = req.headers["x-webhook-delivery-id"];

  try {
    // Try to insert the delivery ID (unique constraint)
    await db.webhookDeliveries.insertOne({
      deliveryId,
      receivedAt: new Date(),
      processed: false,
    });
  } catch (error) {
    if (error.code === 11000) {
      // Duplicate key - already processed
      console.log(`Duplicate delivery ${deliveryId}`);
      return res.status(200).json({ received: true, duplicate: true });
    }
    throw error;
  }

  try {
    await processWebhook(req.body);

    // Mark as processed
    await db.webhookDeliveries.updateOne(
      { deliveryId },
      { $set: { processed: true, processedAt: new Date() } }
    );

    res.status(200).json({ received: true });
  } catch (error) {
    console.error("Processing failed:", error);
    res.status(500).json({ error: "Processing failed" });
  }
});

app.post("/webhooks/autosend", async (req, res) => {
  try {
    // Verify signature
    const signature = req.headers["x-webhook-signature"];
    const isValid = verifySignature(signature, req.body, WEBHOOK_SECRET);

    if (!isValid) {
      // Invalid signature is a permanent error
      // Return 200 to prevent unnecessary retries
      return res.status(200).json({
        error: "Invalid signature",
        retryable: false
      });
    }

    // Process webhook
    await processWebhook(req.body);
    res.status(200).json({ received: true });
  } catch (error) {
    console.error("Webhook error:", error);

    // Determine if error is temporary or permanent
    if (error.code === "ECONNREFUSED" || error.code === "ETIMEDOUT") {
      // Temporary database/service error - retry
      return res.status(500).json({
        error: "Service temporarily unavailable",
        retryable: true
      });
    } else if (error.name === "ValidationError") {
      // Permanent error - bad data, don't retry
      return res.status(200).json({
        error: "Invalid data format",
        retryable: false
      });
    } else {
      // Unknown error - retry to be safe
      return res.status(500).json({
        error: "Internal error",
        retryable: true
      });
    }
  }
});

const Queue = require("bull");
const webhookQueue = new Queue("webhooks", {
  redis: { host: "localhost", port: 6379 },
});

// ❌ Bad - Synchronous processing (may timeout)
app.post("/webhooks/autosend", async (req, res) => {
  await updateDatabase(req.body);      // 2 seconds
  await sendToAnalytics(req.body);     // 3 seconds
  await notifySlack(req.body);         // 2 seconds
  await triggerWorkflow(req.body);     // 4 seconds
  // Total: 11 seconds - WILL TIMEOUT!

  res.status(200).json({ received: true });
});

// ✅ Good - Asynchronous processing
app.post("/webhooks/autosend", async (req, res) => {
  const deliveryId = req.headers["x-webhook-delivery-id"];

  // Queue for background processing (fast!)
  await webhookQueue.add("process", {
    deliveryId,
    event: req.body.type,
    data: req.body.data,
  });

  // Respond immediately (< 100ms)
  res.status(200).json({ received: true });
});

// Process in background worker
webhookQueue.process("process", async (job) => {
  const { deliveryId, event, data } = job.data;

  console.log(`Processing webhook ${deliveryId} for event ${event}`);

  await updateDatabase(data);
  await sendToAnalytics(data);
  await notifySlack(data);
  await triggerWorkflow(data);

  console.log(`Completed processing webhook ${deliveryId}`);
});

const winston = require("winston");

const logger = winston.createLogger({
  level: "info",
  format: winston.format.json(),
  transports: [
    new winston.transports.File({ filename: "webhooks.log" }),
    new winston.transports.Console(),
  ],
});

app.post("/webhooks/autosend", async (req, res) => {
  const deliveryId = req.headers["x-webhook-delivery-id"];
  const event = req.body.type;
  const timestamp = req.headers["x-webhook-timestamp"];

  logger.info("Webhook received", {
    deliveryId,
    event,
    timestamp,
    receivedAt: new Date().toISOString(),
  });

  try {
    await processWebhook(req.body);

    logger.info("Webhook processed successfully", {
      deliveryId,
      event,
      processingTime: Date.now() - parseInt(timestamp),
    });

    res.status(200).json({ received: true });
  } catch (error) {
    logger.error("Webhook processing failed", {
      deliveryId,
      event,
      error: error.message,
      stack: error.stack,
    });

    res.status(500).json({ error: "Processing failed" });
  }
});

// Simulate intermittent failures for testing
const deliveryAttempts = new Map();

app.post("/webhooks/autosend", async (req, res) => {
  const deliveryId = req.headers["x-webhook-delivery-id"];

  // Track attempts for this delivery
  const attempts = (deliveryAttempts.get(deliveryId) || 0) + 1;
  deliveryAttempts.set(deliveryId, attempts);

  console.log(`Delivery ${deliveryId} - Attempt ${attempts}`);

  // Simulate: Fail first 2 attempts, succeed on 3rd
  if (attempts <= 2) {
    console.log(`Simulating failure on attempt ${attempts}`);
    return res.status(500).json({ error: "Simulated error" });
  }

  console.log(`Success on attempt ${attempts}`);

  // Process webhook
  await processWebhook(req.body);

  // Clean up tracking
  deliveryAttempts.delete(deliveryId);

  res.status(200).json({ received: true, attempts });
});

const express = require("express");
const cluster = require("cluster");
const os = require("os");

if (cluster.isMaster) {
  // Fork workers (one per CPU core)
  const numCPUs = os.cpus().length;
  console.log(`Master process starting ${numCPUs} workers`);

  for (let i = 0; i < numCPUs; i++) {
    cluster.fork();
  }

  cluster.on("exit", (worker) => {
    console.log(`Worker ${worker.process.pid} died, starting new worker`);
    cluster.fork();
  });
} else {
  // Worker process
  const app = express();
  app.use(express.json());

  app.post("/webhooks/autosend", async (req, res) => {
    try {
      await processWebhook(req.body);
      res.status(200).json({ received: true });
    } catch (error) {
      res.status(500).json({ error: "Processing failed" });
    }
  });

  app.listen(3000, () => {
    console.log(`Worker ${process.pid} listening on port 3000`);
  });
}