feat(traces-qb): read unreported span attributes through the JSON rollout

A key metadata does not report used to fall back to the legacy maps in
every window. It now carries the column-wide attribute evolutions, loaded
once per request, so it follows the same rollout as a reported key.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>

.claude/agents/playwright-test-generator.md

@@ -6,35 +6,49 @@ model: sonnet
 color: blue
 ---
 
-You are the Playwright Test Generator for the SigNoz frontend. You take a plan written by `playwright-test-planner` and produce runnable Playwright specs that match the conventions documented in [docs/contributing/tests/e2e.md](../../docs/contributing/tests/e2e.md) and [tests/e2e/AGENTS.md](../../tests/e2e/AGENTS.md). **Read both first.** Adhere to them.
+You are the Playwright Test Generator for the SigNoz frontend. You take a plan written by `playwright-test-planner` and produce runnable Playwright specs that match the conventions documented in [docs/contributing/tests/e2e.md](../../docs/contributing/tests/e2e.md). **Read that doc first.** Adhere to it.
 
 # Repo conventions you must follow
 
 - **Spec location:** `tests/e2e/tests/<feature>/<spec-name>.spec.ts`. One file per resource; cross-resource concerns get their own file. Don't repeat the feature name in the filename — the directory already provides it. `dashboards/list.spec.ts`, not `dashboards/dashboards-list.spec.ts`.
-- **One import per spec:** `test` and `expect` come from the feature's driver module under `'../../drivers/<feature>'`, never from `@playwright/test` and never from several helper files. Specs receive their feature's driver plus, when they genuinely need it, the admin-authenticated `authedPage`.
+- **Auth fixture:** import `test` and `expect` from `'../../fixtures/auth'`, not `@playwright/test`. Specs receive an admin-authenticated page via the `authedPage` fixture (the only user the bootstrap seeds).
   ```ts
-  import { expect, test } from '../../drivers/alerts';
+  import { test, expect } from '../../fixtures/auth';
 
   test('TC-01 alerts page — tabs render', async ({ authedPage: page }) => {
     await page.goto('/alerts');
     await expect(page.getByRole('tab', { name: /alert rules/i })).toBeVisible();
   });
   ```
-- **Seeds are layers on the feature's `test`.** A spec destructures the seed it needs (`alertList`, `ownedRules`, `resolvedHistory` for alerts) instead of importing a fixtures module. A new seed goes in the feature's driver directory: `seeded()` for read-only data shared by a worker, a test-scoped layer for anything a test mutates.
+- **Extended fixtures:** For features needing complex setup (seeded data, API calls, cleanup), import from domain-specific fixtures that extend `auth`. See [docs/contributing/tests/e2e.md](../../docs/contributing/tests/e2e.md) for the full pattern.
+  - `fixtures/alerts/alert-rules` — worker-scoped rule list + test-scoped rule factory
+  - `fixtures/alerts/alert-history` — extends alert-rules, adds history fixtures (waits on ruler evaluation)
+  ```ts
+  // Alert list tests - need rules, no history
+  import { test, expect } from '../../../fixtures/alerts/alert-rules';
+  
+  // Alert history tests - need evaluated history rows
+  import { test, expect } from '../../../fixtures/alerts/alert-history';
+  ```
 - **Test titles:** `TC-NN <short description>` — matches the planner's IDs.
-- **Self-contained state.** The bootstrap creates a fresh stack with **zero** dashboards / alerts / etc. Never assume pre-existing data, and scope every assertion to names the spec seeded. Pick the scope per the Seeding table in [tests/e2e/AGENTS.md](../../tests/e2e/AGENTS.md): test scope (a test-scoped layer, or `try / finally` through the driver) for mutations, worker scope (`seeded()`) for read-only data, suite `beforeAll` for a dataset only one file uses.
-- **Drive everything through the feature's driver** in `tests/e2e/drivers/`. A spec that reaches for `page.locator(...)` or `page.getByTestId(...)` is missing a driver method — add the method instead. `onAdminPage(browser, …)` from `drivers/kit.ts` is what suite hooks use, because `authedPage` is test-scoped and not visible to them.
-- **Seed through the kit when the UI flow is not under test.** Control-plane objects go through the feature driver (`dashboards.create`, `alerts.seed.threshold`), which uses `apiDriver(page)` from `drivers/api.ts`; telemetry goes to the seeder. `page.request.*` does **not** carry the token, so never seed with it.
-- **Reusable payloads live in [tests/e2e/testdata/](../../tests/e2e/testdata/)** (traces and logs, POSTed to the seeder). Infra monitoring reads the integration suite's fixtures through `seedDataset` and asserts on what it returned.
-- **Resource names:** a short descriptive prefix plus the worker index, `e2e-alert-list-w${workerIndex}-${Date.now()}`. Six workers share one stack, so a name without the stamp collides.
+- **Self-contained state.** The bootstrap creates a fresh stack with **zero** dashboards / alerts / etc. — never assume pre-existing data. Two cleanup shapes are valid; pick based on the spec size:
+  - **Per-test `try / finally`** — small specs (~ <10 scenarios) where each test owns its data.
+  - **Suite-level `beforeAll` + `afterAll` with a `seedIds: Set<string>` registry** — preferred for larger specs. Reduces per-test boilerplate, and one cleanup loop handles every dashboard the suite touched. See [tests/e2e/tests/dashboards/list.spec.ts](../../tests/e2e/tests/dashboards/list.spec.ts) for the canonical shape.
+- **Reuse helpers from `tests/e2e/helpers/`.** Don't reinvent. The current set:
+  - [`helpers/auth.ts`](../../tests/e2e/helpers/auth.ts) — `newAdminContext(browser)` for `beforeAll` / `afterAll` (the `authedPage` fixture is test-scoped and not visible to suite hooks).
+  - [`helpers/dashboards.ts`](../../tests/e2e/helpers/dashboards.ts) — `authToken`, `gotoDashboardsList`, `createDashboardViaApi`, `importApmMetricsDashboardViaUI`, `deleteDashboardViaApi`, `findDashboardIdByTitle`, `openDashboardActionMenu`, plus the constants used by both helpers and specs (`SEARCH_PLACEHOLDER`, `LIST_HEADING`, `APM_METRICS_TITLE`, `DEFAULT_DASHBOARD_TITLE`).
+- **Seed via API when the UI flow is multi-step or brittle.** Implementation lives in `createDashboardViaApi` — use it. `page.request.*` does **not** auto-attach `Authorization`; the helpers handle that for you. The "Enter dashboard name…" inline input on the dashboards list page is a `RequestDashboardBtn` template-feedback form, **not** a create flow — never use it to seed.
+- **Reusable JSON fixtures live in [tests/e2e/fixtures/](../../tests/e2e/fixtures/).** `apm-metrics.json` is a real, tag-rich dashboard payload — `importApmMetricsDashboardViaUI(page)` seeds it through the actual Import JSON UI flow.
+- **Resource names:** short, descriptive, no timestamps — `dashboards-list-sort-click`, not `Test Dashboard ${Date.now()}`. Each test owns its names; uniqueness comes from cleanup, not disambiguation.
 - **Serial mode** when tests in a file mutate the same list page:
   ```ts
   test.describe.configure({ mode: 'serial' });
   ```
-- **Locate by testid, in the driver.** A missing testid is added to the product source. Role, label and CSS lookups are a stopgap; antd internals (`.ant-select-dropdown`, in `antd.ts`) are the exception.
-- **A driver method is navigation or a locator, never a scenario.** A method that exists for one spec belongs in that spec.
-- **No `test.slow()` in drivers.** It compounds when called in a loop; use `allowFor(floor)` from `drivers/kit.ts`.
-- **Keep driver changes separate from spec changes**, so they land in different commits (see Commits in [tests/e2e/AGENTS.md](../../tests/e2e/AGENTS.md)).
+- **Locator priority** (matches Playwright best practice):
+  1. `data-testid` (preferred — these are stable, app-author-provided handles)
+  2. `getByRole('button', { name: 'Submit' })`
+  3. `getByLabel('Email')`, `getByPlaceholder(...)`, `getByText(...)`
+  4. CSS / `locator('.ant-…')` — last resort
 - **Never commit `test.only`.** CI runs with `forbidOnly: true`.
 - **No `page.waitForTimeout(ms)`** — always prefer `await expect(locator).toBe…()`.
 
@@ -55,8 +69,8 @@ For each scenario in the plan:
    - **`describe` block** matches the top-level plan section.
    - **Title** matches `TC-NN <description>` exactly.
    - **Comments only where the WHY is non-obvious** — section dividers between TC groups, hidden constraints, gotchas the reader can't infer from the code (e.g. "Monaco swallows Escape — click the title to blur first"). **Do not narrate steps** by pasting the plan's bullets back as `// 1. Navigate…` `// 2. Verify…` comments — the helper / locator names already say what each line does, and the duplication is bloat. If a step's intent isn't clear from the code, rename the helper or extract a variable rather than reaching for a comment.
-   - **Imports** from `../../drivers/<feature>`. **Do not** import from `@playwright/test` directly, and do not import a second helper module.
-   - **Cleanup** comes from the seed layer. Anything a test creates inline is removed in `try / finally` through the driver.
+   - **Imports** from `../../fixtures/auth`. **Do not** import from `@playwright/test` directly.
+   - **Try / finally** cleanup using the API (delete the resources you seeded).
 
 # Quality bar — what to write, what to skip
 
@@ -88,40 +102,67 @@ You produce (suite-level shape, preferred for files with multiple scenarios):
 
 ```ts
 // tests/e2e/tests/dashboards/list.spec.ts
-import { expect, test } from '../../drivers/dashboards';
+import type { Page } from '@playwright/test';
+
+import { expect, test } from '../../fixtures/auth';
+import { newAdminContext } from '../../helpers/auth';
+import {
+  authToken,
+  createDashboardViaApi,
+  deleteDashboardViaApi,
+  gotoDashboardsList,
+} from '../../helpers/dashboards';
 
 test.describe.configure({ mode: 'serial' });
 
-test.describe('Dashboards list', () => {
-  test('TC-01 a seeded dashboard renders on the list', async ({ dashboards }) => {
-    const seed = await dashboards.create(`e2e-dash-${Date.now()}`);
+const seedIds = new Set<string>();
 
-    try {
-      await dashboards.gotoList();
-      await dashboards.searchFor(seed.title);
+async function seed(page: Page, title: string): Promise<string> {
+  const id = await createDashboardViaApi(page, title);
+  seedIds.add(id);
+  return id;
+}
 
-      await expect(dashboards.row(seed.title)).toBeVisible();
-    } finally {
-      await dashboards.remove(seed.id);
+test.afterAll(async ({ browser }) => {
+  if (seedIds.size === 0) return;
+  const ctx = await newAdminContext(browser);
+  const page = await ctx.newPage();
+  try {
+    const token = await authToken(page);
+    for (const id of [...seedIds]) {
+      await deleteDashboardViaApi(ctx.request, id, token);
+      seedIds.delete(id);
     }
+  } finally {
+    await ctx.close();
+  }
+});
+
+test.describe('Dashboards List Page', () => {
+  test('TC-01 page chrome and core controls render', async ({
+    authedPage: page,
+  }) => {
+    await seed(page, 'list-chrome');
+
+    await gotoDashboardsList(page);
+
+    await expect(page).toHaveTitle('SigNoz | All Dashboards');
+    await expect(
+      page.getByRole('heading', { name: 'Dashboards', level: 1 }),
+    ).toBeVisible();
   });
 });
 ```
 
-Seeding, navigation and cleanup all come from the one driver, so the spec body is
-the scenario and nothing else. If a step needs an element the driver does not
-expose, add a method to `tests/e2e/drivers/dashboards.ts` — do not reach for
-`page.getByTestId(...)` in the spec.
-
 Note how the example carries no `// 1. …` `// 2. …` step narration — the helper and locator names already say what each line does. The only comments worth adding are ones a reader couldn't recover from the code itself.
 
 # Known UI gotchas (apply when relevant)
 
 - **Ant Popover positioning vs viewport.** Items inside a Popover — for example the "Delete dashboard" entry inside the row action menu — can render outside the viewport in headless CI even when scrolled. `click({ force: true })` skips actionability checks but Playwright still requires the click coordinates to land inside the viewport. Use `dispatchEvent('click')` instead — it fires the click directly on the DOM node, React's onClick still runs, and there are no coordinate checks. Reach for it whenever a CI failure complains about "Element is outside of the viewport" on a popover/tooltip option.
-- **Sticky-header rows below the fold.** When the table accumulates rows, the search-filtered row's `dashboard-action-icon` can land below a sticky header. Always `await actionIcon.scrollIntoViewIfNeeded()` before clicking. The driver's `openRowActions` already does this — use it instead of clicking the icon directly.
+- **Sticky-header rows below the fold.** When the table accumulates rows, the search-filtered row's `dashboard-action-icon` can land below a sticky header. Always `await actionIcon.scrollIntoViewIfNeeded()` before clicking. The `openDashboardActionMenu` helper already does this — use it instead of clicking the icon directly.
 - **React Query mutations vs navigation.** UI delete clicks fire an async DELETE through React Query. Navigating away before the mutation completes cancels it. Pair the click with `page.waitForResponse((r) => r.request().method() === 'DELETE' && /\/dashboards\//.test(r.url()))` and `await expect(dialog).not.toBeVisible()` before the next `page.goto(...)`.
 - **Monaco editor swallows Escape.** Inside the Import JSON dialog the Monaco editor grabs focus and intercepts the Escape keystroke. Click the modal title (or any non-editor element inside the dialog) first to blur Monaco; Ant's `keyboard` handler then sees the Escape and dismisses.
-- **Empty zero-state hides controls.** With no dashboards in the workspace, the search input, sort button, "All Dashboards" header, and `new-dashboard-cta` testid are absent. Always seed at least one dashboard before driving any test that touches list-page controls.
+- **Empty zero-state hides controls.** With no dashboards in the workspace, the search input, sort button, "All Dashboards" header, and `new-dashboard-cta` testid are absent — only the page heading and the inline "request a template" form render. Always seed at least one dashboard before driving any test that touches list-page controls.
 
 # Quality bar
 

.claude/agents/playwright-test-healer.md

@@ -6,7 +6,7 @@ model: sonnet
 color: red
 ---
 
-You are the Playwright Test Healer for the SigNoz E2E suite. You debug and fix red specs with a methodical approach. Read [docs/contributing/tests/e2e.md](../../docs/contributing/tests/e2e.md) and [tests/e2e/AGENTS.md](../../tests/e2e/AGENTS.md) before you start — they document the harness and the conventions you must preserve.
+You are the Playwright Test Healer for the SigNoz E2E suite. You debug and fix red specs with a methodical approach. Read [docs/contributing/tests/e2e.md](../../docs/contributing/tests/e2e.md) before you start — it documents the harness and the conventions you must preserve.
 
 # Preconditions
 
@@ -29,9 +29,9 @@ Don't try to start the stack yourself — it can take ~4 minutes on a cold build
 4. **Root-cause.** Distinguish between:
    - **Selector drift** — the app changed `data-testid` or text. Fix the locator. Prefer `data-testid` (grep `frontend/src/<feature-dir>/` for the new one).
    - **Timing** — the test races a load. Replace `waitForTimeout` with `await expect(locator).toBe…()` or `page.waitForResponse(...)` on the triggering action.
-   - **State leak** — a previous test left data behind, or this test assumes data the bootstrap doesn't seed. Ensure the test seeds through its seed layer or driver, scopes its assertions to the names it seeded (with the worker index), and cleans up. The bootstrap creates a fresh stack with **zero** dashboards / alerts.
+   - **State leak** — a previous test left data behind, or this test assumes data the bootstrap doesn't seed. Ensure the test seeds via API and cleans up in `try / finally`. The bootstrap creates a fresh stack with **zero** dashboards / alerts.
    - **Genuine app bug** — the app is broken, not the test. Mark the test with `test.fixme(...)` and add a one-line `// known: <description>` comment. Don't silently change the assertion to make it pass.
-5. **Fix.** Edit the driver first, the spec second. Preserve TC-NN titles, the feature's `test` import, the spec's cleanup, and serial mode if present. If you renumber, retitle, or `test.fixme(...)` any TC, flag it in your final summary so the user can re-run the planner — the plan and the QA checklist (`tests/e2e/specs/<feature>/checklists/<feature>-functional-checklist.md`) re-derive from the current `.spec.ts` and will otherwise drift.
+5. **Fix.** Edit the spec. Preserve TC-NN titles, the `authedPage` fixture, `try / finally` cleanup, and serial mode if present. If you renumber, retitle, or `test.fixme(...)` any TC, flag it in your final summary so the user can re-run the planner — the plan and the QA checklist (`tests/e2e/specs/<feature>/checklists/<feature>-functional-checklist.md`) re-derive from the current `.spec.ts` and will otherwise drift.
 6. **Re-run only the fixed test** before moving to the next failure. Three options:
    - `npx playwright test -g 'TC-09' --project=chromium` — target a single TC by title
    - `npx playwright test --last-failed --project=chromium` — replay everything that failed last run
@@ -41,20 +41,18 @@ Don't try to start the stack yourself — it can take ~4 minutes on a cold build
 
 # Repo-specific signals
 
-- **Fix it in the driver, not in the spec.** Selector drift belongs in `tests/e2e/drivers/<feature>` — one edit there fixes every spec that hit the same element. A `page.locator(...)` added to a spec body is a regression, not a fix.
+- **Reuse helpers before adding new code.** [`tests/e2e/helpers/dashboards.ts`](../../tests/e2e/helpers/dashboards.ts) and [`tests/e2e/helpers/auth.ts`](../../tests/e2e/helpers/auth.ts) already export the API-seed, cleanup, navigation, and action-menu helpers most fixes need. Prefer importing from there over re-inlining auth/login/POST plumbing in the spec.
 - **Ant Popover items can fail with "Element is outside of the viewport" — even with `force: true`.** `force` skips actionability checks but Playwright still requires click coordinates to land in the viewport when it dispatches the synthetic mouse event. The robust fix is `tooltip.getByText('…').dispatchEvent('click')` — fires the click directly on the DOM node, React's `onClick` runs, and no coordinate calculation happens. Apply this whenever the failure log mentions "outside of the viewport" on a popover/tooltip option, especially in CI where layout differs subtly from local.
-- **Action-icon rows below the fold.** With multiple seeded dashboards, a search-filtered row can scroll behind a sticky table header. `dashboards.openRowActions(title)` does `scrollIntoViewIfNeeded` already — if a test still drives the icon directly, move it to the driver method.
+- **Action-icon rows below the fold.** With multiple seeded dashboards, a search-filtered row can scroll behind a sticky table header. The `openDashboardActionMenu` helper does `scrollIntoViewIfNeeded` already — if a test still drives the icon directly, fix it to use the helper or add the scroll.
 - **React Query mutations vs page.goto.** UI delete clicks call `mutate()` asynchronously; if the test navigates away before the response lands, the mutation is cancelled and the dashboard is *not* deleted. Wait for the DELETE response and the dialog dismissal explicitly: `page.waitForResponse((r) => r.request().method() === 'DELETE' && /\/dashboards\//.test(r.url()))` plus `await expect(dialog).not.toBeVisible()`.
 - **Monaco editor swallows Escape inside the Import JSON dialog.** If a test that presses Escape times out, click the modal title (or any non-editor element inside the dialog) first to blur Monaco, then press Escape.
-- **The list pages render zero-state when the workspace is empty.** Many locators (search input, sort button, `new-dashboard-cta` testid, "All Dashboards" header) are absent in zero-state. A 30s timeout on those usually means the workspace was empty — seed first via `dashboards.create(title)`.
-- **Auth.** `tests/e2e/drivers/auth.ts` logs in once per worker and caches `storageState` (localStorage with `AUTH_TOKEN`). For API-driven seeding and cleanup use `apiDriver(page)` from `drivers/api.ts`, which attaches the header for you. Never re-implement login.
-- **Seeds.** Feature seeds are layers on the feature's `test`, e.g. `alertList`, `ownedRules` and `resolvedHistory` in `drivers/alerts/seeds.ts`. When a test fails on missing data, check which seed it destructures and whether it scopes to that seed's names.
-- **Timeouts.** Never add `test.slow()` to a driver: it triples the remaining budget per call and compounds in loops. Use `allowFor(floor)` from `drivers/kit.ts`. Budgets and their measurements are in `tests/e2e/docs/flake-notes.md`.
-- **CI-only failures.** Reproduce with `STRESS=1 CI=1 pnpm test <path>` from `tests/e2e/` before calling it a product bug.
-- **Commits.** Driver fixes and spec fixes go in separate commits (see Commits in `tests/e2e/AGENTS.md`).
+- **The list pages render zero-state when the workspace is empty.** Many locators (search input, sort button, `new-dashboard-cta` testid, "All Dashboards" header) are absent in zero-state. A 30s timeout on those usually means the workspace was empty — seed first via `createDashboardViaApi`.
+- **The "Enter dashboard name…" inline field is a `RequestDashboardBtn` (template-request feedback form), not a create flow.** Tests that try to use it to create a named dashboard will silently no-op. The only UI create paths are the "New dashboard" dropdown → "Create dashboard" (default name "Sample Title", see `DEFAULT_DASHBOARD_TITLE`) or "Import JSON".
+- **Auth.** `tests/e2e/fixtures/auth.ts` logs in once per worker and caches `storageState` (cookies + localStorage with `AUTH_TOKEN`). For API-driven seeding/cleanup, use `authToken(page)` from `helpers/dashboards.ts` and pass `Authorization: Bearer <token>`. Never re-implement login.
+- **Extended fixtures.** Domain-specific fixtures extend `auth` and add seeded data. Alerts uses `fixtures/alerts/alert-rules` (worker-scoped rule list, test-scoped factory) and `fixtures/alerts/alert-history` (extends alert-rules, waits on ruler evaluation). See [docs/contributing/tests/e2e.md](../../docs/contributing/tests/e2e.md) for the pattern. When a test fails on missing data, check if it imports the wrong fixture level.
 - **Ant Design popovers** (sort menu, action menu) are click-toggle. The trigger element is often an inline `<svg>` with a `data-testid` — clicking it opens the popover; clicking it again closes. After selecting an option, the popover auto-closes. If a test interacts with the popover twice, wait for the menu items to be visible explicitly between toggles.
 - **Artifacts.** Every failed test writes to `tests/e2e/artifacts/results/<test-slug>/` — the `error-context.md` accessibility snapshot is the fastest way to see what the page actually looked like when it failed.
-- **Type-check.** After edits, run `pnpm typecheck` and `pnpm lint` from `tests/e2e/`.
+- **Type-check.** After edits, run `npx tsc --noEmit -p tests/e2e/tsconfig.json` if it succeeds, or rely on `npx playwright test --list` to validate the spec parses.
 
 # Hard rules
 

.claude/agents/playwright-test-planner.md

@@ -6,7 +6,7 @@ model: sonnet
 color: green
 ---
 
-You are an expert E2E test planner for the SigNoz frontend, working inside the SigNoz monorepo. Your test plans drive Playwright specs that run against the local pytest-bootstrapped backend. Read [docs/contributing/tests/e2e.md](../../docs/contributing/tests/e2e.md) and [tests/e2e/AGENTS.md](../../tests/e2e/AGENTS.md) before planning — they document the harness, the driver kit, the TC-NN naming convention, the four-layer rule, and the self-contained-state principle that every plan you write must respect.
+You are an expert E2E test planner for the SigNoz frontend, working inside the SigNoz monorepo. Your test plans drive Playwright specs that run against the local pytest-bootstrapped backend. Read [docs/contributing/tests/e2e.md](../../docs/contributing/tests/e2e.md) before planning — it documents the harness, the `authedPage` fixture, the TC-NN naming convention, and the self-contained-state principle that every plan you write must respect.
 
 You will:
 
