chore(deps): bump github.com/openfga/openfga from 1.11.2 to 1.14.1

Bumps [github.com/openfga/openfga](https://github.com/openfga/openfga) from 1.11.2 to 1.14.1.
- [Release notes](https://github.com/openfga/openfga/releases)
- [Changelog](https://github.com/openfga/openfga/blob/main/CHANGELOG.md)
- [Commits](https://github.com/openfga/openfga/compare/v1.11.2...v1.14.1)

---
updated-dependencies:
- dependency-name: github.com/openfga/openfga
  dependency-version: 1.14.1
  dependency-type: direct:production
...

Signed-off-by: dependabot[bot] <support@github.com>

.github/workflows/e2eci.yaml

@@ -1,70 +0,0 @@
-name: e2eci
-
-on:
-  pull_request:
-    types:
-      - labeled
-  pull_request_target:
-    types:
-      - labeled
-
-jobs:
-  test:
-    strategy:
-      fail-fast: false
-      matrix:
-        project:
-          - chromium
-    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:
-      - name: checkout
-        uses: actions/checkout@v4
-      - name: python
-        uses: actions/setup-python@v5
-        with:
-          python-version: 3.13
-      - name: uv
-        uses: astral-sh/setup-uv@v4
-      - name: node
-        uses: actions/setup-node@v4
-        with:
-          node-version: lts/*
-      - name: python-install
-        run: |
-          cd tests && uv sync
-      - name: yarn-install
-        run: |
-          cd tests/e2e && yarn install --frozen-lockfile
-      - name: playwright-browsers
-        run: |
-          cd tests/e2e && yarn playwright install --with-deps ${{ matrix.project }}
-      - name: bring-up-stack
-        run: |
-          cd tests && \
-            uv run pytest \
-            --basetemp=./tmp/ \
-            -vv --reuse --with-web \
-            e2e/bootstrap/setup.py::test_setup
-      - name: playwright-test
-        run: |
-          cd tests/e2e && \
-            yarn playwright test --project=${{ matrix.project }}
-      - name: teardown-stack
-        if: always()
-        run: |
-          cd tests && \
-            uv run pytest \
-            --basetemp=./tmp/ \
-            -vv --teardown \
-            e2e/bootstrap/setup.py::test_teardown
-      - name: upload-artifacts
-        if: always()
-        uses: actions/upload-artifact@v4
-        with:
-          name: playwright-artifacts-${{ matrix.project }}
-          path: tests/e2e/artifacts/
-          retention-days: 5

.github/workflows/integrationci.yaml

@@ -25,11 +25,11 @@ jobs:
         uses: astral-sh/setup-uv@v4
       - name: install
         run: |
-          cd tests && uv sync
+          cd tests/integration && uv sync
       - name: fmt
         run: |
           make py-fmt
-          git diff --exit-code -- tests/
+          git diff --exit-code -- tests/integration/
       - name: lint
         run: |
           make py-lint
@@ -37,21 +37,21 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        suite:
-          - alerts
+        src:
+          - bootstrap
+          - passwordauthn
           - callbackauthn
           - cloudintegrations
           - dashboard
-          - ingestionkeys
           - logspipelines
-          - passwordauthn
           - preference
           - querier
-          - rawexportdata
           - role
+          - ttl
+          - alerts
+          - ingestionkeys
           - rootuser
           - serviceaccount
-          - ttl
         sqlstore-provider:
           - postgres
           - sqlite
@@ -79,9 +79,8 @@ jobs:
         uses: astral-sh/setup-uv@v4
       - name: install
         run: |
-          cd tests && uv sync
+          cd tests/integration && uv sync
       - name: webdriver
-        if: matrix.suite == 'callbackauthn'
         run: |
           wget -q -O - https://dl-ssl.google.com/linux/linux_signing_key.pub | sudo apt-key add -
           echo "deb http://dl.google.com/linux/chrome/deb/ stable main" | sudo tee -a /etc/apt/sources.list.d/google-chrome.list
@@ -100,10 +99,10 @@ jobs:
           google-chrome-stable --version
       - name: run
         run: |
-          cd tests && \
+          cd tests/integration && \
             uv run pytest \
             --basetemp=./tmp/ \
-            integration/tests/${{matrix.suite}} \
+            src/${{matrix.src}} \
             --sqlstore-provider ${{matrix.sqlstore-provider}} \
             --sqlite-mode ${{matrix.sqlite-mode}} \
             --postgres-version ${{matrix.postgres-version}} \

.github/workflows/run-e2e.yaml

@@ -0,0 +1,62 @@
+name: e2eci
+
+on:
+  workflow_dispatch:
+    inputs:
+      userRole:
+        description: "Role of the user (ADMIN, EDITOR, VIEWER)"
+        required: true
+        type: choice
+        options:
+          - ADMIN
+          - EDITOR
+          - VIEWER
+
+jobs:
+  test:
+    name: Run Playwright Tests
+    runs-on: ubuntu-latest
+    timeout-minutes: 60
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: lts/*
+
+      - name: Mask secrets and input
+        run: |
+          echo "::add-mask::${{ secrets.BASE_URL }}"
+          echo "::add-mask::${{ secrets.LOGIN_USERNAME }}"
+          echo "::add-mask::${{ secrets.LOGIN_PASSWORD }}"
+          echo "::add-mask::${{ github.event.inputs.userRole }}"
+
+      - name: Install dependencies
+        working-directory: frontend
+        run: |
+          npm install -g yarn
+          yarn
+
+      - name: Install Playwright Browsers
+        working-directory: frontend
+        run: yarn playwright install --with-deps
+
+      - name: Run Playwright Tests
+        working-directory: frontend
+        run: |
+          BASE_URL="${{ secrets.BASE_URL }}" \
+          LOGIN_USERNAME="${{ secrets.LOGIN_USERNAME }}" \
+          LOGIN_PASSWORD="${{ secrets.LOGIN_PASSWORD }}" \
+          USER_ROLE="${{ github.event.inputs.userRole }}" \
+          yarn playwright test
+
+      - name: Upload Playwright Report
+        uses: actions/upload-artifact@v4
+        if: always()
+        with:
+          name: playwright-report
+          path: frontend/playwright-report/
+          retention-days: 30

Makefile

@@ -201,26 +201,26 @@ docker-buildx-enterprise: go-build-enterprise js-build
 # python commands
 ##############################################################
 .PHONY: py-fmt
-py-fmt: ## Run black across the shared tests project
-	@cd tests && uv run black .
+py-fmt: ## Run black for integration tests
+	@cd tests/integration && uv run black .
 
 .PHONY: py-lint
-py-lint: ## Run lint across the shared tests project
-	@cd tests && uv run isort .
-	@cd tests && uv run autoflake .
-	@cd tests && uv run pylint .
+py-lint: ## Run lint for integration tests
+	@cd tests/integration && uv run isort .
+	@cd tests/integration && uv run autoflake .
+	@cd tests/integration && uv run pylint .
 
 .PHONY: py-test-setup
-py-test-setup: ## Bring up the shared SigNoz backend used by integration and e2e tests
-	@cd tests && uv run pytest --basetemp=./tmp/ -vv --reuse --capture=no integration/bootstrap/setup.py::test_setup
+py-test-setup: ## Runs integration tests
+	@cd tests/integration && uv run pytest --basetemp=./tmp/ -vv --reuse --capture=no src/bootstrap/setup.py::test_setup
 
 .PHONY: py-test-teardown
-py-test-teardown: ## Tear down the shared SigNoz backend
-	@cd tests && uv run pytest --basetemp=./tmp/ -vv --teardown --capture=no  integration/bootstrap/setup.py::test_teardown
+py-test-teardown: ## Runs integration tests with teardown
+	@cd tests/integration && uv run pytest --basetemp=./tmp/ -vv --teardown --capture=no  src/bootstrap/setup.py::test_teardown
 
 .PHONY: py-test
 py-test: ## Runs integration tests
-	@cd tests && uv run pytest --basetemp=./tmp/ -vv --capture=no integration/tests/
+	@cd tests/integration && uv run pytest --basetemp=./tmp/ -vv --capture=no src/
 
 .PHONY: py-clean
 py-clean: ## Clear all pycache and pytest cache from tests directory recursively

docs/api/openapi.yml

@@ -2287,125 +2287,6 @@ components:
         enabled:
           type: boolean
       type: object
-    InframonitoringtypesHostFilter:
-      properties:
-        expression:
-          type: string
-        filterByStatus:
-          $ref: '#/components/schemas/InframonitoringtypesHostStatus'
-      type: object
-    InframonitoringtypesHostRecord:
-      properties:
-        activeHostCount:
-          type: integer
-        cpu:
-          format: double
-          type: number
-        diskUsage:
-          format: double
-          type: number
-        hostName:
-          type: string
-        inactiveHostCount:
-          type: integer
-        load15:
-          format: double
-          type: number
-        memory:
-          format: double
-          type: number
-        meta:
-          additionalProperties: {}
-          nullable: true
-          type: object
-        status:
-          $ref: '#/components/schemas/InframonitoringtypesHostStatus'
-        wait:
-          format: double
-          type: number
-      required:
-      - hostName
-      - status
-      - activeHostCount
-      - inactiveHostCount
-      - cpu
-      - memory
-      - wait
-      - load15
-      - diskUsage
-      - meta
-      type: object
-    InframonitoringtypesHostStatus:
-      enum:
-      - active
-      - inactive
-      - ""
-      type: string
-    InframonitoringtypesHosts:
-      properties:
-        endTimeBeforeRetention:
-          type: boolean
-        records:
-          items:
-            $ref: '#/components/schemas/InframonitoringtypesHostRecord'
-          nullable: true
-          type: array
-        requiredMetricsCheck:
-          $ref: '#/components/schemas/InframonitoringtypesRequiredMetricsCheck'
-        total:
-          type: integer
-        type:
-          $ref: '#/components/schemas/InframonitoringtypesResponseType'
-        warning:
-          $ref: '#/components/schemas/Querybuildertypesv5QueryWarnData'
-      required:
-      - type
-      - records
-      - total
-      - requiredMetricsCheck
-      - endTimeBeforeRetention
-      type: object
-    InframonitoringtypesPostableHosts:
-      properties:
-        end:
-          format: int64
-          type: integer
-        filter:
-          $ref: '#/components/schemas/InframonitoringtypesHostFilter'
-        groupBy:
-          items:
-            $ref: '#/components/schemas/Querybuildertypesv5GroupByKey'
-          nullable: true
-          type: array
-        limit:
-          type: integer
-        offset:
-          type: integer
-        orderBy:
-          $ref: '#/components/schemas/Querybuildertypesv5OrderBy'
-        start:
-          format: int64
-          type: integer
-      required:
-      - start
-      - end
-      - limit
-      type: object
-    InframonitoringtypesRequiredMetricsCheck:
-      properties:
-        missingMetrics:
-          items:
-            type: string
-          nullable: true
-          type: array
-      required:
-      - missingMetrics
-      type: object
-    InframonitoringtypesResponseType:
-      enum:
-      - list
-      - grouped_list
-      type: string
     MetricsexplorertypesInspectMetricsRequest:
       properties:
         end:
@@ -9972,72 +9853,6 @@ paths:
       summary: Health check
       tags:
       - health
-  /api/v2/infra_monitoring/hosts:
-    post:
-      deprecated: false
-      description: 'Returns a paginated list of hosts with key infrastructure metrics:
-        CPU usage (%), memory usage (%), I/O wait (%), disk usage (%), and 15-minute
-        load average. Each host includes its current status (active/inactive based
-        on metrics reported in the last 10 minutes) and metadata attributes (e.g.,
-        os.type). Supports filtering via a filter expression, filtering by host status,
-        custom groupBy to aggregate hosts by any attribute, ordering by any of the
-        five metrics, and pagination via offset/limit. The response type is ''list''
-        for the default host.name grouping or ''grouped_list'' for custom groupBy
-        keys. Also reports missing required metrics and whether the requested time
-        range falls before the data retention boundary.'
-      operationId: ListHosts
-      requestBody:
-        content:
-          application/json:
-            schema:
-              $ref: '#/components/schemas/InframonitoringtypesPostableHosts'
-      responses:
-        "200":
-          content:
-            application/json:
-              schema:
-                properties:
-                  data:
-                    $ref: '#/components/schemas/InframonitoringtypesHosts'
-                  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:
-        - VIEWER
-      - tokenizer:
-        - VIEWER
-      summary: List Hosts for Infra Monitoring
-      tags:
-      - inframonitoring
   /api/v2/livez:
     get:
       deprecated: false

docs/contributing/go/integration.md

@@ -0,0 +1,216 @@
+# Integration Tests
+
+SigNoz uses integration tests to verify that different components work together correctly in a real environment. These tests run against actual services (ClickHouse, PostgreSQL, etc.) to ensure end-to-end functionality.
+
+## How to set up the integration test environment?
+
+### Prerequisites
+
+Before running integration tests, ensure you have the following installed:
+
+- Python 3.13+
+- [uv](https://docs.astral.sh/uv/getting-started/installation/)
+- Docker (for containerized services)
+
+### Initial Setup
+
+1. Navigate to the integration tests directory:
+```bash
+cd tests/integration
+```
+
+2. Install dependencies using uv:
+```bash
+uv sync
+```
+
+> **_NOTE:_**  the build backend could throw an error while installing `psycopg2`, pleae see https://www.psycopg.org/docs/install.html#build-prerequisites
+
+### Starting the Test Environment
+
+To spin up all the containers necessary for writing integration tests and keep them running:
+
+```bash
+uv run pytest --basetemp=./tmp/ -vv --reuse src/bootstrap/setup.py::test_setup
+```
+
+This command will:
+- Start all required services (ClickHouse, PostgreSQL, Zookeeper, etc.)
+- Keep containers running due to the `--reuse` flag
+- Verify that the setup is working correctly
+
+### Stopping the Test Environment
+
+When you're done writing integration tests, clean up the environment:
+
+```bash
+uv run pytest --basetemp=./tmp/ -vv --teardown -s src/bootstrap/setup.py::test_teardown
+```
+
+This will destroy the running integration test setup and clean up resources.
+
+## Understanding the Integration Test Framework
+
+Python and pytest form the foundation of the integration testing framework. Testcontainers are used to spin up disposable integration environments. Wiremock is used to spin up **test doubles** of other services.
+
+- **Why Python/pytest?** It's expressive, low-boilerplate, and has powerful fixture capabilities that make integration testing straightforward. Extensive libraries for HTTP requests, JSON handling, and data analysis (numpy) make it easier to test APIs and verify data
+- **Why testcontainers?** They let us spin up isolated dependencies that match our production environment without complex setup.
+- **Why wiremock?** Well maintained, documented and extensible.
+
+```
+.
+├── conftest.py
+├── fixtures
+│   ├── __init__.py
+│   ├── auth.py
+│   ├── clickhouse.py
+│   ├── fs.py
+│   ├── http.py
+│   ├── migrator.py
+│   ├── network.py
+│   ├── postgres.py
+│   ├── signoz.py
+│   ├── sql.py
+│   ├── sqlite.py
+│   ├── types.py
+│   └── zookeeper.py
+├── uv.lock
+├── pyproject.toml
+└── src
+    └── bootstrap
+        ├── __init__.py
+        ├── 01_database.py
+        ├── 02_register.py
+        └── 03_license.py
+```
+
+Each test suite follows some important principles:
+
+1. **Organization**: Test suites live under `src/` in self-contained packages. Fixtures (a pytest concept) live inside `fixtures/`.
+2. **Execution Order**: Files are prefixed with two-digit numbers (`01_`, `02_`, `03_`) to ensure sequential execution.
+3. **Time Constraints**: Each suite should complete in under 10 minutes (setup takes ~4 mins).
+
+### Test Suite Design
+
+Test suites should target functional domains or subsystems within SigNoz. When designing a test suite, consider these principles:
+
+- **Functional Cohesion**: Group tests around a specific capability or service boundary
+- **Data Flow**: Follow the path of data through related components
+- **Change Patterns**: Components frequently modified together should be tested together
+
+The exact boundaries for modules are intentionally flexible, allowing teams to define logical groupings based on their specific context and knowledge of the system.
+
+Eg: The **bootstrap** integration test suite validates core system functionality:
+
+- Database initialization
+- Version check
+
+Other test suites can be **pipelines, auth, querier.**
+
+## How to write an integration test?
+
+Now start writing an integration test. Create a new file `src/bootstrap/05_version.py` and paste the following:
+
+```python
+import requests
+
+from fixtures import types
+from fixtures.logger import setup_logger
+
+logger = setup_logger(__name__)
+
+def test_version(signoz: types.SigNoz) -> None:
+    response = requests.get(signoz.self.host_config.get("/api/v1/version"), timeout=2)
+    logger.info(response)
+```
+
+We have written a simple test which calls the `version` endpoint of the container in step 1. In **order to just run this function, run the following command:**
+
+```bash
+uv run pytest --basetemp=./tmp/ -vv --reuse src/bootstrap/05_version.py::test_version
+```
+
+> Note: The `--reuse` flag is used to reuse the environment if it is already running. Always use this flag when writing and running integration tests. If you don't use this flag, the environment will be destroyed and recreated every time you run the test.
+
+Here's another example of how to write a more comprehensive integration test:
+
+```python
+from http import HTTPStatus
+import requests
+from fixtures import types
+from fixtures.logger import setup_logger
+
+logger = setup_logger(__name__)
+
+def test_user_registration(signoz: types.SigNoz) -> None:
+    """Test user registration functionality."""
+    response = requests.post(
+        signoz.self.host_configs["8080"].get("/api/v1/register"),
+        json={
+            "name": "testuser",
+            "orgId": "",
+            "orgName": "test.org",
+            "email": "test@example.com",
+            "password": "password123Z$",
+        },
+        timeout=2,
+    )
+
+    assert response.status_code == HTTPStatus.OK
+    assert response.json()["setupCompleted"] is True
+```
+
+## How to run integration tests?
+
+### Running All Tests
+
+```bash
+uv run pytest --basetemp=./tmp/ -vv --reuse src/
+```
+
+### Running Specific Test Categories
+
+```bash
+uv run pytest --basetemp=./tmp/ -vv --reuse src/<suite>
+
+# Run querier tests
+uv run pytest --basetemp=./tmp/ -vv --reuse src/querier/
+# Run auth tests
+uv run pytest --basetemp=./tmp/ -vv --reuse src/auth/
+```
+
+### Running Individual Tests
+
+```bash
+uv run pytest --basetemp=./tmp/ -vv --reuse src/<suite>/<file>.py::test_name
+
+# Run test_register in file 01_register.py in passwordauthn suite
+uv run pytest --basetemp=./tmp/ -vv --reuse src/passwordauthn/01_register.py::test_register
+```
+
+## How to configure different options for integration tests?
+
+Tests can be configured using pytest options:
+
+- `--sqlstore-provider` - Choose database provider (default: postgres)
+- `--sqlite-mode` - SQLite journal mode: `delete` or `wal` (default: delete). Only relevant when `--sqlstore-provider=sqlite`.
+- `--postgres-version` - PostgreSQL version (default: 15)
+- `--clickhouse-version` - ClickHouse version (default: 25.5.6)
+- `--zookeeper-version` - Zookeeper version (default: 3.7.1)
+
+Example:
+```bash
+uv run pytest --basetemp=./tmp/ -vv --reuse --sqlstore-provider=postgres --postgres-version=14 src/auth/
+```
+
+## What should I remember?
+
+- **Always use the `--reuse` flag** when setting up the environment to keep containers running
+- **Use the `--teardown` flag** when cleaning up to avoid resource leaks
+- **Follow the naming convention** with two-digit numeric prefixes (`01_`, `02_`) for test execution order
+- **Use proper timeouts** in HTTP requests to avoid hanging tests
+- **Clean up test data** between tests to avoid interference
+- **Use descriptive test names** that clearly indicate what is being tested
+- **Leverage fixtures** for common setup and authentication
+- **Test both success and failure scenarios** to ensure robust functionality
+- **`--sqlite-mode=wal` does not work on macOS.** The integration test environment runs SigNoz inside a Linux container with the SQLite database file mounted from the macOS host. WAL mode requires shared memory between connections, and connections crossing the VM boundary (macOS host ↔ Linux container) cannot share the WAL index, resulting in `SQLITE_IOERR_SHORT_READ`. WAL mode is tested in CI on Linux only.

docs/contributing/go/readme.md

@@ -15,6 +15,7 @@ We **recommend** (almost enforce) reviewing these guides before contributing to
 - [Endpoint](endpoint.md) - HTTP endpoint patterns
 - [Flagger](flagger.md) - Feature flag patterns
 - [Handler](handler.md) - HTTP handler patterns
+- [Integration](integration.md) - Integration testing
 - [Provider](provider.md) - Dependency injection and provider patterns
 - [Packages](packages.md) - Naming, layout, and conventions for `pkg/` packages
 - [Service](service.md) - Managed service lifecycle with `factory.Service`

docs/contributing/tests/e2e.md

@@ -1,261 +0,0 @@
-# E2E Tests
-
-SigNoz uses end-to-end tests to verify the frontend works correctly against a real backend. These tests use Playwright to drive a real browser against a containerized SigNoz stack that pytest brings up — the same fixture graph integration tests use, with an extra HTTP seeder container for per-spec telemetry seeding.
-
-## How to set up the E2E test environment?
-
-### Prerequisites
-
-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 Yarn
-
-### Initial Setup
-
-1. Install Python deps for the shared tests project:
-```bash
-cd tests
-uv sync
-```
-
-2. Install Node deps and Playwright browsers:
-```bash
-cd e2e
-yarn install
-yarn install:browsers   # one-time Playwright browser install
-```
-
-### Starting the Test Environment
-
-To spin up the backend stack (SigNoz, ClickHouse, Postgres, Zookeeper, Zeus mock, gateway mock, seeder, migrator-with-web) and keep it running:
-
-```bash
-cd tests
-uv run pytest --basetemp=./tmp/ -vv --reuse --with-web \
-  e2e/bootstrap/setup.py::test_setup
-```
-
-This command will:
-- Bring up all containers via pytest fixtures
-- Register the admin user (`admin@integration.test` / `password123Z$`)
-- Apply the enterprise license (via a WireMock stub of Zeus) and dismiss the org-onboarding prompt so specs can navigate directly to feature pages
-- Start the HTTP seeder container (`tests/seeder/` — exposing `/telemetry/{traces,logs,metrics}` POST + DELETE)
-- Write backend coordinates to `tests/e2e/.env.local` (loaded by `playwright.config.ts` via dotenv)
-- Keep containers running via the `--reuse` flag
-
-The `--with-web` flag builds the frontend into the SigNoz container — required for E2E. The build takes ~4 mins on a cold start.
-
-### Stopping the Test Environment
-
-When you're done writing E2E tests, clean up the environment:
-
-```bash
-cd tests
-uv run pytest --basetemp=./tmp/ -vv --teardown \
-  e2e/bootstrap/setup.py::test_teardown
-```
-
-## Understanding the E2E Test Framework
-
-Playwright drives a real browser (Chromium / Firefox / WebKit) against the running SigNoz frontend. The backend is brought up by the same pytest fixture graph integration tests use, so both suites share one source of truth for container lifecycle, license seeding, and test-user accounts.
-
-- **Why Playwright?** First-class TypeScript support, network interception, automatic wait-for-visibility, built-in trace viewer that captures every request/response the UI triggers — so specs rarely need separate API probes alongside UI clicks.
-- **Why pytest for lifecycle?** The integration suite already owns container bring-up. Reusing it keeps the E2E stack exactly in sync with the integration stack and avoids a parallel lifecycle framework.
-- **Why a separate seeder container?** Per-spec telemetry seeding (traces / logs / metrics) needs a thin HTTP wrapper around the ClickHouse insert helpers so a browser spec can POST from inside the test. The seeder lives at `tests/seeder/`, is built from `tests/Dockerfile.seeder`, and reuses the same `fixtures/{traces,logs,metrics}.py` as integration tests.
-
-```
-tests/
-├── fixtures/                  # shared with integration (see integration.md)
-├── integration/               # pytest integration suite
-├── seeder/                    # standalone HTTP seeder container
-│   ├── __init__.py
-│   ├── Dockerfile
-│   └── server.py              # FastAPI app wrapping fixtures.{traces,logs,metrics}
-└── e2e/
-    ├── package.json
-    ├── playwright.config.ts   # loads .env + .env.local via dotenv
-    ├── .env.example           # staging-mode template
-    ├── .env.local             # generated by bootstrap/setup.py (gitignored)
-    ├── bootstrap/
-    │   └── setup.py           # test_setup / test_teardown — pytest lifecycle
-    ├── fixtures/
-    │   └── auth.ts            # authedPage Playwright fixture + per-worker storageState cache
-    ├── tests/                 # Playwright .spec.ts files, one dir per feature area
-    │   └── alerts/
-    │       └── alerts.spec.ts
-    └── artifacts/             # per-run output (gitignored)
-        ├── html/              # HTML reporter output
-        ├── json/              # JSON reporter output
-        └── results/           # per-test traces / screenshots / videos on failure
-```
-
-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. 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 creates what it needs and cleans up in `try/finally`. No global pre-seeding fixtures.
-
-## How to write an E2E test?
-
-Create a new file `tests/e2e/tests/alerts/smoke.spec.ts`:
-
-```typescript
-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();
-  await expect(page.getByRole('tab', { name: /configuration/i })).toBeVisible();
-});
-```
-
-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`):
-
-```bash
-cd tests/e2e
-npx playwright test tests/alerts/smoke.spec.ts --project=chromium
-```
-
-Here's a more comprehensive example that exercises a CRUD flow via the UI:
-
-```typescript
-import { test, expect } from '../../fixtures/auth';
-
-test.describe.configure({ mode: 'serial' });
-
-test('TC-02 alerts list — create, toggle, delete', async ({ authedPage: page }) => {
-  await page.goto('/alerts?tab=AlertRules');
-  const name = 'smoke-rule';
-
-  // 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 ...
-
-  // 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);
-});
-```
-
-### Locator priority
-
-1. `getByRole('button', { name: 'Submit' })`
-2. `getByLabel('Email')`
-3. `getByPlaceholder('...')`
-4. `getByText('...')`
-5. `getByTestId('...')`
-6. `locator('.ant-select')` — last resort (Ant Design dropdowns often have no semantic alternative)
-
-## How to run E2E tests?
-
-### Running All Tests
-
-With the stack already up, from `tests/e2e/`:
-
-```bash
-yarn test                 # headless, all projects
-```
-
-### Running Specific Projects
-
-```bash
-yarn test:chromium        # chromium only
-yarn test:firefox
-yarn test:webkit
-```
-
-### Running Specific Tests
-
-```bash
-cd tests/e2e
-
-# Single feature dir
-npx playwright test tests/alerts/ --project=chromium
-
-# Single file
-npx playwright test tests/alerts/alerts.spec.ts --project=chromium
-
-# Single test by title grep
-npx playwright test --project=chromium -g "TC-01"
-```
-
-### Iterative modes
-
-```bash
-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
-
-Point `SIGNOZ_E2E_BASE_URL` at a remote env via `.env` — no local backend bring-up, no `.env.local` generated, Playwright hits the URL directly:
-
-```bash
-cd tests/e2e
-cp .env.example .env      # fill SIGNOZ_E2E_USERNAME / PASSWORD
-yarn test:staging
-```
-
-## How to configure different options for E2E tests?
-
-### Environment variables
-
-| Variable | Description |
-|---|---|
-| `SIGNOZ_E2E_BASE_URL` | Base URL the browser targets. Written by `bootstrap/setup.py` for local mode; set manually for staging. |
-| `SIGNOZ_E2E_USERNAME` | Admin email. Bootstrap writes `admin@integration.test`. |
-| `SIGNOZ_E2E_PASSWORD` | Admin password. Bootstrap writes the integration-test default. |
-| `SIGNOZ_E2E_SEEDER_URL` | Seeder HTTP base URL — hit by specs that need per-test telemetry. |
-
-Loading order in `playwright.config.ts`: `.env` first (user-provided, staging), then `.env.local` with `override: true` (bootstrap-generated, local mode). Anything already set in `process.env` at yarn-test time wins because dotenv doesn't touch vars that are already present.
-
-### Playwright options
-
-The full `playwright.config.ts` is the source of truth. Common things to tweak:
-
-- `projects` — Chromium / Firefox / WebKit are enabled by default. Disable to speed up iteration.
-- `retries` — `2` on CI (`process.env.CI`), `0` locally.
-- `fullyParallel: true` — files run in parallel by worker; within a file, use `test.describe.configure({ mode: 'serial' })` if tests share list pages / mutate shared state.
-- `trace: 'on-first-retry'`, `screenshot: 'only-on-failure'`, `video: 'retain-on-failure'` — default diagnostic artifacts land in `artifacts/results/<test>/`.
-
-### Pytest options (bootstrap side)
-
-The same pytest flags integration tests expose work here, since E2E reuses the shared fixture graph:
-
-- `--reuse` — keep containers warm between runs (required for all iteration).
-- `--teardown` — tear everything down.
-- `--with-web` — build the frontend into the SigNoz container. **Required for E2E**; integration tests don't need it.
-- `--sqlstore-provider`, `--postgres-version`, `--clickhouse-version`, etc. — see `docs/contributing/integration.md`.
-
-## What should I remember?
-
-- **Always use the `--reuse` flag** when setting up the E2E stack. `--with-web` adds a ~4 min frontend build; you only want to pay that once.
-- **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. 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.
-- **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.
-- **Artifacts go to `tests/e2e/artifacts/`** — HTML report at `artifacts/html`, traces at `artifacts/results/<test>/`. All gitignored; archive the dir in CI.

docs/contributing/tests/integration.md

@@ -1,251 +0,0 @@
-# Integration Tests
-
-SigNoz uses integration tests to verify that different components work together correctly in a real environment. These tests run against actual services (ClickHouse, PostgreSQL, SigNoz, Zeus mock, Keycloak, etc.) spun up as containers, so suites exercise the same code paths production does.
-
-## How to set up the integration test environment?
-
-### Prerequisites
-
-Before running integration tests, ensure you have the following installed:
-
-- Python 3.13+
-- [uv](https://docs.astral.sh/uv/getting-started/installation/)
-- Docker (for containerized services)
-
-### Initial Setup
-
-1. Navigate to the shared tests project:
-```bash
-cd tests
-```
-
-2. Install dependencies using uv:
-```bash
-uv sync
-```
-
-> **_NOTE:_** the build backend could throw an error while installing `psycopg2`, please see https://www.psycopg.org/docs/install.html#build-prerequisites
-
-### Starting the Test Environment
-
-To spin up all the containers necessary for writing integration tests and keep them running:
-
-```bash
-make py-test-setup
-```
-
-Under the hood this runs, from `tests/`:
-
-```bash
-uv run pytest --basetemp=./tmp/ -vv --reuse integration/bootstrap/setup.py::test_setup
-```
-
-This command will:
-- Start all required services (ClickHouse, PostgreSQL, Zookeeper, SigNoz, Zeus mock, gateway mock)
-- Register an admin user
-- Keep containers running via the `--reuse` flag
-
-### Stopping the Test Environment
-
-When you're done writing integration tests, clean up the environment:
-
-```bash
-make py-test-teardown
-```
-
-Which runs:
-
-```bash
-uv run pytest --basetemp=./tmp/ -vv --teardown integration/bootstrap/setup.py::test_teardown
-```
-
-This destroys the running integration test setup and cleans up resources.
-
-## Understanding the Integration Test Framework
-
-Python and pytest form the foundation of the integration testing framework. Testcontainers are used to spin up disposable integration environments. WireMock is used to spin up **test doubles** of external services (Zeus cloud API, gateway, etc.).
-
-- **Why Python/pytest?** It's expressive, low-boilerplate, and has powerful fixture capabilities that make integration testing straightforward. Extensive libraries for HTTP requests, JSON handling, and data analysis (numpy) make it easier to test APIs and verify data.
-- **Why testcontainers?** They let us spin up isolated dependencies that match our production environment without complex setup.
-- **Why WireMock?** Well maintained, documented, and extensible.
-
-```
-tests/
-├── conftest.py              # pytest_plugins registration
-├── pyproject.toml
-├── uv.lock
-├── fixtures/                # shared fixture library (flat package)
-│   ├── __init__.py
-│   ├── auth.py              # admin/editor/viewer users, tokens, license
-│   ├── clickhouse.py
-│   ├── http.py              # WireMock helpers
-│   ├── keycloak.py          # IdP container
-│   ├── postgres.py
-│   ├── signoz.py            # SigNoz-backend container
-│   ├── sql.py
-│   ├── types.py
-│   └── ...                  # logs, metrics, traces, alerts, dashboards, ...
-├── integration/
-│   ├── bootstrap/
-│   │   └── setup.py         # test_setup / test_teardown
-│   ├── testdata/            # JSON / JSONL / YAML inputs per suite
-│   └── tests/               # one directory per feature area
-│       ├── alerts/
-│       │   ├── 01_*.py      # numbered suite files
-│       │   └── conftest.py  # optional suite-local fixtures
-│       ├── auditquerier/
-│       ├── cloudintegrations/
-│       ├── dashboard/
-│       ├── passwordauthn/
-│       ├── querier/
-│       └── ...
-└── e2e/                     # Playwright suite (see docs/contributing/e2e.md)
-```
-
-Each test suite follows these principles:
-
-1. **Organization**: Suites live under `tests/integration/tests/` in self-contained packages. Shared fixtures live in the top-level `tests/fixtures/` package so the e2e tree can reuse them.
-2. **Execution Order**: Files are prefixed with two-digit numbers (`01_`, `02_`, `03_`) to ensure sequential execution when tests depend on ordering.
-3. **Time Constraints**: Each suite should complete in under 10 minutes (setup takes ~4 mins).
-
-### Test Suite Design
-
-Test suites should target functional domains or subsystems within SigNoz. When designing a test suite, consider these principles:
-
-- **Functional Cohesion**: Group tests around a specific capability or service boundary
-- **Data Flow**: Follow the path of data through related components
-- **Change Patterns**: Components frequently modified together should be tested together
-
-The exact boundaries for suites are intentionally flexible, allowing contributors to define logical groupings based on their domain knowledge. Current suites cover alerts, audit querier, callback authn, cloud integrations, dashboards, ingestion keys, logs pipelines, password authn, preferences, querier, raw export data, roles, root user, service accounts, and TTL.
-
-## How to write an integration test?
-
-Now start writing an integration test. Create a new file `tests/integration/tests/bootstrap/01_version.py` and paste the following:
-
-```python
-import requests
-
-from fixtures import types
-from fixtures.logger import setup_logger
-
-logger = setup_logger(__name__)
-
-
-def test_version(signoz: types.SigNoz) -> None:
-    response = requests.get(
-        signoz.self.host_configs["8080"].get("/api/v1/version"),
-        timeout=2,
-    )
-    logger.info(response)
-```
-
-We have written a simple test which calls the `version` endpoint of the SigNoz backend. **To run just this function, run the following command:**
-
-```bash
-cd tests
-uv run pytest --basetemp=./tmp/ -vv --reuse \
-  integration/tests/bootstrap/01_version.py::test_version
-```
-
-> **Note:** The `--reuse` flag is used to reuse the environment if it is already running. Always use this flag when writing and running integration tests. Without it the environment is destroyed and recreated every run.
-
-Here's another example of how to write a more comprehensive integration test:
-
-```python
-from http import HTTPStatus
-import requests
-from fixtures import types
-from fixtures.logger import setup_logger
-
-logger = setup_logger(__name__)
-
-
-def test_user_registration(signoz: types.SigNoz) -> None:
-    """Test user registration functionality."""
-    response = requests.post(
-        signoz.self.host_configs["8080"].get("/api/v1/register"),
-        json={
-            "name": "testuser",
-            "orgId": "",
-            "orgName": "test.org",
-            "email": "test@example.com",
-            "password": "password123Z$",
-        },
-        timeout=2,
-    )
-
-    assert response.status_code == HTTPStatus.OK
-    assert response.json()["setupCompleted"] is True
-```
-
-Test inputs (JSON fixtures, expected payloads) go under `tests/integration/testdata/<suite>/` and are loaded via `fixtures.fs.get_testdata_file_path`.
-
-## How to run integration tests?
-
-### Running All Tests
-
-```bash
-make py-test
-```
-
-Which runs:
-
-```bash
-uv run pytest --basetemp=./tmp/ -vv integration/tests/
-```
-
-### Running Specific Test Categories
-
-```bash
-cd tests
-uv run pytest --basetemp=./tmp/ -vv --reuse integration/tests/<suite>/
-
-# Run querier tests
-uv run pytest --basetemp=./tmp/ -vv --reuse integration/tests/querier/
-# Run passwordauthn tests
-uv run pytest --basetemp=./tmp/ -vv --reuse integration/tests/passwordauthn/
-```
-
-### Running Individual Tests
-
-```bash
-uv run pytest --basetemp=./tmp/ -vv --reuse \
-  integration/tests/<suite>/<file>.py::test_name
-
-# Run test_register in 01_register.py in the passwordauthn suite
-uv run pytest --basetemp=./tmp/ -vv --reuse \
-  integration/tests/passwordauthn/01_register.py::test_register
-```
-
-## How to configure different options for integration tests?
-
-Tests can be configured using pytest options:
-
-- `--sqlstore-provider` — Choose the SQL store provider (default: `postgres`)
-- `--sqlite-mode` — SQLite journal mode: `delete` or `wal` (default: `delete`). Only relevant when `--sqlstore-provider=sqlite`.
-- `--postgres-version` — PostgreSQL version (default: `15`)
-- `--clickhouse-version` — ClickHouse version (default: `25.5.6`)
-- `--zookeeper-version` — Zookeeper version (default: `3.7.1`)
-- `--schema-migrator-version` — SigNoz schema migrator version (default: `v0.144.2`)
-
-Example:
-
-```bash
-uv run pytest --basetemp=./tmp/ -vv --reuse \
-  --sqlstore-provider=postgres --postgres-version=14 \
-  integration/tests/passwordauthn/
-```
-
-## What should I remember?
-
-- **Always use the `--reuse` flag** when setting up the environment or running tests to keep containers warm. Without it every run rebuilds the stack (~4 mins).
-- **Use the `--teardown` flag** only when cleaning up — mixing `--teardown` with `--reuse` is a contradiction.
-- **Do not pre-emptively teardown before setup.** If the stack is partially up, `--reuse` picks up from wherever it is. `make py-test-teardown` then `make py-test-setup` wastes minutes.
-- **Follow the naming convention** with two-digit numeric prefixes (`01_`, `02_`) for ordered test execution within a suite.
-- **Use proper timeouts** in HTTP requests to avoid hanging tests (`timeout=5` is typical).
-- **Clean up test data** between tests in the same suite to avoid interference — or rely on a fresh SigNoz container if you need full isolation.
-- **Use descriptive test names** that clearly indicate what is being tested.
-- **Leverage fixtures** for common setup. The shared fixture package is at `tests/fixtures/` — reuse before adding new ones.
-- **Test both success and failure scenarios** (4xx / 5xx paths) to ensure robust functionality.
-- **Run `make py-fmt` and `make py-lint` before committing** Python changes — black + isort + autoflake + pylint.
-- **`--sqlite-mode=wal` does not work on macOS.** The integration test environment runs SigNoz inside a Linux container with the SQLite database file mounted from the macOS host. WAL mode requires shared memory between connections, and connections crossing the VM boundary (macOS host ↔ Linux container) cannot share the WAL index, resulting in `SQLITE_IOERR_SHORT_READ`. WAL mode is tested in CI on Linux only.

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

@@ -1,106 +0,0 @@
-/**
- * ! Do not edit manually
- * * The file has been auto-generated using Orval for SigNoz
- * * regenerate with 'yarn generate:api'
- * SigNoz
- */
-import { useMutation } from 'react-query';
-import type {
-	MutationFunction,
-	UseMutationOptions,
-	UseMutationResult,
-} from 'react-query';
-
-import type {
-	InframonitoringtypesPostableHostsDTO,
-	ListHosts200,
-	RenderErrorResponseDTO,
-} from '../sigNoz.schemas';
-
-import { GeneratedAPIInstance } from '../../../generatedAPIInstance';
-import type { ErrorType, BodyType } from '../../../generatedAPIInstance';
-
-/**
- * Returns a paginated list of hosts with key infrastructure metrics: CPU usage (%), memory usage (%), I/O wait (%), disk usage (%), and 15-minute load average. Each host includes its current status (active/inactive based on metrics reported in the last 10 minutes) and metadata attributes (e.g., os.type). Supports filtering via a filter expression, filtering by host status, custom groupBy to aggregate hosts by any attribute, ordering by any of the five metrics, and pagination via offset/limit. The response type is 'list' for the default host.name grouping or 'grouped_list' for custom groupBy keys. Also reports missing required metrics and whether the requested time range falls before the data retention boundary.
- * @summary List Hosts for Infra Monitoring
- */
-export const listHosts = (
-	inframonitoringtypesPostableHostsDTO: BodyType<InframonitoringtypesPostableHostsDTO>,
-	signal?: AbortSignal,
-) => {
-	return GeneratedAPIInstance<ListHosts200>({
-		url: `/api/v2/infra_monitoring/hosts`,
-		method: 'POST',
-		headers: { 'Content-Type': 'application/json' },
-		data: inframonitoringtypesPostableHostsDTO,
-		signal,
-	});
-};
-
-export const getListHostsMutationOptions = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown,
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof listHosts>>,
-		TError,
-		{ data: BodyType<InframonitoringtypesPostableHostsDTO> },
-		TContext
-	>;
-}): UseMutationOptions<
-	Awaited<ReturnType<typeof listHosts>>,
-	TError,
-	{ data: BodyType<InframonitoringtypesPostableHostsDTO> },
-	TContext
-> => {
-	const mutationKey = ['listHosts'];
-	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 listHosts>>,
-		{ data: BodyType<InframonitoringtypesPostableHostsDTO> }
-	> = (props) => {
-		const { data } = props ?? {};
-
-		return listHosts(data);
-	};
-
-	return { mutationFn, ...mutationOptions };
-};
-
-export type ListHostsMutationResult = NonNullable<
-	Awaited<ReturnType<typeof listHosts>>
->;
-export type ListHostsMutationBody =
-	BodyType<InframonitoringtypesPostableHostsDTO>;
-export type ListHostsMutationError = ErrorType<RenderErrorResponseDTO>;
-
-/**
- * @summary List Hosts for Infra Monitoring
- */
-export const useListHosts = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown,
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof listHosts>>,
-		TError,
-		{ data: BodyType<InframonitoringtypesPostableHostsDTO> },
-		TContext
-	>;
-}): UseMutationResult<
-	Awaited<ReturnType<typeof listHosts>>,
-	TError,
-	{ data: BodyType<InframonitoringtypesPostableHostsDTO> },
-	TContext
-> => {
-	const mutationOptions = getListHostsMutationOptions(options);
-
-	return useMutation(mutationOptions);
-};

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

@@ -3053,131 +3053,6 @@ export interface GlobaltypesTokenizerConfigDTO {
 	enabled?: boolean;
 }
 
-export interface InframonitoringtypesHostFilterDTO {
-	/**
-	 * @type string
-	 */
-	expression?: string;
-	filterByStatus?: InframonitoringtypesHostStatusDTO;
-}
-
-/**
- * @nullable
- */
-export type InframonitoringtypesHostRecordDTOMeta = {
-	[key: string]: unknown;
-} | null;
-
-export interface InframonitoringtypesHostRecordDTO {
-	/**
-	 * @type integer
-	 */
-	activeHostCount: number;
-	/**
-	 * @type number
-	 * @format double
-	 */
-	cpu: number;
-	/**
-	 * @type number
-	 * @format double
-	 */
-	diskUsage: number;
-	/**
-	 * @type string
-	 */
-	hostName: string;
-	/**
-	 * @type integer
-	 */
-	inactiveHostCount: number;
-	/**
-	 * @type number
-	 * @format double
-	 */
-	load15: number;
-	/**
-	 * @type number
-	 * @format double
-	 */
-	memory: number;
-	/**
-	 * @type object
-	 * @nullable true
-	 */
-	meta: InframonitoringtypesHostRecordDTOMeta;
-	status: InframonitoringtypesHostStatusDTO;
-	/**
-	 * @type number
-	 * @format double
-	 */
-	wait: number;
-}
-
-export enum InframonitoringtypesHostStatusDTO {
-	active = 'active',
-	inactive = 'inactive',
-	'' = '',
-}
-export interface InframonitoringtypesHostsDTO {
-	/**
-	 * @type boolean
-	 */
-	endTimeBeforeRetention: boolean;
-	/**
-	 * @type array
-	 * @nullable true
-	 */
-	records: InframonitoringtypesHostRecordDTO[] | null;
-	requiredMetricsCheck: InframonitoringtypesRequiredMetricsCheckDTO;
-	/**
-	 * @type integer
-	 */
-	total: number;
-	type: InframonitoringtypesResponseTypeDTO;
-	warning?: Querybuildertypesv5QueryWarnDataDTO;
-}
-
-export interface InframonitoringtypesPostableHostsDTO {
-	/**
-	 * @type integer
-	 * @format int64
-	 */
-	end: number;
-	filter?: InframonitoringtypesHostFilterDTO;
-	/**
-	 * @type array
-	 * @nullable true
-	 */
-	groupBy?: Querybuildertypesv5GroupByKeyDTO[] | null;
-	/**
-	 * @type integer
-	 */
-	limit: number;
-	/**
-	 * @type integer
-	 */
-	offset?: number;
-	orderBy?: Querybuildertypesv5OrderByDTO;
-	/**
-	 * @type integer
-	 * @format int64
-	 */
-	start: number;
-}
-
-export interface InframonitoringtypesRequiredMetricsCheckDTO {
-	/**
-	 * @type array
-	 * @nullable true
-	 */
-	missingMetrics: string[] | null;
-}
-
-export enum InframonitoringtypesResponseTypeDTO {
-	list = 'list',
-	grouped_list = 'grouped_list',
-}
 export interface MetricsexplorertypesInspectMetricsRequestDTO {
 	/**
 	 * @type integer
@@ -6763,14 +6638,6 @@ export type Healthz503 = {
 	status: string;
 };
 
-export type ListHosts200 = {
-	data: InframonitoringtypesHostsDTO;
-	/**
-	 * @type string
-	 */
-	status: string;
-};
-
 export type Livez200 = {
 	data: FactoryResponseDTO;
 	/**

frontend/src/api/thirdPartyApis/listOverview.ts

@@ -6,20 +6,15 @@ import { PayloadProps, Props } from 'types/api/thirdPartyApis/listOverview';
 
 const listOverview = async (
 	props: Props,
-	signal?: AbortSignal,
 ): Promise<SuccessResponseV2<PayloadProps>> => {
 	const { start, end, show_ip: showIp, filter } = props;
 	try {
-		const response = await axios.post(
-			`/third-party-apis/overview/list`,
-			{
-				start,
-				end,
-				show_ip: showIp,
-				filter,
-			},
-			{ signal },
-		);
+		const response = await axios.post(`/third-party-apis/overview/list`, {
+			start,
+			end,
+			show_ip: showIp,
+			filter,
+		});
 
 		return {
 			httpStatusCode: response.status,

frontend/src/components/QueryCancelledPlaceholder/QueryCancelledPlaceholder.module.scss

@@ -1,26 +0,0 @@
-.placeholder {
-	display: flex;
-	flex-direction: column;
-	align-items: center;
-	justify-content: center;
-	height: 100%;
-	min-height: 240px;
-	width: 100%;
-	padding: 24px;
-	gap: 12px;
-}
-
-.emoji {
-	width: 48px;
-	height: 48px;
-}
-
-.text {
-	text-align: center;
-	font-size: 14px;
-	color: var(--muted-foreground);
-}
-
-.subText {
-	color: var(--foreground);
-}

frontend/src/components/QueryCancelledPlaceholder/QueryCancelledPlaceholder.tsx

@@ -1,31 +0,0 @@
-import { Typography } from 'antd';
-import eyesEmojiUrl from 'assets/Images/eyesEmoji.svg';
-
-import styles from './QueryCancelledPlaceholder.module.scss';
-
-interface QueryCancelledPlaceholderProps {
-	subText?: string;
-}
-
-function QueryCancelledPlaceholder({
-	subText,
-}: QueryCancelledPlaceholderProps): JSX.Element {
-	return (
-		<div className={styles.placeholder}>
-			<img className={styles.emoji} src={eyesEmojiUrl} alt="eyes emoji" />
-			<Typography className={styles.text}>
-				Query cancelled.
-				<span className={styles.subText}>
-					{' '}
-					{subText || 'Click "Run Query" to load data.'}
-				</span>
-			</Typography>
-		</div>
-	);
-}
-
-QueryCancelledPlaceholder.defaultProps = {
-	subText: undefined,
-};
-
-export default QueryCancelledPlaceholder;

frontend/src/components/QueryCancelledPlaceholder/index.ts

@@ -1 +0,0 @@
-export { default } from './QueryCancelledPlaceholder';

frontend/src/constants/reactQuery.ts

@@ -1,8 +0,0 @@
-/**
- * Maximum number of retries for a failed react-query request before giving up.
- * Used as the upper bound in the default `retry` predicate:
- *   `return failureCount < MAX_QUERY_RETRIES;`
- *
- * This retries up to 3 times (4 attempts total including the initial request).
- */
-export const MAX_QUERY_RETRIES = 3;

frontend/src/constants/reactQueryKeys.ts

@@ -25,8 +25,7 @@ export const REACT_QUERY_KEY = {
 	ALERT_RULE_TIMELINE_GRAPH: 'ALERT_RULE_TIMELINE_GRAPH',
 	GET_CONSUMER_LAG_DETAILS: 'GET_CONSUMER_LAG_DETAILS',
 	TOGGLE_ALERT_STATE: 'TOGGLE_ALERT_STATE',
-	GET_ALL_ALERTS: 'GET_ALL_ALERTS',
-	ALERT_RULES_CHART_PREVIEW: 'ALERT_RULES_CHART_PREVIEW',
+	GET_ALL_ALLERTS: 'GET_ALL_ALLERTS',
 	REMOVE_ALERT_RULE: 'REMOVE_ALERT_RULE',
 	DUPLICATE_ALERT_RULE: 'DUPLICATE_ALERT_RULE',
 	GET_HOST_LIST: 'GET_HOST_LIST',

frontend/src/container/AllError/index.tsx

@@ -21,7 +21,6 @@ import { FilterConfirmProps } from 'antd/lib/table/interface';
 import logEvent from 'api/common/logEvent';
 import getAll from 'api/errors/getAll';
 import getErrorCounts from 'api/errors/getErrorCounts';
-import QueryCancelledPlaceholder from 'components/QueryCancelledPlaceholder';
 import { ResizeTable } from 'components/ResizeTable';
 import { DATE_TIME_FORMATS } from 'constants/dateTimeFormats';
 import ROUTES from 'constants/routes';
@@ -37,7 +36,6 @@ import useUrlQuery from 'hooks/useUrlQuery';
 import createQueryParams from 'lib/createQueryParams';
 import history from 'lib/history';
 import { isUndefined } from 'lodash-es';
-import { useAllErrorsQueryState } from 'pages/AllErrors/QueryStateContext';
 import { useTimezone } from 'providers/Timezone';
 import { AppState } from 'store/reducers';
 import { ErrorResponse, SuccessResponse } from 'types/api';
@@ -123,13 +121,7 @@ function AllErrors(): JSX.Element {
 	const { queries } = useResourceAttribute();
 	const compositeData = useGetCompositeQueryParam();
 
-	const setIsFetching = useAllErrorsQueryState((s) => s.setIsFetching);
-	const isCancelled = useAllErrorsQueryState((s) => s.isCancelled);
-
-	const [
-		{ isLoading, isFetching: isErrorsFetching, data },
-		errorCountResponse,
-	] = useQueries([
+	const [{ isLoading, data }, errorCountResponse] = useQueries([
 		{
 			queryKey: ['getAllErrors', updatedPath, maxTime, minTime, compositeData],
 			queryFn: (): Promise<SuccessResponse<PayloadProps> | ErrorResponse> =>
@@ -170,12 +162,6 @@ function AllErrors(): JSX.Element {
 			enabled: !loading,
 		},
 	]);
-
-	const isFetching = isErrorsFetching || errorCountResponse.isFetching;
-	useEffect(() => {
-		setIsFetching(isFetching);
-	}, [isFetching, setIsFetching]);
-
 	const { notifications } = useNotifications();
 
 	useEffect(() => {
@@ -487,12 +473,6 @@ function AllErrors(): JSX.Element {
 		// eslint-disable-next-line react-hooks/exhaustive-deps
 	}, [errorCountResponse.data?.payload]);
 
-	if (isCancelled && !data?.payload?.length) {
-		return (
-			<QueryCancelledPlaceholder subText='Click "Run Query" to load exceptions.' />
-		);
-	}
-
 	return (
 		<ResizeTable
 			columns={columns}

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

@@ -1,16 +1,12 @@
 import { useCallback, useEffect, useMemo, useState } from 'react';
-import { useQueryClient } from 'react-query';
 // eslint-disable-next-line no-restricted-imports
 import { useSelector } from 'react-redux';
 import { LoadingOutlined } from '@ant-design/icons';
 import { Spin, Table } from 'antd';
 import logEvent from 'api/common/logEvent';
-import emptyStateUrl from 'assets/Icons/emptyState.svg';
 import cx from 'classnames';
 import QuerySearch from 'components/QueryBuilderV2/QueryV2/QuerySearch/QuerySearch';
-import QueryCancelledPlaceholder from 'components/QueryCancelledPlaceholder';
 import { initialQueriesMap } from 'constants/queryBuilder';
-import { REACT_QUERY_KEY } from 'constants/reactQueryKeys';
 import RightToolbarActions from 'container/QueryBuilder/components/ToolbarActions/RightToolbarActions';
 import Toolbar from 'container/Toolbar/Toolbar';
 import { useGetCompositeQueryParam } from 'hooks/queryBuilder/useGetCompositeQueryParam';
@@ -27,6 +23,8 @@ import { DataSource } from 'types/common/queryBuilder';
 import { GlobalReducer } from 'types/reducer/globalTime';
 import DOCLINKS from 'utils/docLinks';
 
+import emptyStateUrl from '@/assets/Icons/emptyState.svg';
+
 import { ApiMonitoringHardcodedAttributeKeys } from '../../constants';
 import { DEFAULT_PARAMS, useApiMonitoringParams } from '../../queryParams';
 import { columnsConfig, formatDataForTable } from '../../utils';
@@ -42,7 +40,6 @@ function DomainList(): JSX.Element {
 		(state) => state.globalTime,
 	);
 
-	const queryClient = useQueryClient();
 	const { currentQuery, handleRunQuery } = useQueryBuilder();
 	const query = useMemo(() => currentQuery?.builder?.queryData[0] || null, [
 		currentQuery,
@@ -56,19 +53,6 @@ function DomainList(): JSX.Element {
 
 	const compositeData = useGetCompositeQueryParam();
 
-	const [isCancelled, setIsCancelled] = useState(false);
-
-	const handleCancelQuery = useCallback(() => {
-		queryClient.cancelQueries([REACT_QUERY_KEY.GET_DOMAINS_LIST]);
-		setIsCancelled(true);
-	}, [queryClient]);
-
-	const handleStageAndRunQuery = useCallback(() => {
-		setIsCancelled(false);
-		queryClient.invalidateQueries([REACT_QUERY_KEY.GET_DOMAINS_LIST]);
-		handleRunQuery();
-	}, [queryClient, handleRunQuery]);
-
 	const { data, isLoading, isFetching } = useListOverview({
 		start: minTime,
 		end: maxTime,
@@ -121,13 +105,6 @@ function DomainList(): JSX.Element {
 		[data],
 	);
 
-	// Auto-reset cancelled state when a new fetch starts
-	useEffect(() => {
-		if (isFetching) {
-			setIsCancelled(false);
-		}
-	}, [isFetching]);
-
 	// Open drawer if selectedDomain is set in URL
 	useEffect(() => {
 		if (selectedDomain && formattedDataForTable?.length > 0) {
@@ -142,13 +119,7 @@ function DomainList(): JSX.Element {
 		<section className={cx('api-module-right-section')}>
 			<Toolbar
 				showAutoRefresh={false}
-				rightActions={
-					<RightToolbarActions
-						onStageRunQuery={handleStageAndRunQuery}
-						isLoadingQueries={isFetching}
-						handleCancelQuery={handleCancelQuery}
-					/>
-				}
+				rightActions={<RightToolbarActions onStageRunQuery={handleRunQuery} />}
 			/>
 			<div className={cx('api-monitoring-list-header')}>
 				<QuerySearch
@@ -159,44 +130,38 @@ function DomainList(): JSX.Element {
 					hardcodedAttributeKeys={ApiMonitoringHardcodedAttributeKeys}
 				/>
 			</div>
-			{isCancelled && formattedDataForTable.length === 0 && (
-				<QueryCancelledPlaceholder subText='Click "Run Query" to load API monitoring data.' />
-			)}
-			{!isCancelled &&
-				!isFetching &&
-				!isLoading &&
-				formattedDataForTable.length === 0 && (
-					<div className="no-filtered-domains-message-container">
-						<div className="no-filtered-domains-message-content">
-							<img
-								src={emptyStateUrl}
-								alt="thinking-emoji"
-								className="empty-state-svg"
-							/>
+			{!isFetching && !isLoading && formattedDataForTable.length === 0 && (
+				<div className="no-filtered-domains-message-container">
+					<div className="no-filtered-domains-message-content">
+						<img
+							src={emptyStateUrl}
+							alt="thinking-emoji"
+							className="empty-state-svg"
+						/>
 
-							<div className="no-filtered-domains-message">
-								<div className="no-domain-title">
-									No External API calls detected with applied filters.
-								</div>
-								<div className="no-domain-subtitle">
-									Ensure all HTTP client spans are being sent with kind as{' '}
-									<span className="attribute">Client</span> and url set in{' '}
-									<span className="attribute">url.full</span> or{' '}
-									<span className="attribute">http.url</span> attribute.
-								</div>
-								<a
-									href={DOCLINKS.EXTERNAL_API_MONITORING}
-									target="_blank"
-									rel="noreferrer"
-									className="external-api-doc-link"
-								>
-									Learn how External API monitoring works in SigNoz{' '}
-									<MoveUpRight size={14} />
-								</a>
+						<div className="no-filtered-domains-message">
+							<div className="no-domain-title">
+								No External API calls detected with applied filters.
 							</div>
+							<div className="no-domain-subtitle">
+								Ensure all HTTP client spans are being sent with kind as{' '}
+								<span className="attribute">Client</span> and url set in{' '}
+								<span className="attribute">url.full</span> or{' '}
+								<span className="attribute">http.url</span> attribute.
+							</div>
+							<a
+								href={DOCLINKS.EXTERNAL_API_MONITORING}
+								target="_blank"
+								rel="noreferrer"
+								className="external-api-doc-link"
+							>
+								Learn how External API monitoring works in SigNoz{' '}
+								<MoveUpRight size={14} />
+							</a>
 						</div>
 					</div>
-				)}
+				</div>
+			)}
 			{(isFetching || isLoading || formattedDataForTable.length > 0) && (
 				<Table
 					className="api-monitoring-domain-list-table"

frontend/src/container/CreateAlertV2/QuerySection/ChartPreview/ChartPreview.tsx

@@ -18,16 +18,9 @@ import { GlobalReducer } from 'types/reducer/globalTime';
 export interface ChartPreviewProps {
 	alertDef: AlertDef;
 	source?: YAxisSource;
-	isCancelled?: boolean;
-	onFetchingStateChange?: (isFetching: boolean) => void;
 }
 
-function ChartPreview({
-	alertDef,
-	source,
-	isCancelled = false,
-	onFetchingStateChange,
-}: ChartPreviewProps): JSX.Element {
+function ChartPreview({ alertDef, source }: ChartPreviewProps): JSX.Element {
 	const { currentQuery, panelType, stagedQuery } = useQueryBuilder();
 	const {
 		alertType,
@@ -95,8 +88,6 @@ function ChartPreview({
 			graphType={panelType || PANEL_TYPES.TIME_SERIES}
 			setQueryStatus={setQueryStatus}
 			additionalThresholds={thresholdState.thresholds}
-			isCancelled={isCancelled}
-			onFetchingStateChange={onFetchingStateChange}
 		/>
 	);
 
@@ -111,8 +102,6 @@ function ChartPreview({
 			graphType={panelType || PANEL_TYPES.TIME_SERIES}
 			setQueryStatus={setQueryStatus}
 			additionalThresholds={thresholdState.thresholds}
-			isCancelled={isCancelled}
-			onFetchingStateChange={onFetchingStateChange}
 		/>
 	);
 

frontend/src/container/CreateAlertV2/QuerySection/QuerySection.tsx

@@ -1,11 +1,9 @@
-import { useCallback, useEffect, useMemo, useState } from 'react';
-import { useQueryClient } from 'react-query';
+import { useCallback, useMemo } from 'react';
 import { Button } from 'antd';
 import classNames from 'classnames';
 import { YAxisSource } from 'components/YAxisUnitSelector/types';
 import { QueryParams } from 'constants/query';
 import { PANEL_TYPES } from 'constants/queryBuilder';
-import { REACT_QUERY_KEY } from 'constants/reactQueryKeys';
 import QuerySectionComponent from 'container/FormAlertRules/QuerySection';
 import { useQueryBuilder } from 'hooks/queryBuilder/useQueryBuilder';
 import { getMetricNameFromQueryData } from 'hooks/useGetYAxisUnit';
@@ -64,24 +62,7 @@ function QuerySection(): JSX.Element {
 		return currentQueryKey !== stagedQueryKey;
 	}, [currentQuery, alertType, thresholdState, stagedQuery]);
 
-	const queryClient = useQueryClient();
-	const [isLoadingQueries, setIsLoadingQueries] = useState(false);
-	const [isCancelled, setIsCancelled] = useState(false);
-
-	useEffect(() => {
-		if (isLoadingQueries) {
-			setIsCancelled(false);
-		}
-	}, [isLoadingQueries]);
-
-	const handleCancelQuery = useCallback(() => {
-		queryClient.cancelQueries([REACT_QUERY_KEY.ALERT_RULES_CHART_PREVIEW]);
-		setIsCancelled(true);
-	}, [queryClient]);
-
 	const runQueryHandler = useCallback(() => {
-		setIsCancelled(false);
-		queryClient.invalidateQueries([REACT_QUERY_KEY.ALERT_RULES_CHART_PREVIEW]);
 		// Reset the source param when the query is changed
 		// Then manually run the query
 		if (source === YAxisSource.DASHBOARDS && didQueryChange) {
@@ -95,7 +76,6 @@ function QuerySection(): JSX.Element {
 		currentQuery,
 		didQueryChange,
 		handleRunQuery,
-		queryClient,
 		redirectWithQueryBuilderData,
 		source,
 	]);
@@ -126,12 +106,7 @@ function QuerySection(): JSX.Element {
 	return (
 		<div className="query-section">
 			<Stepper stepNumber={1} label="Define the query" />
-			<ChartPreview
-				alertDef={alertDef}
-				source={source}
-				isCancelled={isCancelled}
-				onFetchingStateChange={setIsLoadingQueries}
-			/>
+			<ChartPreview alertDef={alertDef} source={source} />
 			<div className="query-section-tabs">
 				<div className="query-section-query-actions">
 					{tabs.map((tab) => (
@@ -155,8 +130,6 @@ function QuerySection(): JSX.Element {
 				setQueryCategory={onQueryCategoryChange}
 				alertType={alertType}
 				runQuery={runQueryHandler}
-				isLoadingQueries={isLoadingQueries}
-				handleCancelQuery={handleCancelQuery}
 				alertDef={alertDef}
 				panelType={PANEL_TYPES.TIME_SERIES}
 				key={currentQuery.queryType}

frontend/src/container/FormAlertRules/ChartPreview/index.tsx

@@ -4,14 +4,12 @@ import { useTranslation } from 'react-i18next';
 import { useDispatch, useSelector } from 'react-redux';
 import { useLocation } from 'react-router-dom';
 import ErrorInPlace from 'components/ErrorInPlace/ErrorInPlace';
-import QueryCancelledPlaceholder from 'components/QueryCancelledPlaceholder';
 import Spinner from 'components/Spinner';
 import WarningPopover from 'components/WarningPopover/WarningPopover';
 import { ENTITY_VERSION_V5 } from 'constants/app';
 import { FeatureKeys } from 'constants/features';
 import { QueryParams } from 'constants/query';
 import { initialQueriesMap, PANEL_TYPES } from 'constants/queryBuilder';
-import { REACT_QUERY_KEY } from 'constants/reactQueryKeys';
 import AnomalyAlertEvaluationView from 'container/AnomalyAlertEvaluationView';
 import { INITIAL_CRITICAL_THRESHOLD } from 'container/CreateAlertV2/context/constants';
 import { Threshold } from 'container/CreateAlertV2/context/types';
@@ -71,8 +69,6 @@ export interface ChartPreviewProps {
 	setQueryStatus?: (status: string) => void;
 	showSideLegend?: boolean;
 	additionalThresholds?: Threshold[];
-	isCancelled?: boolean;
-	onFetchingStateChange?: (isFetching: boolean) => void;
 }
 
 // eslint-disable-next-line sonarjs/cognitive-complexity
@@ -90,8 +86,6 @@ function ChartPreview({
 	setQueryStatus,
 	showSideLegend = false,
 	additionalThresholds,
-	isCancelled = false,
-	onFetchingStateChange,
 }: ChartPreviewProps): JSX.Element | null {
 	const { t } = useTranslation('alerts');
 	const dispatch = useDispatch();
@@ -191,7 +185,7 @@ function ChartPreview({
 		ENTITY_VERSION_V5,
 		{
 			queryKey: [
-				REACT_QUERY_KEY.ALERT_RULES_CHART_PREVIEW,
+				'chartPreview',
 				userQueryKey || JSON.stringify(query),
 				selectedInterval,
 				minTime,
@@ -199,14 +193,9 @@ function ChartPreview({
 				alertDef?.ruleType,
 			],
 			enabled: canQuery,
-			keepPreviousData: true,
 		},
 	);
 
-	useEffect(() => {
-		onFetchingStateChange?.(queryResponse.isFetching);
-	}, [queryResponse.isFetching, onFetchingStateChange]);
-
 	const graphRef = useRef<HTMLDivElement>(null);
 
 	useEffect((): void => {
@@ -345,16 +334,11 @@ function ChartPreview({
 
 	const chartData = getUPlotChartData(queryResponse?.data?.payload);
 
-	const hasResultData = !!queryResponse?.data?.payload?.data?.result?.length;
-
 	const isAnomalyDetectionAlert =
 		alertDef?.ruleType === AlertDetectionTypes.ANOMALY_DETECTION_ALERT;
 
 	const chartDataAvailable =
-		chartData &&
-		hasResultData &&
-		!queryResponse.isLoading &&
-		(!queryResponse.isError || isCancelled);
+		chartData && !queryResponse.isError && !queryResponse.isLoading;
 
 	const isAnomalyDetectionEnabled =
 		featureFlags?.find((flag) => flag.name === FeatureKeys.ANOMALY_DETECTION)
@@ -375,14 +359,10 @@ function ChartPreview({
 					{queryResponse.isLoading && (
 						<Spinner size="large" tip="Loading..." height="100%" />
 					)}
-					{(queryResponse?.isError || queryResponse?.error) && !isCancelled && (
+					{(queryResponse?.isError || queryResponse?.error) && (
 						<ErrorInPlace error={queryResponse.error as APIError} />
 					)}
 
-					{isCancelled && !queryResponse.isLoading && !hasResultData && (
-						<QueryCancelledPlaceholder subText='Click "Run Query" to load the chart preview.' />
-					)}
-
 					{chartDataAvailable && !isAnomalyDetectionAlert && (
 						<GridPanelSwitch
 							options={options}
@@ -423,8 +403,6 @@ ChartPreview.defaultProps = {
 	setQueryStatus: (): void => {},
 	showSideLegend: false,
 	additionalThresholds: undefined,
-	isCancelled: false,
-	onFetchingStateChange: undefined,
 };
 
 export default ChartPreview;

frontend/src/container/FormAlertRules/QuerySection.tsx

@@ -35,8 +35,6 @@ function QuerySection({
 	setQueryCategory,
 	alertType,
 	runQuery,
-	isLoadingQueries,
-	handleCancelQuery,
 	alertDef,
 	panelType,
 	ruleId,
@@ -228,8 +226,6 @@ function QuerySection({
 												queryType: queryCategory,
 											});
 										}}
-										handleCancelQuery={handleCancelQuery}
-										isLoadingQueries={isLoadingQueries}
 									/>
 								</span>
 							}
@@ -249,11 +245,7 @@ function QuerySection({
 							onChange={handleQueryCategoryChange}
 							tabBarExtraContent={
 								<span style={{ display: 'flex', gap: '1rem', alignItems: 'center' }}>
-									<RunQueryBtn
-										onStageRunQuery={runQuery}
-										handleCancelQuery={handleCancelQuery}
-										isLoadingQueries={isLoadingQueries}
-									/>
+									<RunQueryBtn onStageRunQuery={runQuery} />
 								</span>
 							}
 							items={items}
@@ -295,8 +287,6 @@ interface QuerySectionProps {
 	setQueryCategory: (n: EQueryType) => void;
 	alertType: AlertTypes;
 	runQuery: VoidFunction;
-	isLoadingQueries: boolean;
-	handleCancelQuery: () => void;
 	alertDef: AlertDef;
 	panelType: PANEL_TYPES;
 	ruleId: string;

frontend/src/container/FormAlertRules/index.tsx

@@ -136,19 +136,6 @@ function FormAlertRules({
 
 	// use query client
 	const ruleCache = useQueryClient();
-	const [isChartQueryCancelled, setIsChartQueryCancelled] = useState(false);
-	const [isLoadingAlertQuery, setIsLoadingAlertQuery] = useState(false);
-
-	useEffect(() => {
-		if (isLoadingAlertQuery) {
-			setIsChartQueryCancelled(false);
-		}
-	}, [isLoadingAlertQuery]);
-
-	const handleCancelAlertQuery = useCallback(() => {
-		ruleCache.cancelQueries(REACT_QUERY_KEY.ALERT_RULES_CHART_PREVIEW);
-		setIsChartQueryCancelled(true);
-	}, [ruleCache]);
 
 	const isNewRule = !ruleId || isEmpty(ruleId);
 
@@ -715,8 +702,6 @@ function FormAlertRules({
 			yAxisUnit={yAxisUnit || ''}
 			graphType={panelType || PANEL_TYPES.TIME_SERIES}
 			setQueryStatus={setQueryStatus}
-			isCancelled={isChartQueryCancelled}
-			onFetchingStateChange={setIsLoadingAlertQuery}
 		/>
 	);
 
@@ -735,8 +720,6 @@ function FormAlertRules({
 			yAxisUnit={yAxisUnit || ''}
 			graphType={panelType || PANEL_TYPES.TIME_SERIES}
 			setQueryStatus={setQueryStatus}
-			isCancelled={isChartQueryCancelled}
-			onFetchingStateChange={setIsLoadingAlertQuery}
 		/>
 	);
 
@@ -919,15 +902,7 @@ function FormAlertRules({
 							queryCategory={currentQuery.queryType}
 							setQueryCategory={onQueryCategoryChange}
 							alertType={alertType || AlertTypes.METRICS_BASED_ALERT}
-							runQuery={(): void => {
-								setIsChartQueryCancelled(false);
-								ruleCache.invalidateQueries([
-									REACT_QUERY_KEY.ALERT_RULES_CHART_PREVIEW,
-								]);
-								handleRunQuery();
-							}}
-							isLoadingQueries={isLoadingAlertQuery}
-							handleCancelQuery={handleCancelAlertQuery}
+							runQuery={(): void => handleRunQuery()}
 							alertDef={alertDef}
 							panelType={panelType || PANEL_TYPES.TIME_SERIES}
 							key={currentQuery.queryType}

frontend/src/container/GridCardLayout/GridCard/FullView/index.tsx

@@ -6,7 +6,6 @@ import React, {
 	useRef,
 	useState,
 } from 'react';
-import { useQueryClient } from 'react-query';
 // eslint-disable-next-line no-restricted-imports
 import { useSelector } from 'react-redux'; // old code, TODO: fix this correctly
 import {
@@ -19,7 +18,6 @@ import cx from 'classnames';
 import { ToggleGraphProps } from 'components/Graph/types';
 import OverlayScrollbar from 'components/OverlayScrollbar/OverlayScrollbar';
 import { QueryBuilderV2 } from 'components/QueryBuilderV2/QueryBuilderV2';
-import QueryCancelledPlaceholder from 'components/QueryCancelledPlaceholder';
 import Spinner from 'components/Spinner';
 import TimePreference from 'components/TimePreferenceDropDown';
 import WarningPopover from 'components/WarningPopover/WarningPopover';
@@ -88,7 +86,6 @@ function FullView({
 
 	const fullViewRef = useRef<HTMLDivElement>(null);
 	const { handleRunQuery } = useQueryBuilder();
-	const queryClient = useQueryClient();
 
 	useEffect(() => {
 		setCurrentGraphRef(fullViewRef);
@@ -206,8 +203,8 @@ function FullView({
 		});
 	}, [selectedPanelType]);
 
-	const queryRangeKey = useMemo(
-		() => [
+	const response = useGetQueryRange(requestData, ENTITY_VERSION_V5, {
+		queryKey: [
 			widget?.query,
 			selectedPanelType,
 			requestData,
@@ -215,28 +212,10 @@ function FullView({
 			minTime,
 			maxTime,
 		],
-		[widget?.query, selectedPanelType, requestData, version, minTime, maxTime],
-	);
-
-	const response = useGetQueryRange(requestData, ENTITY_VERSION_V5, {
-		queryKey: queryRangeKey,
 		enabled: !isDependedDataLoaded,
 		keepPreviousData: true,
 	});
 
-	const [isCancelled, setIsCancelled] = useState(false);
-
-	useEffect(() => {
-		if (response.isFetching) {
-			setIsCancelled(false);
-		}
-	}, [response.isFetching]);
-
-	const handleCancelQuery = useCallback(() => {
-		queryClient.cancelQueries(queryRangeKey);
-		setIsCancelled(true);
-	}, [queryClient, queryRangeKey]);
-
 	const onDragSelect = useCallback((start: number, end: number): void => {
 		const startTimestamp = Math.trunc(start);
 		const endTimestamp = Math.trunc(end);
@@ -375,8 +354,6 @@ function FullView({
 									onStageRunQuery={(): void => {
 										handleRunQuery();
 									}}
-									isLoadingQueries={response.isFetching}
-									handleCancelQuery={handleCancelQuery}
 								/>
 							</>
 						)}
@@ -409,27 +386,23 @@ function FullView({
 									}}
 								/>
 							)}
-							{isCancelled ? (
-								<QueryCancelledPlaceholder subText='Click "Run Query" to reload the widget.' />
-							) : (
-								<PanelWrapper
-									panelMode={PanelMode.STANDALONE_VIEW}
-									queryResponse={response}
-									widget={widget}
-									setRequestData={setRequestData}
-									isFullViewMode
-									onToggleModelHandler={onToggleModelHandler}
-									setGraphVisibility={setGraphsVisibilityStates}
-									graphVisibility={graphsVisibilityStates}
-									onDragSelect={customOnDragSelect ?? onDragSelect}
-									tableProcessedDataRef={tableProcessedDataRef}
-									searchTerm={searchTerm}
-									onClickHandler={onClickHandler}
-									enableDrillDown={enableDrillDown}
-									selectedGraph={selectedPanelType}
-									onColumnWidthsChange={onColumnWidthsChange}
-								/>
-							)}
+							<PanelWrapper
+								panelMode={PanelMode.STANDALONE_VIEW}
+								queryResponse={response}
+								widget={widget}
+								setRequestData={setRequestData}
+								isFullViewMode
+								onToggleModelHandler={onToggleModelHandler}
+								setGraphVisibility={setGraphsVisibilityStates}
+								graphVisibility={graphsVisibilityStates}
+								onDragSelect={customOnDragSelect ?? onDragSelect}
+								tableProcessedDataRef={tableProcessedDataRef}
+								searchTerm={searchTerm}
+								onClickHandler={onClickHandler}
+								enableDrillDown={enableDrillDown}
+								selectedGraph={selectedPanelType}
+								onColumnWidthsChange={onColumnWidthsChange}
+							/>
 						</GraphContainer>
 					</div>
 				</>

frontend/src/container/MeterExplorer/Explorer/Explorer.tsx

@@ -1,5 +1,4 @@
 import { useCallback, useEffect, useMemo, useState } from 'react';
-import { useQueryClient } from 'react-query';
 import * as Sentry from '@sentry/react';
 import { Button, Tooltip } from 'antd';
 import logEvent from 'api/common/logEvent';
@@ -8,7 +7,6 @@ import { QueryBuilderV2 } from 'components/QueryBuilderV2/QueryBuilderV2';
 import QuickFilters from 'components/QuickFilters/QuickFilters';
 import { QuickFiltersSource, SignalType } from 'components/QuickFilters/types';
 import { initialQueryMeterWithType, PANEL_TYPES } from 'constants/queryBuilder';
-import { REACT_QUERY_KEY } from 'constants/reactQueryKeys';
 import ExplorerOptionWrapper from 'container/ExplorerOptions/ExplorerOptionWrapper';
 import RightToolbarActions from 'container/QueryBuilder/components/ToolbarActions/RightToolbarActions';
 import { QueryBuilderProps } from 'container/QueryBuilder/QueryBuilder.interfaces';
@@ -39,20 +37,6 @@ function Explorer(): JSX.Element {
 		currentQuery,
 	} = useQueryBuilder();
 	const { safeNavigate } = useSafeNavigate();
-	const queryClient = useQueryClient();
-	const [isLoadingQueries, setIsLoadingQueries] = useState(false);
-	const [isCancelled, setIsCancelled] = useState(false);
-
-	useEffect(() => {
-		if (isLoadingQueries) {
-			setIsCancelled(false);
-		}
-	}, [isLoadingQueries]);
-
-	const handleCancelQuery = useCallback(() => {
-		queryClient.cancelQueries([REACT_QUERY_KEY.GET_QUERY_RANGE]);
-		setIsCancelled(true);
-	}, [queryClient]);
 
 	const [showQuickFilters, setShowQuickFilters] = useState(true);
 
@@ -171,11 +155,7 @@ function Explorer(): JSX.Element {
 
 							<div className="explore-header-right-actions">
 								<DateTimeSelector showAutoRefresh />
-								<RightToolbarActions
-									onStageRunQuery={(): void => handleRunQuery()}
-									isLoadingQueries={isLoadingQueries}
-									handleCancelQuery={handleCancelQuery}
-								/>
+								<RightToolbarActions onStageRunQuery={(): void => handleRunQuery()} />
 							</div>
 						</div>
 						<QueryBuilderV2
@@ -191,10 +171,7 @@ function Explorer(): JSX.Element {
 						/>
 
 						<div className="explore-content">
-							<TimeSeries
-								onFetchingStateChange={setIsLoadingQueries}
-								isCancelled={isCancelled}
-							/>
+							<TimeSeries />
 						</div>
 					</div>
 					<ExplorerOptionWrapper

frontend/src/container/MeterExplorer/Explorer/QuerySection.tsx

@@ -0,0 +1,43 @@
+import { Button } from 'antd';
+import logEvent from 'api/common/logEvent';
+import { PANEL_TYPES } from 'constants/queryBuilder';
+import { QueryBuilder } from 'container/QueryBuilder';
+import { ButtonWrapper } from 'container/TracesExplorer/QuerySection/styles';
+import { useGetPanelTypesQueryParam } from 'hooks/queryBuilder/useGetPanelTypesQueryParam';
+import { useQueryBuilder } from 'hooks/queryBuilder/useQueryBuilder';
+import { DataSource } from 'types/common/queryBuilder';
+
+import { MeterExplorerEventKeys, MeterExplorerEvents } from '../events';
+
+function QuerySection(): JSX.Element {
+	const { handleRunQuery } = useQueryBuilder();
+
+	const panelTypes = useGetPanelTypesQueryParam(PANEL_TYPES.TIME_SERIES);
+
+	return (
+		<div className="query-section">
+			<QueryBuilder
+				panelType={panelTypes}
+				config={{ initialDataSource: DataSource.METRICS, queryVariant: 'static' }}
+				version="v4"
+				actions={
+					<ButtonWrapper>
+						<Button
+							onClick={(): void => {
+								handleRunQuery();
+								logEvent(MeterExplorerEvents.QueryBuilderQueryChanged, {
+									[MeterExplorerEventKeys.Tab]: 'explorer',
+								});
+							}}
+							type="primary"
+						>
+							Run Query
+						</Button>
+					</ButtonWrapper>
+				}
+			/>
+		</div>
+	);
+}
+
+export default QuerySection;

frontend/src/container/MeterExplorer/Explorer/TimeSeries.tsx

@@ -1,12 +1,10 @@
-import { useEffect, useMemo } from 'react';
+import { useMemo } from 'react';
 import { useQueries } from 'react-query';
 // eslint-disable-next-line no-restricted-imports
 import { useSelector } from 'react-redux';
 import { isAxiosError } from 'axios';
-import QueryCancelledPlaceholder from 'components/QueryCancelledPlaceholder';
 import { ENTITY_VERSION_V5 } from 'constants/app';
 import { initialQueryMeterWithType, PANEL_TYPES } from 'constants/queryBuilder';
-import { MAX_QUERY_RETRIES } from 'constants/reactQuery';
 import { REACT_QUERY_KEY } from 'constants/reactQueryKeys';
 import EmptyMetricsSearch from 'container/MetricsExplorer/Explorer/EmptyMetricsSearch';
 import { BuilderUnitsFilter } from 'container/QueryBuilder/filters/BuilderUnitsFilter';
@@ -23,15 +21,7 @@ import { MetricRangePayloadProps } from 'types/api/metrics/getQueryRange';
 import { DataSource } from 'types/common/queryBuilder';
 import { GlobalReducer } from 'types/reducer/globalTime';
 
-interface TimeSeriesProps {
-	onFetchingStateChange?: (isFetching: boolean) => void;
-	isCancelled?: boolean;
-}
-
-function TimeSeries({
-	onFetchingStateChange,
-	isCancelled = false,
-}: TimeSeriesProps): JSX.Element {
+function TimeSeries(): JSX.Element {
 	const { stagedQuery, currentQuery } = useQueryBuilder();
 	const { yAxisUnit, onUnitChange } = useUrlYAxisUnit('');
 
@@ -77,11 +67,7 @@ function TimeSeries({
 				minTime,
 				index,
 			],
-			queryFn: ({
-				signal,
-			}: {
-				signal?: AbortSignal;
-			}): Promise<SuccessResponse<MetricRangePayloadProps>> =>
+			queryFn: (): Promise<SuccessResponse<MetricRangePayloadProps>> =>
 				GetMetricQueryRange(
 					{
 						query: payload,
@@ -93,15 +79,9 @@ function TimeSeries({
 						},
 					},
 					ENTITY_VERSION_V5,
-					undefined,
-					signal,
 				),
 			enabled: !!payload,
-			retry: (failureCount: number, error: unknown): boolean => {
-				if (isAxiosError(error) && error.code === 'ERR_CANCELED') {
-					return false;
-				}
-
+			retry: (failureCount: number, error: Error): boolean => {
 				let status: number | undefined;
 
 				if (error instanceof APIError) {
@@ -114,7 +94,7 @@ function TimeSeries({
 					return false;
 				}
 
-				return failureCount < MAX_QUERY_RETRIES;
+				return failureCount < 3;
 			},
 			onError: (error: APIError): void => {
 				showErrorModal(error);
@@ -122,11 +102,6 @@ function TimeSeries({
 		})),
 	);
 
-	const isFetching = queries.some((q) => q.isFetching);
-	useEffect(() => {
-		onFetchingStateChange?.(isFetching);
-	}, [isFetching, onFetchingStateChange]);
-
 	const data = useMemo(() => queries.map(({ data }) => data) ?? [], [queries]);
 
 	const responseData = useMemo(
@@ -147,11 +122,7 @@ function TimeSeries({
 			<BuilderUnitsFilter onChange={onUnitChange} yAxisUnit={yAxisUnit} />
 			<div className="time-series-container">
 				{!hasMetricSelected && <EmptyMetricsSearch />}
-				{isCancelled && hasMetricSelected && (
-					<QueryCancelledPlaceholder subText='Click "Run Query" to load metrics.' />
-				)}
-				{!isCancelled &&
-					hasMetricSelected &&
+				{hasMetricSelected &&
 					responseData.map((datapoint, index) => (
 						<div
 							className="time-series-view-panel"

frontend/src/container/MetricsExplorer/Explorer/Explorer.tsx

@@ -1,5 +1,4 @@
 import { useCallback, useEffect, useMemo, useState } from 'react';
-import { useQueryClient } from 'react-query';
 import { useSearchParams } from 'react-router-dom-v5-compat';
 import * as Sentry from '@sentry/react';
 import { Switch, Tooltip } from 'antd';
@@ -7,7 +6,6 @@ import logEvent from 'api/common/logEvent';
 import { QueryBuilderV2 } from 'components/QueryBuilderV2/QueryBuilderV2';
 import WarningPopover from 'components/WarningPopover/WarningPopover';
 import { initialQueriesMap, PANEL_TYPES } from 'constants/queryBuilder';
-import { REACT_QUERY_KEY } from 'constants/reactQueryKeys';
 import ExplorerOptionWrapper from 'container/ExplorerOptions/ExplorerOptionWrapper';
 import RightToolbarActions from 'container/QueryBuilder/components/ToolbarActions/RightToolbarActions';
 import { QueryBuilderProps } from 'container/QueryBuilder/QueryBuilder.interfaces';
@@ -56,21 +54,6 @@ function Explorer(): JSX.Element {
 	const { handleExplorerTabChange } = useHandleExplorerTabChange();
 	const [isMetricDetailsOpen, setIsMetricDetailsOpen] = useState(false);
 
-	const queryClient = useQueryClient();
-	const [isLoadingQueries, setIsLoadingQueries] = useState(false);
-	const [isCancelled, setIsCancelled] = useState(false);
-
-	useEffect(() => {
-		if (isLoadingQueries) {
-			setIsCancelled(false);
-		}
-	}, [isLoadingQueries]);
-
-	const handleCancelQuery = useCallback(() => {
-		queryClient.cancelQueries([REACT_QUERY_KEY.GET_QUERY_RANGE]);
-		setIsCancelled(true);
-	}, [queryClient]);
-
 	const metricNames = useMemo(() => {
 		const currentMetricNames: string[] = [];
 		stagedQuery?.builder.queryData.forEach((query) => {
@@ -324,11 +307,7 @@ function Explorer(): JSX.Element {
 					<div className="explore-header-right-actions">
 						{!isEmpty(warning) && <WarningPopover warningData={warning} />}
 						<DateTimeSelector showAutoRefresh />
-						<RightToolbarActions
-							onStageRunQuery={(): void => handleRunQuery()}
-							isLoadingQueries={isLoadingQueries}
-							handleCancelQuery={handleCancelQuery}
-						/>
+						<RightToolbarActions onStageRunQuery={(): void => handleRunQuery()} />
 					</div>
 				</div>
 				<QueryBuilderV2
@@ -340,7 +319,6 @@ function Explorer(): JSX.Element {
 				/>
 				<div className="explore-content">
 					<TimeSeries
-						onFetchingStateChange={setIsLoadingQueries}
 						showOneChartPerQuery={showOneChartPerQuery}
 						setWarning={setWarning}
 						areAllMetricUnitsSame={areAllMetricUnitsSame}
@@ -353,7 +331,6 @@ function Explorer(): JSX.Element {
 						yAxisUnit={yAxisUnit}
 						setYAxisUnit={setYAxisUnit}
 						showYAxisUnitSelector={showYAxisUnitSelector}
-						isCancelled={isCancelled}
 					/>
 				</div>
 			</div>

frontend/src/container/MetricsExplorer/Explorer/QuerySection.tsx

@@ -1,10 +1,7 @@
-import { useCallback } from 'react';
-import { useIsFetching, useQueryClient } from 'react-query';
+import { Button } from 'antd';
 import logEvent from 'api/common/logEvent';
 import { PANEL_TYPES } from 'constants/queryBuilder';
-import { REACT_QUERY_KEY } from 'constants/reactQueryKeys';
 import { QueryBuilder } from 'container/QueryBuilder';
-import RunQueryBtn from 'container/QueryBuilder/components/RunQueryBtn/RunQueryBtn';
 import { ButtonWrapper } from 'container/TracesExplorer/QuerySection/styles';
 import { useGetPanelTypesQueryParam } from 'hooks/queryBuilder/useGetPanelTypesQueryParam';
 import { useQueryBuilder } from 'hooks/queryBuilder/useQueryBuilder';
@@ -14,16 +11,9 @@ import { MetricsExplorerEventKeys, MetricsExplorerEvents } from '../events';
 
 function QuerySection(): JSX.Element {
 	const { handleRunQuery } = useQueryBuilder();
-	const queryClient = useQueryClient();
 
 	const panelTypes = useGetPanelTypesQueryParam(PANEL_TYPES.TIME_SERIES);
 
-	const isLoadingQueries = useIsFetching([REACT_QUERY_KEY.GET_QUERY_RANGE]) > 0;
-
-	const handleCancelQuery = useCallback(() => {
-		queryClient.cancelQueries([REACT_QUERY_KEY.GET_QUERY_RANGE]);
-	}, [queryClient]);
-
 	return (
 		<div className="query-section">
 			<QueryBuilder
@@ -32,16 +22,17 @@ function QuerySection(): JSX.Element {
 				version="v4"
 				actions={
 					<ButtonWrapper>
-						<RunQueryBtn
-							onStageRunQuery={(): void => {
+						<Button
+							onClick={(): void => {
 								handleRunQuery();
 								logEvent(MetricsExplorerEvents.QueryBuilderQueryChanged, {
 									[MetricsExplorerEventKeys.Tab]: 'explorer',
 								});
 							}}
-							isLoadingQueries={isLoadingQueries}
-							handleCancelQuery={handleCancelQuery}
-						/>
+							type="primary"
+						>
+							Run Query
+						</Button>
 					</ButtonWrapper>
 				}
 			/>

frontend/src/container/MetricsExplorer/Explorer/TimeSeries.tsx

@@ -1,4 +1,4 @@
-import { useEffect, useMemo } from 'react';
+import { useMemo } from 'react';
 import { useQueries, useQueryClient } from 'react-query';
 // eslint-disable-next-line no-restricted-imports
 import { useSelector } from 'react-redux';
@@ -11,12 +11,10 @@ import {
 } from 'api/generated/services/metrics';
 import { isAxiosError } from 'axios';
 import classNames from 'classnames';
-import QueryCancelledPlaceholder from 'components/QueryCancelledPlaceholder';
 import YAxisUnitSelector from 'components/YAxisUnitSelector';
 import { YAxisSource } from 'components/YAxisUnitSelector/types';
 import { ENTITY_VERSION_V5 } from 'constants/app';
 import { initialQueriesMap, PANEL_TYPES } from 'constants/queryBuilder';
-import { MAX_QUERY_RETRIES } from 'constants/reactQuery';
 import { REACT_QUERY_KEY } from 'constants/reactQueryKeys';
 import TimeSeriesView from 'container/TimeSeriesView/TimeSeriesView';
 import { convertDataValueToMs } from 'container/TimeSeriesView/utils';
@@ -38,7 +36,6 @@ import {
 } from './utils';
 
 function TimeSeries({
-	onFetchingStateChange,
 	showOneChartPerQuery,
 	setWarning,
 	isMetricUnitsLoading,
@@ -49,7 +46,6 @@ function TimeSeries({
 	setYAxisUnit,
 	showYAxisUnitSelector,
 	metrics,
-	isCancelled = false,
 }: TimeSeriesProps): JSX.Element {
 	const { stagedQuery, currentQuery } = useQueryBuilder();
 
@@ -102,11 +98,7 @@ function TimeSeries({
 				minTime,
 				index,
 			],
-			queryFn: ({
-				signal,
-			}: {
-				signal?: AbortSignal;
-			}): Promise<SuccessResponse<MetricRangePayloadProps>> =>
+			queryFn: (): Promise<SuccessResponse<MetricRangePayloadProps>> =>
 				GetMetricQueryRange(
 					{
 						query: payload,
@@ -119,15 +111,9 @@ function TimeSeries({
 					},
 					// ENTITY_VERSION_V4,
 					ENTITY_VERSION_V5,
-					undefined,
-					signal,
 				),
 			enabled: !!payload,
-			retry: (failureCount: number, error: unknown): boolean => {
-				if (isAxiosError(error) && error.code === 'ERR_CANCELED') {
-					return false;
-				}
-
+			retry: (failureCount: number, error: Error): boolean => {
 				let status: number | undefined;
 
 				if (error instanceof APIError) {
@@ -140,16 +126,11 @@ function TimeSeries({
 					return false;
 				}
 
-				return failureCount < MAX_QUERY_RETRIES;
+				return failureCount < 3;
 			},
 		})),
 	);
 
-	const isFetching = queries.some((q) => q.isFetching);
-	useEffect(() => {
-		onFetchingStateChange?.(isFetching);
-	}, [isFetching, onFetchingStateChange]);
-
 	const data = useMemo(() => queries.map(({ data }) => data) ?? [], [queries]);
 
 	const responseData = useMemo(
@@ -250,11 +231,7 @@ function TimeSeries({
 				})}
 			>
 				{metricNames.length === 0 && <EmptyMetricsSearch />}
-				{isCancelled && metricNames.length > 0 && (
-					<QueryCancelledPlaceholder subText='Click "Run Query" to load metrics.' />
-				)}
-				{!isCancelled &&
-					metricNames.length > 0 &&
+				{metricNames.length > 0 &&
 					responseData.map((datapoint, index) => {
 						const isQueryDataItem = index < metricNames.length;
 						const metricName = isQueryDataItem ? metricNames[index] : undefined;

frontend/src/container/MetricsExplorer/Explorer/types.ts

@@ -3,7 +3,6 @@ import { MetricsexplorertypesMetricMetadataDTO } from 'api/generated/services/si
 import { Warning } from 'types/api';
 
 export interface TimeSeriesProps {
-	onFetchingStateChange?: (isFetching: boolean) => void;
 	showOneChartPerQuery: boolean;
 	setWarning: Dispatch<SetStateAction<Warning | undefined>>;
 	areAllMetricUnitsSame: boolean;
@@ -16,5 +15,4 @@ export interface TimeSeriesProps {
 	yAxisUnit: string | undefined;
 	setYAxisUnit: (unit: string) => void;
 	showYAxisUnitSelector: boolean;
-	isCancelled?: boolean;
 }

frontend/src/container/MetricsExplorer/Inspect/Inspect.styles.scss

@@ -4,25 +4,9 @@
 
 	.inspect-metrics-fallback {
 		display: flex;
-		flex-direction: column;
-		gap: 32px;
+		align-items: center;
+		justify-content: center;
 		height: 100%;
-
-		.inspect-metrics-fallback-header-placeholder {
-			// Reserve the same vertical space the GraphView header occupies
-			// (antd middle button height) so swapping chart ↔ fallback causes
-			// no layout shift.
-			height: 32px;
-			flex-shrink: 0;
-		}
-
-		.inspect-metrics-fallback-body {
-			flex: 1;
-			display: flex;
-			align-items: center;
-			justify-content: center;
-			min-height: 520px;
-		}
 	}
 
 	.inspect-metrics-title {

frontend/src/container/MetricsExplorer/Inspect/Inspect.tsx

@@ -1,12 +1,9 @@
-import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
-import { useQueryClient } from 'react-query';
+import { useCallback, useEffect, useMemo, useState } from 'react';
 import * as Sentry from '@sentry/react';
 import { Color } from '@signozhq/design-tokens';
 import { Button, Drawer, Empty, Skeleton, Typography } from 'antd';
 import logEvent from 'api/common/logEvent';
 import { useGetMetricMetadata } from 'api/generated/services/metrics';
-import QueryCancelledPlaceholder from 'components/QueryCancelledPlaceholder';
-import { REACT_QUERY_KEY } from 'constants/reactQueryKeys';
 import { useQueryBuilder } from 'hooks/queryBuilder/useQueryBuilder';
 import { useQueryOperations } from 'hooks/queryBuilder/useQueryBuilderOperations';
 import { useIsDarkMode } from 'hooks/useDarkMode';
@@ -112,28 +109,6 @@ function Inspect({
 		reset,
 	} = useInspectMetrics(appliedMetricName);
 
-	const [isCancelled, setIsCancelled] = useState(false);
-
-	// Auto-reset isCancelled only on the rising edge of a new fetch
-	// (transition from not-loading → loading). Watching `isLoading` directly
-	// races with the cancel flow — when the user cancels mid-fetch, loading
-	// is still true in the render right after setIsCancelled(true), which
-	// would immediately reset it.
-	const wasLoadingRef = useRef(false);
-	useEffect(() => {
-		const nowLoading = isInspectMetricsLoading || isInspectMetricsRefetching;
-		if (!wasLoadingRef.current && nowLoading) {
-			setIsCancelled(false);
-		}
-		wasLoadingRef.current = nowLoading;
-	}, [isInspectMetricsLoading, isInspectMetricsRefetching]);
-
-	const queryClient = useQueryClient();
-	const handleCancelInspectQuery = useCallback(() => {
-		queryClient.cancelQueries(REACT_QUERY_KEY.GET_INSPECT_METRICS_DETAILS);
-		setIsCancelled(true);
-	}, [queryClient]);
-
 	const handleDispatchMetricInspectionOptions = useCallback(
 		(action: MetricInspectionAction): void => {
 			dispatchMetricInspectionOptions(action);
@@ -192,66 +167,96 @@ function Inspect({
 		setExpandedViewOptions(null);
 	}, [inspectionStep]);
 
-	const chartArea = useMemo(() => {
-		const renderFallback = (testId: string, body: JSX.Element): JSX.Element => (
-			<div data-testid={testId} className="inspect-metrics-fallback">
-				<div className="inspect-metrics-fallback-header-placeholder" />
-				<div className="inspect-metrics-fallback-body">{body}</div>
-			</div>
-		);
-
-		// Cancelled state takes precedence over any react-query state — ensures
-		// the placeholder shows immediately on cancel, regardless of whether
-		// isLoading/isRefetching has settled yet.
-		if (isCancelled) {
-			return renderFallback(
-				'inspect-metrics-cancelled',
-				<QueryCancelledPlaceholder subText='Click "Run Query" to see inspect results.' />,
+	const content = useMemo(() => {
+		if (isInspectMetricsLoading && !isInspectMetricsRefetching) {
+			return (
+				<div
+					data-testid="inspect-metrics-loading"
+					className="inspect-metrics-fallback"
+				>
+					<Skeleton active />
+				</div>
 			);
 		}
 
-		if (isInspectMetricsLoading && !isInspectMetricsRefetching) {
-			return renderFallback('inspect-metrics-loading', <Skeleton active />);
-		}
-
 		if (isInspectMetricsError) {
-			return renderFallback(
-				'inspect-metrics-error',
-				<Empty description="Error loading inspect metrics." />,
+			const errorMessage = 'Error loading inspect metrics.';
+
+			return (
+				<div
+					data-testid="inspect-metrics-error"
+					className="inspect-metrics-fallback"
+				>
+					<Empty description={errorMessage} />
+				</div>
 			);
 		}
 
 		if (!inspectMetricsTimeSeries.length) {
-			return renderFallback(
-				'inspect-metrics-empty',
-				<Empty description="No time series found for this metric to inspect." />,
+			return (
+				<div
+					data-testid="inspect-metrics-empty"
+					className="inspect-metrics-fallback"
+				>
+					<Empty description="No time series found for this metric to inspect." />
+				</div>
 			);
 		}
 
 		return (
-			<GraphView
-				inspectMetricsTimeSeries={aggregatedTimeSeries}
-				formattedInspectMetricsTimeSeries={formattedInspectMetricsTimeSeries}
-				resetInspection={resetInspection}
-				metricName={appliedMetricName}
-				metricUnit={selectedMetricUnit}
-				metricType={selectedMetricType}
-				spaceAggregationSeriesMap={spaceAggregationSeriesMap}
-				inspectionStep={inspectionStep}
-				setPopoverOptions={setPopoverOptions}
-				setShowExpandedView={setShowExpandedView}
-				showExpandedView={showExpandedView}
-				setExpandedViewOptions={setExpandedViewOptions}
-				popoverOptions={popoverOptions}
-				metricInspectionAppliedOptions={metricInspectionOptions.appliedOptions}
-				isInspectMetricsRefetching={isInspectMetricsRefetching}
-			/>
+			<div className="inspect-metrics-content">
+				<div className="inspect-metrics-content-first-col">
+					<GraphView
+						inspectMetricsTimeSeries={aggregatedTimeSeries}
+						formattedInspectMetricsTimeSeries={formattedInspectMetricsTimeSeries}
+						resetInspection={resetInspection}
+						metricName={appliedMetricName}
+						metricUnit={selectedMetricUnit}
+						metricType={selectedMetricType}
+						spaceAggregationSeriesMap={spaceAggregationSeriesMap}
+						inspectionStep={inspectionStep}
+						setPopoverOptions={setPopoverOptions}
+						setShowExpandedView={setShowExpandedView}
+						showExpandedView={showExpandedView}
+						setExpandedViewOptions={setExpandedViewOptions}
+						popoverOptions={popoverOptions}
+						metricInspectionAppliedOptions={metricInspectionOptions.appliedOptions}
+						isInspectMetricsRefetching={isInspectMetricsRefetching}
+					/>
+					<QueryBuilder
+						currentMetricName={currentMetricName}
+						setCurrentMetricName={setCurrentMetricName}
+						setAppliedMetricName={setAppliedMetricName}
+						spaceAggregationLabels={spaceAggregationLabels}
+						currentMetricInspectionOptions={metricInspectionOptions.currentOptions}
+						dispatchMetricInspectionOptions={handleDispatchMetricInspectionOptions}
+						inspectionStep={inspectionStep}
+						inspectMetricsTimeSeries={inspectMetricsTimeSeries}
+						currentQuery={currentQueryData}
+						setCurrentQuery={setCurrentQueryData}
+					/>
+				</div>
+				<div className="inspect-metrics-content-second-col">
+					<Stepper
+						inspectionStep={inspectionStep}
+						resetInspection={resetInspection}
+					/>
+					{showExpandedView && (
+						<ExpandedView
+							options={expandedViewOptions}
+							spaceAggregationSeriesMap={spaceAggregationSeriesMap}
+							step={inspectionStep}
+							metricInspectionAppliedOptions={metricInspectionOptions.appliedOptions}
+							timeAggregatedSeriesMap={timeAggregatedSeriesMap}
+						/>
+					)}
+				</div>
+			</div>
 		);
 	}, [
 		isInspectMetricsLoading,
 		isInspectMetricsRefetching,
 		isInspectMetricsError,
-		isCancelled,
 		inspectMetricsTimeSeries,
 		aggregatedTimeSeries,
 		formattedInspectMetricsTimeSeries,
@@ -307,46 +312,7 @@ function Inspect({
 				className="inspect-metrics-modal"
 				destroyOnClose
 			>
-				<div className="inspect-metrics-content">
-					<div className="inspect-metrics-content-first-col">
-						{chartArea}
-						<QueryBuilder
-							currentMetricName={currentMetricName}
-							setCurrentMetricName={setCurrentMetricName}
-							setAppliedMetricName={setAppliedMetricName}
-							spaceAggregationLabels={spaceAggregationLabels}
-							currentMetricInspectionOptions={metricInspectionOptions.currentOptions}
-							dispatchMetricInspectionOptions={handleDispatchMetricInspectionOptions}
-							inspectionStep={inspectionStep}
-							inspectMetricsTimeSeries={inspectMetricsTimeSeries}
-							currentQuery={currentQueryData}
-							setCurrentQuery={setCurrentQueryData}
-							isLoadingQueries={isInspectMetricsLoading || isInspectMetricsRefetching}
-							handleCancelQuery={handleCancelInspectQuery}
-							onRunQuery={(): void => {
-								setIsCancelled(false);
-								queryClient.invalidateQueries([
-									REACT_QUERY_KEY.GET_INSPECT_METRICS_DETAILS,
-								]);
-							}}
-						/>
-					</div>
-					<div className="inspect-metrics-content-second-col">
-						<Stepper
-							inspectionStep={inspectionStep}
-							resetInspection={resetInspection}
-						/>
-						{showExpandedView && (
-							<ExpandedView
-								options={expandedViewOptions}
-								spaceAggregationSeriesMap={spaceAggregationSeriesMap}
-								step={inspectionStep}
-								metricInspectionAppliedOptions={metricInspectionOptions.appliedOptions}
-								timeAggregatedSeriesMap={timeAggregatedSeriesMap}
-							/>
-						)}
-					</div>
-				</div>
+				{content}
 			</Drawer>
 		</Sentry.ErrorBoundary>
 	);

frontend/src/container/MetricsExplorer/Inspect/QueryBuilder.tsx

@@ -20,22 +20,13 @@ function QueryBuilder({
 	inspectMetricsTimeSeries,
 	currentQuery,
 	setCurrentQuery,
-	isLoadingQueries,
-	handleCancelQuery,
-	onRunQuery,
 }: QueryBuilderProps): JSX.Element {
 	const applyInspectionOptions = useCallback(() => {
-		onRunQuery?.();
 		setAppliedMetricName(currentMetricName ?? '');
 		dispatchMetricInspectionOptions({
 			type: 'APPLY_METRIC_INSPECTION_OPTIONS',
 		});
-	}, [
-		currentMetricName,
-		setAppliedMetricName,
-		dispatchMetricInspectionOptions,
-		onRunQuery,
-	]);
+	}, [currentMetricName, setAppliedMetricName, dispatchMetricInspectionOptions]);
 
 	return (
 		<div className="inspect-metrics-query-builder">
@@ -48,11 +39,7 @@ function QueryBuilder({
 				>
 					Query Builder
 				</Button>
-				<RunQueryBtn
-					onStageRunQuery={applyInspectionOptions}
-					handleCancelQuery={handleCancelQuery}
-					isLoadingQueries={isLoadingQueries}
-				/>
+				<RunQueryBtn onStageRunQuery={applyInspectionOptions} />
 			</div>
 			<Card className="inspect-metrics-query-builder-content">
 				<MetricNameSearch

frontend/src/container/MetricsExplorer/Inspect/__tests__/QueryBuilder.test.tsx

@@ -103,8 +103,6 @@ describe('QueryBuilder', () => {
 			filterExpression: '',
 		} as any,
 		setCurrentQuery: jest.fn(),
-		isLoadingQueries: false,
-		handleCancelQuery: jest.fn(),
 	};
 
 	beforeEach(() => {

frontend/src/container/MetricsExplorer/Inspect/types.ts

@@ -65,9 +65,6 @@ export interface QueryBuilderProps {
 	inspectMetricsTimeSeries: InspectMetricsSeries[];
 	currentQuery: IBuilderQuery;
 	setCurrentQuery: (query: IBuilderQuery) => void;
-	isLoadingQueries: boolean;
-	handleCancelQuery: () => void;
-	onRunQuery?: () => void;
 }
 
 export interface MetricNameSearchProps {

frontend/src/container/MetricsExplorer/Inspect/useInspectMetrics.ts

@@ -1,9 +1,6 @@
 import { useCallback, useEffect, useMemo, useReducer, useState } from 'react';
 import { useQuery } from 'react-query';
 import { inspectMetrics } from 'api/generated/services/metrics';
-import { isAxiosError } from 'axios';
-import { MAX_QUERY_RETRIES } from 'constants/reactQuery';
-import { REACT_QUERY_KEY } from 'constants/reactQueryKeys';
 import { themeColors } from 'constants/theme';
 import { useIsDarkMode } from 'hooks/useDarkMode';
 import { generateColor } from 'lib/uPlotLib/utils/generateColor';
@@ -110,7 +107,7 @@ export function useInspectMetrics(
 		isRefetching: isInspectMetricsRefetching,
 	} = useQuery({
 		queryKey: [
-			REACT_QUERY_KEY.GET_INSPECT_METRICS_DETAILS,
+			'inspectMetrics',
 			metricName,
 			start,
 			end,
@@ -130,12 +127,6 @@ export function useInspectMetrics(
 			),
 		enabled: !!metricName,
 		keepPreviousData: true,
-		retry: (failureCount: number, error: Error): boolean => {
-			if (isAxiosError(error) && error.code === 'ERR_CANCELED') {
-				return false;
-			}
-			return failureCount < MAX_QUERY_RETRIES;
-		},
 	});
 
 	const inspectMetricsData = useMemo(

frontend/src/container/MetricsExplorer/Summary/MetricsSearch.tsx

@@ -12,8 +12,6 @@ function MetricsSearch({
 	currentQueryFilterExpression,
 	setCurrentQueryFilterExpression,
 	isLoading,
-	handleCancelQuery,
-	onRunQuery,
 }: MetricsSearchProps): JSX.Element {
 	const handleOnChange = useCallback(
 		(expression: string): void => {
@@ -24,8 +22,7 @@ function MetricsSearch({
 
 	const handleStageAndRunQuery = useCallback(() => {
 		onChange(currentQueryFilterExpression);
-		onRunQuery?.();
-	}, [currentQueryFilterExpression, onChange, onRunQuery]);
+	}, [currentQueryFilterExpression, onChange]);
 
 	const handleRunQuery = useCallback(
 		(expression: string): void => {
@@ -56,7 +53,6 @@ function MetricsSearch({
 			<RunQueryBtn
 				onStageRunQuery={handleStageAndRunQuery}
 				isLoadingQueries={isLoading}
-				handleCancelQuery={handleCancelQuery}
 			/>
 			<div className="metrics-search-options">
 				<DateTimeSelectionV2

frontend/src/container/MetricsExplorer/Summary/Summary.tsx

@@ -4,7 +4,6 @@ import React, { useCallback, useEffect, useMemo, useState } from 'react';
 import { useSelector } from 'react-redux'; // old code, TODO: fix this correctly
 import { useSearchParams } from 'react-router-dom-v5-compat';
 import * as Sentry from '@sentry/react';
-import { Typography } from 'antd';
 import logEvent from 'api/common/logEvent';
 import { convertToApiError } from 'api/ErrorResponseHandlerForGeneratedAPIs';
 import {
@@ -18,7 +17,6 @@ import {
 	Querybuildertypesv5OrderByDTO,
 	Querybuildertypesv5OrderDirectionDTO,
 } from 'api/generated/services/sigNoz.schemas';
-import eyesEmojiUrl from 'assets/Images/eyesEmoji.svg';
 import { convertExpressionToFilters } from 'components/QueryBuilderV2/utils';
 import { initialQueriesMap } from 'constants/queryBuilder';
 import { usePageSize } from 'container/InfraMonitoringK8s/utils';
@@ -106,8 +104,6 @@ function Summary(): JSX.Element {
 		setCurrentQueryFilterExpression,
 	] = useState<string>(appliedFilterExpression);
 
-	const [isCancelled, setIsCancelled] = useState<boolean>(false);
-
 	useEffect(() => {
 		setCurrentQueryFilterExpression(appliedFilterExpression);
 	}, [appliedFilterExpression]);
@@ -168,7 +164,6 @@ function Summary(): JSX.Element {
 		isLoading: isGetMetricsStatsLoading,
 		isError: isGetMetricsStatsError,
 		error: metricsStatsError,
-		reset: resetMetricsStats,
 	} = useGetMetricsStats();
 
 	const {
@@ -177,7 +172,6 @@ function Summary(): JSX.Element {
 		isLoading: isGetMetricsTreemapLoading,
 		isError: isGetMetricsTreemapError,
 		error: metricsTreemapError,
-		reset: resetMetricsTreemap,
 	} = useGetMetricsTreemap();
 
 	const metricsStatsApiError = useMemo(
@@ -202,40 +196,6 @@ function Summary(): JSX.Element {
 		});
 	}, [metricsTreemapQuery, getMetricsTreemap]);
 
-	const handleCancelQuery = useCallback(() => {
-		resetMetricsStats();
-		resetMetricsTreemap();
-		setCurrentQueryFilterExpression(appliedFilterExpression);
-		setIsCancelled(true);
-	}, [
-		resetMetricsStats,
-		resetMetricsTreemap,
-		setCurrentQueryFilterExpression,
-		appliedFilterExpression,
-	]);
-
-	const handleRunQuery = useCallback(() => {
-		setIsCancelled(false);
-		getMetricsStats({
-			data: {
-				...metricsListQuery,
-				filter: { expression: currentQueryFilterExpression },
-			},
-		});
-		getMetricsTreemap({
-			data: {
-				...metricsTreemapQuery,
-				filter: { expression: currentQueryFilterExpression },
-			},
-		});
-	}, [
-		getMetricsStats,
-		getMetricsTreemap,
-		metricsListQuery,
-		metricsTreemapQuery,
-		currentQueryFilterExpression,
-	]);
-
 	const handleFilterChange = useCallback(
 		(expression: string) => {
 			const newFilters: TagFilter = {
@@ -370,19 +330,11 @@ function Summary(): JSX.Element {
 		!isGetMetricsTreemapLoading &&
 		!isGetMetricsTreemapError;
 
-	const isLoadingQueries =
-		isGetMetricsStatsLoading || isGetMetricsTreemapLoading;
-
 	const showFullScreenLoading =
-		isLoadingQueries &&
+		(isGetMetricsStatsLoading || isGetMetricsTreemapLoading) &&
 		formattedMetricsData.length === 0 &&
 		!treeMapData?.data[heatmapView]?.length;
 
-	const showNoMetrics =
-		isMetricsListDataEmpty &&
-		isMetricsTreeMapDataEmpty &&
-		!appliedFilterExpression;
-
 	return (
 		<Sentry.ErrorBoundary fallback={<ErrorBoundaryFallback />}>
 			<div className="metrics-explorer-summary-tab">
@@ -391,26 +343,13 @@ function Summary(): JSX.Element {
 					onChange={handleFilterChange}
 					currentQueryFilterExpression={currentQueryFilterExpression}
 					setCurrentQueryFilterExpression={setCurrentQueryFilterExpression}
-					isLoading={isLoadingQueries}
-					handleCancelQuery={handleCancelQuery}
-					onRunQuery={handleRunQuery}
+					isLoading={isGetMetricsStatsLoading || isGetMetricsTreemapLoading}
 				/>
 				{showFullScreenLoading ? (
 					<MetricsLoading />
-				) : isCancelled ? (
-					<div className="no-logs-container">
-						<div className="no-logs-container-content">
-							<img className="eyes-emoji" src={eyesEmojiUrl} alt="eyes emoji" />
-							<Typography className="no-logs-text">
-								Query cancelled.
-								<span className="sub-text">
-									{' '}
-									Click &quot;Run Query&quot; to load metrics.
-								</span>
-							</Typography>
-						</div>
-					</div>
-				) : showNoMetrics ? (
+				) : isMetricsListDataEmpty &&
+				  isMetricsTreeMapDataEmpty &&
+				  !appliedFilterExpression ? (
 					<NoLogs dataSource={DataSource.METRICS} />
 				) : (
 					<>

frontend/src/container/MetricsExplorer/Summary/types.ts

@@ -33,8 +33,6 @@ export interface MetricsSearchProps {
 	currentQueryFilterExpression: string;
 	setCurrentQueryFilterExpression: (expression: string) => void;
 	isLoading: boolean;
-	handleCancelQuery: () => void;
-	onRunQuery: () => void;
 }
 
 export interface MetricsTreemapProps {

frontend/src/container/NewWidget/LeftContainer/QuerySection/index.tsx

@@ -1,4 +1,5 @@
 import { useCallback, useEffect, useMemo } from 'react';
+import { QueryKey } from 'react-query';
 import { Color } from '@signozhq/design-tokens';
 import { Button, Tabs, Typography } from 'antd';
 import logEvent from 'api/common/logEvent';
@@ -24,8 +25,8 @@ import PromQLQueryContainer from './QueryBuilder/promQL';
 import './QuerySection.styles.scss';
 function QuerySection({
 	selectedGraph,
+	queryRangeKey,
 	isLoadingQueries,
-	handleCancelQuery,
 	selectedWidget,
 	dashboardVersion,
 	dashboardId,
@@ -178,7 +179,7 @@ function QuerySection({
 							label="Stage & Run Query"
 							onStageRunQuery={handleRunQuery}
 							isLoadingQueries={isLoadingQueries}
-							handleCancelQuery={handleCancelQuery}
+							queryRangeKey={queryRangeKey}
 						/>
 					</span>
 				}
@@ -190,8 +191,8 @@ function QuerySection({
 
 interface QueryProps {
 	selectedGraph: PANEL_TYPES;
-	isLoadingQueries: boolean;
-	handleCancelQuery: () => void;
+	queryRangeKey?: QueryKey;
+	isLoadingQueries?: boolean;
 	selectedWidget: Widgets;
 	dashboardVersion?: string;
 	dashboardId?: string;

frontend/src/container/NewWidget/LeftContainer/WidgetGraph/index.tsx

@@ -1,6 +1,5 @@
 import { memo } from 'react';
 import { InfoCircleOutlined } from '@ant-design/icons';
-import QueryCancelledPlaceholder from 'components/QueryCancelledPlaceholder';
 import WarningPopover from 'components/WarningPopover/WarningPopover';
 import { Card } from 'container/GridCardLayout/styles';
 import DateTimeSelectionV2 from 'container/TopNav/DateTimeSelectionV2';
@@ -23,7 +22,6 @@ function WidgetGraph({
 	selectedWidget,
 	isLoadingPanelData,
 	enableDrillDown = false,
-	isCancelled = false,
 }: WidgetGraphContainerProps): JSX.Element {
 	const { currentQuery } = useQueryBuilder();
 
@@ -48,24 +46,20 @@ function WidgetGraph({
 				</div>
 				<DateTimeSelectionV2 showAutoRefresh={false} hideShareModal />
 			</div>
-			{!isCancelled && queryResponse.error && (
+			{queryResponse.error && (
 				<AlertIconContainer color="red" title={queryResponse.error.message}>
 					<InfoCircleOutlined />
 				</AlertIconContainer>
 			)}
 
-			{isCancelled ? (
-				<QueryCancelledPlaceholder subText='Click "Run Query" to reload the chart.' />
-			) : (
-				<WidgetGraphComponent
-					isLoadingPanelData={isLoadingPanelData}
-					selectedGraph={selectedGraph}
-					queryResponse={queryResponse}
-					setRequestData={setRequestData}
-					selectedWidget={selectedWidget}
-					enableDrillDown={enableDrillDown}
-				/>
-			)}
+			<WidgetGraphComponent
+				isLoadingPanelData={isLoadingPanelData}
+				selectedGraph={selectedGraph}
+				queryResponse={queryResponse}
+				setRequestData={setRequestData}
+				selectedWidget={selectedWidget}
+				enableDrillDown={enableDrillDown}
+			/>
 		</Container>
 	);
 }

frontend/src/container/NewWidget/LeftContainer/index.tsx

@@ -1,5 +1,5 @@
-import { memo, useCallback, useEffect, useMemo, useState } from 'react';
-import { useQueryClient } from 'react-query';
+import { memo, useEffect } from 'react';
+import { useMemo } from 'react';
 // eslint-disable-next-line no-restricted-imports
 import { useSelector } from 'react-redux';
 import { ENTITY_VERSION_V5 } from 'constants/app';
@@ -34,7 +34,6 @@ function LeftContainer({
 	isNewPanel = false,
 }: WidgetGraphProps): JSX.Element {
 	const { stagedQuery } = useQueryBuilder();
-	const queryClient = useQueryClient();
 
 	const { selectedTime: globalSelectedInterval, minTime, maxTime } = useSelector<
 		AppState,
@@ -50,25 +49,12 @@ function LeftContainer({
 		],
 		[globalSelectedInterval, requestData, minTime, maxTime],
 	);
-	const [isCancelled, setIsCancelled] = useState(false);
-
-	const handleCancelQuery = useCallback(() => {
-		queryClient.cancelQueries(queryRangeKey);
-		setIsCancelled(true);
-	}, [queryClient, queryRangeKey]);
-
 	const queryResponse = useGetQueryRange(requestData, ENTITY_VERSION_V5, {
 		enabled: !!stagedQuery,
 		queryKey: queryRangeKey,
 		keepPreviousData: true,
 	});
 
-	useEffect(() => {
-		if (queryResponse.isFetching) {
-			setIsCancelled(false);
-		}
-	}, [queryResponse.isFetching]);
-
 	// Update parent component with query response for legend colors
 	useEffect(() => {
 		if (setQueryResponse) {
@@ -85,13 +71,12 @@ function LeftContainer({
 				selectedWidget={selectedWidget}
 				isLoadingPanelData={isLoadingPanelData}
 				enableDrillDown={enableDrillDown}
-				isCancelled={isCancelled}
 			/>
 			<QueryContainer className="query-section-left-container">
 				<QuerySection
 					selectedGraph={selectedGraph}
+					queryRangeKey={queryRangeKey}
 					isLoadingQueries={queryResponse.isFetching}
-					handleCancelQuery={handleCancelQuery}
 					selectedWidget={selectedWidget}
 					dashboardVersion={ENTITY_VERSION_V5}
 					dashboardId={dashboardData?.id}

frontend/src/container/NewWidget/types.ts

@@ -50,5 +50,4 @@ export type WidgetGraphContainerProps = {
 	selectedWidget: Widgets;
 	isLoadingPanelData: boolean;
 	enableDrillDown?: boolean;
-	isCancelled?: boolean;
 };

frontend/src/container/QueryBuilder/components/RunQueryBtn/RunQueryBtn.tsx

@@ -1,3 +1,5 @@
+import { useCallback } from 'react';
+import { QueryKey, useIsFetching, useQueryClient } from 'react-query';
 import { Button } from '@signozhq/ui';
 import cx from 'classnames';
 import {
@@ -10,23 +12,14 @@ import {
 import { getUserOperatingSystem, UserOperatingSystem } from 'utils/getUserOS';
 
 import './RunQueryBtn.scss';
-
-type RunQueryBtnProps = {
+interface RunQueryBtnProps {
 	className?: string;
 	label?: string;
-	disabled?: boolean;
-} & (
-	| {
-			onStageRunQuery: () => void;
-			handleCancelQuery: () => void;
-			isLoadingQueries: boolean;
-	  }
-	| {
-			onStageRunQuery?: never;
-			handleCancelQuery?: never;
-			isLoadingQueries?: never;
-	  }
-);
+	isLoadingQueries?: boolean;
+	handleCancelQuery?: () => void;
+	onStageRunQuery?: () => void;
+	queryRangeKey?: QueryKey;
+}
 
 function RunQueryBtn({
 	className,
@@ -34,10 +27,26 @@ function RunQueryBtn({
 	isLoadingQueries,
 	handleCancelQuery,
 	onStageRunQuery,
-	disabled,
+	queryRangeKey,
 }: RunQueryBtnProps): JSX.Element {
 	const isMac = getUserOperatingSystem() === UserOperatingSystem.MACOS;
-	const isLoading = isLoadingQueries ?? false;
+	const queryClient = useQueryClient();
+	const isKeyFetchingCount = useIsFetching(
+		queryRangeKey as QueryKey | undefined,
+	);
+	const isLoading =
+		typeof isLoadingQueries === 'boolean'
+			? isLoadingQueries
+			: isKeyFetchingCount > 0;
+
+	const onCancel = useCallback(() => {
+		if (handleCancelQuery) {
+			return handleCancelQuery();
+		}
+		if (queryRangeKey) {
+			queryClient.cancelQueries(queryRangeKey);
+		}
+	}, [handleCancelQuery, queryClient, queryRangeKey]);
 
 	return isLoading ? (
 		<Button
@@ -45,7 +54,7 @@ function RunQueryBtn({
 			type="button"
 			prefix={<Loader2 size={14} className="loading-icon animate-spin" />}
 			className={cx('cancel-query-btn', className)}
-			onClick={handleCancelQuery}
+			onClick={onCancel}
 		>
 			Cancel
 		</Button>
@@ -54,7 +63,7 @@ function RunQueryBtn({
 			color="primary"
 			type="button"
 			className={cx('run-query-btn', className)}
-			disabled={disabled}
+			disabled={isLoading || !onStageRunQuery}
 			onClick={onStageRunQuery}
 			prefix={<Play size={14} />}
 		>

frontend/src/container/QueryBuilder/components/RunQueryBtn/__test__/RunQueryBtn.test.tsx

@@ -1,8 +1,18 @@
-import { render, screen } from '@testing-library/react';
-import userEvent from '@testing-library/user-event';
+// frontend/src/container/QueryBuilder/components/RunQueryBtn/__tests__/RunQueryBtn.test.tsx
+import { fireEvent, render, screen } from '@testing-library/react';
 
 import RunQueryBtn from '../RunQueryBtn';
 
+jest.mock('react-query', () => {
+	const actual = jest.requireActual('react-query');
+	return {
+		...actual,
+		useIsFetching: jest.fn(),
+		useQueryClient: jest.fn(),
+	};
+});
+import { useIsFetching, useQueryClient } from 'react-query';
+
 // Mock OS util
 jest.mock('utils/getUserOS', () => ({
 	getUserOperatingSystem: jest.fn(),
@@ -16,60 +26,79 @@ describe('RunQueryBtn', () => {
 		(getUserOperatingSystem as jest.Mock).mockReturnValue(
 			UserOperatingSystem.MACOS,
 		);
+		(useIsFetching as jest.Mock).mockReturnValue(0);
+		(useQueryClient as jest.Mock).mockReturnValue({
+			cancelQueries: jest.fn(),
+		});
 	});
 
-	test('renders run state and triggers on click', async () => {
-		const user = userEvent.setup();
+	test('uses isLoadingQueries prop over useIsFetching', () => {
+		// Simulate fetching but prop forces not loading
+		(useIsFetching as jest.Mock).mockReturnValue(1);
 		const onRun = jest.fn();
+		render(<RunQueryBtn onStageRunQuery={onRun} isLoadingQueries={false} />);
+		// Should show "Run Query" (not cancel)
+		const runBtn = screen.getByRole('button', { name: /run query/i });
+		expect(runBtn).toBeInTheDocument();
+		expect(runBtn).toBeEnabled();
+	});
+
+	test('fallback cancel: uses handleCancelQuery when no key provided', () => {
+		(useIsFetching as jest.Mock).mockReturnValue(0);
+		const cancelQueries = jest.fn();
+		(useQueryClient as jest.Mock).mockReturnValue({ cancelQueries });
+
 		const onCancel = jest.fn();
-		render(
-			<RunQueryBtn
-				onStageRunQuery={onRun}
-				handleCancelQuery={onCancel}
-				isLoadingQueries={false}
-			/>,
-		);
+		render(<RunQueryBtn isLoadingQueries handleCancelQuery={onCancel} />);
+
+		const cancelBtn = screen.getByRole('button', { name: /cancel/i });
+		fireEvent.click(cancelBtn);
+		expect(onCancel).toHaveBeenCalledTimes(1);
+		expect(cancelQueries).not.toHaveBeenCalled();
+	});
+
+	test('renders run state and triggers on click', () => {
+		const onRun = jest.fn();
+		render(<RunQueryBtn onStageRunQuery={onRun} />);
 		const btn = screen.getByRole('button', { name: /run query/i });
 		expect(btn).toBeEnabled();
-		await user.click(btn);
+		fireEvent.click(btn);
 		expect(onRun).toHaveBeenCalledTimes(1);
 	});
 
-	test('shows cancel state and calls handleCancelQuery', async () => {
-		const user = userEvent.setup();
-		const onRun = jest.fn();
-		const onCancel = jest.fn();
-		render(
-			<RunQueryBtn
-				onStageRunQuery={onRun}
-				handleCancelQuery={onCancel}
-				isLoadingQueries
-			/>,
-		);
-		const cancel = screen.getByRole('button', { name: /cancel/i });
-		await user.click(cancel);
-		expect(onCancel).toHaveBeenCalledTimes(1);
-	});
-
-	test('disabled when disabled prop is true', () => {
-		render(<RunQueryBtn disabled />);
+	test('disabled when onStageRunQuery is undefined', () => {
+		render(<RunQueryBtn />);
 		expect(screen.getByRole('button', { name: /run query/i })).toBeDisabled();
 	});
 
-	test('disabled when no props provided', () => {
-		render(<RunQueryBtn />);
-		expect(
-			screen.getByRole('button', { name: /run query/i }),
-		).toBeInTheDocument();
+	test('shows cancel state and calls handleCancelQuery', () => {
+		const onCancel = jest.fn();
+		render(<RunQueryBtn isLoadingQueries handleCancelQuery={onCancel} />);
+		const cancel = screen.getByRole('button', { name: /cancel/i });
+		fireEvent.click(cancel);
+		expect(onCancel).toHaveBeenCalledTimes(1);
+	});
+
+	test('derives loading from queryKey via useIsFetching and cancels via queryClient', () => {
+		(useIsFetching as jest.Mock).mockReturnValue(1);
+		const cancelQueries = jest.fn();
+		(useQueryClient as jest.Mock).mockReturnValue({ cancelQueries });
+
+		const queryKey = ['GET_QUERY_RANGE', '1h', { some: 'req' }, 1, 2];
+		render(<RunQueryBtn queryRangeKey={queryKey} />);
+
+		// Button switches to cancel state
+		const cancelBtn = screen.getByRole('button', { name: /cancel/i });
+		expect(cancelBtn).toBeInTheDocument();
+
+		// Clicking cancel calls cancelQueries with the key
+		fireEvent.click(cancelBtn);
+		expect(cancelQueries).toHaveBeenCalledWith(queryKey);
 	});
 
 	test('shows Command + CornerDownLeft on mac', () => {
 		const { container } = render(
-			<RunQueryBtn
-				onStageRunQuery={jest.fn()}
-				handleCancelQuery={jest.fn()}
-				isLoadingQueries={false}
-			/>,
+			<RunQueryBtn onStageRunQuery={(): void => {}} />,
 		);
 		expect(container.querySelector('.lucide-command')).toBeInTheDocument();
 		expect(
@@ -82,11 +111,7 @@ describe('RunQueryBtn', () => {
 			UserOperatingSystem.WINDOWS,
 		);
 		const { container } = render(
-			<RunQueryBtn
-				onStageRunQuery={jest.fn()}
-				handleCancelQuery={jest.fn()}
-				isLoadingQueries={false}
-			/>,
+			<RunQueryBtn onStageRunQuery={(): void => {}} />,
 		);
 		expect(container.querySelector('.lucide-chevron-up')).toBeInTheDocument();
 		expect(container.querySelector('.lucide-command')).not.toBeInTheDocument();
@@ -96,14 +121,8 @@ describe('RunQueryBtn', () => {
 	});
 
 	test('renders custom label when provided', () => {
-		render(
-			<RunQueryBtn
-				onStageRunQuery={jest.fn()}
-				handleCancelQuery={jest.fn()}
-				isLoadingQueries={false}
-				label="Stage & Run Query"
-			/>,
-		);
+		const onRun = jest.fn();
+		render(<RunQueryBtn onStageRunQuery={onRun} label="Stage & Run Query" />);
 		expect(
 			screen.getByRole('button', { name: /stage & run query/i }),
 		).toBeInTheDocument();

frontend/src/container/QueryBuilder/components/ToolbarActions/RightToolbarActions.tsx

@@ -1,4 +1,5 @@
-import { useEffect } from 'react';
+import { MutableRefObject, useEffect } from 'react';
+import { useQueryClient } from 'react-query';
 import { LogsExplorerShortcuts } from 'constants/shortcuts/logsExplorerShortcuts';
 import { useKeyboardHotkeys } from 'hooks/hotkeys/useKeyboardHotkeys';
 
@@ -8,19 +9,23 @@ import './ToolbarActions.styles.scss';
 
 interface RightToolbarActionsProps {
 	onStageRunQuery: () => void;
-	isLoadingQueries: boolean;
-	handleCancelQuery: () => void;
+	isLoadingQueries?: boolean;
+	listQueryKeyRef?: MutableRefObject<any>;
+	chartQueryKeyRef?: MutableRefObject<any>;
 	showLiveLogs?: boolean;
 }
 
 export default function RightToolbarActions({
 	onStageRunQuery,
 	isLoadingQueries,
-	handleCancelQuery,
+	listQueryKeyRef,
+	chartQueryKeyRef,
 	showLiveLogs,
 }: RightToolbarActionsProps): JSX.Element {
 	const { registerShortcut, deregisterShortcut } = useKeyboardHotkeys();
 
+	const queryClient = useQueryClient();
+
 	useEffect(() => {
 		if (showLiveLogs) {
 			return;
@@ -37,11 +42,20 @@ export default function RightToolbarActions({
 	if (showLiveLogs) {
 		return (
 			<div className="right-toolbar-actions-container">
-				<RunQueryBtn disabled />
+				<RunQueryBtn />
 			</div>
 		);
 	}
 
+	const handleCancelQuery = (): void => {
+		if (listQueryKeyRef?.current) {
+			queryClient.cancelQueries(listQueryKeyRef.current);
+		}
+		if (chartQueryKeyRef?.current) {
+			queryClient.cancelQueries(chartQueryKeyRef.current);
+		}
+	};
+
 	return (
 		<div className="right-toolbar-actions-container">
 			<RunQueryBtn
@@ -54,5 +68,8 @@ export default function RightToolbarActions({
 }
 
 RightToolbarActions.defaultProps = {
+	isLoadingQueries: false,
+	listQueryKeyRef: null,
+	chartQueryKeyRef: null,
 	showLiveLogs: false,
 };

frontend/src/container/QueryBuilder/components/ToolbarActions/tests/ToolbarActions.test.tsx

@@ -92,12 +92,7 @@ describe('ToolbarActions', () => {
 		const onStageRunQuery = jest.fn();
 		const { queryByText } = render(
 			<MockQueryClientProvider>
-				<RightToolbarActions
-					onStageRunQuery={onStageRunQuery}
-					isLoadingQueries={false}
-					handleCancelQuery={jest.fn()}
-				/>
-				,
+				<RightToolbarActions onStageRunQuery={onStageRunQuery} />,
 			</MockQueryClientProvider>,
 		);
 

frontend/src/hooks/queryBuilder/useGetQueryRange.ts

@@ -2,7 +2,6 @@ import { useMemo } from 'react';
 import { useQuery, UseQueryOptions, UseQueryResult } from 'react-query';
 import { isAxiosError } from 'axios';
 import { PANEL_TYPES } from 'constants/queryBuilder';
-import { MAX_QUERY_RETRIES } from 'constants/reactQuery';
 import { REACT_QUERY_KEY } from 'constants/reactQueryKeys';
 import { updateBarStepInterval } from 'container/GridCardLayout/utils';
 import { useDashboardVariablesByType } from 'hooks/dashboard/useDashboardVariablesByType';
@@ -133,10 +132,6 @@ export const useGetQueryRange: UseGetQueryRange = (
 			return options.retry;
 		}
 		return (failureCount: number, error: Error): boolean => {
-			if (isAxiosError(error) && error.code === 'ERR_CANCELED') {
-				return false;
-			}
-
 			let status: number | undefined;
 
 			if (error instanceof APIError) {
@@ -149,7 +144,7 @@ export const useGetQueryRange: UseGetQueryRange = (
 				return false;
 			}
 
-			return failureCount < MAX_QUERY_RETRIES;
+			return failureCount < 3;
 		};
 	}, [options?.retry]);
 

frontend/src/hooks/thirdPartyApis/useListOverview.ts

@@ -1,7 +1,5 @@
 import { useQuery, UseQueryResult } from 'react-query';
 import listOverview from 'api/thirdPartyApis/listOverview';
-import { isAxiosError } from 'axios';
-import { MAX_QUERY_RETRIES } from 'constants/reactQuery';
 import { REACT_QUERY_KEY } from 'constants/reactQueryKeys';
 import { SuccessResponseV2 } from 'types/api';
 import APIError from 'types/api/error';
@@ -22,21 +20,12 @@ export const useListOverview = (
 			showIp,
 			filter.expression,
 		],
-		queryFn: ({ signal }) =>
-			listOverview(
-				{
-					start,
-					end,
-					show_ip: showIp,
-					filter,
-				},
-				signal,
-			),
-		retry: (failureCount, error): boolean => {
-			if (isAxiosError(error) && error.code === 'ERR_CANCELED') {
-				return false;
-			}
-			return failureCount < MAX_QUERY_RETRIES;
-		},
+		queryFn: () =>
+			listOverview({
+				start,
+				end,
+				show_ip: showIp,
+				filter,
+			}),
 	});
 };

frontend/src/pages/AllErrors/QueryStateContext.ts

@@ -1,23 +0,0 @@
-import { create } from 'zustand';
-
-interface AllErrorsQueryState {
-	isFetching: boolean;
-	isCancelled: boolean;
-	setIsFetching: (isFetching: boolean) => void;
-	setIsCancelled: (isCancelled: boolean) => void;
-}
-
-export const useAllErrorsQueryState = create<AllErrorsQueryState>((set) => ({
-	isFetching: false,
-	isCancelled: false,
-	setIsFetching: (isFetching): void => {
-		set((state) => ({
-			isFetching,
-			// Auto-reset cancelled when a new fetch starts
-			isCancelled: isFetching ? false : state.isCancelled,
-		}));
-	},
-	setIsCancelled: (isCancelled): void => {
-		set({ isCancelled });
-	},
-}));

frontend/src/pages/AllErrors/index.tsx

@@ -1,5 +1,4 @@
-import { useCallback, useState } from 'react';
-import { useQueryClient } from 'react-query';
+import { useState } from 'react';
 import { useLocation } from 'react-router-dom';
 import { FilterOutlined } from '@ant-design/icons';
 import { Button, Tooltip } from 'antd';
@@ -20,22 +19,12 @@ import history from 'lib/history';
 import { isNull } from 'lodash-es';
 
 import { routes } from './config';
-import { useAllErrorsQueryState } from './QueryStateContext';
 
 import './AllErrors.styles.scss';
 
 function AllErrors(): JSX.Element {
 	const { pathname } = useLocation();
 	const { handleRunQuery } = useQueryBuilder();
-	const queryClient = useQueryClient();
-
-	const isLoadingQueries = useAllErrorsQueryState((s) => s.isFetching);
-	const setIsCancelled = useAllErrorsQueryState((s) => s.setIsCancelled);
-	const handleCancelQuery = useCallback(() => {
-		queryClient.cancelQueries(['getAllErrors']);
-		queryClient.cancelQueries(['getErrorCounts']);
-		setIsCancelled(true);
-	}, [queryClient, setIsCancelled]);
 
 	const [showFilters, setShowFilters] = useState<boolean>(() => {
 		const localStorageValue = getLocalStorageKey(
@@ -88,11 +77,7 @@ function AllErrors(): JSX.Element {
 							}
 							rightActions={
 								<div className="right-toolbar-actions-container">
-									<RightToolbarActions
-										onStageRunQuery={handleRunQuery}
-										isLoadingQueries={isLoadingQueries}
-										handleCancelQuery={handleCancelQuery}
-									/>
+									<RightToolbarActions onStageRunQuery={handleRunQuery} />
 									<HeaderRightSection
 										enableAnnouncements={false}
 										enableShare

frontend/src/pages/LogsExplorer/index.tsx

@@ -1,12 +1,10 @@
 import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
-import { useQueryClient } from 'react-query';
 import * as Sentry from '@sentry/react';
 import getLocalStorageKey from 'api/browser/localstorage/get';
 import setLocalStorageApi from 'api/browser/localstorage/set';
 import { TelemetryFieldKey } from 'api/v5/v5';
 import cx from 'classnames';
 import ExplorerCard from 'components/ExplorerCard/ExplorerCard';
-import QueryCancelledPlaceholder from 'components/QueryCancelledPlaceholder';
 import QuickFilters from 'components/QuickFilters/QuickFilters';
 import { QuickFiltersSource, SignalType } from 'components/QuickFilters/types';
 import WarningPopover from 'components/WarningPopover/WarningPopover';
@@ -76,27 +74,6 @@ function LogsExplorer(): JSX.Element {
 	const chartQueryKeyRef = useRef<any>();
 
 	const [isLoadingQueries, setIsLoadingQueries] = useState<boolean>(false);
-	const [isCancelled, setIsCancelled] = useState(false);
-
-	useEffect(() => {
-		if (isLoadingQueries) {
-			setIsCancelled(false);
-		}
-	}, [isLoadingQueries]);
-
-	const queryClient = useQueryClient();
-	const handleCancelQuery = useCallback(() => {
-		if (listQueryKeyRef.current) {
-			queryClient.cancelQueries(listQueryKeyRef.current);
-		}
-		if (chartQueryKeyRef.current) {
-			queryClient.cancelQueries(chartQueryKeyRef.current);
-		}
-		setIsCancelled(true);
-		// Reset loading state — the views container unmounts when cancelled, so
-		// no child will call setIsLoadingQueries(false) otherwise.
-		setIsLoadingQueries(false);
-	}, [queryClient]);
 
 	const [warning, setWarning] = useState<Warning | undefined>(undefined);
 
@@ -319,12 +296,10 @@ function LogsExplorer(): JSX.Element {
 							}
 							rightActions={
 								<RightToolbarActions
-									onStageRunQuery={(): void => {
-										setIsCancelled(false);
-										handleRunQuery();
-									}}
+									onStageRunQuery={(): void => handleRunQuery()}
+									listQueryKeyRef={listQueryKeyRef}
+									chartQueryKeyRef={chartQueryKeyRef}
 									isLoadingQueries={isLoadingQueries}
-									handleCancelQuery={handleCancelQuery}
 									showLiveLogs={showLiveLogs}
 								/>
 							}
@@ -340,18 +315,14 @@ function LogsExplorer(): JSX.Element {
 								</ExplorerCard>
 							</div>
 							<div className="logs-explorer-views">
-								{isCancelled ? (
-									<QueryCancelledPlaceholder subText='Click "Run Query" to load logs.' />
-								) : (
-									<LogsExplorerViewsContainer
-										listQueryKeyRef={listQueryKeyRef}
-										chartQueryKeyRef={chartQueryKeyRef}
-										setIsLoadingQueries={setIsLoadingQueries}
-										setWarning={setWarning}
-										showLiveLogs={showLiveLogs}
-										handleChangeSelectedView={handleChangeSelectedView}
-									/>
-								)}
+								<LogsExplorerViewsContainer
+									listQueryKeyRef={listQueryKeyRef}
+									chartQueryKeyRef={chartQueryKeyRef}
+									setIsLoadingQueries={setIsLoadingQueries}
+									setWarning={setWarning}
+									showLiveLogs={showLiveLogs}
+									handleChangeSelectedView={handleChangeSelectedView}
+								/>
 							</div>
 						</div>
 					</section>

frontend/src/pages/TracesExplorer/index.tsx

@@ -1,12 +1,10 @@
 import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
-import { useQueryClient } from 'react-query';
 import { useSearchParams } from 'react-router-dom-v5-compat';
 import * as Sentry from '@sentry/react';
 import { Card } from 'antd';
 import logEvent from 'api/common/logEvent';
 import cx from 'classnames';
 import ExplorerCard from 'components/ExplorerCard/ExplorerCard';
-import QueryCancelledPlaceholder from 'components/QueryCancelledPlaceholder';
 import QuickFilters from 'components/QuickFilters/QuickFilters';
 import { QuickFiltersSource, SignalType } from 'components/QuickFilters/types';
 import WarningPopover from 'components/WarningPopover/WarningPopover';
@@ -73,29 +71,11 @@ function TracesExplorer(): JSX.Element {
 	});
 
 	const [searchParams] = useSearchParams();
-	const queryClient = useQueryClient();
 	const listQueryKeyRef = useRef<any>();
 
 	// Get panel type from URL
 	const panelTypesFromUrl = useGetPanelTypesQueryParam(PANEL_TYPES.LIST);
 	const [isLoadingQueries, setIsLoadingQueries] = useState<boolean>(false);
-	const [isCancelled, setIsCancelled] = useState(false);
-
-	useEffect(() => {
-		if (isLoadingQueries) {
-			setIsCancelled(false);
-		}
-	}, [isLoadingQueries]);
-
-	const handleCancelQuery = useCallback(() => {
-		if (listQueryKeyRef.current) {
-			queryClient.cancelQueries(listQueryKeyRef.current);
-		}
-		setIsCancelled(true);
-		// Reset loading state — the active view unmounts when cancelled, so no
-		// child will call setIsLoadingQueries(false) otherwise.
-		setIsLoadingQueries(false);
-	}, [queryClient]);
 
 	const [selectedView, setSelectedView] = useState<ExplorerViews>(() =>
 		getExplorerViewFromUrl(searchParams, panelTypesFromUrl),
@@ -230,12 +210,9 @@ function TracesExplorer(): JSX.Element {
 							}
 							rightActions={
 								<RightToolbarActions
-									onStageRunQuery={(): void => {
-										setIsCancelled(false);
-										handleRunQuery();
-									}}
+									onStageRunQuery={(): void => handleRunQuery()}
 									isLoadingQueries={isLoadingQueries}
-									handleCancelQuery={handleCancelQuery}
+									listQueryKeyRef={listQueryKeyRef}
 								/>
 							}
 						/>
@@ -247,11 +224,7 @@ function TracesExplorer(): JSX.Element {
 					</ExplorerCard>
 
 					<div className="traces-explorer-views">
-						{isCancelled && (
-							<QueryCancelledPlaceholder subText='Click "Run Query" to load traces.' />
-						)}
-
-						{!isCancelled && selectedView === ExplorerViews.LIST && (
+						{selectedView === ExplorerViews.LIST && (
 							<div className="trace-explorer-list-view">
 								<ListView
 									isFilterApplied={isFilterApplied}
@@ -262,7 +235,7 @@ function TracesExplorer(): JSX.Element {
 							</div>
 						)}
 
-						{!isCancelled && selectedView === ExplorerViews.TRACE && (
+						{selectedView === ExplorerViews.TRACE && (
 							<div className="trace-explorer-traces-view">
 								<TracesView
 									isFilterApplied={isFilterApplied}
@@ -273,7 +246,7 @@ function TracesExplorer(): JSX.Element {
 							</div>
 						)}
 
-						{!isCancelled && selectedView === ExplorerViews.TIMESERIES && (
+						{selectedView === ExplorerViews.TIMESERIES && (
 							<div className="trace-explorer-time-series-view">
 								<TimeSeriesView
 									dataSource={DataSource.TRACES}
@@ -285,7 +258,7 @@ function TracesExplorer(): JSX.Element {
 							</div>
 						)}
 
-						{!isCancelled && selectedView === ExplorerViews.TABLE && (
+						{selectedView === ExplorerViews.TABLE && (
 							<div className="trace-explorer-table-view">
 								<TableView
 									setWarning={setWarning}

go.mod

@@ -5,7 +5,7 @@ go 1.25.7
 require (
 	dario.cat/mergo v1.0.2
 	github.com/AfterShip/clickhouse-sql-parser v0.4.16
-	github.com/ClickHouse/clickhouse-go/v2 v2.40.1
+	github.com/ClickHouse/clickhouse-go/v2 v2.43.0
 	github.com/DATA-DOG/go-sqlmock v1.5.2
 	github.com/SigNoz/govaluate v0.0.0-20240203125216-988004ccc7fd
 	github.com/SigNoz/signoz-otel-collector v0.144.3-rc.4
@@ -30,15 +30,15 @@ require (
 	github.com/gorilla/mux v1.8.1
 	github.com/gorilla/websocket v1.5.4-0.20250319132907-e064f32e3674
 	github.com/huandu/go-sqlbuilder v1.39.1
-	github.com/jackc/pgx/v5 v5.8.0
+	github.com/jackc/pgx/v5 v5.9.1
 	github.com/json-iterator/go v1.1.13-0.20220915233716-71ac16282d12
 	github.com/knadh/koanf v1.5.0
 	github.com/knadh/koanf/v2 v2.3.2
 	github.com/mailru/easyjson v0.9.0
 	github.com/open-telemetry/opamp-go v0.22.0
 	github.com/open-telemetry/opentelemetry-collector-contrib/pkg/stanza v0.144.0
-	github.com/openfga/api/proto v0.0.0-20250909172242-b4b2a12f5c67
-	github.com/openfga/language/pkg/go v0.2.0-beta.2.0.20251027165255-0f8f255e5f6c
+	github.com/openfga/api/proto v0.0.0-20260319214821-f153694bfc20
+	github.com/openfga/language/pkg/go v0.2.1
 	github.com/opentracing/opentracing-go v1.2.0
 	github.com/perses/perses v0.53.1
 	github.com/pkg/errors v0.9.1
@@ -66,13 +66,12 @@ require (
 	github.com/uptrace/bun/dialect/pgdialect v1.2.9
 	github.com/uptrace/bun/dialect/sqlitedialect v1.2.9
 	github.com/uptrace/bun/extra/bunotel v1.2.9
-	github.com/yuin/goldmark v1.7.16
 	go.opentelemetry.io/collector/confmap v1.51.0
 	go.opentelemetry.io/collector/otelcol v0.144.0
 	go.opentelemetry.io/collector/pdata v1.51.0
 	go.opentelemetry.io/contrib/config v0.10.0
 	go.opentelemetry.io/contrib/instrumentation/github.com/gorilla/mux/otelmux v0.63.0
-	go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.65.0
+	go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.68.0
 	go.opentelemetry.io/otel v1.43.0
 	go.opentelemetry.io/otel/metric v1.43.0
 	go.opentelemetry.io/otel/sdk v1.43.0
@@ -80,7 +79,7 @@ require (
 	go.uber.org/multierr v1.11.0
 	go.uber.org/zap v1.27.1
 	golang.org/x/crypto v0.49.0
-	golang.org/x/exp v0.0.0-20260112195511-716be5621a96
+	golang.org/x/exp v0.0.0-20260312153236-7ab1446f8b90
 	golang.org/x/net v0.52.0
 	golang.org/x/oauth2 v0.35.0
 	golang.org/x/sync v0.20.0
@@ -91,7 +90,7 @@ require (
 	gopkg.in/yaml.v2 v2.4.0
 	gopkg.in/yaml.v3 v3.0.1
 	k8s.io/apimachinery v0.35.2
-	modernc.org/sqlite v1.40.1
+	modernc.org/sqlite v1.48.2
 )
 
 require (
@@ -136,7 +135,7 @@ require (
 	github.com/leodido/go-urn v1.4.0 // indirect
 	github.com/mattn/go-isatty v0.0.20 // indirect
 	github.com/muhlemmer/gu v0.3.1 // indirect
-	github.com/ncruces/go-strftime v0.1.9 // indirect
+	github.com/ncruces/go-strftime v1.0.0 // indirect
 	github.com/perses/common v0.30.2 // indirect
 	github.com/prometheus/client_golang/exp v0.0.0-20260108101519-fb0838f53562 // indirect
 	github.com/redis/go-redis/extra/rediscmd/v9 v9.15.1 // indirect
@@ -156,7 +155,7 @@ require (
 	go.opentelemetry.io/collector/pdata/xpdata v0.144.0 // indirect
 	go.yaml.in/yaml/v2 v2.4.3 // indirect
 	golang.org/x/arch v0.20.0 // indirect
-	modernc.org/libc v1.66.10 // indirect
+	modernc.org/libc v1.70.0 // indirect
 	modernc.org/mathutil v1.7.1 // indirect
 	modernc.org/memory v1.11.0 // indirect
 )
@@ -170,7 +169,7 @@ require (
 	github.com/Azure/azure-sdk-for-go/sdk/azidentity v1.13.1 // indirect
 	github.com/Azure/azure-sdk-for-go/sdk/internal v1.11.2 // indirect
 	github.com/AzureAD/microsoft-authentication-library-for-go v1.6.0 // indirect
-	github.com/ClickHouse/ch-go v0.67.0 // indirect
+	github.com/ClickHouse/ch-go v0.71.0 // indirect
 	github.com/Masterminds/squirrel v1.5.4 // indirect
 	github.com/Yiling-J/theine-go v0.6.2 // indirect
 	github.com/alecthomas/units v0.0.0-20240927000941-0f3dac36c52b
@@ -191,7 +190,7 @@ require (
 	github.com/edsrzf/mmap-go v1.2.0 // indirect
 	github.com/elastic/lunes v0.2.0 // indirect
 	github.com/emirpasic/gods v1.18.1 // indirect
-	github.com/envoyproxy/protoc-gen-validate v1.3.0 // indirect
+	github.com/envoyproxy/protoc-gen-validate v1.3.3 // indirect
 	github.com/expr-lang/expr v1.17.7
 	github.com/facette/natsort v0.0.0-20181210072756-2cd4dd1e2dcb // indirect
 	github.com/felixge/httpsnoop v1.0.4 // indirect
@@ -217,7 +216,7 @@ require (
 	github.com/golang/protobuf v1.5.4 // indirect
 	github.com/golang/snappy v1.0.0 // indirect
 	github.com/google/btree v1.1.3 // indirect
-	github.com/google/cel-go v0.27.0 // indirect
+	github.com/google/cel-go v0.28.0 // indirect
 	github.com/google/s2a-go v0.1.9 // indirect
 	github.com/googleapis/enterprise-certificate-proxy v0.3.11 // indirect
 	github.com/googleapis/gax-go/v2 v2.16.0 // indirect
@@ -246,7 +245,7 @@ require (
 	github.com/josharian/intern v1.0.0 // indirect
 	github.com/jpillora/backoff v1.0.0 // indirect
 	github.com/jtolds/gls v4.20.0+incompatible // indirect
-	github.com/klauspost/compress v1.18.3 // indirect
+	github.com/klauspost/compress v1.18.4 // indirect
 	github.com/klauspost/cpuid/v2 v2.3.0 // indirect
 	github.com/kylelemons/godebug v1.1.0 // indirect
 	github.com/lann/builder v0.0.0-20180802200727-47ae307949d0 // indirect
@@ -277,14 +276,14 @@ require (
 	github.com/open-telemetry/opentelemetry-collector-contrib/internal/exp/metrics v0.145.0 // indirect
 	github.com/open-telemetry/opentelemetry-collector-contrib/pkg/pdatautil v0.145.0 // indirect
 	github.com/open-telemetry/opentelemetry-collector-contrib/processor/deltatocumulativeprocessor v0.145.0 // indirect
-	github.com/openfga/openfga v1.11.2
-	github.com/paulmach/orb v0.11.1 // indirect
+	github.com/openfga/openfga v1.14.1
+	github.com/paulmach/orb v0.12.0 // indirect
 	github.com/pelletier/go-toml/v2 v2.2.4 // indirect
-	github.com/pierrec/lz4/v4 v4.1.23 // indirect
+	github.com/pierrec/lz4/v4 v4.1.25 // indirect
 	github.com/pkg/browser v0.0.0-20240102092130-5ac0b6a4141c // indirect
 	github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 // indirect
 	github.com/power-devops/perfstat v0.0.0-20240221224432-82ca36839d55 // indirect
-	github.com/pressly/goose/v3 v3.26.0 // indirect
+	github.com/pressly/goose/v3 v3.27.0 // indirect
 	github.com/prometheus/client_model v0.6.2 // indirect
 	github.com/prometheus/exporter-toolkit v0.15.1 // indirect
 	github.com/prometheus/otlptranslator v1.0.0 // indirect
@@ -294,7 +293,7 @@ require (
 	github.com/robfig/cron/v3 v3.0.1 // indirect
 	github.com/sagikazarmark/locafero v0.9.0 // indirect
 	github.com/sean-/seed v0.0.0-20170313163322-e2103e2c3529 // indirect
-	github.com/segmentio/asm v1.2.0 // indirect
+	github.com/segmentio/asm v1.2.1 // indirect
 	github.com/segmentio/backo-go v1.0.1 // indirect
 	github.com/sethvargo/go-retry v0.3.0 // indirect
 	github.com/shirou/gopsutil/v4 v4.25.12 // indirect
@@ -371,7 +370,7 @@ require (
 	go.opentelemetry.io/otel/exporters/otlp/otlpmetric/otlpmetricgrpc v1.39.0 // indirect
 	go.opentelemetry.io/otel/exporters/otlp/otlpmetric/otlpmetrichttp v1.43.0 // indirect
 	go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.43.0 // indirect
-	go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc v1.40.0 // indirect
+	go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc v1.43.0 // indirect
 	go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp v1.43.0 // indirect
 	go.opentelemetry.io/otel/exporters/prometheus v0.60.0
 	go.opentelemetry.io/otel/exporters/stdout/stdoutlog v0.14.0 // indirect
@@ -384,12 +383,12 @@ require (
 	go.uber.org/atomic v1.11.0 // indirect
 	go.uber.org/mock v0.6.0 // indirect
 	go.yaml.in/yaml/v3 v3.0.4 // indirect
-	golang.org/x/mod v0.33.0 // indirect
+	golang.org/x/mod v0.34.0 // indirect
 	golang.org/x/sys v0.42.0 // indirect
 	golang.org/x/time v0.14.0 // indirect
-	golang.org/x/tools v0.42.0 // indirect
+	golang.org/x/tools v0.43.0 // indirect
 	google.golang.org/genproto/googleapis/api v0.0.0-20260401024825-9d38bb4040a9 // indirect
-	google.golang.org/genproto/googleapis/rpc v0.0.0-20260401024825-9d38bb4040a9
+	google.golang.org/genproto/googleapis/rpc v0.0.0-20260406210006-6f92a3bedf2d
 	google.golang.org/grpc v1.80.0 // indirect
 	gopkg.in/telebot.v3 v3.3.8 // indirect
 	k8s.io/client-go v0.35.2 // indirect

go.sum

@@ -64,8 +64,8 @@ cloud.google.com/go/storage v1.14.0/go.mod h1:GrKmX003DSIwi9o29oFT7YDnHYwZoctc3f
 dario.cat/mergo v1.0.2 h1:85+piFYR1tMbRrLcDwR18y4UKJ3aH1Tbzi24VRW1TK8=
 dario.cat/mergo v1.0.2/go.mod h1:E/hbnu0NxMFBjpMIE34DRGLWqDy0g5FuKDhCb31ngxA=
 dmitri.shuralyov.com/gpu/mtl v0.0.0-20190408044501-666a987793e9/go.mod h1:H6x//7gZCb22OMCxBHrMx7a5I7Hp++hsVxbQ4BYO7hU=
-filippo.io/edwards25519 v1.1.1 h1:YpjwWWlNmGIDyXOn8zLzqiD+9TyIlPhGFG96P39uBpw=
-filippo.io/edwards25519 v1.1.1/go.mod h1:BxyFTGdWcka3PhytdK4V28tE5sGfRvvvRV7EaN4VDT4=
+filippo.io/edwards25519 v1.2.0 h1:crnVqOiS4jqYleHd9vaKZ+HKtHfllngJIiOpNpoJsjo=
+filippo.io/edwards25519 v1.2.0/go.mod h1:xzAOLCNug/yB62zG1bQ8uziwrIqIuxhctzJT18Q77mc=
 github.com/AfterShip/clickhouse-sql-parser v0.4.16 h1:gpl+wXclYUKT0p4+gBq22XeRYWwEoZ9f35vogqMvkLQ=
 github.com/AfterShip/clickhouse-sql-parser v0.4.16/go.mod h1:W0Z82wJWkJxz2RVun/RMwxue3g7ut47Xxl+SFqdJGus=
 github.com/Azure/azure-sdk-for-go v68.0.0+incompatible h1:fcYLmCpyNYRnvJbPerq7U0hS+6+I79yEDJBqVNcqUzU=
@@ -87,10 +87,10 @@ github.com/AzureAD/microsoft-authentication-library-for-go v1.6.0 h1:XRzhVemXdgv
 github.com/AzureAD/microsoft-authentication-library-for-go v1.6.0/go.mod h1:HKpQxkWaGLJ+D/5H8QRpyQXA1eKjxkFlOMwck5+33Jk=
 github.com/BurntSushi/toml v0.3.1/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03qcyfWMU=
 github.com/BurntSushi/xgb v0.0.0-20160522181843-27f122750802/go.mod h1:IVnqGOEym/WlBOVXweHU+Q+/VP0lqqI8lqeDx9IjBqo=
-github.com/ClickHouse/ch-go v0.67.0 h1:18MQF6vZHj+4/hTRaK7JbS/TIzn4I55wC+QzO24uiqc=
-github.com/ClickHouse/ch-go v0.67.0/go.mod h1:2MSAeyVmgt+9a2k2SQPPG1b4qbTPzdGDpf1+bcHh+18=
-github.com/ClickHouse/clickhouse-go/v2 v2.40.1 h1:PbwsHBgqXRydU7jKULD1C8CHmifczffvQqmFvltM2W4=
-github.com/ClickHouse/clickhouse-go/v2 v2.40.1/go.mod h1:GDzSBLVhladVm8V01aEB36IoBOVLLICfyeuiIp/8Ezc=
+github.com/ClickHouse/ch-go v0.71.0 h1:bUdZ/EZj/LcVHsMqaRUP2holqygrPWQKeMjc6nZoyRM=
+github.com/ClickHouse/ch-go v0.71.0/go.mod h1:NwbNc+7jaqfY58dmdDUbG4Jl22vThgx1cYjBw0vtgXw=
+github.com/ClickHouse/clickhouse-go/v2 v2.43.0 h1:fUR05TrF1GyvLDa/mAQjkx7KbgwdLRffs2n9O3WobtE=
+github.com/ClickHouse/clickhouse-go/v2 v2.43.0/go.mod h1:o6jf7JM/zveWC/PP277BLxjHy5KjnGX/jfljhM4s34g=
 github.com/Code-Hex/go-generics-cache v1.5.1 h1:6vhZGc5M7Y/YD8cIUcY8kcuQLB4cHR7U+0KMqAA0KcU=
 github.com/Code-Hex/go-generics-cache v1.5.1/go.mod h1:qxcC9kRVrct9rHeiYpFWSoW1vxyillCVzX13KZG8dl4=
 github.com/DATA-DOG/go-sqlmock v1.5.2 h1:OcvFkGmslmlZibjAjaHm3L//6LiuBgolP7OputlJIzU=
@@ -303,8 +303,8 @@ github.com/envoyproxy/go-control-plane v0.14.0 h1:hbG2kr4RuFj222B6+7T83thSPqLjwB
 github.com/envoyproxy/go-control-plane/envoy v1.36.0 h1:yg/JjO5E7ubRyKX3m07GF3reDNEnfOboJ0QySbH736g=
 github.com/envoyproxy/go-control-plane/envoy v1.36.0/go.mod h1:ty89S1YCCVruQAm9OtKeEkQLTb+Lkz0k8v9W0Oxsv98=
 github.com/envoyproxy/protoc-gen-validate v0.1.0/go.mod h1:iSmxcyjqTsJpI2R4NaDN7+kN2VEUnK/pcBlmesArF7c=
-github.com/envoyproxy/protoc-gen-validate v1.3.0 h1:TvGH1wof4H33rezVKWSpqKz5NXWg5VPuZ0uONDT6eb4=
-github.com/envoyproxy/protoc-gen-validate v1.3.0/go.mod h1:HvYl7zwPa5mffgyeTUHA9zHIH36nmrm7oCbo4YKoSWA=
+github.com/envoyproxy/protoc-gen-validate v1.3.3 h1:MVQghNeW+LZcmXe7SY1V36Z+WFMDjpqGAGacLe2T0ds=
+github.com/envoyproxy/protoc-gen-validate v1.3.3/go.mod h1:TsndJ/ngyIdQRhMcVVGDDHINPLWB7C82oDArY51KfB0=
 github.com/facette/natsort v0.0.0-20181210072756-2cd4dd1e2dcb h1:IT4JYU7k4ikYg1SCxNI1/Tieq/NFvh6dzLdgi7eu0tM=
 github.com/facette/natsort v0.0.0-20181210072756-2cd4dd1e2dcb/go.mod h1:bH6Xx7IW64qjjJq8M2u4dxNaBiDfKK+z/3eGDpXEQhc=
 github.com/fatih/color v1.7.0/go.mod h1:Zm6kSWBoL9eyXnKyktHP6abPY2pDugNf5KwzbycvMj4=
@@ -489,8 +489,8 @@ github.com/google/btree v0.0.0-20180813153112-4030bb1f1f0c/go.mod h1:lNA+9X1NB3Z
 github.com/google/btree v1.0.0/go.mod h1:lNA+9X1NB3Zf8V7Ke586lFgjr2dZNuvo3lPJSGZ5JPQ=
 github.com/google/btree v1.1.3 h1:CVpQJjYgC4VbzxeGVHfvZrv1ctoYCAI8vbl07Fcxlyg=
 github.com/google/btree v1.1.3/go.mod h1:qOPhT0dTNdNzV6Z/lhRX0YXUafgPLFUh+gZMl761Gm4=
-github.com/google/cel-go v0.27.0 h1:e7ih85+4qVrBuqQWTW4FKSqZYokVuc3HnhH5keboFTo=
-github.com/google/cel-go v0.27.0/go.mod h1:tTJ11FWqnhw5KKpnWpvW9CJC3Y9GK4EIS0WXnBbebzw=
+github.com/google/cel-go v0.28.0 h1:KjSWstCpz/MN5t4a8gnGJNIYUsJRpdi/r97xWDphIQc=
+github.com/google/cel-go v0.28.0/go.mod h1:X0bD6iVNR8pkROSOoHVdgTkzmRcosof7WQqCD6wcMc8=
 github.com/google/gnostic-models v0.7.0 h1:qwTtogB15McXDaNqTZdzPJRHvaVJlAl+HVQnLmJEJxo=
 github.com/google/gnostic-models v0.7.0/go.mod h1:whL5G0m6dmc5cPxKc5bdKdEN3UjI7OUGxBlw57miDrQ=
 github.com/google/go-cmp v0.2.0/go.mod h1:oXzfMopK8JAjlY9xF4vHSVASa0yLyX7SntLO5aqRK0M=
@@ -675,8 +675,8 @@ github.com/jackc/pgpassfile v1.0.0 h1:/6Hmqy13Ss2zCq62VdNG8tM1wchn8zjSGOBJ6icpsI
 github.com/jackc/pgpassfile v1.0.0/go.mod h1:CEx0iS5ambNFdcRtxPj5JhEz+xB6uRky5eyVu/W2HEg=
 github.com/jackc/pgservicefile v0.0.0-20240606120523-5a60cdf6a761 h1:iCEnooe7UlwOQYpKFhBabPMi4aNAfoODPEFNiAnClxo=
 github.com/jackc/pgservicefile v0.0.0-20240606120523-5a60cdf6a761/go.mod h1:5TJZWKEWniPve33vlWYSoGYefn3gLQRzjfDlhSJ9ZKM=
-github.com/jackc/pgx/v5 v5.8.0 h1:TYPDoleBBme0xGSAX3/+NujXXtpZn9HBONkQC7IEZSo=
-github.com/jackc/pgx/v5 v5.8.0/go.mod h1:QVeDInX2m9VyzvNeiCJVjCkNFqzsNb43204HshNSZKw=
+github.com/jackc/pgx/v5 v5.9.1 h1:uwrxJXBnx76nyISkhr33kQLlUqjv7et7b9FjCen/tdc=
+github.com/jackc/pgx/v5 v5.9.1/go.mod h1:mal1tBGAFfLHvZzaYh77YS/eC6IX9OWbRV1QIIM0Jn4=
 github.com/jackc/puddle/v2 v2.2.2 h1:PR8nw+E/1w0GLuRFSmiioY6UooMp6KJv0/61nB7icHo=
 github.com/jackc/puddle/v2 v2.2.2/go.mod h1:vriiEXHvEE654aYKXXjOvZM39qJ0q+azkZFrfEOc3H4=
 github.com/jessevdk/go-flags v1.6.1 h1:Cvu5U8UGrLay1rZfv/zP7iLpSHGUZ/Ou68T0iX1bBK4=
@@ -714,8 +714,8 @@ github.com/kisielk/errcheck v1.5.0/go.mod h1:pFxgyoBC7bSaBwPgfKdkLd5X25qrDl4LWUI
 github.com/kisielk/gotool v1.0.0/go.mod h1:XhKaO+MFFWcvkIS/tQcRk01m1F5IRFswLeQ+oQHNcck=
 github.com/kisielk/sqlstruct v0.0.0-20201105191214-5f3e10d3ab46/go.mod h1:yyMNCyc/Ib3bDTKd379tNMpB/7/H5TjM2Y9QJ5THLbE=
 github.com/klauspost/compress v1.13.6/go.mod h1:/3/Vjq9QcHkK5uEr5lBEmyoZ1iFhe47etQ6QUkpK6sk=
-github.com/klauspost/compress v1.18.3 h1:9PJRvfbmTabkOX8moIpXPbMMbYN60bWImDDU7L+/6zw=
-github.com/klauspost/compress v1.18.3/go.mod h1:R0h/fSBs8DE4ENlcrlib3PsXS61voFxhIs2DeRhCvJ4=
+github.com/klauspost/compress v1.18.4 h1:RPhnKRAQ4Fh8zU2FY/6ZFDwTVTxgJ/EMydqSTzE9a2c=
+github.com/klauspost/compress v1.18.4/go.mod h1:R0h/fSBs8DE4ENlcrlib3PsXS61voFxhIs2DeRhCvJ4=
 github.com/klauspost/cpuid/v2 v2.3.0 h1:S4CRMLnYUhGeDFDqkGriYKdfoFlDnMtqTiI/sFzhA9Y=
 github.com/klauspost/cpuid/v2 v2.3.0/go.mod h1:hqwkgyIinND0mEev00jJYCxPNVRVXFQeu1XKlok6oO0=
 github.com/knadh/koanf v1.5.0 h1:q2TSd/3Pyc/5yP9ldIrSdIz26MCcyNQzW0pEAugLPNs=
@@ -812,6 +812,10 @@ github.com/mitchellh/reflectwalk v1.0.2 h1:G2LzWKi524PWgd3mLHV8Y5k7s6XUvT0Gef6zx
 github.com/mitchellh/reflectwalk v1.0.2/go.mod h1:mSTlrgnPZtwu0c4WaC2kGObEpuNDbx0jmZXqmk4esnw=
 github.com/moby/docker-image-spec v1.3.1 h1:jMKff3w6PgbfSa69GfNg+zN/XLhfXJGnEx3Nl2EsFP0=
 github.com/moby/docker-image-spec v1.3.1/go.mod h1:eKmb5VW8vQEh/BAr2yvVNvuiJuY6UIocYsFu/DxxRpo=
+github.com/moby/moby/api v1.53.0 h1:PihqG1ncw4W+8mZs69jlwGXdaYBeb5brF6BL7mPIS/w=
+github.com/moby/moby/api v1.53.0/go.mod h1:8mb+ReTlisw4pS6BRzCMts5M49W5M7bKt1cJy/YbAqc=
+github.com/moby/moby/client v0.2.2 h1:Pt4hRMCAIlyjL3cr8M5TrXCwKzguebPAc2do2ur7dEM=
+github.com/moby/moby/client v0.2.2/go.mod h1:2EkIPVNCqR05CMIzL1mfA07t0HvVUUOl85pasRz/GmQ=
 github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
 github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd h1:TRLaZ9cD/w8PVh93nsPXa1VrQ6jlwL5oN8l14QlcNfg=
 github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
@@ -830,8 +834,8 @@ github.com/mwitkow/go-conntrack v0.0.0-20190716064945-2f068394615f h1:KUppIJq7/+
 github.com/mwitkow/go-conntrack v0.0.0-20190716064945-2f068394615f/go.mod h1:qRWi+5nqEBWmkhHvq77mSJWrCKwh8bxhgT7d/eI7P4U=
 github.com/natefinch/wrap v0.2.0 h1:IXzc/pw5KqxJv55gV0lSOcKHYuEZPGbQrOOXr/bamRk=
 github.com/natefinch/wrap v0.2.0/go.mod h1:6gMHlAl12DwYEfKP3TkuykYUfLSEAvHw67itm4/KAS8=
-github.com/ncruces/go-strftime v0.1.9 h1:bY0MQC28UADQmHmaF5dgpLmImcShSi2kHU9XLdhx/f4=
-github.com/ncruces/go-strftime v0.1.9/go.mod h1:Fwc5htZGVVkseilnfgOVb9mKy6w1naJmn9CehxcKcls=
+github.com/ncruces/go-strftime v1.0.0 h1:HMFp8mLCTPp341M/ZnA4qaf7ZlsbTc+miZjCLOFAw7w=
+github.com/ncruces/go-strftime v1.0.0/go.mod h1:Fwc5htZGVVkseilnfgOVb9mKy6w1naJmn9CehxcKcls=
 github.com/nexucis/lamenv v0.5.2 h1:tK/u3XGhCq9qIoVNcXsK9LZb8fKopm0A5weqSRvHd7M=
 github.com/nexucis/lamenv v0.5.2/go.mod h1:HusJm6ltmmT7FMG8A750mOLuME6SHCsr2iFYxp5fFi0=
 github.com/npillmayer/nestext v0.1.3/go.mod h1:h2lrijH8jpicr25dFY+oAJLyzlya6jhnuG+zWp9L0Uk=
@@ -874,12 +878,12 @@ github.com/opencontainers/go-digest v1.0.0 h1:apOUWs51W5PlhuyGyz9FCeeBIOUDA/6nW8
 github.com/opencontainers/go-digest v1.0.0/go.mod h1:0JzlMkj0TRzQZfJkVvzbP0HBR3IKzErnv2BNG4W4MAM=
 github.com/opencontainers/image-spec v1.1.1 h1:y0fUlFfIZhPF1W537XOLg0/fcx6zcHCJwooC2xJA040=
 github.com/opencontainers/image-spec v1.1.1/go.mod h1:qpqAh3Dmcf36wStyyWU+kCeDgrGnAve2nCC8+7h8Q0M=
-github.com/openfga/api/proto v0.0.0-20250909172242-b4b2a12f5c67 h1:58mhO5nqkdka2Mpg5mijuZOHScX7reowhzRciwjFCU8=
-github.com/openfga/api/proto v0.0.0-20250909172242-b4b2a12f5c67/go.mod h1:XDX4qYNBUM2Rsa2AbKPh+oocZc2zgme+EF2fFC6amVU=
-github.com/openfga/language/pkg/go v0.2.0-beta.2.0.20251027165255-0f8f255e5f6c h1:xPbHNFG8QbPr/fpL7u0MPI0x74/BCLm7Sx02btL1m5Q=
-github.com/openfga/language/pkg/go v0.2.0-beta.2.0.20251027165255-0f8f255e5f6c/go.mod h1:BG26d1Fk4GSg0wMj60TRJ6Pe4ka2WQ33akhO+mzt3t0=
-github.com/openfga/openfga v1.11.2 h1:6vFZSSE0pyyt9qz320BgQLh/sHxZY5nfPOcJ3d5g8Bg=
-github.com/openfga/openfga v1.11.2/go.mod h1:aCDb0gaWsU6dDAdC+zNOR2XC2W3lteGwKSkRWcSjGW8=
+github.com/openfga/api/proto v0.0.0-20260319214821-f153694bfc20 h1:xdVG0EDz9Z9Uhd7YZ5OMN1F8tkAz/Dpgdjxd0cuTBJo=
+github.com/openfga/api/proto v0.0.0-20260319214821-f153694bfc20/go.mod h1:XDX4qYNBUM2Rsa2AbKPh+oocZc2zgme+EF2fFC6amVU=
+github.com/openfga/language/pkg/go v0.2.1 h1:nmVJTPfjvaJC2EWGcy8HrUyL15KkIfjjnmB3VFVeCts=
+github.com/openfga/language/pkg/go v0.2.1/go.mod h1:wg+EuPmYIaM855F2uPygT1hJoWcoUxAoecgYC5akXsw=
+github.com/openfga/openfga v1.14.1 h1:z43+jLcv8FjaKKRf4WlMYZsfSXLvetcxkO8D4vApEQY=
+github.com/openfga/openfga v1.14.1/go.mod h1:AqMyFFi3y24Hko1mIME6ctOdCsCru2HA3uHX1vu9bMg=
 github.com/opentracing/opentracing-go v1.1.0/go.mod h1:UkNAQd3GIcIGf0SeVgPpRdFStlNbqXla1AfSYxPUl2o=
 github.com/opentracing/opentracing-go v1.2.0 h1:uEJPy/1a5RIPAJ0Ov+OIO8OxWu77jEv+1B0VhjKrZUs=
 github.com/opentracing/opentracing-go v1.2.0/go.mod h1:GxEUsuufX4nBwe+T+Wl9TAgYrxe9dPLANfrWvHYVTgc=
@@ -888,8 +892,8 @@ github.com/ovh/go-ovh v1.9.0/go.mod h1:cTVDnl94z4tl8pP1uZ/8jlVxntjSIf09bNcQ5TJSC
 github.com/pascaldekloe/goe v0.0.0-20180627143212-57f6aae5913c/go.mod h1:lzWF7FIEvWOWxwDKqyGYQf6ZUaNfKdP144TG7ZOy1lc=
 github.com/pascaldekloe/goe v0.1.0 h1:cBOtyMzM9HTpWjXfbbunk26uA6nG3a8n06Wieeh0MwY=
 github.com/pascaldekloe/goe v0.1.0/go.mod h1:lzWF7FIEvWOWxwDKqyGYQf6ZUaNfKdP144TG7ZOy1lc=
-github.com/paulmach/orb v0.11.1 h1:3koVegMC4X/WeiXYz9iswopaTwMem53NzTJuTF20JzU=
-github.com/paulmach/orb v0.11.1/go.mod h1:5mULz1xQfs3bmQm63QEJA6lNGujuRafwA5S/EnuLaLU=
+github.com/paulmach/orb v0.12.0 h1:z+zOwjmG3MyEEqzv92UN49Lg1JFYx0L9GpGKNVDKk1s=
+github.com/paulmach/orb v0.12.0/go.mod h1:5mULz1xQfs3bmQm63QEJA6lNGujuRafwA5S/EnuLaLU=
 github.com/paulmach/protoscan v0.2.1/go.mod h1:SpcSwydNLrxUGSDvXvO0P7g7AuhJ7lcKfDlhJCDw2gY=
 github.com/pborman/getopt v0.0.0-20170112200414-7148bc3a4c30/go.mod h1:85jBQOZwpVEaDAr341tbn15RS4fCAsIst0qp7i8ex1o=
 github.com/pelletier/go-toml v1.7.0/go.mod h1:vwGMzjaWMwyfHwgIBhI2YUM4fB6nL6lVAvS1LBMMhTE=
@@ -903,8 +907,8 @@ github.com/perses/common v0.30.2/go.mod h1:DFtur1QPah2/ChXbKKhw7djYdwNgz27s5fPKp
 github.com/perses/perses v0.53.1 h1:9VY/6p9QWrZwPSV7qiwTMSOsgcB37Lb1AXKT0ORXc6I=
 github.com/perses/perses v0.53.1/go.mod h1:ro8fsgBkHYOdrL/MV+fdP9mflKzYCy/+gcbxiaReI/A=
 github.com/pierrec/lz4 v2.0.5+incompatible/go.mod h1:pdkljMzZIN41W+lC3N2tnIh5sFi+IEE17M5jbnwPHcY=
-github.com/pierrec/lz4/v4 v4.1.23 h1:oJE7T90aYBGtFNrI8+KbETnPymobAhzRrR8Mu8n1yfU=
-github.com/pierrec/lz4/v4 v4.1.23/go.mod h1:EoQMVJgeeEOMsCqCzqFm2O0cJvljX2nGZjcRIPL34O4=
+github.com/pierrec/lz4/v4 v4.1.25 h1:kocOqRffaIbU5djlIBr7Wh+cx82C0vtFb0fOurZHqD0=
+github.com/pierrec/lz4/v4 v4.1.25/go.mod h1:EoQMVJgeeEOMsCqCzqFm2O0cJvljX2nGZjcRIPL34O4=
 github.com/pkg/browser v0.0.0-20240102092130-5ac0b6a4141c h1:+mdjkGKdHQG3305AYmdv1U2eRNDiU2ErMBj1gwrq8eQ=
 github.com/pkg/browser v0.0.0-20240102092130-5ac0b6a4141c/go.mod h1:7rwL4CYBLnjLxUqIJNnCWiEdr3bn6IUYi15bNlnbCCU=
 github.com/pkg/diff v0.0.0-20210226163009-20ebb0f2a09e/go.mod h1:pJLUxLENpZxwdsKMEsNbx1VGcRFpLqf3715MtcvvzbA=
@@ -922,8 +926,8 @@ github.com/posener/complete v1.1.1/go.mod h1:em0nMJCgc9GFtwrmVmEMR/ZL6WyhyjMBndr
 github.com/posener/complete v1.2.3/go.mod h1:WZIdtGGp+qx0sLrYKtIRAruyNpv6hFCicSgv7Sy7s/s=
 github.com/power-devops/perfstat v0.0.0-20240221224432-82ca36839d55 h1:o4JXh1EVt9k/+g42oCprj/FisM4qX9L3sZB3upGN2ZU=
 github.com/power-devops/perfstat v0.0.0-20240221224432-82ca36839d55/go.mod h1:OmDBASR4679mdNQnz2pUhc2G8CO2JrUAVFDRBDP/hJE=
-github.com/pressly/goose/v3 v3.26.0 h1:KJakav68jdH0WDvoAcj8+n61WqOIaPGgH0bJWS6jpmM=
-github.com/pressly/goose/v3 v3.26.0/go.mod h1:4hC1KrritdCxtuFsqgs1R4AU5bWtTAf+cnWvfhf2DNY=
+github.com/pressly/goose/v3 v3.27.0 h1:/D30gVTuQhu0WsNZYbJi4DMOsx1lNq+6SkLe+Wp59BM=
+github.com/pressly/goose/v3 v3.27.0/go.mod h1:3ZBeCXqzkgIRvrEMDkYh1guvtoJTU5oMMuDdkutoM78=
 github.com/prometheus/alertmanager v0.31.0 h1:DQW02uIUNNiAa9AD9VA5xaFw5D+xrV+bocJc4gN9bEU=
 github.com/prometheus/alertmanager v0.31.0/go.mod h1:zWPQwhbLt2ybee8rL921UONeQ59Oncash+m/hGP17tU=
 github.com/prometheus/client_golang v0.9.1/go.mod h1:7SWBe2y4D6OKWSNQJUaRYU/AaXPKyh/dDVn+NZz0KFw=
@@ -1008,8 +1012,8 @@ github.com/sebdah/goldie/v2 v2.5.3 h1:9ES/mNN+HNUbNWpVAlrzuZ7jE+Nrczbj8uFRjM7624
 github.com/sebdah/goldie/v2 v2.5.3/go.mod h1:oZ9fp0+se1eapSRjfYbsV/0Hqhbuu3bJVvKI/NNtssI=
 github.com/segmentio/analytics-go/v3 v3.2.1 h1:G+f90zxtc1p9G+WigVyTR0xNfOghOGs/PYAlljLOyeg=
 github.com/segmentio/analytics-go/v3 v3.2.1/go.mod h1:p8owAF8X+5o27jmvUognuXxdtqvSGtD0ZrfY2kcS9bE=
-github.com/segmentio/asm v1.2.0 h1:9BQrFxC+YOHJlTlHGkTrFWf59nbL3XnCoFLTwDCI7ys=
-github.com/segmentio/asm v1.2.0/go.mod h1:BqMnlJP91P8d+4ibuonYZw9mfnzI9HfxselHZr5aAcs=
+github.com/segmentio/asm v1.2.1 h1:DTNbBqs57ioxAD4PrArqftgypG4/qNpXoJx8TVXxPR0=
+github.com/segmentio/asm v1.2.1/go.mod h1:BqMnlJP91P8d+4ibuonYZw9mfnzI9HfxselHZr5aAcs=
 github.com/segmentio/backo-go v1.0.1 h1:68RQccglxZeyURy93ASB/2kc9QudzgIDexJ927N++y4=
 github.com/segmentio/backo-go v1.0.1/go.mod h1:9/Rh6yILuLysoQnZ2oNooD2g7aBnvM7r/fNVxRNWfBc=
 github.com/sergi/go-diff v1.4.0 h1:n/SP9D5ad1fORl+llWyN+D6qoUETXNZARKjyY2/KVCw=
@@ -1153,8 +1157,6 @@ github.com/yuin/goldmark v1.1.27/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9de
 github.com/yuin/goldmark v1.1.32/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
 github.com/yuin/goldmark v1.2.1/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
 github.com/yuin/goldmark v1.3.5/go.mod h1:mwnBkeHKe2W/ZEtQ+71ViKU8L12m81fl3OWwC1Zlc8k=
-github.com/yuin/goldmark v1.7.16 h1:n+CJdUxaFMiDUNnWC3dMWCIQJSkxH4uz3ZwQBkAlVNE=
-github.com/yuin/goldmark v1.7.16/go.mod h1:ip/1k0VRfGynBgxOz0yCqHrbZXhcjxyuS66Brc7iBKg=
 github.com/yusufpapurcu/wmi v1.2.4 h1:zFUKzehAFReQwLys1b/iSMl+JQGSCSjtVqQn9bBrPo0=
 github.com/yusufpapurcu/wmi v1.2.4/go.mod h1:SBZ9tNy3G9/m5Oi98Zks0QjeHVDvuK0qfxQmPyzfmi0=
 github.com/zeebo/assert v1.3.1 h1:vukIABvugfNMZMQO1ABsyQDJDTVQbn+LWSMy1ol1h6A=
@@ -1310,8 +1312,8 @@ go.opentelemetry.io/contrib/instrumentation/github.com/gorilla/mux/otelmux v0.63
 go.opentelemetry.io/contrib/instrumentation/github.com/gorilla/mux/otelmux v0.63.0/go.mod h1:34csimR1lUhdT5HH4Rii9aKPrvBcnFRwxLwcevsU+Kk=
 go.opentelemetry.io/contrib/instrumentation/net/http/httptrace/otelhttptrace v0.65.0 h1:ab5U7DpTjjN8pNgwqlA/s0Csb+N2Raqo9eTSDhfg4Z8=
 go.opentelemetry.io/contrib/instrumentation/net/http/httptrace/otelhttptrace v0.65.0/go.mod h1:nwFJC46Dxhqz5R9k7IV8To/Z46JPvW+GNKhTxQQlUzg=
-go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.65.0 h1:7iP2uCb7sGddAr30RRS6xjKy7AZ2JtTOPA3oolgVSw8=
-go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.65.0/go.mod h1:c7hN3ddxs/z6q9xwvfLPk+UHlWRQyaeR1LdgfL/66l0=
+go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.68.0 h1:CqXxU8VOmDefoh0+ztfGaymYbhdB/tT3zs79QaZTNGY=
+go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.68.0/go.mod h1:BuhAPThV8PBHBvg8ZzZ/Ok3idOdhWIodywz2xEcRbJo=
 go.opentelemetry.io/contrib/otelconf v0.18.0 h1:ciF2Gf00BWs0DnexKFZXcxg9kJ8r3SUW1LOzW3CsKA8=
 go.opentelemetry.io/contrib/otelconf v0.18.0/go.mod h1:FcP7k+JLwBLdOxS6qY6VQ/4b5VBntI6L6o80IMwhAeI=
 go.opentelemetry.io/contrib/propagators/b3 v1.39.0 h1:PI7pt9pkSnimWcp5sQhUA9OzLbc3Ba4sL+VEUTNsxrk=
@@ -1330,8 +1332,8 @@ go.opentelemetry.io/otel/exporters/otlp/otlpmetric/otlpmetrichttp v1.43.0 h1:w1K
 go.opentelemetry.io/otel/exporters/otlp/otlpmetric/otlpmetrichttp v1.43.0/go.mod h1:HBy4BjzgVE8139ieRI75oXm3EcDN+6GhD88JT1Kjvxg=
 go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.43.0 h1:88Y4s2C8oTui1LGM6bTWkw0ICGcOLCAI5l6zsD1j20k=
 go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.43.0/go.mod h1:Vl1/iaggsuRlrHf/hfPJPvVag77kKyvrLeD10kpMl+A=
-go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc v1.40.0 h1:DvJDOPmSWQHWywQS6lKL+pb8s3gBLOZUtw4N+mavW1I=
-go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc v1.40.0/go.mod h1:EtekO9DEJb4/jRyN4v4Qjc2yA7AtfCBuz2FynRUWTXs=
+go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc v1.43.0 h1:RAE+JPfvEmvy+0LzyUA25/SGawPwIUbZ6u0Wug54sLc=
+go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc v1.43.0/go.mod h1:AGmbycVGEsRx9mXMZ75CsOyhSP6MFIcj/6dnG+vhVjk=
 go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp v1.43.0 h1:3iZJKlCZufyRzPzlQhUIWVmfltrXuGyfjREgGP3UUjc=
 go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp v1.43.0/go.mod h1:/G+nUPfhq2e+qiXMGxMwumDrP5jtzU+mWN7/sjT2rak=
 go.opentelemetry.io/otel/exporters/prometheus v0.60.0 h1:cGtQxGvZbnrWdC2GyjZi0PDKVSLWP/Jocix3QWfXtbo=
@@ -1412,8 +1414,8 @@ golang.org/x/exp v0.0.0-20191227195350-da58074b4299/go.mod h1:2RIsYlXP63K8oxa1u0
 golang.org/x/exp v0.0.0-20200119233911-0405dc783f0a/go.mod h1:2RIsYlXP63K8oxa1u096TMicItID8zy7Y6sNkU49FU4=
 golang.org/x/exp v0.0.0-20200207192155-f17229e696bd/go.mod h1:J/WKrq2StrnmMY6+EHIKF9dgMWnmCNThgcyBT1FY9mM=
 golang.org/x/exp v0.0.0-20200224162631-6cc2880d07d6/go.mod h1:3jZMyOhIsHpP37uCMkUooju7aAi5cS1Q23tOzKc+0MU=
-golang.org/x/exp v0.0.0-20260112195511-716be5621a96 h1:Z/6YuSHTLOHfNFdb8zVZomZr7cqNgTJvA8+Qz75D8gU=
-golang.org/x/exp v0.0.0-20260112195511-716be5621a96/go.mod h1:nzimsREAkjBCIEFtHiYkrJyT+2uy9YZJB7H1k68CXZU=
+golang.org/x/exp v0.0.0-20260312153236-7ab1446f8b90 h1:jiDhWWeC7jfWqR9c/uplMOqJ0sbNlNWv0UkzE0vX1MA=
+golang.org/x/exp v0.0.0-20260312153236-7ab1446f8b90/go.mod h1:xE1HEv6b+1SCZ5/uscMRjUBKtIxworgEcEi+/n9NQDQ=
 golang.org/x/image v0.0.0-20190227222117-0694c2d4d067/go.mod h1:kZ7UVZpmo3dzQBMxlp+ypCbDeSB+sBbTgSJuh5dn5js=
 golang.org/x/image v0.0.0-20190802002840-cff245a6509b/go.mod h1:FeLwcggjj3mMvU+oOTbSwawSJRM1uh48EjtB4UJZlP0=
 golang.org/x/lint v0.0.0-20181026193005-c67002cb31c3/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE=
@@ -1439,8 +1441,8 @@ golang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
 golang.org/x/mod v0.4.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
 golang.org/x/mod v0.4.1/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
 golang.org/x/mod v0.4.2/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
-golang.org/x/mod v0.33.0 h1:tHFzIWbBifEmbwtGz65eaWyGiGZatSrT9prnU8DbVL8=
-golang.org/x/mod v0.33.0/go.mod h1:swjeQEj+6r7fODbD2cqrnje9PnziFuw4bmLbBZFrQ5w=
+golang.org/x/mod v0.34.0 h1:xIHgNUUnW6sYkcM5Jleh05DvLOtwc6RitGHbDk4akRI=
+golang.org/x/mod v0.34.0/go.mod h1:ykgH52iCZe79kzLLMhyCUzhMci+nQj+0XkbXpNYtVjY=
 golang.org/x/net v0.0.0-20180724234803-3673e40ba225/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
 golang.org/x/net v0.0.0-20180826012351-8a410e7b638d/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
 golang.org/x/net v0.0.0-20181114220301-adae6a3d119a/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
@@ -1693,8 +1695,8 @@ golang.org/x/tools v0.1.2/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk=
 golang.org/x/tools v0.1.3/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk=
 golang.org/x/tools v0.1.4/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk=
 golang.org/x/tools v0.1.5/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk=
-golang.org/x/tools v0.42.0 h1:uNgphsn75Tdz5Ji2q36v/nsFSfR/9BRFvqhGBaJGd5k=
-golang.org/x/tools v0.42.0/go.mod h1:Ma6lCIwGZvHK6XtgbswSoWroEkhugApmsXyrUmBhfr0=
+golang.org/x/tools v0.43.0 h1:12BdW9CeB3Z+J/I/wj34VMl8X+fEXBxVR90JeMX5E7s=
+golang.org/x/tools v0.43.0/go.mod h1:uHkMso649BX2cZK6+RpuIPXS3ho2hZo4FVwfoy1vIk0=
 golang.org/x/tools/godoc v0.1.0-deprecated h1:o+aZ1BOj6Hsx/GBdJO/s815sqftjSnrZZwyYTHODvtk=
 golang.org/x/tools/godoc v0.1.0-deprecated/go.mod h1:qM63CriJ961IHWmnWa9CjZnBndniPt4a3CK0PVB9bIg=
 golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
@@ -1837,8 +1839,8 @@ google.golang.org/genproto v0.0.0-20251202230838-ff82c1b0f217 h1:GvESR9BIyHUahIb
 google.golang.org/genproto v0.0.0-20251202230838-ff82c1b0f217/go.mod h1:yJ2HH4EHEDTd3JiLmhds6NkJ17ITVYOdV3m3VKOnws0=
 google.golang.org/genproto/googleapis/api v0.0.0-20260401024825-9d38bb4040a9 h1:VPWxll4HlMw1Vs/qXtN7BvhZqsS9cdAittCNvVENElA=
 google.golang.org/genproto/googleapis/api v0.0.0-20260401024825-9d38bb4040a9/go.mod h1:7QBABkRtR8z+TEnmXTqIqwJLlzrZKVfAUm7tY3yGv0M=
-google.golang.org/genproto/googleapis/rpc v0.0.0-20260401024825-9d38bb4040a9 h1:m8qni9SQFH0tJc1X0vmnpw/0t+AImlSvp30sEupozUg=
-google.golang.org/genproto/googleapis/rpc v0.0.0-20260401024825-9d38bb4040a9/go.mod h1:4Hqkh8ycfw05ld/3BWL7rJOSfebL2Q+DVDeRgYgxUU8=
+google.golang.org/genproto/googleapis/rpc v0.0.0-20260406210006-6f92a3bedf2d h1:wT2n40TBqFY6wiwazVK9/iTWbsQrgk5ZfCSVFLO9LQA=
+google.golang.org/genproto/googleapis/rpc v0.0.0-20260406210006-6f92a3bedf2d/go.mod h1:4Hqkh8ycfw05ld/3BWL7rJOSfebL2Q+DVDeRgYgxUU8=
 google.golang.org/grpc v1.14.0/go.mod h1:yo6s7OP7yaDglbqo1J04qKzAhqBH6lvTonzMVmEdcZw=
 google.golang.org/grpc v1.19.0/go.mod h1:mqu4LbDTu4XGKhr4mRzUsmM4RtVoemTSY81AxZiDr8c=
 google.golang.org/grpc v1.20.1/go.mod h1:10oTOabMzJvdu6/UiuZezV6QK5dSlG84ov/aaiqXj38=
@@ -1942,18 +1944,20 @@ k8s.io/kube-openapi v0.0.0-20250910181357-589584f1c912 h1:Y3gxNAuB0OBLImH611+UDZ
 k8s.io/kube-openapi v0.0.0-20250910181357-589584f1c912/go.mod h1:kdmbQkyfwUagLfXIad1y2TdrjPFWp2Q89B3qkRwf/pQ=
 k8s.io/utils v0.0.0-20251002143259-bc988d571ff4 h1:SjGebBtkBqHFOli+05xYbK8YF1Dzkbzn+gDM4X9T4Ck=
 k8s.io/utils v0.0.0-20251002143259-bc988d571ff4/go.mod h1:OLgZIPagt7ERELqWJFomSt595RzquPNLL48iOWgYOg0=
-modernc.org/cc/v4 v4.26.5 h1:xM3bX7Mve6G8K8b+T11ReenJOT+BmVqQj0FY5T4+5Y4=
-modernc.org/cc/v4 v4.26.5/go.mod h1:uVtb5OGqUKpoLWhqwNQo/8LwvoiEBLvZXIQ/SmO6mL0=
-modernc.org/ccgo/v4 v4.28.1 h1:wPKYn5EC/mYTqBO373jKjvX2n+3+aK7+sICCv4Fjy1A=
-modernc.org/ccgo/v4 v4.28.1/go.mod h1:uD+4RnfrVgE6ec9NGguUNdhqzNIeeomeXf6CL0GTE5Q=
-modernc.org/fileutil v1.3.40 h1:ZGMswMNc9JOCrcrakF1HrvmergNLAmxOPjizirpfqBA=
-modernc.org/fileutil v1.3.40/go.mod h1:HxmghZSZVAz/LXcMNwZPA/DRrQZEVP9VX0V4LQGQFOc=
+modernc.org/cc/v4 v4.27.1 h1:9W30zRlYrefrDV2JE2O8VDtJ1yPGownxciz5rrbQZis=
+modernc.org/cc/v4 v4.27.1/go.mod h1:uVtb5OGqUKpoLWhqwNQo/8LwvoiEBLvZXIQ/SmO6mL0=
+modernc.org/ccgo/v4 v4.32.0 h1:hjG66bI/kqIPX1b2yT6fr/jt+QedtP2fqojG2VrFuVw=
+modernc.org/ccgo/v4 v4.32.0/go.mod h1:6F08EBCx5uQc38kMGl+0Nm0oWczoo1c7cgpzEry7Uc0=
+modernc.org/fileutil v1.4.0 h1:j6ZzNTftVS054gi281TyLjHPp6CPHr2KCxEXjEbD6SM=
+modernc.org/fileutil v1.4.0/go.mod h1:EqdKFDxiByqxLk8ozOxObDSfcVOv/54xDs/DUHdvCUU=
 modernc.org/gc/v2 v2.6.5 h1:nyqdV8q46KvTpZlsw66kWqwXRHdjIlJOhG6kxiV/9xI=
 modernc.org/gc/v2 v2.6.5/go.mod h1:YgIahr1ypgfe7chRuJi2gD7DBQiKSLMPgBQe9oIiito=
+modernc.org/gc/v3 v3.1.2 h1:ZtDCnhonXSZexk/AYsegNRV1lJGgaNZJuKjJSWKyEqo=
+modernc.org/gc/v3 v3.1.2/go.mod h1:HFK/6AGESC7Ex+EZJhJ2Gni6cTaYpSMmU/cT9RmlfYY=
 modernc.org/goabi0 v0.2.0 h1:HvEowk7LxcPd0eq6mVOAEMai46V+i7Jrj13t4AzuNks=
 modernc.org/goabi0 v0.2.0/go.mod h1:CEFRnnJhKvWT1c1JTI3Avm+tgOWbkOu5oPA8eH8LnMI=
-modernc.org/libc v1.66.10 h1:yZkb3YeLx4oynyR+iUsXsybsX4Ubx7MQlSYEw4yj59A=
-modernc.org/libc v1.66.10/go.mod h1:8vGSEwvoUoltr4dlywvHqjtAqHBaw0j1jI7iFBTAr2I=
+modernc.org/libc v1.70.0 h1:U58NawXqXbgpZ/dcdS9kMshu08aiA6b7gusEusqzNkw=
+modernc.org/libc v1.70.0/go.mod h1:OVmxFGP1CI/Z4L3E0Q3Mf1PDE0BucwMkcXjjLntvHJo=
 modernc.org/mathutil v1.7.1 h1:GCZVGXdaN8gTqB1Mf/usp1Y/hSqgI2vAGGP4jZMCxOU=
 modernc.org/mathutil v1.7.1/go.mod h1:4p5IwJITfppl0G4sUEDtCr4DthTaT47/N3aT6MhfgJg=
 modernc.org/memory v1.11.0 h1:o4QC8aMQzmcwCK3t3Ux/ZHmwFPzE6hf2Y5LbkRs+hbI=
@@ -1962,8 +1966,8 @@ modernc.org/opt v0.1.4 h1:2kNGMRiUjrp4LcaPuLY2PzUfqM/w9N23quVwhKt5Qm8=
 modernc.org/opt v0.1.4/go.mod h1:03fq9lsNfvkYSfxrfUhZCWPk1lm4cq4N+Bh//bEtgns=
 modernc.org/sortutil v1.2.1 h1:+xyoGf15mM3NMlPDnFqrteY07klSFxLElE2PVuWIJ7w=
 modernc.org/sortutil v1.2.1/go.mod h1:7ZI3a3REbai7gzCLcotuw9AC4VZVpYMjDzETGsSMqJE=
-modernc.org/sqlite v1.40.1 h1:VfuXcxcUWWKRBuP8+BR9L7VnmusMgBNNnBYGEe9w/iY=
-modernc.org/sqlite v1.40.1/go.mod h1:9fjQZ0mB1LLP0GYrp39oOJXx/I2sxEnZtzCmEQIKvGE=
+modernc.org/sqlite v1.48.2 h1:5CnW4uP8joZtA0LedVqLbZV5GD7F/0x91AXeSyjoh5c=
+modernc.org/sqlite v1.48.2/go.mod h1:hWjRO6Tj/5Ik8ieqxQybiEOUXy0NJFNp2tpvVpKlvig=
 modernc.org/strutil v1.2.1 h1:UneZBkQA+DX2Rp35KcM69cSsNES9ly8mQWD71HKlOA0=
 modernc.org/strutil v1.2.1/go.mod h1:EHkiggD70koQxjVdSBM3JKM7k6L0FbGE5eymy9i3B9A=
 modernc.org/token v1.1.0 h1:Xl7Ap9dKaEs5kLoOQeQmPWevfnk/DM5qcLcYlA8ys6Y=
@@ -1975,8 +1979,8 @@ sigs.k8s.io/json v0.0.0-20250730193827-2d320260d730 h1:IpInykpT6ceI+QxKBbEflcR5E
 sigs.k8s.io/json v0.0.0-20250730193827-2d320260d730/go.mod h1:mdzfpAEoE6DHQEN0uh9ZbOCuHbLK5wOm7dK4ctXE9Tg=
 sigs.k8s.io/randfill v1.0.0 h1:JfjMILfT8A6RbawdsK2JXGBR5AQVfd+9TbzrlneTyrU=
 sigs.k8s.io/randfill v1.0.0/go.mod h1:XeLlZ/jmk4i1HRopwe7/aU3H5n1zNUcX6TM94b3QxOY=
-sigs.k8s.io/structured-merge-diff/v6 v6.3.0 h1:jTijUJbW353oVOd9oTlifJqOGEkUw2jB/fXCbTiQEco=
-sigs.k8s.io/structured-merge-diff/v6 v6.3.0/go.mod h1:M3W8sfWvn2HhQDIbGWj3S099YozAsymCo/wrT5ohRUE=
+sigs.k8s.io/structured-merge-diff/v6 v6.3.2-0.20260122202528-d9cc6641c482 h1:2WOzJpHUBVrrkDjU4KBT8n5LDcj824eX0I5UKcgeRUs=
+sigs.k8s.io/structured-merge-diff/v6 v6.3.2-0.20260122202528-d9cc6641c482/go.mod h1:M3W8sfWvn2HhQDIbGWj3S099YozAsymCo/wrT5ohRUE=
 sigs.k8s.io/yaml v1.2.0/go.mod h1:yfXDCHCao9+ENCvLSE62v9VSji2MKu5jeNfTrofGhJc=
 sigs.k8s.io/yaml v1.6.0 h1:G8fkbMSAFqgEFgh4b1wmtzDnioxFCUgTZhlbj5P9QYs=
 sigs.k8s.io/yaml v1.6.0/go.mod h1:796bPqUfzR/0jLAl6XjHl3Ck7MiyVv8dbTdyT3/pMf4=

pkg/apiserver/signozapiserver/inframonitoring.go

@@ -1,33 +0,0 @@
-package signozapiserver
-
-import (
-	"net/http"
-
-	"github.com/SigNoz/signoz/pkg/http/handler"
-	"github.com/SigNoz/signoz/pkg/types"
-	"github.com/SigNoz/signoz/pkg/types/inframonitoringtypes"
-	"github.com/gorilla/mux"
-)
-
-func (provider *provider) addInfraMonitoringRoutes(router *mux.Router) error {
-	if err := router.Handle("/api/v2/infra_monitoring/hosts", handler.New(
-		provider.authZ.ViewAccess(provider.infraMonitoringHandler.ListHosts),
-		handler.OpenAPIDef{
-			ID:                  "ListHosts",
-			Tags:                []string{"inframonitoring"},
-			Summary:             "List Hosts for Infra Monitoring",
-			Description:         "Returns a paginated list of hosts with key infrastructure metrics: CPU usage (%), memory usage (%), I/O wait (%), disk usage (%), and 15-minute load average. Each host includes its current status (active/inactive based on metrics reported in the last 10 minutes) and metadata attributes (e.g., os.type). Supports filtering via a filter expression, filtering by host status, custom groupBy to aggregate hosts by any attribute, ordering by any of the five metrics, and pagination via offset/limit. The response type is 'list' for the default host.name grouping or 'grouped_list' for custom groupBy keys. Also reports missing required metrics and whether the requested time range falls before the data retention boundary.",
-			Request:             new(inframonitoringtypes.PostableHosts),
-			RequestContentType:  "application/json",
-			Response:            new(inframonitoringtypes.Hosts),
-			ResponseContentType: "application/json",
-			SuccessStatusCode:   http.StatusOK,
-			ErrorStatusCodes:    []int{http.StatusBadRequest, http.StatusUnauthorized},
-			Deprecated:          false,
-			SecuritySchemes:     newSecuritySchemes(types.RoleViewer),
-		})).Methods(http.MethodPost).GetError(); err != nil {
-		return err
-	}
-
-	return nil
-}

pkg/apiserver/signozapiserver/provider.go

@@ -17,7 +17,6 @@ import (
 	"github.com/SigNoz/signoz/pkg/modules/dashboard"
 	"github.com/SigNoz/signoz/pkg/modules/fields"
 	"github.com/SigNoz/signoz/pkg/modules/metricsexplorer"
-	"github.com/SigNoz/signoz/pkg/modules/inframonitoring"
 	"github.com/SigNoz/signoz/pkg/modules/organization"
 	"github.com/SigNoz/signoz/pkg/modules/preference"
 	"github.com/SigNoz/signoz/pkg/modules/promote"
@@ -50,7 +49,6 @@ type provider struct {
 	dashboardModule         dashboard.Module
 	dashboardHandler        dashboard.Handler
 	metricsExplorerHandler  metricsexplorer.Handler
-	infraMonitoringHandler  inframonitoring.Handler
 	gatewayHandler          gateway.Handler
 	fieldsHandler           fields.Handler
 	authzHandler            authz.Handler
@@ -79,7 +77,6 @@ func NewFactory(
 	dashboardModule dashboard.Module,
 	dashboardHandler dashboard.Handler,
 	metricsExplorerHandler metricsexplorer.Handler,
-	infraMonitoringHandler inframonitoring.Handler,
 	gatewayHandler gateway.Handler,
 	fieldsHandler fields.Handler,
 	authzHandler authz.Handler,
@@ -111,7 +108,6 @@ func NewFactory(
 			dashboardModule,
 			dashboardHandler,
 			metricsExplorerHandler,
-			infraMonitoringHandler,
 			gatewayHandler,
 			fieldsHandler,
 			authzHandler,
@@ -145,7 +141,6 @@ func newProvider(
 	dashboardModule dashboard.Module,
 	dashboardHandler dashboard.Handler,
 	metricsExplorerHandler metricsexplorer.Handler,
-	infraMonitoringHandler inframonitoring.Handler,
 	gatewayHandler gateway.Handler,
 	fieldsHandler fields.Handler,
 	authzHandler authz.Handler,
@@ -177,7 +172,6 @@ func newProvider(
 		dashboardModule:         dashboardModule,
 		dashboardHandler:        dashboardHandler,
 		metricsExplorerHandler:  metricsExplorerHandler,
-		infraMonitoringHandler:  infraMonitoringHandler,
 		gatewayHandler:          gatewayHandler,
 		fieldsHandler:           fieldsHandler,
 		authzHandler:            authzHandler,
@@ -246,10 +240,6 @@ func (provider *provider) AddToRouter(router *mux.Router) error {
 		return err
 	}
 
-	if err := provider.addInfraMonitoringRoutes(router); err != nil {
-		return err
-	}
-
 	if err := provider.addGatewayRoutes(router); err != nil {
 		return err
 	}

pkg/modules/inframonitoring/config.go

@@ -1,33 +0,0 @@
-package inframonitoring
-
-import (
-	"github.com/SigNoz/signoz/pkg/errors"
-	"github.com/SigNoz/signoz/pkg/factory"
-)
-
-type Config struct {
-	TelemetryStore TelemetryStoreConfig `mapstructure:"telemetrystore"`
-}
-
-type TelemetryStoreConfig struct {
-	Threads int `mapstructure:"threads"`
-}
-
-func NewConfigFactory() factory.ConfigFactory {
-	return factory.NewConfigFactory(factory.MustNewName("inframonitoring"), newConfig)
-}
-
-func newConfig() factory.Config {
-	return Config{
-		TelemetryStore: TelemetryStoreConfig{
-			Threads: 8,
-		},
-	}
-}
-
-func (c Config) Validate() error {
-	if c.TelemetryStore.Threads <= 0 {
-		return errors.NewInvalidInputf(errors.CodeInvalidInput, "inframonitoring.telemetrystore.threads must be positive, got %d", c.TelemetryStore.Threads)
-	}
-	return nil
-}

pkg/modules/inframonitoring/implinframonitoring/handler.go

@@ -1,47 +0,0 @@
-package implinframonitoring
-
-import (
-	"net/http"
-
-	"github.com/SigNoz/signoz/pkg/http/binding"
-	"github.com/SigNoz/signoz/pkg/http/render"
-	"github.com/SigNoz/signoz/pkg/modules/inframonitoring"
-	"github.com/SigNoz/signoz/pkg/types/authtypes"
-	"github.com/SigNoz/signoz/pkg/types/inframonitoringtypes"
-	"github.com/SigNoz/signoz/pkg/valuer"
-)
-
-type handler struct {
-	module inframonitoring.Module
-}
-
-// NewHandler returns an inframonitoring.Handler implementation.
-func NewHandler(m inframonitoring.Module) inframonitoring.Handler {
-	return &handler{
-		module: m,
-	}
-}
-
-func (h *handler) ListHosts(rw http.ResponseWriter, req *http.Request) {
-	claims, err := authtypes.ClaimsFromContext(req.Context())
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	orgID := valuer.MustNewUUID(claims.OrgID)
-
-	var parsedReq inframonitoringtypes.PostableHosts
-	if err := binding.JSON.BindBody(req.Body, &parsedReq); err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	result, err := h.module.ListHosts(req.Context(), orgID, &parsedReq)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	render.Success(rw, http.StatusOK, result)
-}

pkg/modules/inframonitoring/implinframonitoring/helpers.go

@@ -1,573 +0,0 @@
-package implinframonitoring
-
-import (
-	"context"
-	"fmt"
-	"sort"
-	"strings"
-
-	"github.com/SigNoz/signoz/pkg/errors"
-	"github.com/SigNoz/signoz/pkg/querybuilder"
-	"github.com/SigNoz/signoz/pkg/telemetrymetrics"
-	"github.com/SigNoz/signoz/pkg/types/metrictypes"
-	qbtypes "github.com/SigNoz/signoz/pkg/types/querybuildertypes/querybuildertypesv5"
-	"github.com/SigNoz/signoz/pkg/types/telemetrytypes"
-	"github.com/huandu/go-sqlbuilder"
-)
-
-// quoteIdentifier wraps s in backticks for use as a ClickHouse identifier,
-// escaping any embedded backticks by doubling them.
-func quoteIdentifier(s string) string {
-	return fmt.Sprintf("`%s`", strings.ReplaceAll(s, "`", "``"))
-}
-
-func isKeyInGroupByAttrs(groupByAttrs []qbtypes.GroupByKey, key string) bool {
-	for _, groupBy := range groupByAttrs {
-		if groupBy.Name == key {
-			return true
-		}
-	}
-	return false
-}
-
-func mergeFilterExpressions(queryFilterExpr, reqFilterExpr string) string {
-	queryFilterExpr = strings.TrimSpace(queryFilterExpr)
-	reqFilterExpr = strings.TrimSpace(reqFilterExpr)
-	if queryFilterExpr == "" {
-		return reqFilterExpr
-	}
-	if reqFilterExpr == "" {
-		return queryFilterExpr
-	}
-	return fmt.Sprintf("(%s) AND (%s)", queryFilterExpr, reqFilterExpr)
-}
-
-// compositeKeyFromList builds a composite key by joining the given parts
-// with a null byte separator. This is the canonical way to construct
-// composite keys for group identification across the infra monitoring module.
-func compositeKeyFromList(parts []string) string {
-	return strings.Join(parts, "\x00")
-}
-
-// compositeKeyFromLabels builds a composite key from a label map by extracting
-// the value for each groupBy key in order and joining them via compositeKeyFromList.
-func compositeKeyFromLabels(labels map[string]string, groupBy []qbtypes.GroupByKey) string {
-	parts := make([]string, len(groupBy))
-	for i, key := range groupBy {
-		parts[i] = labels[key.Name]
-	}
-	return compositeKeyFromList(parts)
-}
-
-// parseAndSortGroups extracts group label maps from a ScalarData response and
-// sorts them by the ranking query's aggregation value.
-func parseAndSortGroups(
-	resp *qbtypes.QueryRangeResponse,
-	rankingQueryName string,
-	groupBy []qbtypes.GroupByKey,
-	direction qbtypes.OrderDirection,
-) []rankedGroup {
-	if resp == nil || len(resp.Data.Results) == 0 {
-		return nil
-	}
-
-	// Find the ScalarData that contains the ranking column.
-	var sd *qbtypes.ScalarData
-	for _, r := range resp.Data.Results {
-		candidate, ok := r.(*qbtypes.ScalarData)
-		if !ok || candidate == nil {
-			continue
-		}
-		for _, col := range candidate.Columns {
-			if col.Type == qbtypes.ColumnTypeAggregation && col.QueryName == rankingQueryName {
-				sd = candidate
-				break
-			}
-		}
-		if sd != nil {
-			break
-		}
-	}
-	if sd == nil || len(sd.Data) == 0 {
-		return nil
-	}
-
-	groupColIndices := make(map[string]int)
-	rankingColIdx := -1
-	for i, col := range sd.Columns {
-		if col.Type == qbtypes.ColumnTypeGroup {
-			groupColIndices[col.Name] = i
-		}
-		if col.Type == qbtypes.ColumnTypeAggregation && col.QueryName == rankingQueryName {
-			rankingColIdx = i
-		}
-	}
-	if rankingColIdx == -1 {
-		return nil
-	}
-
-	groups := make([]rankedGroup, 0, len(sd.Data))
-	for _, row := range sd.Data {
-		labels := make(map[string]string, len(groupBy))
-		for _, key := range groupBy {
-			if idx, ok := groupColIndices[key.Name]; ok && idx < len(row) {
-				labels[key.Name] = fmt.Sprintf("%v", row[idx])
-			}
-		}
-		var value float64
-		if rankingColIdx < len(row) {
-			if v, ok := row[rankingColIdx].(float64); ok {
-				value = v
-			}
-		}
-		groups = append(groups, rankedGroup{
-			labels:       labels,
-			value:        value,
-			compositeKey: compositeKeyFromLabels(labels, groupBy),
-		})
-	}
-
-	sort.Slice(groups, func(i, j int) bool {
-		if groups[i].value != groups[j].value {
-			if direction == qbtypes.OrderDirectionAsc {
-				return groups[i].value < groups[j].value
-			}
-			return groups[i].value > groups[j].value
-		}
-		return groups[i].compositeKey < groups[j].compositeKey
-	})
-
-	return groups
-}
-
-// paginateWithBackfill returns the page of groups for [offset, offset+limit).
-// The virtual sorted list is: metric-ranked groups first, then metadata-only
-// groups (those in metadataMap but not in metric results) sorted alphabetically.
-func paginateWithBackfill(
-	metricGroups []rankedGroup,
-	metadataMap map[string]map[string]string,
-	groupBy []qbtypes.GroupByKey,
-	offset, limit int,
-) []map[string]string {
-	metricKeySet := make(map[string]bool, len(metricGroups))
-	for _, g := range metricGroups {
-		metricKeySet[g.compositeKey] = true
-	}
-
-	metadataOnlyKeys := make([]string, 0)
-	for compositeKey := range metadataMap {
-		if !metricKeySet[compositeKey] {
-			metadataOnlyKeys = append(metadataOnlyKeys, compositeKey)
-		}
-	}
-	sort.Strings(metadataOnlyKeys)
-
-	totalMetric := len(metricGroups)
-	totalAll := totalMetric + len(metadataOnlyKeys)
-
-	end := offset + limit
-	if end > totalAll {
-		end = totalAll
-	}
-	if offset >= totalAll {
-		return nil
-	}
-
-	pageGroups := make([]map[string]string, 0, end-offset)
-	for i := offset; i < end; i++ {
-		if i < totalMetric {
-			pageGroups = append(pageGroups, metricGroups[i].labels)
-		} else {
-			compositeKey := metadataOnlyKeys[i-totalMetric]
-			attrs := metadataMap[compositeKey]
-			labels := make(map[string]string, len(groupBy))
-			for _, key := range groupBy {
-				labels[key.Name] = attrs[key.Name]
-			}
-			pageGroups = append(pageGroups, labels)
-		}
-	}
-	return pageGroups
-}
-
-// buildPageGroupsFilterExpr builds a filter expression that restricts results
-// to the given page of groups via IN clauses.
-// Returns e.g. "host.name IN ('h1','h2') AND os.type IN ('linux','windows')".
-func buildPageGroupsFilterExpr(pageGroups []map[string]string) string {
-	groupValues := make(map[string][]string)
-	for _, labels := range pageGroups {
-		for k, v := range labels {
-			groupValues[k] = append(groupValues[k], v)
-		}
-	}
-
-	inClauses := make([]string, 0, len(groupValues))
-	for key, values := range groupValues {
-		quoted := make([]string, len(values))
-		for i, v := range values {
-			quoted[i] = fmt.Sprintf("'%s'", v)
-		}
-		inClauses = append(inClauses, fmt.Sprintf("%s IN (%s)", key, strings.Join(quoted, ", ")))
-	}
-	return strings.Join(inClauses, " AND ")
-}
-
-// buildFullQueryRequest creates a QueryRangeRequest for all metrics,
-// restricted to the given page of groups via an IN filter.
-// Accepts primitive fields so it can be reused across different v2 APIs
-// (hosts, pods, etc.).
-func buildFullQueryRequest(
-	start int64,
-	end int64,
-	filterExpr string,
-	groupBy []qbtypes.GroupByKey,
-	pageGroups []map[string]string,
-	tableListQuery *qbtypes.QueryRangeRequest,
-) *qbtypes.QueryRangeRequest {
-	inFilterExpr := buildPageGroupsFilterExpr(pageGroups)
-
-	fullReq := &qbtypes.QueryRangeRequest{
-		Start:       uint64(start),
-		End:         uint64(end),
-		RequestType: qbtypes.RequestTypeScalar,
-		CompositeQuery: qbtypes.CompositeQuery{
-			Queries: make([]qbtypes.QueryEnvelope, 0, len(tableListQuery.CompositeQuery.Queries)),
-		},
-	}
-
-	for _, envelope := range tableListQuery.CompositeQuery.Queries {
-		copied := envelope
-		if copied.Type == qbtypes.QueryTypeBuilder {
-			existingExpr := ""
-			if f := copied.GetFilter(); f != nil {
-				existingExpr = f.Expression
-			}
-			merged := mergeFilterExpressions(existingExpr, filterExpr)
-			merged = mergeFilterExpressions(merged, inFilterExpr)
-			copied.SetFilter(&qbtypes.Filter{Expression: merged})
-			copied.SetGroupBy(groupBy)
-		}
-		fullReq.CompositeQuery.Queries = append(fullReq.CompositeQuery.Queries, copied)
-	}
-
-	return fullReq
-}
-
-// parseFullQueryResponse extracts per-group metric values from the full
-// composite query response. Returns compositeKey -> (queryName -> value).
-// Each enabled query/formula produces its own ScalarData entry in Results,
-// so we iterate over all of them and merge metrics per composite key.
-func parseFullQueryResponse(
-	resp *qbtypes.QueryRangeResponse,
-	groupBy []qbtypes.GroupByKey,
-) map[string]map[string]float64 {
-	result := make(map[string]map[string]float64)
-	if resp == nil || len(resp.Data.Results) == 0 {
-		return result
-	}
-
-	for _, r := range resp.Data.Results {
-		sd, ok := r.(*qbtypes.ScalarData)
-		if !ok || sd == nil {
-			continue
-		}
-
-		groupColIndices := make(map[string]int)
-		aggCols := make(map[int]string) // col index -> query name
-		for i, col := range sd.Columns {
-			if col.Type == qbtypes.ColumnTypeGroup {
-				groupColIndices[col.Name] = i
-			}
-			if col.Type == qbtypes.ColumnTypeAggregation {
-				aggCols[i] = col.QueryName
-			}
-		}
-
-		for _, row := range sd.Data {
-			labels := make(map[string]string, len(groupBy))
-			for _, key := range groupBy {
-				if idx, ok := groupColIndices[key.Name]; ok && idx < len(row) {
-					labels[key.Name] = fmt.Sprintf("%v", row[idx])
-				}
-			}
-			compositeKey := compositeKeyFromLabels(labels, groupBy)
-
-			if result[compositeKey] == nil {
-				result[compositeKey] = make(map[string]float64)
-			}
-			for idx, queryName := range aggCols {
-				if idx < len(row) {
-					if v, ok := row[idx].(float64); ok {
-						result[compositeKey][queryName] = v
-					}
-				}
-			}
-		}
-	}
-	return result
-}
-
-// buildSamplesTblFingerprintSubQuery returns a SelectBuilder that selects distinct fingerprints
-// from the samples table for the given metric names andtime range.
-func (m *module) buildSamplesTblFingerprintSubQuery(metricNames []string, startMs, endMs int64) *sqlbuilder.SelectBuilder {
-	samplesTableName := telemetrymetrics.WhichSamplesTableToUse(
-		uint64(startMs), uint64(endMs),
-		metrictypes.UnspecifiedType,
-		metrictypes.TimeAggregationUnspecified,
-		nil,
-	)
-	localSamplesTable := strings.TrimPrefix(samplesTableName, "distributed_")
-	fpSB := sqlbuilder.NewSelectBuilder()
-	fpSB.Select("DISTINCT fingerprint")
-	fpSB.From(fmt.Sprintf("%s.%s", telemetrymetrics.DBName, localSamplesTable))
-	fpSB.Where(
-		fpSB.In("metric_name", sqlbuilder.List(metricNames)),
-		fpSB.GE("unix_milli", startMs),
-		fpSB.L("unix_milli", endMs),
-	)
-	return fpSB
-}
-
-func (m *module) buildFilterClause(ctx context.Context, filter *qbtypes.Filter, startMillis, endMillis int64) (*sqlbuilder.WhereClause, error) {
-	expression := ""
-	if filter != nil {
-		expression = strings.TrimSpace(filter.Expression)
-	}
-	if expression == "" {
-		return sqlbuilder.NewWhereClause(), nil
-	}
-
-	whereClauseSelectors := querybuilder.QueryStringToKeysSelectors(expression)
-	for idx := range whereClauseSelectors {
-		whereClauseSelectors[idx].Signal = telemetrytypes.SignalMetrics
-		whereClauseSelectors[idx].SelectorMatchType = telemetrytypes.FieldSelectorMatchTypeExact
-	}
-
-	keys, _, err := m.telemetryMetadataStore.GetKeysMulti(ctx, whereClauseSelectors)
-	if err != nil {
-		return nil, err
-	}
-
-	opts := querybuilder.FilterExprVisitorOpts{
-		Context:          ctx,
-		Logger:           m.logger,
-		FieldMapper:      m.fieldMapper,
-		ConditionBuilder: m.condBuilder,
-		FullTextColumn:   &telemetrytypes.TelemetryFieldKey{Name: "metric_name", FieldContext: telemetrytypes.FieldContextMetric},
-		FieldKeys:        keys,
-		StartNs:          querybuilder.ToNanoSecs(uint64(startMillis)),
-		EndNs:            querybuilder.ToNanoSecs(uint64(endMillis)),
-	}
-
-	whereClause, err := querybuilder.PrepareWhereClause(expression, opts)
-	if err != nil {
-		return nil, err
-	}
-
-	if whereClause == nil || whereClause.WhereClause == nil {
-		return sqlbuilder.NewWhereClause(), nil
-	}
-
-	return whereClause.WhereClause, nil
-}
-
-// NOTE: this method is not specific to infra monitoring — it queries attributes_metadata generically.
-// Consider moving to telemetryMetaStore when a second use case emerges.
-//
-// getMetricsExistenceAndEarliestTime checks which of the given metric names have been
-// reported. It returns a list of missing metrics (those not found or with zero count)
-// and the earliest first-reported timestamp across all present metrics.
-// When all metrics are missing, minFirstReportedUnixMilli is 0.
-// TODO(nikhilmantri0902, srikanthccv): This method was designed this way because querier errors if any of the metrics
-// in the querier list was never sent, the QueryRange call throws not found error. Modify this method, if QueryRange
-// behaviour changes towards this.
-func (m *module) getMetricsExistenceAndEarliestTime(ctx context.Context, metricNames []string) ([]string, uint64, error) {
-	if len(metricNames) == 0 {
-		return nil, 0, nil
-	}
-
-	sb := sqlbuilder.NewSelectBuilder()
-	sb.Select("metric_name", "count(*) AS cnt", "min(first_reported_unix_milli) AS min_first_reported")
-	sb.From(fmt.Sprintf("%s.%s", telemetrymetrics.DBName, telemetrymetrics.AttributesMetadataTableName))
-	sb.Where(sb.In("metric_name", sqlbuilder.List(metricNames)))
-	sb.GroupBy("metric_name")
-
-	query, args := sb.BuildWithFlavor(sqlbuilder.ClickHouse)
-
-	rows, err := m.telemetryStore.ClickhouseDB().Query(ctx, query, args...)
-	if err != nil {
-		return nil, 0, err
-	}
-	defer rows.Close()
-
-	type metricInfo struct {
-		count            uint64
-		minFirstReported uint64
-	}
-	found := make(map[string]metricInfo, len(metricNames))
-
-	for rows.Next() {
-		var name string
-		var cnt, minFR uint64
-		if err := rows.Scan(&name, &cnt, &minFR); err != nil {
-			return nil, 0, err
-		}
-		found[name] = metricInfo{count: cnt, minFirstReported: minFR}
-	}
-	if err := rows.Err(); err != nil {
-		return nil, 0, err
-	}
-
-	var missingMetrics []string
-	var globalMinFirstReported uint64
-	for _, name := range metricNames {
-		info, ok := found[name]
-		if !ok || info.count == 0 {
-			missingMetrics = append(missingMetrics, name)
-			continue
-		}
-		if globalMinFirstReported == 0 || info.minFirstReported < globalMinFirstReported {
-			globalMinFirstReported = info.minFirstReported
-		}
-	}
-
-	return missingMetrics, globalMinFirstReported, nil
-}
-
-// getMetadata fetches the latest values of additionalCols for each unique combination of groupBy keys,
-// within the given time range and metric names. It uses argMax(tuple(...), unix_milli) to ensure
-// we always pick attribute values from the latest timestamp for each group.
-// The returned map has a composite key of groupBy column values joined by "\x00" (null byte),
-// mapping to a flat map of attr_name -> attr_value (includes both groupBy and additional cols).
-func (m *module) getMetadata(
-	ctx context.Context,
-	metricNames []string,
-	groupBy []qbtypes.GroupByKey,
-	additionalCols []string,
-	filter *qbtypes.Filter,
-	startMs, endMs int64,
-) (map[string]map[string]string, error) {
-	if len(metricNames) == 0 {
-		return nil, errors.NewInvalidInputf(errors.CodeInvalidInput, "metricNames must not be empty")
-	}
-	if len(groupBy) == 0 {
-		return nil, errors.NewInvalidInputf(errors.CodeInvalidInput, "groupBy must not be empty")
-	}
-
-	// Pick the optimal timeseries table based on time range; also get adjusted start.
-	adjustedStart, adjustedEnd, distributedTableName, _ := telemetrymetrics.WhichTSTableToUse(
-		uint64(startMs), uint64(endMs), nil,
-	)
-
-	fpSB := m.buildSamplesTblFingerprintSubQuery(metricNames, startMs, endMs)
-
-	// Flatten groupBy keys to string names for SQL expressions and result scanning.
-	groupByCols := make([]string, len(groupBy))
-	for i, key := range groupBy {
-		groupByCols[i] = key.Name
-	}
-	allCols := append(groupByCols, additionalCols...)
-
-	// --- Build inner query ---
-	innerSB := sqlbuilder.NewSelectBuilder()
-
-	// Inner SELECT columns: JSONExtractString for each groupBy col + argMax(tuple(...)) for additional cols
-	innerSelectCols := make([]string, 0, len(groupByCols)+1)
-	for _, col := range groupByCols {
-		innerSelectCols = append(innerSelectCols,
-			fmt.Sprintf("JSONExtractString(labels, %s) AS %s", innerSB.Var(col), quoteIdentifier(col)),
-		)
-	}
-
-	// Build the argMax(tuple(...), unix_milli) expression for all additional cols
-	if len(additionalCols) > 0 {
-		tupleArgs := make([]string, 0, len(additionalCols))
-		for _, col := range additionalCols {
-			tupleArgs = append(tupleArgs, fmt.Sprintf("JSONExtractString(labels, %s)", innerSB.Var(col)))
-		}
-		innerSelectCols = append(innerSelectCols,
-			fmt.Sprintf("argMax(tuple(%s), unix_milli) AS latest_attrs", strings.Join(tupleArgs, ", ")),
-		)
-	}
-
-	innerSB.Select(innerSelectCols...)
-	innerSB.From(fmt.Sprintf("%s.%s", telemetrymetrics.DBName, distributedTableName))
-	innerSB.Where(
-		innerSB.In("metric_name", sqlbuilder.List(metricNames)),
-		innerSB.GE("unix_milli", adjustedStart),
-		innerSB.L("unix_milli", adjustedEnd),
-		fmt.Sprintf("fingerprint IN (%s)", innerSB.Var(fpSB)),
-	)
-
-	// Apply optional filter expression
-	if filter != nil && strings.TrimSpace(filter.Expression) != "" {
-		filterClause, err := m.buildFilterClause(ctx, filter, startMs, endMs)
-		if err != nil {
-			return nil, err
-		}
-		if filterClause != nil {
-			innerSB.AddWhereClause(filterClause)
-		}
-	}
-
-	groupByAliases := make([]string, 0, len(groupByCols))
-	for _, col := range groupByCols {
-		groupByAliases = append(groupByAliases, quoteIdentifier(col))
-	}
-	innerSB.GroupBy(groupByAliases...)
-
-	innerQuery, innerArgs := innerSB.BuildWithFlavor(sqlbuilder.ClickHouse)
-
-	// --- Build outer query ---
-	// Outer SELECT columns: groupBy cols directly + tupleElement(latest_attrs, N) for each additionalCol
-	outerSelectCols := make([]string, 0, len(allCols))
-	for _, col := range groupByCols {
-		outerSelectCols = append(outerSelectCols, quoteIdentifier(col))
-	}
-	for i, col := range additionalCols {
-		outerSelectCols = append(outerSelectCols,
-			fmt.Sprintf("tupleElement(latest_attrs, %d) AS %s", i+1, quoteIdentifier(col)),
-		)
-	}
-
-	outerSB := sqlbuilder.NewSelectBuilder()
-	outerSB.Select(outerSelectCols...)
-	outerSB.From(fmt.Sprintf("(%s)", innerQuery))
-
-	outerQuery, _ := outerSB.BuildWithFlavor(sqlbuilder.ClickHouse)
-	// All ? params are in innerArgs; outer query introduces none of its own.
-
-	rows, err := m.telemetryStore.ClickhouseDB().Query(ctx, outerQuery, innerArgs...)
-	if err != nil {
-		return nil, err
-	}
-	defer rows.Close()
-
-	result := make(map[string]map[string]string)
-
-	for rows.Next() {
-		row := make([]string, len(allCols))
-		scanPtrs := make([]any, len(row))
-		for i := range row {
-			scanPtrs[i] = &row[i]
-		}
-
-		if err := rows.Scan(scanPtrs...); err != nil {
-			return nil, err
-		}
-
-		compositeKey := compositeKeyFromList(row[:len(groupByCols)])
-
-		attrMap := make(map[string]string, len(allCols))
-		for i, col := range allCols {
-			attrMap[col] = row[i]
-		}
-		result[compositeKey] = attrMap
-	}
-
-	if err := rows.Err(); err != nil {
-		return nil, err
-	}
-
-	return result, nil
-}

pkg/modules/inframonitoring/implinframonitoring/helpers_test.go

@@ -1,283 +0,0 @@
-package implinframonitoring
-
-import (
-	"testing"
-
-	qbtypes "github.com/SigNoz/signoz/pkg/types/querybuildertypes/querybuildertypesv5"
-	"github.com/SigNoz/signoz/pkg/types/telemetrytypes"
-)
-
-func groupByKey(name string) qbtypes.GroupByKey {
-	return qbtypes.GroupByKey{
-		TelemetryFieldKey: telemetrytypes.TelemetryFieldKey{Name: name},
-	}
-}
-
-func TestIsKeyInGroupByAttrs(t *testing.T) {
-	tests := []struct {
-		name          string
-		groupByAttrs  []qbtypes.GroupByKey
-		key           string
-		expectedFound bool
-	}{
-		{
-			name:          "key present in single-element list",
-			groupByAttrs:  []qbtypes.GroupByKey{groupByKey("host.name")},
-			key:           "host.name",
-			expectedFound: true,
-		},
-		{
-			name: "key present in multi-element list",
-			groupByAttrs: []qbtypes.GroupByKey{
-				groupByKey("host.name"),
-				groupByKey("os.type"),
-				groupByKey("k8s.cluster.name"),
-			},
-			key:           "os.type",
-			expectedFound: true,
-		},
-		{
-			name: "key at last position",
-			groupByAttrs: []qbtypes.GroupByKey{
-				groupByKey("host.name"),
-				groupByKey("os.type"),
-			},
-			key:           "os.type",
-			expectedFound: true,
-		},
-		{
-			name:          "key not in list",
-			groupByAttrs:  []qbtypes.GroupByKey{groupByKey("host.name")},
-			key:           "os.type",
-			expectedFound: false,
-		},
-		{
-			name:          "empty group by list",
-			groupByAttrs:  []qbtypes.GroupByKey{},
-			key:           "host.name",
-			expectedFound: false,
-		},
-		{
-			name:          "nil group by list",
-			groupByAttrs:  nil,
-			key:           "host.name",
-			expectedFound: false,
-		},
-		{
-			name:          "empty key string",
-			groupByAttrs:  []qbtypes.GroupByKey{groupByKey("host.name")},
-			key:           "",
-			expectedFound: false,
-		},
-		{
-			name:          "empty key matches empty-named group by key",
-			groupByAttrs:  []qbtypes.GroupByKey{groupByKey("")},
-			key:           "",
-			expectedFound: true,
-		},
-		{
-			name: "partial match does not count",
-			groupByAttrs: []qbtypes.GroupByKey{
-				groupByKey("host"),
-			},
-			key:           "host.name",
-			expectedFound: false,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			got := isKeyInGroupByAttrs(tt.groupByAttrs, tt.key)
-			if got != tt.expectedFound {
-				t.Errorf("isKeyInGroupByAttrs(%v, %q) = %v, want %v",
-					tt.groupByAttrs, tt.key, got, tt.expectedFound)
-			}
-		})
-	}
-}
-
-func TestMergeFilterExpressions(t *testing.T) {
-	tests := []struct {
-		name            string
-		queryFilterExpr string
-		reqFilterExpr   string
-		expected        string
-	}{
-		{
-			name:            "both non-empty",
-			queryFilterExpr: "cpu > 50",
-			reqFilterExpr:   "host.name = 'web-1'",
-			expected:        "(cpu > 50) AND (host.name = 'web-1')",
-		},
-		{
-			name:            "query empty, req non-empty",
-			queryFilterExpr: "",
-			reqFilterExpr:   "host.name = 'web-1'",
-			expected:        "host.name = 'web-1'",
-		},
-		{
-			name:            "query non-empty, req empty",
-			queryFilterExpr: "cpu > 50",
-			reqFilterExpr:   "",
-			expected:        "cpu > 50",
-		},
-		{
-			name:            "both empty",
-			queryFilterExpr: "",
-			reqFilterExpr:   "",
-			expected:        "",
-		},
-		{
-			name:            "whitespace-only query treated as empty",
-			queryFilterExpr: "   ",
-			reqFilterExpr:   "host.name = 'web-1'",
-			expected:        "host.name = 'web-1'",
-		},
-		{
-			name:            "whitespace-only req treated as empty",
-			queryFilterExpr: "cpu > 50",
-			reqFilterExpr:   "   ",
-			expected:        "cpu > 50",
-		},
-		{
-			name:            "both whitespace-only",
-			queryFilterExpr: "  ",
-			reqFilterExpr:   "  ",
-			expected:        "",
-		},
-		{
-			name:            "leading/trailing whitespace trimmed before merge",
-			queryFilterExpr: "  cpu > 50  ",
-			reqFilterExpr:   "  mem < 80  ",
-			expected:        "(cpu > 50) AND (mem < 80)",
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			got := mergeFilterExpressions(tt.queryFilterExpr, tt.reqFilterExpr)
-			if got != tt.expected {
-				t.Errorf("mergeFilterExpressions(%q, %q) = %q, want %q",
-					tt.queryFilterExpr, tt.reqFilterExpr, got, tt.expected)
-			}
-		})
-	}
-}
-
-func TestCompositeKeyFromList(t *testing.T) {
-	tests := []struct {
-		name     string
-		parts    []string
-		expected string
-	}{
-		{
-			name:     "single part",
-			parts:    []string{"web-1"},
-			expected: "web-1",
-		},
-		{
-			name:     "multiple parts joined with null separator",
-			parts:    []string{"web-1", "linux", "us-east"},
-			expected: "web-1\x00linux\x00us-east",
-		},
-		{
-			name:     "empty slice returns empty string",
-			parts:    []string{},
-			expected: "",
-		},
-		{
-			name:     "nil slice returns empty string",
-			parts:    nil,
-			expected: "",
-		},
-		{
-			name:     "parts with empty strings",
-			parts:    []string{"web-1", "", "us-east"},
-			expected: "web-1\x00\x00us-east",
-		},
-		{
-			name:     "all empty strings",
-			parts:    []string{"", ""},
-			expected: "\x00",
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			got := compositeKeyFromList(tt.parts)
-			if got != tt.expected {
-				t.Errorf("compositeKeyFromList(%v) = %q, want %q",
-					tt.parts, got, tt.expected)
-			}
-		})
-	}
-}
-
-func TestCompositeKeyFromLabels(t *testing.T) {
-	tests := []struct {
-		name     string
-		labels   map[string]string
-		groupBy  []qbtypes.GroupByKey
-		expected string
-	}{
-		{
-			name:     "single group-by key",
-			labels:   map[string]string{"host.name": "web-1"},
-			groupBy:  []qbtypes.GroupByKey{groupByKey("host.name")},
-			expected: "web-1",
-		},
-		{
-			name: "multiple group-by keys joined with null separator",
-			labels: map[string]string{
-				"host.name": "web-1",
-				"os.type":   "linux",
-			},
-			groupBy:  []qbtypes.GroupByKey{groupByKey("host.name"), groupByKey("os.type")},
-			expected: "web-1\x00linux",
-		},
-		{
-			name:     "missing label yields empty segment",
-			labels:   map[string]string{"host.name": "web-1"},
-			groupBy:  []qbtypes.GroupByKey{groupByKey("host.name"), groupByKey("os.type")},
-			expected: "web-1\x00",
-		},
-		{
-			name:     "empty labels map",
-			labels:   map[string]string{},
-			groupBy:  []qbtypes.GroupByKey{groupByKey("host.name")},
-			expected: "",
-		},
-		{
-			name:     "empty group-by slice",
-			labels:   map[string]string{"host.name": "web-1"},
-			groupBy:  []qbtypes.GroupByKey{},
-			expected: "",
-		},
-		{
-			name:     "nil labels map",
-			labels:   nil,
-			groupBy:  []qbtypes.GroupByKey{groupByKey("host.name")},
-			expected: "",
-		},
-		{
-			name: "order matches group-by order, not map iteration order",
-			labels: map[string]string{
-				"z": "last",
-				"a": "first",
-				"m": "middle",
-			},
-			groupBy:  []qbtypes.GroupByKey{groupByKey("a"), groupByKey("m"), groupByKey("z")},
-			expected: "first\x00middle\x00last",
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			got := compositeKeyFromLabels(tt.labels, tt.groupBy)
-			if got != tt.expected {
-				t.Errorf("compositeKeyFromLabels(%v, %v) = %q, want %q",
-					tt.labels, tt.groupBy, got, tt.expected)
-			}
-		})
-	}
-}

pkg/modules/inframonitoring/implinframonitoring/hosts.go

@@ -1,354 +0,0 @@
-package implinframonitoring
-
-import (
-	"context"
-	"fmt"
-	"slices"
-	"strings"
-
-	"github.com/SigNoz/signoz/pkg/telemetrymetrics"
-	"github.com/SigNoz/signoz/pkg/types/inframonitoringtypes"
-	qbtypes "github.com/SigNoz/signoz/pkg/types/querybuildertypes/querybuildertypesv5"
-	"github.com/SigNoz/signoz/pkg/valuer"
-	"github.com/huandu/go-sqlbuilder"
-)
-
-// getPerGroupHostStatusCounts computes the number of active and inactive hosts per group
-// for the current page. It queries the timeseries table using the provided filter
-// expression (which includes user filter + status filter + page groups IN clause).
-// Uses GLOBAL IN with the active-hosts subquery inside uniqExactIf for active count,
-// and a simple uniqExactIf for total count. Inactive = total - active (computed in Go).
-func (m *module) getPerGroupHostStatusCounts(
-	ctx context.Context,
-	req *inframonitoringtypes.PostableHosts,
-	metricNames []string,
-	pageGroups []map[string]string,
-	sinceUnixMilli int64,
-) (map[string]groupHostStatusCounts, error) {
-
-	// Build the full filter expression from req (user filter + status filter) and page groups.
-	reqFilterExpr := ""
-	if req.Filter != nil {
-		reqFilterExpr = req.Filter.Expression
-	}
-	pageGroupsFilterExpr := buildPageGroupsFilterExpr(pageGroups)
-	filterExpr := mergeFilterExpressions(reqFilterExpr, pageGroupsFilterExpr)
-
-	adjustedStart, adjustedEnd, distributedTimeSeriesTableName, _ := telemetrymetrics.WhichTSTableToUse(
-		uint64(req.Start), uint64(req.End), nil,
-	)
-
-	hostNameExpr := fmt.Sprintf("JSONExtractString(labels, '%s')", hostNameAttrKey)
-
-	sb := sqlbuilder.NewSelectBuilder()
-	selectCols := make([]string, 0, len(req.GroupBy)+2)
-	for _, key := range req.GroupBy {
-		selectCols = append(selectCols,
-			fmt.Sprintf("JSONExtractString(labels, %s) AS %s", sb.Var(key.Name), quoteIdentifier(key.Name)),
-		)
-	}
-
-	activeHostsSQ := m.getActiveHostsQuery(metricNames, hostNameAttrKey, sinceUnixMilli)
-	selectCols = append(selectCols,
-		fmt.Sprintf("uniqExactIf(%s, %s GLOBAL IN (%s)) AS active_host_count", hostNameExpr, hostNameExpr, sb.Var(activeHostsSQ)),
-		fmt.Sprintf("uniqExactIf(%s, %s != '') AS total_host_count", hostNameExpr, hostNameExpr),
-	)
-
-	// Build a fingerprint subquery to restrict to fingerprints with actual sample
-	// data in the original time range (not the wider timeseries table window).
-	fpSB := m.buildSamplesTblFingerprintSubQuery(metricNames, req.Start, req.End)
-
-	sb.Select(selectCols...)
-	sb.From(fmt.Sprintf("%s.%s", telemetrymetrics.DBName, distributedTimeSeriesTableName))
-	sb.Where(
-		sb.In("metric_name", sqlbuilder.List(metricNames)),
-		sb.GE("unix_milli", adjustedStart),
-		sb.L("unix_milli", adjustedEnd),
-		fmt.Sprintf("fingerprint IN (%s)", sb.Var(fpSB)),
-	)
-
-	// Apply the combined filter expression (user filter + status filter + page groups IN).
-	if filterExpr != "" {
-		filterClause, err := m.buildFilterClause(ctx, &qbtypes.Filter{Expression: filterExpr}, req.Start, req.End)
-		if err != nil {
-			return nil, err
-		}
-		if filterClause != nil {
-			sb.AddWhereClause(filterClause)
-		}
-	}
-
-	// GROUP BY
-	groupByAliases := make([]string, 0, len(req.GroupBy))
-	for _, key := range req.GroupBy {
-		groupByAliases = append(groupByAliases, quoteIdentifier(key.Name))
-	}
-	sb.GroupBy(groupByAliases...)
-
-	query, args := sb.BuildWithFlavor(sqlbuilder.ClickHouse)
-
-	rows, err := m.telemetryStore.ClickhouseDB().Query(ctx, query, args...)
-	if err != nil {
-		return nil, err
-	}
-	defer rows.Close()
-
-	result := make(map[string]groupHostStatusCounts)
-	for rows.Next() {
-		groupVals := make([]string, len(req.GroupBy))
-		scanPtrs := make([]any, 0, len(req.GroupBy)+2)
-		for i := range groupVals {
-			scanPtrs = append(scanPtrs, &groupVals[i])
-		}
-
-		var activeCount, totalCount uint64
-		scanPtrs = append(scanPtrs, &activeCount, &totalCount)
-
-		if err := rows.Scan(scanPtrs...); err != nil {
-			return nil, err
-		}
-
-		compositeKey := compositeKeyFromList(groupVals)
-		result[compositeKey] = groupHostStatusCounts{
-			Active:   int(activeCount),
-			Inactive: int(totalCount - activeCount),
-		}
-	}
-
-	if err := rows.Err(); err != nil {
-		return nil, err
-	}
-
-	return result, nil
-}
-
-// buildHostRecords constructs the final list of HostRecords for a page.
-// Groups that had no metric data get default values of -1.
-//
-// hostCounts is nil when host.name is in the groupBy — in that case, counts are
-// derived directly from activeHostsMap (1/0 per host). When non-nil (custom groupBy
-// without host.name), counts are looked up from the map.
-func buildHostRecords(
-	isHostNameInGroupBy bool,
-	resp *qbtypes.QueryRangeResponse,
-	pageGroups []map[string]string,
-	groupBy []qbtypes.GroupByKey,
-	metadataMap map[string]map[string]string,
-	activeHostsMap map[string]bool,
-	hostCounts map[string]groupHostStatusCounts,
-) []inframonitoringtypes.HostRecord {
-	metricsMap := parseFullQueryResponse(resp, groupBy)
-
-	records := make([]inframonitoringtypes.HostRecord, 0, len(pageGroups))
-	for _, labels := range pageGroups {
-		compositeKey := compositeKeyFromLabels(labels, groupBy)
-		hostName := labels[hostNameAttrKey]
-
-		activeStatus := inframonitoringtypes.HostStatusNone
-		activeHostCount := 0
-		inactiveHostCount := 0
-		if isHostNameInGroupBy { // derive from activeHostsMap since each row = one host
-			if hostName != "" {
-				if activeHostsMap[hostName] {
-					activeStatus = inframonitoringtypes.HostStatusActive
-					activeHostCount = 1
-				} else {
-					activeStatus = inframonitoringtypes.HostStatusInactive
-					inactiveHostCount = 1
-				}
-			}
-		} else { // derive from hostCounts since custom groupBy without host.name
-			if counts, ok := hostCounts[compositeKey]; ok {
-				activeHostCount = counts.Active
-				inactiveHostCount = counts.Inactive
-			}
-		}
-
-		record := inframonitoringtypes.HostRecord{
-			HostName:          hostName,
-			Status:            activeStatus,
-			ActiveHostCount:   activeHostCount,
-			InactiveHostCount: inactiveHostCount,
-			CPU:               -1,
-			Memory:            -1,
-			Wait:              -1,
-			Load15:            -1,
-			DiskUsage:         -1,
-			Meta:              map[string]any{},
-		}
-
-		if metrics, ok := metricsMap[compositeKey]; ok {
-			if v, exists := metrics["F1"]; exists {
-				record.CPU = v
-			}
-			if v, exists := metrics["F2"]; exists {
-				record.Memory = v
-			}
-			if v, exists := metrics["F3"]; exists {
-				record.Wait = v
-			}
-			if v, exists := metrics["F4"]; exists {
-				record.DiskUsage = v
-			}
-			if v, exists := metrics["G"]; exists {
-				record.Load15 = v
-			}
-		}
-
-		if attrs, ok := metadataMap[compositeKey]; ok {
-			for k, v := range attrs {
-				record.Meta[k] = v
-			}
-		}
-
-		records = append(records, record)
-	}
-	return records
-}
-
-// getTopHostGroups runs a ranking query for the ordering metric, sorts the
-// results, paginates, and backfills from metadataMap when the page extends
-// past the metric-ranked groups.
-func (m *module) getTopHostGroups(
-	ctx context.Context,
-	orgID valuer.UUID,
-	req *inframonitoringtypes.PostableHosts,
-	metadataMap map[string]map[string]string,
-) ([]map[string]string, error) {
-	orderByKey := req.OrderBy.Key.Name
-	queryNamesForOrderBy := orderByToHostsQueryNames[orderByKey]
-	// The last entry is the formula/query whose value we sort by.
-	rankingQueryName := queryNamesForOrderBy[len(queryNamesForOrderBy)-1]
-
-	topReq := &qbtypes.QueryRangeRequest{
-		Start:       uint64(req.Start),
-		End:         uint64(req.End),
-		RequestType: qbtypes.RequestTypeScalar,
-		CompositeQuery: qbtypes.CompositeQuery{
-			Queries: make([]qbtypes.QueryEnvelope, 0, len(queryNamesForOrderBy)),
-		},
-	}
-
-	for _, envelope := range m.newListHostsQuery().CompositeQuery.Queries {
-		if !slices.Contains(queryNamesForOrderBy, envelope.GetQueryName()) {
-			continue
-		}
-		copied := envelope
-		if copied.Type == qbtypes.QueryTypeBuilder {
-			existingExpr := ""
-			if f := copied.GetFilter(); f != nil {
-				existingExpr = f.Expression
-			}
-			reqFilterExpr := ""
-			if req.Filter != nil {
-				reqFilterExpr = req.Filter.Expression
-			}
-			merged := mergeFilterExpressions(existingExpr, reqFilterExpr)
-			copied.SetFilter(&qbtypes.Filter{Expression: merged})
-			copied.SetGroupBy(req.GroupBy)
-		}
-		topReq.CompositeQuery.Queries = append(topReq.CompositeQuery.Queries, copied)
-	}
-
-	resp, err := m.querier.QueryRange(ctx, orgID, topReq)
-	if err != nil {
-		return nil, err
-	}
-
-	allMetricGroups := parseAndSortGroups(resp, rankingQueryName, req.GroupBy, req.OrderBy.Direction)
-	return paginateWithBackfill(allMetricGroups, metadataMap, req.GroupBy, req.Offset, req.Limit), nil
-}
-
-// applyHostsActiveStatusFilter MODIFIES req.Filter.Expression to include an IN/NOT IN
-// clause based on FilterByStatus and the set of active hosts.
-// Returns true if the caller should short-circuit with an empty result (eg. ACTIVE
-// requested but no hosts are active).
-func (m *module) applyHostsActiveStatusFilter(req *inframonitoringtypes.PostableHosts, activeHostsMap map[string]bool) (shouldShortCircuit bool) {
-	if req.Filter == nil || (req.Filter.FilterByStatus != inframonitoringtypes.HostStatusActive && req.Filter.FilterByStatus != inframonitoringtypes.HostStatusInactive) {
-		return false
-	}
-
-	activeHosts := make([]string, 0, len(activeHostsMap))
-	for host := range activeHostsMap {
-		activeHosts = append(activeHosts, fmt.Sprintf("'%s'", host))
-	}
-
-	if len(activeHosts) == 0 {
-		return req.Filter.FilterByStatus == inframonitoringtypes.HostStatusActive
-	}
-
-	op := "IN"
-	if req.Filter.FilterByStatus == inframonitoringtypes.HostStatusInactive {
-		op = "NOT IN"
-	}
-	statusClause := fmt.Sprintf("%s %s (%s)", hostNameAttrKey, op, strings.Join(activeHosts, ", "))
-	req.Filter.Expression = mergeFilterExpressions(req.Filter.Expression, statusClause)
-	return false
-}
-
-func (m *module) getHostsTableMetadata(ctx context.Context, req *inframonitoringtypes.PostableHosts) (map[string]map[string]string, error) {
-	var nonGroupByAttrs []string
-	for _, key := range hostAttrKeysForMetadata {
-		if !isKeyInGroupByAttrs(req.GroupBy, key) {
-			nonGroupByAttrs = append(nonGroupByAttrs, key)
-		}
-	}
-	var filter *qbtypes.Filter
-	if req.Filter != nil {
-		filter = &req.Filter.Filter
-	}
-	metadataMap, err := m.getMetadata(ctx, hostsTableMetricNamesList, req.GroupBy, nonGroupByAttrs, filter, req.Start, req.End)
-	if err != nil {
-		return nil, err
-	}
-	return metadataMap, nil
-}
-
-// getActiveHostsQuery builds a SelectBuilder that returns distinct host names
-// with metrics reported in the last 10 minutes. The builder is not executed —
-// callers can either execute it (getActiveHosts) or embed it as a subquery
-// (getPerGroupActiveInactiveHostCounts).
-func (m *module) getActiveHostsQuery(metricNames []string, hostNameAttr string, sinceUnixMilli int64) *sqlbuilder.SelectBuilder {
-	sb := sqlbuilder.NewSelectBuilder()
-	sb.Distinct()
-	sb.Select("attr_string_value")
-	sb.From(fmt.Sprintf("%s.%s", telemetrymetrics.DBName, telemetrymetrics.AttributesMetadataTableName))
-	sb.Where(
-		sb.In("metric_name", sqlbuilder.List(metricNames)),
-		sb.E("attr_name", hostNameAttr),
-		sb.NE("attr_string_value", ""),
-		sb.GE("last_reported_unix_milli", sinceUnixMilli),
-	)
-
-	return sb
-}
-
-// getActiveHosts returns a set of host names that have reported metrics recently.
-// It queries distributed_metadata for hosts where last_reported_unix_milli >= sinceUnixMilli.
-func (m *module) getActiveHosts(ctx context.Context, metricNames []string, hostNameAttr string, sinceUnixMilli int64) (map[string]bool, error) {
-	sb := m.getActiveHostsQuery(metricNames, hostNameAttr, sinceUnixMilli)
-	query, args := sb.BuildWithFlavor(sqlbuilder.ClickHouse)
-
-	rows, err := m.telemetryStore.ClickhouseDB().Query(ctx, query, args...)
-	if err != nil {
-		return nil, err
-	}
-	defer rows.Close()
-
-	activeHosts := make(map[string]bool)
-	for rows.Next() {
-		var hostName string
-		if err := rows.Scan(&hostName); err != nil {
-			return nil, err
-		}
-		if hostName != "" {
-			activeHosts[hostName] = true
-		}
-	}
-
-	if err := rows.Err(); err != nil {
-		return nil, err
-	}
-
-	return activeHosts, nil
-}

pkg/modules/inframonitoring/implinframonitoring/hosts_constants.go

@@ -1,270 +0,0 @@
-package implinframonitoring
-
-import (
-	"github.com/SigNoz/signoz/pkg/types/inframonitoringtypes"
-	"github.com/SigNoz/signoz/pkg/types/metrictypes"
-	qbtypes "github.com/SigNoz/signoz/pkg/types/querybuildertypes/querybuildertypesv5"
-	"github.com/SigNoz/signoz/pkg/types/telemetrytypes"
-)
-
-const (
-	hostNameAttrKey = "host.name"
-)
-
-// Helper group-by key used across all queries.
-var hostNameGroupByKey = qbtypes.GroupByKey{
-	TelemetryFieldKey: telemetrytypes.TelemetryFieldKey{
-		Name:          hostNameAttrKey,
-		FieldContext:  telemetrytypes.FieldContextResource,
-		FieldDataType: telemetrytypes.FieldDataTypeString,
-	},
-}
-
-var hostsTableMetricNamesList = []string{
-	"system.cpu.time",
-	"system.memory.usage",
-	"system.cpu.load_average.15m",
-	"system.filesystem.usage",
-}
-
-var hostAttrKeysForMetadata = []string{
-	"os.type",
-}
-
-// orderByToHostsQueryNames maps the orderBy column to the query/formula names
-// from HostsTableListQuery used for ranking host groups.
-var orderByToHostsQueryNames = map[string][]string{
-	inframonitoringtypes.HostsOrderByCPU:       {"A", "B", "F1"},
-	inframonitoringtypes.HostsOrderByMemory:    {"C", "D", "F2"},
-	inframonitoringtypes.HostsOrderByWait:      {"E", "F", "F3"},
-	inframonitoringtypes.HostsOrderByDiskUsage: {"H", "I", "F4"},
-	inframonitoringtypes.HostsOrderByLoad15:    {"G"},
-}
-
-// newListHostsQuery constructs the base QueryRangeRequest with all the queries for the hosts table.
-// This is kept in this file because the queries themselves do not change based on the request parameters
-// only the filters, group bys, and order bys change, which are applied in buildFullQueryRequest.
-func (m *module) newListHostsQuery() *qbtypes.QueryRangeRequest {
-	return &qbtypes.QueryRangeRequest{
-		RequestType: qbtypes.RequestTypeScalar,
-		CompositeQuery: qbtypes.CompositeQuery{
-			Queries: []qbtypes.QueryEnvelope{
-				// Query A: CPU usage logic (non-idle)
-				{
-					Type: qbtypes.QueryTypeBuilder,
-					Spec: qbtypes.QueryBuilderQuery[qbtypes.MetricAggregation]{
-						Name:   "A",
-						Signal: telemetrytypes.SignalMetrics,
-						Aggregations: []qbtypes.MetricAggregation{
-							{
-								MetricName:       "system.cpu.time",
-								TimeAggregation:  metrictypes.TimeAggregationRate,
-								SpaceAggregation: metrictypes.SpaceAggregationSum,
-								ReduceTo:         qbtypes.ReduceToAvg,
-							},
-						},
-						Filter: &qbtypes.Filter{
-							Expression: "state != 'idle'",
-						},
-						GroupBy:  []qbtypes.GroupByKey{hostNameGroupByKey},
-						Disabled: true,
-					},
-				},
-				// Query B: CPU usage (all states)
-				{
-					Type: qbtypes.QueryTypeBuilder,
-					Spec: qbtypes.QueryBuilderQuery[qbtypes.MetricAggregation]{
-						Name:   "B",
-						Signal: telemetrytypes.SignalMetrics,
-						Aggregations: []qbtypes.MetricAggregation{
-							{
-								MetricName:       "system.cpu.time",
-								TimeAggregation:  metrictypes.TimeAggregationRate,
-								SpaceAggregation: metrictypes.SpaceAggregationSum,
-								ReduceTo:         qbtypes.ReduceToAvg,
-							},
-						},
-						GroupBy:  []qbtypes.GroupByKey{hostNameGroupByKey},
-						Disabled: true,
-					},
-				},
-				// Formula F1: CPU Usage (%)
-				{
-					Type: qbtypes.QueryTypeFormula,
-					Spec: qbtypes.QueryBuilderFormula{
-						Name:       "F1",
-						Expression: "A/B",
-						Legend:     "CPU Usage (%)",
-						Disabled:   false,
-					},
-				},
-				// Query C: Memory usage (state = used)
-				{
-					Type: qbtypes.QueryTypeBuilder,
-					Spec: qbtypes.QueryBuilderQuery[qbtypes.MetricAggregation]{
-						Name:   "C",
-						Signal: telemetrytypes.SignalMetrics,
-						Aggregations: []qbtypes.MetricAggregation{
-							{
-								MetricName:       "system.memory.usage",
-								TimeAggregation:  metrictypes.TimeAggregationAvg,
-								SpaceAggregation: metrictypes.SpaceAggregationSum,
-								ReduceTo:         qbtypes.ReduceToAvg,
-							},
-						},
-						Filter: &qbtypes.Filter{
-							Expression: "state = 'used'",
-						},
-						GroupBy:  []qbtypes.GroupByKey{hostNameGroupByKey},
-						Disabled: true,
-					},
-				},
-				// Query D: Memory usage (all states)
-				{
-					Type: qbtypes.QueryTypeBuilder,
-					Spec: qbtypes.QueryBuilderQuery[qbtypes.MetricAggregation]{
-						Name:   "D",
-						Signal: telemetrytypes.SignalMetrics,
-						Aggregations: []qbtypes.MetricAggregation{
-							{
-								MetricName:       "system.memory.usage",
-								TimeAggregation:  metrictypes.TimeAggregationAvg,
-								SpaceAggregation: metrictypes.SpaceAggregationSum,
-								ReduceTo:         qbtypes.ReduceToAvg,
-							},
-						},
-						GroupBy:  []qbtypes.GroupByKey{hostNameGroupByKey},
-						Disabled: true,
-					},
-				},
-				// Formula F2: Memory Usage (%)
-				{
-					Type: qbtypes.QueryTypeFormula,
-					Spec: qbtypes.QueryBuilderFormula{
-						Name:       "F2",
-						Expression: "C/D",
-						Legend:     "Memory Usage (%)",
-						Disabled:   false,
-					},
-				},
-				// Query E: CPU Wait time (state = wait)
-				{
-					Type: qbtypes.QueryTypeBuilder,
-					Spec: qbtypes.QueryBuilderQuery[qbtypes.MetricAggregation]{
-						Name:   "E",
-						Signal: telemetrytypes.SignalMetrics,
-						Aggregations: []qbtypes.MetricAggregation{
-							{
-								MetricName:       "system.cpu.time",
-								TimeAggregation:  metrictypes.TimeAggregationRate,
-								SpaceAggregation: metrictypes.SpaceAggregationSum,
-								ReduceTo:         qbtypes.ReduceToAvg,
-							},
-						},
-						Filter: &qbtypes.Filter{
-							Expression: "state = 'wait'",
-						},
-						GroupBy:  []qbtypes.GroupByKey{hostNameGroupByKey},
-						Disabled: true,
-					},
-				},
-				// Query F: CPU time (all states)
-				{
-					Type: qbtypes.QueryTypeBuilder,
-					Spec: qbtypes.QueryBuilderQuery[qbtypes.MetricAggregation]{
-						Name:   "F",
-						Signal: telemetrytypes.SignalMetrics,
-						Aggregations: []qbtypes.MetricAggregation{
-							{
-								MetricName:       "system.cpu.time",
-								TimeAggregation:  metrictypes.TimeAggregationRate,
-								SpaceAggregation: metrictypes.SpaceAggregationSum,
-								ReduceTo:         qbtypes.ReduceToAvg,
-							},
-						},
-						GroupBy:  []qbtypes.GroupByKey{hostNameGroupByKey},
-						Disabled: true,
-					},
-				},
-				// Formula F3: CPU Wait Time (%)
-				{
-					Type: qbtypes.QueryTypeFormula,
-					Spec: qbtypes.QueryBuilderFormula{
-						Name:       "F3",
-						Expression: "E/F",
-						Legend:     "CPU Wait Time (%)",
-						Disabled:   false,
-					},
-				},
-				// Query G: Load15
-				{
-					Type: qbtypes.QueryTypeBuilder,
-					Spec: qbtypes.QueryBuilderQuery[qbtypes.MetricAggregation]{
-						Name:   "G",
-						Signal: telemetrytypes.SignalMetrics,
-						Legend: "CPU Load Average (15m)",
-						Aggregations: []qbtypes.MetricAggregation{
-							{
-								MetricName:       "system.cpu.load_average.15m",
-								TimeAggregation:  metrictypes.TimeAggregationAvg,
-								SpaceAggregation: metrictypes.SpaceAggregationSum,
-								ReduceTo:         qbtypes.ReduceToAvg,
-							},
-						},
-						GroupBy:  []qbtypes.GroupByKey{hostNameGroupByKey},
-						Disabled: false,
-					},
-				},
-				// Query H: Filesystem Usage (state = used)
-				{
-					Type: qbtypes.QueryTypeBuilder,
-					Spec: qbtypes.QueryBuilderQuery[qbtypes.MetricAggregation]{
-						Name:   "H",
-						Signal: telemetrytypes.SignalMetrics,
-						Aggregations: []qbtypes.MetricAggregation{
-							{
-								MetricName:       "system.filesystem.usage",
-								TimeAggregation:  metrictypes.TimeAggregationAvg,
-								SpaceAggregation: metrictypes.SpaceAggregationSum,
-								ReduceTo:         qbtypes.ReduceToAvg,
-							},
-						},
-						Filter: &qbtypes.Filter{
-							Expression: "state = 'used'",
-						},
-						GroupBy:  []qbtypes.GroupByKey{hostNameGroupByKey},
-						Disabled: true,
-					},
-				},
-				// Query I: Filesystem Usage (all states)
-				{
-					Type: qbtypes.QueryTypeBuilder,
-					Spec: qbtypes.QueryBuilderQuery[qbtypes.MetricAggregation]{
-						Name:   "I",
-						Signal: telemetrytypes.SignalMetrics,
-						Aggregations: []qbtypes.MetricAggregation{
-							{
-								MetricName:       "system.filesystem.usage",
-								TimeAggregation:  metrictypes.TimeAggregationAvg,
-								SpaceAggregation: metrictypes.SpaceAggregationSum,
-								ReduceTo:         qbtypes.ReduceToAvg,
-							},
-						},
-						GroupBy:  []qbtypes.GroupByKey{hostNameGroupByKey},
-						Disabled: true,
-					},
-				},
-				// Formula F4: Disk Usage (%)
-				{
-					Type: qbtypes.QueryTypeFormula,
-					Spec: qbtypes.QueryBuilderFormula{
-						Name:       "F4",
-						Expression: "H/I",
-						Legend:     "Disk Usage (%)",
-						Disabled:   false,
-					},
-				},
-			},
-		},
-	}
-}

pkg/modules/inframonitoring/implinframonitoring/internaltypes.go

@@ -1,16 +0,0 @@
-package implinframonitoring
-
-// The types in this file are only used within the implinframonitoring package, and are not exposed outside.
-// They are primarily used for internal processing and structuring of data within the module's implementation.
-
-type rankedGroup struct {
-	labels       map[string]string
-	value        float64
-	compositeKey string
-}
-
-// groupHostStatusCounts holds per-group active and inactive host counts.
-type groupHostStatusCounts struct {
-	Active   int
-	Inactive int
-}

pkg/modules/inframonitoring/implinframonitoring/module.go

@@ -1,161 +0,0 @@
-package implinframonitoring
-
-import (
-	"context"
-	"log/slog"
-	"time"
-
-	"github.com/SigNoz/signoz/pkg/factory"
-	"github.com/SigNoz/signoz/pkg/modules/inframonitoring"
-	"github.com/SigNoz/signoz/pkg/querier"
-	"github.com/SigNoz/signoz/pkg/telemetrymetrics"
-	"github.com/SigNoz/signoz/pkg/telemetrystore"
-	"github.com/SigNoz/signoz/pkg/types/inframonitoringtypes"
-	qbtypes "github.com/SigNoz/signoz/pkg/types/querybuildertypes/querybuildertypesv5"
-	"github.com/SigNoz/signoz/pkg/types/telemetrytypes"
-	"github.com/SigNoz/signoz/pkg/valuer"
-)
-
-type module struct {
-	telemetryStore         telemetrystore.TelemetryStore
-	telemetryMetadataStore telemetrytypes.MetadataStore
-	querier                querier.Querier
-	fieldMapper            qbtypes.FieldMapper
-	condBuilder            qbtypes.ConditionBuilder
-	logger                 *slog.Logger
-	config                 inframonitoring.Config
-}
-
-// NewModule constructs the inframonitoring module with the provided dependencies.
-func NewModule(
-	telemetryStore telemetrystore.TelemetryStore,
-	telemetryMetadataStore telemetrytypes.MetadataStore,
-	querier querier.Querier,
-	providerSettings factory.ProviderSettings,
-	cfg inframonitoring.Config,
-) inframonitoring.Module {
-	fieldMapper := telemetrymetrics.NewFieldMapper()
-	condBuilder := telemetrymetrics.NewConditionBuilder(fieldMapper)
-	return &module{
-		telemetryStore:         telemetryStore,
-		telemetryMetadataStore: telemetryMetadataStore,
-		querier:                querier,
-		fieldMapper:            fieldMapper,
-		condBuilder:            condBuilder,
-		logger:                 providerSettings.Logger,
-		config:                 cfg,
-	}
-}
-
-func (m *module) ListHosts(ctx context.Context, orgID valuer.UUID, req *inframonitoringtypes.PostableHosts) (*inframonitoringtypes.Hosts, error) {
-	if err := req.Validate(); err != nil {
-		return nil, err
-	}
-
-	resp := &inframonitoringtypes.Hosts{}
-
-	// default to cpu order by
-	if req.OrderBy == nil {
-		req.OrderBy = &qbtypes.OrderBy{
-			Key: qbtypes.OrderByKey{
-				TelemetryFieldKey: telemetrytypes.TelemetryFieldKey{
-					Name: "cpu",
-				},
-			},
-			Direction: qbtypes.OrderDirectionDesc,
-		}
-	}
-
-	// default to host name group by
-	if len(req.GroupBy) == 0 {
-		req.GroupBy = []qbtypes.GroupByKey{hostNameGroupByKey}
-		resp.Type = inframonitoringtypes.ResponseTypeList
-	} else {
-		resp.Type = inframonitoringtypes.ResponseTypeGroupedList
-	}
-
-	// 1. Check which required metrics exist and get earliest retention time.
-	// If any required metric is missing, return early with the list of missing metrics.
-	// 2. If metrics exist but req.End is before the earliest reported time, return early with endTimeBeforeRetention=true.
-	missingMetrics, minFirstReportedUnixMilli, err := m.getMetricsExistenceAndEarliestTime(ctx, hostsTableMetricNamesList)
-	if err != nil {
-		return nil, err
-	}
-	if len(missingMetrics) > 0 {
-		resp.RequiredMetricsCheck = inframonitoringtypes.RequiredMetricsCheck{MissingMetrics: missingMetrics}
-		resp.Records = []inframonitoringtypes.HostRecord{}
-		resp.Total = 0
-		return resp, nil
-	}
-	if req.End < int64(minFirstReportedUnixMilli) {
-		resp.EndTimeBeforeRetention = true
-		resp.Records = []inframonitoringtypes.HostRecord{}
-		resp.Total = 0
-		return resp, nil
-	}
-	resp.RequiredMetricsCheck = inframonitoringtypes.RequiredMetricsCheck{MissingMetrics: []string{}}
-
-	// TOD(nikhilmantri0902): replace this separate ClickHouse query with a sub-query inside the main query builder query
-	// once QB supports sub-queries.
-	// Determine active hosts: those with metrics reported in the last 10 minutes.
-	// Compute the cutoff once so every downstream query/subquery agrees on what "active" means.
-	sinceUnixMilli := time.Now().Add(-10 * time.Minute).UTC().UnixMilli()
-	activeHostsMap, err := m.getActiveHosts(ctx, hostsTableMetricNamesList, hostNameAttrKey, sinceUnixMilli)
-	if err != nil {
-		return nil, err
-	}
-
-	// this check below modifies req.Filter by adding `AND active hosts filter` if req.FilterByStatus is set.
-	if m.applyHostsActiveStatusFilter(req, activeHostsMap) {
-		resp.Records = []inframonitoringtypes.HostRecord{}
-		resp.Total = 0
-		return resp, nil
-	}
-
-	metadataMap, err := m.getHostsTableMetadata(ctx, req)
-	if err != nil {
-		return nil, err
-	}
-
-	resp.Total = len(metadataMap)
-
-	pageGroups, err := m.getTopHostGroups(ctx, orgID, req, metadataMap)
-	if err != nil {
-		return nil, err
-	}
-
-	if len(pageGroups) == 0 {
-		resp.Records = []inframonitoringtypes.HostRecord{}
-		return resp, nil
-	}
-
-	hostsFilterExpr := ""
-	if req.Filter != nil {
-		hostsFilterExpr = req.Filter.Expression
-	}
-
-	fullQueryReq := buildFullQueryRequest(req.Start, req.End, hostsFilterExpr, req.GroupBy, pageGroups, m.newListHostsQuery())
-	queryResp, err := m.querier.QueryRange(ctx, orgID, fullQueryReq)
-	if err != nil {
-		return nil, err
-	}
-
-	// Compute per-group active/inactive host counts.
-	// When host.name is in groupBy, each row = one host, so counts are derived
-	// directly from activeHostsMap in buildHostRecords (no extra query needed).
-	// When host.name is not in groupBy, we need to run an additional query to get the counts per group for the current page,
-	// using the same filter expression as the main query (including user filters + page groups IN clause).
-	hostCounts := make(map[string]groupHostStatusCounts)
-	isHostNameInGroupBy := isKeyInGroupByAttrs(req.GroupBy, hostNameAttrKey)
-	if !isHostNameInGroupBy {
-		hostCounts, err = m.getPerGroupHostStatusCounts(ctx, req, hostsTableMetricNamesList, pageGroups, sinceUnixMilli)
-		if err != nil {
-			return nil, err
-		}
-	}
-
-	resp.Records = buildHostRecords(isHostNameInGroupBy, queryResp, pageGroups, req.GroupBy, metadataMap, activeHostsMap, hostCounts)
-	resp.Warning = queryResp.Warning
-
-	return resp, nil
-}

pkg/modules/inframonitoring/inframonitoring.go

@@ -1,17 +0,0 @@
-package inframonitoring
-
-import (
-	"context"
-	"net/http"
-
-	"github.com/SigNoz/signoz/pkg/types/inframonitoringtypes"
-	"github.com/SigNoz/signoz/pkg/valuer"
-)
-
-type Handler interface {
-	ListHosts(http.ResponseWriter, *http.Request)
-}
-
-type Module interface {
-	ListHosts(ctx context.Context, orgID valuer.UUID, req *inframonitoringtypes.PostableHosts) (*inframonitoringtypes.Hosts, error)
-}

pkg/signoz/config.go

@@ -23,7 +23,6 @@ import (
 	"github.com/SigNoz/signoz/pkg/identn"
 	"github.com/SigNoz/signoz/pkg/instrumentation"
 	"github.com/SigNoz/signoz/pkg/modules/cloudintegration"
-	"github.com/SigNoz/signoz/pkg/modules/inframonitoring"
 	"github.com/SigNoz/signoz/pkg/modules/metricsexplorer"
 	"github.com/SigNoz/signoz/pkg/modules/serviceaccount"
 	"github.com/SigNoz/signoz/pkg/modules/user"
@@ -115,9 +114,6 @@ type Config struct {
 	// MetricsExplorer config
 	MetricsExplorer metricsexplorer.Config `mapstructure:"metricsexplorer"`
 
-	// InfraMonitoring config
-	InfraMonitoring inframonitoring.Config `mapstructure:"inframonitoring"`
-
 	// Flagger config
 	Flagger flagger.Config `mapstructure:"flagger"`
 
@@ -161,7 +157,6 @@ func NewConfig(ctx context.Context, logger *slog.Logger, resolverConfig config.R
 		gateway.NewConfigFactory(),
 		tokenizer.NewConfigFactory(),
 		metricsexplorer.NewConfigFactory(),
-		inframonitoring.NewConfigFactory(),
 		flagger.NewConfigFactory(),
 		user.NewConfigFactory(),
 		identn.NewConfigFactory(),

pkg/signoz/handler.go

@@ -22,8 +22,6 @@ import (
 	"github.com/SigNoz/signoz/pkg/modules/dashboard/impldashboard"
 	"github.com/SigNoz/signoz/pkg/modules/fields"
 	"github.com/SigNoz/signoz/pkg/modules/fields/implfields"
-	"github.com/SigNoz/signoz/pkg/modules/inframonitoring"
-	"github.com/SigNoz/signoz/pkg/modules/inframonitoring/implinframonitoring"
 	"github.com/SigNoz/signoz/pkg/modules/metricsexplorer"
 	"github.com/SigNoz/signoz/pkg/modules/metricsexplorer/implmetricsexplorer"
 	"github.com/SigNoz/signoz/pkg/modules/quickfilter"
@@ -57,7 +55,6 @@ type Handlers struct {
 	SpanPercentile          spanpercentile.Handler
 	Services                services.Handler
 	MetricsExplorer         metricsexplorer.Handler
-	InfraMonitoring         inframonitoring.Handler
 	Global                  global.Handler
 	FlaggerHandler          flagger.Handler
 	GatewayHandler          gateway.Handler
@@ -98,7 +95,6 @@ func NewHandlers(
 		RawDataExport:           implrawdataexport.NewHandler(modules.RawDataExport),
 		Services:                implservices.NewHandler(modules.Services),
 		MetricsExplorer:         implmetricsexplorer.NewHandler(modules.MetricsExplorer),
-		InfraMonitoring:         implinframonitoring.NewHandler(modules.InfraMonitoring),
 		SpanPercentile:          implspanpercentile.NewHandler(modules.SpanPercentile),
 		Global:                  signozglobal.NewHandler(global),
 		FlaggerHandler:          flagger.NewHandler(flaggerService),

pkg/signoz/module.go

@@ -14,8 +14,6 @@ import (
 	"github.com/SigNoz/signoz/pkg/modules/authdomain/implauthdomain"
 	"github.com/SigNoz/signoz/pkg/modules/cloudintegration"
 	"github.com/SigNoz/signoz/pkg/modules/dashboard"
-	"github.com/SigNoz/signoz/pkg/modules/inframonitoring"
-	"github.com/SigNoz/signoz/pkg/modules/inframonitoring/implinframonitoring"
 	"github.com/SigNoz/signoz/pkg/modules/metricsexplorer"
 	"github.com/SigNoz/signoz/pkg/modules/metricsexplorer/implmetricsexplorer"
 	"github.com/SigNoz/signoz/pkg/modules/organization"
@@ -71,7 +69,6 @@ type Modules struct {
 	Services         services.Module
 	SpanPercentile   spanpercentile.Module
 	MetricsExplorer  metricsexplorer.Module
-	InfraMonitoring  inframonitoring.Module
 	Promote          promote.Module
 	ServiceAccount   serviceaccount.Module
 	CloudIntegration cloudintegration.Module
@@ -122,7 +119,6 @@ func NewModules(
 		SpanPercentile:   implspanpercentile.NewModule(querier, providerSettings),
 		Services:         implservices.NewModule(querier, telemetryStore),
 		MetricsExplorer:  implmetricsexplorer.NewModule(telemetryStore, telemetryMetadataStore, cache, ruleStore, dashboard, providerSettings, config.MetricsExplorer),
-		InfraMonitoring:  implinframonitoring.NewModule(telemetryStore, telemetryMetadataStore, querier, providerSettings, config.InfraMonitoring),
 		Promote:          implpromote.NewModule(telemetryMetadataStore, telemetryStore),
 		ServiceAccount:   serviceAccount,
 		RuleStateHistory: implrulestatehistory.NewModule(implrulestatehistory.NewStore(telemetryStore, telemetryMetadataStore, providerSettings.Logger)),

pkg/signoz/openapi.go

@@ -22,7 +22,6 @@ import (
 	"github.com/SigNoz/signoz/pkg/modules/dashboard"
 	"github.com/SigNoz/signoz/pkg/modules/fields"
 	"github.com/SigNoz/signoz/pkg/modules/metricsexplorer"
-	"github.com/SigNoz/signoz/pkg/modules/inframonitoring"
 	"github.com/SigNoz/signoz/pkg/modules/organization"
 	"github.com/SigNoz/signoz/pkg/modules/preference"
 	"github.com/SigNoz/signoz/pkg/modules/promote"
@@ -62,7 +61,6 @@ func NewOpenAPI(ctx context.Context, instrumentation instrumentation.Instrumenta
 		struct{ dashboard.Module }{},
 		struct{ dashboard.Handler }{},
 		struct{ metricsexplorer.Handler }{},
-		struct{ inframonitoring.Handler }{},
 		struct{ gateway.Handler }{},
 		struct{ fields.Handler }{},
 		struct{ authz.Handler }{},

pkg/signoz/provider.go

@@ -272,7 +272,6 @@ func NewAPIServerProviderFactories(orgGetter organization.Getter, authz authz.Au
 			modules.Dashboard,
 			handlers.Dashboard,
 			handlers.MetricsExplorer,
-			handlers.InfraMonitoring,
 			handlers.GatewayHandler,
 			handlers.Fields,
 			handlers.AuthzHandler,

pkg/templating/markdownrenderer/blockkit/blockkit.go

@@ -1,755 +0,0 @@
-package blockkit
-
-import (
-	"bytes"
-	"encoding/json"
-	"strings"
-
-	"github.com/SigNoz/signoz/pkg/types/templatingtypes"
-	"github.com/yuin/goldmark"
-	"github.com/yuin/goldmark/ast"
-	"github.com/yuin/goldmark/extension"
-	extensionast "github.com/yuin/goldmark/extension/ast"
-	"github.com/yuin/goldmark/renderer"
-	"github.com/yuin/goldmark/util"
-)
-
-// Extender is a goldmark.Extender that registers the Block Kit node renderer
-// together with the GFM extensions it relies on (tables, strikethrough, task
-// lists).
-var Extender goldmark.Extender = &extender{}
-
-type extender struct{}
-
-func (e *extender) Extend(m goldmark.Markdown) {
-	extension.Table.Extend(m)
-	extension.Strikethrough.Extend(m)
-	extension.TaskList.Extend(m)
-	m.Renderer().AddOptions(
-		renderer.WithNodeRenderers(util.Prioritized(newRenderer(), 1)),
-	)
-}
-
-// listFrame tracks state for a single level of list nesting.
-type listFrame struct {
-	style     string // "bullet" or "ordered"
-	indent    int
-	itemCount int
-}
-
-// listContext holds all state while processing a list tree.
-type listContext struct {
-	result             []templatingtypes.RichTextList
-	stack              []listFrame
-	current            *templatingtypes.RichTextList
-	currentItemInlines []interface{}
-}
-
-// tableContext holds state while processing a table.
-type tableContext struct {
-	rows               [][]templatingtypes.TableCell
-	currentRow         []templatingtypes.TableCell
-	currentCellInlines []interface{}
-	isHeader           bool
-}
-
-// nodeRenderer converts Markdown AST to Slack Block Kit JSON.
-type nodeRenderer struct {
-	blocks []interface{}
-	mrkdwn strings.Builder
-	// holds active styles for the current rich text element
-	styleStack []templatingtypes.RichTextStyle
-	// holds the current list context while processing a list tree.
-	listCtx *listContext
-	// holds the current table context while processing a table.
-	tableCtx *tableContext
-	// stores the current blockquote depth while processing a blockquote.
-	// so blockquote with nested list can be rendered correctly.
-	blockquoteDepth int
-}
-
-func newRenderer() renderer.NodeRenderer {
-	return &nodeRenderer{}
-}
-
-// RegisterFuncs registers node rendering functions.
-func (r *nodeRenderer) RegisterFuncs(reg renderer.NodeRendererFuncRegisterer) {
-	// Blocks
-	reg.Register(ast.KindDocument, r.renderDocument)
-	reg.Register(ast.KindHeading, r.renderHeading)
-	reg.Register(ast.KindParagraph, r.renderParagraph)
-	reg.Register(ast.KindThematicBreak, r.renderThematicBreak)
-	reg.Register(ast.KindCodeBlock, r.renderCodeBlock)
-	reg.Register(ast.KindFencedCodeBlock, r.renderFencedCodeBlock)
-	reg.Register(ast.KindBlockquote, r.renderBlockquote)
-	reg.Register(ast.KindList, r.renderList)
-	reg.Register(ast.KindListItem, r.renderListItem)
-	reg.Register(ast.KindImage, r.renderImage)
-
-	// Inlines
-	reg.Register(ast.KindText, r.renderText)
-	reg.Register(ast.KindEmphasis, r.renderEmphasis)
-	reg.Register(ast.KindCodeSpan, r.renderCodeSpan)
-	reg.Register(ast.KindLink, r.renderLink)
-
-	// Extensions
-	reg.Register(extensionast.KindStrikethrough, r.renderStrikethrough)
-	reg.Register(extensionast.KindTable, r.renderTable)
-	reg.Register(extensionast.KindTableHeader, r.renderTableHeader)
-	reg.Register(extensionast.KindTableRow, r.renderTableRow)
-	reg.Register(extensionast.KindTableCell, r.renderTableCell)
-	reg.Register(extensionast.KindTaskCheckBox, r.renderTaskCheckBox)
-}
-
-// inRichTextMode returns true when we're inside a list or table context
-// in slack blockkit list and table items are rendered as rich_text elements
-// if more cases are found in future those needs to be added here.
-func (r *nodeRenderer) inRichTextMode() bool {
-	return r.listCtx != nil || r.tableCtx != nil
-}
-
-// currentStyle merges the stored style stack into templatingtypes.RichTextStyle
-// which can be applied on rich text elements.
-func (r *nodeRenderer) currentStyle() *templatingtypes.RichTextStyle {
-	s := templatingtypes.RichTextStyle{}
-	for _, f := range r.styleStack {
-		s.Bold = s.Bold || f.Bold
-		s.Italic = s.Italic || f.Italic
-		s.Strike = s.Strike || f.Strike
-		s.Code = s.Code || f.Code
-	}
-	if s == (templatingtypes.RichTextStyle{}) {
-		return nil
-	}
-	return &s
-}
-
-// flushMrkdwn collects markdown text and adds it as a templatingtypes.SectionBlock with mrkdwn text
-// whenever starting a new block we flush markdown to render it as a separate block.
-func (r *nodeRenderer) flushMrkdwn() {
-	text := strings.TrimSpace(r.mrkdwn.String())
-	if text != "" {
-		r.blocks = append(r.blocks, templatingtypes.SectionBlock{
-			Type: "section",
-			Text: &templatingtypes.TextObject{
-				Type: "mrkdwn",
-				Text: text,
-			},
-		})
-	}
-	r.mrkdwn.Reset()
-}
-
-// addInline adds an inline element to the appropriate context.
-func (r *nodeRenderer) addInline(el interface{}) {
-	if r.listCtx != nil {
-		r.listCtx.currentItemInlines = append(r.listCtx.currentItemInlines, el)
-	} else if r.tableCtx != nil {
-		r.tableCtx.currentCellInlines = append(r.tableCtx.currentCellInlines, el)
-	}
-}
-
-// --- Document ---
-
-func (r *nodeRenderer) renderDocument(w util.BufWriter, source []byte, node ast.Node, entering bool) (ast.WalkStatus, error) {
-	if entering {
-		r.blocks = nil
-		r.mrkdwn.Reset()
-		r.styleStack = nil
-		r.listCtx = nil
-		r.tableCtx = nil
-		r.blockquoteDepth = 0
-	} else {
-		// on exiting the document node write the json for the collected blocks.
-		r.flushMrkdwn()
-		var data []byte
-		var err error
-		if len(r.blocks) > 0 {
-			data, err = json.Marshal(r.blocks)
-			if err != nil {
-				return ast.WalkStop, err
-			}
-		} else {
-			// if no blocks are collected, write an empty array.
-			data = []byte("[]")
-		}
-		_, err = w.Write(data)
-		if err != nil {
-			return ast.WalkStop, err
-		}
-	}
-	return ast.WalkContinue, nil
-}
-
-// --- Heading ---
-
-func (r *nodeRenderer) renderHeading(w util.BufWriter, source []byte, node ast.Node, entering bool) (ast.WalkStatus, error) {
-	if entering {
-		r.mrkdwn.WriteString("*")
-	} else {
-		r.mrkdwn.WriteString("*\n")
-	}
-	return ast.WalkContinue, nil
-}
-
-// --- Paragraph ---
-
-func (r *nodeRenderer) renderParagraph(w util.BufWriter, source []byte, node ast.Node, entering bool) (ast.WalkStatus, error) {
-	if entering {
-		if r.mrkdwn.Len() > 0 {
-			text := r.mrkdwn.String()
-			if !strings.HasSuffix(text, "\n") {
-				r.mrkdwn.WriteString("\n")
-			}
-		}
-		// handling of nested blockquotes
-		if r.blockquoteDepth > 0 {
-			r.mrkdwn.WriteString(strings.Repeat("> ", r.blockquoteDepth))
-		}
-	}
-	return ast.WalkContinue, nil
-}
-
-// --- ThematicBreak ---
-
-func (r *nodeRenderer) renderThematicBreak(w util.BufWriter, source []byte, node ast.Node, entering bool) (ast.WalkStatus, error) {
-	if entering {
-		r.flushMrkdwn()
-		r.blocks = append(r.blocks, templatingtypes.DividerBlock{Type: "divider"})
-	}
-	return ast.WalkContinue, nil
-}
-
-// --- CodeBlock (indented) ---
-
-func (r *nodeRenderer) renderCodeBlock(w util.BufWriter, source []byte, node ast.Node, entering bool) (ast.WalkStatus, error) {
-	if !entering {
-		return ast.WalkContinue, nil
-	}
-	r.flushMrkdwn()
-
-	var buf bytes.Buffer
-	lines := node.Lines()
-	for i := 0; i < lines.Len(); i++ {
-		line := lines.At(i)
-		buf.Write(line.Value(source))
-	}
-
-	text := buf.String()
-	// Remove trailing newline
-	text = strings.TrimRight(text, "\n")
-	// Slack API rejects empty text in rich_text_preformatted elements
-	if text == "" {
-		text = " "
-	}
-
-	elements := []interface{}{
-		templatingtypes.RichTextInline{Type: "text", Text: text},
-	}
-
-	r.blocks = append(r.blocks, templatingtypes.RichTextBlock{
-		Type: "rich_text",
-		Elements: []interface{}{
-			templatingtypes.RichTextPreformatted{
-				Type:     "rich_text_preformatted",
-				Elements: elements,
-				Border:   0,
-			},
-		},
-	})
-	return ast.WalkContinue, nil
-}
-
-// --- FencedCodeBlock ---
-
-func (r *nodeRenderer) renderFencedCodeBlock(w util.BufWriter, source []byte, node ast.Node, entering bool) (ast.WalkStatus, error) {
-	if !entering {
-		return ast.WalkContinue, nil
-	}
-	r.flushMrkdwn()
-
-	n := node.(*ast.FencedCodeBlock)
-	var buf bytes.Buffer
-	lines := node.Lines()
-	for i := 0; i < lines.Len(); i++ {
-		line := lines.At(i)
-		buf.Write(line.Value(source))
-	}
-
-	text := buf.String()
-	text = strings.TrimRight(text, "\n")
-	// Slack API rejects empty text in rich_text_preformatted elements
-	if text == "" {
-		text = " "
-	}
-
-	elements := []interface{}{
-		templatingtypes.RichTextInline{Type: "text", Text: text},
-	}
-
-	// If language is specified, collect it.
-	var language string
-	lang := n.Language(source)
-	if len(lang) > 0 {
-		language = string(lang)
-	}
-	// Add the preformatted block to the blocks slice with the collected language.
-	r.blocks = append(r.blocks, templatingtypes.RichTextBlock{
-		Type: "rich_text",
-		Elements: []interface{}{
-			templatingtypes.RichTextPreformatted{
-				Type:     "rich_text_preformatted",
-				Elements: elements,
-				Border:   0,
-				Language: language,
-			},
-		},
-	})
-
-	return ast.WalkSkipChildren, nil
-}
-
-// --- Blockquote ---
-
-func (r *nodeRenderer) renderBlockquote(w util.BufWriter, source []byte, node ast.Node, entering bool) (ast.WalkStatus, error) {
-	if entering {
-		r.blockquoteDepth++
-	} else {
-		r.blockquoteDepth--
-	}
-	return ast.WalkContinue, nil
-}
-
-// --- List ---
-
-func (r *nodeRenderer) renderList(w util.BufWriter, source []byte, node ast.Node, entering bool) (ast.WalkStatus, error) {
-	list := node.(*ast.List)
-
-	if entering {
-		style := "bullet"
-		if list.IsOrdered() {
-			style = "ordered"
-		}
-
-		if r.listCtx == nil {
-			// Top-level list: flush mrkdwn and create context
-			r.flushMrkdwn()
-			r.listCtx = &listContext{}
-		} else {
-			// Nested list: check if we already have some collected list items that needs to be flushed.
-			// in slack blockkit, list items with different levels of indentation are added as different rich_text_list blocks.
-			if len(r.listCtx.currentItemInlines) > 0 {
-				sec := templatingtypes.RichTextBlock{
-					Type:     "rich_text_section",
-					Elements: r.listCtx.currentItemInlines,
-				}
-				if r.listCtx.current != nil {
-					r.listCtx.current.Elements = append(r.listCtx.current.Elements, sec)
-				}
-				r.listCtx.currentItemInlines = nil
-				// Increment parent's itemCount
-				if len(r.listCtx.stack) > 0 {
-					r.listCtx.stack[len(r.listCtx.stack)-1].itemCount++
-				}
-			}
-			// Finalize current list to result only if items were collected
-			if r.listCtx.current != nil && len(r.listCtx.current.Elements) > 0 {
-				r.listCtx.result = append(r.listCtx.result, *r.listCtx.current)
-			}
-		}
-
-		// the stack accumulated till this level derives hte indentation
-		// the stack get's collected as we go in more nested levels of list
-		// and as we get our of the nesting we remove the items from the slack
-		indent := len(r.listCtx.stack)
-		r.listCtx.stack = append(r.listCtx.stack, listFrame{
-			style:     style,
-			indent:    indent,
-			itemCount: 0,
-		})
-
-		newList := &templatingtypes.RichTextList{
-			Type:     "rich_text_list",
-			Style:    style,
-			Indent:   indent,
-			Border:   0,
-			Elements: []interface{}{},
-		}
-
-		// Handle ordered list with start > 1
-		if list.IsOrdered() && list.Start > 1 {
-			newList.Offset = list.Start - 1
-		}
-
-		r.listCtx.current = newList
-
-	} else {
-		// Leaving list: finalize current list
-		if r.listCtx.current != nil && len(r.listCtx.current.Elements) > 0 {
-			r.listCtx.result = append(r.listCtx.result, *r.listCtx.current)
-		}
-
-		// Pop stack to so upcoming indentations can be handled correctly.
-		r.listCtx.stack = r.listCtx.stack[:len(r.listCtx.stack)-1]
-
-		if len(r.listCtx.stack) > 0 {
-			// Resume parent: start a new list segment at parent indent/style
-			parent := &r.listCtx.stack[len(r.listCtx.stack)-1]
-			newList := &templatingtypes.RichTextList{
-				Type:     "rich_text_list",
-				Style:    parent.style,
-				Indent:   parent.indent,
-				Border:   0,
-				Elements: []interface{}{},
-			}
-			// Set offset for ordered parent continuation
-			if parent.style == "ordered" && parent.itemCount > 0 {
-				newList.Offset = parent.itemCount
-			}
-			r.listCtx.current = newList
-		} else {
-			// Top-level list is done since all stack are popped: build templatingtypes.RichTextBlock if non-empty
-			if len(r.listCtx.result) > 0 {
-				elements := make([]interface{}, len(r.listCtx.result))
-				for i, l := range r.listCtx.result {
-					elements[i] = l
-				}
-				r.blocks = append(r.blocks, templatingtypes.RichTextBlock{
-					Type:     "rich_text",
-					Elements: elements,
-				})
-			}
-			r.listCtx = nil
-		}
-	}
-
-	return ast.WalkContinue, nil
-}
-
-// --- ListItem ---
-
-func (r *nodeRenderer) renderListItem(w util.BufWriter, source []byte, node ast.Node, entering bool) (ast.WalkStatus, error) {
-	if entering {
-		r.listCtx.currentItemInlines = nil
-	} else {
-		// Only add if there are inlines (might be empty after nested list consumed them)
-		if len(r.listCtx.currentItemInlines) > 0 {
-			sec := templatingtypes.RichTextBlock{
-				Type:     "rich_text_section",
-				Elements: r.listCtx.currentItemInlines,
-			}
-			if r.listCtx.current != nil {
-				r.listCtx.current.Elements = append(r.listCtx.current.Elements, sec)
-			}
-			r.listCtx.currentItemInlines = nil
-			// Increment parent frame's itemCount
-			if len(r.listCtx.stack) > 0 {
-				r.listCtx.stack[len(r.listCtx.stack)-1].itemCount++
-			}
-		}
-	}
-
-	return ast.WalkContinue, nil
-}
-
-// --- Table ---
-// when table is encountered, we flush the markdown and create a table context.
-// when header row is encountered, we set the isHeader flag to true
-// when each row ends in renderTableRow we add that row to rows array of table context.
-// when table cell is encountered, we apply header related styles to the collected inline items,
-// all inline items are parsed as separate AST items like list item, links, text, etc. are collected
-// using the addInline function and wrapped in a rich_text_section block.
-
-func (r *nodeRenderer) renderTable(w util.BufWriter, source []byte, node ast.Node, entering bool) (ast.WalkStatus, error) {
-	if entering {
-		r.flushMrkdwn()
-		r.tableCtx = &tableContext{}
-	} else {
-		// Pad short rows to match header column count for valid Block Kit payload
-		// without this slack blockkit attachment is invalid and the API fails
-		rows := r.tableCtx.rows
-		if len(rows) > 0 {
-			maxCols := len(rows[0])
-			for i, row := range rows {
-				for len(row) < maxCols {
-					emptySec := templatingtypes.RichTextBlock{
-						Type:     "rich_text_section",
-						Elements: []interface{}{templatingtypes.RichTextInline{Type: "text", Text: " "}},
-					}
-					row = append(row, templatingtypes.TableCell{
-						Type:     "rich_text",
-						Elements: []interface{}{emptySec},
-					})
-				}
-				rows[i] = row
-			}
-		}
-		r.blocks = append(r.blocks, templatingtypes.TableBlock{
-			Type: "table",
-			Rows: rows,
-		})
-		r.tableCtx = nil
-	}
-	return ast.WalkContinue, nil
-}
-
-func (r *nodeRenderer) renderTableHeader(w util.BufWriter, source []byte, node ast.Node, entering bool) (ast.WalkStatus, error) {
-	if entering {
-		r.tableCtx.isHeader = true
-		r.tableCtx.currentRow = nil
-	} else {
-		r.tableCtx.rows = append(r.tableCtx.rows, r.tableCtx.currentRow)
-		r.tableCtx.currentRow = nil
-		r.tableCtx.isHeader = false
-	}
-	return ast.WalkContinue, nil
-}
-
-func (r *nodeRenderer) renderTableRow(w util.BufWriter, source []byte, node ast.Node, entering bool) (ast.WalkStatus, error) {
-	if entering {
-		r.tableCtx.currentRow = nil
-	} else {
-		r.tableCtx.rows = append(r.tableCtx.rows, r.tableCtx.currentRow)
-		r.tableCtx.currentRow = nil
-	}
-	return ast.WalkContinue, nil
-}
-
-func (r *nodeRenderer) renderTableCell(w util.BufWriter, source []byte, node ast.Node, entering bool) (ast.WalkStatus, error) {
-	if entering {
-		r.tableCtx.currentCellInlines = nil
-	} else {
-		// If header, make text bold for the collected inline items.
-		if r.tableCtx.isHeader {
-			for i, el := range r.tableCtx.currentCellInlines {
-				if inline, ok := el.(templatingtypes.RichTextInline); ok {
-					if inline.Style == nil {
-						inline.Style = &templatingtypes.RichTextStyle{Bold: true}
-					} else {
-						inline.Style.Bold = true
-					}
-					r.tableCtx.currentCellInlines[i] = inline
-				}
-			}
-		}
-		// Ensure cell has at least one element for valid Block Kit payload
-		if len(r.tableCtx.currentCellInlines) == 0 {
-			r.tableCtx.currentCellInlines = []interface{}{
-				templatingtypes.RichTextInline{Type: "text", Text: " "},
-			}
-		}
-		// All inline items that are collected for a table cell are wrapped in a rich_text_section block.
-		sec := templatingtypes.RichTextBlock{
-			Type:     "rich_text_section",
-			Elements: r.tableCtx.currentCellInlines,
-		}
-		// The rich_text_section block is wrapped in a rich_text block.
-		cell := templatingtypes.TableCell{
-			Type:     "rich_text",
-			Elements: []interface{}{sec},
-		}
-		r.tableCtx.currentRow = append(r.tableCtx.currentRow, cell)
-		r.tableCtx.currentCellInlines = nil
-	}
-	return ast.WalkContinue, nil
-}
-
-// --- TaskCheckBox ---
-
-func (r *nodeRenderer) renderTaskCheckBox(w util.BufWriter, source []byte, node ast.Node, entering bool) (ast.WalkStatus, error) {
-	if !entering {
-		return ast.WalkContinue, nil
-	}
-	n := node.(*extensionast.TaskCheckBox)
-	text := "[ ] "
-	if n.IsChecked {
-		text = "[x] "
-	}
-	if r.inRichTextMode() {
-		r.addInline(templatingtypes.RichTextInline{Type: "text", Text: text})
-	} else {
-		r.mrkdwn.WriteString(text)
-	}
-	return ast.WalkContinue, nil
-}
-
-// --- Inline: Text ---
-
-func (r *nodeRenderer) renderText(w util.BufWriter, source []byte, node ast.Node, entering bool) (ast.WalkStatus, error) {
-	if !entering {
-		return ast.WalkContinue, nil
-	}
-	n := node.(*ast.Text)
-	value := string(n.Segment.Value(source))
-
-	if r.inRichTextMode() {
-		r.addInline(templatingtypes.RichTextInline{
-			Type:  "text",
-			Text:  value,
-			Style: r.currentStyle(),
-		})
-		if n.HardLineBreak() || n.SoftLineBreak() {
-			r.addInline(templatingtypes.RichTextInline{Type: "text", Text: "\n"})
-		}
-	} else {
-		r.mrkdwn.WriteString(value)
-		if n.HardLineBreak() || n.SoftLineBreak() {
-			r.mrkdwn.WriteString("\n")
-			if r.blockquoteDepth > 0 {
-				r.mrkdwn.WriteString(strings.Repeat("> ", r.blockquoteDepth))
-			}
-		}
-	}
-	return ast.WalkContinue, nil
-}
-
-// --- Inline: Emphasis ---
-
-func (r *nodeRenderer) renderEmphasis(w util.BufWriter, source []byte, node ast.Node, entering bool) (ast.WalkStatus, error) {
-	n := node.(*ast.Emphasis)
-	if r.inRichTextMode() {
-		if entering {
-			s := templatingtypes.RichTextStyle{}
-			if n.Level == 1 {
-				s.Italic = true
-			} else {
-				s.Bold = true
-			}
-			r.styleStack = append(r.styleStack, s)
-		} else {
-			// the collected style gets used by the rich text element using currentStyle()
-			// so we remove this style from the stack.
-			if len(r.styleStack) > 0 {
-				r.styleStack = r.styleStack[:len(r.styleStack)-1]
-			}
-		}
-	} else {
-		if n.Level == 1 {
-			r.mrkdwn.WriteString("_")
-		} else {
-			r.mrkdwn.WriteString("*")
-		}
-	}
-	return ast.WalkContinue, nil
-}
-
-// --- Inline: Strikethrough ---
-
-func (r *nodeRenderer) renderStrikethrough(w util.BufWriter, source []byte, node ast.Node, entering bool) (ast.WalkStatus, error) {
-	if r.inRichTextMode() {
-		if entering {
-			r.styleStack = append(r.styleStack, templatingtypes.RichTextStyle{Strike: true})
-		} else {
-			// the collected style gets used by the rich text element using currentStyle()
-			// so we remove this style from the stack.
-			if len(r.styleStack) > 0 {
-				r.styleStack = r.styleStack[:len(r.styleStack)-1]
-			}
-		}
-	} else {
-		r.mrkdwn.WriteString("~")
-	}
-	return ast.WalkContinue, nil
-}
-
-// --- Inline: CodeSpan ---
-
-func (r *nodeRenderer) renderCodeSpan(w util.BufWriter, source []byte, node ast.Node, entering bool) (ast.WalkStatus, error) {
-	if !entering {
-		return ast.WalkContinue, nil
-	}
-	if r.inRichTextMode() {
-		// Collect all child text
-		var buf bytes.Buffer
-		for c := node.FirstChild(); c != nil; c = c.NextSibling() {
-			if t, ok := c.(*ast.Text); ok {
-				v := t.Segment.Value(source)
-				if bytes.HasSuffix(v, []byte("\n")) {
-					buf.Write(v[:len(v)-1])
-					buf.WriteByte(' ')
-				} else {
-					buf.Write(v)
-				}
-			} else if s, ok := c.(*ast.String); ok {
-				buf.Write(s.Value)
-			}
-		}
-		style := r.currentStyle()
-		if style == nil {
-			style = &templatingtypes.RichTextStyle{Code: true}
-		} else {
-			style.Code = true
-		}
-		r.addInline(templatingtypes.RichTextInline{
-			Type:  "text",
-			Text:  buf.String(),
-			Style: style,
-		})
-		return ast.WalkSkipChildren, nil
-	}
-	// mrkdwn mode
-	r.mrkdwn.WriteByte('`')
-	for c := node.FirstChild(); c != nil; c = c.NextSibling() {
-		if t, ok := c.(*ast.Text); ok {
-			v := t.Segment.Value(source)
-			if bytes.HasSuffix(v, []byte("\n")) {
-				r.mrkdwn.Write(v[:len(v)-1])
-				r.mrkdwn.WriteByte(' ')
-			} else {
-				r.mrkdwn.Write(v)
-			}
-		} else if s, ok := c.(*ast.String); ok {
-			r.mrkdwn.Write(s.Value)
-		}
-	}
-	r.mrkdwn.WriteByte('`')
-	return ast.WalkSkipChildren, nil
-}
-
-// --- Inline: Link ---
-
-func (r *nodeRenderer) renderLink(w util.BufWriter, source []byte, node ast.Node, entering bool) (ast.WalkStatus, error) {
-	n := node.(*ast.Link)
-	if r.inRichTextMode() {
-		if entering {
-			// Walk the entire subtree to collect text from all descendants,
-			// including nested inline nodes like emphasis, strong, code spans, etc.
-			var buf bytes.Buffer
-			_ = ast.Walk(node, func(child ast.Node, entering bool) (ast.WalkStatus, error) {
-				if !entering || child == node {
-					return ast.WalkContinue, nil
-				}
-				if t, ok := child.(*ast.Text); ok {
-					buf.Write(t.Segment.Value(source))
-				} else if s, ok := child.(*ast.String); ok {
-					buf.Write(s.Value)
-				}
-				return ast.WalkContinue, nil
-			})
-			// Once we've collected the text for the link (given it was present)
-			// let's add the link to the rich text block.
-			r.addInline(templatingtypes.RichTextLink{
-				Type:  "link",
-				URL:   string(n.Destination),
-				Text:  buf.String(),
-				Style: r.currentStyle(),
-			})
-			return ast.WalkSkipChildren, nil
-		}
-	} else {
-		if entering {
-			r.mrkdwn.WriteString("<")
-			r.mrkdwn.Write(n.Destination)
-			r.mrkdwn.WriteString("|")
-		} else {
-			r.mrkdwn.WriteString(">")
-		}
-	}
-	return ast.WalkContinue, nil
-}
-
-// --- Image (skip) ---
-
-func (r *nodeRenderer) renderImage(w util.BufWriter, source []byte, node ast.Node, entering bool) (ast.WalkStatus, error) {
-	return ast.WalkSkipChildren, nil
-}

pkg/templating/markdownrenderer/blockkit/blockkit_test.go

@@ -1,542 +0,0 @@
-package blockkit
-
-import (
-	"bytes"
-	"encoding/json"
-	"testing"
-
-	"github.com/yuin/goldmark"
-)
-
-func jsonEqual(a, b string) bool {
-	var va, vb interface{}
-	if err := json.Unmarshal([]byte(a), &va); err != nil {
-		return false
-	}
-	if err := json.Unmarshal([]byte(b), &vb); err != nil {
-		return false
-	}
-	ja, _ := json.Marshal(va)
-	jb, _ := json.Marshal(vb)
-	return string(ja) == string(jb)
-}
-
-func prettyJSON(s string) string {
-	var v interface{}
-	if err := json.Unmarshal([]byte(s), &v); err != nil {
-		return s
-	}
-	b, _ := json.MarshalIndent(v, "", "  ")
-	return string(b)
-}
-
-func TestRenderer(t *testing.T) {
-	tests := []struct {
-		name     string
-		markdown string
-		expected string
-	}{
-		{
-			name:     "empty input",
-			markdown: "",
-			expected: `[]`,
-		},
-		{
-			name:     "simple paragraph",
-			markdown: "Hello world",
-			expected: `[
-				{
-					"type": "section",
-					"text": { "type": "mrkdwn", "text": "Hello world" }
-				}
-			]`,
-		},
-		{
-			name:     "heading",
-			markdown: "# My Heading",
-			expected: `[
-				{
-					"type": "section",
-					"text": { "type": "mrkdwn", "text": "*My Heading*" }
-				}
-			]`,
-		},
-		{
-			name:     "multiple paragraphs",
-			markdown: "First paragraph\n\nSecond paragraph",
-			expected: `[
-				{
-					"type": "section",
-					"text": { "type": "mrkdwn", "text": "First paragraph\nSecond paragraph" }
-				}
-			]`,
-		},
-		{
-			name:     "todo list ",
-			markdown: "- [ ] item 1\n- [x] item 2",
-			expected: `[
-				{
-					"type": "rich_text",
-					"elements": [
-					{ 
-						"border": 0, 
-						"elements": [ 
-							{ "elements": [ { "text": "[ ] ", "type": "text" }, { "text": "item 1", "type": "text" } ], "type": "rich_text_section" }, 
-							{ "elements": [ { "text": "[x] ", "type": "text" }, { "text": "item 2", "type": "text" } ], "type": "rich_text_section" } 
-						],
-						"indent": 0, 
-						"style": "bullet", 
-						"type": "rich_text_list" 
-						}
-					]
-				}
-			]`,
-		},
-		{
-			name:     "thematic break between paragraphs",
-			markdown: "Before\n\n---\n\nAfter",
-			expected: `[
-				{ "type": "section", "text": { "type": "mrkdwn", "text": "Before" } },
-				{ "type": "divider" },
-				{ "type": "section", "text": { "type": "mrkdwn", "text": "After" } }
-			]`,
-		},
-		{
-			name:     "fenced code block with language",
-			markdown: "```go\nfmt.Println(\"hello\")\n```",
-			expected: `[
-				{
-					"type": "rich_text",
-					"elements": [
-						{
-							"type": "rich_text_preformatted",
-							"border": 0,
-							"language": "go",
-							"elements": [
-								{ "type": "text", "text": "fmt.Println(\"hello\")" }
-							]
-						}
-					]
-				}
-			]`,
-		},
-		{
-			name:     "indented code block",
-			markdown: "    code line 1\n    code line 2",
-			expected: `[
-				{
-					"type": "rich_text",
-					"elements": [
-						{
-							"type": "rich_text_preformatted",
-							"border": 0,
-							"elements": [
-								{ "type": "text", "text": "code line 1\ncode line 2" }
-							]
-						}
-					]
-				}
-			]`,
-		},
-		{
-			name:     "empty fenced code block",
-			markdown: "```\n```",
-			expected: `[
-				{
-					"type": "rich_text",
-					"elements": [
-						{
-							"type": "rich_text_preformatted",
-							"border": 0,
-							"elements": [
-								{ "type": "text", "text": " " }
-							]
-						}
-					]
-				}
-			]`,
-		},
-		{
-			name:     "simple bullet list",
-			markdown: "- item 1\n- item 2\n- item 3",
-			expected: `[
-				{
-					"type": "rich_text",
-					"elements": [
-						{
-							"type": "rich_text_list", "style": "bullet", "indent": 0, "border": 0,
-							"elements": [
-								{ "type": "rich_text_section", "elements": [{ "type": "text", "text": "item 1" }] },
-								{ "type": "rich_text_section", "elements": [{ "type": "text", "text": "item 2" }] },
-								{ "type": "rich_text_section", "elements": [{ "type": "text", "text": "item 3" }] }
-							]
-						}
-					]
-				}
-			]`,
-		},
-		{
-			name:     "simple ordered list",
-			markdown: "1. first\n2. second\n3. third",
-			expected: `[
-				{
-					"type": "rich_text",
-					"elements": [
-						{
-							"type": "rich_text_list", "style": "ordered", "indent": 0, "border": 0,
-							"elements": [
-								{ "type": "rich_text_section", "elements": [{ "type": "text", "text": "first" }] },
-								{ "type": "rich_text_section", "elements": [{ "type": "text", "text": "second" }] },
-								{ "type": "rich_text_section", "elements": [{ "type": "text", "text": "third" }] }
-							]
-						}
-					]
-				}
-			]`,
-		},
-		{
-			name:     "nested bullet list (2 levels)",
-			markdown: "- item 1\n- item 2\n  - sub a\n  - sub b\n- item 3",
-			expected: `[
-				{
-					"type": "rich_text",
-					"elements": [
-						{
-							"type": "rich_text_list", "style": "bullet", "indent": 0, "border": 0,
-							"elements": [
-								{ "type": "rich_text_section", "elements": [{ "type": "text", "text": "item 1" }] },
-								{ "type": "rich_text_section", "elements": [{ "type": "text", "text": "item 2" }] }
-							]
-						},
-						{
-							"type": "rich_text_list", "style": "bullet", "indent": 1, "border": 0,
-							"elements": [
-								{ "type": "rich_text_section", "elements": [{ "type": "text", "text": "sub a" }] },
-								{ "type": "rich_text_section", "elements": [{ "type": "text", "text": "sub b" }] }
-							]
-						},
-						{
-							"type": "rich_text_list", "style": "bullet", "indent": 0, "border": 0,
-							"elements": [
-								{ "type": "rich_text_section", "elements": [{ "type": "text", "text": "item 3" }] }
-							]
-						}
-					]
-				}
-			]`,
-		},
-		{
-			name:     "nested ordered list with offset",
-			markdown: "1. first\n   1. nested-a\n   2. nested-b\n2. second\n3. third",
-			expected: `[
-				{
-					"type": "rich_text",
-					"elements": [
-						{
-							"type": "rich_text_list", "style": "ordered", "indent": 0, "border": 0,
-							"elements": [
-								{ "type": "rich_text_section", "elements": [{ "type": "text", "text": "first" }] }
-							]
-						},
-						{
-							"type": "rich_text_list", "style": "ordered", "indent": 1, "border": 0,
-							"elements": [
-								{ "type": "rich_text_section", "elements": [{ "type": "text", "text": "nested-a" }] },
-								{ "type": "rich_text_section", "elements": [{ "type": "text", "text": "nested-b" }] }
-							]
-						},
-						{
-							"type": "rich_text_list", "style": "ordered", "indent": 0, "border": 0, "offset": 1,
-							"elements": [
-								{ "type": "rich_text_section", "elements": [{ "type": "text", "text": "second" }] },
-								{ "type": "rich_text_section", "elements": [{ "type": "text", "text": "third" }] }
-							]
-						}
-					]
-				}
-			]`,
-		},
-		{
-			name:     "mixed ordered/bullet nesting",
-			markdown: "1. ordered\n   - bullet child\n2. ordered again",
-			expected: `[
-				{
-					"type": "rich_text",
-					"elements": [
-						{
-							"type": "rich_text_list", "style": "ordered", "indent": 0, "border": 0,
-							"elements": [
-								{ "type": "rich_text_section", "elements": [{ "type": "text", "text": "ordered" }] }
-							]
-						},
-						{
-							"type": "rich_text_list", "style": "bullet", "indent": 1, "border": 0,
-							"elements": [
-								{ "type": "rich_text_section", "elements": [{ "type": "text", "text": "bullet child" }] }
-							]
-						},
-						{
-							"type": "rich_text_list", "style": "ordered", "indent": 0, "border": 0, "offset": 1,
-							"elements": [
-								{ "type": "rich_text_section", "elements": [{ "type": "text", "text": "ordered again" }] }
-							]
-						}
-					]
-				}
-			]`,
-		},
-		{
-			name:     "list items with bold/italic/link/code",
-			markdown: "- **bold item**\n- _italic item_\n- [link](http://example.com)\n- `code item`",
-			expected: `[
-				{
-					"type": "rich_text",
-					"elements": [
-						{
-							"type": "rich_text_list", "style": "bullet", "indent": 0, "border": 0,
-							"elements": [
-								{ "type": "rich_text_section", "elements": [{ "type": "text", "text": "bold item", "style": { "bold": true } }] },
-								{ "type": "rich_text_section", "elements": [{ "type": "text", "text": "italic item", "style": { "italic": true } }] },
-								{ "type": "rich_text_section", "elements": [{ "type": "link", "url": "http://example.com", "text": "link" }] },
-								{ "type": "rich_text_section", "elements": [{ "type": "text", "text": "code item", "style": { "code": true } }] }
-							]
-						}
-					]
-				}
-			]`,
-		},
-		{
-			name:     "table with header and body",
-			markdown: "| Name | Age |\n|------|-----|\n| Alice | 30 |",
-			expected: `[
-				{
-					"type": "table",
-					"rows": [
-						[
-							{ "type": "rich_text", "elements": [
-								{ "type": "rich_text_section", "elements": [{ "type": "text", "text": "Name", "style": { "bold": true } }] }
-							]},
-							{ "type": "rich_text", "elements": [
-								{ "type": "rich_text_section", "elements": [{ "type": "text", "text": "Age", "style": { "bold": true } }] }
-							]}
-						],
-						[
-							{ "type": "rich_text", "elements": [
-								{ "type": "rich_text_section", "elements": [{ "type": "text", "text": "Alice" }] }
-							]},
-							{ "type": "rich_text", "elements": [
-								{ "type": "rich_text_section", "elements": [{ "type": "text", "text": "30" }] }
-							]}
-						]
-					]
-				}
-			]`,
-		},
-		{
-			name:     "blockquote",
-			markdown: "> quoted text",
-			expected: `[
-				{
-					"type": "section",
-					"text": { "type": "mrkdwn", "text": "> quoted text" }
-				}
-			]`,
-		},
-		{
-			name:     "blockquote with nested list",
-			markdown: "> item 1\n> > item 2\n> > item 3",
-			expected: `[
-				{
-					"text": {
-					"text": "> item 1\n> > item 2\n> > item 3",
-					"type": "mrkdwn"
-					},
-					"type": "section"
-				}
-			]`,
-		},
-		{
-			name:     "inline formatting in paragraph",
-			markdown: "This is **bold** and _italic_ and ~strike~ and `code`",
-			expected: `[
-				{
-					"type": "section",
-					"text": { "type": "mrkdwn", "text": "This is *bold* and _italic_ and ~strike~ and ` + "`code`" + `" }
-				}
-			]`,
-		},
-		{
-			name:     "link in paragraph",
-			markdown: "Visit [Google](http://google.com)",
-			expected: `[
-				{
-					"type": "section",
-					"text": { "type": "mrkdwn", "text": "Visit <http://google.com|Google>" }
-				}
-			]`,
-		},
-		{
-			name:     "image is skipped",
-			markdown: "![alt](http://example.com/image.png)",
-			// For image skip the block and return empty array
-			expected: `[]`,
-		},
-		{
-			name:     "paragraph then list then paragraph",
-			markdown: "Before\n\n- item\n\nAfter",
-			expected: `[
-				{ "type": "section", "text": { "type": "mrkdwn", "text": "Before" } },
-				{
-					"type": "rich_text",
-					"elements": [
-						{
-							"type": "rich_text_list", "style": "bullet", "indent": 0, "border": 0,
-							"elements": [
-								{ "type": "rich_text_section", "elements": [{ "type": "text", "text": "item" }] }
-							]
-						}
-					]
-				},
-				{ "type": "section", "text": { "type": "mrkdwn", "text": "After" } }
-			]`,
-		},
-		{
-			name:     "ordered list with start > 1",
-			markdown: "5. fifth\n6. sixth",
-			expected: `[
-				{
-					"type": "rich_text",
-					"elements": [
-						{
-							"type": "rich_text_list", "style": "ordered", "indent": 0, "border": 0, "offset": 4,
-							"elements": [
-								{ "type": "rich_text_section", "elements": [{ "type": "text", "text": "fifth" }] },
-								{ "type": "rich_text_section", "elements": [{ "type": "text", "text": "sixth" }] }
-							]
-						}
-					]
-				}
-			]`,
-		},
-		{
-			name:     "deeply nested ordered list (3 levels) with offsets",
-			markdown: "1. Some things\n\t1. are best left\n2. to the fate\n\t1. of the world\n\t\t1. and then\n\t\t2. this is how\n3. it turns out to be",
-			expected: `[
-				{
-					"type": "rich_text",
-					"elements": [
-						{ "type": "rich_text_list", "style": "ordered", "indent": 0, "border": 0,
-						  "elements": [{ "type": "rich_text_section", "elements": [{ "type": "text", "text": "Some things" }] }] },
-
-						{ "type": "rich_text_list", "style": "ordered", "indent": 1, "border": 0,
-						  "elements": [{ "type": "rich_text_section", "elements": [{ "type": "text", "text": "are best left" }] }] },
-
-						{ "type": "rich_text_list", "style": "ordered", "indent": 0, "border": 0, "offset": 1,
-						  "elements": [{ "type": "rich_text_section", "elements": [{ "type": "text", "text": "to the fate" }] }] },
-
-						{ "type": "rich_text_list", "style": "ordered", "indent": 1, "border": 0,
-						  "elements": [{ "type": "rich_text_section", "elements": [{ "type": "text", "text": "of the world" }] }] },
-
-						{ "type": "rich_text_list", "style": "ordered", "indent": 2, "border": 0,
-						  "elements": [
-						    { "type": "rich_text_section", "elements": [{ "type": "text", "text": "and then" }] },
-						    { "type": "rich_text_section", "elements": [{ "type": "text", "text": "this is how" }] }
-						  ]
-						},
-
-						{ "type": "rich_text_list", "style": "ordered", "indent": 0, "border": 0, "offset": 2,
-						  "elements": [{ "type": "rich_text_section", "elements": [{ "type": "text", "text": "it turns out to be" }] }] }
-					]
-				}
-			]`,
-		},
-		{
-			name:     "link with bold label in list item",
-			markdown: "- [**docs**](http://example.com)",
-			expected: `[
-				{
-					"type": "rich_text",
-					"elements": [
-						{
-							"type": "rich_text_list", "style": "bullet", "indent": 0, "border": 0,
-							"elements": [
-								{ "type": "rich_text_section", "elements": [{ "type": "link", "url": "http://example.com", "text": "docs" }] }
-							]
-						}
-					]
-				}
-			]`,
-		},
-		{
-			name:     "table with empty cell",
-			markdown: "| A | B |\n|---|---|\n| 1 | |",
-			expected: `[
-				{
-					"type": "table",
-					"rows": [
-						[
-							{ "type": "rich_text", "elements": [
-								{ "type": "rich_text_section", "elements": [{ "type": "text", "text": "A", "style": { "bold": true } }] }
-							]},
-							{ "type": "rich_text", "elements": [
-								{ "type": "rich_text_section", "elements": [{ "type": "text", "text": "B", "style": { "bold": true } }] }
-							]}
-						],
-						[
-							{ "type": "rich_text", "elements": [
-								{ "type": "rich_text_section", "elements": [{ "type": "text", "text": "1" }] }
-							]},
-							{ "type": "rich_text", "elements": [
-								{ "type": "rich_text_section", "elements": [{ "type": "text", "text": " " }] }
-							]}
-						]
-					]
-				}
-			]`,
-		},
-		{
-			name:     "table with missing column in row",
-			markdown: "| A | B |\n|---|---|\n| 1 |",
-			expected: `[
-				{
-					"type": "table",
-					"rows": [
-						[
-							{ "type": "rich_text", "elements": [
-								{ "type": "rich_text_section", "elements": [{ "type": "text", "text": "A", "style": { "bold": true } }] }
-							]},
-							{ "type": "rich_text", "elements": [
-								{ "type": "rich_text_section", "elements": [{ "type": "text", "text": "B", "style": { "bold": true } }] }
-							]}
-						],
-						[
-							{ "type": "rich_text", "elements": [
-								{ "type": "rich_text_section", "elements": [{ "type": "text", "text": "1" }] }
-							]},
-							{ "type": "rich_text", "elements": [
-								{ "type": "rich_text_section", "elements": [{ "type": "text", "text": " " }] }
-							]}
-						]
-					]
-				}
-			]`,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			md := goldmark.New(
-				goldmark.WithExtensions(Extender),
-			)
-			var buf bytes.Buffer
-			if err := md.Convert([]byte(tt.markdown), &buf); err != nil {
-				t.Fatalf("convert error: %v", err)
-			}
-			got := buf.String()
-			if !jsonEqual(got, tt.expected) {
-				t.Errorf("JSON mismatch\n\nMarkdown:\n%s\n\nExpected:\n%s\n\nGot:\n%s",
-					tt.markdown, prettyJSON(tt.expected), prettyJSON(got))
-			}
-		})
-	}
-}

pkg/templating/markdownrenderer/blockkit/doc.go

@@ -1,9 +0,0 @@
-// Package blockkit provides a goldmark extension that renders markdown as
-// Slack Block Kit JSON (an array of blocks suitable for the Slack API's
-// `blocks` payload field).
-//
-// The current Slack notifier uses the sibling mrkdwn package instead, because
-// Block Kit's hard limits (one table per message, 50 blocks per message,
-// 12k-character total text) would silently truncate or reject notifications
-// with rich bodies. This package is kept in tree for future use.
-package blockkit

pkg/templating/markdownrenderer/concurrency_test.go

@@ -1,47 +0,0 @@
-package markdownrenderer
-
-import (
-	"sync"
-	"testing"
-)
-
-// TestConcurrentRender exercises every render entry point from many
-// goroutines. Run with `go test -race` to catch shared-state regressions
-// in the HTML, Block Kit or mrkdwn paths.
-func TestConcurrentRender(t *testing.T) {
-	const goroutines = 32
-	const iterations = 20
-
-	markdowns := []string{
-		"# Heading\n\nparagraph **bold** *em* `code`",
-		"- item 1\n- item 2\n  - nested\n- item 3",
-		"| a | b |\n| - | - |\n| 1 | 2 |\n| 3 | 4 |",
-		"> quote\n>> nested quote",
-		"```go\npackage main\n```",
-		"[link](https://example.com) and ![img](https://example.com/i.png)",
-	}
-
-	renderers := map[string]func(string) (string, error){
-		"html":     RenderHTML,
-		"blockkit": RenderSlackBlockKit,
-		"mrkdwn":   RenderSlackMrkdwn,
-	}
-
-	var wg sync.WaitGroup
-	for name, render := range renderers {
-		for g := 0; g < goroutines; g++ {
-			wg.Add(1)
-			go func(name string, render func(string) (string, error), g int) {
-				defer wg.Done()
-				for i := 0; i < iterations; i++ {
-					md := markdowns[(g+i)%len(markdowns)]
-					if _, err := render(md); err != nil {
-						t.Errorf("%s render failed: %v", name, err)
-						return
-					}
-				}
-			}(name, render, g)
-		}
-	}
-	wg.Wait()
-}

pkg/templating/markdownrenderer/doc.go

@@ -1,3 +0,0 @@
-// Package markdownrenderer renders markdown to the formats that alert
-// notifications are delivered in: HTML, Slack Block Kit JSON, and Slack mrkdwn.
-package markdownrenderer

pkg/templating/markdownrenderer/html_test.go

@@ -1,166 +0,0 @@
-package markdownrenderer
-
-import (
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-)
-
-var testMarkdown = `# 🔥 FIRING: High CPU Usage on api-gateway
-
-https://signoz.example.com/alerts/123
-https://runbooks.example.com/cpu-high
-
-## Alert Details
-
-**Status:** **FIRING** | *api-gateway* service is experiencing high CPU usage. ~~resolved~~ previously.
-
-Alert triggered because ` + "`cpu_usage_percent`" + ` exceeded threshold ` + "`90`" + `.
-
-[View Alert in SigNoz](https://signoz.example.com/alerts/123) | [View Logs](https://signoz.example.com/logs?service=api-gateway) | [View Traces](https://signoz.example.com/traces?service=api-gateway)
-
-![critical](https://signoz.example.com/badges/critical.svg "Critical Alert")
-
-## Alert Labels
-
-| Label    | Value       |
-| -------- | ----------- |
-| service  | api-gateway |
-| instance | pod-5a8b3c  |
-| severity | critical    |
-| region   | us-east-1   |
-
-## Remediation Steps
-
-1. Check current CPU usage on the pod
-2. Review recent deployments for regressions
-3. Scale horizontally if load-related
-    1. Increase replica count
-    2. Verify HPA configuration
-
-## Affected Services
-
-* api-gateway
-* auth-service
-* payment-service
-    * payment-processor
-    * payment-validator
-
-## Incident Checklist
-
-- [x] Alert acknowledged
-- [x] On-call notified
-- [ ] Root cause identified
-- [ ] Fix deployed
-
-## Alert Rule Description
-
-> This alert fires when CPU usage exceeds 90% for more than 5 minutes on any pod in the api-gateway service.
->
->> For capacity planning guidelines, see the infrastructure runbook section on horizontal pod autoscaling.
-
-## Triggered Query
-` + "```promql\navg(rate(container_cpu_usage_seconds_total{service=\"api-gateway\"}[5m])) by (pod) > 0.9\n```" + `
-
-## Inline Details
-
-This alert was generated by SigNoz using ` + "`alertmanager`" + ` rules engine.
-`
-
-func TestRenderHTML_Composite(t *testing.T) {
-	html, err := RenderHTML(testMarkdown)
-	require.NoError(t, err)
-
-	expected := "<h1>🔥 FIRING: High CPU Usage on api-gateway</h1>\n" +
-		"<p><a href=\"https://signoz.example.com/alerts/123\">https://signoz.example.com/alerts/123</a>\n<a href=\"https://runbooks.example.com/cpu-high\">https://runbooks.example.com/cpu-high</a></p>\n" +
-		"<h2>Alert Details</h2>\n" +
-		"<p><strong>Status:</strong> <strong>FIRING</strong> | <em>api-gateway</em> service is experiencing high CPU usage. <del>resolved</del> previously.</p>\n" +
-		"<p>Alert triggered because <code>cpu_usage_percent</code> exceeded threshold <code>90</code>.</p>\n" +
-		"<p><a href=\"https://signoz.example.com/alerts/123\">View Alert in SigNoz</a> | <a href=\"https://signoz.example.com/logs?service=api-gateway\">View Logs</a> | <a href=\"https://signoz.example.com/traces?service=api-gateway\">View Traces</a></p>\n" +
-		"<p><img src=\"https://signoz.example.com/badges/critical.svg\" alt=\"critical\" title=\"Critical Alert\"></p>\n" +
-		"<h2>Alert Labels</h2>\n" +
-		"<table>\n<thead>\n<tr>\n<th>Label</th>\n<th>Value</th>\n</tr>\n</thead>\n" +
-		"<tbody>\n<tr>\n<td>service</td>\n<td>api-gateway</td>\n</tr>\n" +
-		"<tr>\n<td>instance</td>\n<td>pod-5a8b3c</td>\n</tr>\n" +
-		"<tr>\n<td>severity</td>\n<td>critical</td>\n</tr>\n" +
-		"<tr>\n<td>region</td>\n<td>us-east-1</td>\n</tr>\n</tbody>\n</table>\n" +
-		"<h2>Remediation Steps</h2>\n" +
-		"<ol>\n<li>Check current CPU usage on the pod</li>\n<li>Review recent deployments for regressions</li>\n<li>Scale horizontally if load-related\n" +
-		"<ol>\n<li>Increase replica count</li>\n<li>Verify HPA configuration</li>\n</ol>\n</li>\n</ol>\n" +
-		"<h2>Affected Services</h2>\n" +
-		"<ul>\n<li>api-gateway</li>\n<li>auth-service</li>\n<li>payment-service\n" +
-		"<ul>\n<li>payment-processor</li>\n<li>payment-validator</li>\n</ul>\n</li>\n</ul>\n" +
-		"<h2>Incident Checklist</h2>\n" +
-		"<ul>\n<li><input checked=\"\" disabled=\"\" type=\"checkbox\"> Alert acknowledged</li>\n" +
-		"<li><input checked=\"\" disabled=\"\" type=\"checkbox\"> On-call notified</li>\n" +
-		"<li><input disabled=\"\" type=\"checkbox\"> Root cause identified</li>\n" +
-		"<li><input disabled=\"\" type=\"checkbox\"> Fix deployed</li>\n</ul>\n" +
-		"<h2>Alert Rule Description</h2>\n" +
-		"<blockquote>\n<p>This alert fires when CPU usage exceeds 90% for more than 5 minutes on any pod in the api-gateway service.</p>\n" +
-		"<blockquote>\n<p>For capacity planning guidelines, see the infrastructure runbook section on horizontal pod autoscaling.</p>\n</blockquote>\n</blockquote>\n" +
-		"<h2>Triggered Query</h2>\n" +
-		"<pre><code class=\"language-promql\">avg(rate(container_cpu_usage_seconds_total{service=&quot;api-gateway&quot;}[5m])) by (pod) &gt; 0.9\n</code></pre>\n" +
-		"<h2>Inline Details</h2>\n" +
-		"<p>This alert was generated by SigNoz using <code>alertmanager</code> rules engine.</p>\n"
-
-	assert.Equal(t, expected, html)
-}
-
-func TestRenderHTML_InlineFormatting(t *testing.T) {
-	input := `# 🔥 FIRING: High CPU on api-gateway
-## Alert Status
-
-**FIRING** alert for *api-gateway* service — ~~resolved~~ previously.
-
-Metric ` + "`cpu_usage_percent`" + ` exceeded threshold. [View in SigNoz](https://signoz.example.com/alerts/123)
-
-![critical](https://signoz.example.com/badges/critical.svg "Critical Alert")`
-
-	html, err := RenderHTML(input)
-	require.NoError(t, err)
-
-	expected := "<h1>🔥 FIRING: High CPU on api-gateway</h1>\n<h2>Alert Status</h2>\n" +
-		"<p><strong>FIRING</strong> alert for <em>api-gateway</em> service — <del>resolved</del> previously.</p>\n" +
-		"<p>Metric <code>cpu_usage_percent</code> exceeded threshold. <a href=\"https://signoz.example.com/alerts/123\">View in SigNoz</a></p>\n" +
-		"<p><img src=\"https://signoz.example.com/badges/critical.svg\" alt=\"critical\" title=\"Critical Alert\"></p>\n"
-
-	assert.Equal(t, expected, html)
-}
-
-func TestRenderHTML_BlockElements(t *testing.T) {
-	input := `1. Check CPU usage on the pod
-2. Review recent deployments
-3. Scale horizontally if needed
-
-* api-gateway
-* auth-service
-* payment-service
-
-- [x] Alert acknowledged
-- [ ] Root cause identified
-
-> This alert fires when CPU usage exceeds 90% for more than 5 minutes.
-
-| Label    | Value       |
-| -------- | ----------- |
-| service  | api-gateway |
-| severity | <no value>    |
-
-` + "```promql\navg(rate(container_cpu_usage_seconds_total{service=\"api-gateway\"}[5m])) by (pod) > 0.9\n```"
-
-	html, err := RenderHTML(input)
-	require.NoError(t, err)
-
-	expected := "<ol>\n<li>Check CPU usage on the pod</li>\n<li>Review recent deployments</li>\n<li>Scale horizontally if needed</li>\n</ol>\n" +
-		"<ul>\n<li>api-gateway</li>\n<li>auth-service</li>\n<li>payment-service</li>\n</ul>\n" +
-		"<ul>\n<li><input checked=\"\" disabled=\"\" type=\"checkbox\"> Alert acknowledged</li>\n" +
-		"<li><input disabled=\"\" type=\"checkbox\"> Root cause identified</li>\n</ul>\n" +
-		"<blockquote>\n<p>This alert fires when CPU usage exceeds 90% for more than 5 minutes.</p>\n</blockquote>\n" +
-		"<table>\n<thead>\n<tr>\n<th>Label</th>\n<th>Value</th>\n</tr>\n</thead>\n" +
-		"<tbody>\n<tr>\n<td>service</td>\n<td>api-gateway</td>\n</tr>\n" +
-		"<tr>\n<td>severity</td>\n<td>&lt;no value&gt;</td>\n</tr>\n</tbody>\n</table>\n" +
-		"<pre><code class=\"language-promql\">avg(rate(container_cpu_usage_seconds_total{service=&quot;api-gateway&quot;}[5m])) by (pod) &gt; 0.9\n</code></pre>\n"
-
-	assert.Equal(t, expected, html)
-}

pkg/templating/markdownrenderer/markdownrenderer.go

@@ -1,62 +0,0 @@
-package markdownrenderer
-
-import (
-	"bytes"
-	"sync"
-
-	"github.com/SigNoz/signoz/pkg/errors"
-	"github.com/SigNoz/signoz/pkg/templating/markdownrenderer/blockkit"
-	"github.com/SigNoz/signoz/pkg/templating/markdownrenderer/mrkdwn"
-	"github.com/yuin/goldmark"
-	"github.com/yuin/goldmark/extension"
-)
-
-// htmlRenderer is built once and shared. Goldmark's built-in HTML path and
-// the novalue extension carry no mutable state, so a single goldmark.Markdown
-// is safe to Convert concurrently.
-var htmlRenderer = goldmark.New(goldmark.WithExtensions(extension.GFM, escapeNoValue))
-
-// The Slack renderers hold per-document state on the node renderer (list
-// context, table context, style stack, blockquote/list prefixes). Two
-// goroutines calling Convert on the same goldmark.Markdown would corrupt
-// that state. A sync.Pool gives each concurrent caller its own instance
-// while still amortising the cost of building the pipeline.
-var (
-	blockkitPool = sync.Pool{
-		New: func() any {
-			return goldmark.New(goldmark.WithExtensions(blockkit.Extender))
-		},
-	}
-	mrkdwnPool = sync.Pool{
-		New: func() any {
-			return goldmark.New(goldmark.WithExtensions(mrkdwn.Extender))
-		},
-	}
-)
-
-// RenderHTML converts markdown to HTML.
-func RenderHTML(markdown string) (string, error) {
-	return render(htmlRenderer, markdown, "HTML")
-}
-
-// RenderSlackBlockKit converts markdown to a Slack Block Kit JSON array.
-func RenderSlackBlockKit(markdown string) (string, error) {
-	md := blockkitPool.Get().(goldmark.Markdown)
-	defer blockkitPool.Put(md)
-	return render(md, markdown, "Slack Block Kit")
-}
-
-// RenderSlackMrkdwn converts markdown to Slack's mrkdwn format.
-func RenderSlackMrkdwn(markdown string) (string, error) {
-	md := mrkdwnPool.Get().(goldmark.Markdown)
-	defer mrkdwnPool.Put(md)
-	return render(md, markdown, "Slack mrkdwn")
-}
-
-func render(md goldmark.Markdown, markdown string, format string) (string, error) {
-	var buf bytes.Buffer
-	if err := md.Convert([]byte(markdown), &buf); err != nil {
-		return "", errors.WrapInternalf(err, errors.CodeInternal, "failed to convert markdown to %s", format)
-	}
-	return buf.String(), nil
-}

pkg/templating/markdownrenderer/mrkdwn/doc.go

@@ -1,4 +0,0 @@
-// Package mrkdwn provides a goldmark extension that renders markdown as
-// Slack's "mrkdwn" text format (the legacy text field used in attachments
-// and message payloads).
-package mrkdwn

pkg/templating/markdownrenderer/mrkdwn/mrkdwn.go

@@ -1,404 +0,0 @@
-package mrkdwn
-
-import (
-	"bytes"
-	"fmt"
-	"strings"
-	"unicode/utf8"
-
-	"github.com/yuin/goldmark"
-	"github.com/yuin/goldmark/ast"
-	"github.com/yuin/goldmark/extension"
-	extensionast "github.com/yuin/goldmark/extension/ast"
-	"github.com/yuin/goldmark/renderer"
-	"github.com/yuin/goldmark/util"
-)
-
-// Extender is a goldmark.Extender that registers the Slack mrkdwn node
-// renderer together with the GFM extensions it relies on (tables,
-// strikethrough).
-var Extender goldmark.Extender = &extender{}
-
-type extender struct{}
-
-func (e *extender) Extend(m goldmark.Markdown) {
-	extension.Table.Extend(m)
-	extension.Strikethrough.Extend(m)
-	m.Renderer().AddOptions(
-		renderer.WithNodeRenderers(util.Prioritized(newRenderer(), 1)),
-	)
-}
-
-// nodeRenderer renders nodes as Slack mrkdwn.
-type nodeRenderer struct {
-	prefixes []string
-}
-
-func newRenderer() renderer.NodeRenderer {
-	return &nodeRenderer{}
-}
-
-// RegisterFuncs implements NodeRenderer.RegisterFuncs.
-func (r *nodeRenderer) RegisterFuncs(reg renderer.NodeRendererFuncRegisterer) {
-	// Blocks
-	reg.Register(ast.KindDocument, r.renderDocument)
-	reg.Register(ast.KindHeading, r.renderHeading)
-	reg.Register(ast.KindBlockquote, r.renderBlockquote)
-	reg.Register(ast.KindCodeBlock, r.renderCodeBlock)
-	reg.Register(ast.KindFencedCodeBlock, r.renderCodeBlock)
-	reg.Register(ast.KindList, r.renderList)
-	reg.Register(ast.KindListItem, r.renderListItem)
-	reg.Register(ast.KindParagraph, r.renderParagraph)
-	reg.Register(ast.KindTextBlock, r.renderTextBlock)
-	reg.Register(ast.KindRawHTML, r.renderRawHTML)
-	reg.Register(ast.KindThematicBreak, r.renderThematicBreak)
-
-	// Inlines
-	reg.Register(ast.KindAutoLink, r.renderAutoLink)
-	reg.Register(ast.KindCodeSpan, r.renderCodeSpan)
-	reg.Register(ast.KindEmphasis, r.renderEmphasis)
-	reg.Register(ast.KindImage, r.renderImage)
-	reg.Register(ast.KindLink, r.renderLink)
-	reg.Register(ast.KindText, r.renderText)
-
-	// Extensions
-	reg.Register(extensionast.KindStrikethrough, r.renderStrikethrough)
-	reg.Register(extensionast.KindTable, r.renderTable)
-}
-
-func (r *nodeRenderer) writePrefix(w util.BufWriter) {
-	for _, p := range r.prefixes {
-		_, _ = w.WriteString(p)
-	}
-}
-
-// writeLineSeparator writes a newline followed by the current prefix.
-// Used for tight separations (e.g., between list items or text blocks).
-func (r *nodeRenderer) writeLineSeparator(w util.BufWriter) {
-	_ = w.WriteByte('\n')
-	r.writePrefix(w)
-}
-
-// writeBlockSeparator writes a blank line separator between block-level elements,
-// respecting any active prefixes for proper nesting (e.g., inside blockquotes).
-func (r *nodeRenderer) writeBlockSeparator(w util.BufWriter) {
-	r.writeLineSeparator(w)
-	r.writeLineSeparator(w)
-}
-
-// separateFromPrevious writes a block separator if the node has a previous sibling.
-func (r *nodeRenderer) separateFromPrevious(w util.BufWriter, n ast.Node) {
-	if n.PreviousSibling() != nil {
-		r.writeBlockSeparator(w)
-	}
-}
-
-func (r *nodeRenderer) renderDocument(w util.BufWriter, source []byte, node ast.Node, entering bool) (ast.WalkStatus, error) {
-	if entering {
-		// The renderer is pooled, so wipe any prefix stack left over from a
-		// prior document (e.g. one that errored mid-walk and left push/pop
-		// unbalanced) before starting a fresh convert.
-		r.prefixes = r.prefixes[:0]
-	} else {
-		_, _ = w.WriteString("\n\n")
-	}
-	return ast.WalkContinue, nil
-}
-
-func (r *nodeRenderer) renderHeading(w util.BufWriter, source []byte, node ast.Node, entering bool) (ast.WalkStatus, error) {
-	if entering {
-		r.separateFromPrevious(w, node)
-	}
-	_, _ = w.WriteString("*")
-	return ast.WalkContinue, nil
-}
-
-func (r *nodeRenderer) renderBlockquote(w util.BufWriter, source []byte, n ast.Node, entering bool) (ast.WalkStatus, error) {
-	if entering {
-		r.separateFromPrevious(w, n)
-		r.prefixes = append(r.prefixes, "> ")
-		_, _ = w.WriteString("> ")
-	} else {
-		r.prefixes = r.prefixes[:len(r.prefixes)-1]
-	}
-	return ast.WalkContinue, nil
-}
-
-func (r *nodeRenderer) renderCodeBlock(w util.BufWriter, source []byte, n ast.Node, entering bool) (ast.WalkStatus, error) {
-	if entering {
-		r.separateFromPrevious(w, n)
-		// start code block and write code line by line
-		_, _ = w.WriteString("```\n")
-		l := n.Lines().Len()
-		for i := 0; i < l; i++ {
-			line := n.Lines().At(i)
-			v := line.Value(source)
-			_, _ = w.Write(v)
-		}
-	} else {
-		_, _ = w.WriteString("```")
-	}
-	return ast.WalkContinue, nil
-}
-
-func (r *nodeRenderer) renderList(w util.BufWriter, source []byte, node ast.Node, entering bool) (ast.WalkStatus, error) {
-	if entering {
-		if node.PreviousSibling() != nil {
-			r.writeLineSeparator(w)
-			// another line break if not a nested list item and starting another block
-			if node.Parent() == nil || node.Parent().Kind() != ast.KindListItem {
-				r.writeLineSeparator(w)
-			}
-		}
-	}
-	return ast.WalkContinue, nil
-}
-
-func (r *nodeRenderer) renderListItem(w util.BufWriter, source []byte, n ast.Node, entering bool) (ast.WalkStatus, error) {
-	if entering {
-		if n.PreviousSibling() != nil {
-			r.writeLineSeparator(w)
-		}
-		parent := n.Parent().(*ast.List)
-		// compute and write the prefix based on list type and index
-		var prefixStr string
-		if parent.IsOrdered() {
-			index := parent.Start
-			for c := parent.FirstChild(); c != nil && c != n; c = c.NextSibling() {
-				index++
-			}
-			prefixStr = fmt.Sprintf("%d. ", index)
-		} else {
-			prefixStr = "• "
-		}
-		_, _ = w.WriteString(prefixStr)
-		r.prefixes = append(r.prefixes, "\t") // add tab for nested list items
-	} else {
-		r.prefixes = r.prefixes[:len(r.prefixes)-1]
-	}
-	return ast.WalkContinue, nil
-}
-
-func (r *nodeRenderer) renderParagraph(w util.BufWriter, source []byte, n ast.Node, entering bool) (ast.WalkStatus, error) {
-	if entering {
-		r.separateFromPrevious(w, n)
-	}
-	return ast.WalkContinue, nil
-}
-
-func (r *nodeRenderer) renderTextBlock(w util.BufWriter, source []byte, n ast.Node, entering bool) (ast.WalkStatus, error) {
-	if entering && n.PreviousSibling() != nil {
-		r.writeLineSeparator(w)
-	}
-	return ast.WalkContinue, nil
-}
-
-func (r *nodeRenderer) renderRawHTML(w util.BufWriter, source []byte, n ast.Node, entering bool) (ast.WalkStatus, error) {
-	if entering {
-		n := n.(*ast.RawHTML)
-		l := n.Segments.Len()
-		for i := 0; i < l; i++ {
-			segment := n.Segments.At(i)
-			_, _ = w.Write(segment.Value(source))
-		}
-	}
-	return ast.WalkContinue, nil
-}
-
-func (r *nodeRenderer) renderThematicBreak(w util.BufWriter, source []byte, n ast.Node, entering bool) (ast.WalkStatus, error) {
-	if entering {
-		r.separateFromPrevious(w, n)
-		_, _ = w.WriteString("---")
-	}
-	return ast.WalkContinue, nil
-}
-
-func (r *nodeRenderer) renderAutoLink(w util.BufWriter, source []byte, node ast.Node, entering bool) (ast.WalkStatus, error) {
-	if !entering {
-		return ast.WalkContinue, nil
-	}
-	n := node.(*ast.AutoLink)
-	url := string(n.URL(source))
-	label := string(n.Label(source))
-
-	if n.AutoLinkType == ast.AutoLinkEmail && !strings.HasPrefix(strings.ToLower(url), "mailto:") {
-		url = "mailto:" + url
-	}
-
-	if url == label {
-		_, _ = fmt.Fprintf(w, "<%s>", url)
-	} else {
-		_, _ = fmt.Fprintf(w, "<%s|%s>", url, label)
-	}
-	return ast.WalkContinue, nil
-}
-
-func (r *nodeRenderer) renderCodeSpan(w util.BufWriter, source []byte, n ast.Node, entering bool) (ast.WalkStatus, error) {
-	if entering {
-		_ = w.WriteByte('`')
-		for c := n.FirstChild(); c != nil; c = c.NextSibling() {
-			segment := c.(*ast.Text).Segment
-			value := segment.Value(source)
-			if bytes.HasSuffix(value, []byte("\n")) { // replace newline with space
-				_, _ = w.Write(value[:len(value)-1])
-				_ = w.WriteByte(' ')
-			} else {
-				_, _ = w.Write(value)
-			}
-		}
-		return ast.WalkSkipChildren, nil
-	}
-	_ = w.WriteByte('`')
-	return ast.WalkContinue, nil
-}
-
-func (r *nodeRenderer) renderEmphasis(w util.BufWriter, source []byte, node ast.Node, entering bool) (ast.WalkStatus, error) {
-	n := node.(*ast.Emphasis)
-	mark := "_"
-	if n.Level == 2 {
-		mark = "*"
-	}
-	_, _ = w.WriteString(mark)
-	return ast.WalkContinue, nil
-}
-
-func (r *nodeRenderer) renderLink(w util.BufWriter, source []byte, node ast.Node, entering bool) (ast.WalkStatus, error) {
-	n := node.(*ast.Link)
-	if entering {
-		_, _ = w.WriteString("<")
-		_, _ = w.Write(util.URLEscape(n.Destination, true))
-		_, _ = w.WriteString("|")
-	} else {
-		_, _ = w.WriteString(">")
-	}
-	return ast.WalkContinue, nil
-}
-
-func (r *nodeRenderer) renderImage(w util.BufWriter, source []byte, node ast.Node, entering bool) (ast.WalkStatus, error) {
-	if !entering {
-		return ast.WalkContinue, nil
-	}
-	n := node.(*ast.Image)
-	_, _ = w.WriteString("<")
-	_, _ = w.Write(util.URLEscape(n.Destination, true))
-	_, _ = w.WriteString("|")
-
-	// Write the alt text directly
-	var altBuf bytes.Buffer
-	for c := n.FirstChild(); c != nil; c = c.NextSibling() {
-		if textNode, ok := c.(*ast.Text); ok {
-			altBuf.Write(textNode.Segment.Value(source))
-		}
-	}
-	_, _ = w.Write(altBuf.Bytes())
-
-	_, _ = w.WriteString(">")
-	return ast.WalkSkipChildren, nil
-}
-
-func (r *nodeRenderer) renderText(w util.BufWriter, source []byte, node ast.Node, entering bool) (ast.WalkStatus, error) {
-	if !entering {
-		return ast.WalkContinue, nil
-	}
-	n := node.(*ast.Text)
-	segment := n.Segment
-	value := segment.Value(source)
-	_, _ = w.Write(value)
-	if n.HardLineBreak() || n.SoftLineBreak() {
-		r.writeLineSeparator(w)
-	}
-	return ast.WalkContinue, nil
-}
-
-func (r *nodeRenderer) renderStrikethrough(w util.BufWriter, source []byte, node ast.Node, entering bool) (ast.WalkStatus, error) {
-	_, _ = w.WriteString("~")
-	return ast.WalkContinue, nil
-}
-
-func (r *nodeRenderer) renderTable(w util.BufWriter, source []byte, node ast.Node, entering bool) (ast.WalkStatus, error) {
-	if !entering {
-		return ast.WalkContinue, nil
-	}
-
-	r.separateFromPrevious(w, node)
-
-	// Collect cells and max widths
-	var rows [][]string
-	var colWidths []int
-
-	for c := node.FirstChild(); c != nil; c = c.NextSibling() {
-		if c.Kind() == extensionast.KindTableHeader || c.Kind() == extensionast.KindTableRow {
-			var row []string
-			colIdx := 0
-			for cc := c.FirstChild(); cc != nil; cc = cc.NextSibling() {
-				if cc.Kind() == extensionast.KindTableCell {
-					cellText := extractPlainText(cc, source)
-					row = append(row, cellText)
-					runeLen := utf8.RuneCountInString(cellText)
-					if colIdx >= len(colWidths) {
-						colWidths = append(colWidths, runeLen)
-					} else if runeLen > colWidths[colIdx] {
-						colWidths[colIdx] = runeLen
-					}
-					colIdx++
-				}
-			}
-			rows = append(rows, row)
-		}
-	}
-
-	// writing table in code block
-	_, _ = w.WriteString("```\n")
-	for i, row := range rows {
-		for colIdx, cellText := range row {
-			width := 0
-			if colIdx < len(colWidths) {
-				width = colWidths[colIdx]
-			}
-			runeLen := utf8.RuneCountInString(cellText)
-			padding := max(0, width-runeLen)
-
-			_, _ = w.WriteString(cellText)
-			_, _ = w.WriteString(strings.Repeat(" ", padding))
-			if colIdx < len(row)-1 {
-				_, _ = w.WriteString(" | ")
-			}
-		}
-		_ = w.WriteByte('\n')
-
-		// Print separator after header
-		if i == 0 {
-			for colIdx := range row {
-				width := 0
-				if colIdx < len(colWidths) {
-					width = colWidths[colIdx]
-				}
-				_, _ = w.WriteString(strings.Repeat("-", width))
-				if colIdx < len(row)-1 {
-					_, _ = w.WriteString("-|-")
-				}
-			}
-			_ = w.WriteByte('\n')
-		}
-	}
-	_, _ = w.WriteString("```")
-
-	return ast.WalkSkipChildren, nil
-}
-
-// extractPlainText extracts all the text content from the given node.
-func extractPlainText(n ast.Node, source []byte) string {
-	var buf bytes.Buffer
-	_ = ast.Walk(n, func(node ast.Node, entering bool) (ast.WalkStatus, error) {
-		if !entering {
-			return ast.WalkContinue, nil
-		}
-		if textNode, ok := node.(*ast.Text); ok {
-			buf.Write(textNode.Segment.Value(source))
-		} else if strNode, ok := node.(*ast.String); ok {
-			buf.Write(strNode.Value)
-		}
-		return ast.WalkContinue, nil
-	})
-	return strings.TrimSpace(buf.String())
-}

pkg/templating/markdownrenderer/mrkdwn/mrkdwn_test.go

@@ -1,115 +0,0 @@
-package mrkdwn
-
-import (
-	"bytes"
-	"testing"
-
-	"github.com/yuin/goldmark"
-)
-
-func TestRenderer(t *testing.T) {
-	tests := []struct {
-		name     string
-		markdown string
-		expected string
-	}{
-		{
-			name:     "Heading with Thematic Break",
-			markdown: "# Title 1\n# Hello World\n---\nthis is sometext",
-			expected: "*Title 1*\n\n*Hello World*\n\n---\n\nthis is sometext\n\n",
-		},
-		{
-			name:     "Blockquote",
-			markdown: "> This is a quote\n> It continues",
-			expected: "> This is a quote\n> It continues\n\n",
-		},
-		{
-			name:     "Fenced Code Block",
-			markdown: "```go\npackage main\nfunc main() {}\n```",
-			expected: "```\npackage main\nfunc main() {}\n```\n\n",
-		},
-		{
-			name:     "Unordered List",
-			markdown: "- item 1\n- item 2\n- item 3",
-			expected: "• item 1\n• item 2\n• item 3\n\n",
-		},
-		{
-			name:     "nested unordered list",
-			markdown: "- item 1\n- item 2\n\t- item 2.1\n\t\t- item 2.1.1\n\t\t- item 2.1.2\n\t- item 2.2\n- item 3",
-			expected: "• item 1\n• item 2\n\t• item 2.1\n\t\t• item 2.1.1\n\t\t• item 2.1.2\n\t• item 2.2\n• item 3\n\n",
-		},
-		{
-			name:     "Ordered List",
-			markdown: "1. item 1\n2. item 2\n3. item 3",
-			expected: "1. item 1\n2. item 2\n3. item 3\n\n",
-		},
-		{
-			name:     "nested ordered list",
-			markdown: "1. item 1\n2. item 2\n\t1. item 2.1\n\t\t1. item 2.1.1\n\t\t2. item 2.1.2\n\t2. item 2.2\n\t3. item 2.3\n3. item 3\n4. item 4",
-			expected: "1. item 1\n2. item 2\n\t1. item 2.1\n\t\t1. item 2.1.1\n\t\t2. item 2.1.2\n\t2. item 2.2\n\t3. item 2.3\n3. item 3\n4. item 4\n\n",
-		},
-		{
-			name:     "Links and AutoLinks",
-			markdown: "This is a [link](https://example.com) and an autolink <https://test.com>",
-			expected: "This is a <https://example.com|link> and an autolink <https://test.com>\n\n",
-		},
-		{
-			name:     "Images",
-			markdown: "An image ![alt text](https://example.com/image.png)",
-			expected: "An image <https://example.com/image.png|alt text>\n\n",
-		},
-		{
-			name:     "Emphasis",
-			markdown: "This is **bold** and *italic* and __bold__ and _italic_",
-			expected: "This is *bold* and _italic_ and *bold* and _italic_\n\n",
-		},
-		{
-			name:     "Strikethrough",
-			markdown: "This is ~~strike~~",
-			expected: "This is ~strike~\n\n",
-		},
-		{
-			name:     "Code Span",
-			markdown: "This is `inline code` embedded.",
-			expected: "This is `inline code` embedded.\n\n",
-		},
-		{
-			name:     "Table",
-			markdown: "Col 1 | Col 2 | Col 3\n--- | --- | ---\nVal 1 | Long Value 2 | 3\nShort | V | 1000",
-			expected: "```\nCol 1 | Col 2        | Col 3\n------|--------------|------\nVal 1 | Long Value 2 | 3    \nShort | V            | 1000 \n```\n\n",
-		},
-		{
-			name:     "Mixed Nested Lists",
-			markdown: "1. first\n\t- nested bullet\n\t- another bullet\n2. second",
-			expected: "1. first\n\t• nested bullet\n\t• another bullet\n2. second\n\n",
-		},
-		{
-			name:     "Email AutoLink",
-			markdown: "<user@example.com>",
-			expected: "<mailto:user@example.com|user@example.com>\n\n",
-		},
-		{
-			name:     "No value string parsed as is",
-			markdown: "Service: <no value>",
-			expected: "Service: <no value>\n\n",
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			md := goldmark.New(goldmark.WithExtensions(Extender))
-
-			var buf bytes.Buffer
-			if err := md.Convert([]byte(tt.markdown), &buf); err != nil {
-				t.Fatalf("failed to convert: %v", err)
-			}
-
-			// Do exact string matching
-			actual := buf.String()
-			if actual != tt.expected {
-				t.Errorf("\nExpected:\n%q\nGot:\n%q\nRaw Expected:\n%s\nRaw Got:\n%s",
-					tt.expected, actual, tt.expected, actual)
-			}
-		})
-	}
-}

pkg/templating/markdownrenderer/novalue.go

@@ -1,61 +0,0 @@
-package markdownrenderer
-
-import (
-	"github.com/yuin/goldmark"
-	gast "github.com/yuin/goldmark/ast"
-	"github.com/yuin/goldmark/renderer"
-	"github.com/yuin/goldmark/renderer/html"
-	"github.com/yuin/goldmark/util"
-)
-
-// Go text/template writes the literal string "<no value>" when a referenced
-// key is missing. The default goldmark HTML path treats it as raw HTML and
-// drops it, hiding the missing value. This renderer escapes it so operators
-// can see which variable was unset in the rendered notification.
-type noValueHTMLRenderer struct {
-	html.Config
-}
-
-func newNoValueHTMLRenderer(opts ...html.Option) renderer.NodeRenderer {
-	r := &noValueHTMLRenderer{Config: html.NewConfig()}
-	for _, opt := range opts {
-		opt.SetHTMLOption(&r.Config)
-	}
-	return r
-}
-
-func (r *noValueHTMLRenderer) RegisterFuncs(reg renderer.NodeRendererFuncRegisterer) {
-	reg.Register(gast.KindRawHTML, r.renderRawHTML)
-}
-
-func (r *noValueHTMLRenderer) renderRawHTML(w util.BufWriter, source []byte, node gast.Node, entering bool) (gast.WalkStatus, error) {
-	if !entering {
-		return gast.WalkSkipChildren, nil
-	}
-	n := node.(*gast.RawHTML)
-	if r.Unsafe {
-		for i := 0; i < n.Segments.Len(); i++ {
-			segment := n.Segments.At(i)
-			_, _ = w.Write(segment.Value(source))
-		}
-		return gast.WalkSkipChildren, nil
-	}
-	if string(n.Segments.Value(source)) == "<no value>" {
-		_, _ = w.WriteString("&lt;no value&gt;")
-		return gast.WalkSkipChildren, nil
-	}
-	_, _ = w.WriteString("<!-- raw HTML omitted -->")
-	return gast.WalkSkipChildren, nil
-}
-
-type escapeNoValueExtension struct{}
-
-// escapeNoValue renders the literal `<no value>` produced by Go's text/template
-// as visible escaped text instead of dropping it as raw HTML.
-var escapeNoValue = &escapeNoValueExtension{}
-
-func (e *escapeNoValueExtension) Extend(m goldmark.Markdown) {
-	m.Renderer().AddOptions(renderer.WithNodeRenderers(
-		util.Prioritized(newNoValueHTMLRenderer(), 500),
-	))
-}

pkg/templating/markdownrenderer/novalue_test.go

@@ -1,66 +0,0 @@
-package markdownrenderer
-
-import (
-	"bytes"
-	"testing"
-
-	"github.com/yuin/goldmark"
-	"github.com/yuin/goldmark/extension"
-)
-
-func TestEscapeNoValue(t *testing.T) {
-	tests := []struct {
-		name     string
-		markdown string
-		expected string
-	}{
-		{
-			name:     "plain text",
-			markdown: "Service: <no value>",
-			expected: "<p>Service: &lt;no value&gt;</p>\n",
-		},
-		{
-			name:     "inside strong",
-			markdown: "Service: **<no value>**",
-			expected: "<p>Service: <strong>&lt;no value&gt;</strong></p>\n",
-		},
-		{
-			name:     "inside emphasis",
-			markdown: "Service: *<no value>*",
-			expected: "<p>Service: <em>&lt;no value&gt;</em></p>\n",
-		},
-		{
-			name:     "inside strikethrough",
-			markdown: "Service: ~~<no value>~~",
-			expected: "<p>Service: <del>&lt;no value&gt;</del></p>\n",
-		},
-		{
-			name:     "real html still omitted",
-			markdown: "hello <div>world</div>",
-			expected: "<p>hello <!-- raw HTML omitted -->world<!-- raw HTML omitted --></p>\n",
-		},
-		{
-			name:     "inside heading",
-			markdown: "# Title <no value>",
-			expected: "<h1>Title &lt;no value&gt;</h1>\n",
-		},
-		{
-			name:     "inside list item",
-			markdown: "- item <no value>",
-			expected: "<ul>\n<li>item &lt;no value&gt;</li>\n</ul>\n",
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			gm := goldmark.New(goldmark.WithExtensions(escapeNoValue, extension.Strikethrough))
-			var buf bytes.Buffer
-			if err := gm.Convert([]byte(tt.markdown), &buf); err != nil {
-				t.Fatal(err)
-			}
-			if buf.String() != tt.expected {
-				t.Errorf("expected:\n%s\ngot:\n%s", tt.expected, buf.String())
-			}
-		})
-	}
-}

pkg/templating/markdownrenderer/slack_test.go

@@ -1,145 +0,0 @@
-package markdownrenderer
-
-import (
-	"encoding/json"
-	"testing"
-)
-
-func jsonEqual(a, b string) bool {
-	var va, vb any
-	if err := json.Unmarshal([]byte(a), &va); err != nil {
-		return false
-	}
-	if err := json.Unmarshal([]byte(b), &vb); err != nil {
-		return false
-	}
-	ja, _ := json.Marshal(va)
-	jb, _ := json.Marshal(vb)
-	return string(ja) == string(jb)
-}
-
-func prettyJSON(s string) string {
-	var v any
-	if err := json.Unmarshal([]byte(s), &v); err != nil {
-		return s
-	}
-	b, _ := json.MarshalIndent(v, "", "  ")
-	return string(b)
-}
-
-func TestRenderSlackBlockKit(t *testing.T) {
-	tests := []struct {
-		name     string
-		markdown string
-		expected string
-	}{
-		{
-			name:     "simple paragraph",
-			markdown: "Hello world",
-			expected: `[
-				{
-					"type": "section",
-					"text": { "type": "mrkdwn", "text": "Hello world" }
-				}
-			]`,
-		},
-		{
-			name: "alert-themed with heading, list, and code block",
-			markdown: `# Alert Triggered
-
-- Service: **checkout-api**
-- Status: _critical_
-
-` + "```" + `
-error: connection timeout after 30s
-` + "```",
-			expected: `[
-				{
-					"type": "section",
-					"text": { "type": "mrkdwn", "text": "*Alert Triggered*" }
-				},
-				{
-					"type": "rich_text",
-					"elements": [
-						{
-							"type": "rich_text_list", "style": "bullet", "indent": 0, "border": 0,
-							"elements": [
-								{ "type": "rich_text_section", "elements": [
-									{ "type": "text", "text": "Service: " },
-									{ "type": "text", "text": "checkout-api", "style": { "bold": true } }
-								]},
-								{ "type": "rich_text_section", "elements": [
-									{ "type": "text", "text": "Status: " },
-									{ "type": "text", "text": "critical", "style": { "italic": true } }
-								]}
-							]
-						}
-					]
-				},
-				{
-					"type": "rich_text",
-					"elements": [
-						{
-							"type": "rich_text_preformatted",
-							"border": 0,
-							"elements": [
-								{ "type": "text", "text": "error: connection timeout after 30s" }
-							]
-						}
-					]
-				}
-			]`,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			got, err := RenderSlackBlockKit(tt.markdown)
-			if err != nil {
-				t.Fatalf("Render error: %v", err)
-			}
-
-			if !json.Valid([]byte(got)) {
-				t.Fatalf("output is not valid JSON:\n%s", got)
-			}
-
-			if !jsonEqual(got, tt.expected) {
-				t.Errorf("JSON mismatch\n\nMarkdown:\n%s\n\nExpected:\n%s\n\nGot:\n%s",
-					tt.markdown, prettyJSON(tt.expected), prettyJSON(got))
-			}
-		})
-	}
-}
-
-func TestRenderSlackMrkdwn(t *testing.T) {
-	markdown := `# Alert Triggered
-
-- Service: **checkout-api**
-- Status: _critical_
-- Dashboard: [View Dashboard](https://example.com/dashboard)
-
-| Metric | Value | Threshold |
-| --- | --- | --- |
-| Latency | 250ms | 100ms |
-| Error Rate | 5.2% | 1% |
-
-` + "```" + `
-error: connection timeout after 30s
-` + "```"
-
-	expected := "*Alert Triggered*\n\n" +
-		"• Service: *checkout-api*\n" +
-		"• Status: _critical_\n" +
-		"• Dashboard: <https://example.com/dashboard|View Dashboard>\n\n" +
-		"```\nMetric     | Value | Threshold\n-----------|-------|----------\nLatency    | 250ms | 100ms    \nError Rate | 5.2%  | 1%       \n```\n\n" +
-		"```\nerror: connection timeout after 30s\n```\n\n"
-
-	got, err := RenderSlackMrkdwn(markdown)
-	if err != nil {
-		t.Fatalf("Render error: %v", err)
-	}
-
-	if got != expected {
-		t.Errorf("mrkdwn mismatch\n\nExpected:\n%q\n\nGot:\n%q", expected, got)
-	}
-}

pkg/types/inframonitoringtypes/commontypes.go

@@ -1,21 +0,0 @@
-package inframonitoringtypes
-
-import (
-	"github.com/SigNoz/signoz/pkg/valuer"
-)
-
-type ResponseType struct {
-	valuer.String
-}
-
-var (
-	ResponseTypeList        = ResponseType{valuer.NewString("list")}
-	ResponseTypeGroupedList = ResponseType{valuer.NewString("grouped_list")}
-)
-
-func (ResponseType) Enum() []any {
-	return []any{
-		ResponseTypeList,
-		ResponseTypeGroupedList,
-	}
-}

pkg/types/inframonitoringtypes/hosts.go

@@ -1,117 +0,0 @@
-package inframonitoringtypes
-
-import (
-	"encoding/json"
-	"slices"
-
-	"github.com/SigNoz/signoz/pkg/errors"
-	qbtypes "github.com/SigNoz/signoz/pkg/types/querybuildertypes/querybuildertypesv5"
-)
-
-type Hosts struct {
-	Type                   ResponseType           `json:"type" required:"true"`
-	Records                []HostRecord           `json:"records" required:"true"`
-	Total                  int                    `json:"total" required:"true"`
-	RequiredMetricsCheck   RequiredMetricsCheck   `json:"requiredMetricsCheck" required:"true"`
-	EndTimeBeforeRetention bool                   `json:"endTimeBeforeRetention" required:"true"`
-	Warning                *qbtypes.QueryWarnData `json:"warning,omitempty"`
-}
-
-type HostRecord struct {
-	HostName          string                 `json:"hostName" required:"true"`
-	Status            HostStatus             `json:"status" required:"true"`
-	ActiveHostCount   int                    `json:"activeHostCount" required:"true"`
-	InactiveHostCount int                    `json:"inactiveHostCount" required:"true"`
-	CPU               float64                `json:"cpu" required:"true"`
-	Memory            float64                `json:"memory" required:"true"`
-	Wait              float64                `json:"wait" required:"true"`
-	Load15            float64                `json:"load15" required:"true"`
-	DiskUsage         float64                `json:"diskUsage" required:"true"`
-	Meta              map[string]interface{} `json:"meta" required:"true"`
-}
-
-type RequiredMetricsCheck struct {
-	MissingMetrics []string `json:"missingMetrics" required:"true"`
-}
-
-type PostableHosts struct {
-	Start   int64                `json:"start" required:"true"`
-	End     int64                `json:"end" required:"true"`
-	Filter  *HostFilter          `json:"filter"`
-	GroupBy []qbtypes.GroupByKey `json:"groupBy"`
-	OrderBy *qbtypes.OrderBy     `json:"orderBy"`
-	Offset  int                  `json:"offset"`
-	Limit   int                  `json:"limit" required:"true"`
-}
-
-type HostFilter struct {
-	qbtypes.Filter `json:",inline"`
-	FilterByStatus HostStatus `json:"filterByStatus"`
-}
-
-// Validate ensures HostsListRequest contains acceptable values.
-func (req *PostableHosts) Validate() error {
-	if req == nil {
-		return errors.NewInvalidInputf(errors.CodeInvalidInput, "request is nil")
-	}
-
-	if req.Start <= 0 {
-		return errors.NewInvalidInputf(
-			errors.CodeInvalidInput,
-			"invalid start time %d: start must be greater than 0",
-			req.Start,
-		)
-	}
-
-	if req.End <= 0 {
-		return errors.NewInvalidInputf(
-			errors.CodeInvalidInput,
-			"invalid end time %d: end must be greater than 0",
-			req.End,
-		)
-	}
-
-	if req.Start >= req.End {
-		return errors.NewInvalidInputf(
-			errors.CodeInvalidInput,
-			"invalid time range: start (%d) must be less than end (%d)",
-			req.Start,
-			req.End,
-		)
-	}
-
-	if req.Limit < 1 || req.Limit > 5000 {
-		return errors.NewInvalidInputf(errors.CodeInvalidInput, "limit must be between 1 and 5000")
-	}
-
-	if req.Offset < 0 {
-		return errors.NewInvalidInputf(errors.CodeInvalidInput, "offset cannot be negative")
-	}
-
-	if req.Filter != nil && !req.Filter.FilterByStatus.IsZero() &&
-		req.Filter.FilterByStatus != HostStatusActive && req.Filter.FilterByStatus != HostStatusInactive {
-		return errors.NewInvalidInputf(errors.CodeInvalidInput, "invalid filter by status: %s", req.Filter.FilterByStatus)
-	}
-
-	if req.OrderBy != nil {
-		if !slices.Contains(HostsValidOrderByKeys, req.OrderBy.Key.Name) {
-			return errors.NewInvalidInputf(errors.CodeInvalidInput, "invalid order by key: %s", req.OrderBy.Key.Name)
-		}
-		if req.OrderBy.Direction != qbtypes.OrderDirectionAsc && req.OrderBy.Direction != qbtypes.OrderDirectionDesc {
-			return errors.NewInvalidInputf(errors.CodeInvalidInput, "invalid order by direction: %s", req.OrderBy.Direction)
-		}
-	}
-
-	return nil
-}
-
-// UnmarshalJSON validates input immediately after decoding.
-func (req *PostableHosts) UnmarshalJSON(data []byte) error {
-	type raw PostableHosts
-	var decoded raw
-	if err := json.Unmarshal(data, &decoded); err != nil {
-		return err
-	}
-	*req = PostableHosts(decoded)
-	return req.Validate()
-}

pkg/types/inframonitoringtypes/hosts_constants.go

@@ -1,37 +0,0 @@
-package inframonitoringtypes
-
-import "github.com/SigNoz/signoz/pkg/valuer"
-
-type HostStatus struct {
-	valuer.String
-}
-
-var (
-	HostStatusActive   = HostStatus{valuer.NewString("active")}
-	HostStatusInactive = HostStatus{valuer.NewString("inactive")}
-	HostStatusNone     = HostStatus{valuer.NewString("")}
-)
-
-func (HostStatus) Enum() []any {
-	return []any{
-		HostStatusActive,
-		HostStatusInactive,
-		HostStatusNone,
-	}
-}
-
-const (
-	HostsOrderByCPU       = "cpu"
-	HostsOrderByMemory    = "memory"
-	HostsOrderByWait      = "wait"
-	HostsOrderByDiskUsage = "disk_usage"
-	HostsOrderByLoad15    = "load15"
-)
-
-var HostsValidOrderByKeys = []string{
-	HostsOrderByCPU,
-	HostsOrderByMemory,
-	HostsOrderByWait,
-	HostsOrderByDiskUsage,
-	HostsOrderByLoad15,
-}

pkg/types/inframonitoringtypes/hosts_test.go

@@ -1,244 +0,0 @@
-package inframonitoringtypes
-
-import (
-	"testing"
-
-	"github.com/SigNoz/signoz/pkg/errors"
-	qbtypes "github.com/SigNoz/signoz/pkg/types/querybuildertypes/querybuildertypesv5"
-	"github.com/SigNoz/signoz/pkg/types/telemetrytypes"
-	"github.com/SigNoz/signoz/pkg/valuer"
-	"github.com/stretchr/testify/require"
-)
-
-func TestHostsListRequest_Validate(t *testing.T) {
-	tests := []struct {
-		name    string
-		req     *PostableHosts
-		wantErr bool
-	}{
-		{
-			name: "valid request",
-			req: &PostableHosts{
-				Start:  1000,
-				End:    2000,
-				Limit:  100,
-				Offset: 0,
-			},
-			wantErr: false,
-		},
-		{
-			name:    "nil request",
-			req:     nil,
-			wantErr: true,
-		},
-		{
-			name: "start time zero",
-			req: &PostableHosts{
-				Start:  0,
-				End:    2000,
-				Limit:  100,
-				Offset: 0,
-			},
-			wantErr: true,
-		},
-		{
-			name: "start time negative",
-			req: &PostableHosts{
-				Start:  -1000,
-				End:    2000,
-				Limit:  100,
-				Offset: 0,
-			},
-			wantErr: true,
-		},
-		{
-			name: "end time zero",
-			req: &PostableHosts{
-				Start:  1000,
-				End:    0,
-				Limit:  100,
-				Offset: 0,
-			},
-			wantErr: true,
-		},
-		{
-			name: "start time greater than end time",
-			req: &PostableHosts{
-				Start:  2000,
-				End:    1000,
-				Limit:  100,
-				Offset: 0,
-			},
-			wantErr: true,
-		},
-		{
-			name: "start time equal to end time",
-			req: &PostableHosts{
-				Start:  1000,
-				End:    1000,
-				Limit:  100,
-				Offset: 0,
-			},
-			wantErr: true,
-		},
-		{
-			name: "limit zero",
-			req: &PostableHosts{
-				Start:  1000,
-				End:    2000,
-				Limit:  0,
-				Offset: 0,
-			},
-			wantErr: true,
-		},
-		{
-			name: "limit negative",
-			req: &PostableHosts{
-				Start:  1000,
-				End:    2000,
-				Limit:  -10,
-				Offset: 0,
-			},
-			wantErr: true,
-		},
-		{
-			name: "limit exceeds max",
-			req: &PostableHosts{
-				Start:  1000,
-				End:    2000,
-				Limit:  5001,
-				Offset: 0,
-			},
-			wantErr: true,
-		},
-		{
-			name: "offset negative",
-			req: &PostableHosts{
-				Start:  1000,
-				End:    2000,
-				Limit:  100,
-				Offset: -5,
-			},
-			wantErr: true,
-		},
-		{
-			name: "filter by status ACTIVE",
-			req: &PostableHosts{
-				Start:  1000,
-				End:    2000,
-				Limit:  100,
-				Offset: 0,
-				Filter: &HostFilter{FilterByStatus: HostStatusActive},
-			},
-			wantErr: false,
-		},
-		{
-			name: "filter by status INACTIVE",
-			req: &PostableHosts{
-				Start:  1000,
-				End:    2000,
-				Limit:  100,
-				Offset: 0,
-				Filter: &HostFilter{FilterByStatus: HostStatusInactive},
-			},
-			wantErr: false,
-		},
-		{
-			name: "filter by status empty (zero value)",
-			req: &PostableHosts{
-				Start:  1000,
-				End:    2000,
-				Limit:  100,
-				Offset: 0,
-			},
-			wantErr: false,
-		},
-		{
-			name: "filter by status invalid value",
-			req: &PostableHosts{
-				Start:  1000,
-				End:    2000,
-				Limit:  100,
-				Offset: 0,
-				Filter: &HostFilter{FilterByStatus: HostStatus{valuer.NewString("UNKNOWN")}},
-			},
-			wantErr: true,
-		},
-		{
-			name: "orderBy nil is valid",
-			req: &PostableHosts{
-				Start:  1000,
-				End:    2000,
-				Limit:  100,
-				Offset: 0,
-			},
-			wantErr: false,
-		},
-		{
-			name: "orderBy with valid key cpu and direction asc",
-			req: &PostableHosts{
-				Start:  1000,
-				End:    2000,
-				Limit:  100,
-				Offset: 0,
-				OrderBy: &qbtypes.OrderBy{
-					Key: qbtypes.OrderByKey{
-						TelemetryFieldKey: telemetrytypes.TelemetryFieldKey{
-							Name: HostsOrderByCPU,
-						},
-					},
-					Direction: qbtypes.OrderDirectionAsc,
-				},
-			},
-			wantErr: false,
-		},
-		{
-			name: "orderBy with invalid key",
-			req: &PostableHosts{
-				Start:  1000,
-				End:    2000,
-				Limit:  100,
-				Offset: 0,
-				OrderBy: &qbtypes.OrderBy{
-					Key: qbtypes.OrderByKey{
-						TelemetryFieldKey: telemetrytypes.TelemetryFieldKey{
-							Name: "unknown",
-						},
-					},
-					Direction: qbtypes.OrderDirectionDesc,
-				},
-			},
-			wantErr: true,
-		},
-		{
-			name: "orderBy with valid key but invalid direction",
-			req: &PostableHosts{
-				Start:  1000,
-				End:    2000,
-				Limit:  100,
-				Offset: 0,
-				OrderBy: &qbtypes.OrderBy{
-					Key: qbtypes.OrderByKey{
-						TelemetryFieldKey: telemetrytypes.TelemetryFieldKey{
-							Name: HostsOrderByMemory,
-						},
-					},
-					Direction: qbtypes.OrderDirection{String: valuer.NewString("invalid")},
-				},
-			},
-			wantErr: true,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			err := tt.req.Validate()
-			if tt.wantErr {
-				require.Error(t, err)
-				require.True(t, errors.Ast(err, errors.TypeInvalidInput), "expected error to be of type InvalidInput")
-			} else {
-				require.NoError(t, err)
-			}
-		})
-	}
-}

pkg/types/templatingtypes/templatingtypes.go

@@ -1,83 +0,0 @@
-// Package templatingtypes holds the data types produced by the markdown
-// renderers under pkg/templating (e.g. Slack Block Kit JSON DTOs).
-package templatingtypes
-
-// SectionBlock represents a Slack section block with mrkdwn text.
-type SectionBlock struct {
-	Type string      `json:"type"`
-	Text *TextObject `json:"text"`
-}
-
-// DividerBlock represents a Slack divider block.
-type DividerBlock struct {
-	Type string `json:"type"`
-}
-
-// RichTextBlock is a container for rich text elements (lists, code blocks,
-// table and cell blocks).
-type RichTextBlock struct {
-	Type     string `json:"type"`
-	Elements []any  `json:"elements"`
-}
-
-// TableBlock represents a Slack table rendered as a rich_text block with
-// preformatted text.
-type TableBlock struct {
-	Type string        `json:"type"`
-	Rows [][]TableCell `json:"rows"`
-}
-
-// TableCell is a cell in a TableBlock.
-type TableCell struct {
-	Type     string `json:"type"`
-	Elements []any  `json:"elements"`
-}
-
-// TextObject is the text field inside a SectionBlock.
-type TextObject struct {
-	Type string `json:"type"`
-	Text string `json:"text"`
-}
-
-// RichTextList represents an ordered or unordered list.
-type RichTextList struct {
-	Type     string `json:"type"`
-	Style    string `json:"style"`
-	Indent   int    `json:"indent"`
-	Border   int    `json:"border"`
-	Offset   int    `json:"offset,omitempty"`
-	Elements []any  `json:"elements"`
-}
-
-// RichTextPreformatted represents a code block.
-type RichTextPreformatted struct {
-	Type     string `json:"type"`
-	Elements []any  `json:"elements"`
-	Border   int    `json:"border"`
-	Language string `json:"language,omitempty"`
-}
-
-// RichTextInline represents inline text with optional styling, e.g. text
-// inside a list or a table cell.
-type RichTextInline struct {
-	Type  string         `json:"type"`
-	Text  string         `json:"text"`
-	Style *RichTextStyle `json:"style,omitempty"`
-}
-
-// RichTextLink represents a link inside rich text, e.g. a link inside a list
-// or a table cell.
-type RichTextLink struct {
-	Type  string         `json:"type"`
-	URL   string         `json:"url"`
-	Text  string         `json:"text,omitempty"`
-	Style *RichTextStyle `json:"style,omitempty"`
-}
-
-// RichTextStyle toggles inline styling on a rich-text element.
-type RichTextStyle struct {
-	Bold   bool `json:"bold,omitempty"`
-	Italic bool `json:"italic,omitempty"`
-	Strike bool `json:"strike,omitempty"`
-	Code   bool `json:"code,omitempty"`
-}

tests/.dockerignore

@@ -1,19 +0,0 @@
-# Build context for tests/Dockerfile.seeder. Keep the context lean — the
-# seeder image only needs fixtures/ to be importable alongside seeder/,
-# plus pyproject.toml + uv.lock for dep install.
-
-.venv
-.pytest_cache
-tmp
-**/__pycache__
-**/*.pyc
-
-# e2e Playwright outputs and deps
-e2e/node_modules
-e2e/artifacts
-e2e/.auth
-e2e/.playwright-cli
-
-# Integration-side outputs (if any stale dirs remain)
-integration/tmp
-integration/testdata

tests/Dockerfile.seeder

@@ -1,35 +0,0 @@
-# HTTP seeder for Playwright e2e tests. Wraps the direct-ClickHouse-insert
-# helpers in tests/fixtures/{traces,logs,metrics}.py so a browser test can
-# seed telemetry with fine-grained control.
-#
-# Build context is tests/ (this file sits at its root) so `fixtures/` is
-# importable inside the image alongside `seeder/`.
-
-FROM python:3.13-slim
-
-COPY --from=ghcr.io/astral-sh/uv:latest /uv /uvx /bin/
-
-WORKDIR /app
-
-RUN apt-get update \
-    && apt-get install -y --no-install-recommends gcc libpq-dev python3-dev \
-    && rm -rf /var/lib/apt/lists/*
-
-# Install project dependencies from the pytest project's pyproject.toml +
-# uv.lock so the seeder container's Python env matches local dev exactly
-# (single source of truth for versions; no parallel requirements.txt).
-# --no-install-project skips building the signoz-tests project itself
-# (there is no buildable package here — pyproject is used purely for dep
-# management alongside pythonpath = ["."]).
-COPY pyproject.toml uv.lock /app/
-RUN uv sync --frozen --no-install-project --no-dev
-ENV PATH="/app/.venv/bin:$PATH"
-
-# Ship the whole fixtures/ package so server.py can `from fixtures.traces
-# import ...` with the same module path the pytest side uses.
-COPY fixtures /app/fixtures
-COPY seeder /app/seeder
-
-EXPOSE 8080
-
-CMD ["uvicorn", "seeder.server:app", "--host", "0.0.0.0", "--port", "8080"]

tests/e2e/.env.example

@@ -1,15 +0,0 @@
-# Copy this to .env and fill in values for staging-mode runs.
-#
-# This file (.env) holds user-provided defaults — staging credentials, role
-# override. It is loaded by playwright.config.ts via dotenv.
-#
-# Local-mode runs (`cd tests && uv run pytest ... e2e/bootstrap/setup.py::test_setup`)
-# bring up a containerized backend and write .env.local, which overrides .env.
-# You do NOT need to touch this file for local mode.
-
-# Staging base URL (set to opt out of local backend bring-up)
-SIGNOZ_E2E_BASE_URL=https://app.us.staging.signoz.cloud
-
-# Test credentials (required only when SIGNOZ_E2E_BASE_URL is set — i.e. staging mode)
-SIGNOZ_E2E_USERNAME=
-SIGNOZ_E2E_PASSWORD=

tests/e2e/.eslintignore

@@ -1,38 +0,0 @@
-# Dependencies
-node_modules/
-
-# Build outputs
-dist/
-build/
-
-# Test results
-test-results/
-playwright-report/
-coverage/
-
-# Environment files
-.env
-.env.local
-.env.production
-
-# Editor files
-.vscode/
-.idea/
-*.swp
-*.swo
-
-# OS files
-.DS_Store
-Thumbs.db
-
-# Logs
-*.log
-npm-debug.log*
-yarn-debug.log*
-yarn-error.log*
-
-# Runtime data
-pids
-*.pid
-*.seed
-*.pid.lock

tests/e2e/.eslintrc.js

@@ -1,68 +0,0 @@
-module.exports = {
-  parser: '@typescript-eslint/parser',
-  parserOptions: {
-    ecmaVersion: 2022,
-    sourceType: 'module',
-  },
-  extends: [
-    'eslint:recommended',
-    'plugin:@typescript-eslint/recommended',
-    'plugin:playwright/recommended',
-  ],
-  env: {
-    node: true,
-    es2022: true,
-  },
-  rules: {
-    // Code Quality
-    '@typescript-eslint/no-unused-vars': 'error',
-    '@typescript-eslint/no-explicit-any': 'warn',
-    'prefer-const': 'error',
-    'no-var': 'error',
-
-    // Formatting Rules (ESLint handles formatting)
-    'semi': ['error', 'always'],
-    'quotes': ['error', 'single', { avoidEscape: true }],
-    'comma-dangle': ['error', 'always-multiline'],
-    'indent': ['error', 2, { SwitchCase: 1 }],
-    'object-curly-spacing': ['error', 'always'],
-    'array-bracket-spacing': ['error', 'never'],
-    'space-before-function-paren': ['error', {
-      anonymous: 'always',
-      named: 'never',
-      asyncArrow: 'always',
-    }],
-    'keyword-spacing': 'error',
-    'space-infix-ops': 'error',
-    'eol-last': 'error',
-    'no-trailing-spaces': 'error',
-    'no-multiple-empty-lines': ['error', { max: 2, maxEOF: 1 }],
-
-    // Playwright-specific (enhanced)
-    'playwright/expect-expect': 'error',
-    'playwright/no-conditional-in-test': 'error',
-    'playwright/no-page-pause': 'error',
-    'playwright/no-wait-for-timeout': 'warn',
-    'playwright/prefer-web-first-assertions': 'error',
-
-    // Console usage
-    'no-console': ['warn', { allow: ['warn', 'error'] }],
-  },
-  overrides: [
-    {
-      // Config files can use console and have relaxed formatting
-      files: ['*.config.{js,ts}', 'playwright.config.ts'],
-      rules: {
-        'no-console': 'off',
-        '@typescript-eslint/no-explicit-any': 'off',
-      },
-    },
-    {
-      // Test files specific rules
-      files: ['**/*.spec.ts', '**/*.test.ts'],
-      rules: {
-        '@typescript-eslint/no-explicit-any': 'off', // Page objects often need any
-      },
-    },
-  ],
-};

tests/e2e/.gitignore

@@ -1,24 +0,0 @@
-node_modules/
-# All Playwright output — HTML report, JSON summary, per-test traces /
-# screenshots / videos. Set via outputDir + reporter paths in playwright.config.ts.
-/artifacts/
-/playwright/.cache/
-.env
-dist/
-*.log
-yarn-error.log
-.yarn/cache
-.yarn/install-state.gz
-.vscode/
-
-# playwright-cli artifacts (snapshots, screenshots, videos, traces)
-.playwright-cli/
-
-# backend coordinates written by the pytest bootstrap (bootstrap/setup.py);
-# loaded by playwright.config.ts via dotenv override.
-.env.local
-
-# AI test-planner scratch (playwright-test-planner writes markdown plans
-# here before the generator turns them into .spec.ts files; the tests are
-# the source of truth, plans are regenerable).
-specs/

tests/e2e/.prettierignore

@@ -1,30 +0,0 @@
-# Dependencies
-node_modules/
-
-# Generated test outputs
-artifacts/
-playwright/.cache/
-
-# Build outputs
-dist/
-
-# Environment files
-.env
-.env.local
-.env*.local
-
-# Lock files
-yarn.lock
-package-lock.json
-pnpm-lock.yaml
-
-# Logs
-*.log
-yarn-error.log
-
-# IDE
-.vscode/
-.idea/
-
-# Other
-.DS_Store

tests/e2e/.prettierrc.json

@@ -1,6 +0,0 @@
-{
-  "useTabs": false,
-  "tabWidth": 2,
-  "singleQuote": true,
-  "trailingComma": "all"
-}

tests/e2e/bootstrap/setup.py

@@ -1,44 +0,0 @@
-import os
-from pathlib import Path
-
-import pytest
-
-from fixtures import types
-from fixtures.auth import USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD
-
-
-def _env_file(pytestconfig: pytest.Config) -> Path:
-    override = os.environ.get("SIGNOZ_E2E_ENV_FILE")
-    if override:
-        return Path(override)
-    return pytestconfig.rootpath / "e2e" / ".env.local"
-
-
-def test_setup(
-    signoz: types.SigNoz,
-    create_user_admin: types.Operation,  # pylint: disable=unused-argument
-    apply_license: types.Operation,  # pylint: disable=unused-argument
-    seeder: types.TestContainerDocker,
-    pytestconfig: pytest.Config,
-) -> None:
-    """Bring the backend up and write e2e coordinates to .env.local."""
-    host_cfg = signoz.self.host_configs["8080"]
-    seeder_cfg = seeder.host_configs["8080"]
-    out = _env_file(pytestconfig)
-    out.parent.mkdir(parents=True, exist_ok=True)
-    out.write_text(
-        "# Generated by tests/e2e/bootstrap/setup.py — do not edit.\n"
-        f"SIGNOZ_E2E_BASE_URL={host_cfg.base()}\n"
-        f"SIGNOZ_E2E_USERNAME={USER_ADMIN_EMAIL}\n"
-        f"SIGNOZ_E2E_PASSWORD={USER_ADMIN_PASSWORD}\n"
-        f"SIGNOZ_E2E_SEEDER_URL={seeder_cfg.base()}\n"
-    )
-
-
-def test_teardown(
-    signoz: types.SigNoz,  # pylint: disable=unused-argument
-    create_user_admin: types.Operation,  # pylint: disable=unused-argument
-    apply_license: types.Operation,  # pylint: disable=unused-argument
-    seeder: types.TestContainerDocker,  # pylint: disable=unused-argument
-) -> None:
-    """Fixture dependencies trigger container teardown via --teardown."""