refactor: adding validation on update account request

.devenv/docker/clickhouse/compose.yaml

@@ -27,8 +27,8 @@ services:
       - ${PWD}/fs/tmp/var/lib/clickhouse/user_scripts/:/var/lib/clickhouse/user_scripts/
       - ${PWD}/../../../deploy/common/clickhouse/custom-function.xml:/etc/clickhouse-server/custom-function.xml
     ports:
-      - "127.0.0.1:8123:8123"
-      - "127.0.0.1:9000:9000"
+      - '127.0.0.1:8123:8123'
+      - '127.0.0.1:9000:9000'
     tty: true
     healthcheck:
       test:
@@ -47,16 +47,13 @@ services:
         condition: service_healthy
     environment:
       - CLICKHOUSE_SKIP_USER_SETUP=1
-    networks:
-      - default
-      - signoz-devenv
   zookeeper:
     image: signoz/zookeeper:3.7.1
     container_name: zookeeper
     volumes:
       - ${PWD}/fs/tmp/zookeeper:/bitnami/zookeeper
     ports:
-      - "127.0.0.1:2181:2181"
+      - '127.0.0.1:2181:2181'
     environment:
       - ALLOW_ANONYMOUS_LOGIN=yes
     healthcheck:
@@ -77,19 +74,12 @@ services:
     entrypoint:
       - /bin/sh
     command:
-      - -c
-      - |
-        /signoz-otel-collector migrate bootstrap &&
-        /signoz-otel-collector migrate sync up &&
-        /signoz-otel-collector migrate async up
+    - -c 
+    - |
+      /signoz-otel-collector migrate bootstrap &&
+      /signoz-otel-collector migrate sync up &&
+      /signoz-otel-collector migrate async up
     depends_on:
       clickhouse:
         condition: service_healthy
     restart: on-failure
-    networks:
-      - default
-      - signoz-devenv
-
-networks:
-  signoz-devenv:
-    name: signoz-devenv

.devenv/docker/signoz-otel-collector/compose.yaml

@@ -3,7 +3,7 @@ services:
     image: signoz/signoz-otel-collector:v0.142.0
     container_name: signoz-otel-collector-dev
     entrypoint:
-      - /bin/sh
+    - /bin/sh
     command:
       - -c
       - |
@@ -34,11 +34,4 @@ services:
       retries: 3
     restart: unless-stopped
     extra_hosts:
-      - "host.docker.internal:host-gateway"
-    networks:
-      - default
-      - signoz-devenv
-
-networks:
-  signoz-devenv:
-    name: signoz-devenv
+      - "host.docker.internal:host-gateway"

.devenv/docker/signoz-otel-collector/otel-collector-config.yaml

@@ -12,10 +12,10 @@ receivers:
       scrape_configs:
         - job_name: otel-collector
           static_configs:
-            - targets:
-                - localhost:8888
-              labels:
-                job_name: otel-collector
+          - targets:
+              - localhost:8888
+            labels:
+              job_name: otel-collector
 
 processors:
   batch:
@@ -29,26 +29,7 @@ processors:
   signozspanmetrics/delta:
     metrics_exporter: signozclickhousemetrics
     metrics_flush_interval: 60s
-    latency_histogram_buckets:
-      [
-        100us,
-        1ms,
-        2ms,
-        6ms,
-        10ms,
-        50ms,
-        100ms,
-        250ms,
-        500ms,
-        1000ms,
-        1400ms,
-        2000ms,
-        5s,
-        10s,
-        20s,
-        40s,
-        60s,
-      ]
+    latency_histogram_buckets: [100us, 1ms, 2ms, 6ms, 10ms, 50ms, 100ms, 250ms, 500ms, 1000ms, 1400ms, 2000ms, 5s, 10s, 20s, 40s, 60s ]
     dimensions_cache_size: 100000
     aggregation_temporality: AGGREGATION_TEMPORALITY_DELTA
     enable_exp_histogram: true
@@ -79,13 +60,13 @@ extensions:
 
 exporters:
   clickhousetraces:
-    datasource: tcp://clickhouse:9000/signoz_traces
+    datasource: tcp://host.docker.internal:9000/signoz_traces
     low_cardinal_exception_grouping: ${env:LOW_CARDINAL_EXCEPTION_GROUPING}
     use_new_schema: true
   signozclickhousemetrics:
-    dsn: tcp://clickhouse:9000/signoz_metrics
+    dsn: tcp://host.docker.internal:9000/signoz_metrics
   clickhouselogsexporter:
-    dsn: tcp://clickhouse:9000/signoz_logs
+    dsn: tcp://host.docker.internal:9000/signoz_logs
     timeout: 10s
     use_new_schema: true
 
@@ -112,4 +93,4 @@ service:
     logs:
       receivers: [otlp]
       processors: [batch]
-      exporters: [clickhouselogsexporter]
+      exporters: [clickhouselogsexporter]

.golangci.yml

@@ -6,14 +6,12 @@ linters:
     - depguard
     - errcheck
     - forbidigo
-    - godot
     - govet
     - iface
     - ineffassign
     - misspell
     - nilnil
     - sloglint
-    - staticcheck
     - wastedassign
     - unparam
     - unused

cmd/community/server.go

@@ -12,16 +12,18 @@ 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"
 	"github.com/SigNoz/signoz/pkg/gateway/noopgateway"
 	"github.com/SigNoz/signoz/pkg/licensing"
 	"github.com/SigNoz/signoz/pkg/licensing/nooplicensing"
+	"github.com/SigNoz/signoz/pkg/modules/cloudintegration"
+	"github.com/SigNoz/signoz/pkg/modules/cloudintegration/implcloudintegration"
 	"github.com/SigNoz/signoz/pkg/modules/dashboard"
 	"github.com/SigNoz/signoz/pkg/modules/dashboard/impldashboard"
 	"github.com/SigNoz/signoz/pkg/modules/organization"
+	"github.com/SigNoz/signoz/pkg/modules/user"
 	"github.com/SigNoz/signoz/pkg/querier"
 	"github.com/SigNoz/signoz/pkg/query-service/app"
 	"github.com/SigNoz/signoz/pkg/queryparser"
@@ -29,6 +31,7 @@ import (
 	"github.com/SigNoz/signoz/pkg/sqlschema"
 	"github.com/SigNoz/signoz/pkg/sqlstore"
 	"github.com/SigNoz/signoz/pkg/types/authtypes"
+	"github.com/SigNoz/signoz/pkg/types/cloudintegrationtypes"
 	"github.com/SigNoz/signoz/pkg/version"
 	"github.com/SigNoz/signoz/pkg/zeus"
 	"github.com/SigNoz/signoz/pkg/zeus/noopzeus"
@@ -79,13 +82,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)
@@ -96,6 +94,9 @@ func runServer(ctx context.Context, config signoz.Config, logger *slog.Logger) e
 		func(ps factory.ProviderSettings, q querier.Querier, a analytics.Analytics) querier.Handler {
 			return querier.NewHandler(ps, q, a)
 		},
+		func(_ cloudintegrationtypes.Store, _ zeus.Zeus, _ gateway.Gateway, _ licensing.Licensing, _ user.Getter, _ user.Setter) (cloudintegration.Module, error) {
+			return implcloudintegration.NewModule(), nil
+		},
 	)
 	if err != nil {
 		logger.ErrorContext(ctx, "failed to create signoz", errors.Attr(err))

cmd/enterprise/server.go

@@ -12,10 +12,10 @@ 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"
+	"github.com/SigNoz/signoz/ee/modules/cloudintegration/implcloudintegration"
 	"github.com/SigNoz/signoz/ee/modules/dashboard/impldashboard"
 	eequerier "github.com/SigNoz/signoz/ee/querier"
 	enterpriseapp "github.com/SigNoz/signoz/ee/query-service/app"
@@ -30,9 +30,11 @@ import (
 	"github.com/SigNoz/signoz/pkg/factory"
 	"github.com/SigNoz/signoz/pkg/gateway"
 	"github.com/SigNoz/signoz/pkg/licensing"
+	"github.com/SigNoz/signoz/pkg/modules/cloudintegration"
 	"github.com/SigNoz/signoz/pkg/modules/dashboard"
 	pkgimpldashboard "github.com/SigNoz/signoz/pkg/modules/dashboard/impldashboard"
 	"github.com/SigNoz/signoz/pkg/modules/organization"
+	"github.com/SigNoz/signoz/pkg/modules/user"
 	"github.com/SigNoz/signoz/pkg/querier"
 	"github.com/SigNoz/signoz/pkg/queryparser"
 	"github.com/SigNoz/signoz/pkg/signoz"
@@ -40,6 +42,7 @@ import (
 	"github.com/SigNoz/signoz/pkg/sqlstore"
 	"github.com/SigNoz/signoz/pkg/sqlstore/sqlstorehook"
 	"github.com/SigNoz/signoz/pkg/types/authtypes"
+	"github.com/SigNoz/signoz/pkg/types/cloudintegrationtypes"
 	"github.com/SigNoz/signoz/pkg/version"
 	"github.com/SigNoz/signoz/pkg/zeus"
 )
@@ -119,13 +122,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)
@@ -137,8 +135,10 @@ func runServer(ctx context.Context, config signoz.Config, logger *slog.Logger) e
 			communityHandler := querier.NewHandler(ps, q, a)
 			return eequerier.NewHandler(ps, q, communityHandler)
 		},
+		func(store cloudintegrationtypes.Store, zeus zeus.Zeus, gateway gateway.Gateway, licensing licensing.Licensing, userGetter user.Getter, userSetter user.Setter) (cloudintegration.Module, error) {
+			return implcloudintegration.NewModule(store, config.Global, zeus, gateway, licensing, userGetter, userSetter)
+		},
 	)
