chore: broke down drilldown navigate into a saperate hook

.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:
@@ -4387,193 +4268,6 @@ components:
       type: object
     Sigv4SigV4Config:
       type: object
-    SpanattributemappingtypesCondition:
-      properties:
-        attributes:
-          items:
-            type: string
-          nullable: true
-          type: array
-        resource:
-          items:
-            type: string
-          nullable: true
-          type: array
-      required:
-      - attributes
-      - resource
-      type: object
-    SpanattributemappingtypesFieldContext:
-      enum:
-      - attribute
-      - resource
-      type: string
-    SpanattributemappingtypesGettableGroups:
-      properties:
-        items:
-          items:
-            $ref: '#/components/schemas/SpanattributemappingtypesGroup'
-          type: array
-      required:
-      - items
-      type: object
-    SpanattributemappingtypesGettableMappers:
-      properties:
-        items:
-          items:
-            $ref: '#/components/schemas/SpanattributemappingtypesMapper'
-          type: array
-      required:
-      - items
-      type: object
-    SpanattributemappingtypesGroup:
-      properties:
-        category:
-          $ref: '#/components/schemas/SpanattributemappingtypesGroupCategory'
-        condition:
-          $ref: '#/components/schemas/SpanattributemappingtypesCondition'
-        createdAt:
-          format: date-time
-          type: string
-        createdBy:
-          type: string
-        enabled:
-          type: boolean
-        id:
-          type: string
-        name:
-          type: string
-        orgId:
-          type: string
-        updatedAt:
-          format: date-time
-          type: string
-        updatedBy:
-          type: string
-      required:
-      - id
-      - orgId
-      - name
-      - category
-      - condition
-      - enabled
-      type: object
-    SpanattributemappingtypesGroupCategory:
-      type: object
-    SpanattributemappingtypesMapper:
-      properties:
-        config:
-          $ref: '#/components/schemas/SpanattributemappingtypesMapperConfig'
-        createdAt:
-          format: date-time
-          type: string
-        createdBy:
-          type: string
-        enabled:
-          type: boolean
-        field_context:
-          $ref: '#/components/schemas/SpanattributemappingtypesFieldContext'
-        group_id:
-          type: string
-        id:
-          type: string
-        name:
-          type: string
-        updatedAt:
-          format: date-time
-          type: string
-        updatedBy:
-          type: string
-      required:
-      - id
-      - group_id
-      - name
-      - field_context
-      - config
-      - enabled
-      type: object
-    SpanattributemappingtypesMapperConfig:
-      properties:
-        sources:
-          items:
-            $ref: '#/components/schemas/SpanattributemappingtypesMapperSource'
-          nullable: true
-          type: array
-      required:
-      - sources
-      type: object
-    SpanattributemappingtypesMapperOperation:
-      enum:
-      - move
-      - copy
-      type: string
-    SpanattributemappingtypesMapperSource:
-      properties:
-        context:
-          $ref: '#/components/schemas/SpanattributemappingtypesFieldContext'
-        key:
-          type: string
-        operation:
-          $ref: '#/components/schemas/SpanattributemappingtypesMapperOperation'
-        priority:
-          type: integer
-      required:
-      - key
-      - context
-      - operation
-      - priority
-      type: object
-    SpanattributemappingtypesPostableGroup:
-      properties:
-        category:
-          $ref: '#/components/schemas/SpanattributemappingtypesGroupCategory'
-        condition:
-          $ref: '#/components/schemas/SpanattributemappingtypesCondition'
-        enabled:
-          type: boolean
-        name:
-          type: string
-      required:
-      - name
-      - category
-      - condition
-      type: object
-    SpanattributemappingtypesPostableMapper:
-      properties:
-        config:
-          $ref: '#/components/schemas/SpanattributemappingtypesMapperConfig'
-        enabled:
-          type: boolean
-        field_context:
-          $ref: '#/components/schemas/SpanattributemappingtypesFieldContext'
-        name:
-          type: string
-      required:
-      - name
-      - field_context
-      - config
-      type: object
-    SpanattributemappingtypesUpdatableGroup:
-      properties:
-        condition:
-          $ref: '#/components/schemas/SpanattributemappingtypesCondition'
-        enabled:
-          nullable: true
-          type: boolean
-        name:
-          nullable: true
-          type: string
-      type: object
-    SpanattributemappingtypesUpdatableMapper:
-      properties:
-        config:
-          $ref: '#/components/schemas/SpanattributemappingtypesMapperConfig'
-        enabled:
-          nullable: true
-          type: boolean
-        field_context:
-          $ref: '#/components/schemas/SpanattributemappingtypesFieldContext'
-      type: object
     TelemetrytypesFieldContext:
       enum:
       - metric
@@ -9182,487 +8876,6 @@ paths:
       summary: Updates my service account
       tags:
       - serviceaccount
-  /api/v1/span_attribute_mapping_groups:
-    get:
-      deprecated: false
-      description: Returns all span attribute mapping groups for the authenticated
-        org.
-      operationId: ListSpanAttributeMappingGroups
-      parameters:
-      - explode: true
-        in: query
-        name: category
-        schema:
-          $ref: '#/components/schemas/SpanattributemappingtypesGroupCategory'
-        style: deepObject
-      - in: query
-        name: enabled
-        schema:
-          nullable: true
-          type: boolean
-      responses:
-        "200":
-          content:
-            application/json:
-              schema:
-                properties:
-                  data:
-                    $ref: '#/components/schemas/SpanattributemappingtypesGettableGroups'
-                  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 span attribute mapping groups
-      tags:
-      - span-attribute-mapping
-    post:
-      deprecated: false
-      description: Creates a new span attribute mapping group for the org.
-      operationId: CreateMappingGroup
-      requestBody:
-        content:
-          application/json:
-            schema:
-              $ref: '#/components/schemas/SpanattributemappingtypesPostableGroup'
-      responses:
-        "201":
-          content:
-            application/json:
-              schema:
-                properties:
-                  data:
-                    $ref: '#/components/schemas/SpanattributemappingtypesGroup'
-                  status:
-                    type: string
-                required:
-                - status
-                - data
-                type: object
-          description: Created
-        "400":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Bad Request
-        "401":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Unauthorized
-        "403":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Forbidden
-        "409":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Conflict
-        "500":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Internal Server Error
-      security:
-      - api_key:
-        - ADMIN
-      - tokenizer:
-        - ADMIN
-      summary: Create a span attribute mapping group
-      tags:
-      - span-attribute-mapping
-  /api/v1/span_attribute_mapping_groups/{groupId}:
-    delete:
-      deprecated: false
-      description: Hard-deletes a mapping group and cascades to all its mappers.
-      operationId: DeleteMappingGroup
-      parameters:
-      - in: path
-        name: groupId
-        required: true
-        schema:
-          type: string
-      responses:
-        "204":
-          description: No Content
-        "401":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Unauthorized
-        "403":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Forbidden
-        "404":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Not Found
-        "500":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Internal Server Error
-      security:
-      - api_key:
-        - ADMIN
-      - tokenizer:
-        - ADMIN
-      summary: Delete a span attribute mapping group
-      tags:
-      - span-attribute-mapping
-    patch:
-      deprecated: false
-      description: Partially updates an existing mapping group's name, condition,
-        or enabled state.
-      operationId: UpdateMappingGroup
-      parameters:
-      - in: path
-        name: groupId
-        required: true
-        schema:
-          type: string
-      requestBody:
-        content:
-          application/json:
-            schema:
-              $ref: '#/components/schemas/SpanattributemappingtypesUpdatableGroup'
-      responses:
-        "204":
-          description: No Content
-        "400":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Bad Request
-        "401":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Unauthorized
-        "403":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Forbidden
-        "404":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Not Found
-        "500":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Internal Server Error
-      security:
-      - api_key:
-        - ADMIN
-      - tokenizer:
-        - ADMIN
-      summary: Update a span attribute mapping group
-      tags:
-      - span-attribute-mapping
-  /api/v1/span_attribute_mapping_groups/{groupId}/mappers:
-    get:
-      deprecated: false
-      description: Returns all attribute mappers belonging to a mapping group.
-      operationId: ListMappers
-      parameters:
-      - in: path
-        name: groupId
-        required: true
-        schema:
-          type: string
-      responses:
-        "200":
-          content:
-            application/json:
-              schema:
-                properties:
-                  data:
-                    $ref: '#/components/schemas/SpanattributemappingtypesGettableMappers'
-                  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
-        "404":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Not Found
-        "500":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Internal Server Error
-      security:
-      - api_key:
-        - VIEWER
-      - tokenizer:
-        - VIEWER
-      summary: List span attribute mappers for a group
-      tags:
-      - span-attribute-mapping
-    post:
-      deprecated: false
-      description: Adds a new attribute mapper to the specified mapping group.
-      operationId: CreateMapper
-      parameters:
-      - in: path
-        name: groupId
-        required: true
-        schema:
-          type: string
-      requestBody:
-        content:
-          application/json:
-            schema:
-              $ref: '#/components/schemas/SpanattributemappingtypesPostableMapper'
-      responses:
-        "201":
-          content:
-            application/json:
-              schema:
-                properties:
-                  data:
-                    $ref: '#/components/schemas/SpanattributemappingtypesMapper'
-                  status:
-                    type: string
-                required:
-                - status
-                - data
-                type: object
-          description: Created
-        "400":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Bad Request
-        "401":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Unauthorized
-        "403":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Forbidden
-        "404":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Not Found
-        "409":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Conflict
-        "500":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Internal Server Error
-      security:
-      - api_key:
-        - ADMIN
-      - tokenizer:
-        - ADMIN
-      summary: Create a span attribute mapper
-      tags:
-      - span-attribute-mapping
-  /api/v1/span_attribute_mapping_groups/{groupId}/mappers/{mapperId}:
-    delete:
-      deprecated: false
-      description: Hard-deletes a mapper from a mapping group.
-      operationId: DeleteMapper
-      parameters:
-      - in: path
-        name: groupId
-        required: true
-        schema:
-          type: string
-      - in: path
-        name: mapperId
-        required: true
-        schema:
-          type: string
-      responses:
-        "204":
-          description: No Content
-        "401":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Unauthorized
-        "403":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Forbidden
-        "404":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Not Found
-        "500":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Internal Server Error
-      security:
-      - api_key:
-        - ADMIN
-      - tokenizer:
-        - ADMIN
-      summary: Delete a span attribute mapper
-      tags:
-      - span-attribute-mapping
-    patch:
-      deprecated: false
-      description: Partially updates an existing mapper's field context, config, or
-        enabled state.
-      operationId: UpdateMapper
-      parameters:
-      - in: path
-        name: groupId
-        required: true
-        schema:
-          type: string
-      - in: path
-        name: mapperId
-        required: true
-        schema:
-          type: string
-      requestBody:
-        content:
-          application/json:
-            schema:
-              $ref: '#/components/schemas/SpanattributemappingtypesUpdatableMapper'
-      responses:
-        "204":
-          description: No Content
-        "400":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Bad Request
-        "401":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Unauthorized
-        "403":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Forbidden
-        "404":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Not Found
-        "500":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Internal Server Error
-      security:
-      - api_key:
-        - ADMIN
-      - tokenizer:
-        - ADMIN
-      summary: Update a span attribute mapper
-      tags:
-      - span-attribute-mapping
   /api/v1/testChannel:
     post:
       deprecated: true
@@ -10640,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
@@ -5370,194 +5245,6 @@ export interface Sigv4SigV4ConfigDTO {
 	[key: string]: unknown;
 }
 
-export interface SpanattributemappingtypesConditionDTO {
-	/**
-	 * @type array
-	 * @nullable true
-	 */
-	attributes: string[] | null;
-	/**
-	 * @type array
-	 * @nullable true
-	 */
-	resource: string[] | null;
-}
-
-export enum SpanattributemappingtypesFieldContextDTO {
-	attribute = 'attribute',
-	resource = 'resource',
-}
-export interface SpanattributemappingtypesGettableGroupsDTO {
-	/**
-	 * @type array
-	 */
-	items: SpanattributemappingtypesGroupDTO[];
-}
-
-export interface SpanattributemappingtypesGettableMappersDTO {
-	/**
-	 * @type array
-	 */
-	items: SpanattributemappingtypesMapperDTO[];
-}
-
-export interface SpanattributemappingtypesGroupDTO {
-	category: SpanattributemappingtypesGroupCategoryDTO;
-	condition: SpanattributemappingtypesConditionDTO;
-	/**
-	 * @type string
-	 * @format date-time
-	 */
-	createdAt?: Date;
-	/**
-	 * @type string
-	 */
-	createdBy?: string;
-	/**
-	 * @type boolean
-	 */
-	enabled: boolean;
-	/**
-	 * @type string
-	 */
-	id: string;
-	/**
-	 * @type string
-	 */
-	name: string;
-	/**
-	 * @type string
-	 */
-	orgId: string;
-	/**
-	 * @type string
-	 * @format date-time
-	 */
-	updatedAt?: Date;
-	/**
-	 * @type string
-	 */
-	updatedBy?: string;
-}
-
-export interface SpanattributemappingtypesGroupCategoryDTO {
-	[key: string]: unknown;
-}
-
-export interface SpanattributemappingtypesMapperDTO {
-	config: SpanattributemappingtypesMapperConfigDTO;
-	/**
-	 * @type string
-	 * @format date-time
-	 */
-	createdAt?: Date;
-	/**
-	 * @type string
-	 */
-	createdBy?: string;
-	/**
-	 * @type boolean
-	 */
-	enabled: boolean;
-	field_context: SpanattributemappingtypesFieldContextDTO;
-	/**
-	 * @type string
-	 */
-	group_id: string;
-	/**
-	 * @type string
-	 */
-	id: string;
-	/**
-	 * @type string
-	 */
-	name: string;
-	/**
-	 * @type string
-	 * @format date-time
-	 */
-	updatedAt?: Date;
-	/**
-	 * @type string
-	 */
-	updatedBy?: string;
-}
-
-export interface SpanattributemappingtypesMapperConfigDTO {
-	/**
-	 * @type array
-	 * @nullable true
-	 */
-	sources: SpanattributemappingtypesMapperSourceDTO[] | null;
-}
-
-export enum SpanattributemappingtypesMapperOperationDTO {
-	move = 'move',
-	copy = 'copy',
-}
-export interface SpanattributemappingtypesMapperSourceDTO {
-	context: SpanattributemappingtypesFieldContextDTO;
-	/**
-	 * @type string
-	 */
-	key: string;
-	operation: SpanattributemappingtypesMapperOperationDTO;
-	/**
-	 * @type integer
-	 */
-	priority: number;
-}
-
-export interface SpanattributemappingtypesPostableGroupDTO {
-	category: SpanattributemappingtypesGroupCategoryDTO;
-	condition: SpanattributemappingtypesConditionDTO;
-	/**
-	 * @type boolean
-	 */
-	enabled?: boolean;
-	/**
-	 * @type string
-	 */
-	name: string;
-}
-
-export interface SpanattributemappingtypesPostableMapperDTO {
-	config: SpanattributemappingtypesMapperConfigDTO;
-	/**
-	 * @type boolean
-	 */
-	enabled?: boolean;
-	field_context: SpanattributemappingtypesFieldContextDTO;
-	/**
-	 * @type string
-	 */
-	name: string;
-}
-
-export interface SpanattributemappingtypesUpdatableGroupDTO {
-	condition?: SpanattributemappingtypesConditionDTO;
-	/**
-	 * @type boolean
-	 * @nullable true
-	 */
-	enabled?: boolean | null;
-	/**
-	 * @type string
-	 * @nullable true
-	 */
-	name?: string | null;
-}
-
-export interface SpanattributemappingtypesUpdatableMapperDTO {
-	config?: SpanattributemappingtypesMapperConfigDTO;
-	/**
-	 * @type boolean
-	 * @nullable true
-	 */
-	enabled?: boolean | null;
-	field_context?: SpanattributemappingtypesFieldContextDTO;
-}
-
 export enum TelemetrytypesFieldContextDTO {
 	metric = 'metric',
 	log = 'log',
@@ -6777,71 +6464,6 @@ export type GetMyServiceAccount200 = {
 	status: string;
 };
 
-export type ListSpanAttributeMappingGroupsParams = {
-	/**
-	 * @description undefined
-	 */
-	category?: SpanattributemappingtypesGroupCategoryDTO;
-	/**
-	 * @type boolean
-	 * @nullable true
-	 * @description undefined
-	 */
-	enabled?: boolean | null;
-};
-
-export type ListSpanAttributeMappingGroups200 = {
-	data: SpanattributemappingtypesGettableGroupsDTO;
-	/**
-	 * @type string
-	 */
-	status: string;
-};
-
-export type CreateMappingGroup201 = {
-	data: SpanattributemappingtypesGroupDTO;
-	/**
-	 * @type string
-	 */
-	status: string;
-};
-
-export type DeleteMappingGroupPathParameters = {
-	groupId: string;
-};
-export type UpdateMappingGroupPathParameters = {
-	groupId: string;
-};
-export type ListMappersPathParameters = {
-	groupId: string;
-};
-export type ListMappers200 = {
-	data: SpanattributemappingtypesGettableMappersDTO;
-	/**
-	 * @type string
-	 */
-	status: string;
-};
-
-export type CreateMapperPathParameters = {
-	groupId: string;
-};
-export type CreateMapper201 = {
-	data: SpanattributemappingtypesMapperDTO;
-	/**
-	 * @type string
-	 */
-	status: string;
-};
-
-export type DeleteMapperPathParameters = {
-	groupId: string;
-	mapperId: string;
-};
-export type UpdateMapperPathParameters = {
-	groupId: string;
-	mapperId: string;
-};
 export type ListUsersDeprecated200 = {
 	/**
 	 * @type array
@@ -7016,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/generated/services/span-attribute-mapping/index.ts

@@ -1,790 +0,0 @@
-/**
- * ! Do not edit manually
- * * The file has been auto-generated using Orval for SigNoz
- * * regenerate with 'yarn generate:api'
- * SigNoz
- */
-import { useMutation, useQuery } from 'react-query';
-import type {
-	InvalidateOptions,
-	MutationFunction,
-	QueryClient,
-	QueryFunction,
-	QueryKey,
-	UseMutationOptions,
-	UseMutationResult,
-	UseQueryOptions,
-	UseQueryResult,
-} from 'react-query';
-
-import type {
-	CreateMapper201,
-	CreateMapperPathParameters,
-	CreateMappingGroup201,
-	DeleteMapperPathParameters,
-	DeleteMappingGroupPathParameters,
-	ListMappers200,
-	ListMappersPathParameters,
-	ListSpanAttributeMappingGroups200,
-	ListSpanAttributeMappingGroupsParams,
-	RenderErrorResponseDTO,
-	SpanattributemappingtypesPostableGroupDTO,
-	SpanattributemappingtypesPostableMapperDTO,
-	SpanattributemappingtypesUpdatableGroupDTO,
-	SpanattributemappingtypesUpdatableMapperDTO,
-	UpdateMapperPathParameters,
-	UpdateMappingGroupPathParameters,
-} from '../sigNoz.schemas';
-
-import { GeneratedAPIInstance } from '../../../generatedAPIInstance';
-import type { ErrorType, BodyType } from '../../../generatedAPIInstance';
-
-/**
- * Returns all span attribute mapping groups for the authenticated org.
- * @summary List span attribute mapping groups
- */
-export const listSpanAttributeMappingGroups = (
-	params?: ListSpanAttributeMappingGroupsParams,
-	signal?: AbortSignal,
-) => {
-	return GeneratedAPIInstance<ListSpanAttributeMappingGroups200>({
-		url: `/api/v1/span_attribute_mapping_groups`,
-		method: 'GET',
-		params,
-		signal,
-	});
-};
-
-export const getListSpanAttributeMappingGroupsQueryKey = (
-	params?: ListSpanAttributeMappingGroupsParams,
-) => {
-	return [
-		`/api/v1/span_attribute_mapping_groups`,
-		...(params ? [params] : []),
-	] as const;
-};
-
-export const getListSpanAttributeMappingGroupsQueryOptions = <
-	TData = Awaited<ReturnType<typeof listSpanAttributeMappingGroups>>,
-	TError = ErrorType<RenderErrorResponseDTO>,
->(
-	params?: ListSpanAttributeMappingGroupsParams,
-	options?: {
-		query?: UseQueryOptions<
-			Awaited<ReturnType<typeof listSpanAttributeMappingGroups>>,
-			TError,
-			TData
-		>;
-	},
-) => {
-	const { query: queryOptions } = options ?? {};
-
-	const queryKey =
-		queryOptions?.queryKey ?? getListSpanAttributeMappingGroupsQueryKey(params);
-
-	const queryFn: QueryFunction<
-		Awaited<ReturnType<typeof listSpanAttributeMappingGroups>>
-	> = ({ signal }) => listSpanAttributeMappingGroups(params, signal);
-
-	return { queryKey, queryFn, ...queryOptions } as UseQueryOptions<
-		Awaited<ReturnType<typeof listSpanAttributeMappingGroups>>,
-		TError,
-		TData
-	> & { queryKey: QueryKey };
-};
-
-export type ListSpanAttributeMappingGroupsQueryResult = NonNullable<
-	Awaited<ReturnType<typeof listSpanAttributeMappingGroups>>
->;
-export type ListSpanAttributeMappingGroupsQueryError =
-	ErrorType<RenderErrorResponseDTO>;
-
-/**
- * @summary List span attribute mapping groups
- */
-
-export function useListSpanAttributeMappingGroups<
-	TData = Awaited<ReturnType<typeof listSpanAttributeMappingGroups>>,
-	TError = ErrorType<RenderErrorResponseDTO>,
->(
-	params?: ListSpanAttributeMappingGroupsParams,
-	options?: {
-		query?: UseQueryOptions<
-			Awaited<ReturnType<typeof listSpanAttributeMappingGroups>>,
-			TError,
-			TData
-		>;
-	},
-): UseQueryResult<TData, TError> & { queryKey: QueryKey } {
-	const queryOptions = getListSpanAttributeMappingGroupsQueryOptions(
-		params,
-		options,
-	);
-
-	const query = useQuery(queryOptions) as UseQueryResult<TData, TError> & {
-		queryKey: QueryKey;
-	};
-
-	query.queryKey = queryOptions.queryKey;
-
-	return query;
-}
-
-/**
- * @summary List span attribute mapping groups
- */
-export const invalidateListSpanAttributeMappingGroups = async (
-	queryClient: QueryClient,
-	params?: ListSpanAttributeMappingGroupsParams,
-	options?: InvalidateOptions,
-): Promise<QueryClient> => {
-	await queryClient.invalidateQueries(
-		{ queryKey: getListSpanAttributeMappingGroupsQueryKey(params) },
-		options,
-	);
-
-	return queryClient;
-};
-
-/**
- * Creates a new span attribute mapping group for the org.
- * @summary Create a span attribute mapping group
- */
-export const createMappingGroup = (
-	spanattributemappingtypesPostableGroupDTO: BodyType<SpanattributemappingtypesPostableGroupDTO>,
-	signal?: AbortSignal,
-) => {
-	return GeneratedAPIInstance<CreateMappingGroup201>({
-		url: `/api/v1/span_attribute_mapping_groups`,
-		method: 'POST',
-		headers: { 'Content-Type': 'application/json' },
-		data: spanattributemappingtypesPostableGroupDTO,
-		signal,
-	});
-};
-
-export const getCreateMappingGroupMutationOptions = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown,
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof createMappingGroup>>,
-		TError,
-		{ data: BodyType<SpanattributemappingtypesPostableGroupDTO> },
-		TContext
-	>;
-}): UseMutationOptions<
-	Awaited<ReturnType<typeof createMappingGroup>>,
-	TError,
-	{ data: BodyType<SpanattributemappingtypesPostableGroupDTO> },
-	TContext
-> => {
-	const mutationKey = ['createMappingGroup'];
-	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 createMappingGroup>>,
-		{ data: BodyType<SpanattributemappingtypesPostableGroupDTO> }
-	> = (props) => {
-		const { data } = props ?? {};
-
-		return createMappingGroup(data);
-	};
-
-	return { mutationFn, ...mutationOptions };
-};
-
-export type CreateMappingGroupMutationResult = NonNullable<
-	Awaited<ReturnType<typeof createMappingGroup>>
->;
-export type CreateMappingGroupMutationBody =
-	BodyType<SpanattributemappingtypesPostableGroupDTO>;
-export type CreateMappingGroupMutationError = ErrorType<RenderErrorResponseDTO>;
-
-/**
- * @summary Create a span attribute mapping group
- */
-export const useCreateMappingGroup = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown,
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof createMappingGroup>>,
-		TError,
-		{ data: BodyType<SpanattributemappingtypesPostableGroupDTO> },
-		TContext
-	>;
-}): UseMutationResult<
-	Awaited<ReturnType<typeof createMappingGroup>>,
-	TError,
-	{ data: BodyType<SpanattributemappingtypesPostableGroupDTO> },
-	TContext
-> => {
-	const mutationOptions = getCreateMappingGroupMutationOptions(options);
-
-	return useMutation(mutationOptions);
-};
-/**
- * Hard-deletes a mapping group and cascades to all its mappers.
- * @summary Delete a span attribute mapping group
- */
-export const deleteMappingGroup = ({
-	groupId,
-}: DeleteMappingGroupPathParameters) => {
-	return GeneratedAPIInstance<void>({
-		url: `/api/v1/span_attribute_mapping_groups/${groupId}`,
-		method: 'DELETE',
-	});
-};
-
-export const getDeleteMappingGroupMutationOptions = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown,
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof deleteMappingGroup>>,
-		TError,
-		{ pathParams: DeleteMappingGroupPathParameters },
-		TContext
-	>;
-}): UseMutationOptions<
-	Awaited<ReturnType<typeof deleteMappingGroup>>,
-	TError,
-	{ pathParams: DeleteMappingGroupPathParameters },
-	TContext
-> => {
-	const mutationKey = ['deleteMappingGroup'];
-	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 deleteMappingGroup>>,
-		{ pathParams: DeleteMappingGroupPathParameters }
-	> = (props) => {
-		const { pathParams } = props ?? {};
-
-		return deleteMappingGroup(pathParams);
-	};
-
-	return { mutationFn, ...mutationOptions };
-};
-
-export type DeleteMappingGroupMutationResult = NonNullable<
-	Awaited<ReturnType<typeof deleteMappingGroup>>
->;
-
-export type DeleteMappingGroupMutationError = ErrorType<RenderErrorResponseDTO>;
-
-/**
- * @summary Delete a span attribute mapping group
- */
-export const useDeleteMappingGroup = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown,
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof deleteMappingGroup>>,
-		TError,
-		{ pathParams: DeleteMappingGroupPathParameters },
-		TContext
-	>;
-}): UseMutationResult<
-	Awaited<ReturnType<typeof deleteMappingGroup>>,
-	TError,
-	{ pathParams: DeleteMappingGroupPathParameters },
-	TContext
-> => {
-	const mutationOptions = getDeleteMappingGroupMutationOptions(options);
-
-	return useMutation(mutationOptions);
-};
-/**
- * Partially updates an existing mapping group's name, condition, or enabled state.
- * @summary Update a span attribute mapping group
- */
-export const updateMappingGroup = (
-	{ groupId }: UpdateMappingGroupPathParameters,
-	spanattributemappingtypesUpdatableGroupDTO: BodyType<SpanattributemappingtypesUpdatableGroupDTO>,
-) => {
-	return GeneratedAPIInstance<void>({
-		url: `/api/v1/span_attribute_mapping_groups/${groupId}`,
-		method: 'PATCH',
-		headers: { 'Content-Type': 'application/json' },
-		data: spanattributemappingtypesUpdatableGroupDTO,
-	});
-};
-
-export const getUpdateMappingGroupMutationOptions = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown,
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof updateMappingGroup>>,
-		TError,
-		{
-			pathParams: UpdateMappingGroupPathParameters;
-			data: BodyType<SpanattributemappingtypesUpdatableGroupDTO>;
-		},
-		TContext
-	>;
-}): UseMutationOptions<
-	Awaited<ReturnType<typeof updateMappingGroup>>,
-	TError,
-	{
-		pathParams: UpdateMappingGroupPathParameters;
-		data: BodyType<SpanattributemappingtypesUpdatableGroupDTO>;
-	},
-	TContext
-> => {
-	const mutationKey = ['updateMappingGroup'];
-	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 updateMappingGroup>>,
-		{
-			pathParams: UpdateMappingGroupPathParameters;
-			data: BodyType<SpanattributemappingtypesUpdatableGroupDTO>;
-		}
-	> = (props) => {
-		const { pathParams, data } = props ?? {};
-
-		return updateMappingGroup(pathParams, data);
-	};
-
-	return { mutationFn, ...mutationOptions };
-};
-
-export type UpdateMappingGroupMutationResult = NonNullable<
-	Awaited<ReturnType<typeof updateMappingGroup>>
->;
-export type UpdateMappingGroupMutationBody =
-	BodyType<SpanattributemappingtypesUpdatableGroupDTO>;
-export type UpdateMappingGroupMutationError = ErrorType<RenderErrorResponseDTO>;
-
-/**
- * @summary Update a span attribute mapping group
- */
-export const useUpdateMappingGroup = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown,
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof updateMappingGroup>>,
-		TError,
-		{
-			pathParams: UpdateMappingGroupPathParameters;
-			data: BodyType<SpanattributemappingtypesUpdatableGroupDTO>;
-		},
-		TContext
-	>;
-}): UseMutationResult<
-	Awaited<ReturnType<typeof updateMappingGroup>>,
-	TError,
-	{
-		pathParams: UpdateMappingGroupPathParameters;
-		data: BodyType<SpanattributemappingtypesUpdatableGroupDTO>;
-	},
-	TContext
-> => {
-	const mutationOptions = getUpdateMappingGroupMutationOptions(options);
-
-	return useMutation(mutationOptions);
-};
-/**
- * Returns all attribute mappers belonging to a mapping group.
- * @summary List span attribute mappers for a group
- */
-export const listMappers = (
-	{ groupId }: ListMappersPathParameters,
-	signal?: AbortSignal,
-) => {
-	return GeneratedAPIInstance<ListMappers200>({
-		url: `/api/v1/span_attribute_mapping_groups/${groupId}/mappers`,
-		method: 'GET',
-		signal,
-	});
-};
-
-export const getListMappersQueryKey = ({
-	groupId,
-}: ListMappersPathParameters) => {
-	return [`/api/v1/span_attribute_mapping_groups/${groupId}/mappers`] as const;
-};
-
-export const getListMappersQueryOptions = <
-	TData = Awaited<ReturnType<typeof listMappers>>,
-	TError = ErrorType<RenderErrorResponseDTO>,
->(
-	{ groupId }: ListMappersPathParameters,
-	options?: {
-		query?: UseQueryOptions<
-			Awaited<ReturnType<typeof listMappers>>,
-			TError,
-			TData
-		>;
-	},
-) => {
-	const { query: queryOptions } = options ?? {};
-
-	const queryKey = queryOptions?.queryKey ?? getListMappersQueryKey({ groupId });
-
-	const queryFn: QueryFunction<Awaited<ReturnType<typeof listMappers>>> = ({
-		signal,
-	}) => listMappers({ groupId }, signal);
-
-	return {
-		queryKey,
-		queryFn,
-		enabled: !!groupId,
-		...queryOptions,
-	} as UseQueryOptions<
-		Awaited<ReturnType<typeof listMappers>>,
-		TError,
-		TData
-	> & { queryKey: QueryKey };
-};
-
-export type ListMappersQueryResult = NonNullable<
-	Awaited<ReturnType<typeof listMappers>>
->;
-export type ListMappersQueryError = ErrorType<RenderErrorResponseDTO>;
-
-/**
- * @summary List span attribute mappers for a group
- */
-
-export function useListMappers<
-	TData = Awaited<ReturnType<typeof listMappers>>,
-	TError = ErrorType<RenderErrorResponseDTO>,
->(
-	{ groupId }: ListMappersPathParameters,
-	options?: {
-		query?: UseQueryOptions<
-			Awaited<ReturnType<typeof listMappers>>,
-			TError,
-			TData
-		>;
-	},
-): UseQueryResult<TData, TError> & { queryKey: QueryKey } {
-	const queryOptions = getListMappersQueryOptions({ groupId }, options);
-
-	const query = useQuery(queryOptions) as UseQueryResult<TData, TError> & {
-		queryKey: QueryKey;
-	};
-
-	query.queryKey = queryOptions.queryKey;
-
-	return query;
-}
-
-/**
- * @summary List span attribute mappers for a group
- */
-export const invalidateListMappers = async (
-	queryClient: QueryClient,
-	{ groupId }: ListMappersPathParameters,
-	options?: InvalidateOptions,
-): Promise<QueryClient> => {
-	await queryClient.invalidateQueries(
-		{ queryKey: getListMappersQueryKey({ groupId }) },
-		options,
-	);
-
-	return queryClient;
-};
-
-/**
- * Adds a new attribute mapper to the specified mapping group.
- * @summary Create a span attribute mapper
- */
-export const createMapper = (
-	{ groupId }: CreateMapperPathParameters,
-	spanattributemappingtypesPostableMapperDTO: BodyType<SpanattributemappingtypesPostableMapperDTO>,
-	signal?: AbortSignal,
-) => {
-	return GeneratedAPIInstance<CreateMapper201>({
-		url: `/api/v1/span_attribute_mapping_groups/${groupId}/mappers`,
-		method: 'POST',
-		headers: { 'Content-Type': 'application/json' },
-		data: spanattributemappingtypesPostableMapperDTO,
-		signal,
-	});
-};
-
-export const getCreateMapperMutationOptions = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown,
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof createMapper>>,
-		TError,
-		{
-			pathParams: CreateMapperPathParameters;
-			data: BodyType<SpanattributemappingtypesPostableMapperDTO>;
-		},
-		TContext
-	>;
-}): UseMutationOptions<
-	Awaited<ReturnType<typeof createMapper>>,
-	TError,
-	{
-		pathParams: CreateMapperPathParameters;
-		data: BodyType<SpanattributemappingtypesPostableMapperDTO>;
-	},
-	TContext
-> => {
-	const mutationKey = ['createMapper'];
-	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 createMapper>>,
-		{
-			pathParams: CreateMapperPathParameters;
-			data: BodyType<SpanattributemappingtypesPostableMapperDTO>;
-		}
-	> = (props) => {
-		const { pathParams, data } = props ?? {};
-
-		return createMapper(pathParams, data);
-	};
-
-	return { mutationFn, ...mutationOptions };
-};
-
-export type CreateMapperMutationResult = NonNullable<
-	Awaited<ReturnType<typeof createMapper>>
->;
-export type CreateMapperMutationBody =
-	BodyType<SpanattributemappingtypesPostableMapperDTO>;
-export type CreateMapperMutationError = ErrorType<RenderErrorResponseDTO>;
-
-/**
- * @summary Create a span attribute mapper
- */
-export const useCreateMapper = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown,
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof createMapper>>,
-		TError,
-		{
-			pathParams: CreateMapperPathParameters;
-			data: BodyType<SpanattributemappingtypesPostableMapperDTO>;
-		},
-		TContext
-	>;
-}): UseMutationResult<
-	Awaited<ReturnType<typeof createMapper>>,
-	TError,
-	{
-		pathParams: CreateMapperPathParameters;
-		data: BodyType<SpanattributemappingtypesPostableMapperDTO>;
-	},
-	TContext
-> => {
-	const mutationOptions = getCreateMapperMutationOptions(options);
-
-	return useMutation(mutationOptions);
-};
-/**
- * Hard-deletes a mapper from a mapping group.
- * @summary Delete a span attribute mapper
- */
-export const deleteMapper = ({
-	groupId,
-	mapperId,
-}: DeleteMapperPathParameters) => {
-	return GeneratedAPIInstance<void>({
-		url: `/api/v1/span_attribute_mapping_groups/${groupId}/mappers/${mapperId}`,
-		method: 'DELETE',
-	});
-};
-
-export const getDeleteMapperMutationOptions = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown,
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof deleteMapper>>,
-		TError,
-		{ pathParams: DeleteMapperPathParameters },
-		TContext
-	>;
-}): UseMutationOptions<
-	Awaited<ReturnType<typeof deleteMapper>>,
-	TError,
-	{ pathParams: DeleteMapperPathParameters },
-	TContext
-> => {
-	const mutationKey = ['deleteMapper'];
-	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 deleteMapper>>,
-		{ pathParams: DeleteMapperPathParameters }
-	> = (props) => {
-		const { pathParams } = props ?? {};
-
-		return deleteMapper(pathParams);
-	};
-
-	return { mutationFn, ...mutationOptions };
-};
-
-export type DeleteMapperMutationResult = NonNullable<
-	Awaited<ReturnType<typeof deleteMapper>>
->;
-
-export type DeleteMapperMutationError = ErrorType<RenderErrorResponseDTO>;
-
-/**
- * @summary Delete a span attribute mapper
- */
-export const useDeleteMapper = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown,
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof deleteMapper>>,
-		TError,
-		{ pathParams: DeleteMapperPathParameters },
-		TContext
-	>;
-}): UseMutationResult<
-	Awaited<ReturnType<typeof deleteMapper>>,
-	TError,
-	{ pathParams: DeleteMapperPathParameters },
-	TContext
-> => {
-	const mutationOptions = getDeleteMapperMutationOptions(options);
-
-	return useMutation(mutationOptions);
-};
-/**
- * Partially updates an existing mapper's field context, config, or enabled state.
- * @summary Update a span attribute mapper
- */
-export const updateMapper = (
-	{ groupId, mapperId }: UpdateMapperPathParameters,
-	spanattributemappingtypesUpdatableMapperDTO: BodyType<SpanattributemappingtypesUpdatableMapperDTO>,
-) => {
-	return GeneratedAPIInstance<void>({
-		url: `/api/v1/span_attribute_mapping_groups/${groupId}/mappers/${mapperId}`,
-		method: 'PATCH',
-		headers: { 'Content-Type': 'application/json' },
-		data: spanattributemappingtypesUpdatableMapperDTO,
-	});
-};
-
-export const getUpdateMapperMutationOptions = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown,
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof updateMapper>>,
-		TError,
-		{
-			pathParams: UpdateMapperPathParameters;
-			data: BodyType<SpanattributemappingtypesUpdatableMapperDTO>;
-		},
-		TContext
-	>;
-}): UseMutationOptions<
-	Awaited<ReturnType<typeof updateMapper>>,
-	TError,
-	{
-		pathParams: UpdateMapperPathParameters;
-		data: BodyType<SpanattributemappingtypesUpdatableMapperDTO>;
-	},
-	TContext
-> => {
-	const mutationKey = ['updateMapper'];
-	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 updateMapper>>,
-		{
-			pathParams: UpdateMapperPathParameters;
-			data: BodyType<SpanattributemappingtypesUpdatableMapperDTO>;
-		}
-	> = (props) => {
-		const { pathParams, data } = props ?? {};
-
-		return updateMapper(pathParams, data);
-	};
-
-	return { mutationFn, ...mutationOptions };
-};
-
-export type UpdateMapperMutationResult = NonNullable<
-	Awaited<ReturnType<typeof updateMapper>>
->;
-export type UpdateMapperMutationBody =
-	BodyType<SpanattributemappingtypesUpdatableMapperDTO>;
-export type UpdateMapperMutationError = ErrorType<RenderErrorResponseDTO>;
-
-/**
- * @summary Update a span attribute mapper
- */
-export const useUpdateMapper = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown,
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof updateMapper>>,
-		TError,
-		{
-			pathParams: UpdateMapperPathParameters;
-			data: BodyType<SpanattributemappingtypesUpdatableMapperDTO>;
-		},
-		TContext
-	>;
-}): UseMutationResult<
-	Awaited<ReturnType<typeof updateMapper>>,
-	TError,
-	{
-		pathParams: UpdateMapperPathParameters;
-		data: BodyType<SpanattributemappingtypesUpdatableMapperDTO>;
-	},
-	TContext
-> => {
-	const mutationOptions = getUpdateMapperMutationOptions(options);
-
-	return useMutation(mutationOptions);
-};