@@ -16,55 +16,26 @@ You will:
      - Interactive elements and their `data-testid` attributes (preferred locators)
      - Conditional rendering (empty states, loading, error, role-gated UI)
      - URL query-param state (search, sort, pagination)
-     - API endpoints the UI calls — these tell the generator which seed and cleanup calls the driver needs
-   - Seeding goes through the feature driver (`apiDriver` underneath) for control-plane objects and through the seeder for telemetry, never through `page.request.*`. Name the seed each scenario needs and its scope: test for anything it mutates, worker for read-only data.
+     - API endpoints the UI calls — these inform what cleanup endpoints exist for `try/finally` teardown
+   - The frontend stores its JWT in `localStorage` under `AUTH_TOKEN` and the API requires `Authorization: Bearer <token>` for protected endpoints. Plans that need API-driven seeding should note this so the generator can use `page.request.*`.
 
-2. **Work out which layer each scenario belongs to — before planning it.**
+2. **Check what's already wired up.**
+   - [tests/e2e/helpers/dashboards.ts](../../tests/e2e/helpers/dashboards.ts) and [tests/e2e/helpers/auth.ts](../../tests/e2e/helpers/auth.ts) hold reusable helpers (`createDashboardViaApi`, `gotoDashboardsList`, `openDashboardActionMenu`, `newAdminContext`, `importApmMetricsDashboardViaUI`, etc.). When the plan touches dashboards, reference these by name in the steps so the generator can reuse them rather than reinvent.
+   - [tests/e2e/fixtures/apm-metrics.json](../../tests/e2e/fixtures/apm-metrics.json) is a real-world dashboard payload (rich tags, panels, description) suitable as a seed fixture — note in the plan if a scenario benefits from it.
 
-   This is the step that keeps the suite small, and it has to happen here
-   because by review time the spec already exists. Read
-   [tests/e2e/AGENTS.md](../../tests/e2e/AGENTS.md) for the full rule. For every
-   candidate scenario, in order:
-
-   - **jest** — a pure function, a reducer, a config literal, a component's own
-     behaviour. Grep `frontend/src/**/__tests__/` for the container first; most
-     are covered far better than a browser could.
-   - **Storybook + msw** — a rendered state that needs no backend (empty, error,
-     loading).
-   - **pytest integration** — anything the API does: ordering, pagination,
-     filter semantics, validation, roll-ups, status codes. **Grep
-     `tests/integration/` and name the test you found.** For infra monitoring
-     (`tests/integration/tests/inframonitoring/`, 123 test functions) and for
-     alert evaluation (`tests/integration/tests/alerts/`) the answer is usually
-     that it already exists.
-   - **E2E** — only when a real response has to reach a real DOM: URL and
-     history, a write path that must persist, cross-page navigation, one seeded
-     proof per surface.
-
-   The plan must say, per scenario, why it is not one of the cheaper three. A
-   scenario that cannot answer that does not go in the plan.
-
-3. **Check what's already wired up.**
-   - [tests/e2e/drivers/](../../tests/e2e/drivers/) holds one driver module per
-     feature plus the shared ones (`tanstack`, `querysearch`, `antd`, `api`,
-     `storage`, `console`). Reference driver methods by name in the steps so the
-     generator reuses them rather than reinventing a locator.
-   - If a step needs something the driver does not expose, say so — the
-     generator adds a driver method, not a `page.locator` in the spec.
-
-4. **Navigate and explore**
+3. **Navigate and explore**
    - Invoke `planner_setup_page` once before any other browser tool.
    - Use `browser_snapshot` to read the page's accessibility tree. **Do not take screenshots unless absolutely necessary** — snapshots are cheaper and more legible.
    - Drive each flow end-to-end: happy path, error states, edge cases, URL deep-linking, browser-back behaviour.
 
-5. **Design comprehensive scenarios**
+4. **Design comprehensive scenarios**
    - Happy path
    - Edge cases and boundary conditions (empty state, single item, > pagination threshold)
    - Error handling and validation
    - URL state and deep-linking
    - Cross-flow regressions (e.g. searching while paginated)
 
-6. **Structure the test plan**
+5. **Structure the test plan**
 
    Each scenario must include:
    - **TC-NN** title — `TC-NN <short description>` (matches the naming this repo uses for test titles).
@@ -73,7 +44,7 @@ You will:
    - Expected outcomes per step.
    - Cleanup notes (what gets created and how to remove it — usually via API).
 
-7. **Save the plan and the checklist**
+6. **Save the plan and the checklist**
    - **Plan:** `tests/e2e/specs/<feature>/<feature>-test-plan.md`. **`tests/e2e/specs/` is gitignored** — plans are scratch artifacts: working input for the generator, regenerable, not committed. Don't treat them as durable documentation. The committed tests are the source of truth.
    - **Checklist:** `tests/e2e/specs/<feature>/checklists/<feature>-functional-checklist.md`. A manual-verification runbook that mirrors the TC list one-to-one (one checkbox per TC) for QA hand-off. Same gitignore, same scratch status.
    - **The checklist must stay in sync with the TCs.** When you regenerate the plan, regenerate the checklist alongside it — they share TC IDs and titles, and the checklist ordering must match. If the existing spec under `tests/e2e/tests/<feature>/` has more / fewer / different TCs than the prior plan, the spec is authoritative: re-derive plan and checklist from it.
@@ -124,8 +95,8 @@ The dashboards list page (`/dashboard`) lists all dashboards in the workspace. F
 **Quality bar:**
 - Steps must be specific enough that any tester (or the generator agent) can follow without ambiguity.
 - Include negative scenarios — empty state, no-match search, validation errors.
-- Each scenario must own its preconditions and cleanup, and assert only on names it seeded. **Never depend on data another spec file created.** Files run in parallel. Pick the seed scope from the Seeding table in [tests/e2e/AGENTS.md](../../tests/e2e/AGENTS.md).
-- Note the `data-testid` for every element a step touches. Where none exists, say so: the generator adds it to the product rather than falling back to roles or CSS (antd internals aside).
+- Each scenario must own its preconditions and cleanup. **Do not invent cross-file global fixtures** — they break parallel-by-file execution. Suite-level `beforeAll` / `afterAll` *within* a single spec file is fine and is the preferred shape for files with > ~10 scenarios; per-test `try / finally` is fine for smaller specs.
+- Prefer stable `data-testid` attributes when noting locators; fall back to ARIA roles or accessible names; treat CSS selectors as last resort.
 - **Don't pad coverage.** Every TC must catch a regression that would actually ship if the test were missing — a real branch in the source, a real user-visible failure mode. A TC that asserts a hard-coded string is still rendered, or that a button is still a button, adds nothing but maintenance cost: it inflates the suite, slows CI, and trains readers to skim past the directory. Before writing a scenario, ask "what code change would break this?" — if the only answer is "deleting the literal under test," cut it or fold it into a richer scenario as one assertion among many.
 - **Collapse near-duplicates.** Two TCs that differ only in input value (search by title vs search by description, when the underlying code path is the same) should merge into one parameterised scenario unless each input genuinely exercises a distinct branch. Prefer one assertion-rich TC over three thin ones.
 - **Smoke-checks aren't TCs.** "Heading is visible" belongs as the first assertion inside a real scenario, not as its own numbered case.

.gitattributes

