External Event Consumption in Salesforce — Retries & Dead-Letter Concepts

public with sharing class RetryPolicy {
    public static final Integer MAX_ATTEMPTS = 4; // 0,1,2,3,4 = 5 tries total

    public static Integer nextDelayMinutes(Integer attempt) {
        // 0→1m, 1→5m, 2→15m, 3→60m, 4→(no next)
        Integer[] table = new Integer[]{1,5,15,60};
        return attempt < table.size() ? table[attempt] : null;
    }

    public static Boolean isRetryable(Exception ex) {
        String m = ex.getMessage();
        return m != null && (
            m.contains('UNABLE_TO_LOCK_ROW') ||
            m.contains('Read timed out') ||
            m.contains('500 ') || m.contains('502 ') || m.contains('503 ') || m.contains('504 ')
        );
    }
}

D) Worker (Queueable + Schedulable)

Processes events, retries transient ones with backoff, and DLQs terminal errors.

public with sharing class InvoiceWork implements Queueable, Database.AllowsCallouts, Schedulable {
    // Simple DTO for batched requests
    public class Request {
        public String dedupKey;
        public String eventType;
        public String payloadJson;
        public String correlationId;
        public Integer attempt;
        public Request(String dedupKey, String eventType, String payloadJson, String correlationId, Integer attempt) {
            this.dedupKey = dedupKey; this.eventType = eventType; this.payloadJson = payloadJson;
            this.correlationId = correlationId; this.attempt = attempt;
        }
    }
    private List<Request> batch;

    public InvoiceWork(List<Request> batch) { this.batch = batch; }

    public void execute(QueueableContext qc) {
        for (Request r : batch) {
            try {
                processOne(r); // may call out
            } catch (Exception ex) {
                handleFailure(r, ex);
            }
        }
    }

    // Schedulable “delayer” for backoff retries
    public void execute(SchedulableContext sc) {
        // Deserialize the payload from the Cron job's name if you choose, or store in a custom object.
        // For brevity, not implemented here; prefer passing state via a small record.
    }

    private void processOne(Request r) {
        // Example callout to external billing system
        HttpRequest req = new HttpRequest();
        req.setEndpoint('callout:BillingBridge/invoice'); // Named Credential
        req.setMethod('POST');
        req.setHeader('Content-Type', 'application/json');
        req.setHeader('X-Correlation-Id', r.correlationId);
        req.setBody(r.payloadJson);

        HttpResponse res = new Http().send(req);
        Integer code = res.getStatusCode();

        if (code >= 200 && code < 300) {
            // Success — nothing else to do (idempotency already claimed)
            return;
        }
        // Non-2xx: decide retryability
        if (code >= 500 || code == 429) {
            // Retryable
            throw new CalloutException('Retryable HTTP ' + code + ': ' + res.getBody());
        } else {
            // Terminal (e.g., 400/404/422)
            throw new AuraHandledException('Terminal HTTP ' + code + ': ' + res.getBody());
        }
    }

    private void handleFailure(Request r, Exception ex) {
        Boolean retryable = RetryPolicy.isRetryable(ex);
        Integer nextAttempt = r.attempt + 1;

        if (retryable && nextAttempt <= RetryPolicy.MAX_ATTEMPTS) {
            Integer delay = RetryPolicy.nextDelayMinutes(r.attempt);
            if (delay == null) { // no further delay slot
                deadLetter(r, ex);
                return;
            }
            // schedule a delayed retry via Schedulable wrapper
            String cron = cronInMinutes(delay);
            System.schedule('Retry '+r.dedupKey+' #'+nextAttempt, cron,
                new RetryLauncher(r, nextAttempt));
            return;
        }
        // Terminal or attempts exhausted → DLQ
        deadLetter(r, ex);
    }

    private void deadLetter(Request r, Exception ex) {
        insert new Dead_Letter__c(
            DedupKey__c = r.dedupKey,
            EventType__c = r.eventType,
            Payload__c = r.payloadJson,
            Attempts__c = r.attempt,
            LastError__c = ex.getMessage(),
            CorrelationId__c = r.correlationId,
            LastSeen__c = System.now(),
            FirstSeen__c = (r.attempt == 0 ? System.now() : null) // set on first write in real code
        );
    }

    private static String cronInMinutes(Integer minutes) {
        Datetime t = Datetime.now().addMinutes(minutes);
        // sec min hour day month ? year
        return String.format('0 {0} {1} {2} {3} ? {4}',
            new List<String>{
                String.valueOf(t.minute()),
                String.valueOf(t.hour()),
                String.valueOf(t.day()),
                String.valueOf(t.month()),
                String.valueOf(t.year())
            });
    }

    // Tiny Schedulable to re-enqueue a single request after backoff
    global class RetryLauncher implements Schedulable {
        Request r; Integer attempt;
        public RetryLauncher(Request r, Integer attempt) { this.r = r; this.attempt = attempt; }
        global void execute(SchedulableContext sc) {
            r.attempt = attempt;
            System.enqueueJob(new InvoiceWork(new List<Request>{ r }));
        }
    }
}