frontend/src/container/QueryTable/Drilldown/__tests__/useBaseDrilldownNavigate.test.ts

@@ -0,0 +1,282 @@
+import { renderHook } from '@testing-library/react';
+import ROUTES from 'constants/routes';
+import { Query } from 'types/api/queryBuilder/queryBuilderData';
+
+import { getViewQuery } from '../drilldownUtils';
+import { AggregateData } from '../useAggregateDrilldown';
+import useBaseDrilldownNavigate, {
+	buildDrilldownUrl,
+	getRoute,
+} from '../useBaseDrilldownNavigate';
+
+const mockSafeNavigate = jest.fn();
+
+jest.mock('hooks/useSafeNavigate', () => ({
+	useSafeNavigate: (): { safeNavigate: typeof mockSafeNavigate } => ({ safeNavigate: mockSafeNavigate }),
+}));
+
+jest.mock('../drilldownUtils', () => ({
+	...jest.requireActual('../drilldownUtils'),
+	getViewQuery: jest.fn(),
+}));
+
+const mockGetViewQuery = getViewQuery as jest.Mock;
+
+// ─── Fixtures ────────────────────────────────────────────────────────────────
+
+const MOCK_QUERY: Query = {
+	id: 'q1',
+	queryType: 'builder' as any,
+	builder: {
+		queryData: [
+			{
+				queryName: 'A',
+				dataSource: 'metrics' as any,
+				groupBy: [],
+				expression: '',
+				disabled: false,
+				functions: [],
+				legend: '',
+				having: [],
+				limit: null,
+				stepInterval: undefined,
+				orderBy: [],
+			},
+		],
+		queryFormulas: [],
+		queryTraceOperator: [],
+	},
+	promql: [],
+	clickhouse_sql: [],
+};
+
+const MOCK_VIEW_QUERY: Query = {
+	...MOCK_QUERY,
+	builder: {
+		...MOCK_QUERY.builder,
+		queryData: [
+			{
+				...MOCK_QUERY.builder.queryData[0],
+				filters: { items: [], op: 'AND' },
+			},
+		],
+	},
+};
+
+const MOCK_AGGREGATE_DATA: AggregateData = {
+	queryName: 'A',
+	filters: [{ filterKey: 'service_name', filterValue: 'auth', operator: '=' }],
+	timeRange: { startTime: 1000000, endTime: 2000000 },
+};
+
+// ─── getRoute ─────────────────────────────────────────────────────────────────
+
+describe('getRoute', () => {
+	it.each([
+		['view_logs', ROUTES.LOGS_EXPLORER],
+		['view_metrics', ROUTES.METRICS_EXPLORER],
+		['view_traces', ROUTES.TRACES_EXPLORER],
+	])('maps %s to the correct explorer route', (key, expected) => {
+		expect(getRoute(key)).toBe(expected);
+	});
+
+	it('returns empty string for an unknown key', () => {
+		expect(getRoute('view_dashboard')).toBe('');
+	});
+});
+
+// ─── buildDrilldownUrl ────────────────────────────────────────────────────────
+
+describe('buildDrilldownUrl', () => {
+	beforeEach(() => {
+		mockGetViewQuery.mockReturnValue(MOCK_VIEW_QUERY);
+	});
+
+	afterEach(() => {
+		jest.clearAllMocks();
+	});
+
+	it('returns null for an unknown drilldown key', () => {
+		const url = buildDrilldownUrl(MOCK_QUERY, MOCK_AGGREGATE_DATA, 'view_dashboard');
+		expect(url).toBeNull();
+	});
+
+	it('returns null when getViewQuery returns null', () => {
+		mockGetViewQuery.mockReturnValue(null);
+		const url = buildDrilldownUrl(MOCK_QUERY, MOCK_AGGREGATE_DATA, 'view_logs');
+		expect(url).toBeNull();
+	});
+
+	it('returns a URL starting with the logs explorer route for view_logs', () => {
+		const url = buildDrilldownUrl(MOCK_QUERY, MOCK_AGGREGATE_DATA, 'view_logs');
+		expect(url).not.toBeNull();
+		expect(url).toContain(ROUTES.LOGS_EXPLORER);
+	});
+
+	it('returns a URL starting with the traces explorer route for view_traces', () => {
+		const url = buildDrilldownUrl(MOCK_QUERY, MOCK_AGGREGATE_DATA, 'view_traces');
+		expect(url).toContain(ROUTES.TRACES_EXPLORER);
+	});
+
+	it('includes compositeQuery param in the URL', () => {
+		const url = buildDrilldownUrl(MOCK_QUERY, MOCK_AGGREGATE_DATA, 'view_logs');
+		expect(url).toContain('compositeQuery=');
+	});
+
+	it('includes startTime and endTime when aggregateData has a timeRange', () => {
+		const url = buildDrilldownUrl(MOCK_QUERY, MOCK_AGGREGATE_DATA, 'view_logs');
+		expect(url).toContain('startTime=1000000');
+		expect(url).toContain('endTime=2000000');
+	});
+
+	it('omits startTime and endTime when aggregateData has no timeRange', () => {
+		const { timeRange: _, ...withoutTimeRange } = MOCK_AGGREGATE_DATA;
+		const url = buildDrilldownUrl(MOCK_QUERY, withoutTimeRange, 'view_logs');
+		expect(url).not.toContain('startTime=');
+		expect(url).not.toContain('endTime=');
+	});
+
+	it('includes summaryFilters param for view_metrics', () => {
+		const url = buildDrilldownUrl(MOCK_QUERY, MOCK_AGGREGATE_DATA, 'view_metrics');
+		expect(url).toContain(ROUTES.METRICS_EXPLORER);
+		expect(url).toContain('summaryFilters=');
+	});
+
+	it('does not include summaryFilters param for non-metrics routes', () => {
+		const url = buildDrilldownUrl(MOCK_QUERY, MOCK_AGGREGATE_DATA, 'view_logs');
+		expect(url).not.toContain('summaryFilters=');
+	});
+
+	it('handles null aggregateData by passing empty filters and empty queryName', () => {
+		const url = buildDrilldownUrl(MOCK_QUERY, null, 'view_logs');
+		expect(url).not.toBeNull();
+		expect(mockGetViewQuery).toHaveBeenCalledWith(MOCK_QUERY, [], 'view_logs', '');
+	});
+
+	it('passes aggregateData filters and queryName to getViewQuery', () => {
+		buildDrilldownUrl(MOCK_QUERY, MOCK_AGGREGATE_DATA, 'view_logs');
+		expect(mockGetViewQuery).toHaveBeenCalledWith(
+			MOCK_QUERY,
+			MOCK_AGGREGATE_DATA.filters,
+			'view_logs',
+			MOCK_AGGREGATE_DATA.queryName,
+		);
+	});
+});
+
+// ─── useBaseDrilldownNavigate ─────────────────────────────────────────────────
+
+describe('useBaseDrilldownNavigate', () => {
+	beforeEach(() => {
+		mockGetViewQuery.mockReturnValue(MOCK_VIEW_QUERY);
+	});
+
+	afterEach(() => {
+		jest.clearAllMocks();
+	});
+
+	it('calls safeNavigate with the built URL on a valid key', () => {
+		const { result } = renderHook(() =>
+			useBaseDrilldownNavigate({
+				resolvedQuery: MOCK_QUERY,
+				aggregateData: MOCK_AGGREGATE_DATA,
+			}),
+		);
+
+		result.current('view_logs');
+
+		expect(mockSafeNavigate).toHaveBeenCalledTimes(1);
+		const [url] = mockSafeNavigate.mock.calls[0];
+		expect(url).toContain(ROUTES.LOGS_EXPLORER);
+		expect(url).toContain('compositeQuery=');
+	});
+
+	it('opens the explorer in a new tab', () => {
+		const { result } = renderHook(() =>
+			useBaseDrilldownNavigate({
+				resolvedQuery: MOCK_QUERY,
+				aggregateData: MOCK_AGGREGATE_DATA,
+			}),
+		);
+
+		result.current('view_traces');
+
+		expect(mockSafeNavigate).toHaveBeenCalledWith(
+			expect.any(String),
+			{ newTab: true },
+		);
+	});
+
+	it('calls callback after successful navigation', () => {
+		const callback = jest.fn();
+		const { result } = renderHook(() =>
+			useBaseDrilldownNavigate({
+				resolvedQuery: MOCK_QUERY,
+				aggregateData: MOCK_AGGREGATE_DATA,
+				callback,
+			}),
+		);
+
+		result.current('view_logs');
+
+		expect(callback).toHaveBeenCalledTimes(1);
+	});
+
+	it('does not call safeNavigate for an unknown key', () => {
+		const { result } = renderHook(() =>
+			useBaseDrilldownNavigate({
+				resolvedQuery: MOCK_QUERY,
+				aggregateData: MOCK_AGGREGATE_DATA,
+			}),
+		);
+
+		result.current('view_dashboard');
+
+		expect(mockSafeNavigate).not.toHaveBeenCalled();
+	});
+
+	it('still calls callback when the key is unknown', () => {
+		const callback = jest.fn();
+		const { result } = renderHook(() =>
+			useBaseDrilldownNavigate({
+				resolvedQuery: MOCK_QUERY,
+				aggregateData: MOCK_AGGREGATE_DATA,
+				callback,
+			}),
+		);
+
+		result.current('view_dashboard');
+
+		expect(callback).toHaveBeenCalledTimes(1);
+		expect(mockSafeNavigate).not.toHaveBeenCalled();
+	});
+
+	it('still calls callback when getViewQuery returns null', () => {
+		mockGetViewQuery.mockReturnValue(null);
+		const callback = jest.fn();
+		const { result } = renderHook(() =>
+			useBaseDrilldownNavigate({
+				resolvedQuery: MOCK_QUERY,
+				aggregateData: MOCK_AGGREGATE_DATA,
+				callback,
+			}),
+		);
+
+		result.current('view_logs');
+
+		expect(callback).toHaveBeenCalledTimes(1);
+		expect(mockSafeNavigate).not.toHaveBeenCalled();
+	});
+
+	it('handles null aggregateData without throwing', () => {
+		const { result } = renderHook(() =>
+			useBaseDrilldownNavigate({
+				resolvedQuery: MOCK_QUERY,
+				aggregateData: null,
+			}),
+		);
+
+		expect(() => result.current('view_logs')).not.toThrow();
+		expect(mockSafeNavigate).toHaveBeenCalledTimes(1);
+	});
+});

frontend/src/container/QueryTable/Drilldown/drilldownUtils.tsx

@@ -166,7 +166,7 @@ export const getAggregateColumnHeader = (
 	};
 };
 
