fix: correct webhook log status field and close a logging gap

logWebhookAction hardcoded status: 'SUCCESS' on every WebhookLog row,
including calls made with action: 'FAILED' and failed test deliveries -
every failure in the audit trail was mislabeled as successful, which
would silently break any dashboard or filter built on status.

- Add an explicit status param to logWebhookAction (default SUCCESS);
  pass FAILURE at the three call sites that log a failure
- Add a RETRY_SCHEDULED/FAILURE log for a failed attempt that still has
  retries remaining - previously only the terminal outcomes (delivered
  or exhausted) were logged, so the audit trail skipped every attempt
  in between
- Add a RETRY_INITIATED log to retryWebhookEvent - a manual retry
  previously left no record of itself
- Extend 5 existing tests with assertions on the actual status/action
  values written, not just that logWebhookAction was called

71/71 tests passing; tsc error count unchanged (760, all pre-existing)

Author: Alanwiz00

backend/services/WebhookService.ts

@@ -362,6 +362,12 @@ export class WebhookService {
           // survive a restart, silently dropping the retry. nextRetry is
           // persisted instead, and WebhookQueueService's interval drains
           // due events via processPendingRetries() below.
+          await this.logWebhookAction(
+            webhook.id,
+            'RETRY_SCHEDULED',
+            `Event ${payload.eventType} delivery failed on attempt ${attemptNumber + 1}, retry due in ${nextRetryDelay}s`,
+            'FAILURE'
+          );
           logger.info(`Webhook delivery failed. Retry due for event ${event.id} in ${nextRetryDelay}s`);
         } else {
           // Max retries exceeded
@@ -374,7 +380,12 @@ export class WebhookService {
             },
           });
 
-          await this.logWebhookAction(webhook.id, 'FAILED', `Event ${payload.eventType} failed after ${attemptNumber + 1} attempts`);
+          await this.logWebhookAction(
+            webhook.id,
+            'FAILED',
+            `Event ${payload.eventType} failed after ${attemptNumber + 1} attempts`,
+            'FAILURE'
+          );
           logger.error(`Webhook delivery failed permanently for event ${event.id} after ${attemptNumber + 1} attempts`);
         }
       }
@@ -456,7 +467,8 @@ export class WebhookService {
           await this.logWebhookAction(
             event.webhookId,
             'FAILED',
-            'Webhook was deleted or deactivated before its scheduled retry could run'
+            'Webhook was deleted or deactivated before its scheduled retry could run',
+            'FAILURE'
           );
           continue;
         }
@@ -541,14 +553,19 @@ export class WebhookService {
   /**
    * Log webhook action
    */
-  private async logWebhookAction(webhookId: string, action: string, details?: string): Promise<void> {
+  private async logWebhookAction(
+    webhookId: string,
+    action: string,
+    details?: string,
+    status: 'SUCCESS' | 'FAILURE' = 'SUCCESS'
+  ): Promise<void> {
     try {
       await prisma.webhookLog.create({
         data: {
           webhookId,
           action,
           details,
-          status: 'SUCCESS',
+          status,
         },
       });
     } catch (error) {
@@ -631,7 +648,7 @@ export class WebhookService {
         const responseTime = Date.now() - startTime;
         const axiosError = error as AxiosError;
 
-        await this.logWebhookAction(webhook.id, 'TESTED', `Test delivery failed: ${axiosError.message}`);
+        await this.logWebhookAction(webhook.id, 'TESTED', `Test delivery failed: ${axiosError.message}`, 'FAILURE');
 
         return {
           success: false,
@@ -713,6 +730,7 @@ export class WebhookService {
         },
       });
 
+      await this.logWebhookAction(webhook.id, 'RETRY_INITIATED', `Manual retry triggered for event ${event.eventType}`);
       await this.attemptWebhookDelivery(webhook, event, payload, 0);
       logger.info(`Webhook event retried: ${eventId}`);
     } catch (error) {

backend/tests/webhook/WebhookService.test.ts

@@ -317,6 +317,7 @@ describe('WebhookService', () => {
       mockPrisma.webhookEvent.create.mockResolvedValue(mockEvent as any);
       mockPrisma.webhookAttempt.create.mockResolvedValue({} as any);
       mockPrisma.webhookEvent.update.mockResolvedValue({} as any);
+      mockPrisma.webhookLog.create.mockResolvedValue({} as any);
       mockedAxios.post.mockRejectedValue({
         message: 'Request failed with status code 500',
         response: { status: 500, data: 'Server Error' },
@@ -341,6 +342,12 @@ describe('WebhookService', () => {
       expect(mockPrisma.webhookEvent.update).not.toHaveBeenCalledWith(
         expect.objectContaining({ data: expect.objectContaining({ status: 'FAILED' }) })
       );
+      // A failed attempt with retries remaining should still produce a
+      // persisted, correctly-statused log entry — not just the terminal
+      // TRIGGERED/FAILED outcomes.
+      expect(mockPrisma.webhookLog.create).toHaveBeenCalledWith({
+        data: expect.objectContaining({ action: 'RETRY_SCHEDULED', status: 'FAILURE' }),
+      });
     });
 
     it('should treat a network timeout the same as any other delivery failure', async () => {
@@ -512,6 +519,12 @@ describe('WebhookService', () => {
         where: { id: 'event-1' },
         data: expect.objectContaining({ status: 'FAILED', attempts: 2 }),
       });
+      // logWebhookAction used to hardcode status: 'SUCCESS' for every log
+      // entry, including this one — a permanently failed delivery must be
+      // logged with status FAILURE, not SUCCESS.
+      expect(mockPrisma.webhookLog.create).toHaveBeenCalledWith({
+        data: expect.objectContaining({ action: 'FAILED', status: 'FAILURE' }),
+      });
     });
 
     it('should mark the event FAILED if its webhook was deleted or deactivated before the retry ran', async () => {
@@ -672,6 +685,9 @@ describe('WebhookService', () => {
 
       expect(result.success).toBe(false);
       expect(result.error).toBe('Network error');
+      expect(mockPrisma.webhookLog.create).toHaveBeenCalledWith({
+        data: expect.objectContaining({ action: 'TESTED', status: 'FAILURE' }),
+      });
     });
 
     it('should throw error for non-existent webhook', async () => {
@@ -759,7 +775,7 @@ describe('WebhookService', () => {
       mockPrisma.webhook.findUnique.mockResolvedValue(mockWebhook as any);
       mockPrisma.webhookEvent.update.mockResolvedValue({} as any);
       mockPrisma.webhookAttempt.create.mockResolvedValue({} as any);
-      mockPrisma.webhookEvent.update.mockResolvedValue({} as any);
+      mockPrisma.webhookLog.create.mockResolvedValue({} as any);
 
       await webhookService.retryWebhookEvent(eventId);
 
@@ -770,6 +786,9 @@ describe('WebhookService', () => {
           attempts: 0,
         },
       });
+      expect(mockPrisma.webhookLog.create).toHaveBeenCalledWith({
+        data: expect.objectContaining({ action: 'RETRY_INITIATED', status: 'SUCCESS' }),
+      });
     });
 
     it('should throw error for non-existent event', async () => {