feat: update tests

feat: minor fix
Merge branch 'main' of github.com:SigNoz/signoz into feat/traces-table-migration
2026-06-11 03:10:32 +01:00 · 2026-06-10 19:22:38 +05:30 · 2026-06-10 18:59:19 +05:30 · 2026-06-10 18:21:21 +05:30 · 2026-06-10 18:14:14 +05:30 · 2026-06-10 18:08:42 +05:30
148 changed files with 8050 additions and 2359 deletions
--- a/deploy/docker-swarm/docker-compose.ha.yaml
+++ b/deploy/docker-swarm/docker-compose.ha.yaml
@@ -190,7 +190,7 @@ services:
      # - ../common/clickhouse/storage.xml:/etc/clickhouse-server/config.d/storage.xml
  signoz:
    !!merge <<: *db-depend
-    image: signoz/signoz:v0.127.1
+    image: signoz/signoz:v0.128.0
    ports:
      - "8080:8080" # signoz port
    #   - "6060:6060"     # pprof port
--- a/deploy/docker-swarm/docker-compose.yaml
+++ b/deploy/docker-swarm/docker-compose.yaml
@@ -117,7 +117,7 @@ services:
      # - ../common/clickhouse/storage.xml:/etc/clickhouse-server/config.d/storage.xml
  signoz:
    !!merge <<: *db-depend
-    image: signoz/signoz:v0.127.1
+    image: signoz/signoz:v0.128.0
    ports:
      - "8080:8080" # signoz port
    volumes:
--- a/deploy/docker/docker-compose.ha.yaml
+++ b/deploy/docker/docker-compose.ha.yaml
@@ -181,7 +181,7 @@ services:
      # - ../common/clickhouse/storage.xml:/etc/clickhouse-server/config.d/storage.xml
  signoz:
    !!merge <<: *db-depend
-    image: signoz/signoz:${VERSION:-v0.127.1}
+    image: signoz/signoz:${VERSION:-v0.128.0}
    container_name: signoz
    ports:
      - "8080:8080" # signoz port
--- a/deploy/docker/docker-compose.yaml
+++ b/deploy/docker/docker-compose.yaml
@@ -109,7 +109,7 @@ services:
      # - ../common/clickhouse/storage.xml:/etc/clickhouse-server/config.d/storage.xml
  signoz:
    !!merge <<: *db-depend
-    image: signoz/signoz:${VERSION:-v0.127.1}
+    image: signoz/signoz:${VERSION:-v0.128.0}
    container_name: signoz
    ports:
      - "8080:8080" # signoz port
--- a/docs/api/openapi.yml
+++ b/docs/api/openapi.yml
@@ -6726,11 +6726,6 @@ components:
      type: object
    SpantypesGettableWaterfallTrace:
      properties:
-        aggregations:
-          items:
-            $ref: '#/components/schemas/SpantypesSpanAggregationResult'
-          nullable: true
-          type: array
        endTimestampMillis:
          minimum: 0
          type: integer
@@ -6818,14 +6813,6 @@ components:
      type: object
    SpantypesPostableWaterfall:
      properties:
-        aggregations:
-          items:
-            $ref: '#/components/schemas/SpantypesSpanAggregation'
-          nullable: true
-          type: array
-        limit:
-          minimum: 0
-          type: integer
        selectedSpanId:
          type: string
        uncollapsedSpans:
@@ -20681,76 +20668,6 @@ paths:
      summary: Get flamegraph view for a trace
      tags:
      - tracedetail
-  /api/v3/traces/{traceID}/waterfall:
-    post:
-      deprecated: false
-      description: Returns the waterfall view of spans for a given trace ID with tree
-        structure, metadata, and windowed pagination
-      operationId: GetWaterfall
-      parameters:
-      - in: path
-        name: traceID
-        required: true
-        schema:
-          type: string
-      requestBody:
-        content:
-          application/json:
-            schema:
-              $ref: '#/components/schemas/SpantypesPostableWaterfall'
-      responses:
-        "200":
-          content:
-            application/json:
-              schema:
-                properties:
-                  data:
-                    $ref: '#/components/schemas/SpantypesGettableWaterfallTrace'
-                  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: Get waterfall view for a trace
-      tags:
-      - tracedetail
  /api/v4/traces/{traceID}/waterfall:
    post:
      deprecated: false
--- a/frontend/src/api/alerts/getTriggered.ts
+++ b/frontend/src/api/alerts/getTriggered.ts
@@ -5,6 +5,13 @@ import convertObjectIntoParams from 'lib/query/convertObjectIntoParams';
 import { ErrorResponse, SuccessResponse } from 'types/api';
 import { PayloadProps, Props } from 'types/api/alerts/getTriggered';

