remove redundant error in prepareQueryRangeV5

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

.github/CODEOWNERS

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

.github/workflows/integrationci.yaml

@@ -51,12 +51,9 @@ jobs:
           - alerts
           - ingestionkeys
           - rootuser
-          - serviceaccount
         sqlstore-provider:
           - postgres
           - sqlite
-        sqlite-mode:
-          - wal
         clickhouse-version:
           - 25.5.6
           - 25.12.5
@@ -104,7 +101,6 @@ jobs:
             --basetemp=./tmp/ \
             src/${{matrix.src}} \
             --sqlstore-provider ${{matrix.sqlstore-provider}} \
-            --sqlite-mode ${{matrix.sqlite-mode}} \
             --postgres-version ${{matrix.postgres-version}} \
             --clickhouse-version ${{matrix.clickhouse-version}} \
             --schema-migrator-version ${{matrix.schema-migrator-version}}

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

cmd/enterprise/server.go

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

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: wal
-    # The timeout for the sqlite database to wait for a lock.
+    # Mode is the mode to use for the sqlite database.
+    mode: delete
+    # 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:
@@ -354,13 +352,3 @@ identn:
   impersonation:
     # toggle impersonation identN, when enabled, all requests will impersonate the root user
     enabled: false
-
-##################### Service Account #####################
-serviceaccount:
-  email:
-    # email domain for the service account principal
-    domain: signozserviceaccount.com
-
-  analytics:
-    # toggle service account analytics
-    enabled: true

docs/contributing/go/integration.md

@@ -193,7 +193,6 @@ uv run pytest --basetemp=./tmp/ -vv --reuse src/passwordauthn/01_register.py::te
 Tests can be configured using pytest options:
 
 - `--sqlstore-provider` - Choose database provider (default: postgres)
-- `--sqlite-mode` - SQLite journal mode: `delete` or `wal` (default: delete). Only relevant when `--sqlstore-provider=sqlite`.
 - `--postgres-version` - PostgreSQL version (default: 15)
 - `--clickhouse-version` - ClickHouse version (default: 25.5.6)
 - `--zookeeper-version` - Zookeeper version (default: 3.7.1)
