fix(events): switch to blocklist — hide other workspace events, show rest

olexii4 · olexii4 · commit 247960ae6460 · 2026-07-31T15:43:21.000+03:00
Previous approach (allowlist) filtered events to only those matching the
current workspace name or id-prefix, which discarded generic cluster
events (Deployment, ReplicaSet controllers) not yet associated with a
workspace-derived pod name.

New approach: include every event EXCEPT those whose involvedObject.name
starts with another DevWorkspace's id, or exactly equals another
DevWorkspace's name. This shows all current-workspace events
(DevWorkspace CR, Deployment, ReplicaSet, Pod) plus any cluster event
that does not belong to a different workspace.

selectEventsFromResourceVersion now reads selectAllWorkspaces directly
so the component no longer needs to compute the exclusion list.

Assisted-by: Claude Sonnet 4.6
Signed-off-by: Oleksii Orel &lt;oorel@redhat.com&gt;
diff --git a/packages/dashboard-frontend/src/store/Events/__tests__/selectors.spec.ts b/packages/dashboard-frontend/src/store/Events/__tests__/selectors.spec.ts
@@ -10,7 +10,10 @@
  *   Red Hat, Inc. - initial API and implementation
  */
 
+import { WorkspaceAdapter } from '@/services/workspace-adapter';
 import { RootState } from '@/store';