-
 	if err != nil {
 		logger.ErrorContext(ctx, "failed to create signoz", errors.Attr(err))
 		return err

conf/example.yaml

@@ -85,12 +85,10 @@ sqlstore:
   sqlite:
     # The path to the SQLite database file.
     path: /var/lib/signoz/signoz.db
-    # The journal mode for the sqlite database. Supported values: delete, wal.
+    # Mode is the mode to use for the sqlite database.
     mode: delete
-    # The timeout for the sqlite database to wait for a lock.
+    # BusyTimeout is the timeout for the sqlite database to wait for a lock.
     busy_timeout: 10s
-    # The default transaction locking behavior. Supported values: deferred, immediate, exclusive.
-    transaction_mode: deferred
 
 ##################### APIServer #####################
 apiserver:

docs/api/openapi.yml

@@ -421,11 +421,11 @@ components:
       type: object
     CloudintegrationtypesAWSCollectionStrategy:
       properties:
-        aws_logs:
+        logs:
           $ref: '#/components/schemas/CloudintegrationtypesAWSLogsStrategy'
-        aws_metrics:
+        metrics:
           $ref: '#/components/schemas/CloudintegrationtypesAWSMetricsStrategy'
-        s3_buckets:
+        s3Buckets:
           additionalProperties:
             items:
               type: string
@@ -465,12 +465,12 @@ components:
       type: object
     CloudintegrationtypesAWSLogsStrategy:
       properties:
-        cloudwatch_logs_subscriptions:
+        cloudwatchLogsSubscriptions:
           items:
             properties:
-              filter_pattern:
+              filterPattern:
                 type: string
-              log_group_name_prefix:
+              logGroupNamePrefix:
                 type: string
             type: object
           nullable: true
@@ -478,7 +478,7 @@ components:
       type: object
     CloudintegrationtypesAWSMetricsStrategy:
       properties:
-        cloudwatch_metric_stream_filters:
+        cloudwatchMetricStreamFilters:
           items:
             properties:
               MetricNames:
@@ -577,6 +577,26 @@ components:
           nullable: true
           type: array
       type: object
+    CloudintegrationtypesCloudIntegrationService:
+      nullable: true
+      properties:
+        cloudIntegrationId:
+          type: string
+        config:
+          $ref: '#/components/schemas/CloudintegrationtypesServiceConfig'
+        createdAt:
+          format: date-time
+          type: string
+        id:
+          type: string
+        type:
+          $ref: '#/components/schemas/CloudintegrationtypesServiceID'
+        updatedAt:
+          format: date-time
+          type: string
+      required:
+      - id
+      type: object
     CloudintegrationtypesCollectedLogAttribute:
       properties:
         name:
@@ -710,11 +730,54 @@ components:
             type: string
           type: array
         telemetry:
-          $ref: '#/components/schemas/CloudintegrationtypesAWSCollectionStrategy'
+          $ref: '#/components/schemas/CloudintegrationtypesOldAWSCollectionStrategy'
       required:
       - enabled_regions
       - telemetry
       type: object
+    CloudintegrationtypesOldAWSCollectionStrategy:
+      properties:
+        aws_logs:
+          $ref: '#/components/schemas/CloudintegrationtypesOldAWSLogsStrategy'
+        aws_metrics:
+          $ref: '#/components/schemas/CloudintegrationtypesOldAWSMetricsStrategy'
+        provider:
+          type: string
+        s3_buckets:
+          additionalProperties:
+            items:
+              type: string
+            type: array
+          type: object
+      type: object
+    CloudintegrationtypesOldAWSLogsStrategy:
+      properties:
+        cloudwatch_logs_subscriptions:
+          items:
+            properties:
+              filter_pattern:
+                type: string
+              log_group_name_prefix:
+                type: string
+            type: object
+          nullable: true
+          type: array
+      type: object
+    CloudintegrationtypesOldAWSMetricsStrategy:
+      properties:
+        cloudwatch_metric_stream_filters:
+          items:
+            properties:
+              MetricNames:
+                items:
+                  type: string
+                type: array
+              Namespace:
+                type: string
+            type: object
+          nullable: true
+          type: array
+      type: object
     CloudintegrationtypesPostableAgentCheckInRequest:
       properties:
         account_id:
@@ -743,6 +806,8 @@ components:
       properties:
         assets:
           $ref: '#/components/schemas/CloudintegrationtypesAssets'
+        cloudIntegrationService:
+          $ref: '#/components/schemas/CloudintegrationtypesCloudIntegrationService'
         dataCollected:
           $ref: '#/components/schemas/CloudintegrationtypesDataCollected'
         icon:
@@ -751,9 +816,7 @@ components:
           type: string
         overview:
           type: string
-        serviceConfig:
-          $ref: '#/components/schemas/CloudintegrationtypesServiceConfig'
-        supported_signals:
+        supportedSignals:
           $ref: '#/components/schemas/CloudintegrationtypesSupportedSignals'
         telemetryCollectionStrategy:
           $ref: '#/components/schemas/CloudintegrationtypesCollectionStrategy'
@@ -765,9 +828,10 @@ components:
       - icon
       - overview
       - assets
-      - supported_signals
+      - supportedSignals
       - dataCollected
       - telemetryCollectionStrategy
+      - cloudIntegrationService
       type: object
     CloudintegrationtypesServiceConfig:
       properties:
@@ -776,6 +840,22 @@ components:
       required:
       - aws
       type: object
+    CloudintegrationtypesServiceID:
+      enum:
+      - alb
+      - api-gateway
+      - dynamodb
+      - ec2
+      - ecs
+      - eks
+      - elasticache
+      - lambda
+      - msk
+      - rds
+      - s3sync
+      - sns
+      - sqs
+      type: string
     CloudintegrationtypesServiceMetadata:
       properties:
         enabled:
@@ -1114,33 +1194,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 +1342,6 @@ components:
       - temporality
       - isMonotonic
       type: object
-    MetricsexplorertypesMetricsOnboardingResponse:
-      properties:
-        hasMetrics:
-          type: boolean
-      required:
-      - hasMetrics
-      type: object
     MetricsexplorertypesStat:
       properties:
         description:
@@ -3466,6 +3512,61 @@ paths:
       summary: Update account
       tags:
       - cloudintegration
+  /api/v1/cloud_integrations/{cloud_provider}/accounts/{id}/services/{service_id}:
+    put:
+      deprecated: false
+      description: This endpoint updates a service for the specified cloud provider
+      operationId: UpdateService
+      parameters:
+      - in: path
+        name: cloud_provider
+        required: true
+        schema:
+          type: string
+      - in: path
+        name: id
+        required: true
+        schema:
+          type: string
+      - in: path
+        name: service_id
+        required: true
+        schema:
+          type: string
+      requestBody:
+        content:
+          application/json:
+            schema:
+              $ref: '#/components/schemas/CloudintegrationtypesUpdatableService'
+      responses:
+        "204":
+          description: No Content
+        "401":
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/RenderErrorResponse'
+          description: Unauthorized
+        "403":
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/RenderErrorResponse'
+          description: Forbidden
+        "500":
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/RenderErrorResponse'
+          description: Internal Server Error
+      security:
+      - api_key:
+        - ADMIN
+      - tokenizer:
+        - ADMIN
+      summary: Update service
+      tags:
+      - cloudintegration
   /api/v1/cloud_integrations/{cloud_provider}/accounts/check_in:
     post:
       deprecated: false
@@ -3633,55 +3734,6 @@ paths:
       summary: Get service
       tags:
       - cloudintegration
-    put:
-      deprecated: false
-      description: This endpoint updates a service for the specified cloud provider
-      operationId: UpdateService
-      parameters:
-      - in: path
-        name: cloud_provider
-        required: true
-        schema:
-          type: string
-      - in: path
-        name: service_id
-        required: true
-        schema:
-          type: string
-      requestBody:
-        content:
-          application/json:
-            schema:
-              $ref: '#/components/schemas/CloudintegrationtypesUpdatableService'
-      responses:
-        "204":
-          description: No Content
-        "401":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Unauthorized
-        "403":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Forbidden
-        "500":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Internal Server Error
-      security:
-      - api_key:
-        - ADMIN
-      - tokenizer:
-        - ADMIN
-      summary: Update service
-      tags:
-      - cloudintegration
   /api/v1/complete/google:
     get:
       deprecated: false
@@ -7784,111 +7836,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

ee/anomaly/hourly.go

@@ -16,7 +16,7 @@ func (hp *HourlyProvider) GetBaseSeasonalProvider() *BaseSeasonalProvider {
 	return &hp.BaseSeasonalProvider
 }
 
-// NewHourlyProvider now uses the generic option type.
+// NewHourlyProvider now uses the generic option type
 func NewHourlyProvider(opts ...GenericProviderOption[*HourlyProvider]) *HourlyProvider {
 	hp := &HourlyProvider{
 		BaseSeasonalProvider: BaseSeasonalProvider{},

ee/anomaly/params.go

@@ -47,7 +47,7 @@ type AnomaliesResponse struct {
 //		              |                                  |
 //			(rounded value for past peiod)    +      (seasonal growth)
 //
-// score = abs(value - prediction) / stddev (current_season_query).
+// score = abs(value - prediction) / stddev (current_season_query)
 type anomalyQueryParams struct {
 	// CurrentPeriodQuery is the query range params for period user is looking at or eval window
 	// Example: (now-5m, now), (now-30m, now), (now-1h, now)

ee/anomaly/seasonal.go

@@ -18,12 +18,12 @@ var (
 	movingAvgWindowSize = 7
 )
 
-// BaseProvider is an interface that includes common methods for all provider types.
+// BaseProvider is an interface that includes common methods for all provider types
 type BaseProvider interface {
 	GetBaseSeasonalProvider() *BaseSeasonalProvider
 }
 
-// GenericProviderOption is a generic type for provider options.
+// GenericProviderOption is a generic type for provider options
 type GenericProviderOption[T BaseProvider] func(T)
 
 func WithQuerier[T BaseProvider](querier querier.Querier) GenericProviderOption[T] {
@@ -121,7 +121,7 @@ func (p *BaseSeasonalProvider) getResults(ctx context.Context, orgID valuer.UUID
 }
 
 // getMatchingSeries gets the matching series from the query result
-// for the given series.
+// for the given series
 func (p *BaseSeasonalProvider) getMatchingSeries(_ context.Context, queryResult *qbtypes.TimeSeriesData, series *qbtypes.TimeSeries) *qbtypes.TimeSeries {
 	if queryResult == nil || len(queryResult.Aggregations) == 0 || len(queryResult.Aggregations[0].Series) == 0 {
 		return nil
@@ -155,14 +155,13 @@ func (p *BaseSeasonalProvider) getStdDev(series *qbtypes.TimeSeries) float64 {
 	avg := p.getAvg(series)
 	var sum float64
 	for _, smpl := range series.Values {
-		d := smpl.Value - avg
-		sum += d * d
+		sum += math.Pow(smpl.Value-avg, 2)
 	}
 	return math.Sqrt(sum / float64(len(series.Values)))
 }
 
 // getMovingAvg gets the moving average for the given series
-// for the given window size and start index.
+// for the given window size and start index
 func (p *BaseSeasonalProvider) getMovingAvg(series *qbtypes.TimeSeries, movingAvgWindowSize, startIdx int) float64 {
 	if series == nil || len(series.Values) == 0 {
 		return 0
@@ -237,7 +236,7 @@ func (p *BaseSeasonalProvider) getPredictedSeries(
 // getBounds gets the upper and lower bounds for the given series
 // for the given z score threshold
 // moving avg of the previous period series + z score threshold * std dev of the series
-// moving avg of the previous period series - z score threshold * std dev of the series.
+// moving avg of the previous period series - z score threshold * std dev of the series
 func (p *BaseSeasonalProvider) getBounds(
 	series, predictedSeries, weekSeries *qbtypes.TimeSeries,
 	zScoreThreshold float64,
@@ -270,7 +269,7 @@ func (p *BaseSeasonalProvider) getBounds(
 
 // getExpectedValue gets the expected value for the given series
 // for the given index
-// prevSeriesAvg + currentSeasonSeriesAvg - mean of past season series, past2 season series and past3 season series.
+// prevSeriesAvg + currentSeasonSeriesAvg - mean of past season series, past2 season series and past3 season series
 func (p *BaseSeasonalProvider) getExpectedValue(
 	_, prevSeries, currentSeasonSeries, pastSeasonSeries, past2SeasonSeries, past3SeasonSeries *qbtypes.TimeSeries, idx int,
 ) float64 {
@@ -284,7 +283,7 @@ func (p *BaseSeasonalProvider) getExpectedValue(
 
 // getScore gets the anomaly score for the given series
 // for the given index
-// (value - expectedValue) / std dev of the series.
+// (value - expectedValue) / std dev of the series
 func (p *BaseSeasonalProvider) getScore(
 	series, prevSeries, weekSeries, weekPrevSeries, past2SeasonSeries, past3SeasonSeries *qbtypes.TimeSeries, value float64, idx int,
 ) float64 {
@@ -297,7 +296,7 @@ func (p *BaseSeasonalProvider) getScore(
 
 // getAnomalyScores gets the anomaly scores for the given series
 // for the given index
-// (value - expectedValue) / std dev of the series.
+// (value - expectedValue) / std dev of the series
 func (p *BaseSeasonalProvider) getAnomalyScores(
 	series, prevSeries, currentSeasonSeries, pastSeasonSeries, past2SeasonSeries, past3SeasonSeries *qbtypes.TimeSeries,
 ) *qbtypes.TimeSeries {

ee/auditor/otlphttpauditor/export.go

@@ -1,143 +0,0 @@
-package otlphttpauditor
-
-import (
-	"bytes"
-	"context"
-	"io"
-	"log/slog"
-	"net/http"
-
-	"github.com/SigNoz/signoz/pkg/auditor"
-	"github.com/SigNoz/signoz/pkg/errors"
-	"github.com/SigNoz/signoz/pkg/types/audittypes"
-	collogspb "go.opentelemetry.io/proto/otlp/collector/logs/v1"
-	"google.golang.org/protobuf/proto"
-
-	spb "google.golang.org/genproto/googleapis/rpc/status"
-)
-
-const (
-	maxHTTPResponseReadBytes int64  = 64 * 1024
-	protobufContentType      string = "application/x-protobuf"
-)
-
-func (provider *provider) export(ctx context.Context, events []audittypes.AuditEvent) error {
-	logs := audittypes.NewPLogsFromAuditEvents(events, "signoz", provider.build.Version(), "signoz.audit")
-
-	request, err := provider.marshaler.MarshalLogs(logs)
-	if err != nil {
-		return errors.Wrapf(err, errors.TypeInternal, auditor.ErrCodeAuditExportFailed, "failed to marshal audit logs")
-	}
-
-	if err := provider.send(ctx, request); err != nil {
-		provider.settings.Logger().ErrorContext(ctx, "audit export failed", errors.Attr(err), slog.Int("dropped_log_records", len(events)))
-		return err
-	}
-
-	return nil
-}
-
-// Posts a protobuf-encoded OTLP request to the configured endpoint.
-// Retries are handled by the underlying heimdall HTTP client.
-// Ref: https://github.com/open-telemetry/opentelemetry-collector/blob/main/exporter/otlphttpexporter/otlp.go
-func (provider *provider) send(ctx context.Context, body []byte) error {
-	req, err := http.NewRequestWithContext(ctx, http.MethodPost, provider.config.OTLPHTTP.Endpoint.String(), bytes.NewReader(body))
-	if err != nil {
-		return err
-	}
-
-	req.Header.Set("Content-Type", protobufContentType)
-
-	res, err := provider.httpClient.Do(req)
-	if err != nil {
-		return err
-	}
-
-	defer func() {
-		_, _ = io.CopyN(io.Discard, res.Body, maxHTTPResponseReadBytes)
-		res.Body.Close()
-	}()
-
-	if res.StatusCode >= 200 && res.StatusCode <= 299 {
-		provider.onSuccess(ctx, res)
-		return nil
-	}
-
-	return provider.onErr(res)
-}
-
-// Ref: https://github.com/open-telemetry/opentelemetry-collector/blob/01b07fcbb7a253bd996c290dcae6166e71d13732/exporter/otlphttpexporter/otlp.go#L403.
-func (provider *provider) onSuccess(ctx context.Context, res *http.Response) {
-	resBytes, err := readResponseBody(res)
-	if err != nil || resBytes == nil {
-		return
-	}
-
-	exportResponse := &collogspb.ExportLogsServiceResponse{}
-	if err := proto.Unmarshal(resBytes, exportResponse); err != nil {
-		return
-	}
-
-	ps := exportResponse.GetPartialSuccess()
-	if ps == nil {
-		return
-	}
-
-	if ps.GetErrorMessage() != "" || ps.GetRejectedLogRecords() != 0 {
-		provider.settings.Logger().WarnContext(ctx, "partial success response", slog.String("message", ps.GetErrorMessage()), slog.Int64("dropped_log_records", ps.GetRejectedLogRecords()))
-	}
-}
-
-func (provider *provider) onErr(res *http.Response) error {
-	status := readResponseStatus(res)
-
-	if status != nil {
-		return errors.Newf(errors.TypeInternal, auditor.ErrCodeAuditExportFailed, "request to %s responded with status code %d, Message=%s, Details=%v", provider.config.OTLPHTTP.Endpoint.String(), res.StatusCode, status.Message, status.Details)
-	}
-
-	return errors.Newf(errors.TypeInternal, auditor.ErrCodeAuditExportFailed, "request to %s responded with status code %d", provider.config.OTLPHTTP.Endpoint.String(), res.StatusCode)
-}
-
-// Reads at most maxHTTPResponseReadBytes from the response body.
-// Ref: https://github.com/open-telemetry/opentelemetry-collector/blob/01b07fcbb7a253bd996c290dcae6166e71d13732/exporter/otlphttpexporter/otlp.go#L275.
-func readResponseBody(resp *http.Response) ([]byte, error) {
-	if resp.ContentLength == 0 {
-		return nil, nil
-	}
-
-	maxRead := resp.ContentLength
-	if maxRead == -1 || maxRead > maxHTTPResponseReadBytes {
-		maxRead = maxHTTPResponseReadBytes
-	}
-
-	protoBytes := make([]byte, maxRead)
-	n, err := io.ReadFull(resp.Body, protoBytes)
-	if n == 0 && (err == nil || errors.Is(err, io.EOF)) {
-		return nil, nil
-	}
-	if err != nil && !errors.Is(err, io.ErrUnexpectedEOF) {
-		return nil, err
-	}
-
-	return protoBytes[:n], nil
-}
-
-// Decodes a protobuf-encoded Status from 4xx/5xx response bodies. Returns nil if the response is empty or cannot be decoded.
-// Ref: https://github.com/open-telemetry/opentelemetry-collector/blob/01b07fcbb7a253bd996c290dcae6166e71d13732/exporter/otlphttpexporter/otlp.go#L310.
-func readResponseStatus(resp *http.Response) *spb.Status {
-	if resp.StatusCode < 400 || resp.StatusCode > 599 {
-		return nil
-	}
-
-	respBytes, err := readResponseBody(resp)
-	if err != nil || respBytes == nil {
-		return nil
-	}
-
-	respStatus := &spb.Status{}
-	if err := proto.Unmarshal(respBytes, respStatus); err != nil {
-		return nil
-	}
-
-	return respStatus
-}

ee/auditor/otlphttpauditor/provider.go

@@ -1,97 +0,0 @@
-package otlphttpauditor
-
-import (
-	"context"
-
-	"github.com/SigNoz/signoz/pkg/auditor"
-	"github.com/SigNoz/signoz/pkg/auditor/auditorserver"
-	"github.com/SigNoz/signoz/pkg/factory"
-	client "github.com/SigNoz/signoz/pkg/http/client"
-	"github.com/SigNoz/signoz/pkg/licensing"
-	"github.com/SigNoz/signoz/pkg/types/audittypes"
-	"github.com/SigNoz/signoz/pkg/version"
-	"go.opentelemetry.io/collector/pdata/plog"
-)
-
-var _ auditor.Auditor = (*provider)(nil)
-
-type provider struct {
-	settings   factory.ScopedProviderSettings
-	config     auditor.Config
-	licensing  licensing.Licensing
-	build      version.Build
-	server     *auditorserver.Server
-	marshaler  plog.ProtoMarshaler
-	httpClient *client.Client
-}
-
-func NewFactory(licensing licensing.Licensing, build version.Build) factory.ProviderFactory[auditor.Auditor, auditor.Config] {
-	return factory.NewProviderFactory(factory.MustNewName("otlphttp"), func(ctx context.Context, providerSettings factory.ProviderSettings, config auditor.Config) (auditor.Auditor, error) {
-		return newProvider(ctx, providerSettings, config, licensing, build)
-	})
-}
-
-func newProvider(_ context.Context, providerSettings factory.ProviderSettings, config auditor.Config, licensing licensing.Licensing, build version.Build) (auditor.Auditor, error) {
-	settings := factory.NewScopedProviderSettings(providerSettings, "github.com/SigNoz/signoz/ee/auditor/otlphttpauditor")
-
-	httpClient, err := client.New(
-		settings.Logger(),
-		providerSettings.TracerProvider,
-		providerSettings.MeterProvider,
-		client.WithTimeout(config.OTLPHTTP.Timeout),
-		client.WithRetryCount(retryCountFromConfig(config.OTLPHTTP.Retry)),
-		retrierOption(config.OTLPHTTP.Retry),
-	)
-	if err != nil {
-		return nil, err
-	}
-
-	provider := &provider{
-		settings:   settings,
-		config:     config,
-		licensing:  licensing,
-		build:      build,
-		marshaler:  plog.ProtoMarshaler{},
-		httpClient: httpClient,
-	}
-
-	server, err := auditorserver.New(settings,
-		auditorserver.Config{
-			BufferSize:    config.BufferSize,
-			BatchSize:     config.BatchSize,
-			FlushInterval: config.FlushInterval,
-		},
-		provider.export,
-	)
-	if err != nil {
-		return nil, err
-	}
-
-	provider.server = server
-	return provider, nil
-}
-
-func (provider *provider) Start(ctx context.Context) error {
-	return provider.server.Start(ctx)
-}
-
-func (provider *provider) Audit(ctx context.Context, event audittypes.AuditEvent) {
-	if event.PrincipalOrgID.IsZero() {
-		provider.settings.Logger().WarnContext(ctx, "audit event dropped as org_id is zero")
-		return
-	}
-
-	if _, err := provider.licensing.GetActive(ctx, event.PrincipalOrgID); err != nil {
-		return
-	}
-
-	provider.server.Add(ctx, event)
-}
-
-func (provider *provider) Healthy() <-chan struct{} {
-	return provider.server.Healthy()
-}
-
-func (provider *provider) Stop(ctx context.Context) error {
-	return provider.server.Stop(ctx)
-}

ee/auditor/otlphttpauditor/retrier.go

@@ -1,52 +0,0 @@
-package otlphttpauditor
-
-import (
-	"time"
-
-	"github.com/SigNoz/signoz/pkg/auditor"
-	client "github.com/SigNoz/signoz/pkg/http/client"
-)
-
-// retrier implements client.Retriable with exponential backoff
-// derived from auditor.RetryConfig.
-type retrier struct {
-	initialInterval time.Duration
-	maxInterval     time.Duration
-}
-
-func newRetrier(cfg auditor.RetryConfig) *retrier {
-	return &retrier{
-		initialInterval: cfg.InitialInterval,
-		maxInterval:     cfg.MaxInterval,
-	}
-}
-
-// NextInterval returns the backoff duration for the given retry attempt.
-// Uses exponential backoff: initialInterval * 2^retry, capped at maxInterval.
-func (r *retrier) NextInterval(retry int) time.Duration {
-	interval := r.initialInterval
-	for range retry {
-		interval *= 2
-	}
-	return min(interval, r.maxInterval)
-}
-
-func retrierOption(cfg auditor.RetryConfig) client.Option {
-	return client.WithRetriable(newRetrier(cfg))
-}
-
-func retryCountFromConfig(cfg auditor.RetryConfig) int {
-	if !cfg.Enabled || cfg.MaxElapsedTime <= 0 {
-		return 0
-	}
-
-	count := 0
-	elapsed := time.Duration(0)
-	interval := cfg.InitialInterval
-	for elapsed < cfg.MaxElapsedTime {
-		elapsed += interval
-		interval = min(interval*2, cfg.MaxInterval)
-		count++
-	}
-	return count
-}

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/licensing/config.go

@@ -13,7 +13,7 @@ var (
 	once   sync.Once
 )
 
-// Config initializes the licensing configuration.
+// initializes the licensing configuration
 func Config(pollInterval time.Duration, failureThreshold int) licensing.Config {
 	once.Do(func() {
 		config = licensing.Config{PollInterval: pollInterval, FailureThreshold: failureThreshold}

ee/modules/cloudintegration/implcloudintegration/implcloudprovider/awscloudprovider.go

@@ -0,0 +1,189 @@
+package implcloudprovider
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"net/url"
+	"sort"
+
+	"github.com/SigNoz/signoz/pkg/errors"
+	"github.com/SigNoz/signoz/pkg/modules/cloudintegration"
+	"github.com/SigNoz/signoz/pkg/types/cloudintegrationtypes"
+	"github.com/SigNoz/signoz/pkg/types/cloudintegrationtypes/definitions"
+)
+
+type awscloudprovider struct {
+	serviceDefinitions definitions.ServiceDefinitionLoader
+}
+
+func NewAWSCloudProvider() (cloudintegration.CloudProviderModule, error) {
+	loader, err := definitions.NewServiceDefinitionLoader(cloudintegrationtypes.CloudProviderTypeAWS)
+	if err != nil {
+		return nil, err
+	}
+	return &awscloudprovider{
+		serviceDefinitions: loader,
+	}, nil
+}
+func (provider *awscloudprovider) GetConnectionArtifact(ctx context.Context, creds *cloudintegrationtypes.SignozCredentials, account *cloudintegrationtypes.Account, req *cloudintegrationtypes.ConnectionArtifactRequest) (*cloudintegrationtypes.ConnectionArtifact, error) {
+	// TODO: get this from config
+	agentVersion := "v0.0.8"
+
+	baseURL := fmt.Sprintf("https://%s.console.aws.amazon.com/cloudformation/home", req.Aws.DeploymentRegion)
+	u, _ := url.Parse(baseURL)
+
+	q := u.Query()
+	q.Set("region", req.Aws.DeploymentRegion)
+	u.Fragment = "/stacks/quickcreate"
+
+	u.RawQuery = q.Encode()
+
+	q = u.Query()
+	q.Set("stackName", "signoz-integration")
+	q.Set("templateURL", fmt.Sprintf("https://signoz-integrations.s3.us-east-1.amazonaws.com/aws-quickcreate-template-%s.json", agentVersion))
+	q.Set("param_SigNozIntegrationAgentVersion", agentVersion)
+	q.Set("param_SigNozApiUrl", creds.SigNozAPIURL)
+	q.Set("param_SigNozApiKey", creds.SigNozAPIKey)
+	q.Set("param_SigNozAccountId", account.ID.StringValue())
+	q.Set("param_IngestionUrl", creds.IngestionURL)
+	q.Set("param_IngestionKey", creds.IngestionKey)
+
+	return &cloudintegrationtypes.ConnectionArtifact{
+		Aws: &cloudintegrationtypes.AWSConnectionArtifact{
+			ConnectionURL: u.String() + "?&" + q.Encode(), // this format is required by AWS
+		},
+	}, nil
+}
+
+func (provider *awscloudprovider) ListServiceDefinitions() ([]cloudintegrationtypes.ServiceDefinition, error) {
+	return provider.serviceDefinitions.List()
+}
+
+func (provider *awscloudprovider) GetServiceDefinition(serviceID cloudintegrationtypes.ServiceID) (*cloudintegrationtypes.ServiceDefinition, error) {
+	return provider.serviceDefinitions.Get(serviceID)
+}
+
+func (provider *awscloudprovider) StorableConfigFromServiceConfig(cfg *cloudintegrationtypes.ServiceConfig, supported cloudintegrationtypes.SupportedSignals) (string, error) {
+	if cfg == nil || cfg.AWS == nil {
+		return "", nil
+	}
+	// Strip signal configs the service does not support before storing.
+	if !supported.Logs {
+		cfg.AWS.Logs = nil
+	}
+	if !supported.Metrics {
+		cfg.AWS.Metrics = nil
+	}
+	b, err := json.Marshal(cfg.AWS)
+	if err != nil {
+		return "", err
+	}
+	return string(b), nil
+}
+
+func (provider *awscloudprovider) ServiceConfigFromStorableServiceConfig(config string) (*cloudintegrationtypes.ServiceConfig, error) {
+	if config == "" {
+		return nil, errors.NewInternalf(errors.CodeInternal, "service config is empty")
+	}
+
+	var awsCfg cloudintegrationtypes.AWSServiceConfig
+	if err := json.Unmarshal([]byte(config), &awsCfg); err != nil {
+		return nil, err
+	}
+
+	return &cloudintegrationtypes.ServiceConfig{AWS: &awsCfg}, nil
+}
+
+func (provider *awscloudprovider) IsServiceEnabled(config *cloudintegrationtypes.ServiceConfig) bool {
+	if config == nil || config.AWS == nil {
+		return false
+	}
+	logsEnabled := config.AWS.Logs != nil && config.AWS.Logs.Enabled
+	metricsEnabled := config.AWS.Metrics != nil && config.AWS.Metrics.Enabled
+	return logsEnabled || metricsEnabled
+}
+
+func (provider *awscloudprovider) IsMetricsEnabled(config *cloudintegrationtypes.ServiceConfig) bool {
+	if config == nil || config.AWS == nil {
+		return false
+	}
+	return awsMetricsEnabled(config.AWS)
+}
+
+// awsLogsEnabled returns true if the AWS service config has logs explicitly enabled.
+func awsLogsEnabled(cfg *cloudintegrationtypes.AWSServiceConfig) bool {
+	return cfg.Logs != nil && cfg.Logs.Enabled
+}
+
+// awsMetricsEnabled returns true if the AWS service config has metrics explicitly enabled.
+func awsMetricsEnabled(cfg *cloudintegrationtypes.AWSServiceConfig) bool {
+	return cfg.Metrics != nil && cfg.Metrics.Enabled
+}
+
+func (provider *awscloudprovider) BuildIntegrationConfig(
+	account *cloudintegrationtypes.Account,
+	services []*cloudintegrationtypes.StorableCloudIntegrationService,
+) (*cloudintegrationtypes.ProviderIntegrationConfig, error) {
+	// Sort services for deterministic output
+	sort.Slice(services, func(i, j int) bool {
+		return services[i].Type.StringValue() < services[j].Type.StringValue()
+	})
+
+	compiledMetrics := &cloudintegrationtypes.AWSMetricsStrategy{}
+	compiledLogs := &cloudintegrationtypes.AWSLogsStrategy{}
+	var compiledS3Buckets map[string][]string
+
+	for _, storedSvc := range services {
+		svcCfg, err := provider.ServiceConfigFromStorableServiceConfig(storedSvc.Config)
+		if err != nil || svcCfg == nil || svcCfg.AWS == nil {
+			continue
+		}
+
+		svcDef, err := provider.GetServiceDefinition(storedSvc.Type)
+		if err != nil || svcDef == nil || svcDef.Strategy == nil || svcDef.Strategy.AWS == nil {
+			continue
+		}
+
+		strategy := svcDef.Strategy.AWS
+
+		// S3Sync: logs come directly from configured S3 buckets, not CloudWatch subscriptions
+		if storedSvc.Type == cloudintegrationtypes.AWSServiceS3Sync {
+			if awsLogsEnabled(svcCfg.AWS) && svcCfg.AWS.Logs.S3Buckets != nil {
+				compiledS3Buckets = svcCfg.AWS.Logs.S3Buckets
+			}
+			continue
+		}
+
+		if awsLogsEnabled(svcCfg.AWS) && strategy.Logs != nil {
+			compiledLogs.Subscriptions = append(compiledLogs.Subscriptions, strategy.Logs.Subscriptions...)
+		}
+
+		if awsMetricsEnabled(svcCfg.AWS) && strategy.Metrics != nil {
+			compiledMetrics.StreamFilters = append(compiledMetrics.StreamFilters, strategy.Metrics.StreamFilters...)
+		}
+	}
+
+	awsTelemetry := &cloudintegrationtypes.AWSCollectionStrategy{}
+	if len(compiledMetrics.StreamFilters) > 0 {
+		awsTelemetry.Metrics = compiledMetrics
+	}
+	if len(compiledLogs.Subscriptions) > 0 {
+		awsTelemetry.Logs = compiledLogs
+	}
+	if compiledS3Buckets != nil {
+		awsTelemetry.S3Buckets = compiledS3Buckets
+	}
+
+	enabledRegions := []string{}
+	if account.Config != nil && account.Config.AWS != nil && account.Config.AWS.Regions != nil {
+		enabledRegions = account.Config.AWS.Regions
+	}
+
+	return &cloudintegrationtypes.ProviderIntegrationConfig{
+		AWS: &cloudintegrationtypes.AWSIntegrationConfig{
+			EnabledRegions: enabledRegions,
+			Telemetry:      awsTelemetry,
+		},
+	}, nil
+}

ee/modules/cloudintegration/implcloudintegration/implcloudprovider/azurecloudprovider.go

@@ -0,0 +1,50 @@
+package implcloudprovider
+
+import (
+	"context"
+
+	"github.com/SigNoz/signoz/pkg/errors"
+	"github.com/SigNoz/signoz/pkg/modules/cloudintegration"
+	"github.com/SigNoz/signoz/pkg/types/cloudintegrationtypes"
+)
+
+type azurecloudprovider struct{}
+
+func NewAzureCloudProvider() cloudintegration.CloudProviderModule {
+	return &azurecloudprovider{}
+}
+
+func (provider *azurecloudprovider) GetConnectionArtifact(ctx context.Context, creds *cloudintegrationtypes.SignozCredentials, account *cloudintegrationtypes.Account, req *cloudintegrationtypes.ConnectionArtifactRequest) (*cloudintegrationtypes.ConnectionArtifact, error) {
+	panic("implement me")
+}
+
+func (provider *azurecloudprovider) ListServiceDefinitions() ([]cloudintegrationtypes.ServiceDefinition, error) {
+	panic("implement me")
+}
+
+func (provider *azurecloudprovider) GetServiceDefinition(serviceID cloudintegrationtypes.ServiceID) (*cloudintegrationtypes.ServiceDefinition, error) {
+	panic("implement me")
+}
+
+func (provider *azurecloudprovider) StorableConfigFromServiceConfig(cfg *cloudintegrationtypes.ServiceConfig, supported cloudintegrationtypes.SupportedSignals) (string, error) {
+	panic("implement me")
+}
+
+func (provider *azurecloudprovider) ServiceConfigFromStorableServiceConfig(config string) (*cloudintegrationtypes.ServiceConfig, error) {
+	panic("implement me")
+}
+
+func (provider *azurecloudprovider) IsServiceEnabled(config *cloudintegrationtypes.ServiceConfig) bool {
+	panic("implement me")
+}
+
+func (provider *azurecloudprovider) IsMetricsEnabled(config *cloudintegrationtypes.ServiceConfig) bool {
+	panic("implement me")
+}
+
+func (provider *azurecloudprovider) BuildIntegrationConfig(
+	account *cloudintegrationtypes.Account,
+	services []*cloudintegrationtypes.StorableCloudIntegrationService,
+) (*cloudintegrationtypes.ProviderIntegrationConfig, error) {
+	return nil, errors.New(errors.TypeUnsupported, cloudintegrationtypes.ErrCodeUnsupported, "azure cloud provider is not supported")
+}

ee/modules/cloudintegration/implcloudintegration/module.go

@@ -0,0 +1,572 @@
+package implcloudintegration
+
+import (
+	"context"
+	"fmt"
+	"sort"
+	"time"
+
+	"github.com/SigNoz/signoz/ee/modules/cloudintegration/implcloudintegration/implcloudprovider"
+	"github.com/SigNoz/signoz/pkg/errors"
+	"github.com/SigNoz/signoz/pkg/gateway"
+	"github.com/SigNoz/signoz/pkg/global"
+	"github.com/SigNoz/signoz/pkg/licensing"
+	"github.com/SigNoz/signoz/pkg/modules/cloudintegration"
+	"github.com/SigNoz/signoz/pkg/modules/user"
+	"github.com/SigNoz/signoz/pkg/types"
+	"github.com/SigNoz/signoz/pkg/types/cloudintegrationtypes"
+	"github.com/SigNoz/signoz/pkg/types/dashboardtypes"
+	"github.com/SigNoz/signoz/pkg/types/zeustypes"
+	"github.com/SigNoz/signoz/pkg/valuer"
+	"github.com/SigNoz/signoz/pkg/zeus"
+)
+
+type module struct {
+	userGetter        user.Getter
+	userSetter        user.Setter
+	store             cloudintegrationtypes.Store
+	gateway           gateway.Gateway
+	zeus              zeus.Zeus
+	licensing         licensing.Licensing
+	globalConfig      global.Config
+	cloudProvidersMap map[cloudintegrationtypes.CloudProviderType]cloudintegration.CloudProviderModule
+}
+
+func NewModule(
+	store cloudintegrationtypes.Store,
+	globalConfig global.Config,
+	zeus zeus.Zeus,
+	gateway gateway.Gateway,
+	licensing licensing.Licensing,
+	userGetter user.Getter,
+	userSetter user.Setter,
+) (cloudintegration.Module, error) {
+	awsCloudProviderModule, err := implcloudprovider.NewAWSCloudProvider()
+	if err != nil {
+		return nil, err
+	}
+	azureCloudProviderModule := implcloudprovider.NewAzureCloudProvider()
+	cloudProvidersMap := map[cloudintegrationtypes.CloudProviderType]cloudintegration.CloudProviderModule{
+		cloudintegrationtypes.CloudProviderTypeAWS:   awsCloudProviderModule,
+		cloudintegrationtypes.CloudProviderTypeAzure: azureCloudProviderModule,
+	}
+
+	return &module{
+		store:             store,
+		globalConfig:      globalConfig,
+		zeus:              zeus,
+		gateway:           gateway,
+		licensing:         licensing,
+		userGetter:        userGetter,
+		userSetter:        userSetter,
+		cloudProvidersMap: cloudProvidersMap,
+	}, nil
+}
+
+func (module *module) CreateAccount(ctx context.Context, account *cloudintegrationtypes.Account) error {
+	_, err := module.licensing.GetActive(ctx, account.OrgID)
+	if err != nil {
+		return errors.New(errors.TypeLicenseUnavailable, errors.CodeLicenseUnavailable, "a valid license is not available").WithAdditional("this feature requires a valid license").WithAdditional(err.Error())
+	}
+
+	storableCloudIntegration, err := cloudintegrationtypes.NewStorableCloudIntegration(account)
+	if err != nil {
+		return err
+	}
+
+	return module.store.CreateAccount(ctx, storableCloudIntegration)
+}
+
+func (module *module) GetConnectionArtifact(ctx context.Context, account *cloudintegrationtypes.Account, req *cloudintegrationtypes.ConnectionArtifactRequest) (*cloudintegrationtypes.ConnectionArtifact, error) {
+	// TODO: evaluate if this check is really required and remove if the deployment promises to always have this configured.
+	if module.globalConfig.IngestionURL == nil {
+		return nil, errors.New(errors.TypeInternal, errors.CodeInternal, "ingestion URL is not configured")
+	}
+
+	// get license to get the deployment details
+	license, err := module.licensing.GetActive(ctx, account.OrgID)
+	if err != nil {
+		return nil, err
+	}
+
+	// get deployment details from zeus
+	respBytes, err := module.zeus.GetDeployment(ctx, license.Key)
+	if err != nil {
+		return nil, errors.WrapInternalf(err, errors.CodeInternal, "couldn't get deployment")
+	}
+
+	// parse deployment details
+	deployment, err := zeustypes.NewGettableDeployment(respBytes)
+	if err != nil {
+		return nil, err
+	}
+
+	apiKey, err := module.getOrCreateAPIKey(ctx, account.OrgID, account.Provider)
+	if err != nil {
+		return nil, err
+	}
+
+	ingestionKey, err := module.getOrCreateIngestionKey(ctx, account.OrgID, account.Provider)
+	if err != nil {
+		return nil, err
+	}
+
+	creds := &cloudintegrationtypes.SignozCredentials{
+		SigNozAPIURL: deployment.SignozAPIUrl,
+		SigNozAPIKey: apiKey,
+		IngestionURL: module.globalConfig.IngestionURL.String(),
+		IngestionKey: ingestionKey,
+	}
+
+	cloudProviderModule, err := module.GetCloudProvider(account.Provider)
+	if err != nil {
+		return nil, err
+	}
+
+	return cloudProviderModule.GetConnectionArtifact(ctx, creds, account, req)
+}
+
+func (module *module) GetAccount(ctx context.Context, orgID valuer.UUID, accountID valuer.UUID, provider cloudintegrationtypes.CloudProviderType) (*cloudintegrationtypes.Account, error) {
+	_, err := module.licensing.GetActive(ctx, orgID)
+	if err != nil {
+		return nil, errors.New(errors.TypeLicenseUnavailable, errors.CodeLicenseUnavailable, "a valid license is not available").WithAdditional("this feature requires a valid license").WithAdditional(err.Error())
+	}
+
+	storableAccount, err := module.store.GetAccountByID(ctx, orgID, accountID, provider)
+	if err != nil {
+		return nil, err
+	}
+
+	return cloudintegrationtypes.NewAccountFromStorable(storableAccount)
+}
+
+// ListAccounts return only agent connected accounts
+func (module *module) ListAccounts(ctx context.Context, orgID valuer.UUID, provider cloudintegrationtypes.CloudProviderType) ([]*cloudintegrationtypes.Account, error) {
+	_, err := module.licensing.GetActive(ctx, orgID)
+	if err != nil {
+		return nil, errors.New(errors.TypeLicenseUnavailable, errors.CodeLicenseUnavailable, "a valid license is not available").WithAdditional("this feature requires a valid license").WithAdditional(err.Error())
+	}
+
+	storableAccounts, err := module.store.ListConnectedAccounts(ctx, orgID, provider)
+	if err != nil {
+		return nil, err
+	}
+
+	return cloudintegrationtypes.NewAccountsFromStorables(storableAccounts)
+}
+
+func (module *module) AgentCheckIn(ctx context.Context, orgID valuer.UUID, provider cloudintegrationtypes.CloudProviderType, req *cloudintegrationtypes.AgentCheckInRequest) (*cloudintegrationtypes.AgentCheckInResponse, error) {
+	_, err := module.licensing.GetActive(ctx, orgID)
+	if err != nil {
+		return nil, errors.New(errors.TypeLicenseUnavailable, errors.CodeLicenseUnavailable, "a valid license is not available").WithAdditional("this feature requires a valid license").WithAdditional(err.Error())
+	}
+
+	connectedAccount, err := module.store.GetConnectedAccount(ctx, orgID, provider, req.ProviderAccountID)
+	if err != nil && !errors.Ast(err, errors.TypeNotFound) {
+		return nil, err
+	}
+
+	// If a different integration is already connected to this provider account ID, reject the check-in.
+	// Allow re-check-in from the same integration (e.g. agent restarting).
+	if connectedAccount != nil && connectedAccount.ID != req.CloudIntegrationID {
+		errMessage := fmt.Sprintf("provider account id %s is already connected to cloud integration id %s", req.ProviderAccountID, connectedAccount.ID)
+		return nil, errors.New(errors.TypeAlreadyExists, cloudintegrationtypes.ErrCodeCloudIntegrationAlreadyConnected, errMessage)
+	}
+
+	account, err := module.store.GetAccountByID(ctx, orgID, req.CloudIntegrationID, provider)
+	if err != nil {
+		return nil, err
+	}
+
+	account.AccountID = &req.ProviderAccountID
+	account.LastAgentReport = &cloudintegrationtypes.StorableAgentReport{
+		TimestampMillis: time.Now().UnixMilli(),
+		Data:            req.Data,
+	}
+
+	err = module.store.UpdateAccount(ctx, account)
+	if err != nil {
+		return nil, err
+	}
+
+	// If account has been removed (disconnected), return a minimal response with empty integration config.
+	// The agent doesn't act on config for removed accounts.
+	if account.RemovedAt != nil {
+		return &cloudintegrationtypes.AgentCheckInResponse{
+			CloudIntegrationID: account.ID.StringValue(),
+			ProviderAccountID:  req.ProviderAccountID,
+			IntegrationConfig:  &cloudintegrationtypes.ProviderIntegrationConfig{},
+			RemovedAt:          account.RemovedAt,
+		}, nil
+	}
+
+	// Get account as domain object for config access (enabled regions, etc.)
+	accountDomain, err := cloudintegrationtypes.NewAccountFromStorable(account)
+	if err != nil {
+		return nil, err
+	}
+
+	cloudProvider, err := module.GetCloudProvider(provider)
+	if err != nil {
+		return nil, err
+	}
+
+	storedServices, err := module.store.ListServices(ctx, req.CloudIntegrationID)
+	if err != nil {
+		return nil, err
+	}
+
+	// Delegate integration config building entirely to the provider module
+	integrationConfig, err := cloudProvider.BuildIntegrationConfig(accountDomain, storedServices)
+	if err != nil {
+		return nil, err
+	}
+
+	return &cloudintegrationtypes.AgentCheckInResponse{
+		CloudIntegrationID: account.ID.StringValue(),
+		ProviderAccountID:  req.ProviderAccountID,
+		IntegrationConfig:  integrationConfig,
+		RemovedAt:          account.RemovedAt,
+	}, nil
+}
+
+func (module *module) UpdateAccount(ctx context.Context, account *cloudintegrationtypes.Account) error {
+	_, err := module.licensing.GetActive(ctx, account.OrgID)
+	if err != nil {
+		return errors.New(errors.TypeLicenseUnavailable, errors.CodeLicenseUnavailable, "a valid license is not available").WithAdditional("this feature requires a valid license").WithAdditional(err.Error())
+	}
+
+	storableAccount, err := cloudintegrationtypes.NewStorableCloudIntegration(account)
+	if err != nil {
+		return err
+	}
+
+	return module.store.UpdateAccount(ctx, storableAccount)
+}
+
+func (module *module) DisconnectAccount(ctx context.Context, orgID valuer.UUID, accountID valuer.UUID, provider cloudintegrationtypes.CloudProviderType) error {
+	_, err := module.licensing.GetActive(ctx, orgID)
+	if err != nil {
+		return errors.New(errors.TypeLicenseUnavailable, errors.CodeLicenseUnavailable, "a valid license is not available").WithAdditional("this feature requires a valid license").WithAdditional(err.Error())
+	}
+
+	return module.store.RemoveAccount(ctx, orgID, accountID, provider)
+}
+
+func (module *module) ListServicesMetadata(ctx context.Context, orgID valuer.UUID, provider cloudintegrationtypes.CloudProviderType, integrationID *valuer.UUID) ([]*cloudintegrationtypes.ServiceMetadata, error) {
+	_, err := module.licensing.GetActive(ctx, orgID)
+	if err != nil {
+		return nil, errors.New(errors.TypeLicenseUnavailable, errors.CodeLicenseUnavailable, "a valid license is not available").WithAdditional("this feature requires a valid license").WithAdditional(err.Error())
+	}
+
+	cloudProvider, err := module.GetCloudProvider(provider)
+	if err != nil {
+		return nil, err
+	}
+
+	serviceDefinitions, err := cloudProvider.ListServiceDefinitions()
+	if err != nil {
+		return nil, err
+	}
+
+	enabledServiceIDs := map[string]bool{}
+	if integrationID != nil {
+		_, err := module.store.GetAccountByID(ctx, orgID, *integrationID, provider)
+		if err != nil {
+			return nil, err
+		}
+
+		storedServices, err := module.store.ListServices(ctx, *integrationID)
+		if err != nil {
+			return nil, err
+		}
+
+		for _, svc := range storedServices {
+			serviceConfig, err := cloudProvider.ServiceConfigFromStorableServiceConfig(svc.Config)
+			if err != nil {
+				return nil, err
+			}
+
+			if cloudProvider.IsServiceEnabled(serviceConfig) {
+				enabledServiceIDs[svc.Type.StringValue()] = true
+			}
+		}
+	}
+
+	resp := make([]*cloudintegrationtypes.ServiceMetadata, 0, len(serviceDefinitions))
+	for _, serviceDefinition := range serviceDefinitions {
+		resp = append(resp, cloudintegrationtypes.NewServiceMetadata(serviceDefinition, enabledServiceIDs[serviceDefinition.ID]))
+	}
+
+	return resp, nil
+}
+
+func (module *module) GetService(ctx context.Context, orgID valuer.UUID, integrationID *valuer.UUID, serviceID cloudintegrationtypes.ServiceID, provider cloudintegrationtypes.CloudProviderType) (*cloudintegrationtypes.Service, error) {
+	_, err := module.licensing.GetActive(ctx, orgID)
+	if err != nil {
+		return nil, errors.New(errors.TypeLicenseUnavailable, errors.CodeLicenseUnavailable, "a valid license is not available").WithAdditional("this feature requires a valid license").WithAdditional(err.Error())
+	}
+
+	cloudProvider, err := module.GetCloudProvider(provider)
+	if err != nil {
+		return nil, err
+	}
+
+	serviceDefinition, err := cloudProvider.GetServiceDefinition(serviceID)
+	if err != nil {
+		return nil, err
+	}
+
+	var integrationService *cloudintegrationtypes.CloudIntegrationService
+
+	if integrationID != nil {
+		_, err := module.store.GetAccountByID(ctx, orgID, *integrationID, provider)
+		if err != nil {
+			return nil, err
+		}
+
+		storedService, err := module.store.GetServiceByServiceID(ctx, *integrationID, serviceID)
+		if err != nil && !errors.Ast(err, errors.TypeNotFound) {
+			return nil, err
+		}
+		if storedService != nil {
+			serviceConfig, err := cloudProvider.ServiceConfigFromStorableServiceConfig(storedService.Config)
+			if err != nil {
+				return nil, err
+			}
+
+			integrationService = cloudintegrationtypes.NewCloudIntegrationServiceFromStorable(storedService, serviceConfig)
+		}
+	}
+
+	return cloudintegrationtypes.NewService(*serviceDefinition, integrationService), nil
+}
+
+func (module *module) CreateService(ctx context.Context, orgID valuer.UUID, service *cloudintegrationtypes.CloudIntegrationService, provider cloudintegrationtypes.CloudProviderType) error {
+	_, err := module.licensing.GetActive(ctx, orgID)
+	if err != nil {
+		return errors.New(errors.TypeLicenseUnavailable, errors.CodeLicenseUnavailable, "a valid license is not available").WithAdditional("this feature requires a valid license").WithAdditional(err.Error())
+	}
+
+	cloudProvider, err := module.GetCloudProvider(provider)
+	if err != nil {
+		return err
+	}
+
+	serviceDefinition, err := cloudProvider.GetServiceDefinition(service.Type)
+	if err != nil {
+		return err
+	}
+
+	configJSON, err := cloudProvider.StorableConfigFromServiceConfig(service.Config, serviceDefinition.SupportedSignals)
+	if err != nil {
+		return err
+	}
+
+	return module.store.CreateService(ctx, cloudintegrationtypes.NewStorableCloudIntegrationService(service, configJSON))
+}
+
+func (module *module) UpdateService(ctx context.Context, orgID valuer.UUID, integrationService *cloudintegrationtypes.CloudIntegrationService, provider cloudintegrationtypes.CloudProviderType) error {
+	_, err := module.licensing.GetActive(ctx, orgID)
+	if err != nil {
+		return errors.New(errors.TypeLicenseUnavailable, errors.CodeLicenseUnavailable, "a valid license is not available").WithAdditional("this feature requires a valid license").WithAdditional(err.Error())
+	}
+
+	cloudProvider, err := module.GetCloudProvider(provider)
+	if err != nil {
+		return err
+	}
+
+	serviceDefinition, err := cloudProvider.GetServiceDefinition(integrationService.Type)
+	if err != nil {
+		return err
+	}
+
+	configJSON, err := cloudProvider.StorableConfigFromServiceConfig(integrationService.Config, serviceDefinition.SupportedSignals)
+	if err != nil {
+		return err
+	}
+
+	storableService := cloudintegrationtypes.NewStorableCloudIntegrationService(integrationService, configJSON)
+
+	return module.store.UpdateService(ctx, storableService)
+}
+
+func (module *module) listDashboards(ctx context.Context, orgID valuer.UUID) ([]*dashboardtypes.Dashboard, error) {
+	var allDashboards []*dashboardtypes.Dashboard
+
+	for provider := range module.cloudProvidersMap {
+		cloudProvider, err := module.GetCloudProvider(provider)
+		if err != nil {
+			return nil, err
+		}
+
+		connectedAccounts, err := module.store.ListConnectedAccounts(ctx, orgID, provider)
+		if err != nil {
+			return nil, err
+		}
+
+		for _, storableAccount := range connectedAccounts {
+			storedServices, err := module.store.ListServices(ctx, storableAccount.ID)
+			if err != nil {
+				return nil, err
+			}
+
+			for _, storedSvc := range storedServices {
+				serviceConfig, err := cloudProvider.ServiceConfigFromStorableServiceConfig(storedSvc.Config)
+				if err != nil || !cloudProvider.IsMetricsEnabled(serviceConfig) {
+					continue
+				}
+
+				svcDef, err := cloudProvider.GetServiceDefinition(storedSvc.Type)
+				if err != nil || svcDef == nil {
+					continue
+				}
+
+				dashboards := cloudintegrationtypes.GetDashboardsFromAssets(
+					storedSvc.Type.StringValue(),
+					orgID,
+					provider,
+					storableAccount.CreatedAt,
+					svcDef.Assets,
+				)
+				allDashboards = append(allDashboards, dashboards...)
+			}
+		}
+	}
+
+	sort.Slice(allDashboards, func(i, j int) bool {
+		return allDashboards[i].ID < allDashboards[j].ID
+	})
+
+	return allDashboards, nil
+}
+
+func (module *module) GetDashboardByID(ctx context.Context, orgID valuer.UUID, id string) (*dashboardtypes.Dashboard, error) {
+	_, err := module.licensing.GetActive(ctx, orgID)
+	if err != nil {
+		return nil, errors.New(errors.TypeLicenseUnavailable, errors.CodeLicenseUnavailable, "a valid license is not available").WithAdditional("this feature requires a valid license").WithAdditional(err.Error())
+	}
+
+	_, _, _, err = cloudintegrationtypes.ParseCloudIntegrationDashboardID(id)
+	if err != nil {
+		return nil, err
+	}
+
+	allDashboards, err := module.listDashboards(ctx, orgID)
+	if err != nil {
+		return nil, err
+	}
+
+	for _, d := range allDashboards {
+		if d.ID == id {
+			return d, nil
+		}
+	}
+
+	return nil, errors.New(errors.TypeNotFound, cloudintegrationtypes.ErrCodeCloudIntegrationNotFound, "cloud integration dashboard not found")
+}
+
+func (module *module) ListDashboards(ctx context.Context, orgID valuer.UUID) ([]*dashboardtypes.Dashboard, error) {
+	_, err := module.licensing.GetActive(ctx, orgID)
+	if err != nil {
+		return nil, errors.New(errors.TypeLicenseUnavailable, errors.CodeLicenseUnavailable, "a valid license is not available").WithAdditional("this feature requires a valid license").WithAdditional(err.Error())
+	}
+
+	return module.listDashboards(ctx, orgID)
+}
+
+func (module *module) GetCloudProvider(provider cloudintegrationtypes.CloudProviderType) (cloudintegration.CloudProviderModule, error) {
+	if cloudProviderModule, ok := module.cloudProvidersMap[provider]; ok {
+		return cloudProviderModule, nil
+	}
+
+	return nil, errors.NewInvalidInputf(cloudintegrationtypes.ErrCodeCloudProviderInvalidInput, "invalid cloud provider: %s", provider.StringValue())
+}
+
+func (module *module) getOrCreateIngestionKey(ctx context.Context, orgID valuer.UUID, provider cloudintegrationtypes.CloudProviderType) (string, error) {
+	keyName := cloudintegrationtypes.NewIngestionKeyName(provider)
+
+	result, err := module.gateway.SearchIngestionKeysByName(ctx, orgID, keyName, 1, 10)
+	if err != nil {
+		return "", errors.WrapInternalf(err, errors.CodeInternal, "couldn't search ingestion keys")
+	}
+
+	// ideally there should be only one key per cloud integration provider
+	if len(result.Keys) > 0 {
+		return result.Keys[0].Value, nil
+	}
+
+	createdIngestionKey, err := module.gateway.CreateIngestionKey(ctx, orgID, keyName, []string{"integration"}, time.Time{})
+	if err != nil {
+		return "", errors.WrapInternalf(err, errors.CodeInternal, "couldn't create ingestion key")
+	}
+
+	return createdIngestionKey.Value, nil
+}
+
+func (module *module) getOrCreateAPIKey(ctx context.Context, orgID valuer.UUID, provider cloudintegrationtypes.CloudProviderType) (string, error) {
+	integrationUser, err := module.getOrCreateIntegrationUser(ctx, orgID, provider)
+	if err != nil {
+		return "", err
+	}
+
+	existingKeys, err := module.userSetter.ListAPIKeys(ctx, orgID)
+	if err != nil {
+		return "", err
+	}
+
+	keyName := cloudintegrationtypes.NewAPIKeyName(provider)
+
+	for _, key := range existingKeys {
+		if key.Name == keyName && key.UserID == integrationUser.ID {
+			return key.Token, nil
+		}
+	}
+
+	apiKey, err := types.NewStorableAPIKey(keyName, integrationUser.ID, types.RoleViewer, 0)
+	if err != nil {
+		return "", err
+	}
+
+	err = module.userSetter.CreateAPIKey(ctx, apiKey)
+	if err != nil {
+		return "", err
+	}
+
+	return apiKey.Token, nil
+}
+
+func (module *module) getOrCreateIntegrationUser(ctx context.Context, orgID valuer.UUID, provider cloudintegrationtypes.CloudProviderType) (*types.User, error) {
+	email, err := cloudintegrationtypes.GetCloudProviderEmail(provider)
+	if err != nil {
+		return nil, err
+	}
+
+	// get user by email
+	integrationUser, err := module.userGetter.GetNonDeletedUserByEmailAndOrgID(ctx, email, orgID)
+	if err != nil && !errors.Ast(err, errors.TypeNotFound) {
+		return nil, err
+	}
+
+	// if user found, return
+	if integrationUser != nil {
+		return integrationUser, nil
+	}
+
+	// if user not found, create a new one
+	displayName := cloudintegrationtypes.NewIntegrationUserDisplayName(provider)
+	integrationUser, err = types.NewUser(displayName, email, orgID, types.UserStatusActive)
+	if err != nil {
+		return nil, err
+	}
+
+	password := types.MustGenerateFactorPassword(integrationUser.ID.String())
+
+	err = module.userSetter.CreateUser(ctx, integrationUser, user.WithFactorPassword(password))
+	if err != nil {
+		return nil, err
+	}
+
+	return integrationUser, nil
+}

ee/querier/handler.go

@@ -79,7 +79,7 @@ func (h *handler) QueryRange(rw http.ResponseWriter, req *http.Request) {
 		// Build step intervals from the anomaly query
 		stepIntervals := make(map[string]uint64)
 		if anomalyQuery.StepInterval.Duration > 0 {
-			stepIntervals[anomalyQuery.Name] = uint64(anomalyQuery.StepInterval.Seconds())
+			stepIntervals[anomalyQuery.Name] = uint64(anomalyQuery.StepInterval.Duration.Seconds())
 		}
 
 		finalResp := &qbtypes.QueryRangeResponse{

ee/query-service/app/server.go

@@ -242,6 +242,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)

ee/sqlstore/postgressqlstore/dialect.go

@@ -336,10 +336,9 @@ func (dialect *dialect) UpdatePrimaryKey(ctx context.Context, bun bun.IDB, oldMo
 	}
 
 	fkReference := ""
-	switch reference {
-	case Org:
+	if reference == Org {
 		fkReference = OrgReference
-	case User:
+	} else if reference == User {
 		fkReference = UserReference
 	}
 
@@ -393,10 +392,9 @@ func (dialect *dialect) AddPrimaryKey(ctx context.Context, bun bun.IDB, oldModel
 	}
 
 	fkReference := ""
-	switch reference {
-	case Org:
+	if reference == Org {
 		fkReference = OrgReference
-	case User:
+	} else if reference == User {
 		fkReference = UserReference
 	}
 

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
 }

ee/zeus/config.go

@@ -19,7 +19,7 @@ var (
 	once   sync.Once
 )
 
-// initializes the Zeus configuration.
+// initializes the Zeus configuration
 func Config() zeus.Config {
 	once.Do(func() {
 		parsedURL, err := neturl.Parse(url)

ee/zeus/httpzeus/provider.go

@@ -189,7 +189,7 @@ func (provider *Provider) do(ctx context.Context, url *url.URL, method string, k
 	return nil, provider.errFromStatusCode(response.StatusCode, errorMessage)
 }
 
-// This can be taken down to the client package.
+// This can be taken down to the client package
 func (provider *Provider) errFromStatusCode(statusCode int, errorMessage string) error {
 	switch statusCode {
 	case http.StatusBadRequest:

frontend/README.md

@@ -12,7 +12,7 @@
 or
 `docker build . -t tagname`
 
-**Tag to remote url- Introduce versioning later on**
+**Tag to remote url- Introduce versinoing later on**
 
 ```
 docker tag signoz/frontend:latest 7296823551/signoz:latest

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/AppRoutes/Private.tsx

@@ -101,22 +101,6 @@ function PrivateRoute({ children }: PrivateRouteProps): JSX.Element {
 					preference.name === ORG_PREFERENCES.ORG_ONBOARDING,
 			)?.value;
 
-			// Don't redirect to onboarding if workspace has issues (blocked, suspended, or restricted)
-			// User needs access to settings/billing to fix payment issues
-			const isWorkspaceBlocked = trialInfo?.workSpaceBlock;
-			const isWorkspaceSuspended = activeLicense?.state === LicenseState.DEFAULTED;
-			const isWorkspaceAccessRestricted =
-				activeLicense?.state === LicenseState.TERMINATED ||
-				activeLicense?.state === LicenseState.EXPIRED ||
-				activeLicense?.state === LicenseState.CANCELLED;
-
-			const hasWorkspaceIssue =
-				isWorkspaceBlocked || isWorkspaceSuspended || isWorkspaceAccessRestricted;
-
-			if (hasWorkspaceIssue) {
-				return;
-			}
-
 			const isFirstUser = checkFirstTimeUser();
 			if (
 				isFirstUser &&
@@ -135,36 +119,40 @@ function PrivateRoute({ children }: PrivateRouteProps): JSX.Element {
 		orgPreferences,
 		usersData,
 		pathname,
-		trialInfo?.workSpaceBlock,
-		activeLicense?.state,
 	]);
 
-	const navigateToWorkSpaceBlocked = useCallback((): void => {
+	const navigateToWorkSpaceBlocked = (route: any): void => {
+		const { path } = route;
+
 		const isRouteEnabledForWorkspaceBlockedState =
 			isAdmin &&
-			(pathname === ROUTES.SETTINGS ||
-				pathname === ROUTES.ORG_SETTINGS ||
-				pathname === ROUTES.MEMBERS_SETTINGS ||
-				pathname === ROUTES.BILLING ||
-				pathname === ROUTES.MY_SETTINGS);
+			(path === ROUTES.SETTINGS ||
+				path === ROUTES.ORG_SETTINGS ||
+				path === ROUTES.MEMBERS_SETTINGS ||
+				path === ROUTES.BILLING ||
+				path === ROUTES.MY_SETTINGS);
 
 		if (
-			pathname &&
-			pathname !== ROUTES.WORKSPACE_LOCKED &&
+			path &&
+			path !== ROUTES.WORKSPACE_LOCKED &&
 			!isRouteEnabledForWorkspaceBlockedState
 		) {
 			history.push(ROUTES.WORKSPACE_LOCKED);
 		}
-	}, [isAdmin, pathname]);
+	};
 
-	const navigateToWorkSpaceAccessRestricted = useCallback((): void => {
-		if (pathname && pathname !== ROUTES.WORKSPACE_ACCESS_RESTRICTED) {
+	const navigateToWorkSpaceAccessRestricted = (route: any): void => {
+		const { path } = route;
+
+		if (path && path !== ROUTES.WORKSPACE_ACCESS_RESTRICTED) {
 			history.push(ROUTES.WORKSPACE_ACCESS_RESTRICTED);
 		}
-	}, [pathname]);
+	};
 
 	useEffect(() => {
 		if (!isFetchingActiveLicense && activeLicense) {
+			const currentRoute = mapRoutes.get('current');
+
 			const isTerminated = activeLicense.state === LicenseState.TERMINATED;
 			const isExpired = activeLicense.state === LicenseState.EXPIRED;
 			const isCancelled = activeLicense.state === LicenseState.CANCELLED;
@@ -173,53 +161,61 @@ function PrivateRoute({ children }: PrivateRouteProps): JSX.Element {
 
 			const { platform } = activeLicense;
 
-			if (isWorkspaceAccessRestricted && platform === LicensePlatform.CLOUD) {
-				navigateToWorkSpaceAccessRestricted();
+			if (
+				isWorkspaceAccessRestricted &&
+				platform === LicensePlatform.CLOUD &&
+				currentRoute
+			) {
+				navigateToWorkSpaceAccessRestricted(currentRoute);
 			}
 		}
-	}, [
-		isFetchingActiveLicense,
-		activeLicense,
-		navigateToWorkSpaceAccessRestricted,
-	]);
+	}, [isFetchingActiveLicense, activeLicense, mapRoutes, pathname]);
 
 	useEffect(() => {
 		if (!isFetchingActiveLicense) {
+			const currentRoute = mapRoutes.get('current');
 			const shouldBlockWorkspace = trialInfo?.workSpaceBlock;
 
 			if (
 				shouldBlockWorkspace &&
+				currentRoute &&
 				activeLicense?.platform === LicensePlatform.CLOUD
 			) {
-				navigateToWorkSpaceBlocked();
+				navigateToWorkSpaceBlocked(currentRoute);
 			}
 		}
+		// eslint-disable-next-line react-hooks/exhaustive-deps
 	}, [
 		isFetchingActiveLicense,
 		trialInfo?.workSpaceBlock,
 		activeLicense?.platform,
-		navigateToWorkSpaceBlocked,
+		mapRoutes,
+		pathname,
 	]);
 
-	const navigateToWorkSpaceSuspended = useCallback((): void => {
-		if (pathname && pathname !== ROUTES.WORKSPACE_SUSPENDED) {
+	const navigateToWorkSpaceSuspended = (route: any): void => {
+		const { path } = route;
+
+		if (path && path !== ROUTES.WORKSPACE_SUSPENDED) {
 			history.push(ROUTES.WORKSPACE_SUSPENDED);
 		}
-	}, [pathname]);
+	};
 
 	useEffect(() => {
 		if (!isFetchingActiveLicense && activeLicense) {
+			const currentRoute = mapRoutes.get('current');
 			const shouldSuspendWorkspace =
 				activeLicense.state === LicenseState.DEFAULTED;
 
 			if (
 				shouldSuspendWorkspace &&
+				currentRoute &&
 				activeLicense.platform === LicensePlatform.CLOUD
 			) {
-				navigateToWorkSpaceSuspended();
+				navigateToWorkSpaceSuspended(currentRoute);
 			}
 		}
-	}, [isFetchingActiveLicense, activeLicense, navigateToWorkSpaceSuspended]);
+	}, [isFetchingActiveLicense, activeLicense, mapRoutes, pathname]);
 
 	useEffect(() => {
 		if (org && org.length > 0 && org[0].id !== undefined) {

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/cloudintegration/index.ts

@@ -628,6 +628,103 @@ export const useUpdateAccount = <
 
 	return useMutation(mutationOptions);
 };
+/**
+ * This endpoint updates a service for the specified cloud provider
+ * @summary Update service
+ */
+export const updateService = (
+	{ cloudProvider, id, serviceId }: UpdateServicePathParameters,
+	cloudintegrationtypesUpdatableServiceDTO: BodyType<CloudintegrationtypesUpdatableServiceDTO>,
+) => {
+	return GeneratedAPIInstance<void>({
+		url: `/api/v1/cloud_integrations/${cloudProvider}/accounts/${id}/services/${serviceId}`,
+		method: 'PUT',
+		headers: { 'Content-Type': 'application/json' },
+		data: cloudintegrationtypesUpdatableServiceDTO,
+	});
+};
+
+export const getUpdateServiceMutationOptions = <
+	TError = ErrorType<RenderErrorResponseDTO>,
+	TContext = unknown
+>(options?: {
+	mutation?: UseMutationOptions<
+		Awaited<ReturnType<typeof updateService>>,
+		TError,
+		{
+			pathParams: UpdateServicePathParameters;
+			data: BodyType<CloudintegrationtypesUpdatableServiceDTO>;
+		},
+		TContext
+	>;
+}): UseMutationOptions<
+	Awaited<ReturnType<typeof updateService>>,
+	TError,
+	{
+		pathParams: UpdateServicePathParameters;
+		data: BodyType<CloudintegrationtypesUpdatableServiceDTO>;
+	},
+	TContext
+> => {
+	const mutationKey = ['updateService'];
+	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 updateService>>,
+		{
+			pathParams: UpdateServicePathParameters;
+			data: BodyType<CloudintegrationtypesUpdatableServiceDTO>;
+		}
+	> = (props) => {
+		const { pathParams, data } = props ?? {};
+
+		return updateService(pathParams, data);
+	};
+
+	return { mutationFn, ...mutationOptions };
+};
+
+export type UpdateServiceMutationResult = NonNullable<
+	Awaited<ReturnType<typeof updateService>>
+>;
+export type UpdateServiceMutationBody = BodyType<CloudintegrationtypesUpdatableServiceDTO>;
+export type UpdateServiceMutationError = ErrorType<RenderErrorResponseDTO>;
+
+/**
+ * @summary Update service
+ */
+export const useUpdateService = <
+	TError = ErrorType<RenderErrorResponseDTO>,
+	TContext = unknown
+>(options?: {
+	mutation?: UseMutationOptions<
+		Awaited<ReturnType<typeof updateService>>,
+		TError,
+		{
+			pathParams: UpdateServicePathParameters;
+			data: BodyType<CloudintegrationtypesUpdatableServiceDTO>;
+		},
+		TContext
+	>;
+}): UseMutationResult<
+	Awaited<ReturnType<typeof updateService>>,
+	TError,
+	{
+		pathParams: UpdateServicePathParameters;
+		data: BodyType<CloudintegrationtypesUpdatableServiceDTO>;
+	},
+	TContext
+> => {
+	const mutationOptions = getUpdateServiceMutationOptions(options);
+
+	return useMutation(mutationOptions);
+};
 /**
  * This endpoint is called by the deployed agent to check in
  * @summary Agent check-in
@@ -941,101 +1038,3 @@ export const invalidateGetService = async (
 
 	return queryClient;
 };
-
-/**
- * This endpoint updates a service for the specified cloud provider
- * @summary Update service
- */
-export const updateService = (
-	{ cloudProvider, serviceId }: UpdateServicePathParameters,
-	cloudintegrationtypesUpdatableServiceDTO: BodyType<CloudintegrationtypesUpdatableServiceDTO>,
-) => {
-	return GeneratedAPIInstance<void>({
-		url: `/api/v1/cloud_integrations/${cloudProvider}/services/${serviceId}`,
-		method: 'PUT',
-		headers: { 'Content-Type': 'application/json' },
-		data: cloudintegrationtypesUpdatableServiceDTO,
-	});
-};
-
-export const getUpdateServiceMutationOptions = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof updateService>>,
-		TError,
-		{
-			pathParams: UpdateServicePathParameters;
-			data: BodyType<CloudintegrationtypesUpdatableServiceDTO>;
-		},
-		TContext
-	>;
-}): UseMutationOptions<
-	Awaited<ReturnType<typeof updateService>>,
-	TError,
-	{
-		pathParams: UpdateServicePathParameters;
-		data: BodyType<CloudintegrationtypesUpdatableServiceDTO>;
-	},
-	TContext
-> => {
-	const mutationKey = ['updateService'];
-	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 updateService>>,
-		{
-			pathParams: UpdateServicePathParameters;
-			data: BodyType<CloudintegrationtypesUpdatableServiceDTO>;
-		}
-	> = (props) => {
-		const { pathParams, data } = props ?? {};
-
-		return updateService(pathParams, data);
-	};
-
-	return { mutationFn, ...mutationOptions };
-};
-
-export type UpdateServiceMutationResult = NonNullable<
-	Awaited<ReturnType<typeof updateService>>
->;
-export type UpdateServiceMutationBody = BodyType<CloudintegrationtypesUpdatableServiceDTO>;
-export type UpdateServiceMutationError = ErrorType<RenderErrorResponseDTO>;
-
-/**
- * @summary Update service
- */
-export const useUpdateService = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof updateService>>,
-		TError,
-		{
-			pathParams: UpdateServicePathParameters;
-			data: BodyType<CloudintegrationtypesUpdatableServiceDTO>;
-		},
-		TContext
-	>;
-}): UseMutationResult<
-	Awaited<ReturnType<typeof updateService>>,
-	TError,
-	{
-		pathParams: UpdateServicePathParameters;
-		data: BodyType<CloudintegrationtypesUpdatableServiceDTO>;
-	},
-	TContext
-> => {
-	const mutationOptions = getUpdateServiceMutationOptions(options);
-
-	return useMutation(mutationOptions);
-};

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/sigNoz.schemas.ts

@@ -550,12 +550,12 @@ export type CloudintegrationtypesAWSCollectionStrategyDTOS3Buckets = {
 };
 
 export interface CloudintegrationtypesAWSCollectionStrategyDTO {
-	aws_logs?: CloudintegrationtypesAWSLogsStrategyDTO;
-	aws_metrics?: CloudintegrationtypesAWSMetricsStrategyDTO;
+	logs?: CloudintegrationtypesAWSLogsStrategyDTO;
+	metrics?: CloudintegrationtypesAWSMetricsStrategyDTO;
 	/**
 	 * @type object
 	 */
-	s3_buckets?: CloudintegrationtypesAWSCollectionStrategyDTOS3Buckets;
+	s3Buckets?: CloudintegrationtypesAWSCollectionStrategyDTOS3Buckets;
 }
 
 export interface CloudintegrationtypesAWSConnectionArtifactDTO {
@@ -588,11 +588,11 @@ export type CloudintegrationtypesAWSLogsStrategyDTOCloudwatchLogsSubscriptionsIt
 	/**
 	 * @type string
 	 */
-	filter_pattern?: string;
+	filterPattern?: string;
 	/**
 	 * @type string
 	 */
-	log_group_name_prefix?: string;
+	logGroupNamePrefix?: string;
 };
 
 export interface CloudintegrationtypesAWSLogsStrategyDTO {
@@ -600,7 +600,7 @@ export interface CloudintegrationtypesAWSLogsStrategyDTO {
 	 * @type array
 	 * @nullable true
 	 */
-	cloudwatch_logs_subscriptions?:
+	cloudwatchLogsSubscriptions?:
 		| CloudintegrationtypesAWSLogsStrategyDTOCloudwatchLogsSubscriptionsItem[]
 		| null;
 }
@@ -621,7 +621,7 @@ export interface CloudintegrationtypesAWSMetricsStrategyDTO {
 	 * @type array
 	 * @nullable true
 	 */
-	cloudwatch_metric_stream_filters?:
+	cloudwatchMetricStreamFilters?:
 		| CloudintegrationtypesAWSMetricsStrategyDTOCloudwatchMetricStreamFiltersItem[]
 		| null;
 }
@@ -726,6 +726,32 @@ export interface CloudintegrationtypesAssetsDTO {
 	dashboards?: CloudintegrationtypesDashboardDTO[] | null;
 }
 
+/**
+ * @nullable
+ */
+export type CloudintegrationtypesCloudIntegrationServiceDTO = {
+	/**
+	 * @type string
+	 */
+	cloudIntegrationId?: string;
+	config?: CloudintegrationtypesServiceConfigDTO;
+	/**
+	 * @type string
+	 * @format date-time
+	 */
+	createdAt?: Date;
+	/**
+	 * @type string
+	 */
+	id: string;
+	type?: CloudintegrationtypesServiceIDDTO;
+	/**
+	 * @type string
+	 * @format date-time
+	 */
+	updatedAt?: Date;
+} | null;
+
 export interface CloudintegrationtypesCollectedLogAttributeDTO {
 	/**
 	 * @type string
@@ -864,9 +890,68 @@ export type CloudintegrationtypesIntegrationConfigDTO = {
 	 * @type array
 	 */
 	enabled_regions: string[];
-	telemetry: CloudintegrationtypesAWSCollectionStrategyDTO;
+	telemetry: CloudintegrationtypesOldAWSCollectionStrategyDTO;
 } | null;
 
+export type CloudintegrationtypesOldAWSCollectionStrategyDTOS3Buckets = {
+	[key: string]: string[];
+};
+
+export interface CloudintegrationtypesOldAWSCollectionStrategyDTO {
+	aws_logs?: CloudintegrationtypesOldAWSLogsStrategyDTO;
+	aws_metrics?: CloudintegrationtypesOldAWSMetricsStrategyDTO;
+	/**
+	 * @type string
+	 */
+	provider?: string;
+	/**
+	 * @type object
+	 */
+	s3_buckets?: CloudintegrationtypesOldAWSCollectionStrategyDTOS3Buckets;
+}
+
+export type CloudintegrationtypesOldAWSLogsStrategyDTOCloudwatchLogsSubscriptionsItem = {
+	/**
+	 * @type string
+	 */
+	filter_pattern?: string;
+	/**
+	 * @type string
+	 */
+	log_group_name_prefix?: string;
+};
+
+export interface CloudintegrationtypesOldAWSLogsStrategyDTO {
+	/**
+	 * @type array
+	 * @nullable true
+	 */
+	cloudwatch_logs_subscriptions?:
+		| CloudintegrationtypesOldAWSLogsStrategyDTOCloudwatchLogsSubscriptionsItem[]
+		| null;
+}
+
+export type CloudintegrationtypesOldAWSMetricsStrategyDTOCloudwatchMetricStreamFiltersItem = {
+	/**
+	 * @type array
+	 */
+	MetricNames?: string[];
+	/**
+	 * @type string
+	 */
+	Namespace?: string;
+};
+
+export interface CloudintegrationtypesOldAWSMetricsStrategyDTO {
+	/**
+	 * @type array
+	 * @nullable true
+	 */
+	cloudwatch_metric_stream_filters?:
+		| CloudintegrationtypesOldAWSMetricsStrategyDTOCloudwatchMetricStreamFiltersItem[]
+		| null;
+}
+
 /**
  * @nullable
  */
@@ -904,6 +989,7 @@ export interface CloudintegrationtypesProviderIntegrationConfigDTO {
 
 export interface CloudintegrationtypesServiceDTO {
 	assets: CloudintegrationtypesAssetsDTO;
+	cloudIntegrationService: CloudintegrationtypesCloudIntegrationServiceDTO;
 	dataCollected: CloudintegrationtypesDataCollectedDTO;
 	/**
 	 * @type string
@@ -917,8 +1003,7 @@ export interface CloudintegrationtypesServiceDTO {
 	 * @type string
 	 */
 	overview: string;
-	serviceConfig?: CloudintegrationtypesServiceConfigDTO;
-	supported_signals: CloudintegrationtypesSupportedSignalsDTO;
+	supportedSignals: CloudintegrationtypesSupportedSignalsDTO;
 	telemetryCollectionStrategy: CloudintegrationtypesCollectionStrategyDTO;
 	/**
 	 * @type string
@@ -930,6 +1015,21 @@ export interface CloudintegrationtypesServiceConfigDTO {
 	aws: CloudintegrationtypesAWSServiceConfigDTO;
 }
 
+export enum CloudintegrationtypesServiceIDDTO {
+	alb = 'alb',
+	'api-gateway' = 'api-gateway',
+	dynamodb = 'dynamodb',
+	ec2 = 'ec2',
+	ecs = 'ecs',
+	eks = 'eks',
+	elasticache = 'elasticache',
+	lambda = 'lambda',
+	msk = 'msk',
+	rds = 'rds',
+	s3sync = 's3sync',
+	sns = 'sns',
+	sqs = 'sqs',
+}
 export interface CloudintegrationtypesServiceMetadataDTO {
 	/**
 	 * @type boolean
@@ -1363,32 +1463,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 +1608,6 @@ export interface MetricsexplorertypesMetricMetadataDTO {
 	unit: string;
 }
 
-export interface MetricsexplorertypesMetricsOnboardingResponseDTO {
-	/**
-	 * @type boolean
-	 */
-	hasMetrics: boolean;
-}
-
 export interface MetricsexplorertypesStatDTO {
 	/**
 	 * @type string
@@ -3622,6 +3689,11 @@ export type UpdateAccountPathParameters = {
 	cloudProvider: string;
 	id: string;
 };
+export type UpdateServicePathParameters = {
+	cloudProvider: string;
+	id: string;
+	serviceId: string;
+};
 export type AgentCheckInPathParameters = {
 	cloudProvider: string;
 };
@@ -3656,10 +3728,6 @@ export type GetService200 = {
 	status: string;
 };
 
-export type UpdateServicePathParameters = {
-	cloudProvider: string;
-	serviceId: string;
-};
 export type CreateSessionByGoogleCallback303 = {
 	data: AuthtypesGettableTokenDTO;
 	/**
@@ -4424,22 +4492,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;
 	/**

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/GlobalTimeStoreAdapter/GlobalTimeStoreAdapter.tsx

@@ -1,52 +0,0 @@
-import { useEffect } from 'react';
-// eslint-disable-next-line no-restricted-imports
-import { useSelector } from 'react-redux';
-import { refreshIntervalOptions } from 'container/TopNav/AutoRefreshV2/constants';
-import { Time } from 'container/TopNav/DateTimeSelectionV2/types';
-import { useGlobalTimeStore } from 'store/globalTime/globalTimeStore';
-import { createCustomTimeRange } from 'store/globalTime/utils';
-import { AppState } from 'store/reducers';
-import { GlobalReducer } from 'types/reducer/globalTime';
-
-/**
- * Adapter component that syncs Redux global time state to Zustand store.
- * This component should be rendered once at the app level.
- *
- * It reads from the Redux globalTime reducer and updates the Zustand store
- * to provide a migration path from Redux to Zustand.
- */
-export function GlobalTimeStoreAdapter(): null {
-	const globalTime = useSelector<AppState, GlobalReducer>(
-		(state) => state.globalTime,
-	);
-
-	const setSelectedTime = useGlobalTimeStore((s) => s.setSelectedTime);
-
-	useEffect(() => {
-		// Convert the selectedTime to the new format
-		// If it's 'custom', store the min/max times in the custom format
-		const selectedTime =
-			globalTime.selectedTime === 'custom'
-				? createCustomTimeRange(globalTime.minTime, globalTime.maxTime)
-				: (globalTime.selectedTime as Time);
-
-		// Find refresh interval from Redux state
-		const refreshOption = refreshIntervalOptions.find(
-			(option) => option.key === globalTime.selectedAutoRefreshInterval,
-		);
-
-		const refreshInterval =
-			!globalTime.isAutoRefreshDisabled && refreshOption ? refreshOption.value : 0;
-
-		setSelectedTime(selectedTime, refreshInterval);
-	}, [
-		globalTime.selectedTime,
-		globalTime.isAutoRefreshDisabled,
-		globalTime.selectedAutoRefreshInterval,
-		globalTime.minTime,
-		globalTime.maxTime,
-		setSelectedTime,
-	]);
-
-	return null;
-}

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

@@ -1,227 +0,0 @@
-// eslint-disable-next-line no-restricted-imports
-import { Provider } from 'react-redux';
-import { act, render, renderHook } from '@testing-library/react';
-import { DEFAULT_TIME_RANGE } from 'container/TopNav/DateTimeSelectionV2/constants';
-import configureStore, { MockStoreEnhanced } from 'redux-mock-store';
-import { useGlobalTimeStore } from 'store/globalTime/globalTimeStore';
-import { createCustomTimeRange } from 'store/globalTime/utils';
-import { AppState } from 'store/reducers';
-import { GlobalReducer } from 'types/reducer/globalTime';
-
-import { GlobalTimeStoreAdapter } from '../GlobalTimeStoreAdapter';
-
-const mockStore = configureStore<Partial<AppState>>([]);
-
-const randomTime = 1700000000000000000;
-
-describe('GlobalTimeStoreAdapter', () => {
-	let store: MockStoreEnhanced<Partial<AppState>>;
-
-	const createGlobalTimeState = (
-		overrides: Partial<GlobalReducer> = {},
-	): GlobalReducer => ({
-		minTime: randomTime,
-		maxTime: randomTime,
-		loading: false,
-		selectedTime: '15m',
-		isAutoRefreshDisabled: true,
-		selectedAutoRefreshInterval: 'off',
-		...overrides,
-	});
-
-	beforeEach(() => {
-		// Reset Zustand store before each test
-		const { result } = renderHook(() => useGlobalTimeStore());
-		act(() => {
-			result.current.setSelectedTime(DEFAULT_TIME_RANGE, 0);
-		});
-	});
-
-	it('should render null because it just an adapter', () => {
-		store = mockStore({
-			globalTime: createGlobalTimeState(),
-		});
-
-		const { container } = render(
-			<Provider store={store}>
-				<GlobalTimeStoreAdapter />
-			</Provider>,
-		);
-
-		expect(container.firstChild).toBeNull();
-	});
-
-	it('should sync relative time from Redux to Zustand store', () => {
-		store = mockStore({
-			globalTime: createGlobalTimeState({
-				selectedTime: '15m',
-				isAutoRefreshDisabled: true,
-				selectedAutoRefreshInterval: 'off',
-			}),
-		});
-
-		render(
-			<Provider store={store}>
-				<GlobalTimeStoreAdapter />
-			</Provider>,
-		);
-
-		const { result } = renderHook(() => useGlobalTimeStore());
-		expect(result.current.selectedTime).toBe('15m');
-		expect(result.current.refreshInterval).toBe(0);
-		expect(result.current.isRefreshEnabled).toBe(false);
-	});
-
-	it('should sync custom time from Redux to Zustand store', () => {
-		store = mockStore({
-			globalTime: createGlobalTimeState({
-				selectedTime: 'custom',
-				minTime: randomTime,
-				maxTime: randomTime,
-				isAutoRefreshDisabled: true,
-			}),
-		});
-
-		render(
-			<Provider store={store}>
-				<GlobalTimeStoreAdapter />
-			</Provider>,
-		);
-
-		const { result } = renderHook(() => useGlobalTimeStore());
-		expect(result.current.selectedTime).toBe(
-			createCustomTimeRange(randomTime, randomTime),
-		);
-		expect(result.current.isRefreshEnabled).toBe(false);
-	});
-
-	it('should sync refresh interval when auto refresh is enabled', () => {
-		store = mockStore({
-			globalTime: createGlobalTimeState({
-				selectedTime: '15m',
-				isAutoRefreshDisabled: false,
-				selectedAutoRefreshInterval: '5s',
-			}),
-		});
-
-		render(
-			<Provider store={store}>
-				<GlobalTimeStoreAdapter />
-			</Provider>,
-		);
-
-		const { result } = renderHook(() => useGlobalTimeStore());
-		expect(result.current.selectedTime).toBe('15m');
-		expect(result.current.refreshInterval).toBe(5000); // 5s = 5000ms
-		expect(result.current.isRefreshEnabled).toBe(true);
-	});
-
-	it('should set refreshInterval to 0 when auto refresh is disabled', () => {
-		store = mockStore({
-			globalTime: createGlobalTimeState({
-				selectedTime: '15m',
-				isAutoRefreshDisabled: true,
-				selectedAutoRefreshInterval: '5s', // Even with interval set, should be 0 when disabled
-			}),
-		});
-
-		render(
-			<Provider store={store}>
-				<GlobalTimeStoreAdapter />
-			</Provider>,
-		);
-
-		const { result } = renderHook(() => useGlobalTimeStore());
-		expect(result.current.refreshInterval).toBe(0);
-		expect(result.current.isRefreshEnabled).toBe(false);
-	});
-
-	it('should update Zustand store when Redux state changes', () => {
-		store = mockStore({
-			globalTime: createGlobalTimeState({
-				selectedTime: '15m',
-				isAutoRefreshDisabled: true,
-			}),
-		});
-
-		const { rerender } = render(
-			<Provider store={store}>
-				<GlobalTimeStoreAdapter />
-			</Provider>,
-		);
-
-		// Verify initial state
-		let zustandState = renderHook(() => useGlobalTimeStore());
-		expect(zustandState.result.current.selectedTime).toBe('15m');
-
-		// Update Redux store
-		const newStore = mockStore({
-			globalTime: createGlobalTimeState({
-				selectedTime: '1h',
-				isAutoRefreshDisabled: false,
-				selectedAutoRefreshInterval: '30s',
-			}),
-		});
-
-		rerender(
-			<Provider store={newStore}>
-				<GlobalTimeStoreAdapter />
-			</Provider>,
-		);
-
-		// Verify updated state
-		zustandState = renderHook(() => useGlobalTimeStore());
-		expect(zustandState.result.current.selectedTime).toBe('1h');
-		expect(zustandState.result.current.refreshInterval).toBe(30000); // 30s = 30000ms
-		expect(zustandState.result.current.isRefreshEnabled).toBe(true);
-	});
-
-	it('should handle various refresh interval options', () => {
-		const testCases = [
-			{ key: '5s', expectedValue: 5000 },
-			{ key: '10s', expectedValue: 10000 },
-			{ key: '30s', expectedValue: 30000 },
-			{ key: '1m', expectedValue: 60000 },
-			{ key: '5m', expectedValue: 300000 },
-		];
-
-		testCases.forEach(({ key, expectedValue }) => {
-			store = mockStore({
-				globalTime: createGlobalTimeState({
-					selectedTime: '15m',
-					isAutoRefreshDisabled: false,
-					selectedAutoRefreshInterval: key,
-				}),
-			});
-
-			render(
-				<Provider store={store}>
-					<GlobalTimeStoreAdapter />
-				</Provider>,
-			);
-
-			const { result } = renderHook(() => useGlobalTimeStore());
-			expect(result.current.refreshInterval).toBe(expectedValue);
-		});
-	});
-
-	it('should handle unknown refresh interval by setting 0', () => {
-		store = mockStore({
-			globalTime: createGlobalTimeState({
-				selectedTime: '15m',
-				isAutoRefreshDisabled: false,
-				selectedAutoRefreshInterval: 'unknown-interval',
-			}),
-		});
-
-		render(
-			<Provider store={store}>
-				<GlobalTimeStoreAdapter />
-			</Provider>,
-		);
-
-		const { result } = renderHook(() => useGlobalTimeStore());
-		expect(result.current.refreshInterval).toBe(0);
-		expect(result.current.isRefreshEnabled).toBe(false);
-	});
-});

frontend/src/constants/reactQueryKeys.ts

@@ -1,11 +1,4 @@
 export const REACT_QUERY_KEY = {
-	/**
-	 * For any query that should support AutoRefresh and min/max time is from DateTimeSelectionV2
-	 * You can prefix the query with this KEY, it will allow the queries to be automatically refreshed
-	 * when the user clicks in the refresh button, or alert the user when the data is being refreshed.
-	 */
-	AUTO_REFRESH_QUERY: 'AUTO_REFRESH_QUERY',
-
 	GET_PUBLIC_DASHBOARD: 'GET_PUBLIC_DASHBOARD',
 	GET_PUBLIC_DASHBOARD_META: 'GET_PUBLIC_DASHBOARD_META',
 	GET_PUBLIC_DASHBOARD_WIDGET_DATA: 'GET_PUBLIC_DASHBOARD_WIDGET_DATA',

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/Home/Home.tsx

@@ -1,11 +1,10 @@
 /* eslint-disable sonarjs/no-duplicate-string */
-import React, { useCallback, useEffect, useState } from 'react';
+import React, { 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,8 +15,9 @@ 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';
@@ -81,7 +81,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 +91,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 +106,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 +116,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 +126,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 +283,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', {});

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,
@@ -116,12 +116,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,

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';
 // eslint-disable-next-line no-restricted-imports
-import { useSelector } from 'react-redux';
+import { useSelector } from 'react-redux'; // old code, TODO: fix this correctly
+import { useSearchParams } from 'react-router-dom-v5-compat';
 import { LoadingOutlined } from '@ant-design/icons';
 import {
 	Button,
@@ -28,17 +29,12 @@ 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 +49,6 @@ import {
 
 import '../InfraMonitoringK8s.styles.scss';
 import './K8sClustersList.styles.scss';
-
 function K8sClustersList({
 	isFiltersVisible,
 	handleFilterVisibilityChange,
@@ -67,19 +62,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 +136,7 @@ function K8sClustersList({
 		if (quickFiltersLastUpdated !== -1) {
 			setCurrentPage(1);
 		}
-	}, [quickFiltersLastUpdated, setCurrentPage]);
+	}, [quickFiltersLastUpdated]);
 
 	const { featureFlags } = useAppContext();
 	const dotMetricsEnabled =
@@ -158,28 +189,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 +266,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 +374,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({
@@ -414,7 +453,7 @@ function K8sClustersList({
 	}, [selectedClusterName, groupBy.length, clustersData, nestedClustersData]);
 
 	const openClusterInNewTab = (record: K8sClustersRowData): void => {
-		const newParams = new URLSearchParams(document.location.search);
+		const newParams = new URLSearchParams(searchParams);
 		newParams.set(
 			INFRA_MONITORING_K8S_PARAMS_KEYS.CLUSTER_NAME,
 			record.clusterUID,
@@ -438,6 +477,10 @@ function K8sClustersList({
 		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 +509,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 => (
@@ -562,11 +610,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 +638,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 +656,7 @@ function K8sClustersList({
 				category: InfraMonitoringEvents.Cluster,
 			});
 		},
-		[groupByFiltersData, setCurrentPage, setGroupBy],
+		[groupByFiltersData, searchParams, setSearchParams],
 	);
 
 	useEffect(() => {

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';
 // eslint-disable-next-line no-restricted-imports
-import { useSelector } from 'react-redux';
+import { useSelector } from 'react-redux'; // old code, TODO: fix this correctly
+import { useSearchParams } from 'react-router-dom-v5-compat';
 import { LoadingOutlined } from '@ant-design/icons';
 import {
 	Button,
@@ -29,21 +30,12 @@ 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 +64,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 +138,7 @@ function K8sDaemonSetsList({
 		if (quickFiltersLastUpdated !== -1) {
 			setCurrentPage(1);
 		}
-	}, [quickFiltersLastUpdated, setCurrentPage]);
+	}, [quickFiltersLastUpdated]);
 
 	const { featureFlags } = useAppContext();
 	const dotMetricsEnabled =
@@ -170,28 +191,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 +268,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 +378,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({
@@ -430,7 +459,7 @@ function K8sDaemonSetsList({
 	]);
 
 	const openDaemonSetInNewTab = (record: K8sDaemonSetsRowData): void => {
-		const newParams = new URLSearchParams(document.location.search);
+		const newParams = new URLSearchParams(searchParams);
 		newParams.set(
 			INFRA_MONITORING_K8S_PARAMS_KEYS.DAEMONSET_UID,
 			record.daemonsetUID,
@@ -454,6 +483,10 @@ function K8sDaemonSetsList({
 		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 +515,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 => (
@@ -578,10 +616,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 +650,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 +662,7 @@ function K8sDaemonSetsList({
 				category: InfraMonitoringEvents.DaemonSet,
 			});
 		},
-		[groupByFiltersData, setCurrentPage, setGroupBy],
+		[groupByFiltersData, searchParams, setSearchParams],
 	);
 
 	useEffect(() => {

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';
 // eslint-disable-next-line no-restricted-imports
-import { useSelector } from 'react-redux';
+import { useSelector } from 'react-redux'; // old code, TODO: fix this correctly
+import { useSearchParams } from 'react-router-dom-v5-compat';
 import { LoadingOutlined } from '@ant-design/icons';
 import {
 	Button,
@@ -16,34 +17,25 @@ 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 +64,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 +139,7 @@ function K8sDeploymentsList({
 		if (quickFiltersLastUpdated !== -1) {
 			setCurrentPage(1);
 		}
-	}, [quickFiltersLastUpdated, setCurrentPage]);
+	}, [quickFiltersLastUpdated]);
 
 	const { featureFlags } = useAppContext();
 	const dotMetricsEnabled =
@@ -171,28 +192,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 +269,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 +381,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({
@@ -436,7 +465,7 @@ function K8sDeploymentsList({
 	]);
 
 	const openDeploymentInNewTab = (record: K8sDeploymentsRowData): void => {
-		const newParams = new URLSearchParams(document.location.search);
+		const newParams = new URLSearchParams(searchParams);
 		newParams.set(
 			INFRA_MONITORING_K8S_PARAMS_KEYS.DEPLOYMENT_UID,
 			record.deploymentUID,
@@ -460,6 +489,10 @@ function K8sDeploymentsList({
 		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 +521,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 => (
@@ -584,10 +622,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 +657,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 +669,7 @@ function K8sDeploymentsList({
 				category: InfraMonitoringEvents.Deployment,
 			});
 		},
-		[groupByFiltersData, setCurrentPage, setGroupBy],
+		[groupByFiltersData, searchParams, setSearchParams],
 	);
 
 	useEffect(() => {

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';
 // eslint-disable-next-line no-restricted-imports
-import { useSelector } from 'react-redux';
+import { useSelector } from 'react-redux'; // old code, TODO: fix this correctly
+import { useSearchParams } from 'react-router-dom-v5-compat';
 import { LoadingOutlined } from '@ant-design/icons';
 import {
 	Button,
@@ -16,34 +17,25 @@ 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 +63,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 +133,7 @@ function K8sJobsList({
 		if (quickFiltersLastUpdated !== -1) {
 			setCurrentPage(1);
 		}
-	}, [quickFiltersLastUpdated, setCurrentPage]);
+	}, [quickFiltersLastUpdated]);
 
 	const { featureFlags } = useAppContext();
 	const dotMetricsEnabled =
@@ -167,28 +186,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 +256,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 +362,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({
@@ -403,7 +430,7 @@ function K8sJobsList({
 	}, [selectedJobUID, groupBy.length, jobsData, nestedJobsData]);
 
 	const openJobInNewTab = (record: K8sJobsRowData): void => {
-		const newParams = new URLSearchParams(document.location.search);
+		const newParams = new URLSearchParams(searchParams);
 		newParams.set(INFRA_MONITORING_K8S_PARAMS_KEYS.JOB_UID, record.jobUID);
 		openInNewTab(
 			buildAbsolutePath({
@@ -424,6 +451,10 @@ function K8sJobsList({
 		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 +483,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 => (
@@ -548,10 +584,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 +619,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 +630,7 @@ function K8sJobsList({
 				category: InfraMonitoringEvents.Job,
 			});
 		},
-		[groupByFiltersData, setCurrentPage, setGroupBy],
+		[groupByFiltersData, searchParams, setSearchParams],
 	);
 
 	useEffect(() => {

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';
 // eslint-disable-next-line no-restricted-imports
-import { useSelector } from 'react-redux';
+import { useSelector } from 'react-redux'; // old code, TODO: fix this correctly
+import { useSearchParams } from 'react-router-dom-v5-compat';
 import { LoadingOutlined } from '@ant-design/icons';
 import {
 	Button,
@@ -15,34 +16,25 @@ 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 +64,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 +137,7 @@ function K8sNamespacesList({
 		if (quickFiltersLastUpdated !== -1) {
 			setCurrentPage(1);
 		}
-	}, [quickFiltersLastUpdated, setCurrentPage]);
+	}, [quickFiltersLastUpdated]);
 
 	const { featureFlags } = useAppContext();
 	const dotMetricsEnabled =
@@ -170,28 +190,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 +267,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 +377,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({
@@ -433,7 +461,7 @@ function K8sNamespacesList({
 	]);
 
 	const openNamespaceInNewTab = (record: K8sNamespacesRowData): void => {
-		const newParams = new URLSearchParams(document.location.search);
+		const newParams = new URLSearchParams(searchParams);
 		newParams.set(
 			INFRA_MONITORING_K8S_PARAMS_KEYS.NAMESPACE_UID,
 			record.namespaceUID,
@@ -457,6 +485,10 @@ function K8sNamespacesList({
 		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 +517,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 => (
@@ -581,10 +618,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 +654,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 +665,7 @@ function K8sNamespacesList({
 				category: InfraMonitoringEvents.Namespace,
 			});
 		},
-		[groupByFiltersData, setCurrentPage, setGroupBy],
+		[groupByFiltersData, searchParams, setSearchParams],
 	);
 
 	useEffect(() => {

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';
 // eslint-disable-next-line no-restricted-imports
-import { useSelector } from 'react-redux';
+import { useSelector } from 'react-redux'; // old code, TODO: fix this correctly
+import { useSearchParams } from 'react-router-dom-v5-compat';
 import { LoadingOutlined } from '@ant-design/icons';
 import {
 	Button,
@@ -15,34 +16,25 @@ 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 +62,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 +131,7 @@ function K8sNodesList({
 		if (quickFiltersLastUpdated !== -1) {
 			setCurrentPage(1);
 		}
-	}, [quickFiltersLastUpdated, setCurrentPage]);
+	}, [quickFiltersLastUpdated]);
 
 	const { featureFlags } = useAppContext();
 	const dotMetricsEnabled =
@@ -166,28 +184,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 +261,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 +367,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({
@@ -414,7 +440,7 @@ function K8sNodesList({
 	}, [selectedNodeUID, groupBy.length, nodesData, nestedNodesData]);
 
 	const openNodeInNewTab = (record: K8sNodesRowData): void => {
-		const newParams = new URLSearchParams(document.location.search);
+		const newParams = new URLSearchParams(searchParams);
 		newParams.set(INFRA_MONITORING_K8S_PARAMS_KEYS.NODE_UID, record.nodeUID);
 		openInNewTab(
 			buildAbsolutePath({
@@ -435,6 +461,10 @@ function K8sNodesList({
 		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 +493,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 => (
@@ -560,31 +595,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 +641,7 @@ function K8sNodesList({
 				category: InfraMonitoringEvents.Node,
 			});
 		},
-		[groupByFiltersData, setCurrentPage, setGroupBy],
+		[groupByFiltersData, searchParams, setSearchParams],
 	);
 
 	useEffect(() => {

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';
 // eslint-disable-next-line no-restricted-imports
-import { useSelector } from 'react-redux';
+import { useSelector } from 'react-redux'; // old code, TODO: fix this correctly
+import { useSearchParams } from 'react-router-dom-v5-compat';
 import { LoadingOutlined } from '@ant-design/icons';
 import {
 	Button,
@@ -18,34 +19,25 @@ 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 +66,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 +153,7 @@ function K8sPodsList({
 		if (quickFiltersLastUpdated !== -1) {
 			setCurrentPage(1);
 		}
-	}, [quickFiltersLastUpdated, setCurrentPage]);
+	}, [quickFiltersLastUpdated]);
 
 	useEffect(() => {
 		const addedColumns = JSON.parse(get('k8sPodsAddedColumns') ?? '[]');
@@ -164,6 +172,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 +197,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 +295,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 +356,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 +377,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 +428,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 +457,7 @@ function K8sPodsList({
 				category: InfraMonitoringEvents.Pod,
 			});
 		},
-		[groupByFiltersData, setCurrentPage, setGroupBy],
+		[groupByFiltersData, searchParams, setSearchParams],
 	);
 
 	useEffect(() => {
@@ -465,7 +498,7 @@ function K8sPodsList({
 	}, [selectedRowData, fetchGroupedByRowData]);
 
 	const openPodInNewTab = (record: K8sPodsRowData): void => {
-		const newParams = new URLSearchParams(document.location.search);
+		const newParams = new URLSearchParams(searchParams);
 		newParams.set(INFRA_MONITORING_K8S_PARAMS_KEYS.POD_UID, record.podUID);
 		openInNewTab(
 			buildAbsolutePath({
@@ -485,6 +518,10 @@ function K8sPodsList({
 		}
 		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 +536,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 +588,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 +607,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 => (

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';
 // eslint-disable-next-line no-restricted-imports
-import { useSelector } from 'react-redux';
+import { useSelector } from 'react-redux'; // old code, TODO: fix this correctly
+import { useSearchParams } from 'react-router-dom-v5-compat';
 import { LoadingOutlined } from '@ant-design/icons';
 import {
 	Button,
@@ -16,34 +17,25 @@ 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 +50,6 @@ import {
 
 import '../InfraMonitoringK8s.styles.scss';
 import './K8sStatefulSetsList.styles.scss';
-
 function K8sStatefulSetsList({
 	isFiltersVisible,
 	handleFilterVisibilityChange,
@@ -72,26 +63,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 +138,7 @@ function K8sStatefulSetsList({
 		if (quickFiltersLastUpdated !== -1) {
 			setCurrentPage(1);
 		}
-	}, [quickFiltersLastUpdated, setCurrentPage]);
+	}, [quickFiltersLastUpdated]);
 
 	const { featureFlags } = useAppContext();
 	const dotMetricsEnabled =
@@ -171,28 +191,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 +268,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 +380,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({
@@ -434,7 +462,7 @@ function K8sStatefulSetsList({
 	]);
 
 	const openStatefulSetInNewTab = (record: K8sStatefulSetsRowData): void => {
-		const newParams = new URLSearchParams(document.location.search);
+		const newParams = new URLSearchParams(searchParams);
 		newParams.set(
 			INFRA_MONITORING_K8S_PARAMS_KEYS.STATEFULSET_UID,
 			record.statefulsetUID,
@@ -458,6 +486,10 @@ function K8sStatefulSetsList({
 		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 +518,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 => (
@@ -582,10 +619,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 +654,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 +665,7 @@ function K8sStatefulSetsList({
 				category: InfraMonitoringEvents.StatefulSet,
 			});
 		},
-		[groupByFiltersData, setCurrentPage, setGroupBy],
+		[groupByFiltersData, searchParams, setSearchParams],
 	);
 
 	useEffect(() => {

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';
 // eslint-disable-next-line no-restricted-imports
-import { useSelector } from 'react-redux';
+import { useSelector } from 'react-redux'; // old code, TODO: fix this correctly
+import { useSearchParams } from 'react-router-dom-v5-compat';
 import { LoadingOutlined } from '@ant-design/icons';
 import {
 	Button,
@@ -16,30 +17,25 @@ 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';
@@ -48,15 +44,12 @@ import {
 	formatDataForTable,
 	getK8sVolumesListColumns,
 	getK8sVolumesListQuery,
-	getVolumeListGroupedByRowDataQueryKey,
-	getVolumesListQueryKey,
 	K8sVolumesRowData,
 } from './utils';
 import VolumeDetails from './VolumeDetails';
 
 import '../InfraMonitoringK8s.styles.scss';
 import './K8sVolumesList.styles.scss';
-
 function K8sVolumesList({
 	isFiltersVisible,
 	handleFilterVisibilityChange,
@@ -70,21 +63,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,
@@ -111,7 +138,7 @@ function K8sVolumesList({
 		if (quickFiltersLastUpdated !== -1) {
 			setCurrentPage(1);
 		}
-	}, [quickFiltersLastUpdated, setCurrentPage]);
+	}, [quickFiltersLastUpdated]);
 
 	const { featureFlags } = useAppContext();
 	const dotMetricsEnabled =
@@ -164,31 +191,11 @@ 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]);
 
-	const groupedByRowDataQueryKey = useMemo(
-		() =>
-			getVolumeListGroupedByRowDataQueryKey(
-				selectedRowData?.groupedByMeta,
-				queryFilters,
-				orderBy,
-				groupBy,
-				minTime,
-				maxTime,
-			),
-		[
-			selectedRowData?.groupedByMeta,
-			queryFilters,
-			orderBy,
-			groupBy,
-			minTime,
-			maxTime,
-		],
-	);
-
 	const {
 		data: groupedByRowData,
 		isFetching: isFetchingGroupedByRowData,
@@ -198,7 +205,7 @@ function K8sVolumesList({
 	} = useGetK8sVolumesList(
 		fetchGroupedByRowDataQuery as K8sVolumesListPayload,
 		{
-			queryKey: groupedByRowDataQueryKey,
+			queryKey: ['volumeList', fetchGroupedByRowDataQuery],
 			enabled: !!fetchGroupedByRowDataQuery && !!selectedRowData,
 		},
 		undefined,
@@ -235,7 +242,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;
@@ -243,28 +250,6 @@ function K8sVolumesList({
 		return queryPayload;
 	}, [pageSize, currentPage, queryFilters, minTime, maxTime, orderBy, groupBy]);
 
-	const volumesListQueryKey = useMemo(() => {
-		return getVolumesListQueryKey(
-			selectedVolumeUID,
-			pageSize,
-			currentPage,
-			queryFilters,
-			orderBy,
-			groupBy,
-			minTime,
-			maxTime,
-		);
-	}, [
-		selectedVolumeUID,
-		pageSize,
-		currentPage,
-		queryFilters,
-		groupBy,
-		orderBy,
-		minTime,
-		maxTime,
-	]);
-
 	const formattedGroupedByVolumesData = useMemo(
 		() =>
 			formatDataForTable(groupedByRowData?.payload?.data?.records || [], groupBy),
@@ -281,7 +266,7 @@ function K8sVolumesList({
 	const { data, isFetching, isLoading, isError } = useGetK8sVolumesList(
 		query as K8sVolumesListPayload,
 		{
-			queryKey: volumesListQueryKey,
+			queryKey: ['volumeList', query],
 			enabled: !!query,
 		},
 		undefined,
@@ -330,15 +315,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({
@@ -396,7 +392,7 @@ function K8sVolumesList({
 	}, [selectedVolumeUID, volumesData, groupBy.length, nestedVolumesData]);
 
 	const openVolumeInNewTab = (record: K8sVolumesRowData): void => {
-		const newParams = new URLSearchParams(document.location.search);
+		const newParams = new URLSearchParams(searchParams);
 		newParams.set(INFRA_MONITORING_K8S_PARAMS_KEYS.VOLUME_UID, record.volumeUID);
 		openInNewTab(
 			buildAbsolutePath({
@@ -417,6 +413,10 @@ function K8sVolumesList({
 		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);
 		}
@@ -445,6 +445,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 => (
@@ -541,6 +546,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(
@@ -561,6 +573,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, {
@@ -569,7 +585,7 @@ function K8sVolumesList({
 				category: InfraMonitoringEvents.Volumes,
 			});
 		},
-		[groupByFiltersData?.payload?.attributeKeys, setCurrentPage, setGroupBy],
+		[groupByFiltersData?.payload?.attributeKeys, searchParams, setSearchParams],
 	);
 
 	useEffect(() => {

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,77 +75,9 @@ export const getK8sVolumesListQuery = (): K8sVolumesListPayload => ({
 		items: [],
 		op: 'and',
 	},
-	orderBy: { columnName: 'usage', order: 'desc' },
+	orderBy: { columnName: 'cpu', order: 'desc' },
 });
 
-export const getVolumeListGroupedByRowDataQueryKey = (
-	groupedByMeta: K8sVolumesData['meta'] | undefined,
-	queryFilters: IBuilderQuery['filters'],
-	orderBy: { columnName: string; order: 'asc' | 'desc' } | null,
-	groupBy: IBuilderQuery['groupBy'],
-	minTime: number,
-	maxTime: number,
-): (string | undefined)[] => {
-	// When we have grouped by metadata defined
-	// We need to leave out the min/max time
-	// Otherwise it will cause a loop
-	const groupedByMetaStr = JSON.stringify(groupedByMeta || undefined) ?? '';
-	if (groupedByMetaStr) {
-		return [
-			'volumeList',
-			JSON.stringify(queryFilters),
-			JSON.stringify(orderBy),
-			JSON.stringify(groupBy),
-			groupedByMetaStr,
-		];
-	}
-	return [
-		'volumeList',
-		JSON.stringify(queryFilters),
-		JSON.stringify(orderBy),
-		JSON.stringify(groupBy),
-		groupedByMetaStr,
-		String(minTime),
-		String(maxTime),
-	];
-};
-
-export const getVolumesListQueryKey = (
-	selectedVolumeUID: string | null,
-	pageSize: number,
-	currentPage: number,
-	queryFilters: IBuilderQuery['filters'],
-	orderBy: { columnName: string; order: 'asc' | 'desc' } | null,
-	groupBy: IBuilderQuery['groupBy'],
-	minTime: number,
-	maxTime: number,
-): (string | undefined)[] => {
-	// When selected volume is defined
-	// We need to leave out the min/max time
-	// Otherwise it will cause a loop
-	if (selectedVolumeUID) {
-		return [
-			'volumeList',
-			String(pageSize),
-			String(currentPage),
-			JSON.stringify(queryFilters),
-			JSON.stringify(orderBy),
-			JSON.stringify(groupBy),
-		];
-	}
-
-	return [
-		'volumeList',
-		String(pageSize),
-		String(currentPage),
-		JSON.stringify(queryFilters),
-		JSON.stringify(orderBy),
-		JSON.stringify(groupBy),
-		String(minTime),
-		String(maxTime),
-	];
-};
-
 const columnsConfig = [
 	{
 		title: <div className="column-header-left pvc-name-header">PVC Name</div>,

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,93 +1,30 @@
+import setupCommonMocks from '../commonMocks';
+
+setupCommonMocks();
+
 import { QueryClient, QueryClientProvider } from 'react-query';
 // eslint-disable-next-line no-restricted-imports
-import { MemoryRouter } from 'react-router-dom-v5-compat';
+import { Provider } from 'react-redux';
+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 { QueryBuilderProvider } from 'providers/QueryBuilder';
-// eslint-disable-next-line no-restricted-imports
-import { applyMiddleware, legacy_createStore as createStore } from 'redux';
-import thunk from 'redux-thunk';
-import reducers from 'store/reducers';
-import { act, render, screen, userEvent, waitFor } from 'tests/test-utils';
-import { UPDATE_TIME_INTERVAL } from 'types/actions/globalTime';
+import store from 'store';
 import { LicenseResModel } from 'types/api/licensesV3/getActive';
 
-import { INFRA_MONITORING_K8S_PARAMS_KEYS } from '../../constants';
+const queryClient = new QueryClient({
+	defaultOptions: {
+		queries: {
+			retry: false,
+			cacheTime: 0,
+		},
+	},
+});
 
 const SERVER_URL = 'http://localhost/api';
 
-// jsdom does not implement IntersectionObserver — provide a no-op stub
-const mockObserver = {
-	observe: jest.fn(),
-	unobserve: jest.fn(),
-	disconnect: jest.fn(),
-};
-global.IntersectionObserver = jest
-	.fn()
-	.mockImplementation(() => mockObserver) as any;
-
-const mockVolume = {
-	persistentVolumeClaimName: 'test-pvc',
-	volumeAvailable: 1000000,
-	volumeCapacity: 5000000,
-	volumeInodes: 100,
-	volumeInodesFree: 50,
-	volumeInodesUsed: 50,
-	volumeUsage: 4000000,
-	meta: {
-		k8s_cluster_name: 'test-cluster',
-		k8s_namespace_name: 'test-namespace',
-		k8s_node_name: 'test-node',
-		k8s_persistentvolumeclaim_name: 'test-pvc',
-		k8s_pod_name: 'test-pod',
-		k8s_pod_uid: 'test-pod-uid',
-		k8s_statefulset_name: '',
-	},
-};
-
-const mockVolumesResponse = {
-	status: 'success',
-	data: {
-		type: '',
-		records: [mockVolume],
-		groups: null,
-		total: 1,
-		sentAnyHostMetricsData: false,
-		isSendingK8SAgentMetrics: false,
-	},
-};
-
-/** Renders K8sVolumesList with a real Redux store so dispatched actions affect state. */
-function renderWithRealStore(
-	initialEntries?: Record<string, any>,
-): { testStore: ReturnType<typeof createStore> } {
-	const testStore = createStore(reducers, applyMiddleware(thunk as any));
-	const queryClient = new QueryClient({
-		defaultOptions: { queries: { retry: false } },
-	});
-
-	render(
-		<NuqsTestingAdapter searchParams={initialEntries}>
-			<QueryClientProvider client={queryClient}>
-				<QueryBuilderProvider>
-					<MemoryRouter>
-						<K8sVolumesList
-							isFiltersVisible={false}
-							handleFilterVisibilityChange={jest.fn()}
-							quickFiltersLastUpdated={-1}
-						/>
-					</MemoryRouter>
-				</QueryBuilderProvider>
-			</QueryClientProvider>
-		</NuqsTestingAdapter>,
-	);
-
-	return { testStore };
-}
-
 describe('K8sVolumesList - useGetAggregateKeys Category Regression', () => {
 	let requestsMade: Array<{
 		url: string;
@@ -97,6 +34,7 @@ describe('K8sVolumesList - useGetAggregateKeys Category Regression', () => {
 
 	beforeEach(() => {
 		requestsMade = [];
+		queryClient.clear();
 
 		server.use(
 			rest.get(`${SERVER_URL}/v3/autocomplete/attribute_keys`, (req, res, ctx) => {
@@ -142,7 +80,19 @@ describe('K8sVolumesList - useGetAggregateKeys Category Regression', () => {
 	});
 
 	it('should call aggregate keys API with k8s_volume_capacity', async () => {
-		renderWithRealStore();
+		render(
+			<QueryClientProvider client={queryClient}>
+				<Provider store={store}>
+					<MemoryRouter>
+						<K8sVolumesList
+							isFiltersVisible={false}
+							handleFilterVisibilityChange={jest.fn()}
+							quickFiltersLastUpdated={-1}
+						/>
+					</MemoryRouter>
+				</Provider>
+			</QueryClientProvider>,
+		);
 
 		await waitFor(() => {
 			expect(requestsMade.length).toBeGreaterThan(0);
@@ -179,7 +129,19 @@ describe('K8sVolumesList - useGetAggregateKeys Category Regression', () => {
 				activeLicense: (null as unknown) as LicenseResModel,
 			} as IAppContext);
 
-		renderWithRealStore();
+		render(
+			<QueryClientProvider client={queryClient}>
+				<Provider store={store}>
+					<MemoryRouter>
+						<K8sVolumesList
+							isFiltersVisible={false}
+							handleFilterVisibilityChange={jest.fn()}
+							quickFiltersLastUpdated={-1}
+						/>
+					</MemoryRouter>
+				</Provider>
+			</QueryClientProvider>,
+		);
 
 		await waitFor(() => {
 			expect(requestsMade.length).toBeGreaterThan(0);
@@ -198,193 +160,3 @@ describe('K8sVolumesList - useGetAggregateKeys Category Regression', () => {
 		expect(aggregateAttribute).toBe('k8s.volume.capacity');
 	});
 });
-
-describe('K8sVolumesList', () => {
-	beforeEach(() => {
-		server.use(
-			rest.post('http://localhost/api/v1/pvcs/list', (_req, res, ctx) =>
-				res(ctx.status(200), ctx.json(mockVolumesResponse)),
-			),
-			rest.get(
-				'http://localhost/api/v3/autocomplete/attribute_keys',
-				(_req, res, ctx) =>
-					res(ctx.status(200), ctx.json({ data: { attributeKeys: [] } })),
-			),
-		);
-	});
-
-	it('renders volume rows from API response', async () => {
-		renderWithRealStore();
-
-		await waitFor(async () => {
-			const elements = await screen.findAllByText('test-pvc');
-
-			expect(elements.length).toBeGreaterThan(0);
-		});
-	});
-
-	it('opens VolumeDetails when a volume row is clicked', async () => {
-		const user = userEvent.setup();
-		renderWithRealStore();
-
-		const pvcCells = await screen.findAllByText('test-pvc');
-		expect(pvcCells.length).toBeGreaterThan(0);
-
-		const row = pvcCells[0].closest('tr');
-		expect(row).not.toBeNull();
-		await user.click(row!);
-
-		await waitFor(async () => {
-			const cells = await screen.findAllByText('test-pvc');
-			expect(cells.length).toBeGreaterThan(1);
-		});
-	});
-
-	it.skip('closes VolumeDetails when the close button is clicked', async () => {
-		const user = userEvent.setup();
-		renderWithRealStore();
-
-		const pvcCells = await screen.findAllByText('test-pvc');
-		expect(pvcCells.length).toBeGreaterThan(0);
-
-		const row = pvcCells[0].closest('tr');
-		await user.click(row!);
-
-		await waitFor(() => {
-			expect(screen.getByRole('button', { name: 'Close' })).toBeInTheDocument();
-		});
-
-		await user.click(screen.getByRole('button', { name: 'Close' }));
-
-		await waitFor(() => {
-			expect(
-				screen.queryByRole('button', { name: 'Close' }),
-			).not.toBeInTheDocument();
-		});
-	});
-
-	it('does not re-fetch the volumes list when time range changes after selecting a volume', async () => {
-		const user = userEvent.setup();
-		let apiCallCount = 0;
-		server.use(
-			rest.post('http://localhost/api/v1/pvcs/list', async (_req, res, ctx) => {
-				apiCallCount += 1;
-				return res(ctx.status(200), ctx.json(mockVolumesResponse));
-			}),
-		);
-
-		const { testStore } = renderWithRealStore();
-
-		await waitFor(() => expect(apiCallCount).toBe(1));
-
-		const pvcCells = await screen.findAllByText('test-pvc');
-		const row = pvcCells[0].closest('tr');
-		await user.click(row!);
-		await waitFor(async () => {
-			const cells = await screen.findAllByText('test-pvc');
-			expect(cells.length).toBeGreaterThan(1);
-		});
-
-		// Wait for nuqs URL state to fully propagate to the component
-		// The selectedVolumeUID is managed via nuqs (async URL state),
-		// so we need to ensure the state has settled before dispatching time changes
-		await act(async () => {
-			await new Promise((resolve) => {
-				setTimeout(resolve, 0);
-			});
-		});
-
-		const countAfterClick = apiCallCount;
-
-		// There's a specific component causing the min/max time to be updated
-		// After the volume loads, it triggers the change again
-		// And then the query to fetch data for the selected volume enters in a loop
-		act(() => {
-			testStore.dispatch({
-				type: UPDATE_TIME_INTERVAL,
-				payload: {
-					minTime: Date.now() * 1000000 - 30 * 60 * 1000 * 1000000,
-					maxTime: Date.now() * 1000000,
-					selectedTime: '30m',
-				},
-			} as any);
-		});
-
-		// Allow any potential re-fetch to settle
-		await new Promise((resolve) => {
-			setTimeout(resolve, 500);
-		});
-
-		expect(apiCallCount).toBe(countAfterClick);
-	});
-
-	it('does not re-fetch groupedByRowData when time range changes after expanding a volume row with groupBy', async () => {
-		const user = userEvent.setup();
-		const groupByValue = [{ key: 'k8s_namespace_name' }];
-
-		let groupedByRowDataCallCount = 0;
-		server.use(
-			rest.post('http://localhost/api/v1/pvcs/list', async (req, res, ctx) => {
-				const body = await req.json();
-				// Check for both underscore and dot notation keys since dotMetricsEnabled
-				// may be true or false depending on test order
-				const isGroupedByRowDataRequest = body.filters?.items?.some(
-					(item: { key?: { key?: string }; value?: string }) =>
-						(item.key?.key === 'k8s_namespace_name' ||
-							item.key?.key === 'k8s.namespace.name') &&
-						item.value === 'test-namespace',
-				);
-				if (isGroupedByRowDataRequest) {
-					groupedByRowDataCallCount += 1;
-				}
-				return res(ctx.status(200), ctx.json(mockVolumesResponse));
-			}),
-			rest.get(
-				'http://localhost/api/v3/autocomplete/attribute_keys',
-				(_req, res, ctx) =>
-					res(
-						ctx.status(200),
-						ctx.json({
-							data: {
-								attributeKeys: [{ key: 'k8s_namespace_name', dataType: 'string' }],
-							},
-						}),
-					),
-			),
-		);
-
-		const { testStore } = renderWithRealStore({
-			[INFRA_MONITORING_K8S_PARAMS_KEYS.GROUP_BY]: JSON.stringify(groupByValue),
-		});
-
-		await waitFor(async () => {
-			const elements = await screen.findAllByText('test-namespace');
-			return expect(elements.length).toBeGreaterThan(0);
-		});
-
-		const row = (await screen.findAllByText('test-namespace'))[0].closest('tr');
-		expect(row).not.toBeNull();
-		user.click(row as HTMLElement);
-		await waitFor(() => expect(groupedByRowDataCallCount).toBe(1));
-
-		const countAfterExpand = groupedByRowDataCallCount;
-
-		act(() => {
-			testStore.dispatch({
-				type: UPDATE_TIME_INTERVAL,
-				payload: {
-					minTime: Date.now() * 1000000 - 30 * 60 * 1000 * 1000000,
-					maxTime: Date.now() * 1000000,
-					selectedTime: '30m',
-				},
-			} as any);
-		});
-
-		// Allow any potential re-fetch to settle
-		await new Promise((resolve) => {
-			setTimeout(resolve, 500);
-		});
-
-		expect(groupedByRowDataCallCount).toBe(countAfterExpand);
-	});
-});

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;
 		}
 	}

frontend/src/container/InfraMonitoringK8s/hooks.ts

@@ -1,224 +0,0 @@
-import { VIEWS } from 'components/HostMetricsDetail/constants';
-import {
-	Options,
-	parseAsInteger,
-	parseAsJson,
-	parseAsString,
-	useQueryState,
-	UseQueryStateReturn,
-} from 'nuqs';
-import { BaseAutocompleteData } from 'types/api/queryBuilder/queryAutocompleteResponse';
-import {
-	IBuilderQuery,
-	TagFilter,
-} from 'types/api/queryBuilder/queryBuilderData';
-import { parseAsJsonNoValidate } from 'utils/nuqsParsers';
-
-import { INFRA_MONITORING_K8S_PARAMS_KEYS, K8sCategories } from './constants';
-import { orderBySchema, OrderBySchemaType } from './schemas';
-
-const defaultFilters: IBuilderQuery['filters'] = { items: [], op: 'and' };
-const defaultNuqsOptions: Options = {
-	history: 'push',
-};
-
-export const useInfraMonitoringCurrentPage = (): UseQueryStateReturn<
-	number,
-	number
-> =>
-	useQueryState(
-		INFRA_MONITORING_K8S_PARAMS_KEYS.CURRENT_PAGE,
-		parseAsInteger.withDefault(1).withOptions(defaultNuqsOptions),
-	);
-
-export const useInfraMonitoringOrderBy = (): UseQueryStateReturn<
-	OrderBySchemaType,
-	OrderBySchemaType
-> =>
-	useQueryState(
-		INFRA_MONITORING_K8S_PARAMS_KEYS.ORDER_BY,
-		parseAsJson(orderBySchema).withOptions(defaultNuqsOptions),
-	);
-
-export const useInfraMonitoringOrderByHosts = (): UseQueryStateReturn<
-	OrderBySchemaType,
-	OrderBySchemaType
-> =>
-	useQueryState(
-		INFRA_MONITORING_K8S_PARAMS_KEYS.ORDER_BY,
-		parseAsJson(orderBySchema)
-			.withDefault({
-				columnName: 'cpu',
-				order: 'desc',
-			})
-			.withOptions(defaultNuqsOptions),
-	);
-
-export const useInfraMonitoringGroupBy = (): UseQueryStateReturn<
-	BaseAutocompleteData[],
-	[]
-> =>
-	useQueryState(
-		INFRA_MONITORING_K8S_PARAMS_KEYS.GROUP_BY,
-		parseAsJsonNoValidate<IBuilderQuery['groupBy']>()
-			.withDefault([])
-			.withOptions(defaultNuqsOptions),
-	);
-
-export const useInfraMonitoringView = (): UseQueryStateReturn<string, string> =>
-	useQueryState(
-		INFRA_MONITORING_K8S_PARAMS_KEYS.VIEW,
-		parseAsString.withDefault(VIEWS.METRICS).withOptions(defaultNuqsOptions),
-	);
-
-export const useInfraMonitoringLogFilters = (): UseQueryStateReturn<
-	TagFilter,
-	undefined
-> =>
-	useQueryState(
-		INFRA_MONITORING_K8S_PARAMS_KEYS.LOG_FILTERS,
-		parseAsJsonNoValidate<IBuilderQuery['filters']>().withOptions(
-			defaultNuqsOptions,
-		),
-	);
-
-export const useInfraMonitoringTracesFilters = (): UseQueryStateReturn<
-	TagFilter,
-	undefined
-> =>
-	useQueryState(
-		INFRA_MONITORING_K8S_PARAMS_KEYS.TRACES_FILTERS,
-		parseAsJsonNoValidate<IBuilderQuery['filters']>().withOptions(
-			defaultNuqsOptions,
-		),
-	);
-
-export const useInfraMonitoringEventsFilters = (): UseQueryStateReturn<
-	TagFilter,
-	undefined
-> =>
-	useQueryState(
-		INFRA_MONITORING_K8S_PARAMS_KEYS.EVENTS_FILTERS,
-		parseAsJsonNoValidate<IBuilderQuery['filters']>().withOptions(
-			defaultNuqsOptions,
-		),
-	);
-
-export const useInfraMonitoringCategory = (): UseQueryStateReturn<
-	string,
-	string
-> =>
-	useQueryState(
-		INFRA_MONITORING_K8S_PARAMS_KEYS.CATEGORY,
-		parseAsString.withDefault(K8sCategories.PODS).withOptions(defaultNuqsOptions),
-	);
-
-export const useInfraMonitoringFilters = (): UseQueryStateReturn<
-	string,
-	string
-> =>
-	useQueryState(
-		INFRA_MONITORING_K8S_PARAMS_KEYS.FILTERS,
-		parseAsString.withDefault('').withOptions(defaultNuqsOptions),
-	);
-
-export const useInfraMonitoringFiltersK8s = (): UseQueryStateReturn<
-	TagFilter,
-	undefined
-> =>
-	useQueryState(
-		INFRA_MONITORING_K8S_PARAMS_KEYS.FILTERS,
-		parseAsJsonNoValidate<TagFilter>().withOptions(defaultNuqsOptions),
-	);
-
-export const useInfraMonitoringFiltersHosts = (): UseQueryStateReturn<
-	TagFilter,
-	TagFilter | undefined
-> =>
-	useQueryState(
-		INFRA_MONITORING_K8S_PARAMS_KEYS.FILTERS,
-		parseAsJsonNoValidate<IBuilderQuery['filters']>()
-			.withDefault(defaultFilters)
-			.withOptions(defaultNuqsOptions),
-	);
-
-export const useInfraMonitoringClusterName = (): UseQueryStateReturn<
-	string,
-	string
-> =>
-	useQueryState(
-		INFRA_MONITORING_K8S_PARAMS_KEYS.CLUSTER_NAME,
-		parseAsString.withDefault('').withOptions(defaultNuqsOptions),
-	);
-
-export const useInfraMonitoringDaemonSetUID = (): UseQueryStateReturn<
-	string,
-	undefined
-> =>
-	useQueryState(
-		INFRA_MONITORING_K8S_PARAMS_KEYS.DAEMONSET_UID,
-		parseAsString.withOptions(defaultNuqsOptions),
-	);
-
-export const useInfraMonitoringDeploymentUID = (): UseQueryStateReturn<
-	string,
-	undefined
-> =>
-	useQueryState(
-		INFRA_MONITORING_K8S_PARAMS_KEYS.DEPLOYMENT_UID,
-		parseAsString.withOptions(defaultNuqsOptions),
-	);
-
-export const useInfraMonitoringJobUID = (): UseQueryStateReturn<
-	string,
-	undefined
-> =>
-	useQueryState(
-		INFRA_MONITORING_K8S_PARAMS_KEYS.JOB_UID,
-		parseAsString.withOptions(defaultNuqsOptions),
-	);
-
-export const useInfraMonitoringNamespaceUID = (): UseQueryStateReturn<
-	string,
-	undefined
-> =>
-	useQueryState(
-		INFRA_MONITORING_K8S_PARAMS_KEYS.NAMESPACE_UID,
-		parseAsString.withOptions(defaultNuqsOptions),
-	);
-
-export const useInfraMonitoringNodeUID = (): UseQueryStateReturn<
-	string,
-	undefined
-> =>
-	useQueryState(
-		INFRA_MONITORING_K8S_PARAMS_KEYS.NODE_UID,
-		parseAsString.withOptions(defaultNuqsOptions),
-	);
-
-export const useInfraMonitoringPodUID = (): UseQueryStateReturn<
-	string,
-	undefined
-> =>
-	useQueryState(
-		INFRA_MONITORING_K8S_PARAMS_KEYS.POD_UID,
-		parseAsString.withOptions(defaultNuqsOptions),
-	);
-
-export const useInfraMonitoringStatefulSetUID = (): UseQueryStateReturn<
-	string,
-	undefined
-> =>
-	useQueryState(
-		INFRA_MONITORING_K8S_PARAMS_KEYS.STATEFULSET_UID,
-		parseAsString.withOptions(defaultNuqsOptions),
-	);
-
-export const useInfraMonitoringVolumeUID = (): UseQueryStateReturn<
-	string,
-	undefined
-> =>
-	useQueryState(
-		INFRA_MONITORING_K8S_PARAMS_KEYS.VOLUME_UID,
-		parseAsString.withOptions(defaultNuqsOptions),
-	);

frontend/src/container/InfraMonitoringK8s/schemas.ts

@@ -1,10 +0,0 @@
-import { z } from 'zod';
-
-export const orderBySchema = z
-	.object({
-		columnName: z.string(),
-		order: z.enum(['asc', 'desc']),
-	})
-	.nullable();
-
-export type OrderBySchemaType = z.infer<typeof orderBySchema>;

frontend/src/container/InfraMonitoringK8s/utils.tsx

@@ -1,6 +1,7 @@
 import { useCallback, useEffect, useMemo, useState } from 'react';
 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 get from 'api/browser/localstorage/get';
 import set from 'api/browser/localstorage/set';
 import {
@@ -16,7 +17,6 @@ import {
 	ValidateColumnValueWrapper,
 } from './commonUtils';
 import { DEFAULT_PAGE_SIZE, K8sCategory } from './constants';
-import { OrderBySchemaType } from './schemas';
 
 import './InfraMonitoringK8s.styles.scss';
 
@@ -148,7 +148,7 @@ export const dummyColumnConfig = {
 	className: 'column column-dummy',
 };
 
-const columnsConfig: ColumnType<K8sPodsRowData>[] = [
+const columnsConfig = [
 	{
 		title: <div className="column-header pod-name-header">Pod Name</div>,
 		dataIndex: 'podName',
@@ -231,7 +231,7 @@ const columnsConfig: ColumnType<K8sPodsRowData>[] = [
 	// },
 ];
 
-export const namespaceColumnConfig: ColumnType<K8sPodsRowData> = {
+export const namespaceColumnConfig = {
 	title: <div className="column-header">Namespace</div>,
 	dataIndex: 'namespace',
 	key: 'namespace',
@@ -242,7 +242,7 @@ export const namespaceColumnConfig: ColumnType<K8sPodsRowData> = {
 	className: 'column column-namespace',
 };
 
-export const nodeColumnConfig: ColumnType<K8sPodsRowData> = {
+export const nodeColumnConfig = {
 	title: <div className="column-header">Node</div>,
 	dataIndex: 'node',
 	key: 'node',
@@ -253,7 +253,7 @@ export const nodeColumnConfig: ColumnType<K8sPodsRowData> = {
 	className: 'column column-node',
 };
 
-export const clusterColumnConfig: ColumnType<K8sPodsRowData> = {
+export const clusterColumnConfig = {
 	title: <div className="column-header">Cluster</div>,
 	dataIndex: 'cluster',
 	key: 'cluster',
@@ -264,7 +264,7 @@ export const clusterColumnConfig: ColumnType<K8sPodsRowData> = {
 	className: 'column column-cluster',
 };
 
-export const columnConfigMap: Record<string, ColumnType<K8sPodsRowData>> = {
+export const columnConfigMap = {
 	namespace: namespaceColumnConfig,
 	node: nodeColumnConfig,
 	cluster: clusterColumnConfig,
@@ -273,9 +273,8 @@ export const columnConfigMap: Record<string, ColumnType<K8sPodsRowData>> = {
 export const getK8sPodsListColumns = (
 	addedColumns: IEntityColumn[],
 	groupBy: IBuilderQuery['groupBy'],
-	defaultOrderBy: OrderBySchemaType,
 ): ColumnType<K8sPodsRowData>[] => {
-	const updatedColumnsConfig: ColumnType<K8sPodsRowData>[] = [...columnsConfig];
+	const updatedColumnsConfig = [...columnsConfig];
 
 	for (const column of addedColumns) {
 		const config = columnConfigMap[column.id as keyof typeof columnConfigMap];
@@ -294,14 +293,7 @@ export const getK8sPodsListColumns = (
 		return filteredColumns as ColumnType<K8sPodsRowData>[];
 	}
 
-	for (const column of updatedColumnsConfig) {
-		if (column.sorter && column.key === defaultOrderBy?.columnName) {
-			column.defaultSortOrder =
-				defaultOrderBy?.order === 'asc' ? 'ascend' : 'descend';
-		}
-	}
-
-	return updatedColumnsConfig;
+	return updatedColumnsConfig as ColumnType<K8sPodsRowData>[];
 };
 
 const dotToUnder: Record<string, keyof K8sPodsData['meta']> = {