@@ -203,6 +202,7 @@ Example:
 uv run pytest --basetemp=./tmp/ -vv --reuse --sqlstore-provider=postgres --postgres-version=14 src/auth/
 ```
 
+
 ## What should I remember?
 
 - **Always use the `--reuse` flag** when setting up the environment to keep containers running
@@ -213,4 +213,3 @@ uv run pytest --basetemp=./tmp/ -vv --reuse --sqlstore-provider=postgres --postg
 - **Use descriptive test names** that clearly indicate what is being tested
 - **Leverage fixtures** for common setup and authentication
 - **Test both success and failure scenarios** to ensure robust functionality
-- **`--sqlite-mode=wal` does not work on macOS.** The integration test environment runs SigNoz inside a Linux container with the SQLite database file mounted from the macOS host. WAL mode requires shared memory between connections, and connections crossing the VM boundary (macOS host ↔ Linux container) cannot share the WAL index, resulting in `SQLITE_IOERR_SHORT_READ`. WAL mode is tested in CI on Linux only.

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

@@ -32,7 +32,7 @@ func (s Seasonality) IsValid() bool {
 }
 
 type AnomaliesRequest struct {
-	Params      *qbtypes.QueryRangeRequest
+	Params      qbtypes.QueryRangeRequest
 	Seasonality Seasonality
 }
 
@@ -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)
@@ -81,7 +81,7 @@ type anomalyQueryParams struct {
 	Past3SeasonQuery qbtypes.QueryRangeRequest
 }
 
-func prepareAnomalyQueryParams(req *qbtypes.QueryRangeRequest, seasonality Seasonality) *anomalyQueryParams {
+func prepareAnomalyQueryParams(req qbtypes.QueryRangeRequest, seasonality Seasonality) *anomalyQueryParams {
 	start := req.Start
 	end := req.End
 

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.PrincipalAttributes.PrincipalOrgID.IsZero() {
-		provider.settings.Logger().WarnContext(ctx, "audit event dropped as org_id is zero")
-		return
-	}
-
-	if _, err := provider.licensing.GetActive(ctx, event.PrincipalAttributes.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/server.go

@@ -34,22 +34,9 @@ func (server *Server) Stop(ctx context.Context) error {
 }
 
 func (server *Server) CheckWithTupleCreation(ctx context.Context, claims authtypes.Claims, orgID valuer.UUID, relation authtypes.Relation, typeable authtypes.Typeable, selectors []authtypes.Selector, _ []authtypes.Selector) error {
-	subject := ""
-	switch claims.Principal {
-	case authtypes.PrincipalUser:
-		user, err := authtypes.NewSubject(authtypes.TypeableUser, claims.UserID, orgID, nil)
-		if err != nil {
-			return err
-		}
-
-		subject = user
-	case authtypes.PrincipalServiceAccount:
-		serviceAccount, err := authtypes.NewSubject(authtypes.TypeableServiceAccount, claims.ServiceAccountID, orgID, nil)
-		if err != nil {
-			return err
-		}
-
-		subject = serviceAccount
+	subject, err := authtypes.NewSubject(authtypes.TypeableUser, claims.UserID, orgID, nil)
+	if err != nil {
+		return err
 	}
 
 	tupleSlice, err := typeable.Tuples(subject, relation, selectors, orgID)

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/dashboard/impldashboard/module.go

@@ -213,8 +213,8 @@ func (module *module) Update(ctx context.Context, orgID valuer.UUID, id valuer.U
 	return module.pkgDashboardModule.Update(ctx, orgID, id, updatedBy, data, diff)
 }
 
-func (module *module) LockUnlock(ctx context.Context, orgID valuer.UUID, id valuer.UUID, updatedBy string, isAdmin bool, lock bool) error {
-	return module.pkgDashboardModule.LockUnlock(ctx, orgID, id, updatedBy, isAdmin, lock)
+func (module *module) LockUnlock(ctx context.Context, orgID valuer.UUID, id valuer.UUID, updatedBy string, role types.Role, lock bool) error {
+	return module.pkgDashboardModule.LockUnlock(ctx, orgID, id, updatedBy, role, lock)
 }
 
 func (module *module) MustGetTypeables() []authtypes.Typeable {

ee/querier/handler.go

@@ -65,7 +65,7 @@ func (h *handler) QueryRange(rw http.ResponseWriter, req *http.Request) {
 	}
 
 	if anomalyQuery, ok := queryRangeRequest.IsAnomalyRequest(); ok {
-		anomalies, err := h.handleAnomalyQuery(ctx, orgID, anomalyQuery, &queryRangeRequest)
+		anomalies, err := h.handleAnomalyQuery(ctx, orgID, anomalyQuery, queryRangeRequest)
 		if err != nil {
 			render.Error(rw, errors.NewInternalf(errors.CodeInternal, "failed to get anomalies: %v", err))
 			return
@@ -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{
@@ -149,7 +149,7 @@ func (h *handler) createAnomalyProvider(seasonality anomalyV2.Seasonality) anoma
 	}
 }
 
-func (h *handler) handleAnomalyQuery(ctx context.Context, orgID valuer.UUID, anomalyQuery *qbtypes.QueryBuilderQuery[qbtypes.MetricAggregation], queryRangeRequest *qbtypes.QueryRangeRequest) (*anomalyV2.AnomaliesResponse, error) {
+func (h *handler) handleAnomalyQuery(ctx context.Context, orgID valuer.UUID, anomalyQuery *qbtypes.QueryBuilderQuery[qbtypes.MetricAggregation], queryRangeRequest qbtypes.QueryRangeRequest) (*anomalyV2.AnomaliesResponse, error) {
 	seasonality := extractSeasonality(anomalyQuery)
 	provider := h.createAnomalyProvider(seasonality)
 

ee/query-service/app/api/cloudIntegrations.go

@@ -14,9 +14,10 @@ import (
 
 	"github.com/SigNoz/signoz/pkg/errors"
 	"github.com/SigNoz/signoz/pkg/http/render"
+	"github.com/SigNoz/signoz/pkg/modules/user"
 	basemodel "github.com/SigNoz/signoz/pkg/query-service/model"
+	"github.com/SigNoz/signoz/pkg/types"
 	"github.com/SigNoz/signoz/pkg/types/authtypes"
-	"github.com/SigNoz/signoz/pkg/types/serviceaccounttypes"
 	"github.com/SigNoz/signoz/pkg/valuer"
 	"github.com/gorilla/mux"
 )
@@ -49,7 +50,7 @@ func (ah *APIHandler) CloudIntegrationsGenerateConnectionParams(w http.ResponseW
 		return
 	}
 
-	apiKey, apiErr := ah.getOrCreateCloudIntegrationFactorAPIKey(r.Context(), valuer.MustNewUUID(claims.OrgID), cloudProvider)
+	apiKey, apiErr := ah.getOrCreateCloudIntegrationPAT(r.Context(), claims.OrgID, cloudProvider)
 	if apiErr != nil {
 		RespondError(w, basemodel.WrapApiError(
 			apiErr, "couldn't provision PAT for cloud integration:",
@@ -109,44 +110,84 @@ func (ah *APIHandler) CloudIntegrationsGenerateConnectionParams(w http.ResponseW
 	ah.Respond(w, result)
 }
 
-func (ah *APIHandler) getOrCreateCloudIntegrationFactorAPIKey(ctx context.Context, orgID valuer.UUID, cloudProvider string) (
+func (ah *APIHandler) getOrCreateCloudIntegrationPAT(ctx context.Context, orgId string, cloudProvider string) (
 	string, *basemodel.ApiError,
 ) {
-	integrationPATName := fmt.Sprintf("%s", cloudProvider)
-	serviceAccount, apiErr := ah.getOrCreateCloudIntegrationServiceAccount(ctx, orgID)
+	integrationPATName := fmt.Sprintf("%s integration", cloudProvider)
+
+	integrationUser, apiErr := ah.getOrCreateCloudIntegrationUser(ctx, orgId, cloudProvider)
 	if apiErr != nil {
 		return "", apiErr
 	}
 
-	factorAPIKey, err := serviceAccount.NewFactorAPIKey(integrationPATName, 0)
+	orgIdUUID, err := valuer.NewUUID(orgId)
+	if err != nil {
+		return "", basemodel.InternalError(fmt.Errorf(
+			"couldn't parse orgId: %w", err,
+		))
+	}
+
+	allPats, err := ah.Signoz.Modules.UserSetter.ListAPIKeys(ctx, orgIdUUID)
+	if err != nil {
+		return "", basemodel.InternalError(fmt.Errorf(
+			"couldn't list PATs: %w", err,
+		))
+	}
+	for _, p := range allPats {
+		if p.UserID == integrationUser.ID && p.Name == integrationPATName {
+			return p.Token, nil
+		}
+	}
+
+	slog.InfoContext(ctx, "no PAT found for cloud integration, creating a new one",
+		"cloud_provider", cloudProvider,
+	)
+
+	newPAT, err := types.NewStorableAPIKey(
+		integrationPATName,
+		integrationUser.ID,
+		types.RoleViewer,
+		0,
+	)
 	if err != nil {
 		return "", basemodel.InternalError(fmt.Errorf(
 			"couldn't create cloud integration PAT: %w", err,
 		))
 	}
 
-	factorAPIKey, err = ah.Signoz.Modules.ServiceAccount.GetOrCreateFactorAPIKey(ctx, factorAPIKey)
+	err = ah.Signoz.Modules.UserSetter.CreateAPIKey(ctx, newPAT)
 	if err != nil {
 		return "", basemodel.InternalError(fmt.Errorf(
 			"couldn't create cloud integration PAT: %w", err,
 		))
 	}
-	return factorAPIKey.Key, nil
+	return newPAT.Token, nil
 }
 
-func (ah *APIHandler) getOrCreateCloudIntegrationServiceAccount(ctx context.Context, orgId valuer.UUID) (*serviceaccounttypes.ServiceAccount, *basemodel.ApiError) {
-	domain := ah.Signoz.Modules.ServiceAccount.Config().Email.Domain
-	cloudIntegrationServiceAccount := serviceaccounttypes.NewServiceAccount("integration", domain, serviceaccounttypes.ServiceAccountStatusActive, orgId)
-	cloudIntegrationServiceAccount, err := ah.Signoz.Modules.ServiceAccount.GetOrCreate(ctx, orgId, cloudIntegrationServiceAccount)
+func (ah *APIHandler) getOrCreateCloudIntegrationUser(
+	ctx context.Context, orgId string, cloudProvider string,
+) (*types.User, *basemodel.ApiError) {
+	cloudIntegrationUserName := fmt.Sprintf("%s-integration", cloudProvider)
+	email := valuer.MustNewEmail(fmt.Sprintf("%s@signoz.io", cloudIntegrationUserName))
+
+	cloudIntegrationUser, err := types.NewUser(cloudIntegrationUserName, email, valuer.MustNewUUID(orgId), types.UserStatusActive)
 	if err != nil {
-		return nil, basemodel.InternalError(fmt.Errorf("couldn't create cloud integration service account: %w", err))
-	}
-	err = ah.Signoz.Modules.ServiceAccount.SetRoleByName(ctx, orgId, cloudIntegrationServiceAccount.ID, authtypes.SigNozViewerRoleName)
-	if err != nil {
-		return nil, basemodel.InternalError(fmt.Errorf("couldn't create cloud integration service account: %w", err))
+		return nil, basemodel.InternalError(fmt.Errorf("couldn't create cloud integration user: %w", err))
 	}
 
-	return cloudIntegrationServiceAccount, nil
+	password := types.MustGenerateFactorPassword(cloudIntegrationUser.ID.StringValue())
+
+	cloudIntegrationUser, err = ah.Signoz.Modules.UserSetter.GetOrCreateUser(
+		ctx,
+		cloudIntegrationUser,
+		user.WithFactorPassword(password),
+		user.WithRoleNames([]string{authtypes.SigNozViewerRoleName}),
+	)
+	if err != nil {
+		return nil, basemodel.InternalError(fmt.Errorf("couldn't look for integration user: %w", err))
+	}
+
+	return cloudIntegrationUser, nil
 }
 
 func (ah *APIHandler) getIngestionUrlAndSigNozAPIUrl(ctx context.Context, licenseKey string) (

ee/query-service/app/server.go

@@ -29,7 +29,6 @@ import (
 	"github.com/SigNoz/signoz/pkg/cache"
 	"github.com/SigNoz/signoz/pkg/http/middleware"
 	"github.com/SigNoz/signoz/pkg/modules/organization"
-	"github.com/SigNoz/signoz/pkg/modules/rulestatehistory"
 	"github.com/SigNoz/signoz/pkg/prometheus"
 	"github.com/SigNoz/signoz/pkg/querier"
 	"github.com/SigNoz/signoz/pkg/signoz"
@@ -49,6 +48,7 @@ import (
 	opAmpModel "github.com/SigNoz/signoz/pkg/query-service/app/opamp/model"
 	baseconst "github.com/SigNoz/signoz/pkg/query-service/constants"
 	"github.com/SigNoz/signoz/pkg/query-service/healthcheck"
+	baseint "github.com/SigNoz/signoz/pkg/query-service/interfaces"
 	baserules "github.com/SigNoz/signoz/pkg/query-service/rules"
 	"github.com/SigNoz/signoz/pkg/query-service/utils"
 )
@@ -98,6 +98,7 @@ func NewServer(config signoz.Config, signoz *signoz.SigNoz) (*Server, error) {
 	)
 
 	rm, err := makeRulesManager(
+		reader,
 		signoz.Cache,
 		signoz.Alertmanager,
 		signoz.SQLStore,
@@ -105,7 +106,6 @@ func NewServer(config signoz.Config, signoz *signoz.SigNoz) (*Server, error) {
 		signoz.TelemetryMetadataStore,
 		signoz.Prometheus,
 		signoz.Modules.OrgGetter,
-		signoz.Modules.RuleStateHistory,
 		signoz.Querier,
 		signoz.Instrumentation.ToProviderSettings(),
 		signoz.QueryParser,
@@ -227,7 +227,7 @@ func (s *Server) createPublicServer(apiHandler *api.APIHandler, web web.Web) (*h
 		s.config.APIServer.Timeout.Default,
 		s.config.APIServer.Timeout.Max,
 	).Wrap)
-	r.Use(middleware.NewAudit(s.signoz.Instrumentation.Logger(), s.config.APIServer.Logging.ExcludedRoutes, nil).Wrap)
+	r.Use(middleware.NewLogging(s.signoz.Instrumentation.Logger(), s.config.APIServer.Logging.ExcludedRoutes).Wrap)
 	r.Use(middleware.NewComment().Wrap)
 
 	apiHandler.RegisterRoutes(r, am)
@@ -240,6 +240,7 @@ func (s *Server) createPublicServer(apiHandler *api.APIHandler, web web.Web) (*h
 	apiHandler.RegisterWebSocketPaths(r, am)
 	apiHandler.RegisterMessagingQueuesRoutes(r, am)
 	apiHandler.RegisterThirdPartyApiRoutes(r, am)
+	apiHandler.MetricExplorerRoutes(r, am)
 	apiHandler.RegisterTraceFunnelsRoutes(r, am)
 
 	err := s.signoz.APIServer.AddToRouter(r)
@@ -343,28 +344,28 @@ func (s *Server) Stop(ctx context.Context) error {
 	return nil
 }
 
-func makeRulesManager(cache cache.Cache, alertmanager alertmanager.Alertmanager, sqlstore sqlstore.SQLStore, telemetryStore telemetrystore.TelemetryStore, metadataStore telemetrytypes.MetadataStore, prometheus prometheus.Prometheus, orgGetter organization.Getter, ruleStateHistoryModule rulestatehistory.Module, querier querier.Querier, providerSettings factory.ProviderSettings, queryParser queryparser.QueryParser) (*baserules.Manager, error) {
+func makeRulesManager(ch baseint.Reader, cache cache.Cache, alertmanager alertmanager.Alertmanager, sqlstore sqlstore.SQLStore, telemetryStore telemetrystore.TelemetryStore, metadataStore telemetrytypes.MetadataStore, prometheus prometheus.Prometheus, orgGetter organization.Getter, querier querier.Querier, providerSettings factory.ProviderSettings, queryParser queryparser.QueryParser) (*baserules.Manager, error) {
 	ruleStore := sqlrulestore.NewRuleStore(sqlstore, queryParser, providerSettings)
 	maintenanceStore := sqlrulestore.NewMaintenanceStore(sqlstore)
 	// create manager opts
 	managerOpts := &baserules.ManagerOptions{
-		TelemetryStore:         telemetryStore,
-		MetadataStore:          metadataStore,
-		Prometheus:             prometheus,
-		Context:                context.Background(),
-		Querier:                querier,
-		Logger:                 providerSettings.Logger,
-		Cache:                  cache,
-		EvalDelay:              baseconst.GetEvalDelay(),
-		PrepareTaskFunc:        rules.PrepareTaskFunc,
-		PrepareTestRuleFunc:    rules.TestNotification,
-		Alertmanager:           alertmanager,
-		OrgGetter:              orgGetter,
-		RuleStore:              ruleStore,
-		MaintenanceStore:       maintenanceStore,
-		SQLStore:               sqlstore,
-		QueryParser:            queryParser,
-		RuleStateHistoryModule: ruleStateHistoryModule,
+		TelemetryStore:      telemetryStore,
+		MetadataStore:       metadataStore,
+		Prometheus:          prometheus,
+		Context:             context.Background(),
+		Reader:              ch,
+		Querier:             querier,
+		Logger:              providerSettings.Logger,
+		Cache:               cache,
+		EvalDelay:           baseconst.GetEvalDelay(),
+		PrepareTaskFunc:     rules.PrepareTaskFunc,
+		PrepareTestRuleFunc: rules.TestNotification,
+		Alertmanager:        alertmanager,
+		OrgGetter:           orgGetter,
+		RuleStore:           ruleStore,
+		MaintenanceStore:    maintenanceStore,
+		SqlStore:            sqlstore,
+		QueryParser:         queryParser,
 	}
 
 	// create Manager

ee/query-service/rules/anomaly.go

@@ -5,33 +5,40 @@ import (
 	"encoding/json"
 	"fmt"
 	"log/slog"
-	"sync"
+	"math"
+	"strings"
 	"time"
 
+	"github.com/SigNoz/signoz/ee/query-service/anomaly"
+	"github.com/SigNoz/signoz/pkg/cache"
 	"github.com/SigNoz/signoz/pkg/errors"
-	"github.com/SigNoz/signoz/pkg/querier"
-	"github.com/SigNoz/signoz/pkg/types/rulestatehistorytypes"
+	"github.com/SigNoz/signoz/pkg/query-service/common"
+	"github.com/SigNoz/signoz/pkg/transition"
 	"github.com/SigNoz/signoz/pkg/types/ruletypes"
 	"github.com/SigNoz/signoz/pkg/valuer"
 
-	"github.com/SigNoz/signoz/pkg/units"
-
+	"github.com/SigNoz/signoz/pkg/query-service/app/queryBuilder"
+	"github.com/SigNoz/signoz/pkg/query-service/interfaces"
+	v3 "github.com/SigNoz/signoz/pkg/query-service/model/v3"
 	baserules "github.com/SigNoz/signoz/pkg/query-service/rules"
+	"github.com/SigNoz/signoz/pkg/query-service/utils/labels"
 
-	"github.com/SigNoz/signoz/ee/anomaly"
+	querierV5 "github.com/SigNoz/signoz/pkg/querier"
+
+	anomalyV2 "github.com/SigNoz/signoz/ee/anomaly"
 
 	qbtypes "github.com/SigNoz/signoz/pkg/types/querybuildertypes/querybuildertypesv5"
 )
 
+const (
+	RuleTypeAnomaly = "anomaly_rule"
+)
+
 type AnomalyRule struct {
 	*baserules.BaseRule
 
-	mtx sync.Mutex
-
-	// querier is used for alerts migrated after the introduction of new query builder
-	querier querier.Querier
-
-	provider anomaly.Provider
+	provider   anomaly.Provider
+	providerV2 anomalyV2.Provider
 
 	version string
 	logger  *slog.Logger
@@ -45,16 +52,18 @@ func NewAnomalyRule(
 	id string,
 	orgID valuer.UUID,
 	p *ruletypes.PostableRule,
-	querier querier.Querier,
+	reader interfaces.Reader,
+	querierV5 querierV5.Querier,
 	logger *slog.Logger,
+	cache cache.Cache,
 	opts ...baserules.RuleOption,
 ) (*AnomalyRule, error) {
 
-	logger.Info("creating new AnomalyRule", slog.String("rule.id", id))
+	logger.Info("creating new AnomalyRule", "rule_id", id)
 
 	opts = append(opts, baserules.WithLogger(logger))
 
-	baseRule, err := baserules.NewBaseRule(id, orgID, p, opts...)
+	baseRule, err := baserules.NewBaseRule(id, orgID, p, reader, opts...)
 	if err != nil {
 		return nil, err
 	}
@@ -63,49 +72,95 @@ func NewAnomalyRule(
 		BaseRule: baseRule,
 	}
 
-	switch p.RuleCondition.Seasonality {
-	case ruletypes.SeasonalityHourly:
+	switch strings.ToLower(p.RuleCondition.Seasonality) {
+	case "hourly":
 		t.seasonality = anomaly.SeasonalityHourly
-	case ruletypes.SeasonalityDaily:
+	case "daily":
 		t.seasonality = anomaly.SeasonalityDaily
-	case ruletypes.SeasonalityWeekly:
+	case "weekly":
 		t.seasonality = anomaly.SeasonalityWeekly
 	default:
 		t.seasonality = anomaly.SeasonalityDaily
 	}
 
-	logger.Info("using seasonality", slog.String("rule.id", id), slog.String("rule.seasonality", t.seasonality.StringValue()))
+	logger.Info("using seasonality", "seasonality", t.seasonality.String())
 
 	if t.seasonality == anomaly.SeasonalityHourly {
 		t.provider = anomaly.NewHourlyProvider(
-			anomaly.WithQuerier[*anomaly.HourlyProvider](querier),
-			anomaly.WithLogger[*anomaly.HourlyProvider](logger),
+			anomaly.WithCache[*anomaly.HourlyProvider](cache),
+			anomaly.WithKeyGenerator[*anomaly.HourlyProvider](queryBuilder.NewKeyGenerator()),
+			anomaly.WithReader[*anomaly.HourlyProvider](reader),
 		)
 	} else if t.seasonality == anomaly.SeasonalityDaily {
 		t.provider = anomaly.NewDailyProvider(
-			anomaly.WithQuerier[*anomaly.DailyProvider](querier),
-			anomaly.WithLogger[*anomaly.DailyProvider](logger),
+			anomaly.WithCache[*anomaly.DailyProvider](cache),
+			anomaly.WithKeyGenerator[*anomaly.DailyProvider](queryBuilder.NewKeyGenerator()),
+			anomaly.WithReader[*anomaly.DailyProvider](reader),
 		)
 	} else if t.seasonality == anomaly.SeasonalityWeekly {
 		t.provider = anomaly.NewWeeklyProvider(
-			anomaly.WithQuerier[*anomaly.WeeklyProvider](querier),
-			anomaly.WithLogger[*anomaly.WeeklyProvider](logger),
+			anomaly.WithCache[*anomaly.WeeklyProvider](cache),
+			anomaly.WithKeyGenerator[*anomaly.WeeklyProvider](queryBuilder.NewKeyGenerator()),
+			anomaly.WithReader[*anomaly.WeeklyProvider](reader),
+		)
+	}
+
+	if t.seasonality == anomaly.SeasonalityHourly {
+		t.providerV2 = anomalyV2.NewHourlyProvider(
+			anomalyV2.WithQuerier[*anomalyV2.HourlyProvider](querierV5),
+			anomalyV2.WithLogger[*anomalyV2.HourlyProvider](logger),
+		)
+	} else if t.seasonality == anomaly.SeasonalityDaily {
+		t.providerV2 = anomalyV2.NewDailyProvider(
+			anomalyV2.WithQuerier[*anomalyV2.DailyProvider](querierV5),
+			anomalyV2.WithLogger[*anomalyV2.DailyProvider](logger),
+		)
+	} else if t.seasonality == anomaly.SeasonalityWeekly {
+		t.providerV2 = anomalyV2.NewWeeklyProvider(
+			anomalyV2.WithQuerier[*anomalyV2.WeeklyProvider](querierV5),
+			anomalyV2.WithLogger[*anomalyV2.WeeklyProvider](logger),
 		)
 	}
 
-	t.querier = querier
 	t.version = p.Version
 	t.logger = logger
 	return &t, nil
 }
 
 func (r *AnomalyRule) Type() ruletypes.RuleType {
-	return ruletypes.RuleTypeAnomaly
+	return RuleTypeAnomaly
 }
 
-func (r *AnomalyRule) prepareQueryRange(ctx context.Context, ts time.Time) *qbtypes.QueryRangeRequest {
+func (r *AnomalyRule) prepareQueryRange(ctx context.Context, ts time.Time) (*v3.QueryRangeParamsV3, error) {
 
-	r.logger.InfoContext(ctx, "prepare query range request", slog.String("rule.id", r.ID()), slog.Int64("ts", ts.UnixMilli()), slog.Int64("eval.window_ms", r.EvalWindow().Milliseconds()), slog.Int64("eval.delay_ms", r.EvalDelay().Milliseconds()))
+	r.logger.InfoContext(
+		ctx, "prepare query range request v4", "ts", ts.UnixMilli(), "eval_window", r.EvalWindow().Milliseconds(), "eval_delay", r.EvalDelay().Milliseconds(),
+	)
+
+	st, en := r.Timestamps(ts)
+	start := st.UnixMilli()
+	end := en.UnixMilli()
+
+	compositeQuery := r.Condition().CompositeQuery
+
+	if compositeQuery.PanelType != v3.PanelTypeGraph {
+		compositeQuery.PanelType = v3.PanelTypeGraph
+	}
+
+	// default mode
+	return &v3.QueryRangeParamsV3{
+		Start:          start,
+		End:            end,
+		Step:           int64(math.Max(float64(common.MinAllowedStepInterval(start, end)), 60)),
+		CompositeQuery: compositeQuery,
+		Variables:      make(map[string]interface{}, 0),
+		NoCache:        false,
+	}, nil
+}
+
+func (r *AnomalyRule) prepareQueryRangeV5(ctx context.Context, ts time.Time) (*qbtypes.QueryRangeRequest, error) {
+
+	r.logger.InfoContext(ctx, "prepare query range request v5", "ts", ts.UnixMilli(), "eval_window", r.EvalWindow().Milliseconds(), "eval_delay", r.EvalDelay().Milliseconds())
 
 	startTs, endTs := r.Timestamps(ts)
 	start, end := startTs.UnixMilli(), endTs.UnixMilli()
@@ -121,14 +176,25 @@ func (r *AnomalyRule) prepareQueryRange(ctx context.Context, ts time.Time) *qbty
 	}
 	req.CompositeQuery.Queries = make([]qbtypes.QueryEnvelope, len(r.Condition().CompositeQuery.Queries))
 	copy(req.CompositeQuery.Queries, r.Condition().CompositeQuery.Queries)
-	return req
+	return req, nil
+}
+
+func (r *AnomalyRule) GetSelectedQuery() string {
+	return r.Condition().GetSelectedQueryName()
 }
 
 func (r *AnomalyRule) buildAndRunQuery(ctx context.Context, orgID valuer.UUID, ts time.Time) (ruletypes.Vector, error) {
 
-	params := r.prepareQueryRange(ctx, ts)
+	params, err := r.prepareQueryRange(ctx, ts)
+	if err != nil {
+		return nil, err
+	}
+	err = r.PopulateTemporality(ctx, orgID, params)
+	if err != nil {
+		return nil, fmt.Errorf("internal error while setting temporality")
+	}
 
-	anomalies, err := r.provider.GetAnomalies(ctx, orgID, &anomaly.AnomaliesRequest{
+	anomalies, err := r.provider.GetAnomalies(ctx, orgID, &anomaly.GetAnomaliesRequest{
 		Params:      params,
 		Seasonality: r.seasonality,
 	})
@@ -136,43 +202,87 @@ func (r *AnomalyRule) buildAndRunQuery(ctx context.Context, orgID valuer.UUID, t
 		return nil, err
 	}
 
-	var queryResult *qbtypes.TimeSeriesData
+	var queryResult *v3.Result
 	for _, result := range anomalies.Results {
-		if result.QueryName == r.SelectedQuery(ctx) {
+		if result.QueryName == r.GetSelectedQuery() {
 			queryResult = result
 			break
 		}
 	}
 
-	if queryResult == nil {
-		r.logger.WarnContext(ctx, "nil qb result", slog.String("rule.id", r.ID()), slog.Int64("ts", ts.UnixMilli()))
-		return ruletypes.Vector{}, nil
-	}
-
-	hasData := len(queryResult.Aggregations) > 0 &&
-		queryResult.Aggregations[0] != nil &&
-		len(queryResult.Aggregations[0].AnomalyScores) > 0
-
+	hasData := len(queryResult.AnomalyScores) > 0
 	if missingDataAlert := r.HandleMissingDataAlert(ctx, ts, hasData); missingDataAlert != nil {
 		return ruletypes.Vector{*missingDataAlert}, nil
-	} else if !hasData {
-		r.logger.WarnContext(ctx, "no anomaly result", slog.String("rule.id", r.ID()))
-		return ruletypes.Vector{}, nil
 	}
 
 	var resultVector ruletypes.Vector
 
-	scoresJSON, _ := json.Marshal(queryResult.Aggregations[0].AnomalyScores)
-	// TODO(srikanthccv): this could be noisy but we do this to answer false alert requests
-	r.logger.InfoContext(ctx, "anomaly scores", slog.String("rule.id", r.ID()), slog.String("anomaly.scores", string(scoresJSON)))
+	scoresJSON, _ := json.Marshal(queryResult.AnomalyScores)
+	r.logger.InfoContext(ctx, "anomaly scores", "scores", string(scoresJSON))
+
+	for _, series := range queryResult.AnomalyScores {
+		if !r.Condition().ShouldEval(series) {
+			r.logger.InfoContext(ctx, "not enough data points to evaluate series, skipping", "ruleid", r.ID(), "numPoints", len(series.Points), "requiredPoints", r.Condition().RequiredNumPoints)
+			continue
+		}
+		results, err := r.Threshold.Eval(*series, r.Unit(), ruletypes.EvalData{
+			ActiveAlerts:  r.ActiveAlertsLabelFP(),
+			SendUnmatched: r.ShouldSendUnmatched(),
+		})
+		if err != nil {
+			return nil, err
+		}
+		resultVector = append(resultVector, results...)
+	}
+	return resultVector, nil
+}
+
+func (r *AnomalyRule) buildAndRunQueryV5(ctx context.Context, orgID valuer.UUID, ts time.Time) (ruletypes.Vector, error) {
+
+	params, err := r.prepareQueryRangeV5(ctx, ts)
+	if err != nil {
+		return nil, err
+	}
+
+	anomalies, err := r.providerV2.GetAnomalies(ctx, orgID, &anomalyV2.AnomaliesRequest{
+		Params:      *params,
+		Seasonality: anomalyV2.Seasonality{String: valuer.NewString(r.seasonality.String())},
+	})
+	if err != nil {
+		return nil, err
+	}
+
+	var qbResult *qbtypes.TimeSeriesData
+	for _, result := range anomalies.Results {
+		if result.QueryName == r.GetSelectedQuery() {
+			qbResult = result
+			break
+		}
+	}
+
+	if qbResult == nil {
+		r.logger.WarnContext(ctx, "nil qb result", "ts", ts.UnixMilli())
+	}
+
+	queryResult := transition.ConvertV5TimeSeriesDataToV4Result(qbResult)
+
+	hasData := len(queryResult.AnomalyScores) > 0
+	if missingDataAlert := r.HandleMissingDataAlert(ctx, ts, hasData); missingDataAlert != nil {
+		return ruletypes.Vector{*missingDataAlert}, nil
+	}
+
+	var resultVector ruletypes.Vector
+
+	scoresJSON, _ := json.Marshal(queryResult.AnomalyScores)
+	r.logger.InfoContext(ctx, "anomaly scores", "scores", string(scoresJSON))
 
 	// Filter out new series if newGroupEvalDelay is configured
-	seriesToProcess := queryResult.Aggregations[0].AnomalyScores
+	seriesToProcess := queryResult.AnomalyScores
 	if r.ShouldSkipNewGroups() {
 		filteredSeries, filterErr := r.BaseRule.FilterNewSeries(ctx, ts, seriesToProcess)
 		// In case of error we log the error and continue with the original series
 		if filterErr != nil {
-			r.logger.ErrorContext(ctx, "error filtering new series", slog.String("rule.id", r.ID()), errors.Attr(filterErr))
+			r.logger.ErrorContext(ctx, "Error filtering new series, ", errors.Attr(filterErr), "rule_name", r.Name())
 		} else {
 			seriesToProcess = filteredSeries
 		}
@@ -180,10 +290,10 @@ func (r *AnomalyRule) buildAndRunQuery(ctx context.Context, orgID valuer.UUID, t
 
 	for _, series := range seriesToProcess {
 		if !r.Condition().ShouldEval(series) {
-			r.logger.InfoContext(ctx, "not enough data points to evaluate series, skipping", slog.String("rule.id", r.ID()), slog.Int("series.num_points", len(series.Values)), slog.Int("series.required_points", r.Condition().RequiredNumPoints))
+			r.logger.InfoContext(ctx, "not enough data points to evaluate series, skipping", "ruleid", r.ID(), "numPoints", len(series.Points), "requiredPoints", r.Condition().RequiredNumPoints)
 			continue
 		}
-		results, err := r.Threshold.Eval(series, r.Unit(), ruletypes.EvalData{
+		results, err := r.Threshold.Eval(*series, r.Unit(), ruletypes.EvalData{
 			ActiveAlerts:  r.ActiveAlertsLabelFP(),
 			SendUnmatched: r.ShouldSendUnmatched(),
 		})
@@ -196,234 +306,21 @@ func (r *AnomalyRule) buildAndRunQuery(ctx context.Context, orgID valuer.UUID, t
 }
 
 func (r *AnomalyRule) Eval(ctx context.Context, ts time.Time) (int, error) {
-
-	prevState := r.State()
-
-	valueFormatter := units.FormatterFromUnit(r.Unit())
-
 	var res ruletypes.Vector
 	var err error
-
-	r.logger.InfoContext(ctx, "running query", slog.String("rule.id", r.ID()))
-	res, err = r.buildAndRunQuery(ctx, r.OrgID(), ts)
-
+	if r.version == "v5" {
+		r.logger.InfoContext(ctx, "running v5 query")
+		res, err = r.buildAndRunQueryV5(ctx, r.OrgID(), ts)
+	} else {
+		r.logger.InfoContext(ctx, "running v4 query")
+		res, err = r.buildAndRunQuery(ctx, r.OrgID(), ts)
+	}
 	if err != nil {
 		return 0, err
 	}
 
-	r.mtx.Lock()
-	defer r.mtx.Unlock()
-
-	resultFPs := map[uint64]struct{}{}
-	var alerts = make(map[uint64]*ruletypes.Alert, len(res))
-
-	ruleReceivers := r.Threshold.GetRuleReceivers()
-	ruleReceiverMap := make(map[string][]string)
-	for _, value := range ruleReceivers {
-		ruleReceiverMap[value.Name] = value.Channels
+	opts := baserules.EvalVectorOptions{
+		DeleteLabels: []string{labels.MetricNameLabel, labels.TemporalityLabel},
 	}
-
-	for _, smpl := range res {
-		l := make(map[string]string, len(smpl.Metric))
-		for _, lbl := range smpl.Metric {
-			l[lbl.Name] = lbl.Value
-		}
-		value := valueFormatter.Format(smpl.V, r.Unit())
-		threshold := valueFormatter.Format(smpl.Target, smpl.TargetUnit)
-		r.logger.DebugContext(ctx, "alert template data for rule", slog.String("rule.id", r.ID()), slog.String("formatter.name", valueFormatter.Name()), slog.String("alert.value", value), slog.String("alert.threshold", threshold))
-
-		tmplData := ruletypes.AlertTemplateData(l, value, threshold)
-		// Inject some convenience variables that are easier to remember for users
-		// who are not used to Go's templating system.
-		defs := "{{$labels := .Labels}}{{$value := .Value}}{{$threshold := .Threshold}}"
-
-		// utility function to apply go template on labels and annotations
-		expand := func(text string) string {
-
-			tmpl := ruletypes.NewTemplateExpander(
-				ctx,
-				defs+text,
-				"__alert_"+r.Name(),
-				tmplData,
-				nil,
-			)
-			result, err := tmpl.Expand()
-			if err != nil {
-				result = fmt.Sprintf("<error expanding template: %s>", err)
-				r.logger.ErrorContext(ctx, "expanding alert template failed", slog.String("rule.id", r.ID()), errors.Attr(err), slog.Any("alert.template_data", tmplData))
-			}
-			return result
-		}
-
-		lb := ruletypes.NewBuilder(smpl.Metric...).Del(ruletypes.MetricNameLabel).Del(ruletypes.TemporalityLabel)
-		resultLabels := ruletypes.NewBuilder(smpl.Metric...).Del(ruletypes.MetricNameLabel).Del(ruletypes.TemporalityLabel).Labels()
-
-		for name, value := range r.Labels().Map() {
-			lb.Set(name, expand(value))
-		}
-
-		lb.Set(ruletypes.AlertNameLabel, r.Name())
-		lb.Set(ruletypes.AlertRuleIDLabel, r.ID())
-		lb.Set(ruletypes.RuleSourceLabel, r.GeneratorURL())
-
-		annotations := make(ruletypes.Labels, 0, len(r.Annotations().Map()))
-		for name, value := range r.Annotations().Map() {
-			annotations = append(annotations, ruletypes.Label{Name: name, Value: expand(value)})
-		}
-		if smpl.IsMissing {
-			lb.Set(ruletypes.AlertNameLabel, "[No data] "+r.Name())
-			lb.Set(ruletypes.NoDataLabel, "true")
-		}
-
-		lbs := lb.Labels()
-		h := lbs.Hash()
-		resultFPs[h] = struct{}{}
-
-		if _, ok := alerts[h]; ok {
-			r.logger.ErrorContext(ctx, "the alert query returns duplicate records", slog.String("rule.id", r.ID()), slog.Any("alert", alerts[h]))
-			err = errors.NewInternalf(errors.CodeInternal, "duplicate alert found, vector contains metrics with the same labelset after applying alert labels")
-			return 0, err
-		}
-
-		alerts[h] = &ruletypes.Alert{
-			Labels:            lbs,
-			QueryResultLabels: resultLabels,
-			Annotations:       annotations,
-			ActiveAt:          ts,
-			State:             ruletypes.StatePending,
-			Value:             smpl.V,
-			GeneratorURL:      r.GeneratorURL(),
-			Receivers:         ruleReceiverMap[lbs.Map()[ruletypes.LabelThresholdName]],
-			Missing:           smpl.IsMissing,
-			IsRecovering:      smpl.IsRecovering,
-		}
-	}
-
-	r.logger.InfoContext(ctx, "number of alerts found", slog.String("rule.id", r.ID()), slog.Int("alert.count", len(alerts)))
-	// alerts[h] is ready, add or update active list now
-	for h, a := range alerts {
-		// Check whether we already have alerting state for the identifying label set.
-		// Update the last value and annotations if so, create a new alert entry otherwise.
-		if alert, ok := r.Active[h]; ok && alert.State != ruletypes.StateInactive {
-
-			alert.Value = a.Value
-			alert.Annotations = a.Annotations
-			// Update the recovering and missing state of existing alert
-			alert.IsRecovering = a.IsRecovering
-			alert.Missing = a.Missing
-			if v, ok := alert.Labels.Map()[ruletypes.LabelThresholdName]; ok {
-				alert.Receivers = ruleReceiverMap[v]
-			}
-			continue
-		}
-
-		r.Active[h] = a
-	}
-
-	itemsToAdd := []rulestatehistorytypes.RuleStateHistory{}
-
-	// Check if any pending alerts should be removed or fire now. Write out alert timeseries.
-	for fp, a := range r.Active {
-		labelsJSON, err := json.Marshal(a.QueryResultLabels)
-		if err != nil {
-			r.logger.ErrorContext(ctx, "error marshaling labels", slog.String("rule.id", r.ID()), errors.Attr(err), slog.Any("alert.labels", a.Labels))
-		}
-		if _, ok := resultFPs[fp]; !ok {
-			// If the alert was previously firing, keep it around for a given
-			// retention time so it is reported as resolved to the AlertManager.
-			if a.State == ruletypes.StatePending || (!a.ResolvedAt.IsZero() && ts.Sub(a.ResolvedAt) > ruletypes.ResolvedRetention) {
-				delete(r.Active, fp)
-			}
-			if a.State != ruletypes.StateInactive {
-				a.State = ruletypes.StateInactive
-				a.ResolvedAt = ts
-				itemsToAdd = append(itemsToAdd, rulestatehistorytypes.RuleStateHistory{
-					RuleID:       r.ID(),
-					RuleName:     r.Name(),
-					State:        ruletypes.StateInactive,
-					StateChanged: true,
-					UnixMilli:    ts.UnixMilli(),
-					Labels:       rulestatehistorytypes.LabelsString(labelsJSON),
-					Fingerprint:  a.QueryResultLabels.Hash(),
-					Value:        a.Value,
-				})
-			}
-			continue
-		}
-
-		if a.State == ruletypes.StatePending && ts.Sub(a.ActiveAt) >= r.HoldDuration().Duration() {
-			a.State = ruletypes.StateFiring
-			a.FiredAt = ts
-			state := ruletypes.StateFiring
-			if a.Missing {
-				state = ruletypes.StateNoData
-			}
-			itemsToAdd = append(itemsToAdd, rulestatehistorytypes.RuleStateHistory{
-				RuleID:       r.ID(),
-				RuleName:     r.Name(),
-				State:        state,
-				StateChanged: true,
-				UnixMilli:    ts.UnixMilli(),
-				Labels:       rulestatehistorytypes.LabelsString(labelsJSON),
-				Fingerprint:  a.QueryResultLabels.Hash(),
-				Value:        a.Value,
-			})
-		}
-
-		// We need to change firing alert to recovering if the returned sample meets recovery threshold
-		changeFiringToRecovering := a.State == ruletypes.StateFiring && a.IsRecovering
-		// We need to change recovering alerts to firing if the returned sample meets target threshold
-		changeRecoveringToFiring := a.State == ruletypes.StateRecovering && !a.IsRecovering && !a.Missing
-		// in any of the above case we need to update the status of alert
-		if changeFiringToRecovering || changeRecoveringToFiring {
-			state := ruletypes.StateRecovering
-			if changeRecoveringToFiring {
-				state = ruletypes.StateFiring
-			}
-			a.State = state
-			r.logger.DebugContext(ctx, "converting alert state", slog.String("rule.id", r.ID()), slog.Any("alert.state", state))
-			itemsToAdd = append(itemsToAdd, rulestatehistorytypes.RuleStateHistory{
-				RuleID:       r.ID(),
-				RuleName:     r.Name(),
-				State:        state,
-				StateChanged: true,
-				UnixMilli:    ts.UnixMilli(),
-				Labels:       rulestatehistorytypes.LabelsString(labelsJSON),
-				Fingerprint:  a.QueryResultLabels.Hash(),
-				Value:        a.Value,
-			})
-		}
-	}
-
-	currentState := r.State()
-
-	overallStateChanged := currentState != prevState
-	for idx, item := range itemsToAdd {
-		item.OverallStateChanged = overallStateChanged
-		item.OverallState = currentState
-		itemsToAdd[idx] = item
-	}
-
-	r.RecordRuleStateHistory(ctx, prevState, currentState, itemsToAdd)
-
-	return len(r.Active), nil
-}
-
-func (r *AnomalyRule) String() string {
-
-	ar := ruletypes.PostableRule{
-		AlertName:         r.Name(),
-		RuleCondition:     r.Condition(),
-		EvalWindow:        r.EvalWindow(),
-		Labels:            r.Labels().Map(),
-		Annotations:       r.Annotations().Map(),
-		PreferredChannels: r.PreferredChannels(),
-	}
-
-	byt, err := json.Marshal(ar)
-	if err != nil {
-		return fmt.Sprintf("error marshaling alerting rule: %s", err.Error())
-	}
-
-	return string(byt)
+	return r.EvalVector(ctx, ts, res, opts)
 }

ee/query-service/rules/anomaly_test.go

@@ -2,19 +2,21 @@ package rules
 
 import (
 	"context"
+	"log/slog"
 	"testing"
 	"time"
 
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 
+	"github.com/SigNoz/signoz/ee/query-service/anomaly"
 	"github.com/SigNoz/signoz/pkg/instrumentation/instrumentationtest"
-	qbtypes "github.com/SigNoz/signoz/pkg/types/querybuildertypes/querybuildertypesv5"
+	"github.com/SigNoz/signoz/pkg/query-service/app/clickhouseReader"
+	v3 "github.com/SigNoz/signoz/pkg/query-service/model/v3"
+	"github.com/SigNoz/signoz/pkg/telemetrystore"
+	"github.com/SigNoz/signoz/pkg/telemetrystore/telemetrystoretest"
 	"github.com/SigNoz/signoz/pkg/types/ruletypes"
-	"github.com/SigNoz/signoz/pkg/types/telemetrytypes"
 	"github.com/SigNoz/signoz/pkg/valuer"
-
-	"github.com/SigNoz/signoz/ee/anomaly"
 )
 
 // mockAnomalyProvider is a mock implementation of anomaly.Provider for testing.
@@ -22,13 +24,13 @@ import (
 // time periods (current, past period, current season, past season, past 2 seasons,
 // past 3 seasons), making it cumbersome to create mock data.
 type mockAnomalyProvider struct {
-	responses []*anomaly.AnomaliesResponse
+	responses []*anomaly.GetAnomaliesResponse
 	callCount int
 }
 
-func (m *mockAnomalyProvider) GetAnomalies(ctx context.Context, orgID valuer.UUID, req *anomaly.AnomaliesRequest) (*anomaly.AnomaliesResponse, error) {
+func (m *mockAnomalyProvider) GetAnomalies(ctx context.Context, orgID valuer.UUID, req *anomaly.GetAnomaliesRequest) (*anomaly.GetAnomaliesResponse, error) {
 	if m.callCount >= len(m.responses) {
-		return &anomaly.AnomaliesResponse{Results: []*qbtypes.TimeSeriesData{}}, nil
+		return &anomaly.GetAnomaliesResponse{Results: []*v3.Result{}}, nil
 	}
 	resp := m.responses[m.callCount]
 	m.callCount++
@@ -47,46 +49,45 @@ func TestAnomalyRule_NoData_AlertOnAbsent(t *testing.T) {
 	postableRule := ruletypes.PostableRule{
 		AlertName: "Test anomaly no data",
 		AlertType: ruletypes.AlertTypeMetric,
-		RuleType:  ruletypes.RuleTypeAnomaly,
+		RuleType:  RuleTypeAnomaly,
 		Evaluation: &ruletypes.EvaluationEnvelope{Kind: ruletypes.RollingEvaluation, Spec: ruletypes.RollingWindow{
 			EvalWindow: evalWindow,
 			Frequency:  valuer.MustParseTextDuration("1m"),
 		}},
 		RuleCondition: &ruletypes.RuleCondition{
-			CompareOperator: ruletypes.ValueIsAbove,
-			MatchType:       ruletypes.AtleastOnce,
-			Target:          &target,
-			CompositeQuery: &ruletypes.AlertCompositeQuery{
-				QueryType: ruletypes.QueryTypeBuilder,
-				Queries: []qbtypes.QueryEnvelope{{
-					Type: qbtypes.QueryTypeBuilder,
-					Spec: qbtypes.QueryBuilderQuery[qbtypes.MetricAggregation]{
-						Name:   "A",
-						Signal: telemetrytypes.SignalMetrics,
+			CompareOp: ruletypes.ValueIsAbove,
+			MatchType: ruletypes.AtleastOnce,
+			Target:    &target,
+			CompositeQuery: &v3.CompositeQuery{
+				QueryType: v3.QueryTypeBuilder,
+				BuilderQueries: map[string]*v3.BuilderQuery{
+					"A": {
+						QueryName:   "A",
+						Expression:  "A",
+						DataSource:  v3.DataSourceMetrics,
+						Temporality: v3.Unspecified,
 					},
-				}},
+				},
 			},
 			SelectedQuery: "A",
-			Seasonality:   ruletypes.SeasonalityDaily,
+			Seasonality:   "daily",
 			Thresholds: &ruletypes.RuleThresholdData{
 				Kind: ruletypes.BasicThresholdKind,
 				Spec: ruletypes.BasicRuleThresholds{{
-					Name:            "Test anomaly no data",
-					TargetValue:     &target,
-					MatchType:       ruletypes.AtleastOnce,
-					CompareOperator: ruletypes.ValueIsAbove,
+					Name:        "Test anomaly no data",
+					TargetValue: &target,
+					MatchType:   ruletypes.AtleastOnce,
+					CompareOp:   ruletypes.ValueIsAbove,
 				}},
 			},
 		},
 	}
 
-	responseNoData := &anomaly.AnomaliesResponse{
-		Results: []*qbtypes.TimeSeriesData{
+	responseNoData := &anomaly.GetAnomaliesResponse{
+		Results: []*v3.Result{
 			{
-				QueryName: "A",
-				Aggregations: []*qbtypes.AggregationBucket{{
-					AnomalyScores: []*qbtypes.TimeSeries{},
-				}},
+				QueryName:     "A",
+				AnomalyScores: []*v3.Series{},
 			},
 		},
 	}
@@ -114,17 +115,23 @@ func TestAnomalyRule_NoData_AlertOnAbsent(t *testing.T) {
 		t.Run(c.description, func(t *testing.T) {
 			postableRule.RuleCondition.AlertOnAbsent = c.alertOnAbsent
 
+			telemetryStore := telemetrystoretest.New(telemetrystore.Config{}, nil)
+			options := clickhouseReader.NewOptions("primaryNamespace")
+			reader := clickhouseReader.NewReader(slog.Default(), nil, telemetryStore, nil, "", time.Second, nil, nil, options)
+
 			rule, err := NewAnomalyRule(
 				"test-anomaly-rule",
 				valuer.GenerateUUID(),
 				&postableRule,
+				reader,
 				nil,
 				logger,
+				nil,
 			)
 			require.NoError(t, err)
 
 			rule.provider = &mockAnomalyProvider{
-				responses: []*anomaly.AnomaliesResponse{responseNoData},
+				responses: []*anomaly.GetAnomaliesResponse{responseNoData},
 			}
 
 			alertsFound, err := rule.Eval(context.Background(), evalTime)
@@ -149,47 +156,46 @@ func TestAnomalyRule_NoData_AbsentFor(t *testing.T) {
 	postableRule := ruletypes.PostableRule{
 		AlertName: "Test anomaly no data with AbsentFor",
 		AlertType: ruletypes.AlertTypeMetric,
-		RuleType:  ruletypes.RuleTypeAnomaly,
+		RuleType:  RuleTypeAnomaly,
 		Evaluation: &ruletypes.EvaluationEnvelope{Kind: ruletypes.RollingEvaluation, Spec: ruletypes.RollingWindow{
 			EvalWindow: evalWindow,
 			Frequency:  valuer.MustParseTextDuration("1m"),
 		}},
 		RuleCondition: &ruletypes.RuleCondition{
-			CompareOperator: ruletypes.ValueIsAbove,
-			MatchType:       ruletypes.AtleastOnce,
-			AlertOnAbsent:   true,
-			Target:          &target,
-			CompositeQuery: &ruletypes.AlertCompositeQuery{
-				QueryType: ruletypes.QueryTypeBuilder,
-				Queries: []qbtypes.QueryEnvelope{{
-					Type: qbtypes.QueryTypeBuilder,
-					Spec: qbtypes.QueryBuilderQuery[qbtypes.MetricAggregation]{
-						Name:   "A",
-						Signal: telemetrytypes.SignalMetrics,
+			CompareOp:     ruletypes.ValueIsAbove,
+			MatchType:     ruletypes.AtleastOnce,
+			AlertOnAbsent: true,
+			Target:        &target,
+			CompositeQuery: &v3.CompositeQuery{
+				QueryType: v3.QueryTypeBuilder,
+				BuilderQueries: map[string]*v3.BuilderQuery{
+					"A": {
+						QueryName:   "A",
+						Expression:  "A",
+						DataSource:  v3.DataSourceMetrics,
+						Temporality: v3.Unspecified,
 					},
-				}},
+				},
 			},
 			SelectedQuery: "A",
-			Seasonality:   ruletypes.SeasonalityDaily,
+			Seasonality:   "daily",
 			Thresholds: &ruletypes.RuleThresholdData{
 				Kind: ruletypes.BasicThresholdKind,
 				Spec: ruletypes.BasicRuleThresholds{{
-					Name:            "Test anomaly no data with AbsentFor",
-					TargetValue:     &target,
-					MatchType:       ruletypes.AtleastOnce,
-					CompareOperator: ruletypes.ValueIsAbove,
+					Name:        "Test anomaly no data with AbsentFor",
+					TargetValue: &target,
+					MatchType:   ruletypes.AtleastOnce,
+					CompareOp:   ruletypes.ValueIsAbove,
 				}},
 			},
 		},
 	}
 
-	responseNoData := &anomaly.AnomaliesResponse{
-		Results: []*qbtypes.TimeSeriesData{
+	responseNoData := &anomaly.GetAnomaliesResponse{
+		Results: []*v3.Result{
 			{
-				QueryName: "A",
-				Aggregations: []*qbtypes.AggregationBucket{{
-					AnomalyScores: []*qbtypes.TimeSeries{},
-				}},
+				QueryName:     "A",
+				AnomalyScores: []*v3.Series{},
 			},
 		},
 	}
@@ -223,35 +229,32 @@ func TestAnomalyRule_NoData_AbsentFor(t *testing.T) {
 			t1 := baseTime.Add(5 * time.Minute)
 			t2 := t1.Add(c.timeBetweenEvals)
 
-			responseWithData := &anomaly.AnomaliesResponse{
-				Results: []*qbtypes.TimeSeriesData{
+			responseWithData := &anomaly.GetAnomaliesResponse{
+				Results: []*v3.Result{
 					{
 						QueryName: "A",
-						Aggregations: []*qbtypes.AggregationBucket{{
-							AnomalyScores: []*qbtypes.TimeSeries{
-								{
-									Labels: []*qbtypes.Label{
-										{
-											Key:   telemetrytypes.TelemetryFieldKey{Name: "Test"},
-											Value: "labels",
-										},
-									},
-									Values: []*qbtypes.TimeSeriesValue{
-										{Timestamp: baseTime.UnixMilli(), Value: 1.0},
-										{Timestamp: baseTime.Add(time.Minute).UnixMilli(), Value: 1.5},
-									},
+						AnomalyScores: []*v3.Series{
+							{
+								Labels: map[string]string{"test": "label"},
+								Points: []v3.Point{
+									{Timestamp: baseTime.UnixMilli(), Value: 1.0},
+									{Timestamp: baseTime.Add(time.Minute).UnixMilli(), Value: 1.5},
 								},
 							},
-						}},
+						},
 					},
 				},
 			}
 
-			rule, err := NewAnomalyRule("test-anomaly-rule", valuer.GenerateUUID(), &postableRule, nil, logger)
+			telemetryStore := telemetrystoretest.New(telemetrystore.Config{}, nil)
+			options := clickhouseReader.NewOptions("primaryNamespace")
+			reader := clickhouseReader.NewReader(slog.Default(), nil, telemetryStore, nil, "", time.Second, nil, nil, options)
+
+			rule, err := NewAnomalyRule("test-anomaly-rule", valuer.GenerateUUID(), &postableRule, reader, nil, logger, nil)
 			require.NoError(t, err)
 
 			rule.provider = &mockAnomalyProvider{
-				responses: []*anomaly.AnomaliesResponse{responseWithData, responseNoData},
+				responses: []*anomaly.GetAnomaliesResponse{responseWithData, responseNoData},
 			}
 
 			alertsFound1, err := rule.Eval(context.Background(), t1)

ee/query-service/rules/manager.go

@@ -11,7 +11,9 @@ import (
 	"github.com/google/uuid"
 
 	"github.com/SigNoz/signoz/pkg/errors"
+	basemodel "github.com/SigNoz/signoz/pkg/query-service/model"
 	baserules "github.com/SigNoz/signoz/pkg/query-service/rules"
+	"github.com/SigNoz/signoz/pkg/query-service/utils/labels"
 	"github.com/SigNoz/signoz/pkg/types/ruletypes"
 	"github.com/SigNoz/signoz/pkg/valuer"
 )
@@ -21,25 +23,24 @@ func PrepareTaskFunc(opts baserules.PrepareTaskOptions) (baserules.Task, error)
 	rules := make([]baserules.Rule, 0)
 	var task baserules.Task
 
-	ruleID := baserules.RuleIDFromTaskName(opts.TaskName)
+	ruleId := baserules.RuleIdFromTaskName(opts.TaskName)
 	evaluation, err := opts.Rule.Evaluation.GetEvaluation()
 	if err != nil {
 		return nil, errors.NewInvalidInputf(errors.CodeInvalidInput, "evaluation is invalid: %v", err)
 	}
-
 	if opts.Rule.RuleType == ruletypes.RuleTypeThreshold {
 		// create a threshold rule
 		tr, err := baserules.NewThresholdRule(
-			ruleID,
+			ruleId,
 			opts.OrgID,
 			opts.Rule,
+			opts.Reader,
 			opts.Querier,
 			opts.Logger,
 			baserules.WithEvalDelay(opts.ManagerOpts.EvalDelay),
 			baserules.WithSQLStore(opts.SQLStore),
 			baserules.WithQueryParser(opts.ManagerOpts.QueryParser),
 			baserules.WithMetadataStore(opts.ManagerOpts.MetadataStore),
-			baserules.WithRuleStateHistoryModule(opts.ManagerOpts.RuleStateHistoryModule),
 		)
 
 		if err != nil {
@@ -55,15 +56,15 @@ func PrepareTaskFunc(opts baserules.PrepareTaskOptions) (baserules.Task, error)
 
 		// create promql rule
 		pr, err := baserules.NewPromRule(
-			ruleID,
+			ruleId,
 			opts.OrgID,
 			opts.Rule,
 			opts.Logger,
+			opts.Reader,
 			opts.ManagerOpts.Prometheus,
 			baserules.WithSQLStore(opts.SQLStore),
 			baserules.WithQueryParser(opts.ManagerOpts.QueryParser),
 			baserules.WithMetadataStore(opts.ManagerOpts.MetadataStore),
-			baserules.WithRuleStateHistoryModule(opts.ManagerOpts.RuleStateHistoryModule),
 		)
 
 		if err != nil {
@@ -78,16 +79,17 @@ func PrepareTaskFunc(opts baserules.PrepareTaskOptions) (baserules.Task, error)
 	} else if opts.Rule.RuleType == ruletypes.RuleTypeAnomaly {
 		// create anomaly rule
 		ar, err := NewAnomalyRule(
-			ruleID,
+			ruleId,
 			opts.OrgID,
 			opts.Rule,
+			opts.Reader,
 			opts.Querier,
 			opts.Logger,
+			opts.Cache,
 			baserules.WithEvalDelay(opts.ManagerOpts.EvalDelay),
 			baserules.WithSQLStore(opts.SQLStore),
 			baserules.WithQueryParser(opts.ManagerOpts.QueryParser),
 			baserules.WithMetadataStore(opts.ManagerOpts.MetadataStore),
-			baserules.WithRuleStateHistoryModule(opts.ManagerOpts.RuleStateHistoryModule),
 		)
 		if err != nil {
 			return task, err
@@ -99,7 +101,7 @@ func PrepareTaskFunc(opts baserules.PrepareTaskOptions) (baserules.Task, error)
 		task = newTask(baserules.TaskTypeCh, opts.TaskName, evaluation.GetFrequency().Duration(), rules, opts.ManagerOpts, opts.NotifyFunc, opts.MaintenanceStore, opts.OrgID)
 
 	} else {
-		return nil, errors.NewInvalidInputf(errors.CodeInvalidInput, "unsupported rule type %s. Supported types: %s, %s", opts.Rule.RuleType, ruletypes.RuleTypeProm, ruletypes.RuleTypeThreshold)
+		return nil, fmt.Errorf("unsupported rule type %s. Supported types: %s, %s", opts.Rule.RuleType, ruletypes.RuleTypeProm, ruletypes.RuleTypeThreshold)
 	}
 
 	return task, nil
@@ -107,12 +109,12 @@ func PrepareTaskFunc(opts baserules.PrepareTaskOptions) (baserules.Task, error)
 
 // TestNotification prepares a dummy rule for given rule parameters and
 // sends a test notification. returns alert count and error (if any)
-func TestNotification(opts baserules.PrepareTestRuleOptions) (int, error) {
+func TestNotification(opts baserules.PrepareTestRuleOptions) (int, *basemodel.ApiError) {
 
 	ctx := context.Background()
 
 	if opts.Rule == nil {
-		return 0, errors.NewInvalidInputf(errors.CodeInvalidInput, "rule is required")
+		return 0, basemodel.BadRequest(fmt.Errorf("rule is required"))
 	}
 
 	parsedRule := opts.Rule
@@ -132,14 +134,15 @@ func TestNotification(opts baserules.PrepareTestRuleOptions) (int, error) {
 	if parsedRule.RuleType == ruletypes.RuleTypeThreshold {
 
 		// add special labels for test alerts
-		parsedRule.Labels[ruletypes.RuleSourceLabel] = ""
-		parsedRule.Labels[ruletypes.AlertRuleIDLabel] = ""
+		parsedRule.Labels[labels.RuleSourceLabel] = ""
+		parsedRule.Labels[labels.AlertRuleIdLabel] = ""
 
 		// create a threshold rule
 		rule, err = baserules.NewThresholdRule(
 			alertname,
 			opts.OrgID,
 			parsedRule,
+			opts.Reader,
 			opts.Querier,
 			opts.Logger,
 			baserules.WithSendAlways(),
@@ -151,7 +154,7 @@ func TestNotification(opts baserules.PrepareTestRuleOptions) (int, error) {
 
 		if err != nil {
 			slog.Error("failed to prepare a new threshold rule for test", "name", alertname, errors.Attr(err))
-			return 0, err
+			return 0, basemodel.BadRequest(err)
 		}
 
 	} else if parsedRule.RuleType == ruletypes.RuleTypeProm {
@@ -162,6 +165,7 @@ func TestNotification(opts baserules.PrepareTestRuleOptions) (int, error) {
 			opts.OrgID,
 			parsedRule,
 			opts.Logger,
+			opts.Reader,
 			opts.ManagerOpts.Prometheus,
 			baserules.WithSendAlways(),
 			baserules.WithSendUnmatched(),
@@ -172,7 +176,7 @@ func TestNotification(opts baserules.PrepareTestRuleOptions) (int, error) {
 
 		if err != nil {
 			slog.Error("failed to prepare a new promql rule for test", "name", alertname, errors.Attr(err))
-			return 0, err
+			return 0, basemodel.BadRequest(err)
 		}
 	} else if parsedRule.RuleType == ruletypes.RuleTypeAnomaly {
 		// create anomaly rule
@@ -180,8 +184,10 @@ func TestNotification(opts baserules.PrepareTestRuleOptions) (int, error) {
 			alertname,
 			opts.OrgID,
 			parsedRule,
+			opts.Reader,
 			opts.Querier,
 			opts.Logger,
+			opts.Cache,
 			baserules.WithSendAlways(),
 			baserules.WithSendUnmatched(),
 			baserules.WithSQLStore(opts.SQLStore),
@@ -190,10 +196,10 @@ func TestNotification(opts baserules.PrepareTestRuleOptions) (int, error) {
 		)
 		if err != nil {
 			slog.Error("failed to prepare a new anomaly rule for test", "name", alertname, errors.Attr(err))
-			return 0, err
+			return 0, basemodel.BadRequest(err)
 		}
 	} else {
-		return 0, errors.NewInvalidInputf(errors.CodeInvalidInput, "failed to derive ruletype with given information")
+		return 0, basemodel.BadRequest(fmt.Errorf("failed to derive ruletype with given information"))
 	}
 
 	// set timestamp to current utc time
@@ -202,7 +208,7 @@ func TestNotification(opts baserules.PrepareTestRuleOptions) (int, error) {
 	alertsFound, err := rule.Eval(ctx, ts)
 	if err != nil {
 		slog.Error("evaluating rule failed", "rule", rule.Name(), errors.Attr(err))
-		return 0, err
+		return 0, basemodel.InternalError(fmt.Errorf("rule evaluation failed"))
 	}
 	rule.SendAlerts(ctx, ts, 0, time.Minute, opts.NotifyFunc)
 

ee/query-service/rules/manager_test.go

@@ -114,8 +114,11 @@ func TestManager_TestNotification_SendUnmatched_ThresholdRule(t *testing.T) {
 				},
 			})
 
-			count, err := mgr.TestNotification(context.Background(), orgID, string(ruleBytes))
-			require.Nil(t, err)
+			count, apiErr := mgr.TestNotification(context.Background(), orgID, string(ruleBytes))
+			if apiErr != nil {
+				t.Logf("TestNotification error: %v, type: %s", apiErr.Err, apiErr.Typ)
+			}
+			require.Nil(t, apiErr)
 			assert.Equal(t, tc.ExpectAlerts, count)
 
 			if tc.ExpectAlerts > 0 {
@@ -265,8 +268,11 @@ func TestManager_TestNotification_SendUnmatched_PromRule(t *testing.T) {
 				},
 			})
 
-			count, err := mgr.TestNotification(context.Background(), orgID, string(ruleBytes))
-			require.Nil(t, err)
+			count, apiErr := mgr.TestNotification(context.Background(), orgID, string(ruleBytes))
+			if apiErr != nil {
+				t.Logf("TestNotification error: %v, type: %s", apiErr.Err, apiErr.Typ)
+			}
+			require.Nil(t, apiErr)
 			assert.Equal(t, tc.ExpectAlerts, count)
 
 			if tc.ExpectAlerts > 0 {

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/.eslintrc.cjs

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

frontend/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/__mocks__/useSafeNavigate.ts

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

frontend/package.json

@@ -68,8 +68,8 @@
     "@signozhq/toggle-group": "0.0.1",
     "@signozhq/tooltip": "0.0.2",
     "@signozhq/ui": "0.0.5",
-    "@tanstack/react-table": "8.21.3",
-    "@tanstack/react-virtual": "3.13.22",
+    "@tanstack/react-table": "8.20.6",
+    "@tanstack/react-virtual": "3.11.2",
     "@uiw/codemirror-theme-copilot": "4.23.11",
     "@uiw/codemirror-theme-github": "4.24.1",
     "@uiw/react-codemirror": "4.23.10",
@@ -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/public/Logos/hasura.svg

@@ -1 +0,0 @@
-<svg xmlns="http://www.w3.org/2000/svg" fill="#1eb4d4" viewBox="0 0 24 24"><title>Hasura</title><path d="M23.558 8.172c.707-2.152.282-6.447-1.09-8.032a.42.42 0 0 0-.664.051l-1.69 2.59a1.32 1.32 0 0 1-1.737.276C16.544 1.885 14.354 1.204 12 1.204s-4.544.68-6.378 1.853a1.326 1.326 0 0 1-1.736-.276L2.196.191A.42.42 0 0 0 1.532.14C.16 1.728-.265 6.023.442 8.172c.236.716.3 1.472.16 2.207-.137.73-.276 1.61-.276 2.223C.326 18.898 5.553 24 11.997 24c6.447 0 11.671-5.105 11.671-11.398 0-.613-.138-1.494-.276-2.223a4.47 4.47 0 0 1 .166-2.207m-11.56 13.284c-4.984 0-9.036-3.96-9.036-8.827q0-.239.014-.473c.18-3.316 2.243-6.15 5.16-7.5 1.17-.546 2.481-.848 3.864-.848s2.69.302 3.864.85c2.917 1.351 4.98 4.187 5.16 7.501q.013.236.014.473c-.003 4.864-4.057 8.824-9.04 8.824m3.915-5.43-2.31-3.91-1.98-3.26a.26.26 0 0 0-.223-.125H9.508a.26.26 0 0 0-.227.13.25.25 0 0 0 .003.254l1.895 3.109-2.542 3.787a.25.25 0 0 0-.011.259.26.26 0 0 0 .23.132h1.905a.26.26 0 0 0 .218-.116l1.375-2.096 1.233 2.088a.26.26 0 0 0 .224.127h1.878c.094 0 .18-.049.224-.127a.24.24 0 0 0 0-.251z"/></svg>

frontend/public/Logos/n8n.svg

@@ -1 +0,0 @@
-<svg xmlns="http://www.w3.org/2000/svg" fill="#ea4b71" viewBox="0 0 24 24"><title>n8n</title><path d="M21.474 5.684a2.53 2.53 0 0 0-2.447 1.895H16.13a2.526 2.526 0 0 0-2.492 2.11l-.103.624a1.26 1.26 0 0 1-1.246 1.055h-1.001a2.527 2.527 0 0 0-4.893 0H4.973a2.527 2.527 0 1 0 0 1.264h1.422a2.527 2.527 0 0 0 4.894 0h1a1.26 1.26 0 0 1 1.247 1.055l.103.623a2.526 2.526 0 0 0 2.492 2.111h.37a2.527 2.527 0 1 0 0-1.263h-.37a1.26 1.26 0 0 1-1.246-1.056l-.103-.623A2.52 2.52 0 0 0 13.96 12a2.52 2.52 0 0 0 .82-1.48l.104-.622a1.26 1.26 0 0 1 1.246-1.056h2.896a2.527 2.527 0 1 0 2.447-3.158m0 1.263a1.263 1.263 0 0 1 1.263 1.263 1.263 1.263 0 0 1-1.263 1.264A1.263 1.263 0 0 1 20.21 8.21a1.263 1.263 0 0 1 1.264-1.263m-18.948 3.79A1.263 1.263 0 0 1 3.79 12a1.263 1.263 0 0 1-1.264 1.263A1.263 1.263 0 0 1 1.263 12a1.263 1.263 0 0 1 1.263-1.263m6.316 0A1.263 1.263 0 0 1 10.105 12a1.263 1.263 0 0 1-1.263 1.263A1.263 1.263 0 0 1 7.58 12a1.263 1.263 0 0 1 1.263-1.263m10.106 3.79a1.263 1.263 0 0 1 1.263 1.263 1.263 1.263 0 0 1-1.263 1.263 1.263 1.263 0 0 1-1.264-1.263 1.263 1.263 0 0 1 1.263-1.264"/></svg>

frontend/src/AppRoutes/Private.tsx

@@ -1,8 +1,9 @@
 import { ReactChild, useCallback, useEffect, useMemo, useState } from 'react';
+import { useQuery } from 'react-query';
 import { matchPath, Redirect, useLocation } from 'react-router-dom';
 import getLocalStorageApi from 'api/browser/localstorage/get';
 import setLocalStorageApi from 'api/browser/localstorage/set';
-import { useListUsers } from 'api/generated/services/users';
+import getAll from 'api/v1/user/get';
 import { FeatureKeys } from 'constants/features';
 import { LOCALSTORAGE } from 'constants/localStorage';
 import { ORG_PREFERENCES } from 'constants/orgPreferences';
@@ -11,9 +12,12 @@ import { useGetTenantLicense } from 'hooks/useGetTenantLicense';
 import history from 'lib/history';
 import { isEmpty } from 'lodash-es';
 import { useAppContext } from 'providers/App/App';
+import { SuccessResponseV2 } from 'types/api';
+import APIError from 'types/api/error';
 import { LicensePlatform, LicenseState } from 'types/api/licensesV3/getActive';
 import { OrgPreference } from 'types/api/preferences/preference';
 import { Organization } from 'types/api/user/getOrganization';
+import { UserResponse } from 'types/api/user/getUser';
 import { USER_ROLES } from 'types/roles';
 import { routePermission } from 'utils/permission';
 
@@ -59,10 +63,18 @@ function PrivateRoute({ children }: PrivateRouteProps): JSX.Element {
 
 	const [orgData, setOrgData] = useState<Organization | undefined>(undefined);
 
-	const { data: usersData, isFetching: isFetchingUsers } = useListUsers({
-		query: {
-			enabled: !isEmpty(orgData) && user.role === 'ADMIN',
+	const { data: usersData, isFetching: isFetchingUsers } = useQuery<
+		SuccessResponseV2<UserResponse[]> | undefined,
+		APIError
+	>({
+		queryFn: () => {
+			if (orgData && orgData.id !== undefined) {
+				return getAll();
+			}
+			return undefined;
 		},
+		queryKey: ['getOrgUser'],
+		enabled: !isEmpty(orgData) && user.role === 'ADMIN',
 	});
 
 	const checkFirstTimeUser = useCallback((): boolean => {
@@ -89,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 &&
@@ -123,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;
@@ -161,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/AppRoutes/index.tsx

@@ -18,7 +18,7 @@ import AppLayout from 'container/AppLayout';
 import Hex from 'crypto-js/enc-hex';
 import HmacSHA256 from 'crypto-js/hmac-sha256';
 import { KeyboardHotkeysProvider } from 'hooks/hotkeys/useKeyboardHotkeys';
-import { useIsDarkMode, useThemeConfig } from 'hooks/useDarkMode';
+import { useThemeConfig } from 'hooks/useDarkMode';
 import { useGetTenantLicense } from 'hooks/useGetTenantLicense';
 import { NotificationProvider } from 'hooks/useNotifications';
 import { ResourceProvider } from 'hooks/useResourceAttribute';
@@ -212,12 +212,6 @@ function App(): JSX.Element {
 		activeLicenseFetchError,
 	]);
 
-	const isDarkMode = useIsDarkMode();
-
-	useEffect(() => {
-		window.Pylon?.('setTheme', isDarkMode ? 'dark' : 'light');
-	}, [isDarkMode]);
-
 	useEffect(() => {
 		if (
 			pathname === ROUTES.ONBOARDING ||

frontend/src/AppRoutes/pageComponents.ts

@@ -157,6 +157,10 @@ export const IngestionSettings = Loadable(
 	() => import(/* webpackChunkName: "Ingestion Settings" */ 'pages/Settings'),
 );
 
+export const APIKeys = Loadable(
+	() => import(/* webpackChunkName: "All Settings" */ 'pages/Settings'),
+);
+
 export const MySettings = Loadable(
 	() => import(/* webpackChunkName: "All MySettings" */ 'pages/Settings'),
 );

frontend/src/AppRoutes/routes.ts

@@ -513,7 +513,6 @@ export const oldRoutes = [
 	'/logs-save-views',
 	'/traces-save-views',
 	'/settings/access-tokens',
-	'/settings/api-keys',
 	'/messaging-queues',
 	'/alerts/edit',
 ];
@@ -524,8 +523,7 @@ export const oldNewRoutesMapping: Record<string, string> = {
 	'/logs-explorer/live': '/logs/logs-explorer/live',
 	'/logs-save-views': '/logs/saved-views',
 	'/traces-save-views': '/traces/saved-views',
-	'/settings/access-tokens': '/settings/service-accounts',
-	'/settings/api-keys': '/settings/service-accounts',
+	'/settings/access-tokens': '/settings/api-keys',
 	'/messaging-queues': '/messaging-queues/overview',
 	'/alerts/edit': '/alerts/overview',
 };

frontend/src/__tests__/query_range_v5.util.ts

@@ -1,126 +0,0 @@
-import { rest, RestRequest } from 'msw';
-
-import { ENVIRONMENT } from '../constants/env';
-import { server } from '../mocks-server/server';
-import { MetricRangePayloadV5 } from '../types/api/v5/queryRange';
-
-const QUERY_RANGE_URL = `${ENVIRONMENT.baseURL}/api/v5/query_range`;
-
-export type MockLogsOptions = {
-	offset?: number;
-	pageSize?: number;
-	hasMore?: boolean;
-	delay?: number;
-	onReceiveRequest?: (
-		req: RestRequest,
-	) =>
-		| undefined
-		| void
-		| Omit<MockLogsOptions, 'onReceiveRequest'>
-		| Promise<Omit<MockLogsOptions, 'onReceiveRequest'>>
-		| Promise<void>;
-};
-
-const createLogsResponse = ({
-	offset = 0,
-	pageSize = 100,
-	hasMore = true,
-}: MockLogsOptions): MetricRangePayloadV5 => {
-	const itemsForThisPage = hasMore ? pageSize : pageSize / 2;
-
-	return {
-		data: {
-			type: 'raw',
-			data: {
-				results: [
-					{
-						queryName: 'A',
-						rows: Array.from({ length: itemsForThisPage }, (_, index) => {
-							const cumulativeIndex = offset + index;
-							const baseTimestamp = new Date('2024-02-15T21:20:22Z').getTime();
-							const currentTimestamp = new Date(
-								baseTimestamp - cumulativeIndex * 1000,
-							);
-							const timestampString = currentTimestamp.toISOString();
-							const id = `log-id-${cumulativeIndex}`;
-							const logLevel = ['INFO', 'WARN', 'ERROR'][cumulativeIndex % 3];
-							const service = ['frontend', 'backend', 'database'][cumulativeIndex % 3];
-
-							return {
-								timestamp: timestampString,
-								data: {
-									attributes_bool: {},
-									attributes_float64: {},
-									attributes_int64: {},
-									attributes_string: {
-										host_name: 'test-host',
-										log_level: logLevel,
-										service,
-									},
-									body: `${timestampString} ${logLevel} ${service} Log message ${cumulativeIndex}`,
-									id,
-									resources_string: {
-										'host.name': 'test-host',
-									},
-									severity_number: [9, 13, 17][cumulativeIndex % 3],
-									severity_text: logLevel,
-									span_id: `span-${cumulativeIndex}`,
-									trace_flags: 0,
-									trace_id: `trace-${cumulativeIndex}`,
-								},
-							};
-						}),
-					},
-				],
-			},
-			meta: {
-				bytesScanned: 0,
-				durationMs: 0,
-				rowsScanned: 0,
-				stepIntervals: {},
-			},
-		},
-	};
-};
-
-export function mockQueryRangeV5WithLogsResponse({
-	hasMore = true,
-	offset = 0,
-	pageSize = 100,
-	delay = 0,
-	onReceiveRequest,
-}: MockLogsOptions = {}): void {
-	server.use(
-		rest.post(QUERY_RANGE_URL, async (req, res, ctx) =>
-			res(
-				...(delay ? [ctx.delay(delay)] : []),
-				ctx.status(200),
-				ctx.json(
-					createLogsResponse(
-						(await onReceiveRequest?.(req)) ?? {
-							hasMore,
-							pageSize,
-							offset,
-						},
-					),
-				),
-			),
-		),
-	);
-}
-
-export function mockQueryRangeV5WithError(
-	error: string,
-	statusCode = 500,
-): void {
-	server.use(
-		rest.post(QUERY_RANGE_URL, (_, res, ctx) =>
-			res(
-				ctx.status(statusCode),
-				ctx.json({
-					error,
-				}),
-			),
-		),
-	);
-}

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

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

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

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

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

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

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

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

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

@@ -23,15 +23,9 @@ import type {
 	CreateServiceAccount201,
 	CreateServiceAccountKey201,
 	CreateServiceAccountKeyPathParameters,
-	CreateServiceAccountRole201,
-	CreateServiceAccountRolePathParameters,
 	DeleteServiceAccountPathParameters,
-	DeleteServiceAccountRolePathParameters,
-	GetMyServiceAccount200,
 	GetServiceAccount200,
 	GetServiceAccountPathParameters,
-	GetServiceAccountRoles200,
-	GetServiceAccountRolesPathParameters,
 	ListServiceAccountKeys200,
 	ListServiceAccountKeysPathParameters,
 	ListServiceAccounts200,
@@ -39,10 +33,12 @@ import type {
 	RevokeServiceAccountKeyPathParameters,
 	ServiceaccounttypesPostableFactorAPIKeyDTO,
 	ServiceaccounttypesPostableServiceAccountDTO,
-	ServiceaccounttypesPostableServiceAccountRoleDTO,
 	ServiceaccounttypesUpdatableFactorAPIKeyDTO,
+	ServiceaccounttypesUpdatableServiceAccountDTO,
+	ServiceaccounttypesUpdatableServiceAccountStatusDTO,
 	UpdateServiceAccountKeyPathParameters,
 	UpdateServiceAccountPathParameters,
+	UpdateServiceAccountStatusPathParameters,
 } from '../sigNoz.schemas';
 
 /**
@@ -403,13 +399,13 @@ export const invalidateGetServiceAccount = async (
  */
 export const updateServiceAccount = (
 	{ id }: UpdateServiceAccountPathParameters,
-	serviceaccounttypesPostableServiceAccountDTO: BodyType<ServiceaccounttypesPostableServiceAccountDTO>,
+	serviceaccounttypesUpdatableServiceAccountDTO: BodyType<ServiceaccounttypesUpdatableServiceAccountDTO>,
 ) => {
 	return GeneratedAPIInstance<string>({
 		url: `/api/v1/service_accounts/${id}`,
 		method: 'PUT',
 		headers: { 'Content-Type': 'application/json' },
-		data: serviceaccounttypesPostableServiceAccountDTO,
+		data: serviceaccounttypesUpdatableServiceAccountDTO,
 	});
 };
 
@@ -422,7 +418,7 @@ export const getUpdateServiceAccountMutationOptions = <
 		TError,
 		{
 			pathParams: UpdateServiceAccountPathParameters;
-			data: BodyType<ServiceaccounttypesPostableServiceAccountDTO>;
+			data: BodyType<ServiceaccounttypesUpdatableServiceAccountDTO>;
 		},
 		TContext
 	>;
@@ -431,7 +427,7 @@ export const getUpdateServiceAccountMutationOptions = <
 	TError,
 	{
 		pathParams: UpdateServiceAccountPathParameters;
-		data: BodyType<ServiceaccounttypesPostableServiceAccountDTO>;
+		data: BodyType<ServiceaccounttypesUpdatableServiceAccountDTO>;
 	},
 	TContext
 > => {
@@ -448,7 +444,7 @@ export const getUpdateServiceAccountMutationOptions = <
 		Awaited<ReturnType<typeof updateServiceAccount>>,
 		{
 			pathParams: UpdateServiceAccountPathParameters;
-			data: BodyType<ServiceaccounttypesPostableServiceAccountDTO>;
+			data: BodyType<ServiceaccounttypesUpdatableServiceAccountDTO>;
 		}
 	> = (props) => {
 		const { pathParams, data } = props ?? {};
@@ -462,7 +458,7 @@ export const getUpdateServiceAccountMutationOptions = <
 export type UpdateServiceAccountMutationResult = NonNullable<
 	Awaited<ReturnType<typeof updateServiceAccount>>
 >;
-export type UpdateServiceAccountMutationBody = BodyType<ServiceaccounttypesPostableServiceAccountDTO>;
+export type UpdateServiceAccountMutationBody = BodyType<ServiceaccounttypesUpdatableServiceAccountDTO>;
 export type UpdateServiceAccountMutationError = ErrorType<RenderErrorResponseDTO>;
 
 /**
@@ -477,7 +473,7 @@ export const useUpdateServiceAccount = <
 		TError,
 		{
 			pathParams: UpdateServiceAccountPathParameters;
-			data: BodyType<ServiceaccounttypesPostableServiceAccountDTO>;
+			data: BodyType<ServiceaccounttypesUpdatableServiceAccountDTO>;
 		},
 		TContext
 	>;
@@ -486,7 +482,7 @@ export const useUpdateServiceAccount = <
 	TError,
 	{
 		pathParams: UpdateServiceAccountPathParameters;
-		data: BodyType<ServiceaccounttypesPostableServiceAccountDTO>;
+		data: BodyType<ServiceaccounttypesUpdatableServiceAccountDTO>;
 	},
 	TContext
 > => {
@@ -875,150 +871,44 @@ export const useUpdateServiceAccountKey = <
 	return useMutation(mutationOptions);
 };
 /**
- * This endpoint gets all the roles for the existing service account
- * @summary Gets service account roles
+ * This endpoint updates an existing service account status
+ * @summary Updates a service account status
  */
-export const getServiceAccountRoles = (
-	{ id }: GetServiceAccountRolesPathParameters,
-	signal?: AbortSignal,
+export const updateServiceAccountStatus = (
+	{ id }: UpdateServiceAccountStatusPathParameters,
+	serviceaccounttypesUpdatableServiceAccountStatusDTO: BodyType<ServiceaccounttypesUpdatableServiceAccountStatusDTO>,
 ) => {
-	return GeneratedAPIInstance<GetServiceAccountRoles200>({
-		url: `/api/v1/service_accounts/${id}/roles`,
-		method: 'GET',
-		signal,
-	});
-};
-
-export const getGetServiceAccountRolesQueryKey = ({
-	id,
-}: GetServiceAccountRolesPathParameters) => {
-	return [`/api/v1/service_accounts/${id}/roles`] as const;
-};
-
-export const getGetServiceAccountRolesQueryOptions = <
-	TData = Awaited<ReturnType<typeof getServiceAccountRoles>>,
-	TError = ErrorType<RenderErrorResponseDTO>
->(
-	{ id }: GetServiceAccountRolesPathParameters,
-	options?: {
-		query?: UseQueryOptions<
-			Awaited<ReturnType<typeof getServiceAccountRoles>>,
-			TError,
-			TData
-		>;
-	},
-) => {
-	const { query: queryOptions } = options ?? {};
-
-	const queryKey =
-		queryOptions?.queryKey ?? getGetServiceAccountRolesQueryKey({ id });
-
-	const queryFn: QueryFunction<
-		Awaited<ReturnType<typeof getServiceAccountRoles>>
-	> = ({ signal }) => getServiceAccountRoles({ id }, signal);
-
-	return {
-		queryKey,
-		queryFn,
-		enabled: !!id,
-		...queryOptions,
-	} as UseQueryOptions<
-		Awaited<ReturnType<typeof getServiceAccountRoles>>,
-		TError,
-		TData
-	> & { queryKey: QueryKey };
-};
-
-export type GetServiceAccountRolesQueryResult = NonNullable<
-	Awaited<ReturnType<typeof getServiceAccountRoles>>
->;
-export type GetServiceAccountRolesQueryError = ErrorType<RenderErrorResponseDTO>;
-
-/**
- * @summary Gets service account roles
- */
-
-export function useGetServiceAccountRoles<
-	TData = Awaited<ReturnType<typeof getServiceAccountRoles>>,
-	TError = ErrorType<RenderErrorResponseDTO>
->(
-	{ id }: GetServiceAccountRolesPathParameters,
-	options?: {
-		query?: UseQueryOptions<
-			Awaited<ReturnType<typeof getServiceAccountRoles>>,
-			TError,
-			TData
-		>;
-	},
-): UseQueryResult<TData, TError> & { queryKey: QueryKey } {
-	const queryOptions = getGetServiceAccountRolesQueryOptions({ id }, options);
-
-	const query = useQuery(queryOptions) as UseQueryResult<TData, TError> & {
-		queryKey: QueryKey;
-	};
-
-	query.queryKey = queryOptions.queryKey;
-
-	return query;
-}
-
-/**
- * @summary Gets service account roles
- */
-export const invalidateGetServiceAccountRoles = async (
-	queryClient: QueryClient,
-	{ id }: GetServiceAccountRolesPathParameters,
-	options?: InvalidateOptions,
-): Promise<QueryClient> => {
-	await queryClient.invalidateQueries(
-		{ queryKey: getGetServiceAccountRolesQueryKey({ id }) },
-		options,
-	);
-
-	return queryClient;
-};
-
-/**
- * This endpoint assigns a role to a service account
- * @summary Create service account role
- */
-export const createServiceAccountRole = (
-	{ id }: CreateServiceAccountRolePathParameters,
-	serviceaccounttypesPostableServiceAccountRoleDTO: BodyType<ServiceaccounttypesPostableServiceAccountRoleDTO>,
-	signal?: AbortSignal,
-) => {
-	return GeneratedAPIInstance<CreateServiceAccountRole201>({
-		url: `/api/v1/service_accounts/${id}/roles`,
-		method: 'POST',
+	return GeneratedAPIInstance<string>({
+		url: `/api/v1/service_accounts/${id}/status`,
+		method: 'PUT',
 		headers: { 'Content-Type': 'application/json' },
-		data: serviceaccounttypesPostableServiceAccountRoleDTO,
-		signal,
+		data: serviceaccounttypesUpdatableServiceAccountStatusDTO,
 	});
 };
 
-export const getCreateServiceAccountRoleMutationOptions = <
+export const getUpdateServiceAccountStatusMutationOptions = <
 	TError = ErrorType<RenderErrorResponseDTO>,
 	TContext = unknown
 >(options?: {
 	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof createServiceAccountRole>>,
+		Awaited<ReturnType<typeof updateServiceAccountStatus>>,
 		TError,
 		{
-			pathParams: CreateServiceAccountRolePathParameters;
-			data: BodyType<ServiceaccounttypesPostableServiceAccountRoleDTO>;
+			pathParams: UpdateServiceAccountStatusPathParameters;
+			data: BodyType<ServiceaccounttypesUpdatableServiceAccountStatusDTO>;
 		},
 		TContext
 	>;
 }): UseMutationOptions<
-	Awaited<ReturnType<typeof createServiceAccountRole>>,
+	Awaited<ReturnType<typeof updateServiceAccountStatus>>,
 	TError,
 	{
-		pathParams: CreateServiceAccountRolePathParameters;
-		data: BodyType<ServiceaccounttypesPostableServiceAccountRoleDTO>;
+		pathParams: UpdateServiceAccountStatusPathParameters;
+		data: BodyType<ServiceaccounttypesUpdatableServiceAccountStatusDTO>;
 	},
 	TContext
 > => {
-	const mutationKey = ['createServiceAccountRole'];
+	const mutationKey = ['updateServiceAccountStatus'];
 	const { mutation: mutationOptions } = options
 		? options.mutation &&
 		  'mutationKey' in options.mutation &&
@@ -1028,299 +918,52 @@ export const getCreateServiceAccountRoleMutationOptions = <
 		: { mutation: { mutationKey } };
 
 	const mutationFn: MutationFunction<
-		Awaited<ReturnType<typeof createServiceAccountRole>>,
+		Awaited<ReturnType<typeof updateServiceAccountStatus>>,
 		{
-			pathParams: CreateServiceAccountRolePathParameters;
-			data: BodyType<ServiceaccounttypesPostableServiceAccountRoleDTO>;
+			pathParams: UpdateServiceAccountStatusPathParameters;
+			data: BodyType<ServiceaccounttypesUpdatableServiceAccountStatusDTO>;
 		}
 	> = (props) => {
 		const { pathParams, data } = props ?? {};
 
-		return createServiceAccountRole(pathParams, data);
+		return updateServiceAccountStatus(pathParams, data);
 	};
 
 	return { mutationFn, ...mutationOptions };
 };
 
-export type CreateServiceAccountRoleMutationResult = NonNullable<
-	Awaited<ReturnType<typeof createServiceAccountRole>>
+export type UpdateServiceAccountStatusMutationResult = NonNullable<
+	Awaited<ReturnType<typeof updateServiceAccountStatus>>
 >;
-export type CreateServiceAccountRoleMutationBody = BodyType<ServiceaccounttypesPostableServiceAccountRoleDTO>;
-export type CreateServiceAccountRoleMutationError = ErrorType<RenderErrorResponseDTO>;
+export type UpdateServiceAccountStatusMutationBody = BodyType<ServiceaccounttypesUpdatableServiceAccountStatusDTO>;
+export type UpdateServiceAccountStatusMutationError = ErrorType<RenderErrorResponseDTO>;
 
 /**
- * @summary Create service account role
+ * @summary Updates a service account status
  */
-export const useCreateServiceAccountRole = <
+export const useUpdateServiceAccountStatus = <
 	TError = ErrorType<RenderErrorResponseDTO>,
 	TContext = unknown
 >(options?: {
 	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof createServiceAccountRole>>,
+		Awaited<ReturnType<typeof updateServiceAccountStatus>>,
 		TError,
 		{
-			pathParams: CreateServiceAccountRolePathParameters;
-			data: BodyType<ServiceaccounttypesPostableServiceAccountRoleDTO>;
+			pathParams: UpdateServiceAccountStatusPathParameters;
+			data: BodyType<ServiceaccounttypesUpdatableServiceAccountStatusDTO>;
 		},
 		TContext
 	>;
 }): UseMutationResult<
-	Awaited<ReturnType<typeof createServiceAccountRole>>,
+	Awaited<ReturnType<typeof updateServiceAccountStatus>>,
 	TError,
 	{
-		pathParams: CreateServiceAccountRolePathParameters;
-		data: BodyType<ServiceaccounttypesPostableServiceAccountRoleDTO>;
+		pathParams: UpdateServiceAccountStatusPathParameters;
+		data: BodyType<ServiceaccounttypesUpdatableServiceAccountStatusDTO>;
 	},
 	TContext
 > => {
-	const mutationOptions = getCreateServiceAccountRoleMutationOptions(options);
-
-	return useMutation(mutationOptions);
-};
-/**
- * This endpoint revokes a role from service account
- * @summary Delete service account role
- */
-export const deleteServiceAccountRole = ({
-	id,
-	rid,
-}: DeleteServiceAccountRolePathParameters) => {
-	return GeneratedAPIInstance<string>({
-		url: `/api/v1/service_accounts/${id}/roles/${rid}`,
-		method: 'DELETE',
-	});
-};
-
-export const getDeleteServiceAccountRoleMutationOptions = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof deleteServiceAccountRole>>,
-		TError,
-		{ pathParams: DeleteServiceAccountRolePathParameters },
-		TContext
-	>;
-}): UseMutationOptions<
-	Awaited<ReturnType<typeof deleteServiceAccountRole>>,
-	TError,
-	{ pathParams: DeleteServiceAccountRolePathParameters },
-	TContext
-> => {
-	const mutationKey = ['deleteServiceAccountRole'];
-	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 deleteServiceAccountRole>>,
-		{ pathParams: DeleteServiceAccountRolePathParameters }
-	> = (props) => {
-		const { pathParams } = props ?? {};
-
-		return deleteServiceAccountRole(pathParams);
-	};
-
-	return { mutationFn, ...mutationOptions };
-};
-
-export type DeleteServiceAccountRoleMutationResult = NonNullable<
-	Awaited<ReturnType<typeof deleteServiceAccountRole>>
->;
-
-export type DeleteServiceAccountRoleMutationError = ErrorType<RenderErrorResponseDTO>;
-
-/**
- * @summary Delete service account role
- */
-export const useDeleteServiceAccountRole = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof deleteServiceAccountRole>>,
-		TError,
-		{ pathParams: DeleteServiceAccountRolePathParameters },
-		TContext
-	>;
-}): UseMutationResult<
-	Awaited<ReturnType<typeof deleteServiceAccountRole>>,
-	TError,
-	{ pathParams: DeleteServiceAccountRolePathParameters },
-	TContext
-> => {
-	const mutationOptions = getDeleteServiceAccountRoleMutationOptions(options);
-
-	return useMutation(mutationOptions);
-};
-/**
- * This endpoint gets my service account
- * @summary Gets my service account
- */
-export const getMyServiceAccount = (signal?: AbortSignal) => {
-	return GeneratedAPIInstance<GetMyServiceAccount200>({
-		url: `/api/v1/service_accounts/me`,
-		method: 'GET',
-		signal,
-	});
-};
-
-export const getGetMyServiceAccountQueryKey = () => {
-	return [`/api/v1/service_accounts/me`] as const;
-};
-
-export const getGetMyServiceAccountQueryOptions = <
-	TData = Awaited<ReturnType<typeof getMyServiceAccount>>,
-	TError = ErrorType<RenderErrorResponseDTO>
->(options?: {
-	query?: UseQueryOptions<
-		Awaited<ReturnType<typeof getMyServiceAccount>>,
-		TError,
-		TData
-	>;
-}) => {
-	const { query: queryOptions } = options ?? {};
-
-	const queryKey = queryOptions?.queryKey ?? getGetMyServiceAccountQueryKey();
-
-	const queryFn: QueryFunction<
-		Awaited<ReturnType<typeof getMyServiceAccount>>
-	> = ({ signal }) => getMyServiceAccount(signal);
-
-	return { queryKey, queryFn, ...queryOptions } as UseQueryOptions<
-		Awaited<ReturnType<typeof getMyServiceAccount>>,
-		TError,
-		TData
-	> & { queryKey: QueryKey };
-};
-
-export type GetMyServiceAccountQueryResult = NonNullable<
-	Awaited<ReturnType<typeof getMyServiceAccount>>
->;
-export type GetMyServiceAccountQueryError = ErrorType<RenderErrorResponseDTO>;
-
-/**
- * @summary Gets my service account
- */
-
-export function useGetMyServiceAccount<
-	TData = Awaited<ReturnType<typeof getMyServiceAccount>>,
-	TError = ErrorType<RenderErrorResponseDTO>
->(options?: {
-	query?: UseQueryOptions<
-		Awaited<ReturnType<typeof getMyServiceAccount>>,
-		TError,
-		TData
-	>;
-}): UseQueryResult<TData, TError> & { queryKey: QueryKey } {
-	const queryOptions = getGetMyServiceAccountQueryOptions(options);
-
-	const query = useQuery(queryOptions) as UseQueryResult<TData, TError> & {
-		queryKey: QueryKey;
-	};
-
-	query.queryKey = queryOptions.queryKey;
-
-	return query;
-}
-
-/**
- * @summary Gets my service account
- */
-export const invalidateGetMyServiceAccount = async (
-	queryClient: QueryClient,
-	options?: InvalidateOptions,
-): Promise<QueryClient> => {
-	await queryClient.invalidateQueries(
-		{ queryKey: getGetMyServiceAccountQueryKey() },
-		options,
-	);
-
-	return queryClient;
-};
-
-/**
- * This endpoint gets my service account
- * @summary Updates my service account
- */
-export const updateMyServiceAccount = (
-	serviceaccounttypesPostableServiceAccountDTO: BodyType<ServiceaccounttypesPostableServiceAccountDTO>,
-) => {
-	return GeneratedAPIInstance<string>({
-		url: `/api/v1/service_accounts/me`,
-		method: 'PUT',
-		headers: { 'Content-Type': 'application/json' },
-		data: serviceaccounttypesPostableServiceAccountDTO,
-	});
-};
-
-export const getUpdateMyServiceAccountMutationOptions = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof updateMyServiceAccount>>,
-		TError,
-		{ data: BodyType<ServiceaccounttypesPostableServiceAccountDTO> },
-		TContext
-	>;
-}): UseMutationOptions<
-	Awaited<ReturnType<typeof updateMyServiceAccount>>,
-	TError,
-	{ data: BodyType<ServiceaccounttypesPostableServiceAccountDTO> },
-	TContext
-> => {
-	const mutationKey = ['updateMyServiceAccount'];
-	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 updateMyServiceAccount>>,
-		{ data: BodyType<ServiceaccounttypesPostableServiceAccountDTO> }
-	> = (props) => {
-		const { data } = props ?? {};
-
-		return updateMyServiceAccount(data);
-	};
-
-	return { mutationFn, ...mutationOptions };
-};
-
-export type UpdateMyServiceAccountMutationResult = NonNullable<
-	Awaited<ReturnType<typeof updateMyServiceAccount>>
->;
-export type UpdateMyServiceAccountMutationBody = BodyType<ServiceaccounttypesPostableServiceAccountDTO>;
-export type UpdateMyServiceAccountMutationError = ErrorType<RenderErrorResponseDTO>;
-
-/**
- * @summary Updates my service account
- */
-export const useUpdateMyServiceAccount = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof updateMyServiceAccount>>,
-		TError,
-		{ data: BodyType<ServiceaccounttypesPostableServiceAccountDTO> },
-		TContext
-	>;
-}): UseMutationResult<
-	Awaited<ReturnType<typeof updateMyServiceAccount>>,
-	TError,
-	{ data: BodyType<ServiceaccounttypesPostableServiceAccountDTO> },
-	TContext
-> => {
-	const mutationOptions = getUpdateMyServiceAccountMutationOptions(options);
+	const mutationOptions = getUpdateServiceAccountStatusMutationOptions(options);
 
 	return useMutation(mutationOptions);
 };

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

@@ -425,6 +425,39 @@ export interface AuthtypesSessionContextDTO {
 	orgs?: AuthtypesOrgSessionContextDTO[] | null;
 }
 
+export interface AuthtypesStorableRoleDTO {
+	/**
+	 * @type string
+	 * @format date-time
+	 */
+	createdAt?: Date;
+	/**
+	 * @type string
+	 */
+	description?: string;
+	/**
+	 * @type string
+	 */
+	id: string;
+	/**
+	 * @type string
+	 */
+	name?: string;
+	/**
+	 * @type string
+	 */
+	orgId?: string;
+	/**
+	 * @type string
+	 */
+	type?: string;
+	/**
+	 * @type string
+	 * @format date-time
+	 */
+	updatedAt?: Date;
+}
+
 export interface AuthtypesTransactionDTO {
 	object: AuthtypesObjectDTO;
 	/**
@@ -442,25 +475,25 @@ export interface AuthtypesUserRoleDTO {
 	 * @type string
 	 * @format date-time
 	 */
-	createdAt: Date;
+	createdAt?: Date;
 	/**
 	 * @type string
 	 */
 	id: string;
-	role: AuthtypesRoleDTO;
+	role?: AuthtypesStorableRoleDTO;
 	/**
 	 * @type string
 	 */
-	roleId: string;
+	roleId?: string;
 	/**
 	 * @type string
 	 * @format date-time
 	 */
-	updatedAt: Date;
+	updatedAt?: Date;
 	/**
 	 * @type string
 	 */
-	userId: string;
+	userId?: string;
 }
 
 export interface AuthtypesUserWithRolesDTO {
@@ -1330,32 +1363,6 @@ export interface GlobaltypesTokenizerConfigDTO {
 	enabled?: boolean;
 }
 
-export interface MetricsexplorertypesInspectMetricsRequestDTO {
-	/**
-	 * @type integer
-	 * @format int64
-	 */
-	end: number;
-	filter?: Querybuildertypesv5FilterDTO;
-	/**
-	 * @type string
-	 */
-	metricName: string;
-	/**
-	 * @type integer
-	 * @format int64
-	 */
-	start: number;
-}
-
-export interface MetricsexplorertypesInspectMetricsResponseDTO {
-	/**
-	 * @type array
-	 * @nullable true
-	 */
-	series: Querybuildertypesv5TimeSeriesDTO[] | null;
-}
-
 export interface MetricsexplorertypesListMetricDTO {
 	/**
 	 * @type string
@@ -1501,13 +1508,6 @@ export interface MetricsexplorertypesMetricMetadataDTO {
 	unit: string;
 }
 
-export interface MetricsexplorertypesMetricsOnboardingResponseDTO {
-	/**
-	 * @type boolean
-	 */
-	hasMetrics: boolean;
-}
-
 export interface MetricsexplorertypesStatDTO {
 	/**
 	 * @type string
@@ -2677,140 +2677,7 @@ export interface RenderErrorResponseDTO {
 	status: string;
 }
 
-export interface RulestatehistorytypesGettableRuleStateHistoryDTO {
-	/**
-	 * @type integer
-	 * @minimum 0
-	 */
-	fingerprint: number;
-	/**
-	 * @type array
-	 * @nullable true
-	 */
-	labels: Querybuildertypesv5LabelDTO[] | null;
-	overallState: RuletypesAlertStateDTO;
-	/**
-	 * @type boolean
-	 */
-	overallStateChanged: boolean;
-	/**
-	 * @type string
-	 */
-	ruleId: string;
-	/**
-	 * @type string
-	 */
-	ruleName: string;
-	state: RuletypesAlertStateDTO;
-	/**
-	 * @type boolean
-	 */
-	stateChanged: boolean;
-	/**
-	 * @type integer
-	 * @format int64
-	 */
-	unixMilli: number;
-	/**
-	 * @type number
-	 * @format double
-	 */
-	value: number;
-}
-
-export interface RulestatehistorytypesGettableRuleStateHistoryContributorDTO {
-	/**
-	 * @type integer
-	 * @minimum 0
-	 */
-	count: number;
-	/**
-	 * @type integer
-	 * @minimum 0
-	 */
-	fingerprint: number;
-	/**
-	 * @type array
-	 * @nullable true
-	 */
-	labels: Querybuildertypesv5LabelDTO[] | null;
-	/**
-	 * @type string
-	 */
-	relatedLogsLink?: string;
-	/**
-	 * @type string
-	 */
-	relatedTracesLink?: string;
-}
-
-export interface RulestatehistorytypesGettableRuleStateHistoryStatsDTO {
-	/**
-	 * @type number
-	 * @format double
-	 */
-	currentAvgResolutionTime: number;
-	currentAvgResolutionTimeSeries: Querybuildertypesv5TimeSeriesDTO;
-	currentTriggersSeries: Querybuildertypesv5TimeSeriesDTO;
-	/**
-	 * @type number
-	 * @format double
-	 */
-	pastAvgResolutionTime: number;
-	pastAvgResolutionTimeSeries: Querybuildertypesv5TimeSeriesDTO;
-	pastTriggersSeries: Querybuildertypesv5TimeSeriesDTO;
-	/**
-	 * @type integer
-	 * @minimum 0
-	 */
-	totalCurrentTriggers: number;
-	/**
-	 * @type integer
-	 * @minimum 0
-	 */
-	totalPastTriggers: number;
-}
-
-export interface RulestatehistorytypesGettableRuleStateTimelineDTO {
-	/**
-	 * @type array
-	 * @nullable true
-	 */
-	items: RulestatehistorytypesGettableRuleStateHistoryDTO[] | null;
-	/**
-	 * @type string
-	 */
-	nextCursor?: string;
-	/**
-	 * @type integer
-	 * @minimum 0
-	 */
-	total: number;
-}
-
-export interface RulestatehistorytypesGettableRuleStateWindowDTO {
-	/**
-	 * @type integer
-	 * @format int64
-	 */
-	end: number;
-	/**
-	 * @type integer
-	 * @format int64
-	 */
-	start: number;
-	state: RuletypesAlertStateDTO;
-}
-
-export enum RuletypesAlertStateDTO {
-	inactive = 'inactive',
-	pending = 'pending',
-	recovering = 'recovering',
-	firing = 'firing',
-	nodata = 'nodata',
-	disabled = 'disabled',
-}
-export interface ServiceaccounttypesGettableFactorAPIKeyDTO {
+export interface ServiceaccounttypesFactorAPIKeyDTO {
 	/**
 	 * @type string
 	 * @format date-time
@@ -2825,6 +2692,10 @@ export interface ServiceaccounttypesGettableFactorAPIKeyDTO {
 	 * @type string
 	 */
 	id: string;
+	/**
+	 * @type string
+	 */
+	key: string;
 	/**
 	 * @type string
 	 * @format date-time
@@ -2872,14 +2743,15 @@ export interface ServiceaccounttypesPostableServiceAccountDTO {
 	/**
 	 * @type string
 	 */
-	name: string;
-}
-
-export interface ServiceaccounttypesPostableServiceAccountRoleDTO {
+	email: string;
 	/**
 	 * @type string
 	 */
-	id: string;
+	name: string;
+	/**
+	 * @type array
+	 */
+	roles: string[];
 }
 
 export interface ServiceaccounttypesServiceAccountDTO {
@@ -2888,65 +2760,11 @@ export interface ServiceaccounttypesServiceAccountDTO {
 	 * @format date-time
 	 */
 	createdAt?: Date;
-	/**
-	 * @type string
-	 */
-	email: string;
-	/**
-	 * @type string
-	 */
-	id: string;
-	/**
-	 * @type string
-	 */
-	name: string;
-	/**
-	 * @type string
-	 */
-	orgId: string;
-	/**
-	 * @type string
-	 */
-	status: string;
 	/**
 	 * @type string
 	 * @format date-time
 	 */
-	updatedAt?: Date;
-}
-
-export interface ServiceaccounttypesServiceAccountRoleDTO {
-	/**
-	 * @type string
-	 * @format date-time
-	 */
-	createdAt?: Date;
-	/**
-	 * @type string
-	 */
-	id: string;
-	role: AuthtypesRoleDTO;
-	/**
-	 * @type string
-	 */
-	roleId: string;
-	/**
-	 * @type string
-	 */
-	serviceAccountId: string;
-	/**
-	 * @type string
-	 * @format date-time
-	 */
-	updatedAt?: Date;
-}
-
-export interface ServiceaccounttypesServiceAccountWithRolesDTO {
-	/**
-	 * @type string
-	 * @format date-time
-	 */
-	createdAt?: Date;
+	deletedAt: Date;
 	/**
 	 * @type string
 	 */
@@ -2965,9 +2783,8 @@ export interface ServiceaccounttypesServiceAccountWithRolesDTO {
 	orgId: string;
 	/**
 	 * @type array
-	 * @nullable true
 	 */
-	serviceAccountRoles: ServiceaccounttypesServiceAccountRoleDTO[] | null;
+	roles: string[];
 	/**
 	 * @type string
 	 */
@@ -2991,6 +2808,28 @@ export interface ServiceaccounttypesUpdatableFactorAPIKeyDTO {
 	name: string;
 }
 
+export interface ServiceaccounttypesUpdatableServiceAccountDTO {
+	/**
+	 * @type string
+	 */
+	email: string;
+	/**
+	 * @type string
+	 */
+	name: string;
+	/**
+	 * @type array
+	 */
+	roles: string[];
+}
+
+export interface ServiceaccounttypesUpdatableServiceAccountStatusDTO {
+	/**
+	 * @type string
+	 */
+	status: string;
+}
+
 export enum TelemetrytypesFieldContextDTO {
 	metric = 'metric',
 	log = 'log',
@@ -3134,6 +2973,63 @@ export interface TypesDeprecatedUserDTO {
 	updatedAt?: Date;
 }
 
+export interface TypesGettableAPIKeyDTO {
+	/**
+	 * @type string
+	 * @format date-time
+	 */
+	createdAt?: Date;
+	/**
+	 * @type string
+	 */
+	createdBy?: string;
+	createdByUser?: TypesUserDTO;
+	/**
+	 * @type integer
+	 * @format int64
+	 */
+	expiresAt?: number;
+	/**
+	 * @type string
+	 */
+	id: string;
+	/**
+	 * @type integer
+	 * @format int64
+	 */
+	lastUsed?: number;
+	/**
+	 * @type string
+	 */
+	name?: string;
+	/**
+	 * @type boolean
+	 */
+	revoked?: boolean;
+	/**
+	 * @type string
+	 */
+	role?: string;
+	/**
+	 * @type string
+	 */
+	token?: string;
+	/**
+	 * @type string
+	 * @format date-time
+	 */
+	updatedAt?: Date;
+	/**
+	 * @type string
+	 */
+	updatedBy?: string;
+	updatedByUser?: TypesUserDTO;
+	/**
+	 * @type string
+	 */
+	userId?: string;
+}
+
 export interface TypesIdentifiableDTO {
 	/**
 	 * @type string
@@ -3216,6 +3112,22 @@ export interface TypesOrganizationDTO {
 	updatedAt?: Date;
 }
 
+export interface TypesPostableAPIKeyDTO {
+	/**
+	 * @type integer
+	 * @format int64
+	 */
+	expiresInDays?: number;
+	/**
+	 * @type string
+	 */
+	name?: string;
+	/**
+	 * @type string
+	 */
+	role?: string;
+}
+
 export interface TypesPostableBulkInviteRequestDTO {
 	/**
 	 * @type array
@@ -3295,6 +3207,51 @@ export interface TypesResetPasswordTokenDTO {
 	token?: string;
 }
 
+export interface TypesStorableAPIKeyDTO {
+	/**
+	 * @type string
+	 * @format date-time
+	 */
+	createdAt?: Date;
+	/**
+	 * @type string
+	 */
+	createdBy?: string;
+	/**
+	 * @type string
+	 */
+	id: string;
+	/**
+	 * @type string
+	 */
+	name?: string;
+	/**
+	 * @type boolean
+	 */
+	revoked?: boolean;
+	/**
+	 * @type string
+	 */
+	role?: string;
+	/**
+	 * @type string
+	 */
+	token?: string;
+	/**
+	 * @type string
+	 * @format date-time
+	 */
+	updatedAt?: Date;
+	/**
+	 * @type string
+	 */
+	updatedBy?: string;
+	/**
+	 * @type string
+	 */
+	userId?: string;
+}
+
 export interface TypesUpdatableUserDTO {
 	/**
 	 * @type string
@@ -3833,6 +3790,31 @@ export type GetOrgPreference200 = {
 export type UpdateOrgPreferencePathParameters = {
 	name: string;
 };
+export type ListAPIKeys200 = {
+	/**
+	 * @type array
+	 */
+	data: TypesGettableAPIKeyDTO[];
+	/**
+	 * @type string
+	 */
+	status: string;
+};
+
+export type CreateAPIKey201 = {
+	data: TypesGettableAPIKeyDTO;
+	/**
+	 * @type string
+	 */
+	status: string;
+};
+
+export type RevokeAPIKeyPathParameters = {
+	id: string;
+};
+export type UpdateAPIKeyPathParameters = {
+	id: string;
+};
 export type GetPublicDashboardDataPathParameters = {
 	id: string;
 };
@@ -3937,7 +3919,7 @@ export type GetServiceAccountPathParameters = {
 	id: string;
 };
 export type GetServiceAccount200 = {
-	data: ServiceaccounttypesServiceAccountWithRolesDTO;
+	data: ServiceaccounttypesServiceAccountDTO;
 	/**
 	 * @type string
 	 */
@@ -3954,7 +3936,7 @@ export type ListServiceAccountKeys200 = {
 	/**
 	 * @type array
 	 */
-	data: ServiceaccounttypesGettableFactorAPIKeyDTO[];
+	data: ServiceaccounttypesFactorAPIKeyDTO[];
 	/**
 	 * @type string
 	 */
@@ -3980,44 +3962,9 @@ export type UpdateServiceAccountKeyPathParameters = {
 	id: string;
 	fid: string;
 };
-export type GetServiceAccountRolesPathParameters = {
+export type UpdateServiceAccountStatusPathParameters = {
 	id: string;
 };
-export type GetServiceAccountRoles200 = {
-	/**
-	 * @type array
-	 * @nullable true
-	 */
-	data: AuthtypesRoleDTO[] | null;
-	/**
-	 * @type string
-	 */
-	status: string;
-};
-
-export type CreateServiceAccountRolePathParameters = {
-	id: string;
-};
-export type CreateServiceAccountRole201 = {
-	data: TypesIdentifiableDTO;
-	/**
-	 * @type string
-	 */
-	status: string;
-};
-
-export type DeleteServiceAccountRolePathParameters = {
-	id: string;
-	rid: string;
-};
-export type GetMyServiceAccount200 = {
-	data: ServiceaccounttypesServiceAccountWithRolesDTO;
-	/**
-	 * @type string
-	 */
-	status: string;
-};
-
 export type ListUsersDeprecated200 = {
 	/**
 	 * @type array
@@ -4311,22 +4258,6 @@ export type GetMetricMetadata200 = {
 export type UpdateMetricMetadataPathParameters = {
 	metricName: string;
 };
-export type InspectMetrics200 = {
-	data: MetricsexplorertypesInspectMetricsResponseDTO;
-	/**
-	 * @type string
-	 */
-	status: string;
-};
-
-export type GetMetricsOnboardingStatus200 = {
-	data: MetricsexplorertypesMetricsOnboardingResponseDTO;
-	/**
-	 * @type string
-	 */
-	status: string;
-};
-
 export type GetMetricsStats200 = {
 	data: MetricsexplorertypesStatsResponseDTO;
 	/**
@@ -4381,266 +4312,6 @@ export type GetUsersByRoleID200 = {
 	status: string;
 };
 
-export type GetRuleHistoryFilterKeysPathParameters = {
-	id: string;
-};
-export type GetRuleHistoryFilterKeysParams = {
-	/**
-	 * @description undefined
-	 */
-	signal?: TelemetrytypesSignalDTO;
-	/**
-	 * @description undefined
-	 */
-	source?: TelemetrytypesSourceDTO;
-	/**
-	 * @type integer
-	 * @description undefined
-	 */
-	limit?: number;
-	/**
-	 * @type integer
-	 * @format int64
-	 * @description undefined
-	 */
-	startUnixMilli?: number;
-	/**
-	 * @type integer
-	 * @format int64
-	 * @description undefined
-	 */
-	endUnixMilli?: number;
-	/**
-	 * @description undefined
-	 */
-	fieldContext?: TelemetrytypesFieldContextDTO;
-	/**
-	 * @description undefined
-	 */
-	fieldDataType?: TelemetrytypesFieldDataTypeDTO;
-	/**
-	 * @type string
-	 * @description undefined
-	 */
-	metricName?: string;
-	/**
-	 * @type string
-	 * @description undefined
-	 */
-	searchText?: string;
-};
-
-export type GetRuleHistoryFilterKeys200 = {
-	data: TelemetrytypesGettableFieldKeysDTO;
-	/**
-	 * @type string
-	 */
-	status: string;
-};
-
-export type GetRuleHistoryFilterValuesPathParameters = {
-	id: string;
-};
-export type GetRuleHistoryFilterValuesParams = {
-	/**
-	 * @description undefined
-	 */
-	signal?: TelemetrytypesSignalDTO;
-	/**
-	 * @description undefined
-	 */
-	source?: TelemetrytypesSourceDTO;
-	/**
-	 * @type integer
-	 * @description undefined
-	 */
-	limit?: number;
-	/**
-	 * @type integer
-	 * @format int64
-	 * @description undefined
-	 */
-	startUnixMilli?: number;
-	/**
-	 * @type integer
-	 * @format int64
-	 * @description undefined
-	 */
-	endUnixMilli?: number;
-	/**
-	 * @description undefined
-	 */
-	fieldContext?: TelemetrytypesFieldContextDTO;
-	/**
-	 * @description undefined
-	 */
-	fieldDataType?: TelemetrytypesFieldDataTypeDTO;
-	/**
-	 * @type string
-	 * @description undefined
-	 */
-	metricName?: string;
-	/**
-	 * @type string
-	 * @description undefined
-	 */
-	searchText?: string;
-	/**
-	 * @type string
-	 * @description undefined
-	 */
-	name?: string;
-	/**
-	 * @type string
-	 * @description undefined
-	 */
-	existingQuery?: string;
-};
-
-export type GetRuleHistoryFilterValues200 = {
-	data: TelemetrytypesGettableFieldValuesDTO;
-	/**
-	 * @type string
-	 */
-	status: string;
-};
-
-export type GetRuleHistoryOverallStatusPathParameters = {
-	id: string;
-};
-export type GetRuleHistoryOverallStatusParams = {
-	/**
-	 * @type integer
-	 * @format int64
-	 * @description undefined
-	 */
-	start: number;
-	/**
-	 * @type integer
-	 * @format int64
-	 * @description undefined
-	 */
-	end: number;
-};
-
-export type GetRuleHistoryOverallStatus200 = {
-	/**
-	 * @type array
-	 * @nullable true
-	 */
-	data: RulestatehistorytypesGettableRuleStateWindowDTO[] | null;
-	/**
-	 * @type string
-	 */
-	status: string;
-};
-
-export type GetRuleHistoryStatsPathParameters = {
-	id: string;
-};
-export type GetRuleHistoryStatsParams = {
-	/**
-	 * @type integer
-	 * @format int64
-	 * @description undefined
-	 */
-	start: number;
-	/**
-	 * @type integer
-	 * @format int64
-	 * @description undefined
-	 */
-	end: number;
-};
-
-export type GetRuleHistoryStats200 = {
-	data: RulestatehistorytypesGettableRuleStateHistoryStatsDTO;
-	/**
-	 * @type string
-	 */
-	status: string;
-};
-
-export type GetRuleHistoryTimelinePathParameters = {
-	id: string;
-};
-export type GetRuleHistoryTimelineParams = {
-	/**
-	 * @type integer
-	 * @format int64
-	 * @description undefined
-	 */
-	start: number;
-	/**
-	 * @type integer
-	 * @format int64
-	 * @description undefined
-	 */
-	end: number;
-	/**
-	 * @description undefined
-	 */
-	state?: RuletypesAlertStateDTO;
-	/**
-	 * @type string
-	 * @description undefined
-	 */
-	filterExpression?: string;
-	/**
-	 * @type integer
-	 * @format int64
-	 * @description undefined
-	 */
-	limit?: number;
-	/**
-	 * @description undefined
-	 */
-	order?: Querybuildertypesv5OrderDirectionDTO;
-	/**
-	 * @type string
-	 * @description undefined
-	 */
-	cursor?: string;
-};
-
-export type GetRuleHistoryTimeline200 = {
-	data: RulestatehistorytypesGettableRuleStateTimelineDTO;
-	/**
-	 * @type string
-	 */
-	status: string;
-};
-
-export type GetRuleHistoryTopContributorsPathParameters = {
-	id: string;
-};
-export type GetRuleHistoryTopContributorsParams = {
-	/**
-	 * @type integer
-	 * @format int64
-	 * @description undefined
-	 */
-	start: number;
-	/**
-	 * @type integer
-	 * @format int64
-	 * @description undefined
-	 */
-	end: number;
-};
-
-export type GetRuleHistoryTopContributors200 = {
-	/**
-	 * @type array
-	 * @nullable true
-	 */
-	data: RulestatehistorytypesGettableRuleStateHistoryContributorDTO[] | null;
-	/**
-	 * @type string
-	 */
-	status: string;
-};
-
 export type GetSessionContext200 = {
 	data: AuthtypesSessionContextDTO;
 	/**

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

@@ -21,6 +21,7 @@ import type { BodyType, ErrorType } from '../../../generatedAPIInstance';
 import { GeneratedAPIInstance } from '../../../generatedAPIInstance';
 import type {
 	ChangePasswordPathParameters,
+	CreateAPIKey201,
 	CreateInvite201,
 	DeleteUserPathParameters,
 	GetMyUser200,
@@ -35,19 +36,24 @@ import type {
 	GetUserPathParameters,
 	GetUsersByRoleID200,
 	GetUsersByRoleIDPathParameters,
+	ListAPIKeys200,
 	ListUsers200,
 	ListUsersDeprecated200,
 	RemoveUserRoleByUserIDAndRoleIDPathParameters,
 	RenderErrorResponseDTO,
+	RevokeAPIKeyPathParameters,
 	SetRoleByUserIDPathParameters,
 	TypesChangePasswordRequestDTO,
 	TypesDeprecatedUserDTO,
+	TypesPostableAPIKeyDTO,
 	TypesPostableBulkInviteRequestDTO,
 	TypesPostableForgotPasswordDTO,
 	TypesPostableInviteDTO,
 	TypesPostableResetPasswordDTO,
 	TypesPostableRoleDTO,
+	TypesStorableAPIKeyDTO,
 	TypesUpdatableUserDTO,
+	UpdateAPIKeyPathParameters,
 	UpdateUserDeprecated200,
 	UpdateUserDeprecatedPathParameters,
 	UpdateUserPathParameters,
@@ -422,6 +428,349 @@ export const useCreateBulkInvite = <
 
 	return useMutation(mutationOptions);
 };
+/**
+ * This endpoint lists all api keys
+ * @summary List api keys
+ */
+export const listAPIKeys = (signal?: AbortSignal) => {
+	return GeneratedAPIInstance<ListAPIKeys200>({
+		url: `/api/v1/pats`,
+		method: 'GET',
+		signal,
+	});
+};
+
+export const getListAPIKeysQueryKey = () => {
+	return [`/api/v1/pats`] as const;
+};
+
+export const getListAPIKeysQueryOptions = <
+	TData = Awaited<ReturnType<typeof listAPIKeys>>,
+	TError = ErrorType<RenderErrorResponseDTO>
+>(options?: {
+	query?: UseQueryOptions<
+		Awaited<ReturnType<typeof listAPIKeys>>,
+		TError,
+		TData
+	>;
+}) => {
+	const { query: queryOptions } = options ?? {};
+
+	const queryKey = queryOptions?.queryKey ?? getListAPIKeysQueryKey();
+
+	const queryFn: QueryFunction<Awaited<ReturnType<typeof listAPIKeys>>> = ({
+		signal,
+	}) => listAPIKeys(signal);
+
+	return { queryKey, queryFn, ...queryOptions } as UseQueryOptions<
+		Awaited<ReturnType<typeof listAPIKeys>>,
+		TError,
+		TData
+	> & { queryKey: QueryKey };
+};
+
+export type ListAPIKeysQueryResult = NonNullable<
+	Awaited<ReturnType<typeof listAPIKeys>>
+>;
+export type ListAPIKeysQueryError = ErrorType<RenderErrorResponseDTO>;
+
+/**
+ * @summary List api keys
+ */
+
+export function useListAPIKeys<
+	TData = Awaited<ReturnType<typeof listAPIKeys>>,
+	TError = ErrorType<RenderErrorResponseDTO>
+>(options?: {
+	query?: UseQueryOptions<
+		Awaited<ReturnType<typeof listAPIKeys>>,
+		TError,
+		TData
+	>;
+}): UseQueryResult<TData, TError> & { queryKey: QueryKey } {
+	const queryOptions = getListAPIKeysQueryOptions(options);
+
+	const query = useQuery(queryOptions) as UseQueryResult<TData, TError> & {
+		queryKey: QueryKey;
+	};
+
+	query.queryKey = queryOptions.queryKey;
+
+	return query;
+}
+
+/**
+ * @summary List api keys
+ */
+export const invalidateListAPIKeys = async (
+	queryClient: QueryClient,
+	options?: InvalidateOptions,
+): Promise<QueryClient> => {
+	await queryClient.invalidateQueries(
+		{ queryKey: getListAPIKeysQueryKey() },
+		options,
+	);
+
+	return queryClient;
+};
+
+/**
+ * This endpoint creates an api key
+ * @summary Create api key
+ */
+export const createAPIKey = (
+	typesPostableAPIKeyDTO: BodyType<TypesPostableAPIKeyDTO>,
+	signal?: AbortSignal,
+) => {
+	return GeneratedAPIInstance<CreateAPIKey201>({
+		url: `/api/v1/pats`,
+		method: 'POST',
+		headers: { 'Content-Type': 'application/json' },
+		data: typesPostableAPIKeyDTO,
+		signal,
+	});
+};
+
+export const getCreateAPIKeyMutationOptions = <
+	TError = ErrorType<RenderErrorResponseDTO>,
+	TContext = unknown
+>(options?: {
+	mutation?: UseMutationOptions<
+		Awaited<ReturnType<typeof createAPIKey>>,
+		TError,
+		{ data: BodyType<TypesPostableAPIKeyDTO> },
+		TContext
+	>;
+}): UseMutationOptions<
+	Awaited<ReturnType<typeof createAPIKey>>,
+	TError,
+	{ data: BodyType<TypesPostableAPIKeyDTO> },
+	TContext
+> => {
+	const mutationKey = ['createAPIKey'];
+	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 createAPIKey>>,
+		{ data: BodyType<TypesPostableAPIKeyDTO> }
+	> = (props) => {
+		const { data } = props ?? {};
+
+		return createAPIKey(data);
+	};
+
+	return { mutationFn, ...mutationOptions };
+};
+
+export type CreateAPIKeyMutationResult = NonNullable<
+	Awaited<ReturnType<typeof createAPIKey>>
+>;
+export type CreateAPIKeyMutationBody = BodyType<TypesPostableAPIKeyDTO>;
+export type CreateAPIKeyMutationError = ErrorType<RenderErrorResponseDTO>;
+
+/**
+ * @summary Create api key
+ */
+export const useCreateAPIKey = <
+	TError = ErrorType<RenderErrorResponseDTO>,
+	TContext = unknown
+>(options?: {
+	mutation?: UseMutationOptions<
+		Awaited<ReturnType<typeof createAPIKey>>,
+		TError,
+		{ data: BodyType<TypesPostableAPIKeyDTO> },
+		TContext
+	>;
+}): UseMutationResult<
+	Awaited<ReturnType<typeof createAPIKey>>,
+	TError,
+	{ data: BodyType<TypesPostableAPIKeyDTO> },
+	TContext
+> => {
+	const mutationOptions = getCreateAPIKeyMutationOptions(options);
+
+	return useMutation(mutationOptions);
+};
+/**
+ * This endpoint revokes an api key
+ * @summary Revoke api key
+ */
+export const revokeAPIKey = ({ id }: RevokeAPIKeyPathParameters) => {
+	return GeneratedAPIInstance<void>({
+		url: `/api/v1/pats/${id}`,
+		method: 'DELETE',
+	});
+};
+
+export const getRevokeAPIKeyMutationOptions = <
+	TError = ErrorType<RenderErrorResponseDTO>,
+	TContext = unknown
+>(options?: {
+	mutation?: UseMutationOptions<
+		Awaited<ReturnType<typeof revokeAPIKey>>,
+		TError,
+		{ pathParams: RevokeAPIKeyPathParameters },
+		TContext
+	>;
+}): UseMutationOptions<
+	Awaited<ReturnType<typeof revokeAPIKey>>,
+	TError,
+	{ pathParams: RevokeAPIKeyPathParameters },
+	TContext
+> => {
+	const mutationKey = ['revokeAPIKey'];
+	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 revokeAPIKey>>,
+		{ pathParams: RevokeAPIKeyPathParameters }
+	> = (props) => {
+		const { pathParams } = props ?? {};
+
+		return revokeAPIKey(pathParams);
+	};
+
+	return { mutationFn, ...mutationOptions };
+};
+
+export type RevokeAPIKeyMutationResult = NonNullable<
+	Awaited<ReturnType<typeof revokeAPIKey>>
+>;
+
+export type RevokeAPIKeyMutationError = ErrorType<RenderErrorResponseDTO>;
+
+/**
+ * @summary Revoke api key
+ */
+export const useRevokeAPIKey = <
+	TError = ErrorType<RenderErrorResponseDTO>,
+	TContext = unknown
+>(options?: {
+	mutation?: UseMutationOptions<
+		Awaited<ReturnType<typeof revokeAPIKey>>,
+		TError,
+		{ pathParams: RevokeAPIKeyPathParameters },
+		TContext
+	>;
+}): UseMutationResult<
+	Awaited<ReturnType<typeof revokeAPIKey>>,
+	TError,
+	{ pathParams: RevokeAPIKeyPathParameters },
+	TContext
+> => {
+	const mutationOptions = getRevokeAPIKeyMutationOptions(options);
+
+	return useMutation(mutationOptions);
+};
+/**
+ * This endpoint updates an api key
+ * @summary Update api key
+ */
+export const updateAPIKey = (
+	{ id }: UpdateAPIKeyPathParameters,
+	typesStorableAPIKeyDTO: BodyType<TypesStorableAPIKeyDTO>,
+) => {
+	return GeneratedAPIInstance<string>({
+		url: `/api/v1/pats/${id}`,
+		method: 'PUT',
+		headers: { 'Content-Type': 'application/json' },
+		data: typesStorableAPIKeyDTO,
+	});
+};
+
+export const getUpdateAPIKeyMutationOptions = <
+	TError = ErrorType<RenderErrorResponseDTO>,
+	TContext = unknown
+>(options?: {
+	mutation?: UseMutationOptions<
+		Awaited<ReturnType<typeof updateAPIKey>>,
+		TError,
+		{
+			pathParams: UpdateAPIKeyPathParameters;
+			data: BodyType<TypesStorableAPIKeyDTO>;
+		},
+		TContext
+	>;
+}): UseMutationOptions<
+	Awaited<ReturnType<typeof updateAPIKey>>,
+	TError,
+	{
+		pathParams: UpdateAPIKeyPathParameters;
+		data: BodyType<TypesStorableAPIKeyDTO>;
+	},
+	TContext
+> => {
+	const mutationKey = ['updateAPIKey'];
+	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 updateAPIKey>>,
+		{
+			pathParams: UpdateAPIKeyPathParameters;
+			data: BodyType<TypesStorableAPIKeyDTO>;
+		}
+	> = (props) => {
+		const { pathParams, data } = props ?? {};
+
+		return updateAPIKey(pathParams, data);
+	};
+
+	return { mutationFn, ...mutationOptions };
+};
+
+export type UpdateAPIKeyMutationResult = NonNullable<
+	Awaited<ReturnType<typeof updateAPIKey>>
+>;
+export type UpdateAPIKeyMutationBody = BodyType<TypesStorableAPIKeyDTO>;
+export type UpdateAPIKeyMutationError = ErrorType<RenderErrorResponseDTO>;
+
+/**
+ * @summary Update api key
+ */
+export const useUpdateAPIKey = <
+	TError = ErrorType<RenderErrorResponseDTO>,
+	TContext = unknown
+>(options?: {
+	mutation?: UseMutationOptions<
+		Awaited<ReturnType<typeof updateAPIKey>>,
+		TError,
+		{
+			pathParams: UpdateAPIKeyPathParameters;
+			data: BodyType<TypesStorableAPIKeyDTO>;
+		},
+		TContext
+	>;
+}): UseMutationResult<
+	Awaited<ReturnType<typeof updateAPIKey>>,
+	TError,
+	{
+		pathParams: UpdateAPIKeyPathParameters;
+		data: BodyType<TypesStorableAPIKeyDTO>;
+	},
+	TContext
+> => {
+	const mutationOptions = getUpdateAPIKeyMutationOptions(options);
+
+	return useMutation(mutationOptions);
+};
 /**
  * This endpoint resets the password by token
  * @summary Reset password

frontend/src/api/infraMonitoring/getHostLists.ts

@@ -13,9 +13,7 @@ export interface HostListPayload {
 	orderBy?: {
 		columnName: string;
 		order: 'asc' | 'desc';
-	} | null;
-	start?: number;
-	end?: number;
+	};
 }
 
 export interface TimeSeriesValue {

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/api/organization/editOrg.ts

@@ -0,0 +1,26 @@
+import { ApiV2Instance as axios } from 'api';
+import { ErrorResponseHandler } from 'api/ErrorResponseHandler';
+import { AxiosError } from 'axios';
+import { ErrorResponse, SuccessResponse } from 'types/api';
+import { PayloadProps, Props } from 'types/api/user/editOrg';
+
+const editOrg = async (
+	props: Props,
+): Promise<SuccessResponse<PayloadProps> | ErrorResponse> => {
+	try {
+		const response = await axios.put(`/orgs/me`, {
+			displayName: props.displayName,
+		});
+
+		return {
+			statusCode: 204,
+			error: null,
+			message: response.data.status,
+			payload: response.data,
+		};
+	} catch (error) {
+		return ErrorResponseHandler(error as AxiosError);
+	}
+};
+
+export default editOrg;

frontend/src/api/organization/getOrganization.ts

@@ -0,0 +1,28 @@
+import axios from 'api';
+import { ErrorResponseHandler } from 'api/ErrorResponseHandler';
+import { AxiosError } from 'axios';
+import { ErrorResponse, SuccessResponse } from 'types/api';
+import { PayloadProps } from 'types/api/user/getOrganization';
+
+const getOrganization = async (
+	token?: string,
+): Promise<SuccessResponse<PayloadProps> | ErrorResponse> => {
+	try {
+		const response = await axios.get(`/org`, {
+			headers: {
+				Authorization: `bearer ${token}`,
+			},
+		});
+
+		return {
+			statusCode: 200,
+			error: null,
+			message: response.data.status,
+			payload: response.data,
+		};
+	} catch (error) {
+		return ErrorResponseHandler(error as AxiosError);
+	}
+};
+
+export default getOrganization;

frontend/src/api/v1/pats/create.ts

@@ -0,0 +1,28 @@
+import axios from 'api';
+import { ErrorResponseHandlerV2 } from 'api/ErrorResponseHandlerV2';
+import { AxiosError } from 'axios';
+import { ErrorV2Resp, SuccessResponseV2 } from 'types/api';
+import {
+	APIKeyProps,
+	CreateAPIKeyProps,
+	CreatePayloadProps,
+} from 'types/api/pat/types';
+
+const create = async (
+	props: CreateAPIKeyProps,
+): Promise<SuccessResponseV2<APIKeyProps>> => {
+	try {
+		const response = await axios.post<CreatePayloadProps>('/pats', {
+			...props,
+		});
+
+		return {
+			httpStatusCode: response.status,
+			data: response.data.data,
+		};
+	} catch (error) {
+		ErrorResponseHandlerV2(error as AxiosError<ErrorV2Resp>);
+	}
+};
+
+export default create;

frontend/src/api/v1/pats/delete.ts

@@ -0,0 +1,19 @@
+import axios from 'api';
+import { ErrorResponseHandlerV2 } from 'api/ErrorResponseHandlerV2';
+import { AxiosError } from 'axios';
+import { ErrorV2Resp, SuccessResponseV2 } from 'types/api';
+
+const deleteAPIKey = async (id: string): Promise<SuccessResponseV2<null>> => {
+	try {
+		const response = await axios.delete(`/pats/${id}`);
+
+		return {
+			httpStatusCode: response.status,
+			data: null,
+		};
+	} catch (error) {
+		ErrorResponseHandlerV2(error as AxiosError<ErrorV2Resp>);
+	}
+};
+
+export default deleteAPIKey;

frontend/src/api/v1/pats/list.ts

@@ -0,0 +1,20 @@
+import axios from 'api';
+import { ErrorResponseHandlerV2 } from 'api/ErrorResponseHandlerV2';
+import { AxiosError } from 'axios';
+import { ErrorV2Resp, SuccessResponseV2 } from 'types/api';
+import { AllAPIKeyProps, APIKeyProps } from 'types/api/pat/types';
+
+const list = async (): Promise<SuccessResponseV2<APIKeyProps[]>> => {
+	try {
+		const response = await axios.get<AllAPIKeyProps>('/pats');
+
+		return {
+			httpStatusCode: response.status,
+			data: response.data.data,
+		};
+	} catch (error) {
+		ErrorResponseHandlerV2(error as AxiosError<ErrorV2Resp>);
+	}
+};
+
+export default list;

frontend/src/api/v1/pats/update.ts

@@ -0,0 +1,24 @@
+import axios from 'api';
+import { ErrorResponseHandlerV2 } from 'api/ErrorResponseHandlerV2';
+import { AxiosError } from 'axios';
+import { ErrorV2Resp, SuccessResponseV2 } from 'types/api';
+import { UpdateAPIKeyProps } from 'types/api/pat/types';
+
+const updateAPIKey = async (
+	props: UpdateAPIKeyProps,
+): Promise<SuccessResponseV2<null>> => {
+	try {
+		const response = await axios.put(`/pats/${props.id}`, {
+			...props.data,
+		});
+
+		return {
+			httpStatusCode: response.status,
+			data: null,
+		};
+	} catch (error) {
+		ErrorResponseHandlerV2(error as AxiosError<ErrorV2Resp>);
+	}
+};
+
+export default updateAPIKey;

frontend/src/api/v1/user/get.ts

@@ -0,0 +1,21 @@
+import axios from 'api';
+import { ErrorResponseHandlerV2 } from 'api/ErrorResponseHandlerV2';
+import { AxiosError } from 'axios';
+import { ErrorV2Resp, SuccessResponseV2 } from 'types/api';
+import { UserResponse } from 'types/api/user/getUser';
+import { PayloadProps } from 'types/api/user/getUsers';
+
+const getAll = async (): Promise<SuccessResponseV2<UserResponse[]>> => {
+	try {
+		const response = await axios.get<PayloadProps>(`/user`);
+
+		return {
+			httpStatusCode: response.status,
+			data: response.data.data,
+		};
+	} catch (error) {
+		ErrorResponseHandlerV2(error as AxiosError<ErrorV2Resp>);
+	}
+};
+
+export default getAll;

frontend/src/api/v1/user/id/get.ts

@@ -0,0 +1,22 @@
+import axios from 'api';
+import { ErrorResponseHandlerV2 } from 'api/ErrorResponseHandlerV2';
+import { AxiosError } from 'axios';
+import { ErrorV2Resp, SuccessResponseV2 } from 'types/api';
+import { PayloadProps, Props, UserResponse } from 'types/api/user/getUser';
+
+const getUser = async (
+	props: Props,
+): Promise<SuccessResponseV2<UserResponse>> => {
+	try {
+		const response = await axios.get<PayloadProps>(`/user/${props.userId}`);
+
+		return {
+			httpStatusCode: response.status,
+			data: response.data.data,
+		};
+	} catch (error) {
+		ErrorResponseHandlerV2(error as AxiosError<ErrorV2Resp>);
+	}
+};
+
+export default getUser;

frontend/src/api/v1/user/id/update.ts

@@ -0,0 +1,23 @@
+import axios from 'api';
+import { ErrorResponseHandlerV2 } from 'api/ErrorResponseHandlerV2';
+import { AxiosError } from 'axios';
+import { ErrorV2Resp, SuccessResponseV2 } from 'types/api';
+import { Props } from 'types/api/user/editUser';
+
+const update = async (props: Props): Promise<SuccessResponseV2<null>> => {
+	try {
+		const response = await axios.put(`/user/${props.userId}`, {
+			displayName: props.displayName,
+			role: props.role,
+		});
+
+		return {
+			httpStatusCode: response.status,
+			data: null,
+		};
+	} catch (error) {
+		ErrorResponseHandlerV2(error as AxiosError<ErrorV2Resp>);
+	}
+};
+
+export default update;

frontend/src/api/v1/user/me/get.ts

@@ -0,0 +1,20 @@
+import axios from 'api';
+import { ErrorResponseHandlerV2 } from 'api/ErrorResponseHandlerV2';
+import { AxiosError } from 'axios';
+import { ErrorV2Resp, SuccessResponseV2 } from 'types/api';
+import { PayloadProps, UserResponse } from 'types/api/user/getUser';
+
+const get = async (): Promise<SuccessResponseV2<UserResponse>> => {
+	try {
+		const response = await axios.get<PayloadProps>(`/user/me`);
+
+		return {
+			httpStatusCode: response.status,
+			data: response.data.data,
+		};
+	} catch (error) {
+		ErrorResponseHandlerV2(error as AxiosError<ErrorV2Resp>);
+	}
+};
+
+export default get;

frontend/src/components/AnnouncementBanner/AnnouncementBanner.styles.scss

@@ -0,0 +1,97 @@
+.announcement-banner {
+	display: flex;
+	align-items: center;
+	justify-content: space-between;
+	gap: var(--spacing-4);
+	padding: var(--padding-2) var(--padding-4);
+	height: 40px;
+	font-family: var(--font-sans), sans-serif;
+	font-size: var(--label-base-500-font-size);
+	line-height: var(--label-base-500-line-height);
+	font-weight: var(--label-base-500-font-weight);
+	letter-spacing: -0.065px;
+
+	&--warning {
+		background-color: var(--callout-warning-background);
+		color: var(--callout-warning-description);
+		.announcement-banner__action,
+		.announcement-banner__dismiss {
+			background: var(--callout-warning-border);
+		}
+	}
+
+	&--info {
+		background-color: var(--callout-primary-background);
+		color: var(--callout-primary-description);
+		.announcement-banner__action,
+		.announcement-banner__dismiss {
+			background: var(--callout-primary-border);
+		}
+	}
+
+	&--error {
+		background-color: var(--callout-error-background);
+		color: var(--callout-error-description);
+		.announcement-banner__action,
+		.announcement-banner__dismiss {
+			background: var(--callout-error-border);
+		}
+	}
+
+	&--success {
+		background-color: var(--callout-success-background);
+		color: var(--callout-success-description);
+		.announcement-banner__action,
+		.announcement-banner__dismiss {
+			background: var(--callout-success-border);
+		}
+	}
+
+	&__body {
+		display: flex;
+		align-items: center;
+		gap: var(--spacing-4);
+		flex: 1;
+		min-width: 0;
+	}
+
+	&__icon {
+		display: flex;
+		align-items: center;
+		flex-shrink: 0;
+	}
+
+	&__message {
+		flex: 1;
+		min-width: 0;
+		overflow: hidden;
+		text-overflow: ellipsis;
+		white-space: nowrap;
+		line-height: var(--line-height-normal);
+
+		strong {
+			font-weight: var(--font-weight-semibold);
+		}
+	}
+
+	&__action {
+		height: 24px;
+		font-size: var(--label-small-500-font-size);
+		color: currentColor;
+
+		&:hover {
+			opacity: 0.8;
+		}
+	}
+
+	&__dismiss {
+		width: 24px;
+		height: 24px;
+		padding: 0;
+		color: currentColor;
+
+		&:hover {
+			opacity: 0.8;
+		}
+	}
+}

frontend/src/components/AnnouncementBanner/AnnouncementBanner.test.tsx

@@ -0,0 +1,89 @@
+import { render, screen, userEvent } from 'tests/test-utils';
+
+import {
+	AnnouncementBanner,
+	AnnouncementBannerProps,
+	PersistedAnnouncementBanner,
+} from './index';
+
+const STORAGE_KEY = 'test-banner-dismissed';
+
+function renderBanner(props: Partial<AnnouncementBannerProps> = {}): void {
+	render(<AnnouncementBanner message="Test message" {...props} />);
+}
+
+afterEach(() => {
+	localStorage.removeItem(STORAGE_KEY);
+});
+
+describe('AnnouncementBanner', () => {
+	it('renders message and default warning variant', () => {
+		renderBanner({ message: <strong>Heads up</strong> });
+
+		const alert = screen.getByRole('alert');
+		expect(alert).toHaveClass('announcement-banner--warning');
+		expect(alert).toHaveTextContent('Heads up');
+	});
+
+	it.each(['warning', 'info', 'success', 'error'] as const)(
+		'renders %s variant correctly',
+		(type) => {
+			renderBanner({ type, message: 'Test message' });
+			const alert = screen.getByRole('alert');
+			expect(alert).toHaveClass(`announcement-banner--${type}`);
+		},
+	);
+
+	it('calls action onClick when action button is clicked', async () => {
+		const onClick = jest.fn() as jest.MockedFunction<() => void>;
+		renderBanner({ action: { label: 'Go to Settings', onClick } });
+
+		const user = userEvent.setup({ pointerEventsCheck: 0 });
+		await user.click(screen.getByRole('button', { name: /go to settings/i }));
+
+		expect(onClick).toHaveBeenCalledTimes(1);
+	});
+
+	it('hides dismiss button when onClose is not provided and hides icon when icon is null', () => {
+		renderBanner({ onClose: undefined, icon: null });
+
+		expect(
+			screen.queryByRole('button', { name: /dismiss/i }),
+		).not.toBeInTheDocument();
+		expect(
+			screen.queryByRole('alert')?.querySelector('.announcement-banner__icon'),
+		).not.toBeInTheDocument();
+	});
+});
+
+describe('PersistedAnnouncementBanner', () => {
+	it('dismisses on click, calls onDismiss, and persists to localStorage', async () => {
+		const onDismiss = jest.fn() as jest.MockedFunction<() => void>;
+		render(
+			<PersistedAnnouncementBanner
+				message="Test message"
+				storageKey={STORAGE_KEY}
+				onDismiss={onDismiss}
+			/>,
+		);
+
+		const user = userEvent.setup({ pointerEventsCheck: 0 });
+		await user.click(screen.getByRole('button', { name: /dismiss/i }));
+
+		expect(screen.queryByRole('alert')).not.toBeInTheDocument();
+		expect(onDismiss).toHaveBeenCalledTimes(1);
+		expect(localStorage.getItem(STORAGE_KEY)).toBe('true');
+	});
+
+	it('does not render when storageKey is already set in localStorage', () => {
+		localStorage.setItem(STORAGE_KEY, 'true');
+		render(
+			<PersistedAnnouncementBanner
+				message="Test message"
+				storageKey={STORAGE_KEY}
+			/>,
+		);
+
+		expect(screen.queryByRole('alert')).not.toBeInTheDocument();
+	});
+});

frontend/src/components/AnnouncementBanner/AnnouncementBanner.tsx

@@ -0,0 +1,84 @@
+import { ReactNode } from 'react';
+import { Button } from '@signozhq/button';
+import {
+	CircleAlert,
+	CircleCheckBig,
+	Info,
+	TriangleAlert,
+	X,
+} from '@signozhq/icons';
+import cx from 'classnames';
+
+import './AnnouncementBanner.styles.scss';
+
+export type AnnouncementBannerType = 'warning' | 'info' | 'error' | 'success';
+
+export interface AnnouncementBannerAction {
+	label: string;
+	onClick: () => void;
+}
+
+export interface AnnouncementBannerProps {
+	message: ReactNode;
+	type?: AnnouncementBannerType;
+	icon?: ReactNode | null;
+	action?: AnnouncementBannerAction;
+	onClose?: () => void;
+	className?: string;
+}
+
+const DEFAULT_ICONS: Record<AnnouncementBannerType, ReactNode> = {
+	warning: <TriangleAlert size={14} />,
+	info: <Info size={14} />,
+	error: <CircleAlert size={14} />,
+	success: <CircleCheckBig size={14} />,
+};
+
+export default function AnnouncementBanner({
+	message,
+	type = 'warning',
+	icon,
+	action,
+	onClose,
+	className,
+}: AnnouncementBannerProps): JSX.Element {
+	const resolvedIcon = icon === null ? null : icon ?? DEFAULT_ICONS[type];
+
+	return (
+		<div
+			role="alert"
+			className={cx(
+				'announcement-banner',
+				`announcement-banner--${type}`,
+				className,
+			)}
+		>
+			<div className="announcement-banner__body">
+				{resolvedIcon && (
+					<span className="announcement-banner__icon">{resolvedIcon}</span>
+				)}
+				<span className="announcement-banner__message">{message}</span>
+				{action && (
+					<Button
+						type="button"
+						className="announcement-banner__action"
+						onClick={action.onClick}
+					>
+						{action.label}
+					</Button>
+				)}
+			</div>
+
+			{onClose && (
+				<Button
+					type="button"
+					aria-label="Dismiss"
+					className="announcement-banner__dismiss"
+					onClick={onClose}
+				>
+					<X size={14} />
+				</Button>
+			)}
+		</div>
+	);
+}

frontend/src/components/AnnouncementBanner/PersistedAnnouncementBanner.tsx

@@ -0,0 +1,34 @@
+import { useState } from 'react';
+
+import AnnouncementBanner, {
+	AnnouncementBannerProps,
+} from './AnnouncementBanner';
+
+interface PersistedAnnouncementBannerProps extends AnnouncementBannerProps {
+	storageKey: string;
+	onDismiss?: () => void;
+}
+
+function isDismissed(storageKey: string): boolean {
+	return localStorage.getItem(storageKey) === 'true';
+}
+
+export default function PersistedAnnouncementBanner({
+	storageKey,
+	onDismiss,
+	...props
+}: PersistedAnnouncementBannerProps): JSX.Element | null {
+	const [visible, setVisible] = useState(() => !isDismissed(storageKey));
+
+	if (!visible) {
+		return null;
+	}
+
+	const handleClose = (): void => {
+		localStorage.setItem(storageKey, 'true');
+		setVisible(false);
+		onDismiss?.();
+	};
+
+	return <AnnouncementBanner {...props} onClose={handleClose} />;
+}

frontend/src/components/AnnouncementBanner/index.ts

@@ -0,0 +1,12 @@
+import AnnouncementBanner from './AnnouncementBanner';
+import PersistedAnnouncementBanner from './PersistedAnnouncementBanner';
+
+export type {
+	AnnouncementBannerAction,
+	AnnouncementBannerProps,
+	AnnouncementBannerType,
+} from './AnnouncementBanner';
+
+export { AnnouncementBanner, PersistedAnnouncementBanner };
+
+export default AnnouncementBanner;

frontend/src/components/CreateServiceAccountModal/CreateServiceAccountModal.tsx

@@ -12,13 +12,17 @@ import {
 } from 'api/generated/services/serviceaccount';
 import type { RenderErrorResponseDTO } from 'api/generated/services/sigNoz.schemas';
 import { AxiosError } from 'axios';
+import RolesSelect, { useRoles } from 'components/RolesSelect';
 import { SA_QUERY_PARAMS } from 'container/ServiceAccountsSettings/constants';
 import { parseAsBoolean, useQueryState } from 'nuqs';
+import { EMAIL_REGEX } from 'utils/app';
 
 import './CreateServiceAccountModal.styles.scss';
 
 interface FormValues {
 	name: string;
+	email: string;
+	roles: string[];
 }
 
 function CreateServiceAccountModal(): JSX.Element {
@@ -37,6 +41,8 @@ function CreateServiceAccountModal(): JSX.Element {
 		mode: 'onChange',
 		defaultValues: {
 			name: '',
+			email: '',
+			roles: [],
 		},
 	});
 
@@ -64,6 +70,13 @@ function CreateServiceAccountModal(): JSX.Element {
 			},
 		},
 	});
+	const {
+		roles,
+		isLoading: rolesLoading,
+		isError: rolesError,
+		error: rolesErrorObj,
+		refetch: refetchRoles,
+	} = useRoles();
 
 	function handleClose(): void {
 		reset();
@@ -74,6 +87,8 @@ function CreateServiceAccountModal(): JSX.Element {
 		createServiceAccount({
 			data: {
 				name: values.name.trim(),
+				email: values.email.trim(),
+				roles: values.roles,
 			},
 		});
 	}
@@ -119,6 +134,68 @@ function CreateServiceAccountModal(): JSX.Element {
 							<p className="create-sa-form__error">{errors.name.message}</p>
 						)}
 					</div>
+
+					<div className="create-sa-form__item">
+						<label htmlFor="sa-email">Email Address</label>
+						<Controller
+							name="email"
+							control={control}
+							rules={{
+								required: 'Email Address is required',
+								pattern: {
+									value: EMAIL_REGEX,
+									message: 'Please enter a valid email address',
+								},
+							}}
+							render={({ field }): JSX.Element => (
+								<Input
+									id="sa-email"
+									type="email"
+									placeholder="email@example.com"
+									className="create-sa-form__input"
+									value={field.value}
+									onChange={field.onChange}
+									onBlur={field.onBlur}
+								/>
+							)}
+						/>
+						{errors.email && (
+							<p className="create-sa-form__error">{errors.email.message}</p>
+						)}
+					</div>
+					<p className="create-sa-form__helper">
+						Used only for notifications about this service account. It is not used for
+						authentication.
+					</p>
+
+					<div className="create-sa-form__item">
+						<label htmlFor="sa-roles">Roles</label>
+						<Controller
+							name="roles"
+							control={control}
+							rules={{
+								validate: (value): string | true =>
+									value.length > 0 || 'At least one role is required',
+							}}
+							render={({ field }): JSX.Element => (
+								<RolesSelect
+									id="sa-roles"
+									mode="multiple"
+									roles={roles}
+									loading={rolesLoading}
+									isError={rolesError}
+									error={rolesErrorObj}
+									onRefetch={refetchRoles}
+									placeholder="Select roles"
+									value={field.value}
+									onChange={field.onChange}
+								/>
+							)}
+						/>
+						{errors.roles && (
+							<p className="create-sa-form__error">{errors.roles.message}</p>
+						)}
+					</div>
 				</form>
 			</div>
 

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

@@ -1,4 +1,5 @@
 import { toast } from '@signozhq/sonner';
+import { listRolesSuccessResponse } from 'mocks-server/__mockdata__/roles';
 import { rest, server } from 'mocks-server/server';
 import { NuqsTestingAdapter } from 'nuqs/adapters/testing';
 import { render, screen, userEvent, waitFor } from 'tests/test-utils';
@@ -11,6 +12,7 @@ jest.mock('@signozhq/sonner', () => ({
 
 const mockToast = jest.mocked(toast);
 
+const ROLES_ENDPOINT = '*/api/v1/roles';
 const SERVICE_ACCOUNTS_ENDPOINT = '*/api/v1/service_accounts';
 
 function renderModal(): ReturnType<typeof render> {
@@ -25,6 +27,9 @@ describe('CreateServiceAccountModal', () => {
 	beforeEach(() => {
 		jest.clearAllMocks();
 		server.use(
+			rest.get(ROLES_ENDPOINT, (_, res, ctx) =>
+				res(ctx.status(200), ctx.json(listRolesSuccessResponse)),
+			),
 			rest.post(SERVICE_ACCOUNTS_ENDPOINT, (_, res, ctx) =>
 				res(ctx.status(201), ctx.json({ status: 'success', data: {} })),
 			),
@@ -43,11 +48,38 @@ describe('CreateServiceAccountModal', () => {
 		).toBeDisabled();
 	});
 
+	it('submit button remains disabled when email is invalid', async () => {
+		const user = userEvent.setup({ pointerEventsCheck: 0 });
+		renderModal();
+
+		await user.type(screen.getByPlaceholderText('Enter a name'), 'My Bot');
+		await user.type(
+			screen.getByPlaceholderText('email@example.com'),
+			'not-an-email',
+		);
+
+		await user.click(screen.getByText('Select roles'));
+		await user.click(await screen.findByTitle('signoz-admin'));
+
+		await waitFor(() =>
+			expect(
+				screen.getByRole('button', { name: /Create Service Account/i }),
+			).toBeDisabled(),
+		);
+	});
+
 	it('successful submit shows toast.success and closes modal', async () => {
 		const user = userEvent.setup({ pointerEventsCheck: 0 });
 		renderModal();
 
 		await user.type(screen.getByPlaceholderText('Enter a name'), 'Deploy Bot');
+		await user.type(
+			screen.getByPlaceholderText('email@example.com'),
+			'deploy@acme.io',
+		);
+
+		await user.click(screen.getByText('Select roles'));
+		await user.click(await screen.findByTitle('signoz-admin'));
 
 		const submitBtn = screen.getByRole('button', {
 			name: /Create Service Account/i,
@@ -84,6 +116,13 @@ describe('CreateServiceAccountModal', () => {
 		renderModal();
 
 		await user.type(screen.getByPlaceholderText('Enter a name'), 'Dupe Bot');
+		await user.type(
+			screen.getByPlaceholderText('email@example.com'),
+			'dupe@acme.io',
+		);
+
+		await user.click(screen.getByText('Select roles'));
+		await user.click(await screen.findByTitle('signoz-admin'));
 
 		const submitBtn = screen.getByRole('button', {
 			name: /Create Service Account/i,
@@ -125,4 +164,16 @@ describe('CreateServiceAccountModal', () => {
 
 		await screen.findByText('Name is required');
 	});
+
+	it('shows "Please enter a valid email address" for a malformed email', async () => {
+		const user = userEvent.setup({ pointerEventsCheck: 0 });
+		renderModal();
+
+		await user.type(
+			screen.getByPlaceholderText('email@example.com'),
+			'not-an-email',
+		);
+
+		await screen.findByText('Please enter a valid email address');
+	});
 });

frontend/src/components/EditMemberDrawer/DeleteMemberDialog.tsx

@@ -1,75 +0,0 @@
-import { Button } from '@signozhq/button';
-import { DialogFooter, DialogWrapper } from '@signozhq/dialog';
-import { Trash2, X } from '@signozhq/icons';
-import { MemberRow } from 'components/MembersTable/MembersTable';
-
-interface DeleteMemberDialogProps {
-	open: boolean;
-	isInvited: boolean;
-	member: MemberRow | null;
-	isDeleting: boolean;
-	onClose: () => void;
-	onConfirm: () => void;
-}
-
-function DeleteMemberDialog({
-	open,
-	isInvited,
-	member,
-	isDeleting,
-	onClose,
-	onConfirm,
-}: DeleteMemberDialogProps): JSX.Element {
-	const title = isInvited ? 'Revoke Invite' : 'Delete Member';
-
-	const body = isInvited ? (
-		<>
-			Are you sure you want to revoke the invite for{' '}
-			<strong>{member?.email}</strong>? They will no longer be able to join the
-			workspace using this invite.
-		</>
-	) : (
-		<>
-			Are you sure you want to delete{' '}
-			<strong>{member?.name || member?.email}</strong>? This will remove their
-			access to the workspace.
-		</>
-	);
-
-	return (
-		<DialogWrapper
-			open={open}
-			onOpenChange={(isOpen): void => {
-				if (!isOpen) {
-					onClose();
-				}
-			}}
-			title={title}
-			width="narrow"
-			className="alert-dialog delete-dialog"
-			showCloseButton={false}
-			disableOutsideClick={false}
-		>
-			<p className="delete-dialog__body">{body}</p>
-
-			<DialogFooter className="delete-dialog__footer">
-				<Button variant="solid" color="secondary" size="sm" onClick={onClose}>
-					<X size={12} />
-					Cancel
-				</Button>
-				<Button
-					variant="solid"
-					color="destructive"
-					size="sm"
-					disabled={isDeleting}
-					onClick={onConfirm}
-				>
-					<Trash2 size={12} />
-					{isDeleting ? 'Processing...' : title}
-				</Button>
-			</DialogFooter>
-		</DialogWrapper>
-	);
-}
-
-export default DeleteMemberDialog;

frontend/src/components/EditMemberDrawer/EditMemberDrawer.styles.scss

@@ -45,8 +45,8 @@
 		display: flex;
 		align-items: center;
 		justify-content: space-between;
-		min-height: 32px;
-		padding: var(--padding-1) var(--padding-2);
+		height: 32px;
+		padding: 0 var(--padding-2);
 		border-radius: 2px;
 		background: var(--l2-background);
 		border: 1px solid var(--border);
@@ -57,13 +57,6 @@
 		}
 	}
 
-	&__disabled-roles {
-		display: flex;
-		flex-wrap: wrap;
-		gap: var(--spacing-2);
-		flex: 1;
-	}
-
 	&__email-text {
 		font-size: var(--font-size-sm);
 		font-weight: var(--font-weight-normal);
@@ -83,6 +76,35 @@
 		opacity: 0.6;
 	}
 
+	&__role-select {
+		width: 100%;
+		height: 32px;
+
+		.ant-select-selector {
+			background-color: var(--l2-background) !important;
+			border-color: var(--border) !important;
+			border-radius: 2px;
+			padding: 0 var(--padding-2) !important;
+			display: flex;
+			align-items: center;
+		}
+
+		.ant-select-selection-item {
+			font-size: var(--font-size-sm);
+			color: var(--l1-foreground);
+			line-height: 32px;
+			letter-spacing: -0.07px;
+		}
+
+		.ant-select-arrow {
+			color: var(--foreground);
+		}
+
+		&:not(.ant-select-disabled):hover .ant-select-selector {
+			border-color: var(--foreground);
+		}
+	}
+
 	&__meta {
 		display: flex;
 		flex-direction: column;
@@ -146,10 +168,6 @@
 		flex-shrink: 0;
 	}
 
-	&__tooltip-wrapper {
-		display: inline-flex;
-	}
-
 	&__footer-btn {
 		display: inline-flex;
 		align-items: center;

frontend/src/components/EditMemberDrawer/EditMemberDrawer.tsx

@@ -1,66 +1,38 @@
 import { useCallback, useEffect, useState } from 'react';
-import { useCopyToClipboard } from 'react-use';
 import { Badge } from '@signozhq/badge';
 import { Button } from '@signozhq/button';
+import { DialogFooter, DialogWrapper } from '@signozhq/dialog';
 import { DrawerWrapper } from '@signozhq/drawer';
-import { LockKeyhole, RefreshCw, Trash2, X } from '@signozhq/icons';
+import {
+	Check,
+	ChevronDown,
+	Copy,
+	LockKeyhole,
+	RefreshCw,
+	Trash2,
+	X,
+} from '@signozhq/icons';
 import { Input } from '@signozhq/input';
 import { toast } from '@signozhq/sonner';
-import { Skeleton, Tooltip } from 'antd';
+import { Select } from 'antd';
 import { convertToApiError } from 'api/ErrorResponseHandlerForGeneratedAPIs';
-import type { RenderErrorResponseDTO } from 'api/generated/services/sigNoz.schemas';
+import { RenderErrorResponseDTO } from 'api/generated/services/sigNoz.schemas';
 import {
 	getResetPasswordToken,
 	useDeleteUser,
-	useGetUser,
-	useUpdateMyUserV2,
-	useUpdateUser,
+	useUpdateUserDeprecated,
 } from 'api/generated/services/users';
 import { AxiosError } from 'axios';
 import { MemberRow } from 'components/MembersTable/MembersTable';
-import RolesSelect, { useRoles } from 'components/RolesSelect';
-import SaveErrorItem from 'components/ServiceAccountDrawer/SaveErrorItem';
-import type { SaveError } from 'components/ServiceAccountDrawer/utils';
 import { DATE_TIME_FORMATS } from 'constants/dateTimeFormats';
 import { MemberStatus } from 'container/MembersSettings/utils';
-import {
-	MemberRoleUpdateFailure,
-	useMemberRoleManager,
-} from 'hooks/member/useMemberRoleManager';
-import { useAppContext } from 'providers/App/App';
+import { capitalize } from 'lodash-es';
 import { useTimezone } from 'providers/Timezone';
-import APIError from 'types/api/error';
-import { toAPIError } from 'utils/errorUtils';
-
-import DeleteMemberDialog from './DeleteMemberDialog';
-import ResetLinkDialog from './ResetLinkDialog';
+import { ROLES } from 'types/roles';
+import { popupContainer } from 'utils/selectPopupContainer';
 
 import './EditMemberDrawer.styles.scss';
 
-const ROOT_USER_TOOLTIP = 'This operation is not supported for the root user';
-const SELF_DELETE_TOOLTIP =
-	'You cannot perform this action on your own account';
-
-function getDeleteTooltip(
-	isRootUser: boolean,
-	isSelf: boolean,
-): string | undefined {
-	if (isRootUser) {
-		return ROOT_USER_TOOLTIP;
-	}
-	if (isSelf) {
-		return SELF_DELETE_TOOLTIP;
-	}
-	return undefined;
-}
-
-function toSaveApiError(err: unknown): APIError {
-	return (
-		convertToApiError(err as AxiosError<RenderErrorResponseDTO>) ??
-		toAPIError(err as AxiosError<RenderErrorResponseDTO>)
-	);
-}
-
 export interface EditMemberDrawerProps {
 	member: MemberRow | null;
 	open: boolean;
@@ -76,12 +48,9 @@ function EditMemberDrawer({
 	onComplete,
 }: EditMemberDrawerProps): JSX.Element {
 	const { formatTimezoneAdjustedTimestamp } = useTimezone();
-	const { user: currentUser } = useAppContext();
 
-	const [localDisplayName, setLocalDisplayName] = useState('');
-	const [localRole, setLocalRole] = useState('');
-	const [isSaving, setIsSaving] = useState(false);
-	const [saveErrors, setSaveErrors] = useState<SaveError[]>([]);
+	const [displayName, setDisplayName] = useState('');
+	const [selectedRole, setSelectedRole] = useState<ROLES>('VIEWER');
 	const [isGeneratingLink, setIsGeneratingLink] = useState(false);
 	const [showDeleteConfirm, setShowDeleteConfirm] = useState(false);
 	const [resetLink, setResetLink] = useState<string | null>(null);
@@ -90,63 +59,32 @@ function EditMemberDrawer({
 	const [linkType, setLinkType] = useState<'invite' | 'reset' | null>(null);
 
 	const isInvited = member?.status === MemberStatus.Invited;
-	const isSelf = !!member?.id && member.id === currentUser?.id;
 
-	const {
-		data: fetchedUser,
-		isLoading: isFetchingUser,
-		refetch: refetchUser,
-	} = useGetUser(
-		{ id: member?.id ?? '' },
-		{ query: { enabled: open && !!member?.id } },
-	);
-
-	const isRootUser = !!fetchedUser?.data?.isRoot;
-
-	const {
-		roles: availableRoles,
-		isLoading: rolesLoading,
-		isError: rolesError,
-		error: rolesErrorObj,
-		refetch: refetchRoles,
-	} = useRoles();
-
-	const { fetchedRoleIds, applyDiff } = useMemberRoleManager(
-		member?.id ?? '',
-		open && !!member?.id,
-	);
-
-	const fetchedDisplayName =
-		fetchedUser?.data?.displayName ?? member?.name ?? '';
-	const fetchedUserId = fetchedUser?.data?.id;
-	const fetchedUserDisplayName = fetchedUser?.data?.displayName;
-
-	useEffect(() => {
-		if (fetchedUserId) {
-			setLocalDisplayName(fetchedUserDisplayName ?? member?.name ?? '');
-		}
-		setSaveErrors([]);
-	}, [fetchedUserId, fetchedUserDisplayName, member?.name]);
-
-	useEffect(() => {
-		setLocalRole(fetchedRoleIds[0] ?? '');
-	}, [fetchedRoleIds]);
-
-	const isDirty =
-		member !== null &&
-		fetchedUser != null &&
-		(localDisplayName !== fetchedDisplayName ||
-			localRole !== (fetchedRoleIds[0] ?? ''));
-
-	const { mutateAsync: updateMyUser } = useUpdateMyUserV2();
-	const { mutateAsync: updateUser } = useUpdateUser();
+	const { mutate: updateUser, isLoading: isSaving } = useUpdateUserDeprecated({
+		mutation: {
+			onSuccess: (): void => {
+				toast.success('Member details updated successfully', { richColors: true });
+				onComplete();
+				onClose();
+			},
+			onError: (err): void => {
+				const errMessage =
+					convertToApiError(
+						err as AxiosError<RenderErrorResponseDTO, unknown> | null,
+					)?.getErrorMessage() || 'An error occurred';
+				toast.error(`Failed to update member details: ${errMessage}`, {
+					richColors: true,
+				});
+			},
+		},
+	});
 
 	const { mutate: deleteUser, isLoading: isDeleting } = useDeleteUser({
 		mutation: {
 			onSuccess: (): void => {
 				toast.success(
 					isInvited ? 'Invite revoked successfully' : 'Member deleted successfully',
-					{ richColors: true, position: 'top-right' },
+					{ richColors: true },
 				);
 				setShowDeleteConfirm(false);
 				onComplete();
@@ -160,168 +98,53 @@ function EditMemberDrawer({
 				const prefix = isInvited
 					? 'Failed to revoke invite'
 					: 'Failed to delete member';
-				toast.error(`${prefix}: ${errMessage}`, {
-					richColors: true,
-					position: 'top-right',
-				});
+				toast.error(`${prefix}: ${errMessage}`, { richColors: true });
 			},
 		},
 	});
 
-	const makeRoleRetry = useCallback(
-		(
-			context: string,
-			rawRetry: () => Promise<void>,
-		) => async (): Promise<void> => {
-			try {
-				await rawRetry();
-				setSaveErrors((prev) => prev.filter((e) => e.context !== context));
-				refetchUser();
-			} catch (err) {
-				setSaveErrors((prev) =>
-					prev.map((e) =>
-						e.context === context ? { ...e, apiError: toSaveApiError(err) } : e,
-					),
-				);
+	useEffect(() => {
+		if (member) {
+			setDisplayName(member.name ?? '');
+			setSelectedRole(member.role);
+		}
+	}, [member]);
+
+	const isDirty =
+		member !== null &&
+		(displayName !== (member.name ?? '') || selectedRole !== member.role);
+
+	const formatTimestamp = useCallback(
+		(ts: string | null | undefined): string => {
+			if (!ts) {
+				return '—';
 			}
+			const d = new Date(ts);
+			if (Number.isNaN(d.getTime())) {
+				return '—';
+			}
+			return formatTimezoneAdjustedTimestamp(ts, DATE_TIME_FORMATS.DASH_DATETIME);
 		},
-		[refetchUser],
+		[formatTimezoneAdjustedTimestamp],
 	);
 
-	const retryNameUpdate = useCallback(async (): Promise<void> => {
-		if (!member) {
-			return;
-		}
-		try {
-			if (isSelf) {
-				await updateMyUser({ data: { displayName: localDisplayName } });
-			} else {
-				await updateUser({
-					pathParams: { id: member.id },
-					data: { displayName: localDisplayName },
-				});
-			}
-			setSaveErrors((prev) => prev.filter((e) => e.context !== 'Name update'));
-			refetchUser();
-		} catch (err) {
-			setSaveErrors((prev) =>
-				prev.map((e) =>
-					e.context === 'Name update' ? { ...e, apiError: toSaveApiError(err) } : e,
-				),
-			);
-		}
-	}, [member, isSelf, localDisplayName, updateMyUser, updateUser, refetchUser]);
-
-	const handleSave = useCallback(async (): Promise<void> => {
+	const handleSave = useCallback((): void => {
 		if (!member || !isDirty) {
 			return;
 		}
-		setSaveErrors([]);
-		setIsSaving(true);
-		try {
-			const nameChanged = localDisplayName !== fetchedDisplayName;
-			const rolesChanged = localRole !== (fetchedRoleIds[0] ?? '');
-
-			const namePromise = nameChanged
-				? isSelf
-					? updateMyUser({ data: { displayName: localDisplayName } })
-					: updateUser({
-							pathParams: { id: member.id },
-							data: { displayName: localDisplayName },
-					  })
-				: Promise.resolve();
-
-			const [nameResult, rolesResult] = await Promise.allSettled([
-				namePromise,
-				rolesChanged
-					? applyDiff([localRole].filter(Boolean), availableRoles)
-					: Promise.resolve([]),
-			]);
-
-			const errors: SaveError[] = [];
-
-			if (nameResult.status === 'rejected') {
-				errors.push({
-					context: 'Name update',
-					apiError: toSaveApiError(nameResult.reason),
-					onRetry: retryNameUpdate,
-				});
-			}
-
-			if (rolesResult.status === 'rejected') {
-				errors.push({
-					context: 'Roles update',
-					apiError: toSaveApiError(rolesResult.reason),
-					onRetry: async (): Promise<void> => {
-						const failures = await applyDiff(
-							[localRole].filter(Boolean),
-							availableRoles,
-						);
-						setSaveErrors((prev) => {
-							const rest = prev.filter((e) => e.context !== 'Roles update');
-							return [
-								...rest,
-								...failures.map((f: MemberRoleUpdateFailure) => {
-									const ctx = `Role '${f.roleName}'`;
-									return {
-										context: ctx,
-										apiError: toSaveApiError(f.error),
-										onRetry: makeRoleRetry(ctx, f.onRetry),
-									};
-								}),
-							];
-						});
-						refetchUser();
-					},
-				});
-			} else {
-				for (const failure of rolesResult.value ?? []) {
-					const context = `Role '${failure.roleName}'`;
-					errors.push({
-						context,
-						apiError: toSaveApiError(failure.error),
-						onRetry: makeRoleRetry(context, failure.onRetry),
-					});
-				}
-			}
-
-			if (errors.length > 0) {
-				setSaveErrors(errors);
-			} else {
-				toast.success('Member details updated successfully', {
-					richColors: true,
-					position: 'top-right',
-				});
-				onComplete();
-			}
-
-			refetchUser();
-		} finally {
-			setIsSaving(false);
-		}
-	}, [
-		member,
-		isDirty,
-		isSelf,
-		localDisplayName,
-		localRole,
-		fetchedDisplayName,
-		fetchedRoleIds,
-		updateMyUser,
-		updateUser,
-		applyDiff,
-		availableRoles,
-		refetchUser,
-		retryNameUpdate,
-		makeRoleRetry,
-		onComplete,
-	]);
+		updateUser({
+			pathParams: { id: member.id },
+			data: { id: member.id, displayName, role: selectedRole },
+		});
+	}, [member, isDirty, displayName, selectedRole, updateUser]);
 
 	const handleDelete = useCallback((): void => {
 		if (!member) {
 			return;
 		}
-		deleteUser({ pathParams: { id: member.id } });
+		deleteUser({
+			pathParams: { id: member.id },
+		});
 	}, [member, deleteUser]);
 
 	const handleGenerateResetLink = useCallback(async (): Promise<void> => {
@@ -352,31 +175,28 @@ function EditMemberDrawer({
 		} finally {
 			setIsGeneratingLink(false);
 		}
-	}, [member, isInvited, onClose]);
+	}, [member, isInvited, setLinkType, onClose]);
 
-	const [copyState, copyToClipboard] = useCopyToClipboard();
-	const handleCopyResetLink = useCallback((): void => {
+	const handleCopyResetLink = useCallback(async (): Promise<void> => {
 		if (!resetLink) {
 			return;
 		}
-		copyToClipboard(resetLink);
-		setHasCopiedResetLink(true);
-		setTimeout(() => setHasCopiedResetLink(false), 2000);
-		const message =
-			linkType === 'invite'
-				? 'Invite link copied to clipboard'
-				: 'Reset link copied to clipboard';
-		toast.success(message, { richColors: true, position: 'top-right' });
-	}, [resetLink, copyToClipboard, linkType]);
-
-	useEffect(() => {
-		if (copyState.error) {
+		try {
+			await navigator.clipboard.writeText(resetLink);
+			setHasCopiedResetLink(true);
+			setTimeout(() => setHasCopiedResetLink(false), 2000);
+			toast.success(
+				linkType === 'invite'
+					? 'Invite link copied to clipboard'
+					: 'Reset link copied to clipboard',
+				{ richColors: true },
+			);
+		} catch {
 			toast.error('Failed to copy link', {
 				richColors: true,
-				position: 'top-right',
 			});
 		}
-	}, [copyState.error]);
+	}, [resetLink, linkType]);
 
 	const handleClose = useCallback((): void => {
 		setShowDeleteConfirm(false);
@@ -385,176 +205,102 @@ function EditMemberDrawer({
 
 	const joinedOnLabel = isInvited ? 'Invited On' : 'Joined On';
 
-	const formatTimestamp = useCallback(
-		(ts: string | null | undefined): string => {
-			if (!ts) {
-				return '—';
-			}
-			const d = new Date(ts);
-			if (Number.isNaN(d.getTime())) {
-				return '—';
-			}
-			return formatTimezoneAdjustedTimestamp(ts, DATE_TIME_FORMATS.DASH_DATETIME);
-		},
-		[formatTimezoneAdjustedTimestamp],
-	);
-
-	const drawerBody = isFetchingUser ? (
-		<Skeleton active paragraph={{ rows: 6 }} />
-	) : (
-		<>
-			<div className="edit-member-drawer__field">
-				<label className="edit-member-drawer__label" htmlFor="member-name">
-					Name
-				</label>
-				<Tooltip title={isRootUser ? ROOT_USER_TOOLTIP : undefined}>
-					<Input
-						id="member-name"
-						value={localDisplayName}
-						onChange={(e): void => {
-							setLocalDisplayName(e.target.value);
-							setSaveErrors((prev) =>
-								prev.filter((err) => err.context !== 'Name update'),
-							);
-						}}
-						className="edit-member-drawer__input"
-						placeholder="Enter name"
-						disabled={isRootUser}
-					/>
-				</Tooltip>
-			</div>
-
-			<div className="edit-member-drawer__field">
-				<label className="edit-member-drawer__label" htmlFor="member-email">
-					Email Address
-				</label>
-				<div className="edit-member-drawer__input-wrapper edit-member-drawer__input-wrapper--disabled">
-					<span className="edit-member-drawer__email-text">
-						{member?.email || '—'}
-					</span>
-					<LockKeyhole size={16} className="edit-member-drawer__lock-icon" />
-				</div>
-			</div>
-
-			<div className="edit-member-drawer__field">
-				<label className="edit-member-drawer__label" htmlFor="member-role">
-					Roles
-				</label>
-				{isSelf || isRootUser ? (
-					<Tooltip
-						title={isRootUser ? ROOT_USER_TOOLTIP : 'You cannot modify your own role'}
-					>
-						<div className="edit-member-drawer__input-wrapper edit-member-drawer__input-wrapper--disabled">
-							<div className="edit-member-drawer__disabled-roles">
-								{localRole ? (
-									<Badge color="vanilla">
-										{availableRoles.find((r) => r.id === localRole)?.name ?? localRole}
-									</Badge>
-								) : (
-									<span className="edit-member-drawer__email-text">—</span>
-								)}
-							</div>
-							<LockKeyhole size={16} className="edit-member-drawer__lock-icon" />
-						</div>
-					</Tooltip>
-				) : (
-					<RolesSelect
-						id="member-role"
-						roles={availableRoles}
-						loading={rolesLoading}
-						isError={rolesError}
-						error={rolesErrorObj}
-						onRefetch={refetchRoles}
-						value={localRole}
-						onChange={(role): void => {
-							setLocalRole(role);
-							setSaveErrors((prev) =>
-								prev.filter(
-									(err) =>
-										err.context !== 'Roles update' && !err.context.startsWith("Role '"),
-								),
-							);
-						}}
-						placeholder="Select role"
-					/>
-				)}
-			</div>
-
-			<div className="edit-member-drawer__meta">
-				<div className="edit-member-drawer__meta-item">
-					<span className="edit-member-drawer__meta-label">Status</span>
-					{member?.status === MemberStatus.Active ? (
-						<Badge color="forest" variant="outline">
-							ACTIVE
-						</Badge>
-					) : (
-						<Badge color="amber" variant="outline">
-							INVITED
-						</Badge>
-					)}
-				</div>
-
-				<div className="edit-member-drawer__meta-item">
-					<span className="edit-member-drawer__meta-label">{joinedOnLabel}</span>
-					<Badge color="vanilla">{formatTimestamp(member?.joinedOn)}</Badge>
-				</div>
-				{!isInvited && (
-					<div className="edit-member-drawer__meta-item">
-						<span className="edit-member-drawer__meta-label">Last Modified</span>
-						<Badge color="vanilla">{formatTimestamp(member?.updatedAt)}</Badge>
-					</div>
-				)}
-			</div>
-
-			{saveErrors.length > 0 && (
-				<div className="edit-member-drawer__save-errors">
-					{saveErrors.map((e) => (
-						<SaveErrorItem
-							key={e.context}
-							context={e.context}
-							apiError={e.apiError}
-							onRetry={e.onRetry}
-						/>
-					))}
-				</div>
-			)}
-		</>
-	);
-
 	const drawerContent = (
 		<div className="edit-member-drawer__layout">
-			<div className="edit-member-drawer__body">{drawerBody}</div>
+			<div className="edit-member-drawer__body">
+				<div className="edit-member-drawer__field">
+					<label className="edit-member-drawer__label" htmlFor="member-name">
+						Name
+					</label>
+					<Input
+						id="member-name"
+						value={displayName}
+						onChange={(e): void => setDisplayName(e.target.value)}
+						className="edit-member-drawer__input"
+						placeholder="Enter name"
+					/>
+				</div>
+
+				<div className="edit-member-drawer__field">
+					<label className="edit-member-drawer__label" htmlFor="member-email">
+						Email Address
+					</label>
+					<div className="edit-member-drawer__input-wrapper edit-member-drawer__input-wrapper--disabled">
+						<span className="edit-member-drawer__email-text">
+							{member?.email || '—'}
+						</span>
+						<LockKeyhole size={16} className="edit-member-drawer__lock-icon" />
+					</div>
+				</div>
+
+				<div className="edit-member-drawer__field">
+					<label className="edit-member-drawer__label" htmlFor="member-role">
+						Roles
+					</label>
+					<Select
+						id="member-role"
+						value={selectedRole}
+						onChange={(role): void => setSelectedRole(role as ROLES)}
+						className="edit-member-drawer__role-select"
+						suffixIcon={<ChevronDown size={14} />}
+						getPopupContainer={popupContainer}
+					>
+						<Select.Option value="ADMIN">{capitalize('ADMIN')}</Select.Option>
+						<Select.Option value="EDITOR">{capitalize('EDITOR')}</Select.Option>
+						<Select.Option value="VIEWER">{capitalize('VIEWER')}</Select.Option>
+					</Select>
+				</div>
+
+				<div className="edit-member-drawer__meta">
+					<div className="edit-member-drawer__meta-item">
+						<span className="edit-member-drawer__meta-label">Status</span>
+						{member?.status === MemberStatus.Active ? (
+							<Badge color="forest" variant="outline">
+								ACTIVE
+							</Badge>
+						) : (
+							<Badge color="amber" variant="outline">
+								INVITED
+							</Badge>
+						)}
+					</div>
+
+					<div className="edit-member-drawer__meta-item">
+						<span className="edit-member-drawer__meta-label">{joinedOnLabel}</span>
+						<Badge color="vanilla">{formatTimestamp(member?.joinedOn)}</Badge>
+					</div>
+					{!isInvited && (
+						<div className="edit-member-drawer__meta-item">
+							<span className="edit-member-drawer__meta-label">Last Modified</span>
+							<Badge color="vanilla">{formatTimestamp(member?.updatedAt)}</Badge>
+						</div>
+					)}
+				</div>
+			</div>
 
 			<div className="edit-member-drawer__footer">
 				<div className="edit-member-drawer__footer-left">
-					<Tooltip title={getDeleteTooltip(isRootUser, isSelf)}>
-						<span className="edit-member-drawer__tooltip-wrapper">
-							<Button
-								className="edit-member-drawer__footer-btn edit-member-drawer__footer-btn--danger"
-								onClick={(): void => setShowDeleteConfirm(true)}
-								disabled={isRootUser || isSelf}
-							>
-								<Trash2 size={12} />
-								{isInvited ? 'Revoke Invite' : 'Delete Member'}
-							</Button>
-						</span>
-					</Tooltip>
+					<Button
+						className="edit-member-drawer__footer-btn edit-member-drawer__footer-btn--danger"
+						onClick={(): void => setShowDeleteConfirm(true)}
+					>
+						<Trash2 size={12} />
+						{isInvited ? 'Revoke Invite' : 'Delete Member'}
+					</Button>
 
 					<div className="edit-member-drawer__footer-divider" />
-					<Tooltip title={isRootUser ? ROOT_USER_TOOLTIP : undefined}>
-						<span className="edit-member-drawer__tooltip-wrapper">
-							<Button
-								className="edit-member-drawer__footer-btn edit-member-drawer__footer-btn--warning"
-								onClick={handleGenerateResetLink}
-								disabled={isGeneratingLink || isRootUser}
-							>
-								<RefreshCw size={12} />
-								{isGeneratingLink && 'Generating...'}
-								{!isGeneratingLink && isInvited && 'Copy Invite Link'}
-								{!isGeneratingLink && !isInvited && 'Generate Password Reset Link'}
-							</Button>
-						</span>
-					</Tooltip>
+					<Button
+						className="edit-member-drawer__footer-btn edit-member-drawer__footer-btn--warning"
+						onClick={handleGenerateResetLink}
+						disabled={isGeneratingLink}
+					>
+						<RefreshCw size={12} />
+						{isGeneratingLink
+							? 'Generating...'
+							: isInvited
+							? 'Copy Invite Link'
+							: 'Generate Password Reset Link'}
+					</Button>
 				</div>
 
 				<div className="edit-member-drawer__footer-right">
@@ -567,7 +313,7 @@ function EditMemberDrawer({
 						variant="solid"
 						color="primary"
 						size="sm"
-						disabled={!isDirty || isSaving || isRootUser}
+						disabled={!isDirty || isSaving}
 						onClick={handleSave}
 					>
 						{isSaving ? 'Saving...' : 'Save Member Details'}
@@ -577,6 +323,22 @@ function EditMemberDrawer({
 		</div>
 	);
 
+	const deleteDialogTitle = isInvited ? 'Revoke Invite' : 'Delete Member';
+	const deleteDialogBody = isInvited ? (
+		<>
+			Are you sure you want to revoke the invite for{' '}
+			<strong>{member?.email}</strong>? They will no longer be able to join the
+			workspace using this invite.
+		</>
+	) : (
+		<>
+			Are you sure you want to delete{' '}
+			<strong>{member?.name || member?.email}</strong>? This will remove their
+			access to the workspace.
+		</>
+	);
+	const deleteConfirmLabel = isInvited ? 'Revoke Invite' : 'Delete Member';
+
 	return (
 		<>
 			<DrawerWrapper
@@ -596,25 +358,82 @@ function EditMemberDrawer({
 				className="edit-member-drawer"
 			/>
 
-			<ResetLinkDialog
+			<DialogWrapper
 				open={showResetLinkDialog}
-				linkType={linkType}
-				resetLink={resetLink}
-				hasCopied={hasCopiedResetLink}
-				onClose={(): void => {
-					setShowResetLinkDialog(false);
+				onOpenChange={(isOpen): void => {
+					if (!isOpen) {
+						setShowResetLinkDialog(false);
+						setLinkType(null);
+					}
 				}}
-				onCopy={handleCopyResetLink}
-			/>
+				title={linkType === 'invite' ? 'Invite Link' : 'Password Reset Link'}
+				showCloseButton
+				width="base"
+				className="reset-link-dialog"
+			>
+				<div className="reset-link-dialog__content">
+					<p className="reset-link-dialog__description">
+						{linkType === 'invite'
+							? 'Share this one-time link with the team member to complete their account setup.'
+							: 'This creates a one-time link the team member can use to set a new password for their SigNoz account.'}
+					</p>
+					<div className="reset-link-dialog__link-row">
+						<div className="reset-link-dialog__link-text-wrap">
+							<span className="reset-link-dialog__link-text">{resetLink}</span>
+						</div>
+						<Button
+							variant="outlined"
+							color="secondary"
+							size="sm"
+							onClick={handleCopyResetLink}
+							prefixIcon={
+								hasCopiedResetLink ? <Check size={12} /> : <Copy size={12} />
+							}
+							className="reset-link-dialog__copy-btn"
+						>
+							{hasCopiedResetLink ? 'Copied!' : 'Copy'}
+						</Button>
+					</div>
+				</div>
+			</DialogWrapper>
 
-			<DeleteMemberDialog
+			<DialogWrapper
 				open={showDeleteConfirm}
-				isInvited={isInvited}
-				member={member}
-				isDeleting={isDeleting}
-				onClose={(): void => setShowDeleteConfirm(false)}
-				onConfirm={handleDelete}
-			/>
+				onOpenChange={(isOpen): void => {
+					if (!isOpen) {
+						setShowDeleteConfirm(false);
+					}
+				}}
+				title={deleteDialogTitle}
+				width="narrow"
+				className="alert-dialog delete-dialog"
+				showCloseButton={false}
+				disableOutsideClick={false}
+			>
+				<p className="delete-dialog__body">{deleteDialogBody}</p>
+
+				<DialogFooter className="delete-dialog__footer">
+					<Button
+						variant="solid"
+						color="secondary"
+						size="sm"
+						onClick={(): void => setShowDeleteConfirm(false)}
+					>
+						<X size={12} />
+						Cancel
+					</Button>
+					<Button
+						variant="solid"
+						color="destructive"
+						size="sm"
+						disabled={isDeleting}
+						onClick={handleDelete}
+					>
+						<Trash2 size={12} />
+						{isDeleting ? 'Processing...' : deleteConfirmLabel}
+					</Button>
+				</DialogFooter>
+			</DialogWrapper>
 		</>
 	);
 }

frontend/src/components/EditMemberDrawer/ResetLinkDialog.tsx

@@ -1,61 +0,0 @@
-import { Button } from '@signozhq/button';
-import { DialogWrapper } from '@signozhq/dialog';
-import { Check, Copy } from '@signozhq/icons';
-
-interface ResetLinkDialogProps {
-	open: boolean;
-	linkType: 'invite' | 'reset' | null;
-	resetLink: string | null;
-	hasCopied: boolean;
-	onClose: () => void;
-	onCopy: () => void;
-}
-
-function ResetLinkDialog({
-	open,
-	linkType,
-	resetLink,
-	hasCopied,
-	onClose,
-	onCopy,
-}: ResetLinkDialogProps): JSX.Element {
-	return (
-		<DialogWrapper
-			open={open}
-			onOpenChange={(isOpen): void => {
-				if (!isOpen) {
-					onClose();
-				}
-			}}
-			title={linkType === 'invite' ? 'Invite Link' : 'Password Reset Link'}
-			showCloseButton
-			width="base"
-			className="reset-link-dialog"
-		>
-			<div className="reset-link-dialog__content">
-				<p className="reset-link-dialog__description">
-					{linkType === 'invite'
-						? 'Share this one-time link with the team member to complete their account setup.'
-						: 'This creates a one-time link the team member can use to set a new password for their SigNoz account.'}
-				</p>
-				<div className="reset-link-dialog__link-row">
-					<div className="reset-link-dialog__link-text-wrap">
-						<span className="reset-link-dialog__link-text">{resetLink}</span>
-					</div>
-					<Button
-						variant="outlined"
-						color="secondary"
-						size="sm"
-						onClick={onCopy}
-						prefixIcon={hasCopied ? <Check size={12} /> : <Copy size={12} />}
-						className="reset-link-dialog__copy-btn"
-					>
-						{hasCopied ? 'Copied!' : 'Copy'}
-					</Button>
-				</div>
-			</div>
-		</DialogWrapper>
-	);
-}
-
-export default ResetLinkDialog;

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

@@ -4,18 +4,17 @@ import { convertToApiError } from 'api/ErrorResponseHandlerForGeneratedAPIs';
 import {
 	getResetPasswordToken,
 	useDeleteUser,
-	useGetUser,
-	useSetRoleByUserID,
-	useUpdateMyUserV2,
-	useUpdateUser,
+	useUpdateUserDeprecated,
 } from 'api/generated/services/users';
 import { MemberStatus } from 'container/MembersSettings/utils';
 import {
-	listRolesSuccessResponse,
-	managedRoles,
-} from 'mocks-server/__mockdata__/roles';
-import { rest, server } from 'mocks-server/server';
-import { render, screen, userEvent, waitFor } from 'tests/test-utils';
+	fireEvent,
+	render,
+	screen,
+	userEvent,
+	waitFor,
+} from 'tests/test-utils';
+import { ROLES } from 'types/roles';
 
 import EditMemberDrawer, { EditMemberDrawerProps } from '../EditMemberDrawer';
 
@@ -51,10 +50,7 @@ jest.mock('@signozhq/dialog', () => ({
 
 jest.mock('api/generated/services/users', () => ({
 	useDeleteUser: jest.fn(),
-	useGetUser: jest.fn(),
-	useUpdateUser: jest.fn(),
-	useUpdateMyUserV2: jest.fn(),
-	useSetRoleByUserID: jest.fn(),
+	useUpdateUserDeprecated: jest.fn(),
 	getResetPasswordToken: jest.fn(),
 }));
 
@@ -69,63 +65,25 @@ jest.mock('@signozhq/sonner', () => ({
 	},
 }));
 
-const mockCopyToClipboard = jest.fn();
-const mockCopyState = { value: undefined, error: undefined };
-
-jest.mock('react-use', () => ({
-	useCopyToClipboard: (): [typeof mockCopyState, typeof mockCopyToClipboard] => [
-		mockCopyState,
-		mockCopyToClipboard,
-	],
-}));
-
-const ROLES_ENDPOINT = '*/api/v1/roles';
-
+const mockUpdateMutate = jest.fn();
 const mockDeleteMutate = jest.fn();
 const mockGetResetPasswordToken = jest.mocked(getResetPasswordToken);
 
-const mockFetchedUser = {
-	data: {
-		id: 'user-1',
-		displayName: 'Alice Smith',
-		email: 'alice@signoz.io',
-		status: 'active',
-		userRoles: [
-			{
-				id: 'ur-1',
-				roleId: managedRoles[0].id,
-				role: managedRoles[0], // signoz-admin
-			},
-		],
-	},
-};
-
 const activeMember = {
 	id: 'user-1',
 	name: 'Alice Smith',
 	email: 'alice@signoz.io',
+	role: 'ADMIN' as ROLES,
 	status: MemberStatus.Active,
 	joinedOn: '1700000000000',
 	updatedAt: '1710000000000',
 };
 
-const selfMember = {
-	...activeMember,
-	id: 'some-user-id',
-};
-
-const rootMockFetchedUser = {
-	data: {
-		...mockFetchedUser.data,
-		id: 'root-user-1',
-		isRoot: true,
-	},
-};
-
 const invitedMember = {
 	id: 'abc123',
 	name: '',
 	email: 'bob@signoz.io',
+	role: 'VIEWER' as ROLES,
 	status: MemberStatus.Invited,
 	joinedOn: '1700000000000',
 };
@@ -147,26 +105,8 @@ function renderDrawer(
 describe('EditMemberDrawer', () => {
 	beforeEach(() => {
 		jest.clearAllMocks();
-		server.use(
-			rest.get(ROLES_ENDPOINT, (_, res, ctx) =>
-				res(ctx.status(200), ctx.json(listRolesSuccessResponse)),
-			),
-		);
-		(useGetUser as jest.Mock).mockReturnValue({
-			data: mockFetchedUser,
-			isLoading: false,
-			refetch: jest.fn(),
-		});
-		(useUpdateUser as jest.Mock).mockReturnValue({
-			mutateAsync: jest.fn().mockResolvedValue({}),
-			isLoading: false,
-		});
-		(useUpdateMyUserV2 as jest.Mock).mockReturnValue({
-			mutateAsync: jest.fn().mockResolvedValue({}),
-			isLoading: false,
-		});
-		(useSetRoleByUserID as jest.Mock).mockReturnValue({
-			mutateAsync: jest.fn().mockResolvedValue({}),
+		(useUpdateUserDeprecated as jest.Mock).mockReturnValue({
+			mutate: mockUpdateMutate,
 			isLoading: false,
 		});
 		(useDeleteUser as jest.Mock).mockReturnValue({
@@ -175,10 +115,6 @@ describe('EditMemberDrawer', () => {
 		});
 	});
 
-	afterEach(() => {
-		server.resetHandlers();
-	});
-
 	it('renders active member details and disables Save when form is not dirty', () => {
 		renderDrawer();
 
@@ -190,15 +126,16 @@ describe('EditMemberDrawer', () => {
 		).toBeDisabled();
 	});
 
-	it('enables Save after editing name and calls updateUser on confirm', async () => {
+	it('enables Save after editing name and calls update API on confirm', async () => {
 		const onComplete = jest.fn();
 		const user = userEvent.setup({ pointerEventsCheck: 0 });
-		const mockMutateAsync = jest.fn().mockResolvedValue({});
 
-		(useUpdateUser as jest.Mock).mockReturnValue({
-			mutateAsync: mockMutateAsync,
+		(useUpdateUserDeprecated as jest.Mock).mockImplementation((options) => ({
+			mutate: mockUpdateMutate.mockImplementation(() => {
+				options?.mutation?.onSuccess?.();
+			}),
 			isLoading: false,
-		});
+		}));
 
 		renderDrawer({ onComplete });
 
@@ -212,90 +149,12 @@ describe('EditMemberDrawer', () => {
 		await user.click(saveBtn);
 
 		await waitFor(() => {
-			expect(mockMutateAsync).toHaveBeenCalledWith({
-				pathParams: { id: 'user-1' },
-				data: { displayName: 'Alice Updated' },
-			});
-			expect(onComplete).toHaveBeenCalled();
-		});
-	});
-
-	it('does not close the drawer after a successful save', async () => {
-		const onClose = jest.fn();
-		const user = userEvent.setup({ pointerEventsCheck: 0 });
-
-		renderDrawer({ onClose });
-
-		const nameInput = screen.getByDisplayValue('Alice Smith');
-		await user.clear(nameInput);
-		await user.type(nameInput, 'Alice Updated');
-
-		const saveBtn = screen.getByRole('button', { name: /save member details/i });
-		await waitFor(() => expect(saveBtn).not.toBeDisabled());
-		await user.click(saveBtn);
-
-		await waitFor(() => {
-			expect(
-				screen.getByRole('button', { name: /save member details/i }),
-			).toBeInTheDocument();
-		});
-		expect(onClose).not.toHaveBeenCalled();
-	});
-
-	it('selecting a different role calls setRole with the new role name', async () => {
-		const onComplete = jest.fn();
-		const user = userEvent.setup({ pointerEventsCheck: 0 });
-		const mockSet = jest.fn().mockResolvedValue({});
-
-		(useSetRoleByUserID as jest.Mock).mockReturnValue({
-			mutateAsync: mockSet,
-			isLoading: false,
-		});
-
-		renderDrawer({ onComplete });
-
-		// Open the roles dropdown and select signoz-editor
-		await user.click(screen.getByLabelText('Roles'));
-		await user.click(await screen.findByTitle('signoz-editor'));
-
-		const saveBtn = screen.getByRole('button', { name: /save member details/i });
-		await waitFor(() => expect(saveBtn).not.toBeDisabled());
-		await user.click(saveBtn);
-
-		await waitFor(() => {
-			expect(mockSet).toHaveBeenCalledWith({
-				pathParams: { id: 'user-1' },
-				data: { name: 'signoz-editor' },
-			});
-			expect(onComplete).toHaveBeenCalled();
-		});
-	});
-
-	it('does not call removeRole when the role is changed', async () => {
-		const onComplete = jest.fn();
-		const user = userEvent.setup({ pointerEventsCheck: 0 });
-		const mockSet = jest.fn().mockResolvedValue({});
-
-		(useSetRoleByUserID as jest.Mock).mockReturnValue({
-			mutateAsync: mockSet,
-			isLoading: false,
-		});
-
-		renderDrawer({ onComplete });
-
-		// Switch from signoz-admin to signoz-viewer using single-select
-		await user.click(screen.getByLabelText('Roles'));
-		await user.click(await screen.findByTitle('signoz-viewer'));
-
-		const saveBtn = screen.getByRole('button', { name: /save member details/i });
-		await waitFor(() => expect(saveBtn).not.toBeDisabled());
-		await user.click(saveBtn);
-
-		await waitFor(() => {
-			expect(mockSet).toHaveBeenCalledWith({
-				pathParams: { id: 'user-1' },
-				data: { name: 'signoz-viewer' },
-			});
+			expect(mockUpdateMutate).toHaveBeenCalledWith(
+				expect.objectContaining({
+					pathParams: { id: 'user-1' },
+					data: expect.objectContaining({ displayName: 'Alice Updated' }),
+				}),
+			);
 			expect(onComplete).toHaveBeenCalled();
 		});
 	});
@@ -376,33 +235,16 @@ describe('EditMemberDrawer', () => {
 		});
 	});
 
-	it('calls updateUser when saving name change for an invited member', async () => {
+	it('calls update API when saving changes for an invited member', async () => {
 		const onComplete = jest.fn();
 		const user = userEvent.setup({ pointerEventsCheck: 0 });
-		const mockMutateAsync = jest.fn().mockResolvedValue({});
 
-		(useGetUser as jest.Mock).mockReturnValue({
-			data: {
-				data: {
-					...mockFetchedUser.data,
-					id: 'abc123',
-					displayName: 'Bob',
-					userRoles: [
-						{
-							id: 'ur-2',
-							roleId: managedRoles[2].id,
-							role: managedRoles[2], // signoz-viewer
-						},
-					],
-				},
-			},
+		(useUpdateUserDeprecated as jest.Mock).mockImplementation((options) => ({
+			mutate: mockUpdateMutate.mockImplementation(() => {
+				options?.mutation?.onSuccess?.();
+			}),
 			isLoading: false,
-			refetch: jest.fn(),
-		});
-		(useUpdateUser as jest.Mock).mockReturnValue({
-			mutateAsync: mockMutateAsync,
-			isLoading: false,
-		});
+		}));
 
 		renderDrawer({ member: { ...invitedMember, name: 'Bob' }, onComplete });
 
@@ -415,10 +257,12 @@ describe('EditMemberDrawer', () => {
 		await user.click(saveBtn);
 
 		await waitFor(() => {
-			expect(mockMutateAsync).toHaveBeenCalledWith({
-				pathParams: { id: 'abc123' },
-				data: { displayName: 'Bob Updated' },
-			});
+			expect(mockUpdateMutate).toHaveBeenCalledWith(
+				expect.objectContaining({
+					pathParams: { id: 'abc123' },
+					data: expect.objectContaining({ displayName: 'Bob Updated' }),
+				}),
+			);
 			expect(onComplete).toHaveBeenCalled();
 		});
 	});
@@ -432,13 +276,16 @@ describe('EditMemberDrawer', () => {
 			} as ReturnType<typeof convertToApiError>);
 		});
 
-		it('shows SaveErrorItem when updateUser fails for name change', async () => {
+		it('shows API error message when updateUser fails', async () => {
 			const user = userEvent.setup({ pointerEventsCheck: 0 });
+			const mockToast = jest.mocked(toast);
 
-			(useUpdateUser as jest.Mock).mockReturnValue({
-				mutateAsync: jest.fn().mockRejectedValue(new Error('server error')),
+			(useUpdateUserDeprecated as jest.Mock).mockImplementation((options) => ({
+				mutate: mockUpdateMutate.mockImplementation(() => {
+					options?.mutation?.onError?.({});
+				}),
 				isLoading: false,
-			});
+			}));
 
 			renderDrawer();
 
@@ -451,9 +298,10 @@ describe('EditMemberDrawer', () => {
 			await user.click(saveBtn);
 
 			await waitFor(() => {
-				expect(
-					screen.getByText('Name update: Something went wrong on server'),
-				).toBeInTheDocument();
+				expect(mockToast.error).toHaveBeenCalledWith(
+					'Failed to update member details: Something went wrong on server',
+					expect.anything(),
+				);
 			});
 		});
 
@@ -512,105 +360,33 @@ describe('EditMemberDrawer', () => {
 		});
 	});
 
-	describe('self user (isSelf)', () => {
-		it('disables Delete button when viewing own profile', () => {
-			renderDrawer({ member: selfMember });
-			expect(
-				screen.getByRole('button', { name: /delete member/i }),
-			).toBeDisabled();
-		});
+	describe('Generate Password Reset Link', () => {
+		const mockWriteText = jest.fn().mockResolvedValue(undefined);
+		let clipboardSpy: jest.SpyInstance | undefined;
 
-		it('does not open delete confirm dialog when Delete is clicked while disabled (isSelf)', async () => {
-			const user = userEvent.setup({ pointerEventsCheck: 0 });
-			renderDrawer({ member: selfMember });
-
-			await user.click(screen.getByRole('button', { name: /delete member/i }));
-
-			expect(
-				screen.queryByText(/are you sure you want to delete/i),
-			).not.toBeInTheDocument();
-		});
-
-		it('keeps name input enabled when viewing own profile', () => {
-			renderDrawer({ member: selfMember });
-			expect(screen.getByDisplayValue('Alice Smith')).not.toBeDisabled();
-		});
-
-		it('keeps Reset Link button enabled when viewing own profile', () => {
-			renderDrawer({ member: selfMember });
-			expect(
-				screen.getByRole('button', { name: /generate password reset link/i }),
-			).not.toBeDisabled();
-		});
-	});
-
-	describe('root user', () => {
-		beforeEach(() => {
-			(useGetUser as jest.Mock).mockReturnValue({
-				data: rootMockFetchedUser,
-				isLoading: false,
-				refetch: jest.fn(),
+		beforeAll(() => {
+			Object.defineProperty(navigator, 'clipboard', {
+				value: { writeText: (): Promise<void> => Promise.resolve() },
+				configurable: true,
+				writable: true,
 			});
 		});
 
-		it('disables name input for root user', () => {
-			renderDrawer();
-			expect(screen.getByDisplayValue('Alice Smith')).toBeDisabled();
-		});
-
-		it('disables Delete button for root user', () => {
-			renderDrawer();
-			expect(
-				screen.getByRole('button', { name: /delete member/i }),
-			).toBeDisabled();
-		});
-
-		it('disables Reset Link button for root user', () => {
-			renderDrawer();
-			expect(
-				screen.getByRole('button', { name: /generate password reset link/i }),
-			).toBeDisabled();
-		});
-
-		it('disables Save button for root user', () => {
-			renderDrawer();
-			expect(
-				screen.getByRole('button', { name: /save member details/i }),
-			).toBeDisabled();
-		});
-
-		it('does not open delete confirm dialog when Delete is clicked while disabled (root)', async () => {
-			const user = userEvent.setup({ pointerEventsCheck: 0 });
-			renderDrawer();
-
-			await user.click(screen.getByRole('button', { name: /delete member/i }));
-
-			expect(
-				screen.queryByText(/are you sure you want to delete/i),
-			).not.toBeInTheDocument();
-		});
-
-		it('does not call getResetPasswordToken when Reset Link is clicked while disabled (root)', async () => {
-			const user = userEvent.setup({ pointerEventsCheck: 0 });
-			renderDrawer();
-
-			await user.click(
-				screen.getByRole('button', { name: /generate password reset link/i }),
-			);
-
-			expect(mockGetResetPasswordToken).not.toHaveBeenCalled();
-		});
-	});
-
-	describe('Generate Password Reset Link', () => {
 		beforeEach(() => {
-			mockCopyToClipboard.mockClear();
+			mockWriteText.mockClear();
+			clipboardSpy = jest
+				.spyOn(navigator.clipboard, 'writeText')
+				.mockImplementation(mockWriteText);
 			mockGetResetPasswordToken.mockResolvedValue({
 				status: 'success',
 				data: { token: 'reset-tok-abc', id: 'user-1' },
 			});
 		});
 
+		afterEach(() => {
+			clipboardSpy?.mockRestore();
+		});
+
 		it('calls getResetPasswordToken and opens the reset link dialog with the generated link', async () => {
 			const user = userEvent.setup({ pointerEventsCheck: 0 });
 
@@ -645,7 +421,7 @@ describe('EditMemberDrawer', () => {
 			});
 			expect(dialog).toHaveTextContent('reset-tok-abc');
 
-			await user.click(screen.getByRole('button', { name: /^copy$/i }));
+			fireEvent.click(screen.getByRole('button', { name: /^copy$/i }));
 
 			await waitFor(() => {
 				expect(mockToast.success).toHaveBeenCalledWith(
@@ -654,7 +430,7 @@ describe('EditMemberDrawer', () => {
 				);
 			});
 
-			expect(mockCopyToClipboard).toHaveBeenCalledWith(
+			expect(mockWriteText).toHaveBeenCalledWith(
 				expect.stringContaining('reset-tok-abc'),
 			);
 			expect(screen.getByRole('button', { name: /copied!/i })).toBeInTheDocument();

frontend/src/components/ErrorModal/components/ErrorContent.tsx

@@ -10,12 +10,7 @@ import APIError from 'types/api/error';
 import './ErrorContent.styles.scss';
 
 interface ErrorContentProps {
-	error:
-		| APIError
-		| {
-				code: number;
-				message: string;
-		  };
+	error: APIError;
 	icon?: ReactNode;
 }
 
@@ -25,15 +20,7 @@ function ErrorContent({ error, icon }: ErrorContentProps): JSX.Element {
 		errors: errorMessages,
 		code: errorCode,
 		message: errorMessage,
-	} =
-		error && 'error' in error
-			? error?.error?.error || {}
-			: {
-					url: undefined,
-					errors: [],
-					code: error.code || 500,
-					message: error.message || 'Something went wrong',
-			  };
+	} = error?.error?.error || {};
 	return (
 		<section className="error-content">
 			{/* Summary Header */}

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/components/HostMetricsDetail/HostMetricsDetails.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,
@@ -20,6 +21,8 @@ import {
 	initialQueryState,
 } from 'constants/queryBuilder';
 import ROUTES from 'constants/routes';
+import { getFiltersFromParams } from 'container/InfraMonitoringK8s/commonUtils';
+import { INFRA_MONITORING_K8S_PARAMS_KEYS } from 'container/InfraMonitoringK8s/constants';
 import {
 	CustomTimeType,
 	Time,
@@ -49,22 +52,15 @@ import {
 import { GlobalReducer } from 'types/reducer/globalTime';
 import { v4 as uuidv4 } from 'uuid';
 
-import {
-	useInfraMonitoringTracesFilters,
-	useInfraMonitoringView,
-} from '../../container/InfraMonitoringK8s/hooks';
-import { convertFiltersToExpression } from '../QueryBuilderV2/utils';
 import { VIEW_TYPES, VIEWS } from './constants';
 import Containers from './Containers/Containers';
 import { HostDetailProps } from './HostMetricDetail.interfaces';
-import { useInfraMonitoringHostLogsExpression } from './HostMetricsLogs/hooks';
-import HostMetricsLogs from './HostMetricsLogs/HostMetricsLogs';
+import HostMetricLogsDetailedView from './HostMetricsLogs/HostMetricLogsDetailedView';
 import HostMetricTraces from './HostMetricTraces/HostMetricTraces';
 import Metrics from './Metrics/Metrics';
 import Processes from './Processes/Processes';
 
 import './HostMetricsDetail.styles.scss';
-
 // eslint-disable-next-line sonarjs/cognitive-complexity
 function HostMetricsDetails({
 	host,
@@ -75,6 +71,8 @@ function HostMetricsDetails({
 		AppState,
 		GlobalReducer
 	>((state) => state.globalTime);
+	const [searchParams, setSearchParams] = useSearchParams();
+
 	const startMs = useMemo(() => Math.floor(Number(minTime) / 1000000000), [
 		minTime,
 	]);
@@ -97,14 +95,23 @@ function HostMetricsDetails({
 			: (selectedTime as Time),
 	);
 
-	const [selectedView, setSelectedView] = useInfraMonitoringView();
-	const [traceFilters, setTraceFilters] = useInfraMonitoringTracesFilters();
-	const [, setHostMetricLogExpression] = useInfraMonitoringHostLogsExpression();
-
+	const [selectedView, setSelectedView] = useState<VIEWS>(
+		(searchParams.get('view') as VIEWS) || VIEWS.METRICS,
+	);
 	const isDarkMode = useIsDarkMode();
 
-	const [initialFilters] = useState(
-		traceFilters || {
+	const initialFilters = useMemo(() => {
+		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;
+		}
+
+		return {
 			op: 'AND',
 			items: [
 				{
@@ -119,7 +126,11 @@ function HostMetricsDetails({
 					value: host?.hostName || '',
 				},
 			],
-		},
+		};
+	}, [host?.hostName, searchParams]);
+
+	const [logFilters, setLogFilters] = useState<IBuilderQuery['filters']>(
+		initialFilters,
 	);
 
 	const [tracesFilters, setTracesFilters] = useState<IBuilderQuery['filters']>(
@@ -136,6 +147,7 @@ function HostMetricsDetails({
 	}, [host]);
 
 	useEffect(() => {
+		setLogFilters(initialFilters);
 		setTracesFilters(initialFilters);
 	}, [initialFilters]);
 
@@ -157,7 +169,12 @@ function HostMetricsDetails({
 		setSelectedView(e.target.value);
 		if (host?.hostName) {
 			setSelectedView(e.target.value);
-			setTraceFilters(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),
+			});
 		}
 		logEvent(InfraMonitoringEvents.TabChanged, {
 			entity: InfraMonitoringEvents.HostEntity,
@@ -193,32 +210,52 @@ function HostMetricsDetails({
 		[],
 	);
 
-	const initialLogsExpression = useMemo(
-		() =>
-			convertFiltersToExpression({
-				items: [
-					{
-						id: uuidv4(),
-						key: {
-							key: 'host.name',
-							dataType: DataTypes.String,
-							type: 'resource',
-							id: 'host.name--string--resource--false',
-						},
-						op: '=',
-						value: host?.hostName || '',
-					},
-				],
-				op: 'AND',
-			}).expression,
-		[host?.hostName],
-	);
+	const handleChangeLogFilters = useCallback(
+		(value: IBuilderQuery['filters'], view: VIEWS) => {
+			setLogFilters((prevFilters) => {
+				const hostNameFilter = prevFilters?.items?.find(
+					(item) => item.key?.key === 'host.name',
+				);
+				const paginationFilter = value?.items?.find(
+					(item) => item.key?.key === 'id',
+				);
+				const newFilters = value?.items?.filter(
+					(item) => item.key?.key !== 'id' && item.key?.key !== 'host.name',
+				);
 
-	const [hostMetricLogsExpr] = useInfraMonitoringHostLogsExpression();
+				if (newFilters && newFilters?.length > 0) {
+					logEvent(InfraMonitoringEvents.FilterApplied, {
+						entity: InfraMonitoringEvents.HostEntity,
+						view: InfraMonitoringEvents.LogsView,
+						page: InfraMonitoringEvents.DetailedPage,
+					});
+				}
+
+				const updatedFilters = {
+					op: 'AND',
+					items: [
+						hostNameFilter,
+						...(newFilters || []),
+						...(paginationFilter ? [paginationFilter] : []),
+					].filter((item): item is TagFilterItem => item !== undefined),
+				};
+
+				setSearchParams({
+					...Object.fromEntries(searchParams.entries()),
+					[INFRA_MONITORING_K8S_PARAMS_KEYS.LOG_FILTERS]: JSON.stringify(
+						updatedFilters,
+					),
+					[INFRA_MONITORING_K8S_PARAMS_KEYS.VIEW]: view,
+				});
+				return updatedFilters;
+			});
+		},
+		// eslint-disable-next-line react-hooks/exhaustive-deps
+		[],
+	);
 
 	const handleChangeTracesFilters = useCallback(
 		(value: IBuilderQuery['filters'], view: VIEWS) => {
-			setSelectedView(view);
 			setTracesFilters((prevFilters) => {
 				const hostNameFilter = prevFilters?.items?.find(
 					(item) => item.key?.key === 'host.name',
@@ -232,16 +269,27 @@ function HostMetricsDetails({
 					});
 				}
 
-				return {
+				const updatedFilters = {
 					op: 'AND',
 					items: [
 						hostNameFilter,
 						...(value?.items?.filter((item) => item.key?.key !== 'host.name') || []),
 					].filter((item): item is TagFilterItem => item !== undefined),
 				};
+
+				setSearchParams({
+					...Object.fromEntries(searchParams.entries()),
+					[INFRA_MONITORING_K8S_PARAMS_KEYS.TRACES_FILTERS]: JSON.stringify(
+						updatedFilters,
+					),
+					[INFRA_MONITORING_K8S_PARAMS_KEYS.VIEW]: view,
+				});
+
+				return updatedFilters;
 			});
 		},
-		[setSelectedView],
+		// eslint-disable-next-line react-hooks/exhaustive-deps
+		[],
 	);
 
 	const handleExplorePagesRedirect = (): void => {
@@ -260,6 +308,11 @@ function HostMetricsDetails({
 		});
 
 		if (selectedView === VIEW_TYPES.LOGS) {
+			const filtersWithoutPagination = {
+				...logFilters,
+				items: logFilters?.items?.filter((item) => item.key?.key !== 'id') || [],
+			};
+
 			const compositeQuery = {
 				...initialQueryState,
 				queryType: 'builder',
@@ -269,11 +322,7 @@ function HostMetricsDetails({
 						{
 							...initialQueryBuilderFormValuesMap.logs,
 							aggregateOperator: LogsAggregatorOperator.NOOP,
-							filter: { expression: hostMetricLogsExpr },
-							expression: hostMetricLogsExpr,
-							having: {
-								expression: '',
-							},
+							filters: filtersWithoutPagination,
 						},
 					],
 				},
@@ -313,9 +362,7 @@ function HostMetricsDetails({
 	const handleClose = (): void => {
 		setSelectedInterval(selectedTime as Time);
 		lastSelectedInterval.current = null;
-		setSelectedView(null);
-		setTraceFilters(null);
-		setHostMetricLogExpression(null);
+		setSearchParams({});
 
 		if (selectedTime !== 'custom') {
 			const { maxTime, minTime } = GetMinMax(selectedTime);
@@ -517,11 +564,12 @@ function HostMetricsDetails({
 						/>
 					)}
 					{selectedView === VIEW_TYPES.LOGS && (
-						<HostMetricsLogs
+						<HostMetricLogsDetailedView
 							timeRange={modalTimeRange}
 							isModalTimeSelection={isModalTimeSelection}
 							handleTimeChange={handleTimeChange}
-							initialExpression={initialLogsExpression}
+							handleChangeLogFilters={handleChangeLogFilters}
+							logFilters={logFilters}
 							selectedInterval={selectedInterval}
 						/>
 					)}

frontend/src/components/HostMetricsDetail/HostMetricsLogs/HostMetricLogs.module.scss

@@ -1,66 +0,0 @@
-.header {
-	display: flex;
-	justify-content: flex-end;
-	padding: var(--spacing-4) 0px;
-	border-radius: 3px;
-
-	gap: var(--spacing-4);
-}
-
-.logs {
-	border: 1px solid var(--border);
-	margin-top: var(--spacing-4);
-}
-
-.listContainer {
-	flex: 1;
-	height: calc(100vh - 278px) !important;
-	display: flex;
-	height: 100%;
-
-	:global(.raw-log-content) {
-		width: 100%;
-		text-wrap: inherit;
-		word-wrap: break-word;
-	}
-}
-
-.listCard {
-	width: 100%;
-	margin-top: 12px;
-
-	:global(.ant-card-body) {
-		padding: 0;
-		height: 100%;
-		width: 100%;
-	}
-}
-
-.logsLoadingSkeleton {
-	display: flex;
-	flex-direction: column;
-	align-items: center;
-	justify-content: center;
-	gap: 8px;
-	padding: 8px 0;
-
-	:global(.ant-skeleton-input-sm) {
-		height: 18px;
-	}
-}
-
-.noLogsFound {
-	height: 50vh;
-	width: 100%;
-	display: flex;
-	justify-content: center;
-	align-items: center;
-	padding: 24px;
-	box-sizing: border-box;
-
-	p {
-		display: flex;
-		align-items: center;
-		gap: 16px;
-	}
-}

frontend/src/components/HostMetricsDetail/HostMetricsLogs/HostMetricLogs.styles.scss

@@ -0,0 +1,133 @@
+.host-metrics-logs-container {
+	margin-top: 1rem;
+
+	.filter-section {
+		flex: 1;
+
+		.ant-select-selector {
+			border-radius: 2px;
+			border: 1px solid var(--bg-slate-400) !important;
+			background-color: var(--bg-ink-300) !important;
+
+			input {
+				font-size: 12px;
+			}
+
+			.ant-tag .ant-typography {
+				font-size: 12px;
+			}
+		}
+	}
+
+	.host-metrics-logs-header {
+		display: flex;
+		justify-content: space-between;
+		gap: 8px;
+
+		padding: 12px;
+		border-radius: 3px;
+		border: 1px solid var(--bg-slate-500);
+	}
+
+	.host-metrics-logs {
+		margin-top: 1rem;
+
+		.virtuoso-list {
+			overflow-y: hidden !important;
+
+			&::-webkit-scrollbar {
+				width: 0.3rem;
+				height: 0.3rem;
+			}
+
+			&::-webkit-scrollbar-track {
+				background: transparent;
+			}
+
+			&::-webkit-scrollbar-thumb {
+				background: var(--bg-slate-300);
+			}
+
+			&::-webkit-scrollbar-thumb:hover {
+				background: var(--bg-slate-200);
+			}
+
+			.ant-row {
+				width: fit-content;
+			}
+		}
+
+		.skeleton-container {
+			height: 100%;
+			padding: 16px;
+		}
+	}
+}
+
+.host-metrics-logs-list-container {
+	flex: 1;
+	height: calc(100vh - 272px) !important;
+	display: flex;
+	height: 100%;
+
+	.raw-log-content {
+		width: 100%;
+		text-wrap: inherit;
+		word-wrap: break-word;
+	}
+}
+
+.host-metrics-logs-list-card {
+	width: 100%;
+	margin-top: 12px;
+
+	.ant-card-body {
+		padding: 0;
+
+		height: 100%;
+		width: 100%;
+	}
+}
+
+.logs-loading-skeleton {
+	display: flex;
+	flex-direction: column;
+	align-items: center;
+	justify-content: center;
+	gap: 8px;
+	padding: 8px 0;
+
+	.ant-skeleton-input-sm {
+		height: 18px;
+	}
+}
+
+.no-logs-found {
+	height: 50vh;
+	width: 100%;
+	display: flex;
+	justify-content: center;
+	align-items: center;
+
+	padding: 24px;
+	box-sizing: border-box;
+
+	.ant-typography {
+		display: flex;
+		align-items: center;
+		gap: 16px;
+	}
+}
+
+.lightMode {
+	.filter-section {
+		border-top: 1px solid var(--bg-vanilla-300);
+		border-bottom: 1px solid var(--bg-vanilla-300);
+
+		.ant-select-selector {
+			border-color: var(--bg-vanilla-300) !important;
+			background-color: var(--bg-vanilla-100) !important;
+			color: var(--bg-ink-200);
+		}
+	}
+}

frontend/src/components/HostMetricsDetail/HostMetricsLogs/HostMetricLogsDetailedView.tsx

@@ -0,0 +1,100 @@
+import { useMemo } from 'react';
+import QueryBuilderSearch from 'container/QueryBuilder/filters/QueryBuilderSearch';
+import DateTimeSelectionV2 from 'container/TopNav/DateTimeSelectionV2';
+import {
+	CustomTimeType,
+	Time,
+} from 'container/TopNav/DateTimeSelectionV2/types';
+import { useQueryBuilder } from 'hooks/queryBuilder/useQueryBuilder';
+import { IBuilderQuery } from 'types/api/queryBuilder/queryBuilderData';
+import { DataSource } from 'types/common/queryBuilder';
+
+import { VIEWS } from '../constants';
+import HostMetricsLogs from './HostMetricsLogs';
+
+import './HostMetricLogs.styles.scss';
+
+interface Props {
+	timeRange: {
+		startTime: number;
+		endTime: number;
+	};
+	isModalTimeSelection: boolean;
+	handleTimeChange: (
+		interval: Time | CustomTimeType,
+		dateTimeRange?: [number, number],
+	) => void;
+	handleChangeLogFilters: (value: IBuilderQuery['filters'], view: VIEWS) => void;
+	logFilters: IBuilderQuery['filters'];
+	selectedInterval: Time;
+}
+
+function HostMetricLogsDetailedView({
+	timeRange,
+	isModalTimeSelection,
+	handleTimeChange,
+	handleChangeLogFilters,
+	logFilters,
+	selectedInterval,
+}: Props): JSX.Element {
+	const { currentQuery } = useQueryBuilder();
+	const updatedCurrentQuery = useMemo(
+		() => ({
+			...currentQuery,
+			builder: {
+				...currentQuery.builder,
+				queryData: [
+					{
+						...currentQuery.builder.queryData[0],
+						dataSource: DataSource.LOGS,
+						aggregateOperator: 'noop',
+						aggregateAttribute: {
+							...currentQuery.builder.queryData[0].aggregateAttribute,
+						},
+						filters: {
+							items:
+								logFilters?.items?.filter((item) => item.key?.key !== 'host.name') ||
+								[],
+							op: 'AND',
+						},
+					},
+				],
+			},
+		}),
+		[currentQuery, logFilters?.items],
+	);
+
+	const query = updatedCurrentQuery?.builder?.queryData[0] || null;
+
+	return (
+		<div className="host-metrics-logs-container">
+			<div className="host-metrics-logs-header">
+				<div className="filter-section">
+					{query && (
+						<QueryBuilderSearch
+							query={query as IBuilderQuery}
+							onChange={(value): void => handleChangeLogFilters(value, VIEWS.LOGS)}
+							disableNavigationShortcuts
+						/>
+					)}
+				</div>
+				<div className="datetime-section">
+					<DateTimeSelectionV2
+						showAutoRefresh
+						showRefreshText={false}
+						hideShareModal
+						isModalTimeSelection={isModalTimeSelection}
+						onTimeChange={handleTimeChange}
+						defaultRelativeTime="5m"
+						modalSelectedInterval={selectedInterval}
+						modalInitialStartTime={timeRange.startTime * 1000}
+						modalInitialEndTime={timeRange.endTime * 1000}
+					/>
+				</div>
+			</div>
+			<HostMetricsLogs timeRange={timeRange} filters={logFilters} />
+		</div>
+	);
+}
+
+export default HostMetricLogsDetailedView;

frontend/src/components/HostMetricsDetail/HostMetricsLogs/HostMetricsLogs.tsx

@@ -1,165 +1,87 @@
-import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
+import { useCallback, useEffect, useMemo, useRef } from 'react';
+import { useQuery } from 'react-query';
 import { Virtuoso, VirtuosoHandle } from 'react-virtuoso';
 import { Card } from 'antd';
-import logEvent from 'api/common/logEvent';
 import LogDetail from 'components/LogDetail';
 import RawLogView from 'components/Logs/RawLogView';
 import OverlayScrollbar from 'components/OverlayScrollbar/OverlayScrollbar';
-import QuerySearch from 'components/QueryBuilderV2/QueryV2/QuerySearch/QuerySearch';
-import { InfraMonitoringEvents } from 'constants/events';
+import { DEFAULT_ENTITY_VERSION } from 'constants/app';
 import LogsError from 'container/LogsError/LogsError';
 import { LogsLoading } from 'container/LogsLoading/LogsLoading';
 import { FontSize } from 'container/OptionsMenu/types';
-import RunQueryBtn from 'container/QueryBuilder/components/RunQueryBtn/RunQueryBtn';
-import DateTimeSelectionV2 from 'container/TopNav/DateTimeSelectionV2';
-import {
-	CustomTimeType,
-	Time,
-} from 'container/TopNav/DateTimeSelectionV2/types';
-import { getOldLogsOperatorFromNew } from 'hooks/logs/useActiveLog';
+import { useHandleLogsPagination } from 'hooks/infraMonitoring/useHandleLogsPagination';
 import useLogDetailHandlers from 'hooks/logs/useLogDetailHandlers';
 import useScrollToLog from 'hooks/logs/useScrollToLog';
-import useDebounce from 'hooks/useDebounce';
-import { generateFilterQuery } from 'lib/logs/generateFilterQuery';
+import { GetMetricQueryRange } from 'lib/dashboard/getQueryResults';
 import { ILog } from 'types/api/logs/log';
-import { DataSource } from 'types/common/queryBuilder';
-import { validateQuery } from 'utils/queryValidationUtils';
+import { IBuilderQuery } from 'types/api/queryBuilder/queryBuilderData';
 
-import {
-	useInfiniteHostMetricLogs,
-	useInfraMonitoringHostLogsExpression,
-} from './hooks';
+import { getHostLogsQueryPayload } from './constants';
 import NoLogsContainer from './NoLogsContainer';
-import { getHostLogsQueryPayload } from './utils';
 
-import styles from './HostMetricLogs.module.scss';
+import './HostMetricLogs.styles.scss';
 
 interface Props {
-	initialExpression: string;
 	timeRange: {
 		startTime: number;
 		endTime: number;
 	};
-	isModalTimeSelection: boolean;
-	handleTimeChange: (
-		interval: Time | CustomTimeType,
-		dateTimeRange?: [number, number],
-	) => void;
-	selectedInterval: Time;
+	filters: IBuilderQuery['filters'];
 }
 
-const EXPRESSION_DEBOUNCE_TIME_MS = 300;
-
-function HostMetricsLogs({
-	initialExpression,
-	timeRange,
-	isModalTimeSelection,
-	handleTimeChange,
-	selectedInterval,
-}: Props): JSX.Element {
+function HostMetricsLogs({ timeRange, filters }: Props): JSX.Element {
 	const virtuosoRef = useRef<VirtuosoHandle>(null);
-
-	const [
-		filterExpression,
-		setFilterExpression,
-	] = useInfraMonitoringHostLogsExpression();
-
-	const [inputExpression, setInputExpression] = useState(
-		filterExpression || initialExpression,
-	);
-
-	useEffect(() => {
-		// If expression is present in the URL, prefer it and don't override it.
-		// Otherwise, initialize URL state from the host's default expression.
-		if (filterExpression) {
-			setInputExpression(filterExpression);
-			return;
-		}
-
-		setInputExpression(initialExpression);
-		setFilterExpression(initialExpression);
-	}, [filterExpression, initialExpression, setFilterExpression]);
-
-	const debouncedFilterExpression = useDebounce(
-		filterExpression?.trim() || initialExpression,
-		EXPRESSION_DEBOUNCE_TIME_MS,
-	);
-
 	const {
 		activeLog,
+		onAddToQuery,
 		selectedTab,
 		handleSetActiveLog,
 		handleCloseLogDetail,
 	} = useLogDetailHandlers();
 
-	const onAddToQuery = useCallback(
-		(fieldKey: string, fieldValue: string, operator: string): void => {
-			handleCloseLogDetail();
-
-			const partExpression = generateFilterQuery({
-				fieldKey,
-				fieldValue,
-				type: getOldLogsOperatorFromNew(operator),
-			});
-
-			const newExpression = inputExpression.trim()
-				? `${inputExpression} AND ${partExpression}`
-				: partExpression;
-
-			setInputExpression(newExpression);
-			setFilterExpression(newExpression);
-		},
-		[inputExpression, setFilterExpression, handleCloseLogDetail],
+	const basePayload = getHostLogsQueryPayload(
+		timeRange.startTime,
+		timeRange.endTime,
+		filters,
 	);
-
-	const handleFilterChange = useCallback((expression: string): void => {
-		setInputExpression(expression);
-	}, []);
-
 	const {
 		logs,
+		hasReachedEndOfLogs,
+		isPaginating,
+		currentPage,
+		setIsPaginating,
+		handleNewData,
 		loadMoreLogs,
-		hasNextPage,
-		isFetchingNextPage,
-		isLoading,
-		isFetching,
-		isError,
-		refetch,
-	} = useInfiniteHostMetricLogs({
-		expression: debouncedFilterExpression,
-		startTime: timeRange.startTime,
-		endTime: timeRange.endTime,
+		queryPayload,
+	} = useHandleLogsPagination({
+		timeRange,
+		filters,
+		excludeFilterKeys: ['host.name'],
+		basePayload,
 	});
 
-	const handleRunQuery = useCallback(
-		(updatedExpression?: string): void => {
-			const validation = validateQuery(updatedExpression || inputExpression);
-			if (validation.isValid) {
-				setFilterExpression(updatedExpression || inputExpression);
+	const { data, isLoading, isFetching, isError } = useQuery({
+		queryKey: [
+			'hostMetricsLogs',
+			timeRange.startTime,
+			timeRange.endTime,
+			filters,
+			currentPage,
+		],
+		queryFn: () => GetMetricQueryRange(queryPayload, DEFAULT_ENTITY_VERSION),
+		enabled: !!queryPayload,
+		keepPreviousData: isPaginating,
+	});
 
-				logEvent(InfraMonitoringEvents.FilterApplied, {
-					entity: InfraMonitoringEvents.HostEntity,
-					view: InfraMonitoringEvents.LogsView,
-					page: InfraMonitoringEvents.DetailedPage,
-				});
+	useEffect(() => {
+		if (data?.payload?.data?.newResult?.data?.result) {
+			handleNewData(data.payload.data.newResult.data.result);
+		}
+	}, [data, handleNewData]);
 
-				refetch();
-			}
-		},
-		[inputExpression, refetch, setFilterExpression],
-	);
-
-	const queryData = useMemo(
-		() =>
-			getHostLogsQueryPayload({
-				start: timeRange.startTime,
-				end: timeRange.endTime,
-				// this should use inputExpression to show suggestions correctly
-				// while we don't accept the final expression yet
-				expression: inputExpression,
-			}).queryData,
-		[timeRange.startTime, timeRange.endTime, inputExpression],
-	);
+	useEffect(() => {
+		setIsPaginating(false);
+	}, [data, setIsPaginating]);
 
 	const handleScrollToLog = useScrollToLog({
 		logs,
@@ -200,21 +122,22 @@ function HostMetricsLogs({
 	const renderFooter = useCallback(
 		(): JSX.Element | null => (
 			<>
-				{isFetchingNextPage ? (
-					<div className={styles.logsLoadingSkeleton}> Loading more logs ... </div>
-				) : !hasNextPage && logs.length > 0 ? (
-					<div className={styles.logsLoadingSkeleton}> *** End *** </div>
+				{isFetching ? (
+					<div className="logs-loading-skeleton"> Loading more logs ... </div>
+				) : hasReachedEndOfLogs ? (
+					<div className="logs-loading-skeleton"> *** End *** </div>
 				) : null}
 			</>
 		),
-		[isFetchingNextPage, hasNextPage, logs.length],
+		[isFetching, hasReachedEndOfLogs],
 	);
 
 	const renderContent = useMemo(
 		() => (
-			<Card bordered={false} className={styles.listCard}>
+			<Card bordered={false} className="host-metrics-logs-list-card">
 				<OverlayScrollbar isVirtuoso>
 					<Virtuoso
+						className="host-metrics-logs-virtuoso"
 						key="host-metrics-logs-virtuoso"
 						ref={virtuosoRef}
 						data={logs}
@@ -232,60 +155,32 @@ function HostMetricsLogs({
 		[logs, loadMoreLogs, getItemContent, renderFooter],
 	);
 
-	const showInitialLoading = isLoading || (isFetching && logs.length === 0);
-
 	return (
-		<>
-			<div className={styles.header}>
-				<DateTimeSelectionV2
-					showAutoRefresh
-					showRefreshText={false}
-					hideShareModal
-					isModalTimeSelection={isModalTimeSelection}
-					onTimeChange={handleTimeChange}
-					defaultRelativeTime="5m"
-					modalSelectedInterval={selectedInterval}
-					modalInitialStartTime={timeRange.startTime * 1000}
-					modalInitialEndTime={timeRange.endTime * 1000}
+		<div className="host-metrics-logs">
+			{isLoading && <LogsLoading />}
+			{!isLoading && !isError && logs.length === 0 && <NoLogsContainer />}
+			{isError && !isLoading && <LogsError />}
+			{!isLoading && !isError && logs.length > 0 && (
+				<div
+					className="host-metrics-logs-list-container"
+					data-log-detail-ignore="true"
+				>
+					{renderContent}
+				</div>
+			)}
+			{selectedTab && activeLog && (
+				<LogDetail
+					log={activeLog}
+					onClose={handleCloseLogDetail}
+					logs={logs}
+					onNavigateLog={handleSetActiveLog}
+					selectedTab={selectedTab}
+					onAddToQuery={onAddToQuery}
+					onClickActionItem={onAddToQuery}
+					onScrollToLog={handleScrollToLog}
 				/>
-				<RunQueryBtn
-					isLoadingQueries={isLoading || isFetching}
-					onStageRunQuery={(): void => handleRunQuery()}
-				/>
-			</div>
-
-			<QuerySearch
-				queryData={queryData}
-				onChange={handleFilterChange}
-				dataSource={DataSource.LOGS}
-				onRun={handleRunQuery}
-			/>
-
-			<div className={styles.logs}>
-				{showInitialLoading && <LogsLoading />}
-				{!showInitialLoading && !isError && logs.length === 0 && (
-					<NoLogsContainer />
-				)}
-				{isError && !showInitialLoading && <LogsError />}
-				{!showInitialLoading && !isError && logs.length > 0 && (
-					<div className={styles.listContainer} data-log-detail-ignore="true">
-						{renderContent}
-					</div>
-				)}
-				{selectedTab && activeLog && (
-					<LogDetail
-						log={activeLog}
-						onClose={handleCloseLogDetail}
-						logs={logs}
-						onNavigateLog={handleSetActiveLog}
-						selectedTab={selectedTab}
-						onAddToQuery={onAddToQuery}
-						onClickActionItem={onAddToQuery}
-						onScrollToLog={handleScrollToLog}
-					/>
-				)}
-			</div>
-		</>
+			)}
+		</div>
 	);
 }
 

frontend/src/components/HostMetricsDetail/HostMetricsLogs/NoLogsContainer.tsx

@@ -1,15 +1,16 @@
 import { Color } from '@signozhq/design-tokens';
+import { Typography } from 'antd';
 import { Ghost } from 'lucide-react';
 
-import styles from './HostMetricLogs.module.scss';
+const { Text } = Typography;
 
 export default function NoLogsContainer(): React.ReactElement {
 	return (
-		<div className={styles.noLogsFound}>
-			<p>
+		<div className="no-logs-found">
+			<Text type="secondary">
 				<Ghost size={24} color={Color.BG_AMBER_500} /> No logs found for this host
 				in the selected time range.
-			</p>
+			</Text>
 		</div>
 	);
 }

frontend/src/components/HostMetricsDetail/HostMetricsLogs/__tests__/HostMetricsLogs.test.tsx

@@ -1,899 +0,0 @@
-import { VirtuosoMockContext } from 'react-virtuoso';
-import { ENVIRONMENT } from 'constants/env';
-import { server } from 'mocks-server/server';
-import { rest } from 'msw';
-import { NuqsTestingAdapter } from 'nuqs/adapters/testing';
-import { act, render, screen, userEvent, waitFor } from 'tests/test-utils';
-
-import { mockQueryRangeV5WithLogsResponse } from '../../../../__tests__/query_range_v5.util';
-import HostMetricsLogs from '../HostMetricsLogs';
-
-jest.mock('react-virtuoso', () => {
-	const actual = jest.requireActual('react-virtuoso');
-	return {
-		...actual,
-		Virtuoso: ({
-			data,
-			itemContent,
-			endReached,
-			components,
-			className,
-		}: {
-			data?: any[];
-			itemContent?: (index: number, item: any) => React.ReactNode;
-			endReached?: (index: number) => void;
-			components?: { Footer?: React.ComponentType };
-			className?: string;
-		}): JSX.Element => (
-			<div data-testid="virtuoso-mock" className={className}>
-				{Array.isArray(data) &&
-					data.map((item, index) => (
-						<div key={item?.id ?? index} data-testid={`virtuoso-item-${index}`}>
-							{itemContent?.(index, item)}
-						</div>
-					))}
-				<button
-					type="button"
-					data-testid="virtuoso-end-reached"
-					onClick={(): void => endReached?.((data?.length || 0) - 1)}
-				>
-					endReached
-				</button>
-				{components?.Footer ? <components.Footer /> : null}
-			</div>
-		),
-	};
-});
-
-const QUERY_RANGE_URL = `${ENVIRONMENT.baseURL}/api/v5/query_range`;
-const FIELDS_KEYS_URL = `${ENVIRONMENT.baseURL}/api/v1/fields/keys`;
-const FIELDS_VALUES_URL = `${ENVIRONMENT.baseURL}/api/v1/fields/values`;
-
-const defaultProps = {
-	initialExpression: 'host_name = "test-host"',
-	timeRange: {
-		startTime: 1708000000,
-		endTime: 1708003600,
-	},
-	isModalTimeSelection: false,
-	handleTimeChange: jest.fn(),
-	selectedInterval: '15m' as const,
-};
-
-// Mock OverlayScrollbar to avoid scroll behavior issues in tests
-jest.mock('components/OverlayScrollbar/OverlayScrollbar', () => ({
-	__esModule: true,
-	default: ({ children }: { children: React.ReactNode }): JSX.Element => (
-		<div>{children}</div>
-	),
-}));
-
-jest.mock('container/TopNav/DateTimeSelectionV2/index.tsx', () => ({
-	__esModule: true,
-	default: ({
-		onTimeChange,
-	}: {
-		onTimeChange?: (interval: string, dateTimeRange?: [number, number]) => void;
-	}): JSX.Element => {
-		return (
-			<div className="datetime-section" data-testid="datetime-selection">
-				<button
-					data-testid="time-picker-btn"
-					onClick={(): void => {
-						onTimeChange?.('5m');
-					}}
-				>
-					Select Time
-				</button>
-			</div>
-		);
-	},
-}));
-
-const createFieldKeysResponse = (): any => ({
-	status: 'success',
-	data: {
-		complete: true,
-		keys: {},
-	},
-});
-
-const createFieldValuesResponse = (): any => ({
-	status: 'success',
-	data: {
-		values: {
-			stringValues: [],
-			numberValues: [],
-			boolValues: [],
-		},
-	},
-});
-
-const renderComponent = (
-	props = defaultProps,
-	searchParams?: Record<string, string>,
-): ReturnType<typeof render> =>
-	render(
-		<NuqsTestingAdapter searchParams={searchParams} hasMemory>
-			<VirtuosoMockContext.Provider
-				value={{ viewportHeight: 600, itemHeight: 50 }}
-			>
-				<HostMetricsLogs {...props} />
-			</VirtuosoMockContext.Provider>
-		</NuqsTestingAdapter>,
-	);
-
-describe('HostMetricsLogs', () => {
-	beforeEach(() => {
-		window.history.pushState({}, 'Test', '/');
-		server.use(
-			rest.get(FIELDS_KEYS_URL, (_, res, ctx) =>
-				res(ctx.status(200), ctx.json(createFieldKeysResponse())),
-			),
-			rest.get(FIELDS_VALUES_URL, (_, res, ctx) =>
-				res(ctx.status(200), ctx.json(createFieldValuesResponse())),
-			),
-		);
-	});
-
-	describe('loading state', () => {
-		it('should show loading state while fetching logs', async () => {
-			let resolveRequest: (value: any) => void;
-			const pendingPromise = new Promise<void>((resolve) => {
-				resolveRequest = resolve;
-			});
-
-			mockQueryRangeV5WithLogsResponse({
-				onReceiveRequest: async () => await pendingPromise,
-			});
-
-			renderComponent();
-
-			expect(
-				await screen.findByText('pending_data_placeholder'),
-			).toBeInTheDocument();
-
-			act(() => {
-				resolveRequest!(true);
-			});
-		});
-	});
-
-	describe('empty state', () => {
-		it('should show no logs message when no logs are returned', async () => {
-			mockQueryRangeV5WithLogsResponse({
-				pageSize: 0,
-			});
-
-			renderComponent();
-
-			await waitFor(async () => {
-				expect(
-					await screen.findByText(/No logs found for this host/i),
-				).toBeInTheDocument();
-			});
-		});
-	});
-
-	describe('error state', () => {
-		it('should show error state when API returns error', async () => {
-			server.use(
-				rest.post(QUERY_RANGE_URL, (_, res, ctx) =>
-					res(ctx.status(500), ctx.json({ error: 'Internal Server Error' })),
-				),
-			);
-
-			renderComponent();
-
-			await waitFor(async () => {
-				expect(
-					await screen.findByText(/Something went wrong/i),
-				).toBeInTheDocument();
-			});
-		});
-	});
-
-	describe('success state', () => {
-		it('should render logs when API returns data', async () => {
-			mockQueryRangeV5WithLogsResponse({
-				pageSize: 5,
-			});
-
-			renderComponent();
-
-			await waitFor(async () => {
-				expect(await screen.findByText(/Log message 0/)).toBeInTheDocument();
-			});
-		});
-
-		it('should render initial expression in QuerySearch editor', async () => {
-			mockQueryRangeV5WithLogsResponse({
-				pageSize: 5,
-			});
-
-			renderComponent();
-
-			await waitFor(() => {
-				const editorText =
-					document.querySelector('.query-where-clause-editor')?.textContent || '';
-				expect(editorText).toContain('host_name');
-				expect(editorText).toContain('test-host');
-			});
-		});
-
-		it('should render the filter section', async () => {
-			mockQueryRangeV5WithLogsResponse({
-				pageSize: 5,
-			});
-
-			renderComponent();
-
-			await waitFor(() => {
-				expect(
-					document.querySelector('.code-mirror-where-clause'),
-				).toBeInTheDocument();
-			});
-		});
-
-		it('should render date time selection component', async () => {
-			mockQueryRangeV5WithLogsResponse({
-				pageSize: 5,
-			});
-
-			renderComponent();
-
-			await waitFor(() => {
-				// DateTimeSelectionV2 renders a time picker button
-				expect(document.querySelector('.datetime-section')).toBeInTheDocument();
-			});
-		});
-	});
-
-	describe('pagination', () => {
-		it('should send correct offset for pagination', async () => {
-			const requestPayloads: any[] = [];
-
-			mockQueryRangeV5WithLogsResponse({
-				onReceiveRequest: async (req) => {
-					const payload = await req.json();
-					requestPayloads.push(payload);
-
-					const querySpec = payload.compositeQuery?.queries?.[0]?.spec;
-					const offset = querySpec?.offset ?? 0;
-
-					return {
-						offset,
-						pageSize: 100,
-						hasMore: offset === 0,
-					};
-				},
-			});
-
-			renderComponent();
-
-			await waitFor(() => {
-				expect(requestPayloads.length).toBeGreaterThanOrEqual(1);
-			});
-
-			const firstPayload = requestPayloads[0];
-			const querySpec = firstPayload.compositeQuery?.queries?.[0]?.spec;
-			expect(querySpec?.offset).toBe(0);
-		});
-
-		it('should fetch next page when virtuoso endReached is triggered', async () => {
-			const requestPayloads: any[] = [];
-
-			mockQueryRangeV5WithLogsResponse({
-				onReceiveRequest: async (req) => {
-					const payload = await req.json();
-					requestPayloads.push(payload);
-
-					const querySpec = payload.compositeQuery?.queries?.[0]?.spec;
-					const offset = querySpec?.offset ?? 0;
-
-					return {
-						offset,
-						pageSize: 100,
-						hasMore: offset === 0,
-					};
-				},
-			});
-
-			renderComponent();
-
-			await waitFor(async () => {
-				expect(await screen.findByText(/Log message 0/)).toBeInTheDocument();
-			});
-
-			expect(requestPayloads[0]?.compositeQuery?.queries?.[0]?.spec?.offset).toBe(
-				0,
-			);
-
-			await userEvent.click(screen.getByTestId('virtuoso-end-reached'));
-
-			await waitFor(() => {
-				expect(requestPayloads.length).toBeGreaterThanOrEqual(2);
-			});
-
-			expect(requestPayloads[1]?.compositeQuery?.queries?.[0]?.spec?.offset).toBe(
-				100,
-			);
-		});
-	});
-
-	describe('filter expression', () => {
-		it('should include initial expression in the query', async () => {
-			const requestPayloads: any[] = [];
-
-			mockQueryRangeV5WithLogsResponse({
-				onReceiveRequest: async (req) => {
-					const payload = await req.json();
-					requestPayloads.push(payload);
-
-					return {
-						pageSize: 5,
-						offset: 0,
-					};
-				},
-			});
-
-			renderComponent();
-
-			await waitFor(() => {
-				expect(requestPayloads.length).toBeGreaterThanOrEqual(1);
-			});
-
-			const firstPayload = requestPayloads[0];
-			const querySpec = firstPayload.compositeQuery?.queries?.[0]?.spec;
-
-			expect(querySpec?.filter?.expression).toContain('host_name = "test-host"');
-		});
-
-		it('should load expression from URL and persist it in the query', async () => {
-			const requestPayloads: any[] = [];
-
-			mockQueryRangeV5WithLogsResponse({
-				onReceiveRequest: async (req) => {
-					const payload = await req.json();
-					requestPayloads.push(payload);
-
-					return {
-						pageSize: 100,
-						offset: 0,
-						hasMore: true,
-					};
-				},
-			});
-
-			const urlExpression = 'service = "from-url"';
-
-			renderComponent(defaultProps, { hostMetricsLogsExpression: urlExpression });
-
-			await waitFor(() => {
-				expect(requestPayloads.length).toBeGreaterThanOrEqual(1);
-			});
-
-			expect(
-				requestPayloads[0]?.compositeQuery?.queries?.[0]?.spec?.filter?.expression,
-			).toContain(urlExpression);
-
-			await userEvent.click(screen.getByTestId('virtuoso-end-reached'));
-
-			await waitFor(() => {
-				expect(requestPayloads.length).toBeGreaterThanOrEqual(2);
-			});
-
-			expect(
-				requestPayloads[1]?.compositeQuery?.queries?.[0]?.spec?.filter?.expression,
-			).toContain(urlExpression);
-		});
-
-		it('should use custom expression when provided', async () => {
-			const requestPayloads: any[] = [];
-
-			mockQueryRangeV5WithLogsResponse({
-				onReceiveRequest: async (req) => {
-					const payload = await req.json();
-					requestPayloads.push(payload);
-
-					return {
-						pageSize: 5,
-						offset: 0,
-					};
-				},
-			});
-
-			const customExpression = 'service = "custom-service"';
-
-			renderComponent({
-				...defaultProps,
-				initialExpression: customExpression,
-			});
-
-			// Wait for debounce and potential re-renders to settle
-			await waitFor(
-				() => {
-					const hasCustomExpression = requestPayloads.some((payload) => {
-						const querySpec = payload.compositeQuery?.queries?.[0]?.spec;
-						return querySpec?.filter?.expression?.includes('custom-service');
-					});
-					expect(hasCustomExpression).toBe(true);
-				},
-				{ timeout: 2000 },
-			);
-		});
-	});
-
-	describe('time range', () => {
-		it('should include correct time range in the query', async () => {
-			const requestPayloads: any[] = [];
-
-			mockQueryRangeV5WithLogsResponse({
-				onReceiveRequest: async (req) => {
-					const payload = await req.json();
-					requestPayloads.push(payload);
-
-					return {
-						pageSize: 5,
-						offset: 0,
-					};
-				},
-			});
-
-			const customTimeRange = {
-				startTime: 1700000000,
-				endTime: 1700003600,
-			};
-
-			renderComponent({
-				...defaultProps,
-				timeRange: customTimeRange,
-			});
-
-			await waitFor(() => {
-				expect(requestPayloads.length).toBeGreaterThanOrEqual(1);
-			});
-
-			const firstPayload = requestPayloads[0];
-
-			// V5 API expects milliseconds (seconds * 1000)
-			expect(firstPayload.start).toBe(customTimeRange.startTime * 1000);
-			expect(firstPayload.end).toBe(customTimeRange.endTime * 1000);
-		});
-	});
-
-	describe('query structure', () => {
-		it('should send correct query structure to the API', async () => {
-			const requestPayloads: any[] = [];
-
-			mockQueryRangeV5WithLogsResponse({
-				onReceiveRequest: async (req) => {
-					const payload = await req.json();
-					requestPayloads.push(payload);
-
-					return {
-						pageSize: 5,
-						offset: 0,
-					};
-				},
-			});
-
-			renderComponent();
-
-			await waitFor(() => {
-				expect(requestPayloads.length).toBeGreaterThanOrEqual(1);
-			});
-
-			const firstPayload = requestPayloads[0];
-			const querySpec = firstPayload.compositeQuery?.queries?.[0]?.spec;
-
-			expect(querySpec?.signal).toBe('logs');
-			expect(querySpec?.order).toEqual(
-				expect.arrayContaining([
-					expect.objectContaining({
-						key: expect.objectContaining({ name: 'timestamp' }),
-						direction: 'desc',
-					}),
-				]),
-			);
-		});
-
-		it('should send request type as raw for logs list', async () => {
-			const requestPayloads: any[] = [];
-
-			mockQueryRangeV5WithLogsResponse({
-				onReceiveRequest: async (req) => {
-					const payload = await req.json();
-					requestPayloads.push(payload);
-
-					return {
-						pageSize: 5,
-						offset: 0,
-					};
-				},
-			});
-
-			renderComponent();
-
-			await waitFor(() => {
-				expect(requestPayloads.length).toBeGreaterThanOrEqual(1);
-			});
-
-			const firstPayload = requestPayloads[0];
-			expect(firstPayload.requestType).toBe('raw');
-		});
-
-		it('should include pageSize in the query', async () => {
-			const requestPayloads: any[] = [];
-
-			mockQueryRangeV5WithLogsResponse({
-				onReceiveRequest: async (req) => {
-					const payload = await req.json();
-					requestPayloads.push(payload);
-
-					return {
-						pageSize: 5,
-						offset: 0,
-					};
-				},
-			});
-
-			renderComponent();
-
-			await waitFor(() => {
-				expect(requestPayloads.length).toBeGreaterThanOrEqual(1);
-			});
-
-			const firstPayload = requestPayloads[0];
-			const querySpec = firstPayload.compositeQuery?.queries?.[0]?.spec;
-
-			// Should have a limit set for pagination
-			expect(querySpec?.limit).toBeDefined();
-			expect(typeof querySpec?.limit).toBe('number');
-		});
-	});
-
-	describe('component props', () => {
-		it('should render datetime section with isModalTimeSelection', async () => {
-			mockQueryRangeV5WithLogsResponse({
-				pageSize: 5,
-				offset: 0,
-			});
-
-			renderComponent({
-				...defaultProps,
-				isModalTimeSelection: true,
-			});
-
-			await waitFor(() => {
-				expect(document.querySelector('.datetime-section')).toBeInTheDocument();
-			});
-		});
-
-		it('should render component with handleTimeChange', async () => {
-			const mockHandleTimeChange = jest.fn();
-
-			mockQueryRangeV5WithLogsResponse({
-				pageSize: 5,
-				offset: 0,
-			});
-
-			renderComponent({
-				...defaultProps,
-				handleTimeChange: mockHandleTimeChange,
-			});
-
-			await waitFor(() => {
-				expect(document.querySelector('.datetime-section')).toBeInTheDocument();
-			});
-		});
-	});
-
-	describe('log detail interactions', () => {
-		it('should open log detail drawer when clicking on a log', async () => {
-			mockQueryRangeV5WithLogsResponse({
-				pageSize: 5,
-				offset: 0,
-			});
-
-			renderComponent();
-
-			// Wait for logs to render
-			await waitFor(async () => {
-				expect(await screen.findByText(/Log message 0/)).toBeInTheDocument();
-			});
-
-			// Click on the first log
-			const logElement = await screen.findByText(/Log message 0/);
-			await userEvent.click(logElement);
-
-			// Log detail drawer should open - it contains "Log details" title
-			await waitFor(async () => {
-				expect(await screen.findByText('Log details')).toBeInTheDocument();
-			});
-		});
-
-		it('should close log detail drawer when clicking on the same log again', async () => {
-			mockQueryRangeV5WithLogsResponse({
-				pageSize: 5,
-				offset: 0,
-			});
-
-			renderComponent();
-
-			// Wait for logs to render
-			await waitFor(async () => {
-				expect(await screen.findByText(/Log message 0/)).toBeInTheDocument();
-			});
-
-			// Click on the first log to open
-			const logElement = await screen.findByText(/Log message 0/);
-			await userEvent.click(logElement);
-
-			// Wait for drawer to open
-			await waitFor(async () => {
-				expect(await screen.findByText('Log details')).toBeInTheDocument();
-			});
-
-			// Click on the same log to close (through the close button)
-			const closeButton = document.querySelector('.ant-drawer-close');
-			if (closeButton) {
-				await userEvent.click(closeButton);
-			}
-
-			// Drawer should close
-			await waitFor(() => {
-				expect(screen.queryByText('Log details')).not.toBeInTheDocument();
-			});
-		});
-
-		it('should display log body in detail drawer', async () => {
-			mockQueryRangeV5WithLogsResponse({
-				pageSize: 5,
-				offset: 0,
-			});
-
-			renderComponent();
-
-			// Wait for logs to render
-			await waitFor(async () => {
-				expect(await screen.findByText(/Log message 0/)).toBeInTheDocument();
-			});
-
-			// Click on the first log to open drawer
-			const logElement = await screen.findByText(/Log message 0/);
-			await userEvent.click(logElement);
-
-			// Wait for drawer to open
-			await waitFor(async () => {
-				expect(await screen.findByText('Log details')).toBeInTheDocument();
-			});
-
-			// Verify the drawer tabs are displayed
-			// The drawer should show the Overview tab
-			await waitFor(async () => {
-				expect(await screen.findByText('Overview')).toBeInTheDocument();
-			});
-
-			// Verify other tabs are present
-			expect(await screen.findByText('JSON')).toBeInTheDocument();
-			expect(await screen.findByText('Context')).toBeInTheDocument();
-		});
-	});
-
-	describe('log detail filter actions', () => {
-		it('should apply filter-in from log detail and close the drawer', async () => {
-			const requestPayloads: any[] = [];
-
-			mockQueryRangeV5WithLogsResponse({
-				onReceiveRequest: async (req) => {
-					const payload = await req.json();
-					requestPayloads.push(payload);
-
-					return {
-						pageSize: 5,
-						offset: 0,
-					};
-				},
-			});
-
-			renderComponent();
-
-			await waitFor(async () => {
-				expect(await screen.findByText(/Log message 0/)).toBeInTheDocument();
-			});
-
-			await userEvent.click(await screen.findByText(/Log message 0/));
-
-			await waitFor(async () => {
-				expect(await screen.findByText('Log details')).toBeInTheDocument();
-			});
-
-			const serviceRow = await waitFor(() => {
-				const attributeNameCells = Array.from(
-					document.querySelectorAll('.attribute-name'),
-				);
-				const serviceCell = attributeNameCells.find((cell) =>
-					(cell.textContent || '').toLowerCase().includes('service'),
-				);
-				const row = serviceCell?.closest('tr');
-				if (!row) {
-					throw new Error('Service attribute row not found');
-				}
-				return row;
-			});
-
-			const filterButtons = serviceRow.querySelectorAll('button.filter-btn');
-			expect(filterButtons?.length).toBeGreaterThanOrEqual(2);
-
-			await userEvent.click(filterButtons[0] as HTMLButtonElement);
-
-			await waitFor(() => {
-				expect(screen.queryByText('Log details')).not.toBeInTheDocument();
-			});
-
-			await waitFor(
-				() => {
-					const matched = requestPayloads.some((payload) => {
-						const expression =
-							payload.compositeQuery?.queries?.[0]?.spec?.filter?.expression || '';
-						return (
-							(expression.includes('attributes_string.service') ||
-								expression.includes('service')) &&
-							expression.includes("('frontend')") &&
-							expression.includes('IN')
-						);
-					});
-					expect(matched).toBe(true);
-				},
-				{ timeout: 2500 },
-			);
-		});
-
-		it('should apply filter-out from log detail and close the drawer', async () => {
-			const requestPayloads: any[] = [];
-
-			mockQueryRangeV5WithLogsResponse({
-				onReceiveRequest: async (req) => {
-					const payload = await req.json();
-					requestPayloads.push(payload);
-
-					return {
-						pageSize: 5,
-						offset: 0,
-					};
-				},
-			});
-
-			renderComponent();
-
-			await waitFor(async () => {
-				const el = await screen.findByText(/Log message 0/);
-
-				expect(el).toBeInTheDocument();
-			});
-
-			await userEvent.click(await screen.findByText(/Log message 0/));
-
-			await waitFor(async () => {
-				expect(await screen.findByText('Log details')).toBeInTheDocument();
-			});
-
-			const serviceRow = await waitFor(() => {
-				const attributeNameCells = Array.from(
-					document.querySelectorAll('.attribute-name'),
-				);
-				const serviceCell = attributeNameCells.find((cell) =>
-					(cell.textContent || '').toLowerCase().includes('service'),
-				);
-				const row = serviceCell?.closest('tr');
-				if (!row) {
-					throw new Error('Service attribute row not found');
-				}
-				return row;
-			});
-
-			const filterButtons = serviceRow.querySelectorAll('button.filter-btn');
-			expect(filterButtons?.length).toBeGreaterThanOrEqual(2);
-
-			// the second button that represents filter out
-			await userEvent.click(filterButtons[1] as HTMLButtonElement);
-
-			await waitFor(() => {
-				expect(screen.queryByText('Log details')).not.toBeInTheDocument();
-			});
-
-			await waitFor(
-				() => {
-					const matched = requestPayloads.some((payload) => {
-						const expression =
-							payload.compositeQuery?.queries?.[0]?.spec?.filter?.expression || '';
-						return (
-							(expression.includes('attributes_string.service') ||
-								expression.includes('service')) &&
-							expression.includes("('frontend')") &&
-							(expression.includes('NIN') || expression.includes('NOT_IN'))
-						);
-					});
-					expect(matched).toBe(true);
-				},
-				{ timeout: 2500 },
-			);
-		});
-	});
-
-	describe('time range change', () => {
-		it('should use different time ranges for different renders', async () => {
-			const requestPayloads: any[] = [];
-
-			mockQueryRangeV5WithLogsResponse({
-				onReceiveRequest: async (req) => {
-					const payload = await req.json();
-					requestPayloads.push(payload);
-
-					return {
-						pageSize: 5,
-						offset: 0,
-					};
-				},
-			});
-
-			// First render with initial time range
-			const { unmount } = renderComponent();
-
-			// Wait for initial fetch
-			await waitFor(() => {
-				expect(requestPayloads.length).toBeGreaterThanOrEqual(1);
-			});
-
-			const firstStartTime = requestPayloads[0].start;
-			expect(firstStartTime).toBe(defaultProps.timeRange.startTime * 1000);
-
-			// Unmount and render again with different time range
-			unmount();
-
-			const newTimeRange = {
-				startTime: 1709000000,
-				endTime: 1709003600,
-			};
-
-			renderComponent({
-				...defaultProps,
-				timeRange: newTimeRange,
-			});
-
-			// Wait for fetch with new time range
-			await waitFor(() => {
-				const hasNewTimeRange = requestPayloads.some(
-					(p) => p.start === newTimeRange.startTime * 1000,
-				);
-				expect(hasNewTimeRange).toBe(true);
-			});
-		});
-
-		it('should call handleTimeChange callback when time picker is clicked', async () => {
-			const mockHandleTimeChange = jest.fn();
-
-			mockQueryRangeV5WithLogsResponse({
-				pageSize: 5,
-				offset: 0,
-			});
-
-			renderComponent({
-				...defaultProps,
-				handleTimeChange: mockHandleTimeChange,
-			});
-
-			// Wait for component to render
-			await waitFor(() => {
-				expect(screen.getByTestId('time-picker-btn')).toBeInTheDocument();
-			});
-
-			// Click the time picker button (from mock)
-			await userEvent.click(screen.getByTestId('time-picker-btn'));
-
-			// Verify the callback was called
-			expect(mockHandleTimeChange).toHaveBeenCalledWith('5m');
-		});
-	});
-});

frontend/src/components/HostMetricsDetail/HostMetricsLogs/__tests__/hooks.test.tsx

@@ -1,240 +0,0 @@
-import { QueryClient, QueryClientProvider } from 'react-query';
-import { act, renderHook, waitFor } from '@testing-library/react';
-
-import {
-	mockQueryRangeV5WithError,
-	mockQueryRangeV5WithLogsResponse,
-} from '../../../../__tests__/query_range_v5.util';
-import { useInfiniteHostMetricLogs } from '../hooks';
-
-const createWrapper = (): React.FC<{ children: React.ReactNode }> => {
-	const queryClient = new QueryClient({
-		defaultOptions: {
-			queries: {
-				retry: false,
-			},
-		},
-	});
-
-	return function Wrapper({
-		children,
-	}: {
-		children: React.ReactNode;
-	}): JSX.Element {
-		return (
-			<QueryClientProvider client={queryClient}>{children}</QueryClientProvider>
-		);
-	};
-};
-
-describe('useInfiniteHostMetricLogs', () => {
-	const defaultParams = {
-		expression: 'host_name = "test-host"',
-		startTime: 1708000000,
-		endTime: 1708003600,
-	};
-
-	describe('initial state', () => {
-		it('should return initial loading state', () => {
-			mockQueryRangeV5WithLogsResponse({
-				delay: 100,
-			});
-
-			const { result } = renderHook(
-				() => useInfiniteHostMetricLogs(defaultParams),
-				{
-					wrapper: createWrapper(),
-				},
-			);
-
-			expect(result.current.isLoading).toBe(true);
-			expect(result.current.logs).toEqual([]);
-		});
-	});
-
-	describe('successful data fetching', () => {
-		it('should return logs after successful fetch', async () => {
-			mockQueryRangeV5WithLogsResponse({
-				pageSize: 5,
-				hasMore: true,
-			});
-
-			const { result } = renderHook(
-				() => useInfiniteHostMetricLogs(defaultParams),
-				{
-					wrapper: createWrapper(),
-				},
-			);
-
-			await waitFor(() => {
-				expect(result.current.isLoading).toBe(false);
-			});
-
-			expect(result.current.error).toBeFalsy();
-			expect(result.current.logs.length).toBe(5);
-			expect(result.current.isError).toBe(false);
-		});
-
-		it('should set hasNextPage based on response size', async () => {
-			mockQueryRangeV5WithLogsResponse({
-				pageSize: 100,
-				hasMore: true,
-			});
-
-			const { result } = renderHook(
-				() => useInfiniteHostMetricLogs(defaultParams),
-				{
-					wrapper: createWrapper(),
-				},
-			);
-
-			await waitFor(() => {
-				expect(result.current.isLoading).toBe(false);
-			});
-
-			expect(result.current.hasNextPage).toBe(true);
-		});
-
-		it('should not have next page when response is smaller than page size', async () => {
-			mockQueryRangeV5WithLogsResponse({
-				pageSize: 100,
-				hasMore: false,
-			});
-
-			const { result } = renderHook(
-				() => useInfiniteHostMetricLogs(defaultParams),
-				{
-					wrapper: createWrapper(),
-				},
-			);
-
-			await waitFor(() => {
-				expect(result.current.isLoading).toBe(false);
-			});
-
-			expect(result.current.hasNextPage).toBe(false);
-		});
-	});
-
-	describe('empty state', () => {
-		it('should return empty logs array when no data', async () => {
-			mockQueryRangeV5WithLogsResponse({
-				pageSize: 0,
-				hasMore: false,
-			});
-
-			const { result } = renderHook(
-				() => useInfiniteHostMetricLogs(defaultParams),
-				{
-					wrapper: createWrapper(),
-				},
-			);
-
-			await waitFor(() => {
-				expect(result.current.isLoading).toBe(false);
-			});
-
-			expect(result.current.logs).toEqual([]);
-			expect(result.current.hasNextPage).toBe(false);
-		});
-	});
-
-	describe('error handling', () => {
-		it('should set isError on API failure', async () => {
-			mockQueryRangeV5WithError('Internal Server Error');
-
-			const { result } = renderHook(
-				() => useInfiniteHostMetricLogs(defaultParams),
-				{
-					wrapper: createWrapper(),
-				},
-			);
-
-			await waitFor(() => {
-				expect(result.current.isError).toBe(true);
-			});
-
-			expect(result.current.logs).toEqual([]);
-		});
-	});
-
-	describe('query disabled state', () => {
-		it('should not fetch when expression is empty', async () => {
-			const requestCount = { count: 0 };
-
-			mockQueryRangeV5WithLogsResponse({
-				pageSize: 0,
-				hasMore: false,
-				onReceiveRequest: (): void => {
-					requestCount.count += 1;
-				},
-			});
-
-			const { result } = renderHook(
-				() =>
-					useInfiniteHostMetricLogs({
-						...defaultParams,
-						expression: '',
-					}),
-				{
-					wrapper: createWrapper(),
-				},
-			);
-
-			// Wait a bit to ensure no request is made
-			await new Promise((resolve) => {
-				setTimeout(resolve, 300);
-			});
-
-			expect(requestCount.count).toBe(0);
-			expect(result.current.isLoading).toBe(false);
-		});
-	});
-
-	describe('load more functionality', () => {
-		it('should fetch next page when loadMoreLogs is called', async () => {
-			const requestCount = { count: 0 };
-
-			mockQueryRangeV5WithLogsResponse({
-				pageSize: 100,
-				offset: 0,
-				hasMore: true,
-				onReceiveRequest: () => {
-					requestCount.count += 1;
-
-					if (requestCount.count > 1) {
-						return { offset: 100, pageSize: 100, hasMore: false };
-					}
-
-					return undefined;
-				},
-			});
-
-			const { result } = renderHook(
-				() => useInfiniteHostMetricLogs(defaultParams),
-				{
-					wrapper: createWrapper(),
-				},
-			);
-
-			await waitFor(() => {
-				expect(result.current.isLoading).toBe(false);
-			});
-
-			expect(result.current.logs.length).toBe(100);
-			expect(result.current.hasNextPage).toBe(true);
-			expect(requestCount.count).toBe(1);
-
-			act(() => {
-				result.current.loadMoreLogs();
-			});
-
-			await waitFor(() => {
-				expect(result.current.logs.length).toBe(150);
-			});
-
-			expect(result.current.hasNextPage).toBe(false);
-			expect(requestCount.count).toBe(2);
-		});
-	});
-});

frontend/src/components/HostMetricsDetail/HostMetricsLogs/constants.ts

@@ -0,0 +1,61 @@
+import { PANEL_TYPES } from 'constants/queryBuilder';
+import { GetQueryResultsProps } from 'lib/dashboard/getQueryResults';
+import { DataTypes } from 'types/api/queryBuilder/queryAutocompleteResponse';
+import { IBuilderQuery } from 'types/api/queryBuilder/queryBuilderData';
+import { EQueryType } from 'types/common/dashboard';
+import { DataSource, ReduceOperators } from 'types/common/queryBuilder';
+import { v4 as uuidv4 } from 'uuid';
+
+export const getHostLogsQueryPayload = (
+	start: number,
+	end: number,
+	filters: IBuilderQuery['filters'],
+): GetQueryResultsProps => ({
+	graphType: PANEL_TYPES.LIST,
+	selectedTime: 'GLOBAL_TIME',
+	query: {
+		clickhouse_sql: [],
+		promql: [],
+		builder: {
+			queryData: [
+				{
+					dataSource: DataSource.LOGS,
+					queryName: 'A',
+					aggregateOperator: 'noop',
+					aggregateAttribute: {
+						id: '------false',
+						dataType: DataTypes.String,
+						key: '',
+						type: '',
+					},
+					timeAggregation: 'rate',
+					spaceAggregation: 'sum',
+					functions: [],
+					filters,
+					expression: 'A',
+					disabled: false,
+					stepInterval: 60,
+					having: [],
+					limit: null,
+					orderBy: [
+						{
+							columnName: 'timestamp',
+							order: 'desc',
+						},
+					],
+					groupBy: [],
+					legend: '',
+					reduceTo: ReduceOperators.AVG,
+					offset: 0,
+					pageSize: 100,
+				},
+			],
+			queryFormulas: [],
+			queryTraceOperator: [],
+		},
+		id: uuidv4(),
+		queryType: EQueryType.QUERY_BUILDER,
+	},
+	start,
+	end,
+});

frontend/src/components/HostMetricsDetail/HostMetricsLogs/hooks.ts

@@ -1,107 +0,0 @@
-import { useCallback, useMemo } from 'react';
-import { useInfiniteQuery } from 'react-query';
-import { ENTITY_VERSION_V5 } from 'constants/app';
-import { DEFAULT_PER_PAGE_VALUE } from 'container/Controls/config';
-import { GetMetricQueryRange } from 'lib/dashboard/getQueryResults';
-import { parseAsString, useQueryState, UseQueryStateReturn } from 'nuqs';
-import { ILog } from 'types/api/logs/log';
-
-import { getHostLogsQueryPayload } from './utils';
-
-export function useInfiniteHostMetricLogs({
-	expression,
-	startTime,
-	endTime,
-}: {
-	expression: string;
-	startTime: number;
-	endTime: number;
-}): {
-	logs: ILog[];
-	isLoading: boolean;
-	isFetching: boolean;
-	isFetchingNextPage: boolean;
-	isError: boolean;
-	error?: unknown;
-	hasNextPage: boolean;
-	loadMoreLogs: () => void;
-	refetch: () => void;
-} {
-	const {
-		data,
-		isLoading,
-		isFetching,
-		isFetchingNextPage,
-		isError,
-		error,
-		hasNextPage,
-		fetchNextPage,
-		refetch,
-	} = useInfiniteQuery({
-		queryKey: ['hostMetricsLogs', startTime, endTime, expression],
-		queryFn: async ({ pageParam = 0 }) => {
-			const { query } = getHostLogsQueryPayload({
-				start: startTime,
-				end: endTime,
-				expression,
-				offset: pageParam,
-				pageSize: DEFAULT_PER_PAGE_VALUE,
-			});
-			return GetMetricQueryRange(query, ENTITY_VERSION_V5);
-		},
-		getNextPageParam: (lastPage, allPages) => {
-			const list = lastPage?.payload?.data?.newResult?.data?.result?.[0]?.list;
-			if (!list || list.length < DEFAULT_PER_PAGE_VALUE) {
-				return undefined;
-			}
-			return allPages.length * DEFAULT_PER_PAGE_VALUE;
-		},
-		enabled: !!expression,
-	});
-
-	const logs = useMemo<ILog[]>(() => {
-		if (!data?.pages) {
-			return [];
-		}
-
-		return data.pages.flatMap((page) => {
-			const list = page.payload.data.newResult.data.result?.[0]?.list;
-			if (!list) {
-				return [];
-			}
-
-			return list.map(
-				(item) =>
-					({
-						...item.data,
-						timestamp: item.timestamp,
-					} as ILog),
-			);
-		});
-	}, [data?.pages]);
-
-	const loadMoreLogs = useCallback(() => {
-		if (hasNextPage && !isFetchingNextPage) {
-			fetchNextPage();
-		}
-	}, [hasNextPage, isFetchingNextPage, fetchNextPage]);
-
-	return {
-		logs,
-		isLoading,
-		isFetching,
-		isFetchingNextPage,
-		isError,
-		error,
-		hasNextPage: !!hasNextPage,
-		loadMoreLogs,
-		refetch,
-	};
-}
-
-export function useInfraMonitoringHostLogsExpression(): UseQueryStateReturn<
-	string,
-	undefined
-> {
-	return useQueryState('hostMetricsLogsExpression', parseAsString);
-}

frontend/src/components/HostMetricsDetail/HostMetricsLogs/utils.ts

@@ -1,86 +0,0 @@
-import { PANEL_TYPES } from 'constants/queryBuilder';
-import { DEFAULT_PER_PAGE_VALUE } from 'container/Controls/config';
-import { GetQueryResultsProps } from 'lib/dashboard/getQueryResults';
-import { DataTypes } from 'types/api/queryBuilder/queryAutocompleteResponse';
-import { IBuilderQuery } from 'types/api/queryBuilder/queryBuilderData';
-import { EQueryType } from 'types/common/dashboard';
-import { DataSource, ReduceOperators } from 'types/common/queryBuilder';
-import { v4 as uuidv4 } from 'uuid';
-
-export interface HostLogsQueryParams {
-	start: number;
-	end: number;
-	expression: string;
-	offset?: number;
-	pageSize?: number;
-}
-
-export const getHostLogsQueryPayload = ({
-	start,
-	end,
-	expression,
-	offset = 0,
-	pageSize = DEFAULT_PER_PAGE_VALUE,
-}: HostLogsQueryParams): {
-	query: GetQueryResultsProps;
-	queryData: IBuilderQuery;
-} => {
-	const queryData: IBuilderQuery = {
-		dataSource: DataSource.LOGS,
-		queryName: 'A',
-		aggregateOperator: 'noop',
-		aggregateAttribute: {
-			id: '------false',
-			dataType: DataTypes.String,
-			key: '',
-			type: '',
-		},
-		timeAggregation: 'rate',
-		spaceAggregation: 'sum',
-		functions: [],
-		filter: { expression },
-		expression,
-		having: {
-			expression: '',
-		},
-		disabled: false,
-		stepInterval: 60,
-		limit: null,
-		orderBy: [
-			{
-				columnName: 'timestamp',
-				order: 'desc',
-			},
-			{
-				columnName: 'id',
-				order: 'desc',
-			},
-		],
-		groupBy: [],
-		legend: '',
-		reduceTo: ReduceOperators.AVG,
-		offset,
-		pageSize,
-	};
-
-	return {
-		query: {
-			graphType: PANEL_TYPES.LIST,
-			selectedTime: 'GLOBAL_TIME',
-			query: {
-				clickhouse_sql: [],
-				promql: [],
-				builder: {
-					queryData: [queryData],
-					queryFormulas: [],
-					queryTraceOperator: [],
-				},
-				id: uuidv4(),
-				queryType: EQueryType.QUERY_BUILDER,
-			},
-			start,
-			end,
-		},
-		queryData,
-	};
-};

frontend/src/components/InviteMembersModal/InviteMembersModal.tsx

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

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

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

frontend/src/components/LogDetail/index.tsx

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

frontend/src/components/Logs/LogLinesActionButtons/LogLinesActionButtons.styles.scss

@@ -28,22 +28,14 @@
 	}
 }
 
-// In table/column view, keep action buttons visible at the viewport's right edge
-.log-line-action-buttons.table-view-log-actions {
-	position: absolute;
-	top: 50%;
-	right: 8px;
-	left: auto;
-	transform: translateY(-50%);
-	margin: 0;
-	z-index: 5;
-}
-
 .lightMode {
 	.log-line-action-buttons {
 		border: 1px solid var(--bg-vanilla-400);
 		background: var(--bg-vanilla-400);
 
+		.ant-btn-default {
+		}
+
 		.copy-log-btn {
 			border-left: 1px solid var(--bg-vanilla-400);
 			border-color: var(--bg-vanilla-400) !important;