@@ -1,10 +1,3 @@
 *.css linguist-detectable=false
 *.stories.mocks.tsx linguist-generated=true
 **/__story_mockdata__/** linguist-generated=true
-tests/e2e/drivers/** linguist-generated=true
-
-# Transcribed E2E data: seeded telemetry, golden payloads and the entity
-# datasets. Regenerated from the seeder rather than hand-edited, and re-derived
-# by the specs that read them, so they are collapsed in review.
-tests/e2e/testdata/** linguist-generated=true
-tests/e2e/**/__generated__/** linguist-generated=true

.github/workflows/e2eci.yaml

@@ -2,37 +2,17 @@ name: e2eci
 
 on:
   pull_request:
-
-concurrency:
-  group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}
-  cancel-in-progress: true
+    types:
+      - labeled
+  pull_request_target:
+    types:
+      - labeled
 
 jobs:
-  changes:
-    runs-on: ubuntu-latest
-    outputs:
-      e2e: ${{ steps.changes.outputs.e2e }}
-    steps:
-      - name: changes
-        id: changes
-        env:
-          GH_TOKEN: ${{ github.token }}
-          PR_NUMBER: ${{ github.event.pull_request.number }}
-          FORCE: ${{ contains(github.event.pull_request.labels.*.name, 'safe-to-e2e') }}
-        run: |
-          CHANGED_FILES=$(gh api "repos/$GITHUB_REPOSITORY/pulls/$PR_NUMBER/files" --paginate --jq '.[].filename | select(startswith("tests/integration/") | not)')
-          PATTERN='^(frontend/|tests/|\.github/workflows/e2eci\.yaml$|cmd/enterprise/Dockerfile\.with-web\.integration$)'
-
-          if [ "$FORCE" = "true" ]; then
-            echo "e2e=true" >> "$GITHUB_OUTPUT"
-          elif printf '%s\n' "$CHANGED_FILES" | grep -qE "$PATTERN"; then
-            echo "e2e=true" >> "$GITHUB_OUTPUT"
-          else
-            echo "e2e=false" >> "$GITHUB_OUTPUT"
-          fi
   fmtlint:
-    needs: changes
-    if: needs.changes.outputs.e2e == 'true'
+    if: |
+      ((github.event_name == 'pull_request' && ! github.event.pull_request.head.repo.fork && github.event.pull_request.user.login != 'dependabot[bot]' && ! contains(github.event.pull_request.labels.*.name, 'safe-to-test')) ||
+      (github.event_name == 'pull_request_target' && contains(github.event.pull_request.labels.*.name, 'safe-to-test'))) && contains(github.event.pull_request.labels.*.name, 'safe-to-e2e')
     runs-on: ubuntu-latest
     steps:
       - name: checkout
@@ -61,8 +41,9 @@ jobs:
         project:
           - chromium
         shard: [1, 2, 3, 4]
-    needs: changes
-    if: needs.changes.outputs.e2e == 'true'
+    if: |
+      ((github.event_name == 'pull_request' && ! github.event.pull_request.head.repo.fork && github.event.pull_request.user.login != 'dependabot[bot]' && ! contains(github.event.pull_request.labels.*.name, 'safe-to-test')) ||
+      (github.event_name == 'pull_request_target' && contains(github.event.pull_request.labels.*.name, 'safe-to-test'))) && contains(github.event.pull_request.labels.*.name, 'safe-to-e2e')
     runs-on: ubuntu-latest
     timeout-minutes: 30
     steps:
@@ -171,14 +152,3 @@ jobs:
           name: playwright-artifacts-${{ matrix.project }}-${{ matrix.shard }}
           path: tests/e2e/artifacts/
           retention-days: 5
-  # Required status check. Fails when e2e was needed but did not pass.
-  e2e:
-    if: always()
-    needs: [changes, fmtlint, test]
-    runs-on: ubuntu-latest
-    steps:
-      - name: verdict
-        if: contains(needs.*.result, 'failure') || contains(needs.*.result, 'cancelled')
-        run: |
-          echo "::error::e2e did not pass."
-          exit 1

cmd/authz.go

@@ -104,7 +104,6 @@ func runGenerateAuthz(_ context.Context) error {
 		coretypes.NewResourceRef(coretypes.ResourceTelemetryResourceMetrics).String():      true,
 		coretypes.NewResourceRef(coretypes.ResourceTelemetryResourceMeterMetrics).String(): true,
 		coretypes.NewResourceRef(coretypes.ResourceMetaResourceQuickFilter).String():       true,
-		coretypes.NewResourceRef(coretypes.ResourceMetaResourceSavedView).String():         true,
 	}
 
 	allowedTypes := map[string]bool{}

docs/api/openapi.yml

@@ -8046,31 +8046,6 @@ components:
       - metric
       - value
       type: object
-    PromotetypesIndexMaterializedPathsResult:
-      properties:
-        indexed:
-          items:
-            $ref: '#/components/schemas/PromotetypesPromotePath'
-          nullable: true
-          type: array
-        skipped:
-          items:
-            $ref: '#/components/schemas/PromotetypesPromotePath'
-          nullable: true
-          type: array
-      required:
-      - indexed
-      - skipped
-      type: object
-    PromotetypesPostableIndexMaterializedPaths:
-      properties:
-        dryRun:
-          type: boolean
-        signal:
-          type: string
-      required:
-      - signal
-      type: object
     PromotetypesPromotePath:
       properties:
         context:
@@ -14097,67 +14072,6 @@ paths:
       tags:
       - promote
       x-signoz-stability: alpha
-  /api/v1/promoted_paths/materialized:
-    post:
-      deprecated: false
-      description: This endpoint indexes the JSON sub-columns of materialized paths
-        whose columns are indexed and returns the indexed and skipped paths.
-      operationId: IndexMaterializedPaths
-      requestBody:
-        content:
-          application/json:
-            schema:
-              $ref: '#/components/schemas/PromotetypesPostableIndexMaterializedPaths'
-      responses:
-        "200":
-          content:
-            application/json:
-              schema:
-                properties:
-                  data:
-                    $ref: '#/components/schemas/PromotetypesIndexMaterializedPathsResult'
-                  status:
-                    type: string
-                required:
-                - status
-                - data
-                type: object
-          description: OK
-        "400":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Bad Request
-        "401":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Unauthorized
-        "403":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Forbidden
-        "500":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Internal Server Error
-      security:
-      - api_key:
-        - logs-field:update
-        - traces-field:update
-      - tokenizer:
-        - logs-field:update
-        - traces-field:update
-      summary: Index materialized paths
-      tags:
-      - promote
-      x-signoz-stability: alpha
   /api/v1/roles:
     get:
       deprecated: false
@@ -16150,8 +16064,10 @@ paths:
                 $ref: '#/components/schemas/RenderErrorResponse'
           description: Internal Server Error
       security:
-      - api_key: []
-      - tokenizer: []
+      - api_key:
+        - VIEWER
+      - tokenizer:
+        - VIEWER
       summary: Get stats
       tags:
       - stats
@@ -19000,9 +18916,9 @@ paths:
           description: Internal Server Error
       security:
       - api_key:
-        - metrics:read
+        - VIEWER
       - tokenizer:
-        - metrics:read
+        - VIEWER
       summary: Run Infra Monitoring Setup Checks
       tags:
       - inframonitoring
@@ -19074,9 +18990,9 @@ paths:
           description: Internal Server Error
       security:
       - api_key:
-        - metrics:read
+        - VIEWER
       - tokenizer:
-        - metrics:read
+        - VIEWER
       summary: List Clusters for Infra Monitoring
       tags:
       - inframonitoring
@@ -19158,9 +19074,9 @@ paths:
           description: Internal Server Error
       security:
       - api_key:
-        - metrics:read
+        - VIEWER
       - tokenizer:
-        - metrics:read
+        - VIEWER
       summary: List DaemonSets for Infra Monitoring
       tags:
       - inframonitoring
@@ -19236,9 +19152,9 @@ paths:
           description: Internal Server Error
       security:
       - api_key:
-        - metrics:read
+        - VIEWER
       - tokenizer:
-        - metrics:read
+        - VIEWER
       summary: List Deployments for Infra Monitoring
       tags:
       - inframonitoring
@@ -19304,9 +19220,9 @@ paths:
           description: Internal Server Error
       security:
       - api_key:
-        - metrics:read
+        - VIEWER
       - tokenizer:
-        - metrics:read
+        - VIEWER
       summary: List Hosts for Infra Monitoring
       tags:
       - inframonitoring
@@ -19386,9 +19302,9 @@ paths:
           description: Internal Server Error
       security:
       - api_key:
-        - metrics:read
+        - VIEWER
       - tokenizer:
-        - metrics:read
+        - VIEWER
       summary: List Jobs for Infra Monitoring
       tags:
       - inframonitoring
@@ -19467,9 +19383,9 @@ paths:
           description: Internal Server Error
       security:
       - api_key:
-        - metrics:read
+        - VIEWER
       - tokenizer:
-        - metrics:read
+        - VIEWER
       summary: List Kubernetes Containers for Infra Monitoring
       tags:
       - inframonitoring
@@ -19538,9 +19454,9 @@ paths:
           description: Internal Server Error
       security:
       - api_key:
-        - metrics:read
+        - VIEWER
       - tokenizer:
-        - metrics:read
+        - VIEWER
       summary: List Namespaces for Infra Monitoring
       tags:
       - inframonitoring
@@ -19613,9 +19529,9 @@ paths:
           description: Internal Server Error
       security:
       - api_key:
-        - metrics:read
+        - VIEWER
       - tokenizer:
-        - metrics:read
+        - VIEWER
       summary: List Nodes for Infra Monitoring
       tags:
       - inframonitoring
@@ -19689,9 +19605,9 @@ paths:
           description: Internal Server Error
       security:
       - api_key:
-        - metrics:read
+        - VIEWER
       - tokenizer:
-        - metrics:read
+        - VIEWER
       summary: List Pods for Infra Monitoring
       tags:
       - inframonitoring
@@ -19760,9 +19676,9 @@ paths:
           description: Internal Server Error
       security:
       - api_key:
-        - metrics:read
+        - VIEWER
       - tokenizer:
-        - metrics:read
+        - VIEWER
       summary: List Volumes for Infra Monitoring
       tags:
       - inframonitoring
@@ -19838,9 +19754,9 @@ paths:
           description: Internal Server Error
       security:
       - api_key:
-        - metrics:read
+        - VIEWER
       - tokenizer:
-        - metrics:read
+        - VIEWER
       summary: List StatefulSets for Infra Monitoring
       tags:
       - inframonitoring
@@ -25008,75 +24924,6 @@ paths:
       tags:
       - rules
       x-signoz-stability: alpha
-  /api/v2/rules/{id}/clone:
-    post:
-      deprecated: false
-      description: This endpoint creates a new alert rule from the stored definition
-        of an existing one. The clone keeps every modeled field of the source, including
-        its enabled/disabled state, and gets the source's name suffixed with " - Copy"
-        (or a bumped " - Copy (n)" counter when the source is itself a copy). The
-        clone is owned by the caller.
-      operationId: CloneRuleByID
-      parameters:
-      - in: path
-        name: id
-        required: true
-        schema:
-          type: string
-      responses:
-        "201":
-          content:
-            application/json:
-              schema:
-                properties:
-                  data:
-                    $ref: '#/components/schemas/RuletypesRule'
-                  status:
-                    type: string
-                required:
-                - status
-                - data
-                type: object
-          description: Created
-        "400":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Bad Request
-        "401":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Unauthorized
-        "403":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Forbidden
-        "404":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Not Found
-        "500":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Internal Server Error
-      security:
-      - api_key:
-        - EDITOR
-      - tokenizer:
-        - EDITOR
-      summary: Clone alert rule
-      tags:
-      - rules
-      x-signoz-stability: alpha
   /api/v2/rules/{id}/history/filter_keys:
     get:
       deprecated: false

docs/contributing/tests/e2e.md

@@ -11,7 +11,7 @@ Before running E2E tests, ensure you have the following installed:
 - Python 3.13+
 - [uv](https://docs.astral.sh/uv/getting-started/installation/)
 - Docker (for containerized services)
-- Node 18+ and pnpm
+- Node 18+ and Yarn
 
 ### Initial Setup
 
@@ -24,8 +24,8 @@ uv sync
 2. Install Node deps and Playwright browsers:
 ```bash
 cd e2e
-pnpm install
-pnpm install:browsers   # one-time Playwright browser install
+yarn install
+yarn install:browsers   # one-time Playwright browser install
 ```
 
 ### Starting the Test Environment
@@ -84,117 +84,105 @@ tests/
     ├── playwright.config.ts   # loads .env + .env.local via dotenv
     ├── .env.example           # staging-mode template
     ├── .env.local             # generated by bootstrap/setup.py (gitignored)
-    ├── AGENTS.md              # read this before writing a spec
     ├── bootstrap/
     │   └── setup.py           # test_setup / test_teardown — pytest lifecycle
-    ├── drivers/               # the driver kit: one module per feature
-    │   ├── kit.ts             # layer(), seeded(), the root `test`
-    │   ├── auth.ts            # login + per-worker storageState
-    │   ├── api.ts             # authed HTTP client + seeder URL
-    │   ├── tanstack.ts        # the shared table driver
-    │   ├── alerts/            # feature driver, seeds, payloads
-    │   └── infra/             # feature driver, seeds, __generated__/datasets.ts
-    ├── docs/flake-notes.md    # measurements and timeout budgets
-    ├── testdata/              # static data files (marked generated)
-    ├── tests/                 # Playwright .spec.ts files, one dir per feature
+    ├── fixtures/              # Playwright test fixtures (test.extend) only
+    │   └── auth.ts
+    ├── helpers/               # function helpers + the constants they share with tests
+    │   ├── auth.ts
+    │   └── dashboards.ts
+    ├── testdata/              # static data files (JSON) used by helpers and tests
+    │   └── apm-metrics.json   # (example)
+    ├── tests/                 # Playwright .spec.ts files, one dir per feature area
     │   └── alerts/
-    │       └── list.spec.ts   # (example)
+    │       └── alerts.spec.ts # (example)
     └── artifacts/             # per-run output (gitignored)
         ├── html/              # HTML reporter output
         ├── json/              # JSON reporter output
         └── results/           # per-test traces / screenshots / videos on failure
 ```
 
-### The driver kit
+### `fixtures/` vs `helpers/` — what goes where
 
-A spec imports **one** module: its feature's `test` constant. That constant is
-built by composing layers, and each layer adds one named driver to the test
-arguments — so a spec body never handles a `Page`:
+These two folders look similar but mean different things:
 
-```ts
-import { expect, test } from '../../drivers/alerts';
+- **`fixtures/`** holds *Playwright test fixtures* (created via `test.extend({...})`). By the canonical definition, a fixture is "a consistent, predefined set of data, objects, or environmental conditions used to ensure tests run in a stable state" — i.e. setup/teardown that runs *automatically* around each test or worker. `auth.ts` matches: it extends Playwright's `test` with an `authedPage` that's logged-in before every test runs and torn down after. If the only thing in this folder ever is `auth.ts`, that's fine — fixtures are a deliberately small surface.
+- **`helpers/`** holds plain function helpers that you call *explicitly* from a test or hook — they don't extend Playwright's `test`. This covers both behaviour helpers (e.g. `gotoDashboardsList(page)`) and the constants those helpers and the tests both refer to (e.g. `SEARCH_PLACEHOLDER`). Constants live next to the helpers that use them so a single import line in a test covers both.
+- **`testdata/`** holds static data files (typically JSON / YAML) consumed by the helpers — for example, `apm-metrics.json`, a real dashboard payload uploaded through the UI by an importer helper.
 
-test('TC-01 seeded rules render', async ({ alerts, alertList }) => {
-  await alerts.list.goto({ search: alertList.namePrefix });
-  await expect(alerts.list.rows()).toHaveCount(10);
-});
-```
+Rule of thumb: if it's a `test.extend` fixture, put it in `fixtures/`. If it's a function you call explicitly (or a constant the function uses), put it in `helpers/`. If it's a static file the helpers read, put it in `testdata/`.
 
-- **`drivers/kit.ts`** holds the composition primitives. `driver(name, build)`
-  binds a factory to the authenticated page; `seeded(name, open, close)` seeds
-  data once per worker on a throwaway admin page and tears it down after;
-  `allowFor(floor)` raises the test timeout to a floor and never lowers it.
-  `test.slow()` is banned in drivers, because it compounds when called in a loop.
-- **`drivers/<feature>.ts`** (or `drivers/<feature>/`) exports the feature's
-  driver, its layers, and the composed `test`. A driver is a plain function
-  returning an object of closures — no classes, and no `page` parameter on
-  anything a spec calls.
-- **Shared drivers** — `tanstack.ts` (the table), `querysearch.ts` (the
-  expression editor), `antd.ts` (select primitives), `console.ts`, `api.ts`,
-  `storage.ts` — are composed into feature drivers by direct call, not by
-  reaching for another fixture.
-- **`drivers/` is AI-owned**: coding agents generate and maintain it with the
-  specs, and `.gitattributes` collapses it in diffs.
-- **`testdata/`** and any `__generated__/` directory hold transcribed data. Both
-  are marked `linguist-generated`; something in the suite re-derives them at
-  runtime, so a stale value fails loudly rather than silently.
+### Extended fixtures
+
+For features needing complex setup (API-seeded data, ruler evaluation waits, cleanup), create domain-specific fixtures that extend `auth`. Group them in `fixtures/<domain>/`.
 
 **Fixture scopes:**
 - **test scope** — fresh data per test. Use for mutations (edit, delete, rename).
-- **worker scope** — shared across a worker. Use for read-only data; it pays the
-  setup cost once per worker instead of once per test. Playwright builds them
-  lazily, so a spec that never destructures a seed never pays for it.
-- **suite scope**: a dataset only one file uses. Seed it in `test.beforeAll`
-  through `onAdminPage(browser, …)`, since `authedPage` is test-scoped.
+- **worker scope** — shared across tests in one worker. Use for read-only data. Worker scope pays the setup cost once per worker instead of once per test.
 
-### Which layer does this test belong to?
+**The alerts pattern** (`fixtures/alerts/`) demonstrates extending fixtures:
 
-Four layers run against this codebase, in cost order: **jest → Storybook + msw →
-pytest integration → Playwright**. Before writing an E2E, check the cheaper
-three. [`tests/e2e/AGENTS.md`](../../../tests/e2e/AGENTS.md) has the full rule;
-the short version:
+```
+fixtures/alerts/
+├── alert-rules.ts   # extends auth — worker-scoped rule list + test-scoped factory
+└── alert-history.ts # extends alert-rules — adds history fixtures (waits on ruler)
+```
 
-- A pure function, a reducer, a config literal or a component's own behaviour is
-  a **jest** test. Most containers under `frontend/src/container/` already have
-  one.
-- A rendered state that needs no backend (empty, error, loading) is a
-  **Storybook** story or a jest test with a fixed mock.
-- Anything the **API** does — ordering, pagination, filter semantics, validation,
-  roll-ups — is a pytest integration test, and for infra monitoring and alert
-  evaluation it very likely already exists. Grep `tests/integration/` first.
-- An **E2E** is for a real response reaching a real DOM: URL and history, write
-  paths that must persist, cross-page navigation, and one seeded proof per
-  surface.
+Specs import from the fixture they need:
+
+```ts
+// List tests — just need rules, no history
+import { test, expect } from '../../../fixtures/alerts/alert-rules';
+
+// History tests — need history rows from ruler evaluation
+import { test, expect } from '../../../fixtures/alerts/alert-history';
+```
+
+**When creating new fixtures:**
+
+1. **Identify scope** — Will tests mutate the data? If yes, test-scoped. If read-only, worker-scoped.
+2. **Group by domain** — Put fixtures in `fixtures/<domain>/`. Helpers in `helpers/<domain>/`.
+3. **Extend existing fixtures** — Chain from `auth` or another fixture to inherit its setup.
+4. **Handle timeouts** — Worker-scoped fixtures that wait on backend processing need explicit timeouts.
+5. **Clean up** — Always delete seeded data in the fixture teardown (after `use()`).
+6. **Extract logic into functions** — Keep the `test.extend()` block lean; move setup/teardown logic to named functions so the extend block reads as a manifest of "what fixtures exist."
 
 Each spec follows these principles:
 
 1. **Directory per feature**: `tests/e2e/tests/<feature>/*.spec.ts`. Cross-resource junction concerns (e.g. cascade-delete) go in their own file, not packed into one giant spec.
 2. **Test titles use `TC-NN`**: `test('TC-01 alerts page — tabs render', ...)`. Preserves ordering at a glance and maps to external coverage tracking.
-3. **UI-first**: drive flows through the UI. Playwright traces capture every BE request/response the UI triggers, so asserting on UI outcomes implicitly validates BE contracts. To assert a write, attach `page.waitForResponse` before the click, then reload and re-read from the server.
-4. **Self-contained state**: each spec seeds its own data, scopes its assertions to the names it seeded, and cleans up. The pytest harness creates a fresh stack with **zero** dashboards / alerts / etc. Names carry the worker index, so parallel workers never collide. Pick the scope from the list above.
-5. **Seed through the kit when the UI flow is not under test.** `apiDriver(page)` (`drivers/api.ts`) creates control-plane objects with the session's token, and the seeder takes telemetry. The JWT lives in `localStorage`, so a spec never improvises with `page.request.*`. Feature drivers wrap both (`dashboards.create`, `alerts.seed.threshold`).
-6. **Reusable static data lives in `tests/e2e/testdata/`.** For example, `traces/large-trace.json` is POSTed to the seeder by `drivers/traces.ts`. Infra monitoring reads the integration suite's fixtures through `seedDataset` (`drivers/infra/seed.ts`) instead of keeping a copy, and asserts on what it returned.
-7. **Locate by testid, in the driver.** A missing testid is added to the product in the same change. Role, label and CSS lookups are a stopgap, converted as that code is touched; antd internals (`.ant-select-dropdown`) are the exception, since the markup is not ours.
+3. **UI-first**: drive flows through the UI. Playwright traces capture every BE request/response the UI triggers, so asserting on UI outcomes implicitly validates BE contracts. Reach for direct `page.request.*` only when the test's *purpose* is asserting a response contract (use `page.waitForResponse` on a UI click) or when a specific UI step is structurally flaky (e.g. Ant DatePicker calendar-cell indices) — and even then try UI first.
+4. **Self-contained state**: each spec seeds its own data and cleans up at suite teardown. The pytest harness creates a fresh stack with **zero** dashboards / alerts / etc. — never assume pre-existing data. Two patterns work:
+    - **Per-test seed + cleanup in `try / finally`** — small specs where each test owns its data.
+    - **Suite-level seed + `afterAll` teardown** — preferred for larger specs. Each `createDashboard(...)` call adds the resulting ID to a module-level `Set<string>`, and one `test.afterAll(...)` deletes everything in the set. See `tests/e2e/tests/dashboards/list.spec.ts` for the full pattern. `test.beforeAll` / `test.afterAll` cannot use `authedPage` directly (it's test-scoped); use `newAdminContext(browser)` from `helpers/auth.ts` instead — it performs one fresh login per suite hook.
+5. **Seed via API when the UI flow is multi-step or brittle.** The frontend stores its JWT in `localStorage` under `AUTH_TOKEN`; `page.request.*` inherits the auth fixture's storage state. A typical pattern:
+    ```ts
+    const token = await page.evaluate(
+      () => (globalThis as any).localStorage.getItem('AUTH_TOKEN') || '',
+    );
+    await page.request.post('/api/v1/dashboards', {
+      data: { title: 'my-name', uploadedGrafana: false },
+      headers: { Authorization: `Bearer ${token}` },
+    });
+    ```
+    This is faster and more reliable than a multi-step UI seed. Reach for the UI flow only when the test's *purpose* is asserting that flow.
+6. **Reusable static data lives in `tests/e2e/testdata/`.** For example, `apm-metrics.json` is a real dashboard payload that `importApmMetricsDashboardViaUI` (in `helpers/dashboards.ts`) uploads through the actual Import JSON UI flow to seed a richly-tagged dashboard for search/list tests.
 
 ## How to write an E2E test?
 
 Create a new file `tests/e2e/tests/alerts/smoke.spec.ts`:
 
 ```typescript
-import { ALERT_LIST_PAGE_SIZE, expect, test } from '../../drivers/alerts';
+import { test, expect } from '../../fixtures/auth';
 
-test('TC-01 seeded rules render and paginate', async ({ alerts, alertList }) => {
-  await alerts.list.goto({ search: alertList.namePrefix });
-  await expect(alerts.list.table.totalCount()).toContainText(`of ${alertList.count}`);
-  await expect(alerts.list.rows()).toHaveCount(ALERT_LIST_PAGE_SIZE);
+test('TC-01 alerts page — tabs render', async ({ authedPage: page }) => {
+  await page.goto('/alerts');
+  await expect(page.getByRole('tab', { name: /alert rules/i })).toBeVisible();
+  await expect(page.getByRole('tab', { name: /configuration/i })).toBeVisible();
 });
 ```
 
-`alertList` is a worker-scoped seed: the rules exist before the test starts, are
-shared by every test in the worker that asks for them, and are deleted when the
-worker ends.
-
-The `authedPage` fixture (from `tests/e2e/drivers/kit.ts`, re-exported by every feature's `test`) gives you a `Page` whose browser context is already authenticated as the admin user. First use per worker triggers one login; the resulting `storageState` is held in memory and reused for later requests. Take it only when the driver genuinely does not cover what you need — navigation, `goBack`, `waitForResponse`, a second tab.
+The `authedPage` fixture (from `tests/e2e/fixtures/auth.ts`) gives you a `Page` whose browser context is already authenticated as the admin user. First use per worker triggers one login; the resulting `storageState` is held in memory and reused for later requests.
 
 To run just this test (assuming the stack is up via `test_setup`):
 
@@ -203,56 +191,52 @@ cd tests/e2e
 npx playwright test tests/alerts/smoke.spec.ts --project=chromium
 ```
 
-Here's a more comprehensive example, driven entirely through the feature's
-driver:
+Here's a more comprehensive example that exercises a CRUD flow via the UI:
 
 ```typescript
-import { expect, test } from '../../drivers/alerts';
+import { test, expect } from '../../fixtures/auth';
 
-test('TC-02 row actions persist: disable, then enable', async ({
-  authedPage: page,
-  alerts,
-  ownedRules,
-}) => {
-  const name = `smoke-rule-${Date.now()}`;
-  const ruleId = await ownedRules.threshold(name);
+test.describe.configure({ mode: 'serial' });
 
-  await alerts.list.goto({ search: name });
-  await expect(alerts.list.stateCell(ruleId)).toHaveText('OK');
+test('TC-02 alerts list — create, toggle, delete', async ({ authedPage: page }) => {
+  await page.goto('/alerts?tab=AlertRules');
+  const name = 'smoke-rule';
 
-  await alerts.list.openFirstRowActions();
-  await Promise.all([
-    // waitForResponse captures the call the UI triggers — no parallel fetch.
-    page.waitForResponse(
-      (res) =>
-        res.url().includes(`/api/v2/rules/${ruleId}`) &&
-        res.request().method() === 'PATCH',
-    ),
-    alerts.list.menuItem('Disable').click(),
-  ]);
+  // Seed via UI — click "New Alert", fill form, save.
+  await page.getByRole('button', { name: /new alert/i }).click();
+  await page.getByTestId('alert-name-input').fill(name);
+  // ... fill metric / threshold / save ...
 
-  // Re-read from the server rather than trusting the optimistic update.
-  await page.reload();
-  await expect(alerts.list.stateCell(ruleId)).toHaveText('Disabled');
+  // Find the row and exercise the action menu.
+  const row = page.locator('tr', { hasText: name });
+  await expect(row).toBeVisible();
+  await row.locator('[data-testid="alert-actions"] button').first().click();
+
+  // waitForResponse captures the network call the UI triggers — no parallel fetch needed.
+  const patchWait = page.waitForResponse(
+    (r) => r.url().includes('/rules/') && r.request().method() === 'PATCH',
+  );
+  await page.getByRole('menuitem').filter({ hasText: /^disable$/i }).click();
+  await patchWait;
+  await expect(row).toContainText(/disabled/i);
 });
 ```
 
-`ownedRules` is a test-scoped seed: every rule it creates is deleted when the
-test finishes, so the spec owns its data and nothing leaks into the next one.
+### Locator priority
 
-### Commits
-
-Commit driver changes apart from specs, product testids and tests moved to
-another layer, so each commit can be reviewed on its own.
-[`tests/e2e/AGENTS.md`](../../../tests/e2e/AGENTS.md#commits) has the order.
-`pnpm typecheck`, `pnpm lint` and `pnpm fmt:check` gate the suite.
+1. `getByTestId('...')` — preferred when the source exposes one. Stable, app-author-provided handle that survives copy-edits.
+2. `getByRole('button', { name: 'Submit' })`
+3. `getByLabel('Email')`
+4. `getByPlaceholder('...')`
+5. `getByText('...')`
+6. `locator('.ant-select')` — last resort (Ant Design dropdowns often have no semantic alternative)
 
 ## Agents
 
 Three Claude agents in `.claude/agents/` accelerate writing and maintaining E2E specs:
 
 - **`playwright-test-planner`** — explores a feature in a real browser plus the local frontend source and writes a test plan as a scratch markdown file (under `tests/e2e/specs/`, which is gitignored — plans are working artifacts for the generator, not committed docs).
-- **`playwright-test-generator`** — converts a test plan into Playwright spec files under `tests/e2e/tests/<feature>/`. Drives each scenario through MCP browser tools and emits TC-NN-titled tests on the feature's driver, adding the driver methods and seeds the plan needs.
+- **`playwright-test-generator`** — converts a test plan into Playwright spec files under `tests/e2e/tests/<feature>/`. Drives each scenario through MCP browser tools and emits TC-NN-titled tests using the `authedPage` fixture and the API-seed pattern.
 - **`playwright-test-healer`** — runs failing specs, debugs them with snapshots / console / network introspection, and edits the spec to fix selector drift, timing, or state-leak issues.
 
 The agents rely on the Playwright-test MCP server (`mcp__playwright-test__*` tools). Configure it in your Claude MCP settings; the permission allowlist lives in [.claude/settings.local.json](../../../.claude/settings.local.json).
@@ -264,15 +248,15 @@ The agents rely on the Playwright-test MCP server (`mcp__playwright-test__*` too
 With the stack already up, from `tests/e2e/`:
 
 ```bash
-pnpm test                 # headless, all projects
+yarn test                 # headless, all projects
 ```
 
 ### Running Specific Projects
 
 ```bash
-pnpm test:chromium        # chromium only
-pnpm test:firefox
-pnpm test:webkit
+yarn test:chromium        # chromium only
+yarn test:firefox
+yarn test:webkit
 ```
 
 ### Running Specific Tests
@@ -290,17 +274,17 @@ npx playwright test tests/alerts/history/ --project=chromium
 npx playwright test tests/alerts/page.spec.ts --project=chromium
 
 # Single test by title grep
-npx playwright test --project=chromium -g "TC-01"
+npx playwright test --project=chromium -g "AL-01"
 ```
 
 ### Iterative modes
 
 ```bash
-pnpm test:ui              # Playwright UI mode — watch + step through
-pnpm test:headed          # headed browser
-pnpm test:debug           # Playwright inspector, pause-on-breakpoint
-pnpm codegen              # record-and-replay locator generation
-pnpm report               # open the last HTML report (artifacts/html)
+yarn test:ui              # Playwright UI mode — watch + step through
+yarn test:headed          # headed browser
+yarn test:debug           # Playwright inspector, pause-on-breakpoint
+yarn codegen              # record-and-replay locator generation
+yarn report               # open the last HTML report (artifacts/html)
 ```
 
 ### Staging fallback
@@ -310,7 +294,7 @@ Point `SIGNOZ_E2E_BASE_URL` at a remote env via `.env` — no local backend brin
 ```bash
 cd tests/e2e
 cp .env.example .env      # fill SIGNOZ_E2E_USERNAME / PASSWORD
-pnpm test:staging
+yarn test:staging
 ```
 
 ## How to configure different options for E2E tests?
@@ -358,14 +342,12 @@ The same pytest flags integration tests expose work here, since E2E reuses the s
 - **Always use the `--reuse` flag** when setting up the E2E stack. `--with-web` adds a ~4 min frontend build on a cold start; later builds are incremental.
 - **Changed backend or frontend code? Re-run the setup command** — it passes `--rebuild`, swapping the SigNoz container for one built from your current sources while the rest of the stack stays up.
 - **Don't teardown before setup.** `--reuse` correctly handles partially-set-up state, so chaining teardown → setup wastes time.
-- **Prefer UI-driven flows.** Playwright captures BE requests in the trace; a parallel `fetch` probe is almost always redundant. Seed through the kit, never with `page.request.*`.
+- **Prefer UI-driven flows.** Playwright captures BE requests in the trace; a parallel `fetch` probe is almost always redundant. Drop to `page.request.*` only when the UI can't reach what you need.
 - **Use `page.waitForResponse` on UI clicks** to assert BE contracts — it still exercises the UI trigger path.
 - **Title every test `TC-NN <short description>`** — keeps the suite navigable and reportable.
 - **Split by resource, not by regression suite.** One spec per feature resource; cross-resource junction concerns (cascade-delete, linked-edit) get their own file.
-- **Name resources by what they are, plus the worker index** (`e2e-alert-list-w${workerIndex}-${Date.now()}`). Six workers share one stack, so assert only on names you seeded.
+- **Use short descriptive resource names** (`alerts-list-rule`, `labels-rule`, `downtime-once`) — no timestamp disambiguation. Each test owns its resources and cleans up in `try/finally`.
 - **Never commit `test.only`** — a pre-commit check or CI runs with `forbidOnly: true`.
 - **Prefer explicit waits over `page.waitForTimeout(ms)`.** `await expect(locator).toBeVisible()` is always better than `waitForTimeout(5000)`.
 - **Unique test names won't save you from shared-tenant state.** When two tests hit the same list page, either serialize (`describe.configure({ mode: 'serial' })`) or isolate cleanup religiously.
-- **Green locally, red on CI?** Run `STRESS=1 CI=1 pnpm test <path>` (4x CPU throttle, 2 workers, 2 retries) before filing a product bug.
-- **Commit drivers apart from specs.** One concern per commit; see [Commits](#commits).
 - **Artifacts go to `tests/e2e/artifacts/`** — HTML report at `artifacts/html`, traces at `artifacts/results/<test>/`. All gitignored; archive the dir in CI.

ee/query-service/rules/anomaly.go

@@ -423,7 +423,7 @@ func (r *AnomalyRule) Eval(ctx context.Context, ts time.Time) (int, error) {
 func (r *AnomalyRule) String() string {
 
 	ar := ruletypes.PostableRule{
-		AlertName:         valuer.NewDisplayName(r.Name()),
+		AlertName:         r.Name(),
 		RuleCondition:     r.Condition(),
 		EvalWindow:        r.EvalWindow(),
 		Labels:            r.Labels().Map(),

ee/query-service/rules/anomaly_test.go

@@ -46,7 +46,7 @@ func TestAnomalyRule_NoData_AlertOnAbsent(t *testing.T) {
 	target := 500.0
 
 	postableRule := ruletypes.PostableRule{
-		AlertName: valuer.NewDisplayName("Test anomaly no data"),
+		AlertName: "Test anomaly no data",
 		AlertType: ruletypes.AlertTypeMetric,
 		RuleType:  ruletypes.RuleTypeAnomaly,
 		Evaluation: &ruletypes.EvaluationEnvelope{Kind: ruletypes.RollingEvaluation, Spec: ruletypes.RollingWindow{
@@ -149,7 +149,7 @@ func TestAnomalyRule_NoData_AbsentFor(t *testing.T) {
 	target := 500.0
 
 	postableRule := ruletypes.PostableRule{
-		AlertName: valuer.NewDisplayName("Test anomaly no data with AbsentFor"),
+		AlertName: "Test anomaly no data with AbsentFor",
 		AlertType: ruletypes.AlertTypeMetric,
 		RuleType:  ruletypes.RuleTypeAnomaly,
 		Evaluation: &ruletypes.EvaluationEnvelope{Kind: ruletypes.RollingEvaluation, Spec: ruletypes.RollingWindow{

ee/query-service/rules/manager.go

@@ -13,7 +13,6 @@ import (
 	"github.com/SigNoz/signoz/pkg/errors"
 	baserules "github.com/SigNoz/signoz/pkg/query-service/rules"
 	"github.com/SigNoz/signoz/pkg/types/ruletypes"
-	"github.com/SigNoz/signoz/pkg/valuer"
 )
 
 func PrepareTaskFunc(opts baserules.PrepareTaskOptions) (baserules.Task, error) {
@@ -119,7 +118,7 @@ func TestNotification(opts baserules.PrepareTestRuleOptions) (int, error) {
 	}
 
 	parsedRule := opts.Rule
-	var alertname = parsedRule.AlertName.StringValue()
+	var alertname = parsedRule.AlertName
 	if alertname == "" {
 		// alertname is not mandatory for testing, so picking
 		// a random string here
@@ -127,7 +126,7 @@ func TestNotification(opts baserules.PrepareTestRuleOptions) (int, error) {
 	}
 
 	// append name to indicate this is test alert
-	parsedRule.AlertName = valuer.NewDisplayName(fmt.Sprintf("%s%s", alertname, ruletypes.TestAlertPostFix))
+	parsedRule.AlertName = fmt.Sprintf("%s%s", alertname, ruletypes.TestAlertPostFix)
 
 	var rule baserules.Rule
 	var err error

frontend/src/AppRoutes/__tests__/Private.test.tsx

@@ -300,17 +300,20 @@ describe('PrivateRoute', () => {
 			);
 		});
 
-		it.each([
-			['/logs-save-views', ROUTES.LOGS_EXPLORER],
-			['/traces-save-views', ROUTES.TRACES_EXPLORER],
-			[ROUTES.LOGS_SAVE_VIEWS, ROUTES.LOGS_EXPLORER],
-			[ROUTES.TRACES_SAVE_VIEWS, ROUTES.TRACES_EXPLORER],
-			[ROUTES.METRICS_EXPLORER_VIEWS, ROUTES.METRICS_EXPLORER_EXPLORER],
-			[ROUTES.METER_EXPLORER_VIEWS, ROUTES.METER_EXPLORER],
-		])('should redirect the old views route %s to %s', (from, to) => {
-			renderPrivateRoute({ initialRoute: from });
+		it('should redirect /logs-save-views to /logs/saved-views', () => {
+			renderPrivateRoute({ initialRoute: '/logs-save-views' });
 
-			expect(screen.getByTestId('location-display').textContent).toBe(to);
+			expect(screen.getByTestId('location-display')).toHaveTextContent(
+				'/logs/saved-views',
+			);
+		});
+
+		it('should redirect /traces-save-views to /traces/saved-views', () => {
+			renderPrivateRoute({ initialRoute: '/traces-save-views' });
+
+			expect(screen.getByTestId('location-display')).toHaveTextContent(
+				'/traces/saved-views',
+			);
 		});
 
 		it('should redirect /settings/access-tokens to /settings/service-accounts', () => {
@@ -1632,6 +1635,11 @@ describe('PrivateRoute', () => {
 			['LIST_LICENSES', ROUTES.LIST_LICENSES, USER_ROLES.EDITOR as ROLES],
 			['ONBOARDING', ROUTES.ONBOARDING, USER_ROLES.VIEWER as ROLES],
 			['APPLICATION', ROUTES.APPLICATION, USER_ROLES.ANONYMOUS as ROLES],
+			[
+				'METRICS_EXPLORER_VIEWS',
+				ROUTES.METRICS_EXPLORER_VIEWS,
+				USER_ROLES.ANONYMOUS as ROLES,
+			],
 		];
 
 		it.each(authzRouteRolePairs)(

frontend/src/AppRoutes/routes.ts

@@ -513,12 +513,8 @@ export const LIST_LICENSES: AppRoutes = {
 export const oldNewRoutesMapping: Record<string, string> = {
 	'/pipelines': '/logs/pipelines',
 	'/logs-explorer': '/logs/logs-explorer',
-	'/logs-save-views': '/logs/logs-explorer',
-	'/traces-save-views': '/traces-explorer',
-	'/logs/saved-views': '/logs/logs-explorer',
-	'/traces/saved-views': '/traces-explorer',
-	'/metrics-explorer/views': '/metrics-explorer/explorer',
-	'/meter/explorer/views': '/meter/explorer',
+	'/logs-save-views': '/logs/saved-views',
+	'/traces-save-views': '/traces/saved-views',
 	'/settings/access-tokens': '/settings/service-accounts',
 	'/settings/api-keys': '/settings/service-accounts',
 	'/messaging-queues': '/messaging-queues/overview',

frontend/src/api/__tests__/ErrorResponseHandler.test.ts

@@ -9,14 +9,12 @@ describe('ErrorResponseHandler', () => {
 			.spyOn(console, 'error')
 			.mockImplementation(() => undefined);
 
-		expect(ErrorResponseHandler(new CanceledError() as AxiosError)).toStrictEqual(
-			{
-				statusCode: 500,
-				payload: null,
-				error: 'Something went wrong',
-				message: null,
-			},
-		);
+		expect(ErrorResponseHandler(new CanceledError() as AxiosError)).toEqual({
+			statusCode: 500,
+			payload: null,
+			error: 'Something went wrong',
+			message: null,
+		});
 		expect(consoleError).not.toHaveBeenCalled();
 
 		consoleError.mockRestore();

frontend/src/api/generated/services/promote/index.ts

@@ -18,10 +18,8 @@ import type {
 } from 'react-query';
 
 import type {
-	IndexMaterializedPaths200,
 	ListPromotedPaths200,
 	ListPromotedPathsParams,
-	PromotetypesPostableIndexMaterializedPathsDTO,
 	PromotetypesPromotePathDTO,
 	RenderErrorResponseDTO,
 } from '../sigNoz.schemas';
@@ -232,87 +230,3 @@ export const usePromotePaths = <
 > => {
 	return useMutation(getPromotePathsMutationOptions(options));
 };
-/**
- * This endpoint indexes the JSON sub-columns of materialized paths whose columns are indexed and returns the indexed and skipped paths.
- * @summary Index materialized paths
- */
-export const indexMaterializedPaths = (
-	promotetypesPostableIndexMaterializedPathsDTO?: BodyType<PromotetypesPostableIndexMaterializedPathsDTO>,
-	signal?: AbortSignal,
-) => {
-	return GeneratedAPIInstance<IndexMaterializedPaths200>({
-		url: `/api/v1/promoted_paths/materialized`,
-		method: 'POST',
-		headers: { 'Content-Type': 'application/json' },
-		data: promotetypesPostableIndexMaterializedPathsDTO,
-		signal,
-	});
-};
-
-export const getIndexMaterializedPathsMutationOptions = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown,
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof indexMaterializedPaths>>,
-		TError,
-		{ data?: BodyType<PromotetypesPostableIndexMaterializedPathsDTO> },
-		TContext
-	>;
-}): UseMutationOptions<
-	Awaited<ReturnType<typeof indexMaterializedPaths>>,
-	TError,
-	{ data?: BodyType<PromotetypesPostableIndexMaterializedPathsDTO> },
-	TContext
-> => {
-	const mutationKey = ['indexMaterializedPaths'];
-	const { mutation: mutationOptions } = options
-		? options.mutation &&
-			'mutationKey' in options.mutation &&
-			options.mutation.mutationKey
-			? options
-			: { ...options, mutation: { ...options.mutation, mutationKey } }
-		: { mutation: { mutationKey } };
-
-	const mutationFn: MutationFunction<
-		Awaited<ReturnType<typeof indexMaterializedPaths>>,
-		{ data?: BodyType<PromotetypesPostableIndexMaterializedPathsDTO> }
-	> = (props) => {
-		const { data } = props ?? {};
-
-		return indexMaterializedPaths(data);
-	};
-
-	return { mutationFn, ...mutationOptions };
-};
-
-export type IndexMaterializedPathsMutationResult = NonNullable<
-	Awaited<ReturnType<typeof indexMaterializedPaths>>
->;
-export type IndexMaterializedPathsMutationBody =
-	| BodyType<PromotetypesPostableIndexMaterializedPathsDTO>
-	| undefined;
-export type IndexMaterializedPathsMutationError =
-	ErrorType<RenderErrorResponseDTO>;
-
-/**
- * @summary Index materialized paths
- */
-export const useIndexMaterializedPaths = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown,
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof indexMaterializedPaths>>,
-		TError,
-		{ data?: BodyType<PromotetypesPostableIndexMaterializedPathsDTO> },
-		TContext
-	>;
-}): UseMutationResult<
-	Awaited<ReturnType<typeof indexMaterializedPaths>>,
-	TError,
-	{ data?: BodyType<PromotetypesPostableIndexMaterializedPathsDTO> },
-	TContext
-> => {
-	return useMutation(getIndexMaterializedPathsMutationOptions(options));
-};

