feat: generating openapi spec

docs/api/openapi.yml

@@ -1364,6 +1364,8 @@ components:
       - appservice
       - containerapp
       - aks
+      - sqldatabase
+      - sqldatabasemi
       type: string
     CloudintegrationtypesServiceMetadata:
       properties:
@@ -2436,6 +2438,13 @@ components:
         url:
           type: string
       type: object
+    DashboardPanelDisplay:
+      properties:
+        description:
+          type: string
+        name:
+          type: string
+      type: object
     DashboardTextVariableSpec:
       properties:
         constant:
@@ -2489,17 +2498,10 @@ components:
           $ref: '#/components/schemas/DashboardtypesTimePreference'
       type: object
     DashboardtypesBuilderQuerySpec:
-      discriminator:
-        mapping:
-          logs: '#/components/schemas/Querybuildertypesv5QueryBuilderQueryGithubComSigNozSignozPkgTypesQuerybuildertypesQuerybuildertypesv5LogAggregation'
-          metrics: '#/components/schemas/Querybuildertypesv5QueryBuilderQueryGithubComSigNozSignozPkgTypesQuerybuildertypesQuerybuildertypesv5MetricAggregation'
-          traces: '#/components/schemas/Querybuildertypesv5QueryBuilderQueryGithubComSigNozSignozPkgTypesQuerybuildertypesQuerybuildertypesv5TraceAggregation'
-        propertyName: signal
       oneOf:
       - $ref: '#/components/schemas/Querybuildertypesv5QueryBuilderQueryGithubComSigNozSignozPkgTypesQuerybuildertypesQuerybuildertypesv5LogAggregation'
       - $ref: '#/components/schemas/Querybuildertypesv5QueryBuilderQueryGithubComSigNozSignozPkgTypesQuerybuildertypesQuerybuildertypesv5MetricAggregation'
       - $ref: '#/components/schemas/Querybuildertypesv5QueryBuilderQueryGithubComSigNozSignozPkgTypesQuerybuildertypesQuerybuildertypesv5TraceAggregation'
-      type: object
     DashboardtypesComparisonOperator:
       enum:
       - above
@@ -2563,12 +2565,13 @@ components:
             $ref: '#/components/schemas/DashboardtypesDatasourceSpec'
           type: object
         display:
-          $ref: '#/components/schemas/DashboardtypesDisplay'
+          $ref: '#/components/schemas/CommonDisplay'
         duration:
           type: string
         layouts:
           items:
             $ref: '#/components/schemas/DashboardtypesLayout'
+          nullable: true
           type: array
         links:
           items:
@@ -2577,6 +2580,7 @@ components:
         panels:
           additionalProperties:
             $ref: '#/components/schemas/DashboardtypesPanel'
+          nullable: true
           type: object
         refreshInterval:
           type: string
@@ -2584,20 +2588,10 @@ components:
           items:
             $ref: '#/components/schemas/DashboardtypesVariable'
           type: array
-      required:
-      - display
-      - variables
-      - panels
-      - layouts
       type: object
     DashboardtypesDatasourcePlugin:
-      discriminator:
-        mapping:
-          signoz/Datasource: '#/components/schemas/DashboardtypesDatasourcePluginVariantStruct'
-        propertyName: kind
       oneOf:
       - $ref: '#/components/schemas/DashboardtypesDatasourcePluginVariantStruct'
-      type: object
     DashboardtypesDatasourcePluginKind:
       enum:
       - signoz/Datasource
@@ -2624,15 +2618,6 @@ components:
         plugin:
           $ref: '#/components/schemas/DashboardtypesDatasourcePlugin'
       type: object
-    DashboardtypesDisplay:
-      properties:
-        description:
-          type: string
-        name:
-          type: string
-      required:
-      - name
-      type: object
     DashboardtypesDynamicVariableSpec:
       properties:
         name:
@@ -2673,7 +2658,7 @@ components:
           $ref: '#/components/schemas/DashboardtypesDashboardSpec'
         tags:
           items:
-            $ref: '#/components/schemas/TagtypesGettableTag'
+            $ref: '#/components/schemas/TagtypesPostableTag'
           nullable: true
           type: array
         updatedAt:
@@ -2750,13 +2735,8 @@ components:
       - path
       type: object
     DashboardtypesLayout:
-      discriminator:
-        mapping:
-          Grid: '#/components/schemas/DashboardtypesLayoutEnvelopeGithubComPersesSpecGoDashboardGridLayoutSpec'
-        propertyName: kind
       oneOf:
       - $ref: '#/components/schemas/DashboardtypesLayoutEnvelopeGithubComPersesSpecGoDashboardGridLayoutSpec'
-      type: object
     DashboardtypesLayoutEnvelopeGithubComPersesSpecGoDashboardGridLayoutSpec:
       properties:
         kind:
@@ -2796,11 +2776,6 @@ components:
       - solid
       - dashed
       type: string
-    DashboardtypesListOrder:
-      enum:
-      - asc
-      - desc
-      type: string
     DashboardtypesListPanelSpec:
       properties:
         selectFields:
@@ -2808,12 +2783,6 @@ components:
             $ref: '#/components/schemas/TelemetrytypesTelemetryFieldKey'
           type: array
       type: object
-    DashboardtypesListSort:
-      enum:
-      - updated_at
-      - created_at
-      - name
-      type: string
     DashboardtypesListVariableSpec:
       properties:
         allowAllValue:
@@ -2827,7 +2796,7 @@ components:
         defaultValue:
           $ref: '#/components/schemas/VariableDefaultValue'
         display:
-          $ref: '#/components/schemas/DashboardtypesDisplay'
+          $ref: '#/components/schemas/VariableDisplay'
         name:
           type: string
         plugin:
@@ -2835,136 +2804,6 @@ components:
         sort:
           nullable: true
           type: string
-      required:
-      - display
-      type: object
-    DashboardtypesListableDashboardForUserV2:
-      properties:
-        dashboards:
-          items:
-            $ref: '#/components/schemas/DashboardtypesListedDashboardForUserV2'
-          type: array
-        tags:
-          items:
-            $ref: '#/components/schemas/TagtypesGettableTag'
-          type: array
-        total:
-          format: int64
-          type: integer
-      required:
-      - dashboards
-      - total
-      - tags
-      type: object
-    DashboardtypesListableDashboardV2:
-      properties:
-        dashboards:
-          items:
-            $ref: '#/components/schemas/DashboardtypesListedDashboardV2'
-          type: array
-        tags:
-          items:
-            $ref: '#/components/schemas/TagtypesGettableTag'
-          type: array
-        total:
-          format: int64
-          type: integer
-      required:
-      - dashboards
-      - total
-      - tags
-      type: object
-    DashboardtypesListedDashboardForUserV2:
-      properties:
-        createdAt:
-          format: date-time
-          type: string
-        createdBy:
-          type: string
-        id:
-          type: string
-        image:
-          type: string
-        locked:
-          type: boolean
-        name:
-          type: string
-        orgId:
-          type: string
-        pinned:
-          type: boolean
-        schemaVersion:
-          type: string
-        source:
-          $ref: '#/components/schemas/DashboardtypesSource'
-        spec:
-          $ref: '#/components/schemas/DashboardtypesListedDashboardV2Spec'
-        tags:
-          items:
-            $ref: '#/components/schemas/TagtypesGettableTag'
-          type: array
-        updatedAt:
-          format: date-time
-          type: string
-        updatedBy:
-          type: string
-      required:
-      - id
-      - orgId
-      - locked
-      - source
-      - schemaVersion
-      - name
-      - tags
-      - spec
-      - pinned
-      type: object
-    DashboardtypesListedDashboardV2:
-      properties:
-        createdAt:
-          format: date-time
-          type: string
-        createdBy:
-          type: string
-        id:
-          type: string
-        image:
-          type: string
-        locked:
-          type: boolean
-        name:
-          type: string
-        orgId:
-          type: string
-        schemaVersion:
-          type: string
-        source:
-          $ref: '#/components/schemas/DashboardtypesSource'
-        spec:
-          $ref: '#/components/schemas/DashboardtypesListedDashboardV2Spec'
-        tags:
-          items:
-            $ref: '#/components/schemas/TagtypesGettableTag'
-          type: array
-        updatedAt:
-          format: date-time
-          type: string
-        updatedBy:
-          type: string
-      required:
-      - id
-      - orgId
-      - locked
-      - source
-      - schemaVersion
-      - name
-      - tags
-      - spec
-      type: object
-    DashboardtypesListedDashboardV2Spec:
-      properties:
-        display:
-          $ref: '#/components/schemas/DashboardtypesDisplay'
       type: object
     DashboardtypesNumberPanelSpec:
       properties:
@@ -2984,9 +2823,6 @@ components:
           $ref: '#/components/schemas/DashboardtypesPanelKind'
         spec:
           $ref: '#/components/schemas/DashboardtypesPanelSpec'
-      required:
-      - kind
-      - spec
       type: object
     DashboardtypesPanelFormatting:
       properties:
@@ -3000,16 +2836,6 @@ components:
       - Panel
       type: string
     DashboardtypesPanelPlugin:
-      discriminator:
-        mapping:
-          signoz/BarChartPanel: '#/components/schemas/DashboardtypesPanelPluginVariantGithubComSigNozSignozPkgTypesDashboardtypesBarChartPanelSpec'
-          signoz/HistogramPanel: '#/components/schemas/DashboardtypesPanelPluginVariantGithubComSigNozSignozPkgTypesDashboardtypesHistogramPanelSpec'
-          signoz/ListPanel: '#/components/schemas/DashboardtypesPanelPluginVariantGithubComSigNozSignozPkgTypesDashboardtypesListPanelSpec'
-          signoz/NumberPanel: '#/components/schemas/DashboardtypesPanelPluginVariantGithubComSigNozSignozPkgTypesDashboardtypesNumberPanelSpec'
-          signoz/PieChartPanel: '#/components/schemas/DashboardtypesPanelPluginVariantGithubComSigNozSignozPkgTypesDashboardtypesPieChartPanelSpec'
-          signoz/TablePanel: '#/components/schemas/DashboardtypesPanelPluginVariantGithubComSigNozSignozPkgTypesDashboardtypesTablePanelSpec'
-          signoz/TimeSeriesPanel: '#/components/schemas/DashboardtypesPanelPluginVariantGithubComSigNozSignozPkgTypesDashboardtypesTimeSeriesPanelSpec'
-        propertyName: kind
       oneOf:
       - $ref: '#/components/schemas/DashboardtypesPanelPluginVariantGithubComSigNozSignozPkgTypesDashboardtypesTimeSeriesPanelSpec'
       - $ref: '#/components/schemas/DashboardtypesPanelPluginVariantGithubComSigNozSignozPkgTypesDashboardtypesBarChartPanelSpec'
@@ -3018,7 +2844,6 @@ components:
       - $ref: '#/components/schemas/DashboardtypesPanelPluginVariantGithubComSigNozSignozPkgTypesDashboardtypesTablePanelSpec'
       - $ref: '#/components/schemas/DashboardtypesPanelPluginVariantGithubComSigNozSignozPkgTypesDashboardtypesHistogramPanelSpec'
       - $ref: '#/components/schemas/DashboardtypesPanelPluginVariantGithubComSigNozSignozPkgTypesDashboardtypesListPanelSpec'
-      type: object
     DashboardtypesPanelPluginKind:
       enum:
       - signoz/TimeSeriesPanel
@@ -3116,7 +2941,7 @@ components:
     DashboardtypesPanelSpec:
       properties:
         display:
-          $ref: '#/components/schemas/DashboardtypesDisplay'
+          $ref: '#/components/schemas/DashboardPanelDisplay'
         links:
           items:
             $ref: '#/components/schemas/DashboardLink'
@@ -3126,12 +2951,7 @@ components:
         queries:
           items:
             $ref: '#/components/schemas/DashboardtypesQuery'
-          nullable: true
           type: array
-      required:
-      - display
-      - plugin
-      - queries
       type: object
     DashboardtypesPatchOp:
       enum:
@@ -3200,20 +3020,8 @@ components:
           $ref: '#/components/schemas/Querybuildertypesv5RequestType'
         spec:
           $ref: '#/components/schemas/DashboardtypesQuerySpec'
-      required:
-      - kind
-      - spec
       type: object
     DashboardtypesQueryPlugin:
-      discriminator:
-        mapping:
-          signoz/BuilderQuery: '#/components/schemas/DashboardtypesQueryPluginVariantGithubComSigNozSignozPkgTypesDashboardtypesBuilderQuerySpec'
-          signoz/ClickHouseSQL: '#/components/schemas/DashboardtypesQueryPluginVariantGithubComSigNozSignozPkgTypesQuerybuildertypesQuerybuildertypesv5ClickHouseQuery'
-          signoz/CompositeQuery: '#/components/schemas/DashboardtypesQueryPluginVariantGithubComSigNozSignozPkgTypesQuerybuildertypesQuerybuildertypesv5CompositeQuery'
-          signoz/Formula: '#/components/schemas/DashboardtypesQueryPluginVariantGithubComSigNozSignozPkgTypesQuerybuildertypesQuerybuildertypesv5QueryBuilderFormula'
-          signoz/PromQLQuery: '#/components/schemas/DashboardtypesQueryPluginVariantGithubComSigNozSignozPkgTypesQuerybuildertypesQuerybuildertypesv5PromQuery'
-          signoz/TraceOperator: '#/components/schemas/DashboardtypesQueryPluginVariantGithubComSigNozSignozPkgTypesQuerybuildertypesQuerybuildertypesv5QueryBuilderTraceOperator'
-        propertyName: kind
       oneOf:
       - $ref: '#/components/schemas/DashboardtypesQueryPluginVariantGithubComSigNozSignozPkgTypesDashboardtypesBuilderQuerySpec'
       - $ref: '#/components/schemas/DashboardtypesQueryPluginVariantGithubComSigNozSignozPkgTypesQuerybuildertypesQuerybuildertypesv5CompositeQuery'
@@ -3221,7 +3029,6 @@ components:
       - $ref: '#/components/schemas/DashboardtypesQueryPluginVariantGithubComSigNozSignozPkgTypesQuerybuildertypesQuerybuildertypesv5PromQuery'
       - $ref: '#/components/schemas/DashboardtypesQueryPluginVariantGithubComSigNozSignozPkgTypesQuerybuildertypesQuerybuildertypesv5ClickHouseQuery'
       - $ref: '#/components/schemas/DashboardtypesQueryPluginVariantGithubComSigNozSignozPkgTypesQuerybuildertypesQuerybuildertypesv5QueryBuilderTraceOperator'
-      type: object
     DashboardtypesQueryPluginKind:
       enum:
       - signoz/BuilderQuery
@@ -3309,8 +3116,6 @@ components:
           type: string
         plugin:
           $ref: '#/components/schemas/DashboardtypesQueryPlugin'
-      required:
-      - plugin
       type: object
     DashboardtypesQueryVariableSpec:
       properties:
@@ -3478,15 +3283,9 @@ components:
           type: boolean
       type: object
     DashboardtypesVariable:
-      discriminator:
-        mapping:
-          ListVariable: '#/components/schemas/DashboardtypesVariableEnvelopeGithubComSigNozSignozPkgTypesDashboardtypesListVariableSpec'
-          TextVariable: '#/components/schemas/DashboardtypesVariableEnvelopeGithubComPersesSpecGoDashboardTextVariableSpec'
-        propertyName: kind
       oneOf:
       - $ref: '#/components/schemas/DashboardtypesVariableEnvelopeGithubComSigNozSignozPkgTypesDashboardtypesListVariableSpec'
       - $ref: '#/components/schemas/DashboardtypesVariableEnvelopeGithubComPersesSpecGoDashboardTextVariableSpec'
-      type: object
     DashboardtypesVariableEnvelopeGithubComPersesSpecGoDashboardTextVariableSpec:
       properties:
         kind:
@@ -3512,17 +3311,10 @@ components:
       - spec
       type: object
     DashboardtypesVariablePlugin:
-      discriminator:
-        mapping:
-          signoz/CustomVariable: '#/components/schemas/DashboardtypesVariablePluginVariantGithubComSigNozSignozPkgTypesDashboardtypesCustomVariableSpec'
-          signoz/DynamicVariable: '#/components/schemas/DashboardtypesVariablePluginVariantGithubComSigNozSignozPkgTypesDashboardtypesDynamicVariableSpec'
-          signoz/QueryVariable: '#/components/schemas/DashboardtypesVariablePluginVariantGithubComSigNozSignozPkgTypesDashboardtypesQueryVariableSpec'
-        propertyName: kind
       oneOf:
       - $ref: '#/components/schemas/DashboardtypesVariablePluginVariantGithubComSigNozSignozPkgTypesDashboardtypesDynamicVariableSpec'
       - $ref: '#/components/schemas/DashboardtypesVariablePluginVariantGithubComSigNozSignozPkgTypesDashboardtypesQueryVariableSpec'
       - $ref: '#/components/schemas/DashboardtypesVariablePluginVariantGithubComSigNozSignozPkgTypesDashboardtypesCustomVariableSpec'
-      type: object
     DashboardtypesVariablePluginKind:
       enum:
       - signoz/DynamicVariable
@@ -5725,15 +5517,11 @@ components:
             $ref: '#/components/schemas/TelemetrytypesTelemetryFieldKey'
           type: array
         signal:
-          enum:
-          - logs
-          type: string
+          $ref: '#/components/schemas/TelemetrytypesSignal'
         source:
           $ref: '#/components/schemas/TelemetrytypesSource'
         stepInterval:
           $ref: '#/components/schemas/Querybuildertypesv5Step'
-      required:
-      - signal
       type: object
     Querybuildertypesv5QueryBuilderQueryGithubComSigNozSignozPkgTypesQuerybuildertypesQuerybuildertypesv5MetricAggregation:
       properties:
@@ -5780,15 +5568,11 @@ components:
             $ref: '#/components/schemas/TelemetrytypesTelemetryFieldKey'
           type: array
         signal:
-          enum:
-          - metrics
-          type: string
+          $ref: '#/components/schemas/TelemetrytypesSignal'
         source:
           $ref: '#/components/schemas/TelemetrytypesSource'
         stepInterval:
           $ref: '#/components/schemas/Querybuildertypesv5Step'
-      required:
-      - signal
       type: object
     Querybuildertypesv5QueryBuilderQueryGithubComSigNozSignozPkgTypesQuerybuildertypesQuerybuildertypesv5TraceAggregation:
       properties:
@@ -5835,15 +5619,11 @@ components:
             $ref: '#/components/schemas/TelemetrytypesTelemetryFieldKey'
           type: array
         signal:
-          enum:
-          - traces
-          type: string
+          $ref: '#/components/schemas/TelemetrytypesSignal'
         source:
           $ref: '#/components/schemas/TelemetrytypesSource'
         stepInterval:
           $ref: '#/components/schemas/Querybuildertypesv5Step'
-      required:
-      - signal
       type: object
     Querybuildertypesv5QueryBuilderTraceOperator:
       properties:
@@ -7284,16 +7064,6 @@ components:
       required:
       - references
       type: object
-    TagtypesGettableTag:
-      properties:
-        key:
-          type: string
-        value:
-          type: string
-      required:
-      - key
-      - value
-      type: object
     TagtypesPostableTag:
       properties:
         key:
@@ -13329,82 +13099,6 @@ paths:
       tags:
       - preferences
   /api/v2/dashboards:
-    get:
-      deprecated: false
-      description: Returns a page of v2-shape dashboards for the org. This is the
-        pure, user-independent list — it carries no pin state. Use ListDashboardsForUserV2
-        for the personalized, pin-aware list. Supports a filter DSL (`query`), sort
-        (`updated_at`/`created_at`/`name`), order (`asc`/`desc`), and offset-based
-        pagination (`limit`/`offset`).
-      operationId: ListDashboardsV2
-      parameters:
-      - in: query
-        name: query
-        schema:
-          type: string
-      - in: query
-        name: sort
-        schema:
-          $ref: '#/components/schemas/DashboardtypesListSort'
-      - in: query
-        name: order
-        schema:
-          $ref: '#/components/schemas/DashboardtypesListOrder'
-      - in: query
-        name: limit
-        schema:
-          type: integer
-      - in: query
-        name: offset
-        schema:
-          type: integer
-      responses:
-        "200":
-          content:
-            application/json:
-              schema:
-                properties:
-                  data:
-                    $ref: '#/components/schemas/DashboardtypesListableDashboardV2'
-                  status:
-                    type: string
-                required:
-                - status
-                - data
-                type: object
-          description: OK
-        "400":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Bad Request
-        "401":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Unauthorized
-        "403":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Forbidden
-        "500":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Internal Server Error
-      security:
-      - api_key:
-        - VIEWER
-      - tokenizer:
-        - VIEWER
-      summary: List dashboards (v2)
-      tags:
-      - dashboard
     post:
       deprecated: false
       description: This endpoint creates a dashboard in the v2 format that follows
@@ -13463,62 +13157,6 @@ paths:
       tags:
       - dashboard
   /api/v2/dashboards/{id}:
-    delete:
-      deprecated: false
-      description: This endpoint deletes a v2-shape dashboard along with its tag relations.
-        Locked dashboards are rejected.
-      operationId: DeleteDashboardV2
-      parameters:
-      - in: path
-        name: id
-        required: true
-        schema:
-          type: string
-      responses:
-        "204":
-          content:
-            application/json:
-              schema:
-                type: string
-          description: No Content
-        "400":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Bad Request
-        "401":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Unauthorized
-        "403":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Forbidden
-        "404":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Not Found
-        "500":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Internal Server Error
-      security:
-      - api_key:
-        - EDITOR
-      - tokenizer:
-        - EDITOR
-      summary: Delete dashboard (v2)
-      tags:
-      - dashboard
     get:
       deprecated: false
       description: This endpoint returns a v2-shape dashboard.
@@ -20741,196 +20379,6 @@ paths:
       summary: Update my user v2
       tags:
       - users
-  /api/v2/users/me/dashboards:
-    get:
-      deprecated: false
-      description: 'Same as ListDashboardsV2 but personalized for the calling user:
-        each dashboard carries the caller''s `pinned` state, and pinned dashboards
-        float to the top of the requested ordering. Supports the same filter DSL,
-        sort, order, and pagination.'
-      operationId: ListDashboardsForUserV2
-      parameters:
-      - in: query
-        name: query
-        schema:
-          type: string
-      - in: query
-        name: sort
-        schema:
-          $ref: '#/components/schemas/DashboardtypesListSort'
-      - in: query
-        name: order
-        schema:
-          $ref: '#/components/schemas/DashboardtypesListOrder'
-      - in: query
-        name: limit
-        schema:
-          type: integer
-      - in: query
-        name: offset
-        schema:
-          type: integer
-      responses:
-        "200":
-          content:
-            application/json:
-              schema:
-                properties:
-                  data:
-                    $ref: '#/components/schemas/DashboardtypesListableDashboardForUserV2'
-                  status:
-                    type: string
-                required:
-                - status
-                - data
-                type: object
-          description: OK
-        "400":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Bad Request
-        "401":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Unauthorized
-        "403":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Forbidden
-        "500":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Internal Server Error
-      security:
-      - api_key:
-        - VIEWER
-      - tokenizer:
-        - VIEWER
-      summary: List dashboards for the current user (v2)
-      tags:
-      - dashboard
-  /api/v2/users/me/dashboards/{id}/pins:
-    delete:
-      deprecated: false
-      description: Removes the pin for the calling user. Idempotent — unpinning a
-        dashboard that wasn't pinned still returns 204.
-      operationId: UnpinDashboardV2
-      parameters:
-      - in: path
-        name: id
-        required: true
-        schema:
-          type: string
-      responses:
-        "204":
-          content:
-            application/json:
-              schema:
-                type: string
-          description: No Content
-        "400":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Bad Request
-        "401":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Unauthorized
-        "403":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Forbidden
-        "500":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Internal Server Error
-      security:
-      - api_key:
-        - VIEWER
-      - tokenizer:
-        - VIEWER
-      summary: Unpin a dashboard for the current user (v2)
-      tags:
-      - dashboard
-    put:
-      deprecated: false
-      description: Pins the dashboard for the calling user. A user can pin at most
-        10 dashboards; pinning when at the limit returns 409. Re-pinning an already-pinned
-        dashboard is a no-op success.
-      operationId: PinDashboardV2
-      parameters:
-      - in: path
-        name: id
-        required: true
-        schema:
-          type: string
-      responses:
-        "204":
-          content:
-            application/json:
-              schema:
-                type: string
-          description: No Content
-        "400":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Bad Request
-        "401":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Unauthorized
-        "403":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Forbidden
-        "404":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Not Found
-        "409":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Conflict
-        "500":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Internal Server Error
-      security:
-      - api_key:
-        - VIEWER
-      - tokenizer:
-        - VIEWER
-      summary: Pin a dashboard for the current user (v2)
-      tags:
-      - dashboard
   /api/v2/users/me/factor_password:
     put:
       deprecated: false

docs/contributing/go/handler.md

