🐛 fix(notifications): preserve update-applied success events across rename race (#290)

Author: s-b-e-n-s-o-n

app/agent/AgentClient.test.ts

@@ -954,6 +954,29 @@ describe('AgentClient', () => {
       expect(event.emitContainerUpdateApplied).toHaveBeenCalledWith('local_nginx');
     });
 
+    test('should emit update-applied payload with agent context when agent sends object payload', async () => {
+      await client.handleEvent('dd:update-applied', {
+        containerName: 'local_nginx',
+        container: {
+          id: 'c1',
+          name: 'nginx',
+          watcher: 'local',
+          updateAvailable: true,
+          updateKind: { kind: 'tag', semverDiff: 'major' },
+        },
+      });
+
+      expect(event.emitContainerUpdateApplied).toHaveBeenCalledWith({
+        containerName: 'local_nginx',
+        container: expect.objectContaining({
+          id: 'c1',
+          name: 'nginx',
+          watcher: 'local',
+          agent: 'test-agent',
+        }),
+      });
+    });
+
     test('should ignore update-applied when data is an empty string', async () => {
       await client.handleEvent('dd:update-applied', '');
 
@@ -1369,6 +1392,40 @@ describe('AgentClient', () => {
     });
   });
 
+  describe('getWatcher', () => {
+    test('should fetch watcher detail from the agent', async () => {
+      axios.get.mockResolvedValue({
+        data: {
+          id: 'docker.local',
+          type: 'docker',
+          name: 'local',
+          configuration: { cron: '0 * * * *' },
+          metadata: { nextRunAt: '2026-04-09T13:00:00.000Z' },
+        },
+      });
+
+      const result = await client.getWatcher('docker', 'local');
+
+      expect(axios.get).toHaveBeenCalledWith(
+        expect.stringContaining('/api/watchers/docker/local'),
+        expect.any(Object),
+      );
+      expect(result).toEqual({
+        id: 'docker.local',
+        type: 'docker',
+        name: 'local',
+        configuration: { cron: '0 * * * *' },
+        metadata: { nextRunAt: '2026-04-09T13:00:00.000Z' },
+      });
+    });
+
+    test('should throw when fetching watcher detail fails', async () => {
+      axios.get.mockRejectedValue(new Error('watcher fetch failed'));
+
+      await expect(client.getWatcher('docker', 'local')).rejects.toThrow('watcher fetch failed');
+    });
+  });
+
   describe('watchContainer', () => {
     test('should post to watcher container endpoint and process report', async () => {
       const report = { container: { id: 'c1' } };

app/agent/AgentClient.ts

@@ -4,6 +4,7 @@ import { StringDecoder } from 'node:string_decoder';
 import axios, { type AxiosRequestConfig } from 'axios';
 import type { Logger } from 'pino';
 import type {
+  ContainerUpdateAppliedEventPayload,
   ContainerUpdateFailedEventPayload,
   SecurityAlertEventPayload,
   SecurityAlertSummary,
@@ -51,9 +52,12 @@ interface AgentClientRuntimeInfo {
 }
 
 interface AgentComponentDescriptor {
+  id?: string;
   type: string;
   name: string;
   configuration: Record<string, unknown>;
+  agent?: string;
+  metadata?: Record<string, unknown>;
 }
 
 interface AgentRuntimeAckPayload {
@@ -90,6 +94,17 @@ const INITIAL_SSE_RECONNECT_DELAY_MS = 1_000;
 const MAX_SSE_RECONNECT_DELAY_MS = 60_000;
 const REMOTE_UPDATE_TRIGGER_TYPES = new Set(['docker', 'dockercompose']);
 
+function isContainerUpdateAppliedEventPayload(
+  data: unknown,
+): data is ContainerUpdateAppliedEventPayload {
+  if (!data || typeof data !== 'object') {
+    return false;
+  }
+
+  const containerName = (data as { containerName?: unknown }).containerName;
+  return typeof containerName === 'string' && containerName.length > 0;
+}
+
 export class AgentClient {
   public name: string;
   public config: AgentClientConfig;
@@ -604,6 +619,17 @@ export class AgentClient {
       case 'dd:update-applied':
         if (typeof data === 'string' && data.length > 0) {
           await emitContainerUpdateApplied(data);
+        } else if (isContainerUpdateAppliedEventPayload(data)) {
+          await emitContainerUpdateApplied({
+            containerName: data.containerName,
+            container:
+              data.container && typeof data.container === 'object'
+                ? {
+                    ...data.container,
+                    agent: this.name,
+                  }
+                : undefined,
+          });
         }
         return;
       case 'dd:update-failed': {
@@ -742,6 +768,21 @@ export class AgentClient {
     }
   }
 
+  async getWatcher(watcherType: string, watcherName: string) {
+    try {
+      const response = await axios.get<AgentComponentDescriptor>(
+        `${this.baseUrl}/api/watchers/${encodeURIComponent(watcherType)}/${encodeURIComponent(watcherName)}`,
+        this.axiosOptions,
+      );
+      return response.data;
+    } catch (error: unknown) {
+      this.log.error(
+        `Error fetching watcher on agent: ${sanitizeLogParam(getErrorMessage(error))}`,
+      );
+      throw error;
+    }
+  }
+
   async watch(watcherType: string, watcherName: string) {
     try {
       const response = await axios.post<ContainerReport[]>(

app/agent/api/event.test.ts

@@ -381,6 +381,28 @@ describe('agent API event', () => {
       expect(payload).toContain('"local_nginx"');
     });
 
+    test('update-applied handler should send object payloads to connected clients', () => {
+      eventApi.subscribeEvents(req, res);
+      res.write.mockClear();
+      eventApi.initEvents();
+
+      const updateAppliedHandler = event.registerContainerUpdateApplied.mock.calls[0][0];
+      updateAppliedHandler({
+        containerName: 'local_nginx',
+        container: {
+          id: 'c1',
+          name: 'nginx',
+          watcher: 'local',
+        },
+      });
+
+      expect(res.write).toHaveBeenCalled();
+      const payload = res.write.mock.calls[0][0];
+      expect(payload).toContain('dd:update-applied');
+      expect(payload).toContain('"containerName":"local_nginx"');
+      expect(payload).toContain('"name":"nginx"');
+    });
+
     test('update-failed handler should send SSE to connected clients', () => {
       eventApi.subscribeEvents(req, res);
       res.write.mockClear();

app/agent/api/event.ts

@@ -263,8 +263,8 @@ export function initEvents() {
   event.registerWatcherSnapshot((payload: event.WatcherSnapshotEventPayload) =>
     sendSseEvent('dd:watcher-snapshot', sanitizeWatcherSnapshotPayloadForAgentSse(payload)),
   );
-  event.registerContainerUpdateApplied((containerName: string) =>
-    sendSseEvent('dd:update-applied', containerName),
+  event.registerContainerUpdateApplied((payload: event.ContainerUpdateAppliedEvent) =>
+    sendSseEvent('dd:update-applied', payload),
   );
   event.registerContainerUpdateFailed((payload: event.ContainerUpdateFailedEventPayload) =>
     sendSseEvent('dd:update-failed', payload),

app/event/audit-subscriptions.test.ts

@@ -8,6 +8,7 @@ import {
 import type {
   AgentDisconnectedEventPayload,
   ContainerLifecycleEventPayload,
+  ContainerUpdateAppliedEvent,
   ContainerUpdateFailedEventPayload,
   SecurityAlertEventPayload,
 } from './index.js';
@@ -54,7 +55,7 @@ function setupAuditSubscriptions(): {
 
   const registrars: AuditSubscriptionRegistrars = {
     registerContainerReport: registerOrdered<ContainerReport>(() => {}),
-    registerContainerUpdateApplied: registerOrdered<string>(() => {}),
+    registerContainerUpdateApplied: registerOrdered<ContainerUpdateAppliedEvent>(() => {}),
     registerContainerUpdateFailed: registerOrdered<ContainerUpdateFailedEventPayload>(() => {}),
     registerSecurityAlert: registerOrdered<SecurityAlertEventPayload>((handler) => {
       handlers.securityAlert = handler;

app/event/audit-subscriptions.ts

@@ -4,6 +4,7 @@ import * as auditStore from '../store/audit.js';
 import type {
   AgentDisconnectedEventPayload,
   ContainerLifecycleEventPayload,
+  ContainerUpdateAppliedEvent,
   ContainerUpdateFailedEventPayload,
   SecurityAlertEventPayload,
 } from './index.js';
@@ -26,7 +27,7 @@ type EventRegistrarFn<TPayload> = (handler: (payload: TPayload) => void) => void
 
 export interface AuditSubscriptionRegistrars {
   registerContainerReport: OrderedEventRegistrarFn<ContainerReport>;
-  registerContainerUpdateApplied: OrderedEventRegistrarFn<string>;
+  registerContainerUpdateApplied: OrderedEventRegistrarFn<ContainerUpdateAppliedEvent>;
   registerContainerUpdateFailed: OrderedEventRegistrarFn<ContainerUpdateFailedEventPayload>;
   registerSecurityAlert: OrderedEventRegistrarFn<SecurityAlertEventPayload>;
   registerAgentDisconnected: OrderedEventRegistrarFn<AgentDisconnectedEventPayload>;
@@ -38,6 +39,22 @@ export interface AuditSubscriptionRegistrars {
 const securityAlertAuditSeenAt = new Map<string, number>();
 const agentDisconnectedAuditSeenAt = new Map<string, number>();
 
+function getContainerUpdateAppliedEventContainerName(
+  payload: ContainerUpdateAppliedEvent,
+): string | undefined {
+  if (typeof payload === 'string') {
+    return payload || undefined;
+  }
+
+  if (!payload || typeof payload !== 'object') {
+    return undefined;
+  }
+
+  return typeof payload.containerName === 'string' && payload.containerName !== ''
+    ? payload.containerName
+    : undefined;
+}
+
 function pruneAuditDedupeCache(
   cache: Map<string, number>,
   now: number,
@@ -83,12 +100,16 @@ export function registerAuditLogSubscriptions(registrars: AuditSubscriptionRegis
     }
   }, AUDIT_HANDLER_OPTIONS);
 
-  registrars.registerContainerUpdateApplied(async (containerId: string) => {
+  registrars.registerContainerUpdateApplied(async (payload) => {
+    const containerName = getContainerUpdateAppliedEventContainerName(payload);
+    if (!containerName) {
+      return;
+    }
     auditStore.insertAudit({
       id: '',
       timestamp: new Date().toISOString(),
       action: 'update-applied',
-      containerName: containerId,
+      containerName,
       status: 'success',
     });
     getAuditCounter()?.inc({ action: 'update-applied' });

app/event/index.audit.test.ts

@@ -101,6 +101,24 @@ describe('event default audit listeners', () => {
     expect(mockInc).toHaveBeenCalledWith({ action: 'update-applied' });
   });
 
+  test('should record update-applied audits from object payloads', async () => {
+    const event = await loadEventModule();
+
+    await event.emitContainerUpdateApplied({
+      containerName: 'container-456',
+      container: { id: 'c1', name: 'nginx', watcher: 'local' },
+    });
+
+    expect(mockInsertAudit).toHaveBeenCalledWith(
+      expect.objectContaining({
+        action: 'update-applied',
+        containerName: 'container-456',
+        status: 'success',
+      }),
+    );
+    expect(mockInc).toHaveBeenCalledWith({ action: 'update-applied' });
+  });
+
   test('should record update-failed audits', async () => {
     const event = await loadEventModule();
 

app/event/index.ts

@@ -69,6 +69,13 @@ export interface ContainerUpdateFailedEventPayload {
   error: string;
 }
 
+export interface ContainerUpdateAppliedEventPayload {
+  containerName: string;
+  container?: Container | Record<string, unknown>;
+}
+
+export type ContainerUpdateAppliedEvent = string | ContainerUpdateAppliedEventPayload;
+
 export interface SecurityAlertSummary {
   unknown: number;
   low: number;
@@ -112,7 +119,10 @@ export type ContainerLifecycleEventPayload = Partial<Omit<Container, 'image'>> &
 const containerReportHandlers = new Map<number, OrderedEventHandler<ContainerReport>>();
 const containerReportsHandlers = new Map<number, OrderedEventHandler<ContainerReport[]>>();
 const watcherSnapshotHandlers = new Map<number, OrderedEventHandler<WatcherSnapshotEventPayload>>();
-const containerUpdateAppliedHandlers = new Map<number, OrderedEventHandler<string>>();
+const containerUpdateAppliedHandlers = new Map<
+  number,
+  OrderedEventHandler<ContainerUpdateAppliedEvent>
+>();
 const containerUpdateFailedHandlers = new Map<
   number,
   OrderedEventHandler<ContainerUpdateFailedEventPayload>
@@ -229,18 +239,35 @@ export function registerContainerReport(
 
 /**
  * Emit ContainerUpdateApplied event.
- * @param containerId
+ * @param payload
  */
-export async function emitContainerUpdateApplied(containerId: string): Promise<void> {
-  await emitOrderedHandlers(containerUpdateAppliedHandlers, containerId);
+export async function emitContainerUpdateApplied(
+  payload: ContainerUpdateAppliedEvent,
+): Promise<void> {
+  await emitOrderedHandlers(containerUpdateAppliedHandlers, payload);
+}
+
+export function getContainerUpdateAppliedEventContainerName(
+  payload: ContainerUpdateAppliedEvent,
+): string | undefined {
+  if (typeof payload === 'string') {
+    return payload || undefined;
+  }
+
+  if (!payload || typeof payload !== 'object') {
+    return undefined;
+  }
+
+  const containerName = payload.containerName;
+  return typeof containerName === 'string' && containerName !== '' ? containerName : undefined;
 }
 
 /**
  * Register to ContainerUpdateApplied event.
  * @param handler
  */
 export function registerContainerUpdateApplied(
-  handler: OrderedEventHandlerFn<string>,
+  handler: OrderedEventHandlerFn<ContainerUpdateAppliedEvent>,
   options: EventHandlerRegistrationOptions = {},
 ): () => void {
   return registerOrderedEventHandler(containerUpdateAppliedHandlers, handler, options);