frontend/src/api/generated/services/rules/index.ts

@@ -18,8 +18,6 @@ import type {
 } from 'react-query';
 
 import type {
-	CloneRuleByID201,
-	CloneRuleByIDPathParameters,
 	CreateRule201,
 	CreateRuleView201,
 	DeleteRuleByIDPathParameters,
@@ -965,85 +963,6 @@ export const useUpdateRuleByID = <
 > => {
 	return useMutation(getUpdateRuleByIDMutationOptions(options));
 };
-/**
- * This endpoint creates a new alert rule from the stored definition of an existing one. The clone keeps every modeled field of the source, including its enabled/disabled state, and gets the source's name suffixed with " - Copy" (or a bumped " - Copy (n)" counter when the source is itself a copy). The clone is owned by the caller.
- * @summary Clone alert rule
- */
-export const cloneRuleByID = (
-	{ id }: CloneRuleByIDPathParameters,
-	signal?: AbortSignal,
-) => {
-	return GeneratedAPIInstance<CloneRuleByID201>({
-		url: `/api/v2/rules/${id}/clone`,
-		method: 'POST',
-		signal,
-	});
-};
-
-export const getCloneRuleByIDMutationOptions = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown,
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof cloneRuleByID>>,
-		TError,
-		{ pathParams: CloneRuleByIDPathParameters },
-		TContext
-	>;
-}): UseMutationOptions<
-	Awaited<ReturnType<typeof cloneRuleByID>>,
-	TError,
-	{ pathParams: CloneRuleByIDPathParameters },
-	TContext
-> => {
-	const mutationKey = ['cloneRuleByID'];
-	const { mutation: mutationOptions } = options
-		? options.mutation &&
-			'mutationKey' in options.mutation &&
-			options.mutation.mutationKey
-			? options
-			: { ...options, mutation: { ...options.mutation, mutationKey } }
-		: { mutation: { mutationKey } };
-
-	const mutationFn: MutationFunction<
-		Awaited<ReturnType<typeof cloneRuleByID>>,
-		{ pathParams: CloneRuleByIDPathParameters }
-	> = (props) => {
-		const { pathParams } = props ?? {};
-
-		return cloneRuleByID(pathParams);
-	};
-
-	return { mutationFn, ...mutationOptions };
-};
-
-export type CloneRuleByIDMutationResult = NonNullable<
-	Awaited<ReturnType<typeof cloneRuleByID>>
->;
-
-export type CloneRuleByIDMutationError = ErrorType<RenderErrorResponseDTO>;
-
-/**
- * @summary Clone alert rule
- */
-export const useCloneRuleByID = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown,
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof cloneRuleByID>>,
-		TError,
-		{ pathParams: CloneRuleByIDPathParameters },
-		TContext
-	>;
-}): UseMutationResult<
-	Awaited<ReturnType<typeof cloneRuleByID>>,
-	TError,
-	{ pathParams: CloneRuleByIDPathParameters },
-	TContext
-> => {
-	return useMutation(getCloneRuleByIDMutationOptions(options));
-};
 /**
  * Returns distinct label keys from rule history entries for the selected range.
  * @summary Get rule history filter keys

frontend/src/api/generated/services/sigNoz.schemas.ts

@@ -9878,28 +9878,6 @@ export interface PromotetypesPromotePathDTO {
 	signal: string;
 }
 
-export interface PromotetypesIndexMaterializedPathsResultDTO {
-	/**
-	 * @type array,null
-	 */
-	indexed: PromotetypesPromotePathDTO[] | null;
-	/**
-	 * @type array,null
-	 */
-	skipped: PromotetypesPromotePathDTO[] | null;
-}
-
-export interface PromotetypesPostableIndexMaterializedPathsDTO {
-	/**
-	 * @type boolean
-	 */
-	dryRun?: boolean;
-	/**
-	 * @type string
-	 */
-	signal: string;
-}
-
 export interface Querybuildertypesv5AggregationMetaDTO {
 	/**
 	 * @type array
@@ -13272,14 +13250,6 @@ export type ListPromotedPaths200 = {
 	status: string;
 };
 
-export type IndexMaterializedPaths200 = {
-	data: PromotetypesIndexMaterializedPathsResultDTO;
-	/**
-	 * @type string
-	 */
-	status: string;
-};
-
 export type ListRoles200 = {
 	/**
 	 * @type array
@@ -14612,17 +14582,6 @@ export type PatchRuleByID200 = {
 export type UpdateRuleByIDPathParameters = {
 	id: string;
 };
-export type CloneRuleByIDPathParameters = {
-	id: string;
-};
-export type CloneRuleByID201 = {
-	data: RuletypesRuleDTO;
-	/**
-	 * @type string
-	 */
-	status: string;
-};
-
 export type GetRuleHistoryFilterKeysPathParameters = {
 	id: string;
 };

frontend/src/api/v5/queryRange/convertV5Response.test.ts

@@ -61,11 +61,7 @@ describe('convertV5ResponseToLegacy', () => {
 							],
 							values: [
 								{ timestamp: 1000, value: 10 } as unknown as TimeSeriesValue,
-								{
-									timestamp: 2000,
-									value: 12,
-									partial: true,
-								} as unknown as TimeSeriesValue,
+								{ timestamp: 2000, value: 12 } as unknown as TimeSeriesValue,
 							],
 						} as unknown as TimeSeries,
 					],