-const getFiltersFromMetric = (metric: any): FilterData[] =>
+export const getFiltersFromMetric = (metric: any): FilterData[] =>
 	Object.keys(metric).map((key) => ({
 		filterKey: key,
 		filterValue: metric[key],

frontend/src/container/QueryTable/Drilldown/useBaseAggregateOptions.tsx

@@ -2,14 +2,10 @@ import { useCallback, useEffect, useMemo, useState } from 'react';
 import { useLocation } from 'react-router-dom';
 import { LinkOutlined, LoadingOutlined } from '@ant-design/icons';
 import OverlayScrollbar from 'components/OverlayScrollbar/OverlayScrollbar';
-import { QueryParams } from 'constants/query';
 import { PANEL_TYPES } from 'constants/queryBuilder';
-import ROUTES from 'constants/routes';
 import useUpdatedQuery from 'container/GridCardLayout/useResolveQuery';
 import { processContextLinks } from 'container/NewWidget/RightContainer/ContextLinks/utils';
 import useContextVariables from 'hooks/dashboard/useContextVariables';
-import { useSafeNavigate } from 'hooks/useSafeNavigate';
-import createQueryParams from 'lib/createQueryParams';
 import ContextMenu from 'periscope/components/ContextMenu';
 import { useDashboardStore } from 'providers/Dashboard/store/useDashboardStore';
 import { ContextLinksData } from 'types/api/dashboard/getAll';
@@ -17,9 +13,10 @@ import { Query } from 'types/api/queryBuilder/queryBuilderData';
 
 import { ContextMenuItem } from './contextConfig';
 import { getDataLinks } from './dataLinksUtils';
-import { getAggregateColumnHeader, getViewQuery } from './drilldownUtils';
+import { getAggregateColumnHeader } from './drilldownUtils';
 import { getBaseContextConfig } from './menuOptions';
 import { AggregateData } from './useAggregateDrilldown';
+import useBaseDrilldownNavigate from './useBaseDrilldownNavigate';
 
 interface UseBaseAggregateOptionsProps {
 	query: Query;
@@ -37,19 +34,6 @@ interface BaseAggregateOptionsConfig {
 	items?: ContextMenuItem;
 }
 
-const getRoute = (key: string): string => {
-	switch (key) {
-		case 'view_logs':
-			return ROUTES.LOGS_EXPLORER;
-		case 'view_metrics':
-			return ROUTES.METRICS_EXPLORER;
-		case 'view_traces':
-			return ROUTES.TRACES_EXPLORER;
-		default:
-			return '';
-	}
-};
-
 const useBaseAggregateOptions = ({
 	query,
 	onClose,
@@ -62,10 +46,8 @@ const useBaseAggregateOptions = ({
 	baseAggregateOptionsConfig: BaseAggregateOptionsConfig;
 } => {
 	const [resolvedQuery, setResolvedQuery] = useState<Query>(query);
-	const {
-		getUpdatedQuery,
-		isLoading: isResolveQueryLoading,
-	} = useUpdatedQuery();
+	const { getUpdatedQuery, isLoading: isResolveQueryLoading } =
+		useUpdatedQuery();
 	const { dashboardData } = useDashboardStore();
 
 	useEffect(() => {
@@ -87,8 +69,6 @@ const useBaseAggregateOptions = ({
 		// eslint-disable-next-line react-hooks/exhaustive-deps
 	}, [query, aggregateData, panelType]);
 
-	const { safeNavigate } = useSafeNavigate();
-
 	// Use the new useContextVariables hook
 	const { processedVariables } = useContextVariables({
 		maxValues: 2,
@@ -122,50 +102,16 @@ const useBaseAggregateOptions = ({
 					{label}
 				</ContextMenu.Item>
 			));
-		} catch (error) {
+		} catch {
 			return [];
 		}
 	}, [contextLinks, processedVariables, onClose, aggregateData, query]);
 
-	const handleBaseDrilldown = useCallback(
-		(key: string): void => {
-			const route = getRoute(key);
-			const timeRange = aggregateData?.timeRange;
-			const filtersToAdd = aggregateData?.filters || [];
-			const viewQuery = getViewQuery(
-				resolvedQuery,
-				filtersToAdd,
-				key,
-				aggregateData?.queryName || '',
-			);
-
-			let queryParams = {
-				[QueryParams.compositeQuery]: encodeURIComponent(JSON.stringify(viewQuery)),
-				...(timeRange && {
-					[QueryParams.startTime]: timeRange?.startTime.toString(),
-					[QueryParams.endTime]: timeRange?.endTime.toString(),
-				}),
-			} as Record<string, string>;
-
-			if (route === ROUTES.METRICS_EXPLORER) {
-				queryParams = {
-					...queryParams,
-					[QueryParams.summaryFilters]: JSON.stringify(
-						viewQuery?.builder.queryData[0].filters,
-					),
-				};
-			}
-
-			if (route) {
-				safeNavigate(`${route}?${createQueryParams(queryParams)}`, {
-					newTab: true,
-				});
-			}
-
-			onClose();
-		},
-		[resolvedQuery, safeNavigate, onClose, aggregateData],
-	);
+	const handleBaseDrilldown = useBaseDrilldownNavigate({
+		resolvedQuery,
+		aggregateData,
+		callback: onClose,
+	});
 
 	const { pathname } = useLocation();
 

frontend/src/container/QueryTable/Drilldown/useBaseDrilldownNavigate.ts

@@ -0,0 +1,117 @@
+import { useCallback } from 'react';
+import { QueryParams } from 'constants/query';
+import ROUTES from 'constants/routes';
+import { useSafeNavigate } from 'hooks/useSafeNavigate';
+import createQueryParams from 'lib/createQueryParams';
+import { Query } from 'types/api/queryBuilder/queryBuilderData';
+
+import { getViewQuery } from './drilldownUtils';
+import { AggregateData } from './useAggregateDrilldown';
+
+type DrilldownKey = 'view_logs' | 'view_metrics' | 'view_traces';
+
+const DRILLDOWN_ROUTE_MAP: Record<DrilldownKey, string> = {
+	view_logs: ROUTES.LOGS_EXPLORER,
+	view_metrics: ROUTES.METRICS_EXPLORER,
+	view_traces: ROUTES.TRACES_EXPLORER,
+};
+
+const getRoute = (key: string): string =>
+	DRILLDOWN_ROUTE_MAP[key as DrilldownKey] ?? '';
+
+interface UseBaseDrilldownNavigateProps {
+	resolvedQuery: Query;
+	aggregateData: AggregateData | null;
+	callback?: () => void;
+}
+
+const useBaseDrilldownNavigate = ({
+	resolvedQuery,
+	aggregateData,
+	callback,
+}: UseBaseDrilldownNavigateProps): ((key: string) => void) => {
+	const { safeNavigate } = useSafeNavigate();
+
+	return useCallback(
+		(key: string): void => {
+			const route = getRoute(key);
+			const viewQuery = getViewQuery(
+				resolvedQuery,
+				aggregateData?.filters ?? [],
+				key,
+				aggregateData?.queryName ?? '',
+			);
+
+			if (!viewQuery || !route) {
+				callback?.();
+				return;
+			}
+
+			const timeRange = aggregateData?.timeRange;
+			let queryParams: Record<string, string> = {
+				[QueryParams.compositeQuery]: encodeURIComponent(JSON.stringify(viewQuery)),
+				...(timeRange && {
+					[QueryParams.startTime]: timeRange.startTime.toString(),
+					[QueryParams.endTime]: timeRange.endTime.toString(),
+				}),
+			};
+
+			if (route === ROUTES.METRICS_EXPLORER) {
+				queryParams = {
+					...queryParams,
+					[QueryParams.summaryFilters]: JSON.stringify(
+						viewQuery.builder.queryData[0].filters,
+					),
+				};
+			}
+
+			safeNavigate(`${route}?${createQueryParams(queryParams)}`, {
+				newTab: true,
+			});
+
+			callback?.();
+		},
+		[resolvedQuery, safeNavigate, callback, aggregateData],
+	);
+};
+
+export function buildDrilldownUrl(
+	resolvedQuery: Query,
+	aggregateData: AggregateData | null,
+	key: string,
+): string | null {
+	const route = getRoute(key);
+	const viewQuery = getViewQuery(
+		resolvedQuery,
+		aggregateData?.filters ?? [],
+		key,
+		aggregateData?.queryName ?? '',
+	);
+
+	if (!viewQuery || !route) {
+		return null;
+	}
+
+	const timeRange = aggregateData?.timeRange;
+	let queryParams: Record<string, string> = {
+		[QueryParams.compositeQuery]: encodeURIComponent(JSON.stringify(viewQuery)),
+		...(timeRange && {
+			[QueryParams.startTime]: timeRange.startTime.toString(),
+			[QueryParams.endTime]: timeRange.endTime.toString(),
+		}),
+	};
+
+	if (route === ROUTES.METRICS_EXPLORER) {
+		queryParams = {
+			...queryParams,
+			[QueryParams.summaryFilters]: JSON.stringify(
+				viewQuery.builder.queryData[0].filters,
+			),
+		};
+	}
+
+	return `${route}?${createQueryParams(queryParams)}`;
+}
+
+export { getRoute };
+export default useBaseDrilldownNavigate;

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

@@ -16,7 +16,6 @@ import (
 	"github.com/SigNoz/signoz/pkg/modules/cloudintegration"
 	"github.com/SigNoz/signoz/pkg/modules/dashboard"
 	"github.com/SigNoz/signoz/pkg/modules/fields"
-	"github.com/SigNoz/signoz/pkg/modules/inframonitoring"
 	"github.com/SigNoz/signoz/pkg/modules/metricsexplorer"
 	"github.com/SigNoz/signoz/pkg/modules/organization"
 	"github.com/SigNoz/signoz/pkg/modules/preference"
@@ -25,7 +24,6 @@ import (
 	"github.com/SigNoz/signoz/pkg/modules/rulestatehistory"
 	"github.com/SigNoz/signoz/pkg/modules/serviceaccount"
 	"github.com/SigNoz/signoz/pkg/modules/session"
-	"github.com/SigNoz/signoz/pkg/modules/spanattributemapping"
 	"github.com/SigNoz/signoz/pkg/modules/user"
 	"github.com/SigNoz/signoz/pkg/querier"
 	"github.com/SigNoz/signoz/pkg/ruler"
@@ -36,35 +34,33 @@ import (
 )
 
 type provider struct {
-	config                      apiserver.Config
-	settings                    factory.ScopedProviderSettings
-	router                      *mux.Router
-	authZ                       *middleware.AuthZ
-	orgHandler                  organization.Handler
-	userHandler                 user.Handler
-	sessionHandler              session.Handler
-	authDomainHandler           authdomain.Handler
-	preferenceHandler           preference.Handler
-	globalHandler               global.Handler
-	promoteHandler              promote.Handler
-	flaggerHandler              flagger.Handler
-	dashboardModule             dashboard.Module
-	dashboardHandler            dashboard.Handler
-	metricsExplorerHandler      metricsexplorer.Handler
-	infraMonitoringHandler      inframonitoring.Handler
-	gatewayHandler              gateway.Handler
-	fieldsHandler               fields.Handler
-	authzHandler                authz.Handler
-	rawDataExportHandler        rawdataexport.Handler
-	zeusHandler                 zeus.Handler
-	querierHandler              querier.Handler
-	serviceAccountHandler       serviceaccount.Handler
-	factoryHandler              factory.Handler
-	cloudIntegrationHandler     cloudintegration.Handler
-	ruleStateHistoryHandler     rulestatehistory.Handler
-	spanAttributeMappingHandler spanattributemapping.Handler
-	alertmanagerHandler         alertmanager.Handler
-	rulerHandler                ruler.Handler
+	config                  apiserver.Config
+	settings                factory.ScopedProviderSettings
+	router                  *mux.Router
+	authZ                   *middleware.AuthZ
+	orgHandler              organization.Handler
+	userHandler             user.Handler
+	sessionHandler          session.Handler
+	authDomainHandler       authdomain.Handler
+	preferenceHandler       preference.Handler
+	globalHandler           global.Handler
+	promoteHandler          promote.Handler
+	flaggerHandler          flagger.Handler
+	dashboardModule         dashboard.Module
+	dashboardHandler        dashboard.Handler
+	metricsExplorerHandler  metricsexplorer.Handler
+	gatewayHandler          gateway.Handler
+	fieldsHandler           fields.Handler
+	authzHandler            authz.Handler
+	rawDataExportHandler    rawdataexport.Handler
+	zeusHandler             zeus.Handler
+	querierHandler          querier.Handler
+	serviceAccountHandler   serviceaccount.Handler
+	factoryHandler          factory.Handler
+	cloudIntegrationHandler cloudintegration.Handler
+	ruleStateHistoryHandler rulestatehistory.Handler
+	alertmanagerHandler     alertmanager.Handler
+	rulerHandler            ruler.Handler
 }
 
 func NewFactory(
@@ -81,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,
@@ -92,7 +87,6 @@ func NewFactory(
 	factoryHandler factory.Handler,
 	cloudIntegrationHandler cloudintegration.Handler,
 	ruleStateHistoryHandler rulestatehistory.Handler,
-	spanAttributeMappingHandler spanattributemapping.Handler,
 	alertmanagerHandler alertmanager.Handler,
 	rulerHandler ruler.Handler,
 ) factory.ProviderFactory[apiserver.APIServer, apiserver.Config] {
@@ -114,7 +108,6 @@ func NewFactory(
 			dashboardModule,
 			dashboardHandler,
 			metricsExplorerHandler,
-			infraMonitoringHandler,
 			gatewayHandler,
 			fieldsHandler,
 			authzHandler,
@@ -125,7 +118,6 @@ func NewFactory(
 			factoryHandler,
 			cloudIntegrationHandler,
 			ruleStateHistoryHandler,
-			spanAttributeMappingHandler,
 			alertmanagerHandler,
 			rulerHandler,
 		)
@@ -149,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,
@@ -160,7 +151,6 @@ func newProvider(
 	factoryHandler factory.Handler,
 	cloudIntegrationHandler cloudintegration.Handler,
 	ruleStateHistoryHandler rulestatehistory.Handler,
-	spanAttributeMappingHandler spanattributemapping.Handler,
 	alertmanagerHandler alertmanager.Handler,
 	rulerHandler ruler.Handler,
 ) (apiserver.APIServer, error) {
@@ -168,34 +158,32 @@ func newProvider(
 	router := mux.NewRouter().UseEncodedPath()
 
 	provider := &provider{
-		config:                      config,
-		settings:                    settings,
-		router:                      router,
-		orgHandler:                  orgHandler,
-		userHandler:                 userHandler,
-		sessionHandler:              sessionHandler,
-		authDomainHandler:           authDomainHandler,
-		preferenceHandler:           preferenceHandler,
-		globalHandler:               globalHandler,
-		promoteHandler:              promoteHandler,
-		flaggerHandler:              flaggerHandler,
-		dashboardModule:             dashboardModule,
-		dashboardHandler:            dashboardHandler,
-		metricsExplorerHandler:      metricsExplorerHandler,
-		infraMonitoringHandler:      infraMonitoringHandler,
-		gatewayHandler:              gatewayHandler,
-		fieldsHandler:               fieldsHandler,
-		authzHandler:                authzHandler,
-		rawDataExportHandler:        rawDataExportHandler,
-		zeusHandler:                 zeusHandler,
-		querierHandler:              querierHandler,
-		serviceAccountHandler:       serviceAccountHandler,
-		factoryHandler:              factoryHandler,
-		cloudIntegrationHandler:     cloudIntegrationHandler,
-		ruleStateHistoryHandler:     ruleStateHistoryHandler,
-		spanAttributeMappingHandler: spanAttributeMappingHandler,
-		alertmanagerHandler:         alertmanagerHandler,
-		rulerHandler:                rulerHandler,
+		config:                  config,
+		settings:                settings,
+		router:                  router,
+		orgHandler:              orgHandler,
+		userHandler:             userHandler,
+		sessionHandler:          sessionHandler,
+		authDomainHandler:       authDomainHandler,
+		preferenceHandler:       preferenceHandler,
+		globalHandler:           globalHandler,
+		promoteHandler:          promoteHandler,
+		flaggerHandler:          flaggerHandler,
+		dashboardModule:         dashboardModule,
+		dashboardHandler:        dashboardHandler,
+		metricsExplorerHandler:  metricsExplorerHandler,
+		gatewayHandler:          gatewayHandler,
+		fieldsHandler:           fieldsHandler,
+		authzHandler:            authzHandler,
+		rawDataExportHandler:    rawDataExportHandler,
+		zeusHandler:             zeusHandler,
+		querierHandler:          querierHandler,
+		serviceAccountHandler:   serviceAccountHandler,
+		factoryHandler:          factoryHandler,
+		cloudIntegrationHandler: cloudIntegrationHandler,
+		ruleStateHistoryHandler: ruleStateHistoryHandler,
+		alertmanagerHandler:     alertmanagerHandler,
+		rulerHandler:            rulerHandler,
 	}
 
 	provider.authZ = middleware.NewAuthZ(settings.Logger(), orgGetter, authz)
@@ -252,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
 	}
@@ -300,10 +284,6 @@ func (provider *provider) AddToRouter(router *mux.Router) error {
 		return err
 	}
 
-	if err := provider.addSpanAttributeMappingRoutes(router); err != nil {
-		return err
-	}
-
 	if err := provider.addAlertmanagerRoutes(router); err != nil {
 		return err
 	}

pkg/apiserver/signozapiserver/spanattributemapping.go

@@ -1,171 +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/spanattributemappingtypes"
-	"github.com/gorilla/mux"
-)
-
-func (provider *provider) addSpanAttributeMappingRoutes(router *mux.Router) error {
-	if err := router.Handle("/api/v1/span_attribute_mapping_groups", handler.New(
-		provider.authZ.ViewAccess(provider.spanAttributeMappingHandler.ListGroups),
-		handler.OpenAPIDef{
-			ID:                  "ListSpanAttributeMappingGroups",
-			Tags:                []string{"span-attribute-mapping"},
-			Summary:             "List span attribute mapping groups",
-			Description:         "Returns all span attribute mapping groups for the authenticated org.",
-			Request:             nil,
-			RequestContentType:  "",
-			RequestQuery:        new(spanattributemappingtypes.ListGroupsQuery),
-			Response:            new(spanattributemappingtypes.GettableGroups),
-			ResponseContentType: "application/json",
-			SuccessStatusCode:   http.StatusOK,
-			ErrorStatusCodes:    []int{http.StatusBadRequest},
-			Deprecated:          false,
-			SecuritySchemes:     newSecuritySchemes(types.RoleViewer),
-		},
-	)).Methods(http.MethodGet).GetError(); err != nil {
-		return err
-	}
-
-	if err := router.Handle("/api/v1/span_attribute_mapping_groups", handler.New(
-		provider.authZ.AdminAccess(provider.spanAttributeMappingHandler.CreateGroup),
-		handler.OpenAPIDef{
-			ID:                  "CreateMappingGroup",
-			Tags:                []string{"span-attribute-mapping"},
-			Summary:             "Create a span attribute mapping group",
-			Description:         "Creates a new span attribute mapping group for the org.",
-			Request:             new(spanattributemappingtypes.PostableGroup),
-			RequestContentType:  "application/json",
-			Response:            new(spanattributemappingtypes.GettableGroup),
-			ResponseContentType: "application/json",
-			SuccessStatusCode:   http.StatusCreated,
-			ErrorStatusCodes:    []int{http.StatusBadRequest, http.StatusConflict},
-			Deprecated:          false,
-			SecuritySchemes:     newSecuritySchemes(types.RoleAdmin),
-		},
-	)).Methods(http.MethodPost).GetError(); err != nil {
-		return err
-	}
-
-	if err := router.Handle("/api/v1/span_attribute_mapping_groups/{groupId}", handler.New(
-		provider.authZ.AdminAccess(provider.spanAttributeMappingHandler.UpdateGroup),
-		handler.OpenAPIDef{
-			ID:                 "UpdateMappingGroup",
-			Tags:               []string{"span-attribute-mapping"},
-			Summary:            "Update a span attribute mapping group",
-			Description:        "Partially updates an existing mapping group's name, condition, or enabled state.",
-			Request:            new(spanattributemappingtypes.UpdatableGroup),
-			RequestContentType: "application/json",
-			SuccessStatusCode:  http.StatusNoContent,
-			ErrorStatusCodes:   []int{http.StatusBadRequest, http.StatusNotFound},
-			Deprecated:         false,
-			SecuritySchemes:    newSecuritySchemes(types.RoleAdmin),
-		},
-	)).Methods(http.MethodPatch).GetError(); err != nil {
-		return err
-	}
-
-	if err := router.Handle("/api/v1/span_attribute_mapping_groups/{groupId}", handler.New(
-		provider.authZ.AdminAccess(provider.spanAttributeMappingHandler.DeleteGroup),
-		handler.OpenAPIDef{
-			ID:                  "DeleteMappingGroup",
-			Tags:                []string{"span-attribute-mapping"},
-			Summary:             "Delete a span attribute mapping group",
-			Description:         "Hard-deletes a mapping group and cascades to all its mappers.",
-			Request:             nil,
-			RequestContentType:  "",
-			Response:            nil,
-			ResponseContentType: "",
-			SuccessStatusCode:   http.StatusNoContent,
-			ErrorStatusCodes:    []int{http.StatusNotFound},
-			Deprecated:          false,
-			SecuritySchemes:     newSecuritySchemes(types.RoleAdmin),
-		},
-	)).Methods(http.MethodDelete).GetError(); err != nil {
-		return err
-	}
-
-	if err := router.Handle("/api/v1/span_attribute_mapping_groups/{groupId}/mappers", handler.New(
-		provider.authZ.ViewAccess(provider.spanAttributeMappingHandler.ListMappers),
-		handler.OpenAPIDef{
-			ID:                  "ListMappers",
-			Tags:                []string{"span-attribute-mapping"},
-			Summary:             "List span attribute mappers for a group",
-			Description:         "Returns all attribute mappers belonging to a mapping group.",
-			Request:             nil,
-			RequestContentType:  "",
-			Response:            new(spanattributemappingtypes.GettableMappers),
-			ResponseContentType: "application/json",
-			SuccessStatusCode:   http.StatusOK,
-			ErrorStatusCodes:    []int{http.StatusBadRequest, http.StatusNotFound},
-			Deprecated:          false,
-			SecuritySchemes:     newSecuritySchemes(types.RoleViewer),
-		},
-	)).Methods(http.MethodGet).GetError(); err != nil {
-		return err
-	}
-
-	if err := router.Handle("/api/v1/span_attribute_mapping_groups/{groupId}/mappers", handler.New(
-		provider.authZ.AdminAccess(provider.spanAttributeMappingHandler.CreateMapper),
-		handler.OpenAPIDef{
-			ID:                  "CreateMapper",
-			Tags:                []string{"span-attribute-mapping"},
-			Summary:             "Create a span attribute mapper",
-			Description:         "Adds a new attribute mapper to the specified mapping group.",
-			Request:             new(spanattributemappingtypes.PostableMapper),
-			RequestContentType:  "application/json",
-			Response:            new(spanattributemappingtypes.GettableMapper),
-			ResponseContentType: "application/json",
-			SuccessStatusCode:   http.StatusCreated,
-			ErrorStatusCodes:    []int{http.StatusBadRequest, http.StatusNotFound, http.StatusConflict},
-			Deprecated:          false,
-			SecuritySchemes:     newSecuritySchemes(types.RoleAdmin),
-		},
-	)).Methods(http.MethodPost).GetError(); err != nil {
-		return err
-	}
-
-	if err := router.Handle("/api/v1/span_attribute_mapping_groups/{groupId}/mappers/{mapperId}", handler.New(
-		provider.authZ.AdminAccess(provider.spanAttributeMappingHandler.UpdateMapper),
-		handler.OpenAPIDef{
-			ID:                 "UpdateMapper",
-			Tags:               []string{"span-attribute-mapping"},
-			Summary:            "Update a span attribute mapper",
-			Description:        "Partially updates an existing mapper's field context, config, or enabled state.",
-			Request:            new(spanattributemappingtypes.UpdatableMapper),
-			RequestContentType: "application/json",
-			SuccessStatusCode:  http.StatusNoContent,
-			ErrorStatusCodes:   []int{http.StatusBadRequest, http.StatusNotFound},
-			Deprecated:         false,
-			SecuritySchemes:    newSecuritySchemes(types.RoleAdmin),
-		},
-	)).Methods(http.MethodPatch).GetError(); err != nil {
-		return err
-	}
-
-	if err := router.Handle("/api/v1/span_attribute_mapping_groups/{groupId}/mappers/{mapperId}", handler.New(
-		provider.authZ.AdminAccess(provider.spanAttributeMappingHandler.DeleteMapper),
-		handler.OpenAPIDef{
-			ID:                  "DeleteMapper",
-			Tags:                []string{"span-attribute-mapping"},
-			Summary:             "Delete a span attribute mapper",
-			Description:         "Hard-deletes a mapper from a mapping group.",
-			Request:             nil,
-			RequestContentType:  "",
-			Response:            nil,
-			ResponseContentType: "",
-			SuccessStatusCode:   http.StatusNoContent,
-			ErrorStatusCodes:    []int{http.StatusNotFound},
-			Deprecated:          false,
-			SecuritySchemes:     newSecuritySchemes(types.RoleAdmin),
-		},
-	)).Methods(http.MethodDelete).GetError(); err != nil {
-		return err
-	}
-
-	return nil
-}

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/modules/spanattributemapping/implspanattributemapping/handler.go

@@ -1,333 +0,0 @@
-package implspanattributemapping
-
-import (
-	"context"
-	"net/http"
-	"time"
-
-	"github.com/SigNoz/signoz/pkg/errors"
-	"github.com/SigNoz/signoz/pkg/factory"
-	"github.com/SigNoz/signoz/pkg/http/binding"
-	"github.com/SigNoz/signoz/pkg/http/render"
-	"github.com/SigNoz/signoz/pkg/modules/spanattributemapping"
-	"github.com/SigNoz/signoz/pkg/types/authtypes"
-	"github.com/SigNoz/signoz/pkg/types/spanattributemappingtypes"
-	"github.com/SigNoz/signoz/pkg/valuer"
-	"github.com/gorilla/mux"
-)
-
-type handler struct {
-	module           spanattributemapping.Module
-	providerSettings factory.ProviderSettings
-}
-
-func NewHandler(module spanattributemapping.Module, providerSettings factory.ProviderSettings) spanattributemapping.Handler {
-	return &handler{module: module, providerSettings: providerSettings}
-}
-
-// ListGroups handles GET /api/v1/span_attribute_mapping_groups.
-func (h *handler) ListGroups(rw http.ResponseWriter, r *http.Request) {
-	ctx, cancel := context.WithTimeout(r.Context(), 10*time.Second)
-	defer cancel()
-
-	claims, err := authtypes.ClaimsFromContext(ctx)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	orgID, err := valuer.NewUUID(claims.OrgID)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	var q spanattributemappingtypes.ListGroupsQuery
-	if err := binding.Query.BindQuery(r.URL.Query(), &q); err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	groups, err := h.module.ListGroups(ctx, orgID, &q)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	render.Success(rw, http.StatusOK, spanattributemappingtypes.NewGettableGroups(groups))
-}
-
-// CreateGroup handles POST /api/v1/span_attribute_mapping_groups.
-func (h *handler) CreateGroup(rw http.ResponseWriter, r *http.Request) {
-	ctx, cancel := context.WithTimeout(r.Context(), 10*time.Second)
-	defer cancel()
-
-	claims, err := authtypes.ClaimsFromContext(ctx)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	orgID, err := valuer.NewUUID(claims.OrgID)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	req := new(spanattributemappingtypes.PostableGroup)
-	if err := binding.JSON.BindBody(r.Body, req); err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	group := spanattributemappingtypes.NewGroupFromPostable(req)
-
-	err = h.module.CreateGroup(ctx, orgID, claims.Email, group)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-	render.Success(rw, http.StatusCreated, group)
-}
-
-// UpdateGroup handles PUT /api/v1/span_attribute_mapping_groups/{id}.
-func (h *handler) UpdateGroup(rw http.ResponseWriter, r *http.Request) {
-	ctx, cancel := context.WithTimeout(r.Context(), 10*time.Second)
-	defer cancel()
-
-	claims, err := authtypes.ClaimsFromContext(ctx)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	orgID, err := valuer.NewUUID(claims.OrgID)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	id, err := groupIDFromPath(r)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	req := new(spanattributemappingtypes.UpdatableGroup)
-	if err := binding.JSON.BindBody(r.Body, req); err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	err = h.module.UpdateGroup(ctx, orgID, id, claims.Email, spanattributemappingtypes.NewGroupFromUpdatable(req))
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	render.Success(rw, http.StatusNoContent, nil)
-}
-
-// DeleteGroup handles DELETE /api/v1/span_attribute_mapping_groups/{id}.
-func (h *handler) DeleteGroup(rw http.ResponseWriter, r *http.Request) {
-	ctx, cancel := context.WithTimeout(r.Context(), 10*time.Second)
-	defer cancel()
-
-	claims, err := authtypes.ClaimsFromContext(ctx)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	orgID, err := valuer.NewUUID(claims.OrgID)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	id, err := groupIDFromPath(r)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	if err := h.module.DeleteGroup(ctx, orgID, id); err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	render.Success(rw, http.StatusNoContent, nil)
-}
-
-// ListMappers handles GET /api/v1/span_attribute_mapping_groups/{id}/mappers.
-func (h *handler) ListMappers(rw http.ResponseWriter, r *http.Request) {
-	ctx, cancel := context.WithTimeout(r.Context(), 10*time.Second)
-	defer cancel()
-
-	claims, err := authtypes.ClaimsFromContext(ctx)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	orgID, err := valuer.NewUUID(claims.OrgID)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	groupID, err := groupIDFromPath(r)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	mappers, err := h.module.ListMappers(ctx, orgID, groupID)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	render.Success(rw, http.StatusOK, spanattributemappingtypes.NewGettableMappers(mappers))
-}
-
-// CreateMapper handles POST /api/v1/span_attribute_mapping_groups/{id}/mappers.
-func (h *handler) CreateMapper(rw http.ResponseWriter, r *http.Request) {
-	ctx, cancel := context.WithTimeout(r.Context(), 10*time.Second)
-	defer cancel()
-
-	claims, err := authtypes.ClaimsFromContext(ctx)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	orgID, err := valuer.NewUUID(claims.OrgID)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	groupID, err := groupIDFromPath(r)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	req := new(spanattributemappingtypes.PostableMapper)
-	if err := binding.JSON.BindBody(r.Body, req); err != nil {
-		render.Error(rw, err)
-		return
-	}
-	mapper := spanattributemappingtypes.NewMapperFromPostable(req)
-
-	err = h.module.CreateMapper(ctx, orgID, groupID, claims.Email, mapper)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	render.Success(rw, http.StatusCreated, mapper)
-}
-
-// UpdateMapper handles PUT /api/v1/span_attribute_mapping_groups/{groupId}/mappers/{mapperId}.
-func (h *handler) UpdateMapper(rw http.ResponseWriter, r *http.Request) {
-	ctx, cancel := context.WithTimeout(r.Context(), 10*time.Second)
-	defer cancel()
-
-	claims, err := authtypes.ClaimsFromContext(ctx)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	orgID, err := valuer.NewUUID(claims.OrgID)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	groupID, err := groupIDFromPath(r)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	mapperID, err := mapperIDFromPath(r)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	req := new(spanattributemappingtypes.UpdatableMapper)
-	if err := binding.JSON.BindBody(r.Body, req); err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	err = h.module.UpdateMapper(ctx, orgID, groupID, mapperID, claims.Email, spanattributemappingtypes.NewMapperFromUpdatable(req))
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	render.Success(rw, http.StatusNoContent, nil)
-}
-
-// DeleteMapper handles DELETE /api/v1/span_attribute_mapping_groups/{groupId}/mappers/{mapperId}.
-func (h *handler) DeleteMapper(rw http.ResponseWriter, r *http.Request) {
-	ctx, cancel := context.WithTimeout(r.Context(), 10*time.Second)
-	defer cancel()
-
-	claims, err := authtypes.ClaimsFromContext(ctx)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	orgID, err := valuer.NewUUID(claims.OrgID)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	groupID, err := groupIDFromPath(r)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	mapperID, err := mapperIDFromPath(r)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	if err := h.module.DeleteMapper(ctx, orgID, groupID, mapperID); err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	render.Success(rw, http.StatusNoContent, nil)
-}
-
-// groupIDFromPath extracts and validates the {id} or {groupId} path variable.
-func groupIDFromPath(r *http.Request) (valuer.UUID, error) {
-	vars := mux.Vars(r)
-	raw := vars["groupId"]
-	id, err := valuer.NewUUID(raw)
-	if err != nil {
-		return valuer.UUID{}, errors.Wrapf(err, errors.TypeInvalidInput, spanattributemappingtypes.ErrCodeMappingInvalidInput, "group id is not a valid uuid")
-	}
-	return id, nil
-}
-
-// mapperIDFromPath extracts and validates the {mapperId} path variable.
-func mapperIDFromPath(r *http.Request) (valuer.UUID, error) {
-	raw := mux.Vars(r)["mapperId"]
-	id, err := valuer.NewUUID(raw)
-	if err != nil {
-		return valuer.UUID{}, errors.Wrapf(err, errors.TypeInvalidInput, spanattributemappingtypes.ErrCodeMappingInvalidInput, "mapper id is not a valid uuid")
-	}
-	return id, nil
-}

pkg/modules/spanattributemapping/spanattributemapping.go

@@ -1,41 +0,0 @@
-package spanattributemapping
-
-import (
-	"context"
-	"net/http"
-
-	"github.com/SigNoz/signoz/pkg/types/spanattributemappingtypes"
-	"github.com/SigNoz/signoz/pkg/valuer"
-)
-
-// Module defines the business logic for span attribute mapping groups and mappers.
-type Module interface {
-	// Group operations
-	ListGroups(ctx context.Context, orgID valuer.UUID, q *spanattributemappingtypes.ListGroupsQuery) ([]*spanattributemappingtypes.Group, error)
-	GetGroup(ctx context.Context, orgID valuer.UUID, id valuer.UUID) (*spanattributemappingtypes.Group, error)
-	CreateGroup(ctx context.Context, orgID valuer.UUID, createdBy string, group *spanattributemappingtypes.Group) error
-	UpdateGroup(ctx context.Context, orgID valuer.UUID, id valuer.UUID, updatedBy string, group *spanattributemappingtypes.Group) error
-	DeleteGroup(ctx context.Context, orgID valuer.UUID, id valuer.UUID) error
-
-	// Mapper operations
-	ListMappers(ctx context.Context, orgID valuer.UUID, groupID valuer.UUID) ([]*spanattributemappingtypes.Mapper, error)
-	GetMapper(ctx context.Context, orgID valuer.UUID, groupID valuer.UUID, id valuer.UUID) (*spanattributemappingtypes.Mapper, error)
-	CreateMapper(ctx context.Context, orgID valuer.UUID, groupID valuer.UUID, createdBy string, mapper *spanattributemappingtypes.Mapper) error
-	UpdateMapper(ctx context.Context, orgID valuer.UUID, groupID valuer.UUID, id valuer.UUID, updatedBy string, mapper *spanattributemappingtypes.Mapper) error
-	DeleteMapper(ctx context.Context, orgID valuer.UUID, groupID valuer.UUID, id valuer.UUID) error
-}
-
-// Handler defines the HTTP handler interface for mapping group and mapper endpoints.
-type Handler interface {
-	// Group handlers
-	ListGroups(rw http.ResponseWriter, r *http.Request)
-	CreateGroup(rw http.ResponseWriter, r *http.Request)
-	UpdateGroup(rw http.ResponseWriter, r *http.Request)
-	DeleteGroup(rw http.ResponseWriter, r *http.Request)
-
-	// Mapper handlers
-	ListMappers(rw http.ResponseWriter, r *http.Request)
-	CreateMapper(rw http.ResponseWriter, r *http.Request)
-	UpdateMapper(rw http.ResponseWriter, r *http.Request)
-	DeleteMapper(rw http.ResponseWriter, r *http.Request)
-}

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

@@ -3,6 +3,8 @@ package signoz
 import (
 	"github.com/SigNoz/signoz/pkg/alertmanager"
 	"github.com/SigNoz/signoz/pkg/alertmanager/signozalertmanager"
+	"github.com/SigNoz/signoz/pkg/ruler"
+	"github.com/SigNoz/signoz/pkg/ruler/signozruler"
 	"github.com/SigNoz/signoz/pkg/analytics"
 	"github.com/SigNoz/signoz/pkg/authz"
 	"github.com/SigNoz/signoz/pkg/authz/signozauthzapi"
@@ -20,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"
@@ -36,44 +36,38 @@ import (
 	"github.com/SigNoz/signoz/pkg/modules/serviceaccount/implserviceaccount"
 	"github.com/SigNoz/signoz/pkg/modules/services"
 	"github.com/SigNoz/signoz/pkg/modules/services/implservices"
-	"github.com/SigNoz/signoz/pkg/modules/spanattributemapping"
-	"github.com/SigNoz/signoz/pkg/modules/spanattributemapping/implspanattributemapping"
 	"github.com/SigNoz/signoz/pkg/modules/spanpercentile"
 	"github.com/SigNoz/signoz/pkg/modules/spanpercentile/implspanpercentile"
 	"github.com/SigNoz/signoz/pkg/modules/tracefunnel"
 	"github.com/SigNoz/signoz/pkg/modules/tracefunnel/impltracefunnel"
 	"github.com/SigNoz/signoz/pkg/querier"
-	"github.com/SigNoz/signoz/pkg/ruler"
-	"github.com/SigNoz/signoz/pkg/ruler/signozruler"
 	"github.com/SigNoz/signoz/pkg/types/telemetrytypes"
 	"github.com/SigNoz/signoz/pkg/zeus"
 )
 
 type Handlers struct {
-	SavedView                  savedview.Handler
-	Apdex                      apdex.Handler
-	Dashboard                  dashboard.Handler
-	QuickFilter                quickfilter.Handler
-	TraceFunnel                tracefunnel.Handler
-	RawDataExport              rawdataexport.Handler
-	SpanPercentile             spanpercentile.Handler
-	Services                   services.Handler
-	MetricsExplorer            metricsexplorer.Handler
-	InfraMonitoring            inframonitoring.Handler
-	Global                     global.Handler
-	FlaggerHandler             flagger.Handler
-	GatewayHandler             gateway.Handler
-	Fields                     fields.Handler
-	AuthzHandler               authz.Handler
-	ZeusHandler                zeus.Handler
-	QuerierHandler             querier.Handler
-	ServiceAccountHandler      serviceaccount.Handler
-	RegistryHandler            factory.Handler
-	CloudIntegrationHandler    cloudintegration.Handler
-	RuleStateHistory           rulestatehistory.Handler
-	SpanAttributeMappingHander spanattributemapping.Handler
-	AlertmanagerHandler        alertmanager.Handler
-	RulerHandler               ruler.Handler
+	SavedView               savedview.Handler
+	Apdex                   apdex.Handler
+	Dashboard               dashboard.Handler
+	QuickFilter             quickfilter.Handler
+	TraceFunnel             tracefunnel.Handler
+	RawDataExport           rawdataexport.Handler
+	SpanPercentile          spanpercentile.Handler
+	Services                services.Handler
+	MetricsExplorer         metricsexplorer.Handler
+	Global                  global.Handler
+	FlaggerHandler          flagger.Handler
+	GatewayHandler          gateway.Handler
+	Fields                  fields.Handler
+	AuthzHandler            authz.Handler
+	ZeusHandler             zeus.Handler
+	QuerierHandler          querier.Handler
+	ServiceAccountHandler   serviceaccount.Handler
+	RegistryHandler         factory.Handler
+	CloudIntegrationHandler cloudintegration.Handler
+	RuleStateHistory        rulestatehistory.Handler
+	AlertmanagerHandler     alertmanager.Handler
+	RulerHandler            ruler.Handler
 }
 
 func NewHandlers(
@@ -93,29 +87,27 @@ func NewHandlers(
 	rulerService ruler.Ruler,
 ) Handlers {
 	return Handlers{
-		SavedView:                  implsavedview.NewHandler(modules.SavedView),
-		Apdex:                      implapdex.NewHandler(modules.Apdex),
-		Dashboard:                  impldashboard.NewHandler(modules.Dashboard, providerSettings, authz),
-		QuickFilter:                implquickfilter.NewHandler(modules.QuickFilter),
-		TraceFunnel:                impltracefunnel.NewHandler(modules.TraceFunnel),
-		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),
-		GatewayHandler:             gateway.NewHandler(gatewayService),
-		Fields:                     implfields.NewHandler(providerSettings, telemetryMetadataStore),
-		AuthzHandler:               signozauthzapi.NewHandler(authz),
-		ZeusHandler:                zeus.NewHandler(zeusService, licensing),
-		QuerierHandler:             querierHandler,
-		ServiceAccountHandler:      implserviceaccount.NewHandler(modules.ServiceAccount),
-		RegistryHandler:            registryHandler,
-		RuleStateHistory:           implrulestatehistory.NewHandler(modules.RuleStateHistory),
-		CloudIntegrationHandler:    implcloudintegration.NewHandler(modules.CloudIntegration),
-		SpanAttributeMappingHander: implspanattributemapping.NewHandler(nil, providerSettings), // todo(nitya): will update this in future PR
-		AlertmanagerHandler:        signozalertmanager.NewHandler(alertmanagerService),
-		RulerHandler:               signozruler.NewHandler(rulerService),
+		SavedView:               implsavedview.NewHandler(modules.SavedView),
+		Apdex:                   implapdex.NewHandler(modules.Apdex),
+		Dashboard:               impldashboard.NewHandler(modules.Dashboard, providerSettings, authz),
+		QuickFilter:             implquickfilter.NewHandler(modules.QuickFilter),
+		TraceFunnel:             impltracefunnel.NewHandler(modules.TraceFunnel),
+		RawDataExport:           implrawdataexport.NewHandler(modules.RawDataExport),
+		Services:                implservices.NewHandler(modules.Services),
+		MetricsExplorer:         implmetricsexplorer.NewHandler(modules.MetricsExplorer),
+		SpanPercentile:          implspanpercentile.NewHandler(modules.SpanPercentile),
+		Global:                  signozglobal.NewHandler(global),
+		FlaggerHandler:          flagger.NewHandler(flaggerService),
+		GatewayHandler:          gateway.NewHandler(gatewayService),
+		Fields:                  implfields.NewHandler(providerSettings, telemetryMetadataStore),
+		AuthzHandler:            signozauthzapi.NewHandler(authz),
+		ZeusHandler:             zeus.NewHandler(zeusService, licensing),
+		QuerierHandler:          querierHandler,
+		ServiceAccountHandler:   implserviceaccount.NewHandler(modules.ServiceAccount),
+		RegistryHandler:         registryHandler,
+		RuleStateHistory:        implrulestatehistory.NewHandler(modules.RuleStateHistory),
+		CloudIntegrationHandler: implcloudintegration.NewHandler(modules.CloudIntegration),
+		AlertmanagerHandler:     signozalertmanager.NewHandler(alertmanagerService),
+		RulerHandler:            signozruler.NewHandler(rulerService),
 	}
 }

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"
@@ -30,7 +29,6 @@ import (
 	"github.com/SigNoz/signoz/pkg/modules/rulestatehistory"
 	"github.com/SigNoz/signoz/pkg/modules/serviceaccount"
 	"github.com/SigNoz/signoz/pkg/modules/session"
-	"github.com/SigNoz/signoz/pkg/modules/spanattributemapping"
 	"github.com/SigNoz/signoz/pkg/modules/user"
 	"github.com/SigNoz/signoz/pkg/querier"
 	"github.com/SigNoz/signoz/pkg/ruler"
@@ -63,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 }{},
@@ -74,7 +71,6 @@ func NewOpenAPI(ctx context.Context, instrumentation instrumentation.Instrumenta
 		struct{ factory.Handler }{},
 		struct{ cloudintegration.Handler }{},
 		struct{ rulestatehistory.Handler }{},
-		struct{ spanattributemapping.Handler }{},
 		struct{ alertmanager.Handler }{},
 		struct{ ruler.Handler }{},
 	).New(ctx, instrumentation.ToProviderSettings(), apiserver.Config{})

pkg/signoz/provider.go

@@ -3,6 +3,8 @@ package signoz
 import (
 	"github.com/SigNoz/signoz/pkg/alertmanager"
 	"github.com/SigNoz/signoz/pkg/alertmanager/nfmanager"
+	"github.com/SigNoz/signoz/pkg/auditor"
+	"github.com/SigNoz/signoz/pkg/auditor/noopauditor"
 	"github.com/SigNoz/signoz/pkg/alertmanager/nfmanager/rulebasednotification"
 	"github.com/SigNoz/signoz/pkg/alertmanager/signozalertmanager"
 	"github.com/SigNoz/signoz/pkg/analytics"
@@ -10,8 +12,6 @@ import (
 	"github.com/SigNoz/signoz/pkg/analytics/segmentanalytics"
 	"github.com/SigNoz/signoz/pkg/apiserver"
 	"github.com/SigNoz/signoz/pkg/apiserver/signozapiserver"
-	"github.com/SigNoz/signoz/pkg/auditor"
-	"github.com/SigNoz/signoz/pkg/auditor/noopauditor"
 	"github.com/SigNoz/signoz/pkg/authz"
 	"github.com/SigNoz/signoz/pkg/cache"
 	"github.com/SigNoz/signoz/pkg/cache/memorycache"
@@ -227,6 +227,8 @@ func NewAlertmanagerProviderFactories(sqlstore sqlstore.SQLStore, orgGetter orga
 	)
 }
 
+
+
 func NewEmailingProviderFactories() factory.NamedMap[factory.ProviderFactory[emailing.Emailing, emailing.Config]] {
 	return factory.MustNewNamedMap(
 		noopemailing.NewFactory(),
@@ -270,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,
@@ -281,7 +282,6 @@ func NewAPIServerProviderFactories(orgGetter organization.Getter, authz authz.Au
 			handlers.RegistryHandler,
 			handlers.CloudIntegrationHandler,
 			handlers.RuleStateHistory,
-			handlers.SpanAttributeMappingHander,
 			handlers.AlertmanagerHandler,
 			handlers.RulerHandler,
 		),

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/spanattributemappingtypes/group.go

@@ -1,109 +0,0 @@
-package spanattributemappingtypes
-
-import (
-	"github.com/SigNoz/signoz/pkg/errors"
-	"github.com/SigNoz/signoz/pkg/types"
-	"github.com/SigNoz/signoz/pkg/valuer"
-)
-
-var (
-	ErrCodeMappingGroupNotFound      = errors.MustNewCode("span_attribute_mapping_group_not_found")
-	ErrCodeMappingGroupAlreadyExists = errors.MustNewCode("span_attribute_mapping_group_already_exists")
-)
-
-// GroupCategory defaults will be llm, tool, agent but user can configure more as they want.
-type GroupCategory valuer.String
-
-// A group runs when any of the listed attribute/resource key patterns match.
-type Condition struct {
-	Attributes []string `json:"attributes" required:"true" nullable:"true"`
-	Resource   []string `json:"resource" required:"true" nullable:"true"`
-}
-
-// Group is the domain model for a span attribute mapping group.
-type Group struct {
-	types.TimeAuditable
-	types.UserAuditable
-
-	ID        valuer.UUID   `json:"id" required:"true"`
-	OrgID     valuer.UUID   `json:"orgId" required:"true"`
-	Name      string        `json:"name" required:"true"`
-	Category  GroupCategory `json:"category" required:"true"`
-	Condition Condition     `json:"condition" required:"true"`
-	Enabled   bool          `json:"enabled" required:"true"`
-}
-
-// GettableGroup is the HTTP response representation of a mapping group.
-type GettableGroup = Group
-
-type PostableGroup struct {
-	Name      string        `json:"name"      required:"true"`
-	Category  GroupCategory `json:"category"  required:"true"`
-	Condition Condition     `json:"condition" required:"true"`
-	Enabled   bool          `json:"enabled"`
-}
-
-// UpdatableGroup is the HTTP request body for updating a mapping group.
-// All fields are optional; only non-nil fields are applied.
-type UpdatableGroup struct {
-	Name      *string    `json:"name,omitempty"`
-	Condition *Condition `json:"condition,omitempty"`
-	Enabled   *bool      `json:"enabled,omitempty"`
-}
-
-type ListGroupsQuery struct {
-	Category *GroupCategory `query:"category"`
-	Enabled  *bool          `query:"enabled"`
-}
-
-type GettableGroups struct {
-	Items []*GettableGroup `json:"items" required:"true" nullable:"false"`
-}
-
-func NewGroupFromStorable(s *StorableGroup) *Group {
-	return &Group{
-		TimeAuditable: s.TimeAuditable,
-		UserAuditable: s.UserAuditable,
-		ID:            s.ID,
-		OrgID:         s.OrgID,
-		Name:          s.Name,
-		Category:      s.Category,
-		Condition:     s.Condition,
-		Enabled:       s.Enabled,
-	}
-}
-
-func NewGroupFromPostable(p *PostableGroup) *Group {
-	return &Group{
-		Name:      p.Name,
-		Category:  p.Category,
-		Condition: p.Condition,
-		Enabled:   p.Enabled,
-	}
-}
-
-func NewGroupFromUpdatable(u *UpdatableGroup) *Group {
-	g := &Group{}
-	if u.Name != nil {
-		g.Name = *u.Name
-	}
-	if u.Condition != nil {
-		g.Condition = *u.Condition
-	}
-	if u.Enabled != nil {
-		g.Enabled = *u.Enabled
-	}
-	return g
-}
-
-func NewGroupsFromStorableGroups(ss []*StorableGroup) []*Group {
-	groups := make([]*Group, len(ss))
-	for i, s := range ss {
-		groups[i] = NewGroupFromStorable(s)
-	}
-	return groups
-}
-
-func NewGettableGroups(g []*Group) *GettableGroups {
-	return &GettableGroups{Items: g}
-}

pkg/types/spanattributemappingtypes/mapper.go

@@ -1,137 +0,0 @@
-package spanattributemappingtypes
-
-import (
-	"github.com/SigNoz/signoz/pkg/errors"
-	"github.com/SigNoz/signoz/pkg/types"
-	"github.com/SigNoz/signoz/pkg/valuer"
-)
-
-var (
-	ErrCodeMapperNotFound      = errors.MustNewCode("span_attribute_mapper_not_found")
-	ErrCodeMapperAlreadyExists = errors.MustNewCode("span_attribute_mapper_already_exists")
-	ErrCodeMappingInvalidInput = errors.MustNewCode("span_attribute_mapping_invalid_input")
-)
-
-// FieldContext is where the target attribute is written.
-type FieldContext struct {
-	valuer.String
-}
-
-var (
-	FieldContextSpanAttribute = FieldContext{valuer.NewString("attribute")}
-	FieldContextResource      = FieldContext{valuer.NewString("resource")}
-)
-
-// MapperOperation determines whether the source attribute is moved (deleted) or copied.
-type MapperOperation struct {
-	valuer.String
-}
-
-var (
-	MapperOperationMove = MapperOperation{valuer.NewString("move")}
-	MapperOperationCopy = MapperOperation{valuer.NewString("copy")}
-)
-
-// MapperSource describes one candidate source for a target attribute.
-type MapperSource struct {
-	Key       string          `json:"key" required:"true"`
-	Context   FieldContext    `json:"context" required:"true"`
-	Operation MapperOperation `json:"operation" required:"true"`
-	Priority  int             `json:"priority" required:"true"`
-}
-
-// MapperConfig holds the mapping logic for a single target attribute.
-// It implements driver.Valuer and sql.Scanner for JSON text column storage.
-type MapperConfig struct {
-	Sources []MapperSource `json:"sources" required:"true" nullable:"true"`
-}
-
-// Mapper is the domain model for a span attribute mapper.
-type Mapper struct {
-	types.TimeAuditable
-	types.UserAuditable
-
-	ID           valuer.UUID  `json:"id"            required:"true"`
-	GroupID      valuer.UUID  `json:"group_id"      required:"true"`
-	Name         string       `json:"name"          required:"true"`
-	FieldContext FieldContext `json:"field_context" required:"true"`
-	Config       MapperConfig `json:"config"        required:"true"`
-	Enabled      bool         `json:"enabled"       required:"true"`
-}
-
-type PostableMapper struct {
-	Name         string       `json:"name"          required:"true"`
-	FieldContext FieldContext `json:"field_context" required:"true"`
-	Config       MapperConfig `json:"config"        required:"true"`
-	Enabled      bool         `json:"enabled"`
-}
-
-// UpdatableMapper is the HTTP request body for updating a mapper.
-// All fields are optional; only non-nil fields are applied.
-type UpdatableMapper struct {
-	FieldContext FieldContext  `json:"field_context,omitempty"`
-	Config       *MapperConfig `json:"config,omitempty"`
-	Enabled      *bool         `json:"enabled,omitempty"`
-}
-
-type GettableMapper = Mapper
-
-type GettableMappers struct {
-	Items []*GettableMapper `json:"items" required:"true" nullable:"false"`
-}
-
-func (FieldContext) Enum() []any {
-	return []any{FieldContextSpanAttribute, FieldContextResource}
-}
-
-func (MapperOperation) Enum() []any {
-	return []any{MapperOperationMove, MapperOperationCopy}
-}
-
-func NewMapperFromStorable(s *StorableMapper) *Mapper {
-	return &Mapper{
-		TimeAuditable: s.TimeAuditable,
-		UserAuditable: s.UserAuditable,
-		ID:            s.ID,
-		GroupID:       s.GroupID,
-		Name:          s.Name,
-		FieldContext:  s.FieldContext,
-		Config:        s.Config,
-		Enabled:       s.Enabled,
-	}
-}
-
-func NewMapperFromPostable(req *PostableMapper) *Mapper {
-	return &Mapper{
-		Name:         req.Name,
-		FieldContext: req.FieldContext,
-		Config:       req.Config,
-		Enabled:      req.Enabled,
-	}
-}
-
-func NewMapperFromUpdatable(req *UpdatableMapper) *Mapper {
-	m := &Mapper{}
-	if req.FieldContext != (FieldContext{}) {
-		m.FieldContext = req.FieldContext
-	}
-	if req.Config != nil {
-		m.Config = *req.Config
-	}
-	if req.Enabled != nil {
-		m.Enabled = *req.Enabled
-	}
-	return m
-}
-
-func NewMappersFromStorableMappers(ss []*StorableMapper) []*Mapper {
-	mappers := make([]*Mapper, len(ss))
-	for i, s := range ss {
-		mappers[i] = NewMapperFromStorable(s)
-	}
-	return mappers
-}
-
-func NewGettableMappers(m []*Mapper) *GettableMappers {
-	return &GettableMappers{Items: m}
-}

pkg/types/spanattributemappingtypes/storable.go

@@ -1,87 +0,0 @@
-package spanattributemappingtypes
-
-import (
-	"database/sql/driver"
-	"encoding/json"
-
-	"github.com/SigNoz/signoz/pkg/errors"
-	"github.com/SigNoz/signoz/pkg/types"
-	"github.com/SigNoz/signoz/pkg/valuer"
-	"github.com/uptrace/bun"
-)
-
-type StorableGroup struct {
-	bun.BaseModel `bun:"table:span_attribute_mapping_group,alias:span_attribute_mapping_group"`
-
-	types.Identifiable
-	types.TimeAuditable
-	types.UserAuditable
-
-	OrgID     valuer.UUID   `bun:"org_id,type:text,notnull"`
-	Name      string        `bun:"name,type:text,notnull"`
-	Category  GroupCategory `bun:"category,type:text,notnull"`
-	Condition Condition     `bun:"condition,type:jsob,notnull"`
-	Enabled   bool          `bun:"enabled,notnull,default:true"`
-}
-
-type StorableMapper struct {
-	bun.BaseModel `bun:"table:span_attribute_mapping,alias:span_attribute_mapping"`
-
-	types.Identifiable
-	types.TimeAuditable
-	types.UserAuditable
-
-	GroupID      valuer.UUID  `bun:"group_id,type:text,notnull"`
-	Name         string       `bun:"name,type:text,notnull"`
-	FieldContext FieldContext `bun:"field_context,type:text,notnull"`
-	Config       MapperConfig `bun:"config,type:jsonb,notnull"`
-	Enabled      bool         `bun:"enabled,notnull,default:true"`
-}
-
-func (c Condition) Value() (driver.Value, error) {
-	b, err := json.Marshal(c)
-	if err != nil {
-		return nil, err
-	}
-	return string(b), nil
-}
-
-func (c *Condition) Scan(src any) error {
-	var raw []byte
-	switch v := src.(type) {
-	case string:
-		raw = []byte(v)
-	case []byte:
-		raw = v
-	case nil:
-		*c = Condition{}
-		return nil
-	default:
-		return errors.NewInternalf(errors.CodeInternal, "spanattributemappingtypes: cannot scan %T into Condition", src)
-	}
-	return json.Unmarshal(raw, c)
-}
-
-func (m MapperConfig) Value() (driver.Value, error) {
-	b, err := json.Marshal(m)
-	if err != nil {
-		return nil, err
-	}
-	return string(b), nil
-}
-
-func (m *MapperConfig) Scan(src any) error {
-	var raw []byte
-	switch v := src.(type) {
-	case string:
-		raw = []byte(v)
-	case []byte:
-		raw = v
-	case nil:
-		*m = MapperConfig{}
-		return nil
-	default:
-		return errors.NewInternalf(errors.CodeInternal, "spanattributemapping: cannot scan %T into MapperConfig", src)
-	}
-	return json.Unmarshal(raw, m)
-}

pkg/types/spanattributemappingtypes/store.go

@@ -1,23 +0,0 @@
-package spanattributemappingtypes
-
-import (
-	"context"
-
-	"github.com/SigNoz/signoz/pkg/valuer"
-)
-
-type Store interface {
-	// Group operations
-	ListGroups(ctx context.Context, orgID valuer.UUID, q *ListGroupsQuery) ([]*StorableGroup, error)
-	GetGroup(ctx context.Context, orgID, id valuer.UUID) (*StorableGroup, error)
-	CreateGroup(ctx context.Context, group *StorableGroup) error
-	UpdateGroup(ctx context.Context, group *StorableGroup) error
-	DeleteGroup(ctx context.Context, orgID, id valuer.UUID) error
-
-	// Mapper operations
-	ListMappers(ctx context.Context, orgID, groupID valuer.UUID) ([]*StorableMapper, error)
-	GetMapper(ctx context.Context, orgID, groupID, id valuer.UUID) (*StorableMapper, error)
-	CreateMapper(ctx context.Context, mapper *StorableMapper) error
-	UpdateMapper(ctx context.Context, mapper *StorableMapper) error
-	DeleteMapper(ctx context.Context, orgID, groupID, id valuer.UUID) error
-}

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."""

tests/e2e/fixtures/auth.ts

@@ -1,85 +0,0 @@
-import {
-  test as base,
-  expect,
-  type Browser,
-  type BrowserContext,
-  type Page,
-} from '@playwright/test';
-
-export type User = { email: string; password: string };
-
-// Default user — admin from the pytest bootstrap (.env.local) or staging .env.
-export const ADMIN: User = {
-  email: process.env.SIGNOZ_E2E_USERNAME!,
-  password: process.env.SIGNOZ_E2E_PASSWORD!,
-};
-
-// Per-worker storageState cache. One login per unique user per worker.
-// Promise-valued so concurrent requests share the same in-flight work.
-// Held in memory only — no .auth/ dir, no JSON on disk.
-type StorageState = Awaited<ReturnType<BrowserContext['storageState']>>;
-const storageByUser = new Map<string, Promise<StorageState>>();
-
-async function storageFor(browser: Browser, user: User): Promise<StorageState> {
-  const cached = storageByUser.get(user.email);
-  if (cached) return cached;
-
-  const task = (async () => {
-    const ctx = await browser.newContext();
-    const page = await ctx.newPage();
-    await login(page, user);
-    const state = await ctx.storageState();
-    await ctx.close();
-    return state;
-  })();
-
-  storageByUser.set(user.email, task);
-  return task;
-}
-
-async function login(page: Page, user: User): Promise<void> {
-  if (!user.email || !user.password) {
-    throw new Error(
-      'User credentials missing. Set SIGNOZ_E2E_USERNAME / SIGNOZ_E2E_PASSWORD ' +
-        '(pytest bootstrap writes them to .env.local), or pass a User via test.use({ user: ... }).',
-    );
-  }
-  await page.goto('/login?password=Y');
-  await page.getByTestId('email').fill(user.email);
-  await page.getByTestId('initiate_login').click();
-  await page.getByTestId('password').fill(user.password);
-  await page.getByRole('button', { name: 'Sign in with Password' }).click();
-  // Post-login lands somewhere different depending on whether the org is
-  // licensed (onboarding flow on ENTERPRISE) or not (legacy "Hello there"
-  // welcome). Wait for URL to move off /login — whichever page follows
-  // is fine, each spec navigates to the feature under test anyway.
-  await page.waitForURL((url) => !url.pathname.startsWith('/login'));
-}
-
-export const test = base.extend<{
-  /**
-   * User identity for this test. Override with `test.use({ user: ... })` at
-   * the describe or test level to run the suite as a different user.
-   * Defaults to ADMIN (the pytest-bootstrap-seeded admin).
-   */
-  user: User;
-
-  /**
-   * A Page whose context is already authenticated as `user`. First request
-   * for a given user triggers one login per worker; the resulting
-   * storageState is held in memory and reused for all later requests.
-   */
-  authedPage: Page;
-}>({
-  user: [ADMIN, { option: true }],
-
-  authedPage: async ({ browser, user }, use) => {
-    const storageState = await storageFor(browser, user);
-    const ctx = await browser.newContext({ storageState });
-    const page = await ctx.newPage();
-    await use(page);
-    await ctx.close();
-  },
-});
-
-export { expect };

tests/e2e/package.json

@@ -1,45 +0,0 @@
-{
-  "name": "signoz-frontend-automation",
-  "version": "1.0.0",
-  "description": "E2E tests for SigNoz frontend with Playwright",
-  "main": "index.js",
-  "scripts": {
-    "test": "playwright test",
-    "test:staging": "SIGNOZ_E2E_BASE_URL=https://app.us.staging.signoz.cloud playwright test",
-    "test:ui": "playwright test --ui",
-    "test:headed": "playwright test --headed",
-    "test:debug": "playwright test --debug",
-    "test:chromium": "playwright test --project=chromium",
-    "test:firefox": "playwright test --project=firefox",
-    "test:webkit": "playwright test --project=webkit",
-    "report": "playwright show-report artifacts/html",
-    "codegen": "playwright codegen",
-    "install:browsers": "playwright install",
-    "install:cli": "npm install -g @playwright/cli@latest && playwright-cli install --skills",
-    "lint": "eslint . --ext .ts,.js",
-    "lint:fix": "eslint . --ext .ts,.js --fix",
-    "typecheck": "tsc --noEmit"
-  },
-  "keywords": [
-    "playwright",
-    "e2e",
-    "testing",
-    "signoz"
-  ],
-  "author": "",
-  "license": "MIT",
-  "devDependencies": {
-    "@playwright/test": "^1.57.0-alpha-2025-10-09",
-    "@types/node": "^20.0.0",
-    "@typescript-eslint/eslint-plugin": "^6.0.0",
-    "@typescript-eslint/parser": "^6.0.0",
-    "dotenv": "^16.0.0",
-    "eslint": "^9.26.0",
-    "eslint-plugin-playwright": "^0.16.0",
-    "typescript": "^5.0.0"
-  },
-  "engines": {
-    "node": ">=18.0.0",
-    "yarn": ">=1.22.0"
-  }
-}

tests/e2e/playwright-cli.json

@@ -1,11 +0,0 @@
-{
-  "browser": {
-    "browserName": "chromium",
-    "launchOptions": { "headless": true }
-  },
-  "timeouts": {
-    "action": 5000,
-    "navigation": 30000
-  },
-  "outputDir": ".playwright-cli"
-}

tests/e2e/playwright.config.ts

@@ -1,61 +0,0 @@
-import { defineConfig, devices } from '@playwright/test';
-import dotenv from 'dotenv';
-import path from 'path';
-
-// .env holds user-provided defaults (staging creds).
-// .env.local is written by tests/e2e/bootstrap/setup.py when the pytest
-// lifecycle brings the backend up locally; override=true so local-backend
-// coordinates win over any stale .env values. Subprocess-injected env
-// (e.g. when pytest shells out to `yarn test`) still takes priority —
-// dotenv doesn't touch vars that are already set in process.env.
-dotenv.config({ path: path.resolve(__dirname, '.env') });
-dotenv.config({ path: path.resolve(__dirname, '.env.local'), override: true });
-
-export default defineConfig({
-  testDir: './tests',
-
-  // All Playwright output lands under artifacts/. One subdir per reporter
-  // plus results/ for per-test artifacts (traces/screenshots/videos).
-  // CI can archive the whole dir with `tar czf artifacts.tgz tests/e2e/artifacts`.
-  outputDir: 'artifacts/results',
-
-  // Run tests in parallel
-  fullyParallel: true,
-
-  // Fail the build on CI if you accidentally left test.only
-  forbidOnly: !!process.env.CI,
-
-  // Retry on CI only
-  retries: process.env.CI ? 2 : 0,
-
-  // Workers
-  workers: process.env.CI ? 2 : undefined,
-
-  // Reporter
-  reporter: [
-    ['html', { outputFolder: 'artifacts/html', open: 'never' }],
-    ['json', { outputFile: 'artifacts/json/results.json' }],
-    ['list'],
-  ],
-
-  // Shared settings
-  use: {
-    baseURL:
-      process.env.SIGNOZ_E2E_BASE_URL || 'https://app.us.staging.signoz.cloud',
-    trace: 'on-first-retry',
-    screenshot: 'only-on-failure',
-    video: 'retain-on-failure',
-    colorScheme: 'dark',
-    locale: 'en-US',
-    viewport: { width: 1280, height: 720 },
-  },
-
-  // Browser projects. No project-level auth — specs opt in via the
-  // authedPage fixture in tests/e2e/fixtures/auth.ts, which logs a user
-  // in on first use and caches the resulting storageState per worker.
-  projects: [
-    { name: 'chromium', use: devices['Desktop Chrome'] },
-    { name: 'firefox', use: devices['Desktop Firefox'] },
-    { name: 'webkit', use: devices['Desktop Safari'] },
-  ],
-});

tests/e2e/tests/alerts/alerts.spec.ts

@@ -1,7 +0,0 @@
-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();
-});

tests/e2e/tsconfig.json

@@ -1,23 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2020",
-    "module": "commonjs",
-    "moduleResolution": "bundler",
-    "lib": ["ES2020"],
-    "strict": true,
-    "esModuleInterop": true,
-    "skipLibCheck": true,
-    "forceConsistentCasingInFileNames": true,
-    "resolveJsonModule": true,
-    "types": ["node", "@playwright/test"],
-    "paths": {
-      "@tests/*": ["./tests/*"],
-      "@utils/*": ["./utils/*"],
-      "@specs/*": ["./specs/*"]
-    },
-    "outDir": "./dist",
-    "rootDir": "."
-  },
-  "include": ["tests/**/*.ts", "utils/**/*.ts", "playwright.config.ts"],
-  "exclude": ["node_modules", "dist"]
-}

tests/fixtures/auth.py

@@ -1,445 +0,0 @@
-import time
-from http import HTTPStatus
-from typing import Callable, Dict, List, Tuple
-
-import pytest
-import requests
-from wiremock.client import Mappings
-from wiremock.constants import Config
-from wiremock.resources.mappings import (
-    HttpMethods,
-    Mapping,
-    MappingRequest,
-    MappingResponse,
-    WireMockMatchers,
-)
-
-from fixtures import reuse, types
-from fixtures.logger import setup_logger
-
-logger = setup_logger(__name__)
-
-USER_ADMIN_NAME = "admin"
-USER_ADMIN_EMAIL = "admin@integration.test"
-USER_ADMIN_PASSWORD = "password123Z$"
-
-USER_EDITOR_NAME = "editor"
-USER_EDITOR_EMAIL = "editor@integration.test"
-USER_EDITOR_PASSWORD = "password123Z$"
-
-USER_VIEWER_NAME = "viewer"
-USER_VIEWER_EMAIL = "viewer@integration.test"
-USER_VIEWER_PASSWORD = "password123Z$"
-
-USERS_BASE = "/api/v2/users"
-
-
-def _login(signoz: types.SigNoz, email: str, password: str) -> str:
-    """Complete GET /sessions/context + POST /sessions/email_password; return accessToken."""
-    ctx = requests.get(
-        signoz.self.host_configs["8080"].get("/api/v2/sessions/context"),
-        params={
-            "email": email,
-            "ref": f"{signoz.self.host_configs['8080'].base()}",
-        },
-        timeout=5,
-    )
-    assert ctx.status_code == HTTPStatus.OK
-    org_id = ctx.json()["data"]["orgs"][0]["id"]
-
-    login = requests.post(
-        signoz.self.host_configs["8080"].get("/api/v2/sessions/email_password"),
-        json={"email": email, "password": password, "orgId": org_id},
-        timeout=5,
-    )
-    assert login.status_code == HTTPStatus.OK
-    return login.json()["data"]["accessToken"]
-
-
-@pytest.fixture(name="create_user_admin", scope="package")
-def create_user_admin(
-    signoz: types.SigNoz, request: pytest.FixtureRequest, pytestconfig: pytest.Config
-) -> types.Operation:
-    def create() -> None:
-        response = requests.post(
-            signoz.self.host_configs["8080"].get("/api/v1/register"),
-            json={
-                "name": USER_ADMIN_NAME,
-                "orgName": "",
-                "email": USER_ADMIN_EMAIL,
-                "password": USER_ADMIN_PASSWORD,
-            },
-            timeout=5,
-        )
-
-        assert response.status_code == HTTPStatus.OK
-
-        return types.Operation(name="create_user_admin")
-
-    def delete(_: types.Operation) -> None:
-        pass
-
-    def restore(cache: dict) -> types.Operation:
-        return types.Operation(name=cache["name"])
-
-    return reuse.wrap(
-        request,
-        pytestconfig,
-        "create_user_admin",
-        lambda: types.Operation(name=""),
-        create,
-        delete,
-        restore,
-    )
-
-
-@pytest.fixture(name="get_session_context", scope="function")
-def get_session_context(signoz: types.SigNoz) -> Callable[[str, str], str]:
-    def _get_session_context(email: str) -> str:
-        response = requests.get(
-            signoz.self.host_configs["8080"].get("/api/v2/sessions/context"),
-            params={
-                "email": email,
-                "ref": f"{signoz.self.host_configs['8080'].base()}",
-            },
-            timeout=5,
-        )
-
-        assert response.status_code == HTTPStatus.OK
-        return response.json()["data"]
-
-    return _get_session_context
-
-
-@pytest.fixture(name="get_token", scope="function")
-def get_token(signoz: types.SigNoz) -> Callable[[str, str], str]:
-    def _get_token(email: str, password: str) -> str:
-        response = requests.get(
-            signoz.self.host_configs["8080"].get("/api/v2/sessions/context"),
-            params={
-                "email": email,
-                "ref": f"{signoz.self.host_configs['8080'].base()}",
-            },
-            timeout=5,
-        )
-
-        assert response.status_code == HTTPStatus.OK
-        org_id = response.json()["data"]["orgs"][0]["id"]
-
-        response = requests.post(
-            signoz.self.host_configs["8080"].get("/api/v2/sessions/email_password"),
-            json={
-                "email": email,
-                "password": password,
-                "orgId": org_id,
-            },
-            timeout=5,
-        )
-
-        assert response.status_code == HTTPStatus.OK
-        return response.json()["data"]["accessToken"]
-
-    return _get_token
-
-
-@pytest.fixture(name="get_tokens", scope="function")
-def get_tokens(signoz: types.SigNoz) -> Callable[[str, str], Tuple[str, str]]:
-    def _get_tokens(email: str, password: str) -> str:
-        response = requests.get(
-            signoz.self.host_configs["8080"].get("/api/v2/sessions/context"),
-            params={
-                "email": email,
-                "ref": f"{signoz.self.host_configs['8080'].base()}",
-            },
-            timeout=5,
-        )
-
-        assert response.status_code == HTTPStatus.OK
-        org_id = response.json()["data"]["orgs"][0]["id"]
-
-        response = requests.post(
-            signoz.self.host_configs["8080"].get("/api/v2/sessions/email_password"),
-            json={
-                "email": email,
-                "password": password,
-                "orgId": org_id,
-            },
-            timeout=5,
-        )
-
-        assert response.status_code == HTTPStatus.OK
-        access_token = response.json()["data"]["accessToken"]
-        refresh_token = response.json()["data"]["refreshToken"]
-        return access_token, refresh_token
-
-    return _get_tokens
-
-
-@pytest.fixture(name="apply_license", scope="package")
-def apply_license(
-    signoz: types.SigNoz,
-    create_user_admin: types.Operation,  # pylint: disable=unused-argument,redefined-outer-name
-    request: pytest.FixtureRequest,
-    pytestconfig: pytest.Config,
-) -> types.Operation:
-    """Stub Zeus license-lookup, then POST /api/v3/licenses so the BE flips
-    to ENTERPRISE. Package-scoped so an e2e bootstrap can pull it in and
-    every spec inherits the licensed state."""
-
-    def create() -> types.Operation:
-        Config.base_url = signoz.zeus.host_configs["8080"].get("/__admin")
-        Mappings.create_mapping(
-            mapping=Mapping(
-                request=MappingRequest(
-                    method=HttpMethods.GET,
-                    url="/v2/licenses/me",
-                    headers={
-                        "X-Signoz-Cloud-Api-Key": {
-                            WireMockMatchers.EQUAL_TO: "secret-key"
-                        }
-                    },
-                ),
-                response=MappingResponse(
-                    status=200,
-                    json_body={
-                        "status": "success",
-                        "data": {
-                            "id": "0196360e-90cd-7a74-8313-1aa815ce2a67",
-                            "key": "secret-key",
-                            "valid_from": 1732146923,
-                            "valid_until": -1,
-                            "status": "VALID",
-                            "state": "EVALUATING",
-                            "plan": {"name": "ENTERPRISE"},
-                            "platform": "CLOUD",
-                            "features": [],
-                            "event_queue": {},
-                        },
-                    },
-                ),
-                persistent=False,
-            )
-        )
-
-        access_token = _login(signoz, USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD)
-
-        # 202 = applied, 409 = already applied. Retry transient failures —
-        # the BE occasionally 5xxs right after startup before the license
-        # sync goroutine is ready.
-        license_url = signoz.self.host_configs["8080"].get("/api/v3/licenses")
-        auth_header = {"Authorization": f"Bearer {access_token}"}
-        for attempt in range(10):
-            resp = requests.post(
-                license_url,
-                json={"key": "secret-key"},
-                headers=auth_header,
-                timeout=5,
-            )
-            if resp.status_code in (HTTPStatus.ACCEPTED, HTTPStatus.CONFLICT):
-                break
-            if attempt == 9:
-                resp.raise_for_status()
-            time.sleep(1)
-
-        # The ENTERPRISE license flips on the `onboarding` feature which
-        # redirects first-time admins to a questionnaire. Mark the preference
-        # complete so specs can navigate directly to the feature under test.
-        pref_resp = requests.put(
-            signoz.self.host_configs["8080"].get(
-                "/api/v1/org/preferences/org_onboarding"
-            ),
-            json={"value": True},
-            headers=auth_header,
-            timeout=5,
-        )
-        assert pref_resp.status_code in (HTTPStatus.OK, HTTPStatus.NO_CONTENT)
-        return types.Operation(name="apply_license")
-
-    def delete(_: types.Operation) -> None:
-        pass
-
-    def restore(cache: dict) -> types.Operation:
-        return types.Operation(name=cache["name"])
-
-    return reuse.wrap(
-        request,
-        pytestconfig,
-        "apply_license",
-        lambda: types.Operation(name=""),
-        create,
-        delete,
-        restore,
-    )
-
-
-# This is not a fixture purposefully, we just want to add a license to the signoz instance.
-# This is also idempotent in nature.
-def add_license(
-    signoz: types.SigNoz,
-    make_http_mocks: Callable[[types.TestContainerDocker, List[Mapping]], None],
-    get_token: Callable[[str, str], str],  # pylint: disable=redefined-outer-name
-) -> None:
-    make_http_mocks(
-        signoz.zeus,
-        [
-            Mapping(
-                request=MappingRequest(
-                    method=HttpMethods.GET,
-                    url="/v2/licenses/me",
-                    headers={
-                        "X-Signoz-Cloud-Api-Key": {
-                            WireMockMatchers.EQUAL_TO: "secret-key"
-                        }
-                    },
-                ),
-                response=MappingResponse(
-                    status=200,
-                    json_body={
-                        "status": "success",
-                        "data": {
-                            "id": "0196360e-90cd-7a74-8313-1aa815ce2a67",
-                            "key": "secret-key",
-                            "valid_from": 1732146923,
-                            "valid_until": -1,
-                            "status": "VALID",
-                            "state": "EVALUATING",
-                            "plan": {
-                                "name": "ENTERPRISE",
-                            },
-                            "platform": "CLOUD",
-                            "features": [],
-                            "event_queue": {},
-                        },
-                    },
-                ),
-                persistent=False,
-            )
-        ],
-    )
-
-    access_token = get_token(USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD)
-
-    response = requests.post(
-        url=signoz.self.host_configs["8080"].get("/api/v3/licenses"),
-        json={"key": "secret-key"},
-        headers={"Authorization": "Bearer " + access_token},
-        timeout=5,
-    )
-
-    if response.status_code == HTTPStatus.CONFLICT:
-        return
-
-    assert response.status_code == HTTPStatus.ACCEPTED
-
-    response = requests.post(
-        url=signoz.zeus.host_configs["8080"].get("/__admin/requests/count"),
-        json={"method": "GET", "url": "/v2/licenses/me"},
-        timeout=5,
-    )
-
-    assert response.json()["count"] == 1
-
-
-def create_active_user(
-    signoz: types.SigNoz,
-    admin_token: str,
-    email: str,
-    role: str,
-    password: str,
-    name: str = "",
-) -> str:
-    """Invite a user and activate via resetPassword. Returns user ID."""
-    response = requests.post(
-        signoz.self.host_configs["8080"].get("/api/v1/invite"),
-        json={"email": email, "role": role, "name": name},
-        headers={"Authorization": f"Bearer {admin_token}"},
-        timeout=5,
-    )
-    assert response.status_code == HTTPStatus.CREATED, response.text
-    invited_user = response.json()["data"]
-
-    response = requests.post(
-        signoz.self.host_configs["8080"].get("/api/v1/resetPassword"),
-        json={"password": password, "token": invited_user["token"]},
-        timeout=5,
-    )
-    assert response.status_code == HTTPStatus.NO_CONTENT, response.text
-
-    return invited_user["id"]
-
-
-def find_user_by_email(signoz: types.SigNoz, token: str, email: str) -> Dict:
-    """Find a user by email from the user list. Raises AssertionError if not found."""
-    response = requests.get(
-        signoz.self.host_configs["8080"].get(USERS_BASE),
-        headers={"Authorization": f"Bearer {token}"},
-        timeout=5,
-    )
-    assert response.status_code == HTTPStatus.OK, response.text
-    user = next((u for u in response.json()["data"] if u["email"] == email), None)
-    assert user is not None, f"User with email '{email}' not found"
-    return user
-
-
-def find_user_with_roles_by_email(signoz: types.SigNoz, token: str, email: str) -> Dict:
-    """Find a user by email and return UserWithRoles (user fields + userRoles).
-
-    Raises AssertionError if the user is not found.
-    """
-    user = find_user_by_email(signoz, token, email)
-    response = requests.get(
-        signoz.self.host_configs["8080"].get(f"{USERS_BASE}/{user['id']}"),
-        headers={"Authorization": f"Bearer {token}"},
-        timeout=5,
-    )
-    assert response.status_code == HTTPStatus.OK, response.text
-    return response.json()["data"]
-
-
-def assert_user_has_role(data: Dict, role_name: str) -> None:
-    """Assert that a UserWithRoles response contains the expected managed role."""
-    role_names = {ur["role"]["name"] for ur in data.get("userRoles", [])}
-    assert role_name in role_names, f"Expected role '{role_name}' in {role_names}"
-
-
-def change_user_role(
-    signoz: types.SigNoz,
-    admin_token: str,
-    user_id: str,
-    old_role: str,
-    new_role: str,
-) -> None:
-    """Change a user's role (remove old, assign new).
-
-    Role names should be managed role names (e.g. signoz-editor).
-    """
-    # Get current roles to find the old role's ID
-    response = requests.get(
-        signoz.self.host_configs["8080"].get(f"{USERS_BASE}/{user_id}/roles"),
-        headers={"Authorization": f"Bearer {admin_token}"},
-        timeout=5,
-    )
-    assert response.status_code == HTTPStatus.OK, response.text
-    roles = response.json()["data"]
-
-    old_role_entry = next((r for r in roles if r["name"] == old_role), None)
-    assert old_role_entry is not None, f"User does not have role '{old_role}'"
-
-    # Remove old role
-    response = requests.delete(
-        signoz.self.host_configs["8080"].get(
-            f"{USERS_BASE}/{user_id}/roles/{old_role_entry['id']}"
-        ),
-        headers={"Authorization": f"Bearer {admin_token}"},
-        timeout=5,
-    )
-    assert response.status_code == HTTPStatus.NO_CONTENT, response.text
-
-    # Assign new role
-    response = requests.post(
-        signoz.self.host_configs["8080"].get(f"{USERS_BASE}/{user_id}/roles"),
-        json={"name": new_role},
-        headers={"Authorization": f"Bearer {admin_token}"},
-        timeout=5,
-    )
-    assert response.status_code == HTTPStatus.OK, response.text

tests/fixtures/fs.py

@@ -1,25 +0,0 @@
-import os
-from typing import Any, Generator
-
-import pytest
-
-from fixtures import types
-
-
-@pytest.fixture(scope="package")
-def tmpfs(
-    tmp_path_factory: pytest.TempPathFactory,
-) -> Generator[types.LegacyPath, Any, None]:
-    def _tmp(basename: str):
-        return tmp_path_factory.mktemp(basename)
-
-    yield _tmp
-
-
-def get_testdata_file_path(file: str) -> str:
-    # Integration testdata lives at tests/integration/testdata/. This helper
-    # resolves from tests/fixtures/fs.py, so walk up to tests/ and across.
-    testdata_dir = os.path.join(
-        os.path.dirname(__file__), "..", "integration", "testdata"
-    )
-    return os.path.join(testdata_dir, file)

tests/fixtures/seeder.py

@@ -1,101 +0,0 @@
-import time
-from http import HTTPStatus
-
-import docker
-import docker.errors
-import pytest
-import requests
-from testcontainers.core.container import DockerContainer, Network
-
-from fixtures import reuse, types
-from fixtures.logger import setup_logger
-
-logger = setup_logger(__name__)
-
-
-@pytest.fixture(name="seeder", scope="package")
-def seeder(
-    network: Network,
-    clickhouse: types.TestContainerClickhouse,
-    request: pytest.FixtureRequest,
-    pytestconfig: pytest.Config,
-) -> types.TestContainerDocker:
-    """HTTP seeder container exposing POST/DELETE endpoints for per-test telemetry."""
-
-    def create() -> types.TestContainerDocker:
-        docker_client = docker.from_env()
-        docker_client.images.build(
-            path=str(pytestconfig.rootpath),
-            dockerfile="Dockerfile.seeder",
-            tag="signoz-tests-seeder:latest",
-            rm=True,
-        )
-
-        container = DockerContainer("signoz-tests-seeder:latest")
-        container.with_env(
-            "CH_HOST", clickhouse.container.container_configs["8123"].address
-        )
-        container.with_env(
-            "CH_PORT", str(clickhouse.container.container_configs["8123"].port)
-        )
-        container.with_env(
-            "CH_USER", clickhouse.env["SIGNOZ_TELEMETRYSTORE_CLICKHOUSE_USERNAME"]
-        )
-        container.with_env(
-            "CH_PASSWORD", clickhouse.env["SIGNOZ_TELEMETRYSTORE_CLICKHOUSE_PASSWORD"]
-        )
-        container.with_env(
-            "CH_CLUSTER", clickhouse.env["SIGNOZ_TELEMETRYSTORE_CLICKHOUSE_CLUSTER"]
-        )
-        container.with_exposed_ports(8080)
-        container.with_network(network=network)
-        container.start()
-
-        host = container.get_container_host_ip()
-        host_port = container.get_exposed_port(8080)
-
-        for attempt in range(20):
-            try:
-                response = requests.get(f"http://{host}:{host_port}/healthz", timeout=2)
-                if response.status_code == HTTPStatus.OK:
-                    break
-            except Exception as e:  # pylint: disable=broad-exception-caught
-                logger.info("seeder attempt %d: %s", attempt + 1, e)
-            time.sleep(1)
-        else:
-            raise TimeoutError("seeder container did not become ready")
-
-        return types.TestContainerDocker(
-            id=container.get_wrapped_container().id,
-            host_configs={
-                "8080": types.TestContainerUrlConfig("http", host, host_port),
-            },
-            container_configs={
-                "8080": types.TestContainerUrlConfig(
-                    "http", container.get_wrapped_container().name, 8080
-                ),
-            },
-        )
-
-    def delete(container: types.TestContainerDocker) -> None:
-        client = docker.from_env()
-        try:
-            client.containers.get(container_id=container.id).stop()
-            client.containers.get(container_id=container.id).remove(v=True)
-        except docker.errors.NotFound:
-            logger.info("Seeder container %s already gone", container.id)
-
-    def restore(cache: dict) -> types.TestContainerDocker:
-        return types.TestContainerDocker.from_cache(cache)
-
-    return reuse.wrap(
-        request,
-        pytestconfig,
-        "seeder",
-        empty=lambda: types.TestContainerDocker(
-            id="", host_configs={}, container_configs={}
-        ),
-        create=create,
-        delete=delete,
-        restore=restore,
-    )

tests/integration/conftest.py

@@ -17,13 +17,12 @@ pytest_plugins = [
     "fixtures.traces",
     "fixtures.metrics",
     "fixtures.meter",
-    "fixtures.browser",
-    "fixtures.keycloak",
+    "fixtures.driver",
     "fixtures.idp",
+    "fixtures.idputils",
     "fixtures.notification_channel",
     "fixtures.alerts",
     "fixtures.cloudintegrations",
-    "fixtures.seeder",
 ]
 
 

tests/integration/fixtures/alerts.py

@@ -0,0 +1,110 @@
+from datetime import datetime, timezone
+from http import HTTPStatus
+from typing import Callable, List
+
+import pytest
+import requests
+
+from fixtures import types
+from fixtures.auth import USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD
+from fixtures.logger import setup_logger
+from fixtures.logs import Logs
+from fixtures.metrics import Metrics
+from fixtures.traces import Traces
+from fixtures.utils import get_testdata_file_path
+
+logger = setup_logger(__name__)
+
+
+@pytest.fixture(name="create_alert_rule", scope="function")
+def create_alert_rule(
+    signoz: types.SigNoz, get_token: Callable[[str, str], str]
+) -> Callable[[dict], str]:
+    admin_token = get_token(USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD)
+
+    rule_ids = []
+
+    def _create_alert_rule(rule_data: dict) -> str:
+        response = requests.post(
+            signoz.self.host_configs["8080"].get("/api/v1/rules"),
+            json=rule_data,
+            headers={"Authorization": f"Bearer {admin_token}"},
+            timeout=5,
+        )
+        assert (
+            response.status_code == HTTPStatus.OK
+        ), f"Failed to create rule, api returned {response.status_code} with response: {response.text}"
+        rule_id = response.json()["data"]["id"]
+        rule_ids.append(rule_id)
+        return rule_id
+
+    def _delete_alert_rule(rule_id: str):
+        logger.info("Deleting rule: %s", {"rule_id": rule_id})
+        response = requests.delete(
+            signoz.self.host_configs["8080"].get(f"/api/v1/rules/{rule_id}"),
+            headers={"Authorization": f"Bearer {admin_token}"},
+            timeout=5,
+        )
+        if response.status_code != HTTPStatus.OK:
+            raise Exception(  # pylint: disable=broad-exception-raised
+                f"Failed to delete rule, api returned {response.status_code} with response: {response.text}"
+            )
+
+    yield _create_alert_rule
+    # delete the rule on cleanup
+    for rule_id in rule_ids:
+        try:
+            _delete_alert_rule(rule_id)
+        except Exception as e:  # pylint: disable=broad-exception-caught
+            logger.error("Error deleting rule: %s", {"rule_id": rule_id, "error": e})
+
+
+@pytest.fixture(name="insert_alert_data", scope="function")
+def insert_alert_data(
+    insert_metrics: Callable[[List[Metrics]], None],
+    insert_traces: Callable[[List[Traces]], None],
+    insert_logs: Callable[[List[Logs]], None],
+) -> Callable[[List[types.AlertData]], None]:
+
+    def _insert_alert_data(
+        alert_data_items: List[types.AlertData],
+        base_time: datetime = None,
+    ) -> None:
+
+        metrics: List[Metrics] = []
+        traces: List[Traces] = []
+        logs: List[Logs] = []
+
+        now = base_time or datetime.now(tz=timezone.utc).replace(
+            second=0, microsecond=0
+        )
+
+        for data_item in alert_data_items:
+            if data_item.type == "metrics":
+                _metrics = Metrics.load_from_file(
+                    get_testdata_file_path(data_item.data_path),
+                    base_time=now,
+                )
+                metrics.extend(_metrics)
+            elif data_item.type == "traces":
+                _traces = Traces.load_from_file(
+                    get_testdata_file_path(data_item.data_path),
+                    base_time=now,
+                )
+                traces.extend(_traces)
+            elif data_item.type == "logs":
+                _logs = Logs.load_from_file(
+                    get_testdata_file_path(data_item.data_path),
+                    base_time=now,
+                )
+                logs.extend(_logs)
+
+        # Add data to ClickHouse if any data is present
+        if len(metrics) > 0:
+            insert_metrics(metrics)
+        if len(traces) > 0:
+            insert_traces(traces)
+        if len(logs) > 0:
+            insert_logs(logs)
+
+    yield _insert_alert_data

tests/integration/fixtures/alertutils.py

@@ -1,118 +1,18 @@
 import base64
 import json
 import time
-from datetime import datetime, timedelta, timezone
+from datetime import datetime, timedelta
 from http import HTTPStatus
-from typing import Callable, List
+from typing import List
 
-import pytest
 import requests
 
 from fixtures import types
-from fixtures.auth import USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD
-from fixtures.fs import get_testdata_file_path
 from fixtures.logger import setup_logger
-from fixtures.logs import Logs
-from fixtures.metrics import Metrics
-from fixtures.traces import Traces
 
 logger = setup_logger(__name__)
 
 
-@pytest.fixture(name="create_alert_rule", scope="function")
-def create_alert_rule(
-    signoz: types.SigNoz, get_token: Callable[[str, str], str]
-) -> Callable[[dict], str]:
-    admin_token = get_token(USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD)
-
-    rule_ids = []
-
-    def _create_alert_rule(rule_data: dict) -> str:
-        response = requests.post(
-            signoz.self.host_configs["8080"].get("/api/v1/rules"),
-            json=rule_data,
-            headers={"Authorization": f"Bearer {admin_token}"},
-            timeout=5,
-        )
-        assert (
-            response.status_code == HTTPStatus.OK
-        ), f"Failed to create rule, api returned {response.status_code} with response: {response.text}"
-        rule_id = response.json()["data"]["id"]
-        rule_ids.append(rule_id)
-        return rule_id
-
-    def _delete_alert_rule(rule_id: str):
-        logger.info("Deleting rule: %s", {"rule_id": rule_id})
-        response = requests.delete(
-            signoz.self.host_configs["8080"].get(f"/api/v1/rules/{rule_id}"),
-            headers={"Authorization": f"Bearer {admin_token}"},
-            timeout=5,
-        )
-        if response.status_code != HTTPStatus.OK:
-            raise Exception(  # pylint: disable=broad-exception-raised
-                f"Failed to delete rule, api returned {response.status_code} with response: {response.text}"
-            )
-
-    yield _create_alert_rule
-    # delete the rule on cleanup
-    for rule_id in rule_ids:
-        try:
-            _delete_alert_rule(rule_id)
-        except Exception as e:  # pylint: disable=broad-exception-caught
-            logger.error("Error deleting rule: %s", {"rule_id": rule_id, "error": e})
-
-
-@pytest.fixture(name="insert_alert_data", scope="function")
-def insert_alert_data(
-    insert_metrics: Callable[[List[Metrics]], None],
-    insert_traces: Callable[[List[Traces]], None],
-    insert_logs: Callable[[List[Logs]], None],
-) -> Callable[[List[types.AlertData]], None]:
-
-    def _insert_alert_data(
-        alert_data_items: List[types.AlertData],
-        base_time: datetime = None,
-    ) -> None:
-
-        metrics: List[Metrics] = []
-        traces: List[Traces] = []
-        logs: List[Logs] = []
-
-        now = base_time or datetime.now(tz=timezone.utc).replace(
-            second=0, microsecond=0
-        )
-
-        for data_item in alert_data_items:
-            if data_item.type == "metrics":
-                _metrics = Metrics.load_from_file(
-                    get_testdata_file_path(data_item.data_path),
-                    base_time=now,
-                )
-                metrics.extend(_metrics)
-            elif data_item.type == "traces":
-                _traces = Traces.load_from_file(
-                    get_testdata_file_path(data_item.data_path),
-                    base_time=now,
-                )
-                traces.extend(_traces)
-            elif data_item.type == "logs":
-                _logs = Logs.load_from_file(
-                    get_testdata_file_path(data_item.data_path),
-                    base_time=now,
-                )
-                logs.extend(_logs)
-
-        # Add data to ClickHouse if any data is present
-        if len(metrics) > 0:
-            insert_metrics(metrics)
-        if len(traces) > 0:
-            insert_traces(traces)
-        if len(logs) > 0:
-            insert_logs(logs)
-
-    yield _insert_alert_data
-
-
 def collect_webhook_firing_alerts(
     webhook_test_container: types.TestContainerDocker, notification_channel_name: str
 ) -> List[types.FiringAlert]:

tests/integration/fixtures/auth.py

@@ -0,0 +1,216 @@
+from http import HTTPStatus
+from typing import Callable, List, Tuple
+
+import pytest
+import requests
+from wiremock.resources.mappings import (
+    HttpMethods,
+    Mapping,
+    MappingRequest,
+    MappingResponse,
+    WireMockMatchers,
+)
+
+from fixtures import dev, types
+from fixtures.logger import setup_logger
+
+logger = setup_logger(__name__)
+
+USER_ADMIN_NAME = "admin"
+USER_ADMIN_EMAIL = "admin@integration.test"
+USER_ADMIN_PASSWORD = "password123Z$"
+
+USER_EDITOR_NAME = "editor"
+USER_EDITOR_EMAIL = "editor@integration.test"
+USER_EDITOR_PASSWORD = "password123Z$"
+
+USER_VIEWER_NAME = "viewer"
+USER_VIEWER_EMAIL = "viewer@integration.test"
+USER_VIEWER_PASSWORD = "password123Z$"
+
+
+@pytest.fixture(name="create_user_admin", scope="package")
+def create_user_admin(
+    signoz: types.SigNoz, request: pytest.FixtureRequest, pytestconfig: pytest.Config
+) -> types.Operation:
+    def create() -> None:
+        response = requests.post(
+            signoz.self.host_configs["8080"].get("/api/v1/register"),
+            json={
+                "name": USER_ADMIN_NAME,
+                "orgName": "",
+                "email": USER_ADMIN_EMAIL,
+                "password": USER_ADMIN_PASSWORD,
+            },
+            timeout=5,
+        )
+
+        assert response.status_code == HTTPStatus.OK
+
+        return types.Operation(name="create_user_admin")
+
+    def delete(_: types.Operation) -> None:
+        pass
+
+    def restore(cache: dict) -> types.Operation:
+        return types.Operation(name=cache["name"])
+
+    return dev.wrap(
+        request,
+        pytestconfig,
+        "create_user_admin",
+        lambda: types.Operation(name=""),
+        create,
+        delete,
+        restore,
+    )
+
+
+@pytest.fixture(name="get_session_context", scope="function")
+def get_session_context(signoz: types.SigNoz) -> Callable[[str, str], str]:
+    def _get_session_context(email: str) -> str:
+        response = requests.get(
+            signoz.self.host_configs["8080"].get("/api/v2/sessions/context"),
+            params={
+                "email": email,
+                "ref": f"{signoz.self.host_configs['8080'].base()}",
+            },
+            timeout=5,
+        )
+
+        assert response.status_code == HTTPStatus.OK
+        return response.json()["data"]
+
+    return _get_session_context
+
+
+@pytest.fixture(name="get_token", scope="function")
+def get_token(signoz: types.SigNoz) -> Callable[[str, str], str]:
+    def _get_token(email: str, password: str) -> str:
+        response = requests.get(
+            signoz.self.host_configs["8080"].get("/api/v2/sessions/context"),
+            params={
+                "email": email,
+                "ref": f"{signoz.self.host_configs['8080'].base()}",
+            },
+            timeout=5,
+        )
+
+        assert response.status_code == HTTPStatus.OK
+        org_id = response.json()["data"]["orgs"][0]["id"]
+
+        response = requests.post(
+            signoz.self.host_configs["8080"].get("/api/v2/sessions/email_password"),
+            json={
+                "email": email,
+                "password": password,
+                "orgId": org_id,
+            },
+            timeout=5,
+        )
+
+        assert response.status_code == HTTPStatus.OK
+        return response.json()["data"]["accessToken"]
+
+    return _get_token
+
+
+@pytest.fixture(name="get_tokens", scope="function")
+def get_tokens(signoz: types.SigNoz) -> Callable[[str, str], Tuple[str, str]]:
+    def _get_tokens(email: str, password: str) -> str:
+        response = requests.get(
+            signoz.self.host_configs["8080"].get("/api/v2/sessions/context"),
+            params={
+                "email": email,
+                "ref": f"{signoz.self.host_configs['8080'].base()}",
+            },
+            timeout=5,
+        )
+
+        assert response.status_code == HTTPStatus.OK
+        org_id = response.json()["data"]["orgs"][0]["id"]
+
+        response = requests.post(
+            signoz.self.host_configs["8080"].get("/api/v2/sessions/email_password"),
+            json={
+                "email": email,
+                "password": password,
+                "orgId": org_id,
+            },
+            timeout=5,
+        )
+
+        assert response.status_code == HTTPStatus.OK
+        access_token = response.json()["data"]["accessToken"]
+        refresh_token = response.json()["data"]["refreshToken"]
+        return access_token, refresh_token
+
+    return _get_tokens
+
+
+# This is not a fixture purposefully, we just want to add a license to the signoz instance.
+# This is also idempotent in nature.
+def add_license(
+    signoz: types.SigNoz,
+    make_http_mocks: Callable[[types.TestContainerDocker, List[Mapping]], None],
+    get_token: Callable[[str, str], str],  # pylint: disable=redefined-outer-name
+) -> None:
+    make_http_mocks(
+        signoz.zeus,
+        [
+            Mapping(
+                request=MappingRequest(
+                    method=HttpMethods.GET,
+                    url="/v2/licenses/me",
+                    headers={
+                        "X-Signoz-Cloud-Api-Key": {
+                            WireMockMatchers.EQUAL_TO: "secret-key"
+                        }
+                    },
+                ),
+                response=MappingResponse(
+                    status=200,
+                    json_body={
+                        "status": "success",
+                        "data": {
+                            "id": "0196360e-90cd-7a74-8313-1aa815ce2a67",
+                            "key": "secret-key",
+                            "valid_from": 1732146923,
+                            "valid_until": -1,
+                            "status": "VALID",
+                            "state": "EVALUATING",
+                            "plan": {
+                                "name": "ENTERPRISE",
+                            },
+                            "platform": "CLOUD",
+                            "features": [],
+                            "event_queue": {},
+                        },
+                    },
+                ),
+                persistent=False,
+            )
+        ],
+    )
+
+    access_token = get_token(USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD)
+
+    response = requests.post(
+        url=signoz.self.host_configs["8080"].get("/api/v3/licenses"),
+        json={"key": "secret-key"},
+        headers={"Authorization": "Bearer " + access_token},
+        timeout=5,
+    )
+
+    if response.status_code == HTTPStatus.CONFLICT:
+        return
+
+    assert response.status_code == HTTPStatus.ACCEPTED
+
+    response = requests.post(
+        url=signoz.zeus.host_configs["8080"].get("/__admin/requests/count"),
+        json={"method": "GET", "url": "/v2/licenses/me"},
+        timeout=5,
+    )
+
+    assert response.json()["count"] == 1

tests/integration/fixtures/authutils.py

@@ -0,0 +1,115 @@
+"""Reusable helpers for user API tests."""
+
+from http import HTTPStatus
+from typing import Dict
+
+import requests
+
+from fixtures import types
+
+USERS_BASE = "/api/v2/users"
+
+
+def create_active_user(
+    signoz: types.SigNoz,
+    admin_token: str,
+    email: str,
+    role: str,
+    password: str,
+    name: str = "",
+) -> str:
+    """Invite a user and activate via resetPassword. Returns user ID."""
+    response = requests.post(
+        signoz.self.host_configs["8080"].get("/api/v1/invite"),
+        json={"email": email, "role": role, "name": name},
+        headers={"Authorization": f"Bearer {admin_token}"},
+        timeout=5,
+    )
+    assert response.status_code == HTTPStatus.CREATED, response.text
+    invited_user = response.json()["data"]
+
+    response = requests.post(
+        signoz.self.host_configs["8080"].get("/api/v1/resetPassword"),
+        json={"password": password, "token": invited_user["token"]},
+        timeout=5,
+    )
+    assert response.status_code == HTTPStatus.NO_CONTENT, response.text
+
+    return invited_user["id"]
+
+
+def find_user_by_email(signoz: types.SigNoz, token: str, email: str) -> Dict:
+    """Find a user by email from the user list. Raises AssertionError if not found."""
+    response = requests.get(
+        signoz.self.host_configs["8080"].get(USERS_BASE),
+        headers={"Authorization": f"Bearer {token}"},
+        timeout=5,
+    )
+    assert response.status_code == HTTPStatus.OK, response.text
+    user = next((u for u in response.json()["data"] if u["email"] == email), None)
+    assert user is not None, f"User with email '{email}' not found"
+    return user
+
+
+def find_user_with_roles_by_email(signoz: types.SigNoz, token: str, email: str) -> Dict:
+    """Find a user by email and return UserWithRoles (user fields + userRoles).
+
+    Raises AssertionError if the user is not found.
+    """
+    user = find_user_by_email(signoz, token, email)
+    response = requests.get(
+        signoz.self.host_configs["8080"].get(f"{USERS_BASE}/{user['id']}"),
+        headers={"Authorization": f"Bearer {token}"},
+        timeout=5,
+    )
+    assert response.status_code == HTTPStatus.OK, response.text
+    return response.json()["data"]
+
+
+def assert_user_has_role(data: Dict, role_name: str) -> None:
+    """Assert that a UserWithRoles response contains the expected managed role."""
+    role_names = {ur["role"]["name"] for ur in data.get("userRoles", [])}
+    assert role_name in role_names, f"Expected role '{role_name}' in {role_names}"
+
+
+def change_user_role(
+    signoz: types.SigNoz,
+    admin_token: str,
+    user_id: str,
+    old_role: str,
+    new_role: str,
+) -> None:
+    """Change a user's role (remove old, assign new).
+
+    Role names should be managed role names (e.g. signoz-editor).
+    """
+    # Get current roles to find the old role's ID
+    response = requests.get(
+        signoz.self.host_configs["8080"].get(f"{USERS_BASE}/{user_id}/roles"),
+        headers={"Authorization": f"Bearer {admin_token}"},
+        timeout=5,
+    )
+    assert response.status_code == HTTPStatus.OK, response.text
+    roles = response.json()["data"]
+
+    old_role_entry = next((r for r in roles if r["name"] == old_role), None)
+    assert old_role_entry is not None, f"User does not have role '{old_role}'"
+
+    # Remove old role
+    response = requests.delete(
+        signoz.self.host_configs["8080"].get(
+            f"{USERS_BASE}/{user_id}/roles/{old_role_entry['id']}"
+        ),
+        headers={"Authorization": f"Bearer {admin_token}"},
+        timeout=5,
+    )
+    assert response.status_code == HTTPStatus.NO_CONTENT, response.text
+
+    # Assign new role
+    response = requests.post(
+        signoz.self.host_configs["8080"].get(f"{USERS_BASE}/{user_id}/roles"),
+        json={"name": new_role},
+        headers={"Authorization": f"Bearer {admin_token}"},
+        timeout=5,
+    )
+    assert response.status_code == HTTPStatus.OK, response.text

tests/integration/fixtures/clickhouse.py

@@ -10,7 +10,7 @@ import pytest
 from testcontainers.clickhouse import ClickHouseContainer
 from testcontainers.core.container import Network
 
-from fixtures import reuse, types
+from fixtures import dev, types
 from fixtures.logger import setup_logger
 
 logger = setup_logger(__name__)
@@ -256,7 +256,7 @@ def clickhouse(
             env=env,
         )
 
-    return reuse.wrap(
+    return dev.wrap(
         request,
         pytestconfig,
         "clickhouse",

tests/integration/fixtures/cloudintegrations.py

@@ -5,13 +5,6 @@ from typing import Callable
 
 import pytest
 import requests
-from wiremock.client import (
-    HttpMethods,
-    Mapping,
-    MappingRequest,
-    MappingResponse,
-    WireMockMatchers,
-)
 
 from fixtures import types
 from fixtures.auth import USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD
@@ -160,140 +153,3 @@ def create_cloud_integration_account(
                 logger.info("Cleaned up test account: %s", account_id)
         except Exception as exc:  # pylint: disable=broad-except
             logger.info("Post-test delete cleanup failed: %s", exc)
-
-
-def deprecated_simulate_agent_checkin(
-    signoz: types.SigNoz,
-    admin_token: str,
-    cloud_provider: str,
-    account_id: str,
-    cloud_account_id: str,
-) -> requests.Response:
-    endpoint = f"/api/v1/cloud-integrations/{cloud_provider}/agent-check-in"
-
-    checkin_payload = {
-        "account_id": account_id,
-        "cloud_account_id": cloud_account_id,
-        "data": {},
-    }
-
-    response = requests.post(
-        signoz.self.host_configs["8080"].get(endpoint),
-        headers={"Authorization": f"Bearer {admin_token}"},
-        json=checkin_payload,
-        timeout=10,
-    )
-
-    if not response.ok:
-        logger.error(
-            "Agent check-in failed: %s, response: %s",
-            response.status_code,
-            response.text,
-        )
-
-    return response
-
-
-def setup_create_account_mocks(
-    signoz: types.SigNoz,
-    make_http_mocks: Callable,
-) -> None:
-    """Set up Zeus and Gateway mocks required by the CreateAccount endpoint."""
-    make_http_mocks(
-        signoz.zeus,
-        [
-            Mapping(
-                request=MappingRequest(
-                    method=HttpMethods.GET,
-                    url="/v2/deployments/me",
-                    headers={
-                        "X-Signoz-Cloud-Api-Key": {
-                            WireMockMatchers.EQUAL_TO: "secret-key"
-                        }
-                    },
-                ),
-                response=MappingResponse(
-                    status=200,
-                    json_body={
-                        "status": "success",
-                        "data": {
-                            "name": "test-deployment",
-                            "cluster": {"region": {"dns": "test.signoz.cloud"}},
-                        },
-                    },
-                ),
-                persistent=False,
-            )
-        ],
-    )
-    make_http_mocks(
-        signoz.gateway,
-        [
-            Mapping(
-                request=MappingRequest(
-                    method=HttpMethods.GET,
-                    url="/v1/workspaces/me/keys/search?name=aws-integration&page=1&per_page=10",
-                ),
-                response=MappingResponse(
-                    status=200,
-                    json_body={
-                        "status": "success",
-                        "data": [],
-                        "_pagination": {"page": 1, "per_page": 10, "total": 0},
-                    },
-                ),
-                persistent=False,
-            ),
-            Mapping(
-                request=MappingRequest(
-                    method=HttpMethods.POST,
-                    url="/v1/workspaces/me/keys",
-                ),
-                response=MappingResponse(
-                    status=200,
-                    json_body={
-                        "status": "success",
-                        "data": {
-                            "name": "aws-integration",
-                            "value": "test-ingestion-key-123456",
-                        },
-                        "error": "",
-                    },
-                ),
-                persistent=False,
-            ),
-        ],
-    )
-
-
-def simulate_agent_checkin(
-    signoz: types.SigNoz,
-    admin_token: str,
-    cloud_provider: str,
-    account_id: str,
-    cloud_account_id: str,
-    data: dict | None = None,
-) -> requests.Response:
-    endpoint = f"/api/v1/cloud_integrations/{cloud_provider}/accounts/check_in"
-
-    checkin_payload = {
-        "cloudIntegrationId": account_id,
-        "providerAccountId": cloud_account_id,
-        "data": data or {},
-    }
-
-    response = requests.post(
-        signoz.self.host_configs["8080"].get(endpoint),
-        headers={"Authorization": f"Bearer {admin_token}"},
-        json=checkin_payload,
-        timeout=10,
-    )
-
-    if not response.ok:
-        logger.error(
-            "Agent check-in failed: %s, response: %s",
-            response.status_code,
-            response.text,
-        )
-
-    return response

tests/integration/fixtures/cloudintegrationsutils.py

@@ -0,0 +1,154 @@
+"""Fixtures for cloud integration tests."""
+
+from typing import Callable
+
+import requests
+from wiremock.client import (
+    HttpMethods,
+    Mapping,
+    MappingRequest,
+    MappingResponse,
+    WireMockMatchers,
+)
+
+from fixtures import types
+from fixtures.logger import setup_logger
+
+logger = setup_logger(__name__)
+
+
+def deprecated_simulate_agent_checkin(
+    signoz: types.SigNoz,
+    admin_token: str,
+    cloud_provider: str,
+    account_id: str,
+    cloud_account_id: str,
+) -> requests.Response:
+    endpoint = f"/api/v1/cloud-integrations/{cloud_provider}/agent-check-in"
+
+    checkin_payload = {
+        "account_id": account_id,
+        "cloud_account_id": cloud_account_id,
+        "data": {},
+    }
+
+    response = requests.post(
+        signoz.self.host_configs["8080"].get(endpoint),
+        headers={"Authorization": f"Bearer {admin_token}"},
+        json=checkin_payload,
+        timeout=10,
+    )
+
+    if not response.ok:
+        logger.error(
+            "Agent check-in failed: %s, response: %s",
+            response.status_code,
+            response.text,
+        )
+
+    return response
+
+
+def setup_create_account_mocks(
+    signoz: types.SigNoz,
+    make_http_mocks: Callable,
+) -> None:
+    """Set up Zeus and Gateway mocks required by the CreateAccount endpoint."""
+    make_http_mocks(
+        signoz.zeus,
+        [
+            Mapping(
+                request=MappingRequest(
+                    method=HttpMethods.GET,
+                    url="/v2/deployments/me",
+                    headers={
+                        "X-Signoz-Cloud-Api-Key": {
+                            WireMockMatchers.EQUAL_TO: "secret-key"
+                        }
+                    },
+                ),
+                response=MappingResponse(
+                    status=200,
+                    json_body={
+                        "status": "success",
+                        "data": {
+                            "name": "test-deployment",
+                            "cluster": {"region": {"dns": "test.signoz.cloud"}},
+                        },
+                    },
+                ),
+                persistent=False,
+            )
+        ],
+    )
+    make_http_mocks(
+        signoz.gateway,
+        [
+            Mapping(
+                request=MappingRequest(
+                    method=HttpMethods.GET,
+                    url="/v1/workspaces/me/keys/search?name=aws-integration&page=1&per_page=10",
+                ),
+                response=MappingResponse(
+                    status=200,
+                    json_body={
+                        "status": "success",
+                        "data": [],
+                        "_pagination": {"page": 1, "per_page": 10, "total": 0},
+                    },
+                ),
+                persistent=False,
+            ),
+            Mapping(
+                request=MappingRequest(
+                    method=HttpMethods.POST,
+                    url="/v1/workspaces/me/keys",
+                ),
+                response=MappingResponse(
+                    status=200,
+                    json_body={
+                        "status": "success",
+                        "data": {
+                            "name": "aws-integration",
+                            "value": "test-ingestion-key-123456",
+                        },
+                        "error": "",
+                    },
+                ),
+                persistent=False,
+            ),
+        ],
+    )
+
+
+def simulate_agent_checkin(
+    signoz: types.SigNoz,
+    admin_token: str,
+    cloud_provider: str,
+    account_id: str,
+    cloud_account_id: str,
+    data: dict | None = None,
+) -> requests.Response:
+    endpoint = f"/api/v1/cloud_integrations/{cloud_provider}/accounts/check_in"
+
+    checkin_payload = {
+        "cloudIntegrationId": account_id,
+        "providerAccountId": cloud_account_id,
+        "data": data or {},
+    }
+
+    response = requests.post(
+        signoz.self.host_configs["8080"].get(endpoint),
+        headers={"Authorization": f"Bearer {admin_token}"},
+        json=checkin_payload,
+        timeout=10,
+    )
+
+    if not response.ok:
+        logger.error(
+            "Agent check-in failed: %s, response: %s",
+            response.status_code,
+            response.text,
+        )
+
+    return response

tests/integration/fixtures/fs.py

@@ -0,0 +1,15 @@
+from typing import Any, Generator
+
+import pytest
+
+from fixtures import types
+
+
+@pytest.fixture(scope="package")
+def tmpfs(
+    tmp_path_factory: pytest.TempPathFactory,
+) -> Generator[types.LegacyPath, Any, None]:
+    def _tmp(basename: str):
+        return tmp_path_factory.mktemp(basename)
+
+    yield _tmp

tests/integration/fixtures/http.py

@@ -12,7 +12,7 @@ from wiremock.client import (
 from wiremock.constants import Config
 from wiremock.testing.testcontainer import WireMockContainer
 
-from fixtures import reuse, types
+from fixtures import dev, types
 from fixtures.logger import setup_logger
 
 logger = setup_logger(__name__)
@@ -63,7 +63,7 @@ def zeus(
     def restore(cache: dict) -> types.TestContainerDocker:
         return types.TestContainerDocker.from_cache(cache)
 
-    return reuse.wrap(
+    return dev.wrap(
         request,
         pytestconfig,
         "zeus",
@@ -120,7 +120,7 @@ def gateway(
     def restore(cache: dict) -> types.TestContainerDocker:
         return types.TestContainerDocker.from_cache(cache)
 
-    return reuse.wrap(
+    return dev.wrap(
         request,
         pytestconfig,
         "gateway",

tests/integration/fixtures/idp.py

@@ -4,7 +4,7 @@ import pytest
 from testcontainers.core.container import Network
 from testcontainers.keycloak import KeycloakContainer
 
-from fixtures import reuse, types
+from fixtures import dev, types
 from fixtures.logger import setup_logger
 
 logger = setup_logger(__name__)
@@ -80,7 +80,7 @@ def idp(
             container=container,
         )
 
-    return reuse.wrap(
+    return dev.wrap(
         request,
         pytestconfig,
         "idp",

tests/integration/fixtures/idputils.py

@@ -11,7 +11,7 @@ from selenium.webdriver.support import expected_conditions as EC
 from selenium.webdriver.support.wait import WebDriverWait
 
 from fixtures import types
-from fixtures.keycloak import IDP_ROOT_PASSWORD, IDP_ROOT_USERNAME
+from fixtures.idp import IDP_ROOT_PASSWORD, IDP_ROOT_USERNAME
 
 
 @pytest.fixture(name="create_saml_client", scope="function")

tests/integration/fixtures/logs.py

@@ -11,7 +11,7 @@ from ksuid import KsuidMs
 
 from fixtures import types
 from fixtures.fingerprint import LogsOrTracesFingerprint
-from fixtures.time import parse_timestamp
+from fixtures.utils import parse_timestamp
 
 
 class LogsResource(ABC):
@@ -391,124 +391,112 @@ class Logs(ABC):
         return logs
 
 
-def insert_logs_to_clickhouse(conn, logs: List[Logs]) -> None:
-    """
-    Insert logs into ClickHouse tables following the same logic as the Go exporter.
-    Handles insertion into:
-    - distributed_logs_v2 (main logs table)
-    - distributed_logs_v2_resource (resource fingerprints)
-    - distributed_tag_attributes_v2 (tag attributes)
-    - distributed_logs_attribute_keys (attribute keys)
-    - distributed_logs_resource_keys (resource keys)
-
-    Pure function so the seeder container can reuse the exact insert path
-    used by the pytest fixture. `conn` is a clickhouse-connect Client.
-    """
-    resources: List[LogsResource] = []
-    for log in logs:
-        resources.extend(log.resource)
-
-    if len(resources) > 0:
-        conn.insert(
-            database="signoz_logs",
-            table="distributed_logs_v2_resource",
-            data=[resource.np_arr() for resource in resources],
-            column_names=[
-                "labels",
-                "fingerprint",
-                "seen_at_ts_bucket_start",
-            ],
-        )
-
-    tag_attributes: List[LogsTagAttributes] = []
-    for log in logs:
-        tag_attributes.extend(log.tag_attributes)
-
-    if len(tag_attributes) > 0:
-        conn.insert(
-            database="signoz_logs",
-            table="distributed_tag_attributes_v2",
-            data=[tag_attribute.np_arr() for tag_attribute in tag_attributes],
-        )
-
-    attribute_keys: List[LogsResourceOrAttributeKeys] = []
-    for log in logs:
-        attribute_keys.extend(log.attribute_keys)
-
-    if len(attribute_keys) > 0:
-        conn.insert(
-            database="signoz_logs",
-            table="distributed_logs_attribute_keys",
-            data=[attribute_key.np_arr() for attribute_key in attribute_keys],
-        )
-
-    resource_keys: List[LogsResourceOrAttributeKeys] = []
-    for log in logs:
-        resource_keys.extend(log.resource_keys)
-
-    if len(resource_keys) > 0:
-        conn.insert(
-            database="signoz_logs",
-            table="distributed_logs_resource_keys",
-            data=[resource_key.np_arr() for resource_key in resource_keys],
-        )
-
-    conn.insert(
-        database="signoz_logs",
-        table="distributed_logs_v2",
-        data=[log.np_arr() for log in logs],
-        column_names=[
-            "ts_bucket_start",
-            "resource_fingerprint",
-            "timestamp",
-            "observed_timestamp",
-            "id",
-            "trace_id",
-            "span_id",
-            "trace_flags",
-            "severity_text",
-            "severity_number",
-            "body",
-            "attributes_string",
-            "attributes_number",
-            "attributes_bool",
-            "resources_string",
-            "scope_name",
-            "scope_version",
-            "scope_string",
-            "resource",
-        ],
-    )
-
-
-_LOGS_TABLES_TO_TRUNCATE = [
-    "logs_v2",
-    "logs_v2_resource",
-    "tag_attributes_v2",
-    "logs_attribute_keys",
-    "logs_resource_keys",
-]
-
-
-def truncate_logs_tables(conn, cluster: str) -> None:
-    """Truncate all logs tables. Used by the pytest fixture teardown and by
-    the seeder's DELETE /telemetry/logs endpoint."""
-    for table in _LOGS_TABLES_TO_TRUNCATE:
-        conn.query(f"TRUNCATE TABLE signoz_logs.{table} ON CLUSTER '{cluster}' SYNC")
-
-
 @pytest.fixture(name="insert_logs", scope="function")
 def insert_logs(
     clickhouse: types.TestContainerClickhouse,
 ) -> Generator[Callable[[List[Logs]], None], Any, None]:
     def _insert_logs(logs: List[Logs]) -> None:
-        insert_logs_to_clickhouse(clickhouse.conn, logs)
+        """
+        Insert logs into ClickHouse tables following the same logic as the Go exporter.
+        This function handles insertion into multiple tables:
+        - distributed_logs_v2 (main logs table)
+        - distributed_logs_v2_resource (resource fingerprints)
+        - distributed_tag_attributes_v2 (tag attributes)
+        - distributed_logs_attribute_keys (attribute keys)
+        - distributed_logs_resource_keys (resource keys)
+        """
+        resources: List[LogsResource] = []
+        for log in logs:
+            resources.extend(log.resource)
+
+        if len(resources) > 0:
+            clickhouse.conn.insert(
+                database="signoz_logs",
+                table="distributed_logs_v2_resource",
+                data=[resource.np_arr() for resource in resources],
+                column_names=[
+                    "labels",
+                    "fingerprint",
+                    "seen_at_ts_bucket_start",
+                ],
+            )
+
+        tag_attributes: List[LogsTagAttributes] = []
+        for log in logs:
+            tag_attributes.extend(log.tag_attributes)
+
+        if len(tag_attributes) > 0:
+            clickhouse.conn.insert(
+                database="signoz_logs",
+                table="distributed_tag_attributes_v2",
+                data=[tag_attribute.np_arr() for tag_attribute in tag_attributes],
+            )
+
+        attribute_keys: List[LogsResourceOrAttributeKeys] = []
+        for log in logs:
+            attribute_keys.extend(log.attribute_keys)
+
+        if len(attribute_keys) > 0:
+            clickhouse.conn.insert(
+                database="signoz_logs",
+                table="distributed_logs_attribute_keys",
+                data=[attribute_key.np_arr() for attribute_key in attribute_keys],
+            )
+
+        resource_keys: List[LogsResourceOrAttributeKeys] = []
+        for log in logs:
+            resource_keys.extend(log.resource_keys)
+
+        if len(resource_keys) > 0:
+            clickhouse.conn.insert(
+                database="signoz_logs",
+                table="distributed_logs_resource_keys",
+                data=[resource_key.np_arr() for resource_key in resource_keys],
+            )
+
+        clickhouse.conn.insert(
+            database="signoz_logs",
+            table="distributed_logs_v2",
+            data=[log.np_arr() for log in logs],
+            column_names=[
+                "ts_bucket_start",
+                "resource_fingerprint",
+                "timestamp",
+                "observed_timestamp",
+                "id",
+                "trace_id",
+                "span_id",
+                "trace_flags",
+                "severity_text",
+                "severity_number",
+                "body",
+                "attributes_string",
+                "attributes_number",
+                "attributes_bool",
+                "resources_string",
+                "scope_name",
+                "scope_version",
+                "scope_string",
+                "resource",
+            ],
+        )
 
     yield _insert_logs
 
-    truncate_logs_tables(
-        clickhouse.conn,
-        clickhouse.env["SIGNOZ_TELEMETRYSTORE_CLICKHOUSE_CLUSTER"],
+    clickhouse.conn.query(
+        f"TRUNCATE TABLE signoz_logs.logs_v2 ON CLUSTER '{clickhouse.env['SIGNOZ_TELEMETRYSTORE_CLICKHOUSE_CLUSTER']}' SYNC"
+    )
+    clickhouse.conn.query(
+        f"TRUNCATE TABLE signoz_logs.logs_v2_resource ON CLUSTER '{clickhouse.env['SIGNOZ_TELEMETRYSTORE_CLICKHOUSE_CLUSTER']}' SYNC"
+    )
+    clickhouse.conn.query(
+        f"TRUNCATE TABLE signoz_logs.tag_attributes_v2 ON CLUSTER '{clickhouse.env['SIGNOZ_TELEMETRYSTORE_CLICKHOUSE_CLUSTER']}' SYNC"
+    )
+    clickhouse.conn.query(
+        f"TRUNCATE TABLE signoz_logs.logs_attribute_keys ON CLUSTER '{clickhouse.env['SIGNOZ_TELEMETRYSTORE_CLICKHOUSE_CLUSTER']}' SYNC"
+    )
+    clickhouse.conn.query(
+        f"TRUNCATE TABLE signoz_logs.logs_resource_keys ON CLUSTER '{clickhouse.env['SIGNOZ_TELEMETRYSTORE_CLICKHOUSE_CLUSTER']}' SYNC"
     )
 
 

tests/integration/fixtures/metrics.py

@@ -8,7 +8,7 @@ import numpy as np
 import pytest
 
 from fixtures import types
-from fixtures.time import parse_timestamp
+from fixtures.utils import parse_timestamp
 
 
 class MetricsTimeSeries(ABC):
@@ -417,166 +417,151 @@ class Metrics(ABC):
         return metrics
 
 
-def insert_metrics_to_clickhouse(conn, metrics: List[Metrics]) -> None:
-    """
-    Insert metrics into ClickHouse tables.
-    Handles insertion into:
-    - distributed_time_series_v4 (time series metadata)
-    - distributed_samples_v4 (actual sample values)
-    - distributed_metadata (metric attribute metadata)
-
-    Pure function so the seeder container can reuse the exact insert path
-    used by the pytest fixture. `conn` is a clickhouse-connect Client.
-    """
-    time_series_map: dict[int, MetricsTimeSeries] = {}
-    for metric in metrics:
-        fp = int(metric.time_series.fingerprint)
-        if fp not in time_series_map:
-            time_series_map[fp] = metric.time_series
-
-    if len(time_series_map) > 0:
-        conn.insert(
-            database="signoz_metrics",
-            table="distributed_time_series_v4",
-            column_names=[
-                "env",
-                "temporality",
-                "metric_name",
-                "description",
-                "unit",
-                "type",
-                "is_monotonic",
-                "fingerprint",
-                "unix_milli",
-                "labels",
-                "attrs",
-                "scope_attrs",
-                "resource_attrs",
-                "__normalized",
-            ],
-            data=[ts.to_row() for ts in time_series_map.values()],
-        )
-
-    samples = [metric.sample for metric in metrics]
-    if len(samples) > 0:
-        conn.insert(
-            database="signoz_metrics",
-            table="distributed_samples_v4",
-            column_names=[
-                "env",
-                "temporality",
-                "metric_name",
-                "fingerprint",
-                "unix_milli",
-                "value",
-                "flags",
-            ],
-            data=[sample.to_row() for sample in samples],
-        )
-
-    # (metric_name, attr_type, attr_name, attr_value) -> MetricsMetadata
-    metadata_map: dict[tuple, MetricsMetadata] = {}
-    for metric in metrics:
-        ts = metric.time_series
-        for attr_name, attr_value in metric.labels.items():
-            key = (ts.metric_name, "point", attr_name, str(attr_value))
-            if key not in metadata_map:
-                metadata_map[key] = MetricsMetadata(
-                    metric_name=ts.metric_name,
-                    attr_name=attr_name,
-                    attr_type="point",
-                    attr_datatype="String",
-                    attr_string_value=str(attr_value),
-                    timestamp=metric.timestamp,
-                    temporality=ts.temporality,
-                    description=ts.description,
-                    unit=ts.unit,
-                    type_=ts.type,
-                    is_monotonic=ts.is_monotonic,
-                )
-        for attr_name, attr_value in ts.resource_attrs.items():
-            key = (ts.metric_name, "resource", attr_name, str(attr_value))
-            if key not in metadata_map:
-                metadata_map[key] = MetricsMetadata(
-                    metric_name=ts.metric_name,
-                    attr_name=attr_name,
-                    attr_type="resource",
-                    attr_datatype="String",
-                    attr_string_value=str(attr_value),
-                    timestamp=metric.timestamp,
-                    temporality=ts.temporality,
-                    description=ts.description,
-                    unit=ts.unit,
-                    type_=ts.type,
-                    is_monotonic=ts.is_monotonic,
-                )
-        for attr_name, attr_value in ts.scope_attrs.items():
-            key = (ts.metric_name, "scope", attr_name, str(attr_value))
-            if key not in metadata_map:
-                metadata_map[key] = MetricsMetadata(
-                    metric_name=ts.metric_name,
-                    attr_name=attr_name,
-                    attr_type="scope",
-                    attr_datatype="String",
-                    attr_string_value=str(attr_value),
-                    timestamp=metric.timestamp,
-                    temporality=ts.temporality,
-                    description=ts.description,
-                    unit=ts.unit,
-                    type_=ts.type,
-                    is_monotonic=ts.is_monotonic,
-                )
-
-    if len(metadata_map) > 0:
-        conn.insert(
-            database="signoz_metrics",
-            table="distributed_metadata",
-            column_names=[
-                "temporality",
-                "metric_name",
-                "description",
-                "unit",
-                "type",
-                "is_monotonic",
-                "attr_name",
-                "attr_type",
-                "attr_datatype",
-                "attr_string_value",
-                "first_reported_unix_milli",
-                "last_reported_unix_milli",
-            ],
-            data=[m.to_row() for m in metadata_map.values()],
-        )
-
-
-_METRICS_TABLES_TO_TRUNCATE = [
-    "time_series_v4",
-    "samples_v4",
-    "exp_hist",
-    "metadata",
-]
-
-
-def truncate_metrics_tables(conn, cluster: str) -> None:
-    """Truncate all metrics tables. Used by the pytest fixture teardown and by
-    the seeder's DELETE /telemetry/metrics endpoint."""
-    for table in _METRICS_TABLES_TO_TRUNCATE:
-        conn.query(f"TRUNCATE TABLE signoz_metrics.{table} ON CLUSTER '{cluster}' SYNC")
-
-
 @pytest.fixture(name="insert_metrics", scope="function")
 def insert_metrics(
     clickhouse: types.TestContainerClickhouse,
 ) -> Generator[Callable[[List[Metrics]], None], Any, None]:
     def _insert_metrics(metrics: List[Metrics]) -> None:
-        insert_metrics_to_clickhouse(clickhouse.conn, metrics)
+        """
+        Insert metrics into ClickHouse tables.
+        This function handles insertion into:
+        - distributed_time_series_v4 (time series metadata)
+        - distributed_samples_v4 (actual sample values)
+        - distributed_metadata (metric attribute metadata)
+        """
+        time_series_map: dict[int, MetricsTimeSeries] = {}
+        for metric in metrics:
+            fp = int(metric.time_series.fingerprint)
+            if fp not in time_series_map:
+                time_series_map[fp] = metric.time_series
+
+        if len(time_series_map) > 0:
+            clickhouse.conn.insert(
+                database="signoz_metrics",
+                table="distributed_time_series_v4",
+                column_names=[
+                    "env",
+                    "temporality",
+                    "metric_name",
+                    "description",
+                    "unit",
+                    "type",
+                    "is_monotonic",
+                    "fingerprint",
+                    "unix_milli",
+                    "labels",
+                    "attrs",
+                    "scope_attrs",
+                    "resource_attrs",
+                    "__normalized",
+                ],
+                data=[ts.to_row() for ts in time_series_map.values()],
+            )
+
+        samples = [metric.sample for metric in metrics]
+        if len(samples) > 0:
+            clickhouse.conn.insert(
+                database="signoz_metrics",
+                table="distributed_samples_v4",
+                column_names=[
+                    "env",
+                    "temporality",
+                    "metric_name",
+                    "fingerprint",
+                    "unix_milli",
+                    "value",
+                    "flags",
+                ],
+                data=[sample.to_row() for sample in samples],
+            )
+
+        # (metric_name, attr_type, attr_name, attr_value) -> MetricsMetadata
+        metadata_map: dict[tuple, MetricsMetadata] = {}
+        for metric in metrics:
+            ts = metric.time_series
+            for attr_name, attr_value in metric.labels.items():
+                key = (ts.metric_name, "point", attr_name, str(attr_value))
+                if key not in metadata_map:
+                    metadata_map[key] = MetricsMetadata(
+                        metric_name=ts.metric_name,
+                        attr_name=attr_name,
+                        attr_type="point",
+                        attr_datatype="String",
+                        attr_string_value=str(attr_value),
+                        timestamp=metric.timestamp,
+                        temporality=ts.temporality,
+                        description=ts.description,
+                        unit=ts.unit,
+                        type_=ts.type,
+                        is_monotonic=ts.is_monotonic,
+                    )
+            for attr_name, attr_value in ts.resource_attrs.items():
+                key = (ts.metric_name, "resource", attr_name, str(attr_value))
+                if key not in metadata_map:
+                    metadata_map[key] = MetricsMetadata(
+                        metric_name=ts.metric_name,
+                        attr_name=attr_name,
+                        attr_type="resource",
+                        attr_datatype="String",
+                        attr_string_value=str(attr_value),
+                        timestamp=metric.timestamp,
+                        temporality=ts.temporality,
+                        description=ts.description,
+                        unit=ts.unit,
+                        type_=ts.type,
+                        is_monotonic=ts.is_monotonic,
+                    )
+            for attr_name, attr_value in ts.scope_attrs.items():
+                key = (ts.metric_name, "scope", attr_name, str(attr_value))
+                if key not in metadata_map:
+                    metadata_map[key] = MetricsMetadata(
+                        metric_name=ts.metric_name,
+                        attr_name=attr_name,
+                        attr_type="scope",
+                        attr_datatype="String",
+                        attr_string_value=str(attr_value),
+                        timestamp=metric.timestamp,
+                        temporality=ts.temporality,
+                        description=ts.description,
+                        unit=ts.unit,
+                        type_=ts.type,
+                        is_monotonic=ts.is_monotonic,
+                    )
+
+        if len(metadata_map) > 0:
+            clickhouse.conn.insert(
+                database="signoz_metrics",
+                table="distributed_metadata",
+                column_names=[
+                    "temporality",
+                    "metric_name",
+                    "description",
+                    "unit",
+                    "type",
+                    "is_monotonic",
+                    "attr_name",
+                    "attr_type",
+                    "attr_datatype",
+                    "attr_string_value",
+                    "first_reported_unix_milli",
+                    "last_reported_unix_milli",
+                ],
+                data=[m.to_row() for m in metadata_map.values()],
+            )
 
     yield _insert_metrics
 
-    truncate_metrics_tables(
-        clickhouse.conn,
-        clickhouse.env["SIGNOZ_TELEMETRYSTORE_CLICKHOUSE_CLUSTER"],
-    )
+    cluster = clickhouse.env["SIGNOZ_TELEMETRYSTORE_CLICKHOUSE_CLUSTER"]
+    tables_to_truncate = [
+        "time_series_v4",
+        "samples_v4",
+        "exp_hist",
+        "metadata",
+    ]
+    for table in tables_to_truncate:
+        clickhouse.conn.query(
+            f"TRUNCATE TABLE signoz_metrics.{table} ON CLUSTER '{cluster}' SYNC"
+        )
 
 
 @pytest.fixture(name="remove_metrics_ttl_and_storage_settings", scope="function")

tests/integration/fixtures/migrator.py

@@ -2,7 +2,7 @@ import docker
 import pytest
 from testcontainers.core.container import Network
 
-from fixtures import reuse, types
+from fixtures import dev, types
 from fixtures.logger import setup_logger
 
 logger = setup_logger(__name__)
@@ -67,7 +67,7 @@ def migrator(
     def restore(cache: dict) -> types.Operation:
         return types.Operation(name=cache["name"])
 
-    return reuse.wrap(
+    return dev.wrap(
         request,
         pytestconfig,
         "migrator",

tests/integration/fixtures/network.py

@@ -3,7 +3,7 @@ import docker.errors
 import pytest
 from testcontainers.core.network import Network
 
-from fixtures import reuse, types
+from fixtures import dev, types
 from fixtures.logger import setup_logger
 
 logger = setup_logger(__name__)
@@ -37,7 +37,7 @@ def network(
         nw = client.networks.get(network_id=existing.get("id"))
         return types.Network(id=nw.id, name=nw.name)
 
-    return reuse.wrap(
+    return dev.wrap(
         request,
         pytestconfig,
         "network",

tests/integration/fixtures/notification_channel.py

@@ -8,7 +8,7 @@ import requests
 from testcontainers.core.container import Network
 from wiremock.testing.testcontainer import WireMockContainer
 
-from fixtures import reuse, types
+from fixtures import dev, types
 from fixtures.auth import USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD
 from fixtures.logger import setup_logger
 
@@ -60,7 +60,7 @@ def notification_channel(
     def restore(cache: dict) -> types.TestContainerDocker:
         return types.TestContainerDocker.from_cache(cache)
 
-    return reuse.wrap(
+    return dev.wrap(
         request,
         pytestconfig,
         "notification_channel",

tests/integration/fixtures/postgres.py

@@ -5,7 +5,7 @@ from sqlalchemy import create_engine, sql
 from testcontainers.core.container import Network
 from testcontainers.postgres import PostgresContainer
 
-from fixtures import reuse, types
+from fixtures import dev, types
 from fixtures.logger import setup_logger
 
 logger = setup_logger(__name__)
@@ -97,7 +97,7 @@ def postgres(
             env=env,
         )
 
-    return reuse.wrap(
+    return dev.wrap(
         request,
         pytestconfig,
         "postgres",

tests/integration/fixtures/querier.py

@@ -1,13 +1,10 @@
 from dataclasses import dataclass
-from datetime import datetime, timedelta, timezone
-from http import HTTPStatus
+from datetime import datetime, timedelta
 from typing import Any, Dict, List, Optional, Union
 
 import requests
 
 from fixtures import types
-from fixtures.logs import Logs
-from fixtures.traces import TraceIdGenerator, Traces, TracesKind, TracesStatusCode
 
 DEFAULT_STEP_INTERVAL = 60  # seconds
 DEFAULT_TOLERANCE = 1e-9
@@ -586,251 +583,3 @@ def assert_scalar_column_order(
         f"{context}: Column {column_index} order mismatch. "
         f"Expected {expected_values}, got {actual_values}"
     )
-
-
-def format_timestamp(dt: datetime) -> str:
-    """
-    Format a datetime object to match the API's timestamp format.
-    The API returns timestamps with minimal fractional seconds precision.
-    Example: 2026-02-03T20:54:56.5Z for 500000 microseconds
-    """
-    base_str = dt.strftime("%Y-%m-%dT%H:%M:%S")
-    if dt.microsecond:
-        # Convert microseconds to fractional seconds and strip trailing zeros
-        fractional = f"{dt.microsecond / 1000000:.6f}"[2:].rstrip("0")
-        return f"{base_str}.{fractional}Z"
-    return f"{base_str}Z"
-
-
-def assert_identical_query_response(
-    response1: requests.Response, response2: requests.Response
-) -> None:
-    """
-    Assert that two query responses are identical in status and data.
-    """
-    assert response1.status_code == response2.status_code, "Status codes do not match"
-    if response1.status_code == HTTPStatus.OK:
-        assert (
-            response1.json()["status"] == response2.json()["status"]
-        ), "Response statuses do not match"
-        assert (
-            response1.json()["data"]["data"]["results"]
-            == response2.json()["data"]["data"]["results"]
-        ), "Response data do not match"
-
-
-def generate_logs_with_corrupt_metadata() -> List[Logs]:
-    """
-    Specifically, entries with 'id', 'timestamp', 'severity_text', 'severity_number' and 'body' fields in metadata
-    """
-    now = datetime.now(tz=timezone.utc).replace(second=0, microsecond=0)
-
-    return [
-        Logs(
-            timestamp=now - timedelta(seconds=4),
-            body="POST /integration request received",
-            severity_text="INFO",
-            resources={
-                "deployment.environment": "production",
-                "service.name": "http-service",
-                "os.type": "linux",
-                "host.name": "linux-000",
-                "cloud.provider": "integration",
-                "cloud.account.id": "000",
-                "timestamp": "corrupt_data",
-            },
-            attributes={
-                "net.transport": "IP.TCP",
-                "http.scheme": "http",
-                "http.user_agent": "Integration Test",
-                "http.request.method": "POST",
-                "http.response.status_code": "200",
-                "severity_text": "corrupt_data",
-                "timestamp": "corrupt_data",
-            },
-            trace_id="1",
-        ),
-        Logs(
-            timestamp=now - timedelta(seconds=3),
-            body="SELECT query executed",
-            severity_text="DEBUG",
-            resources={
-                "deployment.environment": "production",
-                "service.name": "http-service",
-                "os.type": "linux",
-                "host.name": "linux-000",
-                "cloud.provider": "integration",
-                "cloud.account.id": "000",
-                "severity_number": "corrupt_data",
-                "id": "corrupt_data",
-            },
-            attributes={
-                "db.name": "integration",
-                "db.operation": "SELECT",
-                "db.statement": "SELECT * FROM integration",
-                "trace_id": "2",
-            },
-        ),
-        Logs(
-            timestamp=now - timedelta(seconds=2),
-            body="HTTP PATCH failed with 404",
-            severity_text="WARN",
-            resources={
-                "deployment.environment": "production",
-                "service.name": "http-service",
-                "os.type": "linux",
-                "host.name": "linux-000",
-                "cloud.provider": "integration",
-                "cloud.account.id": "000",
-                "body": "corrupt_data",
-                "trace_id": "3",
-            },
-            attributes={
-                "http.request.method": "PATCH",
-                "http.status_code": "404",
-                "id": "1",
-            },
-        ),
-        Logs(
-            timestamp=now - timedelta(seconds=1),
-            body="{'trace_id': '4'}",
-            severity_text="ERROR",
-            resources={
-                "deployment.environment": "production",
-                "service.name": "topic-service",
-                "os.type": "linux",
-                "host.name": "linux-001",
-                "cloud.provider": "integration",
-                "cloud.account.id": "001",
-            },
-            attributes={
-                "message.type": "SENT",
-                "messaging.operation": "publish",
-                "messaging.message.id": "001",
-                "body": "corrupt_data",
-                "timestamp": "corrupt_data",
-            },
-        ),
-    ]
-
-
-def generate_traces_with_corrupt_metadata() -> List[Traces]:
-    """
-    Specifically, entries with 'id', 'timestamp', 'trace_id' and 'duration_nano' fields in metadata
-    """
-    http_service_trace_id = TraceIdGenerator.trace_id()
-    http_service_span_id = TraceIdGenerator.span_id()
-    http_service_db_span_id = TraceIdGenerator.span_id()
-    http_service_patch_span_id = TraceIdGenerator.span_id()
-    topic_service_trace_id = TraceIdGenerator.trace_id()
-    topic_service_span_id = TraceIdGenerator.span_id()
-
-    now = datetime.now(tz=timezone.utc).replace(second=0, microsecond=0)
-
-    return [
-        Traces(
-            timestamp=now - timedelta(seconds=4),
-            duration=timedelta(seconds=3),
-            trace_id=http_service_trace_id,
-            span_id=http_service_span_id,
-            parent_span_id="",
-            name="POST /integration",
-            kind=TracesKind.SPAN_KIND_SERVER,
-            status_code=TracesStatusCode.STATUS_CODE_OK,
-            status_message="",
-            resources={
-                "deployment.environment": "production",
-                "service.name": "http-service",
-                "os.type": "linux",
-                "host.name": "linux-000",
-                "cloud.provider": "integration",
-                "cloud.account.id": "000",
-                "trace_id": "corrupt_data",
-            },
-            attributes={
-                "net.transport": "IP.TCP",
-                "http.scheme": "http",
-                "http.user_agent": "Integration Test",
-                "http.request.method": "POST",
-                "http.response.status_code": "200",
-                "timestamp": "corrupt_data",
-            },
-        ),
-        Traces(
-            timestamp=now - timedelta(seconds=3.5),
-            duration=timedelta(seconds=5),
-            trace_id=http_service_trace_id,
-            span_id=http_service_db_span_id,
-            parent_span_id=http_service_span_id,
-            name="SELECT",
-            kind=TracesKind.SPAN_KIND_CLIENT,
-            status_code=TracesStatusCode.STATUS_CODE_OK,
-            status_message="",
-            resources={
-                "deployment.environment": "production",
-                "service.name": "http-service",
-                "os.type": "linux",
-                "host.name": "linux-000",
-                "cloud.provider": "integration",
-                "cloud.account.id": "000",
-                "timestamp": "corrupt_data",
-            },
-            attributes={
-                "db.name": "integration",
-                "db.operation": "SELECT",
-                "db.statement": "SELECT * FROM integration",
-                "trace_d": "corrupt_data",
-            },
-        ),
-        Traces(
-            timestamp=now - timedelta(seconds=3),
-            duration=timedelta(seconds=1),
-            trace_id=http_service_trace_id,
-            span_id=http_service_patch_span_id,
-            parent_span_id=http_service_span_id,
-            name="HTTP PATCH",
-            kind=TracesKind.SPAN_KIND_CLIENT,
-            status_code=TracesStatusCode.STATUS_CODE_OK,
-            status_message="",
-            resources={
-                "deployment.environment": "production",
-                "service.name": "http-service",
-                "os.type": "linux",
-                "host.name": "linux-000",
-                "cloud.provider": "integration",
-                "cloud.account.id": "000",
-                "duration_nano": "corrupt_data",
-            },
-            attributes={
-                "http.request.method": "PATCH",
-                "http.status_code": "404",
-                "id": "1",
-            },
-        ),
-        Traces(
-            timestamp=now - timedelta(seconds=1),
-            duration=timedelta(seconds=4),
-            trace_id=topic_service_trace_id,
-            span_id=topic_service_span_id,
-            parent_span_id="",
-            name="topic publish",
-            kind=TracesKind.SPAN_KIND_PRODUCER,
-            status_code=TracesStatusCode.STATUS_CODE_OK,
-            status_message="",
-            resources={
-                "deployment.environment": "production",
-                "service.name": "topic-service",
-                "os.type": "linux",
-                "host.name": "linux-001",
-                "cloud.provider": "integration",
-                "cloud.account.id": "001",
-            },
-            attributes={
-                "message.type": "SENT",
-                "messaging.operation": "publish",
-                "messaging.message.id": "001",
-                "duration_nano": "corrupt_data",
-                "id": 1,
-            },
-        ),
-    ]

tests/integration/fixtures/signoz.py

@@ -11,7 +11,7 @@ import requests
 from testcontainers.core.container import DockerContainer, Network
 from testcontainers.core.image import DockerImage
 
-from fixtures import reuse, types
+from fixtures import dev, types
 from fixtures.logger import setup_logger
 
 logger = setup_logger(__name__)
@@ -49,10 +49,8 @@ def create_signoz(
         if with_web:
             dockerfile_path = "cmd/enterprise/Dockerfile.with-web.integration"
 
-        # Docker build context is the repo root — one up from pytest's
-        # rootdir (tests/).
         self = DockerImage(
-            path=str(pytestconfig.rootpath.parent),
+            path="../../",
             dockerfile_path=dockerfile_path,
             tag="signoz:integration",
             buildargs={
@@ -183,7 +181,7 @@ def create_signoz(
             gateway=gateway,
         )
 
-    return reuse.wrap(
+    return dev.wrap(
         request,
         pytestconfig,
         cache_key,

tests/integration/fixtures/sqlite.py

@@ -4,7 +4,7 @@ from typing import Any, Generator
 import pytest
 from sqlalchemy import create_engine, sql
 
-from fixtures import reuse, types
+from fixtures import dev, types
 
 ConnectionTuple = namedtuple("ConnectionTuple", "connection config")
 
@@ -64,7 +64,7 @@ def sqlite(
             env=cache["env"],
         )
 
-    return reuse.wrap(
+    return dev.wrap(
         request,
         pytestconfig,
         "sqlite",

tests/integration/fixtures/traces.py

@@ -13,7 +13,7 @@ import pytest
 
 from fixtures import types
 from fixtures.fingerprint import LogsOrTracesFingerprint
-from fixtures.time import parse_duration, parse_timestamp
+from fixtures.utils import parse_duration, parse_timestamp
 
 
 class TracesKind(Enum):
@@ -689,142 +689,131 @@ class Traces(ABC):
         return traces
 
 
-def insert_traces_to_clickhouse(conn, traces: List[Traces]) -> None:
-    """
-    Insert traces into ClickHouse tables following the same logic as the Go exporter.
-    Handles insertion into:
-    - distributed_signoz_index_v3 (main traces table)
-    - distributed_traces_v3_resource (resource fingerprints)
-    - distributed_tag_attributes_v2 (tag attributes)
-    - distributed_span_attributes_keys (attribute keys)
-    - distributed_signoz_error_index_v2 (error events)
-
-    Pure function so the seeder container (tests/seeder/) can reuse the
-    exact insert path used by the pytest fixtures. `conn` is a
-    clickhouse-connect Client.
-    """
-    resources: List[TracesResource] = []
-    for trace in traces:
-        resources.extend(trace.resource)
-
-    if len(resources) > 0:
-        conn.insert(
-            database="signoz_traces",
-            table="distributed_traces_v3_resource",
-            data=[resource.np_arr() for resource in resources],
-        )
-
-    tag_attributes: List[TracesTagAttributes] = []
-    for trace in traces:
-        tag_attributes.extend(trace.tag_attributes)
-
-    if len(tag_attributes) > 0:
-        conn.insert(
-            database="signoz_traces",
-            table="distributed_tag_attributes_v2",
-            data=[tag_attribute.np_arr() for tag_attribute in tag_attributes],
-        )
-
-    attribute_keys: List[TracesResourceOrAttributeKeys] = []
-    resource_keys: List[TracesResourceOrAttributeKeys] = []
-    for trace in traces:
-        attribute_keys.extend(trace.attribute_keys)
-        resource_keys.extend(trace.resource_keys)
-
-    if len(attribute_keys) > 0:
-        conn.insert(
-            database="signoz_traces",
-            table="distributed_span_attributes_keys",
-            data=[attribute_key.np_arr() for attribute_key in attribute_keys],
-        )
-
-    if len(resource_keys) > 0:
-        conn.insert(
-            database="signoz_traces",
-            table="distributed_span_attributes_keys",
-            data=[resource_key.np_arr() for resource_key in resource_keys],
-        )
-
-    conn.insert(
-        database="signoz_traces",
-        table="distributed_signoz_index_v3",
-        column_names=[
-            "ts_bucket_start",
-            "resource_fingerprint",
-            "timestamp",
-            "trace_id",
-            "span_id",
-            "trace_state",
-            "parent_span_id",
-            "flags",
-            "name",
-            "kind",
-            "kind_string",
-            "duration_nano",
-            "status_code",
-            "status_message",
-            "status_code_string",
-            "attributes_string",
-            "attributes_number",
-            "attributes_bool",
-            "resources_string",
-            "events",
-            "links",
-            "response_status_code",
-            "external_http_url",
-            "http_url",
-            "external_http_method",
-            "http_method",
-            "http_host",
-            "db_name",
-            "db_operation",
-            "has_error",
-            "is_remote",
-            "resource",
-        ],
-        data=[trace.np_arr() for trace in traces],
-    )
-
-    error_events: List[TracesErrorEvent] = []
-    for trace in traces:
-        error_events.extend(trace.error_events)
-
-    if len(error_events) > 0:
-        conn.insert(
-            database="signoz_traces",
-            table="distributed_signoz_error_index_v2",
-            data=[error_event.np_arr() for error_event in error_events],
-        )
-
-
-_TRACES_TABLES_TO_TRUNCATE = [
-    "signoz_index_v3",
-    "traces_v3_resource",
-    "tag_attributes_v2",
-    "span_attributes_keys",
-    "signoz_error_index_v2",
-]
-
-
-def truncate_traces_tables(conn, cluster: str) -> None:
-    """Truncate all traces tables. Used by the pytest fixture teardown and by
-    the seeder's DELETE /telemetry/traces endpoint."""
-    for table in _TRACES_TABLES_TO_TRUNCATE:
-        conn.query(f"TRUNCATE TABLE signoz_traces.{table} ON CLUSTER '{cluster}' SYNC")
-
-
 @pytest.fixture(name="insert_traces", scope="function")
 def insert_traces(
     clickhouse: types.TestContainerClickhouse,
 ) -> Generator[Callable[[List[Traces]], None], Any, None]:
     def _insert_traces(traces: List[Traces]) -> None:
-        insert_traces_to_clickhouse(clickhouse.conn, traces)
+        """
+        Insert traces into ClickHouse tables following the same logic as the Go exporter.
+        This function handles insertion into multiple tables:
+        - distributed_signoz_index_v3 (main traces table)
+        - distributed_traces_v3_resource (resource fingerprints)
+        - distributed_tag_attributes_v2 (tag attributes)
+        - distributed_span_attributes_keys (attribute keys)
+        - distributed_signoz_error_index_v2 (error events)
+        """
+        resources: List[TracesResource] = []
+        for trace in traces:
+            resources.extend(trace.resource)
+
+        if len(resources) > 0:
+            clickhouse.conn.insert(
+                database="signoz_traces",
+                table="distributed_traces_v3_resource",
+                data=[resource.np_arr() for resource in resources],
+            )
+
+        tag_attributes: List[TracesTagAttributes] = []
+        for trace in traces:
+            tag_attributes.extend(trace.tag_attributes)
+
+        if len(tag_attributes) > 0:
+            clickhouse.conn.insert(
+                database="signoz_traces",
+                table="distributed_tag_attributes_v2",
+                data=[tag_attribute.np_arr() for tag_attribute in tag_attributes],
+            )
+
+        attribute_keys: List[TracesResourceOrAttributeKeys] = []
+        resource_keys: List[TracesResourceOrAttributeKeys] = []
+        for trace in traces:
+            attribute_keys.extend(trace.attribute_keys)
+            resource_keys.extend(trace.resource_keys)
+
+        if len(attribute_keys) > 0:
+            clickhouse.conn.insert(
+                database="signoz_traces",
+                table="distributed_span_attributes_keys",
+                data=[attribute_key.np_arr() for attribute_key in attribute_keys],
+            )
+
+        if len(resource_keys) > 0:
+            clickhouse.conn.insert(
+                database="signoz_traces",
+                table="distributed_span_attributes_keys",
+                data=[resource_key.np_arr() for resource_key in resource_keys],
+            )
+
+        # Insert main traces
+        clickhouse.conn.insert(
+            database="signoz_traces",
+            table="distributed_signoz_index_v3",
+            column_names=[
+                "ts_bucket_start",
+                "resource_fingerprint",
+                "timestamp",
+                "trace_id",
+                "span_id",
+                "trace_state",
+                "parent_span_id",
+                "flags",
+                "name",
+                "kind",
+                "kind_string",
+                "duration_nano",
+                "status_code",
+                "status_message",
+                "status_code_string",
+                "attributes_string",
+                "attributes_number",
+                "attributes_bool",
+                "resources_string",
+                "events",
+                "links",
+                "response_status_code",
+                "external_http_url",
+                "http_url",
+                "external_http_method",
+                "http_method",
+                "http_host",
+                "db_name",
+                "db_operation",
+                "has_error",
+                "is_remote",
+                "resource",
+            ],
+            data=[trace.np_arr() for trace in traces],
+        )
+
+        # Insert error events
+        error_events: List[TracesErrorEvent] = []
+        for trace in traces:
+            error_events.extend(trace.error_events)
+
+        if len(error_events) > 0:
+            clickhouse.conn.insert(
+                database="signoz_traces",
+                table="distributed_signoz_error_index_v2",
+                data=[error_event.np_arr() for error_event in error_events],
+            )
 
     yield _insert_traces
 
-    truncate_traces_tables(
-        clickhouse.conn,
-        clickhouse.env["SIGNOZ_TELEMETRYSTORE_CLICKHOUSE_CLUSTER"],
+    clickhouse.conn.query(
+        f"TRUNCATE TABLE signoz_traces.signoz_index_v3 ON CLUSTER '{clickhouse.env['SIGNOZ_TELEMETRYSTORE_CLICKHOUSE_CLUSTER']}' SYNC"
+    )
+    clickhouse.conn.query(
+        f"TRUNCATE TABLE signoz_traces.traces_v3_resource ON CLUSTER '{clickhouse.env['SIGNOZ_TELEMETRYSTORE_CLICKHOUSE_CLUSTER']}' SYNC"
+    )
+    clickhouse.conn.query(
+        f"TRUNCATE TABLE signoz_traces.tag_attributes_v2 ON CLUSTER '{clickhouse.env['SIGNOZ_TELEMETRYSTORE_CLICKHOUSE_CLUSTER']}' SYNC"
+    )
+    clickhouse.conn.query(
+        f"TRUNCATE TABLE signoz_traces.span_attributes_keys ON CLUSTER '{clickhouse.env['SIGNOZ_TELEMETRYSTORE_CLICKHOUSE_CLUSTER']}' SYNC"
+    )
+    clickhouse.conn.query(
+        f"TRUNCATE TABLE signoz_traces.signoz_error_index_v2 ON CLUSTER '{clickhouse.env['SIGNOZ_TELEMETRYSTORE_CLICKHOUSE_CLUSTER']}' SYNC"
     )
 
 

tests/integration/fixtures/utils.py

@@ -1,4 +1,5 @@
 import datetime
+import os
 from typing import Any
 
 import isodate
@@ -25,3 +26,8 @@ def parse_duration(duration: Any) -> datetime.timedelta:
     if isinstance(duration, datetime.timedelta):
         return duration
     return datetime.timedelta(seconds=duration)
+
+
+def get_testdata_file_path(file: str) -> str:
+    testdata_dir = os.path.join(os.path.dirname(__file__), "..", "testdata")
+    return os.path.join(testdata_dir, file)

tests/integration/fixtures/zookeeper.py

@@ -3,7 +3,7 @@ import docker.errors
 import pytest
 from testcontainers.core.container import DockerContainer, Network
 
-from fixtures import reuse, types
+from fixtures import dev, types
 from fixtures.logger import setup_logger
 
 logger = setup_logger(__name__)
@@ -58,7 +58,7 @@ def zookeeper(
     def restore(cache: dict) -> types.TestContainerDocker:
         return types.TestContainerDocker.from_cache(cache)
 
-    return reuse.wrap(
+    return dev.wrap(
         request,
         pytestconfig,
         "zookeeper",

tests/integration/pyproject.toml

@@ -1,5 +1,5 @@
 [project]
-name = "tests"
+name = "integration"
 version = "0.1.0"
 description = ""
 authors = [{ name = "therealpandey", email = "vibhupandey28@gmail.com" }]
@@ -16,9 +16,6 @@ dependencies = [
     "sqlalchemy>=2.0.43",
     "selenium>=4.40.0",
     "isodate>=0.7.2",
-    "fastapi>=0.115",
-    "uvicorn[standard]>=0.34",
-    "py>=1.11",
 ]
 
 [dependency-groups]
@@ -30,26 +27,14 @@ dev = [
 ]
 
 [tool.pytest.ini_options]
-# Matched against basenames. Numeric-prefixed suite files (NN_name.py) plus
-# the bootstrap entrypoints (setup.py, run.py). Excludes seeder/server.py.
-python_files = ["[0-9][0-9]_*.py", "setup.py", "run.py"]
-# importlib mode: avoids sys.modules collisions between same-basename tests
-# (e.g. querier/01_logs.py vs rawexportdata/01_logs.py) now that all trees
-# share one rootdir at tests/. importlib also disables pytest's implicit
-# sys.path injection — pythonpath below makes `import fixtures` resolve.
-pythonpath = ["."]
-addopts = "-ra -p no:warnings --import-mode=importlib"
+python_files = "src/**/**.py"
 log_cli = true
 log_format = "%(asctime)s [%(levelname)s] (%(filename)s:%(lineno)s) %(message)s"
 log_date_format = "%Y-%m-%d %H:%M:%S"
+addopts = "-ra -p no:warnings"
 
 [tool.pylint.main]
-ignore = [".venv", "node_modules"]
-# `py` (the legacy pytest path lib) uses dynamic attributes that pylint's
-# static analyzer can't resolve. Whitelist it so `py.path.local` stops
-# firing no-member.
-extension-pkg-whitelist = ["py"]
-ignored-modules = ["py"]
+ignore = [".venv"]
 
 [tool.pylint.format]
 max-line-length = "400"