@@ -333,50 +333,6 @@ func (Step) JSONSchema() (jsonschema.Schema, error) {
 }
 ```
 
-### `oneOf` with a discriminator
-
-For a sum type whose variants are keyed by a property (e.g. `kind`), expose the variants via `JSONSchemaOneOf()` and add a discriminator. Without it, code generators intersect the variants (`A & B & C`) instead of producing a clean discriminated union (`A | B | C`).
-
-The parent keeps its `JSONSchemaOneOf()` (the `oneOf` itself) and *additionally* tags it via `PrepareJSONSchema` with the `x-signoz-discriminator` extension; `signoz.attachDiscriminators` then promotes that marker to a real OpenAPI 3 `discriminator` (and strips the duplicate parent properties) after reflection.
-
-```go
-// On the parent: expose the oneOf variants...
-func (Plugin) JSONSchemaOneOf() []any {
-    return []any{FooVariant{}}
-}
-
-// ...and tag that same oneOf with the discriminator marker.
-func (Plugin) PrepareJSONSchema(s *jsonschema.Schema) error {
-    if s.ExtraProperties == nil {
-        s.ExtraProperties = map[string]any{}
-    }
-    s.ExtraProperties["x-signoz-discriminator"] = map[string]any{
-        "propertyName": "kind",
-        "mapping": map[string]string{
-            "signoz/Foo": "#/components/schemas/FooVariant",
-        },
-    }
-    return nil
-}
-```
-
-Each variant must declare the discriminator property (`kind`) and mark it `required`. 
-
-This produces the following in the generated OpenAPI spec:
-
-```yaml
-Plugin:
-  discriminator:
-    propertyName: kind
-    mapping:
-      signoz/Foo: '#/components/schemas/FooVariant'
-  oneOf:
-  - $ref: '#/components/schemas/FooVariant'
-  type: object
-```
-
-Note the discriminator property lives in the variants, not on the parent — the parent is only the union.
-
 
 ## What should I remember?
 

ee/modules/dashboard/impldashboard/module.go

@@ -229,39 +229,10 @@ func (module *module) PatchV2(ctx context.Context, orgID valuer.UUID, id valuer.
 	return module.pkgDashboardModule.PatchV2(ctx, orgID, id, updatedBy, patch)
 }
 
-func (module *module) DeleteV2(ctx context.Context, orgID valuer.UUID, id valuer.UUID) error {
-	return module.store.RunInTx(ctx, func(ctx context.Context) error {
-		if err := module.store.DeletePublic(ctx, id.String()); err != nil && !errors.Ast(err, errors.TypeNotFound) {
-			return err
-		}
-		return module.pkgDashboardModule.DeleteV2(ctx, orgID, id)
-	})
-}
-
 func (module *module) LockUnlockV2(ctx context.Context, orgID valuer.UUID, id valuer.UUID, updatedBy string, isAdmin bool, lock bool) error {
 	return module.pkgDashboardModule.LockUnlockV2(ctx, orgID, id, updatedBy, isAdmin, lock)
 }
 
-func (module *module) ListV2(ctx context.Context, orgID valuer.UUID, params *dashboardtypes.ListDashboardsV2Params) (*dashboardtypes.ListableDashboardV2, error) {
-	return module.pkgDashboardModule.ListV2(ctx, orgID, params)
-}
-
-func (module *module) ListForUserV2(ctx context.Context, orgID valuer.UUID, userID valuer.UUID, params *dashboardtypes.ListDashboardsV2Params) (*dashboardtypes.ListableDashboardForUserV2, error) {
-	return module.pkgDashboardModule.ListForUserV2(ctx, orgID, userID, params)
-}
-
-func (module *module) PinV2(ctx context.Context, orgID valuer.UUID, userID valuer.UUID, id valuer.UUID) error {
-	return module.pkgDashboardModule.PinV2(ctx, orgID, userID, id)
-}
-
-func (module *module) UnpinV2(ctx context.Context, orgID valuer.UUID, userID valuer.UUID, id valuer.UUID) error {
-	return module.pkgDashboardModule.UnpinV2(ctx, orgID, userID, id)
-}
-
-func (module *module) DeletePreferencesForUser(ctx context.Context, orgID valuer.UUID, userID valuer.UUID) error {
-	return module.pkgDashboardModule.DeletePreferencesForUser(ctx, orgID, userID)
-}
-
 func (module *module) Get(ctx context.Context, orgID valuer.UUID, id valuer.UUID) (*dashboardtypes.Dashboard, error) {
 	return module.pkgDashboardModule.Get(ctx, orgID, id)
 }

ee/query-service/app/server.go

@@ -185,7 +185,6 @@ func (s *Server) createPublicServer(apiHandler *api.APIHandler, web web.Web) (*h
 		s.config.APIServer.Timeout.Default,
 		s.config.APIServer.Timeout.Max,
 	).Wrap)
-	r.Use(middleware.NewResource(s.signoz.Instrumentation.Logger()).Wrap)
 	r.Use(middleware.NewAudit(s.signoz.Instrumentation.Logger(), s.config.APIServer.Logging.ExcludedRoutes, s.signoz.Auditor).Wrap)
 	r.Use(middleware.NewComment().Wrap)
 

ee/sqlstore/postgressqlstore/formatter.go

@@ -16,11 +16,10 @@ func newFormatter(dialect schema.Dialect) sqlstore.SQLFormatter {
 }
 
 func (f *formatter) JSONExtractString(column, path string) []byte {
-	ops := f.convertJSONPathToPostgres(path)
-	if len(ops) == 0 {
-		return f.bunf.AppendIdent(nil, column)
-	}
-	return append(f.TextToJsonColumn(column), ops...)
+	var sql []byte
+	sql = f.bunf.AppendIdent(sql, column)
+	sql = append(sql, f.convertJSONPathToPostgres(path)...)
+	return sql
 }
 
 func (f *formatter) JSONType(column, path string) []byte {

ee/sqlstore/postgressqlstore/formatter_test.go

@@ -18,19 +18,19 @@ func TestJSONExtractString(t *testing.T) {
 			name:     "simple path",
 			column:   "data",
 			path:     "$.field",
-			expected: `"data"::jsonb->>'field'`,
+			expected: `"data"->>'field'`,
 		},
 		{
 			name:     "nested path",
 			column:   "metadata",
 			path:     "$.user.name",
-			expected: `"metadata"::jsonb->'user'->>'name'`,
+			expected: `"metadata"->'user'->>'name'`,
 		},
 		{
 			name:     "deeply nested path",
 			column:   "json_col",
 			path:     "$.level1.level2.level3",
-			expected: `"json_col"::jsonb->'level1'->'level2'->>'level3'`,
+			expected: `"json_col"->'level1'->'level2'->>'level3'`,
 		},
 		{
 			name:     "root path",

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

@@ -26,7 +26,6 @@ import type {
 	DashboardtypesPostablePublicDashboardDTO,
 	DashboardtypesUpdatableDashboardV2DTO,
 	DashboardtypesUpdatablePublicDashboardDTO,
-	DeleteDashboardV2PathParameters,
 	DeletePublicDashboardPathParameters,
 	GetDashboardV2200,
 	GetDashboardV2PathParameters,
@@ -36,17 +35,11 @@ import type {
 	GetPublicDashboardPathParameters,
 	GetPublicDashboardWidgetQueryRange200,
 	GetPublicDashboardWidgetQueryRangePathParameters,
-	ListDashboardsForUserV2200,
-	ListDashboardsForUserV2Params,
-	ListDashboardsV2200,
-	ListDashboardsV2Params,
 	LockDashboardV2PathParameters,
 	PatchDashboardV2200,
 	PatchDashboardV2PathParameters,
-	PinDashboardV2PathParameters,
 	RenderErrorResponseDTO,
 	UnlockDashboardV2PathParameters,
-	UnpinDashboardV2PathParameters,
 	UpdateDashboardV2200,
 	UpdateDashboardV2PathParameters,
 	UpdatePublicDashboardPathParameters,
@@ -648,103 +641,6 @@ export const invalidateGetPublicDashboardWidgetQueryRange = async (
 	return queryClient;
 };
 
-/**
- * Returns a page of v2-shape dashboards for the org. This is the pure, user-independent list — it carries no pin state. Use ListDashboardsForUserV2 for the personalized, pin-aware list. Supports a filter DSL (`query`), sort (`updated_at`/`created_at`/`name`), order (`asc`/`desc`), and offset-based pagination (`limit`/`offset`).
- * @summary List dashboards (v2)
- */
-export const listDashboardsV2 = (
-	params?: ListDashboardsV2Params,
-	signal?: AbortSignal,
-) => {
-	return GeneratedAPIInstance<ListDashboardsV2200>({
-		url: `/api/v2/dashboards`,
-		method: 'GET',
-		params,
-		signal,
-	});
-};
-
-export const getListDashboardsV2QueryKey = (
-	params?: ListDashboardsV2Params,
-) => {
-	return [`/api/v2/dashboards`, ...(params ? [params] : [])] as const;
-};
-
-export const getListDashboardsV2QueryOptions = <
-	TData = Awaited<ReturnType<typeof listDashboardsV2>>,
-	TError = ErrorType<RenderErrorResponseDTO>,
->(
-	params?: ListDashboardsV2Params,
-	options?: {
-		query?: UseQueryOptions<
-			Awaited<ReturnType<typeof listDashboardsV2>>,
-			TError,
-			TData
-		>;
-	},
-) => {
-	const { query: queryOptions } = options ?? {};
-
-	const queryKey = queryOptions?.queryKey ?? getListDashboardsV2QueryKey(params);
-
-	const queryFn: QueryFunction<Awaited<ReturnType<typeof listDashboardsV2>>> = ({
-		signal,
-	}) => listDashboardsV2(params, signal);
-
-	return { queryKey, queryFn, ...queryOptions } as UseQueryOptions<
-		Awaited<ReturnType<typeof listDashboardsV2>>,
-		TError,
-		TData
-	> & { queryKey: QueryKey };
-};
-
-export type ListDashboardsV2QueryResult = NonNullable<
-	Awaited<ReturnType<typeof listDashboardsV2>>
->;
-export type ListDashboardsV2QueryError = ErrorType<RenderErrorResponseDTO>;
-
-/**
- * @summary List dashboards (v2)
- */
-
-export function useListDashboardsV2<
-	TData = Awaited<ReturnType<typeof listDashboardsV2>>,
-	TError = ErrorType<RenderErrorResponseDTO>,
->(
-	params?: ListDashboardsV2Params,
-	options?: {
-		query?: UseQueryOptions<
-			Awaited<ReturnType<typeof listDashboardsV2>>,
-			TError,
-			TData
-		>;
-	},
-): UseQueryResult<TData, TError> & { queryKey: QueryKey } {
-	const queryOptions = getListDashboardsV2QueryOptions(params, options);
-
-	const query = useQuery(queryOptions) as UseQueryResult<TData, TError> & {
-		queryKey: QueryKey;
-	};
-
-	return { ...query, queryKey: queryOptions.queryKey };
-}
-
-/**
- * @summary List dashboards (v2)
- */
-export const invalidateListDashboardsV2 = async (
-	queryClient: QueryClient,
-	params?: ListDashboardsV2Params,
-	options?: InvalidateOptions,
-): Promise<QueryClient> => {
-	await queryClient.invalidateQueries(
-		{ queryKey: getListDashboardsV2QueryKey(params) },
-		options,
-	);
-
-	return queryClient;
-};
-
 /**
  * This endpoint creates a dashboard in the v2 format that follows Perses spec.
  * @summary Create dashboard (v2)
@@ -828,85 +724,6 @@ export const useCreateDashboardV2 = <
 > => {
 	return useMutation(getCreateDashboardV2MutationOptions(options));
 };
-/**
- * This endpoint deletes a v2-shape dashboard along with its tag relations. Locked dashboards are rejected.
- * @summary Delete dashboard (v2)
- */
-export const deleteDashboardV2 = (
-	{ id }: DeleteDashboardV2PathParameters,
-	signal?: AbortSignal,
-) => {
-	return GeneratedAPIInstance<string>({
-		url: `/api/v2/dashboards/${id}`,
-		method: 'DELETE',
-		signal,
-	});
-};
-
-export const getDeleteDashboardV2MutationOptions = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown,
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof deleteDashboardV2>>,
-		TError,
-		{ pathParams: DeleteDashboardV2PathParameters },
-		TContext
-	>;
-}): UseMutationOptions<
-	Awaited<ReturnType<typeof deleteDashboardV2>>,
-	TError,
-	{ pathParams: DeleteDashboardV2PathParameters },
-	TContext
-> => {
-	const mutationKey = ['deleteDashboardV2'];
-	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 deleteDashboardV2>>,
-		{ pathParams: DeleteDashboardV2PathParameters }
-	> = (props) => {
-		const { pathParams } = props ?? {};
-
-		return deleteDashboardV2(pathParams);
-	};
-
-	return { mutationFn, ...mutationOptions };
-};
-
-export type DeleteDashboardV2MutationResult = NonNullable<
-	Awaited<ReturnType<typeof deleteDashboardV2>>
->;
-
-export type DeleteDashboardV2MutationError = ErrorType<RenderErrorResponseDTO>;
-
-/**
- * @summary Delete dashboard (v2)
- */
-export const useDeleteDashboardV2 = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown,
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof deleteDashboardV2>>,
-		TError,
-		{ pathParams: DeleteDashboardV2PathParameters },
-		TContext
-	>;
-}): UseMutationResult<
-	Awaited<ReturnType<typeof deleteDashboardV2>>,
-	TError,
-	{ pathParams: DeleteDashboardV2PathParameters },
-	TContext
-> => {
-	return useMutation(getDeleteDashboardV2MutationOptions(options));
-};
 /**
  * This endpoint returns a v2-shape dashboard.
  * @summary Get dashboard (v2)
@@ -1364,260 +1181,3 @@ export const useLockDashboardV2 = <
 > => {
 	return useMutation(getLockDashboardV2MutationOptions(options));
 };
-/**
- * Same as ListDashboardsV2 but personalized for the calling user: each dashboard carries the caller's `pinned` state, and pinned dashboards float to the top of the requested ordering. Supports the same filter DSL, sort, order, and pagination.
- * @summary List dashboards for the current user (v2)
- */
-export const listDashboardsForUserV2 = (
-	params?: ListDashboardsForUserV2Params,
-	signal?: AbortSignal,
-) => {
-	return GeneratedAPIInstance<ListDashboardsForUserV2200>({
-		url: `/api/v2/users/me/dashboards`,
-		method: 'GET',
-		params,
-		signal,
-	});
-};
-
-export const getListDashboardsForUserV2QueryKey = (
-	params?: ListDashboardsForUserV2Params,
-) => {
-	return [`/api/v2/users/me/dashboards`, ...(params ? [params] : [])] as const;
-};
-
-export const getListDashboardsForUserV2QueryOptions = <
-	TData = Awaited<ReturnType<typeof listDashboardsForUserV2>>,
-	TError = ErrorType<RenderErrorResponseDTO>,
->(
-	params?: ListDashboardsForUserV2Params,
-	options?: {
-		query?: UseQueryOptions<
-			Awaited<ReturnType<typeof listDashboardsForUserV2>>,
-			TError,
-			TData
-		>;
-	},
-) => {
-	const { query: queryOptions } = options ?? {};
-
-	const queryKey =
-		queryOptions?.queryKey ?? getListDashboardsForUserV2QueryKey(params);
-
-	const queryFn: QueryFunction<
-		Awaited<ReturnType<typeof listDashboardsForUserV2>>
-	> = ({ signal }) => listDashboardsForUserV2(params, signal);
-
-	return { queryKey, queryFn, ...queryOptions } as UseQueryOptions<
-		Awaited<ReturnType<typeof listDashboardsForUserV2>>,
-		TError,
-		TData
-	> & { queryKey: QueryKey };
-};
-
-export type ListDashboardsForUserV2QueryResult = NonNullable<
-	Awaited<ReturnType<typeof listDashboardsForUserV2>>
->;
-export type ListDashboardsForUserV2QueryError =
-	ErrorType<RenderErrorResponseDTO>;
-
-/**
- * @summary List dashboards for the current user (v2)
- */
-
-export function useListDashboardsForUserV2<
-	TData = Awaited<ReturnType<typeof listDashboardsForUserV2>>,
-	TError = ErrorType<RenderErrorResponseDTO>,
->(
-	params?: ListDashboardsForUserV2Params,
-	options?: {
-		query?: UseQueryOptions<
-			Awaited<ReturnType<typeof listDashboardsForUserV2>>,
-			TError,
-			TData
-		>;
-	},
-): UseQueryResult<TData, TError> & { queryKey: QueryKey } {
-	const queryOptions = getListDashboardsForUserV2QueryOptions(params, options);
-
-	const query = useQuery(queryOptions) as UseQueryResult<TData, TError> & {
-		queryKey: QueryKey;
-	};
-
-	return { ...query, queryKey: queryOptions.queryKey };
-}
-
-/**
- * @summary List dashboards for the current user (v2)
- */
-export const invalidateListDashboardsForUserV2 = async (
-	queryClient: QueryClient,
-	params?: ListDashboardsForUserV2Params,
-	options?: InvalidateOptions,
-): Promise<QueryClient> => {
-	await queryClient.invalidateQueries(
-		{ queryKey: getListDashboardsForUserV2QueryKey(params) },
-		options,
-	);
-
-	return queryClient;
-};
-
-/**
- * Removes the pin for the calling user. Idempotent — unpinning a dashboard that wasn't pinned still returns 204.
- * @summary Unpin a dashboard for the current user (v2)
- */
-export const unpinDashboardV2 = (
-	{ id }: UnpinDashboardV2PathParameters,
-	signal?: AbortSignal,
-) => {
-	return GeneratedAPIInstance<string>({
-		url: `/api/v2/users/me/dashboards/${id}/pins`,
-		method: 'DELETE',
-		signal,
-	});
-};
-
-export const getUnpinDashboardV2MutationOptions = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown,
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof unpinDashboardV2>>,
-		TError,
-		{ pathParams: UnpinDashboardV2PathParameters },
-		TContext
-	>;
-}): UseMutationOptions<
-	Awaited<ReturnType<typeof unpinDashboardV2>>,
-	TError,
-	{ pathParams: UnpinDashboardV2PathParameters },
-	TContext
-> => {
-	const mutationKey = ['unpinDashboardV2'];
-	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 unpinDashboardV2>>,
-		{ pathParams: UnpinDashboardV2PathParameters }
-	> = (props) => {
-		const { pathParams } = props ?? {};
-
-		return unpinDashboardV2(pathParams);
-	};
-
-	return { mutationFn, ...mutationOptions };
-};
-
-export type UnpinDashboardV2MutationResult = NonNullable<
-	Awaited<ReturnType<typeof unpinDashboardV2>>
->;
-
-export type UnpinDashboardV2MutationError = ErrorType<RenderErrorResponseDTO>;
-
-/**
- * @summary Unpin a dashboard for the current user (v2)
- */
-export const useUnpinDashboardV2 = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown,
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof unpinDashboardV2>>,
-		TError,
-		{ pathParams: UnpinDashboardV2PathParameters },
-		TContext
-	>;
-}): UseMutationResult<
-	Awaited<ReturnType<typeof unpinDashboardV2>>,
-	TError,
-	{ pathParams: UnpinDashboardV2PathParameters },
-	TContext
-> => {
-	return useMutation(getUnpinDashboardV2MutationOptions(options));
-};
-/**
- * Pins the dashboard for the calling user. A user can pin at most 10 dashboards; pinning when at the limit returns 409. Re-pinning an already-pinned dashboard is a no-op success.
- * @summary Pin a dashboard for the current user (v2)
- */
-export const pinDashboardV2 = (
-	{ id }: PinDashboardV2PathParameters,
-	signal?: AbortSignal,
-) => {
-	return GeneratedAPIInstance<string>({
-		url: `/api/v2/users/me/dashboards/${id}/pins`,
-		method: 'PUT',
-		signal,
-	});
-};
-
-export const getPinDashboardV2MutationOptions = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown,
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof pinDashboardV2>>,
-		TError,
-		{ pathParams: PinDashboardV2PathParameters },
-		TContext
-	>;
-}): UseMutationOptions<
-	Awaited<ReturnType<typeof pinDashboardV2>>,
-	TError,
-	{ pathParams: PinDashboardV2PathParameters },
-	TContext
-> => {
-	const mutationKey = ['pinDashboardV2'];
-	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 pinDashboardV2>>,
-		{ pathParams: PinDashboardV2PathParameters }
-	> = (props) => {
-		const { pathParams } = props ?? {};
-
-		return pinDashboardV2(pathParams);
-	};
-
-	return { mutationFn, ...mutationOptions };
-};
-
-export type PinDashboardV2MutationResult = NonNullable<
-	Awaited<ReturnType<typeof pinDashboardV2>>
->;
-
-export type PinDashboardV2MutationError = ErrorType<RenderErrorResponseDTO>;
-
-/**
- * @summary Pin a dashboard for the current user (v2)
- */
-export const usePinDashboardV2 = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown,
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof pinDashboardV2>>,
-		TError,
-		{ pathParams: PinDashboardV2PathParameters },
-		TContext
-	>;
-}): UseMutationResult<
-	Awaited<ReturnType<typeof pinDashboardV2>>,
-	TError,
-	{ pathParams: PinDashboardV2PathParameters },
-	TContext
-> => {
-	return useMutation(getPinDashboardV2MutationOptions(options));
-};

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

@@ -2655,6 +2655,8 @@ export enum CloudintegrationtypesServiceIDDTO {
 	appservice = 'appservice',
 	containerapp = 'containerapp',
 	aks = 'aks',
+	sqldatabase = 'sqldatabase',
+	sqldatabasemi = 'sqldatabasemi',
 }
 export type CloudintegrationtypesCloudIntegrationServiceDTOAnyOf = {
 	/**
@@ -3156,6 +3158,17 @@ export interface DashboardLinkDTO {
 	url?: string;
 }
 
+export interface DashboardPanelDisplayDTO {
+	/**
+	 * @type string
+	 */
+	description?: string;
+	/**
+	 * @type string
+	 */
+	name?: string;
+}
+
 export interface VariableDisplayDTO {
 	/**
 	 * @type string
@@ -3484,9 +3497,6 @@ export interface TelemetrytypesTelemetryFieldKeyDTO {
 	unit?: string;
 }
 
-export enum Querybuildertypesv5QueryBuilderQueryGithubComSigNozSignozPkgTypesQuerybuildertypesQuerybuildertypesv5LogAggregationDTOSignal {
-	logs = 'logs',
-}
 export enum TelemetrytypesSourceDTO {
 	meter = 'meter',
 }
@@ -3542,11 +3552,7 @@ export interface Querybuildertypesv5QueryBuilderQueryGithubComSigNozSignozPkgTyp
 	 * @type array
 	 */
 	selectFields?: TelemetrytypesTelemetryFieldKeyDTO[];
-	/**
-	 * @enum logs
-	 * @type string
-	 */
-	signal: Querybuildertypesv5QueryBuilderQueryGithubComSigNozSignozPkgTypesQuerybuildertypesQuerybuildertypesv5LogAggregationDTOSignal;
+	signal?: TelemetrytypesSignalDTO;
 	source?: TelemetrytypesSourceDTO;
 	stepInterval?: Querybuildertypesv5StepDTO;
 }
@@ -3612,9 +3618,6 @@ export interface Querybuildertypesv5MetricAggregationDTO {
 	timeAggregation?: MetrictypesTimeAggregationDTO;
 }
 
-export enum Querybuildertypesv5QueryBuilderQueryGithubComSigNozSignozPkgTypesQuerybuildertypesQuerybuildertypesv5MetricAggregationDTOSignal {
-	metrics = 'metrics',
-}
 export interface Querybuildertypesv5QueryBuilderQueryGithubComSigNozSignozPkgTypesQuerybuildertypesQuerybuildertypesv5MetricAggregationDTO {
 	/**
 	 * @type array
@@ -3667,11 +3670,7 @@ export interface Querybuildertypesv5QueryBuilderQueryGithubComSigNozSignozPkgTyp
 	 * @type array
 	 */
 	selectFields?: TelemetrytypesTelemetryFieldKeyDTO[];
-	/**
-	 * @enum metrics
-	 * @type string
-	 */
-	signal: Querybuildertypesv5QueryBuilderQueryGithubComSigNozSignozPkgTypesQuerybuildertypesQuerybuildertypesv5MetricAggregationDTOSignal;
+	signal?: TelemetrytypesSignalDTO;
 	source?: TelemetrytypesSourceDTO;
 	stepInterval?: Querybuildertypesv5StepDTO;
 }
@@ -3687,9 +3686,6 @@ export interface Querybuildertypesv5TraceAggregationDTO {
 	expression?: string;
 }
 
-export enum Querybuildertypesv5QueryBuilderQueryGithubComSigNozSignozPkgTypesQuerybuildertypesQuerybuildertypesv5TraceAggregationDTOSignal {
-	traces = 'traces',
-}
 export interface Querybuildertypesv5QueryBuilderQueryGithubComSigNozSignozPkgTypesQuerybuildertypesQuerybuildertypesv5TraceAggregationDTO {
 	/**
 	 * @type array
@@ -3742,11 +3738,7 @@ export interface Querybuildertypesv5QueryBuilderQueryGithubComSigNozSignozPkgTyp
 	 * @type array
 	 */
 	selectFields?: TelemetrytypesTelemetryFieldKeyDTO[];
-	/**
-	 * @enum traces
-	 * @type string
-	 */
-	signal: Querybuildertypesv5QueryBuilderQueryGithubComSigNozSignozPkgTypesQuerybuildertypesQuerybuildertypesv5TraceAggregationDTOSignal;
+	signal?: TelemetrytypesSignalDTO;
 	source?: TelemetrytypesSourceDTO;
 	stepInterval?: Querybuildertypesv5StepDTO;
 }
@@ -3881,17 +3873,6 @@ export type DashboardtypesDashboardSpecDTODatasources = {
 export enum DashboardtypesPanelKindDTO {
 	Panel = 'Panel',
 }
-export interface DashboardtypesDisplayDTO {
-	/**
-	 * @type string
-	 */
-	description?: string;
-	/**
-	 * @type string
-	 */
-	name: string;
-}
-
 export enum DashboardtypesPanelPluginVariantGithubComSigNozSignozPkgTypesDashboardtypesTimeSeriesPanelSpecDTOKind {
 	'signoz/TimeSeriesPanel' = 'signoz/TimeSeriesPanel',
 }
@@ -4440,36 +4421,42 @@ export interface DashboardtypesQuerySpecDTO {
 	 * @type string
 	 */
 	name?: string;
-	plugin: DashboardtypesQueryPluginDTO;
+	plugin?: DashboardtypesQueryPluginDTO;
 }
 
 export interface DashboardtypesQueryDTO {
-	kind: Querybuildertypesv5RequestTypeDTO;
-	spec: DashboardtypesQuerySpecDTO;
+	kind?: Querybuildertypesv5RequestTypeDTO;
+	spec?: DashboardtypesQuerySpecDTO;
 }
 
 export interface DashboardtypesPanelSpecDTO {
-	display: DashboardtypesDisplayDTO;
+	display?: DashboardPanelDisplayDTO;
 	/**
 	 * @type array
 	 */
 	links?: DashboardLinkDTO[];
-	plugin: DashboardtypesPanelPluginDTO;
+	plugin?: DashboardtypesPanelPluginDTO;
 	/**
-	 * @type array,null
+	 * @type array
 	 */
-	queries: DashboardtypesQueryDTO[] | null;
+	queries?: DashboardtypesQueryDTO[];
 }
 
 export interface DashboardtypesPanelDTO {
-	kind: DashboardtypesPanelKindDTO;
-	spec: DashboardtypesPanelSpecDTO;
+	kind?: DashboardtypesPanelKindDTO;
+	spec?: DashboardtypesPanelSpecDTO;
 }
 
-export type DashboardtypesDashboardSpecDTOPanels = {
+export type DashboardtypesDashboardSpecDTOPanelsAnyOf = {
 	[key: string]: DashboardtypesPanelDTO;
 };
 
+/**
+ * @nullable
+ */
+export type DashboardtypesDashboardSpecDTOPanels =
+	DashboardtypesDashboardSpecDTOPanelsAnyOf | null;
+
 export enum DashboardtypesLayoutEnvelopeGithubComPersesSpecGoDashboardGridLayoutSpecDTOKind {
 	Grid = 'Grid',
 }
@@ -4566,7 +4553,7 @@ export interface DashboardtypesListVariableSpecDTO {
 	 */
 	customAllValue?: string;
 	defaultValue?: VariableDefaultValueDTO;
-	display: DashboardtypesDisplayDTO;
+	display?: VariableDisplayDTO;
 	/**
 	 * @type string
 	 */
@@ -4608,23 +4595,23 @@ export interface DashboardtypesDashboardSpecDTO {
 	 * @type object
 	 */
 	datasources?: DashboardtypesDashboardSpecDTODatasources;
-	display: DashboardtypesDisplayDTO;
+	display?: CommonDisplayDTO;
 	/**
 	 * @type string
 	 */
 	duration?: string;
 	/**
-	 * @type array
+	 * @type array,null
 	 */
-	layouts: DashboardtypesLayoutDTO[];
+	layouts?: DashboardtypesLayoutDTO[] | null;
 	/**
 	 * @type array
 	 */
 	links?: DashboardLinkDTO[];
 	/**
-	 * @type object
+	 * @type object,null
 	 */
-	panels: DashboardtypesDashboardSpecDTOPanels;
+	panels?: DashboardtypesDashboardSpecDTOPanels;
 	/**
 	 * @type string
 	 */
@@ -4632,13 +4619,13 @@ export interface DashboardtypesDashboardSpecDTO {
 	/**
 	 * @type array
 	 */
-	variables: DashboardtypesVariableDTO[];
+	variables?: DashboardtypesVariableDTO[];
 }
 
 export enum DashboardtypesDatasourcePluginKindDTO {
 	'signoz/Datasource' = 'signoz/Datasource',
 }
-export interface TagtypesGettableTagDTO {
+export interface TagtypesPostableTagDTO {
 	/**
 	 * @type string
 	 */
@@ -4688,7 +4675,7 @@ export interface DashboardtypesGettableDashboardV2DTO {
 	/**
 	 * @type array,null
 	 */
-	tags: TagtypesGettableTagDTO[] | null;
+	tags: TagtypesPostableTagDTO[] | null;
 	/**
 	 * @type string
 	 * @format date-time
@@ -4746,157 +4733,6 @@ export interface DashboardtypesJSONPatchOperationDTO {
 	value?: unknown;
 }
 
-export enum DashboardtypesListOrderDTO {
-	asc = 'asc',
-	desc = 'desc',
-}
-export enum DashboardtypesListSortDTO {
-	updated_at = 'updated_at',
-	created_at = 'created_at',
-	name = 'name',
-}
-export interface DashboardtypesListedDashboardV2SpecDTO {
-	display?: DashboardtypesDisplayDTO;
-}
-
-export interface DashboardtypesListedDashboardForUserV2DTO {
-	/**
-	 * @type string
-	 * @format date-time
-	 */
-	createdAt?: string;
-	/**
-	 * @type string
-	 */
-	createdBy?: string;
-	/**
-	 * @type string
-	 */
-	id: string;
-	/**
-	 * @type string
-	 */
-	image?: string;
-	/**
-	 * @type boolean
-	 */
-	locked: boolean;
-	/**
-	 * @type string
-	 */
-	name: string;
-	/**
-	 * @type string
-	 */
-	orgId: string;
-	/**
-	 * @type boolean
-	 */
-	pinned: boolean;
-	/**
-	 * @type string
-	 */
-	schemaVersion: string;
-	source: DashboardtypesSourceDTO;
-	spec: DashboardtypesListedDashboardV2SpecDTO;
-	/**
-	 * @type array
-	 */
-	tags: TagtypesGettableTagDTO[];
-	/**
-	 * @type string
-	 * @format date-time
-	 */
-	updatedAt?: string;
-	/**
-	 * @type string
-	 */
-	updatedBy?: string;
-}
-
-export interface DashboardtypesListableDashboardForUserV2DTO {
-	/**
-	 * @type array
-	 */
-	dashboards: DashboardtypesListedDashboardForUserV2DTO[];
-	/**
-	 * @type array
-	 */
-	tags: TagtypesGettableTagDTO[];
-	/**
-	 * @type integer
-	 * @format int64
-	 */
-	total: number;
-}
-
-export interface DashboardtypesListedDashboardV2DTO {
-	/**
-	 * @type string
-	 * @format date-time
-	 */
-	createdAt?: string;
-	/**
-	 * @type string
-	 */
-	createdBy?: string;
-	/**
-	 * @type string
-	 */
-	id: string;
-	/**
-	 * @type string
-	 */
-	image?: string;
-	/**
-	 * @type boolean
-	 */
-	locked: boolean;
-	/**
-	 * @type string
-	 */
-	name: string;
-	/**
-	 * @type string
-	 */
-	orgId: string;
-	/**
-	 * @type string
-	 */
-	schemaVersion: string;
-	source: DashboardtypesSourceDTO;
-	spec: DashboardtypesListedDashboardV2SpecDTO;
-	/**
-	 * @type array
-	 */
-	tags: TagtypesGettableTagDTO[];
-	/**
-	 * @type string
-	 * @format date-time
-	 */
-	updatedAt?: string;
-	/**
-	 * @type string
-	 */
-	updatedBy?: string;
-}
-
-export interface DashboardtypesListableDashboardV2DTO {
-	/**
-	 * @type array
-	 */
-	dashboards: DashboardtypesListedDashboardV2DTO[];
-	/**
-	 * @type array
-	 */
-	tags: TagtypesGettableTagDTO[];
-	/**
-	 * @type integer
-	 * @format int64
-	 */
-	total: number;
-}
-
 export enum DashboardtypesPanelPluginKindDTO {
 	'signoz/TimeSeriesPanel' = 'signoz/TimeSeriesPanel',
 	'signoz/BarChartPanel' = 'signoz/BarChartPanel',
@@ -4913,17 +4749,6 @@ export type DashboardtypesPatchableDashboardV2DTO =
 	| DashboardtypesJSONPatchOperationDTO[]
 	| null;
 
-export interface TagtypesPostableTagDTO {
-	/**
-	 * @type string
-	 */
-	key: string;
-	/**
-	 * @type string
-	 */
-	value: string;
-}
-
 export interface DashboardtypesPostableDashboardV2DTO {
 	/**
 	 * @type boolean
@@ -9826,40 +9651,6 @@ export type GetUserPreference200 = {
 export type UpdateUserPreferencePathParameters = {
 	name: string;
 };
-export type ListDashboardsV2Params = {
-	/**
-	 * @type string
-	 * @description undefined
-	 */
-	query?: string;
-	/**
-	 * @description undefined
-	 */
-	sort?: DashboardtypesListSortDTO;
-	/**
-	 * @description undefined
-	 */
-	order?: DashboardtypesListOrderDTO;
-	/**
-	 * @type integer
-	 * @description undefined
-	 */
-	limit?: number;
-	/**
-	 * @type integer
-	 * @description undefined
-	 */
-	offset?: number;
-};
-
-export type ListDashboardsV2200 = {
-	data: DashboardtypesListableDashboardV2DTO;
-	/**
-	 * @type string
-	 */
-	status: string;
-};
-
 export type CreateDashboardV2201 = {
 	data: DashboardtypesGettableDashboardV2DTO;
 	/**
@@ -9868,9 +9659,6 @@ export type CreateDashboardV2201 = {
 	status: string;
 };
 
-export type DeleteDashboardV2PathParameters = {
-	id: string;
-};
 export type GetDashboardV2PathParameters = {
 	id: string;
 };
@@ -10703,46 +10491,6 @@ export type GetMyUser200 = {
 	status: string;
 };
 
-export type ListDashboardsForUserV2Params = {
-	/**
-	 * @type string
-	 * @description undefined
-	 */
-	query?: string;
-	/**
-	 * @description undefined
-	 */
-	sort?: DashboardtypesListSortDTO;
-	/**
-	 * @description undefined
-	 */
-	order?: DashboardtypesListOrderDTO;
-	/**
-	 * @type integer
-	 * @description undefined
-	 */
-	limit?: number;
-	/**
-	 * @type integer
-	 * @description undefined
-	 */
-	offset?: number;
-};
-
-export type ListDashboardsForUserV2200 = {
-	data: DashboardtypesListableDashboardForUserV2DTO;
-	/**
-	 * @type string
-	 */
-	status: string;
-};
-
-export type UnpinDashboardV2PathParameters = {
-	id: string;
-};
-export type PinDashboardV2PathParameters = {
-	id: string;
-};
 export type GetHosts200 = {
 	data: ZeustypesGettableHostDTO;
 	/**

frontend/src/components/QueryBuilderV2/QueryV2/QuerySearch/QuerySearch.styles.scss

@@ -1,11 +1,5 @@
 // TODO: Improve the styling of the query aggregation container and its components. - @YounixM , @H4ad
 
-$dropdown-base-height: 250px;
-$recents-header-height: 30px;
-$recent-row-height: 36px;
-// how many recents are rendered, this caps how tall the dropdown can grow to fit them.
-$max-recents-shown: 5;
-
 .code-mirror-where-clause {
 	width: 100%;
 	display: flex;
@@ -123,23 +117,7 @@ $max-recents-shown: 5;
 				width: 100% !important;
 				max-width: 100% !important;
 				font-family: 'Space Mono', monospace !important;
-				max-height: $dropdown-base-height !important;
-				overflow-y: auto !important;
-
-				// Recents render at the top of the dropdown ahead of regular suggestions.
-				// At the base max-height, having recents in view would crowd out the
-				// suggestion list below. This loop grows the dropdown by one row's worth
-				// of height for every recent present (up to $max-recents-shown), plus the
-				// section header. `:has(> li:nth-of-type(N) .cm-completionIcon-recent)`
-				// matches when the Nth child of <ul> is a recent — i.e. there are at
-				// least N recents visible.
-				@for $i from 1 through $max-recents-shown {
-					&:has(> li:nth-of-type(#{$i}) .cm-completionIcon-recent) {
-						max-height: $dropdown-base-height +
-							$recents-header-height +
-							($i * $recent-row-height) !important;
-					}
-				}
+				min-height: 200px !important;
 
 				&::-webkit-scrollbar {
 					width: 0.3rem;
@@ -155,19 +133,6 @@ $max-recents-shown: 5;
 					background: transparent;
 				}
 
-				completion-section {
-					display: block;
-					padding: 10px 12px 6px;
-					font-size: 10px !important;
-					font-weight: 700;
-					letter-spacing: 0.08em;
-					text-transform: uppercase;
-					color: var(--l3-foreground, var(--l2-foreground));
-					opacity: 0.7;
-					border-bottom: 0;
-					background-color: transparent;
-				}
-
 				li {
 					width: 100% !important;
 					max-width: 100% !important;
@@ -194,78 +159,11 @@ $max-recents-shown: 5;
 						display: none !important;
 					}
 
-					.cm-completionDetail {
-						margin-left: auto;
-						font-style: normal;
-						font-size: var(--periscope-font-size-small, 11px);
-						font-weight: 600;
-						letter-spacing: 0.06em;
-						text-transform: uppercase;
-						opacity: 0.55;
-					}
-
 					&[aria-selected='true'] {
 						background: var(--l3-background) !important;
 						font-weight: 600 !important;
 					}
 				}
-
-				li:has(.cm-completionIcon-recent) {
-					&:hover .cm-recent-delete,
-					&[aria-selected='true'] .cm-recent-delete {
-						opacity: 1;
-					}
-				}
-
-				li .cm-completionLabel {
-					flex: 1;
-					min-width: 0;
-					white-space: nowrap;
-					overflow: hidden;
-					text-overflow: ellipsis;
-				}
-
-				.cm-recent-delete {
-					margin-left: 8px;
-					display: inline-flex;
-					align-items: center;
-					justify-content: center;
-					width: 20px;
-					height: 20px;
-					padding: 0;
-					border: 0;
-					border-radius: 4px;
-					background: transparent;
-					color: var(--l2-foreground);
-					font-size: 18px;
-					line-height: 1;
-					cursor: pointer;
-					opacity: 0.5;
-					transition:
-						opacity 0.12s ease,
-						background-color 0.12s ease;
-
-					&:hover {
-						opacity: 1;
-						background: color-mix(in srgb, var(--l2-foreground) 18%, transparent);
-					}
-				}
-			}
-
-			&::after {
-				content: '↓↑ to navigate · ↵ to apply · esc to dismiss';
-				display: block;
-				padding: 8px 12px;
-				border-top: 1px solid var(--l1-border);
-				font-family: 'Space Mono', monospace;
-				font-size: 11px;
-				font-weight: 500;
-				letter-spacing: 0.02em;
-				color: var(--l2-foreground);
-				opacity: 0.6;
-				background: color-mix(in srgb, var(--l1-background) 50%, transparent);
-				border-bottom-left-radius: 4px;
-				border-bottom-right-radius: 4px;
 			}
 		}
 

frontend/src/components/QueryBuilderV2/QueryV2/QuerySearch/QuerySearch.tsx

@@ -46,15 +46,8 @@ import {
 import { validateQuery } from 'utils/queryValidationUtils';
 import { unquote } from 'utils/stringUtils';
 
-import { getRecentQueries } from 'lib/recentQueries/getRecentQueries';
-import type { SignalType } from 'types/api/v5/queryRange';
-
-import { queryExamples, SUGGESTIONS_SECTION } from './constants';
-import {
-	combineInitialAndUserExpression,
-	getRecentOptions,
-	renderRecentDeleteButton,
-} from './utils';
+import { queryExamples } from './constants';
+import { combineInitialAndUserExpression } from './utils';
 
 import './QuerySearch.styles.scss';
 
@@ -1257,41 +1250,6 @@ function QuerySearch({
 		};
 	}
 
-	const signal = dataSource as SignalType;
-
-	function combinedSuggestions(
-		context: CompletionContext,
-	): CompletionResult | null {
-		const fullDoc = context.state.doc.toString();
-		const recentOptions = getRecentOptions(
-			getRecentQueries(signal, signalSource ?? ''),
-			fullDoc,
-		);
-		const result = autoSuggestions(context);
-
-		const suggestionOptions = (result?.options || []).map((opt) => ({
-			...opt,
-			section: SUGGESTIONS_SECTION,
-		}));
-
-		if (recentOptions.length === 0 && suggestionOptions.length === 0) {
-			return result;
-		}
-
-		if (!result) {
-			return {
-				from: 0,
-				to: fullDoc.length,
-				options: recentOptions,
-			};
-		}
-
-		return {
-			...result,
-			options: [...recentOptions, ...suggestionOptions],
-		};
-	}
-
 	// Effect to handle focus state and trigger suggestions
 	useEffect(() => {
 		const clearTimeout = toggleSuggestions(10);
@@ -1440,12 +1398,11 @@ function QuerySearch({
 					})}
 					extensions={[
 						autocompletion({
-							override: [combinedSuggestions],
+							override: [autoSuggestions],
 							defaultKeymap: true,
 							closeOnBlur: true,
 							activateOnTyping: true,
 							maxRenderedOptions: 50,
-							addToOptions: [{ render: renderRecentDeleteButton, position: 100 }],
 						}),
 						javascript({ jsx: false, typescript: false }),
 						EditorView.lineWrapping,

frontend/src/components/QueryBuilderV2/QueryV2/QuerySearch/constants.ts

@@ -1,14 +1,3 @@
-export const RECENTS_SECTION = { name: 'Recent searches', rank: 1 } as const;
-export const SUGGESTIONS_SECTION = { name: 'Suggestions', rank: 2 } as const;
-
-// Custom CodeMirror Completion.type for recent-query entries. Used to discriminate
-// recents from regular autocomplete completions in renderers and event handlers.
-export const RECENT_COMPLETION_TYPE = 'recent';
-
-// Max number of recents rendered in the autocomplete dropdown.
-//  Do change $max-recents-shown: in QuerySearch.styles.scss if you change this.
-export const RECENTS_DISPLAY_CAP = 5;
-
 export const queryExamples = [
 	{
 		label: 'Basic Query',

frontend/src/components/QueryBuilderV2/QueryV2/QuerySearch/utils.ts

@@ -1,19 +1,3 @@
-import { closeCompletion, startCompletion } from '@codemirror/autocomplete';
-import type { Completion } from '@codemirror/autocomplete';
-import type { EditorView } from '@uiw/react-codemirror';
-import dayjs from 'dayjs';
-import { normalizeFilterExpression } from 'lib/recentQueries/normalize';
-import * as recentQueriesStore from 'lib/recentQueries/recentQueriesStore';
-import type { RecentQueryEntry } from 'lib/recentQueries/types';
-import type { SignalType } from 'types/api/v5/queryRange';
-import 'utils/timeUtils';
-
-import {
-	RECENT_COMPLETION_TYPE,
-	RECENTS_DISPLAY_CAP,
-	RECENTS_SECTION,
-} from './constants';
-
 export function combineInitialAndUserExpression(
 	initial: string,
 	user: string,
@@ -54,106 +38,3 @@ export function getUserExpressionFromCombined(
 	}
 	return c;
 }
-
-// Filters and projects a list of recent-query entries into CodeMirror completions.
-// Entries are supplied by the caller (typically via the useRecents hook) so this
-// function stays pure and React doesn't have to re-subscribe inside CodeMirror's
-// autocomplete callback.
-export function getRecentOptions(
-	entries: RecentQueryEntry[],
-	fullDoc: string,
-): Completion[] {
-	const normalizedDoc = normalizeFilterExpression(fullDoc);
-
-	const matches = entries
-		.filter((e) => {
-			const normalizedRecent = normalizeFilterExpression(e.filter.expression);
-			if (normalizedRecent === normalizedDoc) {
-				return false;
-			}
-			if (normalizedDoc === '') {
-				return true;
-			}
-			return normalizedRecent.includes(normalizedDoc);
-		})
-		.slice(0, RECENTS_DISPLAY_CAP);
-
-	return matches.map((entry, index) => ({
-		label: entry.filter.expression,
-		type: RECENT_COMPLETION_TYPE,
-		// CodeMirror sorts within a section by boost desc, then label asc. The store
-		// returns entries newest-first, so we mirror that by giving the newest entry
-		// the highest boost — otherwise CM falls back to alphabetical order and the
-		// "most recently used" expectation breaks. Stays within the recents section
-		// because section.rank keeps recents above suggestions regardless of boost.
-		boost: matches.length - index,
-		section: RECENTS_SECTION,
-		detail: dayjs(entry.lastUsedAt).fromNow(),
-		recentId: entry.id,
-		recentSignal: entry.signal,
-		recentSource: entry.source,
-		apply: (view: EditorView): void => {
-			view.dispatch({
-				changes: {
-					from: 0,
-					to: view.state.doc.length,
-					insert: entry.filter.expression,
-				},
-				selection: { anchor: entry.filter.expression.length },
-			});
-			closeCompletion(view);
-		},
-	}));
-}
-
-export function renderRecentDeleteButton(
-	completion: Completion,
-	_state: unknown,
-	view: EditorView | null,
-): Node | null {
-	if (completion.type !== RECENT_COMPLETION_TYPE) {
-		return null;
-	}
-
-	const c = completion as Completion & {
-		recentId?: string;
-		recentSignal?: SignalType;
-		recentSource?: string;
-	};
-
-	const btn = document.createElement('button');
-	btn.type = 'button';
-	btn.className = 'cm-recent-delete';
-	btn.setAttribute('aria-label', 'Remove from recent searches');
-	btn.title = 'Remove from recent searches';
-	btn.textContent = '×';
-	queueMicrotask(() => {
-		if (btn.parentElement) {
-			btn.parentElement.title = completion.label;
-		}
-	});
-
-	const stop = (e: Event): void => {
-		e.preventDefault();
-		e.stopPropagation();
-	};
-	// CodeMirror's autocomplete closes the popup on pointerdown / mousedown outside
-	// the editor. The delete button lives inside the popup, so we must stop those
-	// events early — otherwise clicking × would dismiss the dropdown before the
-	// click handler fires and the entry wouldn't actually get removed.
-	btn.addEventListener('pointerdown', stop);
-	btn.addEventListener('mousedown', stop);
-	btn.addEventListener('click', (e) => {
-		stop(e);
-		if (!c.recentId || !c.recentSignal) {
-			return;
-		}
-		recentQueriesStore.remove(c.recentId, c.recentSignal, c.recentSource ?? '');
-		if (view) {
-			view.focus();
-			startCompletion(view);
-		}
-	});
-
-	return btn;
-}

frontend/src/constants/queryBuilderOperators.ts

@@ -6,10 +6,6 @@ import {
 import { SelectOption } from 'types/common/select';
 
 export const metricAggregateOperatorOptions: SelectOption<string, string>[] = [
-	{
-		value: MetricAggregateOperator.NOOP,
-		label: 'No aggregation',
-	},
 	{
 		value: MetricAggregateOperator.COUNT,
 		label: 'Count',

frontend/src/constants/reactQueryKeys.ts

@@ -36,7 +36,6 @@ export const REACT_QUERY_KEY = {
 	GET_TRACE_V4_WATERFALL: 'GET_TRACE_V4_WATERFALL',
 	GET_TRACE_AGGREGATIONS: 'GET_TRACE_AGGREGATIONS',
 	GET_TRACE_V2_FLAMEGRAPH: 'GET_TRACE_V2_FLAMEGRAPH',
-	GET_TRACE_V3_FLAMEGRAPH: 'GET_TRACE_V3_FLAMEGRAPH',
 	GET_POD_LIST: 'GET_POD_LIST',
 	GET_NODE_LIST: 'GET_NODE_LIST',
 	GET_DEPLOYMENT_LIST: 'GET_DEPLOYMENT_LIST',

frontend/src/container/AIAssistant/getAutoContexts.ts

@@ -1,7 +1,6 @@
 import type { MessageContext } from 'api/ai-assistant/chat';
 import { QueryParams } from 'constants/query';
 import ROUTES from 'constants/routes';
-import { deserialize } from 'lib/compositeQuery/serializer';
 import { matchPath } from 'react-router-dom';
 
 /**
@@ -295,11 +294,11 @@ function collectSharedMetadata(
 	// Query Builder state — URL-encoded JSON written by `QueryBuilderProvider`.
 	const compositeQueryRaw = params.get(QueryParams.compositeQuery);
 	if (compositeQueryRaw) {
-		// Decode through the serializer seam (handles every tier + malformed
-		// input → null); never JSON.parse the raw URL value.
-		const decodedQuery = deserialize(compositeQueryRaw);
-		if (decodedQuery) {
-			out.query = decodedQuery;
+		try {
+			out.query = JSON.parse(decodeURIComponent(compositeQueryRaw));
+		} catch {
+			// Malformed JSON in the URL — drop silently rather than throw
+			// inside a context-collection helper.
 		}
 	}
 

frontend/src/container/AIAssistant/hooks/useSpeechRecognition.ts

@@ -40,31 +40,13 @@ type SpeechRecognitionConstructor = new () => ISpeechRecognition;
 
 // ── Vendor-prefix shim for Safari / older browsers ────────────────────────────
 
-// Some hardened/enterprise browsers install a getter
-// on window.SpeechRecognition that THROWS on access ("Web Speech API is disabled
-// due to your security policy") instead of leaving the property undefined.
-// Because this resolves at module-evaluation time, an uncaught throw here aborts
-// the entire bundle and the app renders a blank page. Read defensively so a
-// throwing getter degrades to "unsupported" rather than crashing the app.
-function resolveSpeechRecognitionAPI(): SpeechRecognitionConstructor | null {
-	if (typeof window === 'undefined') {
-		return null;
-	}
-	try {
-		return (
-			// eslint-disable-next-line @typescript-eslint/no-explicit-any
-			(window as any).SpeechRecognition ??
-			// eslint-disable-next-line @typescript-eslint/no-explicit-any
-			(window as any).webkitSpeechRecognition ??
-			null
-		);
-	} catch {
-		return null;
-	}
-}
-
 const SpeechRecognitionAPI: SpeechRecognitionConstructor | null =
-	resolveSpeechRecognitionAPI();
+	typeof window !== 'undefined'
+		? // eslint-disable-next-line @typescript-eslint/no-explicit-any
+			((window as any).SpeechRecognition ??
+			(window as any).webkitSpeechRecognition ??
+			null)
+		: null;
 
 export type SpeechRecognitionError =
 	| 'not-supported'

frontend/src/container/InfraMonitoringK8s/Clusters/constants.ts

@@ -796,7 +796,7 @@ export const getClusterMetricsQueryPayload = (
 								key: k8sDeploymentDesiredKey,
 								type: 'Gauge',
 							},
-							aggregateOperator: 'latest',
+							aggregateOperator: 'avg',
 							dataSource: DataSource.METRICS,
 							disabled: false,
 							expression: 'B',
@@ -839,7 +839,7 @@ export const getClusterMetricsQueryPayload = (
 							reduceTo: ReduceOperators.LAST,
 							spaceAggregation: 'sum',
 							stepInterval: 60,
-							timeAggregation: 'latest',
+							timeAggregation: 'avg',
 						},
 					],
 					queryFormulas: [],

frontend/src/container/InfraMonitoringK8s/EntityDetailsUtils/EntityEvents/EntityEvents.tsx

@@ -40,7 +40,6 @@ import { K8S_ENTITY_EVENTS_EXPRESSION_KEY, useEntityEvents } from './hooks';
 import { getEntityEventsQueryPayload, isEventsKeyNotFoundError } from './utils';
 
 import styles from './EntityEvents.module.scss';
-import { useTimezone } from 'providers/Timezone';
 
 interface EventDataType {
 	key: string;
@@ -168,25 +167,17 @@ function EntityEventsContent({
 		[events],
 	);
 
-	const { formatTimezoneAdjustedTimestamp } = useTimezone();
-	const columns: TableColumnsType<EventDataType> = useMemo(
-		() => [
-			{ title: 'Severity', dataIndex: 'severity', key: 'severity', width: 100 },
-			{
-				title: 'Timestamp',
-				dataIndex: 'timestamp',
-				width: 240,
-				ellipsis: true,
-				key: 'timestamp',
-				render: (value: string | number): string =>
-					formatTimezoneAdjustedTimestamp(
-						typeof value === 'string' ? value : value / 1e6,
-					),
-			},
-			{ title: 'Body', dataIndex: 'body', key: 'body' },
-		],
-		[formatTimezoneAdjustedTimestamp],
-	);
+	const columns: TableColumnsType<EventDataType> = [
+		{ title: 'Severity', dataIndex: 'severity', key: 'severity', width: 100 },
+		{
+			title: 'Timestamp',
+			dataIndex: 'timestamp',
+			width: 240,
+			ellipsis: true,
+			key: 'timestamp',
+		},
+		{ title: 'Body', dataIndex: 'body', key: 'body' },
+	];
 
 	const handleExpandRowIcon = ({
 		expanded,

frontend/src/container/InfraMonitoringK8s/EntityDetailsUtils/EntityTraces/EntityTraces.tsx

@@ -41,7 +41,6 @@ import { getTraceListColumns } from './traceListColumns';
 import { getEntityTracesQueryPayload } from './utils';
 
 import styles from './EntityTraces.module.scss';
-import { useTimezone } from 'providers/Timezone';
 
 interface Props {
 	timeRange: {
@@ -137,11 +136,7 @@ function EntityTracesContent({
 		[timeRange.startTime, timeRange.endTime, userExpression],
 	);
 
-	const { formatTimezoneAdjustedTimestamp } = useTimezone();
-	const traceListColumns = getTraceListColumns(
-		selectedEntityTracesColumns,
-		formatTimezoneAdjustedTimestamp,
-	);
+	const traceListColumns = getTraceListColumns(selectedEntityTracesColumns);
 
 	const isKeyNotFound = isKeyNotFoundError(error);
 	const isDataEmpty =

frontend/src/container/InfraMonitoringK8s/EntityDetailsUtils/EntityTraces/traceListColumns.tsx

@@ -1,14 +1,15 @@
 import { TableColumnsType as ColumnsType } from 'antd';
 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 dayjs from 'dayjs';
 import { RowData } from 'lib/query/createTableColumnsFromQuery';
 import { BaseAutocompleteData } from 'types/api/queryBuilder/queryAutocompleteResponse';
-import { FormatTimezoneAdjustedTimestamp } from 'hooks/useTimezoneFormatter/useTimezoneFormatter';
 
 const keyToLabelMap: Record<string, string> = {
 	timestamp: 'Timestamp',
@@ -58,7 +59,6 @@ const getValueForKey = (data: Record<string, any>, key: string): any => {
 
 export const getTraceListColumns = (
 	selectedColumns: BaseAutocompleteData[],
-	formatTimezoneAdjustedTimestamp: FormatTimezoneAdjustedTimestamp,
 ): ColumnsType<RowData> => {
 	const columns: ColumnsType<RowData> =
 		selectedColumns.map(({ dataType, key, type }) => ({
@@ -73,8 +73,8 @@ export const getTraceListColumns = (
 				if (primaryKey === 'timestamp') {
 					const date =
 						typeof value === 'string'
-							? formatTimezoneAdjustedTimestamp(value)
-							: formatTimezoneAdjustedTimestamp(value / 1e6);
+							? dayjs(value).format(DATE_TIME_FORMATS.ISO_DATETIME_MS)
+							: dayjs(value / 1e6).format(DATE_TIME_FORMATS.ISO_DATETIME_MS);
 
 					return (
 						<BlockLink to={getTraceLink(itemData)} openInNewTab>

frontend/src/container/InfraMonitoringK8s/Pods/constants.ts

@@ -1366,7 +1366,7 @@ export const getPodMetricsQueryPayload = (
 							orderBy: [],
 							queryName: 'B',
 							reduceTo: ReduceOperators.AVG,
-							spaceAggregation: 'sum',
+							spaceAggregation: 'avg',
 							stepInterval: 60,
 							timeAggregation: 'avg',
 						},

frontend/src/container/ResetPassword/ResetPassword.styles.scss

@@ -142,15 +142,6 @@
 		}
 	}
 
-	.reset-password-back-action {
-		margin-top: var(--spacing-12);
-		width: 100%;
-
-		button {
-			width: 100%;
-		}
-	}
-
 	@media (max-width: 768px) {
 		width: 100%;
 		padding: 0 16px;

frontend/src/container/ResetPassword/TokenError.tsx

@@ -1,10 +1,7 @@
-import { ArrowLeft, CircleAlert } from '@signozhq/icons';
-import { Button } from '@signozhq/ui/button';
+import { CircleAlert } from '@signozhq/icons';
 import { Typography } from '@signozhq/ui/typography';
 import AuthError from 'components/AuthError/AuthError';
 import AuthPageContainer from 'components/AuthPageContainer';
-import ROUTES from 'constants/routes';
-import history from 'lib/history';
 import APIError from 'types/api/error';
 
 import './ResetPassword.styles.scss';
@@ -62,16 +59,6 @@ function TokenError({ error }: TokenErrorProps): JSX.Element {
 					</Typography.Text>
 				</div>
 				{error && <AuthError error={error} />}
-				<div className="reset-password-back-action">
-					<Button
-						variant="solid"
-						data-testid="back-to-login"
-						prefix={<ArrowLeft size={12} />}
-						onClick={(): void => history.push(ROUTES.LOGIN)}
-					>
-						Back to login
-					</Button>
-				</div>
 			</div>
 		</AuthPageContainer>
 	);

frontend/src/container/SideNav/SideNav.styles.scss

@@ -119,10 +119,6 @@
 
 				border-radius: 0px 4px 4px 0px;
 				background: var(--l3-background);
-
-				&.version-container-standalone {
-					border-radius: 4px;
-				}
 			}
 
 			.version {

frontend/src/container/SideNav/SideNav.tsx

@@ -1010,7 +1010,7 @@ function SideNav({ isPinned }: { isPinned: boolean }): JSX.Element {
 								<img src={signozBrandLogoUrl} alt="SigNoz" />
 							</div>
 
-							{(licenseTag || currentVersion) && (
+							{licenseTag && (
 								<div
 									className={cx(
 										'brand-title-section',
@@ -1021,7 +1021,7 @@ function SideNav({ isPinned }: { isPinned: boolean }): JSX.Element {
 											'version-update-notification',
 									)}
 								>
-									{licenseTag && <span className="license-type"> {licenseTag} </span>}
+									<span className="license-type"> {licenseTag} </span>
 
 									{currentVersion && (
 										<Tooltip
@@ -1043,12 +1043,7 @@ function SideNav({ isPinned }: { isPinned: boolean }): JSX.Element {
 												)
 											}
 										>
-											<div
-												className={cx(
-													'version-container',
-													!licenseTag && 'version-container-standalone',
-												)}
-											>
+											<div className="version-container">
 												<span
 													className={cx('version', changelog && 'version-clickable')}
 													onClick={onClickVersionHandler}

frontend/src/container/TopNav/DateTimeSelectionV2/index.tsx

@@ -35,7 +35,6 @@ import { GlobalReducer } from 'types/reducer/globalTime';
 import { addCustomTimeRange } from 'utils/customTimeRangeUtils';
 import { persistTimeDurationForRoute } from 'utils/metricsTimeStorageUtils';
 import { normalizeTimeToMs } from 'utils/timeUtils';
-import { serialize } from 'lib/compositeQuery/serializer';
 import { v4 as uuid } from 'uuid';
 
 import AutoRefresh from '../AutoRefreshV2';
@@ -300,7 +299,7 @@ function DateTimeSelection({
 				})),
 			},
 		};
-		return serialize(updatedCompositeQuery);
+		return encodeURIComponent(JSON.stringify(updatedCompositeQuery));
 	}, [currentQuery]);
 
 	const onSelectHandler = useCallback(

frontend/src/hooks/queryBuilder/__tests__/useGetCompositeQueryParam.test.ts

@@ -1,26 +0,0 @@
-import { renderHook } from '@testing-library/react';
-import { initialQueriesMap } from 'constants/queryBuilder';
-import { useGetCompositeQueryParam } from 'hooks/queryBuilder/useGetCompositeQueryParam';
-
-let mockUrlQuery = new URLSearchParams();
-
-jest.mock('hooks/useUrlQuery', () => ({
-	__esModule: true,
-	default: (): URLSearchParams => mockUrlQuery,
-}));
-
-describe('useGetCompositeQueryParam', () => {
-	it('decodes a legacy compositeQuery param', () => {
-		mockUrlQuery = new URLSearchParams({
-			compositeQuery: encodeURIComponent(JSON.stringify(initialQueriesMap.logs)),
-		});
-		const { result } = renderHook(() => useGetCompositeQueryParam());
-		expect(result.current?.builder.queryData[0].dataSource).toBe('logs');
-	});
-
-	it('returns null when the param is absent', () => {
-		mockUrlQuery = new URLSearchParams();
-		const { result } = renderHook(() => useGetCompositeQueryParam());
-		expect(result.current).toBeNull();
-	});
-});

frontend/src/hooks/queryBuilder/useGetCompositeQueryParam.ts

@@ -1,7 +1,12 @@
+import { useMemo } from 'react';
+import {
+	convertAggregationToExpression,
+	convertFiltersToExpressionWithExistingQuery,
+	convertHavingToExpression,
+} from 'components/QueryBuilderV2/utils';
 import { QueryParams } from 'constants/query';
 import useUrlQuery from 'hooks/useUrlQuery';
-import { deserialize } from 'lib/compositeQuery/serializer';
-import { useMemo } from 'react';
+import { BaseAutocompleteData } from 'types/api/queryBuilder/queryAutocompleteResponse';
 import { Query } from 'types/api/queryBuilder/queryBuilderData';
 
 export const useGetCompositeQueryParam = (): Query | null => {
@@ -9,9 +14,59 @@ export const useGetCompositeQueryParam = (): Query | null => {
 
 	return useMemo(() => {
 		const compositeQuery = urlQuery.get(QueryParams.compositeQuery);
-		if (!compositeQuery) {
-			return null;
+		let parsedCompositeQuery: Query | null = null;
+
+		try {
+			if (!compositeQuery) {
+				return null;
+			}
+
+			// MDN reference - https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/decodeURIComponent#decoding_query_parameters_from_a_url
+			// MDN reference to support + characters using encoding - https://developer.mozilla.org/en-US/docs/Web/API/URLSearchParams#preserving_plus_signs add later
+			parsedCompositeQuery = JSON.parse(
+				decodeURIComponent(compositeQuery.replace(/\+/g, ' ')),
+			);
+
+			// Convert old format to new format for each query in builder.queryData
+			if (parsedCompositeQuery?.builder?.queryData) {
+				parsedCompositeQuery.builder.queryData =
+					parsedCompositeQuery.builder.queryData.map((query) => {
+						const existingExpression = query.filter?.expression || '';
+						const convertedQuery = { ...query };
+
+						const convertedFilter = convertFiltersToExpressionWithExistingQuery(
+							query.filters || { items: [], op: 'AND' },
+							existingExpression,
+						);
+						convertedQuery.filter = convertedFilter.filter;
+						convertedQuery.filters = convertedFilter.filters;
+
+						// Convert having if needed
+						if (Array.isArray(query.having)) {
+							const convertedHaving = convertHavingToExpression(query.having);
+							convertedQuery.having = convertedHaving;
+						}
+
+						// Convert aggregation if needed
+						if (!query.aggregations && query.aggregateOperator) {
+							const convertedAggregation = convertAggregationToExpression({
+								aggregateOperator: query.aggregateOperator,
+								aggregateAttribute: query.aggregateAttribute as BaseAutocompleteData,
+								dataSource: query.dataSource,
+								timeAggregation: query.timeAggregation,
+								spaceAggregation: query.spaceAggregation,
+								reduceTo: query.reduceTo,
+								temporality: query.temporality,
+							}) as any; // Type assertion to handle union type
+							convertedQuery.aggregations = convertedAggregation;
+						}
+						return convertedQuery;
+					});
+			}
+		} catch (e) {
+			parsedCompositeQuery = null;
 		}
-		return deserialize(compositeQuery);
+
+		return parsedCompositeQuery;
 	}, [urlQuery]);
 };

frontend/src/hooks/trace/useGetTraceFlamegraphV3.tsx

@@ -1,42 +0,0 @@
-import { getFlamegraph } from 'api/generated/services/tracedetail';
-import {
-	SpantypesGettableFlamegraphTraceDTO,
-	TelemetrytypesTelemetryFieldKeyDTO,
-} from 'api/generated/services/sigNoz.schemas';
-import { REACT_QUERY_KEY } from 'constants/reactQueryKeys';
-import { useQuery, UseQueryResult } from 'react-query';
-import { TelemetryFieldKey } from 'types/api/v5/queryRange';
-
-export interface GetTraceFlamegraphV3Props {
-	traceId: string;
-	selectedSpanId?: string;
-	selectFields?: TelemetryFieldKey[];
-	enabled?: boolean;
-}
-
-const useGetTraceFlamegraphV3 = (
-	props: GetTraceFlamegraphV3Props,
-): UseQueryResult<SpantypesGettableFlamegraphTraceDTO, unknown> =>
-	useQuery({
-		queryFn: () =>
-			getFlamegraph(
-				{ traceID: props.traceId },
-				{
-					selectedSpanId: props.selectedSpanId,
-					// v5 TelemetryFieldKey and the generated DTO are runtime-identical; only
-					// the literal-union vs enum nominal types differ
-					selectFields: props.selectFields as TelemetrytypesTelemetryFieldKeyDTO[],
-				},
-			).then((res) => res.data),
-		queryKey: [
-			REACT_QUERY_KEY.GET_TRACE_V3_FLAMEGRAPH,
-			props.traceId,
-			props.selectedSpanId,
-			props.selectFields,
-		],
-		enabled: props.enabled,
-		keepPreviousData: true,
-		refetchOnWindowFocus: false,
-	});
-
-export default useGetTraceFlamegraphV3;

frontend/src/hooks/useSafeNavigate.ts

@@ -1,7 +1,6 @@
-import { deserialize } from 'lib/compositeQuery/serializer';
-import { isEqual } from 'lodash-es';
 import { useCallback } from 'react';
 import { useLocation, useNavigate } from 'react-router-dom-v5-compat';
+import { cloneDeep, isEqual } from 'lodash-es';
 import { withBasePath } from 'utils/basePath';
 
 interface NavigateOptions {
@@ -39,20 +38,16 @@ const areUrlsEffectivelySame = (url1: URL, url2: URL): boolean => {
 					return false;
 				}
 
-				// Decode through the serializer seam: the URL value may be in any
-				// tier (legacy JSON or a tagged format), so never JSON.parse it raw.
-				const decoded1 = deserialize(query1);
-				const decoded2 = deserialize(query2);
+				const decoded1 = JSON.parse(decodeURIComponent(query1));
+				const decoded2 = JSON.parse(decodeURIComponent(query2));
 
-				if (!decoded1 || !decoded2) {
-					return false;
-				}
+				const filtered1 = cloneDeep(decoded1);
+				const filtered2 = cloneDeep(decoded2);
 
-				// Ignore the volatile `id` when comparing queries.
-				const { id: _id1, ...rest1 } = decoded1;
-				const { id: _id2, ...rest2 } = decoded2;
+				delete filtered1.id;
+				delete filtered2.id;
 
-				return isEqual(rest1, rest2);
+				return isEqual(filtered1, filtered2);
 			} catch (error) {
 				console.warn('Error comparing compositeQuery:', error);
 				return false;

frontend/src/hooks/useTimezoneFormatter/useTimezoneFormatter.ts

@@ -22,13 +22,11 @@ interface CacheEntry {
 const CACHE_SIZE_LIMIT = 1000;
 const CACHE_CLEANUP_PERCENTAGE = 0.5; // Remove 50% when limit is reached
 
-export type FormatTimezoneAdjustedTimestamp = (
-	input: TimestampInput,
-	format?: string,
-) => string;
-
 function useTimezoneFormatter({ userTimezone }: { userTimezone: Timezone }): {
-	formatTimezoneAdjustedTimestamp: FormatTimezoneAdjustedTimestamp;
+	formatTimezoneAdjustedTimestamp: (
+		input: TimestampInput,
+		format?: string,
+	) => string;
 } {
 	// Initialize cache using useMemo to persist between renders
 	const cache = useMemo(() => new Map<string, CacheEntry>(), []);

frontend/src/lib/compositeQuery/__tests__/__snapshots__/baseline.test.ts.snap

@@ -1,213 +0,0 @@
-// Jest Snapshot v1, https://jestjs.io/docs/snapshot-testing
-//
-// ╔════════════════════════════════════════════════════════════════════════════╗
-// ║                        ⚠️  NEVER UPDATE THESE ⚠️                            ║
-// ╠════════════════════════════════════════════════════════════════════════════╣
-// ║  These snapshots guard URL backward compatibility. Every emitted URL       ║
-// ║  encodes a diff against these exact baselines.                             ║
-// ║                                                                            ║
-// ║  If a test fails: REVERT baseline.ts, do NOT update snapshots.             ║
-// ║  If you need a new schema: create BASELINE_V2 + new adapter prefix.        ║
-// ╚════════════════════════════════════════════════════════════════════════════╝
-
-exports[`baseline immutability snapshots LOGS_BASELINE must never change 1`] = `
-{
-  "builder": {
-    "queryData": [
-      {
-        "aggregateAttribute": {
-          "dataType": "",
-          "id": "----",
-          "key": "",
-          "type": "",
-        },
-        "aggregateOperator": null,
-        "aggregations": [
-          {
-            "expression": "count() ",
-          },
-        ],
-        "dataSource": "logs",
-        "disabled": false,
-        "expression": "A",
-        "filter": {
-          "expression": "",
-        },
-        "filters": {
-          "items": [],
-          "op": "AND",
-        },
-        "functions": [],
-        "groupBy": [],
-        "having": [],
-        "legend": "",
-        "limit": null,
-        "orderBy": [],
-        "queryName": "A",
-        "reduceTo": "avg",
-        "source": null,
-        "spaceAggregation": "sum",
-        "stepInterval": null,
-        "timeAggregation": "rate",
-      },
-    ],
-    "queryFormulas": [],
-    "queryTraceOperator": [],
-  },
-  "clickhouse_sql": [
-    {
-      "disabled": false,
-      "legend": "",
-      "name": "A",
-      "query": "",
-    },
-  ],
-  "id": "",
-  "promql": [
-    {
-      "disabled": false,
-      "legend": "",
-      "name": "A",
-      "query": "",
-    },
-  ],
-  "queryType": "builder",
-  "unit": "",
-}
-`;
-
-exports[`baseline immutability snapshots METRICS_BASELINE must never change 1`] = `
-{
-  "builder": {
-    "queryData": [
-      {
-        "aggregateAttribute": {
-          "dataType": "",
-          "id": "----",
-          "key": "",
-          "type": "",
-        },
-        "aggregateOperator": "noop",
-        "aggregations": [
-          {
-            "metricName": "",
-            "reduceTo": "avg",
-            "spaceAggregation": "sum",
-            "temporality": "",
-            "timeAggregation": "avg",
-          },
-        ],
-        "dataSource": "metrics",
-        "disabled": false,
-        "expression": "A",
-        "filter": {
-          "expression": "",
-        },
-        "filters": {
-          "items": [],
-          "op": "AND",
-        },
-        "functions": [],
-        "groupBy": [],
-        "having": [],
-        "legend": "",
-        "limit": null,
-        "orderBy": [],
-        "queryName": "A",
-        "reduceTo": "avg",
-        "source": null,
-        "spaceAggregation": "sum",
-        "stepInterval": null,
-        "timeAggregation": "rate",
-      },
-    ],
-    "queryFormulas": [],
-    "queryTraceOperator": [],
-  },
-  "clickhouse_sql": [
-    {
-      "disabled": false,
-      "legend": "",
-      "name": "A",
-      "query": "",
-    },
-  ],
-  "id": "",
-  "promql": [
-    {
-      "disabled": false,
-      "legend": "",
-      "name": "A",
-      "query": "",
-    },
-  ],
-  "queryType": "builder",
-  "unit": "",
-}
-`;
-
-exports[`baseline immutability snapshots TRACES_BASELINE must never change 1`] = `
-{
-  "builder": {
-    "queryData": [
-      {
-        "aggregateAttribute": {
-          "dataType": "",
-          "id": "----",
-          "key": "",
-          "type": "",
-        },
-        "aggregateOperator": null,
-        "aggregations": [
-          {
-            "expression": "count() ",
-          },
-        ],
-        "dataSource": "traces",
-        "disabled": false,
-        "expression": "A",
-        "filter": {
-          "expression": "",
-        },
-        "filters": {
-          "items": [],
-          "op": "AND",
-        },
-        "functions": [],
-        "groupBy": [],
-        "having": [],
-        "legend": "",
-        "limit": null,
-        "orderBy": [],
-        "queryName": "A",
-        "reduceTo": "avg",
-        "source": null,
-        "spaceAggregation": "sum",
-        "stepInterval": null,
-        "timeAggregation": "rate",
-      },
-    ],
-    "queryFormulas": [],
-    "queryTraceOperator": [],
-  },
-  "clickhouse_sql": [
-    {
-      "disabled": false,
-      "legend": "",
-      "name": "A",
-      "query": "",
-    },
-  ],
-  "id": "",
-  "promql": [
-    {
-      "disabled": false,
-      "legend": "",
-      "name": "A",
-      "query": "",
-    },
-  ],
-  "queryType": "builder",
-  "unit": "",
-}
-`;

frontend/src/lib/compositeQuery/__tests__/baseline.test.ts

@@ -1,123 +0,0 @@
-/**
- * ╔════════════════════════════════════════════════════════════════════════════╗
- * ║                           ⚠️  CRITICAL WARNING ⚠️                           ║
- * ╠════════════════════════════════════════════════════════════════════════════╣
- * ║  These baselines are FROZEN FOREVER. They must NEVER be modified.          ║
- * ║                                                                            ║
- * ║  WHY: Every URL ever emitted by the compositeQuery serializer encodes a    ║
- * ║  diff against these exact baselines. Changing a single byte here silently  ║
- * ║  BREAKS ALL EXISTING URLs — dashboards, saved views, shared links, etc.    ║
- * ║                                                                            ║
- * ║  If these snapshot tests fail:                                             ║
- * ║    1. DO NOT update the snapshots                                          ║
- * ║    2. REVERT your changes to baseline.ts immediately                       ║
- * ║    3. If you need a new schema, create a NEW versioned baseline:           ║
- * ║       - METRICS_BASELINE_V2, LOGS_BASELINE_V2, TRACES_BASELINE_V2          ║
- * ║       - Create a new adapter (e.g., V2~) that uses the new baselines       ║
- * ║       - Keep the old baselines untouched for backwards compatibility       ║
- * ╚════════════════════════════════════════════════════════════════════════════╝
- */
-
-import getBaselineByTag, {
-	LOGS_BASELINE,
-	METRICS_BASELINE,
-	pickBaseline,
-	TRACES_BASELINE,
-} from '../baseline';
-
-describe('baseline immutability snapshots', () => {
-	/**
-	 * ⛔ DO NOT UPDATE THIS SNAPSHOT ⛔
-	 * If this fails, you broke URL compatibility. Revert your changes.
-	 */
-	it('METRICS_BASELINE must never change', () => {
-		expect(METRICS_BASELINE).toMatchSnapshot();
-	});
-
-	/**
-	 * ⛔ DO NOT UPDATE THIS SNAPSHOT ⛔
-	 * If this fails, you broke URL compatibility. Revert your changes.
-	 */
-	it('LOGS_BASELINE must never change', () => {
-		expect(LOGS_BASELINE).toMatchSnapshot();
-	});
-
-	/**
-	 * ⛔ DO NOT UPDATE THIS SNAPSHOT ⛔
-	 * If this fails, you broke URL compatibility. Revert your changes.
-	 */
-	it('TRACES_BASELINE must never change', () => {
-		expect(TRACES_BASELINE).toMatchSnapshot();
-	});
-});
-
-describe('pickBaseline', () => {
-	it('returns metrics baseline for metrics dataSource', () => {
-		const query = {
-			builder: { queryData: [{ dataSource: 'metrics' }] },
-		} as any;
-
-		const result = pickBaseline(query);
-
-		expect(result.baseline).toBe(METRICS_BASELINE);
-		expect(result.tag).toBe('m');
-	});
-
-	it('returns logs baseline for logs dataSource', () => {
-		const query = {
-			builder: { queryData: [{ dataSource: 'logs' }] },
-		} as any;
-
-		const result = pickBaseline(query);
-
-		expect(result.baseline).toBe(LOGS_BASELINE);
-		expect(result.tag).toBe('l');
-	});
-
-	it('returns traces baseline for traces dataSource', () => {
-		const query = {
-			builder: { queryData: [{ dataSource: 'traces' }] },
-		} as any;
-
-		const result = pickBaseline(query);
-
-		expect(result.baseline).toBe(TRACES_BASELINE);
-		expect(result.tag).toBe('t');
-	});
-
-	it('defaults to metrics baseline for unknown dataSource', () => {
-		const query = {
-			builder: { queryData: [{ dataSource: 'unknown' }] },
-		} as any;
-
-		const result = pickBaseline(query);
-
-		expect(result.baseline).toBe(METRICS_BASELINE);
-		expect(result.tag).toBe('m');
-	});
-
-	it('defaults to metrics baseline when queryData is empty', () => {
-		const query = {
-			builder: { queryData: [] },
-		} as any;
-
-		const result = pickBaseline(query);
-
-		expect(result.baseline).toBe(METRICS_BASELINE);
-		expect(result.tag).toBe('m');
-	});
-});
-
-describe('getBaselineByTag', () => {
-	it('returns LOGS_BASELINE for tag "l"', () => {
-		expect(getBaselineByTag('l')).toBe(LOGS_BASELINE);
-	});
-
-	it('returns TRACES_BASELINE for tag "t"', () => {
-		expect(getBaselineByTag('t')).toBe(TRACES_BASELINE);
-	});
-
-	it('returns METRICS_BASELINE for tag "m"', () => {
-		expect(getBaselineByTag('m')).toBe(METRICS_BASELINE);
-	});
-});

frontend/src/lib/compositeQuery/__tests__/serializer.test.ts

@@ -1,40 +0,0 @@
-import { initialQueriesMap } from 'constants/queryBuilder';
-import { deserialize, serialize } from 'lib/compositeQuery/serializer';
-
-describe('composite query serializer', () => {
-	it('serialize picks shortest format', () => {
-		const query = initialQueriesMap.metrics;
-		const serialized = serialize(query);
-		const jsonSerialized = encodeURIComponent(JSON.stringify(query));
-		// Serializer should pick a format shorter than or equal to raw JSON
-		expect(serialized.length).toBeLessThanOrEqual(jsonSerialized.length);
-		// Should use a tagged format with baseline indicator (m/l/t)
-		const usesTaggedFormat =
-			/^V1[mlt]~/.test(serialized) ||
-			/^TV[mlt]~/.test(serialized) ||
-			/^FV[mlt]~/.test(serialized) ||
-			/^FK[mlt]~/.test(serialized);
-		expect(usesTaggedFormat).toBe(true);
-	});
-
-	it('round-trips through serialize/deserialize', () => {
-		const query = initialQueriesMap.logs;
-		const decoded = deserialize(serialize(query));
-		expect(decoded?.builder.queryData[0].dataSource).toBe('logs');
-	});
-
-	it('returns null on corrupt input instead of throwing', () => {
-		expect(deserialize('%7Bnot-json')).toBeNull();
-	});
-
-	it('returns null for empty/missing value', () => {
-		expect(deserialize('')).toBeNull();
-	});
-
-	it('preserves id field through roundtrip', () => {
-		const query = { ...initialQueriesMap.metrics, id: 'test-query-uuid-123' };
-		const serialized = serialize(query);
-		const decoded = deserialize(serialized);
-		expect(decoded?.id).toBe('test-query-uuid-123');
-	});
-});

frontend/src/lib/compositeQuery/adapters/flatKeys/codec.ts

@@ -1,166 +0,0 @@
-/**
- * Flat-keys codec: a baseline-diff serializer that shortens keys but keeps
- * values as raw JSON. Simpler than flat-leaf — no field-aware enum compression.
- *
- * Wire grammar (tokens joined by `*`):
- *   set:    <shortPath>_<escapedJSON>   e.g.  b.qd.0.ds_"logs"
- *   delete: -<shortPath>                e.g.  -b.qd.0.ag.0.mn
- */
-import getBaselineByTag, {
-	BaselineTag,
-	pickBaseline,
-} from 'lib/compositeQuery/baseline';
-import { INVERSE_KEY_MAP, KEY_MAP } from './maps';
-import { Query } from 'types/api/queryBuilder/queryBuilderData';
-
-type Json = unknown;
-type PathSeg = string | number;
-
-const PAIR = '*';
-const KV = '_';
-const DEL = '-';
-
-const isIndex = (seg: string): boolean => /^\d+$/.test(seg);
-
-const isContainer = (value: Json): value is Record<string, Json> | Json[] =>
-	typeof value === 'object' && value !== null;
-
-const isEmptyContainer = (value: Json): boolean =>
-	isContainer(value) &&
-	(Array.isArray(value) ? value.length === 0 : Object.keys(value).length === 0);
-
-const isLeaf = (value: Json): boolean =>
-	!isContainer(value) || isEmptyContainer(value);
-
-const shortenSeg = (seg: PathSeg): PathSeg =>
-	typeof seg === 'number' ? seg : (KEY_MAP[seg] ?? seg);
-
-function leafMap(obj: Json): Record<string, Json> {
-	const out: Record<string, Json> = {};
-	const walk = (node: Json, segs: PathSeg[]): void => {
-		if (isLeaf(node)) {
-			out[segs.map(shortenSeg).join('.')] = node;
-			return;
-		}
-		if (Array.isArray(node)) {
-			node.forEach((value, index) => walk(value, [...segs, index]));
-			return;
-		}
-		Object.entries(node as Record<string, Json>).forEach(([key, value]) =>
-			walk(value, [...segs, key]),
-		);
-	};
-	walk(obj, []);
-	return out;
-}
-
-function escapeValue(str: string): string {
-	let escaped = str.replace(/_/g, '__').replace(/\*/g, '_s');
-	if (escaped[0] === '!') {
-		escaped = `_i${escaped.slice(1)}`;
-	}
-	return escaped;
-}
-
-const UNESCAPE: Record<string, string> = { _: '_', s: '*', i: '!' };
-
-function unescapeValue(str: string): string {
-	let out = '';
-	for (let i = 0; i < str.length; i += 1) {
-		if (str[i] === '_') {
-			const next = str[i + 1];
-			out += UNESCAPE[next] ?? next;
-			i += 1;
-		} else {
-			out += str[i];
-		}
-	}
-	return out;
-}
-
-function encodeLeaf(value: Json): string {
-	if (value === undefined) {
-		return escapeValue('null');
-	}
-	return escapeValue(JSON.stringify(value));
-}
-
-function decodeLeaf(token: string): Json {
-	return JSON.parse(unescapeValue(token));
-}
-
-function parsePath(pathStr: string): PathSeg[] {
-	return pathStr
-		.split('.')
-		.map((seg) => (isIndex(seg) ? Number(seg) : (INVERSE_KEY_MAP[seg] ?? seg)));
-}
-
-function setPath(
-	root: Record<string, Json>,
-	segs: PathSeg[],
-	value: Json,
-): void {
-	let node: Json = root;
-	for (let i = 0; i < segs.length - 1; i += 1) {
-		const seg = segs[i];
-		const container = node as Record<string | number, Json>;
-		if (!isContainer(container[seg])) {
-			container[seg] = typeof segs[i + 1] === 'number' ? [] : {};
-		}
-		node = container[seg];
-	}
-	(node as Record<string | number, Json>)[segs[segs.length - 1]] = value;
-}
-
-function rebuildFromLeaves(map: Record<string, Json>): Record<string, Json> {
-	const root: Record<string, Json> = {};
-	Object.entries(map).forEach(([path, value]) => {
-		setPath(root, parsePath(path), value);
-	});
-	return root;
-}
-
-export function encode(query: Query): { payload: string; tag: BaselineTag } {
-	const { baseline, tag } = pickBaseline(query);
-	const base = leafMap(baseline);
-	const next = leafMap(query);
-	const tokens: string[] = [];
-	Object.entries(next).forEach(([path, value]) => {
-		const baseVal = base[path];
-		const normalizedBase = baseVal === undefined ? null : baseVal;
-		const normalizedNext = value === undefined ? null : value;
-		if (
-			path in base &&
-			JSON.stringify(normalizedBase) === JSON.stringify(normalizedNext)
-		) {
-			return;
-		}
-		tokens.push(`${path}${KV}${encodeLeaf(value)}`);
-	});
-	Object.keys(base).forEach((path) => {
-		if (!(path in next)) {
-			tokens.push(`${DEL}${path}`);
-		}
-	});
-	tokens.sort();
-	return { payload: tokens.join(PAIR), tag };
-}
-
-export function decode(payload: string, tag: BaselineTag): Query {
-	const map = leafMap(getBaselineByTag(tag));
-	if (payload) {
-		payload.split(PAIR).forEach((token) => {
-			if (!token) {
-				return;
-			}
-			if (token[0] === DEL) {
-				delete map[token.slice(1)];
-				return;
-			}
-			const sep = token.indexOf(KV);
-			const path = token.slice(0, sep);
-			map[path] = decodeLeaf(token.slice(sep + 1));
-		});
-	}
-	return rebuildFromLeaves(map) as unknown as Query;
-}

frontend/src/lib/compositeQuery/adapters/flatKeys/flatKeys.test.ts

@@ -1,100 +0,0 @@
-import { initialQueriesMap } from 'constants/queryBuilder';
-import { Query } from 'types/api/queryBuilder/queryBuilderData';
-
-import { roundTripScenarios } from '../testing/scenarios';
-import { decodeFlatKeys, encodeFlatKeys, flatKeysAdapter } from './index';
-
-const roundTrip = (query: Query): Query =>
-	flatKeysAdapter.decode(flatKeysAdapter.encode(query));
-
-const clone = (query: Query): Query =>
-	JSON.parse(JSON.stringify(query)) as Query;
-
-describe('flatKeysAdapter', () => {
-	describe('round-trip scenarios', () => {
-		it.each(roundTripScenarios)('$name', ({ query }) => {
-			expect(roundTrip(query)).toStrictEqual(query);
-		});
-	});
-
-	describe('tag matching', () => {
-		it('tags output with FKm~/FKl~/FKt~', () => {
-			const metricsEncoded = flatKeysAdapter.encode(initialQueriesMap.metrics);
-			expect(metricsEncoded.startsWith('FKm~')).toBe(true);
-
-			const logsEncoded = flatKeysAdapter.encode(initialQueriesMap.logs);
-			expect(logsEncoded.startsWith('FKl~')).toBe(true);
-
-			const tracesEncoded = flatKeysAdapter.encode(initialQueriesMap.traces);
-			expect(tracesEncoded.startsWith('FKt~')).toBe(true);
-		});
-
-		it('matches only own tags', () => {
-			const encoded = flatKeysAdapter.encode(initialQueriesMap.metrics);
-			expect(flatKeysAdapter.matches(encoded)).toBe(true);
-			expect(flatKeysAdapter.matches('FVm~')).toBe(false);
-			expect(flatKeysAdapter.matches('%7Bnot-mine')).toBe(false);
-		});
-	});
-
-	describe('baseline behavior', () => {
-		it('uses correct baseline tag per dataSource', () => {
-			expect(encodeFlatKeys(initialQueriesMap.logs).tag).toBe('l');
-			expect(encodeFlatKeys(initialQueriesMap.traces).tag).toBe('t');
-			expect(encodeFlatKeys(initialQueriesMap.metrics).tag).toBe('m');
-		});
-
-		it('decodeFlatKeys on empty payload returns baseline', () => {
-			const decodedMetrics = decodeFlatKeys('', 'm');
-			expect(decodedMetrics.queryType).toBe('builder');
-			expect(decodedMetrics.builder.queryData[0].dataSource).toBe('metrics');
-
-			const decodedLogs = decodeFlatKeys('', 'l');
-			expect(decodedLogs.builder.queryData[0].dataSource).toBe('logs');
-		});
-	});
-
-	describe('encoding stability', () => {
-		it('identical encoding after roundtrip', () => {
-			const query = initialQueriesMap.metrics;
-			const encoded1 = flatKeysAdapter.encode(query);
-			const decoded = flatKeysAdapter.decode(encoded1);
-			const encoded2 = flatKeysAdapter.encode(decoded);
-
-			expect(encoded2).toBe(encoded1);
-		});
-
-		it('key order independent', () => {
-			const query1 = initialQueriesMap.metrics;
-			const query2 = JSON.parse(JSON.stringify(query1)) as Query;
-
-			const reordered = {
-				unit: query2.unit,
-				id: query2.id,
-				queryType: query2.queryType,
-				clickhouse_sql: query2.clickhouse_sql,
-				promql: query2.promql,
-				builder: query2.builder,
-			} as Query;
-
-			const encoded1 = flatKeysAdapter.encode(query1);
-			const encoded2 = flatKeysAdapter.encode(reordered);
-
-			expect(encoded2).toBe(encoded1);
-		});
-	});
-
-	describe('undefined handling', () => {
-		it('handles undefined values without breaking decode', () => {
-			const query = clone(initialQueriesMap.logs);
-			// eslint-disable-next-line @typescript-eslint/no-explicit-any
-			(query.builder.queryData[0] as any).aggregateOperator = undefined;
-			// eslint-disable-next-line @typescript-eslint/no-explicit-any
-			(query.builder.queryData[0] as any).source = undefined;
-
-			const encoded = flatKeysAdapter.encode(query);
-			const decoded = flatKeysAdapter.decode(encoded);
-			expect(decoded).not.toBeNull();
-		});
-	});
-});

frontend/src/lib/compositeQuery/adapters/flatKeys/index.ts

@@ -1,32 +0,0 @@
-import { BaselineTag } from 'lib/compositeQuery/baseline';
-import { decode, encode } from './codec';
-import { CompositeQueryAdapter } from './types';
-
-const TAG_PREFIX = 'FK';
-const TAG_SUFFIX = '~';
-
-/**
- * Flat-keys (FK~): stores a query as a keys-only, leaf-flattened diff from the
- * frozen baseline. Uses short keys but keeps values as raw JSON (no field-aware
- * enum compression).
- *
- * Useful for benchmarking: isolates contribution of key shortening from value compression.
- */
-export const flatKeysAdapter: CompositeQueryAdapter = {
-	name: 'flat-keys',
-	encode: (query) => {
-		const { payload, tag } = encode(query);
-		return `${TAG_PREFIX}${tag}${TAG_SUFFIX}${payload}`;
-	},
-	matches: (raw) =>
-		raw.startsWith(`${TAG_PREFIX}m${TAG_SUFFIX}`) ||
-		raw.startsWith(`${TAG_PREFIX}l${TAG_SUFFIX}`) ||
-		raw.startsWith(`${TAG_PREFIX}t${TAG_SUFFIX}`),
-	decode: (raw) => {
-		const tag = raw[2] as BaselineTag;
-		const payload = raw.slice(4);
-		return decode(payload, tag);
-	},
-};
-
-export { encode as encodeFlatKeys, decode as decodeFlatKeys } from './codec';

frontend/src/lib/compositeQuery/adapters/flatKeys/maps.ts

@@ -1,51 +0,0 @@
-/**
- * Key shortening map for flatKeys adapter.
- * No value compression - only key shortening.
- */
-export const KEY_MAP: Record<string, string> = {
-	queryType: 'qt',
-	builder: 'b',
-	queryData: 'qd',
-	queryFormulas: 'qf',
-	queryTraceOperator: 'qo',
-	dataSource: 'ds',
-	queryName: 'qn',
-	aggregateOperator: 'ao',
-	aggregateAttribute: 'aa',
-	timeAggregation: 'ta',
-	spaceAggregation: 'sa',
-	filter: 'f',
-	expression: 'e',
-	aggregations: 'ag',
-	functions: 'fn',
-	filters: 'fl',
-	items: 'i',
-	disabled: 'd',
-	stepInterval: 'si',
-	having: 'h',
-	limit: 'l',
-	orderBy: 'ob',
-	groupBy: 'gb',
-	legend: 'lg',
-	reduceTo: 'rt',
-	source: 's',
-	promql: 'pq',
-	clickhouse_sql: 'cs',
-	name: 'n',
-	query: 'q',
-	key: 'k',
-	dataType: 'dt',
-	type: 't',
-	metricName: 'mn',
-	temporality: 'tp',
-	columnName: 'cn',
-	order: 'o',
-	value: 'v',
-	op: 'op',
-	isColumn: 'ic',
-	isJSON: 'ij',
-};
-
-export const INVERSE_KEY_MAP: Record<string, string> = Object.fromEntries(
-	Object.entries(KEY_MAP).map(([long, short]) => [short, long]),
-);

frontend/src/lib/compositeQuery/adapters/flatKeys/types.ts

@@ -1,8 +0,0 @@
-import { Query } from 'types/api/queryBuilder/queryBuilderData';
-
-export interface CompositeQueryAdapter {
-	readonly name: string;
-	encode(query: Query): string;
-	matches(raw: string): boolean;
-	decode(raw: string): Query;
-}

frontend/src/lib/compositeQuery/adapters/flatLeaf/codec.ts

@@ -1,197 +0,0 @@
-/**
- * Flat-leaf codec: a baseline-diff serializer that emits one token per changed
- * scalar leaf, with no JSON wrapper characters on the wire.
- *
- * Both the baseline and the query are flattened to maps of
- * `{ shortDotPath: scalarLeaf }` (arrays walked element-wise, so `queryData[0]`
- * becomes `qd.0`). Encode diffs the two maps and emits a token per changed or
- * removed leaf; decode replays those tokens onto the baseline map and rebuilds
- * the nested object. Because arrays are walked element-wise, adding one filter
- * costs a few scalar tokens instead of a whole-array JSON blob.
- *
- * Wire grammar (tokens joined by `*`):
- *   set:    <shortPath>_<encodedLeaf>   e.g.  b.qd.0.ds_0
- *   delete: -<shortPath>                e.g.  -b.qd.0.ag.0.mn
- */
-import getBaselineByTag, {
-	BaselineTag,
-	pickBaseline,
-} from 'lib/compositeQuery/baseline';
-import {
-	FIELD_DOMAINS,
-	INVERSE_FIELD_DOMAINS,
-	INVERSE_KEY_MAP,
-	KEY_MAP,
-} from './maps';
-import { Query } from 'types/api/queryBuilder/queryBuilderData';
-
-type Json = unknown;
-type PathSeg = string | number;
-
-const PAIR = '*';
-const KV = '_';
-const DEL = '-';
-
-const isIndex = (seg: string): boolean => /^\d+$/.test(seg);
-
-const isContainer = (value: Json): value is Record<string, Json> | Json[] =>
-	typeof value === 'object' && value !== null;
-
-const isEmptyContainer = (value: Json): boolean =>
-	isContainer(value) &&
-	(Array.isArray(value) ? value.length === 0 : Object.keys(value).length === 0);
-
-const isLeaf = (value: Json): boolean =>
-	!isContainer(value) || isEmptyContainer(value);
-
-const shortenSeg = (seg: PathSeg): PathSeg =>
-	typeof seg === 'number' ? seg : (KEY_MAP[seg] ?? seg);
-
-const lastSeg = (path: string): string => path.slice(path.lastIndexOf('.') + 1);
-
-function leafMap(obj: Json): Record<string, Json> {
-	const out: Record<string, Json> = {};
-	const walk = (node: Json, segs: PathSeg[]): void => {
-		if (isLeaf(node)) {
-			out[segs.map(shortenSeg).join('.')] = node;
-			return;
-		}
-		if (Array.isArray(node)) {
-			node.forEach((value, index) => walk(value, [...segs, index]));
-			return;
-		}
-		Object.entries(node as Record<string, Json>).forEach(([key, value]) =>
-			walk(value, [...segs, key]),
-		);
-	};
-	walk(obj, []);
-	return out;
-}
-
-function escapeValue(str: string): string {
-	let escaped = str.replace(/_/g, '__').replace(/\*/g, '_s');
-	if (escaped[0] === '!') {
-		escaped = `_i${escaped.slice(1)}`;
-	}
-	return escaped;
-}
-
-const UNESCAPE: Record<string, string> = { _: '_', s: '*', i: '!' };
-
-function unescapeValue(str: string): string {
-	let out = '';
-	for (let i = 0; i < str.length; i += 1) {
-		if (str[i] === '_') {
-			const next = str[i + 1];
-			out += UNESCAPE[next] ?? next;
-			i += 1;
-		} else {
-			out += str[i];
-		}
-	}
-	return out;
-}
-
-function encodeLeaf(value: Json, shortKey: string): string {
-	if (typeof value === 'string') {
-		const domain = FIELD_DOMAINS[shortKey];
-		if (domain?.[value] !== undefined) {
-			return String(domain[value]);
-		}
-		return escapeValue(value);
-	}
-	if (value === undefined) {
-		return '!null';
-	}
-	return `!${JSON.stringify(value)}`;
-}
-
-function decodeLeaf(token: string, shortKey: string): Json {
-	if (token[0] === '!') {
-		return JSON.parse(token.slice(1));
-	}
-	const inverse = INVERSE_FIELD_DOMAINS[shortKey];
-	if (inverse && isIndex(token)) {
-		const mapped = inverse[Number(token)];
-		if (mapped !== undefined) {
-			return mapped;
-		}
-	}
-	return unescapeValue(token);
-}
-
-function parsePath(pathStr: string): PathSeg[] {
-	return pathStr
-		.split('.')
-		.map((seg) => (isIndex(seg) ? Number(seg) : (INVERSE_KEY_MAP[seg] ?? seg)));
-}
-
-function setPath(
-	root: Record<string, Json>,
-	segs: PathSeg[],
-	value: Json,
-): void {
-	let node: Json = root;
-	for (let i = 0; i < segs.length - 1; i += 1) {
-		const seg = segs[i];
-		const container = node as Record<string | number, Json>;
-		if (!isContainer(container[seg])) {
-			container[seg] = typeof segs[i + 1] === 'number' ? [] : {};
-		}
-		node = container[seg];
-	}
-	(node as Record<string | number, Json>)[segs[segs.length - 1]] = value;
-}
-
-function rebuildFromLeaves(map: Record<string, Json>): Record<string, Json> {
-	const root: Record<string, Json> = {};
-	Object.entries(map).forEach(([path, value]) => {
-		setPath(root, parsePath(path), value);
-	});
-	return root;
-}
-
-export function encode(query: Query): { payload: string; tag: BaselineTag } {
-	const { baseline, tag } = pickBaseline(query);
-	const base = leafMap(baseline);
-	const next = leafMap(query);
-	const tokens: string[] = [];
-	Object.entries(next).forEach(([path, value]) => {
-		const baseVal = base[path];
-		const normalizedBase = baseVal === undefined ? null : baseVal;
-		const normalizedNext = value === undefined ? null : value;
-		if (
-			path in base &&
-			JSON.stringify(normalizedBase) === JSON.stringify(normalizedNext)
-		) {
-			return;
-		}
-		tokens.push(`${path}${KV}${encodeLeaf(value, lastSeg(path))}`);
-	});
-	Object.keys(base).forEach((path) => {
-		if (!(path in next)) {
-			tokens.push(`${DEL}${path}`);
-		}
-	});
-	tokens.sort();
-	return { payload: tokens.join(PAIR), tag };
-}
-
-export function decode(payload: string, tag: BaselineTag): Query {
-	const map = leafMap(getBaselineByTag(tag));
-	if (payload) {
-		payload.split(PAIR).forEach((token) => {
-			if (!token) {
-				return;
-			}
-			if (token[0] === DEL) {
-				delete map[token.slice(1)];
-				return;
-			}
-			const sep = token.indexOf(KV);
-			const path = token.slice(0, sep);
-			map[path] = decodeLeaf(token.slice(sep + 1), lastSeg(path));
-		});
-	}
-	return rebuildFromLeaves(map) as unknown as Query;
-}

frontend/src/lib/compositeQuery/adapters/flatLeaf/flatLeaf.test.ts

@@ -1,151 +0,0 @@
-import { isEqual } from 'lodash-es';
-
-import { initialQueriesMap } from 'constants/queryBuilder';
-import { Query } from 'types/api/queryBuilder/queryBuilderData';
-
-import { roundTripScenarios } from '../testing/scenarios';
-import { decodeFlatLeaf, encodeFlatLeaf, flatLeafAdapter } from './index';
-
-const roundTrip = (query: Query): Query =>
-	flatLeafAdapter.decode(flatLeafAdapter.encode(query));
-
-const clone = (query: Query): Query =>
-	JSON.parse(JSON.stringify(query)) as Query;
-
-describe('flatLeafAdapter', () => {
-	describe('round-trip scenarios', () => {
-		it.each(roundTripScenarios)('$name', ({ query }) => {
-			expect(roundTrip(query)).toStrictEqual(query);
-		});
-	});
-
-	describe('tag matching', () => {
-		it('tags output with FVm~/FVl~/FVt~', () => {
-			const metricsEncoded = flatLeafAdapter.encode(initialQueriesMap.metrics);
-			expect(metricsEncoded.startsWith('FVm~')).toBe(true);
-
-			const logsEncoded = flatLeafAdapter.encode(initialQueriesMap.logs);
-			expect(logsEncoded.startsWith('FVl~')).toBe(true);
-
-			const tracesEncoded = flatLeafAdapter.encode(initialQueriesMap.traces);
-			expect(tracesEncoded.startsWith('FVt~')).toBe(true);
-		});
-
-		it('matches only own tags', () => {
-			const encoded = flatLeafAdapter.encode(initialQueriesMap.metrics);
-			expect(flatLeafAdapter.matches(encoded)).toBe(true);
-			expect(flatLeafAdapter.matches('V1m~[]')).toBe(false);
-			expect(flatLeafAdapter.matches('%7Bnot-mine')).toBe(false);
-		});
-	});
-
-	describe('baseline behavior', () => {
-		it('uses correct baseline tag per dataSource', () => {
-			expect(encodeFlatLeaf(initialQueriesMap.logs).tag).toBe('l');
-			expect(encodeFlatLeaf(initialQueriesMap.traces).tag).toBe('t');
-			expect(encodeFlatLeaf(initialQueriesMap.metrics).tag).toBe('m');
-		});
-
-		it('emits no payload when query equals baseline shape', () => {
-			const { payload, tag } = encodeFlatLeaf(initialQueriesMap.logs);
-			expect(tag).toBe('l');
-			expect(decodeFlatLeaf(payload, tag)).toStrictEqual(initialQueriesMap.logs);
-		});
-
-		it('decodeFlatLeaf on empty payload returns baseline', () => {
-			const decodedMetrics = decodeFlatLeaf('', 'm');
-			expect(decodedMetrics.queryType).toBe('builder');
-			expect(decodedMetrics.builder.queryData[0].dataSource).toBe('metrics');
-
-			const decodedLogs = decodeFlatLeaf('', 'l');
-			expect(decodedLogs.builder.queryData[0].dataSource).toBe('logs');
-		});
-	});
-
-	describe('encoding stability', () => {
-		it('identical encoding after roundtrip', () => {
-			const query = initialQueriesMap.metrics;
-			const encoded1 = flatLeafAdapter.encode(query);
-			const decoded = flatLeafAdapter.decode(encoded1);
-			const encoded2 = flatLeafAdapter.encode(decoded);
-
-			expect(encoded2).toBe(encoded1);
-		});
-
-		it('key order independent', () => {
-			const query1 = initialQueriesMap.metrics;
-			const query2 = JSON.parse(JSON.stringify(query1)) as Query;
-
-			const reordered = {
-				unit: query2.unit,
-				id: query2.id,
-				queryType: query2.queryType,
-				clickhouse_sql: query2.clickhouse_sql,
-				promql: query2.promql,
-				builder: query2.builder,
-			} as Query;
-
-			const encoded1 = flatLeafAdapter.encode(query1);
-			const encoded2 = flatLeafAdapter.encode(reordered);
-
-			expect(encoded2).toBe(encoded1);
-		});
-
-		it('stable after spread/reconstruct', () => {
-			const query = { ...initialQueriesMap.metrics };
-			const encoded1 = flatLeafAdapter.encode(query);
-
-			const transformed = {
-				...query,
-				builder: {
-					...query.builder,
-					queryData: query.builder.queryData.map((item) => ({
-						...item,
-					})),
-				},
-			};
-			const encoded2 = flatLeafAdapter.encode(transformed);
-
-			expect(encoded2).toBe(encoded1);
-		});
-	});
-
-	describe('key validation', () => {
-		it('decoded query has all keys expected by replaceIncorrectObjectFields', () => {
-			const decoded = flatLeafAdapter.decode(
-				flatLeafAdapter.encode(initialQueriesMap.metrics),
-			);
-			const decodedKeys = Object.keys(decoded).sort();
-			const expectedKeys = Object.keys(initialQueriesMap.metrics).sort();
-
-			expect(decodedKeys).toStrictEqual(expectedKeys);
-		});
-	});
-
-	describe('isEqual compatibility', () => {
-		it('lodash isEqual works for decoded queries', () => {
-			const query = initialQueriesMap.metrics;
-			const encoded = flatLeafAdapter.encode(query);
-			const decoded = flatLeafAdapter.decode(encoded);
-
-			const { id: _id1, ...rest1 } = query;
-			const { id: _id2, ...rest2 } = decoded;
-
-			expect(isEqual(rest1, rest2)).toBe(true);
-		});
-	});
-
-	describe('undefined handling', () => {
-		it('handles undefined values without breaking decode', () => {
-			const query = clone(initialQueriesMap.logs);
-			// eslint-disable-next-line @typescript-eslint/no-explicit-any
-			(query.builder.queryData[0] as any).aggregateOperator = undefined;
-			// eslint-disable-next-line @typescript-eslint/no-explicit-any
-			(query.builder.queryData[0] as any).source = undefined;
-
-			const encoded = flatLeafAdapter.encode(query);
-			const decoded = flatLeafAdapter.decode(encoded);
-			expect(decoded).not.toBeNull();
-		});
-	});
-});

frontend/src/lib/compositeQuery/adapters/flatLeaf/index.ts

@@ -1,30 +0,0 @@
-import { BaselineTag } from 'lib/compositeQuery/baseline';
-import { decode, encode } from './codec';
-import { CompositeQueryAdapter } from './types';
-
-const TAG_PREFIX = 'FV';
-const TAG_SUFFIX = '~';
-
-/**
- * Flat-leaf (FV~): stores a query as a field-aware, leaf-flattened diff from the
- * frozen baseline. Uses the smart hybrid strategy — metrics or logs baseline
- * picked by dataSource — so the tag is FVm~ (metrics) or FVl~ (logs).
- */
-export const flatLeafAdapter: CompositeQueryAdapter = {
-	name: 'flat-leaf',
-	encode: (query) => {
-		const { payload, tag } = encode(query);
-		return `${TAG_PREFIX}${tag}${TAG_SUFFIX}${payload}`;
-	},
-	matches: (raw) =>
-		raw.startsWith(`${TAG_PREFIX}m${TAG_SUFFIX}`) ||
-		raw.startsWith(`${TAG_PREFIX}l${TAG_SUFFIX}`) ||
-		raw.startsWith(`${TAG_PREFIX}t${TAG_SUFFIX}`),
-	decode: (raw) => {
-		const tag = raw[2] as BaselineTag;
-		const payload = raw.slice(4);
-		return decode(payload, tag);
-	},
-};
-
-export { encode as encodeFlatLeaf, decode as decodeFlatLeaf } from './codec';

frontend/src/lib/compositeQuery/adapters/flatLeaf/maps.ts

@@ -1,197 +0,0 @@
-import {
-	MetrictypesSpaceAggregationDTO,
-	MetrictypesTemporalityDTO,
-	MetrictypesTimeAggregationDTO,
-} from 'api/generated/services/sigNoz.schemas';
-import {
-	AutocompleteType,
-	DataTypes,
-} from 'types/api/queryBuilder/queryAutocompleteResponse';
-import { EQueryType } from 'types/common/dashboard';
-import {
-	DataSource,
-	LogsAggregatorOperator,
-	MetricAggregateOperator,
-	ReduceOperators,
-	TracesAggregatorOperator,
-} from 'types/common/queryBuilder';
-
-export const KEY_MAP: Record<string, string> = {
-	queryType: 'qt',
-	builder: 'b',
-	queryData: 'qd',
-	queryFormulas: 'qf',
-	queryTraceOperator: 'qo',
-	dataSource: 'ds',
-	queryName: 'qn',
-	aggregateOperator: 'ao',
-	aggregateAttribute: 'aa',
-	timeAggregation: 'ta',
-	spaceAggregation: 'sa',
-	filter: 'f',
-	expression: 'e',
-	aggregations: 'ag',
-	functions: 'fn',
-	filters: 'fl',
-	items: 'i',
-	disabled: 'd',
-	stepInterval: 'si',
-	having: 'h',
-	limit: 'l',
-	orderBy: 'ob',
-	groupBy: 'gb',
-	legend: 'lg',
-	reduceTo: 'rt',
-	source: 's',
-	promql: 'pq',
-	clickhouse_sql: 'cs',
-	name: 'n',
-	query: 'q',
-	key: 'k',
-	dataType: 'dt',
-	type: 't',
-	metricName: 'mn',
-	temporality: 'tp',
-	columnName: 'cn',
-	order: 'o',
-	value: 'v',
-	op: 'op',
-	isColumn: 'ic',
-	isJSON: 'ij',
-};
-
-export const INVERSE_KEY_MAP: Record<string, string> = Object.fromEntries(
-	Object.entries(KEY_MAP).map(([long, short]) => [short, long]),
-);
-
-const DATA_SOURCE: Record<DataSource, number> = {
-	[DataSource.LOGS]: 0,
-	[DataSource.METRICS]: 1,
-	[DataSource.TRACES]: 2,
-};
-
-const QUERY_TYPE: Record<EQueryType, number> = {
-	[EQueryType.QUERY_BUILDER]: 0,
-	[EQueryType.PROM]: 1,
-	[EQueryType.CLICKHOUSE]: 2,
-};
-
-const REDUCE_TO: Record<ReduceOperators, number> = {
-	[ReduceOperators.LAST]: 0,
-	[ReduceOperators.SUM]: 1,
-	[ReduceOperators.AVG]: 2,
-	[ReduceOperators.MAX]: 3,
-	[ReduceOperators.MIN]: 4,
-};
-
-const TEMPORALITY: Record<MetrictypesTemporalityDTO, number> = {
-	[MetrictypesTemporalityDTO.delta]: 0,
-	[MetrictypesTemporalityDTO.cumulative]: 1,
-	[MetrictypesTemporalityDTO.unspecified]: 2,
-};
-
-const TIME_AGGREGATION: Record<MetrictypesTimeAggregationDTO, number> = {
-	[MetrictypesTimeAggregationDTO.latest]: 0,
-	[MetrictypesTimeAggregationDTO.sum]: 1,
-	[MetrictypesTimeAggregationDTO.avg]: 2,
-	[MetrictypesTimeAggregationDTO.min]: 3,
-	[MetrictypesTimeAggregationDTO.max]: 4,
-	[MetrictypesTimeAggregationDTO.count]: 5,
-	[MetrictypesTimeAggregationDTO.count_distinct]: 6,
-	[MetrictypesTimeAggregationDTO.rate]: 7,
-	[MetrictypesTimeAggregationDTO.increase]: 8,
-};
-
-const SPACE_AGGREGATION: Record<MetrictypesSpaceAggregationDTO, number> = {
-	[MetrictypesSpaceAggregationDTO.sum]: 0,
-	[MetrictypesSpaceAggregationDTO.avg]: 1,
-	[MetrictypesSpaceAggregationDTO.min]: 2,
-	[MetrictypesSpaceAggregationDTO.max]: 3,
-	[MetrictypesSpaceAggregationDTO.count]: 4,
-	[MetrictypesSpaceAggregationDTO.p50]: 5,
-	[MetrictypesSpaceAggregationDTO.p75]: 6,
-	[MetrictypesSpaceAggregationDTO.p90]: 7,
-	[MetrictypesSpaceAggregationDTO.p95]: 8,
-	[MetrictypesSpaceAggregationDTO.p99]: 9,
-};
-
-const AGGREGATE_OPERATOR: Record<
-	MetricAggregateOperator | TracesAggregatorOperator | LogsAggregatorOperator,
-	number
-> = {
-	[MetricAggregateOperator.EMPTY]: 0,
-	[MetricAggregateOperator.NOOP]: 1,
-	[MetricAggregateOperator.COUNT]: 2,
-	[MetricAggregateOperator.COUNT_DISTINCT]: 3,
-	[MetricAggregateOperator.SUM]: 4,
-	[MetricAggregateOperator.AVG]: 5,
-	[MetricAggregateOperator.MAX]: 6,
-	[MetricAggregateOperator.MIN]: 7,
-	[MetricAggregateOperator.P05]: 8,
-	[MetricAggregateOperator.P10]: 9,
-	[MetricAggregateOperator.P20]: 10,
-	[MetricAggregateOperator.P25]: 11,
-	[MetricAggregateOperator.P50]: 12,
-	[MetricAggregateOperator.P75]: 13,
-	[MetricAggregateOperator.P90]: 14,
-	[MetricAggregateOperator.P95]: 15,
-	[MetricAggregateOperator.P99]: 16,
-	[MetricAggregateOperator.RATE]: 17,
-	[MetricAggregateOperator.SUM_RATE]: 18,
-	[MetricAggregateOperator.AVG_RATE]: 19,
-	[MetricAggregateOperator.MAX_RATE]: 20,
-	[MetricAggregateOperator.MIN_RATE]: 21,
-	[MetricAggregateOperator.RATE_SUM]: 22,
-	[MetricAggregateOperator.RATE_AVG]: 23,
-	[MetricAggregateOperator.RATE_MIN]: 24,
-	[MetricAggregateOperator.RATE_MAX]: 25,
-	[MetricAggregateOperator.HIST_QUANTILE_50]: 26,
-	[MetricAggregateOperator.HIST_QUANTILE_75]: 27,
-	[MetricAggregateOperator.HIST_QUANTILE_90]: 28,
-	[MetricAggregateOperator.HIST_QUANTILE_95]: 29,
-	[MetricAggregateOperator.HIST_QUANTILE_99]: 30,
-	[MetricAggregateOperator.INCREASE]: 31,
-	[MetricAggregateOperator.LATEST]: 32,
-};
-
-const DATA_TYPE: Record<DataTypes, number> = {
-	[DataTypes.Int64]: 0,
-	[DataTypes.String]: 1,
-	[DataTypes.Float64]: 2,
-	[DataTypes.bool]: 3,
-	[DataTypes.ArrayFloat64]: 4,
-	[DataTypes.ArrayInt64]: 5,
-	[DataTypes.ArrayString]: 6,
-	[DataTypes.ArrayBool]: 7,
-	[DataTypes.EMPTY]: 8,
-};
-
-const ATTR_TYPE: Record<AutocompleteType, number> = {
-	tag: 0,
-	resource: 1,
-	'': 2,
-};
-
-export const FIELD_DOMAINS: Record<string, Record<string, number>> = {
-	ds: DATA_SOURCE,
-	qt: QUERY_TYPE,
-	rt: REDUCE_TO,
-	tp: TEMPORALITY,
-	ta: TIME_AGGREGATION,
-	sa: SPACE_AGGREGATION,
-	ao: AGGREGATE_OPERATOR,
-	dt: DATA_TYPE,
-	t: ATTR_TYPE,
-};
-
-export const INVERSE_FIELD_DOMAINS: Record<
-	string,
-	Record<number, string>
-> = Object.fromEntries(
-	Object.entries(FIELD_DOMAINS).map(([field, domain]) => [
-		field,
-		Object.fromEntries(
-			Object.entries(domain).map(([str, int]) => [int, str]),
-		) as Record<number, string>,
-	]),
-);

frontend/src/lib/compositeQuery/adapters/flatLeaf/types.ts

@@ -1,8 +0,0 @@
-import { Query } from 'types/api/queryBuilder/queryBuilderData';
-
-export interface CompositeQueryAdapter {
-	readonly name: string;
-	encode(query: Query): string;
-	matches(raw: string): boolean;
-	decode(raw: string): Query;
-}

frontend/src/lib/compositeQuery/adapters/json/index.ts

@@ -1,55 +0,0 @@
-import {
-	convertAggregationToExpression,
-	convertFiltersToExpressionWithExistingQuery,
-	convertHavingToExpression,
-} from 'components/QueryBuilderV2/utils';
-import { BaseAutocompleteData } from 'types/api/queryBuilder/queryAutocompleteResponse';
-import { Query } from 'types/api/queryBuilder/queryBuilderData';
-import { CompositeQueryAdapter } from './types';
-
-function migrateLegacyFormat(parsed: Query): Query {
-	if (!parsed?.builder?.queryData) {
-		return parsed;
-	}
-	const next = parsed;
-	next.builder.queryData = parsed.builder.queryData.map((query) => {
-		const existingExpression = query.filter?.expression || '';
-		const convertedQuery = { ...query };
-
-		const convertedFilter = convertFiltersToExpressionWithExistingQuery(
-			query.filters || { items: [], op: 'AND' },
-			existingExpression,
-		);
-		convertedQuery.filter = convertedFilter.filter;
-		convertedQuery.filters = convertedFilter.filters;
-
-		if (Array.isArray(query.having)) {
-			convertedQuery.having = convertHavingToExpression(query.having);
-		}
-
-		if (!query.aggregations && query.aggregateOperator) {
-			convertedQuery.aggregations = convertAggregationToExpression({
-				aggregateOperator: query.aggregateOperator,
-				aggregateAttribute: query.aggregateAttribute as BaseAutocompleteData,
-				dataSource: query.dataSource,
-				timeAggregation: query.timeAggregation,
-				spaceAggregation: query.spaceAggregation,
-				reduceTo: query.reduceTo,
-				temporality: query.temporality,
-				// eslint-disable-next-line @typescript-eslint/no-explicit-any
-			}) as any;
-		}
-		return convertedQuery;
-	});
-	return next;
-}
-
-export const jsonAdapter: CompositeQueryAdapter = {
-	name: 'json(legacy)',
-	encode: (query) => encodeURIComponent(JSON.stringify(query)),
-	matches: () => true,
-	decode: (raw) => {
-		const parsed: Query = JSON.parse(decodeURIComponent(raw.replace(/\+/g, ' ')));
-		return migrateLegacyFormat(parsed);
-	},
-};

frontend/src/lib/compositeQuery/adapters/json/json.test.ts

@@ -1,68 +0,0 @@
-import { initialQueriesMap } from 'constants/queryBuilder';
-import { Query } from 'types/api/queryBuilder/queryBuilderData';
-
-import { jsonAdapter } from './index';
-
-const roundTrip = (query: Query): Query =>
-	jsonAdapter.decode(jsonAdapter.encode(query));
-
-describe('jsonAdapter', () => {
-	describe('round-trip', () => {
-		it.each(['metrics', 'logs', 'traces'] as const)(
-			'round-trips %s baseline preserving dataSource',
-			(source) => {
-				const query = initialQueriesMap[source];
-				const decoded = roundTrip(query);
-				expect(decoded.builder.queryData[0].dataSource).toBe(source);
-			},
-		);
-	});
-
-	describe('legacy format compatibility', () => {
-		it('encodes to legacy format (encodeURIComponent + JSON)', () => {
-			const query = initialQueriesMap.logs;
-			const encoded = jsonAdapter.encode(query);
-
-			expect(encoded).toBe(encodeURIComponent(JSON.stringify(query)));
-			expect(encoded.startsWith('%7B')).toBe(true);
-		});
-	});
-
-	describe('tag matching', () => {
-		it('matches any value (catch-all fallback)', () => {
-			expect(jsonAdapter.matches('%7B%22queryType%22%3A%22builder%22%7D')).toBe(
-				true,
-			);
-			expect(jsonAdapter.matches('z1~abc')).toBe(true);
-		});
-	});
-
-	describe('migration', () => {
-		it('migrates old format (filters -> filter.expression)', () => {
-			const legacy = {
-				queryType: 'builder',
-				builder: {
-					queryData: [
-						{
-							dataSource: 'logs',
-							queryName: 'A',
-							filters: { op: 'AND', items: [] },
-							aggregateOperator: 'count',
-							aggregateAttribute: { key: '', dataType: '', type: '' },
-						},
-					],
-					queryFormulas: [],
-					queryTraceOperator: [],
-				},
-				promql: [],
-				clickhouse_sql: [],
-				id: 'x',
-				unit: '',
-			};
-			const raw = encodeURIComponent(JSON.stringify(legacy));
-			const decoded = jsonAdapter.decode(raw);
-			expect(decoded.builder.queryData[0].filter).toBeDefined();
-			expect(decoded.builder.queryData[0].aggregations).toBeDefined();
-		});
-	});
-});

frontend/src/lib/compositeQuery/adapters/json/types.ts

@@ -1,8 +0,0 @@
-import { Query } from 'types/api/queryBuilder/queryBuilderData';
-
-export interface CompositeQueryAdapter {
-	readonly name: string;
-	encode(query: Query): string;
-	matches(raw: string): boolean;
-	decode(raw: string): Query;
-}

frontend/src/lib/compositeQuery/adapters/testing/scenarios.ts

@@ -1,85 +0,0 @@
-import { initialQueriesMap } from 'constants/queryBuilder';
-import { Query } from 'types/api/queryBuilder/queryBuilderData';
-import { EQueryType } from 'types/common/dashboard';
-
-export interface RoundTripScenario {
-	name: string;
-	query: Query;
-}
-
-const clone = <T>(obj: T): T => JSON.parse(JSON.stringify(obj)) as T;
-
-const makePromqlQuery = (): Query => {
-	const query = clone(initialQueriesMap.metrics);
-	query.queryType = EQueryType.PROM;
-	query.promql[0].query = 'rate(http_requests_total[5m])';
-	return query;
-};
-
-const makeClickhouseQuery = (): Query => {
-	const query = clone(initialQueriesMap.metrics);
-	query.queryType = EQueryType.CLICKHOUSE;
-	query.clickhouse_sql[0].query = 'SELECT count() FROM signoz_logs';
-	return query;
-};
-
-const makeModifiedBuilderQuery = (): Query => {
-	const query = clone(initialQueriesMap.logs);
-	const qd = query.builder.queryData[0];
-	qd.aggregateOperator = 'p95';
-	qd.disabled = true;
-	qd.stepInterval = 60;
-	qd.legend = 'error rate';
-	qd.filter = { expression: "severity_text = 'ERROR'" };
-	qd.filters = {
-		op: 'AND',
-		items: [
-			{
-				key: {
-					key: 'severity_text',
-					dataType: 'string',
-					type: 'tag',
-					isColumn: false,
-					isJSON: false,
-					// eslint-disable-next-line @typescript-eslint/no-explicit-any
-				} as any,
-				id: 'item-1',
-				op: '=',
-				value: 'ERROR',
-			},
-		],
-	};
-	qd.orderBy = [{ columnName: 'timestamp', order: 'desc' }];
-	return query;
-};
-
-const makeQueryWithCustomId = (): Query => ({
-	...initialQueriesMap.metrics,
-	id: 'test-query-uuid-123',
-});
-
-const makeQueryWithEnumLikeLegend = (): Query => {
-	const query = clone(initialQueriesMap.metrics);
-	query.builder.queryData[0].legend = 'sum';
-	query.id = 'my-query-id';
-	return query;
-};
-
-const makeQueryWithWireDelimiters = (): Query => {
-	const query = clone(initialQueriesMap.logs);
-	query.builder.queryData[0].legend = '_a*b_*c';
-	query.builder.queryData[0].filter = { expression: '!weird = "x_y*z"' };
-	return query;
-};
-
-export const roundTripScenarios: RoundTripScenario[] = [
-	{ name: 'metrics baseline', query: initialQueriesMap.metrics },
-	{ name: 'logs baseline', query: initialQueriesMap.logs },
-	{ name: 'traces baseline', query: initialQueriesMap.traces },
-	{ name: 'promql query', query: makePromqlQuery() },
-	{ name: 'clickhouse query', query: makeClickhouseQuery() },
-	{ name: 'modified builder query', query: makeModifiedBuilderQuery() },
-	{ name: 'custom id', query: makeQueryWithCustomId() },
-	{ name: 'enum-like legend preserved', query: makeQueryWithEnumLikeLegend() },
-	{ name: 'wire delimiters in values', query: makeQueryWithWireDelimiters() },
-];

frontend/src/lib/compositeQuery/baseline.ts

@@ -1,179 +0,0 @@
-import { Query } from 'types/api/queryBuilder/queryBuilderData';
-
-/**
- * Frozen canonical baselines the V-raw/TV adapters diff against. Encode stores
- * only the diff from the chosen baseline; decode replays it onto a clone. These
- * MUST stay byte-stable forever — changing them silently invalidates every URL
- * already emitted against the old baseline. To evolve the schema, add NEW
- * tagged adapters (V2~) with their own baselines rather than editing these.
- *
- * `id`/`unit` are empty so a real query's values round-trip as ordinary diff
- * entries (nothing is stripped before diffing).
- */
-
-/** Baseline for metrics queries — uses metric-style aggregations object. */
-export const METRICS_BASELINE = {
-	queryType: 'builder',
-	builder: {
-		queryData: [
-			{
-				dataSource: 'metrics',
-				queryName: 'A',
-				aggregateOperator: 'noop',
-				aggregateAttribute: {
-					id: '----',
-					key: '',
-					dataType: '',
-					type: '',
-				},
-				timeAggregation: 'rate',
-				spaceAggregation: 'sum',
-				filter: { expression: '' },
-				aggregations: [
-					{
-						metricName: '',
-						temporality: '',
-						timeAggregation: 'avg',
-						spaceAggregation: 'sum',
-						reduceTo: 'avg',
-					},
-				],
-				functions: [],
-				filters: { items: [], op: 'AND' },
-				expression: 'A',
-				disabled: false,
-				stepInterval: null,
-				having: [],
-				limit: null,
-				orderBy: [],
-				groupBy: [],
-				legend: '',
-				reduceTo: 'avg',
-				source: null,
-			},
-		],
-		queryFormulas: [],
-		queryTraceOperator: [],
-	},
-	promql: [{ name: 'A', query: '', legend: '', disabled: false }],
-	clickhouse_sql: [{ name: 'A', legend: '', disabled: false, query: '' }],
-	id: '',
-	unit: '',
-	// eslint-disable-next-line @typescript-eslint/no-explicit-any
-} as any as Query;
-
-/** Baseline for logs/traces queries — uses expression-style aggregations. */
-export const LOGS_BASELINE = {
-	queryType: 'builder',
-	builder: {
-		queryData: [
-			{
-				dataSource: 'logs',
-				queryName: 'A',
-				aggregateOperator: null,
-				aggregateAttribute: {
-					id: '----',
-					key: '',
-					dataType: '',
-					type: '',
-				},
-				timeAggregation: 'rate',
-				spaceAggregation: 'sum',
-				filter: { expression: '' },
-				aggregations: [{ expression: 'count() ' }],
-				functions: [],
-				filters: { items: [], op: 'AND' },
-				expression: 'A',
-				disabled: false,
-				stepInterval: null,
-				having: [],
-				limit: null,
-				orderBy: [],
-				groupBy: [],
-				legend: '',
-				reduceTo: 'avg',
-				source: null,
-			},
-		],
-		queryFormulas: [],
-		queryTraceOperator: [],
-	},
-	promql: [{ name: 'A', query: '', legend: '', disabled: false }],
-	clickhouse_sql: [{ name: 'A', legend: '', disabled: false, query: '' }],
-	id: '',
-	unit: '',
-	// eslint-disable-next-line @typescript-eslint/no-explicit-any
-} as any as Query;
-
-/** Baseline for traces queries — same as logs but with dataSource: traces. */
-export const TRACES_BASELINE = {
-	queryType: 'builder',
-	builder: {
-		queryData: [
-			{
-				dataSource: 'traces',
-				queryName: 'A',
-				aggregateOperator: null,
-				aggregateAttribute: {
-					id: '----',
-					key: '',
-					dataType: '',
-					type: '',
-				},
-				timeAggregation: 'rate',
-				spaceAggregation: 'sum',
-				filter: { expression: '' },
-				aggregations: [{ expression: 'count() ' }],
-				functions: [],
-				filters: { items: [], op: 'AND' },
-				expression: 'A',
-				disabled: false,
-				stepInterval: null,
-				having: [],
-				limit: null,
-				orderBy: [],
-				groupBy: [],
-				legend: '',
-				reduceTo: 'avg',
-				source: null,
-			},
-		],
-		queryFormulas: [],
-		queryTraceOperator: [],
-	},
-	promql: [{ name: 'A', query: '', legend: '', disabled: false }],
-	clickhouse_sql: [{ name: 'A', legend: '', disabled: false, query: '' }],
-	id: '',
-	unit: '',
-	// eslint-disable-next-line @typescript-eslint/no-explicit-any
-} as any as Query;
-
-/** Baseline tag indicators for URL encoding. */
-export type BaselineTag = 'm' | 'l' | 't';
-
-/** Pick optimal baseline based on query's primary dataSource. */
-export function pickBaseline(query: Query): {
-	baseline: Query;
-	tag: BaselineTag;
-} {
-	const ds = query.builder?.queryData?.[0]?.dataSource;
-	if (ds === 'logs') {
-		return { baseline: LOGS_BASELINE, tag: 'l' };
-	}
-	if (ds === 'traces') {
-		return { baseline: TRACES_BASELINE, tag: 't' };
-	}
-	return { baseline: METRICS_BASELINE, tag: 'm' };
-}
-
-function getBaselineByTag(tag: BaselineTag): Query {
-	if (tag === 'l') {
-		return LOGS_BASELINE;
-	}
-	if (tag === 't') {
-		return TRACES_BASELINE;
-	}
-	return METRICS_BASELINE;
-}
-
-export default getBaselineByTag;

frontend/src/lib/compositeQuery/serializer.ts

@@ -1,28 +0,0 @@
-import { jsonAdapter } from 'lib/compositeQuery/adapters/json';
-import { CompositeQueryAdapter } from 'lib/compositeQuery/types';
-import { Query } from 'types/api/queryBuilder/queryBuilderData';
-import { flatKeysAdapter } from 'lib/compositeQuery/adapters/flatKeys';
-
-// Order matters for decode: most-specific (tagged) adapters first, json last
-const ADAPTERS: CompositeQueryAdapter[] = [flatKeysAdapter, jsonAdapter];
-
-/** Encode a query to the shortest available URL value. */
-export function serialize(query: Query): string {
-	return ADAPTERS.map((adapter) => adapter.encode(query)).reduce(
-		(shortest, candidate) =>
-			candidate.length < shortest.length ? candidate : shortest,
-	);
-}
-
-/** Decode a URL value back to a Query. Total: returns null on any failure. */
-export function deserialize(raw: string): Query | null {
-	if (!raw) {
-		return null;
-	}
-	try {
-		const adapter = ADAPTERS.find((item) => item.matches(raw)) ?? jsonAdapter;
-		return adapter.decode(raw);
-	} catch {
-		return null;
-	}
-}

frontend/src/lib/compositeQuery/types.ts

@@ -1,14 +0,0 @@
-import { Query } from 'types/api/queryBuilder/queryBuilderData';
-
-/**
- * A serialization tier. `encode` returns the COMPLETE URL value (tag prefix
- * included for tagged tiers). `matches` decides whether a raw value belongs to
- * this adapter on decode. `decode` receives the COMPLETE raw value and strips
- * its own tag.
- */
-export interface CompositeQueryAdapter {
-	readonly name: string;
-	encode(query: Query): string;
-	matches(raw: string): boolean;
-	decode(raw: string): Query;
-}

frontend/src/lib/recentQueries/constants.ts

@@ -1,5 +0,0 @@
-export const STORAGE_KEY_PREFIX = 'qb_recent_v1';
-export const STORAGE_VERSION = 1;
-// Maximum entries kept per (signal, source) bucket. Larger than the UI's
-// RECENTS_DISPLAY_CAP so deleting a visible entry surfaces an older one.
-export const MAX_ENTRIES = 10;

frontend/src/lib/recentQueries/getRecentQueries.ts

@@ -1,15 +0,0 @@
-import type { SignalType } from 'types/api/v5/queryRange';
-
-import * as store from './recentQueriesStore';
-import type { RecentQueryEntry } from './types';
-
-// 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 = '',
-): RecentQueryEntry[] {
-	return store.list(signal, source);
-}

frontend/src/lib/recentQueries/normalize.test.ts

@@ -1,100 +0,0 @@
-import { normalizeFilterExpression } from './normalize';
-
-describe('normalizeFilterExpression', () => {
-	it('returns empty string for empty input', () => {
-		expect(normalizeFilterExpression('')).toBe('');
-	});
-
-	it('returns empty string for whitespace-only input', () => {
-		expect(normalizeFilterExpression('   \t  ')).toBe('');
-	});
-
-	it('strips whitespace around operators', () => {
-		expect(normalizeFilterExpression('  a = 1  ')).toBe('a=1');
-		expect(normalizeFilterExpression('a   =    1')).toBe('a=1');
-		expect(normalizeFilterExpression('a=1')).toBe('a=1');
-	});
-
-	it('lowercases AND / OR / NOT outside quotes', () => {
-		expect(normalizeFilterExpression('A AND B OR NOT C')).toBe('AandBornotC');
-	});
-
-	it('lowercases IN / LIKE / ILIKE / CONTAINS', () => {
-		expect(normalizeFilterExpression('host IN [1, 2] AND name LIKE "foo"')).toBe(
-			'hostin[1,2]andnamelike"foo"',
-		);
-	});
-
-	it('lowercases REGEXP', () => {
-		expect(normalizeFilterExpression('path REGEXP "foo"')).toBe(
-			'pathregexp"foo"',
-		);
-		expect(normalizeFilterExpression('path REGEXP "foo"')).toBe(
-			normalizeFilterExpression('path regexp "foo"'),
-		);
-	});
-
-	it('lowercases HAS / HASANY / HASALL / HASTOKEN function names', () => {
-		expect(normalizeFilterExpression('HAS(tags, "x")')).toBe(
-			normalizeFilterExpression('has(tags, "x")'),
-		);
-		expect(normalizeFilterExpression('HASANY(tags, ["a","b"])')).toBe(
-			normalizeFilterExpression('hasAny(tags, ["a","b"])'),
-		);
-		expect(normalizeFilterExpression('HASALL(tags, ["a","b"])')).toBe(
-			normalizeFilterExpression('hasAll(tags, ["a","b"])'),
-		);
-		expect(normalizeFilterExpression('HASTOKEN(msg, "err")')).toBe(
-			normalizeFilterExpression('hasToken(msg, "err")'),
-		);
-	});
-
-	it('lowercases TRUE / FALSE boolean literals', () => {
-		expect(normalizeFilterExpression('active = TRUE')).toBe(
-			normalizeFilterExpression('active = true'),
-		);
-		expect(normalizeFilterExpression('active = FALSE')).toBe(
-			normalizeFilterExpression('active = false'),
-		);
-	});
-
-	it('preserves whitespace and casing inside single-quoted strings', () => {
-		expect(normalizeFilterExpression("a = 'X  Y'")).toBe("a='X  Y'");
-	});
-
-	it('preserves whitespace and casing inside double-quoted strings', () => {
-		expect(normalizeFilterExpression('a   =   "X  Y"')).toBe('a="X  Y"');
-	});
-
-	it('does not lowercase keyword-looking substrings inside quotes', () => {
-		expect(normalizeFilterExpression("msg = 'AND ERROR'")).toBe(
-			"msg='AND ERROR'",
-		);
-	});
-
-	it('handles escaped quotes inside strings', () => {
-		expect(normalizeFilterExpression("msg = 'a\\'b' AND x = 1")).toBe(
-			"msg='a\\'b'andx=1",
-		);
-	});
-
-	it('treats two formattings of the same expression as identical', () => {
-		const a = normalizeFilterExpression(
-			'service.name = "frontend" AND severity = error',
-		);
-		const b = normalizeFilterExpression(
-			'service.name="frontend"   and  severity=error',
-		);
-		expect(a).toBe(b);
-	});
-
-	it('preserves unquoted value casing (treats them as identifiers)', () => {
-		expect(normalizeFilterExpression('status = OK')).toBe('status=OK');
-	});
-
-	it('handles mixed quotes in one expression', () => {
-		expect(normalizeFilterExpression(`a = 'X' AND b = "Y"`)).toBe(
-			`a='X'andb="Y"`,
-		);
-	});
-});

frontend/src/lib/recentQueries/normalize.ts

@@ -1,56 +0,0 @@
-import {
-	OPERATORS,
-	QUERY_BUILDER_FUNCTIONS,
-	TRACE_OPERATOR_OPERATORS,
-} from 'constants/antlrQueryConstants';
-
-// Reserved keywords sourced from the ANTLR grammar constants so this list stays
-// in sync with the parser. `\b` prevents partial matches inside identifiers
-// (e.g. `OR` inside `originator`). `TRUE`/`FALSE` are BOOL literals, included
-// so case variants of boolean values also dedup.
-const WORD_KEYWORDS = [
-	...Object.keys(OPERATORS).filter((k) => /^[A-Z]+$/.test(k)),
-	...Object.keys(TRACE_OPERATOR_OPERATORS).filter((k) => /^[A-Z]+$/.test(k)),
-	...Object.values(QUERY_BUILDER_FUNCTIONS),
-	'TRUE',
-	'FALSE',
-];
-
-const KEYWORDS_RE = new RegExp(`\\b(${WORD_KEYWORDS.join('|')})\\b`, 'gi');
-
-// Matches single- or double-quoted string literals, supporting escaped quotes
-// (e.g. `'it\'s'` or `"a \" b"`). We preserve quoted spans verbatim during
-// normalisation so user-meaningful whitespace and casing inside string values
-// stays intact: `name = "Foo Bar"` must not collapse to `name="foobar"`.
-const QUOTED_RE = /'(?:\\.|[^'\\])*'|"(?:\\.|[^"\\])*"/g;
-
-// Lowercases reserved keywords and strips ALL whitespace from the unquoted regions
-// of the input. Keywords are normalised so casing variants dedup; whitespace is
-// dropped so formatting variants (`a=1` vs `a = 1`) dedup too.
-function processOutsideQuotes(s: string): string {
-	return s.replace(KEYWORDS_RE, (m) => m.toLowerCase()).replace(/\s+/g, '');
-}
-
-// Produces a canonical form of a filter expression suitable for dedup-key derivation.
-// Walks the input alternating between unquoted regions (where we normalise keywords
-// and whitespace) and quoted regions (which we copy verbatim).
-export function normalizeFilterExpression(input: string): string {
-	if (!input) {
-		return '';
-	}
-
-	let result = '';
-	let lastIndex = 0;
-	QUOTED_RE.lastIndex = 0;
-
-	let match = QUOTED_RE.exec(input);
-	while (match !== null) {
-		result += processOutsideQuotes(input.slice(lastIndex, match.index));
-		result += match[0];
-		lastIndex = QUOTED_RE.lastIndex;
-		match = QUOTED_RE.exec(input);
-	}
-	result += processOutsideQuotes(input.slice(lastIndex));
-
-	return result.trim();
-}

frontend/src/lib/recentQueries/recentQueriesStore.test.ts

@@ -1,247 +0,0 @@
-import { MAX_ENTRIES } from './constants';
-import * as store from './recentQueriesStore';
-import type { RecentQueryInput } from './recentQueriesStore';
-import type { RecentQueryEntry } from './types';
-
-const baseInput = (
-	overrides: Partial<RecentQueryInput> = {},
-): RecentQueryInput => ({
-	signal: 'logs',
-	filter: { expression: "service.name = 'frontend'" },
-	...overrides,
-});
-
-function saveOrThrow(input: RecentQueryInput): RecentQueryEntry {
-	const saved = store.save(input);
-	if (!saved) {
-		throw new Error('expected save to return an entry');
-	}
-	return saved;
-}
-
-describe('recentQueries store', () => {
-	beforeEach(() => {
-		store.useRecentQueriesStore.setState({ buckets: {} });
-		localStorage.clear();
-	});
-
-	describe('save + list', () => {
-		it('saves an entry and lists it', () => {
-			store.save(baseInput());
-			const entries = store.list('logs');
-			expect(entries).toHaveLength(1);
-			expect(entries[0].filter.expression).toBe("service.name = 'frontend'");
-			expect(entries[0].id).toBeTruthy();
-			expect(entries[0].lastUsedAt).toBeGreaterThan(0);
-		});
-
-		it('does not save when the filter expression is empty', () => {
-			const result = store.save(baseInput({ filter: { expression: '' } }));
-			expect(result).toBeNull();
-			expect(store.list('logs')).toHaveLength(0);
-		});
-
-		it('does not save when the filter expression is whitespace only', () => {
-			const result = store.save(baseInput({ filter: { expression: '   ' } }));
-			expect(result).toBeNull();
-			expect(store.list('logs')).toHaveLength(0);
-		});
-	});
-
-	describe('LRU ordering', () => {
-		it('places the most recently saved entry at the front', () => {
-			store.save(baseInput({ filter: { expression: "severity_text = 'ERROR'" } }));
-			store.save(baseInput({ filter: { expression: 'http.status_code >= 500' } }));
-			store.save(baseInput({ filter: { expression: 'attempt = 1' } }));
-
-			const entries = store.list('logs');
-			expect(entries.map((e) => e.filter.expression)).toStrictEqual([
-				'attempt = 1',
-				'http.status_code >= 500',
-				"severity_text = 'ERROR'",
-			]);
-		});
-
-		it('re-saving an existing filter bumps it to the front', () => {
-			store.save(baseInput({ filter: { expression: "severity_text = 'ERROR'" } }));
-			store.save(baseInput({ filter: { expression: 'http.status_code >= 500' } }));
-			store.save(baseInput({ filter: { expression: "severity_text = 'ERROR'" } }));
-
-			const entries = store.list('logs');
-			expect(entries).toHaveLength(2);
-			expect(entries.map((e) => e.filter.expression)).toStrictEqual([
-				"severity_text = 'ERROR'",
-				'http.status_code >= 500',
-			]);
-		});
-	});
-
-	describe('dedup', () => {
-		it('treats formatting variations of the same filter as one entry', () => {
-			store.save(
-				baseInput({
-					filter: { expression: "severity_text = 'ERROR' AND attempt = 1" },
-				}),
-			);
-			store.save(
-				baseInput({
-					filter: { expression: "severity_text='ERROR'   and    attempt=1" },
-				}),
-			);
-
-			expect(store.list('logs')).toHaveLength(1);
-		});
-	});
-
-	describe('signal partitioning', () => {
-		it('saves to the right bucket per signal', () => {
-			store.save(
-				baseInput({
-					signal: 'logs',
-					filter: { expression: "severity_text = 'ERROR'" },
-				}),
-			);
-			store.save(
-				baseInput({
-					signal: 'traces',
-					filter: { expression: "service.name = 'orders-api'" },
-				}),
-			);
-			store.save(
-				baseInput({
-					signal: 'metrics',
-					filter: { expression: 'cpu_usage > 80' },
-				}),
-			);
-
-			expect(store.list('logs')).toHaveLength(1);
-			expect(store.list('traces')).toHaveLength(1);
-			expect(store.list('metrics')).toHaveLength(1);
-			expect(store.list('logs')[0].filter.expression).toBe(
-				"severity_text = 'ERROR'",
-			);
-			expect(store.list('traces')[0].filter.expression).toBe(
-				"service.name = 'orders-api'",
-			);
-			expect(store.list('metrics')[0].filter.expression).toBe('cpu_usage > 80');
-		});
-
-		it('does not leak between signals on dedup', () => {
-			store.save(
-				baseInput({
-					signal: 'logs',
-					filter: { expression: "service.name = 'frontend'" },
-				}),
-			);
-			store.save(
-				baseInput({
-					signal: 'traces',
-					filter: { expression: "service.name = 'frontend'" },
-				}),
-			);
-
-			expect(store.list('logs')).toHaveLength(1);
-			expect(store.list('traces')).toHaveLength(1);
-		});
-	});
-
-	describe('LRU cap', () => {
-		it('caps the bucket at MAX_ENTRIES and evicts the oldest', () => {
-			const total = MAX_ENTRIES + 1;
-			for (let i = 0; i < total; i += 1) {
-				store.save(baseInput({ filter: { expression: `attempt = ${i}` } }));
-			}
-
-			const entries = store.list('logs');
-			expect(entries).toHaveLength(MAX_ENTRIES);
-			expect(entries[0].filter.expression).toBe(`attempt = ${total - 1}`);
-			expect(entries.some((e) => e.filter.expression === 'attempt = 0')).toBe(
-				false,
-			);
-		});
-	});
-
-	describe('remove', () => {
-		it('removes an entry by id', () => {
-			store.save(baseInput({ filter: { expression: "severity_text = 'ERROR'" } }));
-			const saved = saveOrThrow(
-				baseInput({ filter: { expression: 'http.status_code >= 500' } }),
-			);
-			store.remove(saved.id, 'logs');
-
-			const entries = store.list('logs');
-			expect(entries).toHaveLength(1);
-			expect(entries[0].filter.expression).toBe("severity_text = 'ERROR'");
-		});
-
-		it('is a no-op when the id does not exist', () => {
-			store.save(baseInput({ filter: { expression: "severity_text = 'ERROR'" } }));
-			store.remove('does-not-exist', 'logs');
-			expect(store.list('logs')).toHaveLength(1);
-		});
-
-		it('does not touch other signals', () => {
-			const logsEntry = saveOrThrow(
-				baseInput({
-					signal: 'logs',
-					filter: { expression: "service.name = 'frontend'" },
-				}),
-			);
-			store.save(
-				baseInput({
-					signal: 'traces',
-					filter: { expression: "service.name = 'frontend'" },
-				}),
-			);
-
-			store.remove(logsEntry.id, 'logs');
-
-			expect(store.list('logs')).toHaveLength(0);
-			expect(store.list('traces')).toHaveLength(1);
-		});
-	});
-
-	describe('persistence', () => {
-		it('reads back the same entries after the in-memory state is reset', () => {
-			store.save(baseInput({ filter: { expression: "severity_text = 'ERROR'" } }));
-			store.save(baseInput({ filter: { expression: 'http.status_code >= 500' } }));
-
-			store.useRecentQueriesStore.setState({ buckets: {} });
-
-			const entries = store.list('logs');
-			expect(entries.map((e) => e.filter.expression)).toStrictEqual([
-				'http.status_code >= 500',
-				"severity_text = 'ERROR'",
-			]);
-		});
-	});
-
-	describe('reactive subscription via zustand', () => {
-		it('notifies zustand subscribers on save', () => {
-			const cb = jest.fn();
-			const unsubscribe = store.useRecentQueriesStore.subscribe(cb);
-			store.save(baseInput({ filter: { expression: "severity_text = 'ERROR'" } }));
-			expect(cb).toHaveBeenCalledTimes(1);
-			unsubscribe();
-		});
-
-		it('notifies zustand subscribers on remove', () => {
-			const saved = saveOrThrow(
-				baseInput({ filter: { expression: "severity_text = 'ERROR'" } }),
-			);
-			const cb = jest.fn();
-			const unsubscribe = store.useRecentQueriesStore.subscribe(cb);
-			store.remove(saved.id, 'logs');
-			expect(cb).toHaveBeenCalledTimes(1);
-			unsubscribe();
-		});
-
-		it('stops notifying after unsubscribe', () => {
-			const cb = jest.fn();
-			const unsubscribe = store.useRecentQueriesStore.subscribe(cb);
-			unsubscribe();
-			store.save(baseInput({ filter: { expression: "severity_text = 'ERROR'" } }));
-			expect(cb).not.toHaveBeenCalled();
-		});
-	});
-});

frontend/src/lib/recentQueries/recentQueriesStore.ts

@@ -1,144 +0,0 @@
-import get from 'api/browser/localstorage/get';
-import set from 'api/browser/localstorage/set';
-import type { SignalType } from 'types/api/v5/queryRange';
-import { create } from 'zustand';
-
-import { MAX_ENTRIES, STORAGE_VERSION } from './constants';
-import { normalizeFilterExpression } from './normalize';
-import type { RecentQueriesStoreShape, RecentQueryEntry } from './types';
-import { bucketKey, makeId, normalizeSource, storageKeyFor } from './utils';
-
-// Mirrors parsed localStorage so equal raw strings return the same array ref —
-// preserves Object.is for zustand selector bail-out.
-const persistedBucketCache = new Map<
-	string,
-	{ raw: string; parsed: RecentQueryEntry[] }
->();
-
-function loadBucketFromStorage(
-	signal: SignalType,
-	source: string,
-): RecentQueryEntry[] | null {
-	const key = bucketKey(signal, source);
-	try {
-		const raw = get(storageKeyFor(signal, source));
-		if (!raw) {
-			persistedBucketCache.delete(key);
-			return null;
-		}
-		const cached = persistedBucketCache.get(key);
-		if (cached && cached.raw === raw) {
-			return cached.parsed;
-		}
-		const parsedShape = JSON.parse(raw) as RecentQueriesStoreShape;
-		if (
-			parsedShape?.version !== STORAGE_VERSION ||
-			!Array.isArray(parsedShape.entries)
-		) {
-			persistedBucketCache.delete(key);
-			return null;
-		}
-		persistedBucketCache.set(key, { raw, parsed: parsedShape.entries });
-		return parsedShape.entries;
-	} catch {
-		persistedBucketCache.delete(key);
-		return null;
-	}
-}
-
-function saveBucketToStorage(
-	signal: SignalType,
-	source: string,
-	entries: RecentQueryEntry[],
-): void {
-	try {
-		const raw = JSON.stringify({ version: STORAGE_VERSION, entries });
-		if (set(storageKeyFor(signal, source), raw)) {
-			persistedBucketCache.set(bucketKey(signal, source), {
-				raw,
-				parsed: entries,
-			});
-		}
-	} catch {
-		// Ignore storage errors (e.g. quota exceeded, JSON.stringify failure).
-	}
-}
-
-export type RecentQueryInput = Omit<
-	RecentQueryEntry,
-	'id' | 'lastUsedAt' | 'source'
-> & {
-	source?: string;
-};
-
-type RecentQueriesState = {
-	buckets: Record<string, RecentQueryEntry[]>;
-	save: (entry: RecentQueryInput) => RecentQueryEntry | null;
-	remove: (id: string, signal: SignalType, source?: string) => void;
-};
-
-export const useRecentQueriesStore = create<RecentQueriesState>()(
-	(set, get) => ({
-		buckets: {},
-
-		save: (entry): RecentQueryEntry | null => {
-			const normalized = normalizeFilterExpression(entry.filter.expression);
-			if (!normalized) {
-				return null;
-			}
-			const source = normalizeSource(entry.source);
-			const key = bucketKey(entry.signal, source);
-
-			const current =
-				get().buckets[key] ?? loadBucketFromStorage(entry.signal, source) ?? [];
-			const filtered = current.filter(
-				(e) => normalizeFilterExpression(e.filter.expression) !== normalized,
-			);
-
-			const newEntry: RecentQueryEntry = {
-				...entry,
-				source,
-				id: makeId(entry.signal, source, normalized),
-				lastUsedAt: Date.now(),
-			};
-
-			const next = [newEntry, ...filtered].slice(0, MAX_ENTRIES);
-			set({ buckets: { ...get().buckets, [key]: next } });
-			saveBucketToStorage(entry.signal, source, next);
-			return newEntry;
-		},
-
-		remove: (id, signal, source = ''): void => {
-			const key = bucketKey(signal, source);
-			const current = get().buckets[key] ?? loadBucketFromStorage(signal, source);
-			if (!current) {
-				return;
-			}
-			const next = current.filter((e) => e.id !== id);
-			if (next.length === current.length) {
-				return;
-			}
-			set({ buckets: { ...get().buckets, [key]: next } });
-			saveBucketToStorage(signal, source, next);
-		},
-	}),
-);
-
-// Plain-function wrappers for non-React callers — same pattern as useColumnStore.ts.
-export function save(entry: RecentQueryInput): RecentQueryEntry | null {
-	return useRecentQueriesStore.getState().save(entry);
-}
-
-export function remove(id: string, signal: SignalType, source = ''): void {
-	useRecentQueriesStore.getState().remove(id, signal, source);
-}
-
-// Synchronous bucket read with localStorage fallback for non-React callers.
-export function list(signal: SignalType, source = ''): RecentQueryEntry[] {
-	const key = bucketKey(signal, source);
-	const state = useRecentQueriesStore.getState();
-	if (state.buckets[key]) {
-		return state.buckets[key];
-	}
-	return loadBucketFromStorage(signal, source) ?? [];
-}

frontend/src/lib/recentQueries/saveRecentQuery.test.ts

@@ -1,113 +0,0 @@
-import { DataSource } from 'types/common/queryBuilder';
-import type { IBuilderQuery } from 'types/api/queryBuilder/queryBuilderData';
-import { validateQuery } from 'utils/queryValidationUtils';
-
-import * as store from './recentQueriesStore';
-import { saveRecentQuery } from './saveRecentQuery';
-
-jest.mock('utils/queryValidationUtils', () => ({
-	validateQuery: jest.fn(),
-}));
-
-const mockedValidateQuery = validateQuery as jest.MockedFunction<
-	typeof validateQuery
->;
-
-const buildComposite = (
-	overrides: Partial<IBuilderQuery>[] = [{}],
-): { builder: { queryData: IBuilderQuery[] } } => ({
-	builder: {
-		queryData: overrides.map((o, i) => ({
-			queryName: `Q${i}`,
-			dataSource: DataSource.LOGS,
-			aggregateOperator: 'count',
-			aggregateAttribute: undefined as never,
-			functions: [],
-			filter: { expression: 'service.name = "frontend"' },
-			groupBy: [],
-			expression: `Q${i}`,
-			disabled: false,
-			having: [],
-			limit: null,
-			stepInterval: null,
-			orderBy: [],
-			legend: '',
-			...o,
-		})) as IBuilderQuery[],
-	},
-});
-
-describe('saveRecentQuery', () => {
-	beforeEach(() => {
-		store.useRecentQueriesStore.setState({ buckets: {} });
-		localStorage.clear();
-		mockedValidateQuery.mockReturnValue({
-			isValid: true,
-			message: '',
-			errors: [],
-		});
-	});
-
-	it('saves the composite query when validation passes', () => {
-		saveRecentQuery(buildComposite());
-
-		const entries = store.list('logs');
-		expect(entries).toHaveLength(1);
-		expect(entries[0].filter.expression).toBe('service.name = "frontend"');
-	});
-
-	it('does not save when validateQuery rejects the expression', () => {
-		mockedValidateQuery.mockReturnValue({
-			isValid: false,
-			message: 'bad',
-			errors: [],
-		});
-
-		saveRecentQuery(buildComposite());
-
-		expect(store.list('logs')).toHaveLength(0);
-	});
-
-	it('does not save a builder query with an empty filter expression', () => {
-		saveRecentQuery(buildComposite([{ filter: { expression: '' } }]));
-
-		expect(store.list('logs')).toHaveLength(0);
-	});
-
-	it('saves each builder query in the composite separately', () => {
-		saveRecentQuery(
-			buildComposite([
-				{
-					dataSource: DataSource.LOGS,
-					filter: { expression: "service.name = 'frontend'" },
-				},
-				{
-					dataSource: DataSource.TRACES,
-					filter: { expression: "service.name = 'orders-api'" },
-				},
-			]),
-		);
-
-		expect(store.list('logs')).toHaveLength(1);
-		expect(store.list('traces')).toHaveLength(1);
-	});
-
-	it('skips builder queries whose dataSource is not a supported signal', () => {
-		saveRecentQuery(
-			buildComposite([{ dataSource: 'unknown' as IBuilderQuery['dataSource'] }]),
-		);
-
-		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 composite is null, undefined, or empty', () => {
-		saveRecentQuery(null);
-		saveRecentQuery(undefined);
-		saveRecentQuery({ builder: { queryData: [] } });
-		saveRecentQuery({});
-
-		expect(store.list('logs')).toHaveLength(0);
-	});
-});

frontend/src/lib/recentQueries/saveRecentQuery.ts

@@ -1,52 +0,0 @@
-import type { IBuilderQuery } from 'types/api/queryBuilder/queryBuilderData';
-import type { SignalType } from 'types/api/v5/queryRange';
-import { validateQuery } from 'utils/queryValidationUtils';
-
-import * as store from './recentQueriesStore';
-
-function toSignal(dataSource: IBuilderQuery['dataSource']): SignalType | null {
-	if (
-		dataSource === 'logs' ||
-		dataSource === 'traces' ||
-		dataSource === 'metrics'
-	) {
-		return dataSource;
-	}
-	return null;
-}
-
-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: CompositeWithBuilder | null | undefined,
-): void {
-	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;
-		}
-		const validation = validateQuery(expression);
-		if (!validation.isValid) {
-			return;
-		}
-		const signal = toSignal(q.dataSource);
-		if (!signal) {
-			return;
-		}
-		store.save({
-			signal,
-			source: q.source ?? '',
-			filter: q.filter ?? { expression: '' },
-		});
-	});
-}

frontend/src/lib/recentQueries/types.ts

@@ -1,14 +0,0 @@
-import type { Filter, SignalType } from 'types/api/v5/queryRange';
-
-export interface RecentQueryEntry {
-	id: string;
-	signal: SignalType;
-	source: string;
-	filter: Filter;
-	lastUsedAt: number;
-}
-
-export interface RecentQueriesStoreShape {
-	version: 1;
-	entries: RecentQueryEntry[];
-}

frontend/src/lib/recentQueries/utils.ts

@@ -1,24 +0,0 @@
-import type { SignalType } from 'types/api/v5/queryRange';
-
-import { STORAGE_KEY_PREFIX } from './constants';
-
-export function normalizeSource(source: string | undefined): string {
-	return source ?? '';
-}
-
-export function bucketKey(signal: SignalType, source: string): string {
-	return `${signal}:${source}`;
-}
-
-export function storageKeyFor(signal: SignalType, source: string): string {
-	return `${STORAGE_KEY_PREFIX}:${bucketKey(signal, source)}`;
-}
-
-// Same (signal, source, normalized filter) ⇒ same id ⇒ upsert.
-export function makeId(
-	signal: SignalType,
-	source: string,
-	normalizedFilter: string,
-): string {
-	return `${signal}|${source}|${normalizedFilter}`;
-}

frontend/src/pages/DashboardPage/DashboardPage.tsx

@@ -1,53 +0,0 @@
-import { useEffect } from 'react';
-import { useParams } from 'react-router-dom';
-import { Modal } from 'antd';
-import { Typography } from '@signozhq/ui/typography';
-import { AxiosError } from 'axios';
-import NotFound from 'components/NotFound';
-import Spinner from 'components/Spinner';
-import DashboardContainer from 'container/DashboardContainer';
-import { useDashboardBootstrap } from 'hooks/dashboard/useDashboardBootstrap';
-import { useDashboardStore } from 'providers/Dashboard/store/useDashboardStore';
-import { ErrorType } from 'types/common';
-
-function DashboardPage(): JSX.Element {
-	const { dashboardId } = useParams<{ dashboardId: string }>();
-
-	const [onModal, Content] = Modal.useModal();
-
-	const { isLoading, isError, isFetching, error } = useDashboardBootstrap(
-		dashboardId,
-		{ confirm: onModal.confirm },
-	);
-
-	const dashboardTitle = useDashboardStore((s) => s.dashboardData?.data.title);
-
-	useEffect(() => {
-		document.title = dashboardTitle || document.title;
-	}, [dashboardTitle]);
-
-	const errorMessage = isError
-		? (error as AxiosError<{ errorType: string }>)?.response?.data?.errorType
-		: 'Something went wrong';
-
-	if (isError && !isFetching && errorMessage === ErrorType.NotFound) {
-		return <NotFound />;
-	}
-
-	if (isError && errorMessage) {
-		return <Typography>{errorMessage}</Typography>;
-	}
-
-	if (isLoading) {
-		return <Spinner tip="Loading.." />;
-	}
-
-	return (
-		<>
-			{Content}
-			<DashboardContainer />
-		</>
-	);
-}
-
-export default DashboardPage;

frontend/src/pages/DashboardPage/index.tsx

@@ -1,15 +1,53 @@
-import { useIsDashboardV2 } from 'hooks/useIsDashboardV2';
-import DashboardPageV2 from 'pages/DashboardPageV2';
+import { useEffect } from 'react';
+import { useParams } from 'react-router-dom';
+import { Modal } from 'antd';
+import { Typography } from '@signozhq/ui/typography';
+import { AxiosError } from 'axios';
+import NotFound from 'components/NotFound';
+import Spinner from 'components/Spinner';
+import DashboardContainer from 'container/DashboardContainer';
+import { useDashboardBootstrap } from 'hooks/dashboard/useDashboardBootstrap';
+import { useDashboardStore } from 'providers/Dashboard/store/useDashboardStore';
+import { ErrorType } from 'types/common';
 
-import DashboardPage from './DashboardPage';
+function DashboardPage(): JSX.Element {
+	const { dashboardId } = useParams<{ dashboardId: string }>();
 
-// Serves the V2 dashboard detail page when the `use_dashboard_v2` flag is active;
-// otherwise the existing V1 page. Lets V2 dark-ship behind the flag without
-// changing route definitions.
-function DashboardPageEntry(): JSX.Element {
-	const isDashboardV2 = useIsDashboardV2();
+	const [onModal, Content] = Modal.useModal();
 
-	return isDashboardV2 ? <DashboardPageV2 /> : <DashboardPage />;
+	const { isLoading, isError, isFetching, error } = useDashboardBootstrap(
+		dashboardId,
+		{ confirm: onModal.confirm },
+	);
+
+	const dashboardTitle = useDashboardStore((s) => s.dashboardData?.data.title);
+
+	useEffect(() => {
+		document.title = dashboardTitle || document.title;
+	}, [dashboardTitle]);
+
+	const errorMessage = isError
+		? (error as AxiosError<{ errorType: string }>)?.response?.data?.errorType
+		: 'Something went wrong';
+
+	if (isError && !isFetching && errorMessage === ErrorType.NotFound) {
+		return <NotFound />;
+	}
+
+	if (isError && errorMessage) {
+		return <Typography>{errorMessage}</Typography>;
+	}
+
+	if (isLoading) {
+		return <Spinner tip="Loading.." />;
+	}
+
+	return (
+		<>
+			{Content}
+			<DashboardContainer />
+		</>
+	);
 }
 
-export default DashboardPageEntry;
+export default DashboardPage;

frontend/src/pages/DashboardPageV2/DashboardContainer/DashboardSettings/Variables/VariableForm/DynamicVariableFields.tsx

@@ -1,103 +0,0 @@
-import { useEffect, useMemo, useState } from 'react';
-import { SelectSimple } from '@signozhq/ui/select';
-import { Typography } from '@signozhq/ui/typography';
-import cx from 'classnames';
-// eslint-disable-next-line signoz/no-antd-components -- searchable async select: no @signozhq/ui equivalent
-import { Select } from 'antd';
-import { useGetFieldKeys } from 'hooks/dynamicVariables/useGetFieldKeys';
-import { useGetFieldValues } from 'hooks/dynamicVariables/useGetFieldValues';
-import useDebounce from 'hooks/useDebounce';
-
-import { TELEMETRY_SIGNALS, type TelemetrySignal } from '../variableModel';
-import styles from './VariableForm.module.scss';
-
-interface DynamicVariableFieldsProps {
-	attribute: string;
-	signal: TelemetrySignal;
-	onChange: (patch: {
-		dynamicAttribute?: string;
-		dynamicSignal?: TelemetrySignal;
-	}) => void;
-	onPreview: (values: (string | number)[]) => void;
-}
-
-/** Dynamic-variable body: telemetry signal + field, whose live values preview. */
-function DynamicVariableFields({
-	attribute,
-	signal,
-	onChange,
-	onPreview,
-}: DynamicVariableFieldsProps): JSX.Element {
-	const [search, setSearch] = useState('');
-	const debouncedSearch = useDebounce(search, 300);
-
-	const { data: keyData, isLoading } = useGetFieldKeys({
-		signal,
-		name: debouncedSearch || undefined,
-	});
-
-	// `keys` is a Record keyed BY field name; the field names are the map keys.
-	// When the API reports the list is `complete`, search filters locally.
-	const isComplete = keyData?.data?.complete === true;
-	const options = useMemo(
-		() =>
-			Object.keys(keyData?.data?.keys ?? {}).map((name) => ({
-				label: name,
-				value: name,
-			})),
-		[keyData],
-	);
-
-	const { data: valueData } = useGetFieldValues({
-		signal,
-		name: attribute,
-		enabled: !!attribute,
-	});
-
-	useEffect(() => {
-		const payload = valueData?.data;
-		const values =
-			payload?.normalizedValues ?? payload?.values?.StringValues ?? [];
-		onPreview(values);
-		// eslint-disable-next-line react-hooks/exhaustive-deps
-	}, [valueData]);
-
-	return (
-		<>
-			<div className={cx(styles.row, styles.sortSection)}>
-				<div className={styles.labelContainer}>
-					<Typography.Text className={styles.label}>Source</Typography.Text>
-				</div>
-				<SelectSimple
-					className={styles.sortSelect}
-					value={signal}
-					items={TELEMETRY_SIGNALS.map((s) => ({ label: s, value: s }))}
-					onChange={(value): void =>
-						onChange({ dynamicSignal: value as TelemetrySignal })
-					}
-					testId="variable-signal-select"
-				/>
-			</div>
-			<div className={cx(styles.row, styles.sortSection)}>
-				<div className={styles.labelContainer}>
-					<Typography.Text className={styles.label}>Attribute</Typography.Text>
-				</div>
-				<Select
-					className={styles.searchSelect}
-					showSearch
-					value={attribute || undefined}
-					placeholder="Select a telemetry field"
-					loading={isLoading}
-					filterOption={isComplete}
-					onSearch={setSearch}
-					onChange={(value): void => onChange({ dynamicAttribute: value as string })}
-					options={options}
-					notFoundContent={isLoading ? 'Loading…' : 'No fields found'}
-					data-testid="variable-field-select"
-				/>
-			</div>
-		</>
-	);
-}
-
-export default DynamicVariableFields;

frontend/src/pages/DashboardPageV2/DashboardContainer/DashboardSettings/Variables/VariableForm/QueryVariableFields.tsx

@@ -1,93 +0,0 @@
-import { useState } from 'react';
-import { Button } from '@signozhq/ui/button';
-import { Typography } from '@signozhq/ui/typography';
-import dashboardVariablesQuery from 'api/dashboard/variables/dashboardVariablesQuery';
-import Editor from 'components/Editor';
-import sortValues from 'lib/dashboardVariables/sortVariableValues';
-
-import type { VariableSort } from '../variableModel';
-import styles from './VariableForm.module.scss';
-
-interface QueryVariableFieldsProps {
-	queryValue: string;
-	sort: VariableSort;
-	onChange: (queryValue: string) => void;
-	onPreview: (values: (string | number)[]) => void;
-	onError: (message: string | null) => void;
-}
-
-/** Query-variable body: SQL editor + "Test Run Query" that previews the values. */
-function QueryVariableFields({
-	queryValue,
-	sort,
-	onChange,
-	onPreview,
-	onError,
-}: QueryVariableFieldsProps): JSX.Element {
-	const [isRunning, setIsRunning] = useState(false);
-
-	const runTest = async (): Promise<void> => {
-		setIsRunning(true);
-		onError(null);
-		try {
-			const res = await dashboardVariablesQuery({
-				query: queryValue,
-				variables: {},
-			});
-			if (res.statusCode === 200 && res.payload) {
-				onPreview(
-					sortValues(res.payload.variableValues ?? [], sort) as (string | number)[],
-				);
-			} else {
-				onError(res.error || 'Failed to run query');
-				onPreview([]);
-			}
-		} catch (err) {
-			onError((err as Error).message || 'Failed to run query');
-			onPreview([]);
-		} finally {
-			setIsRunning(false);
-		}
-	};
-
-	return (
-		<div className={styles.queryContainer}>
-			<div className={styles.labelContainer}>
-				<Typography.Text className={styles.label}>Query</Typography.Text>
-			</div>
-			<div className={styles.editorWrap}>
-				<Editor
-					language="sql"
-					value={queryValue}
-					onChange={(value): void => onChange(value)}
-					height="240px"
-					options={{
-						fontSize: 13,
-						wordWrap: 'on',
-						lineNumbers: 'off',
-						glyphMargin: false,
-						folding: false,
-						lineDecorationsWidth: 0,
-						lineNumbersMinChars: 0,
-						minimap: { enabled: false },
-					}}
-				/>
-			</div>
-			<div className={styles.testRow}>
-				<Button
-					variant="solid"
-					color="primary"
-					size="sm"
-					loading={isRunning}
-					disabled={!queryValue}
-					onClick={runTest}
-					testId="variable-test-run"
-				>
-					Test Run Query
-				</Button>
-			</div>
-		</div>
-	);
-}
-
-export default QueryVariableFields;

frontend/src/pages/DashboardPageV2/DashboardContainer/DashboardSettings/Variables/VariableForm/VariableForm.module.scss

@@ -1,310 +0,0 @@
-/* Faithful reproduction of the V1 VariableItem layout, scoped as a module and
-   built on @signozhq components where possible. antd is retained only for the
-   monaco Editor, multiline TextArea, Collapse, and searchable Selects. */
-
-.container {
-	display: flex;
-	flex-direction: column;
-	border: 1px solid var(--l1-border);
-	border-radius: 3px;
-}
-
-.allVariables {
-	display: flex;
-	align-items: center;
-	gap: 8px;
-	padding: 10px 16px;
-	border-bottom: 1px solid var(--l1-border);
-}
-
-.allVariablesBtn {
-	--button-height: 24px;
-	--button-padding: 0;
-	color: var(--muted-foreground);
-}
-
-.content {
-	display: flex;
-	flex-direction: column;
-	gap: 20px;
-	padding: 12px 16px 20px;
-}
-
-/* VariableItemRow */
-.row {
-	display: flex;
-	gap: 1rem;
-	margin-bottom: 0;
-}
-
-/* LabelContainer */
-.labelContainer {
-	width: 200px;
-}
-
-.label {
-	color: var(--l2-foreground);
-	font-family: Inter;
-	font-size: 14px;
-	font-weight: 400;
-	line-height: 20px;
-}
-
-.column {
-	flex-direction: column;
-	gap: 8px;
-}
-
-.input,
-.textarea,
-.defaultInput {
-	padding: 6px 6px 6px 8px;
-	border: 1px solid var(--l1-border);
-	border-radius: 2px;
-	background: var(--l3-background);
-}
-
-.input,
-.textarea {
-	width: 100%;
-}
-
-.defaultInput {
-	width: 342px;
-}
-
-.errorText {
-	font-size: 12px;
-	color: var(--bg-amber-500);
-}
-
-/* Variable type segmented group */
-.typeSection {
-	align-items: center;
-	justify-content: space-between;
-}
-
-.typeLabelContainer {
-	display: flex;
-	align-items: center;
-	gap: 8px;
-	width: auto;
-}
-
-.typeBtnGroup {
-	display: grid;
-	grid-template-columns: repeat(4, max-content);
-	height: 32px;
-	flex-shrink: 0;
-	border: 1px solid var(--l1-border);
-	border-radius: 2px;
-	background: var(--l2-background);
-	box-shadow: 0 0 8px 0 rgba(0, 0, 0, 0.1);
-}
-
-.typeBtn {
-	--button-height: 32px;
-	display: flex;
-	align-items: center;
-	justify-content: center;
-	gap: 4px;
-	min-width: 114px;
-	border-radius: 0;
-	color: var(--l2-foreground);
-
-	& + & {
-		border-left: 1px solid var(--l1-border);
-	}
-}
-
-.typeBtnSelected {
-	background: var(--l1-border);
-	color: var(--l1-foreground);
-}
-
-.betaTag {
-	margin-left: 4px;
-}
-
-/* Query */
-.queryContainer {
-	display: flex;
-	flex-flow: column wrap;
-	gap: 1rem;
-	min-width: 0;
-	margin-bottom: 0;
-}
-
-.editorWrap {
-	height: 240px;
-	overflow: hidden;
-	border: 1px solid var(--l1-border);
-	border-radius: 2px;
-}
-
-.testRow {
-	display: flex;
-	margin-top: 8px;
-}
-
-/* Custom — antd Collapse */
-.customSection {
-	margin-bottom: 0;
-}
-
-.customSection :global(.custom-collapse) {
-	width: 100%;
-	border: 1px solid var(--l1-border);
-	border-radius: 3px 3px 0 0;
-
-	:global(.ant-collapse-item) {
-		border-bottom: none;
-	}
-
-	:global(.ant-collapse-header) {
-		align-items: center;
-		gap: 8px;
-		height: 38px;
-		padding: 12px;
-		background: var(--l3-background);
-		border-radius: 3px 3px 0 0;
-	}
-
-	:global(.ant-collapse-header-text) {
-		display: flex;
-		align-items: center;
-		gap: 10px;
-		padding: 1px 2px;
-		color: var(--bg-robin-400);
-		font-family: 'Space Mono';
-		font-size: 14px;
-		line-height: 18px;
-		border-radius: 2px;
-		background: color-mix(in srgb, var(--bg-robin-400) 8%, transparent);
-	}
-
-	:global(.ant-collapse-content-box) {
-		padding: 0;
-	}
-
-	:global(.comma-input) {
-		height: 109px;
-		border: none;
-	}
-}
-
-/* Textbox */
-.textboxSection {
-	align-items: center;
-	justify-content: space-between;
-	margin-bottom: 0;
-}
-
-/* Preview strip */
-.previewSection {
-	display: flex;
-	flex-direction: column;
-	gap: 8px;
-	min-height: 88px;
-	margin-bottom: 0;
-	padding-bottom: 8px;
-	border: 1px solid var(--l1-border);
-	border-radius: 3px;
-}
-
-.previewLabel {
-	align-self: flex-start;
-	display: inline-flex;
-	align-items: center;
-	gap: 10px;
-	padding: 4px 8px;
-	color: var(--bg-robin-400);
-	font-family: 'Space Mono';
-	font-size: 14px;
-	line-height: 18px;
-	border-radius: 3px 0 2px;
-	background: color-mix(in srgb, var(--bg-robin-400) 8%, transparent);
-}
-
-.previewValues {
-	display: flex;
-	flex-flow: wrap;
-	gap: 8px;
-	padding: 4.5px 11px;
-	overflow-y: auto;
-}
-
-.previewValues [data-slot='badge'] {
-	height: 30px;
-	align-items: center;
-	color: var(--l1-foreground);
-	font-family: 'Space Mono';
-	font-size: 14px;
-	border: 1px solid var(--l1-border);
-	border-radius: 2px;
-}
-
-.previewError {
-	color: var(--bg-amber-500);
-}
-
-/* Sort / multi / all / default rows */
-.sortSection,
-.multiSection,
-.allOptionSection,
-.dynamicSection {
-	align-items: flex-start;
-	justify-content: space-between;
-	margin-bottom: 0;
-}
-
-.sortSection {
-	align-items: center;
-}
-
-.rowLabel {
-	width: 339px;
-	color: var(--l2-foreground);
-	font-family: Inter;
-	font-size: 14px;
-	line-height: 20px;
-	letter-spacing: -0.07px;
-}
-
-.sortSelect {
-	width: 192px;
-}
-
-.defaultValueSection {
-	display: grid;
-	grid-template-columns: max-content 1fr;
-	gap: 1rem;
-	align-items: center;
-	margin-bottom: 0;
-}
-
-.defaultValueSection .label {
-	display: block;
-	margin-bottom: 2px;
-}
-
-.defaultValueDesc {
-	display: block;
-	color: var(--l2-foreground);
-	font-family: Inter;
-	font-size: 11px;
-	line-height: 18px;
-	letter-spacing: -0.06px;
-}
-
-.searchSelect {
-	width: 100%;
-}
-
-/* Footer */
-.footer {
-	display: flex;
-	justify-content: flex-end;
-	gap: 1rem;
-	margin-top: 12px;
-}

frontend/src/pages/DashboardPageV2/DashboardContainer/DashboardSettings/Variables/VariableForm/VariableForm.tsx

@@ -1,351 +0,0 @@
-import { useEffect, useState } from 'react';
-import { ArrowLeft, Check, X } from '@signozhq/icons';
-import { Badge } from '@signozhq/ui/badge';
-import { Button } from '@signozhq/ui/button';
-import { Input } from '@signozhq/ui/input';
-import { SelectSimple } from '@signozhq/ui/select';
-import { Switch } from '@signozhq/ui/switch';
-import { Typography } from '@signozhq/ui/typography';
-import cx from 'classnames';
-// eslint-disable-next-line signoz/no-antd-components -- TextArea/Collapse/searchable Select: no @signozhq/ui equivalent
-import { Collapse, Input as AntdInput, Select } from 'antd';
-import { commaValuesParser } from 'lib/dashboardVariables/customCommaValuesParser';
-import sortValues from 'lib/dashboardVariables/sortVariableValues';
-
-import {
-	VARIABLE_SORTS,
-	type VariableFormModel,
-	type VariableSort,
-	type VariableType,
-} from '../variableModel';
-import DynamicVariableFields from './DynamicVariableFields';
-import QueryVariableFields from './QueryVariableFields';
-import VariableTypeSelector from './VariableTypeSelector';
-import styles from './VariableForm.module.scss';
-
-const SORT_LABEL: Record<VariableSort, string> = {
-	DISABLED: 'Disabled',
-	ASC: 'Ascending',
-	DESC: 'Descending',
-};
-
-function getNameError(name: string, existingNames: string[]): string | null {
-	if (name === '') {
-		return 'Variable name is required';
-	}
-	if (/\s/.test(name)) {
-		return 'Variable name cannot contain whitespaces';
-	}
-	if (existingNames.includes(name)) {
-		return 'Variable name already exists';
-	}
-	return null;
-}
-
-interface VariableFormProps {
-	initial: VariableFormModel;
-	/** Names of the other variables, for uniqueness validation. */
-	existingNames: string[];
-	isSaving: boolean;
-	onClose: () => void;
-	onSave: (model: VariableFormModel) => void;
-}
-
-/**
- * In-drawer variable editor reproducing the V1 VariableItem layout, built on
- * @signozhq components (antd kept only for the monaco editor, TextArea, Collapse
- * and searchable selects). Master→detail: renders in place of the list.
- */
-function VariableForm({
-	initial,
-	existingNames,
-	isSaving,
-	onClose,
-	onSave,
-}: VariableFormProps): JSX.Element {
-	const [model, setModel] = useState<VariableFormModel>(initial);
-	const [previewValues, setPreviewValues] = useState<(string | number)[]>([]);
-	const [previewError, setPreviewError] = useState<string | null>(null);
-	const [defaultValue, setDefaultValue] = useState<string>(
-		((initial.defaultValue as { value?: string })?.value ?? '') as string,
-	);
-
-	useEffect(() => {
-		setModel(initial);
-		setPreviewValues([]);
-		setPreviewError(null);
-		setDefaultValue(
-			((initial.defaultValue as { value?: string })?.value ?? '') as string,
-		);
-	}, [initial]);
-
-	const set = (patch: Partial<VariableFormModel>): void =>
-		setModel((prev) => ({ ...prev, ...patch }));
-
-	const selectType = (type: VariableType): void => {
-		set({ type });
-		setPreviewValues([]);
-		setPreviewError(null);
-	};
-
-	const onCustomChange = (value: string): void => {
-		set({ customValue: value });
-		setPreviewValues(
-			sortValues(commaValuesParser(value), model.sort) as (string | number)[],
-		);
-	};
-
-	const trimmedName = model.name.trim();
-	const nameError = getNameError(trimmedName, existingNames);
-
-	const isListType =
-		model.type === 'QUERY' || model.type === 'CUSTOM' || model.type === 'DYNAMIC';
-	const showAllOptionField = model.type === 'QUERY' || model.type === 'CUSTOM';
-
-	const handleSave = (): void => {
-		onSave({
-			...model,
-			name: trimmedName,
-			defaultValue: defaultValue ? { value: defaultValue } : undefined,
-		});
-	};
-
-	return (
-		<>
-			<div className={styles.container}>
-				<div className={styles.allVariables}>
-					<Button
-						variant="ghost"
-						color="secondary"
-						className={styles.allVariablesBtn}
-						prefix={<ArrowLeft size={14} />}
-						onClick={onClose}
-						testId="variable-form-back"
-					>
-						All variables
-					</Button>
-				</div>
-
-				<div className={styles.content}>
-					{/* Name */}
-					<div className={cx(styles.row, styles.column)}>
-						<Typography.Text className={styles.label}>Name</Typography.Text>
-						<Input
-							className={styles.input}
-							value={model.name}
-							placeholder="Unique name of the variable"
-							onChange={(e): void => set({ name: e.target.value })}
-							testId="variable-name-input"
-						/>
-						{nameError ? (
-							<Typography.Text className={styles.errorText}>
-								{nameError}
-							</Typography.Text>
-						) : null}
-					</div>
-
-					{/* Description */}
-					<div className={cx(styles.row, styles.column)}>
-						<Typography.Text className={styles.label}>Description</Typography.Text>
-						<AntdInput.TextArea
-							className={styles.textarea}
-							value={model.description}
-							placeholder="Enter a description for the variable"
-							rows={3}
-							onChange={(e): void => set({ description: e.target.value })}
-							data-testid="variable-description-input"
-						/>
-					</div>
-
-					{/* Variable Type */}
-					<VariableTypeSelector value={model.type} onChange={selectType} />
-
-					{/* Type-specific body */}
-					{model.type === 'DYNAMIC' ? (
-						<DynamicVariableFields
-							attribute={model.dynamicAttribute}
-							signal={model.dynamicSignal}
-							onChange={(patch): void => set(patch)}
-							onPreview={setPreviewValues}
-						/>
-					) : null}
-
-					{model.type === 'QUERY' ? (
-						<QueryVariableFields
-							queryValue={model.queryValue}
-							sort={model.sort}
-							onChange={(queryValue): void => set({ queryValue })}
-							onPreview={setPreviewValues}
-							onError={setPreviewError}
-						/>
-					) : null}
-
-					{model.type === 'CUSTOM' ? (
-						<div className={cx(styles.row, styles.customSection)}>
-							<Collapse
-								collapsible="header"
-								rootClassName="custom-collapse"
-								defaultActiveKey={['1']}
-								items={[
-									{
-										key: '1',
-										label: 'Options',
-										children: (
-											<AntdInput.TextArea
-												value={model.customValue}
-												placeholder="Enter options separated by commas."
-												rootClassName="comma-input"
-												onChange={(e): void => onCustomChange(e.target.value)}
-												data-testid="variable-custom-input"
-											/>
-										),
-									},
-								]}
-							/>
-						</div>
-					) : null}
-
-					{model.type === 'TEXT' ? (
-						<div className={cx(styles.row, styles.textboxSection)}>
-							<div className={styles.labelContainer}>
-								<Typography.Text className={styles.label}>
-									Default Value
-								</Typography.Text>
-							</div>
-							<Input
-								className={styles.defaultInput}
-								value={model.textValue}
-								placeholder="Enter a default value (if any)..."
-								onChange={(e): void => set({ textValue: e.target.value })}
-								testId="variable-text-input"
-							/>
-						</div>
-					) : null}
-
-					{/* Shared rows for list-type variables */}
-					{isListType ? (
-						<>
-							<div className={cx(styles.row, styles.previewSection)}>
-								<Typography.Text className={styles.previewLabel}>
-									Preview of Values
-								</Typography.Text>
-								<div className={styles.previewValues}>
-									{previewError ? (
-										<Typography.Text className={styles.previewError}>
-											{previewError}
-										</Typography.Text>
-									) : (
-										previewValues.map((value, idx) => (
-											<Badge
-												// eslint-disable-next-line react/no-array-index-key -- preview values are display-only and may contain duplicates
-												key={`${value}-${idx}`}
-												color="vanilla"
-											>
-												{value.toString()}
-											</Badge>
-										))
-									)}
-								</div>
-							</div>
-
-							<div className={cx(styles.row, styles.sortSection)}>
-								<div className={styles.labelContainer}>
-									<Typography.Text className={styles.label}>Sort Values</Typography.Text>
-								</div>
-								<SelectSimple
-									className={styles.sortSelect}
-									value={model.sort}
-									items={VARIABLE_SORTS.map((sort) => ({
-										label: SORT_LABEL[sort],
-										value: sort,
-									}))}
-									onChange={(value): void => set({ sort: value as VariableSort })}
-									testId="variable-sort-select"
-								/>
-							</div>
-
-							<div className={cx(styles.row, styles.multiSection)}>
-								<Typography.Text className={styles.rowLabel}>
-									Enable multiple values to be checked
-								</Typography.Text>
-								<Switch
-									value={model.multiSelect}
-									onChange={(checked): void => {
-										set({
-											multiSelect: checked,
-											showAllOption: checked ? model.showAllOption : false,
-										});
-									}}
-									testId="variable-multi-switch"
-								/>
-							</div>
-
-							{model.multiSelect && showAllOptionField ? (
-								<div className={cx(styles.row, styles.allOptionSection)}>
-									<Typography.Text className={styles.rowLabel}>
-										Include an option for ALL values
-									</Typography.Text>
-									<Switch
-										value={model.showAllOption}
-										onChange={(checked): void => set({ showAllOption: checked })}
-										testId="variable-all-switch"
-									/>
-								</div>
-							) : null}
-
-							<div className={cx(styles.row, styles.defaultValueSection)}>
-								<div className={styles.labelContainer}>
-									<Typography.Text className={styles.label}>
-										Default Value
-									</Typography.Text>
-									<Typography.Text className={styles.defaultValueDesc}>
-										{model.type === 'QUERY'
-											? 'Click Test Run Query to see the values or add custom value'
-											: 'Select a value from the preview values or add custom value'}
-									</Typography.Text>
-								</div>
-								<Select
-									className={styles.searchSelect}
-									showSearch
-									allowClear
-									placeholder="Select a default value"
-									value={defaultValue || undefined}
-									onChange={(value): void => setDefaultValue(value ?? '')}
-									options={previewValues.map((value) => ({
-										label: value.toString(),
-										value: value.toString(),
-									}))}
-									data-testid="variable-default-select"
-								/>
-							</div>
-						</>
-					) : null}
-				</div>
-			</div>
-
-			<div className={styles.footer}>
-				<Button
-					variant="solid"
-					color="secondary"
-					prefix={<X size={14} />}
-					onClick={onClose}
-				>
-					Discard
-				</Button>
-				<Button
-					variant="solid"
-					color="primary"
-					prefix={<Check size={14} />}
-					disabled={!!nameError}
-					loading={isSaving}
-					onClick={handleSave}
-					testId="variable-save"
-				>
-					Save Variable
-				</Button>
-			</div>
-		</>
-	);
-}
-
-export default VariableForm;

frontend/src/pages/DashboardPageV2/DashboardContainer/DashboardSettings/Variables/VariableForm/VariableTypeSelector.tsx

@@ -1,99 +0,0 @@
-import {
-	ClipboardType,
-	DatabaseZap,
-	Info,
-	LayoutList,
-	Pyramid,
-} from '@signozhq/icons';
-import { Badge } from '@signozhq/ui/badge';
-import { Button } from '@signozhq/ui/button';
-import { Typography } from '@signozhq/ui/typography';
-import cx from 'classnames';
-import TextToolTip from 'components/TextToolTip';
-
-import type { VariableType } from '../variableModel';
-import styles from './VariableForm.module.scss';
-
-interface VariableTypeSelectorProps {
-	value: VariableType;
-	onChange: (type: VariableType) => void;
-}
-
-/** The segmented Dynamic / Textbox / Custom / Query type picker. */
-function VariableTypeSelector({
-	value,
-	onChange,
-}: VariableTypeSelectorProps): JSX.Element {
-	return (
-		<div className={cx(styles.row, styles.typeSection)}>
-			<div className={styles.typeLabelContainer}>
-				<Typography.Text className={styles.label}>Variable Type</Typography.Text>
-				<TextToolTip
-					text="Learn more about supported variable types"
-					url="https://signoz.io/docs/userguide/manage-variables/#supported-variable-types"
-					urlText="here"
-					useFilledIcon={false}
-					outlinedIcon={<Info size={14} />}
-				/>
-			</div>
-			<div className={styles.typeBtnGroup}>
-				<Button
-					variant="ghost"
-					color="secondary"
-					prefix={<Pyramid size={14} />}
-					className={cx(styles.typeBtn, {
-						[styles.typeBtnSelected]: value === 'DYNAMIC',
-					})}
-					onClick={(): void => onChange('DYNAMIC')}
-					testId="variable-type-dynamic"
-				>
-					Dynamic
-					<Badge color="robin" className={styles.betaTag}>
-						Beta
-					</Badge>
-				</Button>
-				<Button
-					variant="ghost"
-					color="secondary"
-					prefix={<ClipboardType size={14} />}
-					className={cx(styles.typeBtn, {
-						[styles.typeBtnSelected]: value === 'TEXT',
-					})}
-					onClick={(): void => onChange('TEXT')}
-					testId="variable-type-textbox"
-				>
-					Textbox
-				</Button>
-				<Button
-					variant="ghost"
-					color="secondary"
-					prefix={<LayoutList size={14} />}
-					className={cx(styles.typeBtn, {
-						[styles.typeBtnSelected]: value === 'CUSTOM',
-					})}
-					onClick={(): void => onChange('CUSTOM')}
-					testId="variable-type-custom"
-				>
-					Custom
-				</Button>
-				<Button
-					variant="ghost"
-					color="secondary"
-					prefix={<DatabaseZap size={14} />}
-					className={cx(styles.typeBtn, {
-						[styles.typeBtnSelected]: value === 'QUERY',
-					})}
-					onClick={(): void => onChange('QUERY')}
-					testId="variable-type-query"
-				>
-					Query
-					<Badge color="amber" className={styles.betaTag}>
-						Not Recommended
-					</Badge>
-				</Button>
-			</div>
-		</div>
-	);
-}
-
-export default VariableTypeSelector;

frontend/src/pages/DashboardPageV2/DashboardContainer/DashboardSettings/Variables/Variables.module.scss

@@ -1,101 +0,0 @@
-.container {
-	display: flex;
-	flex-direction: column;
-	gap: 16px;
-	padding: 20px 16px;
-}
-
-.header {
-	display: flex;
-	align-items: flex-start;
-	justify-content: space-between;
-	gap: 16px;
-}
-
-.titleRow {
-	display: flex;
-	align-items: baseline;
-	flex-wrap: wrap;
-	gap: 8px;
-}
-
-.title {
-	font-size: 14px;
-	font-weight: 500;
-	color: var(--l1-foreground);
-}
-
-.subtitle {
-	font-size: 12px;
-	color: var(--l2-foreground);
-}
-
-.empty {
-	padding: 32px;
-	text-align: center;
-	border: 1px dashed var(--l1-border);
-	border-radius: 4px;
-	color: var(--l2-foreground);
-}
-
-.list {
-	display: flex;
-	flex-direction: column;
-	gap: 8px;
-}
-
-.row {
-	display: flex;
-	align-items: center;
-	justify-content: space-between;
-	gap: 12px;
-	padding: 10px 12px;
-	border: 1px solid var(--l1-border);
-	border-radius: 4px;
-	background: var(--l1-background);
-}
-
-.rowMain {
-	display: flex;
-	align-items: center;
-	gap: 10px;
-	min-width: 0;
-}
-
-.varName {
-	font-weight: 500;
-	color: var(--l1-foreground);
-}
-
-.varDesc {
-	min-width: 0;
-	overflow: hidden;
-	font-size: 12px;
-	color: var(--l2-foreground);
-	text-overflow: ellipsis;
-	white-space: nowrap;
-}
-
-.typeTag {
-	flex-shrink: 0;
-	padding: 1px 8px;
-	font-size: 11px;
-	letter-spacing: 0.04em;
-	color: var(--l2-foreground);
-	text-transform: uppercase;
-	background: var(--l2-background);
-	border-radius: 10px;
-}
-
-.rowActions {
-	display: flex;
-	flex-shrink: 0;
-	align-items: center;
-	gap: 2px;
-}
-
-.confirmText {
-	margin-right: 4px;
-	font-size: 12px;
-	color: var(--l2-foreground);
-}

frontend/src/pages/DashboardPageV2/DashboardContainer/DashboardSettings/Variables/VariablesList.tsx

@@ -1,139 +0,0 @@
-import {
-	Check,
-	ChevronDown,
-	ChevronUp,
-	PenLine,
-	Trash2,
-	X,
-} from '@signozhq/icons';
-import { Button } from '@signozhq/ui/button';
-import { Typography } from '@signozhq/ui/typography';
-
-import type { VariableFormModel } from './variableModel';
-import styles from './Variables.module.scss';
-
-const TYPE_LABEL: Record<VariableFormModel['type'], string> = {
-	QUERY: 'Query',
-	CUSTOM: 'Custom',
-	TEXT: 'Text',
-	DYNAMIC: 'Dynamic',
-};
-
-interface VariablesListProps {
-	variables: VariableFormModel[];
-	canEdit: boolean;
-	/** Index whose delete is awaiting inline confirmation, if any. */
-	confirmingIndex: number | null;
-	onEdit: (index: number) => void;
-	onRequestDelete: (index: number) => void;
-	onConfirmDelete: (index: number) => void;
-	onCancelDelete: () => void;
-	onMove: (from: number, to: number) => void;
-}
-
-function VariablesList({
-	variables,
-	canEdit,
-	confirmingIndex,
-	onEdit,
-	onRequestDelete,
-	onConfirmDelete,
-	onCancelDelete,
-	onMove,
-}: VariablesListProps): JSX.Element {
-	return (
-		<div className={styles.list} data-testid="variables-list">
-			{variables.map((variable, index) => (
-				<div
-					className={styles.row}
-					key={variable.name || `variable-${index}`}
-					data-testid={`variable-row-${variable.name}`}
-				>
-					<div className={styles.rowMain}>
-						<Typography.Text className={styles.varName}>
-							${variable.name}
-						</Typography.Text>
-						<span className={styles.typeTag}>{TYPE_LABEL[variable.type]}</span>
-						{variable.description ? (
-							<Typography.Text className={styles.varDesc}>
-								{variable.description}
-							</Typography.Text>
-						) : null}
-					</div>
-
-					{canEdit && confirmingIndex === index ? (
-						<div className={styles.rowActions}>
-							<Typography.Text className={styles.confirmText}>Delete?</Typography.Text>
-							<Button
-								variant="ghost"
-								color="destructive"
-								size="icon"
-								onClick={(): void => onConfirmDelete(index)}
-								aria-label="Confirm delete"
-								testId={`variable-delete-confirm-${variable.name}`}
-							>
-								<Check size={14} />
-							</Button>
-							<Button
-								variant="ghost"
-								color="secondary"
-								size="icon"
-								onClick={onCancelDelete}
-								aria-label="Cancel delete"
-							>
-								<X size={14} />
-							</Button>
-						</div>
-					) : null}
-
-					{canEdit && confirmingIndex !== index ? (
-						<div className={styles.rowActions}>
-							<Button
-								variant="ghost"
-								color="secondary"
-								size="icon"
-								disabled={index === 0}
-								onClick={(): void => onMove(index, index - 1)}
-								aria-label="Move up"
-							>
-								<ChevronUp size={14} />
-							</Button>
-							<Button
-								variant="ghost"
-								color="secondary"
-								size="icon"
-								disabled={index === variables.length - 1}
-								onClick={(): void => onMove(index, index + 1)}
-								aria-label="Move down"
-							>
-								<ChevronDown size={14} />
-							</Button>
-							<Button
-								variant="ghost"
-								color="secondary"
-								size="icon"
-								onClick={(): void => onEdit(index)}
-								aria-label="Edit variable"
-								testId={`variable-edit-${variable.name}`}
-							>
-								<PenLine size={14} />
-							</Button>
-							<Button
-								variant="ghost"
-								color="secondary"
-								size="icon"
-								onClick={(): void => onRequestDelete(index)}
-								aria-label="Delete variable"
-								testId={`variable-delete-${variable.name}`}
-							>
-								<Trash2 size={14} />
-							</Button>
-						</div>
-					) : null}
-				</div>
-			))}
-		</div>
-	);
-}
-
-export default VariablesList;

frontend/src/pages/DashboardPageV2/DashboardContainer/DashboardSettings/Variables/index.tsx

@@ -1,147 +0,0 @@
-import { useEffect, useMemo, useState } from 'react';
-import { Plus } from '@signozhq/icons';
-import { Button } from '@signozhq/ui/button';
-import { Typography } from '@signozhq/ui/typography';
-import type { DashboardtypesGettableDashboardV2DTO } from 'api/generated/services/sigNoz.schemas';
-
-import { useDashboardStore } from '../../store/useDashboardStore';
-import { useSaveVariables } from './useSaveVariables';
-import { dtoToFormModel } from './variableAdapters';
-import {
-	emptyVariableFormModel,
-	type VariableFormModel,
-} from './variableModel';
-import VariableForm from './VariableForm/VariableForm';
-import VariablesList from './VariablesList';
-import styles from './Variables.module.scss';
-
-interface VariablesSettingsProps {
-	dashboard: DashboardtypesGettableDashboardV2DTO;
-}
-
-/** `null` index = adding a new variable; a number = editing that row. */
-type EditingState = { index: number | null } | null;
-
-function VariablesSettings({ dashboard }: VariablesSettingsProps): JSX.Element {
-	const isEditable = useDashboardStore((s) => s.isEditable);
-	const { save, isSaving } = useSaveVariables();
-
-	const initialModels = useMemo(
-		() => (dashboard.spec?.variables ?? []).map(dtoToFormModel),
-		[dashboard.spec?.variables],
-	);
-	const [variables, setVariables] = useState<VariableFormModel[]>(initialModels);
-
-	// Resync from the dashboard after a save round-trips (refetch bumps updatedAt).
-	useEffect(() => {
-		setVariables(initialModels);
-		// eslint-disable-next-line react-hooks/exhaustive-deps
-	}, [dashboard.updatedAt]);
-
-	const [editing, setEditing] = useState<EditingState>(null);
-	const [confirmDeleteIndex, setConfirmDeleteIndex] = useState<number | null>(
-		null,
-	);
-
-	const editingModel: VariableFormModel | null = useMemo(() => {
-		if (!editing) {
-			return null;
-		}
-		return editing.index === null
-			? emptyVariableFormModel()
-			: variables[editing.index];
-	}, [editing, variables]);
-
-	const existingNames = useMemo(() => {
-		const self = editing?.index ?? null;
-		return variables.filter((_, i) => i !== self).map((v) => v.name);
-	}, [variables, editing]);
-
-	const persist = (next: VariableFormModel[]): void => {
-		setVariables(next);
-		void save(next);
-	};
-
-	const handleFormSave = (model: VariableFormModel): void => {
-		const next = [...variables];
-		if (editing?.index == null) {
-			next.push(model);
-		} else {
-			next[editing.index] = model;
-		}
-		setEditing(null);
-		persist(next);
-	};
-
-	const handleMove = (from: number, to: number): void => {
-		if (to < 0 || to >= variables.length) {
-			return;
-		}
-		const next = [...variables];
-		const [moved] = next.splice(from, 1);
-		next.splice(to, 0, moved);
-		persist(next);
-	};
-
-	const handleConfirmDelete = (index: number): void => {
-		persist(variables.filter((_, i) => i !== index));
-		setConfirmDeleteIndex(null);
-	};
-
-	// Detail view — edit/new form replaces the list in place (no modal).
-	if (editingModel) {
-		return (
-			<VariableForm
-				initial={editingModel}
-				existingNames={existingNames}
-				isSaving={isSaving}
-				onClose={(): void => setEditing(null)}
-				onSave={handleFormSave}
-			/>
-		);
-	}
-
-	// Master view — the variables list.
-	return (
-		<div className={styles.container}>
-			<div className={styles.header}>
-				<div className={styles.titleRow}>
-					<Typography.Text className={styles.title}>Variables</Typography.Text>
-					<Typography.Text className={styles.subtitle}>
-						Define variables to parameterize panel queries.
-					</Typography.Text>
-				</div>
-				{isEditable ? (
-					<Button
-						variant="solid"
-						color="primary"
-						prefix={<Plus size={14} />}
-						onClick={(): void => setEditing({ index: null })}
-						testId="add-variable"
-					>
-						New variable
-					</Button>
-				) : null}
-			</div>
-
-			{variables.length === 0 ? (
-				<div className={styles.empty}>
-					<Typography.Text>No variables defined yet.</Typography.Text>
-				</div>
-			) : (
-				<VariablesList
-					variables={variables}
-					canEdit={isEditable}
-					confirmingIndex={confirmDeleteIndex}
-					onEdit={(index): void => setEditing({ index })}
-					onRequestDelete={(index): void => setConfirmDeleteIndex(index)}
-					onConfirmDelete={handleConfirmDelete}
-					onCancelDelete={(): void => setConfirmDeleteIndex(null)}
-					onMove={handleMove}
-				/>
-			)}
-		</div>
-	);
-}
-
-export default VariablesSettings;

frontend/src/pages/DashboardPageV2/DashboardContainer/DashboardSettings/Variables/useSaveVariables.ts

@@ -1,51 +0,0 @@
-import { useCallback, useState } from 'react';
-import { patchDashboardV2 } from 'api/generated/services/dashboard';
-import { toast } from '@signozhq/ui/sonner';
-import { useErrorModal } from 'providers/ErrorModalProvider';
-import APIError from 'types/api/error';
-
-import { useDashboardStore } from '../../store/useDashboardStore';
-import { formModelToDto } from './variableAdapters';
-import type { VariableFormModel } from './variableModel';
-import { buildVariablesPatch } from './variablePatchOps';
-
-interface UseSaveVariables {
-	save: (variables: VariableFormModel[]) => Promise<boolean>;
-	isSaving: boolean;
-}
-
-/**
- * Persists the dashboard's variable list via a single `/spec/variables` patch,
- * then refetches. Mirrors the General-settings save flow (patch → toast →
- * refetch → surface errors).
- */
-export function useSaveVariables(): UseSaveVariables {
-	const dashboardId = useDashboardStore((s) => s.dashboardId);
-	const refetch = useDashboardStore((s) => s.refetch);
-	const { showErrorModal } = useErrorModal();
-	const [isSaving, setIsSaving] = useState(false);
-
-	const save = useCallback(
-		async (variables: VariableFormModel[]): Promise<boolean> => {
-			if (!dashboardId) {
-				return false;
-			}
-			const dtos = variables.map(formModelToDto);
-			try {
-				setIsSaving(true);
-				await patchDashboardV2({ id: dashboardId }, buildVariablesPatch(dtos));
-				toast.success('Variables updated');
-				refetch();
-				return true;
-			} catch (error) {
-				showErrorModal(error as APIError);
-				return false;
-			} finally {
-				setIsSaving(false);
-			}
-		},
-		[dashboardId, refetch, showErrorModal],
-	);
-
-	return { save, isSaving };
-}

frontend/src/pages/DashboardPageV2/DashboardContainer/DashboardSettings/Variables/variableAdapters.ts

@@ -1,153 +0,0 @@
-import {
-	DashboardtypesVariableEnvelopeGithubComPersesSpecGoDashboardTextVariableSpecDTOKind as TextEnvelopeKind,
-	DashboardtypesVariableEnvelopeGithubComSigNozSignozPkgTypesDashboardtypesListVariableSpecDTOKind as ListEnvelopeKind,
-	DashboardtypesVariablePluginVariantGithubComSigNozSignozPkgTypesDashboardtypesCustomVariableSpecDTOKind as CustomPluginKind,
-	DashboardtypesVariablePluginVariantGithubComSigNozSignozPkgTypesDashboardtypesDynamicVariableSpecDTOKind as DynamicPluginKind,
-	DashboardtypesVariablePluginVariantGithubComSigNozSignozPkgTypesDashboardtypesQueryVariableSpecDTOKind as QueryPluginKind,
-	TelemetrytypesSignalDTO,
-} from 'api/generated/services/sigNoz.schemas';
-import type {
-	DashboardtypesListVariableSpecDTO,
-	DashboardtypesVariableDTO,
-	DashboardtypesVariablePluginDTO,
-	DashboardTextVariableSpecDTO,
-} from 'api/generated/services/sigNoz.schemas';
-
-import {
-	emptyVariableFormModel,
-	PLUGIN_KIND,
-	type TelemetrySignal,
-	type VariableFormModel,
-	type VariableSort,
-} from './variableModel';
-
-/** DTO envelope → flat form model (for display / editing). */
-export function dtoToFormModel(
-	dto: DashboardtypesVariableDTO,
-): VariableFormModel {
-	const base = emptyVariableFormModel();
-	const display = dto.spec?.display;
-	const common: VariableFormModel = {
-		...base,
-		name: dto.spec?.name ?? display?.name ?? '',
-		description: display?.description ?? '',
-	};
-
-	// Text variable — a distinct envelope (no list plugin).
-	if (dto.kind === TextEnvelopeKind.TextVariable) {
-		const spec = dto.spec as DashboardTextVariableSpecDTO;
-		return {
-			...common,
-			type: 'TEXT',
-			textValue: spec.value ?? '',
-			textConstant: spec.constant ?? false,
-		};
-	}
-
-	// List variable — Query / Custom / Dynamic, distinguished by plugin.kind.
-	const spec = dto.spec as DashboardtypesListVariableSpecDTO;
-	const listCommon: VariableFormModel = {
-		...common,
-		multiSelect: spec.allowMultiple ?? false,
-		showAllOption: spec.allowAllValue ?? false,
-		sort: (spec.sort as VariableSort) ?? 'DISABLED',
-		defaultValue: spec.defaultValue,
-	};
-	const plugin = spec.plugin;
-
-	if (plugin?.kind === CustomPluginKind['signoz/CustomVariable']) {
-		return {
-			...listCommon,
-			type: 'CUSTOM',
-			customValue: plugin.spec.customValue ?? '',
-		};
-	}
-	if (plugin?.kind === DynamicPluginKind['signoz/DynamicVariable']) {
-		return {
-			...listCommon,
-			type: 'DYNAMIC',
-			dynamicAttribute: plugin.spec.name ?? '',
-			dynamicSignal: (plugin.spec.signal as TelemetrySignal) ?? 'traces',
-		};
-	}
-	// Default to Query (also covers a query plugin or a missing/unknown plugin).
-	return {
-		...listCommon,
-		type: 'QUERY',
-		queryValue:
-			plugin?.kind === QueryPluginKind['signoz/QueryVariable']
-				? (plugin.spec.queryValue ?? '')
-				: '',
-	};
-}
-
-function buildPlugin(
-	model: VariableFormModel,
-): DashboardtypesVariablePluginDTO {
-	switch (model.type) {
-		case 'CUSTOM':
-			return {
-				kind: CustomPluginKind['signoz/CustomVariable'],
-				spec: { customValue: model.customValue },
-			};
-		case 'DYNAMIC':
-			return {
-				kind: DynamicPluginKind['signoz/DynamicVariable'],
-				spec: {
-					name: model.dynamicAttribute,
-					signal: model.dynamicSignal as TelemetrytypesSignalDTO,
-				},
-			};
-		case 'QUERY':
-		default:
-			return {
-				kind: QueryPluginKind['signoz/QueryVariable'],
-				spec: { queryValue: model.queryValue },
-			};
-	}
-}
-
-/** Flat form model → DTO envelope (for persistence). */
-export function formModelToDto(
-	model: VariableFormModel,
-): DashboardtypesVariableDTO {
-	const display = {
-		name: model.name,
-		description: model.description,
-		hidden: model.hidden,
-	};
-
-	if (model.type === 'TEXT') {
-		return {
-			kind: TextEnvelopeKind.TextVariable,
-			spec: {
-				name: model.name,
-				display,
-				value: model.textValue,
-				constant: model.textConstant,
-			},
-		};
-	}
-
-	return {
-		kind: ListEnvelopeKind.ListVariable,
-		spec: {
-			name: model.name,
-			display,
-			allowMultiple: model.multiSelect,
-			allowAllValue: model.showAllOption,
-			sort: model.sort,
-			defaultValue: model.defaultValue,
-			plugin: buildPlugin(model),
-		},
-	};
-}
-
-/** Maps the V2 plugin/envelope to the four UI-facing variable types. */
-export function variableTypeOf(
-	dto: DashboardtypesVariableDTO,
-): VariableFormModel['type'] {
-	return dtoToFormModel(dto).type;
-}
-
-export { PLUGIN_KIND };

frontend/src/pages/DashboardPageV2/DashboardContainer/DashboardSettings/Variables/variableModel.ts

@@ -1,78 +0,0 @@
-import type { VariableDefaultValueDTO } from 'api/generated/services/sigNoz.schemas';
-
-/**
- * Flat, UI-friendly representation of a V2 dashboard variable. The wire format
- * (`DashboardtypesVariableDTO`) is a nested envelope/plugin union that is awkward
- * to bind a form to; `variableAdapters` converts between this model and the DTO.
- */
-
-export type VariableType = 'QUERY' | 'CUSTOM' | 'TEXT' | 'DYNAMIC';
-
-export type VariableSort = 'DISABLED' | 'ASC' | 'DESC';
-
-export type TelemetrySignal = 'traces' | 'logs' | 'metrics';
-
-/** Wire `kind` discriminators (string values of the generated enums). */
-export const ENVELOPE_KIND = {
-	LIST: 'ListVariable',
-	TEXT: 'TextVariable',
-} as const;
-
-export const PLUGIN_KIND = {
-	QUERY: 'signoz/QueryVariable',
-	CUSTOM: 'signoz/CustomVariable',
-	DYNAMIC: 'signoz/DynamicVariable',
-} as const;
-
-export const VARIABLE_SORTS: VariableSort[] = ['DISABLED', 'ASC', 'DESC'];
-
-export const TELEMETRY_SIGNALS: TelemetrySignal[] = [
-	'traces',
-	'logs',
-	'metrics',
-];
-
-export interface VariableFormModel {
-	/** Stable identifier, referenced in queries (e.g. `$name`); must be unique. */
-	name: string;
-	description: string;
-	hidden: boolean;
-	type: VariableType;
-
-	// List-variable common fields (Query / Custom / Dynamic).
-	multiSelect: boolean;
-	showAllOption: boolean;
-	sort: VariableSort;
-
-	// Type-specific.
-	queryValue: string; // QUERY
-	customValue: string; // CUSTOM
-	textValue: string; // TEXT
-	textConstant: boolean; // TEXT
-	dynamicAttribute: string; // DYNAMIC — the telemetry field name
-	dynamicSignal: TelemetrySignal; // DYNAMIC — the telemetry signal
-
-	/**
-	 * Runtime-selected default, not editable in the management tab yet; carried
-	 * through edits so saving a definition doesn't clobber it.
-	 */
-	defaultValue?: VariableDefaultValueDTO;
-}
-
-export function emptyVariableFormModel(): VariableFormModel {
-	return {
-		name: '',
-		description: '',
-		hidden: false,
-		type: 'QUERY',
-		multiSelect: false,
-		showAllOption: false,
-		sort: 'DISABLED',
-		queryValue: '',
-		customValue: '',
-		textValue: '',
-		textConstant: false,
-		dynamicAttribute: '',
-		dynamicSignal: 'traces',
-	};
-}

frontend/src/pages/DashboardPageV2/DashboardContainer/DashboardSettings/Variables/variablePatchOps.ts

@@ -1,22 +0,0 @@
-import type {
-	DashboardtypesJSONPatchOperationDTO,
-	DashboardtypesVariableDTO,
-} from 'api/generated/services/sigNoz.schemas';
-
-/**
- * Builds the JSON-Patch to persist the dashboard's variable list. Add/edit/
- * delete/reorder all replace the whole `/spec/variables` array in one atomic op
- * — simpler and race-free vs per-index patches. RFC-6902 `add` on an object
- * member sets-or-replaces, so it works whether or not `variables` already exists.
- */
-export function buildVariablesPatch(
-	variables: DashboardtypesVariableDTO[],
-): DashboardtypesJSONPatchOperationDTO[] {
-	return [
-		{
-			op: 'add' as DashboardtypesJSONPatchOperationDTO['op'],
-			path: '/spec/variables',
-			value: variables,
-		},
-	];
-}

frontend/src/pages/DashboardPageV2/DashboardContainer/DashboardSettings/index.tsx

@@ -1,39 +1,48 @@
 import { useMemo } from 'react';
 
 import { Braces, Globe, Table } from '@signozhq/icons';
-import { TabItemProps, Tabs } from '@signozhq/ui/tabs';
+import { Tabs } from '@signozhq/ui/tabs';
 import type { DashboardtypesGettableDashboardV2DTO } from 'api/generated/services/sigNoz.schemas';
 
 import GeneralSettings from './General';
 import { SettingsTabPlaceholder } from './utils';
-import VariablesSettings from './Variables';
+
+import styles from './DashboardSettings.module.scss';
 
 interface DashboardSettingsProps {
 	dashboard: DashboardtypesGettableDashboardV2DTO;
 }
 
+function tabLabel(icon: JSX.Element, text: string): JSX.Element {
+	return (
+		<span className={styles.tabLabel}>
+			{icon}
+			{text}
+		</span>
+	);
+}
+
 function DashboardSettings({ dashboard }: DashboardSettingsProps): JSX.Element {
-	const items: TabItemProps[] = useMemo(
+	const items = useMemo(
 		() => [
 			{
 				key: 'general',
-				label: 'General',
+				label: tabLabel(<Table size={14} />, 'General'),
 				children: <GeneralSettings dashboard={dashboard} />,
-				prefixIcon: <Table size={14} />,
 			},
 			{
 				key: 'variables',
-				label: 'Variables',
-				children: <VariablesSettings dashboard={dashboard} />,
-				prefixIcon: <Braces size={14} />,
+				label: tabLabel(<Braces size={14} />, 'Variables'),
+				children: (
+					<SettingsTabPlaceholder message="V2 dashboard variables coming next." />
+				),
 			},
 			{
 				key: 'public-dashboard',
-				label: 'Publish',
+				label: tabLabel(<Globe size={14} />, 'Publish'),
 				children: (
 					<SettingsTabPlaceholder message="V2 public dashboard publishing coming next." />
 				),
-				prefixIcon: <Globe size={14} />,
 			},
 		],
 		[dashboard],

frontend/src/pages/DashboardPageV2/DashboardContainer/patchOps.ts

@@ -4,7 +4,7 @@ import type {
 	DashboardtypesLayoutDTO,
 	DashboardtypesPanelDTO,
 } from 'api/generated/services/sigNoz.schemas';
-import { DashboardtypesPatchOpDTO } from 'api/generated/services/sigNoz.schemas';
+import { DashboardtypesJSONPatchOperationDTOOp } from 'api/generated/services/sigNoz.schemas';
 
 import type { GridItem } from './utils';
 
@@ -16,7 +16,7 @@ import type { GridItem } from './utils';
  * patches in DashboardSettings/General and DashboardDescription).
  */
 
-const { add, replace, remove } = DashboardtypesPatchOpDTO;
+const { add, replace, remove } = DashboardtypesJSONPatchOperationDTOOp;
 
 const PANEL_REF_PREFIX = '#/spec/panels/';
 

frontend/src/pages/DashboardsListPage/index.tsx

@@ -1,15 +1,3 @@
-import { useIsDashboardV2 } from 'hooks/useIsDashboardV2';
-import DashboardsListPageV2 from 'pages/DashboardsListPageV2';
-
 import DashboardsListPage from './DashboardsListPage';
 
-// Serves the V2 dashboards list when the `use_dashboard_v2` flag is active;
-// otherwise the existing V1 list. Lets V2 dark-ship behind the flag without
-// changing route definitions.
-function DashboardsListPageEntry(): JSX.Element {
-	const isDashboardV2 = useIsDashboardV2();
-
-	return isDashboardV2 ? <DashboardsListPageV2 /> : <DashboardsListPage />;
-}
-
-export default DashboardsListPageEntry;
+export default DashboardsListPage;

frontend/src/pages/DashboardsListPageV2/components/DashboardsList/DashboardsList.tsx

@@ -8,10 +8,6 @@ import {
 	createDashboardV2,
 	useListDashboardsV2,
 } from 'api/generated/services/dashboard';
-import {
-	DashboardtypesListOrderDTO,
-	DashboardtypesListSortDTO,
-} from 'api/generated/services/sigNoz.schemas';
 import ROUTES from 'constants/routes';
 import { RequestDashboardBtn } from 'container/ListOfDashboard/RequestDashboardBtn';
 import useComponentPermission from 'hooks/useComponentPermission';
@@ -28,6 +24,8 @@ import {
 	useSearch,
 	useSortColumn,
 	useSortOrder,
+	type SortColumn,
+	type SortOrder,
 } from '../../hooks/useDashboardsListQueryParams';
 import type { DashboardListItem } from '../../utils';
 import ConfigureMetadataModal from '../ConfigureMetadataModal/ConfigureMetadataModal';
@@ -133,10 +131,6 @@ function DashboardsList(): JSX.Element {
 				tags: null,
 				spec: {
 					display: { name: t('new_dashboard_title', { ns: 'dashboard' }) },
-					layouts: [],
-					panels: {},
-					variables: [],
-					// TODO(@AshwinBhatkal): duration and refresh interval need to be integrated
 				},
 			});
 			safeNavigate(
@@ -156,7 +150,7 @@ function DashboardsList(): JSX.Element {
 	}, []);
 
 	const onSortChange = useCallback(
-		(column: DashboardtypesListSortDTO): void => {
+		(column: SortColumn): void => {
 			void setSortColumn(column);
 			void setPage(1);
 		},
@@ -164,7 +158,7 @@ function DashboardsList(): JSX.Element {
 	);
 
 	const onOrderChange = useCallback(
-		(order: DashboardtypesListOrderDTO): void => {
+		(order: SortOrder): void => {
 			void setSortOrder(order);
 			void setPage(1);
 		},

frontend/src/pages/DashboardsListPageV2/components/ListHeader/ListHeader.tsx

@@ -7,18 +7,18 @@ import {
 	HdmiPort,
 } from '@signozhq/icons';
 
-import {
-	DashboardtypesListOrderDTO,
-	DashboardtypesListSortDTO,
-} from 'api/generated/services/sigNoz.schemas';
+import type {
+	SortColumn,
+	SortOrder,
+} from '../../hooks/useDashboardsListQueryParams';
 
 import styles from './ListHeader.module.scss';
 
 interface Props {
-	sortColumn: DashboardtypesListSortDTO;
-	onSortChange: (column: DashboardtypesListSortDTO) => void;
-	sortOrder: DashboardtypesListOrderDTO;
-	onOrderChange: (order: DashboardtypesListOrderDTO) => void;
+	sortColumn: SortColumn;
+	onSortChange: (column: SortColumn) => void;
+	sortOrder: SortOrder;
+	onOrderChange: (order: SortOrder) => void;
 	onConfigureMetadata: () => void;
 }
 
@@ -44,57 +44,49 @@ function ListHeader({
 								<Button
 									type="text"
 									className={styles.sortButton}
-									onClick={(): void => onSortChange(DashboardtypesListSortDTO.name)}
+									onClick={(): void => onSortChange('name')}
 									data-testid="sort-by-name"
 								>
 									Name
-									{sortColumn === DashboardtypesListSortDTO.name && <Check size={14} />}
+									{sortColumn === 'name' && <Check size={14} />}
 								</Button>
 								<Button
 									type="text"
 									className={styles.sortButton}
-									onClick={(): void =>
-										onSortChange(DashboardtypesListSortDTO.created_at)
-									}
+									onClick={(): void => onSortChange('created_at')}
 									data-testid="sort-by-last-created"
 								>
 									Last created
-									{sortColumn === DashboardtypesListSortDTO.created_at && (
-										<Check size={14} />
-									)}
+									{sortColumn === 'created_at' && <Check size={14} />}
 								</Button>
 								<Button
 									type="text"
 									className={styles.sortButton}
-									onClick={(): void =>
-										onSortChange(DashboardtypesListSortDTO.updated_at)
-									}
+									onClick={(): void => onSortChange('updated_at')}
 									data-testid="sort-by-last-updated"
 								>
 									Last updated
-									{sortColumn === DashboardtypesListSortDTO.updated_at && (
-										<Check size={14} />
-									)}
+									{sortColumn === 'updated_at' && <Check size={14} />}
 								</Button>
 								<div className={styles.sortDivider} />
 								<Typography.Text className={styles.sortHeading}>Order</Typography.Text>
 								<Button
 									type="text"
 									className={styles.sortButton}
-									onClick={(): void => onOrderChange(DashboardtypesListOrderDTO.asc)}
+									onClick={(): void => onOrderChange('asc')}
 									data-testid="sort-order-asc"
 								>
 									Ascending
-									{sortOrder === DashboardtypesListOrderDTO.asc && <Check size={14} />}
+									{sortOrder === 'asc' && <Check size={14} />}
 								</Button>
 								<Button
 									type="text"
 									className={styles.sortButton}
-									onClick={(): void => onOrderChange(DashboardtypesListOrderDTO.desc)}
+									onClick={(): void => onOrderChange('desc')}
 									data-testid="sort-order-desc"
 								>
 									Descending
-									{sortOrder === DashboardtypesListOrderDTO.desc && <Check size={14} />}
+									{sortOrder === 'desc' && <Check size={14} />}
 								</Button>
 							</div>
 						}

frontend/src/pages/DashboardsListPageV2/components/states/states.module.scss

@@ -1,5 +1,5 @@
-/* Shared building blocks for the dashboards-list view states. */
-/* Composed via CSS-modules `composes:` from each state's own SCSS. */
+// Shared building blocks for the dashboards-list view states.
+// Composed via CSS-modules `composes:` from each state's own SCSS.
 
 .cardWrapper {
 	display: flex;

frontend/src/pages/DashboardsListPageV2/hooks/useDashboardsListQueryParams.ts

@@ -1,7 +1,3 @@
-import {
-	DashboardtypesListOrderDTO,
-	DashboardtypesListSortDTO,
-} from 'api/generated/services/sigNoz.schemas';
 import {
 	parseAsInteger,
 	parseAsString,
@@ -11,31 +7,26 @@ import {
 	type UseQueryStateReturn,
 } from 'nuqs';
 
-export const SORT_COLUMNS = Object.values(DashboardtypesListSortDTO);
-export const SORT_ORDERS = Object.values(DashboardtypesListOrderDTO);
+export const SORT_COLUMNS = ['updated_at', 'created_at', 'name'] as const;
+export type SortColumn = (typeof SORT_COLUMNS)[number];
+
+export const SORT_ORDERS = ['asc', 'desc'] as const;
+export type SortOrder = (typeof SORT_ORDERS)[number];
 
 const opts: Options = { history: 'push' };
 
-export const useSortColumn = (): UseQueryStateReturn<
-	DashboardtypesListSortDTO,
-	DashboardtypesListSortDTO
-> =>
+export const useSortColumn = (): UseQueryStateReturn<SortColumn, SortColumn> =>
 	useQueryState(
 		'sort',
 		parseAsStringLiteral(SORT_COLUMNS)
-			.withDefault(DashboardtypesListSortDTO.updated_at)
+			.withDefault('updated_at')
 			.withOptions(opts),
 	);
 
-export const useSortOrder = (): UseQueryStateReturn<
-	DashboardtypesListOrderDTO,
-	DashboardtypesListOrderDTO
-> =>
+export const useSortOrder = (): UseQueryStateReturn<SortOrder, SortOrder> =>
 	useQueryState(
 		'order',
-		parseAsStringLiteral(SORT_ORDERS)
-			.withDefault(DashboardtypesListOrderDTO.desc)
-			.withOptions(opts),
+		parseAsStringLiteral(SORT_ORDERS).withDefault('desc').withOptions(opts),
 	);
 
 export const usePage = (): UseQueryStateReturn<number, number> =>

frontend/src/pages/DashboardsListPageV2/utils.ts

@@ -1,8 +1,8 @@
 import dayjs from 'dayjs';
 import { isEmpty } from 'lodash-es';
-import type { DashboardtypesListedDashboardV2DTO } from 'api/generated/services/sigNoz.schemas';
+import type { DashboardtypesGettableDashboardWithPinDTO } from 'api/generated/services/sigNoz.schemas';
 
-export type DashboardListItem = DashboardtypesListedDashboardV2DTO;
+export type DashboardListItem = DashboardtypesGettableDashboardWithPinDTO;
 
 export const tagsToStrings = (
 	tags: { key: string; value: string }[] | null | undefined,

frontend/src/pages/ResetPassword/__tests__/ResetPasswordPage.test.tsx

@@ -2,7 +2,7 @@ import { Logout } from 'api/utils';
 import ROUTES from 'constants/routes';
 import history from 'lib/history';
 import { createErrorResponse, rest, server } from 'mocks-server/server';
-import { render, screen, waitFor, fireEvent } from 'tests/test-utils';
+import { render, screen, waitFor } from 'tests/test-utils';
 
 import ResetPassword from '../index';
 
@@ -103,7 +103,6 @@ describe('ResetPassword Page', () => {
 			expect(
 				screen.getByText(/reset password token does not exist/i),
 			).toBeInTheDocument();
-			expect(screen.getByTestId('back-to-login')).toBeInTheDocument();
 		});
 
 		it('shows "token is expired" when token is expired (401) without redirecting to login', async () => {
@@ -138,32 +137,6 @@ describe('ResetPassword Page', () => {
 			// 401 from this endpoint must NOT trigger logout/redirect
 			expect(mockHistoryPush).not.toHaveBeenCalledWith(ROUTES.LOGIN);
 			expect(Logout).not.toHaveBeenCalled();
-			expect(screen.getByTestId('back-to-login')).toBeInTheDocument();
-		});
-
-		it('navigates to login when "Back to login" is clicked on error screen', async () => {
-			server.use(
-				rest.post(
-					VERIFY_TOKEN_ENDPOINT,
-					createErrorResponse(
-						404,
-						'reset_password_token_not_found',
-						'reset password token does not exist',
-					),
-				),
-			);
-
-			window.history.pushState({}, '', '/password-reset?token=invalid-token');
-			render(<ResetPassword />, undefined, {
-				initialRoute: '/password-reset?token=invalid-token',
-			});
-
-			await waitFor(() => {
-				expect(screen.getByTestId('back-to-login')).toBeInTheDocument();
-			});
-
-			fireEvent.click(screen.getByTestId('back-to-login'));
-			expect(mockHistoryPush).toHaveBeenCalledWith(ROUTES.LOGIN);
 		});
 
 		it('redirects to login when no token is in the URL', async () => {

frontend/src/pages/TraceDetailsV3/TraceFlamegraph/TraceFlamegraph.tsx

@@ -1,7 +1,7 @@
 import { useCallback, useEffect, useMemo, useState } from 'react';
 import { useHistory, useLocation, useParams } from 'react-router-dom';
 import { Skeleton } from 'antd';
-import useGetTraceFlamegraphV3 from 'hooks/trace/useGetTraceFlamegraphV3';
+import useGetTraceFlamegraph from 'hooks/trace/useGetTraceFlamegraph';
 import useUrlQuery from 'hooks/useUrlQuery';
 import { TraceDetailFlamegraphURLProps } from 'types/api/trace/getTraceFlamegraph';
 import { SpanV3 } from 'types/api/trace/getTraceV3';
@@ -53,9 +53,6 @@ function TraceFlamegraph({
 	);
 
 	const previewFields = useTraceStore((s) => s.previewFields);
-	// Gate the fetch until prefs load, else selectFields (in the query key)
-	// repopulates and triggers a second fetch.
-	const userPrefsReady = useTraceStore((s) => s.userPreferences !== null);
 
 	// Color-by fields baseline + user-picked preview fields. De-duped by `name`,
 	// color-by entries first so their canonical metadata wins on collision.
@@ -73,14 +70,17 @@ function TraceFlamegraph({
 		data,
 		isFetching,
 		error: fetchError,
-	} = useGetTraceFlamegraphV3({
+	} = useGetTraceFlamegraph({
 		traceId,
 		selectedSpanId: selectedSpanIdForFetch,
+		limit: FLAMEGRAPH_SPAN_LIMIT,
 		selectFields: flamegraphSelectFields,
-		enabled: !!traceId && userPrefsReady,
 	});
 
-	const spans = useMemo(() => data?.spans || [], [data?.spans]);
+	const spans = useMemo(
+		() => data?.payload?.spans || [],
+		[data?.payload?.spans],
+	);
 
 	const {
 		layout,
@@ -99,8 +99,8 @@ function TraceFlamegraph({
 						setFirstSpanAtFetchLevel={setFirstSpanAtFetchLevel}
 						onSpanClick={handleSpanClick}
 						traceMetadata={{
-							startTime: data?.startTimestampMillis || 0,
-							endTime: data?.endTimestampMillis || 0,
+							startTime: data?.payload?.startTimestampMillis || 0,
+							endTime: data?.payload?.endTimestampMillis || 0,
 						}}
 						filteredSpanIds={filteredSpanIds}
 						isFilterActive={isFilterActive}
@@ -124,7 +124,7 @@ function TraceFlamegraph({
 		if (fetchError || workerError) {
 			return <Error error={(fetchError || workerError) as any} />;
 		}
-		if (data?.spans && data.spans.length === 0) {
+		if (data?.payload?.spans && data.payload.spans.length === 0) {
 			return <div>No data found for trace {traceId}</div>;
 		}
 		return (
@@ -134,17 +134,17 @@ function TraceFlamegraph({
 				setFirstSpanAtFetchLevel={setFirstSpanAtFetchLevel}
 				onSpanClick={handleSpanClick}
 				traceMetadata={{
-					startTime: data?.startTimestampMillis || 0,
-					endTime: data?.endTimestampMillis || 0,
+					startTime: data?.payload?.startTimestampMillis || 0,
+					endTime: data?.payload?.endTimestampMillis || 0,
 				}}
 				filteredSpanIds={filteredSpanIds}
 				isFilterActive={isFilterActive}
 			/>
 		);
 	}, [
-		data?.endTimestampMillis,
-		data?.startTimestampMillis,
-		data?.spans,
+		data?.payload?.endTimestampMillis,
+		data?.payload?.startTimestampMillis,
+		data?.payload?.spans,
 		fetchError,
 		filteredSpanIds,
 		firstSpanAtFetchLevel,

frontend/src/pages/TraceDetailsV3/TraceFlamegraph/__tests__/TraceFlamegraph.test.tsx

@@ -1,12 +1,12 @@
 import { render } from '@testing-library/react';
-import useGetTraceFlamegraphV3 from 'hooks/trace/useGetTraceFlamegraphV3';
+import useGetTraceFlamegraph from 'hooks/trace/useGetTraceFlamegraph';
 import { AllTheProviders } from 'tests/test-utils';
 import { SpanV3 } from 'types/api/trace/getTraceV3';
 
 import { FLAMEGRAPH_SPAN_LIMIT } from '../constants';
 import TraceFlamegraph from '../TraceFlamegraph';
 
-jest.mock('hooks/trace/useGetTraceFlamegraphV3');
+jest.mock('hooks/trace/useGetTraceFlamegraph');
 
 // Short-circuit the worker so the test doesn't depend on layout computation.
 jest.mock('../hooks/useVisualLayoutWorker', () => ({
@@ -17,8 +17,9 @@ jest.mock('../hooks/useVisualLayoutWorker', () => ({
 	}),
 }));
 
-const mockUseGetTraceFlamegraph =
-	useGetTraceFlamegraphV3 as jest.MockedFunction<typeof useGetTraceFlamegraphV3>;
+const mockUseGetTraceFlamegraph = useGetTraceFlamegraph as jest.MockedFunction<
+	typeof useGetTraceFlamegraph
+>;
 
 function renderFlamegraph(props: {
 	selectedSpan: SpanV3 | undefined;
@@ -44,7 +45,7 @@ describe('TraceFlamegraph - selectedSpanId pass-through', () => {
 	beforeEach(() => {
 		mockUseGetTraceFlamegraph.mockReset();
 		mockUseGetTraceFlamegraph.mockReturnValue({
-			data: { spans: [] },
+			data: { payload: { spans: [] } },
 			isFetching: false,
 			error: null,
 		} as never);

frontend/src/pages/TraceDetailsV3/TraceFlamegraph/__tests__/computeVisualLayout.test.ts

@@ -1,4 +1,4 @@
-import { SpantypesFlamegraphSpanDTO as FlamegraphSpan } from 'api/generated/services/sigNoz.schemas';
+import { FlamegraphSpan } from 'types/api/trace/getTraceFlamegraph';
 
 import {
 	computeVisualLayout,
@@ -14,12 +14,12 @@ function makeSpan(
 ): FlamegraphSpan {
 	return {
 		parentSpanId: '',
+		traceId: 'trace-1',
 		hasError: false,
+		serviceName: 'svc',
 		name: 'op',
 		level: 0,
 		event: [],
-		resource: {},
-		attributes: {},
 		...overrides,
 	};
 }

frontend/src/pages/TraceDetailsV3/TraceFlamegraph/__tests__/testUtils.ts

@@ -1,4 +1,4 @@
-import { SpantypesFlamegraphSpanDTO as FlamegraphSpan } from 'api/generated/services/sigNoz.schemas';
+import { FlamegraphSpan } from 'types/api/trace/getTraceFlamegraph';
 
 /** Minimal FlamegraphSpan for unit tests */
 export const MOCK_SPAN: FlamegraphSpan = {
@@ -6,12 +6,12 @@ export const MOCK_SPAN: FlamegraphSpan = {
 	durationNano: 50_000_000, // 50ms
 	spanId: 'span-1',
 	parentSpanId: '',
+	traceId: 'trace-1',
 	hasError: false,
+	serviceName: 'test-service',
 	name: 'test-span',
 	level: 0,
 	event: [],
-	resource: {},
-	attributes: {},
 };
 
 /** Nested spans structure for findSpanById tests */

frontend/src/pages/TraceDetailsV3/TraceFlamegraph/__tests__/utils.presentation.test.ts

@@ -65,25 +65,37 @@ describe('Presentation / Styling Utils', () => {
 	describe('getFlamegraphSpanGroupValue', () => {
 		it('returns resource[field.name] when present', () => {
 			const value = getFlamegraphSpanGroupValue(
-				{ resource: { 'service.name': 'svc-from-resource' } },
+				{
+					serviceName: 'legacy',
+					resource: { 'service.name': 'svc-from-resource' },
+				},
 				SERVICE_FIELD,
 			);
 			expect(value).toBe('svc-from-resource');
 		});
 
-		it('returns "unknown" for service.name when resource is empty', () => {
-			const value = getFlamegraphSpanGroupValue({ resource: {} }, SERVICE_FIELD);
-			expect(value).toBe('unknown');
+		it('falls back to top-level serviceName for service.name when resource is empty', () => {
+			const value = getFlamegraphSpanGroupValue(
+				{ serviceName: 'svc-legacy', resource: {} },
+				SERVICE_FIELD,
+			);
+			expect(value).toBe('svc-legacy');
 		});
 
 		it('returns "unknown" for non-service fields when resource is missing', () => {
-			const value = getFlamegraphSpanGroupValue({ resource: {} }, HOST_FIELD);
+			const value = getFlamegraphSpanGroupValue(
+				{ serviceName: 'svc', resource: {} },
+				HOST_FIELD,
+			);
 			expect(value).toBe('unknown');
 		});
 
 		it('reads host.name from resource when present', () => {
 			const value = getFlamegraphSpanGroupValue(
-				{ resource: { 'host.name': 'host-1' } },
+				{
+					serviceName: 'svc',
+					resource: { 'host.name': 'host-1' },
+				},
 				HOST_FIELD,
 			);
 			expect(value).toBe('host-1');

frontend/src/pages/TraceDetailsV3/TraceFlamegraph/computeVisualLayout.ts

@@ -1,10 +1,11 @@
 /* eslint-disable sonarjs/cognitive-complexity */
-import { SpantypesFlamegraphSpanDTO as FlamegraphSpan } from 'api/generated/services/sigNoz.schemas';
+import { FlamegraphSpan } from 'types/api/trace/getTraceFlamegraph';
 
 export interface ConnectorLine {
 	parentRow: number;
 	childRow: number;
 	timestampMs: number;
+	serviceName: string;
 	// Snapshot of the child span's resource so draw-time can resolve the
 	// `colorByField` group value without crossing the worker boundary.
 	resource?: Record<string, string>;
@@ -158,8 +159,24 @@ export function computeVisualLayout(spans: FlamegraphSpan[][]): VisualLayout {
 		}
 	}
 
+	// Extract parentSpanId — the field may be missing at runtime when the API
+	// returns `references` instead.  Fall back to the first CHILD_OF reference.
 	function getParentId(span: FlamegraphSpan): string {
-		return span.parentSpanId || '';
+		if (span.parentSpanId) {
+			return span.parentSpanId;
+		}
+		// eslint-disable-next-line @typescript-eslint/no-explicit-any
+		const refs = (span as any).references as
+			| Array<{ spanId?: string; refType?: string }>
+			| undefined;
+		if (refs) {
+			for (const ref of refs) {
+				if (ref.refType === 'CHILD_OF' && ref.spanId) {
+					return ref.spanId;
+				}
+			}
+		}
+		return '';
 	}
 
 	// Build children map and identify roots
@@ -463,6 +480,7 @@ export function computeVisualLayout(spans: FlamegraphSpan[][]): VisualLayout {
 				parentRow,
 				childRow,
 				timestampMs: child.timestamp,
+				serviceName: child.serviceName,
 				resource: child.resource,
 			});
 		}

frontend/src/pages/TraceDetailsV3/TraceFlamegraph/hooks/useFlamegraphDraw.ts

@@ -1,7 +1,7 @@
 import React, { RefObject, useCallback, useMemo, useRef } from 'react';
 import { generateColorPair } from 'pages/TraceDetailsV3/utils/generateColorPair';
 import { useTraceStore } from 'pages/TraceDetailsV3/stores/traceStore';
-import { SpantypesFlamegraphSpanDTO as FlamegraphSpan } from 'api/generated/services/sigNoz.schemas';
+import { FlamegraphSpan } from 'types/api/trace/getTraceFlamegraph';
 import { TelemetryFieldKey } from 'types/api/v5/queryRange';
 
 import { ConnectorLine } from '../computeVisualLayout';
@@ -200,7 +200,7 @@ function drawConnectorLines(args: DrawConnectorLinesArgs): void {
 		}
 
 		const groupValue = getFlamegraphSpanGroupValue(
-			{ resource: conn.resource },
+			{ serviceName: conn.serviceName, resource: conn.resource },
 			colorByField,
 		);
 		const pair = generateColorPair(groupValue);

frontend/src/pages/TraceDetailsV3/TraceFlamegraph/hooks/useFlamegraphHover.ts

@@ -11,9 +11,10 @@ import {
 import { useTraceStore } from 'pages/TraceDetailsV3/stores/traceStore';
 import { RESERVED_PREVIEW_KEYS } from 'pages/TraceDetailsV3/SpanHoverCard/SpanHoverCard';
 import { getSpanAttribute } from 'pages/TraceDetailsV3/utils';
-import { SpantypesFlamegraphSpanDTO as FlamegraphSpan } from 'api/generated/services/sigNoz.schemas';
+import { FlamegraphSpan } from 'types/api/trace/getTraceFlamegraph';
 
-import { EventRect, ITraceMetadata, SpanRect } from '../types';
+import { EventRect, SpanRect } from '../types';
+import { ITraceMetadata } from '../types';
 import {
 	getFlamegraphServiceName,
 	getFlamegraphSpanGroupValue,
@@ -199,7 +200,7 @@ export function useFlamegraphHover(
 
 			if (eventRect) {
 				const { event, span } = eventRect;
-				const eventTimeMs = (event.timeUnixNano ?? 0) / 1e6;
+				const eventTimeMs = event.timeUnixNano / 1e6;
 				setHoveredEventKey(`${span.spanId}-${event.name}-${event.timeUnixNano}`);
 				setHoveredSpanId(span.spanId);
 				setTooltipContent({
@@ -219,10 +220,10 @@ export function useFlamegraphHover(
 						return isDarkMode ? pair.color : pair.colorDark;
 					})(),
 					event: {
-						name: event.name ?? '',
+						name: event.name,
 						timeOffsetMs: eventTimeMs - span.timestamp,
-						isError: event.isError ?? false,
-						attributeMap: (event.attributeMap as Record<string, string>) ?? {},
+						isError: event.isError,
+						attributeMap: event.attributeMap || {},
 					},
 				});
 				updateCursor(canvas, eventRect.span);

frontend/src/pages/TraceDetailsV3/TraceFlamegraph/hooks/useScrollToSpan.ts

@@ -5,7 +5,7 @@ import {
 	SetStateAction,
 	useEffect,
 } from 'react';
-import { SpantypesFlamegraphSpanDTO as FlamegraphSpan } from 'api/generated/services/sigNoz.schemas';
+import { FlamegraphSpan } from 'types/api/trace/getTraceFlamegraph';
 
 import { MIN_VISIBLE_SPAN_MS } from '../constants';
 import { ITraceMetadata } from '../types';

frontend/src/pages/TraceDetailsV3/TraceFlamegraph/hooks/useVisualLayoutWorker.ts

@@ -1,5 +1,5 @@
 import { useEffect, useRef, useState } from 'react';
-import { SpantypesFlamegraphSpanDTO as FlamegraphSpan } from 'api/generated/services/sigNoz.schemas';
+import { FlamegraphSpan } from 'types/api/trace/getTraceFlamegraph';
 
 import { computeVisualLayout, VisualLayout } from '../computeVisualLayout';
 import { LayoutWorkerResponse } from '../visualLayoutWorkerTypes';

frontend/src/pages/TraceDetailsV3/TraceFlamegraph/types.ts

@@ -1,8 +1,5 @@
-import {
-	SpantypesEventDTO as FlamegraphEvent,
-	SpantypesFlamegraphSpanDTO as FlamegraphSpan,
-} from 'api/generated/services/sigNoz.schemas';
 import { Dispatch, SetStateAction } from 'react';
+import { Event, FlamegraphSpan } from 'types/api/trace/getTraceFlamegraph';
 
 import { VisualLayout } from './computeVisualLayout';
 
@@ -31,7 +28,7 @@ export interface SpanRect {
 }
 
 export interface EventRect {
-	event: FlamegraphEvent;
+	event: Event;
 	span: FlamegraphSpan;
 	cx: number;
 	cy: number;

frontend/src/pages/TraceDetailsV3/TraceFlamegraph/utils.ts

@@ -7,7 +7,7 @@ import {
 	generateColorPair,
 	RESERVED_ERROR,
 } from 'pages/TraceDetailsV3/utils/generateColorPair';
-import { SpantypesFlamegraphSpanDTO as FlamegraphSpan } from 'api/generated/services/sigNoz.schemas';
+import { FlamegraphSpan } from 'types/api/trace/getTraceFlamegraph';
 import { TelemetryFieldKey } from 'types/api/v5/queryRange';
 
 import {
@@ -74,25 +74,34 @@ export function getFlamegraphRowMetrics(
 
 /**
  * Resolve the displayed service.name for a flamegraph span. Used by tooltips
- * (service identity, independent of the active colour-by field). Reads
- * `resource['service.name']`.
+ * (service identity, independent of the active colour-by field). Prefers
+ * `resource['service.name']` with legacy top-level `serviceName` fallback.
  */
 export function getFlamegraphServiceName(
-	span: Partial<Pick<FlamegraphSpan, 'resource' | 'attributes'>>,
+	span: Pick<FlamegraphSpan, 'serviceName' | 'resource' | 'attributes'>,
 ): string {
-	return getSpanAttribute(span, 'service.name') || '';
+	return getSpanAttribute(span, 'service.name') || span.serviceName || '';
 }
 
 /**
  * Resolve the value used to bucket a flamegraph span by colour for the given
- * field. Prefers `resource[field.name]` (contract from `selectFields`), falling
- * back to `'unknown'`.
+ * field. Prefers `resource[field.name]` (new contract from `selectFields`).
+ * For `service.name`, falls back to the legacy top-level `serviceName` when
+ * resource is empty (backward-compat with backends that haven't shipped
+ * `selectFields` yet). For other fields, falls back to `'unknown'`.
  */
 export function getFlamegraphSpanGroupValue(
-	span: Partial<Pick<FlamegraphSpan, 'resource' | 'attributes'>>,
+	span: Pick<FlamegraphSpan, 'serviceName' | 'resource' | 'attributes'>,
 	field: TelemetryFieldKey,
 ): string {
-	return getSpanAttribute(span, field.name) || 'unknown';
+	const fromAttribute = getSpanAttribute(span, field.name);
+	if (fromAttribute) {
+		return fromAttribute;
+	}
+	if (field.name === 'service.name') {
+		return span.serviceName || 'unknown';
+	}
+	return 'unknown';
 }
 
 interface GetSpanColorArgs {
@@ -287,7 +296,7 @@ export function drawSpanBar(args: DrawSpanBarArgs): void {
 			return;
 		}
 
-		const eventTimeMs = (event.timeUnixNano ?? 0) / 1e6;
+		const eventTimeMs = event.timeUnixNano / 1e6;
 		const eventOffsetPercent =
 			((eventTimeMs - span.timestamp) / spanDurationMs) * 100;
 		const clampedOffset = clamp(eventOffsetPercent, 1, 99);
@@ -297,11 +306,7 @@ export function drawSpanBar(args: DrawSpanBarArgs): void {
 		// Event dots derive from the effective bar color so they track the
 		// light/dark variant the bar is rendered with.
 		const parentBarColor = isDarkMode ? color : colorDark;
-		const dotColor = getEventDotColor(
-			parentBarColor,
-			event.isError ?? false,
-			isDarkMode,
-		);
+		const dotColor = getEventDotColor(parentBarColor, event.isError, isDarkMode);
 		const eventKey = `${span.spanId}-${event.name}-${event.timeUnixNano}`;
 		const isEventHovered = hoveredEventKey === eventKey;
 		const dotSize = isEventHovered

frontend/src/pages/TraceDetailsV3/TraceFlamegraph/visualLayoutWorkerTypes.ts

@@ -1,4 +1,4 @@
-import { SpantypesFlamegraphSpanDTO as FlamegraphSpan } from 'api/generated/services/sigNoz.schemas';
+import { FlamegraphSpan } from 'types/api/trace/getTraceFlamegraph';
 
 import { VisualLayout } from './computeVisualLayout';
 

frontend/src/providers/QueryBuilder.tsx

@@ -38,11 +38,9 @@ import { useGetCompositeQueryParam } from 'hooks/queryBuilder/useGetCompositeQue
 import { updateStepInterval } from 'hooks/queryBuilder/useStepInterval';
 import { useSafeNavigate } from 'hooks/useSafeNavigate';
 import useUrlQuery from 'hooks/useUrlQuery';
-import { serialize } from 'lib/compositeQuery/serializer';
 import { createIdFromObjectFields } from 'lib/createIdFromObjectFields';
 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';
@@ -937,7 +935,7 @@ export function QueryBuilderProvider({
 	);
 
 	const { safeNavigate } = useSafeNavigate({
-		preventSameUrlNavigation: true,
+		preventSameUrlNavigation: false,
 	});
 
 	const redirectWithQueryBuilderData = useCallback(
@@ -991,7 +989,10 @@ export function QueryBuilderProvider({
 				);
 			}
 
-			urlQuery.set(QueryParams.compositeQuery, serialize(currentGeneratedQuery));
+			urlQuery.set(
+				QueryParams.compositeQuery,
+				encodeURIComponent(JSON.stringify(currentGeneratedQuery)),
+			);
 
 			if (searchParams) {
 				Object.keys(searchParams).forEach((param) =>
@@ -1030,8 +1031,6 @@ export function QueryBuilderProvider({
 		if (isExplorer) {
 			setCalledFromHandleRunQuery(true);
 		}
-		saveRecentQuery(currentQuery);
-
 		const currentQueryData = {
 			...currentQuery,
 			builder: {

frontend/src/providers/Timezone.tsx

@@ -19,14 +19,17 @@ import {
 } from 'components/CustomTimePicker/timezoneUtils';
 import { LOCALSTORAGE } from 'constants/localStorage';
 import useTimezoneFormatter, {
-	FormatTimezoneAdjustedTimestamp,
+	TimestampInput,
 } from 'hooks/useTimezoneFormatter/useTimezoneFormatter';
 
 export interface TimezoneContextType {
 	timezone: Timezone;
 	browserTimezone: Timezone;
 	updateTimezone: (timezone: Timezone) => void;
-	formatTimezoneAdjustedTimestamp: FormatTimezoneAdjustedTimestamp;
+	formatTimezoneAdjustedTimestamp: (
+		input: TimestampInput,
+		format?: string,
+	) => string;
 	isAdaptationEnabled: boolean;
 	setIsAdaptationEnabled: Dispatch<SetStateAction<boolean>>;
 }

frontend/src/utils/timeUtils.ts

@@ -2,7 +2,6 @@ import { DATE_TIME_FORMATS } from 'constants/dateTimeFormats';
 import dayjs from 'dayjs';
 import customParseFormat from 'dayjs/plugin/customParseFormat';
 import duration from 'dayjs/plugin/duration';
-import relativeTime from 'dayjs/plugin/relativeTime';
 import timezone from 'dayjs/plugin/timezone';
 import utc from 'dayjs/plugin/utc';
 
@@ -10,7 +9,6 @@ dayjs.extend(utc);
 dayjs.extend(customParseFormat);
 dayjs.extend(duration);
 dayjs.extend(timezone);
-dayjs.extend(relativeTime);
 
 export function toUTCEpoch(time: number): number {
 	const x = new Date();