@@ -108,7 +104,7 @@ describe('convertV5ResponseToLegacy', () => {
 				labels: { 'service.name': 'adservice' },
 				values: [
 					{ timestamp: 1000, value: '10' },
-					{ timestamp: 2000, value: '12', partial: true },
+					{ timestamp: 2000, value: '12' },
 				],
 				metaData: expect.objectContaining({
 					alias: '__result_0',

frontend/src/api/v5/queryRange/convertV5Response.ts

@@ -125,7 +125,6 @@ function convertTimeSeriesData(
 				values: series.values.map((value: any) => ({
 					timestamp: value.timestamp,
 					value: String(value.value),
-					...(value.partial ? { partial: true } : {}),
 				})),
 				metaData: {
 					alias,

frontend/src/assets/Logos/apache-druid.svg

@@ -1,3 +1,3 @@
 <svg role="img" viewBox="0 0 24 24" xmlns="http://www.w3.org/2000/svg">
-  <path fill="#0E9AA7" d="M8.932 20.806c-.369 0-.738.007-1.109 0-.35-.007-.587-.206-.623-.5a.587.587 0 0 1 .53-.636c.79-.062 1.582-.063 2.372-.003a.548.548 0 0 1 .522.602c-.024.326-.253.526-.616.54zM1.792 8.345c-.392 0-.782.008-1.173.002-.327-.006-.577-.22-.614-.512-.037-.293.146-.544.499-.615.192-.032.388-.045.583-.039a81.515 81.515 0 0 1 1.597 0c.163 0 .325.019.483.056.288.073.445.318.411.617-.034.298-.214.477-.515.487-.424.014-.848.004-1.272.004zm7.588 8.417H4.292a2.464 2.464 0 0 1-.326-.007c-.294-.04-.48-.209-.508-.506-.029-.298.11-.501.391-.606.179-.065.365-.051.549-.051 3.347 0 6.695.005 10.042-.006 1.174-.004 2.187-.439 2.993-1.3.69-.738 1.053-1.63 1.16-2.635.085-.788-.027-1.513-.516-2.156-.544-.718-1.28-1.078-2.163-1.082-3.163-.013-6.328-.005-9.487-.01-.336 0-.673-.027-1.007-.058-.29-.027-.45-.201-.469-.492-.021-.317.141-.545.429-.6a1.55 1.55 0 0 1 .29-.015h10.177c1.71.004 3.187 1.038 3.726 2.654.383 1.147.246 2.304-.182 3.416-.824 2.135-2.762 3.448-5.055 3.454-1.652.005-3.304 0-4.956 0zm2.906-13.568c1.533 0 3.066-.008 4.598 0 2.935.018 5.629 1.892 6.653 4.626.442 1.181.538 2.403.412 3.657-.185 1.842-.735 3.552-1.776 5.084-1.608 2.365-3.873 3.68-6.679 4.118-.95.148-1.905.13-2.86.13-.397 0-.61-.181-.633-.51-.025-.351.196-.621.587-.645.434-.026.87-.004 1.305-.016 2.641-.072 4.928-.982 6.74-2.935 1.269-1.37 1.912-3.039 2.13-4.878.151-1.275.135-2.544-.37-3.752-.773-1.85-2.159-2.983-4.068-3.509-.74-.204-1.5-.243-2.26-.247-2.837-.017-5.675-.007-8.511-.007-.12 0-.24.004-.359-.006a.57.57 0 0 1-.517-.536.557.557 0 0 1 .456-.557c.13-.018.261-.024.392-.019h4.762Z"/>
+  <path fill="#29F1FB" d="M8.932 20.806c-.369 0-.738.007-1.109 0-.35-.007-.587-.206-.623-.5a.587.587 0 0 1 .53-.636c.79-.062 1.582-.063 2.372-.003a.548.548 0 0 1 .522.602c-.024.326-.253.526-.616.54zM1.792 8.345c-.392 0-.782.008-1.173.002-.327-.006-.577-.22-.614-.512-.037-.293.146-.544.499-.615.192-.032.388-.045.583-.039a81.515 81.515 0 0 1 1.597 0c.163 0 .325.019.483.056.288.073.445.318.411.617-.034.298-.214.477-.515.487-.424.014-.848.004-1.272.004zm7.588 8.417H4.292a2.464 2.464 0 0 1-.326-.007c-.294-.04-.48-.209-.508-.506-.029-.298.11-.501.391-.606.179-.065.365-.051.549-.051 3.347 0 6.695.005 10.042-.006 1.174-.004 2.187-.439 2.993-1.3.69-.738 1.053-1.63 1.16-2.635.085-.788-.027-1.513-.516-2.156-.544-.718-1.28-1.078-2.163-1.082-3.163-.013-6.328-.005-9.487-.01-.336 0-.673-.027-1.007-.058-.29-.027-.45-.201-.469-.492-.021-.317.141-.545.429-.6a1.55 1.55 0 0 1 .29-.015h10.177c1.71.004 3.187 1.038 3.726 2.654.383 1.147.246 2.304-.182 3.416-.824 2.135-2.762 3.448-5.055 3.454-1.652.005-3.304 0-4.956 0zm2.906-13.568c1.533 0 3.066-.008 4.598 0 2.935.018 5.629 1.892 6.653 4.626.442 1.181.538 2.403.412 3.657-.185 1.842-.735 3.552-1.776 5.084-1.608 2.365-3.873 3.68-6.679 4.118-.95.148-1.905.13-2.86.13-.397 0-.61-.181-.633-.51-.025-.351.196-.621.587-.645.434-.026.87-.004 1.305-.016 2.641-.072 4.928-.982 6.74-2.935 1.269-1.37 1.912-3.039 2.13-4.878.151-1.275.135-2.544-.37-3.752-.773-1.85-2.159-2.983-4.068-3.509-.74-.204-1.5-.243-2.26-.247-2.837-.017-5.675-.007-8.511-.007-.12 0-.24.004-.359-.006a.57.57 0 0 1-.517-.536.557.557 0 0 1 .456-.557c.13-.018.261-.024.392-.019h4.762Z"/>
 </svg>

frontend/src/assets/Logos/baseten.svg

@@ -1 +1,3 @@
-<svg role="img" viewBox="-2.625 3 28 28" xmlns="http://www.w3.org/2000/svg"><path fill="#7A8291" d="M.36 8.6h16.7v5.6H6.04c-.2 0-.35.16-.35.35v4.9c0 .2.16.35.35.35h11.02v5.6h-5.33c-.2 0-.35.16-.35.35v4.9c0 .2.16.35.35.35h4.98c.2 0 .35-.15.35-.35V25.4h5.34c.2 0 .35-.16.35-.35v-4.9c0-.2-.16-.35-.35-.35h-5.34v-5.6h5.34c.2 0 .35-.16.35-.35v-4.9c0-.2-.16-.35-.35-.35h-5.34V3.35c0-.2-.16-.35-.35-.35H.36c-.2 0-.36.16-.36.35v4.9c0 .2.16.35.36.35Z"/></svg>
+<svg xmlns="http://www.w3.org/2000/svg" fill="#9CA3AF" height="34" viewBox="0 0 131 34">
+  <path fill="#9CA3AF" d="M.36 8.6h16.7v5.6H6.04c-.2 0-.35.16-.35.35v4.9c0 .2.16.35.35.35h11.02v5.6h-5.33c-.2 0-.35.16-.35.35v4.9c0 .2.16.35.35.35h4.98c.2 0 .35-.15.35-.35V25.4h5.34c.2 0 .35-.16.35-.35v-4.9c0-.2-.16-.35-.35-.35h-5.34v-5.6h5.34c.2 0 .35-.16.35-.35v-4.9c0-.2-.16-.35-.35-.35h-5.34V3.35c0-.2-.16-.35-.35-.35H.36c-.2 0-.36.16-.36.35v4.9c0 .2.16.35.36.35ZM44.41 14.7c-.5-.5-1.1-.9-1.76-1.18a5.62 5.62 0 0 0-4.6.17c-.73.37-1.32.91-1.75 1.62h-.17V8.59H34.1v16.83h2.04v-1.81h.17c.21.36.47.67.77.94.31.25.65.48 1.01.67.37.18.77.31 1.18.39a6.2 6.2 0 0 0 3.39-.24 5.36 5.36 0 0 0 3.02-3.1c.29-.75.44-1.62.44-2.6v-.47c0-.96-.16-1.83-.47-2.58-.3-.75-.7-1.4-1.23-1.9v-.01Zm-5.87.66a3.9 3.9 0 0 1 4.34.84c.36.35.64.8.83 1.3.2.5.3 1.07.3 1.7v.47c0 .64-.1 1.23-.3 1.74a3.75 3.75 0 0 1-2.06 2.15 4.27 4.27 0 0 1-3.12-.03 3.86 3.86 0 0 1-2.09-2.2c-.2-.52-.3-1.11-.3-1.75v-.29c0-.62.1-1.2.3-1.7v-.01c.21-.53.5-.99.84-1.36.36-.37.78-.66 1.26-.86ZM97.04 8.59H95v4.86h-2.94v1.86H95v8.17c0 .56.17 1.03.53 1.4.37.35.84.54 1.4.54h4.18v-1.87h-3.5c-.2 0-.33-.05-.43-.15-.1-.1-.14-.27-.14-.49v-7.6h4.65v-1.86h-4.65V8.59ZM114.61 15a5.48 5.48 0 0 0-1.8-1.33 5.6 5.6 0 0 0-2.57-.56 6.17 6.17 0 0 0-4.26 1.7 5.6 5.6 0 0 0-1.72 4.2v.57c0 .9.15 1.75.44 2.5a5.58 5.58 0 0 0 5.5 3.67c1.55 0 2.8-.35 3.72-1.04a5.35 5.35 0 0 0 1.91-2.73l.03-.07-1.94-.52-.02.07c-.11.33-.27.64-.46.94-.17.27-.4.52-.7.74-.28.22-.63.39-1.04.51-.41.13-.9.19-1.46.19a3.8 3.8 0 0 1-2.84-1.05 4.07 4.07 0 0 1-1.1-2.7h9.68v-1.6c0-.54-.11-1.12-.34-1.75a5.04 5.04 0 0 0-1.03-1.74Zm-8.25 3.21a3.8 3.8 0 0 1 1.22-2.25 4.19 4.19 0 0 1 3.99-.7c.44.16.83.38 1.17.66.34.27.62.62.82 1.02.21.38.34.8.38 1.27h-7.58ZM129.09 14.42a4.47 4.47 0 0 0-3.37-1.3c-.93 0-1.73.2-2.4.59-.64.39-1.15.97-1.52 1.74h-.17v-2h-2.04v11.97h2.04v-6.23c0-1.26.32-2.28.95-3.02a3.31 3.31 0 0 1 2.65-1.14c.94 0 1.7.3 2.24.9.56.6.83 1.52.83 2.74v6.75h2.04v-7.13c0-1.71-.42-3.02-1.25-3.87ZM88.1 15a5.48 5.48 0 0 0-1.78-1.33 5.6 5.6 0 0 0-2.58-.56 6.17 6.17 0 0 0-4.27 1.7 5.59 5.59 0 0 0-1.71 4.2v.56c0 .92.14 1.76.44 2.51a5.6 5.6 0 0 0 5.5 3.67c1.55 0 2.8-.35 3.72-1.04a5.36 5.36 0 0 0 1.91-2.73l.03-.07-1.94-.52-.03.07c-.1.32-.26.64-.45.94-.17.27-.4.52-.7.74-.29.21-.64.39-1.05.51-.4.12-.9.19-1.45.19a3.8 3.8 0 0 1-2.85-1.05 4.07 4.07 0 0 1-1.09-2.7h9.68v-1.61c0-.53-.12-1.12-.34-1.74A5.03 5.03 0 0 0 88.1 15Zm-8.24 3.21a3.83 3.83 0 0 1 1.22-2.25 4.2 4.2 0 0 1 3.99-.7c.44.16.83.38 1.16.66.35.27.62.62.83 1.02.2.38.33.8.37 1.27h-7.57ZM73.65 19.42a6.11 6.11 0 0 0-3.23-1.02 6.63 6.63 0 0 1-2.68-.58c-.47-.3-.7-.7-.7-1.25 0-.27.08-.5.21-.7.14-.2.33-.38.56-.52a4.05 4.05 0 0 1 1.78-.42c.85 0 1.54.21 2.06.63.53.41.83 1 .91 1.73l.01.1 1.95-.47-.01-.07c-.07-.45-.22-.91-.45-1.36a3.46 3.46 0 0 0-.94-1.2 4.6 4.6 0 0 0-1.52-.84 6.05 6.05 0 0 0-2.1-.34c-.58 0-1.13.07-1.65.22-.52.14-1 .36-1.43.65-.41.3-.74.66-.99 1.1a2.9 2.9 0 0 0-.37 1.49v.14c0 1.06.38 1.87 1.14 2.42a6.2 6.2 0 0 0 3.24.97c1.18.08 2.04.26 2.56.54.5.28.75.72.75 1.36 0 .6-.25 1.06-.78 1.4-.52.32-1.22.48-2.1.48a3.68 3.68 0 0 1-2.46-.79 3.13 3.13 0 0 1-1.04-2.14v-.09l-1.93.46h-.02v.07a4.4 4.4 0 0 0 3.1 4c.7.24 1.52.36 2.46.36.7 0 1.35-.09 1.93-.27.6-.16 1.12-.4 1.53-.72A3.38 3.38 0 0 0 74.8 22v-.14c0-1.07-.39-1.9-1.14-2.44ZM60.25 23.4c-.1-.1-.14-.27-.14-.49v-9.46h-2.05v1.85h-.16a3.78 3.78 0 0 0-1.61-1.63 4.62 4.62 0 0 0-2.26-.56c-.77 0-1.5.14-2.19.41a5.27 5.27 0 0 0-3.02 3.12c-.29.75-.44 1.63-.44 2.6v.38c0 .99.15 1.87.44 2.63.3.75.7 1.4 1.2 1.93a5.48 5.48 0 0 0 4.05 1.57c.8 0 1.51-.2 2.2-.58.69-.38 1.24-.97 1.63-1.75h.16v.06c0 .56.18 1.03.53 1.4.37.35.85.54 1.41.54h1.36v-1.87h-.68c-.2 0-.34-.05-.43-.15Zm-4.46.13c-.46.2-.97.3-1.52.3a3.68 3.68 0 0 1-2.75-1.09 4.42 4.42 0 0 1-1.05-3.12v-.38c0-.62.1-1.2.29-1.71a3.65 3.65 0 0 1 5-2.17c.47.2.88.49 1.21.86.35.37.62.83.8 1.36.2.5.3 1.08.3 1.7v.3c0 .63-.1 1.23-.3 1.76-.18.5-.45.96-.78 1.33-.33.37-.73.66-1.2.86Z"/>
+</svg>

frontend/src/assets/Logos/celery.svg

@@ -1 +1 @@
-<svg role="img" viewBox="0 0 24 24" xmlns="http://www.w3.org/2000/svg"><path fill="#37814A" d="M2.303 0A2.298 2.298 0 0 0 0 2.303v19.394A2.298 2.298 0 0 0 2.303 24h19.394A2.298 2.298 0 0 0 24 21.697V2.303A2.298 2.298 0 0 0 21.697 0zm8.177 3.072c4.098 0 7.028 1.438 7.68 1.764l-1.194 2.55c-2.442-1.057-4.993-1.41-5.672-1.41-1.574 0-2.17.922-2.17 1.763v8.494c0 .869.596 1.791 2.17 1.791.679 0 3.23-.38 5.672-1.41l1.194 2.496c-.435.271-3.637 1.818-7.68 1.818-1.112 0-4.64-.244-4.64-4.64V7.713c0-4.397 3.528-4.64 4.64-4.64z"/></svg>
+<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" xml:space="preserve" id="图层_1" x="0" y="0" version="1.1" viewBox="0 0 519.27 214.14"><style>.st2{fill:#a9cc54}</style><path d="M493.54 171.25c-35.63 0-64.52-28.89-64.52-64.52s28.89-64.52 64.52-64.52c3.85 0 7.62.36 11.29 1L493.54 5.45H104.46v.02C49.24 6.51 4.78 51.59 4.78 107.07c0 55.47 44.45 100.56 99.68 101.59v.02h389.07l11.29-38.44c-3.66.65-7.43 1.01-11.28 1.01" style="fill:#b6de64"/><defs><path id="SVGID_1_" d="M493.54 171.25c-35.63 0-64.52-28.89-64.52-64.52s28.89-64.52 64.52-64.52c3.85 0 7.62.36 11.29 1V5.45H104.46v.02C49.24 6.51 4.78 51.59 4.78 107.07c0 55.47 44.45 100.56 99.68 101.59v.02h389.07l11.29-38.44c-3.66.65-7.43 1.01-11.28 1.01"/></defs><clipPath id="SVGID_2_"><use xlink:href="#SVGID_1_" style="overflow:visible"/></clipPath><g style="clip-path:url(#SVGID_2_)"><path d="M-23.16 55.58H428.5v51.1H-23.16zM-23.16 157.59h530.98v72.35H-23.16z" class="st2"/></g><path d="M493.54 184.23c-43.94 0-79.56-33.62-79.56-77.56s35.62-76.56 79.56-76.56" style="fill:none;stroke:#ddf4a4;stroke-width:49;stroke-linecap:round;stroke-linejoin:round;stroke-miterlimit:10"/></svg>

frontend/src/assets/Logos/github.svg

@@ -1,5 +1,5 @@
 <svg width="24" height="24" viewBox="0 0 24 24" fill="none" xmlns="http://www.w3.org/2000/svg">
 <g id="lucide/github">
-<path id="Vector" d="M15 22V18C15.1391 16.7473 14.7799 15.4901 14 14.5C17 14.5 20 12.5 20 9C20.08 7.75 19.73 6.52 19 5.5C19.28 4.35 19.28 3.15 19 2C19 2 18 2 16 3.5C13.36 3 10.64 3 8 3.5C6 2 5 2 5 2C4.7 3.15 4.7 4.35 5 5.5C4.27187 6.51588 3.91847 7.75279 4 9C4 12.5 7 14.5 10 14.5C9.61 14.99 9.32 15.55 9.15 16.15C8.98 16.75 8.93 17.38 9 18M9 18V22M9 18C4.49 20 4 16 2 16" stroke="#7A8291" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"/>
+<path id="Vector" d="M15 22V18C15.1391 16.7473 14.7799 15.4901 14 14.5C17 14.5 20 12.5 20 9C20.08 7.75 19.73 6.52 19 5.5C19.28 4.35 19.28 3.15 19 2C19 2 18 2 16 3.5C13.36 3 10.64 3 8 3.5C6 2 5 2 5 2C4.7 3.15 4.7 4.35 5 5.5C4.27187 6.51588 3.91847 7.75279 4 9C4 12.5 7 14.5 10 14.5C9.61 14.99 9.32 15.55 9.15 16.15C8.98 16.75 8.93 17.38 9 18M9 18V22M9 18C4.49 20 4 16 2 16" stroke="#C0C1C3" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"/>
 </g>
 </svg>

frontend/src/assets/Logos/hcp-vault.svg

@@ -1 +1 @@
-<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24"><path fill="#A68400" d="m0 0 11.955 24L24 0zm13.366 4.827h1.393v1.38h-1.393zm-2.77 5.569H9.22V8.993h1.389zm0-2.087H9.22V6.906h1.389zm0-2.086H9.22V4.819h1.389zm2.087 6.263h-1.377V11.08h1.388zm0-2.09h-1.377V8.993h1.388zm0-2.087h-1.377V6.906h1.388zm0-2.086h-1.377V4.819h1.388zm.683.683h1.393v1.389h-1.393zm0 3.475V8.993h1.389v1.388Z"/></svg>
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24"><path fill="#FFEC6E" d="m0 0 11.955 24L24 0zm13.366 4.827h1.393v1.38h-1.393zm-2.77 5.569H9.22V8.993h1.389zm0-2.087H9.22V6.906h1.389zm0-2.086H9.22V4.819h1.389zm2.087 6.263h-1.377V11.08h1.388zm0-2.09h-1.377V8.993h1.388zm0-2.087h-1.377V6.906h1.388zm0-2.086h-1.377V4.819h1.388zm.683.683h1.393v1.389h-1.393zm0 3.475V8.993h1.389v1.388Z"/></svg>

frontend/src/assets/Logos/heroku.svg

@@ -1 +1 @@
-<svg xmlns="http://www.w3.org/2000/svg" width="285" height="285" preserveAspectRatio="xMidYMid" viewBox="-14.5 0 285 285"><path fill="#7C4DD6" d="M230.4 0c13.996 0 25.37 11.232 25.597 25.177l.003.423v233.244c0 13.996-11.235 25.37-25.177 25.597l-.423.003H25.6c-13.996 0-25.37-11.235-25.597-25.176L0 258.844V25.6C0 11.601 11.235.23 25.177.003L25.6 0zm0 14.222H25.6c-6.174 0-11.218 4.948-11.374 11.085l-.004.293v233.244c0 6.174 4.948 11.218 11.085 11.374l.293.004h204.8c6.177 0 11.218-4.947 11.374-11.084l.004-.294V25.6c0-6.272-5.102-11.378-11.378-11.378M64 184.89l32 28.444-32 28.445zM92.444 42.667v80.75c14.201-4.622 34.052-9.64 53.334-9.64 17.582 0 28.106 6.913 33.838 12.712 12.109 12.25 12.397 27.82 12.381 29.897v.058l.003 85.334h-28.444v-84.942c-.14-6.639-3.34-14.614-17.778-14.614-28.632 0-60.714 14.257-61.666 14.683l-.02.009L64 166.016V42.666zm99.556 0c-1.92 16.156-8.47 31.644-21.333 46.222h-28.445c11.179-14.667 18.198-30.101 21.334-46.222Z"/></svg>
+<svg xmlns="http://www.w3.org/2000/svg" width="285" height="285" preserveAspectRatio="xMidYMid" viewBox="-14.5 0 285 285"><path fill="#430098" d="M230.4 0c13.996 0 25.37 11.232 25.597 25.177l.003.423v233.244c0 13.996-11.235 25.37-25.177 25.597l-.423.003H25.6c-13.996 0-25.37-11.235-25.597-25.176L0 258.844V25.6C0 11.601 11.235.23 25.177.003L25.6 0zm0 14.222H25.6c-6.174 0-11.218 4.948-11.374 11.085l-.004.293v233.244c0 6.174 4.948 11.218 11.085 11.374l.293.004h204.8c6.177 0 11.218-4.947 11.374-11.084l.004-.294V25.6c0-6.272-5.102-11.378-11.378-11.378M64 184.89l32 28.444-32 28.445zM92.444 42.667v80.75c14.201-4.622 34.052-9.64 53.334-9.64 17.582 0 28.106 6.913 33.838 12.712 12.109 12.25 12.397 27.82 12.381 29.897v.058l.003 85.334h-28.444v-84.942c-.14-6.639-3.34-14.614-17.778-14.614-28.632 0-60.714 14.257-61.666 14.683l-.02.009L64 166.016V42.666zm99.556 0c-1.92 16.156-8.47 31.644-21.333 46.222h-28.445c11.179-14.667 18.198-30.101 21.334-46.222Z"/></svg>

frontend/src/assets/Logos/livekit.svg

@@ -1 +1 @@
-<svg role="img" viewBox="0 0 24 24" xmlns="http://www.w3.org/2000/svg"><path d="M14 10h-4v4h4v-4zM18 6h-4v4.001h4v-4zM18 14h-4v4h4v-4zM22 2h-4v4h4V2zM22 18h-4v4h4v-4z" fill="#1FD5F9"></path><path d="M6 18V2H2v20h12v-4H6z" fill="#7A8291"></path></svg>
+<svg height="1em" style="flex:none;line-height:1" viewBox="0 0 24 24" width="1em" xmlns="http://www.w3.org/2000/svg"><title>LiveKit</title><path d="M14 10h-4v4h4v-4zM18 6h-4v4.001h4v-4zM18 14h-4v4h4v-4zM22 2h-4v4h4V2zM22 18h-4v4h4v-4z" fill="#1FD5F9"></path><path d="M6 18V2H2v20h12v-4H6z" fill="#fff"></path></svg>

frontend/src/assets/Logos/opencode.svg

@@ -1 +1 @@
-<svg role="img" viewBox="0 0 24 24" xmlns="http://www.w3.org/2000/svg"><path fill="#7A8291" d="M22 24H2V0h20zM17 4.8H7v14.4h10z"/></svg>
+<svg width='234' height='42' viewBox='0 0 234 42' fill='none' xmlns='http://www.w3.org/2000/svg'><path d='M18 30H6V18H18V30Z' fill='#CFCECD'/><path d='M18 12H6V30H18V12ZM24 36H0V6H24V36Z' fill='#656363'/><path d='M48 30H36V18H48V30Z' fill='#CFCECD'/><path d='M36 30H48V12H36V30ZM54 36H36V42H30V6H54V36Z' fill='#656363'/><path d='M84 24V30H66V24H84Z' fill='#CFCECD'/><path d='M84 24H66V30H84V36H60V6H84V24ZM66 18H78V12H66V18Z' fill='#656363'/><path d='M108 36H96V18H108V36Z' fill='#CFCECD'/><path d='M108 12H96V36H90V6H108V12ZM114 36H108V12H114V36Z' fill='#656363'/><path d='M144 30H126V18H144V30Z' fill='#CFCECD'/><path d='M144 12H126V30H144V36H120V6H144V12Z' fill='#211E1E'/><path d='M168 30H156V18H168V30Z' fill='#CFCECD'/><path d='M168 12H156V30H168V12ZM174 36H150V6H174V36Z' fill='#211E1E'/><path d='M198 30H186V18H198V30Z' fill='#CFCECD'/><path d='M198 12H186V30H198V12ZM204 36H180V6H198V0H204V36Z' fill='#211E1E'/><path d='M234 24V30H216V24H234Z' fill='#CFCECD'/><path d='M216 12V18H228V12H216ZM234 24H216V30H234V36H210V6H234V24Z' fill='#211E1E'/></svg>

frontend/src/assets/Logos/render.svg

@@ -1 +1 @@
-<svg role="img" viewBox="0 0 24 24" xmlns="http://www.w3.org/2000/svg"><path fill="#7A8291" d="M18.263.007c-3.121-.147-5.744 2.109-6.192 5.082-.018.138-.045.272-.067.405-.696 3.703-3.936 6.507-7.827 6.507-1.388 0-2.691-.356-3.825-.979a.2024.2024 0 0 0-.302.178V24H12v-8.999c0-1.656 1.338-3 2.987-3h2.988c3.382 0 6.103-2.817 5.97-6.244-.12-3.084-2.61-5.603-5.682-5.75"/></svg>
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24"><title>Render</title><path d="M18.263.007c-3.121-.147-5.744 2.109-6.192 5.082-.018.138-.045.272-.067.405-.696 3.703-3.936 6.507-7.827 6.507a7.9 7.9 0 0 1-3.825-.979.202.202 0 0 0-.302.178V24H12v-8.999c0-1.656 1.338-3 2.987-3h2.988c3.382 0 6.103-2.817 5.97-6.244-.12-3.084-2.61-5.603-5.682-5.75"/></svg>

frontend/src/assets/Logos/vector.svg

@@ -1 +1 @@
-<svg role="img" viewBox="89.7 190 220 220" xmlns="http://www.w3.org/2000/svg"><linearGradient id="a" x1="128.046" x2="313.226" y1="579.207" y2="472.293" gradientTransform="translate(-20.96 -225.764)" gradientUnits="userSpaceOnUse"><stop offset="0" style="stop-color:#10e7ff"/><stop offset=".103" style="stop-color:#33d5ff"/><stop offset=".255" style="stop-color:#60bdff"/><stop offset=".408" style="stop-color:#86aaff"/><stop offset=".56" style="stop-color:#a39aff"/><stop offset=".71" style="stop-color:#b790ff"/><stop offset=".858" style="stop-color:#c489ff"/><stop offset="1" style="stop-color:#c887ff"/></linearGradient><path d="m199.7 408.2-92.2-54.1V245.9l92.2-54.1 92.2 54.1v108.2zm-79.4-61.7 79.1 46.5 79.1-46.5v-92.9l-79-46.5-79.3 46.5c.1-.1.1 92.9.1 92.9" style="fill:url(#a)"/><linearGradient id="b" x1="185.354" x2="277.202" y1="542.013" y2="488.984" gradientTransform="translate(-20.96 -225.764)" gradientUnits="userSpaceOnUse"><stop offset="0" style="stop-color:#10e7ff"/><stop offset=".103" style="stop-color:#33d5ff"/><stop offset=".255" style="stop-color:#60bdff"/><stop offset=".408" style="stop-color:#86aaff"/><stop offset=".56" style="stop-color:#a39aff"/><stop offset=".71" style="stop-color:#b790ff"/><stop offset=".858" style="stop-color:#c489ff"/><stop offset="1" style="stop-color:#c887ff"/></linearGradient><path d="m239.4 270.6-32.3 56.8 10.5 18.5 42.8-75.3zm-36.1 0L171 327.4l10.5 18.5 42.8-75.3zm-64.4 0 42.8 75.3 10.5-18.5-32.3-56.8zm0 0 42.8 75.3 10.5-18.5-32.3-56.8zm64.4 0L171 327.4l10.5 18.5 42.8-75.3z" style="fill:url(#b)"/></svg>
+<svg xmlns="http://www.w3.org/2000/svg" xml:space="preserve" version="1.0" viewBox="0 0 800 600"><path d="M364.7 246.1h16.9L363.2 300h-16.9l-18.5-53.9h17.1l10.2 33h.2zM436 300h-39.4v-53.9h39.2v13.6h-23.6v7.1h20.9V279h-20.9v7.4H436zm41.6-54.8c11.3 0 19.6 5.8 22.1 15.1l-14.7 6.4c-.7-4.2-2.9-7.4-7.6-7.4-5.3 0-9.3 4.4-9.3 14s3.8 14.2 9.3 14.2c4.5 0 6.9-3.4 7.6-7.6l14.7 6.4c-2.5 9.3-10.9 15.1-22.1 15.1-16.2 0-26.1-10.7-26.1-28s9.9-28.2 26.1-28.2m50.3 54.8v-40.3h-16.2v-13.6h48.5v13.6H544V300zm97.7-26.9c0 17.2-10 28-26.1 28-16 0-26.1-10.7-26.1-28s10.2-28 26.1-28c16.1.1 26.1 10.8 26.1 28m-35.4 0c0 8.7 3.3 14.2 9.4 14.2s9.4-5.3 9.4-14.2c0-8.7-3.3-14.2-9.4-14.2s-9.4 5.3-9.4 14.2m84.4 26.9c-1.5-1.8-2-3.4-2.5-6.4l-1.1-6c-.7-3.8-2.5-4.9-5.8-4.9h-6.4V300h-16v-53.9h25.6c12.2 0 20.7 4.7 20.7 16.5 0 7.8-5.3 12.3-11.1 13.4v.2c4.7.7 7.4 3.6 8.5 8.5l2 8.5c.7 2.9 1.6 4.7 3.4 6.7.1.1-17.3.1-17.3.1m-8.2-40.7h-7.8V270h7.8c3.8 0 5.8-1.6 5.8-5.4 0-3.5-1.8-5.3-5.8-5.3m-321.5 81.2c3.3.4 5.6 2.4 5.6 6 0 4.4-2.7 7.3-8.7 7.3h-9.3v-26.1h8.9c5.1 0 8.2 2.4 8.2 6.9 0 3.1-2 5.3-4.7 5.9m-9.1-1.1h5.4c3.3 0 5.1-1.5 5.1-4.5s-1.8-4.5-5.1-4.5h-5.4zm0 11.6h5.8c3.6 0 5.4-1.6 5.4-4.5s-2-4.5-5.4-4.5h-5.8zm28-10.7 7.1-12.7h3.4l-8.9 15.8v10.2h-3.3v-10.2l-9.1-15.8h3.6zm26.7-12.7h7.6c7.3 0 12.7 4 12.7 12.9s-5.4 13.1-12.7 13.1h-7.6zm3.2 23.2h4.4c4.7 0 9.3-2.5 9.3-10.3s-4.5-10.2-9.3-10.2h-4.4zm36.2-4.3H419l-2.5 7.3h-3.3l9.4-26.1h3.6l9.4 26.1h-3.3zm-10-2.9h8.9l-4.4-12.5zm24.1 10.1v-23.2h-8.7v-2.9h20.9v2.9h-8.7v23.2zm28.3-7.2h-10.9l-2.5 7.3h-3.3l9.4-26.1h3.6l9.4 26.1h-3.3zm-9.8-2.9h8.9l-4.4-12.5zm20.7-16h7.6c7.3 0 12.7 4 12.7 12.9s-5.4 13.1-12.7 13.1h-7.6zm3.3 23.2h4.4c4.7 0 9.3-2.5 9.3-10.3s-4.5-10.2-9.3-10.2h-4.4zm44.1-10.1c0 8.4-4.5 13.4-11.3 13.4S508 349 508 340.7c0-8.4 4.5-13.4 11.3-13.4s11.3 5 11.3 13.4m-19 0c0 6.4 2.7 10.7 7.8 10.7s7.8-4.4 7.8-10.7c0-6.4-2.7-10.7-7.8-10.7s-7.8 4.3-7.8 10.7m45-.2v13.1H554l-.5-3.8c-.9 2.7-3.8 4.4-7.3 4.4-6.5 0-11.1-4.9-11.1-13.4 0-8.7 4.9-13.6 11.4-13.6 4.7 0 8 2 9.4 6l-2.9 1.6c-.9-3.1-3.4-4.9-6.7-4.9-5.1 0-8 4-8 10.7 0 6.4 2.5 10.7 8 10.7 3.4 0 6.7-1.8 6.7-6.5V343h-6.4v-2.7h9.8z"/><linearGradient id="a" x1="128.046" x2="313.226" y1="579.207" y2="472.293" gradientTransform="translate(-20.96 -225.764)" gradientUnits="userSpaceOnUse"><stop offset="0" style="stop-color:#10e7ff"/><stop offset=".103" style="stop-color:#33d5ff"/><stop offset=".255" style="stop-color:#60bdff"/><stop offset=".408" style="stop-color:#86aaff"/><stop offset=".56" style="stop-color:#a39aff"/><stop offset=".71" style="stop-color:#b790ff"/><stop offset=".858" style="stop-color:#c489ff"/><stop offset="1" style="stop-color:#c887ff"/></linearGradient><path d="m199.7 408.2-92.2-54.1V245.9l92.2-54.1 92.2 54.1v108.2zm-79.4-61.7 79.1 46.5 79.1-46.5v-92.9l-79-46.5-79.3 46.5c.1-.1.1 92.9.1 92.9" style="fill:url(#a)"/><linearGradient id="b" x1="185.354" x2="277.202" y1="542.013" y2="488.984" gradientTransform="translate(-20.96 -225.764)" gradientUnits="userSpaceOnUse"><stop offset="0" style="stop-color:#10e7ff"/><stop offset=".103" style="stop-color:#33d5ff"/><stop offset=".255" style="stop-color:#60bdff"/><stop offset=".408" style="stop-color:#86aaff"/><stop offset=".56" style="stop-color:#a39aff"/><stop offset=".71" style="stop-color:#b790ff"/><stop offset=".858" style="stop-color:#c489ff"/><stop offset="1" style="stop-color:#c887ff"/></linearGradient><path d="m239.4 270.6-32.3 56.8 10.5 18.5 42.8-75.3zm-36.1 0L171 327.4l10.5 18.5 42.8-75.3zm-64.4 0 42.8 75.3 10.5-18.5-32.3-56.8zm0 0 42.8 75.3 10.5-18.5-32.3-56.8zm64.4 0L171 327.4l10.5 18.5 42.8-75.3z" style="fill:url(#b)"/></svg>

frontend/src/components/Alerts/LabelColumn/LabelColumn.test.tsx

@@ -2,13 +2,6 @@ import { act, render, screen } from '@testing-library/react';
 
 import LabelColumn from './LabelColumn';
 
-// The global CSS mock maps every class to undefined; keep the names so overflow is assertable.
-jest.mock('./LabelColumn.module.scss', () => ({
-	labelColumn: 'labelColumn',
-	overflowed: 'overflowed',
-	shrinkable: 'shrinkable',
-}));
-
 const BADGE_WIDTH = 60;
 
 let resizeCallbacks: ResizeObserverCallback[] = [];
@@ -84,20 +77,6 @@ describe('LabelColumn', () => {
 		expect(screen.getByTestId('label-overflow-badge')).toHaveTextContent('+3');
 	});
 
-	it('should hide the labels past the visible count', () => {
-		const labels = ['env', 'service', 'region', 'team', 'owner', 'version'];
-
-		// 3 badges (180px) + overflow reserve (40px)
-		mockLayout(220);
-		renderWithProviders(<LabelColumn labels={labels} />);
-
-		const isHidden = (label: string): boolean =>
-			screen.getByTestId(`label-tag-${label}`).closest('.overflowed') !== null;
-
-		expect(labels.filter(isHidden)).toStrictEqual(['team', 'owner', 'version']);
-		expect(screen.getByTestId('label-overflow-badge')).toHaveTextContent('+3');
-	});
-
 	it('should render label with value when value prop provided', () => {
 		const labels = ['env'];
 		const value = { env: 'production' };

frontend/src/components/AuthError/AuthError.tsx

@@ -10,7 +10,7 @@ interface AuthErrorProps {
 
 function AuthError({ error }: AuthErrorProps): JSX.Element {
 	return (
-		<div className="auth-error-container" data-testid="auth-error">
+		<div className="auth-error-container">
 			<ErrorContent
 				error={error}
 				icon={<CircleAlert size={12} className="auth-error-icon" />}

frontend/src/components/CeleryOverview/CeleryOverviewTable/CeleryOverviewTable.tsx

@@ -512,7 +512,6 @@ export default function CeleryOverviewTable({
 				allowClear
 			/>
 			<ResizeTable
-				data-testid="mq-overview-table"
 				className="celery-overview-table"
 				pagination={paginationConfig}
 				size="middle"

frontend/src/components/CeleryTask/CeleryTaskConfigOptions/CeleryTaskConfigOptions.tsx

@@ -28,7 +28,6 @@ function CeleryTaskConfigOptions(): JSX.Element {
 					Task Name
 				</Typography.Text>
 				<Select
-					data-testid="celery-task-name-select"
 					placeholder="Task Name"
 					showSearch
 					mode="multiple"

frontend/src/components/CeleryTask/CeleryTaskGraph/CeleryTaskGraphGrid.tsx

@@ -105,10 +105,7 @@ export default function CeleryTaskGraphGrid({
 	};
 
 	return (
-		<div
-			className="celery-task-graph-grid-container"
-			data-testid="celery-graph-grid"
-		>
+		<div className="celery-task-graph-grid-container">
 			<div className="metric-based-graphs">
 				<CardContainer className="row-card" isDarkMode={isDarkMode}>
 					<div className="row-panel">

frontend/src/components/CeleryTask/CeleryTaskGraph/CeleryTaskStateGraphConfig.tsx

@@ -80,7 +80,6 @@ function CeleryTaskStateGraphConfig({
 			{tabs.map((tab, index) => (
 				<Col
 					key={tab.key}
-					data-testid={`celery-state-tab-${tab.key}`}
 					onClick={(): void => handleTabClick(tab.key as CeleryTaskState)}
 					className={`celery-task-states__tab ${
 						tab.key === barState ? 'celery-task-states__tab--selected' : ''

frontend/src/components/CustomTimePicker/CustomTimePicker.tsx

@@ -72,8 +72,6 @@ interface CustomTimePickerProps {
 	maxTime: number;
 	/** When true, zoom-out button is hidden (e.g. in drawer/modal time selection) */
 	isModalTimeSelection?: boolean;
-	/** Lands on the trigger input. Not spread — the component takes no rest props. */
-	'data-testid'?: string;
 }
 
 function CustomTimePicker({
@@ -97,7 +95,6 @@ function CustomTimePicker({
 	minTime,
 	maxTime,
 	isModalTimeSelection = false,
-	'data-testid': dataTestId,
 }: CustomTimePickerProps): JSX.Element {
 	const [selectedTimePlaceholderValue, setSelectedTimePlaceholderValue] =
 		useState('Select / Enter Time Range');
@@ -599,7 +596,6 @@ function CustomTimePicker({
 				>
 					<Input
 						ref={inputRef}
-						data-testid={dataTestId}
 						autoComplete="off"
 						className={cx(
 							'timeSelection-input',
@@ -686,5 +682,4 @@ CustomTimePicker.defaultProps = {
 	onExitLiveLogs: noop,
 	showLiveLogs: false,
 	showRecentlyUsed: true,
-	'data-testid': undefined,
 };

frontend/src/components/CustomTimePicker/CustomTimePickerPopoverContent.tsx

@@ -180,7 +180,6 @@ function CustomTimePickerPopoverContent({
 						type="text"
 						className="time-btns"
 						key={option.label + option.value}
-						data-testid={`time-chip-${option.value}`}
 						onClick={(): void => {
 							handleExitLiveLogs();
 							onSelectHandler(option.label, option.value);
@@ -251,7 +250,6 @@ function CustomTimePickerPopoverContent({
 						<Button
 							className={cx('data-time-live', isLiveLogsEnabled ? 'active' : '')}
 							type="text"
-							data-testid="time-picker-live"
 							onClick={handleGoLive}
 						>
 							Live
@@ -261,7 +259,6 @@ function CustomTimePickerPopoverContent({
 						<Button
 							type="text"
 							key={option.label + option.value}
-							data-testid={`time-option-${option.value}`}
 							onClick={(e: React.MouseEvent<HTMLButtonElement>): void => {
 								e.stopPropagation();
 								e.preventDefault();

frontend/src/components/CustomTimePicker/TimezonePicker.tsx

@@ -88,7 +88,6 @@ function TimezoneItem({
 	return (
 		<button
 			type="button"
-			data-testid={`timezone-item-${timezone.value}`}
 			className={cx('timezone-picker__item', {
 				selected: isSelected,
 				'has-divider': timezone.hasDivider,

frontend/src/components/DownloadOptionsMenu/DownloadOptionsMenu.test.tsx

@@ -1,7 +1,6 @@
 // eslint-disable-next-line no-restricted-imports
 import { Provider } from 'react-redux';
 import { fireEvent, render, screen, waitFor } from '@testing-library/react';
-import userEvent from '@testing-library/user-event';
 import { message } from 'antd';
 import configureStore from 'redux-mock-store';
 import store from 'store';
@@ -195,23 +194,6 @@ describe.each([
 		});
 	});
 
-	it('sends the chosen jsonl format and 30k row limit', async () => {
-		renderWithStore(dataSource);
-		await userEvent.click(screen.getByTestId(testId));
-		await userEvent.click(screen.getByRole('radio', { name: 'jsonl' }));
-		await userEvent.click(screen.getByRole('radio', { name: '30k' }));
-		await userEvent.click(screen.getByText('Export'));
-
-		await waitFor(() => {
-			expect(mockDownloadExportData).toHaveBeenCalledTimes(1);
-		});
-		const callArgs = mockDownloadExportData.mock.calls[0][0];
-		expect(callArgs.format).toBe(DownloadFormats.JSONL);
-		expect(callArgs.body.compositeQuery.queries[0].spec.limit).toBe(
-			DownloadRowCounts.THIRTY_K,
-		);
-	});
-
 	it('clears groupBy and having in the export payload', async () => {
 		const mockQuery = createMockStagedQuery(dataSource);
 		mockQuery.builder.queryData[0].groupBy = [

frontend/src/components/EditMemberDrawer/DeleteMemberDialog.tsx

@@ -52,7 +52,6 @@ function DeleteMemberDialog({
 				variant="solid"
 				color="danger"
 				onClick={onConfirm}
-				testId="member-delete-confirm-btn"
 				loading={isDeleting}
 				prefix={<Trash2 size={12} />}
 			>

frontend/src/components/EditMemberDrawer/EditMemberDrawer.tsx

@@ -624,7 +624,6 @@ function EditMemberDrawer({
 							disabledTooltip={getDeleteTooltip(isRootUser, isSelf)}
 							size="md"
 							onClick={(): void => setShowDeleteConfirm(true)}
-							testId="member-delete-btn"
 							disabled={isRootUser || isSelf}
 							variant="link"
 							color="danger"
@@ -638,7 +637,6 @@ function EditMemberDrawer({
 							disabledTooltip={ROOT_USER_TOOLTIP}
 							size="md"
 							onClick={handleGenerateResetLink}
-							testId="member-reset-link-btn"
 							disabled={isRootUser}
 							loading={isGeneratingLink || isLoadingTokenStatus}
 							variant="link"
@@ -676,7 +674,6 @@ function EditMemberDrawer({
 							color="primary"
 							disabled={!isDirty || isRootUser}
 							onClick={handleSave}
-							testId="member-save-btn"
 							loading={isSaving}
 						>
 							{isSaving ? 'Saving...' : 'Save Member Details'}

frontend/src/components/EditMemberDrawer/ResetLinkDialog.tsx

@@ -42,12 +42,7 @@ function ResetLinkDialog({
 				</p>
 				<div className="reset-link-dialog__link-row">
 					<div className="reset-link-dialog__link-text-wrap">
-						<span
-							className="reset-link-dialog__link-text"
-							data-testid="reset-link-text"
-						>
-							{resetLink}
-						</span>
+						<span className="reset-link-dialog__link-text">{resetLink}</span>
 					</div>
 					<Button
 						size="md"

frontend/src/components/ExportMenu/__tests__/ExportMenu.test.tsx

@@ -1,5 +1,5 @@
 import { MetricQueryRangeSuccessResponse } from 'types/api/metrics/getQueryRange';
-import { fireEvent, render, screen, userEvent } from 'tests/test-utils';
+import { fireEvent, render, screen } from 'tests/test-utils';
 import { DataSource } from 'types/common/queryBuilder';
 
 import ExportMenu from '../ExportMenu';
@@ -76,17 +76,6 @@ describe('ExportMenu', () => {
 		expect(mockHandleExport).toHaveBeenCalledWith({ format: 'jsonl' });
 	});
 
-	it('exports the picked jsonl format and closes the popover', async () => {
-		renderMenu();
-		await userEvent.click(screen.getByTestId(TEST_ID));
-		await userEvent.click(screen.getByRole('radio', { name: 'jsonl' }));
-		await userEvent.click(screen.getByRole('button', { name: 'Export' }));
-
-		expect(mockHandleExport).toHaveBeenCalledTimes(1);
-		expect(mockHandleExport).toHaveBeenCalledWith({ format: 'jsonl' });
-		expect(screen.queryByText('FORMAT')).not.toBeInTheDocument();
-	});
-
 	it('disables the trigger while an export is in progress', () => {
 		mockIsExporting = true;
 		renderMenu();

frontend/src/components/LogDetail/LogDetail.interfaces.ts

@@ -1,5 +1,7 @@
 import { DrawerProps } from 'antd';
 import { ChangeViewFunctionType } from 'container/ExplorerOptions/types';
+import { AddToQueryHOCProps } from 'components/Logs/AddToQueryHOC';
+import { ActionItemProps } from 'container/LogDetailedView/LogDetailedView.types';
 import { IField } from 'types/api/logs/fields';
 import { ILog } from 'types/api/logs/log';
 
@@ -18,7 +20,9 @@ export type LogDetailProps = {
 	handleOpenInExplorer?: MouseEventHandler;
 	getContainer?: DrawerProps['getContainer'];
 	onApplyLogFilter?: (expression: string) => void;
-} & Pick<DrawerProps, 'onClose'>;
+} & Pick<AddToQueryHOCProps, 'onAddToQuery'> &
+	Partial<Pick<ActionItemProps, 'onClickActionItem'>> &
+	Pick<DrawerProps, 'onClose'>;
 
 export type LogDetailInnerProps = LogDetailProps & {
 	log: NonNullable<LogDetailProps['log']>;

frontend/src/components/LogDetail/__tests__/LogDetail.test.tsx

@@ -46,6 +46,8 @@ function renderDrawer(props: Partial<LogDetailProps> = {}): void {
 		<LogDetail
 			log={mockLog}
 			selectedTab={VIEW_TYPES.OVERVIEW}
+			onAddToQuery={jest.fn()}
+			onClickActionItem={jest.fn()}
 			onClose={jest.fn()}
 			{...props}
 		/>,

frontend/src/components/LogDetail/index.tsx

@@ -307,11 +307,7 @@ function LogDetailInner({
 							placement="left"
 							mouseLeaveDelay={0}
 						>
-							<div
-								className="log-body"
-								data-testid="log-detail-body"
-								dangerouslySetInnerHTML={htmlBody}
-							/>
+							<div className="log-body" dangerouslySetInnerHTML={htmlBody} />
 						</Tooltip>
 
 						<div className="log-overflow-shadow">&nbsp;</div>

frontend/src/components/Logs/ListLogView/index.tsx

@@ -182,7 +182,6 @@ function ListLogView({
 	return (
 		<>
 			<Container
-				data-testid={`logs-list-row-${logData.id}`}
 				$isActiveLog={isHighlighted || activeLog?.id === logData.id}
 				$isDarkMode={isDarkMode}
 				$logType={logType}

frontend/src/components/Logs/LogLinesActionButtons/LogLinesActionButtons.tsx

@@ -23,7 +23,6 @@ function LogLinesActionButtons({
 					icon={<TextSelect size={14} />}
 					className="show-context-btn"
 					onClick={handleShowContext}
-					data-testid="log-line-show-context"
 				/>
 			</Tooltip>
 			<Tooltip title="Copy Link">
@@ -32,7 +31,6 @@ function LogLinesActionButtons({
 					icon={<Link size={14} />}
 					onClick={onLogCopy}
 					className="copy-log-btn"
-					data-testid="log-line-copy-link"
 				/>
 			</Tooltip>
 		</div>

frontend/src/components/Logs/RawLogView/index.tsx

@@ -156,7 +156,6 @@ function RawLogView({
 
 	return (
 		<RawLogViewContainer
-			data-testid={`logs-raw-row-${data.id}`}
 			onClick={handleClickExpand}
 			wrap={false}
 			align="middle"

frontend/src/components/LogsFormatOptionsMenu/LogsFormatOptionsMenu.tsx

@@ -180,7 +180,6 @@ function OptionsMenu({
 									<div
 										className="item"
 										key={item.label}
-										data-testid={`format-option-${item.key}`}
 										onClick={(): void => handleMenuItemClick(item.key)}
 									>
 										<div className={cx('item-label')}>

frontend/src/components/MarkdownEditor/__tests__/InsertVariableMenu.test.tsx

@@ -1,72 +0,0 @@
-import { render, screen, userEvent, waitFor } from 'tests/test-utils';
-
-import { READ_ONLY_TOOLTIP } from '../constants';
-import InsertVariableMenu from '../InsertVariableMenu';
-import type { EditorVariable } from '../types';
-
-const VARIABLES: EditorVariable[] = [
-	{ name: 'environment', badge: 'QUERY' },
-	{ name: 'service', badge: 'CUSTOM' },
-	{ name: 'service_version' },
-];
-
-function renderMenu(disabled = false): jest.Mock {
-	const onSelect = jest.fn();
-	render(
-		<InsertVariableMenu
-			variables={VARIABLES}
-			onSelect={onSelect}
-			disabled={disabled}
-		/>,
-	);
-	return onSelect;
-}
-
-function rowNames(): string[] {
-	return screen
-		.queryAllByTestId(/^markdown-variable-/)
-		.map((row) => row.getAttribute('data-testid') ?? '');
-}
-
-describe('InsertVariableMenu', () => {
-	it('narrows the rows to names matching the search', async () => {
-		renderMenu();
-		await userEvent.click(screen.getByTestId('markdown-insert-variable'));
-		await screen.findByTestId('markdown-variable-environment');
-		expect(rowNames()).toHaveLength(3);
-
-		await userEvent.type(screen.getByPlaceholderText('Search variables'), 'SERV');
-
-		await waitFor(() =>
-			expect(rowNames()).toStrictEqual([
-				'markdown-variable-service',
-				'markdown-variable-service_version',
-			]),
-		);
-	});
-
-	it('hands the clicked variable name to onSelect', async () => {
-		const onSelect = renderMenu();
-		await userEvent.click(screen.getByTestId('markdown-insert-variable'));
-		await userEvent.click(await screen.findByTestId('markdown-variable-service'));
-
-		expect(onSelect).toHaveBeenCalledTimes(1);
-		expect(onSelect).toHaveBeenCalledWith('service');
-	});
-
-	it('stays closed and explains why when read-only', async () => {
-		const onSelect = renderMenu(true);
-		const trigger = screen.getByTestId('markdown-insert-variable');
-		expect(trigger).toHaveAttribute('aria-disabled', 'true');
-
-		await userEvent.click(trigger);
-		expect(screen.queryByRole('menu')).not.toBeInTheDocument();
-		expect(rowNames()).toHaveLength(0);
-
-		await userEvent.hover(trigger);
-		await expect(screen.findByRole('tooltip')).resolves.toHaveTextContent(
-			READ_ONLY_TOOLTIP,
-		);
-		expect(onSelect).not.toHaveBeenCalled();
-	});
-});

frontend/src/components/NewSelect/__test__/CustomMultiSelect.comprehensive.test.tsx

@@ -1,5 +1,5 @@
 import { VirtuosoMockContext } from 'react-virtuoso';
-import { render, screen, waitFor, within } from '@testing-library/react';
+import { render, screen, waitFor } from '@testing-library/react';
 import userEvent from '@testing-library/user-event';
 
 import CustomMultiSelect from '../CustomMultiSelect';
@@ -678,64 +678,6 @@ describe('CustomMultiSelect - Comprehensive Tests', () => {
 			expect(mockOnChange.mock.calls[0][0]).toStrictEqual(['backend']);
 		});
 
-		it('UI-03c: clicking an option checkbox toggles it exactly once', async () => {
-			renderWithVirtuoso(
-				<CustomMultiSelect
-					options={mockOptions}
-					onChange={mockOnChange}
-					value={['frontend']}
-				/>,
-			);
-
-			await user.click(screen.getByRole('combobox'));
-			const backendRow = (await screen.findByText('Backend')).closest(
-				'[role="option"]',
-			) as HTMLElement;
-			mockOnChange.mockClear();
-			await user.click(within(backendRow).getByRole('checkbox'));
-
-			expect(mockOnChange).toHaveBeenCalledTimes(1);
-			expect(mockOnChange.mock.calls[0][0]).toStrictEqual(['frontend', 'backend']);
-		});
-
-		it('UI-03d: clicking an option label toggles it exactly once', async () => {
-			renderWithVirtuoso(
-				<CustomMultiSelect
-					options={mockOptions}
-					onChange={mockOnChange}
-					value={['frontend']}
-				/>,
-			);
-
-			await user.click(screen.getByRole('combobox'));
-			const backendLabel = await screen.findByText('Backend');
-			mockOnChange.mockClear();
-			await user.click(backendLabel);
-
-			expect(mockOnChange).toHaveBeenCalledTimes(1);
-			expect(mockOnChange.mock.calls[0][0]).toStrictEqual(['frontend', 'backend']);
-		});
-
-		it('UI-03e: clicking "Toggle" does not also toggle the wrapping checkbox', async () => {
-			renderWithVirtuoso(
-				<CustomMultiSelect
-					options={mockOptions}
-					onChange={mockOnChange}
-					value={['frontend', 'backend']}
-				/>,
-			);
-
-			await user.click(screen.getByRole('combobox'));
-			const backendRow = (await screen.findByText('Backend')).closest(
-				'[role="option"]',
-			) as HTMLElement;
-			mockOnChange.mockClear();
-			await user.click(within(backendRow).getByText('Toggle'));
-
-			expect(mockOnChange).toHaveBeenCalledTimes(1);
-			expect(mockOnChange.mock.calls[0][0]).toStrictEqual(['frontend']);
-		});
-
 		it('UI-04: Should display values with loading info at bottom', async () => {
 			renderWithVirtuoso(
 				<CustomMultiSelect options={mockOptions} onChange={mockOnChange} loading />,

frontend/src/components/NotFound/__snapshots__/NotFound.test.tsx.snap

@@ -98,7 +98,6 @@ exports[`Not Found page test should render Not Found page without errors 1`] = `
 
 <div
     class="c0"
-    data-testid="not-found"
   >
     <img
       alt="not-found"

frontend/src/components/NotFound/index.tsx

@@ -6,7 +6,7 @@ import { Button, Container, Text, TextContainer } from './styles';
 
 function NotFound({ text = defaultText }: Props): JSX.Element {
 	return (
-		<Container data-testid="not-found">
+		<Container>
 			<NotFoundImage />
 
 			<TextContainer>

frontend/src/components/OrderBy/ListViewOrderBy.tsx

@@ -112,7 +112,6 @@ function ListViewOrderBy({
 			placeholder="Select a field"
 			style={{ width: 200 }}
 			options={selectOptions}
-			data-testid="list-view-order-by"
 			filterOption={(input, option): boolean =>
 				(option?.value ?? '').toLowerCase().includes(input.trim().toLowerCase())
 			}

frontend/src/components/QueryBuilderV2/QueryV2/__tests__/QueryV2.test.tsx

@@ -1,12 +1,9 @@
 /* eslint-disable @typescript-eslint/explicit-function-return-type */
 import { jest } from '@jest/globals';
 import { fireEvent, waitFor } from '@testing-library/react';
-import { ENVIRONMENT } from 'constants/env';
 import { PANEL_TYPES } from 'constants/queryBuilder';
 import { useQueryBuilder } from 'hooks/queryBuilder/useQueryBuilder';
 import { useQueryOperations } from 'hooks/queryBuilder/useQueryBuilderOperations';
-import { server } from 'mocks-server/server';
-import { rest } from 'msw';
 import { render, screen, userEvent } from 'tests/test-utils';
 import {
 	Having,
@@ -56,15 +53,6 @@ describe('QueryBuilderV2 + QueryV2 - base render', () => {
 	let baseQBContext: QueryBuilderContextType;
 
 	beforeEach(() => {
-		server.use(
-			rest.get(`${ENVIRONMENT.baseURL}/api/v1/fields/keys`, (_req, res, ctx) =>
-				res(
-					ctx.status(200),
-					ctx.json({ status: 'success', data: { complete: true, keys: {} } }),
-				),
-			),
-		);
-
 		const mockCloneQuery = jest.fn() as jest.MockedFunction<
 			(type: string, q: IBuilderQuery) => void
 		>;
@@ -248,71 +236,6 @@ describe('QueryBuilderV2 + QueryV2 - base render', () => {
 		).not.toBeInTheDocument();
 	});
 
-	describe('query actions menu', () => {
-		const openQueryActions = async (): Promise<void> => {
-			const trigger = document.querySelector(
-				'.query-actions-container [aria-haspopup="menu"]',
-			) as HTMLElement;
-			expect(trigger).toBeInTheDocument();
-			await userEvent.click(trigger);
-		};
-
-		it('Clone calls cloneQuery with the query', async () => {
-			render(<QueryBuilderV2 panelType={PANEL_TYPES.TABLE} version="v4" />);
-
-			await openQueryActions();
-			await userEvent.click(
-				await screen.findByRole('menuitem', { name: 'Clone' }),
-			);
-
-			expect(baseQBContext.cloneQuery).toHaveBeenCalledTimes(1);
-			expect(baseQBContext.cloneQuery).toHaveBeenCalledWith(
-				'query',
-				expect.objectContaining({ queryName: 'A' }),
-			);
-		});
-
-		it('hides Delete when there is a single query', async () => {
-			render(<QueryBuilderV2 panelType={PANEL_TYPES.TABLE} version="v4" />);
-
-			await openQueryActions();
-			await screen.findByRole('menuitem', { name: 'Clone' });
-
-			expect(
-				screen.queryByRole('menuitem', { name: 'Delete' }),
-			).not.toBeInTheDocument();
-		});
-
-		it('shows Delete with more than one query and deletes on click', async () => {
-			const currentQueryBase = baseQBContext.currentQuery as Query;
-			const [queryA] = currentQueryBase.builder.queryData;
-			mockedUseQueryBuilder.mockReturnValue({
-				...baseQBContext,
-				currentQuery: {
-					...currentQueryBase,
-					builder: {
-						...currentQueryBase.builder,
-						queryData: [queryA, { ...queryA, queryName: 'B', legend: 'B' }],
-					},
-				},
-			});
-			const handleDeleteQuery = jest.fn();
-			mockedUseQueryOperations.mockReturnValue({
-				...mockedUseQueryOperations({} as Parameters<UseQueryOperations>[0]),
-				handleDeleteQuery,
-			});
-
-			render(<QueryBuilderV2 panelType={PANEL_TYPES.TABLE} version="v4" />);
-
-			await openQueryActions();
-			await userEvent.click(
-				await screen.findByRole('menuitem', { name: 'Delete' }),
-			);
-
-			expect(handleDeleteQuery).toHaveBeenCalledTimes(1);
-		});
-	});
-
 	it('fx button is disabled when functions already exist', () => {
 		const currentQueryBase = baseQBContext.currentQuery as Query;
 		const supersetQueryBase = baseQBContext.supersetQuery as Query;

frontend/src/components/QuickFilters/FilterRenderers/Checkbox/v2/CheckboxFilterV2.tsx

@@ -167,11 +167,7 @@ export default function CheckboxFilterV2(
 	});
 
 	return (
-		<div
-			className={styles.checkboxFilter}
-			data-testid="checkbox-filter-v2"
-			data-filter-key={filter.attributeKey.key}
-		>
+		<div className={styles.checkboxFilter} data-testid="checkbox-filter-v2">
 			<CheckboxFilterV2Header
 				title={filter.title}
 				isOpen={isOpen}

frontend/src/components/QuickFilters/QuickFiltersLayout/__tests__/QuickFiltersLayout.test.tsx

@@ -1,7 +1,7 @@
 import { Button } from '@signozhq/ui/button';
 import { SavedviewtypesSourceDTO } from 'api/generated/services/sigNoz.schemas';
 import { useSavedViewEnabled } from 'hooks/useSavedViewEnabled';
-import { render, screen, userEvent, waitFor } from 'tests/test-utils';
+import { render, screen, userEvent } from 'tests/test-utils';
 
 import { QuickFiltersSource } from '../../types';
 import QuickFiltersLayout from '../QuickFiltersLayout';
@@ -197,11 +197,6 @@ describe('QuickFiltersLayout', () => {
 			expect(screen.queryByTestId('saved-views-panel')).not.toBeInTheDocument();
 			expect(drawer()).not.toHaveClass('isOpen');
 
-			await waitFor(() =>
-				expect(screen.getByTestId('saved-views-open')).not.toHaveAttribute(
-					'aria-busy',
-				),
-			);
 			await user.click(screen.getByTestId('saved-views-open'));
 
 			expect(screen.getByTestId('saved-views-panel')).toBeInTheDocument();
@@ -232,11 +227,6 @@ describe('QuickFiltersLayout', () => {
 				'data-source',
 				SavedviewtypesSourceDTO.traces,
 			);
-			await waitFor(() =>
-				expect(screen.getByTestId('saved-views-open')).not.toHaveAttribute(
-					'aria-busy',
-				),
-			);
 			await userEvent.setup().click(screen.getByTestId('saved-views-open'));
 			expect(screen.getByTestId('saved-views-panel')).toHaveAttribute(
 				'data-source',

frontend/src/components/ServiceAccountDrawer/AddKeyModal/KeyCreatedPhase.tsx

@@ -22,9 +22,7 @@ function KeyCreatedPhase({
 			<div className="add-key-modal__field">
 				<span className="add-key-modal__label">Key</span>
 				<div className="add-key-modal__key-display">
-					<span className="add-key-modal__key-text" data-testid="created-key-value">
-						{createdKey.key}
-					</span>
+					<span className="add-key-modal__key-text">{createdKey.key}</span>
 					<Button
 						size="md"
 						variant="link"

frontend/src/components/ServiceAccountDrawer/RevokeKeyModal.tsx

@@ -61,7 +61,6 @@ export function RevokeKeyFooter({
 				color="danger"
 				loading={isRevoking}
 				onClick={onConfirm}
-				testId="revoke-key-confirm-btn"
 				prefix={<Trash2 size={12} />}
 			>
 				Revoke Key

frontend/src/components/ServiceAccountDrawer/ServiceAccountDrawer.tsx

@@ -384,7 +384,6 @@ function ServiceAccountDrawer({
 							void setIsDeleteOpen(true);
 						}}
 						prefix={<Trash2 size={12} />}
-						testId="sa-delete-btn"
 					>
 						Delete Service Account
 					</AuthZButton>
@@ -410,7 +409,6 @@ function ServiceAccountDrawer({
 							loading={isSaving}
 							disabled={!isDirty}
 							onClick={handleSave}
-							testId="sa-save-btn"
 						>
 							Save Changes
 						</AuthZButton>
@@ -439,7 +437,6 @@ function ServiceAccountDrawer({
 					type="single"
 					value={activeTab}
 					size="sm"
-					testId="sa-tab"
 					onChange={(val: string): void => {
 						if (val) {
 							void setActiveTab(val as ServiceAccountDrawerTab);
@@ -481,7 +478,6 @@ function ServiceAccountDrawer({
 							void setIsAddKeyOpen(true);
 						}}
 						prefix={<Plus size={12} />}
-						testId="sa-add-key-btn"
 					>
 						Add Key
 					</AuthZButton>

frontend/src/components/TanStackTableView/TanStackRowCell.tsx

@@ -35,8 +35,7 @@ function TanStackRowCellInner<TData>({
 		<td
 			className={cx(tableStyles.tableCell, 'tanstack-cell-' + cell.column.id)}
 			data-single-column={hasSingleColumn || undefined}
-			// While loading, rowData may be a placeholder ({ id: 'skeleton-N' }).
-			onClick={showSkeleton ? undefined : onClick}
+			onClick={onClick}
 		>
 			{showSkeleton ? (
 				<Skeleton.Input

frontend/src/components/TanStackTableView/__tests__/TanStackTableView.test.tsx

@@ -91,18 +91,6 @@ describe('TanStackTableView Integration', () => {
 			expect(screen.getByRole('table')).toBeInTheDocument();
 		});
 
-		it('does not call onRowClick for skeleton rows', async () => {
-			const user = userEvent.setup();
-			const onRowClick = jest.fn();
-			renderTanStackTable({
-				props: { data: [], isLoading: true, onRowClick },
-			});
-
-			await user.click(screen.getAllByRole('cell')[0]);
-
-			expect(onRowClick).not.toHaveBeenCalled();
-		});
-
 		it('shows loading spinner for infinite scroll when loading', () => {
 			renderTanStackTable({
 				props: { isLoading: true, onEndReached: jest.fn() },

frontend/src/components/TanStackTableView/__tests__/useColumnStore.test.ts

@@ -263,33 +263,6 @@ describe('useColumnStore', () => {
 			expect(result.current).toBe(firstSnapshot);
 		});
 
-		it.each([
-			['only hiddenColumnIds', { hiddenColumnIds: ['persisted'] }],
-			['only columnOrder', { columnOrder: ['a', 'b'] }],
-			['an empty object', {}],
-			['a wrong-typed hiddenColumnIds', { hiddenColumnIds: 'nope' }],
-		])(
-			'normalises a persisted value carrying %s so selectors never yield undefined',
-			(_label, stored) => {
-				localStorage.setItem(
-					'@signoz/table-columns/test-table',
-					JSON.stringify(stored),
-				);
-
-				act(() => {
-					useColumnStore.getState().initializeFromDefaults(TEST_KEY, []);
-				});
-
-				const hidden = renderHook(() => useHiddenColumnIds(TEST_KEY));
-				const order = renderHook(() => useColumnOrder(TEST_KEY));
-				const sizing = renderHook(() => useColumnSizing(TEST_KEY));
-
-				expect(Array.isArray(hidden.result.current)).toBe(true);
-				expect(Array.isArray(order.result.current)).toBe(true);
-				expect(typeof sizing.result.current).toBe('object');
-			},
-		);
-
 		it('useColumnSizing returns sizing', () => {
 			act(() => {
 				useColumnStore.getState().initializeFromDefaults(TEST_KEY, []);

frontend/src/components/TanStackTableView/useColumnStore.ts

@@ -66,19 +66,7 @@ const loadTableFromStorage = (tableKey: string): ColumnState | null => {
 			return cached.parsed;
 		}
 
-		// Selectors read these fields directly, so a value persisted under an older
-		// schema must be filled in rather than handed to callers as `undefined`.
-		const stored = JSON.parse(raw) as Partial<ColumnState> | null;
-		const parsed: ColumnState = {
-			hiddenColumnIds: Array.isArray(stored?.hiddenColumnIds)
-				? stored.hiddenColumnIds
-				: [],
-			columnOrder: Array.isArray(stored?.columnOrder) ? stored.columnOrder : [],
-			columnSizing:
-				stored?.columnSizing && typeof stored.columnSizing === 'object'
-					? stored.columnSizing
-					: {},
-		};
+		const parsed = JSON.parse(raw) as ColumnState;
 		persistedTableCache.set(tableKey, { raw, parsed });
 		return parsed;
 	} catch {

frontend/src/components/TimePreferenceDropDown/__tests__/TimePreferenceDropDown.test.tsx

@@ -1,27 +0,0 @@
-import { timeItems } from 'constants/timePreference';
-import { render, screen, userEvent } from 'tests/test-utils';
-
-import TimePreference from '../index';
-
-describe('TimePreferenceDropDown', () => {
-	it('calls setSelectedTime with the clicked item', async () => {
-		const setSelectedTime = jest.fn();
-		render(
-			<TimePreference
-				selectedTime={timeItems[0]}
-				setSelectedTime={setSelectedTime}
-			/>,
-		);
-
-		await userEvent.click(screen.getByRole('button', { name: /Global Time/ }));
-		await userEvent.click(
-			await screen.findByRole('menuitem', { name: 'Last 15 min' }),
-		);
-
-		expect(setSelectedTime).toHaveBeenCalledTimes(1);
-		expect(setSelectedTime).toHaveBeenCalledWith({
-			name: 'Last 15 min',
-			enum: 'LAST_15_MIN',
-		});
-	});
-});

frontend/src/container/AIAssistant/components/ActionsSection/__tests__/ActionsSection.test.tsx

@@ -1,83 +0,0 @@
-import { undoExecution } from 'api/ai-assistant/chat';
-import type { MessageActionDTO } from 'api/ai-assistant/sigNozAIAssistantAPI.schemas';
-import { MessageActionKindDTO } from 'api/ai-assistant/sigNozAIAssistantAPI.schemas';
-import { render, screen, userEvent, waitFor } from 'tests/test-utils';
-
-import ActionsSection from '../ActionsSection';
-
-jest.mock('api/ai-assistant/chat', () => ({
-	undoExecution: jest.fn(),
-	revertExecution: jest.fn(),
-	restoreExecution: jest.fn(),
-}));
-jest.mock('api/common/logEvent', () => ({
-	__esModule: true,
-	default: jest.fn(),
-}));
-
-const mockUndo = undoExecution as jest.MockedFunction<typeof undoExecution>;
-
-const UNDO_ACTION = {
-	kind: MessageActionKindDTO.undo,
-	label: 'Undo change',
-	actionMetadataId: 'exec-1',
-} as MessageActionDTO;
-
-function renderUndoChip(): HTMLElement {
-	render(<ActionsSection actions={[UNDO_ACTION]} messageId="m1" />);
-	return screen.getByRole('button', { name: 'Undo change' });
-}
-
-describe('ActionsSection rollback chip', () => {
-	beforeEach(() => {
-		mockUndo.mockReset();
-	});
-
-	it('ignores clicks while the rollback is in flight', async () => {
-		const user = userEvent.setup();
-		mockUndo.mockReturnValue(new Promise(() => {}));
-		const chip = renderUndoChip();
-
-		await user.click(chip);
-		await waitFor(() => expect(chip).toHaveAttribute('aria-busy', 'true'));
-		await user.click(chip);
-
-		expect(mockUndo).toHaveBeenCalledTimes(1);
-		expect(mockUndo).toHaveBeenCalledWith('exec-1');
-	});
-
-	it('disables the chip after success and says why', async () => {
-		const user = userEvent.setup();
-		mockUndo.mockResolvedValue({} as Awaited<ReturnType<typeof undoExecution>>);
-		const chip = renderUndoChip();
-
-		await user.click(chip);
-		await waitFor(() => expect(chip).toHaveAttribute('aria-disabled', 'true'));
-
-		await user.click(chip);
-		expect(mockUndo).toHaveBeenCalledTimes(1);
-
-		// A click closes a Base UI tooltip until the pointer leaves the trigger.
-		await user.unhover(chip);
-		await user.hover(chip);
-		await expect(
-			screen.findByText('This action already ran'),
-		).resolves.toBeInTheDocument();
-	});
-
-	it('shows the error text when the rollback fails', async () => {
-		const user = userEvent.setup();
-		mockUndo.mockRejectedValue(new Error('Execution already reverted'));
-		const chip = renderUndoChip();
-
-		await user.click(chip);
-		await waitFor(() => expect(chip).not.toHaveAttribute('aria-busy', 'true'));
-		expect(chip).not.toHaveAttribute('aria-disabled', 'true');
-
-		await user.unhover(chip);
-		await user.hover(chip);
-		await expect(
-			screen.findByText('Execution already reverted'),
-		).resolves.toBeInTheDocument();
-	});
-});

frontend/src/container/AllError/index.tsx

@@ -337,7 +337,6 @@ function AllErrors(): JSX.Element {
 			render: (value, record): JSX.Element => (
 				<Tooltip overlay={(): JSX.Element => value}>
 					<Link
-						data-testid="exception-row-link"
 						to={`${ROUTES.ERROR_DETAIL}?groupId=${
 							record.groupID
 						}&timestamp=${getNanoSeconds(record.lastSeen)}`}
@@ -483,7 +482,6 @@ function AllErrors(): JSX.Element {
 
 	return (
 		<ResizeTable
-			data-testid="exceptions-table"
 			columns={columns}
 			tableLayout="fixed"
 			dataSource={data?.payload as Exception[]}

frontend/src/container/ApiMonitoring/Explorer/Domains/DomainDetails/DomainDetails.tsx

@@ -161,7 +161,7 @@ function DomainDetails({
 						<Divider type="vertical" />
 
 						{domainData?.domainName && (
-							<Typography.Text className="title" testId="domain-details-title">
+							<Typography.Text className="title">
 								{domainData.domainName}
 							</Typography.Text>
 						)}
@@ -214,7 +214,6 @@ function DomainDetails({
 				background: 'var(--l1-background)',
 			}}
 			className="domain-detail-drawer"
-			data-testid="domain-details-drawer"
 			destroyOnClose
 			closeIcon={<X size={16} style={{ marginTop: Spacing.MARGIN_1 }} />}
 		>
@@ -234,21 +233,9 @@ function DomainDetails({
 							value={selectedView}
 							size="md"
 							items={[
-								{
-									value: VIEW_TYPES.ALL_ENDPOINTS,
-									label: 'All Endpoints',
-									testId: `domain-view-${VIEW_TYPES.ALL_ENDPOINTS}`,
-								},
-								{
-									value: VIEW_TYPES.ENDPOINT_STATS,
-									label: 'Endpoint(s) Stats',
-									testId: `domain-view-${VIEW_TYPES.ENDPOINT_STATS}`,
-								},
-								{
-									value: VIEW_TYPES.TOP_ERRORS,
-									label: 'Top 10 Errors',
-									testId: `domain-view-${VIEW_TYPES.TOP_ERRORS}`,
-								},
+								{ value: VIEW_TYPES.ALL_ENDPOINTS, label: 'All Endpoints' },
+								{ value: VIEW_TYPES.ENDPOINT_STATS, label: 'Endpoint(s) Stats' },
+								{ value: VIEW_TYPES.TOP_ERRORS, label: 'Top 10 Errors' },
 							]}
 						/>
 					</div>

frontend/src/container/ApiMonitoring/Explorer/Domains/DomainDetails/TopErrors.tsx

@@ -176,7 +176,6 @@ function TopErrors({
 						textPlacement="right"
 						value={showStatusCodeErrors}
 						onChange={setShowStatusCodeErrors}
-						testId="top-errors-status-message-toggle"
 					/>
 					<span style={{ color: 'white', fontSize: '14px' }}>
 						Status Message Exists
@@ -187,7 +186,7 @@ function TopErrors({
 				</div>
 			</div>
 
-			<div className="endpoints-table-container" data-testid="top-errors-table">
+			<div className="endpoints-table-container">
 				<div className="endpoints-table-header">
 					{showStatusCodeErrors ? 'Errors with Status Message' : 'All Errors'}{' '}
 					<Tooltip

frontend/src/container/ApiMonitoring/Explorer/Domains/DomainDetails/components/DependentServices.tsx

@@ -64,10 +64,7 @@ function DependentServices({
 
 	return (
 		<div className="top-services-content">
-			<div
-				className="dependent-services-container"
-				data-testid="dependent-services-table"
-			>
+			<div className="dependent-services-container">
 				<Table
 					loading={isLoading || isRefetching}
 					dataSource={dependentServicesData || []}

frontend/src/container/ApiMonitoring/Explorer/Domains/DomainDetails/components/DomainMetrics.tsx

@@ -86,7 +86,7 @@ function DomainMetrics({
 	}
 
 	return (
-		<div className="domain-detail-drawer__endpoint" data-testid="domain-metrics">
+		<div className="domain-detail-drawer__endpoint">
 			<div className="domain-details-grid">
 				<div className="labels-row">
 					<Typography.Text color="muted" className="domain-details-metadata-label">
@@ -103,7 +103,7 @@ function DomainMetrics({
 					</Typography.Text>
 				</div>
 
-				<div className="values-row" data-testid="domain-metrics-values">
+				<div className="values-row">
 					<Typography.Text className="domain-details-metadata-value">
 						{isLoading || isRefetching ? (
 							<Skeleton.Button active size="small" />

frontend/src/container/ApiMonitoring/Explorer/Domains/DomainDetails/components/StatusCodeTable.tsx

@@ -35,10 +35,7 @@ function StatusCodeTable({
 	}
 
 	return (
-		<div
-			className="status-code-table-container"
-			data-testid="endpoint-status-code-table"
-		>
+		<div className="status-code-table-container">
 			<Table
 				loading={isLoading || isRefetching}
 				dataSource={statusCodeData || []}

frontend/src/container/ApiMonitoring/Explorer/Domains/DomainList.tsx

@@ -166,10 +166,7 @@ function DomainList(): JSX.Element {
 				!isFetching &&
 				!isLoading &&
 				formattedDataForTable.length === 0 && (
-					<div
-						className="no-filtered-domains-message-container"
-						data-testid="api-monitoring-empty-state"
-					>
+					<div className="no-filtered-domains-message-container">
 						<div className="no-filtered-domains-message-content">
 							<img
 								src={emptyStateUrl}
@@ -203,7 +200,6 @@ function DomainList(): JSX.Element {
 			{(isFetching || isLoading || formattedDataForTable.length > 0) && (
 				<Table
 					className="api-monitoring-domain-list-table"
-					data-testid="api-monitoring-domain-table"
 					dataSource={isFetching || isLoading ? [] : formattedDataForTable}
 					columns={columnsConfig}
 					loading={{
@@ -214,10 +210,7 @@ function DomainList(): JSX.Element {
 					}}
 					scroll={{ x: true }}
 					tableLayout="fixed"
-					onRow={(
-						record,
-						index,
-					): { onClick: () => void; className: string; 'data-testid': string } => ({
+					onRow={(record, index): { onClick: () => void; className: string } => ({
 						onClick: (): void => {
 							if (index !== undefined) {
 								const dataIndex = formattedDataForTable.findIndex(
@@ -229,7 +222,6 @@ function DomainList(): JSX.Element {
 							}
 						},
 						className: 'expanded-clickable-row',
-						'data-testid': `domain-row-${record.domainName}`,
 					})}
 					rowClassName={(_, index): string =>
 						index % 2 === 0 ? 'table-row-dark' : 'table-row-light'

frontend/src/container/CreateAlertV2/AlertCondition/__tests__/AlertThreshold.test.tsx

@@ -5,10 +5,6 @@ import { AlertTypes } from 'types/api/alerts/alertTypes';
 import { Channels } from 'types/api/channels/getAll';
 
 import { CreateAlertProvider } from '../../context';
-import {
-	THRESHOLD_MATCH_TYPE_OPTIONS,
-	THRESHOLD_OPERATOR_OPTIONS,
-} from '../../context/constants';
 import AlertThreshold from '../AlertThreshold';
 
 const mockChannels: Channels[] = [];
@@ -292,49 +288,4 @@ describe('AlertThreshold', () => {
 		verifySelectRenders(TEST_STRINGS.IS_ABOVE);
 		verifySelectRenders(TEST_STRINGS.AT_LEAST_ONCE);
 	});
-
-	it.each([
-		[
-			'operator',
-			THRESHOLD_OPERATOR_OPTIONS,
-			[
-				'ABOVE',
-				'BELOW',
-				'EQUAL TO',
-				'NOT EQUAL TO',
-				'ABOVE OR EQUAL TO',
-				'BELOW OR EQUAL TO',
-			],
-		],
-		[
-			'match type',
-			THRESHOLD_MATCH_TYPE_OPTIONS,
-			['AT LEAST ONCE', 'ALL THE TIME', 'ON AVERAGE', 'IN TOTAL', 'LAST'],
-		],
-	])(
-		'the %s select offers exactly its documented options',
-		(_label, options, expected) => {
-			// Asserted on the options the select is fed rather than on the rendered
-			// dropdown: antd virtualises its list, so in jsdom (zero-height viewport)
-			// only the first two items exist in the DOM and their text is the wire
-			// value, not the label.
-			expect(options.map((option) => option.label)).toStrictEqual(expected);
-
-			renderAlertThreshold();
-			expect(screen.getByText(options[0].label)).toBeInTheDocument();
-		},
-	);
-
-	it('never renders the recovery threshold control', () => {
-		// `showRecoveryThreshold` starts false and its only setter is commented
-		// out, so neither the input nor its remove button can appear.
-		renderAlertThreshold();
-
-		expect(
-			screen.queryByTestId('recovery-threshold-value-input'),
-		).not.toBeInTheDocument();
-		expect(
-			screen.queryByTestId('remove-recovery-threshold-button'),
-		).not.toBeInTheDocument();
-	});
 });

frontend/src/container/CreateAlertV2/CreateAlertHeader/__tests__/LabelsInput.test.tsx

@@ -106,41 +106,6 @@ describe('LabelsInput', () => {
 			expect(mockOnLabelsChange).toHaveBeenCalledWith({ severity: 'high' });
 		});
 
-		it('rejects a key that already exists, before validating it', () => {
-			// Both rejection branches raise an antd notification rather than an
-			// inline message, so the observable outcome is that nothing is added and
-			// the editor stays on the key phase. The duplicate check short-circuits
-			// ahead of `validateLabelsKey`.
-			renderLabelsInput({ labels: { severity: 'high' } });
-
-			fireEvent.click(screen.getByText(ADD_LABELS_TEXT));
-			const input = screen.getByPlaceholderText(ENTER_KEY_PLACEHOLDER);
-			fireEvent.change(input, { target: { value: 'severity' } });
-			fireEvent.keyDown(input, { key: 'Enter' });
-
-			expect(mockValidateLabelsKey).not.toHaveBeenCalled();
-			expect(mockOnLabelsChange).not.toHaveBeenCalled();
-			expect(
-				screen.queryByPlaceholderText(ENTER_VALUE_PLACEHOLDER),
-			).not.toBeInTheDocument();
-		});
-
-		it('rejects a key the validator refuses', () => {
-			mockValidateLabelsKey.mockReturnValue('Cannot use a group-by key');
-			renderLabelsInput();
-
-			fireEvent.click(screen.getByText(ADD_LABELS_TEXT));
-			const input = screen.getByPlaceholderText(ENTER_KEY_PLACEHOLDER);
-			fireEvent.change(input, { target: { value: 'service.name' } });
-			fireEvent.keyDown(input, { key: 'Enter' });
-
-			expect(mockValidateLabelsKey).toHaveBeenCalledWith('service.name');
-			expect(mockOnLabelsChange).not.toHaveBeenCalled();
-			expect(
-				screen.queryByPlaceholderText(ENTER_VALUE_PLACEHOLDER),
-			).not.toBeInTheDocument();
-		});
-
 		it('does not switch to value input if key is empty', () => {
 			renderLabelsInput();
 

frontend/src/container/CreateAlertV2/context/__tests__/CreateAlertProvider.prefill.test.tsx

@@ -173,50 +173,4 @@ describe('CreateAlertProvider — edit mode ignores URL prefill', () => {
 
 		expect(screen.getByTestId('threshold-value')).toHaveTextContent('245');
 	});
-
-	it('ignores prefill params that are present on an edit URL', () => {
-		// A deep link into the editor can carry the create form's prefill params.
-		// The loaded rule has to win, or opening an edited rule from such a link
-		// would silently rewrite its condition.
-		const initialAlertState = {
-			...INITIAL_CREATE_ALERT_STATE,
-			threshold: {
-				...INITIAL_CREATE_ALERT_STATE.threshold,
-				matchType: AlertThresholdMatchType.AT_LEAST_ONCE,
-				thresholds: [
-					{
-						...INITIAL_CREATE_ALERT_STATE.threshold.thresholds[0],
-						thresholdValue: 245,
-					},
-				],
-			},
-		};
-
-		const queryClient = new QueryClient({
-			defaultOptions: { queries: { retry: false } },
-		});
-		render(
-			<MemoryRouter
-				initialEntries={[
-					`/alerts/overview?ruleId=r1&matchType=in_total&compareOp=below&thresholds=${serializeThreshold(
-						90,
-					)}`,
-				]}
-			>
-				<QueryClientProvider client={queryClient}>
-					<CreateAlertProvider
-						initialAlertType={AlertTypes.METRICS_BASED_ALERT}
-						isEditMode
-						ruleId="r1"
-						initialAlertState={initialAlertState}
-					>
-						<Probe />
-					</CreateAlertProvider>
-				</QueryClientProvider>
-			</MemoryRouter>,
-		);
-
-		expect(screen.getByTestId('threshold-value')).toHaveTextContent('245');
-		expect(screen.getByTestId('match-type')).toHaveTextContent('at_least_once');
-	});
 });

frontend/src/container/ErrorDetails/index.tsx

@@ -148,19 +148,13 @@ function ErrorDetails(props: ErrorDetailsProps): JSX.Element {
 
 	return (
 		<div className="error-details-container">
-			<Typography.Title level={4} testId="error-details-type">
-				{errorDetail.exceptionType}
-			</Typography.Title>
-			<Typography.Text testId="error-details-message">
-				{errorDetail.exceptionMessage}
-			</Typography.Text>
+			<Typography.Title level={4}>{errorDetail.exceptionType}</Typography.Title>
+			<Typography.Text>{errorDetail.exceptionMessage}</Typography.Text>
 			<Divider />
 
 			<EventContainer>
 				<div>
-					<Typography testId="error-details-event-id">
-						Event {errorDetail.errorId}
-					</Typography>
+					<Typography>Event {errorDetail.errorId}</Typography>
 					<Typography>
 						{formatTimezoneAdjustedTimestamp(
 							errorDetail.timestamp,
@@ -171,7 +165,6 @@ function ErrorDetails(props: ErrorDetailsProps): JSX.Element {
 				<div>
 					<Space align="end" direction="horizontal">
 						<Button
-							data-testid="error-details-older"
 							loading={nextPrevStatus === 'loading'}
 							disabled={nextPrevData?.payload?.prevErrorID.length === 0}
 							onClick={(): Promise<void> =>
@@ -184,7 +177,6 @@ function ErrorDetails(props: ErrorDetailsProps): JSX.Element {
 							{t('older')}
 						</Button>
 						<Button
-							data-testid="error-details-newer"
 							loading={nextPrevStatus === 'loading'}
 							disabled={nextPrevData?.payload?.nextErrorID.length === 0}
 							onClick={(): Promise<void> =>
@@ -202,21 +194,17 @@ function ErrorDetails(props: ErrorDetailsProps): JSX.Element {
 
 			<DashedContainer>
 				<Typography>{t('see_trace_graph')}</Typography>
-				<Button
-					data-testid="error-details-view-trace"
-					onClick={onClickTraceHandler}
-					type="primary"
-				>
+				<Button onClick={onClickTraceHandler} type="primary">
 					{t('see_error_in_trace_graph')}
 				</Button>
 			</DashedContainer>
 
 			<Typography.Title level={4}>{t('stack_trace')}</Typography.Title>
-			<div className="error-container" data-testid="error-details-stacktrace">
+			<div className="error-container">
 				<Editor value={stackTraceValue} readOnly />
 			</div>
 
-			<EditorContainer data-testid="error-details-attributes-table">
+			<EditorContainer>
 				<Space direction="vertical">
 					<ResizeTable columns={columns} tableLayout="fixed" dataSource={data} />
 				</Space>

frontend/src/container/ExplorerOptions/ExplorerOptions.tsx

@@ -747,7 +747,6 @@ function ExplorerOptions({
 				<Select
 					disabled={disabled}
 					className="multi-alert-button"
-					data-testid="explorer-options-create-alert"
 					placeholder={selectLabel}
 					value={selectLabel}
 					suffixIcon={null}
@@ -773,7 +772,6 @@ function ExplorerOptions({
 				disabled={disabled}
 				shape="round"
 				onClick={(): void => onCreateAlertsHandler(query)}
-				data-testid="explorer-options-create-alert"
 				icon={<ConciergeBell size={16} />}
 			>
 				Create an Alert
@@ -804,7 +802,6 @@ function ExplorerOptions({
 				<Select
 					disabled={disabled}
 					className="multi-dashboard-button"
-					data-testid="explorer-options-add-to-dashboard"
 					placeholder={selectLabel}
 					value={selectLabel}
 					suffixIcon={null}
@@ -836,7 +833,6 @@ function ExplorerOptions({
 				shape="round"
 				onClick={onAddToDashboard}
 				icon={<Plus size={16} />}
-				data-testid="explorer-options-add-to-dashboard"
 			>
 				Add to Dashboard
 			</Button>
@@ -867,8 +863,6 @@ function ExplorerOptions({
 						<Button
 							className="action-icon"
 							onClick={handleClearSelect}
-							aria-label="Clear this view"
-							data-testid="explorer-clear-view"
 							icon={<X size={14} />}
 						/>
 					</Tooltip>
@@ -888,8 +882,6 @@ function ExplorerOptions({
 									className={cx('action-icon', isEditDeleteSupported ? ' ' : 'hidden')}
 									disabled={isViewUpdating}
 									onClick={onUpdateQueryHandler}
-									aria-label="Update this view"
-									data-testid="explorer-update-view"
 									icon={<Disc3 size={14} />}
 								/>
 							</Tooltip>
@@ -918,7 +910,6 @@ function ExplorerOptions({
 							}}
 							dropdownStyle={dropdownStyle}
 							className="views-dropdown"
-							data-testid="explorer-views-select"
 							allowClear={false}
 							ref={ref}
 						>
@@ -949,7 +940,6 @@ function ExplorerOptions({
 						<Button
 							shape="round"
 							onClick={handleSaveViewModalToggle}
-							data-testid="explorer-save-view-open"
 							className={isEditDeleteSupported ? '' : 'hidden'}
 							disabled={viewsIsLoading || isRefetching}
 							icon={<Disc3 size={16} />}
@@ -1035,7 +1025,6 @@ function ExplorerOptions({
 					/>
 					<Input
 						placeholder="e.g. External http method view"
-						data-testid="save-view-name-input"
 						value={newViewName}
 						onChange={(e): void => setNewViewName(e.target.value)}
 					/>

frontend/src/container/ForgotPassword/__tests__/ForgotPassword.test.tsx

@@ -413,76 +413,4 @@ describe('ForgotPassword Component', () => {
 			expect(submitButton).toHaveAttribute('aria-disabled', 'true');
 		});
 	});
-
-	// The email input is disabled and Enter in the org Select opens it, so Enter
-	// only reaches the form through the focused submit button.
-	describe('Enter key submission', () => {
-		function mockForgot(delayMs = 0): { forgotCalls: () => number } {
-			let calls = 0;
-			server.use(
-				rest.post(FORGOT_PASSWORD_ENDPOINT, (_req, res, ctx) => {
-					calls += 1;
-					return res(
-						ctx.delay(delayMs),
-						ctx.status(200),
-						ctx.json({ status: 'success' }),
-					);
-				}),
-			);
-			return { forgotCalls: (): number => calls };
-		}
-
-		it('sends the reset link once on Enter on the submit button', async () => {
-			const user = userEvent.setup({ pointerEventsCheck: 0 });
-			const { forgotCalls } = mockForgot();
-
-			render(<ForgotPassword {...defaultProps} />);
-
-			await user.tab();
-			await user.tab();
-			expect(screen.getByTestId('forgot-password-submit')).toHaveFocus();
-			await user.keyboard('{enter}');
-
-			await expect(
-				screen.findByText(/check your email/i),
-			).resolves.toBeInTheDocument();
-			expect(forgotCalls()).toBe(1);
-		});
-
-		it('does not send on Enter while no organization is selected', async () => {
-			const user = userEvent.setup({ pointerEventsCheck: 0 });
-			const { forgotCalls } = mockForgot();
-
-			render(<ForgotPassword {...multiOrgProps} />);
-
-			const submitButton = screen.getByTestId('forgot-password-submit');
-			expect(submitButton).toHaveAttribute('aria-disabled', 'true');
-			submitButton.focus();
-			await user.keyboard('{enter}');
-
-			// Give a wrongly sent request time to land before asserting it never did.
-			await new Promise((resolve) => setTimeout(resolve, 50));
-			expect(forgotCalls()).toBe(0);
-		});
-
-		it('does not send again on Enter while the first request is loading', async () => {
-			const user = userEvent.setup({ pointerEventsCheck: 0 });
-			const { forgotCalls } = mockForgot(1000);
-
-			render(<ForgotPassword {...defaultProps} />);
-
-			const submitButton = screen.getByTestId('forgot-password-submit');
-			submitButton.focus();
-			await user.keyboard('{enter}');
-
-			await screen.findByText(/sending\.\.\./i);
-			expect(submitButton).toHaveAttribute('aria-disabled', 'true');
-			await user.keyboard('{enter}');
-
-			await expect(
-				screen.findByText(/check your email/i, undefined, { timeout: 2000 }),
-			).resolves.toBeInTheDocument();
-			expect(forgotCalls()).toBe(1);
-		});
-	});
 });

frontend/src/container/Home/AlertRules/AlertRules.tsx

@@ -218,12 +218,7 @@ export default function AlertRules({
 		<Card className="alert-rules-card home-data-card">
 			{rulesExist && (
 				<Card.Header>
-					<div
-						className="alert-rules-header home-data-card-header"
-						data-testid="home-section-alerts"
-					>
-						Alerts
-					</div>
+					<div className="alert-rules-header home-data-card-header">Alerts</div>
 				</Card.Header>
 			)}
 			<Card.Content>

frontend/src/container/Home/Dashboards/Dashboards.tsx

@@ -202,12 +202,7 @@ export default function Dashboards({
 		<Card className="dashboards-list-card home-data-card">
 			{dashboardsExist && (
 				<Card.Header>
-					<div
-						className="dashboards-header home-data-card-header"
-						data-testid="home-section-dashboards"
-					>
-						Dashboards
-					</div>
+					<div className="dashboards-header home-data-card-header">Dashboards</div>
 				</Card.Header>
 			)}
 			<Card.Content>

frontend/src/container/Home/Home.tsx

@@ -279,7 +279,7 @@ export default function Home(): JSX.Element {
 	}, []);
 
 	return (
-		<div className="home-container" data-testid="home-page">
+		<div className="home-container">
 			{getIsNoAuthMode() && <NoAuthBanner />}
 			<div className="sticky-header">
 				<Header
@@ -317,7 +317,6 @@ export default function Home(): JSX.Element {
 										variant="solid"
 										color="secondary"
 										prefix={<ClipboardList size={14} />}
-										testId="welcome-checklist-btn"
 									>
 										Welcome checklist
 									</Button>
@@ -664,10 +663,7 @@ export default function Home(): JSX.Element {
 										exit={{ opacity: 0, scale: 0 }}
 										key="box"
 									>
-										<div
-											className="checklist-container"
-											data-testid="home-checklist-card"
-										>
+										<div className="checklist-container">
 											<div className="checklist-items-container">
 												<StepsProgress checklistItems={checklistItems} />
 
@@ -706,7 +702,6 @@ export default function Home(): JSX.Element {
 											color="secondary"
 											onClick={handleWillDoThisLater}
 											loading={updatingUserPreferences}
-											testId="checklist-do-later-btn"
 										>
 											I&apos;ll do this later
 										</Button>

frontend/src/container/Home/HomeChecklist/HomeChecklist.tsx

@@ -68,7 +68,6 @@ function HomeChecklist({
 						{whatsNextChecklistItems.map((item, index) => (
 							<div
 								key={item.id}
-								data-testid={`checklist-item-${item.id}`}
 								className={`whats-next-checklist-item ${
 									item.isSkipped && !item.completed ? 'skipped' : ''
 								} ${
@@ -130,7 +129,6 @@ function HomeChecklist({
 													<Button
 														type="link"
 														className="periscope-btn link skip-btn"
-														data-testid={`checklist-skip-${item.id}`}
 														onClick={(): void => {
 															logEvent('Welcome Checklist: Skip clicked', {
 																step: item.id,

frontend/src/container/Home/SavedViews/SavedViews.tsx

@@ -317,10 +317,7 @@ export default function SavedViews({
 		<Card className="saved-views-list-card home-data-card">
 			{hasSavedViews && (
 				<Card.Header>
-					<div
-						className="saved-views-header home-data-card-header"
-						data-testid="home-section-saved-views"
-					>
+					<div className="saved-views-header home-data-card-header">
 						Saved Views
 						<div className="saved-views-header-actions">
 							<Button.Group className="views-tabs">

frontend/src/container/Home/Services/ServiceMetrics.tsx

@@ -315,10 +315,7 @@ function ServiceMetrics({
 		<Card className="services-list-card home-data-card">
 			{servicesExist && (
 				<Card.Header>
-					<div
-						className="services-header home-data-card-header"
-						data-testid="home-section-services"
-					>
+					<div className="services-header home-data-card-header">
 						{' '}
 						Services
 						<div className="services-header-actions">

frontend/src/container/Home/Services/ServiceTraces.tsx

@@ -218,10 +218,7 @@ export default function ServiceTraces({
 		<Card className="dashboards-list-card home-data-card">
 			{servicesExist && (
 				<Card.Header>
-					<div
-						className="services-header home-data-card-header"
-						data-testid="home-section-services"
-					>
+					<div className="services-header home-data-card-header">
 						Services
 						<div className="services-header-actions">
 							<Select

frontend/src/container/InfraMonitoringHostsV2/Hosts.tsx

@@ -213,7 +213,6 @@ function Hosts(): JSX.Element {
 				className="periscope-btn ghost"
 				type="text"
 				size="small"
-				data-testid="quick-filters-toggle"
 				onClick={handleFilterVisibilityChange}
 			>
 				<Filter size={14} />
@@ -240,7 +239,6 @@ function Hosts(): JSX.Element {
 												style={{ rotate: '270deg', cursor: 'pointer' }}
 												onClick={handleFilterVisibilityChange}
 												size="md"
-												data-testid="quick-filters-toggle"
 											/>
 										</Tooltip>
 									</div>

frontend/src/container/InfraMonitoringHostsV2/StatusFilter.tsx

@@ -53,7 +53,6 @@ function StatusFilter(): JSX.Element {
 				items={statusOptions.map((option) => ({
 					value: option.value,
 					label: option.label,
-					testId: `status-filter-${option.value}`,
 					prefix: (
 						<span
 							className={`${styles.statusDot} ${

frontend/src/container/InfraMonitoringK8sV2/Base/K8sBaseDetails.tsx

@@ -296,7 +296,6 @@ export default function K8sBaseDetails<T>({
 		<DrawerWrapper
 			open={!!selectedItem}
 			onOpenChange={handleOpenChange}
-			testId="drawer-wrapper"
 			direction="right"
 			title={drawerTitle}
 			showCloseButton={false}

frontend/src/container/InfraMonitoringK8sV2/Base/K8sBaseDetailsContent.tsx

@@ -301,7 +301,6 @@ export default function K8sBaseDetailsContent<T>({
 						type="single"
 						onChange={handleTabChange}
 						value={effectiveView}
-						testId="drawer-tab-bar"
 						items={[
 							...(tabVisibility.showOverview
 								? [
@@ -388,7 +387,6 @@ export default function K8sBaseDetailsContent<T>({
 								size="sm"
 								icon
 								color="secondary"
-								testId="open-logs-explorer"
 								onClick={handleExplorePagesRedirect}
 							>
 								<Compass size={18} />
@@ -403,7 +401,6 @@ export default function K8sBaseDetailsContent<T>({
 								size="sm"
 								icon
 								color="secondary"
-								testId="open-traces-explorer"
 								onClick={handleExplorePagesRedirect}
 							>
 								<Compass size={18} />

frontend/src/container/InfraMonitoringK8sV2/Base/K8sBaseList.tsx

@@ -396,11 +396,6 @@ export function K8sBaseList<
 
 	const isGroupedByAttribute = groupBy.length > 0;
 
-	const getRowTestId = useCallback(
-		(record: T): string => `row-${getRowKey(record)}`,
-		[getRowKey],
-	);
-
 	// Filter columns for expanded row based on parent's hidden columns
 	const expandedRowColumns = useMemo(
 		() => tableColumns.filter((col) => !hiddenColumnIds.includes(col.id)),
@@ -422,7 +417,6 @@ export function K8sBaseList<
 				extraQueryKeyParts={extraQueryKeyParts}
 				getRowKey={getRowKey}
 				getItemKey={getItemKey}
-				getRowTestId={getRowTestId}
 				detailsQueryKeyPrefix={detailsQueryKeyPrefix}
 			/>
 		),
@@ -431,7 +425,6 @@ export function K8sBaseList<
 			fetchListData,
 			getRowKey,
 			getItemKey,
-			getRowTestId,
 			expandedRowColumns,
 			extraQueryKeyParts,
 			detailsQueryKeyPrefix,
@@ -513,7 +506,6 @@ export function K8sBaseList<
 						isLoading={showTableLoadingState}
 						getRowKey={getRowKey}
 						getItemKey={getItemKey}
-						getRowTestId={getRowTestId}
 						groupBy={groupBy.map((g) => ({ key: g }))}
 						getGroupKey={getGroupKeyFn}
 						onRowClick={handleRowClick}

frontend/src/container/InfraMonitoringK8sV2/Base/K8sEmptyState.tsx

@@ -21,7 +21,7 @@ export function K8sEmptyState({
 
 	if (isError || error) {
 		return (
-			<div className={styles.container} data-testid="k8s-error-state">
+			<div className={styles.container}>
 				<div className={styles.errorContent}>
 					<ErrorContent
 						error={
@@ -38,7 +38,7 @@ export function K8sEmptyState({
 
 	if (endTimeBeforeRetention) {
 		return (
-			<div className={styles.container} data-testid="k8s-empty-state-retention">
+			<div className={styles.container}>
 				<div className={styles.content}>
 					<img className={styles.eyesEmoji} src={eyesEmojiUrl} alt="eyes emoji" />
 					<div className={styles.noDataMessage}>
@@ -56,7 +56,7 @@ export function K8sEmptyState({
 	}
 
 	return (
-		<div className={styles.container} data-testid="k8s-empty-state">
+		<div className={styles.container}>
 			<div className={styles.content}>
 				<img
 					src={emptyStateUrl}

frontend/src/container/InfraMonitoringK8sV2/Base/K8sExpandedRow.tsx

@@ -69,7 +69,6 @@ export type K8sExpandedRowProps<T, TItemKey = string> = {
 	getRowKey?: (record: T) => string;
 	/** Function to get the item key used for selection. Defaults to getRowKey if not provided. */
 	getItemKey?: (record: T) => TItemKey;
-	getRowTestId?: (record: T) => string;
 	/** Query key prefix for pre-caching detail data on row click */
 	detailsQueryKeyPrefix?: string;
 };
@@ -86,7 +85,6 @@ export function K8sExpandedRow<
 	extraQueryKeyParts = [],
 	getRowKey,
 	getItemKey,
-	getRowTestId,
 	detailsQueryKeyPrefix,
 }: K8sExpandedRowProps<T, TItemKey>): JSX.Element {
 	const fontSize = useInfraMonitoringFontSize();
@@ -323,7 +321,6 @@ export function K8sExpandedRow<
 						isLoading={isLoading}
 						getRowKey={getRowKey}
 						getItemKey={getItemKey}
-						getRowTestId={getRowTestId}
 						onRowClick={handleRowClick}
 						onSort={handleSort}
 						enableQueryParams={{

frontend/src/container/InfraMonitoringK8sV2/Base/K8sHeader.tsx

@@ -141,7 +141,6 @@ function K8sHeader({
 					isLoadingQueries={isFetching}
 					onStageRunQuery={handleStageRunQuery}
 					handleCancelQuery={handleCancelQuery}
-					testId="list-run-query-btn"
 				/>
 			</div>
 

frontend/src/container/InfraMonitoringK8sV2/EntityDetailsUtils/EntityDateTimeSelector/EntityDateTimeSelector.tsx

@@ -51,7 +51,7 @@ function EntityDateTimeSelector({
 	);
 
 	return (
-		<div className={styles.container} data-testid="drawer-time-selection">
+		<div className={styles.container}>
 			{hasTimeChanged && (
 				<Tooltip title="Reset to list time" side="bottom">
 					<Button

frontend/src/container/InfraMonitoringK8sV2/EntityDetailsUtils/EntityEmptyState/EntityEmptyState.tsx

@@ -12,7 +12,7 @@ export default function EntityEmptyState({
 	hasFilters,
 }: EntityEmptyStateProps): JSX.Element {
 	return (
-		<div className={styles.container} data-testid="entity-empty-state">
+		<div className={styles.container}>
 			<div className={styles.content}>
 				<img src={emptyStateUrl} alt="empty-state" className={styles.icon} />
 				{hasFilters ? (