remove redundant error in prepareQueryRangeV5

.github/CODEOWNERS

@@ -86,8 +86,6 @@ go.mod @therealpandey
 /pkg/types/alertmanagertypes @srikanthccv
 /pkg/alertmanager/ @srikanthccv
 /pkg/ruler/ @srikanthccv
-/pkg/modules/rulestatehistory/ @srikanthccv
-/pkg/types/rulestatehistorytypes/ @srikanthccv
 
 # Correlation-adjacent
 
@@ -107,7 +105,7 @@ go.mod @therealpandey
 /pkg/modules/authdomain/ @vikrantgupta25
 /pkg/modules/role/ @vikrantgupta25
 
-# IdentN Owners
+# IdentN Owners 
 /pkg/identn/ @vikrantgupta25
 /pkg/http/middleware/identn.go @vikrantgupta25
 

cmd/community/server.go

@@ -12,7 +12,6 @@ import (
 	"github.com/SigNoz/signoz/pkg/authz"
 	"github.com/SigNoz/signoz/pkg/authz/openfgaauthz"
 	"github.com/SigNoz/signoz/pkg/authz/openfgaschema"
-	"github.com/SigNoz/signoz/pkg/authz/openfgaserver"
 	"github.com/SigNoz/signoz/pkg/errors"
 	"github.com/SigNoz/signoz/pkg/factory"
 	"github.com/SigNoz/signoz/pkg/gateway"
@@ -79,13 +78,8 @@ func runServer(ctx context.Context, config signoz.Config, logger *slog.Logger) e
 		func(ctx context.Context, providerSettings factory.ProviderSettings, store authtypes.AuthNStore, licensing licensing.Licensing) (map[authtypes.AuthNProvider]authn.AuthN, error) {
 			return signoz.NewAuthNs(ctx, providerSettings, store, licensing)
 		},
-		func(ctx context.Context, sqlstore sqlstore.SQLStore, _ licensing.Licensing, _ dashboard.Module) (factory.ProviderFactory[authz.AuthZ, authz.Config], error) {
-			openfgaDataStore, err := openfgaserver.NewSQLStore(sqlstore)
-			if err != nil {
-				return nil, err
-			}
-
-			return openfgaauthz.NewProviderFactory(sqlstore, openfgaschema.NewSchema().Get(ctx), openfgaDataStore), nil
+		func(ctx context.Context, sqlstore sqlstore.SQLStore, _ licensing.Licensing, _ dashboard.Module) factory.ProviderFactory[authz.AuthZ, authz.Config] {
+			return openfgaauthz.NewProviderFactory(sqlstore, openfgaschema.NewSchema().Get(ctx))
 		},
 		func(store sqlstore.SQLStore, settings factory.ProviderSettings, analytics analytics.Analytics, orgGetter organization.Getter, queryParser queryparser.QueryParser, _ querier.Querier, _ licensing.Licensing) dashboard.Module {
 			return impldashboard.NewModule(impldashboard.NewStore(store), settings, analytics, orgGetter, queryParser)

cmd/enterprise/server.go

@@ -12,7 +12,6 @@ import (
 	"github.com/SigNoz/signoz/ee/authn/callbackauthn/samlcallbackauthn"
 	"github.com/SigNoz/signoz/ee/authz/openfgaauthz"
 	"github.com/SigNoz/signoz/ee/authz/openfgaschema"
-	"github.com/SigNoz/signoz/ee/authz/openfgaserver"
 	"github.com/SigNoz/signoz/ee/gateway/httpgateway"
 	enterpriselicensing "github.com/SigNoz/signoz/ee/licensing"
 	"github.com/SigNoz/signoz/ee/licensing/httplicensing"
@@ -119,13 +118,8 @@ func runServer(ctx context.Context, config signoz.Config, logger *slog.Logger) e
 
 			return authNs, nil
 		},
-		func(ctx context.Context, sqlstore sqlstore.SQLStore, licensing licensing.Licensing, dashboardModule dashboard.Module) (factory.ProviderFactory[authz.AuthZ, authz.Config], error) {
-			openfgaDataStore, err := openfgaserver.NewSQLStore(sqlstore)
-			if err != nil {
-				return nil, err
-			}
-			return openfgaauthz.NewProviderFactory(sqlstore, openfgaschema.NewSchema().Get(ctx), openfgaDataStore, licensing, dashboardModule), nil
-
+		func(ctx context.Context, sqlstore sqlstore.SQLStore, licensing licensing.Licensing, dashboardModule dashboard.Module) factory.ProviderFactory[authz.AuthZ, authz.Config] {
+			return openfgaauthz.NewProviderFactory(sqlstore, openfgaschema.NewSchema().Get(ctx), licensing, dashboardModule)
 		},
 		func(store sqlstore.SQLStore, settings factory.ProviderSettings, analytics analytics.Analytics, orgGetter organization.Getter, queryParser queryparser.QueryParser, querier querier.Querier, licensing licensing.Licensing) dashboard.Module {
 			return impldashboard.NewModule(pkgimpldashboard.NewStore(store), settings, analytics, orgGetter, queryParser, querier, licensing)

docs/api/openapi.yml

@@ -1114,33 +1114,6 @@ components:
         enabled:
           type: boolean
       type: object
-    MetricsexplorertypesInspectMetricsRequest:
-      properties:
-        end:
-          format: int64
-          type: integer
-        filter:
-          $ref: '#/components/schemas/Querybuildertypesv5Filter'
-        metricName:
-          type: string
-        start:
-          format: int64
-          type: integer
-      required:
-      - metricName
-      - start
-      - end
-      type: object
-    MetricsexplorertypesInspectMetricsResponse:
-      properties:
-        series:
-          items:
-            $ref: '#/components/schemas/Querybuildertypesv5TimeSeries'
-          nullable: true
-          type: array
-      required:
-      - series
-      type: object
     MetricsexplorertypesListMetric:
       properties:
         description:
@@ -1289,13 +1262,6 @@ components:
       - temporality
       - isMonotonic
       type: object
-    MetricsexplorertypesMetricsOnboardingResponse:
-      properties:
-        hasMetrics:
-          type: boolean
-      required:
-      - hasMetrics
-      type: object
     MetricsexplorertypesStat:
       properties:
         description:
@@ -2313,140 +2279,6 @@ components:
       - status
       - error
       type: object
-    RulestatehistorytypesAlertState:
-      enum:
-      - inactive
-      - pending
-      - recovering
-      - firing
-      - nodata
-      - disabled
-      type: string
-    RulestatehistorytypesGettableRuleStateHistory:
-      properties:
-        fingerprint:
-          minimum: 0
-          type: integer
-        labels:
-          items:
-            $ref: '#/components/schemas/Querybuildertypesv5Label'
-          nullable: true
-          type: array
-        overallState:
-          $ref: '#/components/schemas/RulestatehistorytypesAlertState'
-        overallStateChanged:
-          type: boolean
-        ruleID:
-          type: string
-        ruleName:
-          type: string
-        state:
-          $ref: '#/components/schemas/RulestatehistorytypesAlertState'
-        stateChanged:
-          type: boolean
-        unixMilli:
-          format: int64
-          type: integer
-        value:
-          format: double
-          type: number
-      required:
-      - ruleID
-      - ruleName
-      - overallState
-      - overallStateChanged
-      - state
-      - stateChanged
-      - unixMilli
-      - labels
-      - fingerprint
-      - value
-      type: object
-    RulestatehistorytypesGettableRuleStateHistoryContributor:
-      properties:
-        count:
-          minimum: 0
-          type: integer
-        fingerprint:
-          minimum: 0
-          type: integer
-        labels:
-          items:
-            $ref: '#/components/schemas/Querybuildertypesv5Label'
-          nullable: true
-          type: array
-        relatedLogsLink:
-          type: string
-        relatedTracesLink:
-          type: string
-      required:
-      - fingerprint
-      - labels
-      - count
-      type: object
-    RulestatehistorytypesGettableRuleStateHistoryStats:
-      properties:
-        currentAvgResolutionTime:
-          format: double
-          type: number
-        currentAvgResolutionTimeSeries:
-          $ref: '#/components/schemas/Querybuildertypesv5TimeSeries'
-        currentTriggersSeries:
-          $ref: '#/components/schemas/Querybuildertypesv5TimeSeries'
-        pastAvgResolutionTime:
-          format: double
-          type: number
-        pastAvgResolutionTimeSeries:
-          $ref: '#/components/schemas/Querybuildertypesv5TimeSeries'
-        pastTriggersSeries:
-          $ref: '#/components/schemas/Querybuildertypesv5TimeSeries'
-        totalCurrentTriggers:
-          minimum: 0
-          type: integer
-        totalPastTriggers:
-          minimum: 0
-          type: integer
-      required:
-      - totalCurrentTriggers
-      - totalPastTriggers
-      - currentTriggersSeries
-      - pastTriggersSeries
-      - currentAvgResolutionTime
-      - pastAvgResolutionTime
-      - currentAvgResolutionTimeSeries
-      - pastAvgResolutionTimeSeries
-      type: object
-    RulestatehistorytypesGettableRuleStateTimeline:
-      properties:
-        items:
-          items:
-            $ref: '#/components/schemas/RulestatehistorytypesGettableRuleStateHistory'
-          nullable: true
-          type: array
-        nextCursor:
-          type: string
-        total:
-          minimum: 0
-          type: integer
-      required:
-      - items
-      - total
-      type: object
-    RulestatehistorytypesGettableRuleStateWindow:
-      properties:
-        end:
-          format: int64
-          type: integer
-        start:
-          format: int64
-          type: integer
-        state:
-          $ref: '#/components/schemas/RulestatehistorytypesAlertState'
-      required:
-      - state
-      - start
-      - end
-      type: object
     ServiceaccounttypesFactorAPIKey:
       properties:
         createdAt:
@@ -7784,111 +7616,6 @@ paths:
       summary: Update metric metadata
       tags:
       - metrics
-  /api/v2/metrics/inspect:
-    post:
-      deprecated: false
-      description: Returns raw time series data points for a metric within a time
-        range (max 30 minutes). Each series includes labels and timestamp/value pairs.
-      operationId: InspectMetrics
-      requestBody:
-        content:
-          application/json:
-            schema:
-              $ref: '#/components/schemas/MetricsexplorertypesInspectMetricsRequest'
-      responses:
-        "200":
-          content:
-            application/json:
-              schema:
-                properties:
-                  data:
-                    $ref: '#/components/schemas/MetricsexplorertypesInspectMetricsResponse'
-                  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: Inspect raw metric data points
-      tags:
-      - metrics
-  /api/v2/metrics/onboarding:
-    get:
-      deprecated: false
-      description: Lightweight endpoint that checks if any non-SigNoz metrics have
-        been ingested, used for onboarding status detection
-      operationId: GetMetricsOnboardingStatus
-      responses:
-        "200":
-          content:
-            application/json:
-              schema:
-                properties:
-                  data:
-                    $ref: '#/components/schemas/MetricsexplorertypesMetricsOnboardingResponse'
-                  status:
-                    type: string
-                required:
-                - status
-                - data
-                type: object
-          description: OK
-        "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: Check if non-SigNoz metrics have been received
-      tags:
-      - metrics
   /api/v2/metrics/stats:
     post:
       deprecated: false
@@ -8196,518 +7923,6 @@ paths:
       summary: Get users by role id
       tags:
       - users
-  /api/v2/rules/{id}/history/filter_keys:
-    get:
-      deprecated: false
-      description: Returns distinct label keys from rule history entries for the selected
-        range.
-      operationId: GetRuleHistoryFilterKeys
-      parameters:
-      - in: query
-        name: signal
-        schema:
-          $ref: '#/components/schemas/TelemetrytypesSignal'
-      - in: query
-        name: source
-        schema:
-          $ref: '#/components/schemas/TelemetrytypesSource'
-      - in: query
-        name: limit
-        schema:
-          type: integer
-      - in: query
-        name: startUnixMilli
-        schema:
-          format: int64
-          type: integer
-      - in: query
-        name: endUnixMilli
-        schema:
-          format: int64
-          type: integer
-      - in: query
-        name: fieldContext
-        schema:
-          $ref: '#/components/schemas/TelemetrytypesFieldContext'
-      - in: query
-        name: fieldDataType
-        schema:
-          $ref: '#/components/schemas/TelemetrytypesFieldDataType'
-      - in: query
-        name: metricName
-        schema:
-          type: string
-      - in: query
-        name: searchText
-        schema:
-          type: string
-      - in: path
-        name: id
-        required: true
-        schema:
-          type: string
-      responses:
-        "200":
-          content:
-            application/json:
-              schema:
-                properties:
-                  data:
-                    $ref: '#/components/schemas/TelemetrytypesGettableFieldKeys'
-                  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: Get rule history filter keys
-      tags:
-      - rules
-  /api/v2/rules/{id}/history/filter_values:
-    get:
-      deprecated: false
-      description: Returns distinct label values for a given key from rule history
-        entries.
-      operationId: GetRuleHistoryFilterValues
-      parameters:
-      - in: query
-        name: signal
-        schema:
-          $ref: '#/components/schemas/TelemetrytypesSignal'
-      - in: query
-        name: source
-        schema:
-          $ref: '#/components/schemas/TelemetrytypesSource'
-      - in: query
-        name: limit
-        schema:
-          type: integer
-      - in: query
-        name: startUnixMilli
-        schema:
-          format: int64
-          type: integer
-      - in: query
-        name: endUnixMilli
-        schema:
-          format: int64
-          type: integer
-      - in: query
-        name: fieldContext
-        schema:
-          $ref: '#/components/schemas/TelemetrytypesFieldContext'
-      - in: query
-        name: fieldDataType
-        schema:
-          $ref: '#/components/schemas/TelemetrytypesFieldDataType'
-      - in: query
-        name: metricName
-        schema:
-          type: string
-      - in: query
-        name: searchText
-        schema:
-          type: string
-      - in: query
-        name: name
-        schema:
-          type: string
-      - in: query
-        name: existingQuery
-        schema:
-          type: string
-      - in: path
-        name: id
-        required: true
-        schema:
-          type: string
-      responses:
-        "200":
-          content:
-            application/json:
-              schema:
-                properties:
-                  data:
-                    $ref: '#/components/schemas/TelemetrytypesGettableFieldValues'
-                  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: Get rule history filter values
-      tags:
-      - rules
-  /api/v2/rules/{id}/history/overall_status:
-    get:
-      deprecated: false
-      description: Returns overall firing/inactive intervals for a rule in the selected
-        time range.
-      operationId: GetRuleHistoryOverallStatus
-      parameters:
-      - in: query
-        name: start
-        required: true
-        schema:
-          format: int64
-          type: integer
-      - in: query
-        name: end
-        required: true
-        schema:
-          format: int64
-          type: integer
-      - in: path
-        name: id
-        required: true
-        schema:
-          type: string
-      responses:
-        "200":
-          content:
-            application/json:
-              schema:
-                properties:
-                  data:
-                    items:
-                      $ref: '#/components/schemas/RulestatehistorytypesGettableRuleStateWindow'
-                    nullable: true
-                    type: array
-                  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: Get rule overall status timeline
-      tags:
-      - rules
-  /api/v2/rules/{id}/history/stats:
-    get:
-      deprecated: false
-      description: Returns trigger and resolution statistics for a rule in the selected
-        time range.
-      operationId: GetRuleHistoryStats
-      parameters:
-      - in: query
-        name: start
-        required: true
-        schema:
-          format: int64
-          type: integer
-      - in: query
-        name: end
-        required: true
-        schema:
-          format: int64
-          type: integer
-      - in: path
-        name: id
-        required: true
-        schema:
-          type: string
-      responses:
-        "200":
-          content:
-            application/json:
-              schema:
-                properties:
-                  data:
-                    $ref: '#/components/schemas/RulestatehistorytypesGettableRuleStateHistoryStats'
-                  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: Get rule history stats
-      tags:
-      - rules
-  /api/v2/rules/{id}/history/timeline:
-    get:
-      deprecated: false
-      description: Returns paginated timeline entries for rule state transitions.
-      operationId: GetRuleHistoryTimeline
-      parameters:
-      - in: query
-        name: start
-        required: true
-        schema:
-          format: int64
-          type: integer
-      - in: query
-        name: end
-        required: true
-        schema:
-          format: int64
-          type: integer
-      - in: query
-        name: state
-        schema:
-          $ref: '#/components/schemas/RulestatehistorytypesAlertState'
-      - in: query
-        name: filterExpression
-        schema:
-          type: string
-      - in: query
-        name: limit
-        schema:
-          format: int64
-          type: integer
-      - in: query
-        name: order
-        schema:
-          $ref: '#/components/schemas/Querybuildertypesv5OrderDirection'
-      - in: query
-        name: cursor
-        schema:
-          type: string
-      - in: path
-        name: id
-        required: true
-        schema:
-          type: string
-      responses:
-        "200":
-          content:
-            application/json:
-              schema:
-                properties:
-                  data:
-                    $ref: '#/components/schemas/RulestatehistorytypesGettableRuleStateTimeline'
-                  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: Get rule history timeline
-      tags:
-      - rules
-  /api/v2/rules/{id}/history/top_contributors:
-    get:
-      deprecated: false
-      description: Returns top label combinations contributing to rule firing in the
-        selected time range.
-      operationId: GetRuleHistoryTopContributors
-      parameters:
-      - in: query
-        name: start
-        required: true
-        schema:
-          format: int64
-          type: integer
-      - in: query
-        name: end
-        required: true
-        schema:
-          format: int64
-          type: integer
-      - in: path
-        name: id
-        required: true
-        schema:
-          type: string
-      responses:
-        "200":
-          content:
-            application/json:
-              schema:
-                properties:
-                  data:
-                    items:
-                      $ref: '#/components/schemas/RulestatehistorytypesGettableRuleStateHistoryContributor'
-                    nullable: true
-                    type: array
-                  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: Get top contributors to rule firing
-      tags:
-      - rules
   /api/v2/sessions:
     delete:
       deprecated: false

ee/authz/openfgaauthz/provider.go

@@ -16,7 +16,6 @@ import (
 	"github.com/SigNoz/signoz/pkg/valuer"
 	openfgav1 "github.com/openfga/api/proto/openfga/v1"
 	openfgapkgtransformer "github.com/openfga/language/pkg/go/transformer"
-	"github.com/openfga/openfga/pkg/storage"
 )
 
 type provider struct {
@@ -27,14 +26,14 @@ type provider struct {
 	registry        []authz.RegisterTypeable
 }
 
-func NewProviderFactory(sqlstore sqlstore.SQLStore, openfgaSchema []openfgapkgtransformer.ModuleFile, openfgaDataStore storage.OpenFGADatastore, licensing licensing.Licensing, registry ...authz.RegisterTypeable) factory.ProviderFactory[authz.AuthZ, authz.Config] {
+func NewProviderFactory(sqlstore sqlstore.SQLStore, openfgaSchema []openfgapkgtransformer.ModuleFile, licensing licensing.Licensing, registry ...authz.RegisterTypeable) factory.ProviderFactory[authz.AuthZ, authz.Config] {
 	return factory.NewProviderFactory(factory.MustNewName("openfga"), func(ctx context.Context, ps factory.ProviderSettings, config authz.Config) (authz.AuthZ, error) {
-		return newOpenfgaProvider(ctx, ps, config, sqlstore, openfgaSchema, openfgaDataStore, licensing, registry)
+		return newOpenfgaProvider(ctx, ps, config, sqlstore, openfgaSchema, licensing, registry)
 	})
 }
 
-func newOpenfgaProvider(ctx context.Context, settings factory.ProviderSettings, config authz.Config, sqlstore sqlstore.SQLStore, openfgaSchema []openfgapkgtransformer.ModuleFile, openfgaDataStore storage.OpenFGADatastore, licensing licensing.Licensing, registry []authz.RegisterTypeable) (authz.AuthZ, error) {
-	pkgOpenfgaAuthzProvider := pkgopenfgaauthz.NewProviderFactory(sqlstore, openfgaSchema, openfgaDataStore)
+func newOpenfgaProvider(ctx context.Context, settings factory.ProviderSettings, config authz.Config, sqlstore sqlstore.SQLStore, openfgaSchema []openfgapkgtransformer.ModuleFile, licensing licensing.Licensing, registry []authz.RegisterTypeable) (authz.AuthZ, error) {
+	pkgOpenfgaAuthzProvider := pkgopenfgaauthz.NewProviderFactory(sqlstore, openfgaSchema)
 	pkgAuthzService, err := pkgOpenfgaAuthzProvider.New(ctx, settings, config)
 	if err != nil {
 		return nil, err

ee/authz/openfgaserver/sqlstore.go

@@ -1,32 +0,0 @@
-package openfgaserver
-
-import (
-	"github.com/SigNoz/signoz/ee/sqlstore/postgressqlstore"
-	"github.com/SigNoz/signoz/pkg/errors"
-	"github.com/SigNoz/signoz/pkg/sqlstore"
-	"github.com/openfga/openfga/pkg/storage"
-	"github.com/openfga/openfga/pkg/storage/postgres"
-	"github.com/openfga/openfga/pkg/storage/sqlcommon"
-	"github.com/openfga/openfga/pkg/storage/sqlite"
-)
-
-func NewSQLStore(store sqlstore.SQLStore) (storage.OpenFGADatastore, error) {
-	switch store.BunDB().Dialect().Name().String() {
-	case "sqlite":
-		return sqlite.NewWithDB(store.SQLDB(), &sqlcommon.Config{
-			MaxTuplesPerWriteField: 100,
-			MaxTypesPerModelField:  100,
-		})
-	case "pg":
-		pgStore, ok := store.(postgressqlstore.Pooler)
-		if !ok {
-			panic(errors.New(errors.TypeInternal, errors.CodeInternal, "postgressqlstore should implement Pooler"))
-		}
-
-		return postgres.NewWithDB(pgStore.Pool(), nil, &sqlcommon.Config{
-			MaxTuplesPerWriteField: 100,
-			MaxTypesPerModelField:  100,
-		})
-	}
-	return nil, errors.Newf(errors.TypeInvalidInput, errors.CodeInvalidInput, "invalid store type: %s", store.BunDB().Dialect().Name().String())
-}

ee/query-service/app/server.go

@@ -29,7 +29,6 @@ import (
 	"github.com/SigNoz/signoz/pkg/cache"
 	"github.com/SigNoz/signoz/pkg/http/middleware"
 	"github.com/SigNoz/signoz/pkg/modules/organization"
-	"github.com/SigNoz/signoz/pkg/modules/rulestatehistory"
 	"github.com/SigNoz/signoz/pkg/prometheus"
 	"github.com/SigNoz/signoz/pkg/querier"
 	"github.com/SigNoz/signoz/pkg/signoz"
@@ -107,7 +106,6 @@ func NewServer(config signoz.Config, signoz *signoz.SigNoz) (*Server, error) {
 		signoz.TelemetryMetadataStore,
 		signoz.Prometheus,
 		signoz.Modules.OrgGetter,
-		signoz.Modules.RuleStateHistory,
 		signoz.Querier,
 		signoz.Instrumentation.ToProviderSettings(),
 		signoz.QueryParser,
@@ -242,6 +240,7 @@ func (s *Server) createPublicServer(apiHandler *api.APIHandler, web web.Web) (*h
 	apiHandler.RegisterWebSocketPaths(r, am)
 	apiHandler.RegisterMessagingQueuesRoutes(r, am)
 	apiHandler.RegisterThirdPartyApiRoutes(r, am)
+	apiHandler.MetricExplorerRoutes(r, am)
 	apiHandler.RegisterTraceFunnelsRoutes(r, am)
 
 	err := s.signoz.APIServer.AddToRouter(r)
@@ -345,29 +344,28 @@ func (s *Server) Stop(ctx context.Context) error {
 	return nil
 }
 
-func makeRulesManager(ch baseint.Reader, cache cache.Cache, alertmanager alertmanager.Alertmanager, sqlstore sqlstore.SQLStore, telemetryStore telemetrystore.TelemetryStore, metadataStore telemetrytypes.MetadataStore, prometheus prometheus.Prometheus, orgGetter organization.Getter, ruleStateHistoryModule rulestatehistory.Module, querier querier.Querier, providerSettings factory.ProviderSettings, queryParser queryparser.QueryParser) (*baserules.Manager, error) {
+func makeRulesManager(ch baseint.Reader, cache cache.Cache, alertmanager alertmanager.Alertmanager, sqlstore sqlstore.SQLStore, telemetryStore telemetrystore.TelemetryStore, metadataStore telemetrytypes.MetadataStore, prometheus prometheus.Prometheus, orgGetter organization.Getter, querier querier.Querier, providerSettings factory.ProviderSettings, queryParser queryparser.QueryParser) (*baserules.Manager, error) {
 	ruleStore := sqlrulestore.NewRuleStore(sqlstore, queryParser, providerSettings)
 	maintenanceStore := sqlrulestore.NewMaintenanceStore(sqlstore)
 	// create manager opts
 	managerOpts := &baserules.ManagerOptions{
-		TelemetryStore:         telemetryStore,
-		MetadataStore:          metadataStore,
-		Prometheus:             prometheus,
-		Context:                context.Background(),
-		Reader:                 ch,
-		Querier:                querier,
-		Logger:                 providerSettings.Logger,
-		Cache:                  cache,
-		EvalDelay:              baseconst.GetEvalDelay(),
-		PrepareTaskFunc:        rules.PrepareTaskFunc,
-		PrepareTestRuleFunc:    rules.TestNotification,
-		Alertmanager:           alertmanager,
-		OrgGetter:              orgGetter,
-		RuleStore:              ruleStore,
-		MaintenanceStore:       maintenanceStore,
-		SqlStore:               sqlstore,
-		QueryParser:            queryParser,
-		RuleStateHistoryModule: ruleStateHistoryModule,
+		TelemetryStore:      telemetryStore,
+		MetadataStore:       metadataStore,
+		Prometheus:          prometheus,
+		Context:             context.Background(),
+		Reader:              ch,
+		Querier:             querier,
+		Logger:              providerSettings.Logger,
+		Cache:               cache,
+		EvalDelay:           baseconst.GetEvalDelay(),
+		PrepareTaskFunc:     rules.PrepareTaskFunc,
+		PrepareTestRuleFunc: rules.TestNotification,
+		Alertmanager:        alertmanager,
+		OrgGetter:           orgGetter,
+		RuleStore:           ruleStore,
+		MaintenanceStore:    maintenanceStore,
+		SqlStore:            sqlstore,
+		QueryParser:         queryParser,
 	}
 
 	// create Manager

ee/query-service/rules/anomaly.go

@@ -7,29 +7,21 @@ import (
 	"log/slog"
 	"math"
 	"strings"
-	"sync"
 	"time"
 
 	"github.com/SigNoz/signoz/ee/query-service/anomaly"
 	"github.com/SigNoz/signoz/pkg/cache"
 	"github.com/SigNoz/signoz/pkg/errors"
 	"github.com/SigNoz/signoz/pkg/query-service/common"
-	"github.com/SigNoz/signoz/pkg/query-service/model"
 	"github.com/SigNoz/signoz/pkg/transition"
 	"github.com/SigNoz/signoz/pkg/types/ruletypes"
 	"github.com/SigNoz/signoz/pkg/valuer"
 
-	querierV2 "github.com/SigNoz/signoz/pkg/query-service/app/querier/v2"
 	"github.com/SigNoz/signoz/pkg/query-service/app/queryBuilder"
 	"github.com/SigNoz/signoz/pkg/query-service/interfaces"
 	v3 "github.com/SigNoz/signoz/pkg/query-service/model/v3"
-	"github.com/SigNoz/signoz/pkg/query-service/utils/labels"
-	"github.com/SigNoz/signoz/pkg/query-service/utils/times"
-	"github.com/SigNoz/signoz/pkg/query-service/utils/timestamp"
-
-	"github.com/SigNoz/signoz/pkg/units"
-
 	baserules "github.com/SigNoz/signoz/pkg/query-service/rules"
+	"github.com/SigNoz/signoz/pkg/query-service/utils/labels"
 
 	querierV5 "github.com/SigNoz/signoz/pkg/querier"
 
@@ -45,16 +37,6 @@ const (
 type AnomalyRule struct {
 	*baserules.BaseRule
 
-	mtx sync.Mutex
-
-	reader interfaces.Reader
-
-	// querierV2 is used for alerts created after the introduction of new metrics query builder
-	querierV2 interfaces.Querier
-
-	// querierV5 is used for alerts migrated after the introduction of new query builder
-	querierV5 querierV5.Querier
-
 	provider   anomaly.Provider
 	providerV2 anomalyV2.Provider
 
@@ -103,14 +85,6 @@ func NewAnomalyRule(
 
 	logger.Info("using seasonality", "seasonality", t.seasonality.String())
 
-	querierOptsV2 := querierV2.QuerierOptions{
-		Reader:       reader,
-		Cache:        cache,
-		KeyGenerator: queryBuilder.NewKeyGenerator(),
-	}
-
-	t.querierV2 = querierV2.NewQuerier(querierOptsV2)
-	t.reader = reader
 	if t.seasonality == anomaly.SeasonalityHourly {
 		t.provider = anomaly.NewHourlyProvider(
 			anomaly.WithCache[*anomaly.HourlyProvider](cache),
@@ -148,7 +122,6 @@ func NewAnomalyRule(
 		)
 	}
 
-	t.querierV5 = querierV5
 	t.version = p.Version
 	t.logger = logger
 	return &t, nil
@@ -333,14 +306,8 @@ func (r *AnomalyRule) buildAndRunQueryV5(ctx context.Context, orgID valuer.UUID,
 }
 
 func (r *AnomalyRule) Eval(ctx context.Context, ts time.Time) (int, error) {
-
-	prevState := r.State()
-
-	valueFormatter := units.FormatterFromUnit(r.Unit())
-
 	var res ruletypes.Vector
 	var err error
-
 	if r.version == "v5" {
 		r.logger.InfoContext(ctx, "running v5 query")
 		res, err = r.buildAndRunQueryV5(ctx, r.OrgID(), ts)
@@ -352,220 +319,8 @@ func (r *AnomalyRule) Eval(ctx context.Context, ts time.Time) (int, error) {
 		return 0, err
 	}
 
-	r.mtx.Lock()
-	defer r.mtx.Unlock()
-
-	resultFPs := map[uint64]struct{}{}
-	var alerts = make(map[uint64]*ruletypes.Alert, len(res))
-
-	ruleReceivers := r.Threshold.GetRuleReceivers()
-	ruleReceiverMap := make(map[string][]string)
-	for _, value := range ruleReceivers {
-		ruleReceiverMap[value.Name] = value.Channels
+	opts := baserules.EvalVectorOptions{
+		DeleteLabels: []string{labels.MetricNameLabel, labels.TemporalityLabel},
 	}
-
-	for _, smpl := range res {
-		l := make(map[string]string, len(smpl.Metric))
-		for _, lbl := range smpl.Metric {
-			l[lbl.Name] = lbl.Value
-		}
-		value := valueFormatter.Format(smpl.V, r.Unit())
-		threshold := valueFormatter.Format(smpl.Target, smpl.TargetUnit)
-		r.logger.DebugContext(ctx, "Alert template data for rule", "rule_name", r.Name(), "formatter", valueFormatter.Name(), "value", value, "threshold", threshold)
-
-		tmplData := ruletypes.AlertTemplateData(l, value, threshold)
-		// Inject some convenience variables that are easier to remember for users
-		// who are not used to Go's templating system.
-		defs := "{{$labels := .Labels}}{{$value := .Value}}{{$threshold := .Threshold}}"
-
-		// utility function to apply go template on labels and annotations
-		expand := func(text string) string {
-
-			tmpl := ruletypes.NewTemplateExpander(
-				ctx,
-				defs+text,
-				"__alert_"+r.Name(),
-				tmplData,
-				times.Time(timestamp.FromTime(ts)),
-				nil,
-			)
-			result, err := tmpl.Expand()
-			if err != nil {
-				result = fmt.Sprintf("<error expanding template: %s>", err)
-				r.logger.ErrorContext(ctx, "Expanding alert template failed", errors.Attr(err), "data", tmplData, "rule_name", r.Name())
-			}
-			return result
-		}
-
-		lb := labels.NewBuilder(smpl.Metric).Del(labels.MetricNameLabel).Del(labels.TemporalityLabel)
-		resultLabels := labels.NewBuilder(smpl.Metric).Del(labels.MetricNameLabel).Del(labels.TemporalityLabel).Labels()
-
-		for name, value := range r.Labels().Map() {
-			lb.Set(name, expand(value))
-		}
-
-		lb.Set(labels.AlertNameLabel, r.Name())
-		lb.Set(labels.AlertRuleIdLabel, r.ID())
-		lb.Set(labels.RuleSourceLabel, r.GeneratorURL())
-
-		annotations := make(labels.Labels, 0, len(r.Annotations().Map()))
-		for name, value := range r.Annotations().Map() {
-			annotations = append(annotations, labels.Label{Name: name, Value: expand(value)})
-		}
-		if smpl.IsMissing {
-			lb.Set(labels.AlertNameLabel, "[No data] "+r.Name())
-			lb.Set(labels.NoDataLabel, "true")
-		}
-
-		lbs := lb.Labels()
-		h := lbs.Hash()
-		resultFPs[h] = struct{}{}
-
-		if _, ok := alerts[h]; ok {
-			r.logger.ErrorContext(ctx, "the alert query returns duplicate records", "rule_id", r.ID(), "alert", alerts[h])
-			err = fmt.Errorf("duplicate alert found, vector contains metrics with the same labelset after applying alert labels")
-			return 0, err
-		}
-
-		alerts[h] = &ruletypes.Alert{
-			Labels:            lbs,
-			QueryResultLables: resultLabels,
-			Annotations:       annotations,
-			ActiveAt:          ts,
-			State:             model.StatePending,
-			Value:             smpl.V,
-			GeneratorURL:      r.GeneratorURL(),
-			Receivers:         ruleReceiverMap[lbs.Map()[ruletypes.LabelThresholdName]],
-			Missing:           smpl.IsMissing,
-			IsRecovering:      smpl.IsRecovering,
-		}
-	}
-
-	r.logger.InfoContext(ctx, "number of alerts found", "rule_name", r.Name(), "alerts_count", len(alerts))
-	// alerts[h] is ready, add or update active list now
-	for h, a := range alerts {
-		// Check whether we already have alerting state for the identifying label set.
-		// Update the last value and annotations if so, create a new alert entry otherwise.
-		if alert, ok := r.Active[h]; ok && alert.State != model.StateInactive {
-
-			alert.Value = a.Value
-			alert.Annotations = a.Annotations
-			// Update the recovering and missing state of existing alert
-			alert.IsRecovering = a.IsRecovering
-			alert.Missing = a.Missing
-			if v, ok := alert.Labels.Map()[ruletypes.LabelThresholdName]; ok {
-				alert.Receivers = ruleReceiverMap[v]
-			}
-			continue
-		}
-
-		r.Active[h] = a
-	}
-
-	itemsToAdd := []model.RuleStateHistory{}
-
-	// Check if any pending alerts should be removed or fire now. Write out alert timeseries.
-	for fp, a := range r.Active {
-		labelsJSON, err := json.Marshal(a.QueryResultLables)
-		if err != nil {
-			r.logger.ErrorContext(ctx, "error marshaling labels", errors.Attr(err), "labels", a.Labels)
-		}
-		if _, ok := resultFPs[fp]; !ok {
-			// If the alert was previously firing, keep it around for a given
-			// retention time so it is reported as resolved to the AlertManager.
-			if a.State == model.StatePending || (!a.ResolvedAt.IsZero() && ts.Sub(a.ResolvedAt) > ruletypes.ResolvedRetention) {
-				delete(r.Active, fp)
-			}
-			if a.State != model.StateInactive {
-				a.State = model.StateInactive
-				a.ResolvedAt = ts
-				itemsToAdd = append(itemsToAdd, model.RuleStateHistory{
-					RuleID:       r.ID(),
-					RuleName:     r.Name(),
-					State:        model.StateInactive,
-					StateChanged: true,
-					UnixMilli:    ts.UnixMilli(),
-					Labels:       model.LabelsString(labelsJSON),
-					Fingerprint:  a.QueryResultLables.Hash(),
-					Value:        a.Value,
-				})
-			}
-			continue
-		}
-
-		if a.State == model.StatePending && ts.Sub(a.ActiveAt) >= r.HoldDuration().Duration() {
-			a.State = model.StateFiring
-			a.FiredAt = ts
-			state := model.StateFiring
-			if a.Missing {
-				state = model.StateNoData
-			}
-			itemsToAdd = append(itemsToAdd, model.RuleStateHistory{
-				RuleID:       r.ID(),
-				RuleName:     r.Name(),
-				State:        state,
-				StateChanged: true,
-				UnixMilli:    ts.UnixMilli(),
-				Labels:       model.LabelsString(labelsJSON),
-				Fingerprint:  a.QueryResultLables.Hash(),
-				Value:        a.Value,
-			})
-		}
-
-		// We need to change firing alert to recovering if the returned sample meets recovery threshold
-		changeFiringToRecovering := a.State == model.StateFiring && a.IsRecovering
-		// We need to change recovering alerts to firing if the returned sample meets target threshold
-		changeRecoveringToFiring := a.State == model.StateRecovering && !a.IsRecovering && !a.Missing
-		// in any of the above case we need to update the status of alert
-		if changeFiringToRecovering || changeRecoveringToFiring {
-			state := model.StateRecovering
-			if changeRecoveringToFiring {
-				state = model.StateFiring
-			}
-			a.State = state
-			r.logger.DebugContext(ctx, "converting alert state", "name", r.Name(), "state", state)
-			itemsToAdd = append(itemsToAdd, model.RuleStateHistory{
-				RuleID:       r.ID(),
-				RuleName:     r.Name(),
-				State:        state,
-				StateChanged: true,
-				UnixMilli:    ts.UnixMilli(),
-				Labels:       model.LabelsString(labelsJSON),
-				Fingerprint:  a.QueryResultLables.Hash(),
-				Value:        a.Value,
-			})
-		}
-	}
-
-	currentState := r.State()
-
-	overallStateChanged := currentState != prevState
-	for idx, item := range itemsToAdd {
-		item.OverallStateChanged = overallStateChanged
-		item.OverallState = currentState
-		itemsToAdd[idx] = item
-	}
-
-	r.RecordRuleStateHistory(ctx, prevState, currentState, itemsToAdd)
-
-	return len(r.Active), nil
-}
-
-func (r *AnomalyRule) String() string {
-
-	ar := ruletypes.PostableRule{
-		AlertName:         r.Name(),
-		RuleCondition:     r.Condition(),
-		EvalWindow:        r.EvalWindow(),
-		Labels:            r.Labels().Map(),
-		Annotations:       r.Annotations().Map(),
-		PreferredChannels: r.PreferredChannels(),
-	}
-
-	byt, err := json.Marshal(ar)
-	if err != nil {
-		return fmt.Sprintf("error marshaling alerting rule: %s", err.Error())
-	}
-
-	return string(byt)
+	return r.EvalVector(ctx, ts, res, opts)
 }

ee/query-service/rules/manager.go

@@ -28,7 +28,6 @@ func PrepareTaskFunc(opts baserules.PrepareTaskOptions) (baserules.Task, error)
 	if err != nil {
 		return nil, errors.NewInvalidInputf(errors.CodeInvalidInput, "evaluation is invalid: %v", err)
 	}
-
 	if opts.Rule.RuleType == ruletypes.RuleTypeThreshold {
 		// create a threshold rule
 		tr, err := baserules.NewThresholdRule(
@@ -42,7 +41,6 @@ func PrepareTaskFunc(opts baserules.PrepareTaskOptions) (baserules.Task, error)
 			baserules.WithSQLStore(opts.SQLStore),
 			baserules.WithQueryParser(opts.ManagerOpts.QueryParser),
 			baserules.WithMetadataStore(opts.ManagerOpts.MetadataStore),
-			baserules.WithRuleStateHistoryModule(opts.ManagerOpts.RuleStateHistoryModule),
 		)
 
 		if err != nil {
@@ -67,7 +65,6 @@ func PrepareTaskFunc(opts baserules.PrepareTaskOptions) (baserules.Task, error)
 			baserules.WithSQLStore(opts.SQLStore),
 			baserules.WithQueryParser(opts.ManagerOpts.QueryParser),
 			baserules.WithMetadataStore(opts.ManagerOpts.MetadataStore),
-			baserules.WithRuleStateHistoryModule(opts.ManagerOpts.RuleStateHistoryModule),
 		)
 
 		if err != nil {
@@ -93,7 +90,6 @@ func PrepareTaskFunc(opts baserules.PrepareTaskOptions) (baserules.Task, error)
 			baserules.WithSQLStore(opts.SQLStore),
 			baserules.WithQueryParser(opts.ManagerOpts.QueryParser),
 			baserules.WithMetadataStore(opts.ManagerOpts.MetadataStore),
-			baserules.WithRuleStateHistoryModule(opts.ManagerOpts.RuleStateHistoryModule),
 		)
 		if err != nil {
 			return task, err

ee/sqlstore/postgressqlstore/provider.go

@@ -14,21 +14,14 @@ import (
 	"github.com/uptrace/bun/dialect/pgdialect"
 )
 
-var _ Pooler = new(provider)
-
 type provider struct {
 	settings  factory.ScopedProviderSettings
 	sqldb     *sql.DB
 	bundb     *sqlstore.BunDB
-	pgxPool   *pgxpool.Pool
 	dialect   *dialect
 	formatter sqlstore.SQLFormatter
 }
 
-type Pooler interface {
-	Pool() *pgxpool.Pool
-}
-
 func NewFactory(hookFactories ...factory.ProviderFactory[sqlstore.SQLStoreHook, sqlstore.Config]) factory.ProviderFactory[sqlstore.SQLStore, sqlstore.Config] {
 	return factory.NewProviderFactory(factory.MustNewName("postgres"), func(ctx context.Context, providerSettings factory.ProviderSettings, config sqlstore.Config) (sqlstore.SQLStore, error) {
 		hooks := make([]sqlstore.SQLStoreHook, len(hookFactories))
@@ -69,7 +62,6 @@ func New(ctx context.Context, providerSettings factory.ProviderSettings, config
 		settings:  settings,
 		sqldb:     sqldb,
 		bundb:     bunDB,
-		pgxPool:   pool,
 		dialect:   new(dialect),
 		formatter: newFormatter(bunDB.Dialect()),
 	}, nil
@@ -83,10 +75,6 @@ func (provider *provider) SQLDB() *sql.DB {
 	return provider.sqldb
 }
 
-func (provider *provider) Pool() *pgxpool.Pool {
-	return provider.pgxPool
-}
-
 func (provider *provider) Dialect() sqlstore.SQLDialect {
 	return provider.dialect
 }

frontend/.eslintrc.cjs

@@ -205,25 +205,6 @@ module.exports = {
 		],
 	},
 	overrides: [
-		{
-			files: ['src/**/*.{jsx,tsx,ts}'],
-			excludedFiles: [
-				'**/*.test.{js,jsx,ts,tsx}',
-				'**/*.spec.{js,jsx,ts,tsx}',
-				'**/__tests__/**/*.{js,jsx,ts,tsx}',
-			],
-			rules: {
-				'no-restricted-properties': [
-					'error',
-					{
-						object: 'navigator',
-						property: 'clipboard',
-						message:
-							'Do not use navigator.clipboard directly since it does not work well with specific browsers. Use hook useCopyToClipboard from react-use library. https://streamich.github.io/react-use/?path=/story/side-effects-usecopytoclipboard--docs',
-					},
-				],
-			},
-		},
 		{
 			files: [
 				'**/*.test.{js,jsx,ts,tsx}',

frontend/__mocks__/useSafeNavigate.ts

@@ -2,7 +2,6 @@
 interface SafeNavigateOptions {
 	replace?: boolean;
 	state?: unknown;
-	newTab?: boolean;
 }
 
 interface SafeNavigateTo {
@@ -21,7 +20,9 @@ interface UseSafeNavigateReturn {
 
 export const useSafeNavigate = (): UseSafeNavigateReturn => ({
 	safeNavigate: jest.fn(
-		(_to: SafeNavigateToType, _options?: SafeNavigateOptions) => {},
+		(to: SafeNavigateToType, options?: SafeNavigateOptions) => {
+			console.log(`Mock safeNavigate called with:`, to, options);
+		},
 	) as jest.MockedFunction<
 		(to: SafeNavigateToType, options?: SafeNavigateOptions) => void
 	>,

frontend/package.json

@@ -164,7 +164,6 @@
     "vite-plugin-html": "3.2.2",
     "web-vitals": "^0.2.4",
     "xstate": "^4.31.0",
-    "zod": "4.3.6",
     "zustand": "5.0.11"
   },
   "browserslist": {
@@ -287,4 +286,4 @@
     "tmp": "0.2.4",
     "vite": "npm:rolldown-vite@7.3.1"
   }
-}
+}

frontend/src/api/dashboard/public/createPublicDashboard.ts

@@ -1,7 +1,6 @@
 import axios from 'api';
 import { ErrorResponseHandlerV2 } from 'api/ErrorResponseHandlerV2';
 import { AxiosError } from 'axios';
-import { DEFAULT_TIME_RANGE } from 'container/TopNav/DateTimeSelectionV2/constants';
 import { ErrorV2Resp, 	 SuccessResponseV2 } from 'types/api';
 import { CreatePublicDashboardProps } from 'types/api/dashboard/public/create';
 
@@ -9,7 +8,7 @@ const createPublicDashboard = async (
 	props: CreatePublicDashboardProps,
 ): Promise<SuccessResponseV2<CreatePublicDashboardProps>> => {
 
-    const { dashboardId, timeRangeEnabled = false, defaultTimeRange = DEFAULT_TIME_RANGE } = props;
+    const { dashboardId, timeRangeEnabled = false, defaultTimeRange = '30m' } = props;
 
 	try {
 		const response = await axios.post(

frontend/src/api/dashboard/public/updatePublicDashboard.ts

@@ -1,7 +1,6 @@
 import axios from 'api';
 import { ErrorResponseHandlerV2 } from 'api/ErrorResponseHandlerV2';
 import { AxiosError } from 'axios';
-import { DEFAULT_TIME_RANGE } from 'container/TopNav/DateTimeSelectionV2/constants';
 import {  ErrorV2Resp, SuccessResponseV2 } from 'types/api';
 import { UpdatePublicDashboardProps } from 'types/api/dashboard/public/update';
 
@@ -9,7 +8,7 @@ const updatePublicDashboard = async (
 	props: UpdatePublicDashboardProps,
 ): Promise<SuccessResponseV2<UpdatePublicDashboardProps>> => {
 
-    const { dashboardId, timeRangeEnabled = false, defaultTimeRange = DEFAULT_TIME_RANGE } = props;
+    const { dashboardId, timeRangeEnabled = false, defaultTimeRange = '30m' } = props;
 
 	try {
 		const response = await axios.put(

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

@@ -31,13 +31,10 @@ import type {
 	GetMetricHighlightsPathParameters,
 	GetMetricMetadata200,
 	GetMetricMetadataPathParameters,
-	GetMetricsOnboardingStatus200,
 	GetMetricsStats200,
 	GetMetricsTreemap200,
-	InspectMetrics200,
 	ListMetrics200,
 	ListMetricsParams,
-	MetricsexplorertypesInspectMetricsRequestDTO,
 	MetricsexplorertypesStatsRequestDTO,
 	MetricsexplorertypesTreemapRequestDTO,
 	MetricsexplorertypesUpdateMetricMetadataRequestDTO,
@@ -781,176 +778,6 @@ export const useUpdateMetricMetadata = <
 
 	return useMutation(mutationOptions);
 };
-/**
- * Returns raw time series data points for a metric within a time range (max 30 minutes). Each series includes labels and timestamp/value pairs.
- * @summary Inspect raw metric data points
- */
-export const inspectMetrics = (
-	metricsexplorertypesInspectMetricsRequestDTO: BodyType<MetricsexplorertypesInspectMetricsRequestDTO>,
-	signal?: AbortSignal,
-) => {
-	return GeneratedAPIInstance<InspectMetrics200>({
-		url: `/api/v2/metrics/inspect`,
-		method: 'POST',
-		headers: { 'Content-Type': 'application/json' },
-		data: metricsexplorertypesInspectMetricsRequestDTO,
-		signal,
-	});
-};
-
-export const getInspectMetricsMutationOptions = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof inspectMetrics>>,
-		TError,
-		{ data: BodyType<MetricsexplorertypesInspectMetricsRequestDTO> },
-		TContext
-	>;
-}): UseMutationOptions<
-	Awaited<ReturnType<typeof inspectMetrics>>,
-	TError,
-	{ data: BodyType<MetricsexplorertypesInspectMetricsRequestDTO> },
-	TContext
-> => {
-	const mutationKey = ['inspectMetrics'];
-	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 inspectMetrics>>,
-		{ data: BodyType<MetricsexplorertypesInspectMetricsRequestDTO> }
-	> = (props) => {
-		const { data } = props ?? {};
-
-		return inspectMetrics(data);
-	};
-
-	return { mutationFn, ...mutationOptions };
-};
-
-export type InspectMetricsMutationResult = NonNullable<
-	Awaited<ReturnType<typeof inspectMetrics>>
->;
-export type InspectMetricsMutationBody = BodyType<MetricsexplorertypesInspectMetricsRequestDTO>;
-export type InspectMetricsMutationError = ErrorType<RenderErrorResponseDTO>;
-
-/**
- * @summary Inspect raw metric data points
- */
-export const useInspectMetrics = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof inspectMetrics>>,
-		TError,
-		{ data: BodyType<MetricsexplorertypesInspectMetricsRequestDTO> },
-		TContext
-	>;
-}): UseMutationResult<
-	Awaited<ReturnType<typeof inspectMetrics>>,
-	TError,
-	{ data: BodyType<MetricsexplorertypesInspectMetricsRequestDTO> },
-	TContext
-> => {
-	const mutationOptions = getInspectMetricsMutationOptions(options);
-
-	return useMutation(mutationOptions);
-};
-/**
- * Lightweight endpoint that checks if any non-SigNoz metrics have been ingested, used for onboarding status detection
- * @summary Check if non-SigNoz metrics have been received
- */
-export const getMetricsOnboardingStatus = (signal?: AbortSignal) => {
-	return GeneratedAPIInstance<GetMetricsOnboardingStatus200>({
-		url: `/api/v2/metrics/onboarding`,
-		method: 'GET',
-		signal,
-	});
-};
-
-export const getGetMetricsOnboardingStatusQueryKey = () => {
-	return [`/api/v2/metrics/onboarding`] as const;
-};
-
-export const getGetMetricsOnboardingStatusQueryOptions = <
-	TData = Awaited<ReturnType<typeof getMetricsOnboardingStatus>>,
-	TError = ErrorType<RenderErrorResponseDTO>
->(options?: {
-	query?: UseQueryOptions<
-		Awaited<ReturnType<typeof getMetricsOnboardingStatus>>,
-		TError,
-		TData
-	>;
-}) => {
-	const { query: queryOptions } = options ?? {};
-
-	const queryKey =
-		queryOptions?.queryKey ?? getGetMetricsOnboardingStatusQueryKey();
-
-	const queryFn: QueryFunction<
-		Awaited<ReturnType<typeof getMetricsOnboardingStatus>>
-	> = ({ signal }) => getMetricsOnboardingStatus(signal);
-
-	return { queryKey, queryFn, ...queryOptions } as UseQueryOptions<
-		Awaited<ReturnType<typeof getMetricsOnboardingStatus>>,
-		TError,
-		TData
-	> & { queryKey: QueryKey };
-};
-
-export type GetMetricsOnboardingStatusQueryResult = NonNullable<
-	Awaited<ReturnType<typeof getMetricsOnboardingStatus>>
->;
-export type GetMetricsOnboardingStatusQueryError = ErrorType<RenderErrorResponseDTO>;
-
-/**
- * @summary Check if non-SigNoz metrics have been received
- */
-
-export function useGetMetricsOnboardingStatus<
-	TData = Awaited<ReturnType<typeof getMetricsOnboardingStatus>>,
-	TError = ErrorType<RenderErrorResponseDTO>
->(options?: {
-	query?: UseQueryOptions<
-		Awaited<ReturnType<typeof getMetricsOnboardingStatus>>,
-		TError,
-		TData
-	>;
-}): UseQueryResult<TData, TError> & { queryKey: QueryKey } {
-	const queryOptions = getGetMetricsOnboardingStatusQueryOptions(options);
-
-	const query = useQuery(queryOptions) as UseQueryResult<TData, TError> & {
-		queryKey: QueryKey;
-	};
-
-	query.queryKey = queryOptions.queryKey;
-
-	return query;
-}
-
-/**
- * @summary Check if non-SigNoz metrics have been received
- */
-export const invalidateGetMetricsOnboardingStatus = async (
-	queryClient: QueryClient,
-	options?: InvalidateOptions,
-): Promise<QueryClient> => {
-	await queryClient.invalidateQueries(
-		{ queryKey: getGetMetricsOnboardingStatusQueryKey() },
-		options,
-	);
-
-	return queryClient;
-};
-
 /**
  * This endpoint provides list of metrics with their number of samples and timeseries for the given time range
  * @summary Get metrics statistics

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

@@ -1,744 +0,0 @@
-/**
- * ! Do not edit manually
- * * The file has been auto-generated using Orval for SigNoz
- * * regenerate with 'yarn generate:api'
- * SigNoz
- */
-import type {
-	InvalidateOptions,
-	QueryClient,
-	QueryFunction,
-	QueryKey,
-	UseQueryOptions,
-	UseQueryResult,
-} from 'react-query';
-import { useQuery } from 'react-query';
-
-import type { ErrorType } from '../../../generatedAPIInstance';
-import { GeneratedAPIInstance } from '../../../generatedAPIInstance';
-import type {
-	GetRuleHistoryFilterKeys200,
-	GetRuleHistoryFilterKeysParams,
-	GetRuleHistoryFilterKeysPathParameters,
-	GetRuleHistoryFilterValues200,
-	GetRuleHistoryFilterValuesParams,
-	GetRuleHistoryFilterValuesPathParameters,
-	GetRuleHistoryOverallStatus200,
-	GetRuleHistoryOverallStatusParams,
-	GetRuleHistoryOverallStatusPathParameters,
-	GetRuleHistoryStats200,
-	GetRuleHistoryStatsParams,
-	GetRuleHistoryStatsPathParameters,
-	GetRuleHistoryTimeline200,
-	GetRuleHistoryTimelineParams,
-	GetRuleHistoryTimelinePathParameters,
-	GetRuleHistoryTopContributors200,
-	GetRuleHistoryTopContributorsParams,
-	GetRuleHistoryTopContributorsPathParameters,
-	RenderErrorResponseDTO,
-} from '../sigNoz.schemas';
-
-/**
- * Returns distinct label keys from rule history entries for the selected range.
- * @summary Get rule history filter keys
- */
-export const getRuleHistoryFilterKeys = (
-	{ id }: GetRuleHistoryFilterKeysPathParameters,
-	params?: GetRuleHistoryFilterKeysParams,
-	signal?: AbortSignal,
-) => {
-	return GeneratedAPIInstance<GetRuleHistoryFilterKeys200>({
-		url: `/api/v2/rules/${id}/history/filter_keys`,
-		method: 'GET',
-		params,
-		signal,
-	});
-};
-
-export const getGetRuleHistoryFilterKeysQueryKey = (
-	{ id }: GetRuleHistoryFilterKeysPathParameters,
-	params?: GetRuleHistoryFilterKeysParams,
-) => {
-	return [
-		`/api/v2/rules/${id}/history/filter_keys`,
-		...(params ? [params] : []),
-	] as const;
-};
-
-export const getGetRuleHistoryFilterKeysQueryOptions = <
-	TData = Awaited<ReturnType<typeof getRuleHistoryFilterKeys>>,
-	TError = ErrorType<RenderErrorResponseDTO>
->(
-	{ id }: GetRuleHistoryFilterKeysPathParameters,
-	params?: GetRuleHistoryFilterKeysParams,
-	options?: {
-		query?: UseQueryOptions<
-			Awaited<ReturnType<typeof getRuleHistoryFilterKeys>>,
-			TError,
-			TData
-		>;
-	},
-) => {
-	const { query: queryOptions } = options ?? {};
-
-	const queryKey =
-		queryOptions?.queryKey ?? getGetRuleHistoryFilterKeysQueryKey({ id }, params);
-
-	const queryFn: QueryFunction<
-		Awaited<ReturnType<typeof getRuleHistoryFilterKeys>>
-	> = ({ signal }) => getRuleHistoryFilterKeys({ id }, params, signal);
-
-	return {
-		queryKey,
-		queryFn,
-		enabled: !!id,
-		...queryOptions,
-	} as UseQueryOptions<
-		Awaited<ReturnType<typeof getRuleHistoryFilterKeys>>,
-		TError,
-		TData
-	> & { queryKey: QueryKey };
-};
-
-export type GetRuleHistoryFilterKeysQueryResult = NonNullable<
-	Awaited<ReturnType<typeof getRuleHistoryFilterKeys>>
->;
-export type GetRuleHistoryFilterKeysQueryError = ErrorType<RenderErrorResponseDTO>;
-
-/**
- * @summary Get rule history filter keys
- */
-
-export function useGetRuleHistoryFilterKeys<
-	TData = Awaited<ReturnType<typeof getRuleHistoryFilterKeys>>,
-	TError = ErrorType<RenderErrorResponseDTO>
->(
-	{ id }: GetRuleHistoryFilterKeysPathParameters,
-	params?: GetRuleHistoryFilterKeysParams,
-	options?: {
-		query?: UseQueryOptions<
-			Awaited<ReturnType<typeof getRuleHistoryFilterKeys>>,
-			TError,
-			TData
-		>;
-	},
-): UseQueryResult<TData, TError> & { queryKey: QueryKey } {
-	const queryOptions = getGetRuleHistoryFilterKeysQueryOptions(
-		{ id },
-		params,
-		options,
-	);
-
-	const query = useQuery(queryOptions) as UseQueryResult<TData, TError> & {
-		queryKey: QueryKey;
-	};
-
-	query.queryKey = queryOptions.queryKey;
-
-	return query;
-}
-
-/**
- * @summary Get rule history filter keys
- */
-export const invalidateGetRuleHistoryFilterKeys = async (
-	queryClient: QueryClient,
-	{ id }: GetRuleHistoryFilterKeysPathParameters,
-	params?: GetRuleHistoryFilterKeysParams,
-	options?: InvalidateOptions,
-): Promise<QueryClient> => {
-	await queryClient.invalidateQueries(
-		{ queryKey: getGetRuleHistoryFilterKeysQueryKey({ id }, params) },
-		options,
-	);
-
-	return queryClient;
-};
-
-/**
- * Returns distinct label values for a given key from rule history entries.
- * @summary Get rule history filter values
- */
-export const getRuleHistoryFilterValues = (
-	{ id }: GetRuleHistoryFilterValuesPathParameters,
-	params?: GetRuleHistoryFilterValuesParams,
-	signal?: AbortSignal,
-) => {
-	return GeneratedAPIInstance<GetRuleHistoryFilterValues200>({
-		url: `/api/v2/rules/${id}/history/filter_values`,
-		method: 'GET',
-		params,
-		signal,
-	});
-};
-
-export const getGetRuleHistoryFilterValuesQueryKey = (
-	{ id }: GetRuleHistoryFilterValuesPathParameters,
-	params?: GetRuleHistoryFilterValuesParams,
-) => {
-	return [
-		`/api/v2/rules/${id}/history/filter_values`,
-		...(params ? [params] : []),
-	] as const;
-};
-
-export const getGetRuleHistoryFilterValuesQueryOptions = <
-	TData = Awaited<ReturnType<typeof getRuleHistoryFilterValues>>,
-	TError = ErrorType<RenderErrorResponseDTO>
->(
-	{ id }: GetRuleHistoryFilterValuesPathParameters,
-	params?: GetRuleHistoryFilterValuesParams,
-	options?: {
-		query?: UseQueryOptions<
-			Awaited<ReturnType<typeof getRuleHistoryFilterValues>>,
-			TError,
-			TData
-		>;
-	},
-) => {
-	const { query: queryOptions } = options ?? {};
-
-	const queryKey =
-		queryOptions?.queryKey ??
-		getGetRuleHistoryFilterValuesQueryKey({ id }, params);
-
-	const queryFn: QueryFunction<
-		Awaited<ReturnType<typeof getRuleHistoryFilterValues>>
-	> = ({ signal }) => getRuleHistoryFilterValues({ id }, params, signal);
-
-	return {
-		queryKey,
-		queryFn,
-		enabled: !!id,
-		...queryOptions,
-	} as UseQueryOptions<
-		Awaited<ReturnType<typeof getRuleHistoryFilterValues>>,
-		TError,
-		TData
-	> & { queryKey: QueryKey };
-};
-
-export type GetRuleHistoryFilterValuesQueryResult = NonNullable<
-	Awaited<ReturnType<typeof getRuleHistoryFilterValues>>
->;
-export type GetRuleHistoryFilterValuesQueryError = ErrorType<RenderErrorResponseDTO>;
-
-/**
- * @summary Get rule history filter values
- */
-
-export function useGetRuleHistoryFilterValues<
-	TData = Awaited<ReturnType<typeof getRuleHistoryFilterValues>>,
-	TError = ErrorType<RenderErrorResponseDTO>
->(
-	{ id }: GetRuleHistoryFilterValuesPathParameters,
-	params?: GetRuleHistoryFilterValuesParams,
-	options?: {
-		query?: UseQueryOptions<
-			Awaited<ReturnType<typeof getRuleHistoryFilterValues>>,
-			TError,
-			TData
-		>;
-	},
-): UseQueryResult<TData, TError> & { queryKey: QueryKey } {
-	const queryOptions = getGetRuleHistoryFilterValuesQueryOptions(
-		{ id },
-		params,
-		options,
-	);
-
-	const query = useQuery(queryOptions) as UseQueryResult<TData, TError> & {
-		queryKey: QueryKey;
-	};
-
-	query.queryKey = queryOptions.queryKey;
-
-	return query;
-}
-
-/**
- * @summary Get rule history filter values
- */
-export const invalidateGetRuleHistoryFilterValues = async (
-	queryClient: QueryClient,
-	{ id }: GetRuleHistoryFilterValuesPathParameters,
-	params?: GetRuleHistoryFilterValuesParams,
-	options?: InvalidateOptions,
-): Promise<QueryClient> => {
-	await queryClient.invalidateQueries(
-		{ queryKey: getGetRuleHistoryFilterValuesQueryKey({ id }, params) },
-		options,
-	);
-
-	return queryClient;
-};
-
-/**
- * Returns overall firing/inactive intervals for a rule in the selected time range.
- * @summary Get rule overall status timeline
- */
-export const getRuleHistoryOverallStatus = (
-	{ id }: GetRuleHistoryOverallStatusPathParameters,
-	params: GetRuleHistoryOverallStatusParams,
-	signal?: AbortSignal,
-) => {
-	return GeneratedAPIInstance<GetRuleHistoryOverallStatus200>({
-		url: `/api/v2/rules/${id}/history/overall_status`,
-		method: 'GET',
-		params,
-		signal,
-	});
-};
-
-export const getGetRuleHistoryOverallStatusQueryKey = (
-	{ id }: GetRuleHistoryOverallStatusPathParameters,
-	params?: GetRuleHistoryOverallStatusParams,
-) => {
-	return [
-		`/api/v2/rules/${id}/history/overall_status`,
-		...(params ? [params] : []),
-	] as const;
-};
-
-export const getGetRuleHistoryOverallStatusQueryOptions = <
-	TData = Awaited<ReturnType<typeof getRuleHistoryOverallStatus>>,
-	TError = ErrorType<RenderErrorResponseDTO>
->(
-	{ id }: GetRuleHistoryOverallStatusPathParameters,
-	params: GetRuleHistoryOverallStatusParams,
-	options?: {
-		query?: UseQueryOptions<
-			Awaited<ReturnType<typeof getRuleHistoryOverallStatus>>,
-			TError,
-			TData
-		>;
-	},
-) => {
-	const { query: queryOptions } = options ?? {};
-
-	const queryKey =
-		queryOptions?.queryKey ??
-		getGetRuleHistoryOverallStatusQueryKey({ id }, params);
-
-	const queryFn: QueryFunction<
-		Awaited<ReturnType<typeof getRuleHistoryOverallStatus>>
-	> = ({ signal }) => getRuleHistoryOverallStatus({ id }, params, signal);
-
-	return {
-		queryKey,
-		queryFn,
-		enabled: !!id,
-		...queryOptions,
-	} as UseQueryOptions<
-		Awaited<ReturnType<typeof getRuleHistoryOverallStatus>>,
-		TError,
-		TData
-	> & { queryKey: QueryKey };
-};
-
-export type GetRuleHistoryOverallStatusQueryResult = NonNullable<
-	Awaited<ReturnType<typeof getRuleHistoryOverallStatus>>
->;
-export type GetRuleHistoryOverallStatusQueryError = ErrorType<RenderErrorResponseDTO>;
-
-/**
- * @summary Get rule overall status timeline
- */
-
-export function useGetRuleHistoryOverallStatus<
-	TData = Awaited<ReturnType<typeof getRuleHistoryOverallStatus>>,
-	TError = ErrorType<RenderErrorResponseDTO>
->(
-	{ id }: GetRuleHistoryOverallStatusPathParameters,
-	params: GetRuleHistoryOverallStatusParams,
-	options?: {
-		query?: UseQueryOptions<
-			Awaited<ReturnType<typeof getRuleHistoryOverallStatus>>,
-			TError,
-			TData
-		>;
-	},
-): UseQueryResult<TData, TError> & { queryKey: QueryKey } {
-	const queryOptions = getGetRuleHistoryOverallStatusQueryOptions(
-		{ id },
-		params,
-		options,
-	);
-
-	const query = useQuery(queryOptions) as UseQueryResult<TData, TError> & {
-		queryKey: QueryKey;
-	};
-
-	query.queryKey = queryOptions.queryKey;
-
-	return query;
-}
-
-/**
- * @summary Get rule overall status timeline
- */
-export const invalidateGetRuleHistoryOverallStatus = async (
-	queryClient: QueryClient,
-	{ id }: GetRuleHistoryOverallStatusPathParameters,
-	params: GetRuleHistoryOverallStatusParams,
-	options?: InvalidateOptions,
-): Promise<QueryClient> => {
-	await queryClient.invalidateQueries(
-		{ queryKey: getGetRuleHistoryOverallStatusQueryKey({ id }, params) },
-		options,
-	);
-
-	return queryClient;
-};
-
-/**
- * Returns trigger and resolution statistics for a rule in the selected time range.
- * @summary Get rule history stats
- */
-export const getRuleHistoryStats = (
-	{ id }: GetRuleHistoryStatsPathParameters,
-	params: GetRuleHistoryStatsParams,
-	signal?: AbortSignal,
-) => {
-	return GeneratedAPIInstance<GetRuleHistoryStats200>({
-		url: `/api/v2/rules/${id}/history/stats`,
-		method: 'GET',
-		params,
-		signal,
-	});
-};
-
-export const getGetRuleHistoryStatsQueryKey = (
-	{ id }: GetRuleHistoryStatsPathParameters,
-	params?: GetRuleHistoryStatsParams,
-) => {
-	return [
-		`/api/v2/rules/${id}/history/stats`,
-		...(params ? [params] : []),
-	] as const;
-};
-
-export const getGetRuleHistoryStatsQueryOptions = <
-	TData = Awaited<ReturnType<typeof getRuleHistoryStats>>,
-	TError = ErrorType<RenderErrorResponseDTO>
->(
-	{ id }: GetRuleHistoryStatsPathParameters,
-	params: GetRuleHistoryStatsParams,
-	options?: {
-		query?: UseQueryOptions<
-			Awaited<ReturnType<typeof getRuleHistoryStats>>,
-			TError,
-			TData
-		>;
-	},
-) => {
-	const { query: queryOptions } = options ?? {};
-
-	const queryKey =
-		queryOptions?.queryKey ?? getGetRuleHistoryStatsQueryKey({ id }, params);
-
-	const queryFn: QueryFunction<
-		Awaited<ReturnType<typeof getRuleHistoryStats>>
-	> = ({ signal }) => getRuleHistoryStats({ id }, params, signal);
-
-	return {
-		queryKey,
-		queryFn,
-		enabled: !!id,
-		...queryOptions,
-	} as UseQueryOptions<
-		Awaited<ReturnType<typeof getRuleHistoryStats>>,
-		TError,
-		TData
-	> & { queryKey: QueryKey };
-};
-
-export type GetRuleHistoryStatsQueryResult = NonNullable<
-	Awaited<ReturnType<typeof getRuleHistoryStats>>
->;
-export type GetRuleHistoryStatsQueryError = ErrorType<RenderErrorResponseDTO>;
-
-/**
- * @summary Get rule history stats
- */
-
-export function useGetRuleHistoryStats<
-	TData = Awaited<ReturnType<typeof getRuleHistoryStats>>,
-	TError = ErrorType<RenderErrorResponseDTO>
->(
-	{ id }: GetRuleHistoryStatsPathParameters,
-	params: GetRuleHistoryStatsParams,
-	options?: {
-		query?: UseQueryOptions<
-			Awaited<ReturnType<typeof getRuleHistoryStats>>,
-			TError,
-			TData
-		>;
-	},
-): UseQueryResult<TData, TError> & { queryKey: QueryKey } {
-	const queryOptions = getGetRuleHistoryStatsQueryOptions(
-		{ id },
-		params,
-		options,
-	);
-
-	const query = useQuery(queryOptions) as UseQueryResult<TData, TError> & {
-		queryKey: QueryKey;
-	};
-
-	query.queryKey = queryOptions.queryKey;
-
-	return query;
-}
-
-/**
- * @summary Get rule history stats
- */
-export const invalidateGetRuleHistoryStats = async (
-	queryClient: QueryClient,
-	{ id }: GetRuleHistoryStatsPathParameters,
-	params: GetRuleHistoryStatsParams,
-	options?: InvalidateOptions,
-): Promise<QueryClient> => {
-	await queryClient.invalidateQueries(
-		{ queryKey: getGetRuleHistoryStatsQueryKey({ id }, params) },
-		options,
-	);
-
-	return queryClient;
-};
-
-/**
- * Returns paginated timeline entries for rule state transitions.
- * @summary Get rule history timeline
- */
-export const getRuleHistoryTimeline = (
-	{ id }: GetRuleHistoryTimelinePathParameters,
-	params: GetRuleHistoryTimelineParams,
-	signal?: AbortSignal,
-) => {
-	return GeneratedAPIInstance<GetRuleHistoryTimeline200>({
-		url: `/api/v2/rules/${id}/history/timeline`,
-		method: 'GET',
-		params,
-		signal,
-	});
-};
-
-export const getGetRuleHistoryTimelineQueryKey = (
-	{ id }: GetRuleHistoryTimelinePathParameters,
-	params?: GetRuleHistoryTimelineParams,
-) => {
-	return [
-		`/api/v2/rules/${id}/history/timeline`,
-		...(params ? [params] : []),
-	] as const;
-};
-
-export const getGetRuleHistoryTimelineQueryOptions = <
-	TData = Awaited<ReturnType<typeof getRuleHistoryTimeline>>,
-	TError = ErrorType<RenderErrorResponseDTO>
->(
-	{ id }: GetRuleHistoryTimelinePathParameters,
-	params: GetRuleHistoryTimelineParams,
-	options?: {
-		query?: UseQueryOptions<
-			Awaited<ReturnType<typeof getRuleHistoryTimeline>>,
-			TError,
-			TData
-		>;
-	},
-) => {
-	const { query: queryOptions } = options ?? {};
-
-	const queryKey =
-		queryOptions?.queryKey ?? getGetRuleHistoryTimelineQueryKey({ id }, params);
-
-	const queryFn: QueryFunction<
-		Awaited<ReturnType<typeof getRuleHistoryTimeline>>
-	> = ({ signal }) => getRuleHistoryTimeline({ id }, params, signal);
-
-	return {
-		queryKey,
-		queryFn,
-		enabled: !!id,
-		...queryOptions,
-	} as UseQueryOptions<
-		Awaited<ReturnType<typeof getRuleHistoryTimeline>>,
-		TError,
-		TData
-	> & { queryKey: QueryKey };
-};
-
-export type GetRuleHistoryTimelineQueryResult = NonNullable<
-	Awaited<ReturnType<typeof getRuleHistoryTimeline>>
->;
-export type GetRuleHistoryTimelineQueryError = ErrorType<RenderErrorResponseDTO>;
-
-/**
- * @summary Get rule history timeline
- */
-
-export function useGetRuleHistoryTimeline<
-	TData = Awaited<ReturnType<typeof getRuleHistoryTimeline>>,
-	TError = ErrorType<RenderErrorResponseDTO>
->(
-	{ id }: GetRuleHistoryTimelinePathParameters,
-	params: GetRuleHistoryTimelineParams,
-	options?: {
-		query?: UseQueryOptions<
-			Awaited<ReturnType<typeof getRuleHistoryTimeline>>,
-			TError,
-			TData
-		>;
-	},
-): UseQueryResult<TData, TError> & { queryKey: QueryKey } {
-	const queryOptions = getGetRuleHistoryTimelineQueryOptions(
-		{ id },
-		params,
-		options,
-	);
-
-	const query = useQuery(queryOptions) as UseQueryResult<TData, TError> & {
-		queryKey: QueryKey;
-	};
-
-	query.queryKey = queryOptions.queryKey;
-
-	return query;
-}
-
-/**
- * @summary Get rule history timeline
- */
-export const invalidateGetRuleHistoryTimeline = async (
-	queryClient: QueryClient,
-	{ id }: GetRuleHistoryTimelinePathParameters,
-	params: GetRuleHistoryTimelineParams,
-	options?: InvalidateOptions,
-): Promise<QueryClient> => {
-	await queryClient.invalidateQueries(
-		{ queryKey: getGetRuleHistoryTimelineQueryKey({ id }, params) },
-		options,
-	);
-
-	return queryClient;
-};
-
-/**
- * Returns top label combinations contributing to rule firing in the selected time range.
- * @summary Get top contributors to rule firing
- */
-export const getRuleHistoryTopContributors = (
-	{ id }: GetRuleHistoryTopContributorsPathParameters,
-	params: GetRuleHistoryTopContributorsParams,
-	signal?: AbortSignal,
-) => {
-	return GeneratedAPIInstance<GetRuleHistoryTopContributors200>({
-		url: `/api/v2/rules/${id}/history/top_contributors`,
-		method: 'GET',
-		params,
-		signal,
-	});
-};
-
-export const getGetRuleHistoryTopContributorsQueryKey = (
-	{ id }: GetRuleHistoryTopContributorsPathParameters,
-	params?: GetRuleHistoryTopContributorsParams,
-) => {
-	return [
-		`/api/v2/rules/${id}/history/top_contributors`,
-		...(params ? [params] : []),
-	] as const;
-};
-
-export const getGetRuleHistoryTopContributorsQueryOptions = <
-	TData = Awaited<ReturnType<typeof getRuleHistoryTopContributors>>,
-	TError = ErrorType<RenderErrorResponseDTO>
->(
-	{ id }: GetRuleHistoryTopContributorsPathParameters,
-	params: GetRuleHistoryTopContributorsParams,
-	options?: {
-		query?: UseQueryOptions<
-			Awaited<ReturnType<typeof getRuleHistoryTopContributors>>,
-			TError,
-			TData
-		>;
-	},
-) => {
-	const { query: queryOptions } = options ?? {};
-
-	const queryKey =
-		queryOptions?.queryKey ??
-		getGetRuleHistoryTopContributorsQueryKey({ id }, params);
-
-	const queryFn: QueryFunction<
-		Awaited<ReturnType<typeof getRuleHistoryTopContributors>>
-	> = ({ signal }) => getRuleHistoryTopContributors({ id }, params, signal);
-
-	return {
-		queryKey,
-		queryFn,
-		enabled: !!id,
-		...queryOptions,
-	} as UseQueryOptions<
-		Awaited<ReturnType<typeof getRuleHistoryTopContributors>>,
-		TError,
-		TData
-	> & { queryKey: QueryKey };
-};
-
-export type GetRuleHistoryTopContributorsQueryResult = NonNullable<
-	Awaited<ReturnType<typeof getRuleHistoryTopContributors>>
->;
-export type GetRuleHistoryTopContributorsQueryError = ErrorType<RenderErrorResponseDTO>;
-
-/**
- * @summary Get top contributors to rule firing
- */
-
-export function useGetRuleHistoryTopContributors<
-	TData = Awaited<ReturnType<typeof getRuleHistoryTopContributors>>,
-	TError = ErrorType<RenderErrorResponseDTO>
->(
-	{ id }: GetRuleHistoryTopContributorsPathParameters,
-	params: GetRuleHistoryTopContributorsParams,
-	options?: {
-		query?: UseQueryOptions<
-			Awaited<ReturnType<typeof getRuleHistoryTopContributors>>,
-			TError,
-			TData
-		>;
-	},
-): UseQueryResult<TData, TError> & { queryKey: QueryKey } {
-	const queryOptions = getGetRuleHistoryTopContributorsQueryOptions(
-		{ id },
-		params,
-		options,
-	);
-
-	const query = useQuery(queryOptions) as UseQueryResult<TData, TError> & {
-		queryKey: QueryKey;
-	};
-
-	query.queryKey = queryOptions.queryKey;
-
-	return query;
-}
-
-/**
- * @summary Get top contributors to rule firing
- */
-export const invalidateGetRuleHistoryTopContributors = async (
-	queryClient: QueryClient,
-	{ id }: GetRuleHistoryTopContributorsPathParameters,
-	params: GetRuleHistoryTopContributorsParams,
-	options?: InvalidateOptions,
-): Promise<QueryClient> => {
-	await queryClient.invalidateQueries(
-		{ queryKey: getGetRuleHistoryTopContributorsQueryKey({ id }, params) },
-		options,
-	);
-
-	return queryClient;
-};

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

@@ -1363,32 +1363,6 @@ export interface GlobaltypesTokenizerConfigDTO {
 	enabled?: boolean;
 }
 
-export interface MetricsexplorertypesInspectMetricsRequestDTO {
-	/**
-	 * @type integer
-	 * @format int64
-	 */
-	end: number;
-	filter?: Querybuildertypesv5FilterDTO;
-	/**
-	 * @type string
-	 */
-	metricName: string;
-	/**
-	 * @type integer
-	 * @format int64
-	 */
-	start: number;
-}
-
-export interface MetricsexplorertypesInspectMetricsResponseDTO {
-	/**
-	 * @type array
-	 * @nullable true
-	 */
-	series: Querybuildertypesv5TimeSeriesDTO[] | null;
-}
-
 export interface MetricsexplorertypesListMetricDTO {
 	/**
 	 * @type string
@@ -1534,13 +1508,6 @@ export interface MetricsexplorertypesMetricMetadataDTO {
 	unit: string;
 }
 
-export interface MetricsexplorertypesMetricsOnboardingResponseDTO {
-	/**
-	 * @type boolean
-	 */
-	hasMetrics: boolean;
-}
-
 export interface MetricsexplorertypesStatDTO {
 	/**
 	 * @type string
@@ -2710,139 +2677,6 @@ export interface RenderErrorResponseDTO {
 	status: string;
 }
 
-export enum RulestatehistorytypesAlertStateDTO {
-	inactive = 'inactive',
-	pending = 'pending',
-	recovering = 'recovering',
-	firing = 'firing',
-	nodata = 'nodata',
-	disabled = 'disabled',
-}
-export interface RulestatehistorytypesGettableRuleStateHistoryDTO {
-	/**
-	 * @type integer
-	 * @minimum 0
-	 */
-	fingerprint: number;
-	/**
-	 * @type array
-	 * @nullable true
-	 */
-	labels: Querybuildertypesv5LabelDTO[] | null;
-	overallState: RulestatehistorytypesAlertStateDTO;
-	/**
-	 * @type boolean
-	 */
-	overallStateChanged: boolean;
-	/**
-	 * @type string
-	 */
-	ruleID: string;
-	/**
-	 * @type string
-	 */
-	ruleName: string;
-	state: RulestatehistorytypesAlertStateDTO;
-	/**
-	 * @type boolean
-	 */
-	stateChanged: boolean;
-	/**
-	 * @type integer
-	 * @format int64
-	 */
-	unixMilli: number;
-	/**
-	 * @type number
-	 * @format double
-	 */
-	value: number;
-}
-
-export interface RulestatehistorytypesGettableRuleStateHistoryContributorDTO {
-	/**
-	 * @type integer
-	 * @minimum 0
-	 */
-	count: number;
-	/**
-	 * @type integer
-	 * @minimum 0
-	 */
-	fingerprint: number;
-	/**
-	 * @type array
-	 * @nullable true
-	 */
-	labels: Querybuildertypesv5LabelDTO[] | null;
-	/**
-	 * @type string
-	 */
-	relatedLogsLink?: string;
-	/**
-	 * @type string
-	 */
-	relatedTracesLink?: string;
-}
-
-export interface RulestatehistorytypesGettableRuleStateHistoryStatsDTO {
-	/**
-	 * @type number
-	 * @format double
-	 */
-	currentAvgResolutionTime: number;
-	currentAvgResolutionTimeSeries: Querybuildertypesv5TimeSeriesDTO;
-	currentTriggersSeries: Querybuildertypesv5TimeSeriesDTO;
-	/**
-	 * @type number
-	 * @format double
-	 */
-	pastAvgResolutionTime: number;
-	pastAvgResolutionTimeSeries: Querybuildertypesv5TimeSeriesDTO;
-	pastTriggersSeries: Querybuildertypesv5TimeSeriesDTO;
-	/**
-	 * @type integer
-	 * @minimum 0
-	 */
-	totalCurrentTriggers: number;
-	/**
-	 * @type integer
-	 * @minimum 0
-	 */
-	totalPastTriggers: number;
-}
-
-export interface RulestatehistorytypesGettableRuleStateTimelineDTO {
-	/**
-	 * @type array
-	 * @nullable true
-	 */
-	items: RulestatehistorytypesGettableRuleStateHistoryDTO[] | null;
-	/**
-	 * @type string
-	 */
-	nextCursor?: string;
-	/**
-	 * @type integer
-	 * @minimum 0
-	 */
-	total: number;
-}
-
-export interface RulestatehistorytypesGettableRuleStateWindowDTO {
-	/**
-	 * @type integer
-	 * @format int64
-	 */
-	end: number;
-	/**
-	 * @type integer
-	 * @format int64
-	 */
-	start: number;
-	state: RulestatehistorytypesAlertStateDTO;
-}
-
 export interface ServiceaccounttypesFactorAPIKeyDTO {
 	/**
 	 * @type string
@@ -4424,22 +4258,6 @@ export type GetMetricMetadata200 = {
 export type UpdateMetricMetadataPathParameters = {
 	metricName: string;
 };
-export type InspectMetrics200 = {
-	data: MetricsexplorertypesInspectMetricsResponseDTO;
-	/**
-	 * @type string
-	 */
-	status: string;
-};
-
-export type GetMetricsOnboardingStatus200 = {
-	data: MetricsexplorertypesMetricsOnboardingResponseDTO;
-	/**
-	 * @type string
-	 */
-	status: string;
-};
-
 export type GetMetricsStats200 = {
 	data: MetricsexplorertypesStatsResponseDTO;
 	/**
@@ -4494,266 +4312,6 @@ export type GetUsersByRoleID200 = {
 	status: string;
 };
 
-export type GetRuleHistoryFilterKeysPathParameters = {
-	id: string;
-};
-export type GetRuleHistoryFilterKeysParams = {
-	/**
-	 * @description undefined
-	 */
-	signal?: TelemetrytypesSignalDTO;
-	/**
-	 * @description undefined
-	 */
-	source?: TelemetrytypesSourceDTO;
-	/**
-	 * @type integer
-	 * @description undefined
-	 */
-	limit?: number;
-	/**
-	 * @type integer
-	 * @format int64
-	 * @description undefined
-	 */
-	startUnixMilli?: number;
-	/**
-	 * @type integer
-	 * @format int64
-	 * @description undefined
-	 */
-	endUnixMilli?: number;
-	/**
-	 * @description undefined
-	 */
-	fieldContext?: TelemetrytypesFieldContextDTO;
-	/**
-	 * @description undefined
-	 */
-	fieldDataType?: TelemetrytypesFieldDataTypeDTO;
-	/**
-	 * @type string
-	 * @description undefined
-	 */
-	metricName?: string;
-	/**
-	 * @type string
-	 * @description undefined
-	 */
-	searchText?: string;
-};
-
-export type GetRuleHistoryFilterKeys200 = {
-	data: TelemetrytypesGettableFieldKeysDTO;
-	/**
-	 * @type string
-	 */
-	status: string;
-};
-
-export type GetRuleHistoryFilterValuesPathParameters = {
-	id: string;
-};
-export type GetRuleHistoryFilterValuesParams = {
-	/**
-	 * @description undefined
-	 */
-	signal?: TelemetrytypesSignalDTO;
-	/**
-	 * @description undefined
-	 */
-	source?: TelemetrytypesSourceDTO;
-	/**
-	 * @type integer
-	 * @description undefined
-	 */
-	limit?: number;
-	/**
-	 * @type integer
-	 * @format int64
-	 * @description undefined
-	 */
-	startUnixMilli?: number;
-	/**
-	 * @type integer
-	 * @format int64
-	 * @description undefined
-	 */
-	endUnixMilli?: number;
-	/**
-	 * @description undefined
-	 */
-	fieldContext?: TelemetrytypesFieldContextDTO;
-	/**
-	 * @description undefined
-	 */
-	fieldDataType?: TelemetrytypesFieldDataTypeDTO;
-	/**
-	 * @type string
-	 * @description undefined
-	 */
-	metricName?: string;
-	/**
-	 * @type string
-	 * @description undefined
-	 */
-	searchText?: string;
-	/**
-	 * @type string
-	 * @description undefined
-	 */
-	name?: string;
-	/**
-	 * @type string
-	 * @description undefined
-	 */
-	existingQuery?: string;
-};
-
-export type GetRuleHistoryFilterValues200 = {
-	data: TelemetrytypesGettableFieldValuesDTO;
-	/**
-	 * @type string
-	 */
-	status: string;
-};
-
-export type GetRuleHistoryOverallStatusPathParameters = {
-	id: string;
-};
-export type GetRuleHistoryOverallStatusParams = {
-	/**
-	 * @type integer
-	 * @format int64
-	 * @description undefined
-	 */
-	start: number;
-	/**
-	 * @type integer
-	 * @format int64
-	 * @description undefined
-	 */
-	end: number;
-};
-
-export type GetRuleHistoryOverallStatus200 = {
-	/**
-	 * @type array
-	 * @nullable true
-	 */
-	data: RulestatehistorytypesGettableRuleStateWindowDTO[] | null;
-	/**
-	 * @type string
-	 */
-	status: string;
-};
-
-export type GetRuleHistoryStatsPathParameters = {
-	id: string;
-};
-export type GetRuleHistoryStatsParams = {
-	/**
-	 * @type integer
-	 * @format int64
-	 * @description undefined
-	 */
-	start: number;
-	/**
-	 * @type integer
-	 * @format int64
-	 * @description undefined
-	 */
-	end: number;
-};
-
-export type GetRuleHistoryStats200 = {
-	data: RulestatehistorytypesGettableRuleStateHistoryStatsDTO;
-	/**
-	 * @type string
-	 */
-	status: string;
-};
-
-export type GetRuleHistoryTimelinePathParameters = {
-	id: string;
-};
-export type GetRuleHistoryTimelineParams = {
-	/**
-	 * @type integer
-	 * @format int64
-	 * @description undefined
-	 */
-	start: number;
-	/**
-	 * @type integer
-	 * @format int64
-	 * @description undefined
-	 */
-	end: number;
-	/**
-	 * @description undefined
-	 */
-	state?: RulestatehistorytypesAlertStateDTO;
-	/**
-	 * @type string
-	 * @description undefined
-	 */
-	filterExpression?: string;
-	/**
-	 * @type integer
-	 * @format int64
-	 * @description undefined
-	 */
-	limit?: number;
-	/**
-	 * @description undefined
-	 */
-	order?: Querybuildertypesv5OrderDirectionDTO;
-	/**
-	 * @type string
-	 * @description undefined
-	 */
-	cursor?: string;
-};
-
-export type GetRuleHistoryTimeline200 = {
-	data: RulestatehistorytypesGettableRuleStateTimelineDTO;
-	/**
-	 * @type string
-	 */
-	status: string;
-};
-
-export type GetRuleHistoryTopContributorsPathParameters = {
-	id: string;
-};
-export type GetRuleHistoryTopContributorsParams = {
-	/**
-	 * @type integer
-	 * @format int64
-	 * @description undefined
-	 */
-	start: number;
-	/**
-	 * @type integer
-	 * @format int64
-	 * @description undefined
-	 */
-	end: number;
-};
-
-export type GetRuleHistoryTopContributors200 = {
-	/**
-	 * @type array
-	 * @nullable true
-	 */
-	data: RulestatehistorytypesGettableRuleStateHistoryContributorDTO[] | null;
-	/**
-	 * @type string
-	 */
-	status: string;
-};
-
 export type GetSessionContext200 = {
 	data: AuthtypesSessionContextDTO;
 	/**

frontend/src/api/metricsExplorer/getInspectMetricsDetails.ts

@@ -0,0 +1,54 @@
+import axios from 'api';
+import { ErrorResponseHandler } from 'api/ErrorResponseHandler';
+import { AxiosError } from 'axios';
+import { ErrorResponse, SuccessResponse } from 'types/api';
+import { TagFilter } from 'types/api/queryBuilder/queryBuilderData';
+
+export interface InspectMetricsRequest {
+	metricName: string;
+	start: number;
+	end: number;
+	filters: TagFilter;
+}
+
+export interface InspectMetricsResponse {
+	status: string;
+	data: {
+		series: InspectMetricsSeries[];
+	};
+}
+
+export interface InspectMetricsSeries {
+	title?: string;
+	strokeColor?: string;
+	labels: Record<string, string>;
+	labelsArray: Array<Record<string, string>>;
+	values: InspectMetricsTimestampValue[];
+}
+
+interface InspectMetricsTimestampValue {
+	timestamp: number;
+	value: string;
+}
+
+export const getInspectMetricsDetails = async (
+	request: InspectMetricsRequest,
+	signal?: AbortSignal,
+	headers?: Record<string, string>,
+): Promise<SuccessResponse<InspectMetricsResponse> | ErrorResponse> => {
+	try {
+		const response = await axios.post(`/metrics/inspect`, request, {
+			signal,
+			headers,
+		});
+
+		return {
+			statusCode: 200,
+			error: null,
+			message: 'Success',
+			payload: response.data,
+		};
+	} catch (error) {
+		return ErrorResponseHandler(error as AxiosError);
+	}
+};

frontend/src/api/metricsExplorer/getMetricDetails.ts

@@ -0,0 +1,75 @@
+import axios from 'api';
+import { ErrorResponseHandler } from 'api/ErrorResponseHandler';
+import { AxiosError } from 'axios';
+import { ErrorResponse, SuccessResponse } from 'types/api';
+
+import { MetricType } from './getMetricsList';
+
+export interface MetricDetails {
+	name: string;
+	description: string;
+	type: string;
+	unit: string;
+	timeseries: number;
+	samples: number;
+	timeSeriesTotal: number;
+	timeSeriesActive: number;
+	lastReceived: string;
+	attributes: MetricDetailsAttribute[] | null;
+	metadata?: {
+		metric_type: MetricType;
+		description: string;
+		unit: string;
+		temporality?: Temporality;
+	};
+	alerts: MetricDetailsAlert[] | null;
+	dashboards: MetricDetailsDashboard[] | null;
+}
+
+export enum Temporality {
+	CUMULATIVE = 'Cumulative',
+	DELTA = 'Delta',
+}
+
+export interface MetricDetailsAttribute {
+	key: string;
+	value: string[];
+	valueCount: number;
+}
+
+export interface MetricDetailsAlert {
+	alert_name: string;
+	alert_id: string;
+}
+
+export interface MetricDetailsDashboard {
+	dashboard_name: string;
+	dashboard_id: string;
+}
+
+export interface MetricDetailsResponse {
+	status: string;
+	data: MetricDetails;
+}
+
+export const getMetricDetails = async (
+	metricName: string,
+	signal?: AbortSignal,
+	headers?: Record<string, string>,
+): Promise<SuccessResponse<MetricDetailsResponse> | ErrorResponse> => {
+	try {
+		const response = await axios.get(`/metrics/${metricName}/metadata`, {
+			signal,
+			headers,
+		});
+
+		return {
+			statusCode: 200,
+			error: null,
+			message: 'Success',
+			payload: response.data,
+		};
+	} catch (error) {
+		return ErrorResponseHandler(error as AxiosError);
+	}
+};

frontend/src/api/metricsExplorer/getMetricsList.ts

@@ -0,0 +1,67 @@
+import axios from 'api';
+import { ErrorResponseHandler } from 'api/ErrorResponseHandler';
+import { AxiosError } from 'axios';
+import {
+	OrderByPayload,
+	TreemapViewType,
+} from 'container/MetricsExplorer/Summary/types';
+import { ErrorResponse, SuccessResponse } from 'types/api';
+import { BaseAutocompleteData } from 'types/api/queryBuilder/queryAutocompleteResponse';
+import { TagFilter } from 'types/api/queryBuilder/queryBuilderData';
+
+export interface MetricsListPayload {
+	filters: TagFilter;
+	groupBy?: BaseAutocompleteData[];
+	offset?: number;
+	limit?: number;
+	orderBy?: OrderByPayload;
+}
+
+export enum MetricType {
+	SUM = 'Sum',
+	GAUGE = 'Gauge',
+	HISTOGRAM = 'Histogram',
+	SUMMARY = 'Summary',
+	EXPONENTIAL_HISTOGRAM = 'ExponentialHistogram',
+}
+
+export interface MetricsListItemData {
+	metric_name: string;
+	description: string;
+	type: MetricType;
+	unit: string;
+	[TreemapViewType.TIMESERIES]: number;
+	[TreemapViewType.SAMPLES]: number;
+	lastReceived: string;
+}
+
+export interface MetricsListResponse {
+	status: string;
+	data: {
+		metrics: MetricsListItemData[];
+		total?: number;
+	};
+}
+
+export const getMetricsList = async (
+	props: MetricsListPayload,
+	signal?: AbortSignal,
+	headers?: Record<string, string>,
+): Promise<SuccessResponse<MetricsListResponse> | ErrorResponse> => {
+	try {
+		const response = await axios.post('/metrics', props, {
+			signal,
+			headers,
+		});
+
+		return {
+			statusCode: 200,
+			error: null,
+			message: response.data.status,
+			payload: response.data,
+			params: props,
+		};
+	} catch (error) {
+		return ErrorResponseHandler(error as AxiosError);
+	}
+};

frontend/src/api/metricsExplorer/getMetricsListFilterKeys.ts

@@ -0,0 +1,44 @@
+import axios from 'api';
+import { ErrorResponseHandler } from 'api/ErrorResponseHandler';
+import { AxiosError } from 'axios';
+import { ErrorResponse, SuccessResponse } from 'types/api';
+import { BaseAutocompleteData } from 'types/api/queryBuilder/queryAutocompleteResponse';
+
+export interface MetricsListFilterKeysResponse {
+	status: string;
+	data: {
+		metricColumns: string[];
+		attributeKeys: BaseAutocompleteData[];
+	};
+}
+
+export interface GetMetricsListFilterKeysParams {
+	searchText: string;
+	limit?: number;
+}
+
+export const getMetricsListFilterKeys = async (
+	params: GetMetricsListFilterKeysParams,
+	signal?: AbortSignal,
+	headers?: Record<string, string>,
+): Promise<SuccessResponse<MetricsListFilterKeysResponse> | ErrorResponse> => {
+	try {
+		const response = await axios.get('/metrics/filters/keys', {
+			params: {
+				searchText: params.searchText,
+				limit: params.limit,
+			},
+			signal,
+			headers,
+		});
+
+		return {
+			statusCode: 200,
+			error: null,
+			message: response.data.status,
+			payload: response.data,
+		};
+	} catch (error) {
+		return ErrorResponseHandler(error as AxiosError);
+	}
+};

frontend/src/api/metricsExplorer/getMetricsListFilterValues.ts

@@ -0,0 +1,43 @@
+import axios from 'api';
+import { ErrorResponseHandler } from 'api/ErrorResponseHandler';
+import { AxiosError } from 'axios';
+import { ErrorResponse, SuccessResponse } from 'types/api';
+
+export interface MetricsListFilterValuesPayload {
+	filterAttributeKeyDataType: string;
+	filterKey: string;
+	searchText: string;
+	limit: number;
+}
+
+export interface MetricsListFilterValuesResponse {
+	status: string;
+	data: {
+		filterValues: string[];
+	};
+}
+
+export const getMetricsListFilterValues = async (
+	props: MetricsListFilterValuesPayload,
+	signal?: AbortSignal,
+	headers?: Record<string, string>,
+): Promise<
+	SuccessResponse<MetricsListFilterValuesResponse> | ErrorResponse
+> => {
+	try {
+		const response = await axios.post('/metrics/filters/values', props, {
+			signal,
+			headers,
+		});
+
+		return {
+			statusCode: 200,
+			error: null,
+			message: response.data.status,
+			payload: response.data,
+			params: props,
+		};
+	} catch (error) {
+		return ErrorResponseHandler(error as AxiosError);
+	}
+};

frontend/src/api/metricsExplorer/getRelatedMetrics.ts

@@ -0,0 +1,60 @@
+import axios from 'api';
+import { ErrorResponseHandler } from 'api/ErrorResponseHandler';
+import { AxiosError } from 'axios';
+import { ErrorResponse, SuccessResponse } from 'types/api';
+import { IBuilderQuery } from 'types/api/queryBuilder/queryBuilderData';
+
+export interface RelatedMetricsPayload {
+	start: number;
+	end: number;
+	currentMetricName: string;
+}
+
+export interface RelatedMetricDashboard {
+	dashboard_name: string;
+	dashboard_id: string;
+	widget_id: string;
+	widget_name: string;
+}
+
+export interface RelatedMetricAlert {
+	alert_name: string;
+	alert_id: string;
+}
+
+export interface RelatedMetric {
+	name: string;
+	query: IBuilderQuery;
+	dashboards: RelatedMetricDashboard[];
+	alerts: RelatedMetricAlert[];
+}
+
+export interface RelatedMetricsResponse {
+	status: 'success';
+	data: {
+		related_metrics: RelatedMetric[];
+	};
+}
+
+export const getRelatedMetrics = async (
+	props: RelatedMetricsPayload,
+	signal?: AbortSignal,
+	headers?: Record<string, string>,
+): Promise<SuccessResponse<RelatedMetricsResponse> | ErrorResponse> => {
+	try {
+		const response = await axios.post('/metrics/related', props, {
+			signal,
+			headers,
+		});
+
+		return {
+			statusCode: 200,
+			error: null,
+			message: response.data.status,
+			payload: response.data,
+			params: props,
+		};
+	} catch (error) {
+		return ErrorResponseHandler(error as AxiosError);
+	}
+};

frontend/src/components/EditMemberDrawer/EditMemberDrawer.tsx

@@ -1,5 +1,4 @@
 import { useCallback, useEffect, useState } from 'react';
-import { useCopyToClipboard } from 'react-use';
 import { Badge } from '@signozhq/badge';
 import { Button } from '@signozhq/button';
 import { DialogFooter, DialogWrapper } from '@signozhq/dialog';
@@ -178,30 +177,26 @@ function EditMemberDrawer({
 		}
 	}, [member, isInvited, setLinkType, onClose]);
 
-	const [copyState, copyToClipboard] = useCopyToClipboard();
 	const handleCopyResetLink = useCallback(async (): Promise<void> => {
 		if (!resetLink) {
 			return;
 		}
-		copyToClipboard(resetLink);
-
-		setHasCopiedResetLink(true);
-		setTimeout(() => setHasCopiedResetLink(false), 2000);
-		toast.success(
-			linkType === 'invite'
-				? 'Invite link copied to clipboard'
-				: 'Reset link copied to clipboard',
-			{ richColors: true },
-		);
-	}, [resetLink, copyToClipboard, linkType]);
-
-	useEffect(() => {
-		if (copyState.error) {
+		try {
+			await navigator.clipboard.writeText(resetLink);
+			setHasCopiedResetLink(true);
+			setTimeout(() => setHasCopiedResetLink(false), 2000);
+			toast.success(
+				linkType === 'invite'
+					? 'Invite link copied to clipboard'
+					: 'Reset link copied to clipboard',
+				{ richColors: true },
+			);
+		} catch {
 			toast.error('Failed to copy link', {
 				richColors: true,
 			});
 		}
-	}, [copyState.error]);
+	}, [resetLink, linkType]);
 
 	const handleClose = useCallback((): void => {
 		setShowDeleteConfirm(false);

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

@@ -7,7 +7,13 @@ import {
 	useUpdateUserDeprecated,
 } from 'api/generated/services/users';
 import { MemberStatus } from 'container/MembersSettings/utils';
-import { render, screen, userEvent, waitFor } from 'tests/test-utils';
+import {
+	fireEvent,
+	render,
+	screen,
+	userEvent,
+	waitFor,
+} from 'tests/test-utils';
 import { ROLES } from 'types/roles';
 
 import EditMemberDrawer, { EditMemberDrawerProps } from '../EditMemberDrawer';
@@ -59,16 +65,6 @@ jest.mock('@signozhq/sonner', () => ({
 	},
 }));
 
-const mockCopyToClipboard = jest.fn();
-const mockCopyState = { value: undefined, error: undefined };
-
-jest.mock('react-use', () => ({
-	useCopyToClipboard: (): [typeof mockCopyState, typeof mockCopyToClipboard] => [
-		mockCopyState,
-		mockCopyToClipboard,
-	],
-}));
-
 const mockUpdateMutate = jest.fn();
 const mockDeleteMutate = jest.fn();
 const mockGetResetPasswordToken = jest.mocked(getResetPasswordToken);
@@ -365,14 +361,32 @@ describe('EditMemberDrawer', () => {
 	});
 
 	describe('Generate Password Reset Link', () => {
+		const mockWriteText = jest.fn().mockResolvedValue(undefined);
+		let clipboardSpy: jest.SpyInstance | undefined;
+
+		beforeAll(() => {
+			Object.defineProperty(navigator, 'clipboard', {
+				value: { writeText: (): Promise<void> => Promise.resolve() },
+				configurable: true,
+				writable: true,
+			});
+		});
+
 		beforeEach(() => {
-			mockCopyToClipboard.mockClear();
+			mockWriteText.mockClear();
+			clipboardSpy = jest
+				.spyOn(navigator.clipboard, 'writeText')
+				.mockImplementation(mockWriteText);
 			mockGetResetPasswordToken.mockResolvedValue({
 				status: 'success',
 				data: { token: 'reset-tok-abc', id: 'user-1' },
 			});
 		});
 
+		afterEach(() => {
+			clipboardSpy?.mockRestore();
+		});
+
 		it('calls getResetPasswordToken and opens the reset link dialog with the generated link', async () => {
 			const user = userEvent.setup({ pointerEventsCheck: 0 });
 
@@ -407,7 +421,7 @@ describe('EditMemberDrawer', () => {
 			});
 			expect(dialog).toHaveTextContent('reset-tok-abc');
 
-			await user.click(screen.getByRole('button', { name: /^copy$/i }));
+			fireEvent.click(screen.getByRole('button', { name: /^copy$/i }));
 
 			await waitFor(() => {
 				expect(mockToast.success).toHaveBeenCalledWith(
@@ -416,7 +430,7 @@ describe('EditMemberDrawer', () => {
 				);
 			});
 
-			expect(mockCopyToClipboard).toHaveBeenCalledWith(
+			expect(mockWriteText).toHaveBeenCalledWith(
 				expect.stringContaining('reset-tok-abc'),
 			);
 			expect(screen.getByRole('button', { name: /copied!/i })).toBeInTheDocument();

frontend/src/components/InviteMembersModal/InviteMembersModal.tsx

@@ -202,8 +202,19 @@ function InviteMembersModal({
 			onComplete?.();
 		} catch (err) {
 			const apiErr = err as APIError;
-			const errorMessage = apiErr?.getErrorMessage?.() ?? 'An error occurred';
-			toast.error(errorMessage, { richColors: true });
+			if (apiErr?.getHttpStatusCode() === 409) {
+				toast.error(
+					touchedRows.length === 1
+						? `${touchedRows[0].email} is already a member`
+						: 'Invite for one or more users already exists',
+					{ richColors: true },
+				);
+			} else {
+				const errorMessage = apiErr?.getErrorMessage?.() ?? 'An error occurred';
+				toast.error(`Failed to send invites: ${errorMessage}`, {
+					richColors: true,
+				});
+			}
 		} finally {
 			setIsSubmitting(false);
 		}

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

@@ -1,18 +1,9 @@
-import { toast } from '@signozhq/sonner';
 import inviteUsers from 'api/v1/invite/bulk/create';
 import sendInvite from 'api/v1/invite/create';
-import { StatusCodes } from 'http-status-codes';
 import { render, screen, userEvent, waitFor } from 'tests/test-utils';
-import APIError from 'types/api/error';
 
 import InviteMembersModal from '../InviteMembersModal';
 
-const makeApiError = (message: string, code = StatusCodes.CONFLICT): APIError =>
-	new APIError({
-		httpStatusCode: code,
-		error: { code: 'already_exists', message, url: '', errors: [] },
-	});
-
 jest.mock('api/v1/invite/create');
 jest.mock('api/v1/invite/bulk/create');
 jest.mock('@signozhq/sonner', () => ({
@@ -151,90 +142,6 @@ describe('InviteMembersModal', () => {
 		});
 	});
 
-	describe('error handling', () => {
-		it('shows BE message on single invite 409', async () => {
-			const user = userEvent.setup({ pointerEventsCheck: 0 });
-			mockSendInvite.mockRejectedValue(
-				makeApiError('An invite already exists for this email: single@signoz.io'),
-			);
-
-			render(<InviteMembersModal {...defaultProps} />);
-
-			await user.type(
-				screen.getAllByPlaceholderText('john@signoz.io')[0],
-				'single@signoz.io',
-			);
-			await user.click(screen.getAllByText('Select roles')[0]);
-			await user.click(await screen.findByText('Viewer'));
-			await user.click(
-				screen.getByRole('button', { name: /invite team members/i }),
-			);
-
-			await waitFor(() => {
-				expect(toast.error).toHaveBeenCalledWith(
-					'An invite already exists for this email: single@signoz.io',
-					expect.anything(),
-				);
-			});
-		});
-
-		it('shows BE message on bulk invite 409', async () => {
-			const user = userEvent.setup({ pointerEventsCheck: 0 });
-			mockInviteUsers.mockRejectedValue(
-				makeApiError('An invite already exists for this email: alice@signoz.io'),
-			);
-
-			render(<InviteMembersModal {...defaultProps} />);
-
-			const emailInputs = screen.getAllByPlaceholderText('john@signoz.io');
-			await user.type(emailInputs[0], 'alice@signoz.io');
-			await user.click(screen.getAllByText('Select roles')[0]);
-			await user.click(await screen.findByText('Viewer'));
-
-			await user.type(emailInputs[1], 'bob@signoz.io');
-			await user.click(screen.getAllByText('Select roles')[0]);
-			const editorOptions = await screen.findAllByText('Editor');
-			await user.click(editorOptions[editorOptions.length - 1]);
-
-			await user.click(
-				screen.getByRole('button', { name: /invite team members/i }),
-			);
-
-			await waitFor(() => {
-				expect(toast.error).toHaveBeenCalledWith(
-					'An invite already exists for this email: alice@signoz.io',
-					expect.anything(),
-				);
-			});
-		});
-
-		it('shows BE message on generic error', async () => {
-			const user = userEvent.setup({ pointerEventsCheck: 0 });
-			mockSendInvite.mockRejectedValue(
-				makeApiError('Internal server error', StatusCodes.INTERNAL_SERVER_ERROR),
-			);
-
-			render(<InviteMembersModal {...defaultProps} />);
-
-			await user.type(
-				screen.getAllByPlaceholderText('john@signoz.io')[0],
-				'single@signoz.io',
-			);
-			await user.click(screen.getAllByText('Select roles')[0]);
-			await user.click(await screen.findByText('Viewer'));
-			await user.click(
-				screen.getByRole('button', { name: /invite team members/i }),
-			);
-
-			await waitFor(() => {
-				expect(toast.error).toHaveBeenCalledWith(
-					'Internal server error',
-					expect.anything(),
-				);
-			});
-		});
-	});
-
 	it('uses inviteUsers (bulk) when multiple rows are filled', async () => {
 		const user = userEvent.setup({ pointerEventsCheck: 0 });
 		const onComplete = jest.fn();

frontend/src/components/LogDetail/index.tsx

@@ -1,6 +1,6 @@
-import React, { useCallback, useEffect, useMemo, useState } from 'react';
+import { useCallback, useEffect, useMemo, useState } from 'react';
 // eslint-disable-next-line no-restricted-imports
-import { useSelector } from 'react-redux'; // old code, TODO: fix this correctly
+import { useSelector } from 'react-redux';
 import { useCopyToClipboard, useLocation } from 'react-use';
 import { Color, Spacing } from '@signozhq/design-tokens';
 import { Button, Divider, Drawer, Radio, Tooltip, Typography } from 'antd';
@@ -49,7 +49,6 @@ import { AppState } from 'store/reducers';
 import { Query, TagFilter } from 'types/api/queryBuilder/queryBuilderData';
 import { DataSource, StringOperators } from 'types/common/queryBuilder';
 import { GlobalReducer } from 'types/reducer/globalTime';
-import { isModifierKeyPressed } from 'utils/app';
 
 import { RESOURCE_KEYS, VIEW_TYPES, VIEWS } from './constants';
 import { LogDetailInnerProps, LogDetailProps } from './LogDetail.interfaces';
@@ -222,7 +221,7 @@ function LogDetailInner({
 	};
 
 	// Go to logs explorer page with the log data
-	const handleOpenInExplorer = (e?: React.MouseEvent): void => {
+	const handleOpenInExplorer = (): void => {
 		const queryParams = {
 			[QueryParams.activeLogId]: `"${log?.id}"`,
 			[QueryParams.startTime]: minTime?.toString() || '',
@@ -235,9 +234,7 @@ function LogDetailInner({
 				),
 			),
 		};
-		safeNavigate(`${ROUTES.LOGS_EXPLORER}?${createQueryParams(queryParams)}`, {
-			newTab: !!e && isModifierKeyPressed(e),
-		});
+		safeNavigate(`${ROUTES.LOGS_EXPLORER}?${createQueryParams(queryParams)}`);
 	};
 
 	const handleQueryExpressionChange = useCallback(

frontend/src/components/MarkdownRenderer/CodeCopyBtn/CodeCopyBtn.tsx

@@ -17,7 +17,6 @@ function CodeCopyBtn({
 		let copiedText = '';
 		if (children && Array.isArray(children)) {
 			setIsSnippetCopied(true);
-			// eslint-disable-next-line no-restricted-properties
 			navigator.clipboard.writeText(children[0].props.children[0]).finally(() => {
 				copiedText = (children[0].props.children[0] as string).slice(0, 200); // slicing is done due to the limitation in accepted char length in attributes
 				setTimeout(() => {

frontend/src/components/NewSelect/CustomMultiSelect.tsx

@@ -401,7 +401,6 @@ const CustomMultiSelect: React.FC<CustomMultiSelectProps> = ({
 
 		const textToCopy = selectedTexts.join(', ');
 
-		// eslint-disable-next-line no-restricted-properties
 		navigator.clipboard.writeText(textToCopy).catch(console.error);
 	}, [selectedChips, selectedValues]);
 

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

@@ -1,7 +1,6 @@
 import { useCallback, useEffect, useState } from 'react';
 import { useForm } from 'react-hook-form';
 import { useQueryClient } from 'react-query';
-import { useCopyToClipboard } from 'react-use';
 import { DialogWrapper } from '@signozhq/dialog';
 import { toast } from '@signozhq/sonner';
 import { convertToApiError } from 'api/ErrorResponseHandlerForGeneratedAPIs';
@@ -106,23 +105,19 @@ function AddKeyModal(): JSX.Element {
 		});
 	}
 
-	const [copyState, copyToClipboard] = useCopyToClipboard();
 	const handleCopy = useCallback(async (): Promise<void> => {
 		if (!createdKey?.key) {
 			return;
 		}
-
-		copyToClipboard(createdKey.key);
-		setHasCopied(true);
-		setTimeout(() => setHasCopied(false), 2000);
-		toast.success('Key copied to clipboard', { richColors: true });
-	}, [copyToClipboard, createdKey?.key]);
-
-	useEffect(() => {
-		if (copyState.error) {
+		try {
+			await navigator.clipboard.writeText(createdKey.key);
+			setHasCopied(true);
+			setTimeout(() => setHasCopied(false), 2000);
+			toast.success('Key copied to clipboard', { richColors: true });
+		} catch {
 			toast.error('Failed to copy key', { richColors: true });
 		}
-	}, [copyState.error]);
+	}, [createdKey]);
 
 	const handleClose = useCallback((): void => {
 		setIsAddKeyOpen(null);

frontend/src/components/ServiceAccountDrawer/__tests__/AddKeyModal.test.tsx

@@ -9,16 +9,6 @@ jest.mock('@signozhq/sonner', () => ({
 	toast: { success: jest.fn(), error: jest.fn() },
 }));
 
-const mockCopyToClipboard = jest.fn();
-const mockCopyState = { value: undefined, error: undefined };
-
-jest.mock('react-use', () => ({
-	useCopyToClipboard: (): [typeof mockCopyState, typeof mockCopyToClipboard] => [
-		mockCopyState,
-		mockCopyToClipboard,
-	],
-}));
-
 const mockToast = jest.mocked(toast);
 
 const SA_KEYS_ENDPOINT = '*/api/v1/service_accounts/sa-1/keys';
@@ -45,9 +35,16 @@ function renderModal(): ReturnType<typeof render> {
 }
 
 describe('AddKeyModal', () => {
+	beforeAll(() => {
+		Object.defineProperty(navigator, 'clipboard', {
+			value: { writeText: jest.fn().mockResolvedValue(undefined) },
+			configurable: true,
+			writable: true,
+		});
+	});
+
 	beforeEach(() => {
 		jest.clearAllMocks();
-		mockCopyToClipboard.mockClear();
 		server.use(
 			rest.post(SA_KEYS_ENDPOINT, (_, res, ctx) =>
 				res(ctx.status(201), ctx.json(createdKeyResponse)),
@@ -93,6 +90,9 @@ describe('AddKeyModal', () => {
 
 	it('copy button writes key to clipboard and shows toast.success', async () => {
 		const user = userEvent.setup({ pointerEventsCheck: 0 });
+		const writeTextSpy = jest
+			.spyOn(navigator.clipboard, 'writeText')
+			.mockResolvedValue(undefined);
 
 		renderModal();
 
@@ -115,12 +115,14 @@ describe('AddKeyModal', () => {
 		await user.click(copyBtn);
 
 		await waitFor(() => {
-			expect(mockCopyToClipboard).toHaveBeenCalledWith('snz_abc123xyz456secret');
+			expect(writeTextSpy).toHaveBeenCalledWith('snz_abc123xyz456secret');
 			expect(mockToast.success).toHaveBeenCalledWith(
 				'Key copied to clipboard',
 				expect.anything(),
 			);
 		});
+
+		writeTextSpy.mockRestore();
 	});
 
 	it('Cancel button closes the modal', async () => {

frontend/src/container/AlertHistory/Statistics/AverageResolutionCard/AverageResolutionCard.tsx

@@ -16,9 +16,9 @@ function AverageResolutionCard({
 }: TotalTriggeredCardProps): JSX.Element {
 	return (
 		<StatsCard
-			displayValue={formatTime(+currentAvgResolutionTime)}
-			totalCurrentCount={+currentAvgResolutionTime}
-			totalPastCount={+pastAvgResolutionTime}
+			displayValue={formatTime(currentAvgResolutionTime)}
+			totalCurrentCount={currentAvgResolutionTime}
+			totalPastCount={pastAvgResolutionTime}
 			title="Avg. Resolution Time"
 			timeSeries={timeSeries}
 		/>

frontend/src/container/ApiMonitoring/Explorer/Domains/DomainDetails/DomainDetails.styles.scss

@@ -800,10 +800,14 @@
 
 			.ant-table-cell:has(.top-services-item-latency) {
 				text-align: center;
+				opacity: 0.8;
+				background: rgba(171, 189, 255, 0.04);
 			}
 
 			.ant-table-cell:has(.top-services-item-latency-title) {
 				text-align: center;
+				opacity: 0.8;
+				background: rgba(171, 189, 255, 0.04);
 			}
 
 			.ant-table-tbody > tr:hover > td {

frontend/src/container/ApiMonitoring/Explorer/Explorer.styles.scss

@@ -9,6 +9,7 @@
 		.api-quick-filters-header {
 			padding: 12px;
 			border-bottom: 1px solid var(--bg-slate-400);
+			border-right: 1px solid var(--bg-slate-400);
 
 			display: flex;
 			align-items: center;
@@ -25,7 +26,6 @@
 		width: 100%;
 
 		.toolbar {
-			border-top: 0px;
 			border-bottom: 1px solid var(--bg-slate-400);
 		}
 
@@ -220,18 +220,6 @@
 }
 
 .lightMode {
-	.api-quick-filter-left-section {
-		.api-quick-filters-header {
-			border-bottom: 1px solid var(--bg-vanilla-300);
-		}
-	}
-
-	.api-module-right-section {
-		.toolbar {
-			border-bottom: 1px solid var(--bg-vanilla-300);
-		}
-	}
-
 	.no-filtered-domains-message-container {
 		.no-filtered-domains-message-content {
 			.no-filtered-domains-message {

frontend/src/container/CreateAlertRule/SelectAlertType/index.tsx

@@ -6,7 +6,6 @@ import { ALERTS_DATA_SOURCE_MAP } from 'constants/alerts';
 import { FeatureKeys } from 'constants/features';
 import { useAppContext } from 'providers/App/App';
 import { AlertTypes } from 'types/api/alerts/alertTypes';
-import { isModifierKeyPressed } from 'utils/app';
 
 import { getOptionList } from './config';
 import { AlertTypeCard, SelectTypeContainer } from './styles';
@@ -71,8 +70,8 @@ function SelectAlertType({ onSelect }: SelectAlertTypeProps): JSX.Element {
 								</Tag>
 							) : undefined
 						}
-						onClick={(e): void => {
-							onSelect(option.selection, isModifierKeyPressed(e));
+						onClick={(): void => {
+							onSelect(option.selection);
 						}}
 						data-testid={`alert-type-card-${option.selection}`}
 					>
@@ -109,7 +108,7 @@ function SelectAlertType({ onSelect }: SelectAlertTypeProps): JSX.Element {
 }
 
 interface SelectAlertTypeProps {
-	onSelect: (type: AlertTypes, newTab?: boolean) => void;
+	onSelect: (typ: AlertTypes) => void;
 }
 
 export default SelectAlertType;

frontend/src/container/CreateAlertV2/Footer/Footer.tsx

@@ -4,7 +4,6 @@ import { Button, Tooltip, Typography } from 'antd';
 import { useQueryBuilder } from 'hooks/queryBuilder/useQueryBuilder';
 import { useSafeNavigate } from 'hooks/useSafeNavigate';
 import { Check, Loader, Send, X } from 'lucide-react';
-import { isModifierKeyPressed } from 'utils/app';
 
 import { useCreateAlertState } from '../context';
 import {
@@ -34,9 +33,9 @@ function Footer(): JSX.Element {
 	const { currentQuery } = useQueryBuilder();
 	const { safeNavigate } = useSafeNavigate();
 
-	const handleDiscard = (e: React.MouseEvent): void => {
+	const handleDiscard = (): void => {
 		discardAlertRule();
-		safeNavigate('/alerts', { newTab: isModifierKeyPressed(e) });
+		safeNavigate('/alerts');
 	};
 
 	const alertValidationMessage = useMemo(

frontend/src/container/DashboardContainer/DashboardSettings/PublicDashboard/__tests__/PublicDashboard.test.tsx

@@ -1,7 +1,6 @@
 import { useCopyToClipboard } from 'react-use';
 import { toast } from '@signozhq/sonner';
 import { fireEvent, within } from '@testing-library/react';
-import { DEFAULT_TIME_RANGE } from 'container/TopNav/DateTimeSelectionV2/constants';
 import { StatusCodes } from 'http-status-codes';
 import {
 	publishedPublicDashboardMeta,
@@ -34,6 +33,7 @@ const mockToast = jest.mocked(toast);
 // Test constants
 const MOCK_DASHBOARD_ID = 'test-dashboard-id';
 const MOCK_PUBLIC_PATH = '/public/dashboard/test-dashboard-id';
+const DEFAULT_TIME_RANGE = '30m';
 const DASHBOARD_VARIABLES_WARNING =
 	"Dashboard variables won't work in public dashboards";
 

frontend/src/container/DashboardContainer/DashboardSettings/PublicDashboard/index.tsx

@@ -7,7 +7,6 @@ import { Button, Select, Typography } from 'antd';
 import createPublicDashboardAPI from 'api/dashboard/public/createPublicDashboard';
 import revokePublicDashboardAccessAPI from 'api/dashboard/public/revokePublicDashboardAccess';
 import updatePublicDashboardAPI from 'api/dashboard/public/updatePublicDashboard';
-import { DEFAULT_TIME_RANGE } from 'container/TopNav/DateTimeSelectionV2/constants';
 import { useGetPublicDashboardMeta } from 'hooks/dashboard/useGetPublicDashboardMeta';
 import { useGetTenantLicense } from 'hooks/useGetTenantLicense';
 import { Copy, ExternalLink, Globe, Info, Loader2, Trash } from 'lucide-react';
@@ -57,7 +56,7 @@ function PublicDashboardSetting(): JSX.Element {
 		PublicDashboardMetaProps | undefined
 	>(undefined);
 	const [timeRangeEnabled, setTimeRangeEnabled] = useState(true);
-	const [defaultTimeRange, setDefaultTimeRange] = useState(DEFAULT_TIME_RANGE);
+	const [defaultTimeRange, setDefaultTimeRange] = useState('30m');
 	const [, setCopyPublicDashboardURL] = useCopyToClipboard();
 
 	const { selectedDashboard } = useDashboardStore();
@@ -100,7 +99,7 @@ function PublicDashboardSetting(): JSX.Element {
 			console.error('Error getting public dashboard', errorPublicDashboard);
 			setPublicDashboardData(undefined);
 			setTimeRangeEnabled(true);
-			setDefaultTimeRange(DEFAULT_TIME_RANGE);
+			setDefaultTimeRange('30m');
 		}
 	}, [publicDashboardResponse, errorPublicDashboard]);
 
@@ -110,7 +109,7 @@ function PublicDashboardSetting(): JSX.Element {
 				publicDashboardResponse?.data?.timeRangeEnabled || false,
 			);
 			setDefaultTimeRange(
-				publicDashboardResponse?.data?.defaultTimeRange || DEFAULT_TIME_RANGE,
+				publicDashboardResponse?.data?.defaultTimeRange || '30m',
 			);
 		}
 	}, [publicDashboardResponse]);

frontend/src/container/ErrorDetails/index.tsx

@@ -16,8 +16,6 @@ import { isUndefined } from 'lodash-es';
 import { urlKey } from 'pages/ErrorDetails/utils';
 import { useTimezone } from 'providers/Timezone';
 import { PayloadProps as GetByErrorTypeAndServicePayload } from 'types/api/errors/getByErrorTypeAndService';
-import { isModifierKeyPressed } from 'utils/app';
-import { openInNewTab } from 'utils/navigation';
 
 import { keyToExclude } from './config';
 import { DashedContainer, EditorContainer, EventContainer } from './styles';
@@ -113,19 +111,14 @@ function ErrorDetails(props: ErrorDetailsProps): JSX.Element {
 			value: errorDetail[key as keyof GetByErrorTypeAndServicePayload],
 		}));
 
-	const onClickTraceHandler = (event: React.MouseEvent): void => {
+	const onClickTraceHandler = (): void => {
 		logEvent('Exception: Navigate to trace detail page', {
 			groupId: errorDetail?.groupID,
 			spanId: errorDetail.spanID,
 			traceId: errorDetail.traceID,
 			exceptionId: errorDetail?.errorId,
 		});
-		const path = `/trace/${errorDetail.traceID}?spanId=${errorDetail.spanID}`;
-		if (isModifierKeyPressed(event)) {
-			openInNewTab(path);
-		} else {
-			history.push(path);
-		}
+		history.push(`/trace/${errorDetail.traceID}?spanId=${errorDetail.spanID}`);
 	};
 
 	const logEventCalledRef = useRef(false);

frontend/src/container/FormAlertRules/index.tsx

@@ -1,4 +1,4 @@
-import React, { useCallback, useEffect, useMemo, useState } from 'react';
+import { useCallback, useEffect, useMemo, useState } from 'react';
 import { useTranslation } from 'react-i18next';
 import { useQueryClient } from 'react-query';
 // eslint-disable-next-line no-restricted-imports
@@ -44,7 +44,6 @@ import { QueryFunction } from 'types/api/v5/queryRange';
 import { EQueryType } from 'types/common/dashboard';
 import { DataSource } from 'types/common/queryBuilder';
 import { GlobalReducer } from 'types/reducer/globalTime';
-import { isModifierKeyPressed } from 'utils/app';
 import { compositeQueryToQueryEnvelope } from 'utils/compositeQueryToQueryEnvelope';
 
 import BasicInfo from './BasicInfo';
@@ -331,18 +330,13 @@ function FormAlertRules({
 		}
 	}, [alertDef, currentQuery?.queryType, queryOptions]);
 
-	const onCancelHandler = useCallback(
-		(e?: React.MouseEvent) => {
-			urlQuery.delete(QueryParams.compositeQuery);
-			urlQuery.delete(QueryParams.panelTypes);
-			urlQuery.delete(QueryParams.ruleId);
-			urlQuery.delete(QueryParams.relativeTime);
-			safeNavigate(`${ROUTES.LIST_ALL_ALERT}?${urlQuery.toString()}`, {
-				newTab: !!e && isModifierKeyPressed(e),
-			});
-		},
-		[safeNavigate, urlQuery],
-	);
+	const onCancelHandler = useCallback(() => {
+		urlQuery.delete(QueryParams.compositeQuery);
+		urlQuery.delete(QueryParams.panelTypes);
+		urlQuery.delete(QueryParams.ruleId);
+		urlQuery.delete(QueryParams.relativeTime);
+		safeNavigate(`${ROUTES.LIST_ALL_ALERT}?${urlQuery.toString()}`);
+	}, [safeNavigate, urlQuery]);
 
 	// onQueryCategoryChange handles changes to query category
 	// in state as well as sets additional defaults

frontend/src/container/GeneralSettings/GeneralSettings.tsx

@@ -464,10 +464,14 @@ function GeneralSettings({
 		onModalToggleHandler(type);
 	};
 
-	const { isCloudUser: isCloudUserVal } = useGetTenantLicense();
+	const {
+		isCloudUser: isCloudUserVal,
+		isEnterpriseSelfHostedUser,
+	} = useGetTenantLicense();
 
 	const isAdmin = user.role === USER_ROLES.ADMIN;
-	const showCustomDomainSettings = isCloudUserVal && isAdmin;
+	const showCustomDomainSettings =
+		(isCloudUserVal || isEnterpriseSelfHostedUser) && isAdmin;
 
 	const renderConfig = [
 		{

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

@@ -38,6 +38,7 @@ jest.mock('hooks/useComponentPermission', () => ({
 jest.mock('hooks/useGetTenantLicense', () => ({
 	useGetTenantLicense: jest.fn(() => ({
 		isCloudUser: false,
+		isEnterpriseSelfHostedUser: false,
 	})),
 }));
 
@@ -388,6 +389,7 @@ describe('GeneralSettings - S3 Logs Retention', () => {
 		beforeEach(() => {
 			(useGetTenantLicense as jest.Mock).mockReturnValue({
 				isCloudUser: true,
+				isEnterpriseSelfHostedUser: false,
 			});
 		});
 
@@ -409,14 +411,15 @@ describe('GeneralSettings - S3 Logs Retention', () => {
 		});
 	});
 
-	describe('Non-cloud user rendering', () => {
+	describe('Enterprise Self-Hosted User Rendering', () => {
 		beforeEach(() => {
 			(useGetTenantLicense as jest.Mock).mockReturnValue({
 				isCloudUser: false,
+				isEnterpriseSelfHostedUser: true,
 			});
 		});
 
-		it('should not render CustomDomainSettings or GeneralSettingsCloud', () => {
+		it('should render CustomDomainSettings but not GeneralSettingsCloud', () => {
 			render(
 				<GeneralSettings
 					metricsTtlValuesPayload={mockMetricsRetention}
@@ -429,14 +432,12 @@ describe('GeneralSettings - S3 Logs Retention', () => {
 				/>,
 			);
 
-			expect(
-				screen.queryByTestId('custom-domain-settings'),
-			).not.toBeInTheDocument();
+			expect(screen.getByTestId('custom-domain-settings')).toBeInTheDocument();
 			expect(
 				screen.queryByTestId('general-settings-cloud'),
 			).not.toBeInTheDocument();
 
-			// Save buttons should be visible for non-cloud users (these are from retentions)
+			// Save buttons should be visible for self-hosted
 			const saveButtons = screen.getAllByRole('button', { name: /save/i });
 			expect(saveButtons.length).toBeGreaterThan(0);
 		});

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

@@ -1,13 +1,7 @@
 /* eslint-disable sonarjs/cognitive-complexity */
-import React, {
-	useCallback,
-	useEffect,
-	useMemo,
-	useRef,
-	useState,
-} from 'react';
+import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
 // eslint-disable-next-line no-restricted-imports
-import { useSelector } from 'react-redux'; // old code, TODO: fix this correctly
+import { useSelector } from 'react-redux';
 import {
 	LoadingOutlined,
 	SearchOutlined,
@@ -52,7 +46,6 @@ import {
 import { AppState } from 'store/reducers';
 import { Warning } from 'types/api';
 import { GlobalReducer } from 'types/reducer/globalTime';
-import { isModifierKeyPressed } from 'utils/app';
 import { getGraphType } from 'utils/getGraphType';
 import { getSortedSeriesData } from 'utils/getSortedSeriesData';
 
@@ -297,11 +290,9 @@ function FullView({
 											<Button
 												className="switch-edit-btn"
 												disabled={response.isFetching || response.isLoading}
-												onClick={(e: React.MouseEvent): void => {
+												onClick={(): void => {
 													if (dashboardEditView) {
-														safeNavigate(dashboardEditView, {
-															newTab: isModifierKeyPressed(e),
-														});
+														safeNavigate(dashboardEditView);
 													}
 												}}
 											>

frontend/src/container/GridCardLayout/GridCard/__tests__/errorDetails.test.ts

@@ -1,65 +0,0 @@
-import APIError from 'types/api/error';
-
-import { errorDetails } from '../utils';
-
-function makeAPIError(
-	message: string,
-	code = 'SOME_CODE',
-	errors: { message: string }[] = [],
-): APIError {
-	return new APIError({
-		httpStatusCode: 500,
-		error: { code, message, url: '', errors },
-	});
-}
-
-describe('errorDetails', () => {
-	describe('when passed an APIError', () => {
-		it('returns the error message', () => {
-			const error = makeAPIError('something went wrong');
-			expect(errorDetails(error)).toBe('something went wrong');
-		});
-
-		it('appends details when errors array is non-empty', () => {
-			const error = makeAPIError('query failed', 'QUERY_ERROR', [
-				{ message: 'field X is invalid' },
-				{ message: 'field Y is missing' },
-			]);
-			const result = errorDetails(error);
-			expect(result).toContain('query failed');
-			expect(result).toContain('field X is invalid');
-			expect(result).toContain('field Y is missing');
-		});
-
-		it('does not append details when errors array is empty', () => {
-			const error = makeAPIError('simple error', 'CODE', []);
-			const result = errorDetails(error);
-			expect(result).toBe('simple error');
-			expect(result).not.toContain('Details');
-		});
-	});
-
-	describe('when passed a plain Error (not an APIError)', () => {
-		it('does not throw', () => {
-			const error = new Error('timeout exceeded');
-			expect(() => errorDetails(error)).not.toThrow();
-		});
-
-		it('returns the plain error message', () => {
-			const error = new Error('timeout exceeded');
-			expect(errorDetails(error)).toBe('timeout exceeded');
-		});
-
-		it('returns fallback when plain Error has no message', () => {
-			const error = new Error('');
-			expect(errorDetails(error)).toBe('Unknown error occurred');
-		});
-	});
-
-	describe('fallback behaviour', () => {
-		it('returns "Unknown error occurred" when message is undefined', () => {
-			const error = makeAPIError('');
-			expect(errorDetails(error)).toBe('Unknown error occurred');
-		});
-	});
-});

frontend/src/container/GridCardLayout/GridCard/utils.ts

@@ -249,14 +249,13 @@ export const handleGraphClick = async ({
 	}
 };
 
-export const errorDetails = (error: APIError | Error): string => {
-	const { message, errors } =
-		(error instanceof APIError ? error.getErrorDetails()?.error : null) || {};
+export const errorDetails = (error: APIError): string => {
+	const { message, errors } = error.getErrorDetails()?.error || {};
 
 	const details =
-		errors && errors.length > 0
+		errors?.length > 0
 			? `\n\nDetails: ${errors.map((e) => e.message).join('\n')}`
 			: '';
-	const errorDetails = `${message ?? error.message} ${details}`;
-	return errorDetails.trim() || 'Unknown error occurred';
+	const errorDetails = `${message} ${details}`;
+	return errorDetails || 'Unknown error occurred';
 };

frontend/src/container/Home/Home.tsx

@@ -1,11 +1,9 @@
-/* eslint-disable sonarjs/no-duplicate-string */
-import React, { useCallback, useEffect, useState } from 'react';
+import { useCallback, useEffect, useMemo, useState } from 'react';
 import { useMutation, useQuery } from 'react-query';
 import { Color } from '@signozhq/design-tokens';
 import { Compass, Dot, House, Plus, Wrench } from '@signozhq/icons';
 import { Button, Popover } from 'antd';
 import logEvent from 'api/common/logEvent';
-import { useGetMetricsOnboardingStatus } from 'api/generated/services/metrics';
 import listUserPreferences from 'api/v1/user/preferences/list';
 import updateUserPreferenceAPI from 'api/v1/user/preferences/name/update';
 import { PersistedAnnouncementBanner } from 'components/AnnouncementBanner';
@@ -16,11 +14,11 @@ import { ORG_PREFERENCES } from 'constants/orgPreferences';
 import { initialQueriesMap, PANEL_TYPES } from 'constants/queryBuilder';
 import { REACT_QUERY_KEY } from 'constants/reactQueryKeys';
 import ROUTES from 'constants/routes';
+import { getMetricsListQuery } from 'container/MetricsExplorer/Summary/utils';
 import { IS_SERVICE_ACCOUNTS_ENABLED } from 'container/ServiceAccountsSettings/config';
-import { DEFAULT_TIME_RANGE } from 'container/TopNav/DateTimeSelectionV2/constants';
+import { useGetMetricsList } from 'hooks/metricsExplorer/useGetMetricsList';
 import { useGetQueryRange } from 'hooks/queryBuilder/useGetQueryRange';
 import { useIsDarkMode } from 'hooks/useDarkMode';
-import { useSafeNavigate } from 'hooks/useSafeNavigate';
 import history from 'lib/history';
 import cloneDeep from 'lodash-es/cloneDeep';
 import { AnimatePresence } from 'motion/react';
@@ -31,7 +29,6 @@ import { UserPreference } from 'types/api/preferences/preference';
 import { DataSource } from 'types/common/queryBuilder';
 import { USER_ROLES } from 'types/roles';
 import { isIngestionActive } from 'utils/app';
-import { isModifierKeyPressed } from 'utils/app';
 import { popupContainer } from 'utils/selectPopupContainer';
 
 import AlertRules from './AlertRules/AlertRules';
@@ -50,7 +47,6 @@ const homeInterval = 30 * 60 * 1000;
 // eslint-disable-next-line sonarjs/cognitive-complexity
 export default function Home(): JSX.Element {
 	const { user } = useAppContext();
-	const { safeNavigate } = useSafeNavigate();
 	const isDarkMode = useIsDarkMode();
 
 	const [startTime, setStartTime] = useState<number | null>(null);
@@ -81,7 +77,7 @@ export default function Home(): JSX.Element {
 			query: initialQueriesMap[DataSource.LOGS],
 			graphType: PANEL_TYPES.VALUE,
 			selectedTime: 'GLOBAL_TIME',
-			globalSelectedInterval: DEFAULT_TIME_RANGE,
+			globalSelectedInterval: '30m',
 			params: {
 				dataSource: DataSource.LOGS,
 			},
@@ -91,7 +87,7 @@ export default function Home(): JSX.Element {
 		{
 			queryKey: [
 				REACT_QUERY_KEY.GET_QUERY_RANGE,
-				DEFAULT_TIME_RANGE,
+				'30m',
 				endTime || Date.now(),
 				startTime || Date.now(),
 				initialQueriesMap[DataSource.LOGS],
@@ -106,7 +102,7 @@ export default function Home(): JSX.Element {
 			query: initialQueriesMap[DataSource.TRACES],
 			graphType: PANEL_TYPES.VALUE,
 			selectedTime: 'GLOBAL_TIME',
-			globalSelectedInterval: DEFAULT_TIME_RANGE,
+			globalSelectedInterval: '30m',
 			params: {
 				dataSource: DataSource.TRACES,
 			},
@@ -116,7 +112,7 @@ export default function Home(): JSX.Element {
 		{
 			queryKey: [
 				REACT_QUERY_KEY.GET_QUERY_RANGE,
-				DEFAULT_TIME_RANGE,
+				'30m',
 				endTime || Date.now(),
 				startTime || Date.now(),
 				initialQueriesMap[DataSource.TRACES],
@@ -126,7 +122,38 @@ export default function Home(): JSX.Element {
 	);
 
 	// Detect Metrics
-	const { data: metricsOnboardingData } = useGetMetricsOnboardingStatus();
+	const query = useMemo(() => {
+		const baseQuery = getMetricsListQuery();
+
+		let queryStartTime = startTime;
+		let queryEndTime = endTime;
+
+		if (!startTime || !endTime) {
+			const now = new Date();
+			const startTime = new Date(now.getTime() - homeInterval);
+			const endTime = now;
+
+			queryStartTime = startTime.getTime();
+			queryEndTime = endTime.getTime();
+		}
+
+		return {
+			...baseQuery,
+			limit: 10,
+			offset: 0,
+			filters: {
+				items: [],
+				op: 'AND',
+			},
+			start: queryStartTime,
+			end: queryEndTime,
+		};
+	}, [startTime, endTime]);
+
+	const { data: metricsData } = useGetMetricsList(query, {
+		enabled: !!query,
+		queryKey: ['metricsList', query],
+	});
 
 	const [isLogsIngestionActive, setIsLogsIngestionActive] = useState(false);
 	const [isTracesIngestionActive, setIsTracesIngestionActive] = useState(false);
@@ -252,12 +279,14 @@ export default function Home(): JSX.Element {
 	}, [tracesData, handleUpdateChecklistDoneItem]);
 
 	useEffect(() => {
-		if (metricsOnboardingData?.data?.hasMetrics) {
+		const metricsDataTotal = metricsData?.payload?.data?.total ?? 0;
+
+		if (metricsDataTotal > 0) {
 			setIsMetricsIngestionActive(true);
 			handleUpdateChecklistDoneItem('ADD_DATA_SOURCE');
 			handleUpdateChecklistDoneItem('SEND_METRICS');
 		}
-	}, [metricsOnboardingData, handleUpdateChecklistDoneItem]);
+	}, [metricsData, handleUpdateChecklistDoneItem]);
 
 	useEffect(() => {
 		logEvent('Homepage: Visited', {});
@@ -364,14 +393,11 @@ export default function Home(): JSX.Element {
 											role="button"
 											tabIndex={0}
 											className="active-ingestion-card-actions"
-											onClick={(e: React.MouseEvent): void => {
-												// eslint-disable-next-line sonarjs/no-duplicate-string
+											onClick={(): void => {
 												logEvent('Homepage: Ingestion Active Explore clicked', {
 													source: 'Logs',
 												});
-												safeNavigate(ROUTES.LOGS_EXPLORER, {
-													newTab: isModifierKeyPressed(e),
-												});
+												history.push(ROUTES.LOGS_EXPLORER);
 											}}
 											onKeyDown={(e): void => {
 												if (e.key === 'Enter') {
@@ -408,13 +434,11 @@ export default function Home(): JSX.Element {
 											className="active-ingestion-card-actions"
 											role="button"
 											tabIndex={0}
-											onClick={(e: React.MouseEvent): void => {
+											onClick={(): void => {
 												logEvent('Homepage: Ingestion Active Explore clicked', {
 													source: 'Traces',
 												});
-												safeNavigate(ROUTES.TRACES_EXPLORER, {
-													newTab: isModifierKeyPressed(e),
-												});
+												history.push(ROUTES.TRACES_EXPLORER);
 											}}
 											onKeyDown={(e): void => {
 												if (e.key === 'Enter') {
@@ -451,13 +475,11 @@ export default function Home(): JSX.Element {
 											className="active-ingestion-card-actions"
 											role="button"
 											tabIndex={0}
-											onClick={(e: React.MouseEvent): void => {
+											onClick={(): void => {
 												logEvent('Homepage: Ingestion Active Explore clicked', {
 													source: 'Metrics',
 												});
-												safeNavigate(ROUTES.METRICS_EXPLORER, {
-													newTab: isModifierKeyPressed(e),
-												});
+												history.push(ROUTES.METRICS_EXPLORER);
 											}}
 											onKeyDown={(e): void => {
 												if (e.key === 'Enter') {
@@ -507,13 +529,11 @@ export default function Home(): JSX.Element {
 												type="default"
 												className="periscope-btn secondary"
 												icon={<Wrench size={14} />}
-												onClick={(e: React.MouseEvent): void => {
+												onClick={(): void => {
 													logEvent('Homepage: Explore clicked', {
 														source: 'Logs',
 													});
-													safeNavigate(ROUTES.LOGS_EXPLORER, {
-														newTab: isModifierKeyPressed(e),
-													});
+													history.push(ROUTES.LOGS_EXPLORER);
 												}}
 											>
 												Open Logs Explorer
@@ -523,13 +543,11 @@ export default function Home(): JSX.Element {
 												type="default"
 												className="periscope-btn secondary"
 												icon={<Wrench size={14} />}
-												onClick={(e: React.MouseEvent): void => {
+												onClick={(): void => {
 													logEvent('Homepage: Explore clicked', {
 														source: 'Traces',
 													});
-													safeNavigate(ROUTES.TRACES_EXPLORER, {
-														newTab: isModifierKeyPressed(e),
-													});
+													history.push(ROUTES.TRACES_EXPLORER);
 												}}
 											>
 												Open Traces Explorer
@@ -539,13 +557,11 @@ export default function Home(): JSX.Element {
 												type="default"
 												className="periscope-btn secondary"
 												icon={<Wrench size={14} />}
-												onClick={(e: React.MouseEvent): void => {
+												onClick={(): void => {
 													logEvent('Homepage: Explore clicked', {
 														source: 'Metrics',
 													});
-													safeNavigate(ROUTES.METRICS_EXPLORER_EXPLORER, {
-														newTab: isModifierKeyPressed(e),
-													});
+													history.push(ROUTES.METRICS_EXPLORER_EXPLORER);
 												}}
 											>
 												Open Metrics Explorer
@@ -582,13 +598,11 @@ export default function Home(): JSX.Element {
 												type="default"
 												className="periscope-btn secondary"
 												icon={<Plus size={14} />}
-												onClick={(e: React.MouseEvent): void => {
+												onClick={(): void => {
 													logEvent('Homepage: Explore clicked', {
 														source: 'Dashboards',
 													});
-													safeNavigate(ROUTES.ALL_DASHBOARD, {
-														newTab: isModifierKeyPressed(e),
-													});
+													history.push(ROUTES.ALL_DASHBOARD);
 												}}
 											>
 												Create dashboard
@@ -626,13 +640,11 @@ export default function Home(): JSX.Element {
 												type="default"
 												className="periscope-btn secondary"
 												icon={<Plus size={14} />}
-												onClick={(e: React.MouseEvent): void => {
+												onClick={(): void => {
 													logEvent('Homepage: Explore clicked', {
 														source: 'Alerts',
 													});
-													safeNavigate(ROUTES.ALERTS_NEW, {
-														newTab: isModifierKeyPressed(e),
-													});
+													history.push(ROUTES.ALERTS_NEW);
 												}}
 											>
 												Create an alert

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

@@ -1,4 +1,4 @@
-import React, { memo, useCallback, useEffect, useMemo, useState } from 'react';
+import { memo, useCallback, useEffect, useMemo, useState } from 'react';
 import { QueryKey } from 'react-query';
 // eslint-disable-next-line no-restricted-imports
 import { useSelector } from 'react-redux';
@@ -30,7 +30,6 @@ import { ServicesList } from 'types/api/metrics/getService';
 import { GlobalReducer } from 'types/reducer/globalTime';
 import { Tags } from 'types/reducer/trace';
 import { USER_ROLES } from 'types/roles';
-import { isModifierKeyPressed } from 'utils/app';
 
 import { FeatureKeys } from '../../../constants/features';
 import { DOCS_LINKS } from '../constants';
@@ -118,7 +117,7 @@ const ServicesListTable = memo(
 		onRowClick,
 	}: {
 		services: ServicesList[];
-		onRowClick: (record: ServicesList, event: React.MouseEvent) => void;
+		onRowClick: (record: ServicesList) => void;
 	}): JSX.Element => (
 		<div className="services-list-container home-data-item-container metrics-services-list">
 			<div className="services-list">
@@ -127,8 +126,8 @@ const ServicesListTable = memo(
 					dataSource={services}
 					pagination={false}
 					className="services-table"
-					onRow={(record: ServicesList): Record<string, unknown> => ({
-						onClick: (event: React.MouseEvent): void => onRowClick(record, event),
+					onRow={(record): { onClick: () => void } => ({
+						onClick: (): void => onRowClick(record),
 					})}
 				/>
 			</div>
@@ -286,13 +285,11 @@ function ServiceMetrics({
 	}, [onUpdateChecklistDoneItem, loadingUserPreferences, servicesExist]);
 
 	const handleRowClick = useCallback(
-		(record: ServicesList, event: React.MouseEvent) => {
+		(record: ServicesList) => {
 			logEvent('Homepage: Service clicked', {
 				serviceName: record.serviceName,
 			});
-			safeNavigate(`${ROUTES.APPLICATION}/${record.serviceName}`, {
-				newTab: isModifierKeyPressed(event),
-			});
+			safeNavigate(`${ROUTES.APPLICATION}/${record.serviceName}`);
 		},
 		[safeNavigate],
 	);

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

@@ -1,6 +1,6 @@
-import React, { useCallback, useEffect, useMemo, useState } from 'react';
+import { useCallback, useEffect, useMemo, useState } from 'react';
 // eslint-disable-next-line no-restricted-imports
-import { useSelector } from 'react-redux'; // old code, TODO: fix this correctly
+import { useSelector } from 'react-redux';
 import { Link } from 'react-router-dom';
 import { Button, Select, Skeleton, Table } from 'antd';
 import logEvent from 'api/common/logEvent';
@@ -16,7 +16,6 @@ import { LicensePlatform } from 'types/api/licensesV3/getActive';
 import { ServicesList } from 'types/api/metrics/getService';
 import { GlobalReducer } from 'types/reducer/globalTime';
 import { USER_ROLES } from 'types/roles';
-import { isModifierKeyPressed } from 'utils/app';
 
 import { DOCS_LINKS } from '../constants';
 import { columns, TIME_PICKER_OPTIONS } from './constants';
@@ -174,15 +173,13 @@ export default function ServiceTraces({
 						dataSource={top5Services}
 						pagination={false}
 						className="services-table"
-						onRow={(record: ServicesList): Record<string, unknown> => ({
-							onClick: (event: React.MouseEvent): void => {
+						onRow={(record): { onClick: () => void } => ({
+							onClick: (): void => {
 								logEvent('Homepage: Service clicked', {
 									serviceName: record.serviceName,
 								});
 
-								safeNavigate(`${ROUTES.APPLICATION}/${record.serviceName}`, {
-									newTab: isModifierKeyPressed(event),
-								});
+								safeNavigate(`${ROUTES.APPLICATION}/${record.serviceName}`);
 							},
 						})}
 					/>

frontend/src/container/InfraMonitoringHosts/HostsList.tsx

@@ -1,6 +1,7 @@
 import { useCallback, useEffect, useMemo, useState } from 'react';
 // eslint-disable-next-line no-restricted-imports
 import { useSelector } from 'react-redux';
+import { useSearchParams } from 'react-router-dom-v5-compat';
 import { VerticalAlignTopOutlined } from '@ant-design/icons';
 import { Button, Tooltip, Typography } from 'antd';
 import logEvent from 'api/common/logEvent';
@@ -10,16 +11,15 @@ import QuickFilters from 'components/QuickFilters/QuickFilters';
 import { QuickFiltersSource } from 'components/QuickFilters/types';
 import { InfraMonitoringEvents } from 'constants/events';
 import {
-	useInfraMonitoringCurrentPage,
-	useInfraMonitoringFiltersHosts,
-	useInfraMonitoringOrderByHosts,
-} from 'container/InfraMonitoringK8s/hooks';
+	getFiltersFromParams,
+	getOrderByFromParams,
+} from 'container/InfraMonitoringK8s/commonUtils';
+import { INFRA_MONITORING_K8S_PARAMS_KEYS } from 'container/InfraMonitoringK8s/constants';
 import { usePageSize } from 'container/InfraMonitoringK8s/utils';
 import { useGetHostList } from 'hooks/infraMonitoring/useGetHostList';
 import { useQueryBuilder } from 'hooks/queryBuilder/useQueryBuilder';
 import { useQueryOperations } from 'hooks/queryBuilder/useQueryBuilderOperations';
 import { Filter } from 'lucide-react';
-import { parseAsString, useQueryState } from 'nuqs';
 import { AppState } from 'store/reducers';
 import { IBuilderQuery, Query } from 'types/api/queryBuilder/queryBuilderData';
 import { GlobalReducer } from 'types/reducer/globalTime';
@@ -35,29 +35,50 @@ function HostsList(): JSX.Element {
 	const { maxTime, minTime } = useSelector<AppState, GlobalReducer>(
 		(state) => state.globalTime,
 	);
+	const [searchParams, setSearchParams] = useSearchParams();
 
-	const [currentPage, setCurrentPage] = useInfraMonitoringCurrentPage();
-	const [filters, setFilters] = useInfraMonitoringFiltersHosts();
-	const [orderBy, setOrderBy] = useInfraMonitoringOrderByHosts();
-
+	const [currentPage, setCurrentPage] = useState(1);
+	const [filters, setFilters] = useState<IBuilderQuery['filters']>(() => {
+		const filters = getFiltersFromParams(
+			searchParams,
+			INFRA_MONITORING_K8S_PARAMS_KEYS.FILTERS,
+		);
+		if (!filters) {
+			return {
+				items: [],
+				op: 'and',
+			};
+		}
+		return filters;
+	});
 	const [showFilters, setShowFilters] = useState<boolean>(true);
 
-	const [selectedHostName, setSelectedHostName] = useQueryState(
-		'hostName',
-		parseAsString.withDefault(''),
-	);
+	const [orderBy, setOrderBy] = useState<{
+		columnName: string;
+		order: 'asc' | 'desc';
+	} | null>(() => getOrderByFromParams(searchParams));
 
 	const handleOrderByChange = (
-		orderByValue: {
+		orderBy: {
 			columnName: string;
 			order: 'asc' | 'desc';
 		} | null,
 	): void => {
-		setOrderBy(orderByValue);
+		setOrderBy(orderBy);
+		setSearchParams({
+			...Object.fromEntries(searchParams.entries()),
+			[INFRA_MONITORING_K8S_PARAMS_KEYS.ORDER_BY]: JSON.stringify(orderBy),
+		});
 	};
 
+	const [selectedHostName, setSelectedHostName] = useState<string | null>(() => {
+		const hostName = searchParams.get('hostName');
+		return hostName || null;
+	});
+
 	const handleHostClick = (hostName: string): void => {
 		setSelectedHostName(hostName);
+		setSearchParams({ ...searchParams, hostName });
 	};
 
 	const { pageSize, setPageSize } = usePageSize('hosts');
@@ -133,8 +154,12 @@ function HostsList(): JSX.Element {
 	const handleFiltersChange = useCallback(
 		(value: IBuilderQuery['filters']): void => {
 			const isNewFilterAdded = value?.items?.length !== filters?.items?.length;
-			setFilters(value ?? null);
+			setFilters(value);
 			handleChangeQueryData('filters', value);
+			setSearchParams({
+				...Object.fromEntries(searchParams.entries()),
+				[INFRA_MONITORING_K8S_PARAMS_KEYS.FILTERS]: JSON.stringify(value),
+			});
 			if (isNewFilterAdded) {
 				setCurrentPage(1);
 
@@ -146,7 +171,8 @@ function HostsList(): JSX.Element {
 				}
 			}
 		},
-		[filters, setFilters, setCurrentPage, handleChangeQueryData],
+		// eslint-disable-next-line react-hooks/exhaustive-deps
+		[filters],
 	);
 
 	useEffect(() => {
@@ -158,7 +184,7 @@ function HostsList(): JSX.Element {
 	}, [data?.payload?.data?.total]);
 
 	const selectedHostData = useMemo(() => {
-		if (!selectedHostName?.trim()) {
+		if (!selectedHostName) {
 			return null;
 		}
 		return (
@@ -234,7 +260,6 @@ function HostsList(): JSX.Element {
 						pageSize={pageSize}
 						setPageSize={setPageSize}
 						setOrderBy={handleOrderByChange}
-						orderBy={orderBy}
 					/>
 				</div>
 			</div>

frontend/src/container/InfraMonitoringHosts/HostsListControls.tsx

@@ -14,7 +14,7 @@ function HostsListControls({
 	showAutoRefresh,
 }: {
 	handleFiltersChange: (value: IBuilderQuery['filters']) => void;
-	filters: IBuilderQuery['filters'] | null;
+	filters: IBuilderQuery['filters'];
 	showAutoRefresh: boolean;
 }): JSX.Element {
 	const currentQuery = initialQueriesMap[DataSource.METRICS];

frontend/src/container/InfraMonitoringHosts/HostsListTable.tsx

@@ -1,4 +1,4 @@
-import React, { useCallback, useMemo, useState } from 'react';
+import React, { useCallback, useMemo } from 'react';
 import { LoadingOutlined } from '@ant-design/icons';
 import {
 	Skeleton,
@@ -11,8 +11,6 @@ import {
 import type { SorterResult } from 'antd/es/table/interface';
 import logEvent from 'api/common/logEvent';
 import { InfraMonitoringEvents } from 'constants/events';
-import { isModifierKeyPressed } from 'utils/app';
-import { openInNewTab } from 'utils/navigation';
 
 import HostsEmptyOrIncorrectMetrics from './HostsEmptyOrIncorrectMetrics';
 import {
@@ -116,12 +114,8 @@ export default function HostsListTable({
 	pageSize,
 	setOrderBy,
 	setPageSize,
-	orderBy,
 }: HostsListTableProps): JSX.Element {
-	const [defaultOrderBy] = useState(orderBy);
-	const columns = useMemo(() => getHostsListColumns(defaultOrderBy), [
-		defaultOrderBy,
-	]);
+	const columns = useMemo(() => getHostsListColumns(), []);
 
 	const sentAnyHostMetricsData = useMemo(
 		() => data?.payload?.data?.sentAnyHostMetricsData || false,
@@ -168,16 +162,7 @@ export default function HostsListTable({
 		[],
 	);
 
-	const handleRowClick = (
-		record: HostRowData,
-		event: React.MouseEvent,
-	): void => {
-		if (isModifierKeyPressed(event)) {
-			const params = new URLSearchParams(window.location.search);
-			params.set('hostName', record.hostName);
-			openInNewTab(`${window.location.pathname}?${params.toString()}`);
-			return;
-		}
+	const handleRowClick = (record: HostRowData): void => {
 		onHostClick(record.hostName);
 		logEvent(InfraMonitoringEvents.ItemClicked, {
 			entity: InfraMonitoringEvents.HostEntity,
@@ -250,8 +235,8 @@ export default function HostsListTable({
 				(record as HostRowData & { key: string }).key ?? record.hostName
 			}
 			onChange={handleTableChange}
-			onRow={(record: HostRowData): Record<string, unknown> => ({
-				onClick: (event: React.MouseEvent): void => handleRowClick(record, event),
+			onRow={(record): { onClick: () => void; className: string } => ({
+				onClick: (): void => handleRowClick(record),
 				className: 'clickable-row',
 			})}
 		/>

frontend/src/container/InfraMonitoringHosts/__tests__/HostsList.test.tsx

@@ -4,7 +4,6 @@ import { Provider } from 'react-redux';
 import { MemoryRouter } from 'react-router-dom';
 import { render } from '@testing-library/react';
 import * as useGetHostListHooks from 'hooks/infraMonitoring/useGetHostList';
-import { withNuqsTestingAdapter } from 'nuqs/adapters/testing';
 import * as appContextHooks from 'providers/App/App';
 import * as timezoneHooks from 'providers/Timezone';
 import store from 'store';
@@ -20,16 +19,6 @@ jest.mock('lib/getMinMax', () => ({
 		isValidShortHandDateTimeFormat: jest.fn().mockReturnValue(true),
 	})),
 }));
-jest.mock('container/TopNav/DateTimeSelectionV2', () => ({
-	__esModule: true,
-	default: (): JSX.Element => (
-		<div data-testid="date-time-selection">Date Time</div>
-	),
-}));
-jest.mock('components/HostMetricsDetail', () => ({
-	__esModule: true,
-	default: (): null => null,
-}));
 jest.mock('components/CustomTimePicker/CustomTimePicker', () => ({
 	__esModule: true,
 	default: ({ onSelect, selectedTime, selectedValue }: any): JSX.Element => (
@@ -66,6 +55,19 @@ jest.mock('react-router-dom', () => {
 		}),
 	};
 });
+jest.mock('react-router-dom-v5-compat', () => {
+	const actual = jest.requireActual('react-router-dom-v5-compat');
+	return {
+		...actual,
+		useSearchParams: jest
+			.fn()
+			.mockReturnValue([
+				{ get: jest.fn(), entries: jest.fn().mockReturnValue([]) },
+				jest.fn(),
+			]),
+		useNavigationType: (): any => 'PUSH',
+	};
+});
 jest.mock('hooks/useSafeNavigate', () => ({
 	useSafeNavigate: (): any => ({
 		safeNavigate: jest.fn(),
@@ -125,35 +127,29 @@ jest.spyOn(appContextHooks, 'useAppContext').mockReturnValue({
 	},
 } as any);
 
-const Wrapper = withNuqsTestingAdapter({ searchParams: {} });
-
 describe('HostsList', () => {
 	it('renders hosts list table', () => {
 		const { container } = render(
-			<Wrapper>
-				<QueryClientProvider client={queryClient}>
-					<MemoryRouter>
-						<Provider store={store}>
-							<HostsList />
-						</Provider>
-					</MemoryRouter>
-				</QueryClientProvider>
-			</Wrapper>,
+			<QueryClientProvider client={queryClient}>
+				<MemoryRouter>
+					<Provider store={store}>
+						<HostsList />
+					</Provider>
+				</MemoryRouter>
+			</QueryClientProvider>,
 		);
 		expect(container.querySelector('.hosts-list-table')).toBeInTheDocument();
 	});
 
 	it('renders filters', () => {
 		const { container } = render(
-			<Wrapper>
-				<QueryClientProvider client={queryClient}>
-					<MemoryRouter>
-						<Provider store={store}>
-							<HostsList />
-						</Provider>
-					</MemoryRouter>
-				</QueryClientProvider>
-			</Wrapper>,
+			<QueryClientProvider client={queryClient}>
+				<MemoryRouter>
+					<Provider store={store}>
+						<HostsList />
+					</Provider>
+				</MemoryRouter>
+			</QueryClientProvider>,
 		);
 		expect(container.querySelector('.filters')).toBeInTheDocument();
 	});

frontend/src/container/InfraMonitoringHosts/__tests__/HostsListTable.test.tsx

@@ -72,7 +72,6 @@ describe('HostsListTable', () => {
 		pageSize: 10,
 		setOrderBy: mockSetOrderBy,
 		setPageSize: mockSetPageSize,
-		orderBy: null,
 	};
 
 	it('renders loading state if isLoading is true and tableData is empty', () => {

frontend/src/container/InfraMonitoringHosts/utils.tsx

@@ -3,7 +3,6 @@ import { InfoCircleOutlined } from '@ant-design/icons';
 import { Color } from '@signozhq/design-tokens';
 import { Progress, TabsProps, Tag, Tooltip, Typography } from 'antd';
 import { TableColumnType as ColumnType } from 'antd';
-import { SortOrder } from 'antd/lib/table/interface';
 import {
 	HostData,
 	HostListPayload,
@@ -21,7 +20,6 @@ import { DataTypes } from 'types/api/queryBuilder/queryAutocompleteResponse';
 import { TagFilter } from 'types/api/queryBuilder/queryBuilderData';
 import { DataSource } from 'types/common/queryBuilder';
 
-import { OrderBySchemaType } from '../InfraMonitoringK8s/schemas';
 import HostsList from './HostsList';
 
 import './InfraMonitoring.styles.scss';
@@ -107,7 +105,6 @@ export interface HostsListTableProps {
 		orderBy: { columnName: string; order: 'asc' | 'desc' } | null,
 	) => void;
 	setPageSize: (pageSize: number) => void;
-	orderBy: OrderBySchemaType;
 }
 
 export interface EmptyOrLoadingViewProps {
@@ -130,17 +127,6 @@ export const getHostListsQuery = (): HostListPayload => ({
 	orderBy: { columnName: 'cpu', order: 'desc' },
 });
 
-function mapOrderByToSortOrder(
-	column: string,
-	orderBy: OrderBySchemaType,
-): SortOrder | undefined {
-	return orderBy?.columnName === column
-		? orderBy?.order === 'asc'
-			? 'ascend'
-			: 'descend'
-		: undefined;
-}
-
 export const getTabsItems = (): TabsProps['items'] => [
 	{
 		label: <TabLabel label="List View" isDisabled={false} tooltipText="" />,
@@ -149,9 +135,7 @@ export const getTabsItems = (): TabsProps['items'] => [
 	},
 ];
 
-export const getHostsListColumns = (
-	orderBy: OrderBySchemaType,
-): ColumnType<HostRowData>[] => [
+export const getHostsListColumns = (): ColumnType<HostRowData>[] => [
 	{
 		title: <div className="hostname-column-header">Hostname</div>,
 		dataIndex: 'hostName',
@@ -180,7 +164,6 @@ export const getHostsListColumns = (
 		key: 'cpu',
 		width: 100,
 		sorter: true,
-		defaultSortOrder: mapOrderByToSortOrder('cpu', orderBy),
 		align: 'right',
 	},
 	{
@@ -196,7 +179,6 @@ export const getHostsListColumns = (
 		key: 'memory',
 		width: 100,
 		sorter: true,
-		defaultSortOrder: mapOrderByToSortOrder('memory', orderBy),
 		align: 'right',
 	},
 	{
@@ -205,7 +187,6 @@ export const getHostsListColumns = (
 		key: 'wait',
 		width: 100,
 		sorter: true,
-		defaultSortOrder: mapOrderByToSortOrder('wait', orderBy),
 		align: 'right',
 	},
 	{
@@ -214,7 +195,6 @@ export const getHostsListColumns = (
 		key: 'load15',
 		width: 100,
 		sorter: true,
-		defaultSortOrder: mapOrderByToSortOrder('load15', orderBy),
 		align: 'right',
 	},
 ];

frontend/src/container/InfraMonitoringK8s/Clusters/ClusterDetails/ClusterDetails.tsx

@@ -1,6 +1,7 @@
 import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
 // eslint-disable-next-line no-restricted-imports
 import { useSelector } from 'react-redux';
+import { useSearchParams } from 'react-router-dom-v5-compat';
 import { Color, Spacing } from '@signozhq/design-tokens';
 import { Button, Divider, Drawer, Radio, Tooltip, Typography } from 'antd';
 import type { RadioChangeEvent } from 'antd/lib';
@@ -14,15 +15,15 @@ import {
 	initialQueryState,
 } from 'constants/queryBuilder';
 import ROUTES from 'constants/routes';
-import { filterDuplicateFilters } from 'container/InfraMonitoringK8s/commonUtils';
-import { K8sCategory } from 'container/InfraMonitoringK8s/constants';
-import { QUERY_KEYS } from 'container/InfraMonitoringK8s/EntityDetailsUtils/utils';
 import {
-	useInfraMonitoringEventsFilters,
-	useInfraMonitoringLogFilters,
-	useInfraMonitoringTracesFilters,
-	useInfraMonitoringView,
-} from 'container/InfraMonitoringK8s/hooks';
+	filterDuplicateFilters,
+	getFiltersFromParams,
+} from 'container/InfraMonitoringK8s/commonUtils';
+import {
+	INFRA_MONITORING_K8S_PARAMS_KEYS,
+	K8sCategory,
+} from 'container/InfraMonitoringK8s/constants';
+import { QUERY_KEYS } from 'container/InfraMonitoringK8s/EntityDetailsUtils/utils';
 import {
 	CustomTimeType,
 	Time,
@@ -92,21 +93,23 @@ function ClusterDetails({
 			: (selectedTime as Time),
 	);
 
-	const [selectedView, setSelectedView] = useInfraMonitoringView();
-	const [logFiltersParam, setLogFiltersParam] = useInfraMonitoringLogFilters();
-	const [
-		tracesFiltersParam,
-		setTracesFiltersParam,
-	] = useInfraMonitoringTracesFilters();
-	const [
-		eventsFiltersParam,
-		setEventsFiltersParam,
-	] = useInfraMonitoringEventsFilters();
+	const [searchParams, setSearchParams] = useSearchParams();
+	const [selectedView, setSelectedView] = useState<VIEWS>(() => {
+		const view = searchParams.get(INFRA_MONITORING_K8S_PARAMS_KEYS.VIEW);
+		if (view) {
+			return view as VIEWS;
+		}
+		return VIEWS.METRICS;
+	});
 	const isDarkMode = useIsDarkMode();
 
 	const initialFilters = useMemo(() => {
-		const filters =
-			selectedView === VIEW_TYPES.LOGS ? logFiltersParam : tracesFiltersParam;
+		const urlView = searchParams.get(INFRA_MONITORING_K8S_PARAMS_KEYS.VIEW);
+		const queryKey =
+			urlView === VIEW_TYPES.LOGS
+				? INFRA_MONITORING_K8S_PARAMS_KEYS.LOG_FILTERS
+				: INFRA_MONITORING_K8S_PARAMS_KEYS.TRACES_FILTERS;
+		const filters = getFiltersFromParams(searchParams, queryKey);
 		if (filters) {
 			return filters;
 		}
@@ -126,16 +129,15 @@ function ClusterDetails({
 				},
 			],
 		};
-	}, [
-		cluster?.meta.k8s_cluster_name,
-		selectedView,
-		logFiltersParam,
-		tracesFiltersParam,
-	]);
+	}, [cluster?.meta.k8s_cluster_name, searchParams]);
 
 	const initialEventsFilters = useMemo(() => {
-		if (eventsFiltersParam) {
-			return eventsFiltersParam;
+		const filters = getFiltersFromParams(
+			searchParams,
+			INFRA_MONITORING_K8S_PARAMS_KEYS.EVENTS_FILTERS,
+		);
+		if (filters) {
+			return filters;
 		}
 		return {
 			op: 'AND',
@@ -164,7 +166,7 @@ function ClusterDetails({
 				},
 			],
 		};
-	}, [cluster?.meta.k8s_cluster_name, eventsFiltersParam]);
+	}, [cluster?.meta.k8s_cluster_name, searchParams]);
 
 	const [logsAndTracesFilters, setLogsAndTracesFilters] = useState<
 		IBuilderQuery['filters']
@@ -205,9 +207,13 @@ function ClusterDetails({
 
 	const handleTabChange = (e: RadioChangeEvent): void => {
 		setSelectedView(e.target.value);
-		setLogFiltersParam(null);
-		setTracesFiltersParam(null);
-		setEventsFiltersParam(null);
+		setSearchParams({
+			...Object.fromEntries(searchParams.entries()),
+			[INFRA_MONITORING_K8S_PARAMS_KEYS.VIEW]: e.target.value,
+			[INFRA_MONITORING_K8S_PARAMS_KEYS.LOG_FILTERS]: JSON.stringify(null),
+			[INFRA_MONITORING_K8S_PARAMS_KEYS.TRACES_FILTERS]: JSON.stringify(null),
+			[INFRA_MONITORING_K8S_PARAMS_KEYS.EVENTS_FILTERS]: JSON.stringify(null),
+		});
 		logEvent(InfraMonitoringEvents.TabChanged, {
 			entity: InfraMonitoringEvents.K8sEntity,
 			page: InfraMonitoringEvents.DetailedPage,
@@ -281,8 +287,13 @@ function ClusterDetails({
 					),
 				};
 
-				setLogFiltersParam(updatedFilters);
-				setSelectedView(view);
+				setSearchParams({
+					...Object.fromEntries(searchParams.entries()),
+					[INFRA_MONITORING_K8S_PARAMS_KEYS.LOG_FILTERS]: JSON.stringify(
+						updatedFilters,
+					),
+					[INFRA_MONITORING_K8S_PARAMS_KEYS.VIEW]: view,
+				});
 
 				return updatedFilters;
 			});
@@ -319,8 +330,13 @@ function ClusterDetails({
 					),
 				};
 
-				setTracesFiltersParam(updatedFilters);
-				setSelectedView(view);
+				setSearchParams({
+					...Object.fromEntries(searchParams.entries()),
+					[INFRA_MONITORING_K8S_PARAMS_KEYS.TRACES_FILTERS]: JSON.stringify(
+						updatedFilters,
+					),
+					[INFRA_MONITORING_K8S_PARAMS_KEYS.VIEW]: view,
+				});
 
 				return updatedFilters;
 			});
@@ -363,8 +379,13 @@ function ClusterDetails({
 					),
 				};
 
-				setEventsFiltersParam(updatedFilters);
-				setSelectedView(view);
+				setSearchParams({
+					...Object.fromEntries(searchParams.entries()),
+					[INFRA_MONITORING_K8S_PARAMS_KEYS.EVENTS_FILTERS]: JSON.stringify(
+						updatedFilters,
+					),
+					[INFRA_MONITORING_K8S_PARAMS_KEYS.VIEW]: view,
+				});
 
 				return updatedFilters;
 			});

frontend/src/container/InfraMonitoringK8s/Clusters/K8sClustersList.tsx

@@ -1,6 +1,7 @@
-import React, { useCallback, useEffect, useMemo, useState } from 'react';
+import { useCallback, useEffect, useMemo, useState } from 'react';
 // eslint-disable-next-line no-restricted-imports
 import { useSelector } from 'react-redux';
+import { useSearchParams } from 'react-router-dom-v5-compat';
 import { LoadingOutlined } from '@ant-design/icons';
 import {
 	Button,
@@ -23,22 +24,15 @@ import { ChevronDown, ChevronRight } from 'lucide-react';
 import { AppState } from 'store/reducers';
 import { IBuilderQuery } from 'types/api/queryBuilder/queryBuilderData';
 import { GlobalReducer } from 'types/reducer/globalTime';
-import { buildAbsolutePath, isModifierKeyPressed } from 'utils/app';
-import { openInNewTab } from 'utils/navigation';
 
 import { FeatureKeys } from '../../../constants/features';
 import { useAppContext } from '../../../providers/App/App';
+import { getOrderByFromParams } from '../commonUtils';
 import {
 	GetK8sEntityToAggregateAttribute,
 	INFRA_MONITORING_K8S_PARAMS_KEYS,
 	K8sCategory,
 } from '../constants';
-import {
-	useInfraMonitoringClusterName,
-	useInfraMonitoringCurrentPage,
-	useInfraMonitoringGroupBy,
-	useInfraMonitoringOrderBy,
-} from '../hooks';
 import K8sHeader from '../K8sHeader';
 import LoadingContainer from '../LoadingContainer';
 import { usePageSize } from '../utils';
@@ -53,7 +47,6 @@ import {
 
 import '../InfraMonitoringK8s.styles.scss';
 import './K8sClustersList.styles.scss';
-
 function K8sClustersList({
 	isFiltersVisible,
 	handleFilterVisibilityChange,
@@ -67,19 +60,55 @@ function K8sClustersList({
 		(state) => state.globalTime,
 	);
 
-	const [currentPage, setCurrentPage] = useInfraMonitoringCurrentPage();
-	const [groupBy, setGroupBy] = useInfraMonitoringGroupBy();
-	const [orderBy, setOrderBy] = useInfraMonitoringOrderBy();
-	const [
-		selectedClusterName,
-		setselectedClusterName,
-	] = useInfraMonitoringClusterName();
+	const [searchParams, setSearchParams] = useSearchParams();
 
+	const [currentPage, setCurrentPage] = useState(() => {
+		const page = searchParams.get(INFRA_MONITORING_K8S_PARAMS_KEYS.CURRENT_PAGE);
+		if (page) {
+			return parseInt(page, 10);
+		}
+		return 1;
+	});
 	const [filtersInitialised, setFiltersInitialised] = useState(false);
 	const [expandedRowKeys, setExpandedRowKeys] = useState<string[]>([]);
 
+	useEffect(() => {
+		setSearchParams({
+			...Object.fromEntries(searchParams.entries()),
+			[INFRA_MONITORING_K8S_PARAMS_KEYS.CURRENT_PAGE]: currentPage.toString(),
+		});
+		// eslint-disable-next-line react-hooks/exhaustive-deps
+	}, [currentPage]);
+
+	const [orderBy, setOrderBy] = useState<{
+		columnName: string;
+		order: 'asc' | 'desc';
+	} | null>(() => getOrderByFromParams(searchParams, false));
+
+	const [selectedClusterName, setselectedClusterName] = useState<string | null>(
+		() => {
+			const clusterName = searchParams.get(
+				INFRA_MONITORING_K8S_PARAMS_KEYS.CLUSTER_NAME,
+			);
+			if (clusterName) {
+				return clusterName;
+			}
+			return null;
+		},
+	);
+
 	const { pageSize, setPageSize } = usePageSize(K8sCategory.CLUSTERS);
 
+	const [groupBy, setGroupBy] = useState<IBuilderQuery['groupBy']>(() => {
+		const groupBy = searchParams.get(INFRA_MONITORING_K8S_PARAMS_KEYS.GROUP_BY);
+		if (groupBy) {
+			const decoded = decodeURIComponent(groupBy);
+			const parsed = JSON.parse(decoded);
+			return parsed as IBuilderQuery['groupBy'];
+		}
+		return [];
+	});
+
 	const [
 		selectedRowData,
 		setSelectedRowData,
@@ -105,7 +134,7 @@ function K8sClustersList({
 		if (quickFiltersLastUpdated !== -1) {
 			setCurrentPage(1);
 		}
-	}, [quickFiltersLastUpdated, setCurrentPage]);
+	}, [quickFiltersLastUpdated]);
 
 	const { featureFlags } = useAppContext();
 	const dotMetricsEnabled =
@@ -158,28 +187,25 @@ function K8sClustersList({
 			filters,
 			start: Math.floor(minTime / 1000000),
 			end: Math.floor(maxTime / 1000000),
-			orderBy: orderBy || baseQuery.orderBy,
+			orderBy,
 		};
 		// eslint-disable-next-line react-hooks/exhaustive-deps
 	}, [minTime, maxTime, orderBy, selectedRowData, groupBy]);
 
 	const groupedByRowDataQueryKey = useMemo(() => {
-		// be careful with what you serialize from selectedRowData
-		// since it's react node, it could contain circular references
-		const selectedRowDataKey = JSON.stringify(selectedRowData?.groupedByMeta);
 		if (selectedClusterName) {
 			return [
 				'clusterList',
 				JSON.stringify(queryFilters),
 				JSON.stringify(orderBy),
-				selectedRowDataKey,
+				JSON.stringify(selectedRowData),
 			];
 		}
 		return [
 			'clusterList',
 			JSON.stringify(queryFilters),
 			JSON.stringify(orderBy),
-			selectedRowDataKey,
+			JSON.stringify(selectedRowData),
 			String(minTime),
 			String(maxTime),
 		];
@@ -238,7 +264,7 @@ function K8sClustersList({
 			filters: queryFilters,
 			start: Math.floor(minTime / 1000000),
 			end: Math.floor(maxTime / 1000000),
-			orderBy: orderBy || baseQuery.orderBy,
+			orderBy,
 		};
 		if (groupBy.length > 0) {
 			queryPayload.groupBy = groupBy;
@@ -346,15 +372,26 @@ function K8sClustersList({
 			}
 
 			if ('field' in sorter && sorter.order) {
-				setOrderBy({
+				const currentOrderBy = {
 					columnName: sorter.field as string,
 					order: (sorter.order === 'ascend' ? 'asc' : 'desc') as 'asc' | 'desc',
+				};
+				setOrderBy(currentOrderBy);
+				setSearchParams({
+					...Object.fromEntries(searchParams.entries()),
+					[INFRA_MONITORING_K8S_PARAMS_KEYS.ORDER_BY]: JSON.stringify(
+						currentOrderBy,
+					),
 				});
 			} else {
 				setOrderBy(null);
+				setSearchParams({
+					...Object.fromEntries(searchParams.entries()),
+					[INFRA_MONITORING_K8S_PARAMS_KEYS.ORDER_BY]: JSON.stringify(null),
+				});
 			}
 		},
-		[setCurrentPage, setOrderBy],
+		[searchParams, setSearchParams],
 	);
 
 	const { handleChangeQueryData } = useQueryOperations({
@@ -413,31 +450,14 @@ function K8sClustersList({
 		);
 	}, [selectedClusterName, groupBy.length, clustersData, nestedClustersData]);
 
-	const openClusterInNewTab = (record: K8sClustersRowData): void => {
-		const newParams = new URLSearchParams(document.location.search);
-		newParams.set(
-			INFRA_MONITORING_K8S_PARAMS_KEYS.CLUSTER_NAME,
-			record.clusterUID,
-		);
-		openInNewTab(
-			buildAbsolutePath({
-				relativePath: '',
-				urlQueryString: newParams.toString(),
-			}),
-		);
-	};
-
-	const handleRowClick = (
-		record: K8sClustersRowData,
-		event: React.MouseEvent,
-	): void => {
-		if (event && isModifierKeyPressed(event)) {
-			openClusterInNewTab(record);
-			return;
-		}
+	const handleRowClick = (record: K8sClustersRowData): void => {
 		if (groupBy.length === 0) {
 			setSelectedRowData(null);
 			setselectedClusterName(record.clusterUID);
+			setSearchParams({
+				...Object.fromEntries(searchParams.entries()),
+				[INFRA_MONITORING_K8S_PARAMS_KEYS.CLUSTER_NAME]: record.clusterUID,
+			});
 		} else {
 			handleGroupByRowClick(record);
 		}
@@ -466,6 +486,11 @@ function K8sClustersList({
 		setSelectedRowData(null);
 		setGroupBy([]);
 		setOrderBy(null);
+		setSearchParams({
+			...Object.fromEntries(searchParams.entries()),
+			[INFRA_MONITORING_K8S_PARAMS_KEYS.GROUP_BY]: JSON.stringify([]),
+			[INFRA_MONITORING_K8S_PARAMS_KEYS.ORDER_BY]: JSON.stringify(null),
+		});
 	};
 
 	const expandedRowRender = (): JSX.Element => (
@@ -489,14 +514,8 @@ function K8sClustersList({
 							indicator: <Spin indicator={<LoadingOutlined size={14} spin />} />,
 						}}
 						showHeader={false}
-						onRow={(
-							record,
-						): { onClick: (event: React.MouseEvent) => void; className: string } => ({
-							onClick: (event: React.MouseEvent): void => {
-								if (event && isModifierKeyPressed(event)) {
-									openClusterInNewTab(record);
-									return;
-								}
+						onRow={(record): { onClick: () => void; className: string } => ({
+							onClick: (): void => {
 								setselectedClusterName(record.clusterUID);
 							},
 							className: 'expanded-clickable-row',
@@ -562,11 +581,25 @@ function K8sClustersList({
 
 	const handleCloseClusterDetail = (): void => {
 		setselectedClusterName(null);
+		setSearchParams({
+			...Object.fromEntries(
+				Array.from(searchParams.entries()).filter(
+					([key]) =>
+						![
+							INFRA_MONITORING_K8S_PARAMS_KEYS.CLUSTER_NAME,
+							INFRA_MONITORING_K8S_PARAMS_KEYS.VIEW,
+							INFRA_MONITORING_K8S_PARAMS_KEYS.TRACES_FILTERS,
+							INFRA_MONITORING_K8S_PARAMS_KEYS.EVENTS_FILTERS,
+							INFRA_MONITORING_K8S_PARAMS_KEYS.LOG_FILTERS,
+						].includes(key),
+				),
+			),
+		});
 	};
 
 	const handleGroupByChange = useCallback(
 		(value: IBuilderQuery['groupBy']) => {
-			const newGroupBy = [];
+			const groupBy = [];
 
 			for (let index = 0; index < value.length; index++) {
 				const element = (value[index] as unknown) as string;
@@ -576,13 +609,17 @@ function K8sClustersList({
 				);
 
 				if (key) {
-					newGroupBy.push(key);
+					groupBy.push(key);
 				}
 			}
 
 			// Reset pagination on switching to groupBy
 			setCurrentPage(1);
-			setGroupBy(newGroupBy);
+			setGroupBy(groupBy);
+			setSearchParams({
+				...Object.fromEntries(searchParams.entries()),
+				[INFRA_MONITORING_K8S_PARAMS_KEYS.GROUP_BY]: JSON.stringify(groupBy),
+			});
 			setExpandedRowKeys([]);
 			logEvent(InfraMonitoringEvents.GroupByChanged, {
 				entity: InfraMonitoringEvents.K8sEntity,
@@ -590,7 +627,7 @@ function K8sClustersList({
 				category: InfraMonitoringEvents.Cluster,
 			});
 		},
-		[groupByFiltersData, setCurrentPage, setGroupBy],
+		[groupByFiltersData, searchParams, setSearchParams],
 	);
 
 	useEffect(() => {
@@ -669,10 +706,8 @@ function K8sClustersList({
 				}}
 				tableLayout="fixed"
 				onChange={handleTableChange}
-				onRow={(
-					record,
-				): { onClick: (event: React.MouseEvent) => void; className: string } => ({
-					onClick: (event: React.MouseEvent): void => handleRowClick(record, event),
+				onRow={(record): { onClick: () => void; className: string } => ({
+					onClick: (): void => handleRowClick(record),
 					className: 'clickable-row',
 				})}
 				expandable={{

frontend/src/container/InfraMonitoringK8s/Clusters/utils.tsx

@@ -1,5 +1,6 @@
 import { Color } from '@signozhq/design-tokens';
-import { TableColumnType as ColumnType, Tag, Tooltip } from 'antd';
+import { Tag, Tooltip } from 'antd';
+import { TableColumnType as ColumnType } from 'antd';
 import {
 	K8sClustersData,
 	K8sClustersListPayload,

frontend/src/container/InfraMonitoringK8s/DaemonSets/DaemonSetDetails/DaemonSetDetails.tsx

@@ -2,6 +2,7 @@
 import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
 // eslint-disable-next-line no-restricted-imports
 import { useSelector } from 'react-redux';
+import { useSearchParams } from 'react-router-dom-v5-compat';
 import { Color, Spacing } from '@signozhq/design-tokens';
 import { Button, Divider, Drawer, Radio, Tooltip, Typography } from 'antd';
 import type { RadioChangeEvent } from 'antd/lib';
@@ -14,14 +15,11 @@ import {
 	initialQueryState,
 } from 'constants/queryBuilder';
 import ROUTES from 'constants/routes';
-import { filterDuplicateFilters } from 'container/InfraMonitoringK8s/commonUtils';
-import { K8sCategory } from 'container/InfraMonitoringK8s/constants';
+import { getFiltersFromParams } from 'container/InfraMonitoringK8s/commonUtils';
 import {
-	useInfraMonitoringEventsFilters,
-	useInfraMonitoringLogFilters,
-	useInfraMonitoringTracesFilters,
-	useInfraMonitoringView,
-} from 'container/InfraMonitoringK8s/hooks';
+	INFRA_MONITORING_K8S_PARAMS_KEYS,
+	K8sCategory,
+} from 'container/InfraMonitoringK8s/constants';
 import {
 	CustomTimeType,
 	Time,
@@ -95,21 +93,23 @@ function DaemonSetDetails({
 			: (selectedTime as Time),
 	);
 
-	const [selectedView, setSelectedView] = useInfraMonitoringView();
-	const [logFiltersParam, setLogFiltersParam] = useInfraMonitoringLogFilters();
-	const [
-		tracesFiltersParam,
-		setTracesFiltersParam,
-	] = useInfraMonitoringTracesFilters();
-	const [
-		eventsFiltersParam,
-		setEventsFiltersParam,
-	] = useInfraMonitoringEventsFilters();
+	const [searchParams, setSearchParams] = useSearchParams();
+	const [selectedView, setSelectedView] = useState<VIEWS>(() => {
+		const view = searchParams.get(INFRA_MONITORING_K8S_PARAMS_KEYS.VIEW);
+		if (view) {
+			return view as VIEWS;
+		}
+		return VIEWS.METRICS;
+	});
 	const isDarkMode = useIsDarkMode();
 
 	const initialFilters = useMemo(() => {
-		const filters =
-			selectedView === VIEW_TYPES.LOGS ? logFiltersParam : tracesFiltersParam;
+		const urlView = searchParams.get(INFRA_MONITORING_K8S_PARAMS_KEYS.VIEW);
+		const queryKey =
+			urlView === VIEW_TYPES.LOGS
+				? INFRA_MONITORING_K8S_PARAMS_KEYS.LOG_FILTERS
+				: INFRA_MONITORING_K8S_PARAMS_KEYS.TRACES_FILTERS;
+		const filters = getFiltersFromParams(searchParams, queryKey);
 		if (filters) {
 			return filters;
 		}
@@ -143,14 +143,16 @@ function DaemonSetDetails({
 	}, [
 		daemonSet?.meta.k8s_daemonset_name,
 		daemonSet?.meta.k8s_namespace_name,
-		selectedView,
-		logFiltersParam,
-		tracesFiltersParam,
+		searchParams,
 	]);
 
 	const initialEventsFilters = useMemo(() => {
-		if (eventsFiltersParam) {
-			return eventsFiltersParam;
+		const filters = getFiltersFromParams(
+			searchParams,
+			INFRA_MONITORING_K8S_PARAMS_KEYS.EVENTS_FILTERS,
+		);
+		if (filters) {
+			return filters;
 		}
 		return {
 			op: 'AND',
@@ -179,7 +181,7 @@ function DaemonSetDetails({
 				},
 			],
 		};
-	}, [daemonSet?.meta.k8s_daemonset_name, eventsFiltersParam]);
+	}, [daemonSet?.meta.k8s_daemonset_name, searchParams]);
 
 	const [logAndTracesFilters, setLogAndTracesFilters] = useState<
 		IBuilderQuery['filters']
@@ -220,9 +222,13 @@ function DaemonSetDetails({
 
 	const handleTabChange = (e: RadioChangeEvent): void => {
 		setSelectedView(e.target.value);
-		setLogFiltersParam(null);
-		setTracesFiltersParam(null);
-		setEventsFiltersParam(null);
+		setSearchParams({
+			...Object.fromEntries(searchParams.entries()),
+			[INFRA_MONITORING_K8S_PARAMS_KEYS.VIEW]: e.target.value,
+			[INFRA_MONITORING_K8S_PARAMS_KEYS.LOG_FILTERS]: JSON.stringify(null),
+			[INFRA_MONITORING_K8S_PARAMS_KEYS.TRACES_FILTERS]: JSON.stringify(null),
+			[INFRA_MONITORING_K8S_PARAMS_KEYS.EVENTS_FILTERS]: JSON.stringify(null),
+		});
 		logEvent(InfraMonitoringEvents.TabChanged, {
 			entity: InfraMonitoringEvents.K8sEntity,
 			page: InfraMonitoringEvents.DetailedPage,
@@ -290,17 +296,20 @@ function DaemonSetDetails({
 
 				const updatedFilters = {
 					op: 'AND',
-					items: filterDuplicateFilters(
-						[
-							...(primaryFilters || []),
-							...(newFilters || []),
-							...(paginationFilter ? [paginationFilter] : []),
-						].filter((item): item is TagFilterItem => item !== undefined),
-					),
+					items: [
+						...(primaryFilters || []),
+						...(newFilters || []),
+						...(paginationFilter ? [paginationFilter] : []),
+					].filter((item): item is TagFilterItem => item !== undefined),
 				};
 
-				setLogFiltersParam(updatedFilters);
-				setSelectedView(view);
+				setSearchParams({
+					...Object.fromEntries(searchParams.entries()),
+					[INFRA_MONITORING_K8S_PARAMS_KEYS.LOG_FILTERS]: JSON.stringify(
+						updatedFilters,
+					),
+					[INFRA_MONITORING_K8S_PARAMS_KEYS.VIEW]: view,
+				});
 				return updatedFilters;
 			});
 		},
@@ -328,18 +337,21 @@ function DaemonSetDetails({
 
 				const updatedFilters = {
 					op: 'AND',
-					items: filterDuplicateFilters(
-						[
-							...(primaryFilters || []),
-							...(value?.items?.filter(
-								(item) => item.key?.key !== QUERY_KEYS.K8S_DAEMON_SET_NAME,
-							) || []),
-						].filter((item): item is TagFilterItem => item !== undefined),
-					),
+					items: [
+						...(primaryFilters || []),
+						...(value?.items?.filter(
+							(item) => item.key?.key !== QUERY_KEYS.K8S_DAEMON_SET_NAME,
+						) || []),
+					].filter((item): item is TagFilterItem => item !== undefined),
 				};
 
-				setTracesFiltersParam(updatedFilters);
-				setSelectedView(view);
+				setSearchParams({
+					...Object.fromEntries(searchParams.entries()),
+					[INFRA_MONITORING_K8S_PARAMS_KEYS.TRACES_FILTERS]: JSON.stringify(
+						updatedFilters,
+					),
+					[INFRA_MONITORING_K8S_PARAMS_KEYS.VIEW]: view,
+				});
 
 				return updatedFilters;
 			});
@@ -380,8 +392,13 @@ function DaemonSetDetails({
 					].filter((item): item is TagFilterItem => item !== undefined),
 				};
 
-				setEventsFiltersParam(updatedFilters);
-				setSelectedView(view);
+				setSearchParams({
+					...Object.fromEntries(searchParams.entries()),
+					[INFRA_MONITORING_K8S_PARAMS_KEYS.EVENTS_FILTERS]: JSON.stringify(
+						updatedFilters,
+					),
+					[INFRA_MONITORING_K8S_PARAMS_KEYS.VIEW]: view,
+				});
 
 				return updatedFilters;
 			});

frontend/src/container/InfraMonitoringK8s/DaemonSets/K8sDaemonSetsList.tsx

@@ -1,6 +1,7 @@
-import React, { useCallback, useEffect, useMemo, useState } from 'react';
+import { useCallback, useEffect, useMemo, useState } from 'react';
 // eslint-disable-next-line no-restricted-imports
 import { useSelector } from 'react-redux';
+import { useSearchParams } from 'react-router-dom-v5-compat';
 import { LoadingOutlined } from '@ant-design/icons';
 import {
 	Button,
@@ -24,26 +25,15 @@ import { ChevronDown, ChevronRight } from 'lucide-react';
 import { AppState } from 'store/reducers';
 import { IBuilderQuery } from 'types/api/queryBuilder/queryBuilderData';
 import { GlobalReducer } from 'types/reducer/globalTime';
-import { buildAbsolutePath, isModifierKeyPressed } from 'utils/app';
-import { openInNewTab } from 'utils/navigation';
 
 import { FeatureKeys } from '../../../constants/features';
 import { useAppContext } from '../../../providers/App/App';
+import { getOrderByFromParams } from '../commonUtils';
 import {
 	GetK8sEntityToAggregateAttribute,
 	INFRA_MONITORING_K8S_PARAMS_KEYS,
 	K8sCategory,
 } from '../constants';
-import {
-	useInfraMonitoringCurrentPage,
-	useInfraMonitoringDaemonSetUID,
-	useInfraMonitoringEventsFilters,
-	useInfraMonitoringGroupBy,
-	useInfraMonitoringLogFilters,
-	useInfraMonitoringOrderBy,
-	useInfraMonitoringTracesFilters,
-	useInfraMonitoringView,
-} from '../hooks';
 import K8sHeader from '../K8sHeader';
 import LoadingContainer from '../LoadingContainer';
 import { usePageSize } from '../utils';
@@ -72,25 +62,54 @@ function K8sDaemonSetsList({
 		(state) => state.globalTime,
 	);
 
-	const [currentPage, setCurrentPage] = useInfraMonitoringCurrentPage();
+	const [searchParams, setSearchParams] = useSearchParams();
+
+	const [currentPage, setCurrentPage] = useState(() => {
+		const page = searchParams.get(INFRA_MONITORING_K8S_PARAMS_KEYS.CURRENT_PAGE);
+		if (page) {
+			return parseInt(page, 10);
+		}
+		return 1;
+	});
 	const [filtersInitialised, setFiltersInitialised] = useState(false);
 	const [expandedRowKeys, setExpandedRowKeys] = useState<string[]>([]);
 
-	const [orderBy, setOrderBy] = useInfraMonitoringOrderBy();
+	useEffect(() => {
+		setSearchParams({
+			...Object.fromEntries(searchParams.entries()),
+			[INFRA_MONITORING_K8S_PARAMS_KEYS.CURRENT_PAGE]: currentPage.toString(),
+		});
+		// eslint-disable-next-line react-hooks/exhaustive-deps
+	}, [currentPage]);
 
-	const [
-		selectedDaemonSetUID,
-		setSelectedDaemonSetUID,
-	] = useInfraMonitoringDaemonSetUID();
+	const [orderBy, setOrderBy] = useState<{
+		columnName: string;
+		order: 'asc' | 'desc';
+	} | null>(() => getOrderByFromParams(searchParams, true));
+
+	const [selectedDaemonSetUID, setSelectedDaemonSetUID] = useState<
+		string | null
+	>(() => {
+		const daemonSetUID = searchParams.get(
+			INFRA_MONITORING_K8S_PARAMS_KEYS.DAEMONSET_UID,
+		);
+		if (daemonSetUID) {
+			return daemonSetUID;
+		}
+		return null;
+	});
 
 	const { pageSize, setPageSize } = usePageSize(K8sCategory.DAEMONSETS);
 
-	const [groupBy, setGroupBy] = useInfraMonitoringGroupBy();
-
-	const [, setView] = useInfraMonitoringView();
-	const [, setTracesFilters] = useInfraMonitoringTracesFilters();
-	const [, setEventsFilters] = useInfraMonitoringEventsFilters();
-	const [, setLogFilters] = useInfraMonitoringLogFilters();
+	const [groupBy, setGroupBy] = useState<IBuilderQuery['groupBy']>(() => {
+		const groupBy = searchParams.get(INFRA_MONITORING_K8S_PARAMS_KEYS.GROUP_BY);
+		if (groupBy) {
+			const decoded = decodeURIComponent(groupBy);
+			const parsed = JSON.parse(decoded);
+			return parsed as IBuilderQuery['groupBy'];
+		}
+		return [];
+	});
 
 	const [
 		selectedRowData,
@@ -117,7 +136,7 @@ function K8sDaemonSetsList({
 		if (quickFiltersLastUpdated !== -1) {
 			setCurrentPage(1);
 		}
-	}, [quickFiltersLastUpdated, setCurrentPage]);
+	}, [quickFiltersLastUpdated]);
 
 	const { featureFlags } = useAppContext();
 	const dotMetricsEnabled =
@@ -170,28 +189,25 @@ function K8sDaemonSetsList({
 			filters,
 			start: Math.floor(minTime / 1000000),
 			end: Math.floor(maxTime / 1000000),
-			orderBy: orderBy || baseQuery.orderBy,
+			orderBy,
 		};
 		// eslint-disable-next-line react-hooks/exhaustive-deps
 	}, [minTime, maxTime, orderBy, selectedRowData, groupBy]);
 
 	const groupedByRowDataQueryKey = useMemo(() => {
-		// be careful with what you serialize from selectedRowData
-		// since it's react node, it could contain circular references
-		const selectedRowDataKey = JSON.stringify(selectedRowData?.groupedByMeta);
 		if (selectedDaemonSetUID) {
 			return [
 				'daemonSetList',
 				JSON.stringify(queryFilters),
 				JSON.stringify(orderBy),
-				selectedRowDataKey,
+				JSON.stringify(selectedRowData),
 			];
 		}
 		return [
 			'daemonSetList',
 			JSON.stringify(queryFilters),
 			JSON.stringify(orderBy),
-			selectedRowDataKey,
+			JSON.stringify(selectedRowData),
 			String(minTime),
 			String(maxTime),
 		];
@@ -250,7 +266,7 @@ function K8sDaemonSetsList({
 			filters: queryFilters,
 			start: Math.floor(minTime / 1000000),
 			end: Math.floor(maxTime / 1000000),
-			orderBy: orderBy || baseQuery.orderBy,
+			orderBy,
 		};
 		if (groupBy.length > 0) {
 			queryPayload.groupBy = groupBy;
@@ -360,15 +376,26 @@ function K8sDaemonSetsList({
 			}
 
 			if ('field' in sorter && sorter.order) {
-				setOrderBy({
+				const currentOrderBy = {
 					columnName: sorter.field as string,
 					order: (sorter.order === 'ascend' ? 'asc' : 'desc') as 'asc' | 'desc',
+				};
+				setOrderBy(currentOrderBy);
+				setSearchParams({
+					...Object.fromEntries(searchParams.entries()),
+					[INFRA_MONITORING_K8S_PARAMS_KEYS.ORDER_BY]: JSON.stringify(
+						currentOrderBy,
+					),
 				});
 			} else {
 				setOrderBy(null);
+				setSearchParams({
+					...Object.fromEntries(searchParams.entries()),
+					[INFRA_MONITORING_K8S_PARAMS_KEYS.ORDER_BY]: JSON.stringify(null),
+				});
 			}
 		},
-		[setCurrentPage, setOrderBy],
+		[searchParams, setSearchParams],
 	);
 
 	const { handleChangeQueryData } = useQueryOperations({
@@ -429,31 +456,14 @@ function K8sDaemonSetsList({
 		nestedDaemonSetsData,
 	]);
 
-	const openDaemonSetInNewTab = (record: K8sDaemonSetsRowData): void => {
-		const newParams = new URLSearchParams(document.location.search);
-		newParams.set(
-			INFRA_MONITORING_K8S_PARAMS_KEYS.DAEMONSET_UID,
-			record.daemonsetUID,
-		);
-		openInNewTab(
-			buildAbsolutePath({
-				relativePath: '',
-				urlQueryString: newParams.toString(),
-			}),
-		);
-	};
-
-	const handleRowClick = (
-		record: K8sDaemonSetsRowData,
-		event?: React.MouseEvent,
-	): void => {
-		if (event && isModifierKeyPressed(event)) {
-			openDaemonSetInNewTab(record);
-			return;
-		}
+	const handleRowClick = (record: K8sDaemonSetsRowData): void => {
 		if (groupBy.length === 0) {
 			setSelectedRowData(null);
 			setSelectedDaemonSetUID(record.daemonsetUID);
+			setSearchParams({
+				...Object.fromEntries(searchParams.entries()),
+				[INFRA_MONITORING_K8S_PARAMS_KEYS.DAEMONSET_UID]: record.daemonsetUID,
+			});
 		} else {
 			handleGroupByRowClick(record);
 		}
@@ -482,6 +492,11 @@ function K8sDaemonSetsList({
 		setSelectedRowData(null);
 		setGroupBy([]);
 		setOrderBy(null);
+		setSearchParams({
+			...Object.fromEntries(searchParams.entries()),
+			[INFRA_MONITORING_K8S_PARAMS_KEYS.GROUP_BY]: JSON.stringify([]),
+			[INFRA_MONITORING_K8S_PARAMS_KEYS.ORDER_BY]: JSON.stringify(null),
+		});
 	};
 
 	const expandedRowRender = (): JSX.Element => (
@@ -505,14 +520,8 @@ function K8sDaemonSetsList({
 							indicator: <Spin indicator={<LoadingOutlined size={14} spin />} />,
 						}}
 						showHeader={false}
-						onRow={(
-							record,
-						): { onClick: (event: React.MouseEvent) => void; className: string } => ({
-							onClick: (event: React.MouseEvent): void => {
-								if (event && isModifierKeyPressed(event)) {
-									openDaemonSetInNewTab(record);
-									return;
-								}
+						onRow={(record): { onClick: () => void; className: string } => ({
+							onClick: (): void => {
 								setSelectedDaemonSetUID(record.daemonsetUID);
 							},
 							className: 'expanded-clickable-row',
@@ -578,10 +587,20 @@ function K8sDaemonSetsList({
 
 	const handleCloseDaemonSetDetail = (): void => {
 		setSelectedDaemonSetUID(null);
-		setView(null);
-		setTracesFilters(null);
-		setEventsFilters(null);
-		setLogFilters(null);
+		setSearchParams({
+			...Object.fromEntries(
+				Array.from(searchParams.entries()).filter(
+					([key]) =>
+						![
+							INFRA_MONITORING_K8S_PARAMS_KEYS.DAEMONSET_UID,
+							INFRA_MONITORING_K8S_PARAMS_KEYS.VIEW,
+							INFRA_MONITORING_K8S_PARAMS_KEYS.TRACES_FILTERS,
+							INFRA_MONITORING_K8S_PARAMS_KEYS.EVENTS_FILTERS,
+							INFRA_MONITORING_K8S_PARAMS_KEYS.LOG_FILTERS,
+						].includes(key),
+				),
+			),
+		});
 	};
 
 	const handleGroupByChange = useCallback(
@@ -602,6 +621,10 @@ function K8sDaemonSetsList({
 
 			setCurrentPage(1);
 			setGroupBy(groupBy);
+			setSearchParams({
+				...Object.fromEntries(searchParams.entries()),
+				[INFRA_MONITORING_K8S_PARAMS_KEYS.GROUP_BY]: JSON.stringify(groupBy),
+			});
 			setExpandedRowKeys([]);
 
 			logEvent(InfraMonitoringEvents.GroupByChanged, {
@@ -610,7 +633,7 @@ function K8sDaemonSetsList({
 				category: InfraMonitoringEvents.DaemonSet,
 			});
 		},
-		[groupByFiltersData, setCurrentPage, setGroupBy],
+		[groupByFiltersData, searchParams, setSearchParams],
 	);
 
 	useEffect(() => {
@@ -691,10 +714,8 @@ function K8sDaemonSetsList({
 				}}
 				tableLayout="fixed"
 				onChange={handleTableChange}
-				onRow={(
-					record,
-				): { onClick: (event: React.MouseEvent) => void; className: string } => ({
-					onClick: (event: React.MouseEvent): void => handleRowClick(record, event),
+				onRow={(record): { onClick: () => void; className: string } => ({
+					onClick: (): void => handleRowClick(record),
 					className: 'clickable-row',
 				})}
 				expandable={{

frontend/src/container/InfraMonitoringK8s/DaemonSets/utils.tsx

@@ -1,5 +1,6 @@
 import { Color } from '@signozhq/design-tokens';
-import { TableColumnType as ColumnType, Tag, Tooltip } from 'antd';
+import { Tag, Tooltip } from 'antd';
+import { TableColumnType as ColumnType } from 'antd';
 import {
 	K8sDaemonSetsData,
 	K8sDaemonSetsListPayload,

frontend/src/container/InfraMonitoringK8s/Deployments/DeploymentDetails/DeploymentDetails.tsx

@@ -2,6 +2,7 @@
 import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
 // eslint-disable-next-line no-restricted-imports
 import { useSelector } from 'react-redux';
+import { useSearchParams } from 'react-router-dom-v5-compat';
 import { Color, Spacing } from '@signozhq/design-tokens';
 import { Button, Divider, Drawer, Radio, Tooltip, Typography } from 'antd';
 import type { RadioChangeEvent } from 'antd/lib';
@@ -15,15 +16,15 @@ import {
 	initialQueryState,
 } from 'constants/queryBuilder';
 import ROUTES from 'constants/routes';
-import { filterDuplicateFilters } from 'container/InfraMonitoringK8s/commonUtils';
-import { K8sCategory } from 'container/InfraMonitoringK8s/constants';
-import { QUERY_KEYS } from 'container/InfraMonitoringK8s/EntityDetailsUtils/utils';
 import {
-	useInfraMonitoringEventsFilters,
-	useInfraMonitoringLogFilters,
-	useInfraMonitoringTracesFilters,
-	useInfraMonitoringView,
-} from 'container/InfraMonitoringK8s/hooks';
+	filterDuplicateFilters,
+	getFiltersFromParams,
+} from 'container/InfraMonitoringK8s/commonUtils';
+import {
+	INFRA_MONITORING_K8S_PARAMS_KEYS,
+	K8sCategory,
+} from 'container/InfraMonitoringK8s/constants';
+import { QUERY_KEYS } from 'container/InfraMonitoringK8s/EntityDetailsUtils/utils';
 import {
 	CustomTimeType,
 	Time,
@@ -96,21 +97,23 @@ function DeploymentDetails({
 			: (selectedTime as Time),
 	);
 
-	const [selectedView, setSelectedView] = useInfraMonitoringView();
-	const [logFiltersParam, setLogFiltersParam] = useInfraMonitoringLogFilters();
-	const [
-		tracesFiltersParam,
-		setTracesFiltersParam,
-	] = useInfraMonitoringTracesFilters();
-	const [
-		eventsFiltersParam,
-		setEventsFiltersParam,
-	] = useInfraMonitoringEventsFilters();
+	const [searchParams, setSearchParams] = useSearchParams();
+	const [selectedView, setSelectedView] = useState<VIEWS>(() => {
+		const view = searchParams.get(INFRA_MONITORING_K8S_PARAMS_KEYS.VIEW);
+		if (view) {
+			return view as VIEWS;
+		}
+		return VIEWS.METRICS;
+	});
 	const isDarkMode = useIsDarkMode();
 
 	const initialFilters = useMemo(() => {
-		const filters =
-			selectedView === VIEW_TYPES.LOGS ? logFiltersParam : tracesFiltersParam;
+		const urlView = searchParams.get(INFRA_MONITORING_K8S_PARAMS_KEYS.VIEW);
+		const queryKey =
+			urlView === VIEW_TYPES.LOGS
+				? INFRA_MONITORING_K8S_PARAMS_KEYS.LOG_FILTERS
+				: INFRA_MONITORING_K8S_PARAMS_KEYS.TRACES_FILTERS;
+		const filters = getFiltersFromParams(searchParams, queryKey);
 		if (filters) {
 			return filters;
 		}
@@ -144,14 +147,16 @@ function DeploymentDetails({
 	}, [
 		deployment?.meta.k8s_deployment_name,
 		deployment?.meta.k8s_namespace_name,
-		selectedView,
-		logFiltersParam,
-		tracesFiltersParam,
+		searchParams,
 	]);
 
 	const initialEventsFilters = useMemo(() => {
-		if (eventsFiltersParam) {
-			return eventsFiltersParam;
+		const filters = getFiltersFromParams(
+			searchParams,
+			INFRA_MONITORING_K8S_PARAMS_KEYS.EVENTS_FILTERS,
+		);
+		if (filters) {
+			return filters;
 		}
 		return {
 			op: 'AND',
@@ -180,7 +185,7 @@ function DeploymentDetails({
 				},
 			],
 		};
-	}, [deployment?.meta.k8s_deployment_name, eventsFiltersParam]);
+	}, [deployment?.meta.k8s_deployment_name, searchParams]);
 
 	const [logAndTracesFilters, setLogAndTracesFilters] = useState<
 		IBuilderQuery['filters']
@@ -221,9 +226,13 @@ function DeploymentDetails({
 
 	const handleTabChange = (e: RadioChangeEvent): void => {
 		setSelectedView(e.target.value);
-		setLogFiltersParam(null);
-		setTracesFiltersParam(null);
-		setEventsFiltersParam(null);
+		setSearchParams({
+			...Object.fromEntries(searchParams.entries()),
+			[INFRA_MONITORING_K8S_PARAMS_KEYS.VIEW]: e.target.value,
+			[INFRA_MONITORING_K8S_PARAMS_KEYS.LOG_FILTERS]: JSON.stringify(null),
+			[INFRA_MONITORING_K8S_PARAMS_KEYS.TRACES_FILTERS]: JSON.stringify(null),
+			[INFRA_MONITORING_K8S_PARAMS_KEYS.EVENTS_FILTERS]: JSON.stringify(null),
+		});
 		logEvent(InfraMonitoringEvents.TabChanged, {
 			entity: InfraMonitoringEvents.K8sEntity,
 			page: InfraMonitoringEvents.DetailedPage,
@@ -300,8 +309,13 @@ function DeploymentDetails({
 					),
 				};
 
-				setLogFiltersParam(updatedFilters);
-				setSelectedView(view);
+				setSearchParams({
+					...Object.fromEntries(searchParams.entries()),
+					[INFRA_MONITORING_K8S_PARAMS_KEYS.LOG_FILTERS]: JSON.stringify(
+						updatedFilters,
+					),
+					[INFRA_MONITORING_K8S_PARAMS_KEYS.VIEW]: view,
+				});
 
 				return updatedFilters;
 			});
@@ -340,8 +354,13 @@ function DeploymentDetails({
 					),
 				};
 
-				setTracesFiltersParam(updatedFilters);
-				setSelectedView(view);
+				setSearchParams({
+					...Object.fromEntries(searchParams.entries()),
+					[INFRA_MONITORING_K8S_PARAMS_KEYS.TRACES_FILTERS]: JSON.stringify(
+						updatedFilters,
+					),
+					[INFRA_MONITORING_K8S_PARAMS_KEYS.VIEW]: view,
+				});
 
 				return updatedFilters;
 			});
@@ -384,8 +403,13 @@ function DeploymentDetails({
 					),
 				};
 
-				setEventsFiltersParam(updatedFilters);
-				setSelectedView(view);
+				setSearchParams({
+					...Object.fromEntries(searchParams.entries()),
+					[INFRA_MONITORING_K8S_PARAMS_KEYS.EVENTS_FILTERS]: JSON.stringify(
+						updatedFilters,
+					),
+					[INFRA_MONITORING_K8S_PARAMS_KEYS.VIEW]: view,
+				});
 
 				return updatedFilters;
 			});

frontend/src/container/InfraMonitoringK8s/Deployments/K8sDeploymentsList.tsx

@@ -1,6 +1,7 @@
-import React, { useCallback, useEffect, useMemo, useState } from 'react';
+import { useCallback, useEffect, useMemo, useState } from 'react';
 // eslint-disable-next-line no-restricted-imports
 import { useSelector } from 'react-redux';
+import { useSearchParams } from 'react-router-dom-v5-compat';
 import { LoadingOutlined } from '@ant-design/icons';
 import {
 	Button,
@@ -16,34 +17,23 @@ import logEvent from 'api/common/logEvent';
 import { K8sDeploymentsListPayload } from 'api/infraMonitoring/getK8sDeploymentsList';
 import classNames from 'classnames';
 import { InfraMonitoringEvents } from 'constants/events';
-import { FeatureKeys } from 'constants/features';
 import { useGetK8sDeploymentsList } from 'hooks/infraMonitoring/useGetK8sDeploymentsList';
 import { useGetAggregateKeys } from 'hooks/queryBuilder/useGetAggregateKeys';
 import { useQueryBuilder } from 'hooks/queryBuilder/useQueryBuilder';
 import { useQueryOperations } from 'hooks/queryBuilder/useQueryBuilderOperations';
 import { ChevronDown, ChevronRight } from 'lucide-react';
-import { useAppContext } from 'providers/App/App';
 import { AppState } from 'store/reducers';
 import { IBuilderQuery } from 'types/api/queryBuilder/queryBuilderData';
 import { GlobalReducer } from 'types/reducer/globalTime';
-import { buildAbsolutePath, isModifierKeyPressed } from 'utils/app';
-import { openInNewTab } from 'utils/navigation';
 
+import { FeatureKeys } from '../../../constants/features';
+import { useAppContext } from '../../../providers/App/App';
+import { getOrderByFromParams } from '../commonUtils';
 import {
 	GetK8sEntityToAggregateAttribute,
 	INFRA_MONITORING_K8S_PARAMS_KEYS,
 	K8sCategory,
 } from '../constants';
-import {
-	useInfraMonitoringCurrentPage,
-	useInfraMonitoringDeploymentUID,
-	useInfraMonitoringEventsFilters,
-	useInfraMonitoringGroupBy,
-	useInfraMonitoringLogFilters,
-	useInfraMonitoringOrderBy,
-	useInfraMonitoringTracesFilters,
-	useInfraMonitoringView,
-} from '../hooks';
 import K8sHeader from '../K8sHeader';
 import LoadingContainer from '../LoadingContainer';
 import { usePageSize } from '../utils';
@@ -72,26 +62,55 @@ function K8sDeploymentsList({
 		(state) => state.globalTime,
 	);
 
-	const [currentPage, setCurrentPage] = useInfraMonitoringCurrentPage();
+	const [searchParams, setSearchParams] = useSearchParams();
+
+	const [currentPage, setCurrentPage] = useState(() => {
+		const page = searchParams.get(INFRA_MONITORING_K8S_PARAMS_KEYS.CURRENT_PAGE);
+		if (page) {
+			return parseInt(page, 10);
+		}
+		return 1;
+	});
 	const [filtersInitialised, setFiltersInitialised] = useState(false);
 
+	useEffect(() => {
+		setSearchParams({
+			...Object.fromEntries(searchParams.entries()),
+			[INFRA_MONITORING_K8S_PARAMS_KEYS.CURRENT_PAGE]: currentPage.toString(),
+		});
+		// eslint-disable-next-line react-hooks/exhaustive-deps
+	}, [currentPage]);
+
 	const [expandedRowKeys, setExpandedRowKeys] = useState<string[]>([]);
 
-	const [orderBy, setOrderBy] = useInfraMonitoringOrderBy();
+	const [orderBy, setOrderBy] = useState<{
+		columnName: string;
+		order: 'asc' | 'desc';
+	} | null>(() => getOrderByFromParams(searchParams, true));
 
-	const [
-		selectedDeploymentUID,
-		setselectedDeploymentUID,
-	] = useInfraMonitoringDeploymentUID();
+	const [selectedDeploymentUID, setselectedDeploymentUID] = useState<
+		string | null
+	>(() => {
+		const deploymentUID = searchParams.get(
+			INFRA_MONITORING_K8S_PARAMS_KEYS.DEPLOYMENT_UID,
+		);
+		if (deploymentUID) {
+			return deploymentUID;
+		}
+		return null;
+	});
 
 	const { pageSize, setPageSize } = usePageSize(K8sCategory.DEPLOYMENTS);
 
-	const [groupBy, setGroupBy] = useInfraMonitoringGroupBy();
-
-	const [, setView] = useInfraMonitoringView();
-	const [, setTracesFilters] = useInfraMonitoringTracesFilters();
-	const [, setEventsFilters] = useInfraMonitoringEventsFilters();
-	const [, setLogFilters] = useInfraMonitoringLogFilters();
+	const [groupBy, setGroupBy] = useState<IBuilderQuery['groupBy']>(() => {
+		const groupBy = searchParams.get(INFRA_MONITORING_K8S_PARAMS_KEYS.GROUP_BY);
+		if (groupBy) {
+			const decoded = decodeURIComponent(groupBy);
+			const parsed = JSON.parse(decoded);
+			return parsed as IBuilderQuery['groupBy'];
+		}
+		return [];
+	});
 
 	const [
 		selectedRowData,
@@ -118,7 +137,7 @@ function K8sDeploymentsList({
 		if (quickFiltersLastUpdated !== -1) {
 			setCurrentPage(1);
 		}
-	}, [quickFiltersLastUpdated, setCurrentPage]);
+	}, [quickFiltersLastUpdated]);
 
 	const { featureFlags } = useAppContext();
 	const dotMetricsEnabled =
@@ -171,28 +190,25 @@ function K8sDeploymentsList({
 			filters,
 			start: Math.floor(minTime / 1000000),
 			end: Math.floor(maxTime / 1000000),
-			orderBy: orderBy || baseQuery.orderBy,
+			orderBy,
 		};
 		// eslint-disable-next-line react-hooks/exhaustive-deps
 	}, [minTime, maxTime, orderBy, selectedRowData, groupBy]);
 
 	const groupedByRowDataQueryKey = useMemo(() => {
-		// be careful with what you serialize from selectedRowData
-		// since it's react node, it could contain circular references
-		const selectedRowDataKey = JSON.stringify(selectedRowData?.groupedByMeta);
 		if (selectedDeploymentUID) {
 			return [
 				'deploymentList',
 				JSON.stringify(queryFilters),
 				JSON.stringify(orderBy),
-				selectedRowDataKey,
+				JSON.stringify(selectedRowData),
 			];
 		}
 		return [
 			'deploymentList',
 			JSON.stringify(queryFilters),
 			JSON.stringify(orderBy),
-			selectedRowDataKey,
+			JSON.stringify(selectedRowData),
 			String(minTime),
 			String(maxTime),
 		];
@@ -251,7 +267,7 @@ function K8sDeploymentsList({
 			filters: queryFilters,
 			start: Math.floor(minTime / 1000000),
 			end: Math.floor(maxTime / 1000000),
-			orderBy: orderBy || baseQuery.orderBy,
+			orderBy,
 		};
 		if (groupBy.length > 0) {
 			queryPayload.groupBy = groupBy;
@@ -363,15 +379,26 @@ function K8sDeploymentsList({
 			}
 
 			if ('field' in sorter && sorter.order) {
-				setOrderBy({
+				const currentOrderBy = {
 					columnName: sorter.field as string,
 					order: (sorter.order === 'ascend' ? 'asc' : 'desc') as 'asc' | 'desc',
+				};
+				setOrderBy(currentOrderBy);
+				setSearchParams({
+					...Object.fromEntries(searchParams.entries()),
+					[INFRA_MONITORING_K8S_PARAMS_KEYS.ORDER_BY]: JSON.stringify(
+						currentOrderBy,
+					),
 				});
 			} else {
 				setOrderBy(null);
+				setSearchParams({
+					...Object.fromEntries(searchParams.entries()),
+					[INFRA_MONITORING_K8S_PARAMS_KEYS.ORDER_BY]: JSON.stringify(null),
+				});
 			}
 		},
-		[setCurrentPage, setOrderBy],
+		[searchParams, setSearchParams],
 	);
 
 	const { handleChangeQueryData } = useQueryOperations({
@@ -435,31 +462,14 @@ function K8sDeploymentsList({
 		nestedDeploymentsData,
 	]);
 
-	const openDeploymentInNewTab = (record: K8sDeploymentsRowData): void => {
-		const newParams = new URLSearchParams(document.location.search);
-		newParams.set(
-			INFRA_MONITORING_K8S_PARAMS_KEYS.DEPLOYMENT_UID,
-			record.deploymentUID,
-		);
-		openInNewTab(
-			buildAbsolutePath({
-				relativePath: '',
-				urlQueryString: newParams.toString(),
-			}),
-		);
-	};
-
-	const handleRowClick = (
-		record: K8sDeploymentsRowData,
-		event?: React.MouseEvent,
-	): void => {
-		if (event && isModifierKeyPressed(event)) {
-			openDeploymentInNewTab(record);
-			return;
-		}
+	const handleRowClick = (record: K8sDeploymentsRowData): void => {
 		if (groupBy.length === 0) {
 			setSelectedRowData(null);
 			setselectedDeploymentUID(record.deploymentUID);
+			setSearchParams({
+				...Object.fromEntries(searchParams.entries()),
+				[INFRA_MONITORING_K8S_PARAMS_KEYS.DEPLOYMENT_UID]: record.deploymentUID,
+			});
 		} else {
 			handleGroupByRowClick(record);
 		}
@@ -488,6 +498,11 @@ function K8sDeploymentsList({
 		setSelectedRowData(null);
 		setGroupBy([]);
 		setOrderBy(null);
+		setSearchParams({
+			...Object.fromEntries(searchParams.entries()),
+			[INFRA_MONITORING_K8S_PARAMS_KEYS.GROUP_BY]: JSON.stringify([]),
+			[INFRA_MONITORING_K8S_PARAMS_KEYS.ORDER_BY]: JSON.stringify(null),
+		});
 	};
 
 	const expandedRowRender = (): JSX.Element => (
@@ -511,14 +526,8 @@ function K8sDeploymentsList({
 							indicator: <Spin indicator={<LoadingOutlined size={14} spin />} />,
 						}}
 						showHeader={false}
-						onRow={(
-							record,
-						): { onClick: (event: React.MouseEvent) => void; className: string } => ({
-							onClick: (event: React.MouseEvent): void => {
-								if (event && isModifierKeyPressed(event)) {
-									openDeploymentInNewTab(record);
-									return;
-								}
+						onRow={(record): { onClick: () => void; className: string } => ({
+							onClick: (): void => {
 								setselectedDeploymentUID(record.deploymentUID);
 							},
 							className: 'expanded-clickable-row',
@@ -584,10 +593,20 @@ function K8sDeploymentsList({
 
 	const handleCloseDeploymentDetail = (): void => {
 		setselectedDeploymentUID(null);
-		setView(null);
-		setTracesFilters(null);
-		setEventsFilters(null);
-		setLogFilters(null);
+		setSearchParams({
+			...Object.fromEntries(
+				Array.from(searchParams.entries()).filter(
+					([key]) =>
+						![
+							INFRA_MONITORING_K8S_PARAMS_KEYS.DEPLOYMENT_UID,
+							INFRA_MONITORING_K8S_PARAMS_KEYS.VIEW,
+							INFRA_MONITORING_K8S_PARAMS_KEYS.TRACES_FILTERS,
+							INFRA_MONITORING_K8S_PARAMS_KEYS.EVENTS_FILTERS,
+							INFRA_MONITORING_K8S_PARAMS_KEYS.LOG_FILTERS,
+						].includes(key),
+				),
+			),
+		});
 	};
 
 	const handleGroupByChange = useCallback(
@@ -609,6 +628,10 @@ function K8sDeploymentsList({
 			// Reset pagination on switching to groupBy
 			setCurrentPage(1);
 			setGroupBy(groupBy);
+			setSearchParams({
+				...Object.fromEntries(searchParams.entries()),
+				[INFRA_MONITORING_K8S_PARAMS_KEYS.GROUP_BY]: JSON.stringify(groupBy),
+			});
 			setExpandedRowKeys([]);
 
 			logEvent(InfraMonitoringEvents.GroupByChanged, {
@@ -617,7 +640,7 @@ function K8sDeploymentsList({
 				category: InfraMonitoringEvents.Deployment,
 			});
 		},
-		[groupByFiltersData, setCurrentPage, setGroupBy],
+		[groupByFiltersData, searchParams, setSearchParams],
 	);
 
 	useEffect(() => {
@@ -698,10 +721,8 @@ function K8sDeploymentsList({
 				}}
 				tableLayout="fixed"
 				onChange={handleTableChange}
-				onRow={(
-					record,
-				): { onClick: (event: React.MouseEvent) => void; className: string } => ({
-					onClick: (event: React.MouseEvent): void => handleRowClick(record, event),
+				onRow={(record): { onClick: () => void; className: string } => ({
+					onClick: (): void => handleRowClick(record),
 					className: 'clickable-row',
 				})}
 				expandable={{

frontend/src/container/InfraMonitoringK8s/Deployments/utils.tsx

@@ -1,5 +1,6 @@
 import { Color } from '@signozhq/design-tokens';
-import { TableColumnType as ColumnType, Tag, Tooltip } from 'antd';
+import { Tag, Tooltip } from 'antd';
+import { TableColumnType as ColumnType } from 'antd';
 import {
 	K8sDeploymentsData,
 	K8sDeploymentsListPayload,

frontend/src/container/InfraMonitoringK8s/EntityDetailsUtils/EntityEvents/entityEvents.styles.scss

@@ -147,11 +147,9 @@
 		.ant-table-cell:nth-child(n + 3) {
 			padding-right: 24px;
 		}
-
 		.column-header-right {
 			text-align: right;
 		}
-
 		.ant-table-tbody > tr > td {
 			border-bottom: none;
 		}

frontend/src/container/InfraMonitoringK8s/EntityDetailsUtils/EntityTraces/entityTraces.styles.scss

@@ -121,11 +121,9 @@
 			.ant-table-cell:nth-child(n + 3) {
 				padding-right: 24px;
 			}
-
 			.column-header-right {
 				text-align: right;
 			}
-
 			.ant-table-tbody > tr > td {
 				border-bottom: none;
 			}

frontend/src/container/InfraMonitoringK8s/EntityDetailsUtils/entityDetails.styles.scss

@@ -102,7 +102,6 @@
 
 			.progress-container {
 				width: 158px;
-
 				.ant-progress {
 					margin: 0;
 
@@ -186,7 +185,6 @@
 			box-shadow: 0px 0px 8px 0px rgba(0, 0, 0, 0.1);
 		}
 	}
-
 	.ant-drawer-close {
 		padding: 0px;
 	}
@@ -371,11 +369,9 @@
 			.ant-table-cell:nth-child(n + 3) {
 				padding-right: 24px;
 			}
-
 			.column-header-right {
 				text-align: right;
 			}
-
 			.ant-table-tbody > tr > td {
 				border-bottom: none;
 			}

frontend/src/container/InfraMonitoringK8s/InfraMonitoringK8s.tsx

@@ -1,4 +1,5 @@
 import { useState } from 'react';
+import { useSearchParams } from 'react-router-dom-v5-compat';
 import { VerticalAlignTopOutlined } from '@ant-design/icons';
 import * as Sentry from '@sentry/react';
 import type { CollapseProps } from 'antd';
@@ -36,16 +37,11 @@ import {
 	GetPodsQuickFiltersConfig,
 	GetStatefulsetsQuickFiltersConfig,
 	GetVolumesQuickFiltersConfig,
+	INFRA_MONITORING_K8S_PARAMS_KEYS,
 	K8sCategories,
 } from './constants';
 import K8sDaemonSetsList from './DaemonSets/K8sDaemonSetsList';
 import K8sDeploymentsList from './Deployments/K8sDeploymentsList';
-import {
-	useInfraMonitoringCategory,
-	useInfraMonitoringFilters,
-	useInfraMonitoringGroupBy,
-	useInfraMonitoringOrderBy,
-} from './hooks';
 import K8sJobsList from './Jobs/K8sJobsList';
 import K8sNamespacesList from './Namespaces/K8sNamespacesList';
 import K8sNodesList from './Nodes/K8sNodesList';
@@ -58,11 +54,14 @@ import './InfraMonitoringK8s.styles.scss';
 export default function InfraMonitoringK8s(): JSX.Element {
 	const [showFilters, setShowFilters] = useState(true);
 
-	const [selectedCategory, setSelectedCategory] = useInfraMonitoringCategory();
-	const [, setFilters] = useInfraMonitoringFilters();
-	const [, setGroupBy] = useInfraMonitoringGroupBy();
-	const [, setOrderBy] = useInfraMonitoringOrderBy();
-
+	const [searchParams, setSearchParams] = useSearchParams();
+	const [selectedCategory, setSelectedCategory] = useState(() => {
+		const category = searchParams.get(INFRA_MONITORING_K8S_PARAMS_KEYS.CATEGORY);
+		if (category) {
+			return category as keyof typeof K8sCategories;
+		}
+		return K8sCategories.PODS;
+	});
 	const [quickFiltersLastUpdated, setQuickFiltersLastUpdated] = useState(-1);
 
 	const { currentQuery } = useQueryBuilder();
@@ -87,7 +86,12 @@ export default function InfraMonitoringK8s(): JSX.Element {
 		// in infra monitoring k8s, we are using only one query, hence updating the 0th index of queryData
 		handleChangeQueryData('filters', query.builder.queryData[0].filters);
 		setQuickFiltersLastUpdated(Date.now());
-		setFilters(JSON.stringify(query.builder.queryData[0].filters));
+		setSearchParams({
+			...Object.fromEntries(searchParams.entries()),
+			[INFRA_MONITORING_K8S_PARAMS_KEYS.FILTERS]: JSON.stringify(
+				query.builder.queryData[0].filters,
+			),
+		});
 
 		logEvent(InfraMonitoringEvents.FilterApplied, {
 			entity: InfraMonitoringEvents.K8sEntity,
@@ -313,10 +317,10 @@ export default function InfraMonitoringK8s(): JSX.Element {
 	const handleCategoryChange = (key: string | string[]): void => {
 		if (Array.isArray(key) && key.length > 0) {
 			setSelectedCategory(key[0] as string);
+			setSearchParams({
+				[INFRA_MONITORING_K8S_PARAMS_KEYS.CATEGORY]: key[0] as string,
+			});
 			// Reset filters
-			setFilters(null);
-			setOrderBy(null);
-			setGroupBy(null);
 			handleChangeQueryData('filters', { items: [], op: 'and' });
 		}
 	};

frontend/src/container/InfraMonitoringK8s/Jobs/JobDetails/JobDetails.tsx

@@ -2,6 +2,7 @@
 import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
 // eslint-disable-next-line no-restricted-imports
 import { useSelector } from 'react-redux';
+import { useSearchParams } from 'react-router-dom-v5-compat';
 import { Color, Spacing } from '@signozhq/design-tokens';
 import { Button, Divider, Drawer, Radio, Tooltip, Typography } from 'antd';
 import type { RadioChangeEvent } from 'antd/lib';
@@ -14,14 +15,11 @@ import {
 	initialQueryState,
 } from 'constants/queryBuilder';
 import ROUTES from 'constants/routes';
-import { filterDuplicateFilters } from 'container/InfraMonitoringK8s/commonUtils';
-import { K8sCategory } from 'container/InfraMonitoringK8s/constants';
+import { getFiltersFromParams } from 'container/InfraMonitoringK8s/commonUtils';
 import {
-	useInfraMonitoringEventsFilters,
-	useInfraMonitoringLogFilters,
-	useInfraMonitoringTracesFilters,
-	useInfraMonitoringView,
-} from 'container/InfraMonitoringK8s/hooks';
+	INFRA_MONITORING_K8S_PARAMS_KEYS,
+	K8sCategory,
+} from 'container/InfraMonitoringK8s/constants';
 import {
 	CustomTimeType,
 	Time,
@@ -92,21 +90,23 @@ function JobDetails({
 			: (selectedTime as Time),
 	);
 
-	const [selectedView, setSelectedView] = useInfraMonitoringView();
-	const [logFiltersParam, setLogFiltersParam] = useInfraMonitoringLogFilters();
-	const [
-		tracesFiltersParam,
-		setTracesFiltersParam,
-	] = useInfraMonitoringTracesFilters();
-	const [
-		eventsFiltersParam,
-		setEventsFiltersParam,
-	] = useInfraMonitoringEventsFilters();
+	const [searchParams, setSearchParams] = useSearchParams();
+	const [selectedView, setSelectedView] = useState<VIEWS>(() => {
+		const view = searchParams.get(INFRA_MONITORING_K8S_PARAMS_KEYS.VIEW);
+		if (view) {
+			return view as VIEWS;
+		}
+		return VIEWS.METRICS;
+	});
 	const isDarkMode = useIsDarkMode();
 
 	const initialFilters = useMemo(() => {
-		const filters =
-			selectedView === VIEW_TYPES.LOGS ? logFiltersParam : tracesFiltersParam;
+		const urlView = searchParams.get(INFRA_MONITORING_K8S_PARAMS_KEYS.VIEW);
+		const queryKey =
+			urlView === VIEW_TYPES.LOGS
+				? INFRA_MONITORING_K8S_PARAMS_KEYS.LOG_FILTERS
+				: INFRA_MONITORING_K8S_PARAMS_KEYS.TRACES_FILTERS;
+		const filters = getFiltersFromParams(searchParams, queryKey);
 		if (filters) {
 			return filters;
 		}
@@ -137,17 +137,15 @@ function JobDetails({
 				},
 			],
 		};
-	}, [
-		job?.meta.k8s_job_name,
-		job?.meta.k8s_namespace_name,
-		selectedView,
-		logFiltersParam,
-		tracesFiltersParam,
-	]);
+	}, [job?.meta.k8s_job_name, job?.meta.k8s_namespace_name, searchParams]);
 
 	const initialEventsFilters = useMemo(() => {
-		if (eventsFiltersParam) {
-			return eventsFiltersParam;
+		const filters = getFiltersFromParams(
+			searchParams,
+			INFRA_MONITORING_K8S_PARAMS_KEYS.EVENTS_FILTERS,
+		);
+		if (filters) {
+			return filters;
 		}
 		return {
 			op: 'AND',
@@ -176,7 +174,7 @@ function JobDetails({
 				},
 			],
 		};
-	}, [job?.meta.k8s_job_name, eventsFiltersParam]);
+	}, [job?.meta.k8s_job_name, searchParams]);
 
 	const [logAndTracesFilters, setLogAndTracesFilters] = useState<
 		IBuilderQuery['filters']
@@ -217,9 +215,13 @@ function JobDetails({
 
 	const handleTabChange = (e: RadioChangeEvent): void => {
 		setSelectedView(e.target.value);
-		setLogFiltersParam(null);
-		setTracesFiltersParam(null);
-		setEventsFiltersParam(null);
+		setSearchParams({
+			...Object.fromEntries(searchParams.entries()),
+			[INFRA_MONITORING_K8S_PARAMS_KEYS.VIEW]: e.target.value,
+			[INFRA_MONITORING_K8S_PARAMS_KEYS.LOG_FILTERS]: JSON.stringify(null),
+			[INFRA_MONITORING_K8S_PARAMS_KEYS.TRACES_FILTERS]: JSON.stringify(null),
+			[INFRA_MONITORING_K8S_PARAMS_KEYS.EVENTS_FILTERS]: JSON.stringify(null),
+		});
 		logEvent(InfraMonitoringEvents.TabChanged, {
 			entity: InfraMonitoringEvents.K8sEntity,
 			page: InfraMonitoringEvents.DetailedPage,
@@ -286,17 +288,20 @@ function JobDetails({
 
 				const updatedFilters = {
 					op: 'AND',
-					items: filterDuplicateFilters(
-						[
-							...(primaryFilters || []),
-							...(newFilters || []),
-							...(paginationFilter ? [paginationFilter] : []),
-						].filter((item): item is TagFilterItem => item !== undefined),
-					),
+					items: [
+						...(primaryFilters || []),
+						...(newFilters || []),
+						...(paginationFilter ? [paginationFilter] : []),
+					].filter((item): item is TagFilterItem => item !== undefined),
 				};
 
-				setLogFiltersParam(updatedFilters);
-				setSelectedView(view);
+				setSearchParams({
+					...Object.fromEntries(searchParams.entries()),
+					[INFRA_MONITORING_K8S_PARAMS_KEYS.LOG_FILTERS]: JSON.stringify(
+						updatedFilters,
+					),
+					[INFRA_MONITORING_K8S_PARAMS_KEYS.VIEW]: view,
+				});
 
 				return updatedFilters;
 			});
@@ -325,18 +330,21 @@ function JobDetails({
 
 				const updatedFilters = {
 					op: 'AND',
-					items: filterDuplicateFilters(
-						[
-							...(primaryFilters || []),
-							...(value?.items?.filter(
-								(item) => item.key?.key !== QUERY_KEYS.K8S_JOB_NAME,
-							) || []),
-						].filter((item): item is TagFilterItem => item !== undefined),
-					),
+					items: [
+						...(primaryFilters || []),
+						...(value?.items?.filter(
+							(item) => item.key?.key !== QUERY_KEYS.K8S_JOB_NAME,
+						) || []),
+					].filter((item): item is TagFilterItem => item !== undefined),
 				};
 
-				setTracesFiltersParam(updatedFilters);
-				setSelectedView(view);
+				setSearchParams({
+					...Object.fromEntries(searchParams.entries()),
+					[INFRA_MONITORING_K8S_PARAMS_KEYS.TRACES_FILTERS]: JSON.stringify(
+						updatedFilters,
+					),
+					[INFRA_MONITORING_K8S_PARAMS_KEYS.VIEW]: view,
+				});
 
 				return updatedFilters;
 			});
@@ -377,8 +385,13 @@ function JobDetails({
 					].filter((item): item is TagFilterItem => item !== undefined),
 				};
 
-				setEventsFiltersParam(updatedFilters);
-				setSelectedView(view);
+				setSearchParams({
+					...Object.fromEntries(searchParams.entries()),
+					[INFRA_MONITORING_K8S_PARAMS_KEYS.EVENTS_FILTERS]: JSON.stringify(
+						updatedFilters,
+					),
+					[INFRA_MONITORING_K8S_PARAMS_KEYS.VIEW]: view,
+				});
 
 				return updatedFilters;
 			});

frontend/src/container/InfraMonitoringK8s/Jobs/K8sJobsList.tsx

@@ -1,6 +1,7 @@
-import React, { useCallback, useEffect, useMemo, useState } from 'react';
+import { useCallback, useEffect, useMemo, useState } from 'react';
 // eslint-disable-next-line no-restricted-imports
 import { useSelector } from 'react-redux';
+import { useSearchParams } from 'react-router-dom-v5-compat';
 import { LoadingOutlined } from '@ant-design/icons';
 import {
 	Button,
@@ -16,34 +17,23 @@ import logEvent from 'api/common/logEvent';
 import { K8sJobsListPayload } from 'api/infraMonitoring/getK8sJobsList';
 import classNames from 'classnames';
 import { InfraMonitoringEvents } from 'constants/events';
-import { FeatureKeys } from 'constants/features';
 import { useGetK8sJobsList } from 'hooks/infraMonitoring/useGetK8sJobsList';
 import { useGetAggregateKeys } from 'hooks/queryBuilder/useGetAggregateKeys';
 import { useQueryBuilder } from 'hooks/queryBuilder/useQueryBuilder';
 import { useQueryOperations } from 'hooks/queryBuilder/useQueryBuilderOperations';
 import { ChevronDown, ChevronRight } from 'lucide-react';
-import { useAppContext } from 'providers/App/App';
 import { AppState } from 'store/reducers';
 import { IBuilderQuery } from 'types/api/queryBuilder/queryBuilderData';
 import { GlobalReducer } from 'types/reducer/globalTime';
-import { buildAbsolutePath, isModifierKeyPressed } from 'utils/app';
-import { openInNewTab } from 'utils/navigation';
 
+import { FeatureKeys } from '../../../constants/features';
+import { useAppContext } from '../../../providers/App/App';
+import { getOrderByFromParams } from '../commonUtils';
 import {
 	GetK8sEntityToAggregateAttribute,
 	INFRA_MONITORING_K8S_PARAMS_KEYS,
 	K8sCategory,
 } from '../constants';
-import {
-	useInfraMonitoringCurrentPage,
-	useInfraMonitoringEventsFilters,
-	useInfraMonitoringGroupBy,
-	useInfraMonitoringJobUID,
-	useInfraMonitoringLogFilters,
-	useInfraMonitoringOrderBy,
-	useInfraMonitoringTracesFilters,
-	useInfraMonitoringView,
-} from '../hooks';
 import K8sHeader from '../K8sHeader';
 import LoadingContainer from '../LoadingContainer';
 import { usePageSize } from '../utils';
@@ -71,24 +61,51 @@ function K8sJobsList({
 	const { maxTime, minTime } = useSelector<AppState, GlobalReducer>(
 		(state) => state.globalTime,
 	);
+	const [searchParams, setSearchParams] = useSearchParams();
 
-	const [currentPage, setCurrentPage] = useInfraMonitoringCurrentPage();
+	const [currentPage, setCurrentPage] = useState(() => {
+		const page = searchParams.get(INFRA_MONITORING_K8S_PARAMS_KEYS.CURRENT_PAGE);
+		if (page) {
+			return parseInt(page, 10);
+		}
+		return 1;
+	});
 	const [filtersInitialised, setFiltersInitialised] = useState(false);
 
+	useEffect(() => {
+		setSearchParams({
+			...Object.fromEntries(searchParams.entries()),
+			[INFRA_MONITORING_K8S_PARAMS_KEYS.CURRENT_PAGE]: currentPage.toString(),
+		});
+		// eslint-disable-next-line react-hooks/exhaustive-deps
+	}, [currentPage]);
+
 	const [expandedRowKeys, setExpandedRowKeys] = useState<string[]>([]);
 
-	const [orderBy, setOrderBy] = useInfraMonitoringOrderBy();
+	const [orderBy, setOrderBy] = useState<{
+		columnName: string;
+		order: 'asc' | 'desc';
+	} | null>(() => getOrderByFromParams(searchParams, true));
 
-	const [selectedJobUID, setselectedJobUID] = useInfraMonitoringJobUID();
+	const [selectedJobUID, setselectedJobUID] = useState<string | null>(() => {
+		const jobUID = searchParams.get(INFRA_MONITORING_K8S_PARAMS_KEYS.JOB_UID);
+		if (jobUID) {
+			return jobUID;
+		}
+		return null;
+	});
 
 	const { pageSize, setPageSize } = usePageSize(K8sCategory.JOBS);
 
-	const [groupBy, setGroupBy] = useInfraMonitoringGroupBy();
-
-	const [, setView] = useInfraMonitoringView();
-	const [, setTracesFilters] = useInfraMonitoringTracesFilters();
-	const [, setEventsFilters] = useInfraMonitoringEventsFilters();
-	const [, setLogFilters] = useInfraMonitoringLogFilters();
+	const [groupBy, setGroupBy] = useState<IBuilderQuery['groupBy']>(() => {
+		const groupBy = searchParams.get(INFRA_MONITORING_K8S_PARAMS_KEYS.GROUP_BY);
+		if (groupBy) {
+			const decoded = decodeURIComponent(groupBy);
+			const parsed = JSON.parse(decoded);
+			return parsed as IBuilderQuery['groupBy'];
+		}
+		return [];
+	});
 
 	const [selectedRowData, setSelectedRowData] = useState<K8sJobsRowData | null>(
 		null,
@@ -114,7 +131,7 @@ function K8sJobsList({
 		if (quickFiltersLastUpdated !== -1) {
 			setCurrentPage(1);
 		}
-	}, [quickFiltersLastUpdated, setCurrentPage]);
+	}, [quickFiltersLastUpdated]);
 
 	const { featureFlags } = useAppContext();
 	const dotMetricsEnabled =
@@ -167,28 +184,25 @@ function K8sJobsList({
 			filters,
 			start: Math.floor(minTime / 1000000),
 			end: Math.floor(maxTime / 1000000),
-			orderBy: orderBy || baseQuery.orderBy,
+			orderBy,
 		};
 		// eslint-disable-next-line react-hooks/exhaustive-deps
 	}, [minTime, maxTime, orderBy, selectedRowData, groupBy]);
 
 	const groupedByRowDataQueryKey = useMemo(() => {
-		// be careful with what you serialize from selectedRowData
-		// since it's react node, it could contain circular references
-		const selectedRowDataKey = JSON.stringify(selectedRowData?.groupedByMeta);
 		if (selectedJobUID) {
 			return [
 				'jobList',
 				JSON.stringify(queryFilters),
 				JSON.stringify(orderBy),
-				selectedRowDataKey,
+				JSON.stringify(selectedRowData),
 			];
 		}
 		return [
 			'jobList',
 			JSON.stringify(queryFilters),
 			JSON.stringify(orderBy),
-			selectedRowDataKey,
+			JSON.stringify(selectedRowData),
 			String(minTime),
 			String(maxTime),
 		];
@@ -240,7 +254,7 @@ function K8sJobsList({
 			filters: queryFilters,
 			start: Math.floor(minTime / 1000000),
 			end: Math.floor(maxTime / 1000000),
-			orderBy: orderBy || baseQuery.orderBy,
+			orderBy,
 		};
 		if (groupBy.length > 0) {
 			queryPayload.groupBy = groupBy;
@@ -346,15 +360,26 @@ function K8sJobsList({
 			}
 
 			if ('field' in sorter && sorter.order) {
-				setOrderBy({
+				const currentOrderBy = {
 					columnName: sorter.field as string,
 					order: (sorter.order === 'ascend' ? 'asc' : 'desc') as 'asc' | 'desc',
+				};
+				setOrderBy(currentOrderBy);
+				setSearchParams({
+					...Object.fromEntries(searchParams.entries()),
+					[INFRA_MONITORING_K8S_PARAMS_KEYS.ORDER_BY]: JSON.stringify(
+						currentOrderBy,
+					),
 				});
 			} else {
 				setOrderBy(null);
+				setSearchParams({
+					...Object.fromEntries(searchParams.entries()),
+					[INFRA_MONITORING_K8S_PARAMS_KEYS.ORDER_BY]: JSON.stringify(null),
+				});
 			}
 		},
-		[setCurrentPage, setOrderBy],
+		[searchParams, setSearchParams],
 	);
 
 	const { handleChangeQueryData } = useQueryOperations({
@@ -402,28 +427,14 @@ function K8sJobsList({
 		return jobsData.find((job) => job.jobName === selectedJobUID) || null;
 	}, [selectedJobUID, groupBy.length, jobsData, nestedJobsData]);
 
-	const openJobInNewTab = (record: K8sJobsRowData): void => {
-		const newParams = new URLSearchParams(document.location.search);
-		newParams.set(INFRA_MONITORING_K8S_PARAMS_KEYS.JOB_UID, record.jobUID);
-		openInNewTab(
-			buildAbsolutePath({
-				relativePath: '',
-				urlQueryString: newParams.toString(),
-			}),
-		);
-	};
-
-	const handleRowClick = (
-		record: K8sJobsRowData,
-		event: React.MouseEvent,
-	): void => {
-		if (event && isModifierKeyPressed(event)) {
-			openJobInNewTab(record);
-			return;
-		}
+	const handleRowClick = (record: K8sJobsRowData): void => {
 		if (groupBy.length === 0) {
 			setSelectedRowData(null);
 			setselectedJobUID(record.jobUID);
+			setSearchParams({
+				...Object.fromEntries(searchParams.entries()),
+				[INFRA_MONITORING_K8S_PARAMS_KEYS.JOB_UID]: record.jobUID,
+			});
 		} else {
 			handleGroupByRowClick(record);
 		}
@@ -452,6 +463,11 @@ function K8sJobsList({
 		setSelectedRowData(null);
 		setGroupBy([]);
 		setOrderBy(null);
+		setSearchParams({
+			...Object.fromEntries(searchParams.entries()),
+			[INFRA_MONITORING_K8S_PARAMS_KEYS.GROUP_BY]: JSON.stringify([]),
+			[INFRA_MONITORING_K8S_PARAMS_KEYS.ORDER_BY]: JSON.stringify(null),
+		});
 	};
 
 	const expandedRowRender = (): JSX.Element => (
@@ -475,14 +491,8 @@ function K8sJobsList({
 							indicator: <Spin indicator={<LoadingOutlined size={14} spin />} />,
 						}}
 						showHeader={false}
-						onRow={(
-							record,
-						): { onClick: (event: React.MouseEvent) => void; className: string } => ({
-							onClick: (event: React.MouseEvent): void => {
-								if (event && isModifierKeyPressed(event)) {
-									openJobInNewTab(record);
-									return;
-								}
+						onRow={(record): { onClick: () => void; className: string } => ({
+							onClick: (): void => {
 								setselectedJobUID(record.jobUID);
 							},
 							className: 'expanded-clickable-row',
@@ -548,10 +558,20 @@ function K8sJobsList({
 
 	const handleCloseJobDetail = (): void => {
 		setselectedJobUID(null);
-		setView(null);
-		setTracesFilters(null);
-		setEventsFilters(null);
-		setLogFilters(null);
+		setSearchParams({
+			...Object.fromEntries(
+				Array.from(searchParams.entries()).filter(
+					([key]) =>
+						![
+							INFRA_MONITORING_K8S_PARAMS_KEYS.JOB_UID,
+							INFRA_MONITORING_K8S_PARAMS_KEYS.VIEW,
+							INFRA_MONITORING_K8S_PARAMS_KEYS.TRACES_FILTERS,
+							INFRA_MONITORING_K8S_PARAMS_KEYS.EVENTS_FILTERS,
+							INFRA_MONITORING_K8S_PARAMS_KEYS.LOG_FILTERS,
+						].includes(key),
+				),
+			),
+		});
 	};
 
 	const handleGroupByChange = useCallback(
@@ -573,6 +593,10 @@ function K8sJobsList({
 			setCurrentPage(1);
 			setGroupBy(groupBy);
 			setExpandedRowKeys([]);
+			setSearchParams({
+				...Object.fromEntries(searchParams.entries()),
+				[INFRA_MONITORING_K8S_PARAMS_KEYS.GROUP_BY]: JSON.stringify(groupBy),
+			});
 
 			logEvent(InfraMonitoringEvents.GroupByChanged, {
 				entity: InfraMonitoringEvents.K8sEntity,
@@ -580,7 +604,7 @@ function K8sJobsList({
 				category: InfraMonitoringEvents.Job,
 			});
 		},
-		[groupByFiltersData, setCurrentPage, setGroupBy],
+		[groupByFiltersData, searchParams, setSearchParams],
 	);
 
 	useEffect(() => {
@@ -659,10 +683,8 @@ function K8sJobsList({
 				}}
 				tableLayout="fixed"
 				onChange={handleTableChange}
-				onRow={(
-					record,
-				): { onClick: (event: React.MouseEvent) => void; className: string } => ({
-					onClick: (event: React.MouseEvent): void => handleRowClick(record, event),
+				onRow={(record): { onClick: () => void; className: string } => ({
+					onClick: (): void => handleRowClick(record),
 					className: 'clickable-row',
 				})}
 				expandable={{

frontend/src/container/InfraMonitoringK8s/Jobs/utils.tsx

@@ -1,5 +1,6 @@
 import { Color } from '@signozhq/design-tokens';
-import { TableColumnType as ColumnType, Tag, Tooltip } from 'antd';
+import { Tag, Tooltip } from 'antd';
+import { TableColumnType as ColumnType } from 'antd';
 import {
 	K8sJobsData,
 	K8sJobsListPayload,

frontend/src/container/InfraMonitoringK8s/K8sHeader.tsx

@@ -1,5 +1,6 @@
 /* eslint-disable @typescript-eslint/explicit-function-return-type */
 import { useCallback, useMemo, useState } from 'react';
+import { useSearchParams } from 'react-router-dom-v5-compat';
 import { Button, Select } from 'antd';
 import { initialQueriesMap } from 'constants/queryBuilder';
 import QueryBuilderSearch from 'container/QueryBuilder/filters/QueryBuilderSearch';
@@ -9,8 +10,7 @@ import { BaseAutocompleteData } from 'types/api/queryBuilder/queryAutocompleteRe
 import { IBuilderQuery } from 'types/api/queryBuilder/queryBuilderData';
 import { DataSource } from 'types/common/queryBuilder';
 
-import { K8sCategory } from './constants';
-import { useInfraMonitoringFiltersK8s } from './hooks';
+import { INFRA_MONITORING_K8S_PARAMS_KEYS, K8sCategory } from './constants';
 import K8sFiltersSidePanel from './K8sFiltersSidePanel/K8sFiltersSidePanel';
 import { IEntityColumn } from './utils';
 
@@ -50,14 +50,17 @@ function K8sHeader({
 	showAutoRefresh,
 }: K8sHeaderProps): JSX.Element {
 	const [isFiltersSidePanelOpen, setIsFiltersSidePanelOpen] = useState(false);
-	const [urlFilters, setUrlFilters] = useInfraMonitoringFiltersK8s();
+	const [searchParams, setSearchParams] = useSearchParams();
 
 	const currentQuery = initialQueriesMap[DataSource.METRICS];
 
 	const updatedCurrentQuery = useMemo(() => {
+		const urlFilters = searchParams.get(INFRA_MONITORING_K8S_PARAMS_KEYS.FILTERS);
 		let { filters } = currentQuery.builder.queryData[0];
 		if (urlFilters) {
-			filters = urlFilters;
+			const decoded = decodeURIComponent(urlFilters);
+			const parsed = JSON.parse(decoded);
+			filters = parsed;
 		}
 		return {
 			...currentQuery,
@@ -75,16 +78,19 @@ function K8sHeader({
 				],
 			},
 		};
-	}, [currentQuery, urlFilters]);
+	}, [currentQuery, searchParams]);
 
 	const query = updatedCurrentQuery?.builder?.queryData[0] || null;
 
 	const handleChangeTagFilters = useCallback(
 		(value: IBuilderQuery['filters']) => {
 			handleFiltersChange(value);
-			setUrlFilters(value || null);
+			setSearchParams({
+				...Object.fromEntries(searchParams.entries()),
+				[INFRA_MONITORING_K8S_PARAMS_KEYS.FILTERS]: JSON.stringify(value),
+			});
 		},
-		[handleFiltersChange, setUrlFilters],
+		[handleFiltersChange, searchParams, setSearchParams],
 	);
 
 	return (

frontend/src/container/InfraMonitoringK8s/Namespaces/K8sNamespacesList.tsx

@@ -1,6 +1,7 @@
-import React, { useCallback, useEffect, useMemo, useState } from 'react';
+import { useCallback, useEffect, useMemo, useState } from 'react';
 // eslint-disable-next-line no-restricted-imports
 import { useSelector } from 'react-redux';
+import { useSearchParams } from 'react-router-dom-v5-compat';
 import { LoadingOutlined } from '@ant-design/icons';
 import {
 	Button,
@@ -15,34 +16,23 @@ import type { SorterResult } from 'antd/es/table/interface';
 import logEvent from 'api/common/logEvent';
 import { K8sNamespacesListPayload } from 'api/infraMonitoring/getK8sNamespacesList';
 import { InfraMonitoringEvents } from 'constants/events';
-import { FeatureKeys } from 'constants/features';
 import { useGetK8sNamespacesList } from 'hooks/infraMonitoring/useGetK8sNamespacesList';
 import { useGetAggregateKeys } from 'hooks/queryBuilder/useGetAggregateKeys';
 import { useQueryBuilder } from 'hooks/queryBuilder/useQueryBuilder';
 import { useQueryOperations } from 'hooks/queryBuilder/useQueryBuilderOperations';
 import { ChevronDown, ChevronRight } from 'lucide-react';
-import { useAppContext } from 'providers/App/App';
 import { AppState } from 'store/reducers';
 import { IBuilderQuery } from 'types/api/queryBuilder/queryBuilderData';
 import { GlobalReducer } from 'types/reducer/globalTime';
-import { buildAbsolutePath, isModifierKeyPressed } from 'utils/app';
-import { openInNewTab } from 'utils/navigation';
 
+import { FeatureKeys } from '../../../constants/features';
+import { useAppContext } from '../../../providers/App/App';
+import { getOrderByFromParams } from '../commonUtils';
 import {
 	GetK8sEntityToAggregateAttribute,
 	INFRA_MONITORING_K8S_PARAMS_KEYS,
 	K8sCategory,
 } from '../constants';
-import {
-	useInfraMonitoringCurrentPage,
-	useInfraMonitoringEventsFilters,
-	useInfraMonitoringGroupBy,
-	useInfraMonitoringLogFilters,
-	useInfraMonitoringNamespaceUID,
-	useInfraMonitoringOrderBy,
-	useInfraMonitoringTracesFilters,
-	useInfraMonitoringView,
-} from '../hooks';
 import K8sHeader from '../K8sHeader';
 import LoadingContainer from '../LoadingContainer';
 import { usePageSize } from '../utils';
@@ -72,25 +62,53 @@ function K8sNamespacesList({
 	);
 
 	const [expandedRowKeys, setExpandedRowKeys] = useState<string[]>([]);
+	const [searchParams, setSearchParams] = useSearchParams();
 
-	const [currentPage, setCurrentPage] = useInfraMonitoringCurrentPage();
+	const [currentPage, setCurrentPage] = useState(() => {
+		const page = searchParams.get(INFRA_MONITORING_K8S_PARAMS_KEYS.CURRENT_PAGE);
+		if (page) {
+			return parseInt(page, 10);
+		}
+		return 1;
+	});
 	const [filtersInitialised, setFiltersInitialised] = useState(false);
 
-	const [orderBy, setOrderBy] = useInfraMonitoringOrderBy();
+	useEffect(() => {
+		setSearchParams({
+			...Object.fromEntries(searchParams.entries()),
+			[INFRA_MONITORING_K8S_PARAMS_KEYS.CURRENT_PAGE]: currentPage.toString(),
+		});
+		// eslint-disable-next-line react-hooks/exhaustive-deps
+	}, [currentPage]);
 
-	const [
-		selectedNamespaceUID,
-		setselectedNamespaceUID,
-	] = useInfraMonitoringNamespaceUID();
+	const [orderBy, setOrderBy] = useState<{
+		columnName: string;
+		order: 'asc' | 'desc';
+	} | null>(() => getOrderByFromParams(searchParams, true));
+
+	const [selectedNamespaceUID, setselectedNamespaceUID] = useState<
+		string | null
+	>(() => {
+		const namespaceUID = searchParams.get(
+			INFRA_MONITORING_K8S_PARAMS_KEYS.NAMESPACE_UID,
+		);
+		if (namespaceUID) {
+			return namespaceUID;
+		}
+		return null;
+	});
 
 	const { pageSize, setPageSize } = usePageSize(K8sCategory.NAMESPACES);
 
-	const [groupBy, setGroupBy] = useInfraMonitoringGroupBy();
-
-	const [, setView] = useInfraMonitoringView();
-	const [, setTracesFilters] = useInfraMonitoringTracesFilters();
-	const [, setEventsFilters] = useInfraMonitoringEventsFilters();
-	const [, setLogFilters] = useInfraMonitoringLogFilters();
+	const [groupBy, setGroupBy] = useState<IBuilderQuery['groupBy']>(() => {
+		const groupBy = searchParams.get(INFRA_MONITORING_K8S_PARAMS_KEYS.GROUP_BY);
+		if (groupBy) {
+			const decoded = decodeURIComponent(groupBy);
+			const parsed = JSON.parse(decoded);
+			return parsed as IBuilderQuery['groupBy'];
+		}
+		return [];
+	});
 
 	const [
 		selectedRowData,
@@ -117,7 +135,7 @@ function K8sNamespacesList({
 		if (quickFiltersLastUpdated !== -1) {
 			setCurrentPage(1);
 		}
-	}, [quickFiltersLastUpdated, setCurrentPage]);
+	}, [quickFiltersLastUpdated]);
 
 	const { featureFlags } = useAppContext();
 	const dotMetricsEnabled =
@@ -170,28 +188,25 @@ function K8sNamespacesList({
 			filters,
 			start: Math.floor(minTime / 1000000),
 			end: Math.floor(maxTime / 1000000),
-			orderBy: orderBy || baseQuery.orderBy,
+			orderBy,
 		};
 		// eslint-disable-next-line react-hooks/exhaustive-deps
 	}, [minTime, maxTime, orderBy, selectedRowData, groupBy]);
 
 	const groupedByRowDataQueryKey = useMemo(() => {
-		// be careful with what you serialize from selectedRowData
-		// since it's react node, it could contain circular references
-		const selectedRowDataKey = JSON.stringify(selectedRowData?.groupedByMeta);
 		if (selectedNamespaceUID) {
 			return [
 				'namespaceList',
 				JSON.stringify(queryFilters),
 				JSON.stringify(orderBy),
-				selectedRowDataKey,
+				JSON.stringify(selectedRowData),
 			];
 		}
 		return [
 			'namespaceList',
 			JSON.stringify(queryFilters),
 			JSON.stringify(orderBy),
-			selectedRowDataKey,
+			JSON.stringify(selectedRowData),
 			String(minTime),
 			String(maxTime),
 		];
@@ -250,7 +265,7 @@ function K8sNamespacesList({
 			filters: queryFilters,
 			start: Math.floor(minTime / 1000000),
 			end: Math.floor(maxTime / 1000000),
-			orderBy: orderBy || baseQuery.orderBy,
+			orderBy,
 		};
 		if (groupBy.length > 0) {
 			queryPayload.groupBy = groupBy;
@@ -360,15 +375,26 @@ function K8sNamespacesList({
 			}
 
 			if ('field' in sorter && sorter.order) {
-				setOrderBy({
+				const currentOrderBy = {
 					columnName: sorter.field as string,
 					order: (sorter.order === 'ascend' ? 'asc' : 'desc') as 'asc' | 'desc',
+				};
+				setOrderBy(currentOrderBy);
+				setSearchParams({
+					...Object.fromEntries(searchParams.entries()),
+					[INFRA_MONITORING_K8S_PARAMS_KEYS.ORDER_BY]: JSON.stringify(
+						currentOrderBy,
+					),
 				});
 			} else {
 				setOrderBy(null);
+				setSearchParams({
+					...Object.fromEntries(searchParams.entries()),
+					[INFRA_MONITORING_K8S_PARAMS_KEYS.ORDER_BY]: JSON.stringify(null),
+				});
 			}
 		},
-		[setCurrentPage, setOrderBy],
+		[searchParams, setSearchParams],
 	);
 
 	const { handleChangeQueryData } = useQueryOperations({
@@ -432,31 +458,14 @@ function K8sNamespacesList({
 		nestedNamespacesData,
 	]);
 
-	const openNamespaceInNewTab = (record: K8sNamespacesRowData): void => {
-		const newParams = new URLSearchParams(document.location.search);
-		newParams.set(
-			INFRA_MONITORING_K8S_PARAMS_KEYS.NAMESPACE_UID,
-			record.namespaceUID,
-		);
-		openInNewTab(
-			buildAbsolutePath({
-				relativePath: '',
-				urlQueryString: newParams.toString(),
-			}),
-		);
-	};
-
-	const handleRowClick = (
-		record: K8sNamespacesRowData,
-		event: React.MouseEvent,
-	): void => {
-		if (event && isModifierKeyPressed(event)) {
-			openNamespaceInNewTab(record);
-			return;
-		}
+	const handleRowClick = (record: K8sNamespacesRowData): void => {
 		if (groupBy.length === 0) {
 			setSelectedRowData(null);
 			setselectedNamespaceUID(record.namespaceUID);
+			setSearchParams({
+				...Object.fromEntries(searchParams.entries()),
+				[INFRA_MONITORING_K8S_PARAMS_KEYS.NAMESPACE_UID]: record.namespaceUID,
+			});
 		} else {
 			handleGroupByRowClick(record);
 		}
@@ -485,6 +494,11 @@ function K8sNamespacesList({
 		setSelectedRowData(null);
 		setGroupBy([]);
 		setOrderBy(null);
+		setSearchParams({
+			...Object.fromEntries(searchParams.entries()),
+			[INFRA_MONITORING_K8S_PARAMS_KEYS.GROUP_BY]: JSON.stringify([]),
+			[INFRA_MONITORING_K8S_PARAMS_KEYS.ORDER_BY]: JSON.stringify(null),
+		});
 	};
 
 	const expandedRowRender = (): JSX.Element => (
@@ -508,14 +522,8 @@ function K8sNamespacesList({
 							indicator: <Spin indicator={<LoadingOutlined size={14} spin />} />,
 						}}
 						showHeader={false}
-						onRow={(
-							record,
-						): { onClick: (event: React.MouseEvent) => void; className: string } => ({
-							onClick: (event: React.MouseEvent): void => {
-								if (isModifierKeyPressed(event)) {
-									openNamespaceInNewTab(record);
-									return;
-								}
+						onRow={(record): { onClick: () => void; className: string } => ({
+							onClick: (): void => {
 								setselectedNamespaceUID(record.namespaceUID);
 							},
 							className: 'expanded-clickable-row',
@@ -581,10 +589,20 @@ function K8sNamespacesList({
 
 	const handleCloseNamespaceDetail = (): void => {
 		setselectedNamespaceUID(null);
-		setView(null);
-		setTracesFilters(null);
-		setEventsFilters(null);
-		setLogFilters(null);
+		setSearchParams({
+			...Object.fromEntries(
+				Array.from(searchParams.entries()).filter(
+					([key]) =>
+						![
+							INFRA_MONITORING_K8S_PARAMS_KEYS.NAMESPACE_UID,
+							INFRA_MONITORING_K8S_PARAMS_KEYS.VIEW,
+							INFRA_MONITORING_K8S_PARAMS_KEYS.TRACES_FILTERS,
+							INFRA_MONITORING_K8S_PARAMS_KEYS.EVENTS_FILTERS,
+							INFRA_MONITORING_K8S_PARAMS_KEYS.LOG_FILTERS,
+						].includes(key),
+				),
+			),
+		});
 	};
 
 	const handleGroupByChange = useCallback(
@@ -607,6 +625,10 @@ function K8sNamespacesList({
 			setCurrentPage(1);
 			setGroupBy(groupBy);
 			setExpandedRowKeys([]);
+			setSearchParams({
+				...Object.fromEntries(searchParams.entries()),
+				[INFRA_MONITORING_K8S_PARAMS_KEYS.GROUP_BY]: JSON.stringify(groupBy),
+			});
 
 			logEvent(InfraMonitoringEvents.GroupByChanged, {
 				entity: InfraMonitoringEvents.K8sEntity,
@@ -614,7 +636,7 @@ function K8sNamespacesList({
 				category: InfraMonitoringEvents.Namespace,
 			});
 		},
-		[groupByFiltersData, setCurrentPage, setGroupBy],
+		[groupByFiltersData, searchParams, setSearchParams],
 	);
 
 	useEffect(() => {
@@ -693,10 +715,8 @@ function K8sNamespacesList({
 				}}
 				tableLayout="fixed"
 				onChange={handleTableChange}
-				onRow={(
-					record,
-				): { onClick: (event: React.MouseEvent) => void; className: string } => ({
-					onClick: (event: React.MouseEvent): void => handleRowClick(record, event),
+				onRow={(record): { onClick: () => void; className: string } => ({
+					onClick: (): void => handleRowClick(record),
 					className: 'clickable-row',
 				})}
 				expandable={{

frontend/src/container/InfraMonitoringK8s/Namespaces/NamespaceDetails/NamespaceDetails.styles.scss

@@ -101,7 +101,6 @@
 
 			.progress-container {
 				width: 158px;
-
 				.ant-progress {
 					margin: 0;
 
@@ -185,7 +184,6 @@
 			box-shadow: 0px 0px 8px 0px rgba(0, 0, 0, 0.1);
 		}
 	}
-
 	.ant-drawer-close {
 		padding: 0px;
 	}

frontend/src/container/InfraMonitoringK8s/Namespaces/NamespaceDetails/NamespaceDetails.tsx

@@ -2,6 +2,7 @@
 import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
 // eslint-disable-next-line no-restricted-imports
 import { useSelector } from 'react-redux';
+import { useSearchParams } from 'react-router-dom-v5-compat';
 import { Color, Spacing } from '@signozhq/design-tokens';
 import { Button, Divider, Drawer, Radio, Tooltip, Typography } from 'antd';
 import type { RadioChangeEvent } from 'antd/lib';
@@ -15,15 +16,12 @@ import {
 	initialQueryState,
 } from 'constants/queryBuilder';
 import ROUTES from 'constants/routes';
-import { filterDuplicateFilters } from 'container/InfraMonitoringK8s/commonUtils';
-import { K8sCategory } from 'container/InfraMonitoringK8s/constants';
-import { QUERY_KEYS } from 'container/InfraMonitoringK8s/EntityDetailsUtils/utils';
+import { getFiltersFromParams } from 'container/InfraMonitoringK8s/commonUtils';
 import {
-	useInfraMonitoringEventsFilters,
-	useInfraMonitoringLogFilters,
-	useInfraMonitoringTracesFilters,
-	useInfraMonitoringView,
-} from 'container/InfraMonitoringK8s/hooks';
+	INFRA_MONITORING_K8S_PARAMS_KEYS,
+	K8sCategory,
+} from 'container/InfraMonitoringK8s/constants';
+import { QUERY_KEYS } from 'container/InfraMonitoringK8s/EntityDetailsUtils/utils';
 import {
 	CustomTimeType,
 	Time,
@@ -96,21 +94,23 @@ function NamespaceDetails({
 			: (selectedTime as Time),
 	);
 
-	const [selectedView, setSelectedView] = useInfraMonitoringView();
-	const [logFiltersParam, setLogFiltersParam] = useInfraMonitoringLogFilters();
-	const [
-		tracesFiltersParam,
-		setTracesFiltersParam,
-	] = useInfraMonitoringTracesFilters();
-	const [
-		eventsFiltersParam,
-		setEventsFiltersParam,
-	] = useInfraMonitoringEventsFilters();
+	const [searchParams, setSearchParams] = useSearchParams();
+	const [selectedView, setSelectedView] = useState<VIEWS>(() => {
+		const view = searchParams.get(INFRA_MONITORING_K8S_PARAMS_KEYS.VIEW);
+		if (view) {
+			return view as VIEWS;
+		}
+		return VIEWS.METRICS;
+	});
 	const isDarkMode = useIsDarkMode();
 
 	const initialFilters = useMemo(() => {
-		const filters =
-			selectedView === VIEW_TYPES.LOGS ? logFiltersParam : tracesFiltersParam;
+		const urlView = searchParams.get(INFRA_MONITORING_K8S_PARAMS_KEYS.VIEW);
+		const queryKey =
+			urlView === VIEW_TYPES.LOGS
+				? INFRA_MONITORING_K8S_PARAMS_KEYS.LOG_FILTERS
+				: INFRA_MONITORING_K8S_PARAMS_KEYS.TRACES_FILTERS;
+		const filters = getFiltersFromParams(searchParams, queryKey);
 		if (filters) {
 			return filters;
 		}
@@ -130,16 +130,15 @@ function NamespaceDetails({
 				},
 			],
 		};
-	}, [
-		namespace?.namespaceName,
-		selectedView,
-		logFiltersParam,
-		tracesFiltersParam,
-	]);
+	}, [namespace?.namespaceName, searchParams]);
 
 	const initialEventsFilters = useMemo(() => {
-		if (eventsFiltersParam) {
-			return eventsFiltersParam;
+		const filters = getFiltersFromParams(
+			searchParams,
+			INFRA_MONITORING_K8S_PARAMS_KEYS.EVENTS_FILTERS,
+		);
+		if (filters) {
+			return filters;
 		}
 		return {
 			op: 'AND',
@@ -168,7 +167,7 @@ function NamespaceDetails({
 				},
 			],
 		};
-	}, [namespace?.namespaceName, eventsFiltersParam]);
+	}, [namespace?.namespaceName, searchParams]);
 
 	const [logAndTracesFilters, setLogAndTracesFilters] = useState<
 		IBuilderQuery['filters']
@@ -209,9 +208,13 @@ function NamespaceDetails({
 
 	const handleTabChange = (e: RadioChangeEvent): void => {
 		setSelectedView(e.target.value);
-		setLogFiltersParam(null);
-		setTracesFiltersParam(null);
-		setEventsFiltersParam(null);
+		setSearchParams({
+			...Object.fromEntries(searchParams.entries()),
+			[INFRA_MONITORING_K8S_PARAMS_KEYS.VIEW]: e.target.value,
+			[INFRA_MONITORING_K8S_PARAMS_KEYS.LOG_FILTERS]: JSON.stringify(null),
+			[INFRA_MONITORING_K8S_PARAMS_KEYS.TRACES_FILTERS]: JSON.stringify(null),
+			[INFRA_MONITORING_K8S_PARAMS_KEYS.EVENTS_FILTERS]: JSON.stringify(null),
+		});
 		logEvent(InfraMonitoringEvents.TabChanged, {
 			entity: InfraMonitoringEvents.K8sEntity,
 			page: InfraMonitoringEvents.DetailedPage,
@@ -278,17 +281,21 @@ function NamespaceDetails({
 
 				const updatedFilters = {
 					op: 'AND',
-					items: filterDuplicateFilters(
-						[
-							...(primaryFilters || []),
-							...(newFilters || []),
-							...(paginationFilter ? [paginationFilter] : []),
-						].filter((item): item is TagFilterItem => item !== undefined),
-					),
+					items: [
+						...(primaryFilters || []),
+						...(newFilters || []),
+						...(paginationFilter ? [paginationFilter] : []),
+					].filter((item): item is TagFilterItem => item !== undefined),
 				};
 
-				setLogFiltersParam(updatedFilters);
-				setSelectedView(view);
+				setSearchParams({
+					...Object.fromEntries(searchParams.entries()),
+					[INFRA_MONITORING_K8S_PARAMS_KEYS.VIEW]: view,
+					[INFRA_MONITORING_K8S_PARAMS_KEYS.LOG_FILTERS]: JSON.stringify(
+						updatedFilters,
+					),
+					[INFRA_MONITORING_K8S_PARAMS_KEYS.VIEW]: view,
+				});
 
 				return updatedFilters;
 			});
@@ -317,18 +324,21 @@ function NamespaceDetails({
 
 				const updatedFilters = {
 					op: 'AND',
-					items: filterDuplicateFilters(
-						[
-							...(primaryFilters || []),
-							...(value?.items?.filter(
-								(item) => item.key?.key !== QUERY_KEYS.K8S_NAMESPACE_NAME,
-							) || []),
-						].filter((item): item is TagFilterItem => item !== undefined),
-					),
+					items: [
+						...(primaryFilters || []),
+						...(value?.items?.filter(
+							(item) => item.key?.key !== QUERY_KEYS.K8S_NAMESPACE_NAME,
+						) || []),
+					].filter((item): item is TagFilterItem => item !== undefined),
 				};
 
-				setTracesFiltersParam(updatedFilters);
-				setSelectedView(view);
+				setSearchParams({
+					...Object.fromEntries(searchParams.entries()),
+					[INFRA_MONITORING_K8S_PARAMS_KEYS.VIEW]: view,
+					[INFRA_MONITORING_K8S_PARAMS_KEYS.TRACES_FILTERS]: JSON.stringify(
+						updatedFilters,
+					),
+				});
 
 				return updatedFilters;
 			});
@@ -369,8 +379,13 @@ function NamespaceDetails({
 					].filter((item): item is TagFilterItem => item !== undefined),
 				};
 
-				setEventsFiltersParam(updatedFilters);
-				setSelectedView(view);
+				setSearchParams({
+					...Object.fromEntries(searchParams.entries()),
+					[INFRA_MONITORING_K8S_PARAMS_KEYS.VIEW]: view,
+					[INFRA_MONITORING_K8S_PARAMS_KEYS.EVENTS_FILTERS]: JSON.stringify(
+						updatedFilters,
+					),
+				});
 
 				return updatedFilters;
 			});

frontend/src/container/InfraMonitoringK8s/Namespaces/utils.tsx

@@ -1,5 +1,6 @@
 import { Color } from '@signozhq/design-tokens';
-import { TableColumnType as ColumnType, Tag } from 'antd';
+import { Tag } from 'antd';
+import { TableColumnType as ColumnType } from 'antd';
 import {
 	K8sNamespacesData,
 	K8sNamespacesListPayload,

frontend/src/container/InfraMonitoringK8s/Nodes/K8sNodesList.tsx

@@ -1,6 +1,7 @@
-import React, { useCallback, useEffect, useMemo, useState } from 'react';
+import { useCallback, useEffect, useMemo, useState } from 'react';
 // eslint-disable-next-line no-restricted-imports
 import { useSelector } from 'react-redux';
+import { useSearchParams } from 'react-router-dom-v5-compat';
 import { LoadingOutlined } from '@ant-design/icons';
 import {
 	Button,
@@ -15,34 +16,23 @@ import type { SorterResult } from 'antd/es/table/interface';
 import logEvent from 'api/common/logEvent';
 import { K8sNodesListPayload } from 'api/infraMonitoring/getK8sNodesList';
 import { InfraMonitoringEvents } from 'constants/events';
-import { FeatureKeys } from 'constants/features';
 import { useGetK8sNodesList } from 'hooks/infraMonitoring/useGetK8sNodesList';
 import { useGetAggregateKeys } from 'hooks/queryBuilder/useGetAggregateKeys';
 import { useQueryBuilder } from 'hooks/queryBuilder/useQueryBuilder';
 import { useQueryOperations } from 'hooks/queryBuilder/useQueryBuilderOperations';
 import { ChevronDown, ChevronRight } from 'lucide-react';
-import { useAppContext } from 'providers/App/App';
 import { AppState } from 'store/reducers';
 import { IBuilderQuery } from 'types/api/queryBuilder/queryBuilderData';
 import { GlobalReducer } from 'types/reducer/globalTime';
-import { buildAbsolutePath, isModifierKeyPressed } from 'utils/app';
-import { openInNewTab } from 'utils/navigation';
 
+import { FeatureKeys } from '../../../constants/features';
+import { useAppContext } from '../../../providers/App/App';
+import { getOrderByFromParams } from '../commonUtils';
 import {
 	GetK8sEntityToAggregateAttribute,
 	INFRA_MONITORING_K8S_PARAMS_KEYS,
 	K8sCategory,
 } from '../constants';
-import {
-	useInfraMonitoringCurrentPage,
-	useInfraMonitoringEventsFilters,
-	useInfraMonitoringGroupBy,
-	useInfraMonitoringLogFilters,
-	useInfraMonitoringNodeUID,
-	useInfraMonitoringOrderBy,
-	useInfraMonitoringTracesFilters,
-	useInfraMonitoringView,
-} from '../hooks';
 import K8sHeader from '../K8sHeader';
 import LoadingContainer from '../LoadingContainer';
 import { usePageSize } from '../utils';
@@ -70,24 +60,50 @@ function K8sNodesList({
 	const { maxTime, minTime } = useSelector<AppState, GlobalReducer>(
 		(state) => state.globalTime,
 	);
+	const [searchParams, setSearchParams] = useSearchParams();
 
-	const [currentPage, setCurrentPage] = useInfraMonitoringCurrentPage();
+	const [currentPage, setCurrentPage] = useState(() => {
+		const page = searchParams.get(INFRA_MONITORING_K8S_PARAMS_KEYS.CURRENT_PAGE);
+		if (page) {
+			return parseInt(page, 10);
+		}
+		return 1;
+	});
 	const [filtersInitialised, setFiltersInitialised] = useState(false);
 
-	const [expandedRowKeys, setExpandedRowKeys] = useState<string[]>([]);
-	const [orderBy, setOrderBy] = useInfraMonitoringOrderBy();
+	useEffect(() => {
+		setSearchParams({
+			...Object.fromEntries(searchParams.entries()),
+			[INFRA_MONITORING_K8S_PARAMS_KEYS.CURRENT_PAGE]: currentPage.toString(),
+		});
+		// eslint-disable-next-line react-hooks/exhaustive-deps
+	}, [currentPage]);
 
-	const [selectedNodeUID, setSelectedNodeUID] = useInfraMonitoringNodeUID();
+	const [expandedRowKeys, setExpandedRowKeys] = useState<string[]>([]);
+	const [orderBy, setOrderBy] = useState<{
+		columnName: string;
+		order: 'asc' | 'desc';
+	} | null>(() => getOrderByFromParams(searchParams, false));
+
+	const [selectedNodeUID, setSelectedNodeUID] = useState<string | null>(() => {
+		const nodeUID = searchParams.get(INFRA_MONITORING_K8S_PARAMS_KEYS.NODE_UID);
+		if (nodeUID) {
+			return nodeUID;
+		}
+		return null;
+	});
 
 	const { pageSize, setPageSize } = usePageSize(K8sCategory.NODES);
 
-	const [groupBy, setGroupBy] = useInfraMonitoringGroupBy();
-
-	// These params are used only for clearing in handleCloseNodeDetail
-	const [, setView] = useInfraMonitoringView();
-	const [, setTracesFilters] = useInfraMonitoringTracesFilters();
-	const [, setEventsFilters] = useInfraMonitoringEventsFilters();
-	const [, setLogFilters] = useInfraMonitoringLogFilters();
+	const [groupBy, setGroupBy] = useState<IBuilderQuery['groupBy']>(() => {
+		const groupBy = searchParams.get(INFRA_MONITORING_K8S_PARAMS_KEYS.GROUP_BY);
+		if (groupBy) {
+			const decoded = decodeURIComponent(groupBy);
+			const parsed = JSON.parse(decoded);
+			return parsed as IBuilderQuery['groupBy'];
+		}
+		return [];
+	});
 
 	const [selectedRowData, setSelectedRowData] = useState<K8sNodesRowData | null>(
 		null,
@@ -113,7 +129,7 @@ function K8sNodesList({
 		if (quickFiltersLastUpdated !== -1) {
 			setCurrentPage(1);
 		}
-	}, [quickFiltersLastUpdated, setCurrentPage]);
+	}, [quickFiltersLastUpdated]);
 
 	const { featureFlags } = useAppContext();
 	const dotMetricsEnabled =
@@ -166,28 +182,25 @@ function K8sNodesList({
 			filters,
 			start: Math.floor(minTime / 1000000),
 			end: Math.floor(maxTime / 1000000),
-			orderBy: orderBy || baseQuery.orderBy,
+			orderBy,
 		};
 		// eslint-disable-next-line react-hooks/exhaustive-deps
 	}, [minTime, maxTime, orderBy, selectedRowData, groupBy]);
 
 	const groupedByRowDataQueryKey = useMemo(() => {
-		// be careful with what you serialize from selectedRowData
-		// since it's react node, it could contain circular references
-		const selectedRowDataKey = JSON.stringify(selectedRowData?.groupedByMeta);
 		if (selectedNodeUID) {
 			return [
 				'nodeList',
 				JSON.stringify(queryFilters),
 				JSON.stringify(orderBy),
-				selectedRowDataKey,
+				JSON.stringify(selectedRowData),
 			];
 		}
 		return [
 			'nodeList',
 			JSON.stringify(queryFilters),
 			JSON.stringify(orderBy),
-			selectedRowDataKey,
+			JSON.stringify(selectedRowData),
 			String(minTime),
 			String(maxTime),
 		];
@@ -246,7 +259,7 @@ function K8sNodesList({
 			filters: queryFilters,
 			start: Math.floor(minTime / 1000000),
 			end: Math.floor(maxTime / 1000000),
-			orderBy: orderBy || baseQuery.orderBy,
+			orderBy,
 		};
 		if (groupBy.length > 0) {
 			queryPayload.groupBy = groupBy;
@@ -352,15 +365,26 @@ function K8sNodesList({
 			}
 
 			if ('field' in sorter && sorter.order) {
-				setOrderBy({
+				const currentOrderBy = {
 					columnName: sorter.field as string,
 					order: (sorter.order === 'ascend' ? 'asc' : 'desc') as 'asc' | 'desc',
+				};
+				setOrderBy(currentOrderBy);
+				setSearchParams({
+					...Object.fromEntries(searchParams.entries()),
+					[INFRA_MONITORING_K8S_PARAMS_KEYS.ORDER_BY]: JSON.stringify(
+						currentOrderBy,
+					),
 				});
 			} else {
 				setOrderBy(null);
+				setSearchParams({
+					...Object.fromEntries(searchParams.entries()),
+					[INFRA_MONITORING_K8S_PARAMS_KEYS.ORDER_BY]: JSON.stringify(null),
+				});
 			}
 		},
-		[setCurrentPage, setOrderBy],
+		[searchParams, setSearchParams],
 	);
 
 	const { handleChangeQueryData } = useQueryOperations({
@@ -413,28 +437,14 @@ function K8sNodesList({
 		return nodesData.find((node) => node.nodeUID === selectedNodeUID) || null;
 	}, [selectedNodeUID, groupBy.length, nodesData, nestedNodesData]);
 
-	const openNodeInNewTab = (record: K8sNodesRowData): void => {
-		const newParams = new URLSearchParams(document.location.search);
-		newParams.set(INFRA_MONITORING_K8S_PARAMS_KEYS.NODE_UID, record.nodeUID);
-		openInNewTab(
-			buildAbsolutePath({
-				relativePath: '',
-				urlQueryString: newParams.toString(),
-			}),
-		);
-	};
-
-	const handleRowClick = (
-		record: K8sNodesRowData,
-		event: React.MouseEvent,
-	): void => {
-		if (event && isModifierKeyPressed(event)) {
-			openNodeInNewTab(record);
-			return;
-		}
+	const handleRowClick = (record: K8sNodesRowData): void => {
 		if (groupBy.length === 0) {
 			setSelectedRowData(null);
 			setSelectedNodeUID(record.nodeUID);
+			setSearchParams({
+				...Object.fromEntries(searchParams.entries()),
+				[INFRA_MONITORING_K8S_PARAMS_KEYS.NODE_UID]: record.nodeUID,
+			});
 		} else {
 			handleGroupByRowClick(record);
 		}
@@ -463,6 +473,11 @@ function K8sNodesList({
 		setSelectedRowData(null);
 		setGroupBy([]);
 		setOrderBy(null);
+		setSearchParams({
+			...Object.fromEntries(searchParams.entries()),
+			[INFRA_MONITORING_K8S_PARAMS_KEYS.GROUP_BY]: JSON.stringify([]),
+			[INFRA_MONITORING_K8S_PARAMS_KEYS.ORDER_BY]: JSON.stringify(null),
+		});
 	};
 
 	const expandedRowRender = (): JSX.Element => (
@@ -487,14 +502,8 @@ function K8sNodesList({
 							indicator: <Spin indicator={<LoadingOutlined size={14} spin />} />,
 						}}
 						showHeader={false}
-						onRow={(
-							record,
-						): { onClick: (event: React.MouseEvent) => void; className: string } => ({
-							onClick: (event: React.MouseEvent): void => {
-								if (isModifierKeyPressed(event)) {
-									openNodeInNewTab(record);
-									return;
-								}
+						onRow={(record): { onClick: () => void; className: string } => ({
+							onClick: (): void => {
 								setSelectedNodeUID(record.nodeUID);
 							},
 							className: 'expanded-clickable-row',
@@ -560,31 +569,45 @@ function K8sNodesList({
 
 	const handleCloseNodeDetail = (): void => {
 		setSelectedNodeUID(null);
-		setView(null);
-		setTracesFilters(null);
-		setEventsFilters(null);
-		setLogFilters(null);
+		setSearchParams({
+			...Object.fromEntries(
+				Array.from(searchParams.entries()).filter(
+					([key]) =>
+						![
+							INFRA_MONITORING_K8S_PARAMS_KEYS.NODE_UID,
+							INFRA_MONITORING_K8S_PARAMS_KEYS.VIEW,
+							INFRA_MONITORING_K8S_PARAMS_KEYS.TRACES_FILTERS,
+							INFRA_MONITORING_K8S_PARAMS_KEYS.EVENTS_FILTERS,
+							INFRA_MONITORING_K8S_PARAMS_KEYS.LOG_FILTERS,
+						].includes(key),
+				),
+			),
+		});
 	};
 
 	const handleGroupByChange = useCallback(
 		(value: IBuilderQuery['groupBy']) => {
-			const newGroupBy = [];
+			const groupBy = [];
 
 			for (let index = 0; index < value.length; index++) {
 				const element = (value[index] as unknown) as string;
 
 				const key = groupByFiltersData?.payload?.attributeKeys?.find(
-					(k) => k.key === element,
+					(key) => key.key === element,
 				);
 
 				if (key) {
-					newGroupBy.push(key);
+					groupBy.push(key);
 				}
 			}
 			// Reset pagination on switching to groupBy
 			setCurrentPage(1);
-			setGroupBy(newGroupBy);
+			setGroupBy(groupBy);
 			setExpandedRowKeys([]);
+			setSearchParams({
+				...Object.fromEntries(searchParams.entries()),
+				[INFRA_MONITORING_K8S_PARAMS_KEYS.GROUP_BY]: JSON.stringify(groupBy),
+			});
 
 			logEvent(InfraMonitoringEvents.GroupByChanged, {
 				entity: InfraMonitoringEvents.K8sEntity,
@@ -592,7 +615,7 @@ function K8sNodesList({
 				category: InfraMonitoringEvents.Node,
 			});
 		},
-		[groupByFiltersData, setCurrentPage, setGroupBy],
+		[groupByFiltersData, searchParams, setSearchParams],
 	);
 
 	useEffect(() => {
@@ -671,10 +694,8 @@ function K8sNodesList({
 				}}
 				tableLayout="fixed"
 				onChange={handleTableChange}
-				onRow={(
-					record,
-				): { onClick: (event: React.MouseEvent) => void; className: string } => ({
-					onClick: (event: React.MouseEvent): void => handleRowClick(record, event),
+				onRow={(record): { onClick: () => void; className: string } => ({
+					onClick: (): void => handleRowClick(record),
 					className: 'clickable-row',
 				})}
 				expandable={{

frontend/src/container/InfraMonitoringK8s/Nodes/NodeDetails/NodeDetails.tsx

@@ -2,6 +2,7 @@
 import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
 // eslint-disable-next-line no-restricted-imports
 import { useSelector } from 'react-redux';
+import { useSearchParams } from 'react-router-dom-v5-compat';
 import { Color, Spacing } from '@signozhq/design-tokens';
 import { Button, Divider, Drawer, Radio, Tooltip, Typography } from 'antd';
 import type { RadioChangeEvent } from 'antd/lib';
@@ -15,15 +16,15 @@ import {
 	initialQueryState,
 } from 'constants/queryBuilder';
 import ROUTES from 'constants/routes';
-import { filterDuplicateFilters } from 'container/InfraMonitoringK8s/commonUtils';
-import { K8sCategory } from 'container/InfraMonitoringK8s/constants';
-import NodeEvents from 'container/InfraMonitoringK8s/EntityDetailsUtils/EntityEvents';
 import {
-	useInfraMonitoringEventsFilters,
-	useInfraMonitoringLogFilters,
-	useInfraMonitoringTracesFilters,
-	useInfraMonitoringView,
-} from 'container/InfraMonitoringK8s/hooks';
+	filterDuplicateFilters,
+	getFiltersFromParams,
+} from 'container/InfraMonitoringK8s/commonUtils';
+import {
+	INFRA_MONITORING_K8S_PARAMS_KEYS,
+	K8sCategory,
+} from 'container/InfraMonitoringK8s/constants';
+import NodeEvents from 'container/InfraMonitoringK8s/EntityDetailsUtils/EntityEvents';
 import {
 	CustomTimeType,
 	Time,
@@ -93,21 +94,23 @@ function NodeDetails({
 			: (selectedTime as Time),
 	);
 
-	const [selectedView, setSelectedView] = useInfraMonitoringView();
-	const [logFiltersParam, setLogFiltersParam] = useInfraMonitoringLogFilters();
-	const [
-		tracesFiltersParam,
-		setTracesFiltersParam,
-	] = useInfraMonitoringTracesFilters();
-	const [
-		eventsFiltersParam,
-		setEventsFiltersParam,
-	] = useInfraMonitoringEventsFilters();
+	const [searchParams, setSearchParams] = useSearchParams();
+	const [selectedView, setSelectedView] = useState<VIEWS>(() => {
+		const view = searchParams.get(INFRA_MONITORING_K8S_PARAMS_KEYS.VIEW);
+		if (view) {
+			return view as VIEWS;
+		}
+		return VIEWS.METRICS;
+	});
 	const isDarkMode = useIsDarkMode();
 
 	const initialFilters = useMemo(() => {
-		const filters =
-			selectedView === VIEW_TYPES.LOGS ? logFiltersParam : tracesFiltersParam;
+		const urlView = searchParams.get(INFRA_MONITORING_K8S_PARAMS_KEYS.VIEW);
+		const queryKey =
+			urlView === VIEW_TYPES.LOGS
+				? INFRA_MONITORING_K8S_PARAMS_KEYS.LOG_FILTERS
+				: INFRA_MONITORING_K8S_PARAMS_KEYS.TRACES_FILTERS;
+		const filters = getFiltersFromParams(searchParams, queryKey);
 		if (filters) {
 			return filters;
 		}
@@ -127,16 +130,15 @@ function NodeDetails({
 				},
 			],
 		};
-	}, [
-		node?.meta.k8s_node_name,
-		selectedView,
-		logFiltersParam,
-		tracesFiltersParam,
-	]);
+	}, [node?.meta.k8s_node_name, searchParams]);
 
 	const initialEventsFilters = useMemo(() => {
-		if (eventsFiltersParam) {
-			return eventsFiltersParam;
+		const filters = getFiltersFromParams(
+			searchParams,
+			INFRA_MONITORING_K8S_PARAMS_KEYS.EVENTS_FILTERS,
+		);
+		if (filters) {
+			return filters;
 		}
 		return {
 			op: 'AND',
@@ -165,7 +167,7 @@ function NodeDetails({
 				},
 			],
 		};
-	}, [node?.meta.k8s_node_name, eventsFiltersParam]);
+	}, [node?.meta.k8s_node_name, searchParams]);
 
 	const [logAndTracesFilters, setLogAndTracesFilters] = useState<
 		IBuilderQuery['filters']
@@ -206,9 +208,13 @@ function NodeDetails({
 
 	const handleTabChange = (e: RadioChangeEvent): void => {
 		setSelectedView(e.target.value);
-		setLogFiltersParam(null);
-		setTracesFiltersParam(null);
-		setEventsFiltersParam(null);
+		setSearchParams({
+			...Object.fromEntries(searchParams.entries()),
+			[INFRA_MONITORING_K8S_PARAMS_KEYS.VIEW]: e.target.value,
+			[INFRA_MONITORING_K8S_PARAMS_KEYS.LOG_FILTERS]: JSON.stringify(null),
+			[INFRA_MONITORING_K8S_PARAMS_KEYS.TRACES_FILTERS]: JSON.stringify(null),
+			[INFRA_MONITORING_K8S_PARAMS_KEYS.EVENTS_FILTERS]: JSON.stringify(null),
+		});
 		logEvent(InfraMonitoringEvents.TabChanged, {
 			entity: InfraMonitoringEvents.K8sEntity,
 			page: InfraMonitoringEvents.DetailedPage,
@@ -284,8 +290,13 @@ function NodeDetails({
 					),
 				};
 
-				setLogFiltersParam(updatedFilters);
-				setSelectedView(view);
+				setSearchParams({
+					...Object.fromEntries(searchParams.entries()),
+					[INFRA_MONITORING_K8S_PARAMS_KEYS.LOG_FILTERS]: JSON.stringify(
+						updatedFilters,
+					),
+					[INFRA_MONITORING_K8S_PARAMS_KEYS.VIEW]: view,
+				});
 
 				return updatedFilters;
 			});
@@ -324,8 +335,13 @@ function NodeDetails({
 					),
 				};
 
-				setTracesFiltersParam(updatedFilters);
-				setSelectedView(view);
+				setSearchParams({
+					...Object.fromEntries(searchParams.entries()),
+					[INFRA_MONITORING_K8S_PARAMS_KEYS.TRACES_FILTERS]: JSON.stringify(
+						updatedFilters,
+					),
+					[INFRA_MONITORING_K8S_PARAMS_KEYS.VIEW]: view,
+				});
 
 				return updatedFilters;
 			});
@@ -366,8 +382,13 @@ function NodeDetails({
 					].filter((item): item is TagFilterItem => item !== undefined),
 				};
 
-				setEventsFiltersParam(updatedFilters);
-				setSelectedView(view);
+				setSearchParams({
+					...Object.fromEntries(searchParams.entries()),
+					[INFRA_MONITORING_K8S_PARAMS_KEYS.EVENTS_FILTERS]: JSON.stringify(
+						updatedFilters,
+					),
+					[INFRA_MONITORING_K8S_PARAMS_KEYS.VIEW]: view,
+				});
 
 				return updatedFilters;
 			});

frontend/src/container/InfraMonitoringK8s/Nodes/utils.tsx

@@ -1,5 +1,6 @@
 import { Color } from '@signozhq/design-tokens';
-import { TableColumnType as ColumnType, Tag, Tooltip } from 'antd';
+import { Tag, Tooltip } from 'antd';
+import { TableColumnType as ColumnType } from 'antd';
 import {
 	K8sNodesData,
 	K8sNodesListPayload,

frontend/src/container/InfraMonitoringK8s/Pods/K8sPodLists.tsx

@@ -1,6 +1,7 @@
-import React, { useCallback, useEffect, useMemo, useState } from 'react';
+import { useCallback, useEffect, useMemo, useState } from 'react';
 // eslint-disable-next-line no-restricted-imports
 import { useSelector } from 'react-redux';
+import { useSearchParams } from 'react-router-dom-v5-compat';
 import { LoadingOutlined } from '@ant-design/icons';
 import {
 	Button,
@@ -18,34 +19,23 @@ import logEvent from 'api/common/logEvent';
 import { K8sPodsListPayload } from 'api/infraMonitoring/getK8sPodsList';
 import classNames from 'classnames';
 import { InfraMonitoringEvents } from 'constants/events';
-import { FeatureKeys } from 'constants/features';
 import { useGetK8sPodsList } from 'hooks/infraMonitoring/useGetK8sPodsList';
 import { useGetAggregateKeys } from 'hooks/queryBuilder/useGetAggregateKeys';
 import { useQueryBuilder } from 'hooks/queryBuilder/useQueryBuilder';
 import { useQueryOperations } from 'hooks/queryBuilder/useQueryBuilderOperations';
 import { ChevronDown, ChevronRight, CornerDownRight } from 'lucide-react';
-import { useAppContext } from 'providers/App/App';
 import { AppState } from 'store/reducers';
 import { IBuilderQuery } from 'types/api/queryBuilder/queryBuilderData';
 import { GlobalReducer } from 'types/reducer/globalTime';
-import { buildAbsolutePath, isModifierKeyPressed } from 'utils/app';
-import { openInNewTab } from 'utils/navigation';
 
+import { FeatureKeys } from '../../../constants/features';
+import { useAppContext } from '../../../providers/App/App';
+import { getOrderByFromParams } from '../commonUtils';
 import {
 	GetK8sEntityToAggregateAttribute,
 	INFRA_MONITORING_K8S_PARAMS_KEYS,
 	K8sCategory,
 } from '../constants';
-import {
-	useInfraMonitoringCurrentPage,
-	useInfraMonitoringEventsFilters,
-	useInfraMonitoringGroupBy,
-	useInfraMonitoringLogFilters,
-	useInfraMonitoringOrderBy,
-	useInfraMonitoringPodUID,
-	useInfraMonitoringTracesFilters,
-	useInfraMonitoringView,
-} from '../hooks';
 import K8sHeader from '../K8sHeader';
 import LoadingContainer from '../LoadingContainer';
 import {
@@ -74,25 +64,41 @@ function K8sPodsList({
 	const { maxTime, minTime } = useSelector<AppState, GlobalReducer>(
 		(state) => state.globalTime,
 	);
+	const [searchParams, setSearchParams] = useSearchParams();
 
-	const [currentPage, setCurrentPage] = useInfraMonitoringCurrentPage();
-	const [groupBy, setGroupBy] = useInfraMonitoringGroupBy();
-	const [orderBy, setOrderBy] = useInfraMonitoringOrderBy();
-	const [defaultOrderBy] = useState(orderBy);
-	const [selectedPodUID, setSelectedPodUID] = useInfraMonitoringPodUID();
-	const [, setView] = useInfraMonitoringView();
-	const [, setTracesFilters] = useInfraMonitoringTracesFilters();
-	const [, setEventsFilters] = useInfraMonitoringEventsFilters();
-	const [, setLogFilters] = useInfraMonitoringLogFilters();
-
+	const [currentPage, setCurrentPage] = useState(() => {
+		const page = searchParams.get(INFRA_MONITORING_K8S_PARAMS_KEYS.CURRENT_PAGE);
+		if (page) {
+			return parseInt(page, 10);
+		}
+		return 1;
+	});
 	const [filtersInitialised, setFiltersInitialised] = useState(false);
 
+	useEffect(() => {
+		setSearchParams({
+			...Object.fromEntries(searchParams.entries()),
+			[INFRA_MONITORING_K8S_PARAMS_KEYS.CURRENT_PAGE]: currentPage.toString(),
+		});
+		// eslint-disable-next-line react-hooks/exhaustive-deps
+	}, [currentPage]);
+
 	const [addedColumns, setAddedColumns] = useState<IEntityColumn[]>([]);
 
 	const [availableColumns, setAvailableColumns] = useState<IEntityColumn[]>(
 		defaultAvailableColumns,
 	);
 
+	const [groupBy, setGroupBy] = useState<IBuilderQuery['groupBy']>(() => {
+		const groupBy = searchParams.get(INFRA_MONITORING_K8S_PARAMS_KEYS.GROUP_BY);
+		if (groupBy) {
+			const decoded = decodeURIComponent(groupBy);
+			const parsed = JSON.parse(decoded);
+			return parsed as IBuilderQuery['groupBy'];
+		}
+		return [];
+	});
+
 	const [selectedRowData, setSelectedRowData] = useState<K8sPodsRowData | null>(
 		null,
 	);
@@ -145,7 +151,7 @@ function K8sPodsList({
 		if (quickFiltersLastUpdated !== -1) {
 			setCurrentPage(1);
 		}
-	}, [quickFiltersLastUpdated, setCurrentPage]);
+	}, [quickFiltersLastUpdated]);
 
 	useEffect(() => {
 		const addedColumns = JSON.parse(get('k8sPodsAddedColumns') ?? '[]');
@@ -164,6 +170,19 @@ function K8sPodsList({
 		}
 	}, []);
 
+	const [orderBy, setOrderBy] = useState<{
+		columnName: string;
+		order: 'asc' | 'desc';
+	} | null>(() => getOrderByFromParams(searchParams, false));
+
+	const [selectedPodUID, setSelectedPodUID] = useState<string | null>(() => {
+		const podUID = searchParams.get(INFRA_MONITORING_K8S_PARAMS_KEYS.POD_UID);
+		if (podUID) {
+			return podUID;
+		}
+		return null;
+	});
+
 	const { pageSize, setPageSize } = usePageSize(K8sCategory.PODS);
 
 	const query = useMemo(() => {
@@ -176,7 +195,7 @@ function K8sPodsList({
 			filters: queryFilters,
 			start: Math.floor(minTime / 1000000),
 			end: Math.floor(maxTime / 1000000),
-			orderBy: orderBy || baseQuery.orderBy,
+			orderBy,
 		};
 
 		if (groupBy.length > 0) {
@@ -274,28 +293,25 @@ function K8sPodsList({
 			filters,
 			start: Math.floor(minTime / 1000000),
 			end: Math.floor(maxTime / 1000000),
-			orderBy: orderBy || baseQuery.orderBy,
+			orderBy,
 		};
 		// eslint-disable-next-line react-hooks/exhaustive-deps
 	}, [minTime, maxTime, orderBy, selectedRowData]);
 
 	const groupedByRowDataQueryKey = useMemo(() => {
-		// be careful with what you serialize from selectedRowData
-		// since it's react node, it could contain circular references
-		const selectedRowDataKey = JSON.stringify(selectedRowData?.groupedByMeta);
 		if (selectedPodUID) {
 			return [
 				'podList',
 				JSON.stringify(queryFilters),
 				JSON.stringify(orderBy),
-				selectedRowDataKey,
+				JSON.stringify(selectedRowData),
 			];
 		}
 		return [
 			'podList',
 			JSON.stringify(queryFilters),
 			JSON.stringify(orderBy),
-			selectedRowDataKey,
+			JSON.stringify(selectedRowData),
 			String(minTime),
 			String(maxTime),
 		];
@@ -338,10 +354,10 @@ function K8sPodsList({
 		[groupedByRowData, groupBy],
 	);
 
-	const columns = useMemo(
-		() => getK8sPodsListColumns(addedColumns, groupBy, defaultOrderBy),
-		[addedColumns, groupBy, defaultOrderBy],
-	);
+	const columns = useMemo(() => getK8sPodsListColumns(addedColumns, groupBy), [
+		addedColumns,
+		groupBy,
+	]);
 
 	const handleTableChange: TableProps<K8sPodsRowData>['onChange'] = useCallback(
 		(
@@ -359,15 +375,26 @@ function K8sPodsList({
 			}
 
 			if ('field' in sorter && sorter.order) {
-				setOrderBy({
+				const currentOrderBy = {
 					columnName: sorter.field as string,
 					order: (sorter.order === 'ascend' ? 'asc' : 'desc') as 'asc' | 'desc',
+				};
+				setOrderBy(currentOrderBy);
+				setSearchParams({
+					...Object.fromEntries(searchParams.entries()),
+					[INFRA_MONITORING_K8S_PARAMS_KEYS.ORDER_BY]: JSON.stringify(
+						currentOrderBy,
+					),
 				});
 			} else {
 				setOrderBy(null);
+				setSearchParams({
+					...Object.fromEntries(searchParams.entries()),
+					[INFRA_MONITORING_K8S_PARAMS_KEYS.ORDER_BY]: JSON.stringify(null),
+				});
 			}
 		},
-		[setCurrentPage, setOrderBy],
+		[searchParams, setSearchParams],
 	);
 
 	const { handleChangeQueryData } = useQueryOperations({
@@ -399,24 +426,28 @@ function K8sPodsList({
 
 	const handleGroupByChange = useCallback(
 		(value: IBuilderQuery['groupBy']) => {
-			const newGroupBy = [];
+			const groupBy = [];
 
 			for (let index = 0; index < value.length; index++) {
 				const element = (value[index] as unknown) as string;
 
 				const key = groupByFiltersData?.payload?.attributeKeys?.find(
-					(k) => k.key === element,
+					(key) => key.key === element,
 				);
 
 				if (key) {
-					newGroupBy.push(key);
+					groupBy.push(key);
 				}
 			}
 
 			// Reset pagination on switching to groupBy
 			setCurrentPage(1);
-			setGroupBy(newGroupBy);
+			setGroupBy(groupBy);
 			setExpandedRowKeys([]);
+			setSearchParams({
+				...Object.fromEntries(searchParams.entries()),
+				[INFRA_MONITORING_K8S_PARAMS_KEYS.GROUP_BY]: JSON.stringify(groupBy),
+			});
 
 			logEvent(InfraMonitoringEvents.GroupByChanged, {
 				entity: InfraMonitoringEvents.K8sEntity,
@@ -424,7 +455,7 @@ function K8sPodsList({
 				category: InfraMonitoringEvents.Pod,
 			});
 		},
-		[groupByFiltersData, setCurrentPage, setGroupBy],
+		[groupByFiltersData, searchParams, setSearchParams],
 	);
 
 	useEffect(() => {
@@ -464,27 +495,13 @@ function K8sPodsList({
 		}
 	}, [selectedRowData, fetchGroupedByRowData]);
 
-	const openPodInNewTab = (record: K8sPodsRowData): void => {
-		const newParams = new URLSearchParams(document.location.search);
-		newParams.set(INFRA_MONITORING_K8S_PARAMS_KEYS.POD_UID, record.podUID);
-		openInNewTab(
-			buildAbsolutePath({
-				relativePath: '',
-				urlQueryString: newParams.toString(),
-			}),
-		);
-	};
-
-	const handleRowClick = (
-		record: K8sPodsRowData,
-		event: React.MouseEvent,
-	): void => {
-		if (event && isModifierKeyPressed(event)) {
-			openPodInNewTab(record);
-			return;
-		}
+	const handleRowClick = (record: K8sPodsRowData): void => {
 		if (groupBy.length === 0) {
 			setSelectedPodUID(record.podUID);
+			setSearchParams({
+				...Object.fromEntries(searchParams.entries()),
+				[INFRA_MONITORING_K8S_PARAMS_KEYS.POD_UID]: record.podUID,
+			});
 			setSelectedRowData(null);
 		} else {
 			handleGroupByRowClick(record);
@@ -499,10 +516,20 @@ function K8sPodsList({
 
 	const handleClosePodDetail = (): void => {
 		setSelectedPodUID(null);
-		setView(null);
-		setTracesFilters(null);
-		setEventsFilters(null);
-		setLogFilters(null);
+		setSearchParams({
+			...Object.fromEntries(
+				Array.from(searchParams.entries()).filter(
+					([key]) =>
+						![
+							INFRA_MONITORING_K8S_PARAMS_KEYS.POD_UID,
+							INFRA_MONITORING_K8S_PARAMS_KEYS.VIEW,
+							INFRA_MONITORING_K8S_PARAMS_KEYS.TRACES_FILTERS,
+							INFRA_MONITORING_K8S_PARAMS_KEYS.EVENTS_FILTERS,
+							INFRA_MONITORING_K8S_PARAMS_KEYS.LOG_FILTERS,
+						].includes(key),
+				),
+			),
+		});
 	};
 
 	const handleAddColumn = useCallback(
@@ -541,10 +568,9 @@ function K8sPodsList({
 		[setAddedColumns, setAvailableColumns],
 	);
 
-	const nestedColumns = useMemo(
-		() => getK8sPodsListColumns(addedColumns, [], defaultOrderBy),
-		[addedColumns, defaultOrderBy],
-	);
+	const nestedColumns = useMemo(() => getK8sPodsListColumns(addedColumns, []), [
+		addedColumns,
+	]);
 
 	const isGroupedByAttribute = groupBy.length > 0;
 
@@ -561,6 +587,11 @@ function K8sPodsList({
 		setSelectedRowData(null);
 		setGroupBy([]);
 		setOrderBy(null);
+		setSearchParams({
+			...Object.fromEntries(searchParams.entries()),
+			[INFRA_MONITORING_K8S_PARAMS_KEYS.GROUP_BY]: JSON.stringify([]),
+			[INFRA_MONITORING_K8S_PARAMS_KEYS.ORDER_BY]: JSON.stringify(null),
+		});
 	};
 
 	const expandedRowRender = (): JSX.Element => (
@@ -584,14 +615,8 @@ function K8sPodsList({
 							spinning: isFetchingGroupedByRowData || isLoadingGroupedByRowData,
 							indicator: <Spin indicator={<LoadingOutlined size={14} spin />} />,
 						}}
-						onRow={(
-							record: K8sPodsRowData,
-						): { onClick: (event: React.MouseEvent) => void; className: string } => ({
-							onClick: (event: React.MouseEvent): void => {
-								if (isModifierKeyPressed(event)) {
-									openPodInNewTab(record);
-									return;
-								}
+						onRow={(record): { onClick: () => void; className: string } => ({
+							onClick: (): void => {
 								setSelectedPodUID(record.podUID);
 							},
 							className: 'expanded-clickable-row',
@@ -727,10 +752,8 @@ function K8sPodsList({
 				scroll={{ x: true }}
 				tableLayout="fixed"
 				onChange={handleTableChange}
-				onRow={(
-					record: K8sPodsRowData,
-				): { onClick: (event: React.MouseEvent) => void; className: string } => ({
-					onClick: (event: React.MouseEvent): void => handleRowClick(record, event),
+				onRow={(record): { onClick: () => void; className: string } => ({
+					onClick: (): void => handleRowClick(record),
 					className: 'clickable-row',
 				})}
 				expandable={{

frontend/src/container/InfraMonitoringK8s/Pods/PodDetails/PodDetails.tsx

@@ -2,6 +2,7 @@
 import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
 // eslint-disable-next-line no-restricted-imports
 import { useSelector } from 'react-redux';
+import { useSearchParams } from 'react-router-dom-v5-compat';
 import { Color, Spacing } from '@signozhq/design-tokens';
 import { Button, Divider, Drawer, Radio, Tooltip, Typography } from 'antd';
 import type { RadioChangeEvent } from 'antd/lib';
@@ -15,15 +16,15 @@ import {
 	initialQueryState,
 } from 'constants/queryBuilder';
 import ROUTES from 'constants/routes';
-import { filterDuplicateFilters } from 'container/InfraMonitoringK8s/commonUtils';
-import { K8sCategory } from 'container/InfraMonitoringK8s/constants';
-import { QUERY_KEYS } from 'container/InfraMonitoringK8s/EntityDetailsUtils/utils';
 import {
-	useInfraMonitoringEventsFilters,
-	useInfraMonitoringLogFilters,
-	useInfraMonitoringTracesFilters,
-	useInfraMonitoringView,
-} from 'container/InfraMonitoringK8s/hooks';
+	filterDuplicateFilters,
+	getFiltersFromParams,
+} from 'container/InfraMonitoringK8s/commonUtils';
+import {
+	INFRA_MONITORING_K8S_PARAMS_KEYS,
+	K8sCategory,
+} from 'container/InfraMonitoringK8s/constants';
+import { QUERY_KEYS } from 'container/InfraMonitoringK8s/EntityDetailsUtils/utils';
 import {
 	CustomTimeType,
 	Time,
@@ -95,21 +96,23 @@ function PodDetails({
 			: (selectedTime as Time),
 	);
 
-	const [selectedView, setSelectedView] = useInfraMonitoringView();
-	const [logFiltersParam, setLogFiltersParam] = useInfraMonitoringLogFilters();
-	const [
-		tracesFiltersParam,
-		setTracesFiltersParam,
-	] = useInfraMonitoringTracesFilters();
-	const [
-		eventsFiltersParam,
-		setEventsFiltersParam,
-	] = useInfraMonitoringEventsFilters();
+	const [searchParams, setSearchParams] = useSearchParams();
+	const [selectedView, setSelectedView] = useState<VIEWS>(() => {
+		const view = searchParams.get(INFRA_MONITORING_K8S_PARAMS_KEYS.VIEW);
+		if (view) {
+			return view as VIEWS;
+		}
+		return VIEWS.METRICS;
+	});
 	const isDarkMode = useIsDarkMode();
 
 	const initialFilters = useMemo(() => {
-		const filters =
-			selectedView === VIEW_TYPES.LOGS ? logFiltersParam : tracesFiltersParam;
+		const urlView = searchParams.get(INFRA_MONITORING_K8S_PARAMS_KEYS.VIEW);
+		const queryKey =
+			urlView === VIEW_TYPES.LOGS
+				? INFRA_MONITORING_K8S_PARAMS_KEYS.LOG_FILTERS
+				: INFRA_MONITORING_K8S_PARAMS_KEYS.TRACES_FILTERS;
+		const filters = getFiltersFromParams(searchParams, queryKey);
 		if (filters) {
 			return filters;
 		}
@@ -140,17 +143,15 @@ function PodDetails({
 				},
 			],
 		};
-	}, [
-		pod?.meta.k8s_namespace_name,
-		pod?.meta.k8s_pod_name,
-		selectedView,
-		logFiltersParam,
-		tracesFiltersParam,
-	]);
+	}, [pod?.meta.k8s_namespace_name, pod?.meta.k8s_pod_name, searchParams]);
 
 	const initialEventsFilters = useMemo(() => {
-		if (eventsFiltersParam) {
-			return eventsFiltersParam;
+		const filters = getFiltersFromParams(
+			searchParams,
+			INFRA_MONITORING_K8S_PARAMS_KEYS.EVENTS_FILTERS,
+		);
+		if (filters) {
+			return filters;
 		}
 		return {
 			op: 'AND',
@@ -179,7 +180,7 @@ function PodDetails({
 				},
 			],
 		};
-	}, [pod?.meta.k8s_pod_name, eventsFiltersParam]);
+	}, [pod?.meta.k8s_pod_name, searchParams]);
 
 	const [logsAndTracesFilters, setLogsAndTracesFilters] = useState<
 		IBuilderQuery['filters']
@@ -220,9 +221,13 @@ function PodDetails({
 
 	const handleTabChange = (e: RadioChangeEvent): void => {
 		setSelectedView(e.target.value);
-		setLogFiltersParam(null);
-		setTracesFiltersParam(null);
-		setEventsFiltersParam(null);
+		setSearchParams({
+			...Object.fromEntries(searchParams.entries()),
+			[INFRA_MONITORING_K8S_PARAMS_KEYS.VIEW]: e.target.value,
+			[INFRA_MONITORING_K8S_PARAMS_KEYS.LOG_FILTERS]: JSON.stringify(null),
+			[INFRA_MONITORING_K8S_PARAMS_KEYS.TRACES_FILTERS]: JSON.stringify(null),
+			[INFRA_MONITORING_K8S_PARAMS_KEYS.EVENTS_FILTERS]: JSON.stringify(null),
+		});
 		logEvent(InfraMonitoringEvents.TabChanged, {
 			entity: InfraMonitoringEvents.K8sEntity,
 			page: InfraMonitoringEvents.DetailedPage,
@@ -300,8 +305,13 @@ function PodDetails({
 					),
 				};
 
-				setLogFiltersParam(updatedFilters);
-				setSelectedView(view);
+				setSearchParams({
+					...Object.fromEntries(searchParams.entries()),
+					[INFRA_MONITORING_K8S_PARAMS_KEYS.LOG_FILTERS]: JSON.stringify(
+						updatedFilters,
+					),
+					[INFRA_MONITORING_K8S_PARAMS_KEYS.VIEW]: view,
+				});
 
 				return updatedFilters;
 			});
@@ -342,8 +352,13 @@ function PodDetails({
 					),
 				};
 
-				setTracesFiltersParam(updatedFilters);
-				setSelectedView(view);
+				setSearchParams({
+					...Object.fromEntries(searchParams.entries()),
+					[INFRA_MONITORING_K8S_PARAMS_KEYS.TRACES_FILTERS]: JSON.stringify(
+						updatedFilters,
+					),
+					[INFRA_MONITORING_K8S_PARAMS_KEYS.VIEW]: view,
+				});
 
 				return updatedFilters;
 			});
@@ -384,8 +399,13 @@ function PodDetails({
 					].filter((item): item is TagFilterItem => item !== undefined),
 				};
 
-				setEventsFiltersParam(updatedFilters);
-				setSelectedView(view);
+				setSearchParams({
+					...Object.fromEntries(searchParams.entries()),
+					[INFRA_MONITORING_K8S_PARAMS_KEYS.EVENTS_FILTERS]: JSON.stringify(
+						updatedFilters,
+					),
+					[INFRA_MONITORING_K8S_PARAMS_KEYS.VIEW]: view,
+				});
 
 				return updatedFilters;
 			});

frontend/src/container/InfraMonitoringK8s/StatefulSets/K8sStatefulSetsList.tsx

@@ -1,6 +1,7 @@
-import React, { useCallback, useEffect, useMemo, useState } from 'react';
+import { useCallback, useEffect, useMemo, useState } from 'react';
 // eslint-disable-next-line no-restricted-imports
 import { useSelector } from 'react-redux';
+import { useSearchParams } from 'react-router-dom-v5-compat';
 import { LoadingOutlined } from '@ant-design/icons';
 import {
 	Button,
@@ -16,34 +17,23 @@ import logEvent from 'api/common/logEvent';
 import { K8sStatefulSetsListPayload } from 'api/infraMonitoring/getsK8sStatefulSetsList';
 import classNames from 'classnames';
 import { InfraMonitoringEvents } from 'constants/events';
-import { FeatureKeys } from 'constants/features';
 import { useGetK8sStatefulSetsList } from 'hooks/infraMonitoring/useGetK8sStatefulSetsList';
 import { useGetAggregateKeys } from 'hooks/queryBuilder/useGetAggregateKeys';
 import { useQueryBuilder } from 'hooks/queryBuilder/useQueryBuilder';
 import { useQueryOperations } from 'hooks/queryBuilder/useQueryBuilderOperations';
 import { ChevronDown, ChevronRight } from 'lucide-react';
-import { useAppContext } from 'providers/App/App';
 import { AppState } from 'store/reducers';
 import { IBuilderQuery } from 'types/api/queryBuilder/queryBuilderData';
 import { GlobalReducer } from 'types/reducer/globalTime';
-import { buildAbsolutePath, isModifierKeyPressed } from 'utils/app';
-import { openInNewTab } from 'utils/navigation';
 
+import { FeatureKeys } from '../../../constants/features';
+import { useAppContext } from '../../../providers/App/App';
+import { getOrderByFromParams } from '../commonUtils';
 import {
 	GetK8sEntityToAggregateAttribute,
 	INFRA_MONITORING_K8S_PARAMS_KEYS,
 	K8sCategory,
 } from '../constants';
-import {
-	useInfraMonitoringCurrentPage,
-	useInfraMonitoringEventsFilters,
-	useInfraMonitoringGroupBy,
-	useInfraMonitoringLogFilters,
-	useInfraMonitoringOrderBy,
-	useInfraMonitoringStatefulSetUID,
-	useInfraMonitoringTracesFilters,
-	useInfraMonitoringView,
-} from '../hooks';
 import K8sHeader from '../K8sHeader';
 import LoadingContainer from '../LoadingContainer';
 import { usePageSize } from '../utils';
@@ -58,7 +48,6 @@ import {
 
 import '../InfraMonitoringK8s.styles.scss';
 import './K8sStatefulSetsList.styles.scss';
-
 function K8sStatefulSetsList({
 	isFiltersVisible,
 	handleFilterVisibilityChange,
@@ -72,26 +61,55 @@ function K8sStatefulSetsList({
 		(state) => state.globalTime,
 	);
 
-	const [currentPage, setCurrentPage] = useInfraMonitoringCurrentPage();
+	const [searchParams, setSearchParams] = useSearchParams();
+
+	const [currentPage, setCurrentPage] = useState(() => {
+		const page = searchParams.get(INFRA_MONITORING_K8S_PARAMS_KEYS.CURRENT_PAGE);
+		if (page) {
+			return parseInt(page, 10);
+		}
+		return 1;
+	});
 	const [filtersInitialised, setFiltersInitialised] = useState(false);
 
+	useEffect(() => {
+		setSearchParams({
+			...Object.fromEntries(searchParams.entries()),
+			[INFRA_MONITORING_K8S_PARAMS_KEYS.CURRENT_PAGE]: currentPage.toString(),
+		});
+		// eslint-disable-next-line react-hooks/exhaustive-deps
+	}, [currentPage]);
+
 	const [expandedRowKeys, setExpandedRowKeys] = useState<string[]>([]);
 
-	const [orderBy, setOrderBy] = useInfraMonitoringOrderBy();
+	const [orderBy, setOrderBy] = useState<{
+		columnName: string;
+		order: 'asc' | 'desc';
+	} | null>(() => getOrderByFromParams(searchParams, true));
 
-	const [
-		selectedStatefulSetUID,
-		setselectedStatefulSetUID,
-	] = useInfraMonitoringStatefulSetUID();
+	const [selectedStatefulSetUID, setselectedStatefulSetUID] = useState<
+		string | null
+	>(() => {
+		const statefulSetUID = searchParams.get(
+			INFRA_MONITORING_K8S_PARAMS_KEYS.STATEFULSET_UID,
+		);
+		if (statefulSetUID) {
+			return statefulSetUID;
+		}
+		return null;
+	});
 
 	const { pageSize, setPageSize } = usePageSize(K8sCategory.STATEFULSETS);
 
-	const [groupBy, setGroupBy] = useInfraMonitoringGroupBy();
-
-	const [, setView] = useInfraMonitoringView();
-	const [, setTracesFilters] = useInfraMonitoringTracesFilters();
-	const [, setEventsFilters] = useInfraMonitoringEventsFilters();
-	const [, setLogFilters] = useInfraMonitoringLogFilters();
+	const [groupBy, setGroupBy] = useState<IBuilderQuery['groupBy']>(() => {
+		const groupBy = searchParams.get(INFRA_MONITORING_K8S_PARAMS_KEYS.GROUP_BY);
+		if (groupBy) {
+			const decoded = decodeURIComponent(groupBy);
+			const parsed = JSON.parse(decoded);
+			return parsed as IBuilderQuery['groupBy'];
+		}
+		return [];
+	});
 
 	const [
 		selectedRowData,
@@ -118,7 +136,7 @@ function K8sStatefulSetsList({
 		if (quickFiltersLastUpdated !== -1) {
 			setCurrentPage(1);
 		}
-	}, [quickFiltersLastUpdated, setCurrentPage]);
+	}, [quickFiltersLastUpdated]);
 
 	const { featureFlags } = useAppContext();
 	const dotMetricsEnabled =
@@ -171,28 +189,25 @@ function K8sStatefulSetsList({
 			filters,
 			start: Math.floor(minTime / 1000000),
 			end: Math.floor(maxTime / 1000000),
-			orderBy: orderBy || baseQuery.orderBy,
+			orderBy,
 		};
 		// eslint-disable-next-line react-hooks/exhaustive-deps
 	}, [minTime, maxTime, orderBy, selectedRowData, groupBy]);
 
 	const groupedByRowDataQueryKey = useMemo(() => {
-		// be careful with what you serialize from selectedRowData
-		// since it's react node, it could contain circular references
-		const selectedRowDataKey = JSON.stringify(selectedRowData?.groupedByMeta);
 		if (selectedStatefulSetUID) {
 			return [
 				'statefulSetList',
 				JSON.stringify(queryFilters),
 				JSON.stringify(orderBy),
-				selectedRowDataKey,
+				JSON.stringify(selectedRowData),
 			];
 		}
 		return [
 			'statefulSetList',
 			JSON.stringify(queryFilters),
 			JSON.stringify(orderBy),
-			selectedRowDataKey,
+			JSON.stringify(selectedRowData),
 			String(minTime),
 			String(maxTime),
 		];
@@ -251,7 +266,7 @@ function K8sStatefulSetsList({
 			filters: queryFilters,
 			start: Math.floor(minTime / 1000000),
 			end: Math.floor(maxTime / 1000000),
-			orderBy: orderBy || baseQuery.orderBy,
+			orderBy,
 		};
 		if (groupBy.length > 0) {
 			queryPayload.groupBy = groupBy;
@@ -363,15 +378,26 @@ function K8sStatefulSetsList({
 			}
 
 			if ('field' in sorter && sorter.order) {
-				setOrderBy({
+				const currentOrderBy = {
 					columnName: sorter.field as string,
 					order: (sorter.order === 'ascend' ? 'asc' : 'desc') as 'asc' | 'desc',
+				};
+				setOrderBy(currentOrderBy);
+				setSearchParams({
+					...Object.fromEntries(searchParams.entries()),
+					[INFRA_MONITORING_K8S_PARAMS_KEYS.ORDER_BY]: JSON.stringify(
+						currentOrderBy,
+					),
 				});
 			} else {
 				setOrderBy(null);
+				setSearchParams({
+					...Object.fromEntries(searchParams.entries()),
+					[INFRA_MONITORING_K8S_PARAMS_KEYS.ORDER_BY]: JSON.stringify(null),
+				});
 			}
 		},
-		[setCurrentPage, setOrderBy],
+		[searchParams, setSearchParams],
 	);
 
 	const { handleChangeQueryData } = useQueryOperations({
@@ -433,31 +459,14 @@ function K8sStatefulSetsList({
 		nestedStatefulSetsData,
 	]);
 
-	const openStatefulSetInNewTab = (record: K8sStatefulSetsRowData): void => {
-		const newParams = new URLSearchParams(document.location.search);
-		newParams.set(
-			INFRA_MONITORING_K8S_PARAMS_KEYS.STATEFULSET_UID,
-			record.statefulsetUID,
-		);
-		openInNewTab(
-			buildAbsolutePath({
-				relativePath: '',
-				urlQueryString: newParams.toString(),
-			}),
-		);
-	};
-
-	const handleRowClick = (
-		record: K8sStatefulSetsRowData,
-		event: React.MouseEvent,
-	): void => {
-		if (event && isModifierKeyPressed(event)) {
-			openStatefulSetInNewTab(record);
-			return;
-		}
+	const handleRowClick = (record: K8sStatefulSetsRowData): void => {
 		if (groupBy.length === 0) {
 			setSelectedRowData(null);
 			setselectedStatefulSetUID(record.statefulsetUID);
+			setSearchParams({
+				...Object.fromEntries(searchParams.entries()),
+				[INFRA_MONITORING_K8S_PARAMS_KEYS.STATEFULSET_UID]: record.statefulsetUID,
+			});
 		} else {
 			handleGroupByRowClick(record);
 		}
@@ -486,6 +495,11 @@ function K8sStatefulSetsList({
 		setSelectedRowData(null);
 		setGroupBy([]);
 		setOrderBy(null);
+		setSearchParams({
+			...Object.fromEntries(searchParams.entries()),
+			[INFRA_MONITORING_K8S_PARAMS_KEYS.GROUP_BY]: JSON.stringify([]),
+			[INFRA_MONITORING_K8S_PARAMS_KEYS.ORDER_BY]: JSON.stringify(null),
+		});
 	};
 
 	const expandedRowRender = (): JSX.Element => (
@@ -509,14 +523,8 @@ function K8sStatefulSetsList({
 							indicator: <Spin indicator={<LoadingOutlined size={14} spin />} />,
 						}}
 						showHeader={false}
-						onRow={(
-							record,
-						): { onClick: (event: React.MouseEvent) => void; className: string } => ({
-							onClick: (event: React.MouseEvent): void => {
-								if (event && isModifierKeyPressed(event)) {
-									openStatefulSetInNewTab(record);
-									return;
-								}
+						onRow={(record): { onClick: () => void; className: string } => ({
+							onClick: (): void => {
 								setselectedStatefulSetUID(record.statefulsetUID);
 							},
 							className: 'expanded-clickable-row',
@@ -582,10 +590,20 @@ function K8sStatefulSetsList({
 
 	const handleCloseStatefulSetDetail = (): void => {
 		setselectedStatefulSetUID(null);
-		setView(null);
-		setTracesFilters(null);
-		setEventsFilters(null);
-		setLogFilters(null);
+		setSearchParams({
+			...Object.fromEntries(
+				Array.from(searchParams.entries()).filter(
+					([key]) =>
+						![
+							INFRA_MONITORING_K8S_PARAMS_KEYS.STATEFULSET_UID,
+							INFRA_MONITORING_K8S_PARAMS_KEYS.VIEW,
+							INFRA_MONITORING_K8S_PARAMS_KEYS.TRACES_FILTERS,
+							INFRA_MONITORING_K8S_PARAMS_KEYS.EVENTS_FILTERS,
+							INFRA_MONITORING_K8S_PARAMS_KEYS.LOG_FILTERS,
+						].includes(key),
+				),
+			),
+		});
 	};
 
 	const handleGroupByChange = useCallback(
@@ -607,6 +625,10 @@ function K8sStatefulSetsList({
 			setCurrentPage(1);
 			setGroupBy(groupBy);
 			setExpandedRowKeys([]);
+			setSearchParams({
+				...Object.fromEntries(searchParams.entries()),
+				[INFRA_MONITORING_K8S_PARAMS_KEYS.GROUP_BY]: JSON.stringify(groupBy),
+			});
 
 			logEvent(InfraMonitoringEvents.GroupByChanged, {
 				entity: InfraMonitoringEvents.K8sEntity,
@@ -614,7 +636,7 @@ function K8sStatefulSetsList({
 				category: InfraMonitoringEvents.StatefulSet,
 			});
 		},
-		[groupByFiltersData, setCurrentPage, setGroupBy],
+		[groupByFiltersData, searchParams, setSearchParams],
 	);
 
 	useEffect(() => {
@@ -695,10 +717,8 @@ function K8sStatefulSetsList({
 				}}
 				tableLayout="fixed"
 				onChange={handleTableChange}
-				onRow={(
-					record,
-				): { onClick: (event: React.MouseEvent) => void; className: string } => ({
-					onClick: (event: React.MouseEvent): void => handleRowClick(record, event),
+				onRow={(record): { onClick: () => void; className: string } => ({
+					onClick: (): void => handleRowClick(record),
 					className: 'clickable-row',
 				})}
 				expandable={{

frontend/src/container/InfraMonitoringK8s/StatefulSets/StatefulSetDetails/StatefulSetDetails.tsx

@@ -2,6 +2,7 @@
 import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
 // eslint-disable-next-line no-restricted-imports
 import { useSelector } from 'react-redux';
+import { useSearchParams } from 'react-router-dom-v5-compat';
 import { Color, Spacing } from '@signozhq/design-tokens';
 import { Button, Divider, Drawer, Radio, Tooltip, Typography } from 'antd';
 import type { RadioChangeEvent } from 'antd/lib';
@@ -14,19 +15,16 @@ import {
 	initialQueryState,
 } from 'constants/queryBuilder';
 import ROUTES from 'constants/routes';
-import { filterDuplicateFilters } from 'container/InfraMonitoringK8s/commonUtils';
-import { K8sCategory } from 'container/InfraMonitoringK8s/constants';
+import { getFiltersFromParams } from 'container/InfraMonitoringK8s/commonUtils';
+import {
+	INFRA_MONITORING_K8S_PARAMS_KEYS,
+	K8sCategory,
+} from 'container/InfraMonitoringK8s/constants';
 import EntityEvents from 'container/InfraMonitoringK8s/EntityDetailsUtils/EntityEvents';
 import EntityLogs from 'container/InfraMonitoringK8s/EntityDetailsUtils/EntityLogs';
 import EntityMetrics from 'container/InfraMonitoringK8s/EntityDetailsUtils/EntityMetrics';
 import EntityTraces from 'container/InfraMonitoringK8s/EntityDetailsUtils/EntityTraces';
 import { QUERY_KEYS } from 'container/InfraMonitoringK8s/EntityDetailsUtils/utils';
-import {
-	useInfraMonitoringEventsFilters,
-	useInfraMonitoringLogFilters,
-	useInfraMonitoringTracesFilters,
-	useInfraMonitoringView,
-} from 'container/InfraMonitoringK8s/hooks';
 import {
 	CustomTimeType,
 	Time,
@@ -95,21 +93,23 @@ function StatefulSetDetails({
 			: (selectedTime as Time),
 	);
 
-	const [selectedView, setSelectedView] = useInfraMonitoringView();
-	const [logFiltersParam, setLogFiltersParam] = useInfraMonitoringLogFilters();
-	const [
-		tracesFiltersParam,
-		setTracesFiltersParam,
-	] = useInfraMonitoringTracesFilters();
-	const [
-		eventsFiltersParam,
-		setEventsFiltersParam,
-	] = useInfraMonitoringEventsFilters();
+	const [searchParams, setSearchParams] = useSearchParams();
+	const [selectedView, setSelectedView] = useState<VIEWS>(() => {
+		const view = searchParams.get(INFRA_MONITORING_K8S_PARAMS_KEYS.VIEW);
+		if (view) {
+			return view as VIEWS;
+		}
+		return VIEWS.METRICS;
+	});
 	const isDarkMode = useIsDarkMode();
 
 	const initialFilters = useMemo(() => {
-		const filters =
-			selectedView === VIEW_TYPES.LOGS ? logFiltersParam : tracesFiltersParam;
+		const urlView = searchParams.get(INFRA_MONITORING_K8S_PARAMS_KEYS.VIEW);
+		const queryKey =
+			urlView === VIEW_TYPES.LOGS
+				? INFRA_MONITORING_K8S_PARAMS_KEYS.LOG_FILTERS
+				: INFRA_MONITORING_K8S_PARAMS_KEYS.TRACES_FILTERS;
+		const filters = getFiltersFromParams(searchParams, queryKey);
 		if (filters) {
 			return filters;
 		}
@@ -141,16 +141,18 @@ function StatefulSetDetails({
 			],
 		};
 	}, [
+		searchParams,
 		statefulSet?.meta.k8s_statefulset_name,
 		statefulSet?.meta.k8s_namespace_name,
-		selectedView,
-		logFiltersParam,
-		tracesFiltersParam,
 	]);
 
 	const initialEventsFilters = useMemo(() => {
-		if (eventsFiltersParam) {
-			return eventsFiltersParam;
+		const filters = getFiltersFromParams(
+			searchParams,
+			INFRA_MONITORING_K8S_PARAMS_KEYS.EVENTS_FILTERS,
+		);
+		if (filters) {
+			return filters;
 		}
 		return {
 			op: 'AND',
@@ -179,7 +181,7 @@ function StatefulSetDetails({
 				},
 			],
 		};
-	}, [statefulSet?.meta.k8s_statefulset_name, eventsFiltersParam]);
+	}, [searchParams, statefulSet?.meta.k8s_statefulset_name]);
 
 	const [logAndTracesFilters, setLogAndTracesFilters] = useState<
 		IBuilderQuery['filters']
@@ -220,9 +222,13 @@ function StatefulSetDetails({
 
 	const handleTabChange = (e: RadioChangeEvent): void => {
 		setSelectedView(e.target.value);
-		setLogFiltersParam(null);
-		setTracesFiltersParam(null);
-		setEventsFiltersParam(null);
+		setSearchParams({
+			...Object.fromEntries(searchParams.entries()),
+			[INFRA_MONITORING_K8S_PARAMS_KEYS.VIEW]: e.target.value,
+			[INFRA_MONITORING_K8S_PARAMS_KEYS.LOG_FILTERS]: JSON.stringify(null),
+			[INFRA_MONITORING_K8S_PARAMS_KEYS.TRACES_FILTERS]: JSON.stringify(null),
+			[INFRA_MONITORING_K8S_PARAMS_KEYS.EVENTS_FILTERS]: JSON.stringify(null),
+		});
 		logEvent(InfraMonitoringEvents.TabChanged, {
 			entity: InfraMonitoringEvents.K8sEntity,
 			page: InfraMonitoringEvents.DetailedPage,
@@ -290,17 +296,20 @@ function StatefulSetDetails({
 
 				const updatedFilters = {
 					op: 'AND',
-					items: filterDuplicateFilters(
-						[
-							...(primaryFilters || []),
-							...(newFilters || []),
-							...(paginationFilter ? [paginationFilter] : []),
-						].filter((item): item is TagFilterItem => item !== undefined),
-					),
+					items: [
+						...(primaryFilters || []),
+						...(newFilters || []),
+						...(paginationFilter ? [paginationFilter] : []),
+					].filter((item): item is TagFilterItem => item !== undefined),
 				};
 
-				setLogFiltersParam(updatedFilters);
-				setSelectedView(view);
+				setSearchParams({
+					...Object.fromEntries(searchParams.entries()),
+					[INFRA_MONITORING_K8S_PARAMS_KEYS.LOG_FILTERS]: JSON.stringify(
+						updatedFilters,
+					),
+					[INFRA_MONITORING_K8S_PARAMS_KEYS.VIEW]: view,
+				});
 
 				return updatedFilters;
 			});
@@ -329,18 +338,21 @@ function StatefulSetDetails({
 
 				const updatedFilters = {
 					op: 'AND',
-					items: filterDuplicateFilters(
-						[
-							...(primaryFilters || []),
-							...(value?.items?.filter(
-								(item) => item.key?.key !== QUERY_KEYS.K8S_STATEFUL_SET_NAME,
-							) || []),
-						].filter((item): item is TagFilterItem => item !== undefined),
-					),
+					items: [
+						...(primaryFilters || []),
+						...(value?.items?.filter(
+							(item) => item.key?.key !== QUERY_KEYS.K8S_STATEFUL_SET_NAME,
+						) || []),
+					].filter((item): item is TagFilterItem => item !== undefined),
 				};
 
-				setTracesFiltersParam(updatedFilters);
-				setSelectedView(view);
+				setSearchParams({
+					...Object.fromEntries(searchParams.entries()),
+					[INFRA_MONITORING_K8S_PARAMS_KEYS.TRACES_FILTERS]: JSON.stringify(
+						updatedFilters,
+					),
+					[INFRA_MONITORING_K8S_PARAMS_KEYS.VIEW]: view,
+				});
 
 				return updatedFilters;
 			});
@@ -381,8 +393,13 @@ function StatefulSetDetails({
 					].filter((item): item is TagFilterItem => item !== undefined),
 				};
 
-				setEventsFiltersParam(updatedFilters);
-				setSelectedView(view);
+				setSearchParams({
+					...Object.fromEntries(searchParams.entries()),
+					[INFRA_MONITORING_K8S_PARAMS_KEYS.EVENTS_FILTERS]: JSON.stringify(
+						updatedFilters,
+					),
+					[INFRA_MONITORING_K8S_PARAMS_KEYS.VIEW]: view,
+				});
 
 				return updatedFilters;
 			});

frontend/src/container/InfraMonitoringK8s/StatefulSets/utils.tsx

@@ -1,5 +1,6 @@
 import { Color } from '@signozhq/design-tokens';
-import { TableColumnType as ColumnType, Tag, Tooltip } from 'antd';
+import { Tag, Tooltip } from 'antd';
+import { TableColumnType as ColumnType } from 'antd';
 import {
 	K8sStatefulSetsData,
 	K8sStatefulSetsListPayload,

frontend/src/container/InfraMonitoringK8s/Volumes/K8sVolumesList.tsx

@@ -1,6 +1,7 @@
-import React, { useCallback, useEffect, useMemo, useState } from 'react';
+import { useCallback, useEffect, useMemo, useState } from 'react';
 // eslint-disable-next-line no-restricted-imports
 import { useSelector } from 'react-redux';
+import { useSearchParams } from 'react-router-dom-v5-compat';
 import { LoadingOutlined } from '@ant-design/icons';
 import {
 	Button,
@@ -16,30 +17,23 @@ import logEvent from 'api/common/logEvent';
 import { K8sVolumesListPayload } from 'api/infraMonitoring/getK8sVolumesList';
 import classNames from 'classnames';
 import { InfraMonitoringEvents } from 'constants/events';
-import { FeatureKeys } from 'constants/features';
 import { useGetK8sVolumesList } from 'hooks/infraMonitoring/useGetK8sVolumesList';
 import { useGetAggregateKeys } from 'hooks/queryBuilder/useGetAggregateKeys';
 import { useQueryBuilder } from 'hooks/queryBuilder/useQueryBuilder';
 import { useQueryOperations } from 'hooks/queryBuilder/useQueryBuilderOperations';
 import { ChevronDown, ChevronRight } from 'lucide-react';
-import { useAppContext } from 'providers/App/App';
 import { AppState } from 'store/reducers';
 import { IBuilderQuery } from 'types/api/queryBuilder/queryBuilderData';
 import { GlobalReducer } from 'types/reducer/globalTime';
-import { buildAbsolutePath, isModifierKeyPressed } from 'utils/app';
-import { openInNewTab } from 'utils/navigation';
 
+import { FeatureKeys } from '../../../constants/features';
+import { useAppContext } from '../../../providers/App/App';
+import { getOrderByFromParams } from '../commonUtils';
 import {
 	GetK8sEntityToAggregateAttribute,
 	INFRA_MONITORING_K8S_PARAMS_KEYS,
 	K8sCategory,
 } from '../constants';
-import {
-	useInfraMonitoringCurrentPage,
-	useInfraMonitoringGroupBy,
-	useInfraMonitoringOrderBy,
-	useInfraMonitoringVolumeUID,
-} from '../hooks';
 import K8sHeader from '../K8sHeader';
 import LoadingContainer from '../LoadingContainer';
 import { usePageSize } from '../utils';
@@ -54,7 +48,6 @@ import VolumeDetails from './VolumeDetails';
 
 import '../InfraMonitoringK8s.styles.scss';
 import './K8sVolumesList.styles.scss';
-
 function K8sVolumesList({
 	isFiltersVisible,
 	handleFilterVisibilityChange,
@@ -68,21 +61,55 @@ function K8sVolumesList({
 		(state) => state.globalTime,
 	);
 
-	const [currentPage, setCurrentPage] = useInfraMonitoringCurrentPage();
+	const [searchParams, setSearchParams] = useSearchParams();
+
+	const [currentPage, setCurrentPage] = useState(() => {
+		const page = searchParams.get(INFRA_MONITORING_K8S_PARAMS_KEYS.CURRENT_PAGE);
+		if (page) {
+			return parseInt(page, 10);
+		}
+		return 1;
+	});
 	const [filtersInitialised, setFiltersInitialised] = useState(false);
 
+	useEffect(() => {
+		setSearchParams({
+			...Object.fromEntries(searchParams.entries()),
+			[INFRA_MONITORING_K8S_PARAMS_KEYS.CURRENT_PAGE]: currentPage.toString(),
+		});
+		// eslint-disable-next-line react-hooks/exhaustive-deps
+	}, [currentPage]);
+
 	const [expandedRowKeys, setExpandedRowKeys] = useState<string[]>([]);
 
-	const [orderBy, setOrderBy] = useInfraMonitoringOrderBy();
+	const [orderBy, setOrderBy] = useState<{
+		columnName: string;
+		order: 'asc' | 'desc';
+	} | null>(() => getOrderByFromParams(searchParams, true));
 
-	const [
-		selectedVolumeUID,
-		setselectedVolumeUID,
-	] = useInfraMonitoringVolumeUID();
+	const [selectedVolumeUID, setselectedVolumeUID] = useState<string | null>(
+		() => {
+			const volumeUID = searchParams.get(
+				INFRA_MONITORING_K8S_PARAMS_KEYS.VOLUME_UID,
+			);
+			if (volumeUID) {
+				return volumeUID;
+			}
+			return null;
+		},
+	);
 
 	const { pageSize, setPageSize } = usePageSize(K8sCategory.VOLUMES);
 
-	const [groupBy, setGroupBy] = useInfraMonitoringGroupBy();
+	const [groupBy, setGroupBy] = useState<IBuilderQuery['groupBy']>(() => {
+		const groupBy = searchParams.get(INFRA_MONITORING_K8S_PARAMS_KEYS.GROUP_BY);
+		if (groupBy) {
+			const decoded = decodeURIComponent(groupBy);
+			const parsed = JSON.parse(decoded);
+			return parsed as IBuilderQuery['groupBy'];
+		}
+		return [];
+	});
 
 	const [
 		selectedRowData,
@@ -109,7 +136,7 @@ function K8sVolumesList({
 		if (quickFiltersLastUpdated !== -1) {
 			setCurrentPage(1);
 		}
-	}, [quickFiltersLastUpdated, setCurrentPage]);
+	}, [quickFiltersLastUpdated]);
 
 	const { featureFlags } = useAppContext();
 	const dotMetricsEnabled =
@@ -162,7 +189,7 @@ function K8sVolumesList({
 			filters,
 			start: Math.floor(minTime / 1000000),
 			end: Math.floor(maxTime / 1000000),
-			orderBy: orderBy || baseQuery.orderBy,
+			orderBy,
 		};
 		// eslint-disable-next-line react-hooks/exhaustive-deps
 	}, [minTime, maxTime, orderBy, selectedRowData, groupBy]);
@@ -190,7 +217,7 @@ function K8sVolumesList({
 		{
 			dataSource: currentQuery.builder.queryData[0].dataSource,
 			aggregateAttribute: GetK8sEntityToAggregateAttribute(
-				K8sCategory.VOLUMES,
+				K8sCategory.NODES,
 				dotMetricsEnabled,
 			),
 			aggregateOperator: 'noop',
@@ -201,7 +228,7 @@ function K8sVolumesList({
 			queryKey: [currentQuery.builder.queryData[0].dataSource, 'noop'],
 		},
 		true,
-		K8sCategory.VOLUMES,
+		K8sCategory.NODES,
 	);
 
 	const query = useMemo(() => {
@@ -213,7 +240,7 @@ function K8sVolumesList({
 			filters: queryFilters,
 			start: Math.floor(minTime / 1000000),
 			end: Math.floor(maxTime / 1000000),
-			orderBy: orderBy || baseQuery.orderBy,
+			orderBy,
 		};
 		if (groupBy.length > 0) {
 			queryPayload.groupBy = groupBy;
@@ -286,15 +313,26 @@ function K8sVolumesList({
 			}
 
 			if ('field' in sorter && sorter.order) {
-				setOrderBy({
+				const currentOrderBy = {
 					columnName: sorter.field as string,
 					order: (sorter.order === 'ascend' ? 'asc' : 'desc') as 'asc' | 'desc',
+				};
+				setOrderBy(currentOrderBy);
+				setSearchParams({
+					...Object.fromEntries(searchParams.entries()),
+					[INFRA_MONITORING_K8S_PARAMS_KEYS.ORDER_BY]: JSON.stringify(
+						currentOrderBy,
+					),
 				});
 			} else {
 				setOrderBy(null);
+				setSearchParams({
+					...Object.fromEntries(searchParams.entries()),
+					[INFRA_MONITORING_K8S_PARAMS_KEYS.ORDER_BY]: JSON.stringify(null),
+				});
 			}
 		},
-		[setCurrentPage, setOrderBy],
+		[searchParams, setSearchParams],
 	);
 
 	const { handleChangeQueryData } = useQueryOperations({
@@ -351,28 +389,14 @@ function K8sVolumesList({
 		);
 	}, [selectedVolumeUID, volumesData, groupBy.length, nestedVolumesData]);
 
-	const openVolumeInNewTab = (record: K8sVolumesRowData): void => {
-		const newParams = new URLSearchParams(document.location.search);
-		newParams.set(INFRA_MONITORING_K8S_PARAMS_KEYS.VOLUME_UID, record.volumeUID);
-		openInNewTab(
-			buildAbsolutePath({
-				relativePath: '',
-				urlQueryString: newParams.toString(),
-			}),
-		);
-	};
-
-	const handleRowClick = (
-		record: K8sVolumesRowData,
-		event: React.MouseEvent,
-	): void => {
-		if (event && isModifierKeyPressed(event)) {
-			openVolumeInNewTab(record);
-			return;
-		}
+	const handleRowClick = (record: K8sVolumesRowData): void => {
 		if (groupBy.length === 0) {
 			setSelectedRowData(null);
 			setselectedVolumeUID(record.volumeUID);
+			setSearchParams({
+				...Object.fromEntries(searchParams.entries()),
+				[INFRA_MONITORING_K8S_PARAMS_KEYS.VOLUME_UID]: record.volumeUID,
+			});
 		} else {
 			handleGroupByRowClick(record);
 		}
@@ -401,6 +425,11 @@ function K8sVolumesList({
 		setSelectedRowData(null);
 		setGroupBy([]);
 		setOrderBy(null);
+		setSearchParams({
+			...Object.fromEntries(searchParams.entries()),
+			[INFRA_MONITORING_K8S_PARAMS_KEYS.GROUP_BY]: JSON.stringify([]),
+			[INFRA_MONITORING_K8S_PARAMS_KEYS.ORDER_BY]: JSON.stringify(null),
+		});
 	};
 
 	const expandedRowRender = (): JSX.Element => (
@@ -424,14 +453,8 @@ function K8sVolumesList({
 							indicator: <Spin indicator={<LoadingOutlined size={14} spin />} />,
 						}}
 						showHeader={false}
-						onRow={(
-							record,
-						): { onClick: (event: React.MouseEvent) => void; className: string } => ({
-							onClick: (event: React.MouseEvent): void => {
-								if (event && isModifierKeyPressed(event)) {
-									openVolumeInNewTab(record);
-									return;
-								}
+						onRow={(record): { onClick: () => void; className: string } => ({
+							onClick: (): void => {
 								setselectedVolumeUID(record.volumeUID);
 							},
 							className: 'expanded-clickable-row',
@@ -497,6 +520,13 @@ function K8sVolumesList({
 
 	const handleCloseVolumeDetail = (): void => {
 		setselectedVolumeUID(null);
+		setSearchParams({
+			...Object.fromEntries(
+				Array.from(searchParams.entries()).filter(
+					([key]) => key !== INFRA_MONITORING_K8S_PARAMS_KEYS.VOLUME_UID,
+				),
+			),
+		});
 	};
 
 	const handleGroupByChange = useCallback(
@@ -517,6 +547,10 @@ function K8sVolumesList({
 
 			setCurrentPage(1);
 			setGroupBy(groupBy);
+			setSearchParams({
+				...Object.fromEntries(searchParams.entries()),
+				[INFRA_MONITORING_K8S_PARAMS_KEYS.GROUP_BY]: JSON.stringify(groupBy),
+			});
 			setExpandedRowKeys([]);
 
 			logEvent(InfraMonitoringEvents.GroupByChanged, {
@@ -525,7 +559,7 @@ function K8sVolumesList({
 				category: InfraMonitoringEvents.Volumes,
 			});
 		},
-		[groupByFiltersData?.payload?.attributeKeys, setCurrentPage, setGroupBy],
+		[groupByFiltersData?.payload?.attributeKeys, searchParams, setSearchParams],
 	);
 
 	useEffect(() => {
@@ -563,7 +597,7 @@ function K8sVolumesList({
 				isLoadingGroupByFilters={isLoadingGroupByFilters}
 				handleGroupByChange={handleGroupByChange}
 				selectedGroupBy={groupBy}
-				entity={K8sCategory.VOLUMES}
+				entity={K8sCategory.NODES}
 				showAutoRefresh={!selectedVolumeData}
 			/>
 			{isError && <Typography>{data?.error || 'Something went wrong'}</Typography>}
@@ -606,10 +640,8 @@ function K8sVolumesList({
 				}}
 				tableLayout="fixed"
 				onChange={handleTableChange}
-				onRow={(
-					record,
-				): { onClick: (event: React.MouseEvent) => void; className: string } => ({
-					onClick: (event: React.MouseEvent): void => handleRowClick(record, event),
+				onRow={(record): { onClick: () => void; className: string } => ({
+					onClick: (): void => handleRowClick(record),
 					className: 'clickable-row',
 				})}
 				expandable={{

frontend/src/container/InfraMonitoringK8s/Volumes/utils.tsx

@@ -1,5 +1,6 @@
 import { Color } from '@signozhq/design-tokens';
-import { TableColumnType as ColumnType, Tag, Tooltip } from 'antd';
+import { Tag, Tooltip } from 'antd';
+import { TableColumnType as ColumnType } from 'antd';
 import {
 	K8sVolumesData,
 	K8sVolumesListPayload,
@@ -74,7 +75,7 @@ export const getK8sVolumesListQuery = (): K8sVolumesListPayload => ({
 		items: [],
 		op: 'and',
 	},
-	orderBy: { columnName: 'usage', order: 'desc' },
+	orderBy: { columnName: 'cpu', order: 'desc' },
 });
 
 const columnsConfig = [

frontend/src/container/InfraMonitoringK8s/__tests__/Clusters/ClusterDetails/ClusterDetails.test.tsx

@@ -8,13 +8,10 @@ import { Provider } from 'react-redux';
 import { MemoryRouter } from 'react-router-dom';
 import { fireEvent, render, screen } from '@testing-library/react';
 import ClusterDetails from 'container/InfraMonitoringK8s/Clusters/ClusterDetails/ClusterDetails';
-import { withNuqsTestingAdapter } from 'nuqs/adapters/testing';
 import store from 'store';
 
 const queryClient = new QueryClient();
 
-const Wrapper = withNuqsTestingAdapter({ searchParams: {} });
-
 describe('ClusterDetails', () => {
 	const mockCluster = {
 		meta: {
@@ -25,19 +22,17 @@ describe('ClusterDetails', () => {
 
 	it('should render modal with relevant metadata', () => {
 		render(
-			<Wrapper>
-				<QueryClientProvider client={queryClient}>
-					<Provider store={store}>
-						<MemoryRouter>
-							<ClusterDetails
-								cluster={mockCluster}
-								isModalTimeSelection
-								onClose={mockOnClose}
-							/>
-						</MemoryRouter>
-					</Provider>
-				</QueryClientProvider>
-			</Wrapper>,
+			<QueryClientProvider client={queryClient}>
+				<Provider store={store}>
+					<MemoryRouter>
+						<ClusterDetails
+							cluster={mockCluster}
+							isModalTimeSelection
+							onClose={mockOnClose}
+						/>
+					</MemoryRouter>
+				</Provider>
+			</QueryClientProvider>,
 		);
 
 		const clusterNameElements = screen.getAllByText('test-cluster');
@@ -47,19 +42,17 @@ describe('ClusterDetails', () => {
 
 	it('should render modal with 4 tabs', () => {
 		render(
-			<Wrapper>
-				<QueryClientProvider client={queryClient}>
-					<Provider store={store}>
-						<MemoryRouter>
-							<ClusterDetails
-								cluster={mockCluster}
-								isModalTimeSelection
-								onClose={mockOnClose}
-							/>
-						</MemoryRouter>
-					</Provider>
-				</QueryClientProvider>
-			</Wrapper>,
+			<QueryClientProvider client={queryClient}>
+				<Provider store={store}>
+					<MemoryRouter>
+						<ClusterDetails
+							cluster={mockCluster}
+							isModalTimeSelection
+							onClose={mockOnClose}
+						/>
+					</MemoryRouter>
+				</Provider>
+			</QueryClientProvider>,
 		);
 
 		const metricsTab = screen.getByText('Metrics');
@@ -77,19 +70,17 @@ describe('ClusterDetails', () => {
 
 	it('default tab should be metrics', () => {
 		render(
-			<Wrapper>
-				<QueryClientProvider client={queryClient}>
-					<Provider store={store}>
-						<MemoryRouter>
-							<ClusterDetails
-								cluster={mockCluster}
-								isModalTimeSelection
-								onClose={mockOnClose}
-							/>
-						</MemoryRouter>
-					</Provider>
-				</QueryClientProvider>
-			</Wrapper>,
+			<QueryClientProvider client={queryClient}>
+				<Provider store={store}>
+					<MemoryRouter>
+						<ClusterDetails
+							cluster={mockCluster}
+							isModalTimeSelection
+							onClose={mockOnClose}
+						/>
+					</MemoryRouter>
+				</Provider>
+			</QueryClientProvider>,
 		);
 
 		const metricsTab = screen.getByRole('radio', { name: 'Metrics' });
@@ -98,19 +89,17 @@ describe('ClusterDetails', () => {
 
 	it('should switch to events tab when events tab is clicked', () => {
 		render(
-			<Wrapper>
-				<QueryClientProvider client={queryClient}>
-					<Provider store={store}>
-						<MemoryRouter>
-							<ClusterDetails
-								cluster={mockCluster}
-								isModalTimeSelection
-								onClose={mockOnClose}
-							/>
-						</MemoryRouter>
-					</Provider>
-				</QueryClientProvider>
-			</Wrapper>,
+			<QueryClientProvider client={queryClient}>
+				<Provider store={store}>
+					<MemoryRouter>
+						<ClusterDetails
+							cluster={mockCluster}
+							isModalTimeSelection
+							onClose={mockOnClose}
+						/>
+					</MemoryRouter>
+				</Provider>
+			</QueryClientProvider>,
 		);
 
 		const eventsTab = screen.getByRole('radio', { name: 'Events' });
@@ -121,19 +110,17 @@ describe('ClusterDetails', () => {
 
 	it('should close modal when close button is clicked', () => {
 		render(
-			<Wrapper>
-				<QueryClientProvider client={queryClient}>
-					<Provider store={store}>
-						<MemoryRouter>
-							<ClusterDetails
-								cluster={mockCluster}
-								isModalTimeSelection
-								onClose={mockOnClose}
-							/>
-						</MemoryRouter>
-					</Provider>
-				</QueryClientProvider>
-			</Wrapper>,
+			<QueryClientProvider client={queryClient}>
+				<Provider store={store}>
+					<MemoryRouter>
+						<ClusterDetails
+							cluster={mockCluster}
+							isModalTimeSelection
+							onClose={mockOnClose}
+						/>
+					</MemoryRouter>
+				</Provider>
+			</QueryClientProvider>,
 		);
 
 		const closeButton = screen.getByRole('button', { name: 'Close' });

frontend/src/container/InfraMonitoringK8s/__tests__/DaemonSets/DaemonSetDetails/DaemonSetDetails.test.tsx

@@ -8,13 +8,10 @@ import { Provider } from 'react-redux';
 import { MemoryRouter } from 'react-router-dom';
 import { fireEvent, render, screen } from '@testing-library/react';
 import DaemonSetDetails from 'container/InfraMonitoringK8s/DaemonSets/DaemonSetDetails/DaemonSetDetails';
-import { withNuqsTestingAdapter } from 'nuqs/adapters/testing';
 import store from 'store';
 
 const queryClient = new QueryClient();
 
-const Wrapper = withNuqsTestingAdapter({ searchParams: {} });
-
 describe('DaemonSetDetails', () => {
 	const mockDaemonSet = {
 		meta: {
@@ -27,19 +24,17 @@ describe('DaemonSetDetails', () => {
 
 	it('should render modal with relevant metadata', () => {
 		render(
-			<Wrapper>
-				<QueryClientProvider client={queryClient}>
-					<Provider store={store}>
-						<MemoryRouter>
-							<DaemonSetDetails
-								daemonSet={mockDaemonSet}
-								isModalTimeSelection
-								onClose={mockOnClose}
-							/>
-						</MemoryRouter>
-					</Provider>
-				</QueryClientProvider>
-			</Wrapper>,
+			<QueryClientProvider client={queryClient}>
+				<Provider store={store}>
+					<MemoryRouter>
+						<DaemonSetDetails
+							daemonSet={mockDaemonSet}
+							isModalTimeSelection
+							onClose={mockOnClose}
+						/>
+					</MemoryRouter>
+				</Provider>
+			</QueryClientProvider>,
 		);
 
 		const daemonSetNameElements = screen.getAllByText('test-daemon-set');
@@ -57,19 +52,17 @@ describe('DaemonSetDetails', () => {
 
 	it('should render modal with 4 tabs', () => {
 		render(
-			<Wrapper>
-				<QueryClientProvider client={queryClient}>
-					<Provider store={store}>
-						<MemoryRouter>
-							<DaemonSetDetails
-								daemonSet={mockDaemonSet}
-								isModalTimeSelection
-								onClose={mockOnClose}
-							/>
-						</MemoryRouter>
-					</Provider>
-				</QueryClientProvider>
-			</Wrapper>,
+			<QueryClientProvider client={queryClient}>
+				<Provider store={store}>
+					<MemoryRouter>
+						<DaemonSetDetails
+							daemonSet={mockDaemonSet}
+							isModalTimeSelection
+							onClose={mockOnClose}
+						/>
+					</MemoryRouter>
+				</Provider>
+			</QueryClientProvider>,
 		);
 
 		const metricsTab = screen.getByText('Metrics');
@@ -87,19 +80,17 @@ describe('DaemonSetDetails', () => {
 
 	it('default tab should be metrics', () => {
 		render(
-			<Wrapper>
-				<QueryClientProvider client={queryClient}>
-					<Provider store={store}>
-						<MemoryRouter>
-							<DaemonSetDetails
-								daemonSet={mockDaemonSet}
-								isModalTimeSelection
-								onClose={mockOnClose}
-							/>
-						</MemoryRouter>
-					</Provider>
-				</QueryClientProvider>
-			</Wrapper>,
+			<QueryClientProvider client={queryClient}>
+				<Provider store={store}>
+					<MemoryRouter>
+						<DaemonSetDetails
+							daemonSet={mockDaemonSet}
+							isModalTimeSelection
+							onClose={mockOnClose}
+						/>
+					</MemoryRouter>
+				</Provider>
+			</QueryClientProvider>,
 		);
 
 		const metricsTab = screen.getByRole('radio', { name: 'Metrics' });
@@ -108,19 +99,17 @@ describe('DaemonSetDetails', () => {
 
 	it('should switch to events tab when events tab is clicked', () => {
 		render(
-			<Wrapper>
-				<QueryClientProvider client={queryClient}>
-					<Provider store={store}>
-						<MemoryRouter>
-							<DaemonSetDetails
-								daemonSet={mockDaemonSet}
-								isModalTimeSelection
-								onClose={mockOnClose}
-							/>
-						</MemoryRouter>
-					</Provider>
-				</QueryClientProvider>
-			</Wrapper>,
+			<QueryClientProvider client={queryClient}>
+				<Provider store={store}>
+					<MemoryRouter>
+						<DaemonSetDetails
+							daemonSet={mockDaemonSet}
+							isModalTimeSelection
+							onClose={mockOnClose}
+						/>
+					</MemoryRouter>
+				</Provider>
+			</QueryClientProvider>,
 		);
 
 		const eventsTab = screen.getByRole('radio', { name: 'Events' });
@@ -131,19 +120,17 @@ describe('DaemonSetDetails', () => {
 
 	it('should close modal when close button is clicked', () => {
 		render(
-			<Wrapper>
-				<QueryClientProvider client={queryClient}>
-					<Provider store={store}>
-						<MemoryRouter>
-							<DaemonSetDetails
-								daemonSet={mockDaemonSet}
-								isModalTimeSelection
-								onClose={mockOnClose}
-							/>
-						</MemoryRouter>
-					</Provider>
-				</QueryClientProvider>
-			</Wrapper>,
+			<QueryClientProvider client={queryClient}>
+				<Provider store={store}>
+					<MemoryRouter>
+						<DaemonSetDetails
+							daemonSet={mockDaemonSet}
+							isModalTimeSelection
+							onClose={mockOnClose}
+						/>
+					</MemoryRouter>
+				</Provider>
+			</QueryClientProvider>,
 		);
 
 		const closeButton = screen.getByRole('button', { name: 'Close' });

frontend/src/container/InfraMonitoringK8s/__tests__/Deployments/DeploymentDetails/DeploymentDetails.test.tsx

@@ -8,13 +8,10 @@ import { Provider } from 'react-redux';
 import { MemoryRouter } from 'react-router-dom';
 import { fireEvent, render, screen } from '@testing-library/react';
 import DeploymentDetails from 'container/InfraMonitoringK8s/Deployments/DeploymentDetails/DeploymentDetails';
-import { withNuqsTestingAdapter } from 'nuqs/adapters/testing';
 import store from 'store';
 
 const queryClient = new QueryClient();
 
-const Wrapper = withNuqsTestingAdapter({ searchParams: {} });
-
 describe('DeploymentDetails', () => {
 	const mockDeployment = {
 		meta: {
@@ -27,19 +24,17 @@ describe('DeploymentDetails', () => {
 
 	it('should render modal with relevant metadata', () => {
 		render(
-			<Wrapper>
-				<QueryClientProvider client={queryClient}>
-					<Provider store={store}>
-						<MemoryRouter>
-							<DeploymentDetails
-								deployment={mockDeployment}
-								isModalTimeSelection
-								onClose={mockOnClose}
-							/>
-						</MemoryRouter>
-					</Provider>
-				</QueryClientProvider>
-			</Wrapper>,
+			<QueryClientProvider client={queryClient}>
+				<Provider store={store}>
+					<MemoryRouter>
+						<DeploymentDetails
+							deployment={mockDeployment}
+							isModalTimeSelection
+							onClose={mockOnClose}
+						/>
+					</MemoryRouter>
+				</Provider>
+			</QueryClientProvider>,
 		);
 
 		const deploymentNameElements = screen.getAllByText('test-deployment');
@@ -57,19 +52,17 @@ describe('DeploymentDetails', () => {
 
 	it('should render modal with 4 tabs', () => {
 		render(
-			<Wrapper>
-				<QueryClientProvider client={queryClient}>
-					<Provider store={store}>
-						<MemoryRouter>
-							<DeploymentDetails
-								deployment={mockDeployment}
-								isModalTimeSelection
-								onClose={mockOnClose}
-							/>
-						</MemoryRouter>
-					</Provider>
-				</QueryClientProvider>
-			</Wrapper>,
+			<QueryClientProvider client={queryClient}>
+				<Provider store={store}>
+					<MemoryRouter>
+						<DeploymentDetails
+							deployment={mockDeployment}
+							isModalTimeSelection
+							onClose={mockOnClose}
+						/>
+					</MemoryRouter>
+				</Provider>
+			</QueryClientProvider>,
 		);
 
 		const metricsTab = screen.getByText('Metrics');
@@ -87,19 +80,17 @@ describe('DeploymentDetails', () => {
 
 	it('default tab should be metrics', () => {
 		render(
-			<Wrapper>
-				<QueryClientProvider client={queryClient}>
-					<Provider store={store}>
-						<MemoryRouter>
-							<DeploymentDetails
-								deployment={mockDeployment}
-								isModalTimeSelection
-								onClose={mockOnClose}
-							/>
-						</MemoryRouter>
-					</Provider>
-				</QueryClientProvider>
-			</Wrapper>,
+			<QueryClientProvider client={queryClient}>
+				<Provider store={store}>
+					<MemoryRouter>
+						<DeploymentDetails
+							deployment={mockDeployment}
+							isModalTimeSelection
+							onClose={mockOnClose}
+						/>
+					</MemoryRouter>
+				</Provider>
+			</QueryClientProvider>,
 		);
 
 		const metricsTab = screen.getByRole('radio', { name: 'Metrics' });
@@ -108,19 +99,17 @@ describe('DeploymentDetails', () => {
 
 	it('should switch to events tab when events tab is clicked', () => {
 		render(
-			<Wrapper>
-				<QueryClientProvider client={queryClient}>
-					<Provider store={store}>
-						<MemoryRouter>
-							<DeploymentDetails
-								deployment={mockDeployment}
-								isModalTimeSelection
-								onClose={mockOnClose}
-							/>
-						</MemoryRouter>
-					</Provider>
-				</QueryClientProvider>
-			</Wrapper>,
+			<QueryClientProvider client={queryClient}>
+				<Provider store={store}>
+					<MemoryRouter>
+						<DeploymentDetails
+							deployment={mockDeployment}
+							isModalTimeSelection
+							onClose={mockOnClose}
+						/>
+					</MemoryRouter>
+				</Provider>
+			</QueryClientProvider>,
 		);
 
 		const eventsTab = screen.getByRole('radio', { name: 'Events' });
@@ -131,19 +120,17 @@ describe('DeploymentDetails', () => {
 
 	it('should close modal when close button is clicked', () => {
 		render(
-			<Wrapper>
-				<QueryClientProvider client={queryClient}>
-					<Provider store={store}>
-						<MemoryRouter>
-							<DeploymentDetails
-								deployment={mockDeployment}
-								isModalTimeSelection
-								onClose={mockOnClose}
-							/>
-						</MemoryRouter>
-					</Provider>
-				</QueryClientProvider>
-			</Wrapper>,
+			<QueryClientProvider client={queryClient}>
+				<Provider store={store}>
+					<MemoryRouter>
+						<DeploymentDetails
+							deployment={mockDeployment}
+							isModalTimeSelection
+							onClose={mockOnClose}
+						/>
+					</MemoryRouter>
+				</Provider>
+			</QueryClientProvider>,
 		);
 
 		const closeButton = screen.getByRole('button', { name: 'Close' });

frontend/src/container/InfraMonitoringK8s/__tests__/Jobs/JobDetails/JobDetails.test.tsx

@@ -2,18 +2,8 @@ import setupCommonMocks from '../../commonMocks';
 
 setupCommonMocks();
 
-import { QueryClient, QueryClientProvider } from 'react-query';
-// eslint-disable-next-line no-restricted-imports
-import { Provider } from 'react-redux';
-import { MemoryRouter } from 'react-router-dom';
-import { fireEvent, render, screen } from '@testing-library/react';
 import JobDetails from 'container/InfraMonitoringK8s/Jobs/JobDetails/JobDetails';
-import { withNuqsTestingAdapter } from 'nuqs/adapters/testing';
-import store from 'store';
-
-const queryClient = new QueryClient();
-
-const Wrapper = withNuqsTestingAdapter({ searchParams: {} });
+import { fireEvent, render, screen } from 'tests/test-utils';
 
 describe('JobDetails', () => {
 	const mockJob = {
@@ -26,15 +16,7 @@ describe('JobDetails', () => {
 
 	it('should render modal with relevant metadata', () => {
 		render(
-			<Wrapper>
-				<QueryClientProvider client={queryClient}>
-					<Provider store={store}>
-						<MemoryRouter>
-							<JobDetails job={mockJob} isModalTimeSelection onClose={mockOnClose} />
-						</MemoryRouter>
-					</Provider>
-				</QueryClientProvider>
-			</Wrapper>,
+			<JobDetails job={mockJob} isModalTimeSelection onClose={mockOnClose} />,
 		);
 
 		const jobNameElements = screen.getAllByText('test-job');
@@ -48,15 +30,7 @@ describe('JobDetails', () => {
 
 	it('should render modal with 4 tabs', () => {
 		render(
-			<Wrapper>
-				<QueryClientProvider client={queryClient}>
-					<Provider store={store}>
-						<MemoryRouter>
-							<JobDetails job={mockJob} isModalTimeSelection onClose={mockOnClose} />
-						</MemoryRouter>
-					</Provider>
-				</QueryClientProvider>
-			</Wrapper>,
+			<JobDetails job={mockJob} isModalTimeSelection onClose={mockOnClose} />,
 		);
 
 		const metricsTab = screen.getByText('Metrics');
@@ -74,15 +48,7 @@ describe('JobDetails', () => {
 
 	it('default tab should be metrics', () => {
 		render(
-			<Wrapper>
-				<QueryClientProvider client={queryClient}>
-					<Provider store={store}>
-						<MemoryRouter>
-							<JobDetails job={mockJob} isModalTimeSelection onClose={mockOnClose} />
-						</MemoryRouter>
-					</Provider>
-				</QueryClientProvider>
-			</Wrapper>,
+			<JobDetails job={mockJob} isModalTimeSelection onClose={mockOnClose} />,
 		);
 
 		const metricsTab = screen.getByRole('radio', { name: 'Metrics' });
@@ -91,15 +57,7 @@ describe('JobDetails', () => {
 
 	it('should switch to events tab when events tab is clicked', () => {
 		render(
-			<Wrapper>
-				<QueryClientProvider client={queryClient}>
-					<Provider store={store}>
-						<MemoryRouter>
-							<JobDetails job={mockJob} isModalTimeSelection onClose={mockOnClose} />
-						</MemoryRouter>
-					</Provider>
-				</QueryClientProvider>
-			</Wrapper>,
+			<JobDetails job={mockJob} isModalTimeSelection onClose={mockOnClose} />,
 		);
 
 		const eventsTab = screen.getByRole('radio', { name: 'Events' });
@@ -110,15 +68,7 @@ describe('JobDetails', () => {
 
 	it('should close modal when close button is clicked', () => {
 		render(
-			<Wrapper>
-				<QueryClientProvider client={queryClient}>
-					<Provider store={store}>
-						<MemoryRouter>
-							<JobDetails job={mockJob} isModalTimeSelection onClose={mockOnClose} />
-						</MemoryRouter>
-					</Provider>
-				</QueryClientProvider>
-			</Wrapper>,
+			<JobDetails job={mockJob} isModalTimeSelection onClose={mockOnClose} />,
 		);
 
 		const closeButton = screen.getByRole('button', { name: 'Close' });

frontend/src/container/InfraMonitoringK8s/__tests__/K8sHeader.test.tsx

@@ -1,131 +0,0 @@
-import setupCommonMocks from './commonMocks';
-
-setupCommonMocks();
-
-import { QueryClient, QueryClientProvider } from 'react-query';
-// eslint-disable-next-line no-restricted-imports
-import { MemoryRouter } from 'react-router-dom';
-import { render, screen } from '@testing-library/react';
-import K8sHeader from 'container/InfraMonitoringK8s/K8sHeader';
-import { withNuqsTestingAdapter } from 'nuqs/adapters/testing';
-
-import { INFRA_MONITORING_K8S_PARAMS_KEYS, K8sCategory } from '../constants';
-
-const queryClient = new QueryClient({
-	defaultOptions: {
-		queries: {
-			retry: false,
-		},
-	},
-});
-
-describe('K8sHeader URL Parameter Parsing', () => {
-	const defaultProps = {
-		selectedGroupBy: [],
-		groupByOptions: [],
-		isLoadingGroupByFilters: false,
-		handleFiltersChange: jest.fn(),
-		handleGroupByChange: jest.fn(),
-		defaultAddedColumns: [],
-		handleFilterVisibilityChange: jest.fn(),
-		isFiltersVisible: true,
-		entity: K8sCategory.PODS,
-		showAutoRefresh: true,
-	};
-
-	const renderComponent = (
-		searchParams?: string | Record<string, string>,
-	): ReturnType<typeof render> => {
-		const Wrapper = withNuqsTestingAdapter({ searchParams: searchParams ?? {} });
-		return render(
-			<Wrapper>
-				<QueryClientProvider client={queryClient}>
-					<MemoryRouter>
-						<K8sHeader {...defaultProps} />
-					</MemoryRouter>
-				</QueryClientProvider>
-			</Wrapper>,
-		);
-	};
-
-	beforeEach(() => {
-		jest.clearAllMocks();
-	});
-
-	it('should render without crashing when no URL params', () => {
-		expect(() => renderComponent()).not.toThrow();
-		expect(screen.getByText('Group by')).toBeInTheDocument();
-	});
-
-	it('should render without crashing with valid filters in URL', () => {
-		const filters = {
-			items: [
-				{
-					id: '1',
-					key: { key: 'k8s_namespace_name' },
-					op: '=',
-					value: 'kube-system',
-				},
-			],
-			op: 'AND',
-		};
-
-		expect(() =>
-			renderComponent({
-				[INFRA_MONITORING_K8S_PARAMS_KEYS.FILTERS]: JSON.stringify(filters),
-			}),
-		).not.toThrow();
-	});
-
-	it('should render without crashing with malformed filters JSON', () => {
-		const consoleSpy = jest.spyOn(console, 'error').mockImplementation(() => {});
-
-		expect(() =>
-			renderComponent({
-				[INFRA_MONITORING_K8S_PARAMS_KEYS.FILTERS]: 'invalid-json',
-			}),
-		).not.toThrow();
-
-		consoleSpy.mockRestore();
-	});
-
-	it('should handle filters with K8s container image values', () => {
-		const filters = {
-			items: [
-				{
-					id: '1',
-					key: { key: 'k8s_container_image' },
-					op: '=',
-					value: 'registry.k8s.io/coredns/coredns:v1.10.1',
-				},
-			],
-			op: 'AND',
-		};
-
-		expect(() =>
-			renderComponent({
-				[INFRA_MONITORING_K8S_PARAMS_KEYS.FILTERS]: JSON.stringify(filters),
-			}),
-		).not.toThrow();
-	});
-
-	it('should handle filters with percent signs in values', () => {
-		const filters = {
-			items: [
-				{
-					id: '1',
-					key: { key: 'k8s_label' },
-					op: '=',
-					value: 'cpu-usage-50%',
-				},
-			],
-			op: 'AND',
-		};
-
-		expect(() =>
-			renderComponent({
-				[INFRA_MONITORING_K8S_PARAMS_KEYS.FILTERS]: JSON.stringify(filters),
-			}),
-		).not.toThrow();
-	});
-});

frontend/src/container/InfraMonitoringK8s/__tests__/Namespaces/NamespaceDetails/NamespaceDetails.test.tsx

@@ -8,13 +8,10 @@ import { Provider } from 'react-redux';
 import { MemoryRouter } from 'react-router-dom';
 import { fireEvent, render, screen } from '@testing-library/react';
 import NamespaceDetails from 'container/InfraMonitoringK8s/Namespaces/NamespaceDetails/NamespaceDetails';
-import { withNuqsTestingAdapter } from 'nuqs/adapters/testing';
 import store from 'store';
 
 const queryClient = new QueryClient();
 
-const Wrapper = withNuqsTestingAdapter({ searchParams: {} });
-
 describe('NamespaceDetails', () => {
 	const mockNamespace = {
 		namespaceName: 'test-namespace',
@@ -26,19 +23,17 @@ describe('NamespaceDetails', () => {
 
 	it('should render modal with relevant metadata', () => {
 		render(
-			<Wrapper>
-				<QueryClientProvider client={queryClient}>
-					<Provider store={store}>
-						<MemoryRouter>
-							<NamespaceDetails
-								namespace={mockNamespace}
-								isModalTimeSelection
-								onClose={mockOnClose}
-							/>
-						</MemoryRouter>
-					</Provider>
-				</QueryClientProvider>
-			</Wrapper>,
+			<QueryClientProvider client={queryClient}>
+				<Provider store={store}>
+					<MemoryRouter>
+						<NamespaceDetails
+							namespace={mockNamespace}
+							isModalTimeSelection
+							onClose={mockOnClose}
+						/>
+					</MemoryRouter>
+				</Provider>
+			</QueryClientProvider>,
 		);
 
 		const namespaceNameElements = screen.getAllByText('test-namespace');
@@ -52,19 +47,17 @@ describe('NamespaceDetails', () => {
 
 	it('should render modal with 4 tabs', () => {
 		render(
-			<Wrapper>
-				<QueryClientProvider client={queryClient}>
-					<Provider store={store}>
-						<MemoryRouter>
-							<NamespaceDetails
-								namespace={mockNamespace}
-								isModalTimeSelection
-								onClose={mockOnClose}
-							/>
-						</MemoryRouter>
-					</Provider>
-				</QueryClientProvider>
-			</Wrapper>,
+			<QueryClientProvider client={queryClient}>
+				<Provider store={store}>
+					<MemoryRouter>
+						<NamespaceDetails
+							namespace={mockNamespace}
+							isModalTimeSelection
+							onClose={mockOnClose}
+						/>
+					</MemoryRouter>
+				</Provider>
+			</QueryClientProvider>,
 		);
 
 		const metricsTab = screen.getByText('Metrics');
@@ -82,19 +75,17 @@ describe('NamespaceDetails', () => {
 
 	it('default tab should be metrics', () => {
 		render(
-			<Wrapper>
-				<QueryClientProvider client={queryClient}>
-					<Provider store={store}>
-						<MemoryRouter>
-							<NamespaceDetails
-								namespace={mockNamespace}
-								isModalTimeSelection
-								onClose={mockOnClose}
-							/>
-						</MemoryRouter>
-					</Provider>
-				</QueryClientProvider>
-			</Wrapper>,
+			<QueryClientProvider client={queryClient}>
+				<Provider store={store}>
+					<MemoryRouter>
+						<NamespaceDetails
+							namespace={mockNamespace}
+							isModalTimeSelection
+							onClose={mockOnClose}
+						/>
+					</MemoryRouter>
+				</Provider>
+			</QueryClientProvider>,
 		);
 
 		const metricsTab = screen.getByRole('radio', { name: 'Metrics' });
@@ -103,19 +94,17 @@ describe('NamespaceDetails', () => {
 
 	it('should switch to events tab when events tab is clicked', () => {
 		render(
-			<Wrapper>
-				<QueryClientProvider client={queryClient}>
-					<Provider store={store}>
-						<MemoryRouter>
-							<NamespaceDetails
-								namespace={mockNamespace}
-								isModalTimeSelection
-								onClose={mockOnClose}
-							/>
-						</MemoryRouter>
-					</Provider>
-				</QueryClientProvider>
-			</Wrapper>,
+			<QueryClientProvider client={queryClient}>
+				<Provider store={store}>
+					<MemoryRouter>
+						<NamespaceDetails
+							namespace={mockNamespace}
+							isModalTimeSelection
+							onClose={mockOnClose}
+						/>
+					</MemoryRouter>
+				</Provider>
+			</QueryClientProvider>,
 		);
 
 		const eventsTab = screen.getByRole('radio', { name: 'Events' });
@@ -126,19 +115,17 @@ describe('NamespaceDetails', () => {
 
 	it('should close modal when close button is clicked', () => {
 		render(
-			<Wrapper>
-				<QueryClientProvider client={queryClient}>
-					<Provider store={store}>
-						<MemoryRouter>
-							<NamespaceDetails
-								namespace={mockNamespace}
-								isModalTimeSelection
-								onClose={mockOnClose}
-							/>
-						</MemoryRouter>
-					</Provider>
-				</QueryClientProvider>
-			</Wrapper>,
+			<QueryClientProvider client={queryClient}>
+				<Provider store={store}>
+					<MemoryRouter>
+						<NamespaceDetails
+							namespace={mockNamespace}
+							isModalTimeSelection
+							onClose={mockOnClose}
+						/>
+					</MemoryRouter>
+				</Provider>
+			</QueryClientProvider>,
 		);
 
 		const closeButton = screen.getByRole('button', { name: 'Close' });

frontend/src/container/InfraMonitoringK8s/__tests__/Nodes/NodeDetails/NodeDetails.test.tsx

@@ -8,13 +8,10 @@ import { Provider } from 'react-redux';
 import { MemoryRouter } from 'react-router-dom';
 import { fireEvent, render, screen } from '@testing-library/react';
 import NodeDetails from 'container/InfraMonitoringK8s/Nodes/NodeDetails/NodeDetails';
-import { withNuqsTestingAdapter } from 'nuqs/adapters/testing';
 import store from 'store';
 
 const queryClient = new QueryClient();
 
-const Wrapper = withNuqsTestingAdapter({ searchParams: {} });
-
 describe('NodeDetails', () => {
 	const mockNode = {
 		meta: {
@@ -26,19 +23,13 @@ describe('NodeDetails', () => {
 
 	it('should render modal with relevant metadata', () => {
 		render(
-			<Wrapper>
-				<QueryClientProvider client={queryClient}>
-					<Provider store={store}>
-						<MemoryRouter>
-							<NodeDetails
-								node={mockNode}
-								isModalTimeSelection
-								onClose={mockOnClose}
-							/>
-						</MemoryRouter>
-					</Provider>
-				</QueryClientProvider>
-			</Wrapper>,
+			<QueryClientProvider client={queryClient}>
+				<Provider store={store}>
+					<MemoryRouter>
+						<NodeDetails node={mockNode} isModalTimeSelection onClose={mockOnClose} />
+					</MemoryRouter>
+				</Provider>
+			</QueryClientProvider>,
 		);
 
 		const nodeNameElements = screen.getAllByText('test-node');
@@ -52,19 +43,13 @@ describe('NodeDetails', () => {
 
 	it('should render modal with 4 tabs', () => {
 		render(
-			<Wrapper>
-				<QueryClientProvider client={queryClient}>
-					<Provider store={store}>
-						<MemoryRouter>
-							<NodeDetails
-								node={mockNode}
-								isModalTimeSelection
-								onClose={mockOnClose}
-							/>
-						</MemoryRouter>
-					</Provider>
-				</QueryClientProvider>
-			</Wrapper>,
+			<QueryClientProvider client={queryClient}>
+				<Provider store={store}>
+					<MemoryRouter>
+						<NodeDetails node={mockNode} isModalTimeSelection onClose={mockOnClose} />
+					</MemoryRouter>
+				</Provider>
+			</QueryClientProvider>,
 		);
 
 		const metricsTab = screen.getByText('Metrics');
@@ -82,19 +67,13 @@ describe('NodeDetails', () => {
 
 	it('default tab should be metrics', () => {
 		render(
-			<Wrapper>
-				<QueryClientProvider client={queryClient}>
-					<Provider store={store}>
-						<MemoryRouter>
-							<NodeDetails
-								node={mockNode}
-								isModalTimeSelection
-								onClose={mockOnClose}
-							/>
-						</MemoryRouter>
-					</Provider>
-				</QueryClientProvider>
-			</Wrapper>,
+			<QueryClientProvider client={queryClient}>
+				<Provider store={store}>
+					<MemoryRouter>
+						<NodeDetails node={mockNode} isModalTimeSelection onClose={mockOnClose} />
+					</MemoryRouter>
+				</Provider>
+			</QueryClientProvider>,
 		);
 
 		const metricsTab = screen.getByRole('radio', { name: 'Metrics' });
@@ -103,19 +82,13 @@ describe('NodeDetails', () => {
 
 	it('should switch to events tab when events tab is clicked', () => {
 		render(
-			<Wrapper>
-				<QueryClientProvider client={queryClient}>
-					<Provider store={store}>
-						<MemoryRouter>
-							<NodeDetails
-								node={mockNode}
-								isModalTimeSelection
-								onClose={mockOnClose}
-							/>
-						</MemoryRouter>
-					</Provider>
-				</QueryClientProvider>
-			</Wrapper>,
+			<QueryClientProvider client={queryClient}>
+				<Provider store={store}>
+					<MemoryRouter>
+						<NodeDetails node={mockNode} isModalTimeSelection onClose={mockOnClose} />
+					</MemoryRouter>
+				</Provider>
+			</QueryClientProvider>,
 		);
 
 		const eventsTab = screen.getByRole('radio', { name: 'Events' });
@@ -126,19 +99,13 @@ describe('NodeDetails', () => {
 
 	it('should close modal when close button is clicked', () => {
 		render(
-			<Wrapper>
-				<QueryClientProvider client={queryClient}>
-					<Provider store={store}>
-						<MemoryRouter>
-							<NodeDetails
-								node={mockNode}
-								isModalTimeSelection
-								onClose={mockOnClose}
-							/>
-						</MemoryRouter>
-					</Provider>
-				</QueryClientProvider>
-			</Wrapper>,
+			<QueryClientProvider client={queryClient}>
+				<Provider store={store}>
+					<MemoryRouter>
+						<NodeDetails node={mockNode} isModalTimeSelection onClose={mockOnClose} />
+					</MemoryRouter>
+				</Provider>
+			</QueryClientProvider>,
 		);
 
 		const closeButton = screen.getByRole('button', { name: 'Close' });

frontend/src/container/InfraMonitoringK8s/__tests__/Pods/K8sPodsList.test.tsx

@@ -1,155 +0,0 @@
-/**
- * Tests for URL parameter parsing in K8s Infra Monitoring components.
- *
- * These tests verify the fix for the double URL decoding bug where
- * components were calling decodeURIComponent() on values already
- * decoded by URLSearchParams.get(), causing crashes on K8s parameters
- * with special characters.
- */
-
-import { getFiltersFromParams } from '../../commonUtils';
-
-describe('K8sPodsList URL Parameter Parsing', () => {
-	describe('getFiltersFromParams', () => {
-		it('should return null when no filters in params', () => {
-			const searchParams = new URLSearchParams();
-			const result = getFiltersFromParams(searchParams, 'filters');
-			expect(result).toBeNull();
-		});
-
-		it('should parse filters from URL params', () => {
-			const filters = {
-				items: [
-					{
-						id: '1',
-						key: { key: 'k8s_namespace_name' },
-						op: '=',
-						value: 'default',
-					},
-				],
-				op: 'AND',
-			};
-			const searchParams = new URLSearchParams();
-			searchParams.set('filters', JSON.stringify(filters));
-
-			const result = getFiltersFromParams(searchParams, 'filters');
-			expect(result).toEqual(filters);
-		});
-
-		it('should handle URL-encoded filters (auto-decoded by URLSearchParams)', () => {
-			const filters = {
-				items: [
-					{
-						id: '1',
-						key: { key: 'k8s_pod_name' },
-						op: 'contains',
-						value: 'api-server',
-					},
-				],
-				op: 'AND',
-			};
-			const encodedValue = encodeURIComponent(JSON.stringify(filters));
-			const searchParams = new URLSearchParams(`filters=${encodedValue}`);
-
-			const result = getFiltersFromParams(searchParams, 'filters');
-			expect(result).toEqual(filters);
-		});
-
-		it('should return null on malformed JSON instead of crashing', () => {
-			const consoleSpy = jest.spyOn(console, 'error').mockImplementation(() => {});
-			const searchParams = new URLSearchParams();
-			searchParams.set('filters', '{invalid-json}');
-
-			const result = getFiltersFromParams(searchParams, 'filters');
-			expect(result).toBeNull();
-			consoleSpy.mockRestore();
-		});
-
-		it('should handle filters with K8s container image names', () => {
-			const filters = {
-				items: [
-					{
-						id: '1',
-						key: { key: 'k8s_container_name' },
-						op: '=',
-						value: 'registry.k8s.io/coredns/coredns:v1.10.1',
-					},
-				],
-				op: 'AND',
-			};
-			const encodedValue = encodeURIComponent(JSON.stringify(filters));
-			const searchParams = new URLSearchParams(`filters=${encodedValue}`);
-
-			const result = getFiltersFromParams(searchParams, 'filters');
-			expect(result).toEqual(filters);
-		});
-	});
-
-	describe('regression: double decoding issue', () => {
-		it('should not crash when URL params are already decoded by URLSearchParams', () => {
-			// The key bug: URLSearchParams.get() auto-decodes, so encoding once in URL
-			// means .get() returns decoded value. Old code called decodeURIComponent()
-			// again which could crash on certain characters.
-
-			const filters = {
-				items: [
-					{
-						id: '1',
-						key: { key: 'k8s_namespace_name' },
-						op: '=',
-						value: 'kube-system',
-					},
-				],
-				op: 'AND',
-			};
-
-			const encodedValue = encodeURIComponent(JSON.stringify(filters));
-			const searchParams = new URLSearchParams(`filters=${encodedValue}`);
-
-			// This should work without crashing
-			const result = getFiltersFromParams(searchParams, 'filters');
-			expect(result).toEqual(filters);
-		});
-
-		it('should handle values with percent signs in labels', () => {
-			// K8s labels might contain literal "%" characters like "cpu-usage-50%"
-			const filters = {
-				items: [
-					{
-						id: '1',
-						key: { key: 'k8s_label' },
-						op: '=',
-						value: 'cpu-50%',
-					},
-				],
-				op: 'AND',
-			};
-
-			const encodedValue = encodeURIComponent(JSON.stringify(filters));
-			const searchParams = new URLSearchParams(`filters=${encodedValue}`);
-
-			const result = getFiltersFromParams(searchParams, 'filters');
-			expect(result).toEqual(filters);
-		});
-
-		it('should handle complex K8s deployment names with special chars', () => {
-			const filters = {
-				items: [
-					{
-						id: '1',
-						key: { key: 'k8s_deployment_name' },
-						op: '=',
-						value: 'nginx-ingress-controller',
-					},
-				],
-				op: 'AND',
-			};
-
-			const encodedValue = encodeURIComponent(JSON.stringify(filters));
-			const searchParams = new URLSearchParams(`filters=${encodedValue}`);
-
-			const result = getFiltersFromParams(searchParams, 'filters');
-			expect(result).toEqual(filters);
-		});
-	});
-});

frontend/src/container/InfraMonitoringK8s/__tests__/Pods/PodDetails/PodDetails.test.tsx

@@ -8,13 +8,10 @@ import { Provider } from 'react-redux';
 import { MemoryRouter } from 'react-router-dom';
 import { fireEvent, render, screen } from '@testing-library/react';
 import PodDetails from 'container/InfraMonitoringK8s/Pods/PodDetails/PodDetails';
-import { withNuqsTestingAdapter } from 'nuqs/adapters/testing';
 import store from 'store';
 
 const queryClient = new QueryClient();
 
-const Wrapper = withNuqsTestingAdapter({ searchParams: {} });
-
 describe('PodDetails', () => {
 	const mockPod = {
 		podName: 'test-pod',
@@ -28,15 +25,13 @@ describe('PodDetails', () => {
 
 	it('should render modal with relevant metadata', () => {
 		render(
-			<Wrapper>
-				<QueryClientProvider client={queryClient}>
-					<Provider store={store}>
-						<MemoryRouter>
-							<PodDetails pod={mockPod} isModalTimeSelection onClose={mockOnClose} />
-						</MemoryRouter>
-					</Provider>
-				</QueryClientProvider>
-			</Wrapper>,
+			<QueryClientProvider client={queryClient}>
+				<Provider store={store}>
+					<MemoryRouter>
+						<PodDetails pod={mockPod} isModalTimeSelection onClose={mockOnClose} />
+					</MemoryRouter>
+				</Provider>
+			</QueryClientProvider>,
 		);
 
 		const clusterNameElements = screen.getAllByText('test-cluster');
@@ -54,15 +49,13 @@ describe('PodDetails', () => {
 
 	it('should render modal with 4 tabs', () => {
 		render(
-			<Wrapper>
-				<QueryClientProvider client={queryClient}>
-					<Provider store={store}>
-						<MemoryRouter>
-							<PodDetails pod={mockPod} isModalTimeSelection onClose={mockOnClose} />
-						</MemoryRouter>
-					</Provider>
-				</QueryClientProvider>
-			</Wrapper>,
+			<QueryClientProvider client={queryClient}>
+				<Provider store={store}>
+					<MemoryRouter>
+						<PodDetails pod={mockPod} isModalTimeSelection onClose={mockOnClose} />
+					</MemoryRouter>
+				</Provider>
+			</QueryClientProvider>,
 		);
 
 		const metricsTab = screen.getByText('Metrics');
@@ -80,15 +73,13 @@ describe('PodDetails', () => {
 
 	it('default tab should be metrics', () => {
 		render(
-			<Wrapper>
-				<QueryClientProvider client={queryClient}>
-					<Provider store={store}>
-						<MemoryRouter>
-							<PodDetails pod={mockPod} isModalTimeSelection onClose={mockOnClose} />
-						</MemoryRouter>
-					</Provider>
-				</QueryClientProvider>
-			</Wrapper>,
+			<QueryClientProvider client={queryClient}>
+				<Provider store={store}>
+					<MemoryRouter>
+						<PodDetails pod={mockPod} isModalTimeSelection onClose={mockOnClose} />
+					</MemoryRouter>
+				</Provider>
+			</QueryClientProvider>,
 		);
 
 		const metricsTab = screen.getByRole('radio', { name: 'Metrics' });
@@ -97,15 +88,13 @@ describe('PodDetails', () => {
 
 	it('should switch to events tab when events tab is clicked', () => {
 		render(
-			<Wrapper>
-				<QueryClientProvider client={queryClient}>
-					<Provider store={store}>
-						<MemoryRouter>
-							<PodDetails pod={mockPod} isModalTimeSelection onClose={mockOnClose} />
-						</MemoryRouter>
-					</Provider>
-				</QueryClientProvider>
-			</Wrapper>,
+			<QueryClientProvider client={queryClient}>
+				<Provider store={store}>
+					<MemoryRouter>
+						<PodDetails pod={mockPod} isModalTimeSelection onClose={mockOnClose} />
+					</MemoryRouter>
+				</Provider>
+			</QueryClientProvider>,
 		);
 
 		const eventsTab = screen.getByRole('radio', { name: 'Events' });
@@ -116,15 +105,13 @@ describe('PodDetails', () => {
 
 	it('should close modal when close button is clicked', () => {
 		render(
-			<Wrapper>
-				<QueryClientProvider client={queryClient}>
-					<Provider store={store}>
-						<MemoryRouter>
-							<PodDetails pod={mockPod} isModalTimeSelection onClose={mockOnClose} />
-						</MemoryRouter>
-					</Provider>
-				</QueryClientProvider>
-			</Wrapper>,
+			<QueryClientProvider client={queryClient}>
+				<Provider store={store}>
+					<MemoryRouter>
+						<PodDetails pod={mockPod} isModalTimeSelection onClose={mockOnClose} />
+					</MemoryRouter>
+				</Provider>
+			</QueryClientProvider>,
 		);
 
 		const closeButton = screen.getByRole('button', { name: 'Close' });

frontend/src/container/InfraMonitoringK8s/__tests__/StatefulSets/StatefulSetDetails/StatefulSetDetails.test.tsx

@@ -4,16 +4,14 @@ setupCommonMocks();
 
 import { QueryClient, QueryClientProvider } from 'react-query';
 // eslint-disable-next-line no-restricted-imports
+import { Provider } from 'react-redux';
 import { MemoryRouter } from 'react-router-dom';
-import { render, screen } from '@testing-library/react';
+import { fireEvent, render, screen } from '@testing-library/react';
 import StatefulSetDetails from 'container/InfraMonitoringK8s/StatefulSets/StatefulSetDetails/StatefulSetDetails';
-import { withNuqsTestingAdapter } from 'nuqs/adapters/testing';
-import { userEvent } from 'tests/test-utils';
+import store from 'store';
 
 const queryClient = new QueryClient();
 
-const Wrapper = withNuqsTestingAdapter({ searchParams: {} });
-
 describe('StatefulSetDetails', () => {
 	const mockStatefulSet = {
 		meta: {
@@ -25,8 +23,8 @@ describe('StatefulSetDetails', () => {
 
 	it('should render modal with relevant metadata', () => {
 		render(
-			<Wrapper>
-				<QueryClientProvider client={queryClient}>
+			<QueryClientProvider client={queryClient}>
+				<Provider store={store}>
 					<MemoryRouter>
 						<StatefulSetDetails
 							statefulSet={mockStatefulSet}
@@ -34,8 +32,8 @@ describe('StatefulSetDetails', () => {
 							onClose={mockOnClose}
 						/>
 					</MemoryRouter>
-				</QueryClientProvider>
-			</Wrapper>,
+				</Provider>
+			</QueryClientProvider>,
 		);
 
 		const statefulSetNameElements = screen.getAllByText('test-stateful-set');
@@ -49,8 +47,8 @@ describe('StatefulSetDetails', () => {
 
 	it('should render modal with 4 tabs', () => {
 		render(
-			<Wrapper>
-				<QueryClientProvider client={queryClient}>
+			<QueryClientProvider client={queryClient}>
+				<Provider store={store}>
 					<MemoryRouter>
 						<StatefulSetDetails
 							statefulSet={mockStatefulSet}
@@ -58,8 +56,8 @@ describe('StatefulSetDetails', () => {
 							onClose={mockOnClose}
 						/>
 					</MemoryRouter>
-				</QueryClientProvider>
-			</Wrapper>,
+				</Provider>
+			</QueryClientProvider>,
 		);
 
 		const metricsTab = screen.getByText('Metrics');
@@ -77,8 +75,8 @@ describe('StatefulSetDetails', () => {
 
 	it('default tab should be metrics', () => {
 		render(
-			<Wrapper>
-				<QueryClientProvider client={queryClient}>
+			<QueryClientProvider client={queryClient}>
+				<Provider store={store}>
 					<MemoryRouter>
 						<StatefulSetDetails
 							statefulSet={mockStatefulSet}
@@ -86,18 +84,18 @@ describe('StatefulSetDetails', () => {
 							onClose={mockOnClose}
 						/>
 					</MemoryRouter>
-				</QueryClientProvider>
-			</Wrapper>,
+				</Provider>
+			</QueryClientProvider>,
 		);
 
 		const metricsTab = screen.getByRole('radio', { name: 'Metrics' });
 		expect(metricsTab).toBeChecked();
 	});
 
-	it('should switch to events tab when events tab is clicked', async () => {
+	it('should switch to events tab when events tab is clicked', () => {
 		render(
-			<Wrapper>
-				<QueryClientProvider client={queryClient}>
+			<QueryClientProvider client={queryClient}>
+				<Provider store={store}>
 					<MemoryRouter>
 						<StatefulSetDetails
 							statefulSet={mockStatefulSet}
@@ -105,20 +103,20 @@ describe('StatefulSetDetails', () => {
 							onClose={mockOnClose}
 						/>
 					</MemoryRouter>
-				</QueryClientProvider>
-			</Wrapper>,
+				</Provider>
+			</QueryClientProvider>,
 		);
 
 		const eventsTab = screen.getByRole('radio', { name: 'Events' });
 		expect(eventsTab).not.toBeChecked();
-		await userEvent.click(eventsTab, { pointerEventsCheck: 0 });
+		fireEvent.click(eventsTab);
 		expect(eventsTab).toBeChecked();
 	});
 
-	it('should close modal when close button is clicked', async () => {
+	it('should close modal when close button is clicked', () => {
 		render(
-			<Wrapper>
-				<QueryClientProvider client={queryClient}>
+			<QueryClientProvider client={queryClient}>
+				<Provider store={store}>
 					<MemoryRouter>
 						<StatefulSetDetails
 							statefulSet={mockStatefulSet}
@@ -126,12 +124,12 @@ describe('StatefulSetDetails', () => {
 							onClose={mockOnClose}
 						/>
 					</MemoryRouter>
-				</QueryClientProvider>
-			</Wrapper>,
+				</Provider>
+			</QueryClientProvider>,
 		);
 
 		const closeButton = screen.getByRole('button', { name: 'Close' });
-		await userEvent.click(closeButton);
+		fireEvent.click(closeButton);
 		expect(mockOnClose).toHaveBeenCalled();
 	});
 });

frontend/src/container/InfraMonitoringK8s/__tests__/Volumes/K8sVolumesList.test.tsx

@@ -1,161 +0,0 @@
-import setupCommonMocks from '../commonMocks';
-
-setupCommonMocks();
-
-import { QueryClient, QueryClientProvider } from 'react-query';
-// eslint-disable-next-line no-restricted-imports
-import { MemoryRouter } from 'react-router-dom';
-import { render, waitFor } from '@testing-library/react';
-import { FeatureKeys } from 'constants/features';
-import K8sVolumesList from 'container/InfraMonitoringK8s/Volumes/K8sVolumesList';
-import { rest, server } from 'mocks-server/server';
-import { NuqsTestingAdapter } from 'nuqs/adapters/testing';
-import { IAppContext, IUser } from 'providers/App/types';
-import { LicenseResModel } from 'types/api/licensesV3/getActive';
-
-const queryClient = new QueryClient({
-	defaultOptions: {
-		queries: {
-			retry: false,
-			cacheTime: 0,
-		},
-	},
-});
-
-const SERVER_URL = 'http://localhost/api';
-
-describe('K8sVolumesList - useGetAggregateKeys Category Regression', () => {
-	let requestsMade: Array<{
-		url: string;
-		params: URLSearchParams;
-		body?: any;
-	}> = [];
-
-	beforeEach(() => {
-		requestsMade = [];
-		queryClient.clear();
-
-		server.use(
-			rest.get(`${SERVER_URL}/v3/autocomplete/attribute_keys`, (req, res, ctx) => {
-				const url = req.url.toString();
-				const params = req.url.searchParams;
-
-				requestsMade.push({
-					url,
-					params,
-				});
-
-				return res(
-					ctx.status(200),
-					ctx.json({
-						status: 'success',
-						data: {
-							attributeKeys: [],
-						},
-					}),
-				);
-			}),
-			rest.post(`${SERVER_URL}/v1/pvcs/list`, (req, res, ctx) =>
-				res(
-					ctx.status(200),
-					ctx.json({
-						status: 'success',
-						data: {
-							type: 'list',
-							records: [],
-							groups: null,
-							total: 0,
-							sentAnyHostMetricsData: false,
-							isSendingK8SAgentMetrics: false,
-						},
-					}),
-				),
-			),
-		);
-	});
-
-	afterEach(() => {
-		server.resetHandlers();
-	});
-
-	it('should call aggregate keys API with k8s_volume_capacity', async () => {
-		render(
-			<NuqsTestingAdapter>
-				<QueryClientProvider client={queryClient}>
-					<MemoryRouter>
-						<K8sVolumesList
-							isFiltersVisible={false}
-							handleFilterVisibilityChange={jest.fn()}
-							quickFiltersLastUpdated={-1}
-						/>
-					</MemoryRouter>
-				</QueryClientProvider>
-			</NuqsTestingAdapter>,
-		);
-
-		await waitFor(() => {
-			expect(requestsMade.length).toBeGreaterThan(0);
-		});
-
-		// Find the attribute_keys request
-		const attributeKeysRequest = requestsMade.find((req) =>
-			req.url.includes('/autocomplete/attribute_keys'),
-		);
-
-		expect(attributeKeysRequest).toBeDefined();
-
-		const aggregateAttribute = attributeKeysRequest?.params.get(
-			'aggregateAttribute',
-		);
-
-		expect(aggregateAttribute).toBe('k8s_volume_capacity');
-	});
-
-	it('should call aggregate keys API with k8s.volume.capacity when dotMetrics enabled', async () => {
-		jest
-			.spyOn(await import('providers/App/App'), 'useAppContext')
-			.mockReturnValue({
-				featureFlags: [
-					{
-						name: FeatureKeys.DOT_METRICS_ENABLED,
-						active: true,
-						usage: 0,
-						usage_limit: 0,
-						route: '',
-					},
-				],
-				user: { role: 'ADMIN' } as IUser,
-				activeLicense: (null as unknown) as LicenseResModel,
-			} as IAppContext);
-
-		render(
-			<NuqsTestingAdapter>
-				<QueryClientProvider client={queryClient}>
-					<MemoryRouter>
-						<K8sVolumesList
-							isFiltersVisible={false}
-							handleFilterVisibilityChange={jest.fn()}
-							quickFiltersLastUpdated={-1}
-						/>
-					</MemoryRouter>
-				</QueryClientProvider>
-			</NuqsTestingAdapter>,
-		);
-
-		await waitFor(() => {
-			expect(requestsMade.length).toBeGreaterThan(0);
-		});
-
-		const attributeKeysRequest = requestsMade.find((req) =>
-			req.url.includes('/autocomplete/attribute_keys'),
-		);
-
-		expect(attributeKeysRequest).toBeDefined();
-
-		const aggregateAttribute = attributeKeysRequest?.params.get(
-			'aggregateAttribute',
-		);
-
-		expect(aggregateAttribute).toBe('k8s.volume.capacity');
-	});
-});

frontend/src/container/InfraMonitoringK8s/__tests__/commonMocks.ts

@@ -1,4 +1,3 @@
-import { createElement } from 'react';
 import * as appContextHooks from 'providers/App/App';
 import * as timezoneHooks from 'providers/Timezone';
 import { LicenseEvent } from 'types/api/licensesV3/getActive';
@@ -46,6 +45,14 @@ const setupCommonMocks = (): void => {
 
 	jest.mock('react-router-dom-v5-compat', () => ({
 		...jest.requireActual('react-router-dom-v5-compat'),
+		useSearchParams: jest.fn().mockReturnValue([
+			{
+				get: jest.fn(),
+				entries: jest.fn(() => []),
+				set: jest.fn(),
+			},
+			jest.fn(),
+		]),
 		useNavigationType: (): any => 'PUSH',
 	}));
 
@@ -96,15 +103,6 @@ const setupCommonMocks = (): void => {
 			safeNavigate: jest.fn(),
 		}),
 	}));
-
-	// TODO: Remove this when https://github.com/SigNoz/engineering-pod/issues/4253
-	jest.mock('container/TopNav/DateTimeSelectionV2', () => {
-		return {
-			__esModule: true,
-			default: (): React.ReactElement =>
-				createElement('div', { 'data-testid': 'datetime-selection' }),
-		};
-	});
 };
 
 export default setupCommonMocks;

frontend/src/container/InfraMonitoringK8s/commonUtils.tsx

@@ -12,7 +12,11 @@ import {
 	TagFilterItem,
 } from 'types/api/queryBuilder/queryBuilderData';
 
-import { getInvalidValueTooltipText, K8sCategory } from './constants';
+import {
+	getInvalidValueTooltipText,
+	INFRA_MONITORING_K8S_PARAMS_KEYS,
+	K8sCategory,
+} from './constants';
 
 /**
  * Converts size in bytes to a human-readable string with appropriate units
@@ -250,6 +254,27 @@ export const filterDuplicateFilters = (
 	return uniqueFilters;
 };
 
+export const getOrderByFromParams = (
+	searchParams: URLSearchParams,
+	returnNullAsDefault = false,
+): {
+	columnName: string;
+	order: 'asc' | 'desc';
+} | null => {
+	const orderByFromParams = searchParams.get(
+		INFRA_MONITORING_K8S_PARAMS_KEYS.ORDER_BY,
+	);
+	if (orderByFromParams) {
+		const decoded = decodeURIComponent(orderByFromParams);
+		const parsed = JSON.parse(decoded);
+		return parsed as { columnName: string; order: 'asc' | 'desc' };
+	}
+	if (returnNullAsDefault) {
+		return null;
+	}
+	return { columnName: 'cpu', order: 'desc' };
+};
+
 export const getFiltersFromParams = (
 	searchParams: URLSearchParams,
 	queryKey: string,
@@ -257,9 +282,10 @@ export const getFiltersFromParams = (
 	const filtersFromParams = searchParams.get(queryKey);
 	if (filtersFromParams) {
 		try {
-			const parsed = JSON.parse(filtersFromParams);
+			const decoded = decodeURIComponent(filtersFromParams);
+			const parsed = JSON.parse(decoded);
 			return parsed as IBuilderQuery['filters'];
-		} catch {
+		} catch (error) {
 			return null;
 		}
 	}