+import { DevWorkspaceBuilder } from '@/store/__mocks__/devWorkspaceBuilder';
+import { MockStoreBuilder } from '@/store/__mocks__/mockStore';
 import {
   selectAllEvents,
   selectEventsError,
@@ -30,90 +33,174 @@ describe('Events Selectors', () => {
       error: 'Something went wrong',
       resourceVersion: '125',
     },
-  } as RootState;
+  } as unknown as RootState;
 
   it('should select all events', () => {
     const result = selectAllEvents(mockState);
     expect(result).toEqual(mockState.events.events);
   });
 
   it('should select events from a specific resource version', () => {
-    const selectFromResourceVersion = selectEventsFromResourceVersion(mockState);
-    const result = selectFromResourceVersion('124');
-    expect(result).toEqual([
+    // No workspaces in store — all events pass the blocklist
+    const store = new MockStoreBuilder()
+      .withEvents({ events: mockState.events.events as never[], resourceVersion: '125' })
+      .build();
+    const fn = selectEventsFromResourceVersion(store.getState() as RootState);
+    expect(fn('124')).toEqual([
       { metadata: { name: 'event2', resourceVersion: '124' } },
       { metadata: { name: 'event3', resourceVersion: '125' } },
     ]);
   });
 
   it('should return an empty array if resource version is invalid', () => {
-    const selectFromResourceVersion = selectEventsFromResourceVersion(mockState);
-    const result = selectFromResourceVersion('invalid');
-    expect(result).toEqual([]);
+    const store = new MockStoreBuilder()
+      .withEvents({ events: mockState.events.events as never[], resourceVersion: '125' })
+      .build();
+    const fn = selectEventsFromResourceVersion(store.getState() as RootState);
+    expect(fn('invalid')).toEqual([]);
   });
 
   it('should select events error', () => {
-    const result = selectEventsError(mockState);
-    expect(result).toEqual(mockState.events.error);
+    expect(selectEventsError(mockState)).toEqual(mockState.events.error);
   });
 
   it('should select events resource version', () => {
-    const result = selectEventsResourceVersion(mockState);
-    expect(result).toEqual(mockState.events.resourceVersion);
+    expect(selectEventsResourceVersion(mockState)).toEqual(mockState.events.resourceVersion);
   });
 
-  describe('workspace filtering', () => {
-    // Real DevSpaces naming: workspace name = 'my-project',
-    // workspace id = 'workspaceabc123' (derived from UID), pod = 'workspaceabc123-<rs>-<pod>'
-    const workspaceId = 'workspaceabc123';
-    const workspaceName = 'my-project';
-
-    const stateWithMixedEvents = {
-      events: {
-        events: [
-          {
-            metadata: { resourceVersion: '100' },
-            involvedObject: { name: workspaceName },
-            message: 'devworkspace event',
-          },
-          {
-            metadata: { resourceVersion: '101' },
-            involvedObject: { name: `${workspaceId}-6bcbf9f88-xyz01` },
-            message: 'pod event',
-          },
-          {
-            metadata: { resourceVersion: '102' },
-            involvedObject: { name: 'other-workspace' },
-            message: 'other workspace devworkspace event',
-          },
-          {
-            metadata: { resourceVersion: '103' },
-            involvedObject: { name: 'workspaceother999-abc-def' },
-            message: 'other workspace pod event',
-          },
-        ],
-        error: undefined,
-        resourceVersion: '103',
+  describe('workspace filtering — blocklist approach', () => {
+    // Build two real DevWorkspace objects via DevWorkspaceBuilder
+    const currentDW = new DevWorkspaceBuilder()
+      .withId('workspaceabc')
+      .withName('my-workspace')
+      .withNamespace('user-che')
+      .build();
+    const otherDW = new DevWorkspaceBuilder()
+      .withId('workspaceXYZ')
+      .withName('other-workspace')
+      .withNamespace('user-che')
+      .build();
+
+    const currentWorkspaceId = WorkspaceAdapter.getId(currentDW);
+    const currentWorkspaceName = 'my-workspace';
+
+    const events = [
+      // current workspace — DevWorkspace CR event
+      {
+        metadata: { resourceVersion: '100' },
+        involvedObject: { name: 'my-workspace' },
+        message: 'devworkspace event',
+      },
+      // current workspace — Deployment event
+      {
+        metadata: { resourceVersion: '101' },
+        involvedObject: { name: currentWorkspaceId },
+        message: 'deployment event',
+      },
+      // current workspace — ReplicaSet event
+      {
+        metadata: { resourceVersion: '102' },
+        involvedObject: { name: currentWorkspaceId + '-7867c75d84' },
+        message: 'replicaset event',
+      },
+      // current workspace — Pod event
+      {
+        metadata: { resourceVersion: '103' },
+        involvedObject: { name: currentWorkspaceId + '-7867c75d84-kwb97' },
+        message: 'pod event',
       },
-    } as RootState;
+      // generic cluster event (not tied to any workspace)
+      {
+        metadata: { resourceVersion: '104' },
+        involvedObject: { name: 'some-other-resource' },
+        message: 'generic event',
+      },
+      // other workspace — DevWorkspace CR event
+      {
+        metadata: { resourceVersion: '105' },
+        involvedObject: { name: 'other-workspace' },
+        message: 'other devworkspace event',
+      },
+      // other workspace — pod event
+      {
+        metadata: { resourceVersion: '106' },
+        involvedObject: { name: WorkspaceAdapter.getId(otherDW) + '-abc123-pod1' },
+        message: 'other pod event',
+      },
+    ];
+
+    let state: RootState;
+    beforeEach(() => {
+      state = new MockStoreBuilder()
+        .withDevWorkspaces({ workspaces: [currentDW, otherDW] })
+        .withEvents({ events: events as never[], resourceVersion: '106' })
+        .build()
+        .getState() as RootState;
+    });
+
+    it('should show current workspace DevWorkspace events', () => {
+      const result = selectEventsFromResourceVersion(state)(
+        '100',
+        currentWorkspaceId,
+        currentWorkspaceName,
+      );
+      expect(result.map(e => (e as { message: string }).message)).toContain('devworkspace event');
+    });
+
+    it('should show current workspace Deployment events', () => {
+      const result = selectEventsFromResourceVersion(state)(
+        '100',
+        currentWorkspaceId,
+        currentWorkspaceName,
+      );
+      expect(result.map(e => (e as { message: string }).message)).toContain('deployment event');
+    });
+
+    it('should show current workspace ReplicaSet events', () => {
+      const result = selectEventsFromResourceVersion(state)(
+        '100',
+        currentWorkspaceId,
+        currentWorkspaceName,
+      );
+      expect(result.map(e => (e as { message: string }).message)).toContain('replicaset event');
+    });
+
+    it('should show current workspace Pod events', () => {
+      const result = selectEventsFromResourceVersion(state)(
+        '100',
+        currentWorkspaceId,
+        currentWorkspaceName,
+      );
+      expect(result.map(e => (e as { message: string }).message)).toContain('pod event');
+    });
 
-    it('should include DevWorkspace events matched by workspace name', () => {
-      const fn = selectEventsFromResourceVersion(stateWithMixedEvents);
-      const result = fn('100', workspaceId, workspaceName);
-      expect(result.map(e => e.message)).toContain('devworkspace event');
+    it('should show generic cluster events not tied to any workspace', () => {
+      const result = selectEventsFromResourceVersion(state)(
+        '100',
+        currentWorkspaceId,
+        currentWorkspaceName,
+      );
+      expect(result.map(e => (e as { message: string }).message)).toContain('generic event');
     });
 
-    it('should include pod events matched by workspace id prefix', () => {
-      const fn = selectEventsFromResourceVersion(stateWithMixedEvents);
-      const result = fn('100', workspaceId, workspaceName);
-      expect(result.map(e => e.message)).toContain('pod event');
+    it('should hide other workspace DevWorkspace events', () => {
+      const result = selectEventsFromResourceVersion(state)(
+        '100',
+        currentWorkspaceId,
+        currentWorkspaceName,
+      );
+      expect(result.map(e => (e as { message: string }).message)).not.toContain(
+        'other devworkspace event',
+      );
     });
 
-    it('should exclude events from a different workspace', () => {
-      const fn = selectEventsFromResourceVersion(stateWithMixedEvents);
-      const result = fn('100', workspaceId, workspaceName);
-      expect(result.map(e => e.message)).not.toContain('other workspace devworkspace event');
-      expect(result.map(e => e.message)).not.toContain('other workspace pod event');
+    it('should hide other workspace Pod events', () => {
+      const result = selectEventsFromResourceVersion(state)(
+        '100',
+        currentWorkspaceId,
+        currentWorkspaceName,
+      );
+      expect(result.map(e => (e as { message: string }).message)).not.toContain('other pod event');
     });
   });
 });
diff --git a/packages/dashboard-frontend/src/store/Events/selectors.ts b/packages/dashboard-frontend/src/store/Events/selectors.ts
@@ -13,37 +13,56 @@
 import { createSelector } from '@reduxjs/toolkit';
 
 import { RootState } from '@/store';
+import { selectAllWorkspaces } from '@/store/Workspaces/selectors';
 
 const selectState = (state: RootState) => state.events;
 
 export const selectAllEvents = createSelector(selectState, state => state.events);
 
-export const selectEventsFromResourceVersion = createSelector(selectAllEvents, allEvents => {
-  return (fromResourceVersionStr: string, workspaceId?: string, workspaceName?: string) => {
-    return allEvents.filter(event => {
-      if (event.metadata.resourceVersion === undefined) {
-        return false;
-      }
-      const resourceVersion = parseInt(event.metadata.resourceVersion, 10);
-      const fromResourceVersion = parseInt(fromResourceVersionStr, 10);
-      if (isNaN(resourceVersion) || isNaN(fromResourceVersion)) {
-        return false;
-      }
-      if (fromResourceVersion > resourceVersion) {
-        return false;
-      }
-      if (workspaceId !== undefined || workspaceName !== undefined) {
+export const selectEventsFromResourceVersion = createSelector(
+  selectAllEvents,
+  selectAllWorkspaces,
+  (allEvents, allWorkspaces) => {
+    // Pre-build the sets of all workspace IDs and names once per selector invocation.
+    const allWorkspaceIds = allWorkspaces.map(w => w.id);
+    const allWorkspaceNames = allWorkspaces.map(w => w.name);
+
+    return (
+      fromResourceVersionStr: string,
+      currentWorkspaceId?: string,
+      currentWorkspaceName?: string,
+    ) => {
+      return allEvents.filter(event => {
+        if (event.metadata.resourceVersion === undefined) {
+          return false;
+        }
+        const resourceVersion = parseInt(event.metadata.resourceVersion, 10);
+        const fromResourceVersion = parseInt(fromResourceVersionStr, 10);
+        if (isNaN(resourceVersion) || isNaN(fromResourceVersion)) {
+          return false;
+        }
+        if (fromResourceVersion > resourceVersion) {
+          return false;
+        }
+
+        if (currentWorkspaceId === undefined) {
+          return true;
+        }
+
+        // Blocklist approach: hide events that belong to a DIFFERENT workspace.
+        // Events for the current workspace (id-prefix match or exact name match) and
+        // events not associated with any devworkspace are all kept.
         const objName = event.involvedObject?.name ?? '';
-        // DevWorkspace resource events use workspace.name; pod/PVC events use
-        // workspace.id (e.g. "workspaceabc123") as a prefix
-        const matchesName = workspaceName !== undefined && objName === workspaceName;
-        const matchesId = workspaceId !== undefined && objName.startsWith(workspaceId);
-        return matchesName || matchesId;
-      }
-      return true;
-    });
-  };
-});
+
+        const belongsToOtherWorkspace =
+          allWorkspaceIds.some(id => id !== currentWorkspaceId && objName.startsWith(id)) ||
+          allWorkspaceNames.some(name => name !== currentWorkspaceName && objName === name);
+
+        return !belongsToOtherWorkspace;
+      });
+    };
+  },
+);
 
 export const selectEventsError = createSelector(selectState, state => state.error);
 