+/**
+ * @deprecated Use the generated `useGetAlerts` hook (or `getAlerts` fetcher) from
+ * `api/generated/services/alerts` instead. This hand-written client targets the
+ * same endpoint and will be removed once call sites migrate.
+ *
+ * Part of https://github.com/SigNoz/engineering-pod/issues/5289, add a comment or update when removing this method.
+ */
 const getTriggered = async (
 	props: Props,
 ): Promise<SuccessResponse<PayloadProps> | ErrorResponse> => {
--- a/frontend/src/api/channels/createEmail.ts
+++ b/frontend/src/api/channels/createEmail.ts
@@ -4,6 +4,13 @@ import { AxiosError } from 'axios';
 import { ErrorV2Resp, SuccessResponseV2 } from 'types/api';
 import { PayloadProps, Props } from 'types/api/channels/createEmail';

+/**
+ * @deprecated Use the generated `useCreateChannel` hook (or `createChannel` fetcher) from
+ * `api/generated/services/channels` instead. This hand-written client targets the
+ * same endpoint and will be removed once call sites migrate.
+ *
+ * Part of https://github.com/SigNoz/engineering-pod/issues/5289, add a comment or update when removing this method.
+ */
 const create = async (
 	props: Props,
 ): Promise<SuccessResponseV2<PayloadProps>> => {
--- a/frontend/src/api/channels/createMsTeams.ts
+++ b/frontend/src/api/channels/createMsTeams.ts
@@ -4,6 +4,13 @@ import { AxiosError } from 'axios';
 import { ErrorV2Resp, SuccessResponseV2 } from 'types/api';
 import { PayloadProps, Props } from 'types/api/channels/createMsTeams';

+/**
+ * @deprecated Use the generated `useCreateChannel` hook (or `createChannel` fetcher) from
+ * `api/generated/services/channels` instead. This hand-written client targets the
+ * same endpoint and will be removed once call sites migrate.
+ *
+ * Part of https://github.com/SigNoz/engineering-pod/issues/5289, add a comment or update when removing this method.
+ */
 const create = async (
 	props: Props,
 ): Promise<SuccessResponseV2<PayloadProps>> => {
--- a/frontend/src/api/channels/createOpsgenie.ts
+++ b/frontend/src/api/channels/createOpsgenie.ts
@@ -4,6 +4,13 @@ import { AxiosError } from 'axios';
 import { ErrorV2Resp, SuccessResponseV2 } from 'types/api';
 import { PayloadProps, Props } from 'types/api/channels/createOpsgenie';

+/**
+ * @deprecated Use the generated `useCreateChannel` hook (or `createChannel` fetcher) from
+ * `api/generated/services/channels` instead. This hand-written client targets the
+ * same endpoint and will be removed once call sites migrate.
+ *
+ * Part of https://github.com/SigNoz/engineering-pod/issues/5289, add a comment or update when removing this method.
+ */
 const create = async (
 	props: Props,
 ): Promise<SuccessResponseV2<PayloadProps>> => {
--- a/frontend/src/api/channels/createPager.ts
+++ b/frontend/src/api/channels/createPager.ts
@@ -4,6 +4,13 @@ import { AxiosError } from 'axios';
 import { ErrorV2Resp, SuccessResponseV2 } from 'types/api';
 import { PayloadProps, Props } from 'types/api/channels/createPager';

+/**
+ * @deprecated Use the generated `useCreateChannel` hook (or `createChannel` fetcher) from
+ * `api/generated/services/channels` instead. This hand-written client targets the
+ * same endpoint and will be removed once call sites migrate.
+ *
+ * Part of https://github.com/SigNoz/engineering-pod/issues/5289, add a comment or update when removing this method.
+ */
 const create = async (
 	props: Props,
 ): Promise<SuccessResponseV2<PayloadProps>> => {
--- a/frontend/src/api/channels/createSlack.ts
+++ b/frontend/src/api/channels/createSlack.ts
@@ -4,6 +4,13 @@ import { AxiosError } from 'axios';
 import { ErrorV2Resp, SuccessResponseV2 } from 'types/api';
 import { PayloadProps, Props } from 'types/api/channels/createSlack';

+/**
+ * @deprecated Use the generated `useCreateChannel` hook (or `createChannel` fetcher) from
+ * `api/generated/services/channels` instead. This hand-written client targets the
+ * same endpoint and will be removed once call sites migrate.
+ *
+ * Part of https://github.com/SigNoz/engineering-pod/issues/5289, add a comment or update when removing this method.
+ */
 const create = async (
 	props: Props,
 ): Promise<SuccessResponseV2<PayloadProps>> => {
--- a/frontend/src/api/channels/createWebhook.ts
+++ b/frontend/src/api/channels/createWebhook.ts
@@ -4,6 +4,13 @@ import { AxiosError } from 'axios';
 import { ErrorV2Resp, SuccessResponseV2 } from 'types/api';
 import { PayloadProps, Props } from 'types/api/channels/createWebhook';

+/**
+ * @deprecated Use the generated `useCreateChannel` hook (or `createChannel` fetcher) from
+ * `api/generated/services/channels` instead. This hand-written client targets the
+ * same endpoint and will be removed once call sites migrate.
+ *
+ * Part of https://github.com/SigNoz/engineering-pod/issues/5289, add a comment or update when removing this method.
+ */
 const create = async (
 	props: Props,
 ): Promise<SuccessResponseV2<PayloadProps>> => {
--- a/frontend/src/api/channels/delete.ts
+++ b/frontend/src/api/channels/delete.ts
@@ -4,6 +4,13 @@ import { AxiosError } from 'axios';
 import { ErrorV2Resp, SuccessResponseV2 } from 'types/api';
 import { PayloadProps, Props } from 'types/api/channels/delete';

+/**
+ * @deprecated Use the generated `useDeleteChannelByID` hook (or `deleteChannelByID` fetcher) from
+ * `api/generated/services/channels` instead. This hand-written client targets the
+ * same endpoint and will be removed once call sites migrate.
+ *
+ * Part of https://github.com/SigNoz/engineering-pod/issues/5289, add a comment or update when removing this method.
+ */
 const deleteChannel = async (
 	props: Props,
 ): Promise<SuccessResponseV2<PayloadProps>> => {
--- a/frontend/src/api/channels/editEmail.ts
+++ b/frontend/src/api/channels/editEmail.ts
@@ -4,6 +4,13 @@ import { AxiosError } from 'axios';
 import { ErrorV2Resp, SuccessResponseV2 } from 'types/api';
 import { PayloadProps, Props } from 'types/api/channels/editEmail';

+/**
+ * @deprecated Use the generated `useUpdateChannelByID` hook (or `updateChannelByID` fetcher) from
+ * `api/generated/services/channels` instead. This hand-written client targets the
+ * same endpoint and will be removed once call sites migrate.
+ *
+ * Part of https://github.com/SigNoz/engineering-pod/issues/5289, add a comment or update when removing this method.
+ */
 const editEmail = async (
 	props: Props,
 ): Promise<SuccessResponseV2<PayloadProps>> => {
--- a/frontend/src/api/channels/editMsTeams.ts
+++ b/frontend/src/api/channels/editMsTeams.ts
@@ -4,6 +4,13 @@ import { AxiosError } from 'axios';
 import { ErrorV2Resp, SuccessResponseV2 } from 'types/api';
 import { PayloadProps, Props } from 'types/api/channels/editMsTeams';

+/**
+ * @deprecated Use the generated `useUpdateChannelByID` hook (or `updateChannelByID` fetcher) from
+ * `api/generated/services/channels` instead. This hand-written client targets the
+ * same endpoint and will be removed once call sites migrate.
+ *
+ * Part of https://github.com/SigNoz/engineering-pod/issues/5289, add a comment or update when removing this method.
+ */
 const editMsTeams = async (
 	props: Props,
 ): Promise<SuccessResponseV2<PayloadProps>> => {
--- a/frontend/src/api/channels/editOpsgenie.ts
+++ b/frontend/src/api/channels/editOpsgenie.ts
@@ -4,6 +4,13 @@ import { AxiosError } from 'axios';
 import { ErrorResponse, ErrorV2Resp, SuccessResponseV2 } from 'types/api';
 import { PayloadProps, Props } from 'types/api/channels/editOpsgenie';

+/**
+ * @deprecated Use the generated `useUpdateChannelByID` hook (or `updateChannelByID` fetcher) from
+ * `api/generated/services/channels` instead. This hand-written client targets the
+ * same endpoint and will be removed once call sites migrate.
+ *
+ * Part of https://github.com/SigNoz/engineering-pod/issues/5289, add a comment or update when removing this method.
+ */
 const editOpsgenie = async (
 	props: Props,
 ): Promise<SuccessResponseV2<PayloadProps> | ErrorResponse> => {
--- a/frontend/src/api/channels/editPager.ts
+++ b/frontend/src/api/channels/editPager.ts
@@ -4,6 +4,13 @@ import { AxiosError } from 'axios';
 import { ErrorV2Resp, SuccessResponseV2 } from 'types/api';
 import { PayloadProps, Props } from 'types/api/channels/editPager';

+/**
+ * @deprecated Use the generated `useUpdateChannelByID` hook (or `updateChannelByID` fetcher) from
+ * `api/generated/services/channels` instead. This hand-written client targets the
+ * same endpoint and will be removed once call sites migrate.
+ *
+ * Part of https://github.com/SigNoz/engineering-pod/issues/5289, add a comment or update when removing this method.
+ */
 const editPager = async (
 	props: Props,
 ): Promise<SuccessResponseV2<PayloadProps>> => {
--- a/frontend/src/api/channels/editSlack.ts
+++ b/frontend/src/api/channels/editSlack.ts
@@ -4,6 +4,13 @@ import { AxiosError } from 'axios';
 import { ErrorV2Resp, SuccessResponseV2 } from 'types/api';
 import { PayloadProps, Props } from 'types/api/channels/editSlack';

+/**
+ * @deprecated Use the generated `useUpdateChannelByID` hook (or `updateChannelByID` fetcher) from
+ * `api/generated/services/channels` instead. This hand-written client targets the
+ * same endpoint and will be removed once call sites migrate.
+ *
+ * Part of https://github.com/SigNoz/engineering-pod/issues/5289, add a comment or update when removing this method.
+ */
 const editSlack = async (
 	props: Props,
 ): Promise<SuccessResponseV2<PayloadProps>> => {
--- a/frontend/src/api/channels/editWebhook.ts
+++ b/frontend/src/api/channels/editWebhook.ts
@@ -4,6 +4,13 @@ import { AxiosError } from 'axios';
 import { ErrorV2Resp, SuccessResponseV2 } from 'types/api';
 import { PayloadProps, Props } from 'types/api/channels/editWebhook';

+/**
+ * @deprecated Use the generated `useUpdateChannelByID` hook (or `updateChannelByID` fetcher) from
+ * `api/generated/services/channels` instead. This hand-written client targets the
+ * same endpoint and will be removed once call sites migrate.
+ *
+ * Part of https://github.com/SigNoz/engineering-pod/issues/5289, add a comment or update when removing this method.
+ */
 const editWebhook = async (
 	props: Props,
 ): Promise<SuccessResponseV2<PayloadProps>> => {
--- a/frontend/src/api/channels/get.ts
+++ b/frontend/src/api/channels/get.ts
@@ -5,6 +5,13 @@ import { ErrorV2Resp, SuccessResponseV2 } from 'types/api';
 import { PayloadProps, Props } from 'types/api/channels/get';
 import { Channels } from 'types/api/channels/getAll';

+/**
+ * @deprecated Use the generated `useGetChannelByID` hook (or `getChannelByID` fetcher) from
+ * `api/generated/services/channels` instead. This hand-written client targets the
+ * same endpoint and will be removed once call sites migrate.
+ *
+ * Part of https://github.com/SigNoz/engineering-pod/issues/5289, add a comment or update when removing this method.
+ */
 const get = async (props: Props): Promise<SuccessResponseV2<Channels>> => {
 	try {
 		const response = await axios.get<PayloadProps>(`/channels/${props.id}`);
--- a/frontend/src/api/channels/getAll.ts
+++ b/frontend/src/api/channels/getAll.ts
@@ -4,6 +4,13 @@ import { AxiosError } from 'axios';
 import { ErrorV2Resp, SuccessResponseV2 } from 'types/api';
 import { Channels, PayloadProps } from 'types/api/channels/getAll';

+/**
+ * @deprecated Use the generated `useListChannels` hook (or `listChannels` fetcher) from
+ * `api/generated/services/channels` instead. This hand-written client targets the
+ * same endpoint and will be removed once call sites migrate.
+ *
+ * Part of https://github.com/SigNoz/engineering-pod/issues/5289, add a comment or update when removing this method.
+ */
 const getAll = async (): Promise<SuccessResponseV2<Channels[]>> => {
 	try {
 		const response = await axios.get<PayloadProps>('/channels');
--- a/frontend/src/api/dashboard/public/createPublicDashboard.ts
+++ b/frontend/src/api/dashboard/public/createPublicDashboard.ts
@@ -5,6 +5,13 @@ import { DEFAULT_TIME_RANGE } from 'container/TopNav/DateTimeSelectionV2/constan
 import { ErrorV2Resp, 	 SuccessResponseV2 } from 'types/api';
 import { CreatePublicDashboardProps } from 'types/api/dashboard/public/create';

+/**
+ * @deprecated Use the generated `useCreatePublicDashboard` hook (or `createPublicDashboard` fetcher) from
+ * `api/generated/services/dashboard` instead. This hand-written client targets the
+ * same endpoint and will be removed once call sites migrate.
+ *
+ * Part of https://github.com/SigNoz/engineering-pod/issues/5289, add a comment or update when removing this method.
+ */
 const createPublicDashboard = async (
 	props: CreatePublicDashboardProps,
 ): Promise<SuccessResponseV2<CreatePublicDashboardProps>> => {
--- a/frontend/src/api/dashboard/public/getPublicDashboardData.ts
+++ b/frontend/src/api/dashboard/public/getPublicDashboardData.ts
@@ -4,6 +4,13 @@ import { AxiosError } from 'axios';
 import { ErrorV2Resp, SuccessResponseV2 } from 'types/api';
 import { GetPublicDashboardDataProps, PayloadProps,PublicDashboardDataProps } from 'types/api/dashboard/public/get';

+/**
+ * @deprecated Use the generated `useGetPublicDashboardData` hook (or `getPublicDashboardData` fetcher) from
+ * `api/generated/services/dashboard` instead. This hand-written client targets the
+ * same endpoint and will be removed once call sites migrate.
+ *
+ * Part of https://github.com/SigNoz/engineering-pod/issues/5289, add a comment or update when removing this method.
+ */
 const getPublicDashboardData = async (props: GetPublicDashboardDataProps): Promise<SuccessResponseV2<PublicDashboardDataProps>> => {
 	try {
 		const response = await axios.get<PayloadProps>(`/public/dashboards/${props.id}`);
--- a/frontend/src/api/dashboard/public/getPublicDashboardMeta.ts
+++ b/frontend/src/api/dashboard/public/getPublicDashboardMeta.ts
@@ -4,6 +4,13 @@ import { AxiosError } from 'axios';
 import { ErrorV2Resp, SuccessResponseV2 } from 'types/api';
 import { GetPublicDashboardMetaProps, PayloadProps,PublicDashboardMetaProps } from 'types/api/dashboard/public/getMeta';

+/**
+ * @deprecated Use the generated `useGetPublicDashboard` hook (or `getPublicDashboard` fetcher) from
+ * `api/generated/services/dashboard` instead. This hand-written client targets the
+ * same endpoint and will be removed once call sites migrate.
+ *
+ * Part of https://github.com/SigNoz/engineering-pod/issues/5289, add a comment or update when removing this method.
+ */
 const getPublicDashboardMeta = async (props: GetPublicDashboardMetaProps): Promise<SuccessResponseV2<PublicDashboardMetaProps>> => {
 	try {
 		const response = await axios.get<PayloadProps>(`/dashboards/${props.id}/public`);
--- a/frontend/src/api/dashboard/public/getPublicDashboardWidgetData.ts
+++ b/frontend/src/api/dashboard/public/getPublicDashboardWidgetData.ts
@@ -6,6 +6,13 @@ import { ErrorV2Resp, SuccessResponseV2 } from 'types/api';
 import { GetPublicDashboardWidgetDataProps } from 'types/api/dashboard/public/getWidgetData';


+/**
+ * @deprecated Use the generated `useGetPublicDashboardWidgetQueryRange` hook (or `getPublicDashboardWidgetQueryRange` fetcher) from
+ * `api/generated/services/dashboard` instead. This hand-written client targets the
+ * same endpoint and will be removed once call sites migrate.
+ *
+ * Part of https://github.com/SigNoz/engineering-pod/issues/5289, add a comment or update when removing this method.
+ */
 const getPublicDashboardWidgetData = async (props: GetPublicDashboardWidgetDataProps): Promise<SuccessResponseV2<MetricRangePayloadV5>> => {
 	try {
 		const response = await axios.get(`/public/dashboards/${props.id}/widgets/${props.index}/query_range`, {
--- a/frontend/src/api/dashboard/public/revokePublicDashboardAccess.ts
+++ b/frontend/src/api/dashboard/public/revokePublicDashboardAccess.ts
@@ -4,6 +4,13 @@ import { AxiosError } from 'axios';
 import { ErrorV2Resp, SuccessResponseV2 } from 'types/api';
 import { PayloadProps,RevokePublicDashboardAccessProps } from 'types/api/dashboard/public/delete';

+/**
+ * @deprecated Use the generated `useDeletePublicDashboard` hook (or `deletePublicDashboard` fetcher) from
+ * `api/generated/services/dashboard` instead. This hand-written client targets the
+ * same endpoint and will be removed once call sites migrate.
+ *
+ * Part of https://github.com/SigNoz/engineering-pod/issues/5289, add a comment or update when removing this method.
+ */
 const revokePublicDashboardAccess = async (
 	props: RevokePublicDashboardAccessProps,
 ): Promise<SuccessResponseV2<PayloadProps>> => {
--- a/frontend/src/api/dashboard/public/updatePublicDashboard.ts
+++ b/frontend/src/api/dashboard/public/updatePublicDashboard.ts
@@ -5,6 +5,13 @@ import { DEFAULT_TIME_RANGE } from 'container/TopNav/DateTimeSelectionV2/constan
 import {  ErrorV2Resp, SuccessResponseV2 } from 'types/api';
 import { UpdatePublicDashboardProps } from 'types/api/dashboard/public/update';

+/**
+ * @deprecated Use the generated `useUpdatePublicDashboard` hook (or `updatePublicDashboard` fetcher) from
+ * `api/generated/services/dashboard` instead. This hand-written client targets the
+ * same endpoint and will be removed once call sites migrate.
+ *
+ * Part of https://github.com/SigNoz/engineering-pod/issues/5289, add a comment or update when removing this method.
+ */
 const updatePublicDashboard = async (
 	props: UpdatePublicDashboardProps,
 ): Promise<SuccessResponseV2<UpdatePublicDashboardProps>> => {
--- a/frontend/src/api/dashboard/substitute_vars.ts
+++ b/frontend/src/api/dashboard/substitute_vars.ts
@@ -9,6 +9,13 @@ interface ISubstituteVars {
 	compositeQuery: ICompositeMetricQuery;
 }

+/**
+ * @deprecated Use the generated `useReplaceVariables` hook (or `replaceVariables` fetcher) from
+ * `api/generated/services/querier` instead. This hand-written client targets the
+ * same endpoint and will be removed once call sites migrate.
+ *
+ * Part of https://github.com/SigNoz/engineering-pod/issues/5289, add a comment or update when removing this method.
+ */
 export const getSubstituteVars = async (
 	props?: Partial<QueryRangePayloadV5>,
 	signal?: AbortSignal,
--- a/frontend/src/api/dynamicVariables/getFieldKeys.ts
+++ b/frontend/src/api/dynamicVariables/getFieldKeys.ts
@@ -8,6 +8,12 @@ import { FieldKeyResponse } from 'types/api/dynamicVariables/getFieldKeys';
 * Get field keys for a given signal type
 * @param signal Type of signal (traces, logs, metrics)
 * @param name Optional search text
+ *
+ * @deprecated Use the generated `useGetFieldsKeys` hook (or `getFieldsKeys` fetcher) from
+ * `api/generated/services/fields` instead. This hand-written client targets the
+ * same endpoint and will be removed once call sites migrate.
+ *
+ * Part of https://github.com/SigNoz/engineering-pod/issues/5289, add a comment or update when removing this method.
 */
 export const getFieldKeys = async (
 	signal?: 'traces' | 'logs' | 'metrics',
--- a/frontend/src/api/dynamicVariables/getFieldValues.ts
+++ b/frontend/src/api/dynamicVariables/getFieldValues.ts
@@ -11,6 +11,12 @@ import { FieldValueResponse } from 'types/api/dynamicVariables/getFieldValues';
 * @param name Name of the attribute for which values are being fetched
 * @param value Optional search text
 * @param existingQuery Optional existing query - across all present dynamic variables
+ *
+ * @deprecated Use the generated `useGetFieldsValues` hook (or `getFieldsValues` fetcher) from
+ * `api/generated/services/fields` instead. This hand-written client targets the
+ * same endpoint and will be removed once call sites migrate.
+ *
+ * Part of https://github.com/SigNoz/engineering-pod/issues/5289, add a comment or update when removing this method.
 */
 export const getFieldValues = async (
 	signal?: 'traces' | 'logs' | 'metrics',
--- a/frontend/src/api/generated/services/sigNoz.schemas.ts
+++ b/frontend/src/api/generated/services/sigNoz.schemas.ts
@@ -8095,10 +8095,6 @@ export interface SpantypesWaterfallSpanDTO {
 }

 export interface SpantypesGettableWaterfallTraceDTO {
-	/**
-	 * @type array,null
-	 */
-	aggregations?: SpantypesSpanAggregationResultDTO[] | null;
 	/**
 	 * @type integer
 	 * @minimum 0
@@ -8218,15 +8214,6 @@ export interface SpantypesPostableTraceAggregationsDTO {
 }

 export interface SpantypesPostableWaterfallDTO {
-	/**
-	 * @type array,null
-	 */
-	aggregations?: SpantypesSpanAggregationDTO[] | null;
-	/**
-	 * @type integer
-	 * @minimum 0
-	 */
-	limit?: number;
 	/**
 	 * @type string
 	 */
@@ -10521,17 +10508,6 @@ export type GetFlamegraph200 = {
 	status: string;
 };

-export type GetWaterfallPathParameters = {
-	traceID: string;
-};
-export type GetWaterfall200 = {
-	data: SpantypesGettableWaterfallTraceDTO;
-	/**
-	 * @type string
-	 */
-	status: string;
-};
-
 export type GetWaterfallV4PathParameters = {
 	traceID: string;
 };
--- a/frontend/src/api/generated/services/tracedetail/index.ts
+++ b/frontend/src/api/generated/services/tracedetail/index.ts
@@ -16,8 +16,6 @@ import type {
 	GetFlamegraphPathParameters,
 	GetTraceAggregations200,
 	GetTraceAggregationsPathParameters,
-	GetWaterfall200,
-	GetWaterfallPathParameters,
 	GetWaterfallV4200,
 	GetWaterfallV4PathParameters,
 	RenderErrorResponseDTO,
@@ -228,105 +226,6 @@ export const useGetFlamegraph = <
 > => {
 	return useMutation(getGetFlamegraphMutationOptions(options));
 };
-/**
- * Returns the waterfall view of spans for a given trace ID with tree structure, metadata, and windowed pagination
- * @summary Get waterfall view for a trace
- */
-export const getWaterfall = (
-	{ traceID }: GetWaterfallPathParameters,
-	spantypesPostableWaterfallDTO?: BodyType<SpantypesPostableWaterfallDTO>,
-	signal?: AbortSignal,
-) => {
-	return GeneratedAPIInstance<GetWaterfall200>({
-		url: `/api/v3/traces/${traceID}/waterfall`,
-		method: 'POST',
-		headers: { 'Content-Type': 'application/json' },
-		data: spantypesPostableWaterfallDTO,
-		signal,
-	});
-};
-
-export const getGetWaterfallMutationOptions = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown,
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof getWaterfall>>,
-		TError,
-		{
-			pathParams: GetWaterfallPathParameters;
-			data?: BodyType<SpantypesPostableWaterfallDTO>;
-		},
-		TContext
-	>;
-}): UseMutationOptions<
-	Awaited<ReturnType<typeof getWaterfall>>,
-	TError,
-	{
-		pathParams: GetWaterfallPathParameters;
-		data?: BodyType<SpantypesPostableWaterfallDTO>;
-	},
-	TContext
-> => {
-	const mutationKey = ['getWaterfall'];
-	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 getWaterfall>>,
-		{
-			pathParams: GetWaterfallPathParameters;
-			data?: BodyType<SpantypesPostableWaterfallDTO>;
-		}
-	> = (props) => {
-		const { pathParams, data } = props ?? {};
-
-		return getWaterfall(pathParams, data);
-	};
-
-	return { mutationFn, ...mutationOptions };
-};
-
-export type GetWaterfallMutationResult = NonNullable<
-	Awaited<ReturnType<typeof getWaterfall>>
->;
-export type GetWaterfallMutationBody =
-	| BodyType<SpantypesPostableWaterfallDTO>
-	| undefined;
-export type GetWaterfallMutationError = ErrorType<RenderErrorResponseDTO>;
-
-/**
- * @summary Get waterfall view for a trace
- */
-export const useGetWaterfall = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown,
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof getWaterfall>>,
-		TError,
-		{
-			pathParams: GetWaterfallPathParameters;
-			data?: BodyType<SpantypesPostableWaterfallDTO>;
-		},
-		TContext
-	>;
-}): UseMutationResult<
-	Awaited<ReturnType<typeof getWaterfall>>,
-	TError,
-	{
-		pathParams: GetWaterfallPathParameters;
-		data?: BodyType<SpantypesPostableWaterfallDTO>;
-	},
-	TContext
-> => {
-	return useMutation(getGetWaterfallMutationOptions(options));
-};
 /**
 * Returns the waterfall view of spans including all spans if total spans are under a limit, a max count otherwise. Aggregations are dropped compared to v3
 * @summary Get waterfall view for a trace
--- a/frontend/src/api/querySuggestions/getKeySuggestions.ts
+++ b/frontend/src/api/querySuggestions/getKeySuggestions.ts
@@ -5,6 +5,13 @@ import {
 	QueryKeySuggestionsResponseProps,
 } from 'types/api/querySuggestions/types';

+/**
+ * @deprecated Use the generated `useGetFieldsKeys` hook (or `getFieldsKeys` fetcher) from
+ * `api/generated/services/fields` instead. This hand-written client targets the
+ * same endpoint and will be removed once call sites migrate.
+ *
+ * Part of https://github.com/SigNoz/engineering-pod/issues/5289, add a comment or update when removing this method.
+ */
 export const getKeySuggestions = (
 	props: QueryKeyRequestProps,
 ): Promise<AxiosResponse<QueryKeySuggestionsResponseProps>> => {
--- a/frontend/src/api/querySuggestions/getValueSuggestion.ts
+++ b/frontend/src/api/querySuggestions/getValueSuggestion.ts
@@ -5,6 +5,13 @@ import {
 	QueryKeyValueSuggestionsResponseProps,
 } from 'types/api/querySuggestions/types';

+/**
+ * @deprecated Use the generated `useGetFieldsValues` hook (or `getFieldsValues` fetcher) from
+ * `api/generated/services/fields` instead. This hand-written client targets the
+ * same endpoint and will be removed once call sites migrate.
+ *
+ * Part of https://github.com/SigNoz/engineering-pod/issues/5289, add a comment or update when removing this method.
+ */
 export const getValueSuggestions = (
 	props: QueryKeyValueRequestProps,
 ): Promise<AxiosResponse<QueryKeyValueSuggestionsResponseProps>> => {
--- a/frontend/src/api/routingPolicies/createRoutingPolicy.ts
+++ b/frontend/src/api/routingPolicies/createRoutingPolicy.ts
@@ -15,6 +15,13 @@ export interface CreateRoutingPolicyResponse {
 	message: string;
 }

+/**
+ * @deprecated Use the generated `useCreateRoutePolicy` hook (or `createRoutePolicy` fetcher) from
+ * `api/generated/services/routepolicies` instead. This hand-written client targets the
+ * same endpoint and will be removed once call sites migrate.
+ *
+ * Part of https://github.com/SigNoz/engineering-pod/issues/5289, add a comment or update when removing this method.
+ */
 const createRoutingPolicy = async (
 	props: CreateRoutingPolicyBody,
 ): Promise<
--- a/frontend/src/api/routingPolicies/deleteRoutingPolicy.ts
+++ b/frontend/src/api/routingPolicies/deleteRoutingPolicy.ts
@@ -8,6 +8,13 @@ export interface DeleteRoutingPolicyResponse {
 	message: string;
 }

+/**
+ * @deprecated Use the generated `useDeleteRoutePolicyByID` hook (or `deleteRoutePolicyByID` fetcher) from
+ * `api/generated/services/routepolicies` instead. This hand-written client targets the
+ * same endpoint and will be removed once call sites migrate.
+ *
+ * Part of https://github.com/SigNoz/engineering-pod/issues/5289, add a comment or update when removing this method.
+ */
 const deleteRoutingPolicy = async (
 	routingPolicyId: string,
 ): Promise<
--- a/frontend/src/api/routingPolicies/getRoutingPolicies.ts
+++ b/frontend/src/api/routingPolicies/getRoutingPolicies.ts
@@ -20,6 +20,13 @@ export interface GetRoutingPoliciesResponse {
 	data?: ApiRoutingPolicy[];
 }

+/**
+ * @deprecated Use the generated `useGetAllRoutePolicies` hook (or `getAllRoutePolicies` fetcher) from
+ * `api/generated/services/routepolicies` instead. This hand-written client targets the
+ * same endpoint and will be removed once call sites migrate.
+ *
+ * Part of https://github.com/SigNoz/engineering-pod/issues/5289, add a comment or update when removing this method.
+ */
 export const getRoutingPolicies = async (
 	signal?: AbortSignal,
 	headers?: Record<string, string>,
--- a/frontend/src/api/routingPolicies/updateRoutingPolicy.ts
+++ b/frontend/src/api/routingPolicies/updateRoutingPolicy.ts
@@ -15,6 +15,13 @@ export interface UpdateRoutingPolicyResponse {
 	message: string;
 }

+/**
+ * @deprecated Use the generated `useUpdateRoutePolicy` hook (or `updateRoutePolicy` fetcher) from
+ * `api/generated/services/routepolicies` instead. This hand-written client targets the
+ * same endpoint and will be removed once call sites migrate.
+ *
+ * Part of https://github.com/SigNoz/engineering-pod/issues/5289, add a comment or update when removing this method.
+ */
 const updateRoutingPolicy = async (
 	id: string,
 	props: UpdateRoutingPolicyBody,
--- a/frontend/src/api/trace/getTraceV4.tsx
+++ b/frontend/src/api/trace/getTraceV4.tsx
@@ -27,7 +27,6 @@ const getTraceV4 = async (
 		{
 			selectedSpanId: props.selectedSpanId,
 			uncollapsedSpans,
-			limit: 10000,
 		},
 	);

--- a/frontend/src/api/v1/factor_password/resetPassword.ts
+++ b/frontend/src/api/v1/factor_password/resetPassword.ts
@@ -4,6 +4,13 @@ import { AxiosError } from 'axios';
 import { ErrorV2Resp, SuccessResponseV2 } from 'types/api';
 import { PayloadProps, Props } from 'types/api/user/resetPassword';

+/**
+ * @deprecated Use the generated `useResetPassword` hook (or `resetPassword` fetcher) from
+ * `api/generated/services/users` instead. This hand-written client targets the
+ * same endpoint and will be removed once call sites migrate.
+ *
+ * Part of https://github.com/SigNoz/engineering-pod/issues/5289, add a comment or update when removing this method.
+ */
 const resetPassword = async (
 	props: Props,
 ): Promise<SuccessResponseV2<PayloadProps>> => {
--- a/frontend/src/api/v1/invite/bulk/create.ts
+++ b/frontend/src/api/v1/invite/bulk/create.ts
@@ -4,6 +4,13 @@ import { AxiosError } from 'axios';
 import { ErrorV2Resp, SuccessResponseV2 } from 'types/api';
 import { UsersProps } from 'types/api/user/inviteUsers';

+/**
+ * @deprecated Use the generated `useCreateBulkInvite` hook (or `createBulkInvite` fetcher) from
+ * `api/generated/services/users` instead. This hand-written client targets the
+ * same endpoint and will be removed once call sites migrate.
+ *
+ * Part of https://github.com/SigNoz/engineering-pod/issues/5289, add a comment or update when removing this method.
+ */
 const inviteUsers = async (
 	users: UsersProps,
 ): Promise<SuccessResponseV2<null>> => {
--- a/frontend/src/api/v1/invite/create.ts
+++ b/frontend/src/api/v1/invite/create.ts
@@ -4,6 +4,13 @@ import { AxiosError } from 'axios';
 import { ErrorV2Resp, SuccessResponseV2 } from 'types/api';
 import { PayloadProps, Props } from 'types/api/user/setInvite';

+/**
+ * @deprecated Use the generated `useCreateInvite` hook (or `createInvite` fetcher) from
+ * `api/generated/services/users` instead. This hand-written client targets the
+ * same endpoint and will be removed once call sites migrate.
+ *
+ * Part of https://github.com/SigNoz/engineering-pod/issues/5289, add a comment or update when removing this method.
+ */
 const sendInvite = async (
 	props: Props,
 ): Promise<SuccessResponseV2<PayloadProps>> => {
--- a/frontend/src/api/v1/org/preferences/list.ts
+++ b/frontend/src/api/v1/org/preferences/list.ts
@@ -5,6 +5,13 @@ import { ErrorV2Resp, SuccessResponseV2 } from 'types/api';
 import { PayloadProps } from 'types/api/preferences/list';
 import { OrgPreference } from 'types/api/preferences/preference';

+/**
+ * @deprecated Use the generated `useListOrgPreferences` hook (or `listOrgPreferences` fetcher) from
+ * `api/generated/services/preferences` instead. This hand-written client targets the
+ * same endpoint and will be removed once call sites migrate.
+ *
+ * Part of https://github.com/SigNoz/engineering-pod/issues/5289, add a comment or update when removing this method.
+ */
 const listPreference = async (): Promise<
 	SuccessResponseV2<OrgPreference[]>
 > => {
--- a/frontend/src/api/v1/org/preferences/name/update.ts
+++ b/frontend/src/api/v1/org/preferences/name/update.ts
@@ -4,6 +4,13 @@ import { AxiosError } from 'axios';
 import { ErrorV2Resp, SuccessResponseV2 } from 'types/api';
 import { Props } from 'types/api/preferences/update';

+/**
+ * @deprecated Use the generated `useUpdateOrgPreference` hook (or `updateOrgPreference` fetcher) from
+ * `api/generated/services/preferences` instead. This hand-written client targets the
+ * same endpoint and will be removed once call sites migrate.
+ *
+ * Part of https://github.com/SigNoz/engineering-pod/issues/5289, add a comment or update when removing this method.
+ */
 const update = async (props: Props): Promise<SuccessResponseV2<null>> => {
 	try {
 		const response = await axios.put(`/org/preferences/${props.name}`, {
--- a/frontend/src/api/v1/user/preferences/list.ts
+++ b/frontend/src/api/v1/user/preferences/list.ts
@@ -5,6 +5,13 @@ import { ErrorV2Resp, SuccessResponseV2 } from 'types/api';
 import { PayloadProps } from 'types/api/preferences/list';
 import { UserPreference } from 'types/api/preferences/preference';

+/**
+ * @deprecated Use the generated `useListUserPreferences` hook (or `listUserPreferences` fetcher) from
+ * `api/generated/services/preferences` instead. This hand-written client targets the
+ * same endpoint and will be removed once call sites migrate.
+ *
+ * Part of https://github.com/SigNoz/engineering-pod/issues/5289, add a comment or update when removing this method.
+ */
 const list = async (): Promise<SuccessResponseV2<UserPreference[]>> => {
 	try {
 		const response = await axios.get<PayloadProps>(`/user/preferences`);
--- a/frontend/src/api/v1/user/preferences/name/get.ts
+++ b/frontend/src/api/v1/user/preferences/name/get.ts
@@ -5,6 +5,13 @@ import { ErrorV2Resp, SuccessResponseV2 } from 'types/api';
 import { PayloadProps, Props } from 'types/api/preferences/get';
 import { UserPreference } from 'types/api/preferences/preference';

+/**
+ * @deprecated Use the generated `useGetUserPreference` hook (or `getUserPreference` fetcher) from
+ * `api/generated/services/preferences` instead. This hand-written client targets the
+ * same endpoint and will be removed once call sites migrate.
+ *
+ * Part of https://github.com/SigNoz/engineering-pod/issues/5289, add a comment or update when removing this method.
+ */
 const get = async (
 	props: Props,
 ): Promise<SuccessResponseV2<UserPreference>> => {
--- a/frontend/src/api/v1/user/preferences/name/update.ts
+++ b/frontend/src/api/v1/user/preferences/name/update.ts
@@ -4,6 +4,13 @@ import { AxiosError } from 'axios';
 import { ErrorV2Resp, SuccessResponseV2 } from 'types/api';
 import { Props } from 'types/api/preferences/update';

+/**
+ * @deprecated Use the generated `useUpdateUserPreference` hook (or `updateUserPreference` fetcher) from
+ * `api/generated/services/preferences` instead. This hand-written client targets the
+ * same endpoint and will be removed once call sites migrate.
+ *
+ * Part of https://github.com/SigNoz/engineering-pod/issues/5289, add a comment or update when removing this method.
+ */
 const update = async (props: Props): Promise<SuccessResponseV2<null>> => {
 	try {
 		const response = await axios.put(`/user/preferences/${props.name}`, {
--- a/frontend/src/api/v2/sessions/context/get.ts
+++ b/frontend/src/api/v2/sessions/context/get.ts
@@ -4,6 +4,13 @@ import { AxiosError } from 'axios';
 import { ErrorV2Resp, RawSuccessResponse, SuccessResponseV2 } from 'types/api';
 import { Props, SessionsContext } from 'types/api/v2/sessions/context/get';

+/**
+ * @deprecated Use the generated `useGetSessionContext` hook (or `getSessionContext` fetcher) from
+ * `api/generated/services/sessions` instead. This hand-written client targets the
+ * same endpoint and will be removed once call sites migrate.
+ *
+ * Part of https://github.com/SigNoz/engineering-pod/issues/5289, add a comment or update when removing this method.
+ */
 const get = async (
 	props: Props,
 ): Promise<SuccessResponseV2<SessionsContext>> => {
--- a/frontend/src/api/v2/sessions/delete.ts
+++ b/frontend/src/api/v2/sessions/delete.ts
@@ -3,6 +3,13 @@ import { ErrorResponseHandlerV2 } from 'api/ErrorResponseHandlerV2';
 import { AxiosError } from 'axios';
 import { ErrorV2Resp, RawSuccessResponse, SuccessResponseV2 } from 'types/api';

+/**
+ * @deprecated Use the generated `useDeleteSession` hook (or `deleteSession` fetcher) from
+ * `api/generated/services/sessions` instead. This hand-written client targets the
+ * same endpoint and will be removed once call sites migrate.
+ *
+ * Part of https://github.com/SigNoz/engineering-pod/issues/5289, add a comment or update when removing this method.
+ */
 const deleteSession = async (): Promise<SuccessResponseV2<null>> => {
 	try {
 		const response = await axios.delete<RawSuccessResponse<null>>('/sessions');
--- a/frontend/src/api/v2/sessions/email_password/post.ts
+++ b/frontend/src/api/v2/sessions/email_password/post.ts
@@ -4,6 +4,13 @@ import { AxiosError } from 'axios';
 import { ErrorV2Resp, RawSuccessResponse, SuccessResponseV2 } from 'types/api';
 import { Props, Token } from 'types/api/v2/sessions/email_password/post';

+/**
+ * @deprecated Use the generated `useCreateSessionByEmailPassword` hook (or `createSessionByEmailPassword` fetcher) from
+ * `api/generated/services/sessions` instead. This hand-written client targets the
+ * same endpoint and will be removed once call sites migrate.
+ *
+ * Part of https://github.com/SigNoz/engineering-pod/issues/5289, add a comment or update when removing this method.
+ */
 const post = async (props: Props): Promise<SuccessResponseV2<Token>> => {
 	try {
 		const response = await axios.post<RawSuccessResponse<Token>>(
--- a/frontend/src/api/v2/sessions/rotate/post.ts
+++ b/frontend/src/api/v2/sessions/rotate/post.ts
@@ -4,6 +4,13 @@ import { AxiosError } from 'axios';
 import { ErrorV2Resp, RawSuccessResponse, SuccessResponseV2 } from 'types/api';
 import { Props, Token } from 'types/api/v2/sessions/rotate/post';

+/**
+ * @deprecated Use the generated `useRotateSession` hook (or `rotateSession` fetcher) from
+ * `api/generated/services/sessions` instead. This hand-written client targets the
+ * same endpoint and will be removed once call sites migrate.
+ *
+ * Part of https://github.com/SigNoz/engineering-pod/issues/5289, add a comment or update when removing this method.
+ */
 const post = async (props: Props): Promise<SuccessResponseV2<Token>> => {
 	try {
 		const response = await axios.post<RawSuccessResponse<Token>>(
--- a/frontend/src/api/v5/queryRange/getQueryRange.ts
+++ b/frontend/src/api/v5/queryRange/getQueryRange.ts
@@ -8,6 +8,13 @@ import {
 	QueryRangePayloadV5,
 } from 'types/api/v5/queryRange';

+/**
+ * @deprecated Use the generated `useQueryRangeV5` hook (or `queryRangeV5` fetcher) from
+ * `api/generated/services/querier` instead. This hand-written client targets the
+ * same endpoint and will be removed once call sites migrate.
+ *
+ * Part of https://github.com/SigNoz/engineering-pod/issues/5289, add a comment or update when removing this method.
+ */
 export const getQueryRangeV5 = async (
 	props: QueryRangePayloadV5,
 	version: string,
--- a/frontend/src/components/FieldsSelector/FieldsSelector.tsx
+++ b/frontend/src/components/FieldsSelector/FieldsSelector.tsx
@@ -192,7 +192,7 @@ function FieldsSelector({
 		() =>
 			fields.map((f) => ({
 				...f,
-				key: f.key ?? buildCompositeKey(f.name, f.fieldContext),
+				key: f.key ?? buildCompositeKey(f.name, f.fieldContext, f.fieldDataType),
 			})),
 		[fields],
 	);
--- a/frontend/src/components/FieldsSelector/OtherFields.tsx
+++ b/frontend/src/components/FieldsSelector/OtherFields.tsx
@@ -52,14 +52,20 @@ function OtherFields({
 		const normalizedSuggestions: TelemetryFieldKey[] = suggestions.map(
 			(attr) => ({
 				...attr,
-				key: buildCompositeKey(attr.name, attr.fieldContext as string),
+				key: buildCompositeKey(
+					attr.name,
+					attr.fieldContext as string,
+					attr.fieldDataType as string | undefined,
+				),
 				signal: attr.signal as SignalType,
 				fieldContext: attr.fieldContext as FieldContext,
 				fieldDataType: attr.fieldDataType as FieldDataType,
 			}),
 		);
 		const addedIds = new Set(
-			addedFields.map((f) => f.key ?? buildCompositeKey(f.name, f.fieldContext)),
+			addedFields.map(
+				(f) => f.key ?? buildCompositeKey(f.name, f.fieldContext, f.fieldDataType),
+			),
 		);
 		return normalizedSuggestions.filter(
 			(attr) => !addedIds.has(attr.key as string),
--- a/frontend/src/components/Traces/TableView/TracesTable.module.scss
+++ b/frontend/src/components/Traces/TableView/TracesTable.module.scss
@@ -0,0 +1,17 @@
+.container {
+	display: flex;
+	flex-direction: column;
+	flex: 1;
+	min-height: 0;
+
+	font-family: var(--traces-table-font, inherit);
+
+	--row-hover-bg: var(--l1-border);
+}
+
+.tableWrapper {
+	flex: 1;
+	min-height: 0;
+	display: flex;
+	flex-direction: column;
+}
--- a/frontend/src/components/Traces/TableView/TracesTable.tsx
+++ b/frontend/src/components/Traces/TableView/TracesTable.tsx
@@ -0,0 +1,113 @@
+import { useCallback } from 'react';
+import { useHistory } from 'react-router-dom';
+import ErrorInPlace from 'components/ErrorInPlace/ErrorInPlace';
+import TanStackTable from 'components/TanStackTableView';
+import type { TableColumnDef } from 'components/TanStackTableView/types';
+import EmptyLogsSearch from 'container/EmptyLogsSearch/EmptyLogsSearch';
+import NoLogs from 'container/NoLogs/NoLogs';
+import { TracesLoading } from 'container/TracesExplorer/TraceLoading/TraceLoading';
+import APIError from 'types/api/error';
+import { DataSource } from 'types/common/queryBuilder';
+import { getAbsoluteUrl } from 'utils/basePath';
+
+import styles from './TracesTable.module.scss';
+
+export type TracesTablePanelType = 'LIST' | 'TRACE';
+
+export type TracesTableProps<TRow> = {
+	data: TRow[];
+	columns: TableColumnDef<TRow>[];
+
+	isLoading: boolean;
+	isFetching: boolean;
+	isError: boolean;
+	error: APIError | Error | null;
+	isFilterApplied: boolean;
+	panelType: TracesTablePanelType;
+
+	columnStorageKey: string;
+	respectColumnOrder?: boolean;
+	cellTypographySize?: 'small' | 'medium' | 'large';
+
+	onColumnOrderChange?: (cols: TableColumnDef<TRow>[]) => void;
+	onColumnRemove?: (id: string) => void;
+
+	/** Build the href for a row. Wrapper handles same-tab navigation + cmd-click new-tab dispatch. */
+	getRowHref: (row: TRow) => string;
+
+	onEndReached: () => void;
+};
+
+export function TracesTable<TRow>({
+	data,
+	columns,
+	isLoading,
+	isFetching,
+	isError,
+	error,
+	isFilterApplied,
+	panelType,
+	columnStorageKey,
+	respectColumnOrder,
+	cellTypographySize = 'medium',
+	onColumnOrderChange,
+	onColumnRemove,
+	getRowHref,
+	onEndReached,
+}: TracesTableProps<TRow>): JSX.Element {
+	const history = useHistory();
+	const isEmpty = data.length === 0;
+	const isInitialLoading = (isLoading || isFetching) && isEmpty;
+
+	const onRowClick = useCallback(
+		(row: TRow): void => {
+			history.push(getRowHref(row));
+		},
+		[history, getRowHref],
+	);
+
+	const onRowClickNewTab = useCallback(
+		(row: TRow): void => {
+			window.open(
+				getAbsoluteUrl(getRowHref(row)),
+				'_blank',
+				'noopener,noreferrer',
+			);
+		},
+		[getRowHref],
+	);
+
+	return (
+		<div className={styles.container}>
+			{isError && error && <ErrorInPlace error={error as APIError} />}
+
+			{isInitialLoading && <TracesLoading />}
+
+			{!isLoading && !isFetching && !isError && !isFilterApplied && isEmpty && (
+				<NoLogs dataSource={DataSource.TRACES} />
+			)}
+
+			{!isLoading && !isFetching && isEmpty && !isError && isFilterApplied && (
+				<EmptyLogsSearch dataSource={DataSource.TRACES} panelType={panelType} />
+			)}
+
+			{!isEmpty && (
+				<div className={styles.tableWrapper}>
+					<TanStackTable<TRow>
+						data={data}
+						columns={columns}
+						columnStorageKey={columnStorageKey}
+						respectColumnOrder={respectColumnOrder}
+						cellTypographySize={cellTypographySize}
+						isLoading={isLoading || isFetching}
+						onEndReached={onEndReached}
+						onColumnOrderChange={onColumnOrderChange}
+						onColumnRemove={onColumnRemove}
+						onRowClick={onRowClick}
+						onRowClickNewTab={onRowClickNewTab}
+					/>
+				</div>
+			)}
+		</div>
+	);
+}
--- a/frontend/src/components/Traces/TableView/tests/useTraceInfiniteQuery.test.ts
+++ b/frontend/src/components/Traces/TableView/tests/useTraceInfiniteQuery.test.ts
@@ -0,0 +1,277 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { act, renderHook } from '@testing-library/react';
+import { useGetQueryRange } from 'hooks/queryBuilder/useGetQueryRange';
+import type { Pagination } from 'hooks/queryPagination';
+
+import { useTraceInfiniteQuery } from '../useTraceInfiniteQuery';
+
+jest.mock('hooks/queryBuilder/useGetQueryRange', () => ({
+	useGetQueryRange: jest.fn(),
+}));
+
+jest.mock('api/common/logEvent', () => ({
+	__esModule: true,
+	default: jest.fn(),
+}));
+
+const mockedUseGetQueryRange = useGetQueryRange as jest.MockedFunction<
+	typeof useGetQueryRange
+>;
+
+type Row = { id: string; name: string };
+
+const PAGE_SIZE = 50;
+
+/**
+ * Builds a fake `useGetQueryRange` return shape with a payload that
+ * transforms into N rows.
+ */
+const makeQueryResult = (
+	rowsForPage: Row[],
+	overrides: Partial<{
+		isLoading: boolean;
+		isFetching: boolean;
+		isError: boolean;
+		error: Error | null;
+	}> = {},
+): any => ({
+	data: {
+		payload: { rows: rowsForPage },
+		warning: undefined,
+		statusCode: 200,
+		error: null,
+		message: '',
+		params: {} as any,
+		warnings: [],
+	},
+	isLoading: false,
+	isFetching: false,
+	isError: false,
+	error: null,
+	...overrides,
+});
+
+const emptyQueryResult = (
+	overrides: Partial<{
+		isLoading: boolean;
+		isFetching: boolean;
+		isError: boolean;
+		error: Error | null;
+	}> = {},
+): any => ({
+	data: undefined,
+	isLoading: true,
+	isFetching: false,
+	isError: false,
+	error: null,
+	...overrides,
+});
+
+/** Generates N rows for a given page. */
+const makePage = (offset: number, count: number): Row[] =>
+	Array.from({ length: count }, (_, i) => ({
+		id: `row-${offset + i}`,
+		name: `name-${offset + i}`,
+	}));
+
+const baseProps = (queryDeps: unknown[] = ['Q1']): any => ({
+	queryDeps,
+	buildRequest: jest.fn((pagination: Pagination) => ({
+		query: {} as any,
+		graphType: 'LIST' as any,
+		selectedTime: 'GLOBAL_TIME' as any,
+		globalSelectedInterval: '5m' as any,
+		params: { dataSource: 'traces' },
+		tableParams: { pagination },
+	})),
+	transformResponse: jest.fn(
+		(payload: any): Row[] => (payload?.rows as Row[]) ?? [],
+	),
+	enabled: true,
+	entityVersion: 'v5',
+	panelType: 'LIST',
+});
+
+describe('useTraceInfiniteQuery', () => {
+	beforeEach(() => {
+		mockedUseGetQueryRange.mockReset();
+	});
+
+	it('starts with empty rows and hasMore=true; appends first page when data arrives', () => {
+		mockedUseGetQueryRange.mockReturnValue(emptyQueryResult());
+
+		const props = baseProps();
+		const { result, rerender } = renderHook(() => useTraceInfiniteQuery(props));
+
+		expect(result.current.rows).toStrictEqual([]);
+		expect(result.current.isLoading).toBe(true);
+
+		// First page returns 50 rows (full page → hasMore stays true).
+		const page1 = makePage(0, PAGE_SIZE);
+		mockedUseGetQueryRange.mockReturnValue(makeQueryResult(page1));
+
+		rerender();
+		expect(result.current.rows).toStrictEqual(page1);
+		expect(result.current.isLoading).toBe(false);
+		expect(result.current.isError).toBe(false);
+	});
+
+	it('appends the next page when handleEndReached is called (no replace)', () => {
+		const page1 = makePage(0, PAGE_SIZE);
+		mockedUseGetQueryRange.mockReturnValue(makeQueryResult(page1));
+
+		const props = baseProps();
+		const { result, rerender } = renderHook(() => useTraceInfiniteQuery(props));
+
+		expect(result.current.rows).toHaveLength(PAGE_SIZE);
+
+		// Trigger next page — pagination state bumps offset.
+		act(() => {
+			result.current.handleEndReached();
+		});
+
+		// buildRequest is called again with the new offset; the hook would now ask
+		// the mocked useGetQueryRange for the next slice. Simulate that by swapping
+		// the returned payload to page 2 and rerendering.
+		const page2 = makePage(PAGE_SIZE, PAGE_SIZE);
+		mockedUseGetQueryRange.mockReturnValue(makeQueryResult(page2));
+		rerender();
+
+		// Accumulator keeps page 1 + page 2.
+		expect(result.current.rows).toHaveLength(PAGE_SIZE * 2);
+		expect(result.current.rows[0]).toStrictEqual(page1[0]);
+		expect(result.current.rows[PAGE_SIZE]).toStrictEqual(page2[0]);
+
+		// buildRequest was called with offset 0 on first render and offset PAGE_SIZE
+		// after handleEndReached.
+		const offsets = props.buildRequest.mock.calls.map(
+			(call: any) => call[0].offset,
+		);
+		expect(offsets).toContain(0);
+		expect(offsets).toContain(PAGE_SIZE);
+	});
+
+	it('sets hasMore=false when fewer than PAGE_SIZE rows are returned; handleEndReached is a no-op afterwards', () => {
+		const partialPage = makePage(0, 12);
+		mockedUseGetQueryRange.mockReturnValue(makeQueryResult(partialPage));
+
+		const props = baseProps();
+		const { result } = renderHook(() => useTraceInfiniteQuery(props));
+
+		expect(result.current.rows).toStrictEqual(partialPage);
+
+		// Capture buildRequest calls before EOF trigger.
+		const callsBefore = props.buildRequest.mock.calls.length;
+
+		act(() => {
+			result.current.handleEndReached();
+		});
+
+		// hasMore should be false → handleEndReached short-circuits, no extra
+		// buildRequest call (pagination state unchanged → no fetch trigger).
+		expect(props.buildRequest.mock.calls).toHaveLength(callsBefore);
+	});
+
+	it('resets accumulator + pagination when queryDeps change', () => {
+		const page1 = makePage(0, PAGE_SIZE);
+		mockedUseGetQueryRange.mockReturnValue(makeQueryResult(page1));
+
+		const props = baseProps(['Q1']);
+		const { result, rerender } = renderHook(
+			(p: any) => useTraceInfiniteQuery(p),
+			{ initialProps: props },
+		);
+
+		expect(result.current.rows).toHaveLength(PAGE_SIZE);
+
+		// Scroll past page 1.
+		act(() => {
+			result.current.handleEndReached();
+		});
+		const page2 = makePage(PAGE_SIZE, PAGE_SIZE);
+		mockedUseGetQueryRange.mockReturnValue(makeQueryResult(page2));
+		rerender(props);
+		expect(result.current.rows).toHaveLength(PAGE_SIZE * 2);
+
+		// queryDeps change → reset should clear the accumulator.
+		const newPage = makePage(0, 5);
+		mockedUseGetQueryRange.mockReturnValue(makeQueryResult(newPage));
+		const nextProps = { ...props, queryDeps: ['Q2'] };
+		rerender(nextProps);
+
+		expect(result.current.rows).toStrictEqual(newPage);
+	});
+
+	it('propagates isError and error from useGetQueryRange', () => {
+		const err = new Error('boom');
+		mockedUseGetQueryRange.mockReturnValue(
+			emptyQueryResult({ isLoading: false, isError: true, error: err }),
+		);
+
+		const props = baseProps();
+		const { result } = renderHook(() => useTraceInfiniteQuery(props));
+
+		expect(result.current.isError).toBe(true);
+		expect(result.current.error).toBe(err);
+		expect(result.current.rows).toStrictEqual([]);
+	});
+
+	it('calls setIsLoadingQueries when isLoading/isFetching changes', () => {
+		const setIsLoadingQueries = jest.fn();
+		mockedUseGetQueryRange.mockReturnValue(
+			emptyQueryResult({ isLoading: true, isFetching: false }),
+		);
+
+		const props = { ...baseProps(), setIsLoadingQueries };
+		const { rerender } = renderHook(() => useTraceInfiniteQuery(props));
+
+		expect(setIsLoadingQueries).toHaveBeenCalledWith(true);
+
+		mockedUseGetQueryRange.mockReturnValue(
+			makeQueryResult([], { isLoading: false, isFetching: false }),
+		);
+		rerender();
+
+		expect(setIsLoadingQueries).toHaveBeenLastCalledWith(false);
+	});
+
+	it('publishes the constructed queryKey via queryKeyRef', () => {
+		mockedUseGetQueryRange.mockReturnValue(emptyQueryResult());
+
+		const queryKeyRef = { current: null as unknown };
+		const props = { ...baseProps(['orderBy-asc', 'time-1h']), queryKeyRef };
+
+		renderHook(() => useTraceInfiniteQuery(props));
+
+		expect(Array.isArray(queryKeyRef.current)).toBe(true);
+		// First element is the GET_QUERY_RANGE tag, then pagination, then the
+		// caller's queryDeps spread.
+		expect(queryKeyRef.current as unknown[]).toStrictEqual(
+			expect.arrayContaining(['orderBy-asc', 'time-1h']),
+		);
+	});
+
+	it('forwards data.warning to setWarning when payload is present', () => {
+		const setWarning = jest.fn();
+		mockedUseGetQueryRange.mockReturnValue({
+			data: {
+				payload: { rows: makePage(0, 3) },
+				warning: { message: 'partial' } as any,
+				statusCode: 200,
+				error: null,
+				message: '',
+				params: {} as any,
+				warnings: [],
+			} as any,
+			isLoading: false,
+			isFetching: false,
+			isError: false,
+			error: null,
+		} as any);
+
+		const props = { ...baseProps(), setWarning };
+		renderHook(() => useTraceInfiniteQuery(props));
+
+		expect(setWarning).toHaveBeenCalledWith({ message: 'partial' });
+	});
+});
--- a/frontend/src/components/Traces/TableView/tests/useTracesTableColumns.test.tsx
+++ b/frontend/src/components/Traces/TableView/tests/useTracesTableColumns.test.tsx
@@ -0,0 +1,107 @@
+import { renderHook } from '@testing-library/react';
+import type { TableColumnDef } from 'components/TanStackTableView/types';
+import type { TelemetryFieldKey } from 'types/api/v5/queryRange';
+
+import { useTracesTableColumns } from '../useTracesTableColumns';
+
+type Row = { trace_id: string; span_id: string };
+
+const cellStub = (): JSX.Element => <span />;
+
+const baseColumns: TableColumnDef<Row>[] = [
+	{
+		id: 'span.timestamp',
+		header: 'Timestamp',
+		accessorFn: (r): unknown => r.span_id,
+		width: { default: 170, min: 170 },
+		cell: cellStub,
+	},
+	{
+		id: 'span.trace_id',
+		header: 'Trace ID',
+		accessorFn: (r): unknown => r.trace_id,
+		width: { min: 200 },
+		cell: cellStub,
+	},
+];
+
+describe('useTracesTableColumns', () => {
+	it('returns baseColumns as-is when no fields are provided', () => {
+		const { result } = renderHook(() =>
+			useTracesTableColumns<Row>({ baseColumns }),
+		);
+		expect(result.current).toHaveLength(baseColumns.length);
+		expect(result.current.map((c) => c.id)).toStrictEqual([
+			'span.timestamp',
+			'span.trace_id',
+		]);
+	});
+
+	it('appends dynamic field columns after baseColumns', () => {
+		const fields: TelemetryFieldKey[] = [
+			{
+				name: 'http.method',
+				fieldContext: 'attribute',
+				fieldDataType: 'string',
+				signal: 'traces',
+			} as TelemetryFieldKey,
+			{
+				name: 'duration_nano',
+				fieldContext: 'span',
+				fieldDataType: 'int64',
+				signal: 'traces',
+			} as TelemetryFieldKey,
+		];
+
+		const { result } = renderHook(() =>
+			useTracesTableColumns<Row>({ baseColumns, fields }),
+		);
+
+		expect(result.current).toHaveLength(baseColumns.length + fields.length);
+		// baseColumns first.
+		expect(
+			result.current.slice(0, baseColumns.length).map((c) => c.id),
+		).toStrictEqual(['span.timestamp', 'span.trace_id']);
+		// Then dynamic fields with 3-arg composite IDs (context.name.dataType).
+		expect(
+			result.current.slice(baseColumns.length).map((c) => c.id),
+		).toStrictEqual(['attribute.http.method.string', 'span.duration_nano.int64']);
+	});
+
+	it('preserves the same array reference when inputs are stable (memoization)', () => {
+		const fields: TelemetryFieldKey[] = [];
+		const { result, rerender } = renderHook(() =>
+			useTracesTableColumns<Row>({ baseColumns, fields }),
+		);
+		const first = result.current;
+		rerender();
+		expect(result.current).toBe(first);
+	});
+
+	it('returns a new array when baseColumns reference changes', () => {
+		const { result, rerender } = renderHook(
+			(props: { baseColumns: TableColumnDef<Row>[] }) =>
+				useTracesTableColumns<Row>({ baseColumns: props.baseColumns }),
+			{ initialProps: { baseColumns } },
+		);
+		const first = result.current;
+		rerender({ baseColumns: [...baseColumns] });
+		expect(result.current).not.toBe(first);
+		expect(result.current.map((c) => c.id)).toStrictEqual(first.map((c) => c.id));
+	});
+
+	it('uses 2-arg composite ID when fieldDataType is empty', () => {
+		const fields: TelemetryFieldKey[] = [
+			{
+				name: 'service.name',
+				fieldContext: 'resource',
+				fieldDataType: '',
+				signal: 'traces',
+			} as TelemetryFieldKey,
+		];
+		const { result } = renderHook(() =>
+			useTracesTableColumns<Row>({ baseColumns: [], fields }),
+		);
+		expect(result.current[0].id).toBe('resource.service.name');
+	});
+});
--- a/frontend/src/components/Traces/TableView/getTraceLink.ts
+++ b/frontend/src/components/Traces/TableView/getTraceLink.ts
@@ -0,0 +1,25 @@
+import ROUTES from 'constants/routes';
+import { formUrlParams } from 'container/TraceDetail/utils';
+
+// Reads camelCase OR snake_case at runtime — accepts any row shape that ships
+// trace_id (and optionally span_id). Both the TanStack ListView's SpanRow and
+// the legacy antd `RowData` (TracesTableComponent, EntityTraces) satisfy this.
+export const getTraceLink = (record: Record<string, unknown>): string => {
+	const traceId = readId(record.traceID) || readId(record.trace_id);
+	const spanId = readId(record.spanID) || readId(record.span_id);
+	return `${ROUTES.TRACE}/${traceId}${formUrlParams({
+		spanId,
+		levelUp: 0,
+		levelDown: 0,
+	})}`;
+};
+
+function readId(value: unknown): string {
+	if (typeof value === 'string') {
+		return value;
+	}
+	if (typeof value === 'number') {
+		return String(value);
+	}
+	return '';
+}
--- a/frontend/src/components/Traces/TableView/useTraceInfiniteQuery.ts
+++ b/frontend/src/components/Traces/TableView/useTraceInfiniteQuery.ts
@@ -0,0 +1,133 @@
+import {
+	useCallback,
+	useEffect,
+	useMemo,
+	useState,
+	type MutableRefObject,
+} from 'react';
+import logEvent from 'api/common/logEvent';
+import { REACT_QUERY_KEY } from 'constants/reactQueryKeys';
+import { useGetQueryRange } from 'hooks/queryBuilder/useGetQueryRange';
+import type { Pagination } from 'hooks/queryPagination';
+import type { GetQueryResultsProps } from 'lib/dashboard/getQueryResults';
+import type { Warning } from 'types/api';
+import type APIError from 'types/api/error';
+import type { MetricQueryRangeSuccessResponse } from 'types/api/metrics/getQueryRange';
+
+const PAGE_SIZE = 50;
+
+export type UseTraceInfiniteQueryOptions<TRow> = {
+	queryDeps: unknown[];
+	buildRequest: (pagination: Pagination) => GetQueryResultsProps;
+	transformResponse: (
+		payload: MetricQueryRangeSuccessResponse['payload'] | undefined,
+	) => TRow[];
+	enabled: boolean;
+	entityVersion: string;
+	queryKeyRef?: MutableRefObject<unknown>;
+	setIsLoadingQueries?: (loading: boolean) => void;
+	setWarning?: (warning: Warning | undefined) => void;
+	panelType: string;
+};
+
+export type UseTraceInfiniteQueryResult<TRow> = {
+	rows: TRow[];
+	isLoading: boolean;
+	isFetching: boolean;
+	isError: boolean;
+	error: APIError | Error | null;
+	handleEndReached: () => void;
+};
+
+export function useTraceInfiniteQuery<TRow>({
+	queryDeps,
+	buildRequest,
+	transformResponse,
+	enabled,
+	entityVersion,
+	queryKeyRef,
+	setIsLoadingQueries,
+	setWarning,
+	panelType,
+}: UseTraceInfiniteQueryOptions<TRow>): UseTraceInfiniteQueryResult<TRow> {
+	const [pagination, setPagination] = useState<Pagination>({
+		offset: 0,
+		limit: PAGE_SIZE,
+	});
+	const [accumulatedRows, setAccumulatedRows] = useState<TRow[]>([]);
+	const [hasMore, setHasMore] = useState(true);
+
+	useEffect(() => {
+		setPagination({ offset: 0, limit: PAGE_SIZE });
+		setAccumulatedRows([]);
+		setHasMore(true);
+		// eslint-disable-next-line react-hooks/exhaustive-deps
+	}, queryDeps);
+
+	const requestParams = useMemo(
+		() => buildRequest(pagination),
+		[buildRequest, pagination],
+	);
+
+	const queryKey = useMemo(
+		() => [REACT_QUERY_KEY.GET_QUERY_RANGE, pagination, ...queryDeps],
+		// eslint-disable-next-line react-hooks/exhaustive-deps
+		[pagination, ...queryDeps],
+	);
+
+	if (queryKeyRef) {
+		queryKeyRef.current = queryKey;
+	}
+
+	const { data, isLoading, isFetching, isError, error } = useGetQueryRange(
+		requestParams,
+		entityVersion,
+		{ queryKey, enabled, keepPreviousData: true },
+	);
+
+	useEffect(() => {
+		if (data?.payload && setWarning) {
+			setWarning(data.warning);
+		}
+	}, [data?.payload, data?.warning, setWarning]);
+
+	// Append-only. Fires solely on new data arriving (pagination is not a dep —
+	// pagination state changes drive the queryKey, which drives a new fetch,
+	// which lands here as a fresh data.payload). Functional updater so the new
+	// rows always pile onto the latest queued accumulator (which is [] right
+	// after reset).
+	useEffect(() => {
+		if (!data?.payload) {
+			return;
+		}
+		const newRows = transformResponse(data.payload);
+		setAccumulatedRows((prev) => [...prev, ...newRows]);
+		setHasMore(newRows.length >= PAGE_SIZE);
+	}, [data?.payload, transformResponse]);
+
+	useEffect(() => {
+		setIsLoadingQueries?.(isLoading || isFetching);
+	}, [isLoading, isFetching, setIsLoadingQueries]);
+
+	useEffect(() => {
+		if (!isLoading && !isFetching && !isError && accumulatedRows.length !== 0) {
+			void logEvent('Traces Explorer: Data present', { panelType });
+		}
+	}, [isLoading, isFetching, isError, accumulatedRows.length, panelType]);
+
+	const handleEndReached = useCallback(() => {
+		if (!hasMore) {
+			return;
+		}
+		setPagination((p) => ({ ...p, offset: p.offset + p.limit }));
+	}, [hasMore]);
+
+	return {
+		rows: accumulatedRows,
+		isLoading,
+		isFetching,
+		isError,
+		error,
+		handleEndReached,
+	};
+}
--- a/frontend/src/components/Traces/TableView/useTracesTableColumns.tsx
+++ b/frontend/src/components/Traces/TableView/useTracesTableColumns.tsx
@@ -0,0 +1,58 @@
+import { useMemo, type ReactElement } from 'react';
+
+import TanStackTable from 'components/TanStackTableView';
+import type { TableColumnDef } from 'components/TanStackTableView/types';
+import { buildCompositeKey } from 'container/OptionsMenu/utils';
+import type { TelemetryFieldKey } from 'types/api/v5/queryRange';
+
+type UseTracesTableColumnsProps<TRow> = {
+	/** Pinned / always-on columns owned by the consumer (e.g. timestamp for List view, the 5 static columns for Traces grouped view). */
+	baseColumns: TableColumnDef<TRow>[];
+	/** Dynamic columns sourced from `selectColumns` (List view). Omit or pass [] for views without a picker (Traces grouped). */
+	fields?: TelemetryFieldKey[];
+};
+
+/**
+ * Shared column builder for the trace list view and the trace (group-by-trace) view.
+ *
+ * Composition: `[...baseColumns, ...fields.map(makeUserFieldCol)]`. Each view owns its
+ * `baseColumns` inline so view-specific changes (timestamp formatting on list, static-column
+ * cell renderers on grouped) stay localized. The shared piece is `makeUserFieldCol` — the
+ * dynamic-field factory that consumes `selectColumns` for the list view.
+ */
+export function useTracesTableColumns<TRow>({
+	baseColumns,
+	fields = [],
+}: UseTracesTableColumnsProps<TRow>): TableColumnDef<TRow>[] {
+	return useMemo<TableColumnDef<TRow>[]>(
+		() => [...baseColumns, ...fields.map((f) => makeUserFieldCol<TRow>(f))],
+		[baseColumns, fields],
+	);
+}
+
+function makeUserFieldCol<TRow>(f: TelemetryFieldKey): TableColumnDef<TRow> {
+	const col: TableColumnDef<Record<string, unknown>> = {
+		id: buildCompositeKey(f.name, f.fieldContext, f.fieldDataType),
+		header: f.name,
+		accessorFn: (row): unknown => row[f.name],
+		enableRemove: true,
+		width: { min: 192 },
+		cell: ({ value }): ReactElement => (
+			<TanStackTable.Text>{stringifyCellValue(value)}</TanStackTable.Text>
+		),
+	};
+	return col as TableColumnDef<TRow>;
+}
+
+function stringifyCellValue(value: unknown): string {
+	if (value == null) {
+		return '';
+	}
+	if (typeof value === 'string') {
+		return value;
+	}
+	if (typeof value === 'number' || typeof value === 'boolean') {
+		return String(value);
+	}
+	return JSON.stringify(value);
+}
--- a/frontend/src/constants/localStorage.ts
+++ b/frontend/src/constants/localStorage.ts
@@ -11,6 +11,7 @@ export enum LOCALSTORAGE {
 	TRACES_LIST_OPTIONS = 'TRACES_LIST_OPTIONS',
 	GRAPH_VISIBILITY_STATES = 'GRAPH_VISIBILITY_STATES',
 	TRACES_LIST_COLUMNS = 'TRACES_LIST_COLUMNS',
+	TRACES_VIEW_COLUMNS = 'TRACES_VIEW_COLUMNS',
 	LOGS_LIST_COLUMNS = 'LOGS_LIST_COLUMNS',
 	LOGS_LIST_COLUMN_SIZING = 'LOGS_LIST_COLUMN_SIZING',
 	LOGGED_IN_USER_NAME = 'LOGGED_IN_USER_NAME',
--- a/frontend/src/container/InfraMonitoringK8s/EntityDetailsUtils/EntityTraces/traceListColumns.tsx
+++ b/frontend/src/container/InfraMonitoringK8s/EntityDetailsUtils/EntityTraces/traceListColumns.tsx
@@ -3,10 +3,8 @@ import { Badge } from '@signozhq/ui/badge';
 import { Typography } from '@signozhq/ui/typography';
 import { DATE_TIME_FORMATS } from 'constants/dateTimeFormats';
 import { getMs } from 'container/Trace/Filters/Panel/PanelBody/Duration/util';
-import {
-	BlockLink,
-	getTraceLink,
-} from 'container/TracesExplorer/ListView/utils';
+import { getTraceLink } from 'components/Traces/TableView/getTraceLink';
+import { BlockLink } from 'container/TracesExplorer/ListView/utils';
 import dayjs from 'dayjs';
 import { RowData } from 'lib/query/createTableColumnsFromQuery';
 import { BaseAutocompleteData } from 'types/api/queryBuilder/queryAutocompleteResponse';
--- a/frontend/src/container/MetricsExplorer/Explorer/Explorer.tsx
+++ b/frontend/src/container/MetricsExplorer/Explorer/Explorer.tsx
@@ -62,7 +62,6 @@ function Explorer(): JSX.Element {
 		handleSetQueryData,
 		redirectWithQueryBuilderData,
 	} = useQueryBuilder();
-
 	const { safeNavigate } = useSafeNavigate();
 	const { handleExplorerTabChange } = useHandleExplorerTabChange();
 	const isAIAssistantEnabled = useIsAIAssistantEnabled();
--- a/frontend/src/container/OptionsMenu/constants.ts
+++ b/frontend/src/container/OptionsMenu/constants.ts
@@ -56,7 +56,7 @@ export function dedupeColumnsByCompositeKey(
 	const seen = new Set<string>();
 	let hasDuplicate = false;
 	const deduped = columns.filter((c) => {
-		const key = buildCompositeKey(c.name, c.fieldContext);
+		const key = buildCompositeKey(c.name, c.fieldContext, c.fieldDataType);
 		if (seen.has(key)) {
 			hasDuplicate = true;
 			return false;
--- a/frontend/src/container/OptionsMenu/useOptionsMenu.ts
+++ b/frontend/src/container/OptionsMenu/useOptionsMenu.ts
@@ -278,10 +278,20 @@ const useOptionsMenu = ({
 		[searchedAttributeKeys, selectedColumnKeys, preferences, updateColumns],
 	);

+	// Logs emits 2-part IDs (no `fieldDataType`); traces emits 3-part for
+	// `http.status_code`-style disambig. Tech debt — migrate logs to 3-part too
+	// and drop this gate.
+	const includeDataType = dataSource !== DataSource.LOGS;
+
 	const handleRemoveSelectedColumn = useCallback(
 		(columnKey: string) => {
 			const newSelectedColumns = preferences?.columns?.filter(
-				(f) => buildCompositeKey(f.name, f.fieldContext) !== columnKey,
+				(f) =>
+					buildCompositeKey(
+						f.name,
+						f.fieldContext,
+						includeDataType ? f.fieldDataType : undefined,
+					) !== columnKey,
 			);

 			if (!newSelectedColumns?.length && dataSource !== DataSource.LOGS) {
@@ -364,14 +374,21 @@ const useOptionsMenu = ({
 		(orderedIds: string[]): void => {
 			const current = preferences?.columns ?? [];
 			const byCompositeKey = new Map(
-				current.map((f) => [buildCompositeKey(f.name, f.fieldContext), f]),
+				current.map((f) => [
+					buildCompositeKey(
+						f.name,
+						f.fieldContext,
+						includeDataType ? f.fieldDataType : undefined,
+					),
+					f,
+				]),
 			);
 			const reordered = orderedIds
 				.map((id) => byCompositeKey.get(id))
 				.filter((f): f is TelemetryFieldKey => f !== undefined);
 			updateColumns(reordered);
 		},
-		[preferences, updateColumns],
+		[preferences, updateColumns, includeDataType],
 	);

 	const handleFocus = (): void => {
--- a/frontend/src/container/OptionsMenu/utils.ts
+++ b/frontend/src/container/OptionsMenu/utils.ts
@@ -15,8 +15,15 @@ export const getOptionsFromKeys = (
 	);
 };

-// Composite identity for a column. Disambiguates same-name fields across
-// different fieldContexts (e.g. resource.service.name vs attribute.service.name).
-// Falls back to bare name when context is missing.
-export const buildCompositeKey = (name: string, context?: string): string =>
-	context ? `${context}.${name}` : name;
+// Composite column id. Disambiguates same-name fields by `context` and `dataType`
+// (e.g. attribute.http.status_code ships as both number and string). Each arg
+// is appended only when truthy. `dataType` is optional — logs callers stay on
+// the 2-arg form until parity lands.
+export const buildCompositeKey = (
+	name: string,
+	context?: string,
+	dataType?: string,
+): string => {
+	const withContext = context ? `${context}.${name}` : name;
+	return dataType ? `${withContext}.${dataType}` : withContext;
+};
--- a/frontend/src/container/TracesExplorer/Controls/index.tsx
+++ b/frontend/src/container/TracesExplorer/Controls/index.tsx
@@ -2,62 +2,37 @@ import { memo, useState } from 'react';
 import { useTranslation } from 'react-i18next';
 import { Settings } from '@signozhq/icons';
 import FieldsSelector from 'components/FieldsSelector';
-import Controls, { ControlsProps } from 'container/Controls';
 import { OptionsMenuConfig } from 'container/OptionsMenu/types';
-import useQueryPagination from 'hooks/queryPagination/useQueryPagination';
 import { DataSource } from 'types/common/queryBuilder';

 import styles from './Controls.module.scss';

 function TraceExplorerControls({
-	isLoading,
-	totalCount,
-	perPageOptions,
 	config,
-	showSizeChanger = true,
 }: TraceExplorerControlsProps): JSX.Element | null {
 	const { t } = useTranslation(['trace']);
 	const [isFieldsSelectorOpen, setIsFieldsSelectorOpen] = useState(false);

-	const {
-		pagination,
-		handleCountItemsPerPageChange,
-		handleNavigateNext,
-		handleNavigatePrevious,
-	} = useQueryPagination(totalCount, perPageOptions);
+	if (!config?.fieldsSelector) {
+		return null;
+	}

 	return (
 		<div className={styles.container}>
-			{config?.fieldsSelector && (
-				<>
-					<div
-						className={styles.optionsTrigger}
-						onClick={(): void => setIsFieldsSelectorOpen(true)}
-					>
-						{t('options_menu.options')}
-						<Settings size="md" />
-					</div>
-					<FieldsSelector
-						isOpen={isFieldsSelectorOpen}
-						title="Edit columns"
-						fields={config.fieldsSelector.value}
-						onFieldsChange={config.fieldsSelector.onFieldsChange}
-						onClose={(): void => setIsFieldsSelectorOpen(false)}
-						signal={DataSource.TRACES}
-					/>
-				</>
-			)}
-
-			<Controls
-				isLoading={isLoading}
-				totalCount={totalCount}
-				offset={pagination.offset}
-				countPerPage={pagination.limit}
-				perPageOptions={perPageOptions}
-				handleCountItemsPerPageChange={handleCountItemsPerPageChange}
-				handleNavigateNext={handleNavigateNext}
-				handleNavigatePrevious={handleNavigatePrevious}
-				showSizeChanger={showSizeChanger}
+			<div
+				className={styles.optionsTrigger}
+				onClick={(): void => setIsFieldsSelectorOpen(true)}
+			>
+				{t('options_menu.options')}
+				<Settings size="md" />
+			</div>
+			<FieldsSelector
+				isOpen={isFieldsSelectorOpen}
+				title="Edit columns"
+				fields={config.fieldsSelector.value}
+				onFieldsChange={config.fieldsSelector.onFieldsChange}
+				onClose={(): void => setIsFieldsSelectorOpen(false)}
+				signal={DataSource.TRACES}
 			/>
 		</div>
 	);
@@ -67,16 +42,8 @@ TraceExplorerControls.defaultProps = {
 	config: null,
 };

-type TraceExplorerControlsProps = Pick<
-	ControlsProps,
-	'isLoading' | 'totalCount' | 'perPageOptions'
-> & {
+type TraceExplorerControlsProps = {
 	config?: OptionsMenuConfig | null;
-	showSizeChanger?: boolean;
-};
-
-TraceExplorerControls.defaultProps = {
-	showSizeChanger: true,
 };

 export default memo(TraceExplorerControls);
--- a/frontend/src/container/TracesExplorer/ListView/ListView.module.scss
+++ b/frontend/src/container/TracesExplorer/ListView/ListView.module.scss
@@ -0,0 +1,13 @@
+.container {
+	display: flex;
+	flex-direction: column;
+	flex: 1;
+	min-height: 0;
+	// Page chain (.trace-explorer-page → .trace-explorer → .traces-explorer-views)
+	// isn't a flex column, so anchor against the viewport.
+	height: calc(100vh - 240px);
+	min-height: 400px;
+
+	--tanstack-cell-padding-left-first-column: 5px;
+	--tanstack-plain-body-line-clamp: 3;
+}
--- a/frontend/src/container/TracesExplorer/ListView/ListView.styles.scss
+++ b/frontend/src/container/TracesExplorer/ListView/ListView.styles.scss
@@ -2,6 +2,7 @@
 	display: flex;
 	justify-content: flex-end;
 	align-items: center;
+	padding: 5px 10px;
 	gap: 8px;

 	.order-by-container {
--- a/frontend/src/container/TracesExplorer/ListView/configs.tsx
+++ b/frontend/src/container/TracesExplorer/ListView/configs.tsx
@@ -1,12 +1,3 @@
 import { DEFAULT_PER_PAGE_OPTIONS } from 'hooks/queryPagination';

-export const defaultSelectedColumns: string[] = [
-	'service.name',
-	'name',
-	'duration_nano',
-	'http_method',
-	'response_status_code',
-	'timestamp',
-];
-
 export const PER_PAGE_OPTIONS: number[] = [10, ...DEFAULT_PER_PAGE_OPTIONS];
--- a/frontend/src/container/TracesExplorer/ListView/index.test.tsx
+++ b/frontend/src/container/TracesExplorer/ListView/index.test.tsx
@@ -54,18 +54,17 @@ const renderListView = (
 	);
 };

-// Helper to verify all controls are visible
+// Helper to verify all controls are visible.
+// Pagination controls were removed in the TanStack-table migration (infinite
+// scroll replaces page-by-page navigation), so only the order-by combobox +
+// options trigger remain in the top toolbar.
 const verifyControlsVisibility = (): void => {
 	// Order by controls
 	expect(screen.getByText(/Order by/i)).toBeInTheDocument();

-	// Pagination controls
-	expect(screen.getByRole('button', { name: /previous/i })).toBeInTheDocument();
-	expect(screen.getByRole('button', { name: /next/i })).toBeInTheDocument();
-
-	// Items per page selector (there are multiple comboboxes, so we check for at least 2)
+	// At least one combobox (order-by); page-size selector is gone post-migration.
 	const comboboxes = screen.getAllByRole('combobox');
-	expect(comboboxes.length).toBeGreaterThanOrEqual(2);
+	expect(comboboxes.length).toBeGreaterThanOrEqual(1);

 	// Options menu (settings button) - check for translation key or actual text
 	expect(screen.getByText(/options_menu.options|options/i)).toBeInTheDocument();
@@ -152,15 +151,10 @@ describe('Traces ListView - Error and Empty States', () => {
 				expect(screen.getByText(/Order by/i)).toBeInTheDocument();
 			});

-			// Order by controls should be interactive
+			// Order-by combobox should be interactive (pagination buttons removed
+			// after the TanStack migration switched List view to infinite scroll).
 			const comboboxes = screen.getAllByRole('combobox');
-			expect(comboboxes.length).toBeGreaterThanOrEqual(2);
-
-			// Pagination controls should be present
-			const previousButton = screen.getByRole('button', { name: /previous/i });
-			const nextButton = screen.getByRole('button', { name: /next/i });
-			expect(previousButton).toBeInTheDocument();
-			expect(nextButton).toBeInTheDocument();
+			expect(comboboxes.length).toBeGreaterThanOrEqual(1);

 			// Options menu should be clickable
 			const optionsButton = screen.getByText(/options_menu.options|options/i);
@@ -175,9 +169,9 @@ describe('Traces ListView - Error and Empty States', () => {
 				expect(screen.getByText(/No traces yet/i)).toBeInTheDocument();
 			});

-			// All controls should be interactive
+			// At least the order-by combobox should be interactive.
 			const comboboxes = screen.getAllByRole('combobox');
-			expect(comboboxes.length).toBeGreaterThanOrEqual(2);
+			expect(comboboxes.length).toBeGreaterThanOrEqual(1);

 			// Options menu should be clickable
 			const optionsButton = screen.getByText(/options_menu.options|options/i);
--- a/frontend/src/container/TracesExplorer/ListView/index.tsx
+++ b/frontend/src/container/TracesExplorer/ListView/index.tsx
@@ -4,48 +4,46 @@ import {
 	MutableRefObject,
 	SetStateAction,
 	useCallback,
-	useEffect,
 	useMemo,
 	useState,
 } from 'react';
 // eslint-disable-next-line no-restricted-imports
 import { useSelector } from 'react-redux';
-import logEvent from 'api/common/logEvent';
+import { ArrowUp10, Minus } from '@signozhq/icons';
 import DownloadOptionsMenu from 'components/DownloadOptionsMenu/DownloadOptionsMenu';
-import ErrorInPlace from 'components/ErrorInPlace/ErrorInPlace';
 import ListViewOrderBy from 'components/OrderBy/ListViewOrderBy';
-import { ResizeTable } from 'components/ResizeTable';
+import { TracesTable } from 'components/Traces/TableView/TracesTable';
+import { useTraceInfiniteQuery } from 'components/Traces/TableView/useTraceInfiniteQuery';
+import { useTracesTableColumns } from 'components/Traces/TableView/useTracesTableColumns';
 import { ENTITY_VERSION_V5 } from 'constants/app';
 import { LOCALSTORAGE } from 'constants/localStorage';
-import { QueryParams } from 'constants/query';
 import { initialQueriesMap, PANEL_TYPES } from 'constants/queryBuilder';
-import { REACT_QUERY_KEY } from 'constants/reactQueryKeys';
-import EmptyLogsSearch from 'container/EmptyLogsSearch/EmptyLogsSearch';
-import NoLogs from 'container/NoLogs/NoLogs';
 import { useOptionsMenu } from 'container/OptionsMenu';
 import { CustomTimeType } from 'container/TopNav/DateTimeSelectionV2/types';
 import TraceExplorerControls from 'container/TracesExplorer/Controls';
 import { getListViewQuery } from 'container/TracesExplorer/explorerUtils';
-import { useGetQueryRange } from 'hooks/queryBuilder/useGetQueryRange';
 import { useQueryBuilder } from 'hooks/queryBuilder/useQueryBuilder';
-import { Pagination } from 'hooks/queryPagination';
-import { getDefaultPaginationConfig } from 'hooks/queryPagination/utils';
-import useUrlQueryData from 'hooks/useUrlQueryData';
-import { ArrowUp10, Minus } from '@signozhq/icons';
+import type { Pagination } from 'hooks/queryPagination';
+import type { GetQueryResultsProps } from 'lib/dashboard/getQueryResults';
 import { useTimezone } from 'providers/Timezone';
 import { AppState } from 'store/reducers';
 import { Warning } from 'types/api';
-import APIError from 'types/api/error';
+import type { MetricQueryRangeSuccessResponse } from 'types/api/metrics/getQueryRange';
 import { DataSource } from 'types/common/queryBuilder';
 import { GlobalReducer } from 'types/reducer/globalTime';

-import { TracesLoading } from '../TraceLoading/TraceLoading';
-import { defaultSelectedColumns, PER_PAGE_OPTIONS } from './configs';
-import { Container, tableStyles } from './styles';
-import { getListColumns, transformDataWithDate } from './utils';
+import { getTraceLink } from 'components/Traces/TableView/getTraceLink';
+import {
+	makeListFieldCol,
+	makeTimestampCol,
+	SpanRow,
+	transformSpanRows,
+} from './utils';

 import './ListView.styles.scss';

+import styles from './ListView.module.scss';
+
 interface ListViewProps {
 	isFilterApplied: boolean;
 	setWarning: Dispatch<SetStateAction<Warning | undefined>>;
@@ -77,25 +75,11 @@ function ListView({
 		storageKey: LOCALSTORAGE.TRACES_LIST_OPTIONS,
 		dataSource: DataSource.TRACES,
 		aggregateOperator: 'count',
-		initialOptions: {
-			selectColumns: defaultSelectedColumns,
-		},
 	});

-	const { queryData: paginationQueryData } = useUrlQueryData<Pagination>(
-		QueryParams.pagination,
-	);
-	const paginationConfig =
-		paginationQueryData ?? getDefaultPaginationConfig(PER_PAGE_OPTIONS);
-
-	const requestQuery = useMemo(
-		() => getListViewQuery(stagedQuery || initialQueriesMap.traces, orderBy),
-		[stagedQuery, orderBy],
-	);
-
-	// TEMP — remove after traces moves to TanStack table.
+	// Stable sorted-name signature for the queryKey + reset trigger.
 	// - Drag updates selectColumns; raw queryKey would churn on reorder.
-	// - Trace API fetches only listed columns → add/remove must refetch.
+	// - Trace API fetches only listed columns → add/remove must refetch from scratch.
 	// - Sorted-name signature: stable on reorder, changes on add/remove.
 	const selectColumnsSignature = useMemo(
 		() =>
@@ -106,140 +90,92 @@ function ListView({
 		[options?.selectColumns],
 	);

-	const queryKey = useMemo(
-		() => [
-			REACT_QUERY_KEY.GET_QUERY_RANGE,
-			globalSelectedTime,
-			maxTime,
-			minTime,
-			stagedQuery,
-			panelType,
-			paginationConfig,
-			selectColumnsSignature,
-			orderBy,
-		],
-		[
-			stagedQuery,
-			panelType,
-			globalSelectedTime,
-			paginationConfig,
-			selectColumnsSignature,
-			maxTime,
-			minTime,
-			orderBy,
-		],
+	const requestQuery = useMemo(
+		() => getListViewQuery(stagedQuery || initialQueriesMap.traces, orderBy),
+		[stagedQuery, orderBy],
 	);

-	if (queryKeyRef) {
-		queryKeyRef.current = queryKey;
-	}
-
-	const { data, isFetching, isLoading, isError, error } = useGetQueryRange(
-		{
+	const buildRequest = useCallback(
+		(pagination: Pagination): GetQueryResultsProps => ({
 			query: requestQuery,
 			graphType: panelType,
 			selectedTime: 'GLOBAL_TIME' as const,
 			globalSelectedInterval: globalSelectedTime as CustomTimeType,
-			params: {
-				dataSource: 'traces',
-			},
+			params: { dataSource: 'traces' },
 			tableParams: {
-				pagination: paginationConfig,
+				pagination,
 				selectColumns: options?.selectColumns,
 			},
+		}),
+		[requestQuery, panelType, globalSelectedTime, options?.selectColumns],
+	);
+
+	const transformResponse = useCallback(
+		(
+			payload: MetricQueryRangeSuccessResponse['payload'] | undefined,
+		): SpanRow[] => {
+			const result = payload?.data?.newResult?.data?.result;
+			return result ? transformSpanRows(result) : [];
 		},
-		// ENTITY_VERSION_V4,
-		ENTITY_VERSION_V5,
-		{
-			queryKey,
-			enabled:
-				// don't make api call while the time range state in redux is loading
-				!timeRangeUpdateLoading &&
-				!!stagedQuery &&
-				panelType === PANEL_TYPES.LIST &&
-				!!options?.selectColumns?.length,
-		},
+		[],
 	);

-	useEffect(() => {
-		if (data?.payload) {
-			setWarning(data?.warning);
-		}
-		// eslint-disable-next-line react-hooks/exhaustive-deps
-	}, [data?.payload, data?.warning]);
-
-	useEffect(() => {
-		if (isLoading || isFetching) {
-			setIsLoadingQueries(true);
-		} else {
-			setIsLoadingQueries(false);
-		}
-	}, [isLoading, isFetching, setIsLoadingQueries]);
-
-	const dataLength =
-		data?.payload?.data?.newResult?.data?.result[0]?.list?.length;
-	const totalCount = useMemo(() => dataLength || 0, [dataLength]);
-
-	const queryTableDataResult = data?.payload?.data?.newResult?.data?.result;
-	const queryTableData = useMemo(
-		() => queryTableDataResult || [],
-		[queryTableDataResult],
-	);
-
-	const { formatTimezoneAdjustedTimestamp } = useTimezone();
-
-	const columns = useMemo(
-		() =>
-			getListColumns(
-				options?.selectColumns || [],
-				formatTimezoneAdjustedTimestamp,
-			),
-		[options?.selectColumns, formatTimezoneAdjustedTimestamp],
-	);
-
-	const transformedQueryTableData = useMemo(
-		() => transformDataWithDate(queryTableData) || [],
-		[queryTableData],
-	);
-
-	const handleDragColumn = useCallback(
-		(fromIndex: number, toIndex: number): void => {
-			const reordered = [...columns];
-			const [moved] = reordered.splice(fromIndex, 1);
-			reordered.splice(toIndex, 0, moved);
-			// `key` is the composite (fieldContext.name) — disambiguates same-name fields.
-			const orderedIds = reordered
-				.map((c) => String(c.key || ('dataIndex' in c && c.dataIndex) || ''))
-				.filter(Boolean);
-			config?.addColumn?.onReorder(orderedIds);
-		},
-		[columns, config],
-	);
+	const {
+		rows: accumulatedRows,
+		isLoading,
+		isFetching,
+		isError,
+		error,
+		handleEndReached,
+	} = useTraceInfiniteQuery<SpanRow>({
+		queryDeps: [
+			stagedQuery,
+			panelType,
+			globalSelectedTime,
+			maxTime,
+			minTime,
+			orderBy,
+			selectColumnsSignature,
+		],
+		buildRequest,
+		transformResponse,
+		enabled:
+			!timeRangeUpdateLoading &&
+			!!stagedQuery &&
+			panelType === PANEL_TYPES.LIST &&
+			!!options?.selectColumns?.length,
+		entityVersion: ENTITY_VERSION_V5,
+		queryKeyRef,
+		setIsLoadingQueries,
+		setWarning,
+		panelType,
+	});

 	const handleOrderChange = useCallback((value: string) => {
 		setOrderBy(value);
 	}, []);

-	const isDataAbsent =
-		!isLoading &&
-		!isFetching &&
-		!isError &&
-		transformedQueryTableData.length === 0;
+	const { formatTimezoneAdjustedTimestamp } = useTimezone();
+
+	const baseColumns = useMemo(
+		() => [
+			makeTimestampCol(formatTimezoneAdjustedTimestamp),
+			...(options?.selectColumns ?? []).map(makeListFieldCol),
+		],
+		[formatTimezoneAdjustedTimestamp, options?.selectColumns],
+	);
+
+	const tableColumns = useTracesTableColumns<SpanRow>({ baseColumns });
+
+	const handleColumnOrderChange = useCallback(
+		(cols: { id: string }[]): void => {
+			config?.addColumn?.onReorder(cols.map((c) => c.id));
+		},
+		[config],
+	);

-	useEffect(() => {
-		if (
-			!isLoading &&
-			!isFetching &&
-			!isError &&
-			transformedQueryTableData.length !== 0
-		) {
-			logEvent('Traces Explorer: Data present', {
-				panelType,
-			});
-		}
-	}, [isLoading, isFetching, isError, transformedQueryTableData, panelType]);
 	return (
-		<Container>
+		<div className={styles.container}>
 			<div className="trace-explorer-controls">
 				<div className="order-by-container">
 					<div className="order-by-label">
@@ -258,41 +194,26 @@ function ListView({
 					selectedColumns={options?.selectColumns}
 				/>

-				<TraceExplorerControls
-					isLoading={isFetching}
-					totalCount={totalCount}
-					config={config}
-					perPageOptions={PER_PAGE_OPTIONS}
-				/>
+				<TraceExplorerControls config={config} />
 			</div>

-			{isError && error && <ErrorInPlace error={error as APIError} />}
-
-			{(isLoading || (isFetching && transformedQueryTableData.length === 0)) && (
-				<TracesLoading />
-			)}
-
-			{isDataAbsent && !isFilterApplied && (
-				<NoLogs dataSource={DataSource.TRACES} />
-			)}
-
-			{isDataAbsent && isFilterApplied && (
-				<EmptyLogsSearch dataSource={DataSource.TRACES} panelType="LIST" />
-			)}
-
-			{!isError && transformedQueryTableData.length !== 0 && (
-				<ResizeTable
-					tableLayout="fixed"
-					pagination={false}
-					scroll={{ x: 'max-content' }}
-					loading={isFetching}
-					style={tableStyles}
-					dataSource={transformedQueryTableData}
-					columns={columns}
-					onDragColumn={handleDragColumn}
-				/>
-			)}
-		</Container>
+			<TracesTable<SpanRow>
+				data={accumulatedRows}
+				columns={tableColumns}
+				isLoading={isLoading}
+				isFetching={isFetching}
+				isError={isError}
+				error={error}
+				isFilterApplied={isFilterApplied}
+				panelType="LIST"
+				columnStorageKey={LOCALSTORAGE.TRACES_LIST_COLUMNS}
+				respectColumnOrder={false}
+				onColumnOrderChange={handleColumnOrderChange}
+				onColumnRemove={config?.addColumn?.onRemove}
+				getRowHref={getTraceLink}
+				onEndReached={handleEndReached}
+			/>
+		</div>
 	);
 }

--- a/frontend/src/container/TracesExplorer/ListView/styles.ts
+++ b/frontend/src/container/TracesExplorer/ListView/styles.ts
@@ -1,21 +1,6 @@
 import { CSSProperties } from 'react';
-import { Typography } from '@signozhq/ui/typography';
-import styled from 'styled-components';

+// Kept for legacy antd consumers (TracesTableComponent, LogsPanelComponent).
 export const tableStyles: CSSProperties = {
 	cursor: 'unset',
 };
-
-export const Container = styled.div`
-	display: flex;
-	flex-direction: column;
-	--typography-color: var(--l1-foreground);
-`;
-
-export const ErrorText = styled(Typography)`
-	text-align: center;
-`;
-
-export const DateText = styled(Typography)`
-	min-width: 145px;
-`;
--- a/frontend/src/container/TracesExplorer/ListView/utils.tsx
+++ b/frontend/src/container/TracesExplorer/ListView/utils.tsx
@@ -3,17 +3,26 @@ import type { TableColumnsType as ColumnsType } from 'antd';
 import { Badge } from '@signozhq/ui/badge';
 import { Typography } from '@signozhq/ui/typography';
 import { TelemetryFieldKey } from 'api/v5/v5';
+import TanStackTable from 'components/TanStackTableView';
+import type { TableColumnDef } from 'components/TanStackTableView/types';
+import { getTraceLink } from 'components/Traces/TableView/getTraceLink';
 import { DATE_TIME_FORMATS } from 'constants/dateTimeFormats';
-import ROUTES from 'constants/routes';
 import { buildCompositeKey } from 'container/OptionsMenu/utils';
 import { getMs } from 'container/Trace/Filters/Panel/PanelBody/Duration/util';
-import { formUrlParams } from 'container/TraceDetail/utils';
 import { TimestampInput } from 'hooks/useTimezoneFormatter/useTimezoneFormatter';
 import { RowData } from 'lib/query/createTableColumnsFromQuery';
 import LineClampedText from 'periscope/components/LineClampedText/LineClampedText';
 import { ILog } from 'types/api/logs/log';
 import { QueryDataV3 } from 'types/api/widgets/getQuery';

+// `BlockLink`, `getListColumns`, `transformDataWithDate` are kept for legacy
+// antd consumers. `getTraceLink` is shared with the TanStack ListView, which
+// otherwise uses `make*Col` / `SpanRow` / `transformSpanRows`.
+
+// ---------------------------------------------------------------------------
+// Legacy antd consumers
+// ---------------------------------------------------------------------------
+
 export function BlockLink({
 	children,
 	to,
@@ -41,12 +50,22 @@ export const transformDataWithDate = (
 	data[0]?.list?.map(({ data, timestamp }) => ({ ...data, date: timestamp })) ||
 	[];

-export const getTraceLink = (record: RowData): string =>
-	`${ROUTES.TRACE}/${record.traceID || record.trace_id}${formUrlParams({
-		spanId: record.spanID || record.span_id,
-		levelUp: 0,
-		levelDown: 0,
-	})}`;
+// Re-export for legacy antd consumers (TracesTableComponent, EntityTraces) that
+// import from this path. New code should import from
+// `components/Traces/TableView/getTraceLink`.
+
+function stringifyCellValue(value: unknown): string {
+	if (value == null) {
+		return '';
+	}
+	if (typeof value === 'string') {
+		return value;
+	}
+	if (typeof value === 'number' || typeof value === 'boolean') {
+		return String(value);
+	}
+	return JSON.stringify(value);
+}

 export const getListColumns = (
 	selectedColumns: TelemetryFieldKey[],
@@ -136,3 +155,111 @@ export const getListColumns = (

 	return [...initialColumns, ...columns];
 };
+
+// ---------------------------------------------------------------------------
+// TanStack ListView (current)
+// ---------------------------------------------------------------------------
+
+// Span row shape for the trace list view. Known intrinsic fields explicit; the
+// rest of the row comes from user-selected dynamic columns (selectColumns), hence
+// the Record intersection. `timestamp` is added by transformSpanRows from the
+// API's wrapping ListItem.timestamp (data itself omits it).
+export type SpanRow = {
+	trace_id: string;
+	span_id: string;
+	timestamp: string;
+} & Record<string, unknown>;
+
+export const transformSpanRows = (data: QueryDataV3[]): SpanRow[] => {
+	const list = data[0]?.list;
+	if (!list) {
+		return [];
+	}
+	return list.map((item) => {
+		const row = item.data as Record<string, unknown>;
+		return {
+			...row,
+			timestamp: item.timestamp,
+			id: row.span_id,
+		};
+	}) as unknown as SpanRow[];
+};
+
+// Field-name allowlists that drive signal-specific cell rendering (kept from the
+// pre-TanStack getListColumns). Both legacy camelCase + snake_case variants are
+// listed because the API has shipped both over time.
+const STATUS_FIELD_NAMES = new Set([
+	'httpMethod',
+	'http_method',
+	'responseStatusCode',
+	'response_status_code',
+]);
+const DURATION_FIELD_NAMES = new Set(['durationNano', 'duration_nano']);
+
+type TimestampFormatter = (
+	input: TimestampInput,
+	format?: string,
+) => string | number;
+
+export function makeTimestampCol(
+	formatTimezoneAdjustedTimestamp: TimestampFormatter,
+): TableColumnDef<SpanRow> {
+	return {
+		id: buildCompositeKey('timestamp', 'span'),
+		header: 'Timestamp',
+		accessorFn: (row): unknown => row.timestamp,
+		// Pinned left as a visual anchor during horizontal scroll. Trade-off: the
+		// sticky-positioning + cell `overflow: hidden` in TanStackTable.module.scss
+		// makes the right-edge resize handle effectively unhittable for pinned
+		// columns — accepted.
+		pin: 'left',
+		canBeHidden: false,
+		enableRemove: false,
+		width: { default: 170, min: 170 },
+		cell: ({ value }): JSX.Element => {
+			const ts = value as string | number;
+			const formatted =
+				typeof ts === 'string'
+					? formatTimezoneAdjustedTimestamp(ts, DATE_TIME_FORMATS.ISO_DATETIME_MS)
+					: formatTimezoneAdjustedTimestamp(
+							ts / 1e6,
+							DATE_TIME_FORMATS.ISO_DATETIME_MS,
+						);
+			return <TanStackTable.Text>{String(formatted)}</TanStackTable.Text>;
+		},
+	};
+}
+
+export function makeListFieldCol(
+	f: TelemetryFieldKey,
+): TableColumnDef<SpanRow> {
+	return {
+		id: buildCompositeKey(f.name, f.fieldContext, f.fieldDataType),
+		header: f.name,
+		accessorFn: (row): unknown => row[f.name],
+		enableRemove: true,
+		width: { min: 192 },
+		cell: ({ value }): JSX.Element => {
+			if (value === '' || value == null) {
+				return <TanStackTable.Text data-testid={f.name}>N/A</TanStackTable.Text>;
+			}
+			const text = stringifyCellValue(value);
+			if (STATUS_FIELD_NAMES.has(f.name)) {
+				return (
+					<Badge data-testid={f.name} color="sakura" variant="outline">
+						{text}
+					</Badge>
+				);
+			}
+			if (DURATION_FIELD_NAMES.has(f.name)) {
+				return (
+					<TanStackTable.Text data-testid={f.name}>
+						{getMs(text)}
+						ms
+					</TanStackTable.Text>
+				);
+			}
+			return <TanStackTable.Text data-testid={f.name}>{text}</TanStackTable.Text>;
+		},
+	};
+}
--- a/frontend/src/container/TracesExplorer/TracesView/TracesView.module.scss
+++ b/frontend/src/container/TracesExplorer/TracesView/TracesView.module.scss
@@ -0,0 +1,18 @@
+.container {
+	display: flex;
+	flex-direction: column;
+	flex: 1;
+	min-height: 0;
+	// Page chain isn't a flex column; anchor against the viewport.
+	height: calc(100vh - 240px);
+	min-height: 400px;
+
+	--tanstack-cell-padding-left-first-column: 12px;
+}
+
+.actionsContainer {
+	display: flex;
+	padding-bottom: 8px;
+	justify-content: space-between;
+	align-items: center;
+}
--- a/frontend/src/container/TracesExplorer/TracesView/configs.tsx
+++ b/frontend/src/container/TracesExplorer/TracesView/configs.tsx
@@ -1,50 +1,72 @@
-import { generatePath, Link } from 'react-router-dom';
-import type { TableColumnsType as ColumnsType } from 'antd';
-import { Typography } from '@signozhq/ui/typography';
-import ROUTES from 'constants/routes';
+import TanStackTable from 'components/TanStackTableView';
+import type { TableColumnDef } from 'components/TanStackTableView/types';
+import { buildCompositeKey } from 'container/OptionsMenu/utils';
 import { getMs } from 'container/Trace/Filters/Panel/PanelBody/Duration/util';
 import { DEFAULT_PER_PAGE_OPTIONS } from 'hooks/queryPagination';
-import { ListItem } from 'types/api/widgets/getQuery';

 export const PER_PAGE_OPTIONS: number[] = [10, ...DEFAULT_PER_PAGE_OPTIONS];

-export const columns: ColumnsType<ListItem['data']> = [
+// Trace-grouped (group-by-trace) row shape. Distinct from logs' `ListItem.data`
+// (which is `Omit<ILog, 'timestamp' | 'span_id'>` — the legacy logs shape).
+// Trace rows ship trace-summary fields; runtime keys often contain dots (e.g.
+// `service.name`), so the row indexes via string keys, not nested-property access.
+export type TraceRow = {
+	'service.name': string;
+	name: string;
+	duration_nano: number | string;
+	span_count: number | string;
+	trace_id: string;
+	// Mirror of trace_id used by TanStack's getRowId. Injected during response
+	// transform — without it, rows fall back to positional index.
+	id: string;
+};
+
+export const columns: TableColumnDef<TraceRow>[] = [
 	{
-		title: 'Root Service Name',
-		dataIndex: 'service.name',
-		key: 'serviceName',
-	},
-	{
-		title: 'Root Operation Name',
-		dataIndex: 'name',
-		key: 'name',
-	},
-	{
-		title: 'Root Duration (in ms)',
-		dataIndex: 'duration_nano',
-		key: 'durationNano',
-		render: (duration: number): JSX.Element => (
-			<Typography>{getMs(String(duration))}ms</Typography>
+		id: buildCompositeKey('service.name', 'resource'),
+		header: 'Root Service Name',
+		accessorFn: (row): unknown => row['service.name'],
+		cell: ({ value }): JSX.Element => (
+			<TanStackTable.Text>{String(value ?? '')}</TanStackTable.Text>
 		),
+		width: { min: 192 },
 	},
 	{
-		title: 'No of Spans',
-		dataIndex: 'span_count',
-		key: 'span_count',
-	},
-	{
-		title: 'TraceID',
-		dataIndex: 'trace_id',
-		key: 'traceID',
-		render: (traceID: string): JSX.Element => (
-			<Link
-				to={generatePath(ROUTES.TRACE_DETAIL, {
-					id: traceID,
-				})}
-				data-testid="trace-id"
-			>
-				{traceID}
-			</Link>
+		id: 'name',
+		header: 'Root Operation Name',
+		accessorFn: (row): unknown => row.name,
+		cell: ({ value }): JSX.Element => (
+			<TanStackTable.Text data-testid="trace-id">
+				{String(value ?? '')}
+			</TanStackTable.Text>
 		),
+		width: { min: 200 },
+	},
+	{
+		id: 'duration_nano',
+		header: 'Root Duration (in ms)',
+		accessorFn: (row): unknown => row.duration_nano,
+		cell: ({ value }): JSX.Element => (
+			<TanStackTable.Text>{getMs(String(value))}ms</TanStackTable.Text>
+		),
+		width: { min: 180 },
+	},
+	{
+		id: 'span_count',
+		header: 'No of Spans',
+		accessorFn: (row): unknown => row.span_count,
+		cell: ({ value }): JSX.Element => (
+			<TanStackTable.Text>{String(value ?? '')}</TanStackTable.Text>
+		),
+		width: { min: 120 },
+	},
+	{
+		id: 'trace_id',
+		header: 'TraceID',
+		accessorFn: (row): unknown => row.trace_id,
+		cell: ({ value }): JSX.Element => (
+			<TanStackTable.Text>{String(value ?? '')}</TanStackTable.Text>
+		),
+		width: { min: 250 },
 	},
 ];
--- a/frontend/src/container/TracesExplorer/TracesView/index.tsx
+++ b/frontend/src/container/TracesExplorer/TracesView/index.tsx
@@ -1,40 +1,34 @@
-/* eslint-disable sonarjs/cognitive-complexity */
 import {
 	Dispatch,
 	memo,
 	MutableRefObject,
 	SetStateAction,
-	useEffect,
+	useCallback,
 	useMemo,
 } from 'react';
 // eslint-disable-next-line no-restricted-imports
 import { useSelector } from 'react-redux';
 import { Typography } from '@signozhq/ui/typography';
-import logEvent from 'api/common/logEvent';
-import ErrorInPlace from 'components/ErrorInPlace/ErrorInPlace';
-import { ResizeTable } from 'components/ResizeTable';
+import { getTraceLink } from 'components/Traces/TableView/getTraceLink';
+import { TracesTable } from 'components/Traces/TableView/TracesTable';
+import { useTraceInfiniteQuery } from 'components/Traces/TableView/useTraceInfiniteQuery';
+import { useTracesTableColumns } from 'components/Traces/TableView/useTracesTableColumns';
 import { ENTITY_VERSION_V5 } from 'constants/app';
-import { QueryParams } from 'constants/query';
+import { LOCALSTORAGE } from 'constants/localStorage';
 import { initialQueriesMap, PANEL_TYPES } from 'constants/queryBuilder';
-import { REACT_QUERY_KEY } from 'constants/reactQueryKeys';
-import EmptyLogsSearch from 'container/EmptyLogsSearch/EmptyLogsSearch';
-import NoLogs from 'container/NoLogs/NoLogs';
 import { getListViewQuery } from 'container/TracesExplorer/explorerUtils';
-import { useGetQueryRange } from 'hooks/queryBuilder/useGetQueryRange';
 import { useQueryBuilder } from 'hooks/queryBuilder/useQueryBuilder';
-import { Pagination } from 'hooks/queryPagination';
-import useUrlQueryData from 'hooks/useUrlQueryData';
+import type { Pagination } from 'hooks/queryPagination';
+import type { GetQueryResultsProps } from 'lib/dashboard/getQueryResults';
 import { AppState } from 'store/reducers';
 import { Warning } from 'types/api';
-import APIError from 'types/api/error';
-import { DataSource } from 'types/common/queryBuilder';
+import type { MetricQueryRangeSuccessResponse } from 'types/api/metrics/getQueryRange';
 import { GlobalReducer } from 'types/reducer/globalTime';
 import DOCLINKS from 'utils/docLinks';

-import TraceExplorerControls from '../Controls';
-import { TracesLoading } from '../TraceLoading/TraceLoading';
-import { columns, PER_PAGE_OPTIONS } from './configs';
-import { ActionsContainer, Container } from './styles';
+import { columns as baseColumns, TraceRow } from './configs';
+
+import styles from './TracesView.module.scss';

 interface TracesViewProps {
 	isFilterApplied: boolean;
@@ -57,92 +51,66 @@ function TracesView({
 		minTime,
 	} = useSelector<AppState, GlobalReducer>((state) => state.globalTime);

-	const { queryData: paginationQueryData } = useUrlQueryData<Pagination>(
-		QueryParams.pagination,
-	);
-
 	const transformedQuery = useMemo(
 		() => getListViewQuery(stagedQuery || initialQueriesMap.traces),
 		[stagedQuery],
 	);

-	const queryKey = useMemo(
-		() => [
-			REACT_QUERY_KEY.GET_QUERY_RANGE,
-			globalSelectedTime,
-			maxTime,
-			minTime,
-			stagedQuery,
-			panelType,
-			paginationQueryData,
-		],
-		[
-			globalSelectedTime,
-			maxTime,
-			minTime,
-			stagedQuery,
-			panelType,
-			paginationQueryData,
-		],
-	);
-
-	if (queryKeyRef) {
-		queryKeyRef.current = queryKey;
-	}
-
-	const { data, isLoading, isFetching, isError, error } = useGetQueryRange(
-		{
+	const buildRequest = useCallback(
+		(pagination: Pagination): GetQueryResultsProps => ({
 			query: transformedQuery,
 			graphType: panelType || PANEL_TYPES.TRACE,
 			selectedTime: 'GLOBAL_TIME',
 			globalSelectedInterval: globalSelectedTime,
-			params: {
-				dataSource: 'traces',
-			},
-			tableParams: {
-				pagination: paginationQueryData,
-			},
-		},
-		ENTITY_VERSION_V5,
-		{
-			queryKey,
-			enabled: !!stagedQuery && panelType === PANEL_TYPES.TRACE,
-		},
+			params: { dataSource: 'traces' },
+			tableParams: { pagination },
+		}),
+		[transformedQuery, panelType, globalSelectedTime],
 	);

-	useEffect(() => {
-		if (data?.payload) {
-			setWarning(data?.warning);
-		}
-		// eslint-disable-next-line react-hooks/exhaustive-deps
-	}, [data?.payload, data?.warning]);
-
-	const responseData = data?.payload?.data?.newResult?.data?.result[0]?.list;
-	const tableData = useMemo(
-		() => responseData?.map((listItem) => listItem.data),
-		[responseData],
-	);
-
-	useEffect(() => {
-		if (isLoading || isFetching) {
-			setIsLoadingQueries(true);
-		} else {
-			setIsLoadingQueries(false);
-		}
-	}, [isLoading, isFetching, setIsLoadingQueries]);
-
-	useEffect(() => {
-		if (!isLoading && !isFetching && !isError && (tableData || []).length !== 0) {
-			logEvent('Traces Explorer: Data present', {
-				panelType: 'TRACE',
+	const transformResponse = useCallback(
+		(
+			payload: MetricQueryRangeSuccessResponse['payload'] | undefined,
+		): TraceRow[] => {
+			const list = payload?.data?.newResult?.data?.result?.[0]?.list;
+			if (!list) {
+				return [];
+			}
+			// API returns trace-summary rows; the `ListItem.data` static type is the
+			// legacy logs shape, so route through `unknown` to land on `TraceRow`.
+			return list.map((li) => {
+				const row = li.data as unknown as TraceRow;
+				return { ...row, id: row.trace_id };
 			});
-		}
-	}, [isLoading, isFetching, isError, panelType, tableData]);
+		},
+		[],
+	);
+
+	const {
+		rows: accumulatedRows,
+		isLoading,
+		isFetching,
+		isError,
+		error,
+		handleEndReached,
+	} = useTraceInfiniteQuery<TraceRow>({
+		queryDeps: [stagedQuery, panelType, globalSelectedTime, maxTime, minTime],
+		buildRequest,
+		transformResponse,
+		enabled: !!stagedQuery && panelType === PANEL_TYPES.TRACE,
+		entityVersion: ENTITY_VERSION_V5,
+		queryKeyRef,
+		setIsLoadingQueries,
+		setWarning,
+		panelType: 'TRACE',
+	});
+
+	const tableColumns = useTracesTableColumns<TraceRow>({ baseColumns });

 	return (
-		<Container>
-			{(tableData || []).length !== 0 && (
-				<ActionsContainer>
+		<div className={styles.container}>
+			{accumulatedRows.length !== 0 && (
+				<div className={styles.actionsContainer}>
 					<Typography>
 						This tab only shows Root Spans. More details
 						<Typography.Link href={DOCLINKS.TRACES_DETAILS_LINK} target="_blank">
@@ -150,48 +118,23 @@ function TracesView({
 							here
 						</Typography.Link>
 					</Typography>
-
-					<div className="trace-explorer-controls">
-						<TraceExplorerControls
-							isLoading={isLoading}
-							totalCount={responseData?.length || 0}
-							perPageOptions={PER_PAGE_OPTIONS}
-						/>
-					</div>
-				</ActionsContainer>
+				</div>
 			)}

-			{isError && error && <ErrorInPlace error={error as APIError} />}
-
-			{(isLoading || (isFetching && (tableData || []).length === 0)) && (
-				<TracesLoading />
-			)}
-
-			{!isLoading &&
-				!isFetching &&
-				!isError &&
-				!isFilterApplied &&
-				(tableData || []).length === 0 && <NoLogs dataSource={DataSource.TRACES} />}
-
-			{!isLoading &&
-				!isFetching &&
-				(tableData || []).length === 0 &&
-				!isError &&
-				isFilterApplied && (
-					<EmptyLogsSearch dataSource={DataSource.TRACES} panelType="TRACE" />
-				)}
-
-			{(tableData || []).length !== 0 && (
-				<ResizeTable
-					loading={isLoading}
-					columns={columns}
-					tableLayout="fixed"
-					dataSource={tableData}
-					scroll={{ x: true }}
-					pagination={false}
-				/>
-			)}
-		</Container>
+			<TracesTable<TraceRow>
+				data={accumulatedRows}
+				columns={tableColumns}
+				isLoading={isLoading}
+				isFetching={isFetching}
+				isError={isError}
+				error={error}
+				isFilterApplied={isFilterApplied}
+				panelType="TRACE"
+				columnStorageKey={LOCALSTORAGE.TRACES_VIEW_COLUMNS}
+				getRowHref={getTraceLink}
+				onEndReached={handleEndReached}
+			/>
+		</div>
 	);
 }

--- a/frontend/src/container/TracesExplorer/TracesView/styles.ts
+++ b/frontend/src/container/TracesExplorer/TracesView/styles.ts
@@ -1,12 +0,0 @@
-import styled from 'styled-components';
-
-export const Container = styled.div`
-	display: flex;
-	flex-direction: column;
-`;
-
-export const ActionsContainer = styled.div`
-	display: flex;
-	justify-content: space-between;
-	align-items: center;
-`;
--- a/frontend/src/container/TracesTableComponent/TracesTableComponent.tsx
+++ b/frontend/src/container/TracesTableComponent/TracesTableComponent.tsx
@@ -11,12 +11,12 @@ import { UseQueryResult } from 'react-query';
 import OverlayScrollbar from 'components/OverlayScrollbar/OverlayScrollbar';
 import { ResizeTable } from 'components/ResizeTable';
 import { SOMETHING_WENT_WRONG } from 'constants/api';
+import { getTraceLink } from 'components/Traces/TableView/getTraceLink';
 import Controls from 'container/Controls';
 import { PER_PAGE_OPTIONS } from 'container/TracesExplorer/ListView/configs';
 import { tableStyles } from 'container/TracesExplorer/ListView/styles';
 import {
 	getListColumns,
-	getTraceLink,
 	transformDataWithDate,
 } from 'container/TracesExplorer/ListView/utils';
 import { Pagination } from 'hooks/queryPagination';
--- a/frontend/src/lib/recentQueries/getRecentQueries.test.ts
+++ b/frontend/src/lib/recentQueries/getRecentQueries.test.ts
@@ -1,51 +0,0 @@
-import * as store from './recentQueriesStore';
-import { getRecentQueries } from './getRecentQueries';
-
-describe('getRecentQueries', () => {
-	beforeEach(() => {
-		store.useRecentQueriesStore.setState({ buckets: {} });
-		localStorage.clear();
-	});
-
-	it('returns the entries for a (signal, source) bucket', () => {
-		store.save({
-			signal: 'logs',
-			filter: { expression: "severity_text = 'ERROR'" },
-		});
-
-		const entries = getRecentQueries('logs', '');
-		expect(entries).toHaveLength(1);
-		expect(entries[0].filter.expression).toBe("severity_text = 'ERROR'");
-	});
-
-	it('returns an empty array for a bucket with no entries', () => {
-		expect(getRecentQueries('logs', '')).toHaveLength(0);
-	});
-
-	it('reads the latest entries on each call (non-subscribing)', () => {
-		expect(getRecentQueries('logs', '')).toHaveLength(0);
-
-		store.save({
-			signal: 'logs',
-			filter: { expression: "severity_text = 'ERROR'" },
-		});
-
-		expect(getRecentQueries('logs', '')).toHaveLength(1);
-	});
-
-	it('partitions by signal and source', () => {
-		store.save({
-			signal: 'logs',
-			filter: { expression: "severity_text = 'ERROR'" },
-		});
-		store.save({
-			signal: 'metrics',
-			source: 'meter',
-			filter: { expression: 'cpu_usage > 80' },
-		});
-
-		expect(getRecentQueries('logs', '')).toHaveLength(1);
-		expect(getRecentQueries('metrics', 'meter')).toHaveLength(1);
-		expect(getRecentQueries('metrics', '')).toHaveLength(0);
-	});
-});
--- a/frontend/src/lib/recentQueries/getRecentQueries.ts
+++ b/frontend/src/lib/recentQueries/getRecentQueries.ts
@@ -3,12 +3,13 @@ import type { SignalType } from 'types/api/v5/queryRange';
 import * as store from './recentQueriesStore';
 import type { RecentQueryEntry } from './types';

-// Non-subscribing read of recent searches for a (signal, source) bucket.
-// Deliberately not the zustand hook — subscribing would reconfigure CodeMirror
-// and close the open completion popup on every store change.
+// Synchronous, non-subscribing read of the recent-queries bucket for a given
+// (signal, source). Read-on-demand by design — subscribing here would
+// reconfigure CodeMirror on every store change and close any open completion
+// popup. Pair with saveQuery() for the write path.
 export function getRecentQueries(
 	signal: SignalType,
-	source: string,
+	source = '',
 ): RecentQueryEntry[] {
 	return store.list(signal, source);
 }
--- a/frontend/src/lib/recentQueries/saveRecentQuery.test.ts
+++ b/frontend/src/lib/recentQueries/saveRecentQuery.test.ts
@@ -1,9 +1,5 @@
-import { EQueryType } from 'types/common/dashboard';
 import { DataSource } from 'types/common/queryBuilder';
-import type {
-	IBuilderQuery,
-	Query,
-} from 'types/api/queryBuilder/queryBuilderData';
+import type { IBuilderQuery } from 'types/api/queryBuilder/queryBuilderData';
 import { validateQuery } from 'utils/queryValidationUtils';

 import * as store from './recentQueriesStore';
@@ -17,14 +13,10 @@ const mockedValidateQuery = validateQuery as jest.MockedFunction<
 	typeof validateQuery
 >;

-const buildQuery = (overrides: Partial<IBuilderQuery>[] = [{}]): Query => ({
-	queryType: EQueryType.QUERY_BUILDER,
-	promql: [],
-	clickhouse_sql: [],
-	id: 'q1',
+const buildComposite = (
+	overrides: Partial<IBuilderQuery>[] = [{}],
+): { builder: { queryData: IBuilderQuery[] } } => ({
 	builder: {
-		queryFormulas: [],
-		queryTraceOperator: [],
 		queryData: overrides.map((o, i) => ({
 			queryName: `Q${i}`,
 			dataSource: DataSource.LOGS,
@@ -56,8 +48,8 @@ describe('saveRecentQuery', () => {
 		});
 	});

-	it('saves the query when validation passes', () => {
-		saveRecentQuery(buildQuery());
+	it('saves the composite query when validation passes', () => {
+		saveRecentQuery(buildComposite());

 		const entries = store.list('logs');
 		expect(entries).toHaveLength(1);
@@ -71,20 +63,20 @@ describe('saveRecentQuery', () => {
 			errors: [],
 		});

-		saveRecentQuery(buildQuery());
+		saveRecentQuery(buildComposite());

 		expect(store.list('logs')).toHaveLength(0);
 	});

 	it('does not save a builder query with an empty filter expression', () => {
-		saveRecentQuery(buildQuery([{ filter: { expression: '' } }]));
+		saveRecentQuery(buildComposite([{ filter: { expression: '' } }]));

 		expect(store.list('logs')).toHaveLength(0);
 	});

 	it('saves each builder query in the composite separately', () => {
 		saveRecentQuery(
-			buildQuery([
+			buildComposite([
 				{
 					dataSource: DataSource.LOGS,
 					filter: { expression: "service.name = 'frontend'" },
@@ -100,26 +92,21 @@ describe('saveRecentQuery', () => {
 		expect(store.list('traces')).toHaveLength(1);
 	});

-	it('keeps a single entry when the same query is run again', () => {
-		saveRecentQuery(buildQuery());
-		saveRecentQuery(buildQuery());
-
-		expect(store.list('logs')).toHaveLength(1);
-	});
-
-	it('adds a second entry when the filter changes', () => {
+	it('skips builder queries whose dataSource is not a supported signal', () => {
 		saveRecentQuery(
-			buildQuery([{ filter: { expression: "severity_text = 'ERROR'" } }]),
-		);
-		saveRecentQuery(
-			buildQuery([{ filter: { expression: 'http.status_code >= 500' } }]),
+			buildComposite([{ dataSource: 'unknown' as IBuilderQuery['dataSource'] }]),
 		);

-		expect(store.list('logs')).toHaveLength(2);
+		expect(store.list('logs')).toHaveLength(0);
+		expect(store.list('traces')).toHaveLength(0);
+		expect(store.list('metrics')).toHaveLength(0);
 	});

-	it('is a no-op when the query is null', () => {
+	it('is a no-op when the composite is null, undefined, or empty', () => {
 		saveRecentQuery(null);
+		saveRecentQuery(undefined);
+		saveRecentQuery({ builder: { queryData: [] } });
+		saveRecentQuery({});

 		expect(store.list('logs')).toHaveLength(0);
 	});
--- a/frontend/src/lib/recentQueries/saveRecentQuery.ts
+++ b/frontend/src/lib/recentQueries/saveRecentQuery.ts
@@ -1,8 +1,4 @@
-import type {
-	IBuilderQuery,
-	Query,
-	QueryState,
-} from 'types/api/queryBuilder/queryBuilderData';
+import type { IBuilderQuery } from 'types/api/queryBuilder/queryBuilderData';
 import type { SignalType } from 'types/api/v5/queryRange';
 import { validateQuery } from 'utils/queryValidationUtils';

@@ -19,20 +15,28 @@ function toSignal(dataSource: IBuilderQuery['dataSource']): SignalType | null {
 	return null;
 }

-// Persists each builder query's filter expression as a recent search, partitioned
-// by signal (and source). Call this on an explicit Stage & Run — not on staged-query
-// changes — so page loads, navigation, and correlation redirects don't pollute recents.
-// The store dedups by normalized filter, so re-running a query just bumps it to the front.
+type CompositeWithBuilder = {
+	builder?: { queryData?: IBuilderQuery[] };
+};
+
+// Persists each builder query in the composite as a recent entry. Call this
+// only from explicit user-driven Run triggers — reacting to stagedQuery or any
+// other derived state pollutes recents with navigation/refresh/go-to traffic.
 export function saveRecentQuery(
-	query: Query | QueryState | null | undefined,
+	query: CompositeWithBuilder | null | undefined,
 ): void {
-	const queryData = query?.builder?.queryData ?? [];
+	const queryData = query?.builder?.queryData;
+	if (!Array.isArray(queryData) || queryData.length === 0) {
+		return;
+	}
+
 	queryData.forEach((q) => {
 		const expression = q.filter?.expression?.trim();
 		if (!expression) {
 			return;
 		}
-		if (!validateQuery(expression).isValid) {
+		const validation = validateQuery(expression);
+		if (!validation.isValid) {
 			return;
 		}
 		const signal = toSignal(q.dataSource);
--- a/frontend/src/pages/TracesExplorer/TracesExplorer.styles.scss
+++ b/frontend/src/pages/TracesExplorer/TracesExplorer.styles.scss
@@ -66,24 +66,28 @@

 .trace-explorer-page {
 	display: flex;
+	height: 100%;
+	min-height: 0;
+	overflow: hidden;

 	.filter {
 		width: 260px;
 		height: 100%;
-		min-height: 100vh;
+		min-height: 0;
+		display: flex;
+		flex-direction: column;
+		overflow: hidden;

-		border-right: 0px;
 		border: 1px solid var(--l1-border);
 		background-color: var(--l1-background);
-
-		> .ant-card-body {
-			padding: 0;
-			width: 258px;
-		}
 	}

 	.trace-explorer {
 		width: 100%;
+		display: flex;
+		flex-direction: column;
+		flex: 1;
+		min-height: 0;
 		background: var(--l1-background);

 		> .ant-card-body {
--- a/frontend/src/pages/TracesExplorer/index.tsx
+++ b/frontend/src/pages/TracesExplorer/index.tsx
@@ -2,7 +2,6 @@ import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
 import { useQueryClient } from 'react-query';
 import { useSearchParams } from 'react-router-dom-v5-compat';
 import * as Sentry from '@sentry/react';
-import { Card } from 'antd';
 import logEvent from 'api/common/logEvent';
 import cx from 'classnames';
 import ExplorerCard from 'components/ExplorerCard/ExplorerCard';
@@ -24,7 +23,6 @@ import {
 	getQueryByPanelType,
 } from 'container/TracesExplorer/explorerUtils';
 import ListView from 'container/TracesExplorer/ListView';
-import { defaultSelectedColumns } from 'container/TracesExplorer/ListView/configs';
 import QuerySection from 'container/TracesExplorer/QuerySection';
 import TableView from 'container/TracesExplorer/TableView';
 import TracesView from 'container/TracesExplorer/TracesView';
@@ -80,9 +78,6 @@ function TracesExplorer(): JSX.Element {
 		storageKey: LOCALSTORAGE.TRACES_LIST_OPTIONS,
 		dataSource: DataSource.TRACES,
 		aggregateOperator: 'noop',
-		initialOptions: {
-			selectColumns: defaultSelectedColumns,
-		},
 	});

 	const [searchParams] = useSearchParams();
@@ -250,16 +245,18 @@ function TracesExplorer(): JSX.Element {
 	return (
 		<Sentry.ErrorBoundary fallback={<ErrorBoundaryFallback />}>
 			<div className="trace-explorer-page">
-				<Card className="filter" hidden={!isOpen}>
-					<QuickFilters
-						className="qf-traces-explorer"
-						source={QuickFiltersSource.TRACES_EXPLORER}
-						signal={SignalType.TRACES}
-						handleFilterVisibilityChange={(): void => {
-							setOpen(!isOpen);
-						}}
-					/>
-				</Card>
+				{isOpen && (
+					<section className="filter">
+						<QuickFilters
+							className="qf-traces-explorer"
+							source={QuickFiltersSource.TRACES_EXPLORER}
+							signal={SignalType.TRACES}
+							handleFilterVisibilityChange={(): void => {
+								setOpen(!isOpen);
+							}}
+						/>
+					</section>
+				)}
 				<div
 					className={cx('trace-explorer', {
 						'filters-expanded': isOpen,
--- a/frontend/src/pages/TracesModulePage/TracesModulePage.styles.scss
+++ b/frontend/src/pages/TracesModulePage/TracesModulePage.styles.scss
@@ -1,13 +1,48 @@
 .traces-module-container {
+	height: 100%;
+	min-height: 0;
+	display: flex;
+	flex-direction: column;
+	overflow: hidden;
+
+	> .ant-tabs {
+		flex: 1;
+		min-height: 0;
+		display: flex;
+		flex-direction: column;
+	}
+
 	.ant-tabs-nav {
 		padding: 0 16px;
 		margin-bottom: 0px;
+		flex-shrink: 0;

 		&::before {
 			border-bottom: 1px solid var(--l1-border) !important;
 		}
 	}

+	.ant-tabs-content-holder {
+		flex: 1;
+		min-height: 0;
+		display: flex;
+		flex-direction: column;
+	}
+
+	.ant-tabs-content {
+		flex: 1;
+		min-height: 0;
+		display: flex;
+		flex-direction: column;
+	}
+
+	.ant-tabs-tabpane-active {
+		flex: 1;
+		min-height: 0;
+		display: flex;
+		flex-direction: column;
+	}
+
 	.tab-item {
 		display: flex;
 		justify-content: center;
--- a/frontend/src/providers/QueryBuilder.tsx
+++ b/frontend/src/providers/QueryBuilder.tsx
@@ -39,9 +39,9 @@ import { updateStepInterval } from 'hooks/queryBuilder/useStepInterval';
 import { useSafeNavigate } from 'hooks/useSafeNavigate';
 import useUrlQuery from 'hooks/useUrlQuery';
 import { createIdFromObjectFields } from 'lib/createIdFromObjectFields';
-import { saveRecentQuery } from 'lib/recentQueries/saveRecentQuery';
 import { createNewBuilderItemName } from 'lib/newQueryBuilder/createNewBuilderItemName';
 import { getOperatorsBySourceAndPanelType } from 'lib/newQueryBuilder/getOperatorsBySourceAndPanelType';
+import { saveRecentQuery } from 'lib/recentQueries/saveRecentQuery';
 import { replaceIncorrectObjectFields } from 'lib/replaceIncorrectObjectFields';
 import { cloneDeep, get, isEqual, set } from 'lodash-es';
 import { BaseAutocompleteData } from 'types/api/queryBuilder/queryAutocompleteResponse';
@@ -1026,17 +1026,14 @@ export function QueryBuilderProvider({
 	);

 	const handleRunQuery = useCallback(() => {
-		// Save the run query to recent searches. Tied to the explicit Stage & Run
-		// gesture (not staged-query changes) so navigation and correlation redirects
-		// don't pollute recents.
-		saveRecentQuery(currentQuery);
-
 		const isExplorer =
 			location.pathname === ROUTES.LOGS_EXPLORER ||
 			location.pathname === ROUTES.TRACES_EXPLORER;
 		if (isExplorer) {
 			setCalledFromHandleRunQuery(true);
 		}
+		saveRecentQuery(currentQuery);
+
 		const currentQueryData = {
 			...currentQuery,
 			builder: {
--- a/frontend/src/providers/preferences/sync/usePreferenceSync.ts
+++ b/frontend/src/providers/preferences/sync/usePreferenceSync.ts
@@ -3,9 +3,9 @@ import { useEffect, useState } from 'react';
 import { TelemetryFieldKey } from 'api/v5/v5';
 import {
 	defaultLogsSelectedColumns,
+	defaultTraceSelectedColumns,
 	ensureLogsRequiredColumns,
 } from 'container/OptionsMenu/constants';
-import { defaultSelectedColumns as defaultTracesSelectedColumns } from 'container/TracesExplorer/ListView/configs';
 import { useGetAllViews } from 'hooks/saveViews/useGetAllViews';
 import { DataSource } from 'types/common/queryBuilder';

@@ -69,7 +69,7 @@ export function usePreferenceSync({
 			};
 		}
 		if (dataSource === DataSource.TRACES) {
-			columns = parsedExtraData?.selectColumns || defaultTracesSelectedColumns;
+			columns = parsedExtraData?.selectColumns || defaultTraceSelectedColumns;
 		}
 		setSavedViewPreferences({ columns, formatting });
 	}, [viewsData, dataSource, savedViewId, mode]);
--- a/pkg/apiserver/signozapiserver/tracedetail.go
+++ b/pkg/apiserver/signozapiserver/tracedetail.go
@@ -10,25 +10,6 @@ import (
 )

 func (provider *provider) addTraceDetailRoutes(router *mux.Router) error {
-	if err := router.Handle("/api/v3/traces/{traceID}/waterfall", handler.New(
-		provider.authzMiddleware.ViewAccess(provider.traceDetailHandler.GetWaterfall),
-		handler.OpenAPIDef{
-			ID:                  "GetWaterfall",
-			Tags:                []string{"tracedetail"},
-			Summary:             "Get waterfall view for a trace",
-			Description:         "Returns the waterfall view of spans for a given trace ID with tree structure, metadata, and windowed pagination",
-			Request:             new(spantypes.PostableWaterfall),
-			RequestContentType:  "application/json",
-			Response:            new(spantypes.GettableWaterfallTrace),
-			ResponseContentType: "application/json",
-			SuccessStatusCode:   http.StatusOK,
-			ErrorStatusCodes:    []int{http.StatusBadRequest, http.StatusNotFound},
-			SecuritySchemes:     newSecuritySchemes(types.RoleViewer),
-		},
-	)).Methods(http.MethodPost).GetError(); err != nil {
-		return err
-	}
-
 	if err := router.Handle("/api/v4/traces/{traceID}/waterfall", handler.New(
 		provider.authzMiddleware.ViewAccess(provider.traceDetailHandler.GetWaterfallV4),
 		handler.OpenAPIDef{
--- a/pkg/modules/cloudintegration/config.go
+++ b/pkg/modules/cloudintegration/config.go
@@ -22,7 +22,7 @@ func newConfig() factory.Config {
 		Agent: AgentConfig{
 			// we will maintain the latest version of cloud integration agent from here,
 			// till we automate it externally or figure out a way to validate it.
-			Version: "v0.0.10",
+			Version: "v0.0.11",
 		},
 	}
 }
--- a/pkg/modules/tracedetail/impltracedetail/handler.go
+++ b/pkg/modules/tracedetail/impltracedetail/handler.go
@@ -18,27 +18,6 @@ func NewHandler(module tracedetail.Module) tracedetail.Handler {
 	return &handler{module: module}
 }

-func (h *handler) GetWaterfall(rw http.ResponseWriter, r *http.Request) {
-	req := new(spantypes.PostableWaterfall)
-	if err := binding.JSON.BindBody(r.Body, req); err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	if err := req.Validate(); err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	result, err := h.module.GetWaterfall(r.Context(), mux.Vars(r)["traceID"], req)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	render.Success(rw, http.StatusOK, result)
-}
-
 func (h *handler) GetWaterfallV4(rw http.ResponseWriter, r *http.Request) {
 	req := new(spantypes.PostableWaterfall)
 	if err := binding.JSON.BindBody(r.Body, req); err != nil {
@@ -51,7 +30,7 @@ func (h *handler) GetWaterfallV4(rw http.ResponseWriter, r *http.Request) {
 		return
 	}

-	result, err := h.module.GetWaterfallV4(r.Context(), mux.Vars(r)["traceID"], req.SelectedSpanID, req.UncollapsedSpans, req.Limit)
+	result, err := h.module.GetWaterfallV4(r.Context(), mux.Vars(r)["traceID"], req.SelectedSpanID, req.UncollapsedSpans)
 	if err != nil {
 		render.Error(rw, err)
 		return
--- a/pkg/modules/tracedetail/impltracedetail/module.go
+++ b/pkg/modules/tracedetail/impltracedetail/module.go
@@ -39,62 +39,16 @@ func NewModule(traceStore spantypes.TraceStore, providerSettings factory.Provide
 	return m
 }

-func (m *module) GetWaterfall(ctx context.Context, traceID string, req *spantypes.PostableWaterfall) (*spantypes.GettableWaterfallTrace, error) {
-	waterfallTrace, err := m.getTraceData(ctx, traceID)
-	if err != nil {
-		return nil, err
-	}
-
-	selectedSpans, uncollapsedSpans, selectedAllSpans := waterfallTrace.GetWaterfallSpans(
-		req.UncollapsedSpans,
-		req.SelectedSpanID,
-		min(req.Limit, m.config.Waterfall.MaxLimitToSelectAllSpans),
-		m.config.Waterfall.SpanPageSize,
-		m.config.Waterfall.MaxDepthToAutoExpand,
-	)
-
-	aggregationResults := make([]spantypes.SpanAggregationResult, 0, len(req.Aggregations))
-	for _, a := range req.Aggregations {
-		aggregationResults = append(aggregationResults, waterfallTrace.GetSpanAggregation(a.Aggregation, a.Field))
-	}
-
-	return spantypes.NewGettableWaterfallTrace(waterfallTrace, selectedSpans, uncollapsedSpans, selectedAllSpans, aggregationResults), nil
-}
-
-// getTraceData fetches all spans for a trace and builds the WaterfallTrace.
-func (m *module) getTraceData(ctx context.Context, traceID string) (*spantypes.WaterfallTrace, error) {
-	summary, err := m.store.GetTraceSummary(ctx, traceID)
-	if err != nil {
-		return nil, err
-	}
-
-	spanItems, err := m.store.GetTraceSpans(ctx, traceID, summary)
-	if err != nil {
-		return nil, err
-	}
-
-	if len(spanItems) == 0 {
-		return nil, spantypes.ErrTraceNotFound
-	}
-
-	nodes := make([]*spantypes.WaterfallSpan, len(spanItems))
-	for i := range spanItems {
-		nodes[i] = spanItems[i].ToWaterfallSpan(traceID)
-	}
-	return spantypes.NewWaterfallTraceFromSpans(nodes), nil
-}
-
 // GetWaterfallV4 is the OOM-safe V4 waterfall.
 // For large traces (NumSpans > effectiveLimit) it uses a two-step fetch:
 // minimal fields for all spans to build the tree, then full fields for the
 // visible window only. Aggregations are not returned.
-func (m *module) GetWaterfallV4(ctx context.Context, traceID string, selectedSpanID string, uncollapsedSpans []string, selectAllLimit uint) (*spantypes.GettableWaterfallTrace, error) {
+func (m *module) GetWaterfallV4(ctx context.Context, traceID string, selectedSpanID string, uncollapsedSpans []string) (*spantypes.GettableWaterfallTrace, error) {
 	summary, err := m.store.GetTraceSummary(ctx, traceID)
 	if err != nil {
 		return nil, err
 	}
-	effectiveLimit := min(selectAllLimit, m.config.Waterfall.MaxLimitToSelectAllSpans)
-	if summary.NumSpans > uint64(effectiveLimit) {
+	if summary.NumSpans > uint64(m.config.Waterfall.MaxLimitToSelectAllSpans) {
 		attrs := metric.WithAttributes(attrResponseType.String(attrResponseTypeWindowed))
 		m.metrics.waterfallRequestCount.Add(ctx, 1, attrs)
 		m.metrics.waterfallSpanCount.Add(ctx, int64(summary.NumSpans), attrs)
@@ -120,7 +74,7 @@ func (m *module) getFullWaterfall(ctx context.Context, traceID string, summary *
 	waterfallTrace := spantypes.NewWaterfallTraceFromSpans(nodes)
 	selectedSpans := waterfallTrace.GetAllSpans()

-	return spantypes.NewGettableWaterfallTrace(waterfallTrace, selectedSpans, nil, true, nil), nil
+	return spantypes.NewGettableWaterfallTrace(waterfallTrace, selectedSpans, nil, true), nil
 }

 func (m *module) GetTraceAggregations(ctx context.Context, traceID string, req *spantypes.PostableTraceAggregations) (*spantypes.GettableTraceAggregations, error) {
@@ -215,7 +169,7 @@ func (m *module) getWindowedWaterfall(ctx context.Context, traceID, selectedSpan
 	spantypes.EnrichSelectedSpans(selectedSpans, fullSpans)

 	return spantypes.NewGettableWaterfallTrace(
-		waterfallTrace, selectedSpans, uncollapsedSpans, false, nil,
+		waterfallTrace, selectedSpans, uncollapsedSpans, false,
 	), nil
 }

--- a/pkg/modules/tracedetail/impltracedetail/waterfall_test.go
+++ b/pkg/modules/tracedetail/impltracedetail/waterfall_test.go
@@ -260,7 +260,7 @@ func TestGetSelectedSpans_MultipleRoots(t *testing.T) {
 	trace := getWaterfallTrace([]*spantypes.WaterfallSpan{root1, root2}, spanMap)
 	spans, _ := trace.GetSelectedSpans([]string{"root1", "root2"}, "root1", 500, 5)

-	traceRespnose := spantypes.NewGettableWaterfallTrace(trace, spans, nil, false, nil)
+	traceRespnose := spantypes.NewGettableWaterfallTrace(trace, spans, nil, false)

 	assert.Equal(t, []string{"root1", "child1", "root2", "child2"}, spanIDs(spans), "root1 subtree must precede root2 subtree")
 	assert.Equal(t, "svc-a", traceRespnose.RootServiceName, "metadata comes from first root")
@@ -567,7 +567,7 @@ func TestGetAllSpans(t *testing.T) {
 	)
 	trace := getWaterfallTrace([]*spantypes.WaterfallSpan{root}, nil)
 	spans := trace.GetAllSpans()
-	traceResponse := spantypes.NewGettableWaterfallTrace(trace, spans, nil, true, nil)
+	traceResponse := spantypes.NewGettableWaterfallTrace(trace, spans, nil, true)
 	assert.ElementsMatch(t, spanIDs(spans), []string{"root", "childA", "grandchildA", "leafA", "childB", "grandchildB", "leafB"})
 	assert.Equal(t, "svc", traceResponse.RootServiceName)
 	assert.Equal(t, "root-op", traceResponse.RootServiceEntryPoint)
--- a/pkg/modules/tracedetail/tracedetail.go
+++ b/pkg/modules/tracedetail/tracedetail.go
@@ -10,7 +10,6 @@ import (

 // Handler exposes HTTP handlers for trace detail APIs.
 type Handler interface {
-	GetWaterfall(http.ResponseWriter, *http.Request)
 	GetWaterfallV4(http.ResponseWriter, *http.Request)
 	GetTraceAggregations(http.ResponseWriter, *http.Request)
 	GetFlamegraph(http.ResponseWriter, *http.Request)
@@ -18,8 +17,7 @@ type Handler interface {

 // Module defines the business logic for trace detail operations.
 type Module interface {
-	GetWaterfall(ctx context.Context, traceID string, req *spantypes.PostableWaterfall) (*spantypes.GettableWaterfallTrace, error)
-	GetWaterfallV4(ctx context.Context, traceID string, selectedSpanID string, uncollapsedSpans []string, selectAllLimit uint) (*spantypes.GettableWaterfallTrace, error)
+	GetWaterfallV4(ctx context.Context, traceID string, selectedSpanID string, uncollapsedSpans []string) (*spantypes.GettableWaterfallTrace, error)
 	GetTraceAggregations(ctx context.Context, traceID string, req *spantypes.PostableTraceAggregations) (*spantypes.GettableTraceAggregations, error)
 	GetFlamegraph(ctx context.Context, traceID string, selectedSpanID string, selectFields []telemetrytypes.TelemetryFieldKey) (*spantypes.GettableFlamegraphTrace, error)
 }
--- a/pkg/query-service/app/clickhouseReader/reader.go
+++ b/pkg/query-service/app/clickhouseReader/reader.go
@@ -898,223 +898,6 @@ func (r *ClickHouseReader) GetSpansForTrace(ctx context.Context, traceID string,
 	return searchScanResponses, nil
 }

-func (r *ClickHouseReader) GetWaterfallSpansForTraceWithMetadataCache(ctx context.Context, orgID valuer.UUID, traceID string) (*model.GetWaterfallSpansForTraceWithMetadataCache, error) {
-	cachedTraceData := new(model.GetWaterfallSpansForTraceWithMetadataCache)
-	err := r.cacheForTraceDetail.Get(ctx, orgID, strings.Join([]string{"getWaterfallSpansForTraceWithMetadata", traceID}, "-"), cachedTraceData)
-	if err != nil {
-		r.logger.Debug("error in retrieving getWaterfallSpansForTraceWithMetadata cache", errorsV2.Attr(err), "traceID", traceID)
-		return nil, err
-	}
-
-	if time.Since(time.UnixMilli(int64(cachedTraceData.EndTime))) < r.fluxIntervalForTraceDetail {
-		r.logger.Info("the trace end time falls under the flux interval, skipping getWaterfallSpansForTraceWithMetadata cache", "traceID", traceID)
-		return nil, errors.Errorf("the trace end time falls under the flux interval, skipping getWaterfallSpansForTraceWithMetadata cache, traceID: %s", traceID)
-	}
-
-	r.logger.Info("cache is successfully hit, applying cache for getWaterfallSpansForTraceWithMetadata", "traceID", traceID)
-	return cachedTraceData, nil
-}
-
-func (r *ClickHouseReader) GetWaterfallSpansForTraceWithMetadata(ctx context.Context, orgID valuer.UUID, traceID string, req *model.GetWaterfallSpansForTraceWithMetadataParams) (*model.GetWaterfallSpansForTraceWithMetadataResponse, error) {
-	response := new(model.GetWaterfallSpansForTraceWithMetadataResponse)
-	var startTime, endTime, durationNano, totalErrorSpans, totalSpans uint64
-	var spanIdToSpanNodeMap = map[string]*model.Span{}
-	var traceRoots []*model.Span
-	var serviceNameToTotalDurationMap = map[string]uint64{}
-	var serviceNameIntervalMap = map[string][]tracedetail.Interval{}
-	var hasMissingSpans bool
-
-	cachedTraceData, err := r.GetWaterfallSpansForTraceWithMetadataCache(ctx, orgID, traceID)
-	if err == nil {
-		startTime = cachedTraceData.StartTime
-		endTime = cachedTraceData.EndTime
-		durationNano = cachedTraceData.DurationNano
-		spanIdToSpanNodeMap = cachedTraceData.SpanIdToSpanNodeMap
-		serviceNameToTotalDurationMap = cachedTraceData.ServiceNameToTotalDurationMap
-		traceRoots = cachedTraceData.TraceRoots
-		totalSpans = cachedTraceData.TotalSpans
-		totalErrorSpans = cachedTraceData.TotalErrorSpans
-		hasMissingSpans = cachedTraceData.HasMissingSpans
-	}
-
-	if err != nil {
-		r.logger.Info("cache miss for getWaterfallSpansForTraceWithMetadata", "traceID", traceID)
-
-		searchScanResponses, err := r.GetSpansForTrace(ctx, traceID, fmt.Sprintf("SELECT DISTINCT ON (span_id) timestamp, duration_nano, span_id, trace_id, has_error, kind, resource_string_service$$name, name, links as references, attributes_string, attributes_number, attributes_bool, resources_string, events, status_message, status_code_string, kind_string FROM %s.%s WHERE trace_id=$1 and ts_bucket_start>=$2 and ts_bucket_start<=$3 ORDER BY timestamp ASC, name ASC", r.TraceDB, r.traceTableName))
-		if err != nil {
-			return nil, err
-		}
-		if len(searchScanResponses) == 0 {
-			return response, nil
-		}
-		totalSpans = uint64(len(searchScanResponses))
-		for _, item := range searchScanResponses {
-			ref := []model.OtelSpanRef{}
-			err := json.Unmarshal([]byte(item.References), &ref)
-			if err != nil {
-				r.logger.Error("getWaterfallSpansForTraceWithMetadata: error unmarshalling references", errorsV2.Attr(err), "traceID", traceID)
-				return nil, errorsV2.Newf(errorsV2.TypeInvalidInput, errorsV2.CodeInvalidInput, "getWaterfallSpansForTraceWithMetadata: error unmarshalling references %s", err.Error())
-			}
-
-			// merge attributes_number and attributes_bool to attributes_string
-			for k, v := range item.Attributes_bool {
-				item.Attributes_string[k] = fmt.Sprintf("%v", v)
-			}
-			for k, v := range item.Attributes_number {
-				item.Attributes_string[k] = strconv.FormatFloat(v, 'f', -1, 64)
-			}
-			for k, v := range item.Resources_string {
-				item.Attributes_string[k] = v
-			}
-
-			events := make([]model.Event, 0)
-			for _, event := range item.Events {
-				var eventMap model.Event
-				err = json.Unmarshal([]byte(event), &eventMap)
-				if err != nil {
-					r.logger.Error("Error unmarshalling events", errorsV2.Attr(err))
-					return nil, errorsV2.Newf(errorsV2.TypeInternal, errorsV2.CodeInternal, "getWaterfallSpansForTraceWithMetadata: error in unmarshalling events %s", err.Error())
-				}
-				events = append(events, eventMap)
-			}
-
-			startTimeUnixNano := uint64(item.TimeUnixNano.UnixNano())
-
-			jsonItem := model.Span{
-				SpanID:           item.SpanID,
-				TraceID:          item.TraceID,
-				ServiceName:      item.ServiceName,
-				Name:             item.Name,
-				Kind:             int32(item.Kind),
-				DurationNano:     item.DurationNano,
-				HasError:         item.HasError,
-				StatusMessage:    item.StatusMessage,
-				StatusCodeString: item.StatusCodeString,
-				SpanKind:         item.SpanKind,
-				References:       ref,
-				Events:           events,
-				TagMap:           item.Attributes_string,
-				Children:         make([]*model.Span, 0),
-				TimeUnixNano:     startTimeUnixNano, // Store nanoseconds temporarily
-			}
-
-			// metadata calculation
-			if startTime == 0 || startTimeUnixNano < startTime {
-				startTime = startTimeUnixNano
-			}
-			if endTime == 0 || (startTimeUnixNano+jsonItem.DurationNano) > endTime {
-				endTime = (startTimeUnixNano + jsonItem.DurationNano)
-			}
-			if durationNano == 0 || jsonItem.DurationNano > durationNano {
-				durationNano = jsonItem.DurationNano
-			}
-
-			if jsonItem.HasError {
-				totalErrorSpans = totalErrorSpans + 1
-			}
-
-			// collect the intervals for service for execution time calculation
-			serviceNameIntervalMap[jsonItem.ServiceName] =
-				append(serviceNameIntervalMap[jsonItem.ServiceName], tracedetail.Interval{StartTime: jsonItem.TimeUnixNano, Duration: jsonItem.DurationNano, Service: jsonItem.ServiceName})
-
-			// append to the span node map
-			spanIdToSpanNodeMap[jsonItem.SpanID] = &jsonItem
-		}
-
-		// traverse through the map and append each node to the children array of the parent node
-		// and add the missing spans
-		for _, spanNode := range spanIdToSpanNodeMap {
-			hasParentSpanNode := false
-			for _, reference := range spanNode.References {
-				if reference.RefType == "CHILD_OF" && reference.SpanId != "" {
-					hasParentSpanNode = true
-
-					if parentNode, exists := spanIdToSpanNodeMap[reference.SpanId]; exists {
-						parentNode.Children = append(parentNode.Children, spanNode)
-					} else {
-						// insert the missing span
-						missingSpan := model.Span{
-							SpanID:           reference.SpanId,
-							TraceID:          spanNode.TraceID,
-							ServiceName:      "",
-							Name:             "Missing Span",
-							TimeUnixNano:     spanNode.TimeUnixNano,
-							Kind:             0,
-							DurationNano:     spanNode.DurationNano,
-							HasError:         false,
-							StatusMessage:    "",
-							StatusCodeString: "",
-							SpanKind:         "",
-							Events:           make([]model.Event, 0),
-							Children:         make([]*model.Span, 0),
-						}
-						missingSpan.Children = append(missingSpan.Children, spanNode)
-						spanIdToSpanNodeMap[missingSpan.SpanID] = &missingSpan
-						traceRoots = append(traceRoots, &missingSpan)
-						hasMissingSpans = true
-					}
-				}
-			}
-			if !hasParentSpanNode && !tracedetail.ContainsWaterfallSpan(traceRoots, spanNode) {
-				traceRoots = append(traceRoots, spanNode)
-			}
-		}
-
-		// sort the trace roots to add missing spans at the right order
-		sort.Slice(traceRoots, func(i, j int) bool {
-			if traceRoots[i].TimeUnixNano == traceRoots[j].TimeUnixNano {
-				return traceRoots[i].Name < traceRoots[j].Name
-			}
-			return traceRoots[i].TimeUnixNano < traceRoots[j].TimeUnixNano
-		})
-
-		serviceNameToTotalDurationMap = tracedetail.CalculateServiceTime(serviceNameIntervalMap)
-
-		// TODO: set the span data (model.GetWaterfallSpansForTraceWithMetadataCache) in cache here
-		// removed existing cache usage since it was not getting used due to this bug https://github.com/SigNoz/engineering-pod/issues/4648
-		// and was causing out of memory issues https://github.com/SigNoz/engineering-pod/issues/4638
-	}
-
-	processingPostCache := time.Now()
-	// When req.Limit is 0 (not set by the client),  selectAllSpans is set to false
-	// preserving the old paged behaviour for backward compatibility
-	limit := min(req.Limit, tracedetail.MaxLimitToSelectAllSpans)
-	selectAllSpans := totalSpans <= uint64(limit)
-
-	var (
-		selectedSpans                          []*model.Span
-		uncollapsedSpans                       []string
-		rootServiceName, rootServiceEntryPoint string
-	)
-	if selectAllSpans {
-		selectedSpans, rootServiceName, rootServiceEntryPoint = tracedetail.GetAllSpans(traceRoots)
-	} else {
-		selectedSpans, uncollapsedSpans, rootServiceName, rootServiceEntryPoint = tracedetail.GetSelectedSpans(req.UncollapsedSpans, req.SelectedSpanID, traceRoots, spanIdToSpanNodeMap, req.IsSelectedSpanIDUnCollapsed)
-	}
-	r.logger.Info("getWaterfallSpansForTraceWithMetadata: processing post cache", "duration", time.Since(processingPostCache), "traceID", traceID)
-
-	// convert start timestamp to millis because right now frontend is expecting it in millis
-	for _, span := range selectedSpans {
-		span.TimeUnixNano = span.TimeUnixNano / 1000000
-	}
-
-	for serviceName, totalDuration := range serviceNameToTotalDurationMap {
-		serviceNameToTotalDurationMap[serviceName] = totalDuration / 1000000
-	}
-
-	response.Spans = selectedSpans
-	response.UncollapsedSpans = uncollapsedSpans // ignoring if all spans are returning
-	response.StartTimestampMillis = startTime / 1000000
-	response.EndTimestampMillis = endTime / 1000000
-	response.TotalSpansCount = totalSpans
-	response.TotalErrorSpansCount = totalErrorSpans
-	response.RootServiceName = rootServiceName
-	response.RootServiceEntryPoint = rootServiceEntryPoint
-	response.ServiceNameToTotalDurationMap = serviceNameToTotalDurationMap
-	response.HasMissingSpans = hasMissingSpans
-	response.HasMore = !selectAllSpans
-	return response, nil
-}

 func (r *ClickHouseReader) GetFlamegraphSpansForTraceCache(ctx context.Context, orgID valuer.UUID, traceID string) (*model.GetFlamegraphSpansForTraceCache, error) {
 	cachedTraceData := new(model.GetFlamegraphSpansForTraceCache)
--- a/pkg/query-service/app/http_handler.go
+++ b/pkg/query-service/app/http_handler.go
@@ -535,7 +535,7 @@ func (aH *APIHandler) RegisterRoutes(router *mux.Router, am *middleware.AuthZ) {
 	router.HandleFunc("/api/v2/traces/fields", am.ViewAccess(aH.traceFields)).Methods(http.MethodGet)
 	router.HandleFunc("/api/v2/traces/fields", am.EditAccess(aH.updateTraceField)).Methods(http.MethodPost)
 	router.HandleFunc("/api/v2/traces/flamegraph/{traceId}", am.ViewAccess(aH.GetFlamegraphSpansForTrace)).Methods(http.MethodPost)
-	router.HandleFunc("/api/v2/traces/waterfall/{traceId}", am.ViewAccess(aH.GetWaterfallSpansForTraceWithMetadata)).Methods(http.MethodPost)
+

 	router.HandleFunc("/api/v1/version", am.OpenAccess(aH.getVersion)).Methods(http.MethodGet)
 	router.HandleFunc("/api/v1/features", am.ViewAccess(aH.getFeatureFlags)).Methods(http.MethodGet)
@@ -1446,39 +1446,6 @@ func (aH *APIHandler) SearchTraces(w http.ResponseWriter, r *http.Request) {

 }

-func (aH *APIHandler) GetWaterfallSpansForTraceWithMetadata(w http.ResponseWriter, r *http.Request) {
-	claims, err := authtypes.ClaimsFromContext(r.Context())
-	if err != nil {
-		render.Error(w, err)
-		return
-	}
-	orgID, err := valuer.NewUUID(claims.OrgID)
-	if err != nil {
-		render.Error(w, err)
-		return
-	}
-	traceID := mux.Vars(r)["traceId"]
-	if traceID == "" {
-		render.Error(w, errors.NewInvalidInputf(errors.CodeInvalidInput, "traceID is required"))
-		return
-	}
-
-	req := new(model.GetWaterfallSpansForTraceWithMetadataParams)
-	err = json.NewDecoder(r.Body).Decode(&req)
-	if err != nil {
-		RespondError(w, model.BadRequest(err), nil)
-		return
-	}
-
-	result, apiErr := aH.reader.GetWaterfallSpansForTraceWithMetadata(r.Context(), orgID, traceID, req)
-	if apiErr != nil {
-		render.Error(w, apiErr)
-		return
-	}
-
-	aH.WriteJSON(w, r, result)
-}
-
 func (aH *APIHandler) GetFlamegraphSpansForTrace(w http.ResponseWriter, r *http.Request) {
 	claims, err := authtypes.ClaimsFromContext(r.Context())
 	if err != nil {
--- a/pkg/query-service/app/traces/tracedetail/waterfall.go
+++ b/pkg/query-service/app/traces/tracedetail/waterfall.go
@@ -1,287 +0,0 @@
-package tracedetail
-
-import (
-	"maps"
-	"slices"
-	"sort"
-
-	"github.com/SigNoz/signoz/pkg/query-service/model"
-)
-
-var (
-	SPAN_LIMIT_PER_REQUEST_FOR_WATERFALL float64 = 500
-
-	maxDepthForSelectedSpanChildren int  = 5
-	MaxLimitToSelectAllSpans        uint = 10_000
-)
-
-type Interval struct {
-	StartTime uint64
-	Duration  uint64
-	Service   string
-}
-
-func mergeIntervals(intervals []Interval) []Interval {
-	if len(intervals) == 0 {
-		return nil
-	}
-
-	var merged []Interval
-	current := intervals[0]
-
-	for i := 1; i < len(intervals); i++ {
-		next := intervals[i]
-		if current.StartTime+current.Duration >= next.StartTime {
-			endTime := max(current.StartTime+current.Duration, next.StartTime+next.Duration)
-			current.Duration = endTime - current.StartTime
-		} else {
-			merged = append(merged, current)
-			current = next
-		}
-	}
-	// Add the last interval
-	merged = append(merged, current)
-
-	return merged
-}
-
-func ContainsWaterfallSpan(slice []*model.Span, item *model.Span) bool {
-	for _, v := range slice {
-		if v.SpanID == item.SpanID {
-			return true
-		}
-	}
-	return false
-}
-
-func findIndexForSelectedSpanFromPreOrder(spans []*model.Span, selectedSpanId string) int {
-	var selectedSpanIndex = -1
-
-	for index, span := range spans {
-		if span.SpanID == selectedSpanId {
-			selectedSpanIndex = index
-			break
-		}
-	}
-
-	return selectedSpanIndex
-}
-
-func getPathFromRootToSelectedSpanId(node *model.Span, selectedSpanId string) (bool, []string) {
-	spansFromRootToNode := []string{}
-
-	spansFromRootToNode = append(spansFromRootToNode, node.SpanID)
-	if node.SpanID == selectedSpanId {
-		return true, spansFromRootToNode
-	}
-
-	isPresentInSubtreeForTheNode := false
-	for _, child := range node.Children {
-		isPresentInThisSubtree, _spansFromRootToNode := getPathFromRootToSelectedSpanId(child, selectedSpanId)
-		// if the interested node is present in the given subtree then add the span node to uncollapsed node list
-		if isPresentInThisSubtree {
-			isPresentInSubtreeForTheNode = true
-			spansFromRootToNode = append(spansFromRootToNode, _spansFromRootToNode...)
-			break
-		}
-	}
-	return isPresentInSubtreeForTheNode, spansFromRootToNode
-}
-
-// traverseOpts holds the traversal configuration that remains constant
-// throughout the recursion. Per-call state (level, isPartOfPreOrder, etc.)
-// is passed as direct arguments.
-type traverseOpts struct {
-	uncollapsedSpans          map[string]struct{}
-	selectedSpanID            string
-	isSelectedSpanUncollapsed bool
-	selectAll                 bool
-}
-
-func traverseTrace(
-	span *model.Span,
-	opts traverseOpts,
-	level uint64,
-	isPartOfPreOrder bool,
-	hasSibling bool,
-	autoExpandDepth int,
-) ([]*model.Span, []string) {
-
-	preOrderTraversal := []*model.Span{}
-	autoExpandedSpans := []string{}
-
-	// sort the children to maintain the order across requests
-	sort.Slice(span.Children, func(i, j int) bool {
-		if span.Children[i].TimeUnixNano == span.Children[j].TimeUnixNano {
-			return span.Children[i].Name < span.Children[j].Name
-		}
-		return span.Children[i].TimeUnixNano < span.Children[j].TimeUnixNano
-	})
-
-	span.SubTreeNodeCount = 0
-	nodeWithoutChildren := model.Span{
-		SpanID:           span.SpanID,
-		TraceID:          span.TraceID,
-		ServiceName:      span.ServiceName,
-		TimeUnixNano:     span.TimeUnixNano,
-		Name:             span.Name,
-		Kind:             int32(span.Kind),
-		DurationNano:     span.DurationNano,
-		HasError:         span.HasError,
-		StatusMessage:    span.StatusMessage,
-		StatusCodeString: span.StatusCodeString,
-		SpanKind:         span.SpanKind,
-		References:       span.References,
-		Events:           span.Events,
-		TagMap:           span.TagMap,
-		Children:         make([]*model.Span, 0),
-		HasChildren:      len(span.Children) > 0,
-		Level:            level,
-		HasSiblings:      hasSibling,
-		SubTreeNodeCount: 0,
-	}
-
-	if isPartOfPreOrder {
-		preOrderTraversal = append(preOrderTraversal, &nodeWithoutChildren)
-	}
-
-	remainingAutoExpandDepth := 0
-	if span.SpanID == opts.selectedSpanID && opts.isSelectedSpanUncollapsed {
-		remainingAutoExpandDepth = maxDepthForSelectedSpanChildren
-	} else if autoExpandDepth > 0 {
-		remainingAutoExpandDepth = autoExpandDepth - 1
-	}
-
-	_, isAlreadyUncollapsed := opts.uncollapsedSpans[span.SpanID]
-	for index, child := range span.Children {
-		// A child is included in the pre-order output if its parent is uncollapsed
-		// OR if the child falls within MAX_DEPTH_FOR_SELECTED_SPAN_CHILDREN levels
-		// below the selected span.
-		isChildWithinMaxDepth := remainingAutoExpandDepth > 0
-		childIsPartOfPreOrder := opts.selectAll || (isPartOfPreOrder && (isAlreadyUncollapsed || isChildWithinMaxDepth))
-
-		if isPartOfPreOrder && isChildWithinMaxDepth && !isAlreadyUncollapsed {
-			if !slices.Contains(autoExpandedSpans, span.SpanID) {
-				autoExpandedSpans = append(autoExpandedSpans, span.SpanID)
-			}
-		}
-
-		_childTraversal, _autoExpanded := traverseTrace(child, opts, level+1, childIsPartOfPreOrder, index != (len(span.Children)-1), remainingAutoExpandDepth)
-		preOrderTraversal = append(preOrderTraversal, _childTraversal...)
-		autoExpandedSpans = append(autoExpandedSpans, _autoExpanded...)
-		nodeWithoutChildren.SubTreeNodeCount += child.SubTreeNodeCount + 1
-		span.SubTreeNodeCount += child.SubTreeNodeCount + 1
-	}
-
-	nodeWithoutChildren.SubTreeNodeCount += 1
-	return preOrderTraversal, autoExpandedSpans
-
-}
-
-func CalculateServiceTime(serviceIntervals map[string][]Interval) map[string]uint64 {
-	totalTimes := make(map[string]uint64)
-
-	for service, serviceIntervals := range serviceIntervals {
-		sort.Slice(serviceIntervals, func(i, j int) bool {
-			return serviceIntervals[i].StartTime < serviceIntervals[j].StartTime
-		})
-		mergedIntervals := mergeIntervals(serviceIntervals)
-		totalTime := uint64(0)
-		for _, interval := range mergedIntervals {
-			totalTime += interval.Duration
-		}
-		totalTimes[service] = totalTime
-	}
-
-	return totalTimes
-}
-
-func GetSelectedSpans(uncollapsedSpans []string, selectedSpanID string, traceRoots []*model.Span, spanIdToSpanNodeMap map[string]*model.Span, isSelectedSpanIDUnCollapsed bool) ([]*model.Span, []string, string, string) {
-
-	var preOrderTraversal = make([]*model.Span, 0)
-	var rootServiceName, rootServiceEntryPoint string
-
-	// create a map of uncollapsed spans for quick lookup
-	uncollapsedSpanMap := make(map[string]struct{})
-	for _, spanID := range uncollapsedSpans {
-		uncollapsedSpanMap[spanID] = struct{}{}
-	}
-
-	selectedSpanIndex := -1
-	for _, rootSpanID := range traceRoots {
-		if rootNode, exists := spanIdToSpanNodeMap[rootSpanID.SpanID]; exists {
-			present, spansFromRootToNode := getPathFromRootToSelectedSpanId(rootNode, selectedSpanID)
-			if present {
-				for _, spanID := range spansFromRootToNode {
-					if selectedSpanID == spanID && !isSelectedSpanIDUnCollapsed {
-						continue
-					}
-					uncollapsedSpanMap[spanID] = struct{}{}
-				}
-			}
-
-			opts := traverseOpts{
-				uncollapsedSpans:          uncollapsedSpanMap,
-				selectedSpanID:            selectedSpanID,
-				isSelectedSpanUncollapsed: isSelectedSpanIDUnCollapsed,
-			}
-			_preOrderTraversal, _autoExpanded := traverseTrace(rootNode, opts, 0, true, false, 0)
-			// Merge auto-expanded spans into updatedUncollapsedSpans for returning in response
-			for _, spanID := range _autoExpanded {
-				uncollapsedSpanMap[spanID] = struct{}{}
-			}
-			_selectedSpanIndex := findIndexForSelectedSpanFromPreOrder(_preOrderTraversal, selectedSpanID)
-
-			if _selectedSpanIndex != -1 {
-				selectedSpanIndex = _selectedSpanIndex + len(preOrderTraversal)
-			}
-
-			preOrderTraversal = append(preOrderTraversal, _preOrderTraversal...)
-
-			if rootServiceName == "" {
-				rootServiceName = rootNode.ServiceName
-			}
-
-			if rootServiceEntryPoint == "" {
-				rootServiceEntryPoint = rootNode.Name
-			}
-		}
-	}
-
-	// if we couldn't find the selectedSpan in the trace then defaulting the selected index to 0
-	if selectedSpanIndex == -1 && selectedSpanID != "" {
-		selectedSpanIndex = 0
-	}
-
-	// get the 0.4*[span limit] before the interested span index
-	startIndex := selectedSpanIndex - int(SPAN_LIMIT_PER_REQUEST_FOR_WATERFALL*0.4)
-	// get the 0.6*[span limit] after the intrested span index
-	endIndex := selectedSpanIndex + int(SPAN_LIMIT_PER_REQUEST_FOR_WATERFALL*0.6)
-
-	// adjust the sliding window according to the available left and right spaces.
-	if startIndex < 0 {
-		endIndex = endIndex - startIndex
-		startIndex = 0
-	}
-	if endIndex > len(preOrderTraversal) {
-		startIndex = startIndex - (endIndex - len(preOrderTraversal))
-		endIndex = len(preOrderTraversal)
-	}
-	if startIndex < 0 {
-		startIndex = 0
-	}
-
-	return preOrderTraversal[startIndex:endIndex], slices.Collect(maps.Keys(uncollapsedSpanMap)), rootServiceName, rootServiceEntryPoint
-}
-
-func GetAllSpans(traceRoots []*model.Span) (spans []*model.Span, rootServiceName, rootEntryPoint string) {
-	if len(traceRoots) > 0 {
-		rootServiceName = traceRoots[0].ServiceName
-		rootEntryPoint = traceRoots[0].Name
-	}
-	for _, root := range traceRoots {
-		childSpans, _ := traverseTrace(root, traverseOpts{selectAll: true}, 0, true, false, 0)
-		spans = append(spans, childSpans...)
-	}
-	return
-}
--- a/pkg/query-service/app/traces/tracedetail/waterfall_test.go
+++ b/pkg/query-service/app/traces/tracedetail/waterfall_test.go
@@ -1,446 +0,0 @@
-// Package tracedetail tests — waterfall
-//
-// # Background
-//
-// The waterfall view renders a trace as a scrollable list of spans in
-// pre-order (parent before children, siblings left-to-right). Because a trace
-// can have thousands of spans, only a window of ~500 is returned per request.
-// The window is centred on the selected span.
-//
-// # Key concepts
-//
-// uncollapsedSpans
-//
-//	The set of span IDs the user has manually expanded in the UI.
-//	Only the direct children of an uncollapsed span are included in the
-//	output; grandchildren stay hidden until their parent is also uncollapsed.
-//	When multiple spans are uncollapsed their children are all visible at once.
-//
-// selectedSpanID
-//
-//	The span currently focused — set when the user clicks a span in the
-//	waterfall or selects one from the flamegraph.  The output window is always
-//	centred on this span.  The path from the trace root down to the selected
-//	span is automatically uncollapsed so ancestors are visible even if they are
-//	not in uncollapsedSpans.
-//
-// isSelectedSpanIDUnCollapsed
-//
-//	Controls whether the selected span's own children are shown:
-//	  true  — user expanded the span (click-to-open in waterfall or flamegraph);
-//	          direct children of the selected span are included.
-//	  false — user selected without expanding;
-//	          the span is visible but its children remain hidden.
-//
-// traceRoots
-//
-//	Root spans of the trace — spans with no parent in the current dataset.
-//	Normally one, but multiple roots are common when upstream services are
-//	not instrumented or their spans were not sampled/exported.
-
-package tracedetail
-
-import (
-	"fmt"
-	"testing"
-
-	"github.com/SigNoz/signoz/pkg/query-service/model"
-	"github.com/stretchr/testify/assert"
-)
-
-// Pre-order traversal is preserved: parent before children, siblings left-to-right.
-func TestGetSelectedSpans_PreOrderTraversal(t *testing.T) {
-	root := mkSpan("root", "svc",
-		mkSpan("child1", "svc", mkSpan("grandchild", "svc")),
-		mkSpan("child2", "svc"),
-	)
-	spanMap := buildSpanMap(root)
-	spans, _, _, _ := GetSelectedSpans([]string{"root", "child1"}, "root", []*model.Span{root}, spanMap, false)
-
-	assert.Equal(t, []string{"root", "child1", "grandchild", "child2"}, spanIDs(spans))
-}
-
-// Multiple roots: both trees are flattened into a single pre-order list with
-// root1's subtree before root2's. Service/entry-point come from the first root.
-//
-//	root1 svc-a          ← selected
-//	  └─ child1
-//	root2 svc-b
-//	  └─ child2
-//
-// Expected output order: root1 → child1 → root2 → child2
-func TestGetSelectedSpans_MultipleRoots(t *testing.T) {
-	root1 := mkSpan("root1", "svc-a", mkSpan("child1", "svc-a"))
-	root2 := mkSpan("root2", "svc-b", mkSpan("child2", "svc-b"))
-	spanMap := buildSpanMap(root1, root2)
-
-	spans, _, svcName, entryPoint := GetSelectedSpans([]string{"root1", "root2"}, "root1", []*model.Span{root1, root2}, spanMap, false)
-
-	assert.Equal(t, []string{"root1", "child1", "root2", "child2"}, spanIDs(spans), "root1 subtree must precede root2 subtree")
-	assert.Equal(t, "svc-a", svcName, "metadata comes from first root")
-	assert.Equal(t, "root1-op", entryPoint, "metadata comes from first root")
-}
-
-// Multiple spans uncollapsed simultaneously: children of all uncollapsed spans
-// are visible at once.
-//
-//	root
-//	  ├─ childA (uncollapsed) → grandchildA ✓
-//	  └─ childB (uncollapsed) → grandchildB ✓
-func TestGetSelectedSpans_MultipleUncollapsed(t *testing.T) {
-	root := mkSpan("root", "svc",
-		mkSpan("childA", "svc", mkSpan("grandchildA", "svc")),
-		mkSpan("childB", "svc", mkSpan("grandchildB", "svc")),
-	)
-	spanMap := buildSpanMap(root)
-	spans, _, _, _ := GetSelectedSpans([]string{"root", "childA", "childB"}, "root", []*model.Span{root}, spanMap, false)
-
-	assert.Equal(t, []string{"root", "childA", "grandchildA", "childB", "grandchildB"}, spanIDs(spans))
-}
-
-// Collapsing a span with other uncollapsed spans
-//
-// root
-// ├─ childA  (previously expanded — in uncollapsedSpans)
-// │    ├─ grandchild1 ✓
-// │    │    └─ greatGrandchild ✗  (grandchild1 not in uncollapsedSpans)
-// │    └─ grandchild2 ✓
-// └─ childB                        ← selected (not expanded)
-func TestGetSelectedSpans_ManualUncollapse(t *testing.T) {
-	root := mkSpan("root", "svc",
-		mkSpan("childA", "svc",
-			mkSpan("grandchild1", "svc", mkSpan("greatGrandchild", "svc")),
-			mkSpan("grandchild2", "svc"),
-		),
-		mkSpan("childB", "svc"),
-	)
-	spanMap := buildSpanMap(root)
-	// childA was expanded in a previous interaction; childB is now selected without expanding
-	spans, _, _, _ := GetSelectedSpans([]string{"childA"}, "childB", []*model.Span{root}, spanMap, false)
-
-	// path to childB auto-uncollpases root → childA and childB appear; childA is in
-	// uncollapsedSpans so its children appear; greatGrandchild stays hidden.
-	assert.Equal(t, []string{"root", "childA", "grandchild1", "grandchild2", "childB"}, spanIDs(spans))
-}
-
-// A collapsed span hides all children.
-func TestGetSelectedSpans_CollapsedSpan(t *testing.T) {
-	root := mkSpan("root", "svc",
-		mkSpan("child1", "svc"),
-		mkSpan("child2", "svc"),
-	)
-	spanMap := buildSpanMap(root)
-	spans, _, _, _ := GetSelectedSpans([]string{}, "root", []*model.Span{root}, spanMap, false)
-
-	assert.Equal(t, []string{"root"}, spanIDs(spans))
-}
-
-// Selecting a span auto-uncollpases the path from root to that span so it is visible.
-//
-//	root → parent → selected
-func TestGetSelectedSpans_PathToSelectedIsUncollapsed(t *testing.T) {
-	root := mkSpan("root", "svc",
-		mkSpan("parent", "svc",
-			mkSpan("selected", "svc"),
-		),
-	)
-	spanMap := buildSpanMap(root)
-	// no manually uncollapsed spans — path should still be opened
-	spans, _, _, _ := GetSelectedSpans([]string{}, "selected", []*model.Span{root}, spanMap, false)
-
-	assert.Equal(t, []string{"root", "parent", "selected"}, spanIDs(spans))
-}
-
-// The path-to-selected spans are returned in updatedUncollapsedSpans.
-func TestGetSelectedSpans_PathReturnedInUncollapsed(t *testing.T) {
-	root := mkSpan("root", "svc",
-		mkSpan("parent", "svc",
-			mkSpan("selected", "svc"),
-		),
-	)
-	spanMap := buildSpanMap(root)
-	spans, uncollapsed, _, _ := GetSelectedSpans([]string{}, "selected", []*model.Span{root}, spanMap, false)
-
-	assert.ElementsMatch(t, []string{"root", "parent"}, uncollapsed)
-	assert.Equal(t, []string{"root", "parent", "selected"}, spanIDs(spans))
-}
-
-// Siblings of ancestors are rendered as collapsed nodes but their subtrees
-// must NOT be expanded.
-//
-//	root
-//	  ├─ unrelated → unrelated-child (✗)
-//	  └─ parent → selected
-func TestGetSelectedSpans_SiblingsNotExpanded(t *testing.T) {
-	root := mkSpan("root", "svc",
-		mkSpan("unrelated", "svc", mkSpan("unrelated-child", "svc")),
-		mkSpan("parent", "svc",
-			mkSpan("selected", "svc"),
-		),
-	)
-	spanMap := buildSpanMap(root)
-	spans, uncollapsed, _, _ := GetSelectedSpans([]string{}, "selected", []*model.Span{root}, spanMap, false)
-
-	// children of root sort alphabetically: parent < unrelated; unrelated-child stays hidden
-	assert.Equal(t, []string{"root", "parent", "selected", "unrelated"}, spanIDs(spans))
-	// only the path nodes are tracked as uncollapsed — unrelated is not
-	assert.ElementsMatch(t, []string{"root", "parent"}, uncollapsed)
-}
-
-// An unknown selectedSpanID must not panic; returns a window from index 0.
-func TestGetSelectedSpans_UnknownSelectedSpan(t *testing.T) {
-	root := mkSpan("root", "svc", mkSpan("child", "svc"))
-	spanMap := buildSpanMap(root)
-	spans, _, _, _ := GetSelectedSpans([]string{}, "nonexistent", []*model.Span{root}, spanMap, false)
-	assert.Equal(t, []string{"root"}, spanIDs(spans))
-}
-
-// Test to check if Level, HasChildren, HasSiblings, and SubTreeNodeCount are populated correctly.
-//
-//	root          level=0, hasChildren=true,  hasSiblings=false, subTree=4
-//	  child1      level=1, hasChildren=true,  hasSiblings=true,  subTree=2
-//	    grandchild level=2, hasChildren=false, hasSiblings=false, subTree=1
-//	  child2      level=1, hasChildren=false, hasSiblings=false, subTree=1
-func TestGetSelectedSpans_SpanMetadata(t *testing.T) {
-	root := mkSpan("root", "svc",
-		mkSpan("child1", "svc", mkSpan("grandchild", "svc")),
-		mkSpan("child2", "svc"),
-	)
-	spanMap := buildSpanMap(root)
-	spans, _, _, _ := GetSelectedSpans([]string{"root", "child1"}, "root", []*model.Span{root}, spanMap, false)
-
-	byID := map[string]*model.Span{}
-	for _, s := range spans {
-		byID[s.SpanID] = s
-	}
-
-	assert.Equal(t, uint64(0), byID["root"].Level)
-	assert.Equal(t, uint64(1), byID["child1"].Level)
-	assert.Equal(t, uint64(1), byID["child2"].Level)
-	assert.Equal(t, uint64(2), byID["grandchild"].Level)
-
-	assert.True(t, byID["root"].HasChildren)
-	assert.True(t, byID["child1"].HasChildren)
-	assert.False(t, byID["child2"].HasChildren)
-	assert.False(t, byID["grandchild"].HasChildren)
-
-	assert.False(t, byID["root"].HasSiblings, "root has no siblings")
-	assert.True(t, byID["child1"].HasSiblings, "child1 has sibling child2")
-	assert.False(t, byID["child2"].HasSiblings, "child2 is the last child")
-	assert.False(t, byID["grandchild"].HasSiblings, "grandchild has no siblings")
-
-	assert.Equal(t, uint64(4), byID["root"].SubTreeNodeCount)
-	assert.Equal(t, uint64(2), byID["child1"].SubTreeNodeCount)
-	assert.Equal(t, uint64(1), byID["grandchild"].SubTreeNodeCount)
-	assert.Equal(t, uint64(1), byID["child2"].SubTreeNodeCount)
-}
-
-// If the selected span is already in uncollapsedSpans AND isSelectedSpanIDUnCollapsed=true,
-func TestGetSelectedSpans_DuplicateInUncollapsed(t *testing.T) {
-	root := mkSpan("root", "svc",
-		mkSpan("selected", "svc", mkSpan("child", "svc")),
-	)
-	spanMap := buildSpanMap(root)
-	_, uncollapsed, _, _ := GetSelectedSpans(
-		[]string{"selected"}, // already present
-		"selected",
-		[]*model.Span{root}, spanMap,
-		true,
-	)
-
-	count := 0
-	for _, id := range uncollapsed {
-		if id == "selected" {
-			count++
-		}
-	}
-	assert.Equal(t, 1, count, "should appear once")
-}
-
-// makeChain builds a linear trace: span0 → span1 → … → span(n-1).
-// All span IDs are "span0", "span1", … so the caller can reference them by index.
-func makeChain(n int) (*model.Span, map[string]*model.Span, []string) {
-	spans := make([]*model.Span, n)
-	for i := n - 1; i >= 0; i-- {
-		if i == n-1 {
-			spans[i] = mkSpan(fmt.Sprintf("span%d", i), "svc")
-		} else {
-			spans[i] = mkSpan(fmt.Sprintf("span%d", i), "svc", spans[i+1])
-		}
-	}
-	uncollapsed := make([]string, n)
-	for i := range spans {
-		uncollapsed[i] = fmt.Sprintf("span%d", i)
-	}
-	return spans[0], buildSpanMap(spans[0]), uncollapsed
-}
-
-// The selected span is centred: 200 spans before it, 300 after (0.4 / 0.6 split).
-func TestGetSelectedSpans_WindowCentredOnSelected(t *testing.T) {
-	root, spanMap, uncollapsed := makeChain(600)
-	spans, _, _, _ := GetSelectedSpans(uncollapsed, "span300", []*model.Span{root}, spanMap, false)
-
-	assert.Equal(t, 500, len(spans), "window should be 500 spans")
-	// window is [100, 600): span300 lands at position 200 (300 - 100)
-	assert.Equal(t, "span100", spans[0].SpanID, "window starts 200 before selected")
-	assert.Equal(t, "span300", spans[200].SpanID, "selected span at position 200 in window")
-	assert.Equal(t, "span599", spans[499].SpanID, "window ends 300 after selected")
-}
-
-// When the selected span is near the start, the window shifts right so no
-// negative index is used — the result is still 500 spans.
-func TestGetSelectedSpans_WindowShiftsAtStart(t *testing.T) {
-	root, spanMap, uncollapsed := makeChain(600)
-	spans, _, _, _ := GetSelectedSpans(uncollapsed, "span10", []*model.Span{root}, spanMap, false)
-
-	assert.Equal(t, 500, len(spans))
-	assert.Equal(t, "span0", spans[0].SpanID, "window clamped to start of trace")
-	assert.Equal(t, "span10", spans[10].SpanID, "selected span still in window")
-}
-
-// Auto-expanded span IDs from ALL branches are returned in
-// updatedUncollapsedSpans. Only internal nodes (spans with children) are
-// tracked — leaf spans are never added.
-//
-//	root (selected)
-//	  ├─ childA (internal ✓)
-//	  │    └─ grandchildA (internal ✓)
-//	  │         └─ leafA (leaf ✗)
-//	  └─ childB (internal ✓)
-//	       └─ grandchildB (internal ✓)
-//	            └─ leafB (leaf ✗)
-func TestGetSelectedSpans_AutoExpandedSpansReturnedInUncollapsed(t *testing.T) {
-	root := mkSpan("root", "svc",
-		mkSpan("childA", "svc",
-			mkSpan("grandchildA", "svc",
-				mkSpan("leafA", "svc"),
-			),
-		),
-		mkSpan("childB", "svc",
-			mkSpan("grandchildB", "svc",
-				mkSpan("leafB", "svc"),
-			),
-		),
-	)
-	spanMap := buildSpanMap(root)
-	_, uncollapsed, _, _ := GetSelectedSpans([]string{}, "root", []*model.Span{root}, spanMap, true)
-
-	// all internal nodes across both branches must be tracked
-	assert.Contains(t, uncollapsed, "root")
-	assert.Contains(t, uncollapsed, "childA", "internal node depth 1, branch A")
-	assert.Contains(t, uncollapsed, "childB", "internal node depth 1, branch B")
-	assert.Contains(t, uncollapsed, "grandchildA", "internal node depth 2, branch A")
-	assert.Contains(t, uncollapsed, "grandchildB", "internal node depth 2, branch B")
-	// leaves have no children to show — never added to uncollapsedSpans
-	assert.NotContains(t, uncollapsed, "leafA", "leaf spans are never added to uncollapsedSpans")
-	assert.NotContains(t, uncollapsed, "leafB", "leaf spans are never added to uncollapsedSpans")
-}
-
-// ─────────────────────────────────────────────────────────────────────────────
-// maxDepthForSelectedSpanChildren boundary tests
-// ─────────────────────────────────────────────────────────────────────────────
-
-// Depth is measured from the selected span, not the trace root.
-// Ancestors appear via the path-to-root logic, not the depth limit.
-// Each depth level has two children to confirm the limit is enforced on all
-// branches, not just the first.
-//
-//	root
-//	  └─ A                           ancestor ✓ (path-to-root)
-//	       └─ selected
-//	            ├─ d1a               depth 1 ✓
-//	            │    ├─ d2a          depth 2 ✓
-//	            │    │    ├─ d3a     depth 3 ✓
-//	            │    │    │    ├─ d4a   depth 4 ✓
-//	            │    │    │    │    ├─ d5a  depth 5 ✓
-//	            │    │    │    │    │    └─ d6a  depth 6 ✗
-//	            │    │    │    │    └─ d5b  depth 5 ✓
-//	            │    │    │    └─ d4b   depth 4 ✓
-//	            │    │    └─ d3b     depth 3 ✓
-//	            │    └─ d2b          depth 2 ✓
-//	            └─ d1b               depth 1 ✓
-func TestGetSelectedSpans_DepthCountedFromSelectedSpan(t *testing.T) {
-	selected := mkSpan("selected", "svc",
-		mkSpan("d1a", "svc",
-			mkSpan("d2a", "svc",
-				mkSpan("d3a", "svc",
-					mkSpan("d4a", "svc",
-						mkSpan("d5a", "svc",
-							mkSpan("d6a", "svc"), // depth 6 — excluded
-						),
-						mkSpan("d5b", "svc"), // depth 5 — included
-					),
-					mkSpan("d4b", "svc"), // depth 4 — included
-				),
-				mkSpan("d3b", "svc"), // depth 3 — included
-			),
-			mkSpan("d2b", "svc"), // depth 2 — included
-		),
-		mkSpan("d1b", "svc"), // depth 1 — included
-	)
-	root := mkSpan("root", "svc", mkSpan("A", "svc", selected))
-
-	spanMap := buildSpanMap(root)
-	spans, _, _, _ := GetSelectedSpans([]string{}, "selected", []*model.Span{root}, spanMap, true)
-	ids := spanIDs(spans)
-
-	assert.Contains(t, ids, "root", "ancestor shown via path-to-root")
-	assert.Contains(t, ids, "A", "ancestor shown via path-to-root")
-	for _, id := range []string{"d1a", "d1b", "d2a", "d2b", "d3a", "d3b", "d4a", "d4b", "d5a", "d5b"} {
-		assert.Contains(t, ids, id, "depth ≤ 5 — must be included")
-	}
-	assert.NotContains(t, ids, "d6a", "depth 6 > limit — excluded")
-}
-
-func TestGetAllSpans(t *testing.T) {
-	root := mkSpan("root", "svc",
-		mkSpan("childA", "svc",
-			mkSpan("grandchildA", "svc",
-				mkSpan("leafA", "svc2"),
-			),
-		),
-		mkSpan("childB", "svc3",
-			mkSpan("grandchildB", "svc",
-				mkSpan("leafB", "svc2"),
-			),
-		),
-	)
-	spans, rootServiceName, rootEntryPoint := GetAllSpans([]*model.Span{root})
-	assert.ElementsMatch(t, spanIDs(spans), []string{"root", "childA", "grandchildA", "leafA", "childB", "grandchildB", "leafB"})
-	assert.Equal(t, rootServiceName, "svc")
-	assert.Equal(t, rootEntryPoint, "root-op")
-}
-
-func mkSpan(id, service string, children ...*model.Span) *model.Span {
-	return &model.Span{
-		SpanID:      id,
-		ServiceName: service,
-		Name:        id + "-op",
-		Children:    children,
-	}
-}
-
-// spanIDs returns SpanIDs in order.
-func spanIDs(spans []*model.Span) []string {
-	ids := make([]string, len(spans))
-	for i, s := range spans {
-		ids[i] = s.SpanID
-	}
-	return ids
-}
-
-// buildSpanMap indexes every span in a set of trees by SpanID.
-func buildSpanMap(roots ...*model.Span) map[string]*model.Span {
-	m := map[string]*model.Span{}
-	var walk func(*model.Span)
-	walk = func(s *model.Span) {
-		m[s.SpanID] = s
-		for _, c := range s.Children {
-			walk(c)
-		}
-	}
-	for _, r := range roots {
-		walk(r)
-	}
-	return m
-}
--- a/pkg/query-service/interfaces/interface.go
+++ b/pkg/query-service/interfaces/interface.go
@@ -43,7 +43,6 @@ type Reader interface {

 	// Search Interfaces
 	SearchTraces(ctx context.Context, params *model.SearchTracesParams) (*[]model.SearchSpansResult, error)
-	GetWaterfallSpansForTraceWithMetadata(ctx context.Context, orgID valuer.UUID, traceID string, req *model.GetWaterfallSpansForTraceWithMetadataParams) (*model.GetWaterfallSpansForTraceWithMetadataResponse, error)
 	GetFlamegraphSpansForTrace(ctx context.Context, orgID valuer.UUID, traceID string, req *model.GetFlamegraphSpansForTraceParams) (*model.GetFlamegraphSpansForTraceResponse, error)

 	// Setter Interfaces
--- a/Show More
+++ b/Show More