chore: resolve conflicts

.gitignore

@@ -1,11 +1,8 @@
 
 node_modules
 
-# editor
 .vscode
 !.vscode/settings.json
-.zed
-.idea
 
 deploy/docker/environment_tiny/common_test
 frontend/node_modules
@@ -34,6 +31,8 @@ frontend/yarn-debug.log*
 frontend/yarn-error.log*
 frontend/src/constants/env.ts
 
+.idea
+
 **/build
 **/storage
 **/locust-scripts/__pycache__/
@@ -230,3 +229,5 @@ cython_debug/
 pyrightconfig.json
 
 
+# cursor files
+frontend/.cursor/

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

@@ -10,7 +10,6 @@ import (
 	"github.com/SigNoz/signoz/ee/query-service/usage"
 	"github.com/SigNoz/signoz/pkg/alertmanager"
 	"github.com/SigNoz/signoz/pkg/global"
-	"github.com/SigNoz/signoz/pkg/http/handler"
 	"github.com/SigNoz/signoz/pkg/http/middleware"
 	querierAPI "github.com/SigNoz/signoz/pkg/querier"
 	baseapp "github.com/SigNoz/signoz/pkg/query-service/app"
@@ -107,10 +106,7 @@ func (ah *APIHandler) RegisterRoutes(router *mux.Router, am *middleware.AuthZ) {
 	router.HandleFunc("/api/v4/query_range", am.ViewAccess(ah.queryRangeV4)).Methods(http.MethodPost)
 
 	// v5
-	router.Handle("/api/v5/query_range", handler.New(
-		am.ViewAccess(ah.queryRangeV5),
-		querierAPI.QueryRangeV5OpenAPIDef,
-	)).Methods(http.MethodPost)
+	router.HandleFunc("/api/v5/query_range", am.ViewAccess(ah.queryRangeV5)).Methods(http.MethodPost)
 
 	router.HandleFunc("/api/v5/substitute_vars", am.ViewAccess(ah.QuerierAPI.ReplaceVariables)).Methods(http.MethodPost)
 

ee/query-service/rules/anomaly.go

@@ -5,23 +5,16 @@ import (
 	"encoding/json"
 	"fmt"
 	"log/slog"
-	"math"
 	"strings"
 	"sync"
 	"time"
 
-	"github.com/SigNoz/signoz/ee/query-service/anomaly"
 	"github.com/SigNoz/signoz/pkg/cache"
-	"github.com/SigNoz/signoz/pkg/query-service/common"
 	"github.com/SigNoz/signoz/pkg/query-service/model"
-	"github.com/SigNoz/signoz/pkg/transition"
 	"github.com/SigNoz/signoz/pkg/types/ruletypes"
 	"github.com/SigNoz/signoz/pkg/valuer"
 
-	querierV2 "github.com/SigNoz/signoz/pkg/query-service/app/querier/v2"
-	"github.com/SigNoz/signoz/pkg/query-service/app/queryBuilder"
 	"github.com/SigNoz/signoz/pkg/query-service/interfaces"
-	v3 "github.com/SigNoz/signoz/pkg/query-service/model/v3"
 	"github.com/SigNoz/signoz/pkg/query-service/utils/labels"
 	"github.com/SigNoz/signoz/pkg/query-service/utils/times"
 	"github.com/SigNoz/signoz/pkg/query-service/utils/timestamp"
@@ -32,6 +25,8 @@ import (
 
 	querierV5 "github.com/SigNoz/signoz/pkg/querier"
 
+	"github.com/SigNoz/signoz/ee/query-service/anomaly"
+
 	anomalyV2 "github.com/SigNoz/signoz/ee/anomaly"
 
 	qbtypes "github.com/SigNoz/signoz/pkg/types/querybuildertypes/querybuildertypesv5"
@@ -48,17 +43,12 @@ type AnomalyRule struct {
 
 	reader interfaces.Reader
 
-	// querierV2 is used for alerts created after the introduction of new metrics query builder
-	querierV2 interfaces.Querier
-
-	// querierV5 is used for alerts migrated after the introduction of new query builder
+	// querierV5 is the query builder v5 querier used for all alert rule evaluation
 	querierV5 querierV5.Querier
 
-	provider   anomaly.Provider
 	providerV2 anomalyV2.Provider
 
-	version string
-	logger  *slog.Logger
+	logger *slog.Logger
 
 	seasonality anomaly.Seasonality
 }
@@ -102,34 +92,6 @@ func NewAnomalyRule(
 
 	logger.Info("using seasonality", "seasonality", t.seasonality.String())
 
-	querierOptsV2 := querierV2.QuerierOptions{
-		Reader:       reader,
-		Cache:        cache,
-		KeyGenerator: queryBuilder.NewKeyGenerator(),
-	}
-
-	t.querierV2 = querierV2.NewQuerier(querierOptsV2)
-	t.reader = reader
-	if t.seasonality == anomaly.SeasonalityHourly {
-		t.provider = anomaly.NewHourlyProvider(
-			anomaly.WithCache[*anomaly.HourlyProvider](cache),
-			anomaly.WithKeyGenerator[*anomaly.HourlyProvider](queryBuilder.NewKeyGenerator()),
-			anomaly.WithReader[*anomaly.HourlyProvider](reader),
-		)
-	} else if t.seasonality == anomaly.SeasonalityDaily {
-		t.provider = anomaly.NewDailyProvider(
-			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.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),
@@ -148,7 +110,7 @@ func NewAnomalyRule(
 	}
 
 	t.querierV5 = querierV5
-	t.version = p.Version
+	t.reader = reader
 	t.logger = logger
 	return &t, nil
 }
@@ -157,36 +119,9 @@ func (r *AnomalyRule) Type() ruletypes.RuleType {
 	return RuleTypeAnomaly
 }
 
-func (r *AnomalyRule) prepareQueryRange(ctx context.Context, ts time.Time) (*v3.QueryRangeParamsV3, error) {
+func (r *AnomalyRule) prepareQueryRange(ctx context.Context, ts time.Time) (*qbtypes.QueryRangeRequest, error) {
 
-	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())
+	r.logger.InfoContext(ctx, "prepare query range request", "ts", ts.UnixMilli(), "eval_window", r.EvalWindow().Milliseconds(), "eval_delay", r.EvalDelay().Milliseconds())
 
 	startTs, endTs := r.Timestamps(ts)
 	start, end := startTs.UnixMilli(), endTs.UnixMilli()
@@ -215,60 +150,6 @@ func (r *AnomalyRule) buildAndRunQuery(ctx context.Context, orgID valuer.UUID, t
 	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.GetAnomaliesRequest{
-		Params:      params,
-		Seasonality: r.seasonality,
-	})
-	if err != nil {
-		return nil, err
-	}
-
-	var queryResult *v3.Result
-	for _, result := range anomalies.Results {
-		if result.QueryName == r.GetSelectedQuery() {
-			queryResult = result
-			break
-		}
-	}
-
-	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))
-
-	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,
@@ -290,20 +171,25 @@ func (r *AnomalyRule) buildAndRunQueryV5(ctx context.Context, orgID valuer.UUID,
 		r.logger.WarnContext(ctx, "nil qb result", "ts", ts.UnixMilli())
 	}
 
-	queryResult := transition.ConvertV5TimeSeriesDataToV4Result(qbResult)
+	var anomalyScores []*qbtypes.TimeSeries
+	if qbResult != nil {
+		for _, bucket := range qbResult.Aggregations {
+			anomalyScores = append(anomalyScores, bucket.AnomalyScores...)
+		}
+	}
 
-	hasData := len(queryResult.AnomalyScores) > 0
+	hasData := len(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)
+	scoresJSON, _ := json.Marshal(anomalyScores)
 	r.logger.InfoContext(ctx, "anomaly scores", "scores", string(scoresJSON))
 
 	// Filter out new series if newGroupEvalDelay is configured
-	seriesToProcess := queryResult.AnomalyScores
+	seriesToProcess := 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
@@ -316,7 +202,7 @@ func (r *AnomalyRule) buildAndRunQueryV5(ctx context.Context, orgID valuer.UUID,
 
 	for _, series := range seriesToProcess {
 		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)
+			r.logger.InfoContext(ctx, "not enough data points to evaluate series, skipping", "ruleid", r.ID(), "numPoints", len(series.Values), "requiredPoints", r.Condition().RequiredNumPoints)
 			continue
 		}
 		results, err := r.Threshold.Eval(*series, r.Unit(), ruletypes.EvalData{
@@ -337,16 +223,7 @@ func (r *AnomalyRule) Eval(ctx context.Context, ts time.Time) (int, error) {
 
 	valueFormatter := formatter.FromUnit(r.Unit())
 
-	var res ruletypes.Vector
-	var err error
-
-	if r.version == "v5" {
-		r.logger.InfoContext(ctx, "running v5 query")
-		res, err = r.buildAndRunQueryV5(ctx, r.OrgID(), ts)
-	} else {
-		r.logger.InfoContext(ctx, "running v4 query")
-		res, err = r.buildAndRunQuery(ctx, r.OrgID(), ts)
-	}
+	res, err := r.buildAndRunQuery(ctx, r.OrgID(), ts)
 	if err != nil {
 		return 0, err
 	}

ee/query-service/rules/anomaly_test.go

@@ -8,28 +8,27 @@ import (
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 
-	"github.com/SigNoz/signoz/ee/query-service/anomaly"
+	anomalyV2 "github.com/SigNoz/signoz/ee/anomaly"
 	"github.com/SigNoz/signoz/pkg/instrumentation/instrumentationtest"
 	"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"
+	qbtypes "github.com/SigNoz/signoz/pkg/types/querybuildertypes/querybuildertypesv5"
 	"github.com/SigNoz/signoz/pkg/types/ruletypes"
+	"github.com/SigNoz/signoz/pkg/types/telemetrytypes"
+	v3 "github.com/SigNoz/signoz/pkg/query-service/model/v3"
 	"github.com/SigNoz/signoz/pkg/valuer"
 )
 
-// mockAnomalyProvider is a mock implementation of anomaly.Provider for testing.
-// We need this because the anomaly provider makes 6 different queries for various
-// 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.GetAnomaliesResponse
+// mockAnomalyProviderV2 is a mock implementation of anomalyV2.Provider for testing.
+type mockAnomalyProviderV2 struct {
+	responses []*anomalyV2.AnomaliesResponse
 	callCount int
 }
 
-func (m *mockAnomalyProvider) GetAnomalies(ctx context.Context, orgID valuer.UUID, req *anomaly.GetAnomaliesRequest) (*anomaly.GetAnomaliesResponse, error) {
+func (m *mockAnomalyProviderV2) GetAnomalies(ctx context.Context, orgID valuer.UUID, req *anomalyV2.AnomaliesRequest) (*anomalyV2.AnomaliesResponse, error) {
 	if m.callCount >= len(m.responses) {
-		return &anomaly.GetAnomaliesResponse{Results: []*v3.Result{}}, nil
+		return &anomalyV2.AnomaliesResponse{Results: []*qbtypes.TimeSeriesData{}}, nil
 	}
 	resp := m.responses[m.callCount]
 	m.callCount++
@@ -82,11 +81,11 @@ func TestAnomalyRule_NoData_AlertOnAbsent(t *testing.T) {
 		},
 	}
 
-	responseNoData := &anomaly.GetAnomaliesResponse{
-		Results: []*v3.Result{
+	responseNoData := &anomalyV2.AnomaliesResponse{
+		Results: []*qbtypes.TimeSeriesData{
 			{
-				QueryName:     "A",
-				AnomalyScores: []*v3.Series{},
+				QueryName:    "A",
+				Aggregations: []*qbtypes.AggregationBucket{},
 			},
 		},
 	}
@@ -129,8 +128,8 @@ func TestAnomalyRule_NoData_AlertOnAbsent(t *testing.T) {
 			)
 			require.NoError(t, err)
 
-			rule.provider = &mockAnomalyProvider{
-				responses: []*anomaly.GetAnomaliesResponse{responseNoData},
+			rule.providerV2 = &mockAnomalyProviderV2{
+				responses: []*anomalyV2.AnomaliesResponse{responseNoData},
 			}
 
 			alertsFound, err := rule.Eval(context.Background(), evalTime)
@@ -190,11 +189,11 @@ func TestAnomalyRule_NoData_AbsentFor(t *testing.T) {
 		},
 	}
 
-	responseNoData := &anomaly.GetAnomaliesResponse{
-		Results: []*v3.Result{
+	responseNoData := &anomalyV2.AnomaliesResponse{
+		Results: []*qbtypes.TimeSeriesData{
 			{
-				QueryName:     "A",
-				AnomalyScores: []*v3.Series{},
+				QueryName:    "A",
+				Aggregations: []*qbtypes.AggregationBucket{},
 			},
 		},
 	}
@@ -228,16 +227,22 @@ func TestAnomalyRule_NoData_AbsentFor(t *testing.T) {
 			t1 := baseTime.Add(5 * time.Minute)
 			t2 := t1.Add(c.timeBetweenEvals)
 
-			responseWithData := &anomaly.GetAnomaliesResponse{
-				Results: []*v3.Result{
+			responseWithData := &anomalyV2.AnomaliesResponse{
+				Results: []*qbtypes.TimeSeriesData{
 					{
 						QueryName: "A",
-						AnomalyScores: []*v3.Series{
+						Aggregations: []*qbtypes.AggregationBucket{
 							{
-								Labels: map[string]string{"test": "label"},
-								Points: []v3.Point{
-									{Timestamp: baseTime.UnixMilli(), Value: 1.0},
-									{Timestamp: baseTime.Add(time.Minute).UnixMilli(), Value: 1.5},
+								AnomalyScores: []*qbtypes.TimeSeries{
+									{
+										Labels: []*qbtypes.Label{
+											{Key: telemetrytypes.TelemetryFieldKey{Name: "test"}, Value: "label"},
+										},
+										Values: []*qbtypes.TimeSeriesValue{
+											{Timestamp: baseTime.UnixMilli(), Value: 1.0},
+											{Timestamp: baseTime.Add(time.Minute).UnixMilli(), Value: 1.5},
+										},
+									},
 								},
 							},
 						},
@@ -252,8 +257,8 @@ func TestAnomalyRule_NoData_AbsentFor(t *testing.T) {
 			rule, err := NewAnomalyRule("test-anomaly-rule", valuer.GenerateUUID(), &postableRule, reader, nil, logger, nil)
 			require.NoError(t, err)
 
-			rule.provider = &mockAnomalyProvider{
-				responses: []*anomaly.GetAnomaliesResponse{responseWithData, responseNoData},
+			rule.providerV2 = &mockAnomalyProviderV2{
+				responses: []*anomalyV2.AnomaliesResponse{responseWithData, responseNoData},
 			}
 
 			alertsFound1, err := rule.Eval(context.Background(), t1)

frontend/.cursor/rules/testing-conventions.mdc

@@ -1,74 +0,0 @@
----
-description: Core testing conventions - imports, rendering, MSW, interactions, queries
-globs: **/*.test.{ts,tsx}
-alwaysApply: false
----
-
-# Testing Conventions
-
-## Imports
-
-Always import from the test harness, never directly from `@testing-library/react`:
-
-```ts
-import { render, screen, userEvent, waitFor } from 'tests/test-utils';
-import { server, rest } from 'mocks-server/server';
-```
-
-## Router
-
-Use the built-in router in `render`:
-
-```ts
-render(<Page />, undefined, { initialRoute: '/traces-explorer' });
-```
-
-Only mock `useLocation` / `useParams` if the test depends on their values.
-
-## MSW
-
-Global MSW server runs automatically. Override per-test:
-
-```ts
-server.use(
-  rest.get('*/api/v1/foo', (_req, res, ctx) =>
-    res(ctx.status(200), ctx.json({ ok: true })))
-);
-```
-
-Keep large response fixtures in `mocks-server/__mockdata_`.
-
-## Interactions
-
-- Prefer `userEvent` for real user interactions (click, type, select, tab).
-- Use `fireEvent` only for low-level events not covered by `userEvent` (e.g., scroll, resize). Wrap in `act(...)` if needed.
-- Always `await` interactions:
-
-```ts
-const user = userEvent.setup({ pointerEventsCheck: 0 });
-await user.click(screen.getByRole('button', { name: /save/i }));
-```
-
-## Timers
-
-No global fake timers. Per-test only, for debounce/throttle:
-
-```ts
-jest.useFakeTimers();
-const user = userEvent.setup({ advanceTimers: (ms) => jest.advanceTimersByTime(ms) });
-await user.type(screen.getByRole('textbox'), 'query');
-jest.advanceTimersByTime(400);
-jest.useRealTimers();
-```
-
-## Queries
-
-Prefer accessible queries: `getByRole` > `findByRole` > `getByLabelText` > visible text > `data-testid` (last resort).
-
-## Anti-patterns
-
-- Never import from `@testing-library/react` directly
-- Never use global fake timers
-- Never wrap `render` in `act(...)`
-- Never mock infra dependencies locally (router, react-query)
-- Limit to 3-5 focused tests per file

frontend/.cursor/rules/testing-mock-strategy.mdc

@@ -1,54 +0,0 @@
----
-description: When to use global vs local mocks in tests
-globs: **/*.test.{ts,tsx}
-alwaysApply: false
----
-
-# Mock Strategy
-
-## Use Global Mocks For
-
-High-frequency dependencies (20+ test files):
-- Core infrastructure: react-router-dom, react-query, antd
-- Browser APIs: ResizeObserver, matchMedia, localStorage
-- Utility libraries: date-fns, lodash
-
-Available global mock files (from jest.config.ts):
-- `uplot` -> `__mocks__/uplotMock.ts`
-
-## Use Local Mocks For
-
-- Business logic dependencies (API endpoints, custom hooks, domain components)
-- Test-specific behavior (different data per test, error scenarios, loading states)
-
-## Decision Tree
-
-```
-Used in 20+ test files?
-  YES -> Global mock
-  NO  -> Business logic or test-specific?
-    YES -> Local mock
-    NO  -> Consider global if usage grows
-```
-
-## Correct Usage
-
-```ts
-// Global mocks are already available - just import
-import { useLocation } from 'react-router-dom';
-
-// Local mocks for business logic
-jest.mock('../api/tracesService', () => ({
-  getTraces: jest.fn(() => mockTracesData),
-}));
-```
-
-## Anti-patterns
-
-```ts
-// Never re-mock globally mocked dependencies locally
-jest.mock('react-router-dom', () => ({ ... }));
-
-// Never put test-specific data in global mocks
-jest.mock('../api/tracesService', () => ({ getTraces: jest.fn(() => specificTestData) }));
-```

frontend/.cursor/rules/testing-type-safety.mdc

@@ -1,54 +0,0 @@
----
-description: TypeScript type safety requirements for Jest tests
-globs: **/*.test.{ts,tsx}
-alwaysApply: false
----
-
-# TypeScript Type Safety in Tests
-
-All Jest tests must be fully type-safe. Never use `any`.
-
-## Mock Function Typing
-
-```ts
-// Use jest.mocked for module mocks
-import useFoo from 'hooks/useFoo';
-jest.mock('hooks/useFoo');
-const mockUseFoo = jest.mocked(useFoo);
-
-// Use jest.MockedFunction for standalone mocks
-const mockFetch = jest.fn() as jest.MockedFunction<(id: number) => Promise<User>>;
-```
-
-## Mock Data
-
-Define interfaces for all mock data:
-
-```ts
-const mockUser: User = { id: 1, name: 'John', email: 'john@example.com' };
-
-const mockProps: ComponentProps = {
-  title: 'Test',
-  data: [mockUser],
-  onSelect: jest.fn() as jest.MockedFunction<(user: User) => void>,
-};
-```
-
-## Hook Mocking Pattern
-
-```ts
-import useFoo from 'hooks/useFoo';
-jest.mock('hooks/useFoo');
-const mockUseFoo = jest.mocked(useFoo);
-mockUseFoo.mockReturnValue(/* minimal shape */);
-```
-
-Prefer helpers (`rqSuccess`, `rqLoading`, `rqError`) for React Query results.
-
-## Checklist
-
-- All mock functions use `jest.MockedFunction<T>` or `jest.mocked()`
-- All mock data has proper interfaces
-- No `any` types in test files
-- Component props are typed
-- API response types are defined

frontend/.cursorrules

@@ -0,0 +1,484 @@
+# Persona
+You are an expert developer with deep knowledge of Jest, React Testing Library, MSW, and TypeScript, tasked with creating unit tests for this repository.
+
+# Auto-detect TypeScript Usage
+Check for TypeScript in the project through tsconfig.json or package.json dependencies.
+Adjust syntax based on this detection.
+
+# TypeScript Type Safety for Jest Tests
+**CRITICAL**: All Jest tests MUST be fully type-safe with proper TypeScript types.
+
+**Type Safety Requirements:**
+- Use proper TypeScript interfaces for all mock data
+- Type all Jest mock functions with `jest.MockedFunction<T>`
+- Use generic types for React components and hooks
+- Define proper return types for mock functions
+- Use `as const` for literal types when needed
+- Avoid `any` type – use proper typing instead
+
+# Unit Testing Focus
+Focus on critical functionality (business logic, utility functions, component behavior)
+Mock dependencies (API calls, external modules) before imports
+Test multiple data scenarios (valid inputs, invalid inputs, edge cases)
+Write maintainable tests with descriptive names grouped in describe blocks
+
+# Global vs Local Mocks
+**Use Global Mocks for:**
+- High-frequency dependencies (20+ test files)
+- Core infrastructure (react-router-dom, react-query, antd)
+- Standard implementations across the app
+- Browser APIs (ResizeObserver, matchMedia, localStorage)
+- Utility libraries (date-fns, lodash)
+
+**Use Local Mocks for:**
+- Business logic dependencies (5-15 test files)
+- Test-specific behavior (different data per test)
+- API endpoints with specific responses
+- Domain-specific components
+- Error scenarios and edge cases
+
+**Global Mock Files Available (from jest.config.ts):**
+- `uplot` → `__mocks__/uplotMock.ts`
+
+# Repo-specific Testing Conventions
+
+## Imports
+Always import from our harness:
+```ts
+import { render, screen, userEvent, waitFor } from 'tests/test-utils';
+```
+For API mocks:
+```ts
+import { server, rest } from 'mocks-server/server';
+```
+Do not import directly from `@testing-library/react`.
+
+## Router
+Use the router built into render:
+```ts
+render(<Page />, undefined, { initialRoute: '/traces-explorer' });
+```
+Only mock `useLocation` / `useParams` if the test depends on them.
+
+## Hook Mocks
+Pattern:
+```ts
+import useFoo from 'hooks/useFoo';
+jest.mock('hooks/useFoo');
+const mockUseFoo = jest.mocked(useFoo);
+mockUseFoo.mockReturnValue(/* minimal shape */ as any);
+```
+Prefer helpers (`rqSuccess`, `rqLoading`, `rqError`) for React Query results.
+
+## MSW
+Global MSW server runs automatically.
+Override per-test:
+```ts
+server.use(
+  rest.get('*/api/v1/foo', (_req, res, ctx) => res(ctx.status(200), ctx.json({ ok: true })))
+);
+```
+Keep large responses in `mocks-server/__mockdata_`.
+
+## Interactions
+- Prefer `userEvent` for real user interactions (click, type, select, tab).
+- Use `fireEvent` only for low-level/programmatic events not covered by `userEvent` (e.g., scroll, resize, setting `element.scrollTop` for virtualization). Wrap in `act(...)` if needed.
+- Always await interactions:
+```ts
+const user = userEvent.setup({ pointerEventsCheck: 0 });
+await user.click(screen.getByRole('button', { name: /save/i }));
+```
+
+```ts
+// Example: virtualized list scroll (no userEvent helper)
+const scroller = container.querySelector('[data-test-id="virtuoso-scroller"]') as HTMLElement;
+scroller.scrollTop = targetScrollTop;
+act(() => { fireEvent.scroll(scroller); });
+```
+
+## Timers
+❌ No global fake timers.
+✅ Per-test only, for debounce/throttle:
+```ts
+jest.useFakeTimers();
+const user = userEvent.setup({ advanceTimers: (ms) => jest.advanceTimersByTime(ms) });
+await user.type(screen.getByRole('textbox'), 'query');
+jest.advanceTimersByTime(400);
+jest.useRealTimers();
+```
+
+## Queries
+Prefer accessible queries (`getByRole`, `findByRole`, `getByLabelText`).
+Fallback: visible text.
+Last resort: `data-testid`.
+
+# Example Test (using only configured global mocks)
+```ts
+import { render, screen, userEvent, waitFor } from 'tests/test-utils';
+import { server, rest } from 'mocks-server/server';
+import MyComponent from '../MyComponent';
+
+describe('MyComponent', () => {
+  it('renders and interacts', async () => {
+    const user = userEvent.setup({ pointerEventsCheck: 0 });
+
+    server.use(
+      rest.get('*/api/v1/example', (_req, res, ctx) => res(ctx.status(200), ctx.json({ value: 42 })))
+    );
+
+    render(<MyComponent />, undefined, { initialRoute: '/foo' });
+
+    expect(await screen.findByText(/value: 42/i)).toBeInTheDocument();
+    await user.click(screen.getByRole('button', { name: /refresh/i }));
+    await waitFor(() => expect(screen.getByText(/loading/i)).toBeInTheDocument());
+  });
+});
+```
+
+# Anti-patterns
+❌ Importing RTL directly
+❌ Using global fake timers
+❌ Wrapping render in `act(...)`
+❌ Mocking infra dependencies locally (router, react-query)
+✅ Use our harness (`tests/test-utils`)
+✅ Use MSW for API overrides
+✅ Use userEvent + await
+✅ Pin time only in tests that assert relative dates
+
+# Best Practices
+- **Critical Functionality**: Prioritize testing business logic and utilities
+- **Dependency Mocking**: Global mocks for infra, local mocks for business logic
+- **Data Scenarios**: Always test valid, invalid, and edge cases
+- **Descriptive Names**: Make test intent clear
+- **Organization**: Group related tests in describe
+- **Consistency**: Match repo conventions
+- **Edge Cases**: Test null, undefined, unexpected values
+- **Limit Scope**: 3–5 focused tests per file
+- **Use Helpers**: `rqSuccess`, `makeUser`, etc.
+- **No Any**: Enforce type safety
+
+# Example Test
+```ts
+import { render, screen, userEvent, waitFor } from 'tests/test-utils';
+import { server, rest } from 'mocks-server/server';
+import MyComponent from '../MyComponent';
+
+describe('MyComponent', () => {
+  it('renders and interacts', async () => {
+    const user = userEvent.setup({ pointerEventsCheck: 0 });
+
+    server.use(
+      rest.get('*/api/v1/example', (_req, res, ctx) => res(ctx.status(200), ctx.json({ value: 42 })))
+    );
+
+    render(<MyComponent />, undefined, { initialRoute: '/foo' });
+
+    expect(await screen.findByText(/value: 42/i)).toBeInTheDocument();
+    await user.click(screen.getByRole('button', { name: /refresh/i }));
+    await waitFor(() => expect(screen.getByText(/loading/i)).toBeInTheDocument());
+  });
+});
+```
+
+# Anti-patterns
+❌ Importing RTL directly
+❌ Using global fake timers
+❌ Wrapping render in `act(...)`
+❌ Mocking infra dependencies locally (router, react-query)
+✅ Use our harness (`tests/test-utils`)
+✅ Use MSW for API overrides
+✅ Use userEvent + await
+✅ Pin time only in tests that assert relative dates
+
+# TypeScript Type Safety Examples
+
+## Proper Mock Typing
+```ts
+// ✅ GOOD - Properly typed mocks
+interface User {
+  id: number;
+  name: string;
+  email: string;
+}
+
+interface ApiResponse<T> {
+  data: T;
+  status: number;
+  message: string;
+}
+
+// Type the mock functions
+const mockFetchUser = jest.fn() as jest.MockedFunction<(id: number) => Promise<ApiResponse<User>>>;
+const mockUpdateUser = jest.fn() as jest.MockedFunction<(user: User) => Promise<ApiResponse<User>>>;
+
+// Mock implementation with proper typing
+mockFetchUser.mockResolvedValue({
+  data: { id: 1, name: 'John Doe', email: 'john@example.com' },
+  status: 200,
+  message: 'Success'
+});
+
+// ❌ BAD - Using any type
+const mockFetchUser = jest.fn() as any; // Don't do this
+```
+
+## React Component Testing with Types
+```ts
+// ✅ GOOD - Properly typed component testing
+interface ComponentProps {
+  title: string;
+  data: User[];
+  onUserSelect: (user: User) => void;
+  isLoading?: boolean;
+}
+
+const TestComponent: React.FC<ComponentProps> = ({ title, data, onUserSelect, isLoading = false }) => {
+  // Component implementation
+};
+
+describe('TestComponent', () => {
+  it('should render with proper props', () => {
+    // Arrange - Type the props properly
+    const mockProps: ComponentProps = {
+      title: 'Test Title',
+      data: [{ id: 1, name: 'John', email: 'john@example.com' }],
+      onUserSelect: jest.fn() as jest.MockedFunction<(user: User) => void>,
+      isLoading: false
+    };
+    
+    // Act
+    render(<TestComponent {...mockProps} />);
+    
+    // Assert
+    expect(screen.getByText('Test Title')).toBeInTheDocument();
+  });
+});
+```
+
+## Hook Testing with Types
+```ts
+// ✅ GOOD - Properly typed hook testing
+interface UseUserDataReturn {
+  user: User | null;
+  loading: boolean;
+  error: string | null;
+  refetch: () => void;
+}
+
+const useUserData = (id: number): UseUserDataReturn => {
+  // Hook implementation
+};
+
+describe('useUserData', () => {
+  it('should return user data with proper typing', () => {
+    // Arrange
+    const mockUser: User = { id: 1, name: 'John', email: 'john@example.com' };
+    mockFetchUser.mockResolvedValue({
+      data: mockUser,
+      status: 200,
+      message: 'Success'
+    });
+    
+    // Act
+    const { result } = renderHook(() => useUserData(1));
+    
+    // Assert
+    expect(result.current.user).toEqual(mockUser);
+    expect(result.current.loading).toBe(false);
+    expect(result.current.error).toBeNull();
+  });
+});
+```
+
+## Global Mock Type Safety
+```ts
+// ✅ GOOD - Type-safe global mocks
+// In __mocks__/routerMock.ts
+export const mockUseLocation = (overrides: Partial<Location> = {}): Location => ({
+  pathname: '/traces',
+  search: '',
+  hash: '',
+  state: null,
+  key: 'test-key',
+  ...overrides,
+});
+
+// In test files
+const location = useLocation(); // Properly typed from global mock
+expect(location.pathname).toBe('/traces');
+```
+
+# TypeScript Configuration for Jest
+
+## Required Jest Configuration
+```json
+// jest.config.ts
+{
+  "preset": "ts-jest/presets/js-with-ts-esm",
+  "globals": {
+    "ts-jest": {
+      "useESM": true,
+      "isolatedModules": true,
+      "tsconfig": "<rootDir>/tsconfig.jest.json"
+    }
+  },
+  "extensionsToTreatAsEsm": [".ts", ".tsx"],
+  "moduleFileExtensions": ["ts", "tsx", "js", "json"]
+}
+```
+
+## TypeScript Jest Configuration
+```json
+// tsconfig.jest.json
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "types": ["jest", "@testing-library/jest-dom"],
+    "esModuleInterop": true,
+    "allowSyntheticDefaultImports": true,
+    "moduleResolution": "node"
+  },
+  "include": [
+    "src/**/*",
+    "**/*.test.ts",
+    "**/*.test.tsx",
+    "__mocks__/**/*"
+  ]
+}
+```
+
+## Common Type Safety Patterns
+
+### Mock Function Typing
+```ts
+// ✅ GOOD - Proper mock function typing
+const mockApiCall = jest.fn() as jest.MockedFunction<typeof apiCall>;
+const mockEventHandler = jest.fn() as jest.MockedFunction<(event: Event) => void>;
+
+// ❌ BAD - Using any
+const mockApiCall = jest.fn() as any;
+```
+
+### Generic Mock Typing
+```ts
+// ✅ GOOD - Generic mock typing
+interface MockApiResponse<T> {
+  data: T;
+  status: number;
+}
+
+const mockFetchData = jest.fn() as jest.MockedFunction<
+  <T>(endpoint: string) => Promise<MockApiResponse<T>>
+>;
+
+// Usage
+mockFetchData<User>('/users').mockResolvedValue({
+  data: { id: 1, name: 'John' },
+  status: 200
+});
+```
+
+### React Testing Library with Types
+```ts
+// ✅ GOOD - Typed testing utilities
+import { render, screen, RenderResult } from '@testing-library/react';
+import { ComponentProps } from 'react';
+
+type TestComponentProps = ComponentProps<typeof TestComponent>;
+
+const renderTestComponent = (props: Partial<TestComponentProps> = {}): RenderResult => {
+  const defaultProps: TestComponentProps = {
+    title: 'Test',
+    data: [],
+    onSelect: jest.fn(),
+    ...props
+  };
+  
+  return render(<TestComponent {...defaultProps} />);
+};
+```
+
+### Error Handling with Types
+```ts
+// ✅ GOOD - Typed error handling
+interface ApiError {
+  message: string;
+  code: number;
+  details?: Record<string, unknown>;
+}
+
+const mockApiError: ApiError = {
+  message: 'API Error',
+  code: 500,
+  details: { endpoint: '/users' }
+};
+
+mockFetchUser.mockRejectedValue(new Error(JSON.stringify(mockApiError)));
+```
+
+## Type Safety Checklist
+- [ ] All mock functions use `jest.MockedFunction<T>`
+- [ ] All mock data has proper interfaces
+- [ ] No `any` types in test files
+- [ ] Generic types are used where appropriate
+- [ ] Error types are properly defined
+- [ ] Component props are typed
+- [ ] Hook return types are defined
+- [ ] API response types are defined
+- [ ] Global mocks are type-safe
+- [ ] Test utilities are properly typed
+
+# Mock Decision Tree
+```
+Is it used in 20+ test files?
+├─ YES → Use Global Mock
+│   ├─ react-router-dom
+│   ├─ react-query
+│   ├─ antd components
+│   └─ browser APIs
+│
+└─ NO → Is it business logic?
+    ├─ YES → Use Local Mock
+    │   ├─ API endpoints
+    │   ├─ Custom hooks
+    │   └─ Domain components
+    │
+    └─ NO → Is it test-specific?
+        ├─ YES → Use Local Mock
+        │   ├─ Error scenarios
+        │   ├─ Loading states
+        │   └─ Specific data
+        │
+        └─ NO → Consider Global Mock
+            └─ If it becomes frequently used
+```
+
+# Common Anti-Patterns to Avoid
+
+❌ **Don't mock global dependencies locally:**
+```js
+// BAD - This is already globally mocked
+jest.mock('react-router-dom', () => ({ ... }));
+```
+
+❌ **Don't create global mocks for test-specific data:**
+```js
+// BAD - This should be local
+jest.mock('../api/tracesService', () => ({
+  getTraces: jest.fn(() => specificTestData)
+}));
+```
+
+✅ **Do use global mocks for infrastructure:**
+```js
+// GOOD - Use global mock
+import { useLocation } from 'react-router-dom';
+```
+
+✅ **Do create local mocks for business logic:**
+```js
+// GOOD - Local mock for specific test needs
+jest.mock('../api/tracesService', () => ({
+  getTraces: jest.fn(() => mockTracesData)
+}));
+```

frontend/package.json

@@ -58,7 +58,6 @@
 		"@signozhq/radio-group": "0.0.2",
 		"@signozhq/resizable": "0.0.0",
 		"@signozhq/sonner": "0.1.0",
-		"@signozhq/switch": "0.0.2",
 		"@signozhq/table": "0.3.7",
 		"@signozhq/tooltip": "0.0.2",
 		"@tanstack/react-table": "8.20.6",

frontend/public/locales/en-GB/routes.json

@@ -12,6 +12,5 @@
 	"pipeline": "Pipeline",
 	"pipelines": "Pipelines",
 	"archives": "Archives",
-	"logs_to_metrics": "Logs To Metrics",
-	"roles": "Roles"
+	"logs_to_metrics": "Logs To Metrics"
 }

frontend/public/locales/en/routes.json

@@ -12,6 +12,5 @@
 	"pipeline": "Pipeline",
 	"pipelines": "Pipelines",
 	"archives": "Archives",
-	"logs_to_metrics": "Logs To Metrics",
-	"roles": "Roles"
+	"logs_to_metrics": "Logs To Metrics"
 }

frontend/public/locales/en/titles.json

@@ -73,6 +73,5 @@
 	"API_MONITORING": "SigNoz | External APIs",
 	"METER_EXPLORER": "SigNoz | Meter Explorer",
 	"METER_EXPLORER_VIEWS": "SigNoz | Meter Explorer Views",
-	"METER": "SigNoz | Meter",
-	"ROLES_SETTINGS": "SigNoz | Roles"
+	"METER": "SigNoz | Meter"
 }

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

@@ -20,20 +20,17 @@ import { useMutation, useQuery } from 'react-query';
 import { GeneratedAPIInstance } from '../../../index';
 import type {
 	GetMetricAlerts200,
-	GetMetricAlertsPathParameters,
+	GetMetricAlertsParams,
 	GetMetricAttributes200,
-	GetMetricAttributesParams,
-	GetMetricAttributesPathParameters,
 	GetMetricDashboards200,
-	GetMetricDashboardsPathParameters,
+	GetMetricDashboardsParams,
 	GetMetricHighlights200,
-	GetMetricHighlightsPathParameters,
+	GetMetricHighlightsParams,
 	GetMetricMetadata200,
-	GetMetricMetadataPathParameters,
+	GetMetricMetadataParams,
 	GetMetricsStats200,
 	GetMetricsTreemap200,
-	ListMetrics200,
-	ListMetricsParams,
+	MetricsexplorertypesMetricAttributesRequestDTO,
 	MetricsexplorertypesStatsRequestDTO,
 	MetricsexplorertypesTreemapRequestDTO,
 	MetricsexplorertypesUpdateMetricMetadataRequestDTO,
@@ -46,128 +43,30 @@ type AwaitedInput<T> = PromiseLike<T> | T;
 type Awaited<O> = O extends AwaitedInput<infer T> ? T : never;
 
 /**
- * This endpoint returns a list of distinct metric names within the specified time range
- * @summary List metric names
+ * This endpoint returns associated alerts for a specified metric
+ * @summary Get metric alerts
  */
-export const listMetrics = (
-	params?: ListMetricsParams,
+export const getMetricAlerts = (
+	params: GetMetricAlertsParams,
 	signal?: AbortSignal,
 ) => {
-	return GeneratedAPIInstance<ListMetrics200>({
-		url: `/api/v2/metrics`,
+	return GeneratedAPIInstance<GetMetricAlerts200>({
+		url: `/api/v2/metric/alerts`,
 		method: 'GET',
 		params,
 		signal,
 	});
 };
 
-export const getListMetricsQueryKey = (params?: ListMetricsParams) => {
-	return ['listMetrics', ...(params ? [params] : [])] as const;
-};
-
-export const getListMetricsQueryOptions = <
-	TData = Awaited<ReturnType<typeof listMetrics>>,
-	TError = RenderErrorResponseDTO
->(
-	params?: ListMetricsParams,
-	options?: {
-		query?: UseQueryOptions<
-			Awaited<ReturnType<typeof listMetrics>>,
-			TError,
-			TData
-		>;
-	},
-) => {
-	const { query: queryOptions } = options ?? {};
-
-	const queryKey = queryOptions?.queryKey ?? getListMetricsQueryKey(params);
-
-	const queryFn: QueryFunction<Awaited<ReturnType<typeof listMetrics>>> = ({
-		signal,
-	}) => listMetrics(params, signal);
-
-	return { queryKey, queryFn, ...queryOptions } as UseQueryOptions<
-		Awaited<ReturnType<typeof listMetrics>>,
-		TError,
-		TData
-	> & { queryKey: QueryKey };
-};
-
-export type ListMetricsQueryResult = NonNullable<
-	Awaited<ReturnType<typeof listMetrics>>
->;
-export type ListMetricsQueryError = RenderErrorResponseDTO;
-
-/**
- * @summary List metric names
- */
-
-export function useListMetrics<
-	TData = Awaited<ReturnType<typeof listMetrics>>,
-	TError = RenderErrorResponseDTO
->(
-	params?: ListMetricsParams,
-	options?: {
-		query?: UseQueryOptions<
-			Awaited<ReturnType<typeof listMetrics>>,
-			TError,
-			TData
-		>;
-	},
-): UseQueryResult<TData, TError> & { queryKey: QueryKey } {
-	const queryOptions = getListMetricsQueryOptions(params, options);
-
-	const query = useQuery(queryOptions) as UseQueryResult<TData, TError> & {
-		queryKey: QueryKey;
-	};
-
-	query.queryKey = queryOptions.queryKey;
-
-	return query;
-}
-
-/**
- * @summary List metric names
- */
-export const invalidateListMetrics = async (
-	queryClient: QueryClient,
-	params?: ListMetricsParams,
-	options?: InvalidateOptions,
-): Promise<QueryClient> => {
-	await queryClient.invalidateQueries(
-		{ queryKey: getListMetricsQueryKey(params) },
-		options,
-	);
-
-	return queryClient;
-};
-
-/**
- * This endpoint returns associated alerts for a specified metric
- * @summary Get metric alerts
- */
-export const getMetricAlerts = (
-	{ metricName }: GetMetricAlertsPathParameters,
-	signal?: AbortSignal,
-) => {
-	return GeneratedAPIInstance<GetMetricAlerts200>({
-		url: `/api/v2/metrics/${metricName}/alerts`,
-		method: 'GET',
-		signal,
-	});
-};
-
-export const getGetMetricAlertsQueryKey = ({
-	metricName,
-}: GetMetricAlertsPathParameters) => {
-	return ['getMetricAlerts'] as const;
+export const getGetMetricAlertsQueryKey = (params?: GetMetricAlertsParams) => {
+	return ['getMetricAlerts', ...(params ? [params] : [])] as const;
 };
 
 export const getGetMetricAlertsQueryOptions = <
 	TData = Awaited<ReturnType<typeof getMetricAlerts>>,
 	TError = RenderErrorResponseDTO
 >(
-	{ metricName }: GetMetricAlertsPathParameters,
+	params: GetMetricAlertsParams,
 	options?: {
 		query?: UseQueryOptions<
 			Awaited<ReturnType<typeof getMetricAlerts>>,
@@ -178,19 +77,13 @@ export const getGetMetricAlertsQueryOptions = <
 ) => {
 	const { query: queryOptions } = options ?? {};
 
-	const queryKey =
-		queryOptions?.queryKey ?? getGetMetricAlertsQueryKey({ metricName });
+	const queryKey = queryOptions?.queryKey ?? getGetMetricAlertsQueryKey(params);
 
 	const queryFn: QueryFunction<Awaited<ReturnType<typeof getMetricAlerts>>> = ({
 		signal,
-	}) => getMetricAlerts({ metricName }, signal);
+	}) => getMetricAlerts(params, signal);
 
-	return {
-		queryKey,
-		queryFn,
-		enabled: !!metricName,
-		...queryOptions,
-	} as UseQueryOptions<
+	return { queryKey, queryFn, ...queryOptions } as UseQueryOptions<
 		Awaited<ReturnType<typeof getMetricAlerts>>,
 		TError,
 		TData
@@ -210,7 +103,7 @@ export function useGetMetricAlerts<
 	TData = Awaited<ReturnType<typeof getMetricAlerts>>,
 	TError = RenderErrorResponseDTO
 >(
-	{ metricName }: GetMetricAlertsPathParameters,
+	params: GetMetricAlertsParams,
 	options?: {
 		query?: UseQueryOptions<
 			Awaited<ReturnType<typeof getMetricAlerts>>,
@@ -219,7 +112,7 @@ export function useGetMetricAlerts<
 		>;
 	},
 ): UseQueryResult<TData, TError> & { queryKey: QueryKey } {
-	const queryOptions = getGetMetricAlertsQueryOptions({ metricName }, options);
+	const queryOptions = getGetMetricAlertsQueryOptions(params, options);
 
 	const query = useQuery(queryOptions) as UseQueryResult<TData, TError> & {
 		queryKey: QueryKey;
@@ -235,126 +128,11 @@ export function useGetMetricAlerts<
  */
 export const invalidateGetMetricAlerts = async (
 	queryClient: QueryClient,
-	{ metricName }: GetMetricAlertsPathParameters,
+	params: GetMetricAlertsParams,
 	options?: InvalidateOptions,
 ): Promise<QueryClient> => {
 	await queryClient.invalidateQueries(
-		{ queryKey: getGetMetricAlertsQueryKey({ metricName }) },
-		options,
-	);
-
-	return queryClient;
-};
-
-/**
- * This endpoint returns attribute keys and their unique values for a specified metric
- * @summary Get metric attributes
- */
-export const getMetricAttributes = (
-	{ metricName }: GetMetricAttributesPathParameters,
-	params?: GetMetricAttributesParams,
-	signal?: AbortSignal,
-) => {
-	return GeneratedAPIInstance<GetMetricAttributes200>({
-		url: `/api/v2/metrics/${metricName}/attributes`,
-		method: 'GET',
-		params,
-		signal,
-	});
-};
-
-export const getGetMetricAttributesQueryKey = (
-	{ metricName }: GetMetricAttributesPathParameters,
-	params?: GetMetricAttributesParams,
-) => {
-	return ['getMetricAttributes', ...(params ? [params] : [])] as const;
-};
-
-export const getGetMetricAttributesQueryOptions = <
-	TData = Awaited<ReturnType<typeof getMetricAttributes>>,
-	TError = RenderErrorResponseDTO
->(
-	{ metricName }: GetMetricAttributesPathParameters,
-	params?: GetMetricAttributesParams,
-	options?: {
-		query?: UseQueryOptions<
-			Awaited<ReturnType<typeof getMetricAttributes>>,
-			TError,
-			TData
-		>;
-	},
-) => {
-	const { query: queryOptions } = options ?? {};
-
-	const queryKey =
-		queryOptions?.queryKey ??
-		getGetMetricAttributesQueryKey({ metricName }, params);
-
-	const queryFn: QueryFunction<
-		Awaited<ReturnType<typeof getMetricAttributes>>
-	> = ({ signal }) => getMetricAttributes({ metricName }, params, signal);
-
-	return {
-		queryKey,
-		queryFn,
-		enabled: !!metricName,
-		...queryOptions,
-	} as UseQueryOptions<
-		Awaited<ReturnType<typeof getMetricAttributes>>,
-		TError,
-		TData
-	> & { queryKey: QueryKey };
-};
-
-export type GetMetricAttributesQueryResult = NonNullable<
-	Awaited<ReturnType<typeof getMetricAttributes>>
->;
-export type GetMetricAttributesQueryError = RenderErrorResponseDTO;
-
-/**
- * @summary Get metric attributes
- */
-
-export function useGetMetricAttributes<
-	TData = Awaited<ReturnType<typeof getMetricAttributes>>,
-	TError = RenderErrorResponseDTO
->(
-	{ metricName }: GetMetricAttributesPathParameters,
-	params?: GetMetricAttributesParams,
-	options?: {
-		query?: UseQueryOptions<
-			Awaited<ReturnType<typeof getMetricAttributes>>,
-			TError,
-			TData
-		>;
-	},
-): UseQueryResult<TData, TError> & { queryKey: QueryKey } {
-	const queryOptions = getGetMetricAttributesQueryOptions(
-		{ metricName },
-		params,
-		options,
-	);
-
-	const query = useQuery(queryOptions) as UseQueryResult<TData, TError> & {
-		queryKey: QueryKey;
-	};
-
-	query.queryKey = queryOptions.queryKey;
-
-	return query;
-}
-
-/**
- * @summary Get metric attributes
- */
-export const invalidateGetMetricAttributes = async (
-	queryClient: QueryClient,
-	{ metricName }: GetMetricAttributesPathParameters,
-	params?: GetMetricAttributesParams,
-	options?: InvalidateOptions,
-): Promise<QueryClient> => {
-	await queryClient.invalidateQueries(
-		{ queryKey: getGetMetricAttributesQueryKey({ metricName }, params) },
+		{ queryKey: getGetMetricAlertsQueryKey(params) },
 		options,
 	);
 
@@ -366,27 +144,28 @@ export const invalidateGetMetricAttributes = async (
  * @summary Get metric dashboards
  */
 export const getMetricDashboards = (
-	{ metricName }: GetMetricDashboardsPathParameters,
+	params: GetMetricDashboardsParams,
 	signal?: AbortSignal,
 ) => {
 	return GeneratedAPIInstance<GetMetricDashboards200>({
-		url: `/api/v2/metrics/${metricName}/dashboards`,
+		url: `/api/v2/metric/dashboards`,
 		method: 'GET',
+		params,
 		signal,
 	});
 };
 
-export const getGetMetricDashboardsQueryKey = ({
-	metricName,
-}: GetMetricDashboardsPathParameters) => {
-	return ['getMetricDashboards'] as const;
+export const getGetMetricDashboardsQueryKey = (
+	params?: GetMetricDashboardsParams,
+) => {
+	return ['getMetricDashboards', ...(params ? [params] : [])] as const;
 };
 
 export const getGetMetricDashboardsQueryOptions = <
 	TData = Awaited<ReturnType<typeof getMetricDashboards>>,
 	TError = RenderErrorResponseDTO
 >(
-	{ metricName }: GetMetricDashboardsPathParameters,
+	params: GetMetricDashboardsParams,
 	options?: {
 		query?: UseQueryOptions<
 			Awaited<ReturnType<typeof getMetricDashboards>>,
@@ -398,18 +177,13 @@ export const getGetMetricDashboardsQueryOptions = <
 	const { query: queryOptions } = options ?? {};
 
 	const queryKey =
-		queryOptions?.queryKey ?? getGetMetricDashboardsQueryKey({ metricName });
+		queryOptions?.queryKey ?? getGetMetricDashboardsQueryKey(params);
 
 	const queryFn: QueryFunction<
 		Awaited<ReturnType<typeof getMetricDashboards>>
-	> = ({ signal }) => getMetricDashboards({ metricName }, signal);
+	> = ({ signal }) => getMetricDashboards(params, signal);
 
-	return {
-		queryKey,
-		queryFn,
-		enabled: !!metricName,
-		...queryOptions,
-	} as UseQueryOptions<
+	return { queryKey, queryFn, ...queryOptions } as UseQueryOptions<
 		Awaited<ReturnType<typeof getMetricDashboards>>,
 		TError,
 		TData
@@ -429,7 +203,7 @@ export function useGetMetricDashboards<
 	TData = Awaited<ReturnType<typeof getMetricDashboards>>,
 	TError = RenderErrorResponseDTO
 >(
-	{ metricName }: GetMetricDashboardsPathParameters,
+	params: GetMetricDashboardsParams,
 	options?: {
 		query?: UseQueryOptions<
 			Awaited<ReturnType<typeof getMetricDashboards>>,
@@ -438,10 +212,7 @@ export function useGetMetricDashboards<
 		>;
 	},
 ): UseQueryResult<TData, TError> & { queryKey: QueryKey } {
-	const queryOptions = getGetMetricDashboardsQueryOptions(
-		{ metricName },
-		options,
-	);
+	const queryOptions = getGetMetricDashboardsQueryOptions(params, options);
 
 	const query = useQuery(queryOptions) as UseQueryResult<TData, TError> & {
 		queryKey: QueryKey;
@@ -457,11 +228,11 @@ export function useGetMetricDashboards<
  */
 export const invalidateGetMetricDashboards = async (
 	queryClient: QueryClient,
-	{ metricName }: GetMetricDashboardsPathParameters,
+	params: GetMetricDashboardsParams,
 	options?: InvalidateOptions,
 ): Promise<QueryClient> => {
 	await queryClient.invalidateQueries(
-		{ queryKey: getGetMetricDashboardsQueryKey({ metricName }) },
+		{ queryKey: getGetMetricDashboardsQueryKey(params) },
 		options,
 	);
 
@@ -473,27 +244,28 @@ export const invalidateGetMetricDashboards = async (
  * @summary Get metric highlights
  */
 export const getMetricHighlights = (
-	{ metricName }: GetMetricHighlightsPathParameters,
+	params: GetMetricHighlightsParams,
 	signal?: AbortSignal,
 ) => {
 	return GeneratedAPIInstance<GetMetricHighlights200>({
-		url: `/api/v2/metrics/${metricName}/highlights`,
+		url: `/api/v2/metric/highlights`,
 		method: 'GET',
+		params,
 		signal,
 	});
 };
 
-export const getGetMetricHighlightsQueryKey = ({
-	metricName,
-}: GetMetricHighlightsPathParameters) => {
-	return ['getMetricHighlights'] as const;
+export const getGetMetricHighlightsQueryKey = (
+	params?: GetMetricHighlightsParams,
+) => {
+	return ['getMetricHighlights', ...(params ? [params] : [])] as const;
 };
 
 export const getGetMetricHighlightsQueryOptions = <
 	TData = Awaited<ReturnType<typeof getMetricHighlights>>,
 	TError = RenderErrorResponseDTO
 >(
-	{ metricName }: GetMetricHighlightsPathParameters,
+	params: GetMetricHighlightsParams,
 	options?: {
 		query?: UseQueryOptions<
 			Awaited<ReturnType<typeof getMetricHighlights>>,
@@ -505,18 +277,13 @@ export const getGetMetricHighlightsQueryOptions = <
 	const { query: queryOptions } = options ?? {};
 
 	const queryKey =
-		queryOptions?.queryKey ?? getGetMetricHighlightsQueryKey({ metricName });
+		queryOptions?.queryKey ?? getGetMetricHighlightsQueryKey(params);
 
 	const queryFn: QueryFunction<
 		Awaited<ReturnType<typeof getMetricHighlights>>
-	> = ({ signal }) => getMetricHighlights({ metricName }, signal);
+	> = ({ signal }) => getMetricHighlights(params, signal);
 
-	return {
-		queryKey,
-		queryFn,
-		enabled: !!metricName,
-		...queryOptions,
-	} as UseQueryOptions<
+	return { queryKey, queryFn, ...queryOptions } as UseQueryOptions<
 		Awaited<ReturnType<typeof getMetricHighlights>>,
 		TError,
 		TData
@@ -536,7 +303,7 @@ export function useGetMetricHighlights<
 	TData = Awaited<ReturnType<typeof getMetricHighlights>>,
 	TError = RenderErrorResponseDTO
 >(
-	{ metricName }: GetMetricHighlightsPathParameters,
+	params: GetMetricHighlightsParams,
 	options?: {
 		query?: UseQueryOptions<
 			Awaited<ReturnType<typeof getMetricHighlights>>,
@@ -545,10 +312,7 @@ export function useGetMetricHighlights<
 		>;
 	},
 ): UseQueryResult<TData, TError> & { queryKey: QueryKey } {
-	const queryOptions = getGetMetricHighlightsQueryOptions(
-		{ metricName },
-		options,
-	);
+	const queryOptions = getGetMetricHighlightsQueryOptions(params, options);
 
 	const query = useQuery(queryOptions) as UseQueryResult<TData, TError> & {
 		queryKey: QueryKey;
@@ -564,115 +328,11 @@ export function useGetMetricHighlights<
  */
 export const invalidateGetMetricHighlights = async (
 	queryClient: QueryClient,
-	{ metricName }: GetMetricHighlightsPathParameters,
+	params: GetMetricHighlightsParams,
 	options?: InvalidateOptions,
 ): Promise<QueryClient> => {
 	await queryClient.invalidateQueries(
-		{ queryKey: getGetMetricHighlightsQueryKey({ metricName }) },
-		options,
-	);
-
-	return queryClient;
-};
-
-/**
- * This endpoint returns metadata information like metric description, unit, type, temporality, monotonicity for a specified metric
- * @summary Get metric metadata
- */
-export const getMetricMetadata = (
-	{ metricName }: GetMetricMetadataPathParameters,
-	signal?: AbortSignal,
-) => {
-	return GeneratedAPIInstance<GetMetricMetadata200>({
-		url: `/api/v2/metrics/${metricName}/metadata`,
-		method: 'GET',
-		signal,
-	});
-};
-
-export const getGetMetricMetadataQueryKey = ({
-	metricName,
-}: GetMetricMetadataPathParameters) => {
-	return ['getMetricMetadata'] as const;
-};
-
-export const getGetMetricMetadataQueryOptions = <
-	TData = Awaited<ReturnType<typeof getMetricMetadata>>,
-	TError = RenderErrorResponseDTO
->(
-	{ metricName }: GetMetricMetadataPathParameters,
-	options?: {
-		query?: UseQueryOptions<
-			Awaited<ReturnType<typeof getMetricMetadata>>,
-			TError,
-			TData
-		>;
-	},
-) => {
-	const { query: queryOptions } = options ?? {};
-
-	const queryKey =
-		queryOptions?.queryKey ?? getGetMetricMetadataQueryKey({ metricName });
-
-	const queryFn: QueryFunction<
-		Awaited<ReturnType<typeof getMetricMetadata>>
-	> = ({ signal }) => getMetricMetadata({ metricName }, signal);
-
-	return {
-		queryKey,
-		queryFn,
-		enabled: !!metricName,
-		...queryOptions,
-	} as UseQueryOptions<
-		Awaited<ReturnType<typeof getMetricMetadata>>,
-		TError,
-		TData
-	> & { queryKey: QueryKey };
-};
-
-export type GetMetricMetadataQueryResult = NonNullable<
-	Awaited<ReturnType<typeof getMetricMetadata>>
->;
-export type GetMetricMetadataQueryError = RenderErrorResponseDTO;
-
-/**
- * @summary Get metric metadata
- */
-
-export function useGetMetricMetadata<
-	TData = Awaited<ReturnType<typeof getMetricMetadata>>,
-	TError = RenderErrorResponseDTO
->(
-	{ metricName }: GetMetricMetadataPathParameters,
-	options?: {
-		query?: UseQueryOptions<
-			Awaited<ReturnType<typeof getMetricMetadata>>,
-			TError,
-			TData
-		>;
-	},
-): UseQueryResult<TData, TError> & { queryKey: QueryKey } {
-	const queryOptions = getGetMetricMetadataQueryOptions({ metricName }, options);
-
-	const query = useQuery(queryOptions) as UseQueryResult<TData, TError> & {
-		queryKey: QueryKey;
-	};
-
-	query.queryKey = queryOptions.queryKey;
-
-	return query;
-}
-
-/**
- * @summary Get metric metadata
- */
-export const invalidateGetMetricMetadata = async (
-	queryClient: QueryClient,
-	{ metricName }: GetMetricMetadataPathParameters,
-	options?: InvalidateOptions,
-): Promise<QueryClient> => {
-	await queryClient.invalidateQueries(
-		{ queryKey: getGetMetricMetadataQueryKey({ metricName }) },
+		{ queryKey: getGetMetricHighlightsQueryKey(params) },
 		options,
 	);
 
@@ -778,6 +438,189 @@ export const useUpdateMetricMetadata = <
 
 	return useMutation(mutationOptions);
 };
+/**
+ * This endpoint returns attribute keys and their unique values for a specified metric
+ * @summary Get metric attributes
+ */
+export const getMetricAttributes = (
+	metricsexplorertypesMetricAttributesRequestDTO: MetricsexplorertypesMetricAttributesRequestDTO,
+	signal?: AbortSignal,
+) => {
+	return GeneratedAPIInstance<GetMetricAttributes200>({
+		url: `/api/v2/metrics/attributes`,
+		method: 'POST',
+		headers: { 'Content-Type': 'application/json' },
+		data: metricsexplorertypesMetricAttributesRequestDTO,
+		signal,
+	});
+};
+
+export const getGetMetricAttributesMutationOptions = <
+	TError = RenderErrorResponseDTO,
+	TContext = unknown
+>(options?: {
+	mutation?: UseMutationOptions<
+		Awaited<ReturnType<typeof getMetricAttributes>>,
+		TError,
+		{ data: MetricsexplorertypesMetricAttributesRequestDTO },
+		TContext
+	>;
+}): UseMutationOptions<
+	Awaited<ReturnType<typeof getMetricAttributes>>,
+	TError,
+	{ data: MetricsexplorertypesMetricAttributesRequestDTO },
+	TContext
+> => {
+	const mutationKey = ['getMetricAttributes'];
+	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 getMetricAttributes>>,
+		{ data: MetricsexplorertypesMetricAttributesRequestDTO }
+	> = (props) => {
+		const { data } = props ?? {};
+
+		return getMetricAttributes(data);
+	};
+
+	return { mutationFn, ...mutationOptions };
+};
+
+export type GetMetricAttributesMutationResult = NonNullable<
+	Awaited<ReturnType<typeof getMetricAttributes>>
+>;
+export type GetMetricAttributesMutationBody = MetricsexplorertypesMetricAttributesRequestDTO;
+export type GetMetricAttributesMutationError = RenderErrorResponseDTO;
+
+/**
+ * @summary Get metric attributes
+ */
+export const useGetMetricAttributes = <
+	TError = RenderErrorResponseDTO,
+	TContext = unknown
+>(options?: {
+	mutation?: UseMutationOptions<
+		Awaited<ReturnType<typeof getMetricAttributes>>,
+		TError,
+		{ data: MetricsexplorertypesMetricAttributesRequestDTO },
+		TContext
+	>;
+}): UseMutationResult<
+	Awaited<ReturnType<typeof getMetricAttributes>>,
+	TError,
+	{ data: MetricsexplorertypesMetricAttributesRequestDTO },
+	TContext
+> => {
+	const mutationOptions = getGetMetricAttributesMutationOptions(options);
+
+	return useMutation(mutationOptions);
+};
+/**
+ * This endpoint returns metadata information like metric description, unit, type, temporality, monotonicity for a specified metric
+ * @summary Get metric metadata
+ */
+export const getMetricMetadata = (
+	params: GetMetricMetadataParams,
+	signal?: AbortSignal,
+) => {
+	return GeneratedAPIInstance<GetMetricMetadata200>({
+		url: `/api/v2/metrics/metadata`,
+		method: 'GET',
+		params,
+		signal,
+	});
+};
+
+export const getGetMetricMetadataQueryKey = (
+	params?: GetMetricMetadataParams,
+) => {
+	return ['getMetricMetadata', ...(params ? [params] : [])] as const;
+};
+
+export const getGetMetricMetadataQueryOptions = <
+	TData = Awaited<ReturnType<typeof getMetricMetadata>>,
+	TError = RenderErrorResponseDTO
+>(
+	params: GetMetricMetadataParams,
+	options?: {
+		query?: UseQueryOptions<
+			Awaited<ReturnType<typeof getMetricMetadata>>,
+			TError,
+			TData
+		>;
+	},
+) => {
+	const { query: queryOptions } = options ?? {};
+
+	const queryKey =
+		queryOptions?.queryKey ?? getGetMetricMetadataQueryKey(params);
+
+	const queryFn: QueryFunction<
+		Awaited<ReturnType<typeof getMetricMetadata>>
+	> = ({ signal }) => getMetricMetadata(params, signal);
+
+	return { queryKey, queryFn, ...queryOptions } as UseQueryOptions<
+		Awaited<ReturnType<typeof getMetricMetadata>>,
+		TError,
+		TData
+	> & { queryKey: QueryKey };
+};
+
+export type GetMetricMetadataQueryResult = NonNullable<
+	Awaited<ReturnType<typeof getMetricMetadata>>
+>;
+export type GetMetricMetadataQueryError = RenderErrorResponseDTO;
+
+/**
+ * @summary Get metric metadata
+ */
+
+export function useGetMetricMetadata<
+	TData = Awaited<ReturnType<typeof getMetricMetadata>>,
+	TError = RenderErrorResponseDTO
+>(
+	params: GetMetricMetadataParams,
+	options?: {
+		query?: UseQueryOptions<
+			Awaited<ReturnType<typeof getMetricMetadata>>,
+			TError,
+			TData
+		>;
+	},
+): UseQueryResult<TData, TError> & { queryKey: QueryKey } {
+	const queryOptions = getGetMetricMetadataQueryOptions(params, options);
+
+	const query = useQuery(queryOptions) as UseQueryResult<TData, TError> & {
+		queryKey: QueryKey;
+	};
+
+	query.queryKey = queryOptions.queryKey;
+
+	return query;
+}
+
+/**
+ * @summary Get metric metadata
+ */
+export const invalidateGetMetricMetadata = async (
+	queryClient: QueryClient,
+	params: GetMetricMetadataParams,
+	options?: InvalidateOptions,
+): Promise<QueryClient> => {
+	await queryClient.invalidateQueries(
+		{ queryKey: getGetMetricMetadataQueryKey(params) },
+		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/query/index.ts

@@ -1,107 +0,0 @@
-/**
- * ! Do not edit manually
- * * The file has been auto-generated using Orval for SigNoz
- * * regenerate with 'yarn generate:api'
- * SigNoz
- */
-import type {
-	MutationFunction,
-	UseMutationOptions,
-	UseMutationResult,
-} from 'react-query';
-import { useMutation } from 'react-query';
-
-import { GeneratedAPIInstance } from '../../../index';
-import type {
-	Querybuildertypesv5QueryRangeRequestDTO,
-	QueryRangeV5200,
-	RenderErrorResponseDTO,
-} from '../sigNoz.schemas';
-
-type AwaitedInput<T> = PromiseLike<T> | T;
-
-type Awaited<O> = O extends AwaitedInput<infer T> ? T : never;
-
-/**
- * Execute a composite query over a time range. Supports builder queries (traces, logs, metrics), formulas, trace operators, PromQL, and ClickHouse SQL.
- * @summary Query range
- */
-export const queryRangeV5 = (
-	querybuildertypesv5QueryRangeRequestDTO: Querybuildertypesv5QueryRangeRequestDTO,
-	signal?: AbortSignal,
-) => {
-	return GeneratedAPIInstance<QueryRangeV5200>({
-		url: `/api/v5/query_range`,
-		method: 'POST',
-		headers: { 'Content-Type': 'application/json' },
-		data: querybuildertypesv5QueryRangeRequestDTO,
-		signal,
-	});
-};
-
-export const getQueryRangeV5MutationOptions = <
-	TError = RenderErrorResponseDTO,
-	TContext = unknown
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof queryRangeV5>>,
-		TError,
-		{ data: Querybuildertypesv5QueryRangeRequestDTO },
-		TContext
-	>;
-}): UseMutationOptions<
-	Awaited<ReturnType<typeof queryRangeV5>>,
-	TError,
-	{ data: Querybuildertypesv5QueryRangeRequestDTO },
-	TContext
-> => {
-	const mutationKey = ['queryRangeV5'];
-	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 queryRangeV5>>,
-		{ data: Querybuildertypesv5QueryRangeRequestDTO }
-	> = (props) => {
-		const { data } = props ?? {};
-
-		return queryRangeV5(data);
-	};
-
-	return { mutationFn, ...mutationOptions };
-};
-
-export type QueryRangeV5MutationResult = NonNullable<
-	Awaited<ReturnType<typeof queryRangeV5>>
->;
-export type QueryRangeV5MutationBody = Querybuildertypesv5QueryRangeRequestDTO;
-export type QueryRangeV5MutationError = RenderErrorResponseDTO;
-
-/**
- * @summary Query range
- */
-export const useQueryRangeV5 = <
-	TError = RenderErrorResponseDTO,
-	TContext = unknown
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof queryRangeV5>>,
-		TError,
-		{ data: Querybuildertypesv5QueryRangeRequestDTO },
-		TContext
-	>;
-}): UseMutationResult<
-	Awaited<ReturnType<typeof queryRangeV5>>,
-	TError,
-	{ data: Querybuildertypesv5QueryRangeRequestDTO },
-	TContext
-> => {
-	const mutationOptions = getQueryRangeV5MutationOptions(options);
-
-	return useMutation(mutationOptions);
-};

frontend/src/api/metricsExplorer/v2/getMetricMetadata.ts

@@ -11,10 +11,13 @@ export const getMetricMetadata = async (
 ): Promise<SuccessResponseV2<MetricMetadataResponse> | ErrorResponseV2> => {
 	try {
 		const encodedMetricName = encodeURIComponent(metricName);
-		const response = await axios.get(`/metrics/${encodedMetricName}/metadata`, {
-			signal,
-			headers,
-		});
+		const response = await axios.get(
+			`/metrics/metadata?metricName=${encodedMetricName}`,
+			{
+				signal,
+				headers,
+			},
+		);
 
 		return {
 			httpStatusCode: response.status,

frontend/src/api/v1/domains/id/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 deleteDomain = async (id: string): Promise<SuccessResponseV2<null>> => {
+	try {
+		const response = await axios.delete<null>(`/domains/${id}`);
+
+		return {
+			httpStatusCode: response.status,
+			data: null,
+		};
+	} catch (error) {
+		ErrorResponseHandlerV2(error as AxiosError<ErrorV2Resp>);
+	}
+};
+
+export default deleteDomain;

frontend/src/api/v1/domains/id/put.ts

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

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

@@ -0,0 +1,24 @@
+import axios from 'api';
+import { ErrorResponseHandlerV2 } from 'api/ErrorResponseHandlerV2';
+import { AxiosError } from 'axios';
+import { ErrorV2Resp, RawSuccessResponse, SuccessResponseV2 } from 'types/api';
+import { GettableAuthDomain } from 'types/api/v1/domains/list';
+
+const listAllDomain = async (): Promise<
+	SuccessResponseV2<GettableAuthDomain[]>
+> => {
+	try {
+		const response = await axios.get<RawSuccessResponse<GettableAuthDomain[]>>(
+			`/domains`,
+		);
+
+		return {
+			httpStatusCode: response.status,
+			data: response.data.data,
+		};
+	} catch (error) {
+		ErrorResponseHandlerV2(error as AxiosError<ErrorV2Resp>);
+	}
+};
+
+export default listAllDomain;

frontend/src/api/v1/domains/post.ts

@@ -0,0 +1,26 @@
+import axios from 'api';
+import { ErrorResponseHandlerV2 } from 'api/ErrorResponseHandlerV2';
+import { AxiosError } from 'axios';
+import { ErrorV2Resp, RawSuccessResponse, SuccessResponseV2 } from 'types/api';
+import { GettableAuthDomain } from 'types/api/v1/domains/list';
+import { PostableAuthDomain } from 'types/api/v1/domains/post';
+
+const post = async (
+	props: PostableAuthDomain,
+): Promise<SuccessResponseV2<GettableAuthDomain>> => {
+	try {
+		const response = await axios.post<RawSuccessResponse<GettableAuthDomain>>(
+			`/domains`,
+			props,
+		);
+
+		return {
+			httpStatusCode: response.status,
+			data: response.data.data,
+		};
+	} catch (error) {
+		ErrorResponseHandlerV2(error as AxiosError<ErrorV2Resp>);
+	}
+};
+
+export default post;

frontend/src/auto-import-registry.d.ts

@@ -24,6 +24,5 @@ import '@signozhq/popover';
 import '@signozhq/radio-group';
 import '@signozhq/resizable';
 import '@signozhq/sonner';
-import '@signozhq/switch';
 import '@signozhq/table';
 import '@signozhq/tooltip';

frontend/src/constants/routes.ts

@@ -55,7 +55,6 @@ const ROUTES = {
 	LOGS_INDEX_FIELDS: '/logs-explorer/index-fields',
 	TRACE_EXPLORER: '/trace-explorer',
 	BILLING: '/settings/billing',
-	ROLES_SETTINGS: '/settings/roles',
 	SUPPORT: '/support',
 	LOGS_SAVE_VIEWS: '/logs/saved-views',
 	TRACES_SAVE_VIEWS: '/traces/saved-views',

frontend/src/container/ApiMonitoring/Explorer/Domains/DomainDetails/constants.ts

@@ -14,6 +14,6 @@ export const VIEW_TYPES = {
 export const SPAN_ATTRIBUTES = {
 	URL_PATH: 'http.url',
 	RESPONSE_STATUS_CODE: 'response_status_code',
-	SERVER_NAME: 'http_host',
+	SERVER_NAME: 'net.peer.name',
 	SERVER_PORT: 'net.peer.port',
 } as const;

frontend/src/container/ApiMonitoring/__tests__/TopErrors.test.tsx

@@ -4,7 +4,6 @@ import { rest, server } from 'mocks-server/server';
 import { fireEvent, render, screen, waitFor, within } from 'tests/test-utils';
 import { DataSource } from 'types/common/queryBuilder';
 
-import { SPAN_ATTRIBUTES } from '../Explorer/Domains/DomainDetails/constants';
 import TopErrors from '../Explorer/Domains/DomainDetails/TopErrors';
 import { getTopErrorsQueryPayload } from '../utils';
 
@@ -216,7 +215,7 @@ describe('TopErrors', () => {
 					value: 'true',
 				}),
 				expect.objectContaining({
-					key: expect.objectContaining({ key: SPAN_ATTRIBUTES.SERVER_NAME }),
+					key: expect.objectContaining({ key: 'net.peer.name' }),
 					op: '=',
 					value: 'test-domain',
 				}),

frontend/src/container/ApiMonitoring/utils.tsx

@@ -638,7 +638,7 @@ export const getEndPointsQueryPayload = (
 										key: {
 											dataType: DataTypes.String,
 											key: SPAN_ATTRIBUTES.SERVER_NAME,
-											type: '',
+											type: 'tag',
 										},
 										op: '=',
 										value: domainName,
@@ -685,7 +685,7 @@ export const getEndPointsQueryPayload = (
 										key: {
 											dataType: DataTypes.String,
 											key: SPAN_ATTRIBUTES.SERVER_NAME,
-											type: '',
+											type: 'tag',
 										},
 										op: '=',
 										value: domainName,
@@ -733,7 +733,7 @@ export const getEndPointsQueryPayload = (
 										key: {
 											dataType: DataTypes.String,
 											key: SPAN_ATTRIBUTES.SERVER_NAME,
-											type: '',
+											type: 'tag',
 										},
 										op: '=',
 										value: domainName,
@@ -780,7 +780,7 @@ export const getEndPointsQueryPayload = (
 										key: {
 											dataType: DataTypes.String,
 											key: SPAN_ATTRIBUTES.SERVER_NAME,
-											type: '',
+											type: 'tag',
 										},
 										op: '=',
 										value: domainName,
@@ -1302,7 +1302,7 @@ export const getTopErrorsCoRelationQueryFilters = (
 		{
 			id: 'e8a043b7',
 			key: {
-				key: SPAN_ATTRIBUTES.SERVER_NAME,
+				key: 'net.peer.name',
 				dataType: DataTypes.String,
 				type: '',
 			},
@@ -2198,7 +2198,7 @@ export const getEndPointZeroStateQueryPayload = (
 									key: {
 										key: SPAN_ATTRIBUTES.SERVER_NAME,
 										dataType: DataTypes.String,
-										type: '',
+										type: 'tag',
 									},
 									op: '=',
 									value: domainName,
@@ -2793,7 +2793,7 @@ export const getStatusCodeBarChartWidgetData = (
 								key: {
 									dataType: DataTypes.String,
 									key: SPAN_ATTRIBUTES.SERVER_NAME,
-									type: '',
+									type: 'tag',
 								},
 								op: '=',
 								value: domainName,

frontend/src/container/DashboardContainer/DashboardVariablesSelection/DashboardVariableSelection.styles.scss

@@ -50,10 +50,6 @@
 	}
 
 	.variable-select {
-		.ant-select-selector {
-			overflow-y: hidden !important;
-		}
-
 		.ant-select-item {
 			display: flex;
 			align-items: center;

frontend/src/container/DashboardContainer/visualization/panels/BarPanel/utils.ts

@@ -1,4 +1,3 @@
-import { ExecStats } from 'api/v5/v5';
 import { Timezone } from 'components/CustomTimePicker/timezoneUtils';
 import { PANEL_TYPES } from 'constants/queryBuilder';
 import { getInitialStackedBands } from 'container/DashboardContainer/visualization/charts/utils/stackSeriesUtils';
@@ -55,13 +54,6 @@ export function prepareBarPanelConfig({
 	minTimeScale?: number;
 	maxTimeScale?: number;
 }): UPlotConfigBuilder {
-	const stepIntervals: ExecStats['stepIntervals'] = get(
-		apiResponse,
-		'data.newResult.meta.stepIntervals',
-		{},
-	);
-	const minStepInterval = Math.min(...Object.values(stepIntervals));
-
 	const builder = buildBaseConfig({
 		widget,
 		isDarkMode,
@@ -73,7 +65,12 @@ export function prepareBarPanelConfig({
 		panelType: PANEL_TYPES.BAR,
 		minTimeScale,
 		maxTimeScale,
-		stepInterval: minStepInterval,
+	});
+
+	builder.setCursor({
+		focus: {
+			prox: 1e3,
+		},
 	});
 
 	if (widget.stackedBarChart) {
@@ -81,6 +78,12 @@ export function prepareBarPanelConfig({
 		builder.setBands(getInitialStackedBands(seriesCount));
 	}
 
+	const stepIntervals: Record<string, number> = get(
+		apiResponse,
+		'data.newResult.meta.stepIntervals',
+		{},
+	);
+
 	const seriesList: QueryData[] = apiResponse?.data?.result || [];
 	seriesList.forEach((series) => {
 		const baseLabelName = getLabelName(

frontend/src/container/DashboardContainer/visualization/panels/TimeSeriesPanel/__tests__/utils.test.ts

@@ -1,325 +0,0 @@
-import { Widgets } from 'types/api/dashboard/getAll';
-import {
-	MetricRangePayloadProps,
-	MetricRangePayloadV3,
-} from 'types/api/metrics/getQueryRange';
-import { Query } from 'types/api/queryBuilder/queryBuilderData';
-
-import { PanelMode } from '../../types';
-import { prepareChartData, prepareUPlotConfig } from '../utils';
-
-jest.mock(
-	'container/DashboardContainer/visualization/panels/utils/legendVisibilityUtils',
-	() => ({
-		getStoredSeriesVisibility: jest.fn(),
-	}),
-);
-
-jest.mock('lib/uPlotLib/plugins/onClickPlugin', () => ({
-	__esModule: true,
-	default: jest.fn().mockReturnValue({ name: 'onClickPlugin' }),
-}));
-
-jest.mock('lib/dashboard/getQueryResults', () => ({
-	getLegend: jest.fn(
-		(_queryData: unknown, _query: unknown, labelName: string) =>
-			`legend-${labelName}`,
-	),
-}));
-
-jest.mock('lib/getLabelName', () => ({
-	__esModule: true,
-	default: jest.fn(
-		(_metric: unknown, _queryName: string, _legend: string) => 'baseLabel',
-	),
-}));
-
-const getLegendMock = jest.requireMock('lib/dashboard/getQueryResults')
-	.getLegend as jest.Mock;
-const getLabelNameMock = jest.requireMock('lib/getLabelName')
-	.default as jest.Mock;
-
-const createApiResponse = (
-	result: MetricRangePayloadProps['data']['result'] = [],
-): MetricRangePayloadProps => ({
-	data: {
-		result,
-		resultType: 'matrix',
-		newResult: (null as unknown) as MetricRangePayloadV3,
-	},
-});
-
-const createWidget = (overrides: Partial<Widgets> = {}): Widgets =>
-	({
-		id: 'widget-1',
-		yAxisUnit: 'ms',
-		isLogScale: false,
-		thresholds: [],
-		customLegendColors: {},
-		...overrides,
-	} as Widgets);
-
-const defaultTimezone = {
-	name: 'UTC',
-	value: 'UTC',
-	offset: 'UTC',
-	searchIndex: 'UTC',
-};
-
-describe('TimeSeriesPanel utils', () => {
-	beforeEach(() => {
-		jest.clearAllMocks();
-		getLabelNameMock.mockReturnValue('baseLabel');
-		getLegendMock.mockImplementation(
-			(_queryData: unknown, _query: unknown, labelName: string) =>
-				`legend-${labelName}`,
-		);
-	});
-
-	describe('prepareChartData', () => {
-		it('returns aligned data with timestamps and empty series when result is empty', () => {
-			const apiResponse = createApiResponse([]);
-
-			const data = prepareChartData(apiResponse);
-
-			expect(data).toHaveLength(1);
-			expect(data[0]).toEqual([]);
-		});
-
-		it('returns timestamps and one series of y values for single series', () => {
-			const apiResponse = createApiResponse([
-				{
-					metric: {},
-					queryName: 'Q',
-					legend: 'Series A',
-					values: [
-						[1000, '10'],
-						[2000, '20'],
-					],
-				} as MetricRangePayloadProps['data']['result'][0],
-			]);
-
-			const data = prepareChartData(apiResponse);
-
-			expect(data).toHaveLength(2);
-			expect(data[0]).toEqual([1000, 2000]);
-			expect(data[1]).toEqual([10, 20]);
-		});
-
-		it('merges timestamps and fills missing values with null for multiple series', () => {
-			const apiResponse = createApiResponse([
-				{
-					metric: {},
-					queryName: 'Q1',
-					values: [
-						[1000, '1'],
-						[3000, '3'],
-					],
-				} as MetricRangePayloadProps['data']['result'][0],
-				{
-					metric: {},
-					queryName: 'Q2',
-					values: [
-						[1000, '10'],
-						[2000, '20'],
-					],
-				} as MetricRangePayloadProps['data']['result'][0],
-			]);
-
-			const data = prepareChartData(apiResponse);
-
-			expect(data[0]).toEqual([1000, 2000, 3000]);
-			// First series: 1, null, 3
-			expect(data[1]).toEqual([1, null, 3]);
-			// Second series: 10, 20, null
-			expect(data[2]).toEqual([10, 20, null]);
-		});
-	});
-
-	describe('prepareUPlotConfig', () => {
-		const baseParams = {
-			widget: createWidget(),
-			isDarkMode: true,
-			currentQuery: {} as Query,
-			onClick: jest.fn(),
-			onDragSelect: jest.fn(),
-			apiResponse: createApiResponse(),
-			timezone: defaultTimezone,
-			panelMode: PanelMode.DASHBOARD_VIEW,
-		};
-
-		it('adds no series when apiResponse has empty result', () => {
-			const builder = prepareUPlotConfig(baseParams);
-
-			const config = builder.getConfig();
-			// Base series (timestamp) only
-			expect(config.series).toHaveLength(1);
-		});
-
-		it('adds one series per result item with label from getLabelName when no currentQuery', () => {
-			getLegendMock.mockReset();
-			const apiResponse = createApiResponse([
-				{
-					metric: { __name__: 'cpu' },
-					queryName: 'Q1',
-					legend: 'CPU',
-					values: [
-						[1000, '1'],
-						[2000, '2'],
-					],
-				} as MetricRangePayloadProps['data']['result'][0],
-			]);
-
-			const builder = prepareUPlotConfig({
-				...baseParams,
-				apiResponse,
-				currentQuery: (null as unknown) as Query,
-			});
-
-			expect(getLabelNameMock).toHaveBeenCalled();
-			expect(getLegendMock).not.toHaveBeenCalled();
-
-			const config = builder.getConfig();
-			expect(config.series).toHaveLength(2);
-			expect(config.series?.[1]).toMatchObject({
-				label: 'baseLabel',
-				scale: 'y',
-			});
-		});
-
-		it('uses getLegend for label when currentQuery is provided', () => {
-			const apiResponse = createApiResponse([
-				{
-					metric: {},
-					queryName: 'Q1',
-					legend: 'L1',
-					values: [[1000, '1']],
-				} as MetricRangePayloadProps['data']['result'][0],
-			]);
-
-			prepareUPlotConfig({
-				...baseParams,
-				apiResponse,
-				currentQuery: {} as Query,
-			});
-
-			expect(getLegendMock).toHaveBeenCalledWith(
-				{
-					legend: 'L1',
-					metric: {},
-					queryName: 'Q1',
-					values: [[1000, '1']],
-				},
-				{},
-				'baseLabel',
-			);
-
-			const config = prepareUPlotConfig({
-				...baseParams,
-				apiResponse,
-				currentQuery: {} as Query,
-			}).getConfig();
-			expect(config.series?.[1]).toMatchObject({
-				label: 'legend-baseLabel',
-			});
-		});
-
-		it('uses DrawStyle.Line and VisibilityMode.Never when series has multiple valid points', () => {
-			const apiResponse = createApiResponse([
-				{
-					metric: {},
-					queryName: 'Q',
-					values: [
-						[1000, '1'],
-						[2000, '2'],
-					],
-				} as MetricRangePayloadProps['data']['result'][0],
-			]);
-
-			const builder = prepareUPlotConfig({ ...baseParams, apiResponse });
-			const config = builder.getConfig();
-			const series = config.series?.[1];
-
-			expect(config.series).toHaveLength(2);
-			// Line style and points never for multi-point series (checked via builder API)
-			const legendItems = builder.getLegendItems();
-			expect(Object.keys(legendItems)).toHaveLength(1);
-			// multi-point series → points hidden
-			expect(series).toBeDefined();
-			expect(series!.points?.show).toBe(false);
-		});
-
-		it('uses DrawStyle.Points and shows points when series has only one valid point', () => {
-			const apiResponse = createApiResponse([
-				{
-					metric: {},
-					queryName: 'Q',
-					values: [
-						[1000, '1'],
-						[2000, 'NaN'],
-						[3000, 'invalid'],
-					],
-				} as MetricRangePayloadProps['data']['result'][0],
-			]);
-
-			const builder = prepareUPlotConfig({ ...baseParams, apiResponse });
-			const config = builder.getConfig();
-
-			expect(config.series).toHaveLength(2);
-			const seriesConfig = config.series?.[1];
-			expect(seriesConfig).toBeDefined();
-			// Single valid point -> Points draw style (asserted via series config)
-			expect(seriesConfig).toMatchObject({
-				scale: 'y',
-				spanGaps: true,
-			});
-			// single-point series → points shown
-			expect(seriesConfig).toBeDefined();
-			expect(seriesConfig!.points?.show).toBe(true);
-		});
-
-		it('uses widget customLegendColors to set series stroke color', () => {
-			const widget = createWidget({
-				customLegendColors: { 'legend-baseLabel': '#ff0000' },
-			});
-			const apiResponse = createApiResponse([
-				{
-					metric: {},
-					queryName: 'Q',
-					values: [[1000, '1']],
-				} as MetricRangePayloadProps['data']['result'][0],
-			]);
-
-			const builder = prepareUPlotConfig({
-				...baseParams,
-				widget,
-				apiResponse,
-			});
-
-			const config = builder.getConfig();
-			const seriesConfig = config.series?.[1];
-			expect(seriesConfig).toBeDefined();
-			expect(seriesConfig!.stroke).toBe('#ff0000');
-		});
-
-		it('adds multiple series when result has multiple items', () => {
-			const apiResponse = createApiResponse([
-				{
-					metric: {},
-					queryName: 'Q1',
-					values: [[1000, '1']],
-				} as MetricRangePayloadProps['data']['result'][0],
-				{
-					metric: {},
-					queryName: 'Q2',
-					values: [[1000, '2']],
-				} as MetricRangePayloadProps['data']['result'][0],
-			]);
-
-			const builder = prepareUPlotConfig({ ...baseParams, apiResponse });
-			const config = builder.getConfig();
-
-			expect(config.series).toHaveLength(3);
-		});
-	});
-});

frontend/src/container/DashboardContainer/visualization/panels/TimeSeriesPanel/utils.ts

@@ -1,4 +1,3 @@
-import { ExecStats } from 'api/v5/v5';
 import { Timezone } from 'components/CustomTimePicker/timezoneUtils';
 import { PANEL_TYPES } from 'constants/queryBuilder';
 import {
@@ -15,12 +14,9 @@ import {
 	VisibilityMode,
 } from 'lib/uPlotV2/config/types';
 import { UPlotConfigBuilder } from 'lib/uPlotV2/config/UPlotConfigBuilder';
-import { isInvalidPlotValue } from 'lib/uPlotV2/utils/dataUtils';
-import get from 'lodash-es/get';
 import { Widgets } from 'types/api/dashboard/getAll';
 import { MetricRangePayloadProps } from 'types/api/metrics/getQueryRange';
 import { Query } from 'types/api/queryBuilder/queryBuilderData';
-import { QueryData } from 'types/api/widgets/getQuery';
 
 import { PanelMode } from '../types';
 import { buildBaseConfig } from '../utils/baseConfigBuilder';
@@ -35,22 +31,6 @@ export const prepareChartData = (
 	return [timestampArr, ...yAxisValuesArr];
 };
 
-function hasSingleVisiblePointForSeries(series: QueryData): boolean {
-	const rawValues = series.values ?? [];
-	let validPointCount = 0;
-
-	for (const [, rawValue] of rawValues) {
-		if (!isInvalidPlotValue(rawValue)) {
-			validPointCount += 1;
-			if (validPointCount > 1) {
-				return false;
-			}
-		}
-	}
-
-	return true;
-}
-
 export const prepareUPlotConfig = ({
 	widget,
 	isDarkMode,
@@ -74,13 +54,6 @@ export const prepareUPlotConfig = ({
 	minTimeScale?: number;
 	maxTimeScale?: number;
 }): UPlotConfigBuilder => {
-	const stepIntervals: ExecStats['stepIntervals'] = get(
-		apiResponse,
-		'data.newResult.meta.stepIntervals',
-		{},
-	);
-	const minStepInterval = Math.min(...Object.values(stepIntervals));
-
 	const builder = buildBaseConfig({
 		widget,
 		isDarkMode,
@@ -92,11 +65,9 @@ export const prepareUPlotConfig = ({
 		panelType: PANEL_TYPES.TIME_SERIES,
 		minTimeScale,
 		maxTimeScale,
-		stepInterval: minStepInterval,
 	});
 
 	apiResponse.data?.result?.forEach((series) => {
-		const hasSingleValidPoint = hasSingleVisiblePointForSeries(series);
 		const baseLabelName = getLabelName(
 			series.metric,
 			series.queryName || '', // query
@@ -109,15 +80,13 @@ export const prepareUPlotConfig = ({
 
 		builder.addSeries({
 			scaleKey: 'y',
-			drawStyle: hasSingleValidPoint ? DrawStyle.Points : DrawStyle.Line,
+			drawStyle: DrawStyle.Line,
 			label: label,
 			colorMapping: widget.customLegendColors ?? {},
 			spanGaps: true,
 			lineStyle: LineStyle.Solid,
 			lineInterpolation: LineInterpolation.Spline,
-			showPoints: hasSingleValidPoint
-				? VisibilityMode.Always
-				: VisibilityMode.Never,
+			showPoints: VisibilityMode.Never,
 			pointSize: 5,
 			isDarkMode,
 			panelType: PANEL_TYPES.TIME_SERIES,

frontend/src/container/DashboardContainer/visualization/panels/utils/__tests__/baseConfigBuilder.test.ts

@@ -1,233 +0,0 @@
-import { PANEL_TYPES } from 'constants/queryBuilder';
-import { STEP_INTERVAL_MULTIPLIER } from 'lib/uPlotV2/constants';
-import { Widgets } from 'types/api/dashboard/getAll';
-import { MetricRangePayloadProps } from 'types/api/metrics/getQueryRange';
-import uPlot from 'uplot';
-
-import { PanelMode } from '../../types';
-import { buildBaseConfig } from '../baseConfigBuilder';
-
-jest.mock(
-	'container/DashboardContainer/visualization/panels/utils/legendVisibilityUtils',
-	() => ({
-		getStoredSeriesVisibility: jest.fn(),
-	}),
-);
-
-jest.mock('lib/uPlotV2/utils', () => ({
-	calculateWidthBasedOnStepInterval: jest.fn(),
-}));
-
-const calculateWidthBasedOnStepIntervalMock = jest.requireMock(
-	'lib/uPlotV2/utils',
-).calculateWidthBasedOnStepInterval as jest.Mock;
-
-jest.mock('lib/uPlotLib/plugins/onClickPlugin', () => ({
-	__esModule: true,
-	default: jest.fn().mockReturnValue({ name: 'onClickPlugin' }),
-}));
-
-const createWidget = (overrides: Partial<Widgets> = {}): Widgets =>
-	({
-		id: 'widget-1',
-		yAxisUnit: 'ms',
-		isLogScale: false,
-		softMin: undefined,
-		softMax: undefined,
-		thresholds: [],
-		...overrides,
-	} as Widgets);
-
-const createApiResponse = (
-	overrides: Partial<MetricRangePayloadProps> = {},
-): MetricRangePayloadProps =>
-	({
-		data: { result: [], resultType: 'matrix', newResult: null },
-		...overrides,
-	} as MetricRangePayloadProps);
-
-const baseProps = {
-	widget: createWidget(),
-	apiResponse: createApiResponse(),
-	isDarkMode: true,
-	panelMode: PanelMode.DASHBOARD_VIEW,
-	panelType: PANEL_TYPES.TIME_SERIES,
-};
-
-describe('buildBaseConfig', () => {
-	it('returns a UPlotConfigBuilder instance', () => {
-		const builder = buildBaseConfig(baseProps);
-
-		expect(builder).toBeDefined();
-		expect(typeof builder.getConfig).toBe('function');
-		expect(typeof builder.getLegendItems).toBe('function');
-	});
-
-	it('configures builder with widgetId and DASHBOARD_VIEW preferences', () => {
-		const builder = buildBaseConfig({
-			...baseProps,
-			panelMode: PanelMode.DASHBOARD_VIEW,
-			widget: createWidget({ id: 'my-widget' }),
-		});
-
-		expect(builder.getWidgetId()).toBe('my-widget');
-		expect(builder.getShouldSaveSelectionPreference()).toBe(true);
-	});
-
-	it('configures builder with IN_MEMORY selection when panelMode is DASHBOARD_EDIT', () => {
-		const builder = buildBaseConfig({
-			...baseProps,
-			panelMode: PanelMode.DASHBOARD_EDIT,
-		});
-
-		expect(builder.getShouldSaveSelectionPreference()).toBe(false);
-		const config = builder.getConfig();
-		expect(config.series).toBeDefined();
-	});
-
-	it('passes stepInterval to builder and cursor prox uses width * multiplier', () => {
-		const stepInterval = 60;
-		const mockWidth = 100;
-		calculateWidthBasedOnStepIntervalMock.mockReturnValue(mockWidth);
-
-		const builder = buildBaseConfig({
-			...baseProps,
-			stepInterval,
-		});
-
-		const config = builder.getConfig();
-		const prox = config.cursor?.hover?.prox;
-		expect(typeof prox).toBe('function');
-
-		const uPlotInstance = {} as uPlot;
-		const proxResult = (prox as (u: uPlot) => number)(uPlotInstance);
-
-		expect(calculateWidthBasedOnStepIntervalMock).toHaveBeenCalledWith({
-			uPlotInstance,
-			stepInterval,
-		});
-		expect(proxResult).toBe(mockWidth * STEP_INTERVAL_MULTIPLIER);
-	});
-
-	it('adds x scale with time config and min/max when provided', () => {
-		const builder = buildBaseConfig({
-			...baseProps,
-			minTimeScale: 1000,
-			maxTimeScale: 2000,
-		});
-
-		const config = builder.getConfig();
-		expect(config.scales?.x).toBeDefined();
-		expect(config.scales?.x?.time).toBe(true);
-		const range = config.scales?.x?.range;
-		expect(Array.isArray(range)).toBe(true);
-		expect((range as [number, number])[0]).toBe(1000);
-	});
-
-	it('configures log scale on y axis when widget.isLogScale is true', () => {
-		const builder = buildBaseConfig({
-			...baseProps,
-			widget: createWidget({ isLogScale: true }),
-		});
-
-		const config = builder.getConfig();
-		expect(config.scales?.y).toBeDefined();
-		expect(config.scales?.y?.log).toBe(10);
-	});
-
-	it('adds onClick plugin when onClick is a function', () => {
-		const onClickPlugin = jest.requireMock('lib/uPlotLib/plugins/onClickPlugin')
-			.default;
-		const onClick = jest.fn();
-
-		buildBaseConfig({
-			...baseProps,
-			onClick,
-			apiResponse: createApiResponse(),
-		});
-
-		expect(onClickPlugin).toHaveBeenCalledWith({
-			onClick,
-			apiResponse: expect.any(Object),
-		});
-	});
-
-	it('does not add onClick plugin when onClick is not a function', () => {
-		const onClickPlugin = jest.requireMock('lib/uPlotLib/plugins/onClickPlugin')
-			.default;
-
-		const builder = buildBaseConfig({
-			...baseProps,
-		});
-
-		const config = builder.getConfig();
-		const plugins = config.plugins ?? [];
-		expect(
-			plugins.some((p) => (p as { name?: string }).name === 'onClickPlugin'),
-		).toBe(false);
-		expect(onClickPlugin).not.toHaveBeenCalled();
-	});
-
-	it('adds thresholds from widget', () => {
-		const builder = buildBaseConfig({
-			...baseProps,
-			widget: createWidget({
-				thresholds: [
-					{
-						thresholdValue: 80,
-						thresholdColor: '#ff0000',
-						thresholdUnit: 'ms',
-						thresholdLabel: 'High',
-					},
-				] as Widgets['thresholds'],
-			}),
-		});
-
-		const config = builder.getConfig();
-		const drawHooks = config.hooks?.draw ?? [];
-		expect(drawHooks.length).toBeGreaterThan(0);
-	});
-
-	it('adds x and y axes with correct scaleKeys and panelType', () => {
-		const builder = buildBaseConfig(baseProps);
-
-		const config = builder.getConfig();
-		expect(config.axes).toHaveLength(2);
-		expect(config.axes?.[0].scale).toBe('x');
-		expect(config.axes?.[1].scale).toBe('y');
-	});
-
-	it('sets tzDate when timezone is provided', () => {
-		const builder = buildBaseConfig({
-			...baseProps,
-			timezone: {
-				name: 'America/New_York',
-				value: 'America/New_York',
-				offset: 'UTC-5',
-				searchIndex: 'America/New_York',
-			},
-		});
-
-		const config = builder.getConfig();
-		expect(config.tzDate).toBeDefined();
-		expect(typeof config.tzDate).toBe('function');
-	});
-
-	it('leaves tzDate undefined when timezone is not provided', () => {
-		const builder = buildBaseConfig(baseProps);
-
-		const config = builder.getConfig();
-		expect(config.tzDate).toBeUndefined();
-	});
-
-	it('register setSelect hook when onDragSelect is provided', () => {
-		const onDragSelect = jest.fn();
-		const builder = buildBaseConfig({
-			...baseProps,
-			onDragSelect,
-		});
-
-		const config = builder.getConfig();
-		expect(config.hooks?.setSelect).toBeDefined();
-	});
-});

frontend/src/container/DashboardContainer/visualization/panels/utils/baseConfigBuilder.ts

@@ -26,7 +26,6 @@ export interface BaseConfigBuilderProps {
 	panelType: PANEL_TYPES;
 	minTimeScale?: number;
 	maxTimeScale?: number;
-	stepInterval?: number;
 }
 
 export function buildBaseConfig({
@@ -40,7 +39,6 @@ export function buildBaseConfig({
 	panelType,
 	minTimeScale,
 	maxTimeScale,
-	stepInterval,
 }: BaseConfigBuilderProps): UPlotConfigBuilder {
 	const tzDate = timezone
 		? (timestamp: number): Date =>
@@ -58,7 +56,6 @@ export function buildBaseConfig({
 		].includes(panelMode)
 			? SelectionPreferencesSource.LOCAL_STORAGE
 			: SelectionPreferencesSource.IN_MEMORY,
-		stepInterval,
 	});
 
 	const thresholdOptions: ThresholdsDrawHookOptions = {

frontend/src/container/FormAlertRules/QuerySection.tsx

@@ -6,7 +6,7 @@ import logEvent from 'api/common/logEvent';
 import PromQLIcon from 'assets/Dashboard/PromQl';
 import { QueryBuilderV2 } from 'components/QueryBuilderV2/QueryBuilderV2';
 import { ALERTS_DATA_SOURCE_MAP } from 'constants/alerts';
-import { ENTITY_VERSION_V4 } from 'constants/app';
+import { ENTITY_VERSION_V5 } from 'constants/app';
 import { PANEL_TYPES } from 'constants/queryBuilder';
 import { QBShortcuts } from 'constants/shortcuts/QBShortcuts';
 import RunQueryBtn from 'container/QueryBuilder/components/RunQueryBtn/RunQueryBtn';
@@ -63,12 +63,8 @@ function QuerySection({
 				signalSource: signalSource === 'meter' ? 'meter' : '',
 			}}
 			showTraceOperator={alertType === AlertTypes.TRACES_BASED_ALERT}
-			showFunctions={
-				(alertType === AlertTypes.METRICS_BASED_ALERT &&
-					alertDef.version === ENTITY_VERSION_V4) ||
-				alertType === AlertTypes.LOGS_BASED_ALERT
-			}
-			version={alertDef.version || 'v3'}
+			showFunctions
+			version={ENTITY_VERSION_V5}
 			onSignalSourceChange={handleSignalSourceChange}
 			signalSourceChangeEnabled
 		/>

frontend/src/container/NewWidget/LeftContainer/WidgetGraph/WidgetGraphContainer.tsx

@@ -51,6 +51,28 @@ function WidgetGraphContainer({
 		return <Spinner size="large" tip="Loading..." />;
 	}
 
+	if (
+		selectedGraph !== PANEL_TYPES.LIST &&
+		selectedGraph !== PANEL_TYPES.VALUE &&
+		queryResponse.data?.payload.data?.result?.length === 0
+	) {
+		return (
+			<NotFoundContainer>
+				<Typography>No Data</Typography>
+			</NotFoundContainer>
+		);
+	}
+	if (
+		(selectedGraph === PANEL_TYPES.LIST || selectedGraph === PANEL_TYPES.VALUE) &&
+		queryResponse.data?.payload?.data?.newResult?.data?.result?.length === 0
+	) {
+		return (
+			<NotFoundContainer>
+				<Typography>No Data</Typography>
+			</NotFoundContainer>
+		);
+	}
+
 	if (queryResponse.isIdle) {
 		return (
 			<NotFoundContainer>

frontend/src/container/OrganizationSettings/AuthDomain/AuthDomain.styles.scss

@@ -7,12 +7,6 @@
 		display: flex;
 		align-items: center;
 		justify-content: space-between;
-
-		.auth-domain-title {
-			margin: 0;
-			font-size: 20px;
-			font-weight: 600;
-		}
 	}
 }
 
@@ -21,36 +15,5 @@
 		display: flex;
 		flex-direction: row;
 		gap: 24px;
-
-		.auth-domain-list-action-link {
-			cursor: pointer;
-			color: var(--primary);
-			transition: color 0.3s;
-			border: none;
-			background: none;
-			padding: 0;
-			font-size: inherit;
-
-			&:hover {
-				opacity: 0.8;
-				text-decoration: underline;
-			}
-
-			&.delete {
-				color: var(--destructive);
-			}
-		}
-	}
-
-	.auth-domain-list-na {
-		padding-left: 6px;
-		color: var(--text-secondary);
-	}
-}
-
-.delete-ingestion-key-modal {
-	.delete-text {
-		color: var(--text);
-		margin: 0;
 	}
 }

frontend/src/container/OrganizationSettings/AuthDomain/CreateEdit/CreateEdit.tsx

@@ -1,38 +1,28 @@
-import { useCallback, useState } from 'react';
-import { Button } from '@signozhq/button';
-import { toast } from '@signozhq/sonner';
-import { Form, Modal } from 'antd';
-import { ErrorResponseHandlerV2 } from 'api/ErrorResponseHandlerV2';
-import {
-	useCreateAuthDomain,
-	useUpdateAuthDomain,
-} from 'api/generated/services/authdomains';
-import {
-	AuthtypesGettableAuthDomainDTO,
-	AuthtypesGoogleConfigDTO,
-	AuthtypesRoleMappingDTO,
-	RenderErrorResponseDTO,
-} from 'api/generated/services/sigNoz.schemas';
-import { AxiosError } from 'axios';
+import { useState } from 'react';
+import { Button, Form, Modal } from 'antd';
+import put from 'api/v1/domains/id/put';
+import post from 'api/v1/domains/post';
 import { FeatureKeys } from 'constants/features';
 import { defaultTo } from 'lodash-es';
 import { useAppContext } from 'providers/App/App';
 import { useErrorModal } from 'providers/ErrorModalProvider';
-import { ErrorV2Resp } from 'types/api';
 import APIError from 'types/api/error';
+import { GettableAuthDomain } from 'types/api/v1/domains/list';
+import { PostableAuthDomain } from 'types/api/v1/domains/post';
 
 import AuthnProviderSelector from './AuthnProviderSelector';
-import {
-	convertDomainMappingsToRecord,
-	convertGroupMappingsToRecord,
-	FormValues,
-	prepareInitialValues,
-} from './CreateEdit.utils';
 import ConfigureGoogleAuthAuthnProvider from './Providers/AuthnGoogleAuth';
 import ConfigureOIDCAuthnProvider from './Providers/AuthnOIDC';
 import ConfigureSAMLAuthnProvider from './Providers/AuthnSAML';
 
 import './CreateEdit.styles.scss';
+
+interface CreateOrEditProps {
+	isCreate: boolean;
+	onClose: () => void;
+	record?: GettableAuthDomain;
+}
+
 function configureAuthnProvider(
 	authnProvider: string,
 	isCreate: boolean,
@@ -49,186 +39,64 @@ function configureAuthnProvider(
 	}
 }
 
-interface CreateOrEditProps {
-	isCreate: boolean;
-	onClose: () => void;
-	record?: AuthtypesGettableAuthDomainDTO;
-}
-
 function CreateOrEdit(props: CreateOrEditProps): JSX.Element {
 	const { isCreate, record, onClose } = props;
-	const [form] = Form.useForm<FormValues>();
+	const [form] = Form.useForm<PostableAuthDomain>();
 	const [authnProvider, setAuthnProvider] = useState<string>(
 		record?.ssoType || '',
 	);
 
 	const { showErrorModal } = useErrorModal();
 	const { featureFlags } = useAppContext();
-
-	const handleError = useCallback(
-		(error: AxiosError<RenderErrorResponseDTO>): void => {
-			try {
-				ErrorResponseHandlerV2(error as AxiosError<ErrorV2Resp>);
-			} catch (apiError) {
-				showErrorModal(apiError as APIError);
-			}
-		},
-		[showErrorModal],
-	);
 	const samlEnabled =
 		featureFlags?.find((flag) => flag.name === FeatureKeys.SSO)?.active || false;
 
-	const {
-		mutate: createAuthDomain,
-		isLoading: isCreating,
-	} = useCreateAuthDomain<AxiosError<RenderErrorResponseDTO>>();
-
-	const {
-		mutate: updateAuthDomain,
-		isLoading: isUpdating,
-	} = useUpdateAuthDomain<AxiosError<RenderErrorResponseDTO>>();
-
-	/**
-	 * Prepares Google Auth config for API payload
-	 */
-	const getGoogleAuthConfig = useCallback(():
-		| AuthtypesGoogleConfigDTO
-		| undefined => {
-		const config = form.getFieldValue('googleAuthConfig');
-		if (!config) {
-			return undefined;
-		}
-
-		const { domainToAdminEmailList, ...rest } = config;
-		const domainToAdminEmail = convertDomainMappingsToRecord(
-			domainToAdminEmailList,
-		);
-
-		return {
-			...rest,
-			...(domainToAdminEmail && { domainToAdminEmail }),
-		};
-	}, [form]);
-
-	// Prepares role mapping for API payload
-	const getRoleMapping = useCallback((): AuthtypesRoleMappingDTO | undefined => {
-		const roleMapping = form.getFieldValue('roleMapping');
-		if (!roleMapping) {
-			return undefined;
-		}
-
-		const { groupMappingsList, ...rest } = roleMapping;
-		const groupMappings = convertGroupMappingsToRecord(groupMappingsList);
-
-		// Only return roleMapping if there's meaningful content
-		const hasDefaultRole = !!rest.defaultRole;
-		const hasUseRoleAttribute = rest.useRoleAttribute === true;
-		const hasGroupMappings =
-			groupMappings && Object.keys(groupMappings).length > 0;
-
-		if (!hasDefaultRole && !hasUseRoleAttribute && !hasGroupMappings) {
-			return undefined;
-		}
-
-		return {
-			...rest,
-			...(groupMappings && { groupMappings }),
-		};
-	}, [form]);
-
-	const onSubmitHandler = useCallback(async (): Promise<void> => {
-		try {
-			await form.validateFields();
-		} catch {
-			return;
-		}
-
+	const onSubmitHandler = async (): Promise<void> => {
 		const name = form.getFieldValue('name');
-		const googleAuthConfig = getGoogleAuthConfig();
+		const googleAuthConfig = form.getFieldValue('googleAuthConfig');
 		const samlConfig = form.getFieldValue('samlConfig');
 		const oidcConfig = form.getFieldValue('oidcConfig');
-		const roleMapping = getRoleMapping();
 
-		if (isCreate) {
-			createAuthDomain(
-				{
-					data: {
-						name,
-						config: {
-							ssoEnabled: true,
-							ssoType: authnProvider,
-							googleAuthConfig,
-							samlConfig,
-							oidcConfig,
-							roleMapping,
-						},
+		try {
+			if (isCreate) {
+				await post({
+					name,
+					config: {
+						ssoEnabled: true,
+						ssoType: authnProvider,
+						googleAuthConfig,
+						samlConfig,
+						oidcConfig,
 					},
-				},
-				{
-					onSuccess: () => {
-						toast.success('Domain created successfully');
-						onClose();
+				});
+			} else {
+				await put({
+					id: record?.id || '',
+					config: {
+						ssoEnabled: form.getFieldValue('ssoEnabled'),
+						ssoType: authnProvider,
+						googleAuthConfig,
+						samlConfig,
+						oidcConfig,
 					},
-					onError: handleError,
-				},
-			);
-		} else {
-			if (!record?.id) {
-				return;
+				});
 			}
 
-			updateAuthDomain(
-				{
-					pathParams: { id: record.id },
-					data: {
-						config: {
-							ssoEnabled: form.getFieldValue('ssoEnabled'),
-							ssoType: authnProvider,
-							googleAuthConfig,
-							samlConfig,
-							oidcConfig,
-							roleMapping,
-						},
-					},
-				},
-				{
-					onSuccess: () => {
-						toast.success('Domain updated successfully');
-						onClose();
-					},
-					onError: handleError,
-				},
-			);
+			onClose();
+		} catch (error) {
+			showErrorModal(error as APIError);
 		}
-	}, [
-		authnProvider,
-		createAuthDomain,
-		form,
-		getGoogleAuthConfig,
-		getRoleMapping,
-		handleError,
-		isCreate,
+	};
 
-		onClose,
-		record,
-		updateAuthDomain,
-	]);
-
-	const onBackHandler = useCallback((): void => {
-		form.resetFields();
+	const onBackHandler = (): void => {
 		setAuthnProvider('');
-	}, [form]);
+	};
 
 	return (
-		<Modal
-			open
-			footer={null}
-			onCancel={onClose}
-			width={authnProvider ? 980 : undefined}
-		>
+		<Modal open footer={null} onCancel={onClose}>
 			<Form
 				name="auth-domain"
-				initialValues={defaultTo(prepareInitialValues(record), {
+				initialValues={defaultTo(record, {
 					name: '',
 					ssoEnabled: false,
 					ssoType: '',
@@ -246,22 +114,9 @@ function CreateOrEdit(props: CreateOrEditProps): JSX.Element {
 					<div className="auth-domain-configure">
 						{configureAuthnProvider(authnProvider, isCreate)}
 						<section className="action-buttons">
-							{isCreate && (
-								<Button onClick={onBackHandler} variant="solid" color="secondary">
-									Back
-								</Button>
-							)}
-							{!isCreate && (
-								<Button onClick={onClose} variant="solid" color="secondary">
-									Cancel
-								</Button>
-							)}
-							<Button
-								onClick={onSubmitHandler}
-								variant="solid"
-								color="primary"
-								loading={isCreating || isUpdating}
-							>
+							{isCreate && <Button onClick={onBackHandler}>Back</Button>}
+							{!isCreate && <Button onClick={onClose}>Cancel</Button>}
+							<Button onClick={onSubmitHandler} type="primary">
 								Save Changes
 							</Button>
 						</section>

frontend/src/container/OrganizationSettings/AuthDomain/CreateEdit/CreateEdit.utils.ts

@@ -1,134 +0,0 @@
-import {
-	AuthtypesGettableAuthDomainDTO,
-	AuthtypesGoogleConfigDTO,
-	AuthtypesOIDCConfigDTO,
-	AuthtypesRoleMappingDTO,
-	AuthtypesSamlConfigDTO,
-} from 'api/generated/services/sigNoz.schemas';
-
-// Form values interface for internal use (includes array-based fields for UI)
-export interface FormValues {
-	name?: string;
-	ssoEnabled?: boolean;
-	ssoType?: string;
-	googleAuthConfig?: AuthtypesGoogleConfigDTO & {
-		domainToAdminEmailList?: Array<{ domain?: string; adminEmail?: string }>;
-	};
-	samlConfig?: AuthtypesSamlConfigDTO;
-	oidcConfig?: AuthtypesOIDCConfigDTO;
-	roleMapping?: AuthtypesRoleMappingDTO & {
-		groupMappingsList?: Array<{ groupName?: string; role?: string }>;
-	};
-}
-
-/**
- * Converts groupMappingsList array to groupMappings Record for API
- */
-export function convertGroupMappingsToRecord(
-	groupMappingsList?: Array<{ groupName?: string; role?: string }>,
-): Record<string, string> | undefined {
-	if (!Array.isArray(groupMappingsList) || groupMappingsList.length === 0) {
-		return undefined;
-	}
-
-	const groupMappings: Record<string, string> = {};
-	groupMappingsList.forEach((item) => {
-		if (item.groupName && item.role) {
-			groupMappings[item.groupName] = item.role;
-		}
-	});
-
-	return Object.keys(groupMappings).length > 0 ? groupMappings : undefined;
-}
-
-/**
- * Converts groupMappings Record to groupMappingsList array for form
- */
-export function convertGroupMappingsToList(
-	groupMappings?: Record<string, string> | null,
-): Array<{ groupName: string; role: string }> {
-	if (!groupMappings) {
-		return [];
-	}
-
-	return Object.entries(groupMappings).map(([groupName, role]) => ({
-		groupName,
-		role,
-	}));
-}
-
-/**
- * Converts domainToAdminEmailList array to domainToAdminEmail Record for API
- */
-export function convertDomainMappingsToRecord(
-	domainToAdminEmailList?: Array<{ domain?: string; adminEmail?: string }>,
-): Record<string, string> | undefined {
-	if (
-		!Array.isArray(domainToAdminEmailList) ||
-		domainToAdminEmailList.length === 0
-	) {
-		return undefined;
-	}
-
-	const domainToAdminEmail: Record<string, string> = {};
-	domainToAdminEmailList.forEach((item) => {
-		if (item.domain && item.adminEmail) {
-			domainToAdminEmail[item.domain] = item.adminEmail;
-		}
-	});
-
-	return Object.keys(domainToAdminEmail).length > 0
-		? domainToAdminEmail
-		: undefined;
-}
-
-/**
- * Converts domainToAdminEmail Record to domainToAdminEmailList array for form
- */
-export function convertDomainMappingsToList(
-	domainToAdminEmail?: Record<string, string>,
-): Array<{ domain: string; adminEmail: string }> {
-	if (!domainToAdminEmail) {
-		return [];
-	}
-
-	return Object.entries(domainToAdminEmail).map(([domain, adminEmail]) => ({
-		domain,
-		adminEmail,
-	}));
-}
-
-/**
- * Prepares initial form values from API record
- */
-export function prepareInitialValues(
-	record?: AuthtypesGettableAuthDomainDTO,
-): FormValues {
-	if (!record) {
-		return {
-			name: '',
-			ssoEnabled: false,
-			ssoType: '',
-		};
-	}
-
-	return {
-		...record,
-		googleAuthConfig: record.googleAuthConfig
-			? {
-					...record.googleAuthConfig,
-					domainToAdminEmailList: convertDomainMappingsToList(
-						record.googleAuthConfig.domainToAdminEmail,
-					),
-			  }
-			: undefined,
-		roleMapping: record.roleMapping
-			? {
-					...record.roleMapping,
-					groupMappingsList: convertGroupMappingsToList(
-						record.roleMapping.groupMappings,
-					),
-			  }
-			: undefined,
-	};
-}

frontend/src/container/OrganizationSettings/AuthDomain/CreateEdit/Providers/AuthnGoogleAuth.tsx

@@ -1,67 +1,20 @@
-import { useCallback, useState } from 'react';
 import { Callout } from '@signozhq/callout';
-import { Checkbox } from '@signozhq/checkbox';
-import { Color, Style } from '@signozhq/design-tokens';
-import {
-	ChevronDown,
-	ChevronRight,
-	CircleHelp,
-	TriangleAlert,
-} from '@signozhq/icons';
-import { Input } from '@signozhq/input';
-import { Collapse, Form, Tooltip } from 'antd';
-import TextArea from 'antd/lib/input/TextArea';
-import { useCollapseSectionErrors } from 'hooks/useCollapseSectionErrors';
-
-import DomainMappingList from './components/DomainMappingList';
-import EmailTagInput from './components/EmailTagInput';
-import RoleMappingSection from './components/RoleMappingSection';
+import { Form, Input, Typography } from 'antd';
 
 import './Providers.styles.scss';
 
-type ExpandedSection = 'workspace-groups' | 'role-mapping' | null;
-
 function ConfigureGoogleAuthAuthnProvider({
 	isCreate,
 }: {
 	isCreate: boolean;
 }): JSX.Element {
-	const form = Form.useFormInstance();
-	const fetchGroups = Form.useWatch(['googleAuthConfig', 'fetchGroups'], form);
-
-	const [expandedSection, setExpandedSection] = useState<ExpandedSection>(null);
-
-	const handleWorkspaceGroupsChange = useCallback(
-		(keys: string | string[]): void => {
-			const isExpanding = Array.isArray(keys) ? keys.length > 0 : !!keys;
-			setExpandedSection(isExpanding ? 'workspace-groups' : null);
-		},
-		[],
-	);
-
-	const handleRoleMappingChange = useCallback((expanded: boolean): void => {
-		setExpandedSection(expanded ? 'role-mapping' : null);
-	}, []);
-
-	const {
-		hasErrors: hasWorkspaceGroupsErrors,
-		errorMessages: workspaceGroupsErrorMessages,
-	} = useCollapseSectionErrors(
-		['googleAuthConfig'],
-		[
-			['googleAuthConfig', 'fetchGroups'],
-			['googleAuthConfig', 'serviceAccountJson'],
-			['googleAuthConfig', 'domainToAdminEmailList'],
-			['googleAuthConfig', 'fetchTransitiveGroupMembership'],
-			['googleAuthConfig', 'allowedGroups'],
-		],
-	);
-
 	return (
-		<div className="authn-provider">
-			<section className="authn-provider__header">
-				<h3 className="authn-provider__title">Edit Google Authentication</h3>
-				<p className="authn-provider__description">
+		<div className="google-auth">
+			<section className="header">
+				<Typography.Text className="title">
+					Edit Google Authentication
+				</Typography.Text>
+				<Typography.Paragraph className="description">
 					Enter OAuth 2.0 credentials obtained from the Google API Console below.
 					Read the{' '}
 					<a
@@ -72,247 +25,50 @@ function ConfigureGoogleAuthAuthnProvider({
 						docs
 					</a>{' '}
 					for more information.
-				</p>
+				</Typography.Paragraph>
 			</section>
 
-			<div className="authn-provider__columns">
-				{/* Left Column - Core OAuth Settings */}
-				<div className="authn-provider__left">
-					<div className="authn-provider__field-group">
-						<label className="authn-provider__label" htmlFor="google-domain">
-							Domain
-							<Tooltip title="The email domain for users who should use SSO (e.g., `example.com` for users with `@example.com` emails)">
-								<CircleHelp size={14} color={Style.L3_FOREGROUND} cursor="help" />
-							</Tooltip>
-						</label>
-						<Form.Item
-							name="name"
-							className="authn-provider__form-item"
-							rules={[
-								{ required: true, message: 'Domain is required', whitespace: true },
-							]}
-						>
-							<Input id="google-domain" disabled={!isCreate} />
-						</Form.Item>
-					</div>
+			<Form.Item
+				label="Domain"
+				name="name"
+				className="field"
+				tooltip={{
+					title:
+						'The email domain for users who should use SSO (e.g., `example.com` for users with `@example.com` emails)',
+				}}
+			>
+				<Input disabled={!isCreate} />
+			</Form.Item>
 
-					<div className="authn-provider__field-group">
-						<label className="authn-provider__label" htmlFor="google-client-id">
-							Client ID
-							<Tooltip title="ClientID is the application's ID. For example, 292085223830.apps.googleusercontent.com.">
-								<CircleHelp size={14} color={Style.L3_FOREGROUND} cursor="help" />
-							</Tooltip>
-						</label>
-						<Form.Item
-							name={['googleAuthConfig', 'clientId']}
-							className="authn-provider__form-item"
-							rules={[
-								{ required: true, message: 'Client ID is required', whitespace: true },
-							]}
-						>
-							<Input id="google-client-id" />
-						</Form.Item>
-					</div>
+			<Form.Item
+				label="Client ID"
+				name={['googleAuthConfig', 'clientId']}
+				className="field"
+				tooltip={{
+					title: `ClientID is the application's ID. For example, 292085223830.apps.googleusercontent.com.`,
+				}}
+			>
+				<Input />
+			</Form.Item>
 
-					<div className="authn-provider__field-group">
-						<label className="authn-provider__label" htmlFor="google-client-secret">
-							Client Secret
-							<Tooltip title="It is the application's secret.">
-								<CircleHelp size={14} color={Style.L3_FOREGROUND} cursor="help" />
-							</Tooltip>
-						</label>
-						<Form.Item
-							name={['googleAuthConfig', 'clientSecret']}
-							className="authn-provider__form-item"
-							rules={[
-								{
-									required: true,
-									message: 'Client Secret is required',
-									whitespace: true,
-								},
-							]}
-						>
-							<Input id="google-client-secret" />
-						</Form.Item>
-					</div>
+			<Form.Item
+				label="Client Secret"
+				name={['googleAuthConfig', 'clientSecret']}
+				className="field"
+				tooltip={{
+					title: `It is the application's secret.`,
+				}}
+			>
+				<Input />
+			</Form.Item>
 
-					<div className="authn-provider__checkbox-row">
-						<Form.Item
-							name={['googleAuthConfig', 'insecureSkipEmailVerified']}
-							valuePropName="checked"
-							noStyle
-						>
-							<Checkbox
-								id="google-skip-email-verification"
-								labelName="Skip Email Verification"
-								onCheckedChange={(checked: boolean): void => {
-									form.setFieldValue(
-										['googleAuthConfig', 'insecureSkipEmailVerified'],
-										checked,
-									);
-								}}
-							/>
-						</Form.Item>
-						<Tooltip title='Whether to skip email verification. Defaults to "false"'>
-							<CircleHelp size={14} color={Style.L3_FOREGROUND} cursor="help" />
-						</Tooltip>
-					</div>
-
-					<Callout
-						type="warning"
-						size="small"
-						showIcon
-						description="Google OAuth2 won't be enabled unless you enter all the attributes above"
-						className="callout"
-					/>
-				</div>
-
-				{/* Right Column - Google Workspace Groups (Advanced) */}
-				<div className="authn-provider__right">
-					<Collapse
-						bordered={false}
-						activeKey={
-							expandedSection === 'workspace-groups' ? ['workspace-groups'] : []
-						}
-						onChange={handleWorkspaceGroupsChange}
-						className="authn-provider__collapse"
-						expandIcon={(): null => null}
-					>
-						<Collapse.Panel
-							key="workspace-groups"
-							header={
-								<div className="authn-provider__collapse-header">
-									{expandedSection !== 'workspace-groups' ? (
-										<ChevronRight size={16} />
-									) : (
-										<ChevronDown size={16} />
-									)}
-									<div className="authn-provider__collapse-header-text">
-										<h4 className="authn-provider__section-title">
-											Google Workspace Groups (Advanced)
-										</h4>
-										<p className="authn-provider__section-description">
-											Enable group fetching to retrieve user groups from Google Workspace.
-											Requires a Service Account with domain-wide delegation.
-										</p>
-									</div>
-									{expandedSection !== 'workspace-groups' && hasWorkspaceGroupsErrors && (
-										<Tooltip
-											title={
-												<div>
-													{workspaceGroupsErrorMessages.map((msg) => (
-														<div key={msg}>{msg}</div>
-													))}
-												</div>
-											}
-										>
-											<TriangleAlert size={16} color={Color.BG_CHERRY_500} />
-										</Tooltip>
-									)}
-								</div>
-							}
-						>
-							<div className="authn-provider__group-content">
-								<div className="authn-provider__checkbox-row">
-									<Form.Item
-										name={['googleAuthConfig', 'fetchGroups']}
-										valuePropName="checked"
-										noStyle
-									>
-										<Checkbox
-											id="google-fetch-groups"
-											labelName="Fetch Groups"
-											onCheckedChange={(checked: boolean): void => {
-												form.setFieldValue(['googleAuthConfig', 'fetchGroups'], checked);
-											}}
-										/>
-									</Form.Item>
-									<Tooltip title="Enable fetching Google Workspace groups for the user. Requires service account configuration.">
-										<CircleHelp size={14} color={Style.L3_FOREGROUND} cursor="help" />
-									</Tooltip>
-								</div>
-
-								{fetchGroups && (
-									<div className="authn-provider__group-fields">
-										<div className="authn-provider__field-group">
-											<label
-												className="authn-provider__label"
-												htmlFor="google-service-account-json"
-											>
-												Service Account JSON
-												<Tooltip title="The JSON content of the Google Service Account credentials file. Required for group fetching.">
-													<CircleHelp size={14} color={Style.L3_FOREGROUND} cursor="help" />
-												</Tooltip>
-											</label>
-											<Form.Item
-												name={['googleAuthConfig', 'serviceAccountJson']}
-												className="authn-provider__form-item"
-											>
-												<TextArea
-													id="google-service-account-json"
-													rows={3}
-													placeholder="Paste service account JSON"
-													className="authn-provider__textarea"
-												/>
-											</Form.Item>
-										</div>
-
-										<DomainMappingList
-											fieldNamePrefix={['googleAuthConfig', 'domainToAdminEmailList']}
-										/>
-
-										<div className="authn-provider__checkbox-row">
-											<Form.Item
-												name={['googleAuthConfig', 'fetchTransitiveGroupMembership']}
-												valuePropName="checked"
-												noStyle
-											>
-												<Checkbox
-													id="google-transitive-membership"
-													labelName="Fetch Transitive Group Membership"
-													onCheckedChange={(checked: boolean): void => {
-														form.setFieldValue(
-															['googleAuthConfig', 'fetchTransitiveGroupMembership'],
-															checked,
-														);
-													}}
-												/>
-											</Form.Item>
-											<Tooltip title="If enabled, recursively fetch groups that contain other groups (transitive membership).">
-												<CircleHelp size={14} color={Style.L3_FOREGROUND} cursor="help" />
-											</Tooltip>
-										</div>
-
-										<div className="authn-provider__field-group">
-											<label
-												className="authn-provider__label"
-												htmlFor="google-allowed-groups"
-											>
-												Allowed Groups
-												<Tooltip title="Optional list of allowed groups. If configured, only users belonging to one of these groups will be allowed to login.">
-													<CircleHelp size={14} color={Style.L3_FOREGROUND} cursor="help" />
-												</Tooltip>
-											</label>
-											<Form.Item
-												name={['googleAuthConfig', 'allowedGroups']}
-												className="authn-provider__form-item"
-											>
-												<EmailTagInput placeholder="Type a group email and press Enter" />
-											</Form.Item>
-										</div>
-									</div>
-								)}
-							</div>
-						</Collapse.Panel>
-					</Collapse>
-
-					<RoleMappingSection
-						fieldNamePrefix={['roleMapping']}
-						isExpanded={expandedSection === 'role-mapping'}
-						onExpandChange={handleRoleMappingChange}
-					/>
-				</div>
-			</div>
+			<Callout
+				type="warning"
+				size="small"
+				showIcon
+				description="Google OAuth2 won’t be enabled unless you enter all the attributes above"
+				className="callout"
+			/>
 		</div>
 	);
 }

frontend/src/container/OrganizationSettings/AuthDomain/CreateEdit/Providers/AuthnOIDC.tsx

@@ -1,212 +1,110 @@
-import { useCallback, useState } from 'react';
 import { Callout } from '@signozhq/callout';
-import { Checkbox } from '@signozhq/checkbox';
-import { Style } from '@signozhq/design-tokens';
-import { CircleHelp } from '@signozhq/icons';
-import { Input } from '@signozhq/input';
-import { Form, Tooltip } from 'antd';
-
-import ClaimMappingSection from './components/ClaimMappingSection';
-import RoleMappingSection from './components/RoleMappingSection';
+import { Checkbox, Form, Input, Typography } from 'antd';
 
 import './Providers.styles.scss';
 
-type ExpandedSection = 'claim-mapping' | 'role-mapping' | null;
-
 function ConfigureOIDCAuthnProvider({
 	isCreate,
 }: {
 	isCreate: boolean;
 }): JSX.Element {
-	const form = Form.useFormInstance();
-
-	const [expandedSection, setExpandedSection] = useState<ExpandedSection>(null);
-
-	const handleClaimMappingChange = useCallback((expanded: boolean): void => {
-		setExpandedSection(expanded ? 'claim-mapping' : null);
-	}, []);
-
-	const handleRoleMappingChange = useCallback((expanded: boolean): void => {
-		setExpandedSection(expanded ? 'role-mapping' : null);
-	}, []);
-
 	return (
-		<div className="authn-provider">
-			<section className="authn-provider__header">
-				<h3 className="authn-provider__title">Edit OIDC Authentication</h3>
-				<p className="authn-provider__description">
-					Configure OpenID Connect Single Sign-On with your Identity Provider. Read
-					the{' '}
-					<a
-						href="https://signoz.io/docs/userguide/sso-authentication"
-						target="_blank"
-						rel="noreferrer"
-					>
-						docs
-					</a>{' '}
-					for more information.
-				</p>
+		<div className="saml">
+			<section className="header">
+				<Typography.Text className="title">
+					Edit OIDC Authentication
+				</Typography.Text>
 			</section>
 
-			<div className="authn-provider__columns">
-				{/* Left Column - Core OIDC Settings */}
-				<div className="authn-provider__left">
-					<div className="authn-provider__field-group">
-						<label className="authn-provider__label" htmlFor="oidc-domain">
-							Domain
-							<Tooltip title="The email domain for users who should use SSO (e.g., `example.com` for users with `@example.com` emails)">
-								<CircleHelp size={14} color={Style.L3_FOREGROUND} cursor="help" />
-							</Tooltip>
-						</label>
-						<Form.Item
-							name="name"
-							className="authn-provider__form-item"
-							rules={[
-								{ required: true, message: 'Domain is required', whitespace: true },
-							]}
-						>
-							<Input id="oidc-domain" disabled={!isCreate} />
-						</Form.Item>
-					</div>
+			<Form.Item
+				label="Domain"
+				name="name"
+				tooltip={{
+					title:
+						'The email domain for users who should use SSO (e.g., `example.com` for users with `@example.com` emails)',
+				}}
+			>
+				<Input disabled={!isCreate} />
+			</Form.Item>
 
-					<div className="authn-provider__field-group">
-						<label className="authn-provider__label" htmlFor="oidc-issuer">
-							Issuer URL
-							<Tooltip title='The URL identifier for the OIDC provider. For example: "https://accounts.google.com" or "https://login.salesforce.com".'>
-								<CircleHelp size={14} color={Style.L3_FOREGROUND} cursor="help" />
-							</Tooltip>
-						</label>
-						<Form.Item
-							name={['oidcConfig', 'issuer']}
-							className="authn-provider__form-item"
-							rules={[
-								{ required: true, message: 'Issuer URL is required', whitespace: true },
-							]}
-						>
-							<Input id="oidc-issuer" />
-						</Form.Item>
-					</div>
+			<Form.Item
+				label="Issuer URL"
+				name={['oidcConfig', 'issuer']}
+				tooltip={{
+					title: `It is the URL identifier for the service. For example: "https://accounts.google.com" or "https://login.salesforce.com".`,
+				}}
+			>
+				<Input />
+			</Form.Item>
 
-					<div className="authn-provider__field-group">
-						<label className="authn-provider__label" htmlFor="oidc-issuer-alias">
-							Issuer Alias
-							<Tooltip title="Optional: Override the issuer URL from .well-known/openid-configuration for providers like Azure or Oracle IDCS.">
-								<CircleHelp size={14} color={Style.L3_FOREGROUND} cursor="help" />
-							</Tooltip>
-						</label>
-						<Form.Item
-							name={['oidcConfig', 'issuerAlias']}
-							className="authn-provider__form-item"
-						>
-							<Input id="oidc-issuer-alias" />
-						</Form.Item>
-					</div>
+			<Form.Item
+				label="Issuer Alias"
+				name={['oidcConfig', 'issuerAlias']}
+				tooltip={{
+					title: `Some offspec providers like Azure, Oracle IDCS have oidc discovery url different from issuer url which causes issuerValidation to fail.
+					This provides a way to override the Issuer url from the .well-known/openid-configuration issuer`,
+				}}
+			>
+				<Input />
+			</Form.Item>
 
-					<div className="authn-provider__field-group">
-						<label className="authn-provider__label" htmlFor="oidc-client-id">
-							Client ID
-							<Tooltip title="The application's client ID from your OIDC provider.">
-								<CircleHelp size={14} color={Style.L3_FOREGROUND} cursor="help" />
-							</Tooltip>
-						</label>
-						<Form.Item
-							name={['oidcConfig', 'clientId']}
-							className="authn-provider__form-item"
-							rules={[
-								{ required: true, message: 'Client ID is required', whitespace: true },
-							]}
-						>
-							<Input id="oidc-client-id" />
-						</Form.Item>
-					</div>
+			<Form.Item
+				label="Client ID"
+				name={['oidcConfig', 'clientId']}
+				tooltip={{ title: `It is the application's ID.` }}
+			>
+				<Input />
+			</Form.Item>
 
-					<div className="authn-provider__field-group">
-						<label className="authn-provider__label" htmlFor="oidc-client-secret">
-							Client Secret
-							<Tooltip title="The application's client secret from your OIDC provider.">
-								<CircleHelp size={14} color={Style.L3_FOREGROUND} cursor="help" />
-							</Tooltip>
-						</label>
-						<Form.Item
-							name={['oidcConfig', 'clientSecret']}
-							className="authn-provider__form-item"
-							rules={[
-								{
-									required: true,
-									message: 'Client Secret is required',
-									whitespace: true,
-								},
-							]}
-						>
-							<Input id="oidc-client-secret" />
-						</Form.Item>
-					</div>
+			<Form.Item
+				label="Client Secret"
+				name={['oidcConfig', 'clientSecret']}
+				tooltip={{ title: `It is the application's secret.` }}
+			>
+				<Input />
+			</Form.Item>
 
-					<div className="authn-provider__checkbox-row">
-						<Form.Item
-							name={['oidcConfig', 'insecureSkipEmailVerified']}
-							valuePropName="checked"
-							noStyle
-						>
-							<Checkbox
-								id="oidc-skip-email-verification"
-								labelName="Skip Email Verification"
-								onCheckedChange={(checked: boolean): void => {
-									form.setFieldValue(
-										['oidcConfig', 'insecureSkipEmailVerified'],
-										checked,
-									);
-								}}
-							/>
-						</Form.Item>
-						<Tooltip title='Whether to skip email verification. Defaults to "false"'>
-							<CircleHelp size={14} color={Style.L3_FOREGROUND} cursor="help" />
-						</Tooltip>
-					</div>
+			<Form.Item
+				label="Email Claim Mapping"
+				name={['oidcConfig', 'claimMapping', 'email']}
+				tooltip={{
+					title: `Mapping of email claims to the corresponding email field in the token.`,
+				}}
+			>
+				<Input />
+			</Form.Item>
 
-					<div className="authn-provider__checkbox-row">
-						<Form.Item
-							name={['oidcConfig', 'getUserInfo']}
-							valuePropName="checked"
-							noStyle
-						>
-							<Checkbox
-								id="oidc-get-user-info"
-								labelName="Get User Info"
-								onCheckedChange={(checked: boolean): void => {
-									form.setFieldValue(['oidcConfig', 'getUserInfo'], checked);
-								}}
-							/>
-						</Form.Item>
-						<Tooltip title="Use the userinfo endpoint to get additional claims. Useful when providers return thin ID tokens.">
-							<CircleHelp size={14} color={Style.L3_FOREGROUND} cursor="help" />
-						</Tooltip>
-					</div>
+			<Form.Item
+				label="Skip Email Verification"
+				name={['oidcConfig', 'insecureSkipEmailVerified']}
+				valuePropName="checked"
+				className="field"
+				tooltip={{
+					title: `Whether to skip email verification. Defaults to "false"`,
+				}}
+			>
+				<Checkbox />
+			</Form.Item>
 
-					<Callout
-						type="warning"
-						size="small"
-						showIcon
-						description="OIDC won't be enabled unless you enter all the attributes above"
-						className="callout"
-					/>
-				</div>
+			<Form.Item
+				label="Get User Info"
+				name={['oidcConfig', 'getUserInfo']}
+				valuePropName="checked"
+				className="field"
+				tooltip={{
+					title: `Uses the userinfo endpoint to get additional claims for the token. This is especially useful where upstreams return "thin" id tokens`,
+				}}
+			>
+				<Checkbox />
+			</Form.Item>
 
-				{/* Right Column - Advanced Settings */}
-				<div className="authn-provider__right">
-					<ClaimMappingSection
-						fieldNamePrefix={['oidcConfig', 'claimMapping']}
-						isExpanded={expandedSection === 'claim-mapping'}
-						onExpandChange={handleClaimMappingChange}
-					/>
-
-					<RoleMappingSection
-						fieldNamePrefix={['roleMapping']}
-						isExpanded={expandedSection === 'role-mapping'}
-						onExpandChange={handleRoleMappingChange}
-					/>
-				</div>
-			</div>
+			<Callout
+				type="warning"
+				size="small"
+				showIcon
+				description="OIDC won’t be enabled unless you enter all the attributes above"
+				className="callout"
+			/>
 		</div>
 	);
 }

frontend/src/container/OrganizationSettings/AuthDomain/CreateEdit/Providers/AuthnSAML.tsx

@@ -1,191 +1,82 @@
-import { useCallback, useState } from 'react';
 import { Callout } from '@signozhq/callout';
-import { Checkbox } from '@signozhq/checkbox';
-import { Style } from '@signozhq/design-tokens';
-import { CircleHelp } from '@signozhq/icons';
-import { Input } from '@signozhq/input';
-import { Form, Tooltip } from 'antd';
-import TextArea from 'antd/lib/input/TextArea';
-
-import AttributeMappingSection from './components/AttributeMappingSection';
-import RoleMappingSection from './components/RoleMappingSection';
+import { Checkbox, Form, Input, Typography } from 'antd';
 
 import './Providers.styles.scss';
 
-type ExpandedSection = 'attribute-mapping' | 'role-mapping' | null;
-
 function ConfigureSAMLAuthnProvider({
 	isCreate,
 }: {
 	isCreate: boolean;
 }): JSX.Element {
-	const form = Form.useFormInstance();
-
-	const [expandedSection, setExpandedSection] = useState<ExpandedSection>(null);
-
-	const handleAttributeMappingChange = useCallback((expanded: boolean): void => {
-		setExpandedSection(expanded ? 'attribute-mapping' : null);
-	}, []);
-
-	const handleRoleMappingChange = useCallback((expanded: boolean): void => {
-		setExpandedSection(expanded ? 'role-mapping' : null);
-	}, []);
-
 	return (
-		<div className="authn-provider">
-			<section className="authn-provider__header">
-				<h3 className="authn-provider__title">Edit SAML Authentication</h3>
-				<p className="authn-provider__description">
-					Configure SAML 2.0 Single Sign-On with your Identity Provider. Read the{' '}
-					<a
-						href="https://signoz.io/docs/userguide/sso-authentication"
-						target="_blank"
-						rel="noreferrer"
-					>
-						docs
-					</a>{' '}
-					for more information.
-				</p>
+		<div className="saml">
+			<section className="header">
+				<Typography.Text className="title">
+					Edit SAML Authentication
+				</Typography.Text>
 			</section>
 
-			<div className="authn-provider__columns">
-				{/* Left Column - Core SAML Settings */}
-				<div className="authn-provider__left">
-					<div className="authn-provider__field-group">
-						<label className="authn-provider__label" htmlFor="saml-domain">
-							Domain
-							<Tooltip title="The email domain for users who should use SSO (e.g., `example.com` for users with `@example.com` emails)">
-								<CircleHelp size={14} color={Style.L3_FOREGROUND} cursor="help" />
-							</Tooltip>
-						</label>
-						<Form.Item
-							name="name"
-							className="authn-provider__form-item"
-							rules={[
-								{ required: true, message: 'Domain is required', whitespace: true },
-							]}
-						>
-							<Input id="saml-domain" disabled={!isCreate} />
-						</Form.Item>
-					</div>
+			<Form.Item
+				label="Domain"
+				name="name"
+				tooltip={{
+					title:
+						'The email domain for users who should use SSO (e.g., `example.com` for users with `@example.com` emails)',
+				}}
+			>
+				<Input disabled={!isCreate} />
+			</Form.Item>
 
-					<div className="authn-provider__field-group">
-						<label className="authn-provider__label" htmlFor="saml-acs-url">
-							SAML ACS URL
-							<Tooltip title="The SSO endpoint of the SAML identity provider. It can typically be found in the SingleSignOnService element in the SAML metadata of the identity provider.">
-								<CircleHelp size={14} color={Style.L3_FOREGROUND} cursor="help" />
-							</Tooltip>
-						</label>
-						<Form.Item
-							name={['samlConfig', 'samlIdp']}
-							className="authn-provider__form-item"
-							rules={[
-								{
-									required: true,
-									message: 'SAML ACS URL is required',
-									whitespace: true,
-								},
-							]}
-						>
-							<Input id="saml-acs-url" />
-						</Form.Item>
-					</div>
+			<Form.Item
+				label="SAML ACS URL"
+				name={['samlConfig', 'samlIdp']}
+				tooltip={{
+					title: `The SSO endpoint of the SAML identity provider. It can typically be found in the SingleSignOnService element in the SAML metadata of the identity provider. Example: <md:SingleSignOnService Binding="urn:oasis:names:tc:SAML:2.0:bindings:HTTP-POST" Location="{samlIdp}"/>`,
+				}}
+			>
+				<Input />
+			</Form.Item>
 
-					<div className="authn-provider__field-group">
-						<label className="authn-provider__label" htmlFor="saml-entity-id">
-							SAML Entity ID
-							<Tooltip title="The entityID of the SAML identity provider. It can typically be found in the EntityID attribute of the EntityDescriptor element in the SAML metadata.">
-								<CircleHelp size={14} color={Style.L3_FOREGROUND} cursor="help" />
-							</Tooltip>
-						</label>
-						<Form.Item
-							name={['samlConfig', 'samlEntity']}
-							className="authn-provider__form-item"
-							rules={[
-								{
-									required: true,
-									message: 'SAML Entity ID is required',
-									whitespace: true,
-								},
-							]}
-						>
-							<Input id="saml-entity-id" />
-						</Form.Item>
-					</div>
+			<Form.Item
+				label="SAML Entity ID"
+				name={['samlConfig', 'samlEntity']}
+				tooltip={{
+					title: `The entityID of the SAML identity provider. It can typically be found in the EntityID attribute of the EntityDescriptor element in the SAML metadata of the identity provider. Example: <md:EntityDescriptor xmlns:md="urn:oasis:names:tc:SAML:2.0:metadata" entityID="{samlEntity}">`,
+				}}
+			>
+				<Input />
+			</Form.Item>
 
-					<div className="authn-provider__field-group">
-						<label className="authn-provider__label" htmlFor="saml-certificate">
-							SAML X.509 Certificate
-							<Tooltip title="The certificate of the SAML identity provider. It can typically be found in the X509Certificate element in the SAML metadata.">
-								<CircleHelp size={14} color={Style.L3_FOREGROUND} cursor="help" />
-							</Tooltip>
-						</label>
-						<Form.Item
-							name={['samlConfig', 'samlCert']}
-							className="authn-provider__form-item"
-							rules={[
-								{
-									required: true,
-									message: 'SAML Certificate is required',
-									whitespace: true,
-								},
-							]}
-						>
-							<TextArea
-								id="saml-certificate"
-								rows={3}
-								placeholder="Paste X.509 certificate"
-								className="authn-provider__textarea"
-							/>
-						</Form.Item>
-					</div>
+			<Form.Item
+				label="SAML X.509 Certificate"
+				name={['samlConfig', 'samlCert']}
+				tooltip={{
+					title: `The certificate of the SAML identity provider. It can typically be found in the X509Certificate element in the SAML metadata of the identity provider. Example: <ds:X509Certificate><ds:X509Certificate>{samlCert}</ds:X509Certificate></ds:X509Certificate>`,
+				}}
+			>
+				<Input.TextArea rows={4} />
+			</Form.Item>
 
-					<div className="authn-provider__checkbox-row">
-						<Form.Item
-							name={['samlConfig', 'insecureSkipAuthNRequestsSigned']}
-							valuePropName="checked"
-							noStyle
-						>
-							<Checkbox
-								id="saml-skip-signing"
-								labelName="Skip Signing AuthN Requests"
-								onCheckedChange={(checked: boolean): void => {
-									form.setFieldValue(
-										['samlConfig', 'insecureSkipAuthNRequestsSigned'],
-										checked,
-									);
-								}}
-							/>
-						</Form.Item>
-						<Tooltip title="Whether to skip signing the SAML requests. For providers like JumpCloud, this should be enabled.">
-							<CircleHelp size={14} color={Style.L3_FOREGROUND} cursor="help" />
-						</Tooltip>
-					</div>
+			<Form.Item
+				label="Skip Signing AuthN Requests"
+				name={['samlConfig', 'insecureSkipAuthNRequestsSigned']}
+				valuePropName="checked"
+				className="field"
+				tooltip={{
+					title: `Whether to skip signing the SAML requests. It can typically be found in the WantAuthnRequestsSigned attribute of the IDPSSODescriptor element in the SAML metadata of the identity provider. Example: <md:IDPSSODescriptor WantAuthnRequestsSigned="false" protocolSupportEnumeration="urn:oasis:names:tc:SAML:2.0:protocol">
+					For providers like jumpcloud, this should be set to true.Note: This is the reverse of WantAuthnRequestsSigned. If WantAuthnRequestsSigned is false, then InsecureSkipAuthNRequestsSigned should be true.`,
+				}}
+			>
+				<Checkbox />
+			</Form.Item>
 
-					<Callout
-						type="warning"
-						size="small"
-						showIcon
-						description="SAML won't be enabled unless you enter all the attributes above"
-						className="callout"
-					/>
-				</div>
-
-				{/* Right Column - Advanced Settings */}
-				<div className="authn-provider__right">
-					<AttributeMappingSection
-						fieldNamePrefix={['samlConfig', 'attributeMapping']}
-						isExpanded={expandedSection === 'attribute-mapping'}
-						onExpandChange={handleAttributeMappingChange}
-					/>
-
-					<RoleMappingSection
-						fieldNamePrefix={['roleMapping']}
-						isExpanded={expandedSection === 'role-mapping'}
-						onExpandChange={handleRoleMappingChange}
-					/>
-				</div>
-			</div>
+			<Callout
+				type="warning"
+				size="small"
+				showIcon
+				description="SAML won’t be enabled unless you enter all the attributes above"
+				className="callout"
+			/>
 		</div>
 	);
 }

frontend/src/container/OrganizationSettings/AuthDomain/CreateEdit/Providers/Providers.styles.scss

@@ -1,240 +1,24 @@
-.authn-provider {
+.google-auth {
 	display: flex;
 	flex-direction: column;
 
-	&__header {
-		display: flex;
-		flex-direction: column;
-		gap: 4px;
-		margin-bottom: 16px;
+	.ant-form-item {
+		margin-bottom: 12px !important;
 	}
 
-	&__title {
-		margin: 0;
-		color: var(--l1-foreground);
-		font-family: 'Inter', sans-serif;
-		font-size: 14px;
-		font-weight: 600;
-		line-height: 20px;
-	}
-
-	&__description {
-		margin: 0;
-		color: var(--l2-foreground);
-		font-family: 'Inter', sans-serif;
-		font-size: 14px;
-		font-weight: 400;
-		line-height: 20px;
-
-		a {
-			color: var(--accent-primary);
-			text-decoration: none;
-
-			&:hover {
-				text-decoration: underline;
-			}
-		}
-	}
-
-	&__columns {
-		display: grid;
-		grid-template-columns: 0.9fr 1fr;
-		gap: 24px;
-	}
-
-	&__left {
-		display: flex;
-		flex-direction: column;
-	}
-
-	&__right {
-		border-left: 1px solid var(--l3-border);
-		padding-left: 24px;
-		display: flex;
-		flex-direction: column;
-	}
-
-	&__field-group {
+	.header {
 		display: flex;
 		flex-direction: column;
 		gap: 4px;
 		margin-bottom: 12px;
-	}
 
-	&__label {
-		display: inline-flex;
-		align-items: center;
-		gap: 6px;
-		color: var(--l1-foreground);
-	}
-
-	&__form-item {
-		margin-bottom: 0 !important;
-	}
-
-	&__checkbox-row {
-		display: flex;
-		align-items: center;
-		gap: 6px;
-		margin-bottom: 12px;
-	}
-
-	input,
-	textarea {
-		height: 32px;
-		background: var(--l3-background) !important;
-		border: 1px solid var(--l3-border) !important;
-		border-radius: 2px;
-		color: var(--l1-foreground) !important;
-
-		&::placeholder {
-			color: var(--l3-foreground) !important;
-			opacity: 1;
+		.title {
+			font-weight: bold;
 		}
 
-		&:hover {
-			border-color: var(--l3-border) !important;
+		.description {
+			margin-bottom: 0px !important;
 		}
-
-		&:focus,
-		&:focus-visible {
-			border-color: var(--primary) !important;
-			box-shadow: none !important;
-			outline: none;
-		}
-	}
-
-	textarea {
-		height: auto;
-	}
-	&__textarea {
-		min-height: 60px !important;
-		max-height: 200px;
-		resize: vertical;
-		background: var(--l3-background) !important;
-		border: 1px solid var(--l3-border) !important;
-		border-radius: 2px;
-		color: var(--l1-foreground) !important;
-		font-family: 'SF Mono', monospace;
-		font-size: 12px;
-		line-height: 18px;
-
-		&::placeholder {
-			color: var(--l3-foreground) !important;
-			font-family: Inter, sans-serif;
-		}
-
-		&:hover {
-			border-color: var(--l3-border) !important;
-		}
-
-		&:focus,
-		&:focus-visible {
-			border-color: var(--primary) !important;
-			box-shadow: none !important;
-			outline: none;
-		}
-	}
-
-	button[role='checkbox'] {
-		border: 1px solid var(--l2-foreground) !important;
-		border-radius: 2px;
-
-		&[data-state='checked'] {
-			background-color: var(--primary) !important;
-			border-color: var(--primary) !important;
-		}
-	}
-
-	&__collapse {
-		background: transparent !important;
-
-		.ant-collapse-item {
-			border: none !important;
-		}
-
-		.ant-collapse-header {
-			padding: 0 !important;
-		}
-
-		.ant-collapse-content {
-			border-top: none !important;
-			background: transparent !important;
-		}
-
-		.ant-collapse-content-box {
-			padding: 12px 0 0 24px !important;
-		}
-	}
-
-	&__collapse-header {
-		display: flex;
-		align-items: flex-start;
-		gap: 8px;
-		cursor: pointer;
-		position: relative;
-		width: 100%;
-
-		svg {
-			margin-top: 2px;
-			color: var(--l3-foreground);
-			flex-shrink: 0;
-		}
-	}
-
-	&__collapse-header-text {
-		display: flex;
-		flex-direction: column;
-		gap: 4px;
-	}
-
-	&__section-title {
-		margin: 0;
-		color: var(--l1-foreground);
-	}
-
-	&__section-description {
-		margin: 0;
-		color: var(--l3-foreground);
-	}
-
-	&__group-content {
-		display: flex;
-		flex-direction: column;
-		gap: 12px;
-	}
-
-	&__group-fields {
-		display: flex;
-		flex-direction: column;
-		gap: 24px;
-		max-height: 45vh;
-		overflow-y: auto;
-		padding-right: 4px;
-
-		.authn-provider__field-group,
-		.authn-provider__checkbox-row {
-			margin-bottom: 0;
-		}
-		&::-webkit-scrollbar {
-			width: 4px;
-		}
-
-		&::-webkit-scrollbar-track {
-			background: transparent;
-		}
-
-		&::-webkit-scrollbar-thumb {
-			background: var(--l3-foreground);
-			border-radius: 4px;
-
-			&:hover {
-				background: var(--l2-foreground);
-			}
-		}
-
-		scrollbar-width: thin;
-		scrollbar-color: var(--l3-foreground) transparent;
 	}
 
 	.callout {

frontend/src/container/OrganizationSettings/AuthDomain/CreateEdit/Providers/components/AttributeMappingSection.styles.scss

@@ -1,128 +0,0 @@
-.attribute-mapping-section {
-	display: flex;
-	flex-direction: column;
-
-	&__collapse {
-		background: transparent !important;
-
-		.ant-collapse-item {
-			border: none !important;
-		}
-
-		.ant-collapse-header {
-			padding: 0 !important;
-		}
-
-		.ant-collapse-content {
-			border-top: none !important;
-			background: transparent !important;
-		}
-
-		.ant-collapse-content-box {
-			padding: 12px 0 0 24px !important;
-		}
-	}
-
-	&__collapse-header {
-		display: flex;
-		align-items: flex-start;
-		gap: 8px;
-		cursor: pointer;
-		position: relative;
-		width: 100%;
-
-		svg {
-			margin-top: 2px;
-			color: var(--l3-foreground);
-			flex-shrink: 0;
-		}
-	}
-
-	&__collapse-header-text {
-		display: flex;
-		flex-direction: column;
-		gap: 4px;
-	}
-
-	&__section-title {
-		margin: 0;
-		color: var(--l1-foreground);
-	}
-
-	&__section-description {
-		margin: 0;
-		color: var(--l3-foreground);
-	}
-
-	&__content {
-		display: flex;
-		flex-direction: column;
-		gap: 16px;
-		max-height: 45vh;
-		overflow-y: auto;
-		padding-right: 4px;
-
-		// Thin scrollbar
-		&::-webkit-scrollbar {
-			width: 4px;
-		}
-
-		&::-webkit-scrollbar-track {
-			background: transparent;
-		}
-
-		&::-webkit-scrollbar-thumb {
-			background: var(--l3-foreground);
-			border-radius: 4px;
-
-			&:hover {
-				background: var(--l2-foreground);
-			}
-		}
-
-		scrollbar-width: thin;
-		scrollbar-color: var(--l3-foreground) transparent;
-	}
-
-	&__field-group {
-		display: flex;
-		flex-direction: column;
-		gap: 4px;
-	}
-
-	&__label {
-		display: inline-flex;
-		align-items: center;
-		gap: 6px;
-		color: var(--l1-foreground);
-	}
-
-	&__form-item {
-		margin-bottom: 0 !important;
-	}
-
-	// todo: https://github.com/SigNoz/components/issues/116
-	input {
-		height: 32px;
-		background: var(--l3-background) !important;
-		border: 1px solid var(--l3-border) !important;
-		border-radius: 2px;
-		color: var(--l1-foreground) !important;
-
-		&::placeholder {
-			color: var(--l3-foreground) !important;
-			opacity: 1;
-		}
-
-		&:hover {
-			border-color: var(--l3-border) !important;
-		}
-
-		&:focus,
-		&:focus-visible {
-			border-color: var(--primary) !important;
-			box-shadow: none !important;
-			outline: none;
-		}
-	}
-}

frontend/src/container/OrganizationSettings/AuthDomain/CreateEdit/Providers/components/AttributeMappingSection.tsx

@@ -1,175 +0,0 @@
-import { useCallback, useState } from 'react';
-import { Color, Style } from '@signozhq/design-tokens';
-import {
-	ChevronDown,
-	ChevronRight,
-	CircleHelp,
-	TriangleAlert,
-} from '@signozhq/icons';
-import { Input } from '@signozhq/input';
-import { Collapse, Form, Tooltip } from 'antd';
-import { useCollapseSectionErrors } from 'hooks/useCollapseSectionErrors';
-
-import './AttributeMappingSection.styles.scss';
-
-interface AttributeMappingSectionProps {
-	fieldNamePrefix: string[];
-	isExpanded?: boolean;
-	onExpandChange?: (expanded: boolean) => void;
-}
-
-function AttributeMappingSection({
-	fieldNamePrefix,
-	isExpanded,
-	onExpandChange,
-}: AttributeMappingSectionProps): JSX.Element {
-	// Support both controlled and uncontrolled modes
-	const [internalExpanded, setInternalExpanded] = useState(false);
-	const isControlled = isExpanded !== undefined;
-	const expanded = isControlled ? isExpanded : internalExpanded;
-
-	const handleCollapseChange = useCallback(
-		(keys: string | string[]): void => {
-			const newExpanded = Array.isArray(keys) ? keys.length > 0 : !!keys;
-			if (isControlled && onExpandChange) {
-				onExpandChange(newExpanded);
-			} else {
-				setInternalExpanded(newExpanded);
-			}
-		},
-		[isControlled, onExpandChange],
-	);
-
-	const collapseActiveKey = expanded ? ['attribute-mapping'] : [];
-	const { hasErrors, errorMessages } = useCollapseSectionErrors(fieldNamePrefix);
-
-	return (
-		<div className="attribute-mapping-section">
-			<Collapse
-				bordered={false}
-				activeKey={collapseActiveKey}
-				onChange={handleCollapseChange}
-				className="attribute-mapping-section__collapse"
-				expandIcon={(): null => null}
-			>
-				<Collapse.Panel
-					key="attribute-mapping"
-					header={
-						<div
-							className="attribute-mapping-section__collapse-header"
-							role="button"
-							aria-expanded={expanded}
-							aria-controls="attribute-mapping-content"
-						>
-							{!expanded ? <ChevronRight size={16} /> : <ChevronDown size={16} />}
-							<div className="attribute-mapping-section__collapse-header-text">
-								<h4 className="attribute-mapping-section__section-title">
-									Attribute Mapping (Advanced)
-								</h4>
-								<p className="attribute-mapping-section__section-description">
-									Configure how SAML assertion attributes from your Identity Provider map
-									to SigNoz user attributes. Leave empty to use default values.
-								</p>
-							</div>
-							{!expanded && hasErrors && (
-								<Tooltip
-									title={
-										<>
-											{errorMessages.map((msg) => (
-												<div key={msg}>{msg}</div>
-											))}
-										</>
-									}
-								>
-									<TriangleAlert size={16} color={Color.BG_CHERRY_500} />
-								</Tooltip>
-							)}
-						</div>
-					}
-				>
-					<div
-						id="attribute-mapping-content"
-						className="attribute-mapping-section__content"
-					>
-						<div className="attribute-mapping-section__field-group">
-							<label
-								className="attribute-mapping-section__label"
-								htmlFor="email-attribute"
-							>
-								Email Attribute
-								<Tooltip title="The SAML attribute key that contains the user's email. Default: 'email'">
-									<CircleHelp size={14} color={Style.L3_FOREGROUND} cursor="help" />
-								</Tooltip>
-							</label>
-							<Form.Item
-								name={[...fieldNamePrefix, 'email']}
-								className="attribute-mapping-section__form-item"
-							>
-								<Input id="email-attribute" placeholder="Email" />
-							</Form.Item>
-						</div>
-
-						{/* Name Attribute */}
-						<div className="attribute-mapping-section__field-group">
-							<label
-								className="attribute-mapping-section__label"
-								htmlFor="name-attribute"
-							>
-								Name Attribute
-								<Tooltip title="The SAML attribute key that contains the user's display name. Default: 'name'">
-									<CircleHelp size={14} color={Style.L3_FOREGROUND} cursor="help" />
-								</Tooltip>
-							</label>
-							<Form.Item
-								name={[...fieldNamePrefix, 'name']}
-								className="attribute-mapping-section__form-item"
-							>
-								<Input id="name-attribute" placeholder="Name" />
-							</Form.Item>
-						</div>
-
-						{/* Groups Attribute */}
-						<div className="attribute-mapping-section__field-group">
-							<label
-								className="attribute-mapping-section__label"
-								htmlFor="groups-attribute"
-							>
-								Groups Attribute
-								<Tooltip title="The SAML attribute key that contains the user's group memberships. Used for role mapping. Default: 'groups'">
-									<CircleHelp size={14} color={Style.L3_FOREGROUND} cursor="help" />
-								</Tooltip>
-							</label>
-							<Form.Item
-								name={[...fieldNamePrefix, 'groups']}
-								className="attribute-mapping-section__form-item"
-							>
-								<Input id="groups-attribute" placeholder="Groups" />
-							</Form.Item>
-						</div>
-
-						{/* Role Attribute */}
-						<div className="attribute-mapping-section__field-group">
-							<label
-								className="attribute-mapping-section__label"
-								htmlFor="role-attribute"
-							>
-								Role Attribute
-								<Tooltip title="The SAML attribute key that contains the user's role directly from the IDP. Default: 'role'">
-									<CircleHelp size={14} color={Style.L3_FOREGROUND} cursor="help" />
-								</Tooltip>
-							</label>
-							<Form.Item
-								name={[...fieldNamePrefix, 'role']}
-								className="attribute-mapping-section__form-item"
-							>
-								<Input id="role-attribute" placeholder="Role" />
-							</Form.Item>
-						</div>
-					</div>
-				</Collapse.Panel>
-			</Collapse>
-		</div>
-	);
-}
-
-export default AttributeMappingSection;

frontend/src/container/OrganizationSettings/AuthDomain/CreateEdit/Providers/components/ClaimMappingSection.styles.scss

@@ -1,128 +0,0 @@
-.claim-mapping-section {
-	display: flex;
-	flex-direction: column;
-
-	&__collapse {
-		background: transparent !important;
-
-		.ant-collapse-item {
-			border: none !important;
-		}
-
-		.ant-collapse-header {
-			padding: 0 !important;
-		}
-
-		.ant-collapse-content {
-			border-top: none !important;
-			background: transparent !important;
-		}
-
-		.ant-collapse-content-box {
-			padding: 12px 0 0 24px !important;
-		}
-	}
-
-	&__collapse-header {
-		display: flex;
-		align-items: flex-start;
-		gap: 8px;
-		cursor: pointer;
-		position: relative;
-		width: 100%;
-
-		svg {
-			margin-top: 2px;
-			color: var(--l3-foreground);
-			flex-shrink: 0;
-		}
-	}
-
-	&__collapse-header-text {
-		display: flex;
-		flex-direction: column;
-		gap: 4px;
-	}
-
-	&__section-title {
-		margin: 0;
-		color: var(--l1-foreground);
-	}
-
-	&__section-description {
-		margin: 0;
-		color: var(--l3-foreground);
-	}
-
-	&__content {
-		display: flex;
-		flex-direction: column;
-		gap: 16px;
-		max-height: 45vh;
-		overflow-y: auto;
-		padding-right: 4px;
-
-		// Thin scrollbar
-		&::-webkit-scrollbar {
-			width: 4px;
-		}
-
-		&::-webkit-scrollbar-track {
-			background: transparent;
-		}
-
-		&::-webkit-scrollbar-thumb {
-			background: var(--l3-foreground);
-			border-radius: 4px;
-
-			&:hover {
-				background: var(--l2-foreground);
-			}
-		}
-
-		scrollbar-width: thin;
-		scrollbar-color: var(--l3-foreground) transparent;
-	}
-
-	&__field-group {
-		display: flex;
-		flex-direction: column;
-		gap: 4px;
-	}
-
-	&__label {
-		display: inline-flex;
-		align-items: center;
-		gap: 6px;
-		color: var(--l1-foreground);
-	}
-
-	&__form-item {
-		margin-bottom: 0 !important;
-	}
-
-	// todo: https://github.com/SigNoz/components/issues/116
-	input {
-		height: 32px;
-		background: var(--l3-background) !important;
-		border: 1px solid var(--l3-border) !important;
-		border-radius: 2px;
-		color: var(--l1-foreground) !important;
-
-		&::placeholder {
-			color: var(--l3-foreground) !important;
-			opacity: 1;
-		}
-
-		&:hover {
-			border-color: var(--l3-border) !important;
-		}
-
-		&:focus,
-		&:focus-visible {
-			border-color: var(--primary) !important;
-			box-shadow: none !important;
-			outline: none;
-		}
-	}
-}

frontend/src/container/OrganizationSettings/AuthDomain/CreateEdit/Providers/components/ClaimMappingSection.tsx

@@ -1,161 +0,0 @@
-import { useCallback, useState } from 'react';
-import { Color, Style } from '@signozhq/design-tokens';
-import {
-	ChevronDown,
-	ChevronRight,
-	CircleHelp,
-	TriangleAlert,
-} from '@signozhq/icons';
-import { Input } from '@signozhq/input';
-import { Collapse, Form, Tooltip } from 'antd';
-import { useCollapseSectionErrors } from 'hooks/useCollapseSectionErrors';
-
-import './ClaimMappingSection.styles.scss';
-
-interface ClaimMappingSectionProps {
-	fieldNamePrefix: string[];
-	isExpanded?: boolean;
-	onExpandChange?: (expanded: boolean) => void;
-}
-
-function ClaimMappingSection({
-	fieldNamePrefix,
-	isExpanded,
-	onExpandChange,
-}: ClaimMappingSectionProps): JSX.Element {
-	// Support both controlled and uncontrolled modes
-	const [internalExpanded, setInternalExpanded] = useState(false);
-	const isControlled = isExpanded !== undefined;
-	const expanded = isControlled ? isExpanded : internalExpanded;
-
-	const handleCollapseChange = useCallback(
-		(keys: string | string[]): void => {
-			const newExpanded = Array.isArray(keys) ? keys.length > 0 : !!keys;
-			if (isControlled && onExpandChange) {
-				onExpandChange(newExpanded);
-			} else {
-				setInternalExpanded(newExpanded);
-			}
-		},
-		[isControlled, onExpandChange],
-	);
-
-	const collapseActiveKey = expanded ? ['claim-mapping'] : [];
-	const { hasErrors, errorMessages } = useCollapseSectionErrors(fieldNamePrefix);
-
-	return (
-		<div className="claim-mapping-section">
-			<Collapse
-				bordered={false}
-				activeKey={collapseActiveKey}
-				onChange={handleCollapseChange}
-				className="claim-mapping-section__collapse"
-				expandIcon={(): null => null}
-			>
-				<Collapse.Panel
-					key="claim-mapping"
-					header={
-						<div
-							className="claim-mapping-section__collapse-header"
-							role="button"
-							aria-expanded={expanded}
-							aria-controls="claim-mapping-content"
-						>
-							{!expanded ? <ChevronRight size={16} /> : <ChevronDown size={16} />}
-							<div className="claim-mapping-section__collapse-header-text">
-								<h4 className="claim-mapping-section__section-title">
-									Claim Mapping (Advanced)
-								</h4>
-								<p className="claim-mapping-section__section-description">
-									Configure how claims from your Identity Provider map to SigNoz user
-									attributes. Leave empty to use default values.
-								</p>
-							</div>
-							{!expanded && hasErrors && (
-								<Tooltip
-									title={
-										<>
-											{errorMessages.map((msg) => (
-												<div key={msg}>{msg}</div>
-											))}
-										</>
-									}
-								>
-									<TriangleAlert size={16} color={Color.BG_CHERRY_500} />
-								</Tooltip>
-							)}
-						</div>
-					}
-				>
-					<div id="claim-mapping-content" className="claim-mapping-section__content">
-						{/* Email Claim */}
-						<div className="claim-mapping-section__field-group">
-							<label className="claim-mapping-section__label" htmlFor="email-claim">
-								Email Claim
-								<Tooltip title="The claim key that contains the user's email address. Default: 'email'">
-									<CircleHelp size={14} color={Style.L3_FOREGROUND} cursor="help" />
-								</Tooltip>
-							</label>
-							<Form.Item
-								name={[...fieldNamePrefix, 'email']}
-								className="claim-mapping-section__form-item"
-							>
-								<Input id="email-claim" placeholder="Email" />
-							</Form.Item>
-						</div>
-
-						{/* Name Claim */}
-						<div className="claim-mapping-section__field-group">
-							<label className="claim-mapping-section__label" htmlFor="name-claim">
-								Name Claim
-								<Tooltip title="The claim key that contains the user's display name. Default: 'name'">
-									<CircleHelp size={14} color={Style.L3_FOREGROUND} cursor="help" />
-								</Tooltip>
-							</label>
-							<Form.Item
-								name={[...fieldNamePrefix, 'name']}
-								className="claim-mapping-section__form-item"
-							>
-								<Input id="name-claim" placeholder="Name" />
-							</Form.Item>
-						</div>
-
-						{/* Groups Claim */}
-						<div className="claim-mapping-section__field-group">
-							<label className="claim-mapping-section__label" htmlFor="groups-claim">
-								Groups Claim
-								<Tooltip title="The claim key that contains the user's group memberships. Used for role mapping. Default: 'groups'">
-									<CircleHelp size={14} color={Style.L3_FOREGROUND} cursor="help" />
-								</Tooltip>
-							</label>
-							<Form.Item
-								name={[...fieldNamePrefix, 'groups']}
-								className="claim-mapping-section__form-item"
-							>
-								<Input id="groups-claim" placeholder="Groups" />
-							</Form.Item>
-						</div>
-
-						{/* Role Claim */}
-						<div className="claim-mapping-section__field-group">
-							<label className="claim-mapping-section__label" htmlFor="role-claim">
-								Role Claim
-								<Tooltip title="The claim key that contains the user's role directly from the IDP. Default: 'role'">
-									<CircleHelp size={14} color={Style.L3_FOREGROUND} cursor="help" />
-								</Tooltip>
-							</label>
-							<Form.Item
-								name={[...fieldNamePrefix, 'role']}
-								className="claim-mapping-section__form-item"
-							>
-								<Input id="role-claim" placeholder="Role" />
-							</Form.Item>
-						</div>
-					</div>
-				</Collapse.Panel>
-			</Collapse>
-		</div>
-	);
-}
-
-export default ClaimMappingSection;

frontend/src/container/OrganizationSettings/AuthDomain/CreateEdit/Providers/components/DomainMappingList.styles.scss

@@ -1,103 +0,0 @@
-.domain-mapping-list {
-	display: flex;
-	flex-direction: column;
-	gap: 8px;
-
-	&__header {
-		display: flex;
-		flex-direction: column;
-		gap: 2px;
-		margin-bottom: 4px;
-	}
-
-	&__title {
-		margin: 0;
-		color: var(--l1-foreground);
-	}
-
-	&__description {
-		margin: 0;
-		color: var(--l3-foreground);
-	}
-
-	&__items {
-		display: flex;
-		flex-direction: column;
-		gap: 8px;
-	}
-
-	&__row {
-		display: flex;
-		align-items: flex-start;
-		gap: 8px;
-
-		.ant-form-item {
-			margin-bottom: 0;
-		}
-	}
-
-	&__field {
-		flex: 1;
-	}
-
-	&__remove-btn {
-		flex-shrink: 0;
-		width: 32px !important;
-		height: 32px !important;
-		min-width: 32px !important;
-		padding: 0 !important;
-		border: none !important;
-		border-radius: 2px !important;
-		background: transparent !important;
-		color: var(--destructive) !important;
-		opacity: 0.6 !important;
-		cursor: pointer;
-		transition: background-color 0.2s, opacity 0.2s;
-		box-shadow: none !important;
-		display: flex;
-		align-items: center;
-		justify-content: center;
-
-		svg {
-			color: var(--destructive) !important;
-			width: 12px !important;
-			height: 12px !important;
-		}
-
-		&:hover {
-			background: rgba(229, 72, 77, 0.1) !important;
-			opacity: 0.9 !important;
-			color: var(--destructive) !important;
-
-			svg {
-				color: var(--destructive) !important;
-			}
-		}
-
-		&:active {
-			opacity: 0.7 !important;
-			background: rgba(229, 72, 77, 0.15) !important;
-		}
-	}
-
-	&__add-btn {
-		width: 100%;
-
-		// Ensure icon is visible
-		svg,
-		[class*='icon'] {
-			color: var(--l2-foreground) !important;
-			display: inline-block !important;
-			opacity: 1 !important;
-		}
-
-		&:hover {
-			color: var(--l1-foreground);
-
-			svg,
-			[class*='icon'] {
-				color: var(--l1-foreground) !important;
-			}
-		}
-	}
-}

frontend/src/container/OrganizationSettings/AuthDomain/CreateEdit/Providers/components/DomainMappingList.tsx

@@ -1,87 +0,0 @@
-import { Button } from '@signozhq/button';
-import { Plus, Trash2 } from '@signozhq/icons';
-import { Input } from '@signozhq/input';
-import { Form } from 'antd';
-
-import './DomainMappingList.styles.scss';
-
-const EMAIL_REGEX = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
-
-const validateEmail = (_: unknown, value: string): Promise<void> => {
-	if (!value) {
-		return Promise.reject(new Error('Admin email is required'));
-	}
-	if (!EMAIL_REGEX.test(value)) {
-		return Promise.reject(new Error('Please enter a valid email'));
-	}
-	return Promise.resolve();
-};
-
-interface DomainMappingListProps {
-	fieldNamePrefix: string[];
-}
-
-function DomainMappingList({
-	fieldNamePrefix,
-}: DomainMappingListProps): JSX.Element {
-	return (
-		<div className="domain-mapping-list">
-			<div className="domain-mapping-list__header">
-				<span className="domain-mapping-list__title">
-					Domain to Admin Email Mapping
-				</span>
-				<p className="domain-mapping-list__description">
-					Map workspace domains to admin emails for service account impersonation.
-					Use &quot;*&quot; as a wildcard for any domain.
-				</p>
-			</div>
-
-			<Form.List name={fieldNamePrefix}>
-				{(fields, { add, remove }): JSX.Element => (
-					<div className="domain-mapping-list__items">
-						{fields.map((field) => (
-							<div key={field.key} className="domain-mapping-list__row">
-								<Form.Item
-									name={[field.name, 'domain']}
-									className="domain-mapping-list__field"
-									rules={[{ required: true, message: 'Domain is required' }]}
-								>
-									<Input placeholder="Domain (e.g., example.com or *)" />
-								</Form.Item>
-
-								<Form.Item
-									name={[field.name, 'adminEmail']}
-									className="domain-mapping-list__field"
-									rules={[{ validator: validateEmail }]}
-								>
-									<Input placeholder="Admin Email" />
-								</Form.Item>
-
-								<Button
-									variant="ghost"
-									color="secondary"
-									className="domain-mapping-list__remove-btn"
-									onClick={(): void => remove(field.name)}
-									aria-label="Remove mapping"
-								>
-									<Trash2 size={12} />
-								</Button>
-							</div>
-						))}
-
-						<Button
-							variant="dashed"
-							onClick={(): void => add({ domain: '', adminEmail: '' })}
-							prefixIcon={<Plus size={14} />}
-							className="domain-mapping-list__add-btn"
-						>
-							Add Domain Mapping
-						</Button>
-					</div>
-				)}
-			</Form.List>
-		</div>
-	);
-}
-
-export default DomainMappingList;

frontend/src/container/OrganizationSettings/AuthDomain/CreateEdit/Providers/components/EmailTagInput.styles.scss

@@ -1,28 +0,0 @@
-.email-tag-input {
-	display: flex;
-	flex-direction: column;
-	gap: 4px;
-
-	&__select {
-		width: 100%;
-
-		.ant-select-selector {
-			.ant-select-selection-search {
-				input {
-					height: 32px !important;
-					border: none !important;
-					background: transparent !important;
-					padding: 0 !important;
-					margin: 0 !important;
-					box-shadow: none !important;
-					font-family: inherit !important;
-				}
-			}
-		}
-	}
-
-	&__error {
-		margin: 0;
-		color: var(--destructive);
-	}
-}

frontend/src/container/OrganizationSettings/AuthDomain/CreateEdit/Providers/components/EmailTagInput.tsx

@@ -1,58 +0,0 @@
-import { useCallback, useState } from 'react';
-import { Select, Tooltip } from 'antd';
-
-import './EmailTagInput.styles.scss';
-
-const EMAIL_REGEX = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
-
-interface EmailTagInputProps {
-	value?: string[];
-	onChange?: (value: string[]) => void;
-	placeholder?: string;
-}
-
-function EmailTagInput({
-	value = [],
-	onChange,
-	placeholder = 'Type an email and press Enter',
-}: EmailTagInputProps): JSX.Element {
-	const [validationError, setValidationError] = useState('');
-
-	const handleChange = useCallback(
-		(newValues: string[]): void => {
-			const addedValues = newValues.filter((v) => !value.includes(v));
-			const invalidEmail = addedValues.find((v) => !EMAIL_REGEX.test(v));
-
-			if (invalidEmail) {
-				setValidationError(`"${invalidEmail}" is not a valid email`);
-				return;
-			}
-			setValidationError('');
-			onChange?.(newValues);
-		},
-		[onChange, value],
-	);
-
-	return (
-		<div className="email-tag-input">
-			<Tooltip
-				title={validationError}
-				open={!!validationError}
-				placement="topRight"
-			>
-				<Select
-					mode="tags"
-					value={value}
-					onChange={handleChange}
-					placeholder={placeholder}
-					tokenSeparators={[',', ' ']}
-					className="email-tag-input__select"
-					allowClear
-					status={validationError ? 'error' : undefined}
-				/>
-			</Tooltip>
-		</div>
-	);
-}
-
-export default EmailTagInput;

frontend/src/container/OrganizationSettings/AuthDomain/CreateEdit/Providers/components/RoleMappingSection.styles.scss

@@ -1,288 +0,0 @@
-.role-mapping-section {
-	display: flex;
-	flex-direction: column;
-	margin-top: 24px;
-
-	&__collapse {
-		background: transparent !important;
-
-		.ant-collapse-item {
-			border: none !important;
-		}
-
-		.ant-collapse-header {
-			padding: 0 !important;
-		}
-
-		.ant-collapse-content {
-			border-top: none !important;
-			background: transparent !important;
-		}
-
-		.ant-collapse-content-box {
-			padding: 12px 0 0 24px !important;
-		}
-	}
-
-	&__collapse-header {
-		display: flex;
-		align-items: flex-start;
-		gap: 8px;
-		cursor: pointer;
-		position: relative;
-		width: 100%;
-
-		svg {
-			margin-top: 2px;
-			color: var(--l3-foreground);
-			flex-shrink: 0;
-		}
-	}
-
-	&__collapse-header-text {
-		display: flex;
-		flex-direction: column;
-		gap: 4px;
-	}
-
-	&__section-title {
-		margin: 0;
-		color: var(--l1-foreground);
-	}
-
-	&__section-description {
-		margin: 0;
-		color: var(--l3-foreground);
-	}
-
-	&__content {
-		display: flex;
-		flex-direction: column;
-		gap: 16px;
-		max-height: 45vh;
-		overflow-y: auto;
-		padding-right: 4px;
-
-		// Thin scrollbar
-		&::-webkit-scrollbar {
-			width: 4px;
-		}
-
-		&::-webkit-scrollbar-track {
-			background: transparent;
-		}
-
-		&::-webkit-scrollbar-thumb {
-			background: var(--l3-foreground);
-			border-radius: 4px;
-
-			&:hover {
-				background: var(--l2-foreground);
-			}
-		}
-
-		scrollbar-width: thin;
-		scrollbar-color: var(--l3-foreground) transparent;
-	}
-
-	&__field-group {
-		display: flex;
-		flex-direction: column;
-		gap: 4px;
-	}
-
-	&__label {
-		display: inline-flex;
-		align-items: center;
-		gap: 6px;
-		color: var(--l1-foreground);
-	}
-
-	&__form-item {
-		margin-bottom: 0 !important;
-	}
-
-	&__checkbox-row {
-		display: flex;
-		align-items: center;
-		gap: 6px;
-	}
-
-	&__select {
-		width: 100%;
-
-		&.ant-select {
-			.ant-select-selector {
-				height: 32px;
-				background: var(--l3-background) !important;
-				border: 1px solid var(--l3-border) !important;
-				border-radius: 2px;
-				color: var(--l1-foreground) !important;
-
-				.ant-select-selection-item {
-					color: var(--l1-foreground) !important;
-				}
-			}
-
-			&:hover .ant-select-selector {
-				border-color: var(--l3-border) !important;
-			}
-
-			&.ant-select-focused .ant-select-selector {
-				border-color: var(--primary) !important;
-				box-shadow: none !important;
-			}
-
-			.ant-select-arrow {
-				color: var(--l3-foreground);
-			}
-		}
-	}
-
-	&__group-mappings {
-		display: flex;
-		flex-direction: column;
-		gap: 8px;
-	}
-
-	&__group-header {
-		display: flex;
-		flex-direction: column;
-		gap: 2px;
-		margin-bottom: 4px;
-	}
-
-	&__group-title {
-		margin: 0;
-		color: var(--l1-foreground);
-	}
-
-	&__group-description {
-		margin: 0;
-		color: var(--l3-foreground);
-	}
-
-	&__items {
-		display: flex;
-		flex-direction: column;
-		gap: 8px;
-	}
-
-	&__row {
-		display: flex;
-		align-items: flex-start;
-		gap: 8px;
-
-		.ant-form-item {
-			margin-bottom: 0;
-		}
-	}
-
-	&__field {
-		&--group {
-			flex: 2;
-		}
-
-		&--role {
-			flex: 1;
-			min-width: 120px;
-		}
-	}
-
-	&__remove-btn {
-		flex-shrink: 0;
-		width: 32px !important;
-		height: 32px !important;
-		min-width: 32px !important;
-		padding: 0 !important;
-		border: none !important;
-		border-radius: 2px !important;
-		background: transparent !important;
-		color: var(--destructive) !important;
-		opacity: 0.6 !important;
-		cursor: pointer;
-		transition: background-color 0.2s, opacity 0.2s;
-		box-shadow: none !important;
-		display: flex;
-		align-items: center;
-		justify-content: center;
-
-		svg {
-			color: var(--destructive) !important;
-			width: 12px !important;
-			height: 12px !important;
-		}
-
-		&:hover {
-			background: rgba(229, 72, 77, 0.1) !important;
-			opacity: 0.9 !important;
-			color: var(--destructive) !important;
-
-			svg {
-				color: var(--destructive) !important;
-			}
-		}
-
-		&:active {
-			opacity: 0.7 !important;
-			background: rgba(229, 72, 77, 0.15) !important;
-		}
-	}
-
-	&__add-btn {
-		width: 100%;
-
-		// Ensure icon is visible
-		svg,
-		[class*='icon'] {
-			color: var(--l2-foreground) !important;
-			display: inline-block !important;
-			opacity: 1 !important;
-		}
-
-		&:hover {
-			color: var(--l1-foreground);
-
-			svg,
-			[class*='icon'] {
-				color: var(--l1-foreground) !important;
-			}
-		}
-	}
-
-	// --- Checkbox border visibility ---
-	button[role='checkbox'] {
-		border: 1px solid var(--l2-foreground) !important;
-		border-radius: 2px;
-
-		&[data-state='checked'] {
-			background-color: var(--primary) !important;
-			border-color: var(--primary) !important;
-		}
-	}
-
-	// todo: https://github.com/SigNoz/components/issues/116
-	input {
-		height: 32px;
-		background: var(--l3-background) !important;
-		border: 1px solid var(--l3-border) !important;
-		border-radius: 2px;
-		color: var(--l1-foreground) !important;
-
-		&::placeholder {
-			color: var(--l3-foreground) !important;
-			opacity: 1;
-		}
-
-		&:hover {
-			border-color: var(--l3-border) !important;
-		}
-
-		&:focus,
-		&:focus-visible {
-			border-color: var(--primary) !important;
-			box-shadow: none !important;
-			outline: none;
-		}
-	}
-}

frontend/src/container/OrganizationSettings/AuthDomain/CreateEdit/Providers/components/RoleMappingSection.tsx

@@ -1,216 +0,0 @@
-import { useCallback, useState } from 'react';
-import { Button } from '@signozhq/button';
-import { Checkbox } from '@signozhq/checkbox';
-import { Color, Style } from '@signozhq/design-tokens';
-import {
-	ChevronDown,
-	ChevronRight,
-	CircleHelp,
-	Plus,
-	Trash2,
-	TriangleAlert,
-} from '@signozhq/icons';
-import { Input } from '@signozhq/input';
-import { Collapse, Form, Select, Tooltip } from 'antd';
-import { useCollapseSectionErrors } from 'hooks/useCollapseSectionErrors';
-
-import './RoleMappingSection.styles.scss';
-
-const ROLE_OPTIONS = [
-	{ value: 'VIEWER', label: 'VIEWER' },
-	{ value: 'EDITOR', label: 'EDITOR' },
-	{ value: 'ADMIN', label: 'ADMIN' },
-];
-
-interface RoleMappingSectionProps {
-	fieldNamePrefix: string[];
-	isExpanded?: boolean;
-	onExpandChange?: (expanded: boolean) => void;
-}
-
-function RoleMappingSection({
-	fieldNamePrefix,
-	isExpanded,
-	onExpandChange,
-}: RoleMappingSectionProps): JSX.Element {
-	const form = Form.useFormInstance();
-	const useRoleAttribute = Form.useWatch(
-		[...fieldNamePrefix, 'useRoleAttribute'],
-		form,
-	);
-
-	// Support both controlled and uncontrolled modes
-	const [internalExpanded, setInternalExpanded] = useState(false);
-	const isControlled = isExpanded !== undefined;
-	const expanded = isControlled ? isExpanded : internalExpanded;
-
-	const handleCollapseChange = useCallback(
-		(keys: string | string[]): void => {
-			const newExpanded = Array.isArray(keys) ? keys.length > 0 : !!keys;
-			if (isControlled && onExpandChange) {
-				onExpandChange(newExpanded);
-			} else {
-				setInternalExpanded(newExpanded);
-			}
-		},
-		[isControlled, onExpandChange],
-	);
-
-	const collapseActiveKey = expanded ? ['role-mapping'] : [];
-	const { hasErrors, errorMessages } = useCollapseSectionErrors(fieldNamePrefix);
-
-	return (
-		<div className="role-mapping-section">
-			<Collapse
-				bordered={false}
-				activeKey={collapseActiveKey}
-				onChange={handleCollapseChange}
-				className="role-mapping-section__collapse"
-				expandIcon={(): null => null}
-			>
-				<Collapse.Panel
-					key="role-mapping"
-					header={
-						<div
-							className="role-mapping-section__collapse-header"
-							role="button"
-							aria-expanded={expanded}
-							aria-controls="role-mapping-content"
-						>
-							{!expanded ? <ChevronRight size={16} /> : <ChevronDown size={16} />}
-							<div className="role-mapping-section__collapse-header-text">
-								<h4 className="role-mapping-section__section-title">
-									Role Mapping (Advanced)
-								</h4>
-								<p className="role-mapping-section__section-description">
-									Configure how user roles are determined from your Identity Provider.
-									You can either use a direct role attribute or map IDP groups to SigNoz
-									roles.
-								</p>
-							</div>
-							{!expanded && hasErrors && (
-								<Tooltip
-									title={
-										<>
-											{errorMessages.map((msg) => (
-												<div key={msg}>{msg}</div>
-											))}
-										</>
-									}
-								>
-									<TriangleAlert size={16} color={Color.BG_CHERRY_500} />
-								</Tooltip>
-							)}
-						</div>
-					}
-				>
-					<div id="role-mapping-content" className="role-mapping-section__content">
-						<div className="role-mapping-section__field-group">
-							<label className="role-mapping-section__label" htmlFor="default-role">
-								Default Role
-								<Tooltip title='The default role assigned to new SSO users if no other role mapping applies. Default: "VIEWER"'>
-									<CircleHelp size={14} color={Style.L3_FOREGROUND} cursor="help" />
-								</Tooltip>
-							</label>
-							<Form.Item
-								name={[...fieldNamePrefix, 'defaultRole']}
-								className="role-mapping-section__form-item"
-								initialValue="VIEWER"
-							>
-								<Select
-									id="default-role"
-									options={ROLE_OPTIONS}
-									className="role-mapping-section__select"
-								/>
-							</Form.Item>
-						</div>
-
-						<div className="role-mapping-section__checkbox-row">
-							<Form.Item
-								name={[...fieldNamePrefix, 'useRoleAttribute']}
-								valuePropName="checked"
-								noStyle
-							>
-								<Checkbox
-									id="use-role-attribute"
-									labelName="Use Role Attribute Directly"
-									onCheckedChange={(checked: boolean): void => {
-										form.setFieldValue([...fieldNamePrefix, 'useRoleAttribute'], checked);
-									}}
-								/>
-							</Form.Item>
-							<Tooltip title="If enabled, the role claim/attribute from the IDP will be used directly instead of group mappings. The role value must match a SigNoz role (VIEWER, EDITOR, or ADMIN).">
-								<CircleHelp size={14} color={Style.L3_FOREGROUND} cursor="help" />
-							</Tooltip>
-						</div>
-
-						{!useRoleAttribute && (
-							<div className="role-mapping-section__group-mappings">
-								<div className="role-mapping-section__group-header">
-									<span className="role-mapping-section__group-title">
-										Group to Role Mappings
-									</span>
-									<p className="role-mapping-section__group-description">
-										Map IDP group names to SigNoz roles. If a user belongs to multiple
-										groups, the highest privilege role will be assigned.
-									</p>
-								</div>
-
-								<Form.List name={[...fieldNamePrefix, 'groupMappingsList']}>
-									{(fields, { add, remove }): JSX.Element => (
-										<div className="role-mapping-section__items">
-											{fields.map((field) => (
-												<div key={field.key} className="role-mapping-section__row">
-													<Form.Item
-														name={[field.name, 'groupName']}
-														className="role-mapping-section__field role-mapping-section__field--group"
-														rules={[{ required: true, message: 'Group name is required' }]}
-													>
-														<Input placeholder="IDP Group Name" />
-													</Form.Item>
-
-													<Form.Item
-														name={[field.name, 'role']}
-														className="role-mapping-section__field role-mapping-section__field--role"
-														rules={[{ required: true, message: 'Role is required' }]}
-														initialValue="VIEWER"
-													>
-														<Select
-															options={ROLE_OPTIONS}
-															className="role-mapping-section__select"
-														/>
-													</Form.Item>
-
-													<Button
-														variant="ghost"
-														color="secondary"
-														className="role-mapping-section__remove-btn"
-														onClick={(): void => remove(field.name)}
-														aria-label="Remove mapping"
-													>
-														<Trash2 size={12} />
-													</Button>
-												</div>
-											))}
-
-											<Button
-												variant="dashed"
-												onClick={(): void => add({ groupName: '', role: 'VIEWER' })}
-												prefixIcon={<Plus size={14} />}
-												className="role-mapping-section__add-btn"
-											>
-												Add Group Mapping
-											</Button>
-										</div>
-									)}
-								</Form.List>
-							</div>
-						)}
-					</div>
-				</Collapse.Panel>
-			</Collapse>
-		</div>
-	);
-}
-
-export default RoleMappingSection;

frontend/src/container/OrganizationSettings/AuthDomain/SSOEnforcementToggle.tsx

@@ -1,77 +0,0 @@
-import { useEffect, useState } from 'react';
-import { Switch } from '@signozhq/switch';
-import { ErrorResponseHandlerV2 } from 'api/ErrorResponseHandlerV2';
-import { useUpdateAuthDomain } from 'api/generated/services/authdomains';
-import {
-	AuthtypesGettableAuthDomainDTO,
-	RenderErrorResponseDTO,
-} from 'api/generated/services/sigNoz.schemas';
-import { AxiosError } from 'axios';
-import { useErrorModal } from 'providers/ErrorModalProvider';
-import { ErrorV2Resp } from 'types/api';
-import APIError from 'types/api/error';
-
-interface SSOEnforcementToggleProps {
-	isDefaultChecked: boolean;
-	record: AuthtypesGettableAuthDomainDTO;
-}
-
-function SSOEnforcementToggle({
-	isDefaultChecked,
-	record,
-}: SSOEnforcementToggleProps): JSX.Element {
-	const [isChecked, setIsChecked] = useState<boolean>(isDefaultChecked);
-	const { showErrorModal } = useErrorModal();
-
-	useEffect(() => {
-		setIsChecked(isDefaultChecked);
-	}, [isDefaultChecked]);
-
-	const { mutate: updateAuthDomain, isLoading } = useUpdateAuthDomain<
-		AxiosError<RenderErrorResponseDTO>
-	>();
-
-	const onChangeHandler = (checked: boolean): void => {
-		if (!record.id) {
-			return;
-		}
-
-		setIsChecked(checked);
-
-		updateAuthDomain(
-			{
-				pathParams: { id: record.id },
-				data: {
-					config: {
-						ssoEnabled: checked,
-						ssoType: record.ssoType,
-						googleAuthConfig: record.googleAuthConfig,
-						oidcConfig: record.oidcConfig,
-						samlConfig: record.samlConfig,
-						roleMapping: record.roleMapping,
-					},
-				},
-			},
-			{
-				onError: (error) => {
-					setIsChecked(!checked);
-					try {
-						ErrorResponseHandlerV2(error as AxiosError<ErrorV2Resp>);
-					} catch (apiError) {
-						showErrorModal(apiError as APIError);
-					}
-				},
-			},
-		);
-	};
-
-	return (
-		<Switch
-			disabled={isLoading}
-			checked={isChecked}
-			onCheckedChange={onChangeHandler}
-		/>
-	);
-}
-
-export default SSOEnforcementToggle;

frontend/src/container/OrganizationSettings/AuthDomain/Toggle.tsx

@@ -0,0 +1,45 @@
+import { useState } from 'react';
+import { Switch } from 'antd';
+import put from 'api/v1/domains/id/put';
+import { useErrorModal } from 'providers/ErrorModalProvider';
+import APIError from 'types/api/error';
+import { GettableAuthDomain } from 'types/api/v1/domains/list';
+
+function Toggle({ isDefaultChecked, record }: ToggleProps): JSX.Element {
+	const [isChecked, setIsChecked] = useState<boolean>(isDefaultChecked);
+	const [isLoading, setIsLoading] = useState<boolean>(false);
+	const { showErrorModal } = useErrorModal();
+
+	const onChangeHandler = async (checked: boolean): Promise<void> => {
+		setIsLoading(true);
+
+		try {
+			await put({
+				id: record.id,
+				config: {
+					ssoEnabled: checked,
+					ssoType: record.ssoType,
+					googleAuthConfig: record.googleAuthConfig,
+					oidcConfig: record.oidcConfig,
+					samlConfig: record.samlConfig,
+				},
+			});
+			setIsChecked(checked);
+		} catch (error) {
+			showErrorModal(error as APIError);
+		}
+
+		setIsLoading(false);
+	};
+
+	return (
+		<Switch loading={isLoading} checked={isChecked} onChange={onChangeHandler} />
+	);
+}
+
+interface ToggleProps {
+	isDefaultChecked: boolean;
+	record: GettableAuthDomain;
+}
+
+export default Toggle;

frontend/src/container/OrganizationSettings/AuthDomain/__tests__/AuthDomain.test.tsx

@@ -1,138 +0,0 @@
-import { rest, server } from 'mocks-server/server';
-import { render, screen, userEvent, waitFor } from 'tests/test-utils';
-
-import AuthDomain from '../index';
-import {
-	AUTH_DOMAINS_LIST_ENDPOINT,
-	mockDomainsListResponse,
-	mockEmptyDomainsResponse,
-	mockErrorResponse,
-} from './mocks';
-
-jest.mock('@signozhq/sonner', () => ({
-	toast: {
-		success: jest.fn(),
-		error: jest.fn(),
-	},
-}));
-
-describe('AuthDomain', () => {
-	beforeEach(() => {
-		jest.clearAllMocks();
-	});
-
-	afterEach(() => {
-		server.resetHandlers();
-	});
-
-	describe('List View', () => {
-		it('renders page header and add button', async () => {
-			server.use(
-				rest.get(AUTH_DOMAINS_LIST_ENDPOINT, (_, res, ctx) =>
-					res(ctx.status(200), ctx.json(mockEmptyDomainsResponse)),
-				),
-			);
-
-			render(<AuthDomain />);
-
-			expect(screen.getByText(/authenticated domains/i)).toBeInTheDocument();
-			expect(
-				screen.getByRole('button', { name: /add domain/i }),
-			).toBeInTheDocument();
-		});
-
-		it('renders list of auth domains successfully', async () => {
-			server.use(
-				rest.get(AUTH_DOMAINS_LIST_ENDPOINT, (_, res, ctx) =>
-					res(ctx.status(200), ctx.json(mockDomainsListResponse)),
-				),
-			);
-
-			render(<AuthDomain />);
-
-			await waitFor(() => {
-				expect(screen.getByText('signoz.io')).toBeInTheDocument();
-				expect(screen.getByText('example.com')).toBeInTheDocument();
-				expect(screen.getByText('corp.io')).toBeInTheDocument();
-			});
-		});
-
-		it('renders empty state when no domains exist', async () => {
-			server.use(
-				rest.get(AUTH_DOMAINS_LIST_ENDPOINT, (_, res, ctx) =>
-					res(ctx.status(200), ctx.json(mockEmptyDomainsResponse)),
-				),
-			);
-
-			render(<AuthDomain />);
-
-			await waitFor(() => {
-				expect(screen.getByText(/no data/i)).toBeInTheDocument();
-			});
-		});
-
-		it('displays error content when API fails', async () => {
-			server.use(
-				rest.get(AUTH_DOMAINS_LIST_ENDPOINT, (_, res, ctx) =>
-					res(ctx.status(500), ctx.json(mockErrorResponse)),
-				),
-			);
-
-			render(<AuthDomain />);
-
-			await waitFor(() => {
-				expect(
-					screen.getByText(/failed to perform operation/i),
-				).toBeInTheDocument();
-			});
-		});
-	});
-
-	describe('Add Domain', () => {
-		it('opens create modal when Add Domain button is clicked', async () => {
-			const user = userEvent.setup({ pointerEventsCheck: 0 });
-
-			server.use(
-				rest.get(AUTH_DOMAINS_LIST_ENDPOINT, (_, res, ctx) =>
-					res(ctx.status(200), ctx.json(mockEmptyDomainsResponse)),
-				),
-			);
-
-			render(<AuthDomain />);
-
-			const addButton = await screen.findByRole('button', { name: /add domain/i });
-			await user.click(addButton);
-
-			await waitFor(() => {
-				expect(
-					screen.getByText(/configure authentication method/i),
-				).toBeInTheDocument();
-			});
-		});
-	});
-
-	describe('Configure Domain', () => {
-		it('opens edit modal when configure action is clicked', async () => {
-			const user = userEvent.setup({ pointerEventsCheck: 0 });
-
-			server.use(
-				rest.get(AUTH_DOMAINS_LIST_ENDPOINT, (_, res, ctx) =>
-					res(ctx.status(200), ctx.json(mockDomainsListResponse)),
-				),
-			);
-
-			render(<AuthDomain />);
-
-			await waitFor(() => {
-				expect(screen.getByText('signoz.io')).toBeInTheDocument();
-			});
-
-			const configureLinks = await screen.findAllByText(/configure google auth/i);
-			await user.click(configureLinks[0]);
-
-			await waitFor(() => {
-				expect(screen.getByText(/edit google authentication/i)).toBeInTheDocument();
-			});
-		});
-	});
-});

frontend/src/container/OrganizationSettings/AuthDomain/__tests__/CreateEdit.test.tsx

@@ -1,354 +0,0 @@
-import { render, screen, userEvent, waitFor } from 'tests/test-utils';
-
-import CreateEdit from '../CreateEdit/CreateEdit';
-import {
-	mockDomainWithRoleMapping,
-	mockGoogleAuthDomain,
-	mockGoogleAuthWithWorkspaceGroups,
-	mockOidcAuthDomain,
-	mockOidcWithClaimMapping,
-	mockSamlAuthDomain,
-	mockSamlWithAttributeMapping,
-} from './mocks';
-
-const mockOnClose = jest.fn();
-
-describe('CreateEdit Modal', () => {
-	beforeEach(() => {
-		jest.clearAllMocks();
-	});
-
-	describe('Provider Selection (Create Mode)', () => {
-		it('renders provider selection when creating new domain', () => {
-			render(<CreateEdit isCreate onClose={mockOnClose} />);
-
-			expect(
-				screen.getByText(/configure authentication method/i),
-			).toBeInTheDocument();
-			expect(screen.getByText(/google apps authentication/i)).toBeInTheDocument();
-			expect(screen.getByText(/saml authentication/i)).toBeInTheDocument();
-			expect(screen.getByText(/oidc authentication/i)).toBeInTheDocument();
-		});
-
-		it('returns to provider selection when back button is clicked', async () => {
-			const user = userEvent.setup({ pointerEventsCheck: 0 });
-
-			render(<CreateEdit isCreate onClose={mockOnClose} />);
-
-			const configureButtons = await screen.findAllByRole('button', {
-				name: /configure/i,
-			});
-			await user.click(configureButtons[0]);
-
-			await waitFor(() => {
-				expect(screen.getByText(/edit google authentication/i)).toBeInTheDocument();
-			});
-
-			const backButton = screen.getByRole('button', { name: /back/i });
-			await user.click(backButton);
-
-			await waitFor(() => {
-				expect(
-					screen.getByText(/configure authentication method/i),
-				).toBeInTheDocument();
-			});
-		});
-	});
-
-	describe('Edit Mode', () => {
-		it('shows provider form directly when editing existing domain', () => {
-			render(
-				<CreateEdit
-					isCreate={false}
-					record={mockGoogleAuthDomain}
-					onClose={mockOnClose}
-				/>,
-			);
-
-			expect(screen.getByText(/edit google authentication/i)).toBeInTheDocument();
-			expect(
-				screen.queryByText(/configure authentication method/i),
-			).not.toBeInTheDocument();
-		});
-
-		it('pre-fills form with existing domain values', () => {
-			render(
-				<CreateEdit
-					isCreate={false}
-					record={mockGoogleAuthDomain}
-					onClose={mockOnClose}
-				/>,
-			);
-
-			expect(screen.getByDisplayValue('signoz.io')).toBeInTheDocument();
-			expect(screen.getByDisplayValue('test-client-id')).toBeInTheDocument();
-		});
-
-		it('disables domain field when editing', () => {
-			render(
-				<CreateEdit
-					isCreate={false}
-					record={mockGoogleAuthDomain}
-					onClose={mockOnClose}
-				/>,
-			);
-
-			const domainInput = screen.getByDisplayValue('signoz.io');
-			expect(domainInput).toBeDisabled();
-		});
-
-		it('shows cancel button instead of back when editing', () => {
-			render(
-				<CreateEdit
-					isCreate={false}
-					record={mockGoogleAuthDomain}
-					onClose={mockOnClose}
-				/>,
-			);
-
-			expect(screen.getByRole('button', { name: /cancel/i })).toBeInTheDocument();
-			expect(
-				screen.queryByRole('button', { name: /back/i }),
-			).not.toBeInTheDocument();
-		});
-	});
-
-	describe('Form Validation', () => {
-		it('shows validation error when submitting without required fields', async () => {
-			const user = userEvent.setup({ pointerEventsCheck: 0 });
-
-			render(<CreateEdit isCreate onClose={mockOnClose} />);
-
-			const configureButtons = await screen.findAllByRole('button', {
-				name: /configure/i,
-			});
-			await user.click(configureButtons[0]);
-
-			const saveButton = await screen.findByRole('button', {
-				name: /save changes/i,
-			});
-			await user.click(saveButton);
-
-			await waitFor(() => {
-				expect(screen.getByText(/domain is required/i)).toBeInTheDocument();
-			});
-		});
-	});
-
-	describe('Google Auth Provider', () => {
-		it('shows Google Auth form fields', async () => {
-			const user = userEvent.setup({ pointerEventsCheck: 0 });
-
-			render(<CreateEdit isCreate onClose={mockOnClose} />);
-
-			const configureButtons = await screen.findAllByRole('button', {
-				name: /configure/i,
-			});
-			await user.click(configureButtons[0]);
-
-			await waitFor(() => {
-				expect(screen.getByText(/edit google authentication/i)).toBeInTheDocument();
-				expect(screen.getByLabelText(/domain/i)).toBeInTheDocument();
-				expect(screen.getByLabelText(/client id/i)).toBeInTheDocument();
-				expect(screen.getByLabelText(/client secret/i)).toBeInTheDocument();
-				expect(screen.getByText(/skip email verification/i)).toBeInTheDocument();
-			});
-		});
-
-		it('shows workspace groups section when expanded', async () => {
-			const user = userEvent.setup({ pointerEventsCheck: 0 });
-
-			render(
-				<CreateEdit
-					isCreate={false}
-					record={mockGoogleAuthWithWorkspaceGroups}
-					onClose={mockOnClose}
-				/>,
-			);
-
-			const workspaceHeader = screen.getByText(/google workspace groups/i);
-			await user.click(workspaceHeader);
-
-			await waitFor(() => {
-				expect(screen.getByText(/fetch groups/i)).toBeInTheDocument();
-				expect(screen.getByText(/service account json/i)).toBeInTheDocument();
-			});
-		});
-	});
-
-	describe('SAML Provider', () => {
-		it('shows SAML-specific fields when editing SAML domain', () => {
-			render(
-				<CreateEdit
-					isCreate={false}
-					record={mockSamlAuthDomain}
-					onClose={mockOnClose}
-				/>,
-			);
-
-			expect(screen.getByText(/edit saml authentication/i)).toBeInTheDocument();
-			expect(
-				screen.getByDisplayValue('https://idp.example.com/sso'),
-			).toBeInTheDocument();
-			expect(screen.getByDisplayValue('urn:example:idp')).toBeInTheDocument();
-		});
-
-		it('shows attribute mapping section for SAML', async () => {
-			const user = userEvent.setup({ pointerEventsCheck: 0 });
-
-			render(
-				<CreateEdit
-					isCreate={false}
-					record={mockSamlWithAttributeMapping}
-					onClose={mockOnClose}
-				/>,
-			);
-
-			expect(
-				screen.getByText(/attribute mapping \(advanced\)/i),
-			).toBeInTheDocument();
-
-			const attributeHeader = screen.getByText(/attribute mapping \(advanced\)/i);
-			await user.click(attributeHeader);
-
-			await waitFor(() => {
-				expect(screen.getByLabelText(/name attribute/i)).toBeInTheDocument();
-				expect(screen.getByLabelText(/groups attribute/i)).toBeInTheDocument();
-				expect(screen.getByLabelText(/role attribute/i)).toBeInTheDocument();
-			});
-		});
-	});
-
-	describe('OIDC Provider', () => {
-		it('shows OIDC-specific fields when editing OIDC domain', () => {
-			render(
-				<CreateEdit
-					isCreate={false}
-					record={mockOidcAuthDomain}
-					onClose={mockOnClose}
-				/>,
-			);
-
-			expect(screen.getByText(/edit oidc authentication/i)).toBeInTheDocument();
-			expect(screen.getByDisplayValue('https://oidc.corp.io')).toBeInTheDocument();
-			expect(screen.getByDisplayValue('oidc-client-id')).toBeInTheDocument();
-		});
-
-		it('shows claim mapping section for OIDC', async () => {
-			const user = userEvent.setup({ pointerEventsCheck: 0 });
-
-			render(
-				<CreateEdit
-					isCreate={false}
-					record={mockOidcWithClaimMapping}
-					onClose={mockOnClose}
-				/>,
-			);
-
-			expect(screen.getByText(/claim mapping \(advanced\)/i)).toBeInTheDocument();
-
-			const claimHeader = screen.getByText(/claim mapping \(advanced\)/i);
-			await user.click(claimHeader);
-
-			await waitFor(() => {
-				expect(screen.getByLabelText(/email claim/i)).toBeInTheDocument();
-				expect(screen.getByLabelText(/name claim/i)).toBeInTheDocument();
-				expect(screen.getByLabelText(/groups claim/i)).toBeInTheDocument();
-				expect(screen.getByLabelText(/role claim/i)).toBeInTheDocument();
-			});
-		});
-
-		it('shows OIDC options checkboxes', () => {
-			render(
-				<CreateEdit
-					isCreate={false}
-					record={mockOidcAuthDomain}
-					onClose={mockOnClose}
-				/>,
-			);
-
-			expect(screen.getByText(/skip email verification/i)).toBeInTheDocument();
-			expect(screen.getByText(/get user info/i)).toBeInTheDocument();
-		});
-	});
-
-	describe('Role Mapping', () => {
-		it('shows role mapping section in provider forms', async () => {
-			const user = userEvent.setup({ pointerEventsCheck: 0 });
-
-			render(<CreateEdit isCreate onClose={mockOnClose} />);
-
-			const configureButtons = await screen.findAllByRole('button', {
-				name: /configure/i,
-			});
-			await user.click(configureButtons[0]);
-
-			await waitFor(() => {
-				expect(screen.getByText(/role mapping \(advanced\)/i)).toBeInTheDocument();
-			});
-		});
-
-		it('expands role mapping section to show default role selector', async () => {
-			const user = userEvent.setup({ pointerEventsCheck: 0 });
-
-			render(
-				<CreateEdit
-					isCreate={false}
-					record={mockDomainWithRoleMapping}
-					onClose={mockOnClose}
-				/>,
-			);
-
-			const roleMappingHeader = screen.getByText(/role mapping \(advanced\)/i);
-			await user.click(roleMappingHeader);
-
-			await waitFor(() => {
-				expect(screen.getByText(/default role/i)).toBeInTheDocument();
-				expect(
-					screen.getByText(/use role attribute directly/i),
-				).toBeInTheDocument();
-			});
-		});
-
-		it('shows group mappings section when useRoleAttribute is false', async () => {
-			const user = userEvent.setup({ pointerEventsCheck: 0 });
-
-			render(
-				<CreateEdit
-					isCreate={false}
-					record={mockDomainWithRoleMapping}
-					onClose={mockOnClose}
-				/>,
-			);
-
-			const roleMappingHeader = screen.getByText(/role mapping \(advanced\)/i);
-			await user.click(roleMappingHeader);
-
-			await waitFor(() => {
-				expect(screen.getByText(/group to role mappings/i)).toBeInTheDocument();
-				expect(
-					screen.getByRole('button', { name: /add group mapping/i }),
-				).toBeInTheDocument();
-			});
-		});
-	});
-
-	describe('Modal Actions', () => {
-		it('calls onClose when cancel button is clicked', async () => {
-			const user = userEvent.setup({ pointerEventsCheck: 0 });
-
-			render(
-				<CreateEdit
-					isCreate={false}
-					record={mockGoogleAuthDomain}
-					onClose={mockOnClose}
-				/>,
-			);
-
-			const cancelButton = screen.getByRole('button', { name: /cancel/i });
-			await user.click(cancelButton);
-
-			expect(mockOnClose).toHaveBeenCalled();
-		});
-	});
-});

frontend/src/container/OrganizationSettings/AuthDomain/__tests__/SSOEnforcementToggle.test.tsx

@@ -1,130 +0,0 @@
-import { rest, server } from 'mocks-server/server';
-import { render, screen, userEvent, waitFor } from 'tests/test-utils';
-
-import SSOEnforcementToggle from '../SSOEnforcementToggle';
-import {
-	AUTH_DOMAINS_UPDATE_ENDPOINT,
-	mockErrorResponse,
-	mockGoogleAuthDomain,
-	mockUpdateSuccessResponse,
-} from './mocks';
-
-describe('SSOEnforcementToggle', () => {
-	beforeEach(() => {
-		jest.clearAllMocks();
-	});
-
-	afterEach(() => {
-		server.resetHandlers();
-	});
-
-	it('renders switch with correct initial state', () => {
-		render(
-			<SSOEnforcementToggle
-				isDefaultChecked={true}
-				record={mockGoogleAuthDomain}
-			/>,
-		);
-
-		const switchElement = screen.getByRole('switch');
-		expect(switchElement).toBeChecked();
-	});
-
-	it('renders unchecked switch when SSO is disabled', () => {
-		render(
-			<SSOEnforcementToggle
-				isDefaultChecked={false}
-				record={{ ...mockGoogleAuthDomain, ssoEnabled: false }}
-			/>,
-		);
-
-		const switchElement = screen.getByRole('switch');
-		expect(switchElement).not.toBeChecked();
-	});
-
-	it('calls update API when toggle is clicked', async () => {
-		const user = userEvent.setup({ pointerEventsCheck: 0 });
-		const mockUpdateAPI = jest.fn();
-
-		server.use(
-			rest.put(AUTH_DOMAINS_UPDATE_ENDPOINT, async (req, res, ctx) => {
-				const body = await req.json();
-				mockUpdateAPI(body);
-				return res(ctx.status(200), ctx.json(mockUpdateSuccessResponse));
-			}),
-		);
-
-		render(
-			<SSOEnforcementToggle
-				isDefaultChecked={true}
-				record={mockGoogleAuthDomain}
-			/>,
-		);
-
-		const switchElement = screen.getByRole('switch');
-		await user.click(switchElement);
-
-		await waitFor(() => {
-			expect(switchElement).not.toBeChecked();
-		});
-
-		expect(mockUpdateAPI).toHaveBeenCalledTimes(1);
-		expect(mockUpdateAPI).toHaveBeenCalledWith(
-			expect.objectContaining({
-				config: expect.objectContaining({
-					ssoEnabled: false,
-				}),
-			}),
-		);
-	});
-
-	it('shows error modal when update fails', async () => {
-		const user = userEvent.setup({ pointerEventsCheck: 0 });
-
-		server.use(
-			rest.put(AUTH_DOMAINS_UPDATE_ENDPOINT, (_, res, ctx) =>
-				res(ctx.status(500), ctx.json(mockErrorResponse)),
-			),
-		);
-
-		render(
-			<SSOEnforcementToggle
-				isDefaultChecked={true}
-				record={mockGoogleAuthDomain}
-			/>,
-		);
-
-		const switchElement = screen.getByRole('switch');
-		await user.click(switchElement);
-
-		await waitFor(() => {
-			expect(screen.getByText(/failed to perform operation/i)).toBeInTheDocument();
-		});
-	});
-
-	it('does not call API when record has no id', async () => {
-		const user = userEvent.setup({ pointerEventsCheck: 0 });
-		let apiCalled = false;
-
-		server.use(
-			rest.put(AUTH_DOMAINS_UPDATE_ENDPOINT, (_, res, ctx) => {
-				apiCalled = true;
-				return res(ctx.status(200), ctx.json(mockUpdateSuccessResponse));
-			}),
-		);
-
-		render(
-			<SSOEnforcementToggle
-				isDefaultChecked={true}
-				record={{ ...mockGoogleAuthDomain, id: undefined }}
-			/>,
-		);
-
-		const switchElement = screen.getByRole('switch');
-		await user.click(switchElement);
-
-		// Wait a bit to ensure no API call was made
-		await new Promise((resolve) => setTimeout(resolve, 100));
-		expect(apiCalled).toBe(false);
-	});
-});

frontend/src/container/OrganizationSettings/AuthDomain/__tests__/mocks.ts

@@ -1,220 +0,0 @@
-import { AuthtypesGettableAuthDomainDTO } from 'api/generated/services/sigNoz.schemas';
-
-// API Endpoints
-export const AUTH_DOMAINS_LIST_ENDPOINT = '*/api/v1/domains';
-export const AUTH_DOMAINS_CREATE_ENDPOINT = '*/api/v1/domains';
-export const AUTH_DOMAINS_UPDATE_ENDPOINT = '*/api/v1/domains/:id';
-export const AUTH_DOMAINS_DELETE_ENDPOINT = '*/api/v1/domains/:id';
-
-// Mock Auth Domain with Google Auth
-export const mockGoogleAuthDomain: AuthtypesGettableAuthDomainDTO = {
-	id: 'domain-1',
-	name: 'signoz.io',
-	ssoEnabled: true,
-	ssoType: 'google_auth',
-	googleAuthConfig: {
-		clientId: 'test-client-id',
-		clientSecret: 'test-client-secret',
-	},
-	authNProviderInfo: {
-		relayStatePath: 'api/v1/sso/relay/domain-1',
-	},
-};
-
-// Mock Auth Domain with SAML
-export const mockSamlAuthDomain: AuthtypesGettableAuthDomainDTO = {
-	id: 'domain-2',
-	name: 'example.com',
-	ssoEnabled: false,
-	ssoType: 'saml',
-	samlConfig: {
-		samlIdp: 'https://idp.example.com/sso',
-		samlEntity: 'urn:example:idp',
-		samlCert: 'MOCK_CERTIFICATE',
-	},
-	authNProviderInfo: {
-		relayStatePath: 'api/v1/sso/relay/domain-2',
-	},
-};
-
-// Mock Auth Domain with OIDC
-export const mockOidcAuthDomain: AuthtypesGettableAuthDomainDTO = {
-	id: 'domain-3',
-	name: 'corp.io',
-	ssoEnabled: true,
-	ssoType: 'oidc',
-	oidcConfig: {
-		issuer: 'https://oidc.corp.io',
-		clientId: 'oidc-client-id',
-		clientSecret: 'oidc-client-secret',
-	},
-	authNProviderInfo: {
-		relayStatePath: 'api/v1/sso/relay/domain-3',
-	},
-};
-
-// Mock Auth Domain with Role Mapping
-export const mockDomainWithRoleMapping: AuthtypesGettableAuthDomainDTO = {
-	id: 'domain-4',
-	name: 'enterprise.com',
-	ssoEnabled: true,
-	ssoType: 'saml',
-	samlConfig: {
-		samlIdp: 'https://idp.enterprise.com/sso',
-		samlEntity: 'urn:enterprise:idp',
-		samlCert: 'MOCK_CERTIFICATE',
-	},
-	roleMapping: {
-		defaultRole: 'EDITOR',
-		useRoleAttribute: false,
-		groupMappings: {
-			'admin-group': 'ADMIN',
-			'dev-team': 'EDITOR',
-			viewers: 'VIEWER',
-		},
-	},
-	authNProviderInfo: {
-		relayStatePath: 'api/v1/sso/relay/domain-4',
-	},
-};
-
-// Mock Auth Domain with useRoleAttribute enabled
-export const mockDomainWithDirectRoleAttribute: AuthtypesGettableAuthDomainDTO = {
-	id: 'domain-5',
-	name: 'direct-role.com',
-	ssoEnabled: true,
-	ssoType: 'oidc',
-	oidcConfig: {
-		issuer: 'https://oidc.direct-role.com',
-		clientId: 'direct-role-client-id',
-		clientSecret: 'direct-role-client-secret',
-	},
-	roleMapping: {
-		defaultRole: 'VIEWER',
-		useRoleAttribute: true,
-	},
-	authNProviderInfo: {
-		relayStatePath: 'api/v1/sso/relay/domain-5',
-	},
-};
-
-// Mock OIDC domain with claim mapping
-export const mockOidcWithClaimMapping: AuthtypesGettableAuthDomainDTO = {
-	id: 'domain-6',
-	name: 'oidc-claims.com',
-	ssoEnabled: true,
-	ssoType: 'oidc',
-	oidcConfig: {
-		issuer: 'https://oidc.claims.com',
-		issuerAlias: 'https://alias.claims.com',
-		clientId: 'claims-client-id',
-		clientSecret: 'claims-client-secret',
-		insecureSkipEmailVerified: true,
-		getUserInfo: true,
-		claimMapping: {
-			email: 'user_email',
-			name: 'display_name',
-			groups: 'user_groups',
-			role: 'user_role',
-		},
-	},
-	authNProviderInfo: {
-		relayStatePath: 'api/v1/sso/relay/domain-6',
-	},
-};
-
-// Mock SAML domain with attribute mapping
-export const mockSamlWithAttributeMapping: AuthtypesGettableAuthDomainDTO = {
-	id: 'domain-7',
-	name: 'saml-attrs.com',
-	ssoEnabled: true,
-	ssoType: 'saml',
-	samlConfig: {
-		samlIdp: 'https://idp.saml-attrs.com/sso',
-		samlEntity: 'urn:saml-attrs:idp',
-		samlCert: 'MOCK_CERTIFICATE_ATTRS',
-		insecureSkipAuthNRequestsSigned: true,
-		attributeMapping: {
-			name: 'user_display_name',
-			groups: 'member_of',
-			role: 'signoz_role',
-		},
-	},
-	authNProviderInfo: {
-		relayStatePath: 'api/v1/sso/relay/domain-7',
-	},
-};
-
-// Mock Google Auth with workspace groups
-export const mockGoogleAuthWithWorkspaceGroups: AuthtypesGettableAuthDomainDTO = {
-	id: 'domain-8',
-	name: 'google-groups.com',
-	ssoEnabled: true,
-	ssoType: 'google_auth',
-	googleAuthConfig: {
-		clientId: 'google-groups-client-id',
-		clientSecret: 'google-groups-client-secret',
-		insecureSkipEmailVerified: false,
-		fetchGroups: true,
-		serviceAccountJson: '{"type": "service_account"}',
-		domainToAdminEmail: {
-			'google-groups.com': 'admin@google-groups.com',
-		},
-		fetchTransitiveGroupMembership: true,
-		allowedGroups: ['allowed-group-1', 'allowed-group-2'],
-	},
-	authNProviderInfo: {
-		relayStatePath: 'api/v1/sso/relay/domain-8',
-	},
-};
-
-// Mock empty list response
-export const mockEmptyDomainsResponse = {
-	status: 'success',
-	data: [],
-};
-
-// Mock list response with domains
-export const mockDomainsListResponse = {
-	status: 'success',
-	data: [mockGoogleAuthDomain, mockSamlAuthDomain, mockOidcAuthDomain],
-};
-
-// Mock single domain list response
-export const mockSingleDomainResponse = {
-	status: 'success',
-	data: [mockGoogleAuthDomain],
-};
-
-// Mock success responses
-export const mockCreateSuccessResponse = {
-	status: 'success',
-	data: mockGoogleAuthDomain,
-};
-
-export const mockUpdateSuccessResponse = {
-	status: 'success',
-	data: { ...mockGoogleAuthDomain, ssoEnabled: false },
-};
-
-export const mockDeleteSuccessResponse = {
-	status: 'success',
-	data: 'Domain deleted successfully',
-};
-
-// Mock error responses
-export const mockErrorResponse = {
-	error: {
-		code: 'internal_error',
-		message: 'Failed to perform operation',
-		url: '',
-	},
-};
-
-export const mockValidationErrorResponse = {
-	error: {
-		code: 'invalid_input',
-		message: 'Domain name is required',
-		url: '',
-	},
-};

frontend/src/container/OrganizationSettings/AuthDomain/index.tsx

@@ -1,214 +1,151 @@
-import { useCallback, useMemo, useState } from 'react';
+import { useState } from 'react';
+import { useQuery } from 'react-query';
 import { PlusOutlined } from '@ant-design/icons';
-import { Button } from '@signozhq/button';
-import { Trash2, X } from '@signozhq/icons';
-import { toast } from '@signozhq/sonner';
-import { Modal } from 'antd';
-import { Table } from 'antd';
+import { Button, Table, Typography } from 'antd';
 import { ColumnsType } from 'antd/lib/table';
-import { ErrorResponseHandlerV2 } from 'api/ErrorResponseHandlerV2';
-import {
-	useDeleteAuthDomain,
-	useListAuthDomains,
-} from 'api/generated/services/authdomains';
-import {
-	AuthtypesGettableAuthDomainDTO,
-	RenderErrorResponseDTO,
-} from 'api/generated/services/sigNoz.schemas';
-import { AxiosError } from 'axios';
+import deleteDomain from 'api/v1/domains/id/delete';
+import listAllDomain from 'api/v1/domains/list';
 import ErrorContent from 'components/ErrorModal/components/ErrorContent';
 import CopyToClipboard from 'periscope/components/CopyToClipboard';
 import { useErrorModal } from 'providers/ErrorModalProvider';
-import { ErrorV2Resp } from 'types/api';
 import APIError from 'types/api/error';
+import { GettableAuthDomain, SSOType } from 'types/api/v1/domains/list';
 
 import CreateEdit from './CreateEdit/CreateEdit';
-import SSOEnforcementToggle from './SSOEnforcementToggle';
+import Toggle from './Toggle';
 
 import './AuthDomain.styles.scss';
-import '../../IngestionSettings/IngestionSettings.styles.scss';
 
-export const SSOType = new Map<string, string>([
-	['google_auth', 'Google Auth'],
-	['saml', 'SAML'],
-	['email_password', 'Email Password'],
-	['oidc', 'OIDC'],
-]);
+const columns: ColumnsType<GettableAuthDomain> = [
+	{
+		title: 'Domain',
+		dataIndex: 'name',
+		key: 'name',
+		width: 100,
+		render: (val): JSX.Element => <Typography.Text>{val}</Typography.Text>,
+	},
+	{
+		title: 'Enforce SSO',
+		dataIndex: 'ssoEnabled',
+		key: 'ssoEnabled',
+		width: 80,
+		render: (value: boolean, record: GettableAuthDomain): JSX.Element => (
+			<Toggle isDefaultChecked={value} record={record} />
+		),
+	},
+	{
+		title: 'IDP Initiated SSO URL',
+		dataIndex: 'relayState',
+		key: 'relayState',
+		width: 80,
+		render: (_, record: GettableAuthDomain): JSX.Element => {
+			const relayPath = record.authNProviderInfo.relayStatePath;
+			if (!relayPath) {
+				return (
+					<Typography.Text style={{ paddingLeft: '6px' }}>N/A</Typography.Text>
+				);
+			}
+
+			const href = `${window.location.origin}/${relayPath}`;
+			return <CopyToClipboard textToCopy={href} />;
+		},
+	},
+	{
+		title: 'Action',
+		dataIndex: 'action',
+		key: 'action',
+		width: 100,
+		render: (_, record: GettableAuthDomain): JSX.Element => (
+			<section className="auth-domain-list-column-action">
+				<Typography.Link data-column-action="configure">
+					Configure {SSOType.get(record.ssoType)}
+				</Typography.Link>
+				<Typography.Link type="danger" data-column-action="delete">
+					Delete
+				</Typography.Link>
+			</section>
+		),
+	},
+];
+
+async function deleteDomainById(
+	id: string,
+	showErrorModal: (error: APIError) => void,
+	refetchAuthDomainListResponse: () => void,
+): Promise<void> {
+	try {
+		await deleteDomain(id);
+		refetchAuthDomainListResponse();
+	} catch (error) {
+		showErrorModal(error as APIError);
+	}
+}
 
 function AuthDomain(): JSX.Element {
-	const [record, setRecord] = useState<AuthtypesGettableAuthDomainDTO>();
+	const [record, setRecord] = useState<GettableAuthDomain>();
 	const [addDomain, setAddDomain] = useState<boolean>(false);
-	const [isDeleteModalOpen, setIsDeleteModalOpen] = useState(false);
-	const [
-		activeDomain,
-		setActiveDomain,
-	] = useState<AuthtypesGettableAuthDomainDTO | null>(null);
-
 	const { showErrorModal } = useErrorModal();
-
 	const {
 		data: authDomainListResponse,
 		isLoading: isLoadingAuthDomainListResponse,
 		isFetching: isFetchingAuthDomainListResponse,
 		error: errorFetchingAuthDomainListResponse,
 		refetch: refetchAuthDomainListResponse,
-	} = useListAuthDomains();
-
-	const { mutate: deleteAuthDomain, isLoading } = useDeleteAuthDomain<
-		AxiosError<RenderErrorResponseDTO>
-	>();
-
-	const showDeleteModal = useCallback(
-		(domain: AuthtypesGettableAuthDomainDTO): void => {
-			setActiveDomain(domain);
-			setIsDeleteModalOpen(true);
-		},
-		[],
-	);
-
-	const hideDeleteModal = useCallback((): void => {
-		setIsDeleteModalOpen(false);
-		setActiveDomain(null);
-	}, []);
-
-	const handleDeleteDomain = useCallback((): void => {
-		if (!activeDomain?.id) {
-			return;
-		}
-
-		deleteAuthDomain(
-			{ pathParams: { id: activeDomain.id } },
-			{
-				onSuccess: () => {
-					toast.success('Domain deleted successfully');
-					refetchAuthDomainListResponse();
-					hideDeleteModal();
-				},
-				onError: (error) => {
-					try {
-						ErrorResponseHandlerV2(error as AxiosError<ErrorV2Resp>);
-					} catch (apiError) {
-						showErrorModal(apiError as APIError);
-					}
-				},
-			},
-		);
-	}, [
-		activeDomain,
-		deleteAuthDomain,
-		hideDeleteModal,
-
-		refetchAuthDomainListResponse,
-		showErrorModal,
-	]);
-
-	const formattedError = useMemo(() => {
-		if (!errorFetchingAuthDomainListResponse) {
-			return null;
-		}
-
-		let errorResult: APIError | null = null;
-		try {
-			ErrorResponseHandlerV2(
-				errorFetchingAuthDomainListResponse as AxiosError<ErrorV2Resp>,
-			);
-		} catch (error) {
-			errorResult = error as APIError;
-		}
-		return errorResult;
-	}, [errorFetchingAuthDomainListResponse]);
-
-	const columns: ColumnsType<AuthtypesGettableAuthDomainDTO> = useMemo(
-		() => [
-			{
-				title: 'Domain',
-				dataIndex: 'name',
-				key: 'name',
-				width: 100,
-				render: (val): JSX.Element => <span>{val}</span>,
-			},
-			{
-				title: 'Enforce SSO',
-				dataIndex: 'ssoEnabled',
-				key: 'ssoEnabled',
-				width: 80,
-				render: (
-					value: boolean,
-					record: AuthtypesGettableAuthDomainDTO,
-				): JSX.Element => (
-					<SSOEnforcementToggle isDefaultChecked={value} record={record} />
-				),
-			},
-			{
-				title: 'IDP Initiated SSO URL',
-				dataIndex: 'relayState',
-				key: 'relayState',
-				width: 80,
-				render: (_, record: AuthtypesGettableAuthDomainDTO): JSX.Element => {
-					const relayPath = record.authNProviderInfo?.relayStatePath;
-					if (!relayPath) {
-						return <span className="auth-domain-list-na">N/A</span>;
-					}
-
-					const href = `${window.location.origin}/${relayPath}`;
-					return <CopyToClipboard textToCopy={href} />;
-				},
-			},
-			{
-				title: 'Action',
-				dataIndex: 'action',
-				key: 'action',
-				width: 100,
-				render: (_, record: AuthtypesGettableAuthDomainDTO): JSX.Element => (
-					<section className="auth-domain-list-column-action">
-						<Button
-							className="auth-domain-list-action-link"
-							onClick={(): void => setRecord(record)}
-							variant="link"
-						>
-							Configure {SSOType.get(record.ssoType || '')}
-						</Button>
-						<Button
-							className="auth-domain-list-action-link delete"
-							onClick={(): void => showDeleteModal(record)}
-							variant="link"
-						>
-							Delete
-						</Button>
-					</section>
-				),
-			},
-		],
-		[showDeleteModal],
-	);
+	} = useQuery({
+		queryFn: listAllDomain,
+		queryKey: ['/api/v1/domains', 'list'],
+		enabled: true,
+	});
 
 	return (
 		<div className="auth-domain">
 			<section className="auth-domain-header">
-				<h3 className="auth-domain-title">Authenticated Domains</h3>
+				<Typography.Title level={3}>Authenticated Domains</Typography.Title>
 				<Button
-					prefixIcon={<PlusOutlined />}
+					type="primary"
+					icon={<PlusOutlined />}
 					onClick={(): void => {
 						setAddDomain(true);
 					}}
-					variant="solid"
-					size="sm"
-					color="primary"
+					className="button"
 				>
 					Add Domain
 				</Button>
 			</section>
-			{formattedError && <ErrorContent error={formattedError} />}
-			{!errorFetchingAuthDomainListResponse && (
+			{(errorFetchingAuthDomainListResponse as APIError) && (
+				<ErrorContent error={errorFetchingAuthDomainListResponse as APIError} />
+			)}
+			{!(errorFetchingAuthDomainListResponse as APIError) && (
 				<Table
 					columns={columns}
-					dataSource={authDomainListResponse?.data?.data}
-					onRow={undefined}
+					dataSource={authDomainListResponse?.data}
+					onRow={(record): any => ({
+						onClick: (
+							event: React.SyntheticEvent<HTMLLinkElement, MouseEvent>,
+						): void => {
+							const target = event.target as HTMLLinkElement;
+							const { columnAction } = target.dataset;
+							switch (columnAction) {
+								case 'configure':
+									setRecord(record);
+
+									break;
+								case 'delete':
+									deleteDomainById(
+										record.id,
+										showErrorModal,
+										refetchAuthDomainListResponse,
+									);
+									break;
+								default:
+									console.error('Unknown action:', columnAction);
+							}
+						},
+					})}
 					loading={
 						isLoadingAuthDomainListResponse || isFetchingAuthDomainListResponse
 					}
 					className="auth-domain-list"
-					rowKey="id"
 				/>
 			)}
 			{(addDomain || record) && (
@@ -222,39 +159,6 @@ function AuthDomain(): JSX.Element {
 					}}
 				/>
 			)}
-
-			<Modal
-				className="delete-ingestion-key-modal"
-				title={<span className="title">Delete Domain</span>}
-				open={isDeleteModalOpen}
-				closable
-				onCancel={hideDeleteModal}
-				destroyOnClose
-				footer={[
-					<Button
-						key="cancel"
-						onClick={hideDeleteModal}
-						className="cancel-btn"
-						prefixIcon={<X size={16} />}
-					>
-						Cancel
-					</Button>,
-					<Button
-						key="submit"
-						prefixIcon={<Trash2 size={16} />}
-						onClick={handleDeleteDomain}
-						className="delete-btn"
-						loading={isLoading}
-					>
-						Delete Domain
-					</Button>,
-				]}
-			>
-				<p className="delete-text">
-					Are you sure you want to delete the domain{' '}
-					<strong>{activeDomain?.name}</strong>? This action cannot be undone.
-				</p>
-			</Modal>
 		</div>
 	);
 }

frontend/src/container/PanelWrapper/PanelWrapper.tsx

@@ -1,5 +1,4 @@
 import { FC } from 'react';
-import Spinner from 'components/Spinner';
 
 import { PanelTypeVsPanelWrapper } from './constants';
 import { PanelWrapperProps } from './panelWrapper.types';
@@ -33,11 +32,6 @@ function PanelWrapper({
 		// eslint-disable-next-line react/jsx-no-useless-fragment
 		return <></>;
 	}
-
-	if (queryResponse.isFetching || queryResponse.isLoading) {
-		return <Spinner height="100%" size="large" tip="Loading..." />;
-	}
-
 	return (
 		<Component
 			panelMode={panelMode}

frontend/src/container/RolesSettings/RolesComponents/RolesListingTable.tsx

@@ -1,246 +0,0 @@
-import { useCallback, useEffect, useMemo } from 'react';
-import { useHistory } from 'react-router-dom';
-import { Pagination, Skeleton } from 'antd';
-import { useListRoles } from 'api/generated/services/role';
-import { RoletypesRoleDTO } from 'api/generated/services/sigNoz.schemas';
-import ErrorInPlace from 'components/ErrorInPlace/ErrorInPlace';
-import { DATE_TIME_FORMATS } from 'constants/dateTimeFormats';
-import useUrlQuery from 'hooks/useUrlQuery';
-import LineClampedText from 'periscope/components/LineClampedText/LineClampedText';
-import { useTimezone } from 'providers/Timezone';
-import { toAPIError } from 'utils/errorUtils';
-
-import '../RolesSettings.styles.scss';
-
-const PAGE_SIZE = 20;
-
-type DisplayItem =
-	| { type: 'section'; label: string; count?: number }
-	| { type: 'role'; role: RoletypesRoleDTO };
-
-interface RolesListingTableProps {
-	searchQuery: string;
-}
-
-function RolesListingTable({
-	searchQuery,
-}: RolesListingTableProps): JSX.Element {
-	const { data, isLoading, isError, error } = useListRoles();
-	const { formatTimezoneAdjustedTimestamp } = useTimezone();
-	const history = useHistory();
-	const urlQuery = useUrlQuery();
-	const pageParam = parseInt(urlQuery.get('page') ?? '1', 10);
-	const currentPage = Number.isNaN(pageParam) || pageParam < 1 ? 1 : pageParam;
-
-	const setCurrentPage = useCallback(
-		(page: number): void => {
-			urlQuery.set('page', String(page));
-			history.replace({ search: urlQuery.toString() });
-		},
-		[history, urlQuery],
-	);
-
-	const roles = useMemo(() => data?.data?.data ?? [], [data]);
-
-	const formatTimestamp = (date?: Date | string): string => {
-		if (!date) {
-			return '—';
-		}
-		const d = new Date(date);
-
-		if (Number.isNaN(d.getTime())) {
-			return '—';
-		}
-
-		return formatTimezoneAdjustedTimestamp(date, DATE_TIME_FORMATS.DASH_DATETIME);
-	};
-
-	const filteredRoles = useMemo(() => {
-		if (!searchQuery.trim()) {
-			return roles;
-		}
-		const query = searchQuery.toLowerCase();
-		return roles.filter(
-			(role) =>
-				role.name?.toLowerCase().includes(query) ||
-				role.description?.toLowerCase().includes(query),
-		);
-	}, [roles, searchQuery]);
-
-	const managedRoles = useMemo(
-		() => filteredRoles.filter((role) => role.type?.toLowerCase() === 'managed'),
-		[filteredRoles],
-	);
-	const customRoles = useMemo(
-		() => filteredRoles.filter((role) => role.type?.toLowerCase() === 'custom'),
-		[filteredRoles],
-	);
-
-	// Combine managed + custom into a flat display list for pagination
-	const displayList = useMemo((): DisplayItem[] => {
-		const result: DisplayItem[] = [];
-
-		if (managedRoles.length > 0) {
-			result.push({ type: 'section', label: 'Managed roles' });
-			managedRoles.forEach((role) => result.push({ type: 'role', role }));
-		}
-		if (customRoles.length > 0) {
-			result.push({
-				type: 'section',
-				label: 'Custom roles',
-				count: customRoles.length,
-			});
-			customRoles.forEach((role) => result.push({ type: 'role', role }));
-		}
-		return result;
-	}, [managedRoles, customRoles]);
-
-	const totalRoleCount = managedRoles.length + customRoles.length;
-
-	// Ensure current page is valid; if out of bounds, redirect to last available page
-	useEffect(() => {
-		if (isLoading || totalRoleCount === 0) {
-			return;
-		}
-		const maxPage = Math.ceil(totalRoleCount / PAGE_SIZE);
-		if (currentPage > maxPage) {
-			setCurrentPage(maxPage);
-		}
-	}, [isLoading, totalRoleCount, currentPage, setCurrentPage]);
-
-	// Paginate: count only role items, but include section headers contextually
-	const paginatedItems = useMemo((): DisplayItem[] => {
-		const startRole = (currentPage - 1) * PAGE_SIZE;
-		const endRole = startRole + PAGE_SIZE;
-		let roleIndex = 0;
-		let lastSection: DisplayItem | null = null;
-		const result: DisplayItem[] = [];
-
-		for (const item of displayList) {
-			if (item.type === 'section') {
-				lastSection = item;
-			} else {
-				if (roleIndex >= startRole && roleIndex < endRole) {
-					// Insert section header before first role in that section on this page
-					if (lastSection) {
-						result.push(lastSection);
-						lastSection = null;
-					}
-					result.push(item);
-				}
-				roleIndex++;
-			}
-		}
-		return result;
-	}, [displayList, currentPage]);
-
-	const showPaginationItem = (total: number, range: number[]): JSX.Element => (
-		<>
-			<span className="numbers">
-				{range[0]} &#8212; {range[1]}
-			</span>
-			<span className="total"> of {total}</span>
-		</>
-	);
-
-	if (isLoading) {
-		return (
-			<div className="roles-listing-table">
-				<Skeleton active paragraph={{ rows: 5 }} />
-			</div>
-		);
-	}
-
-	if (isError) {
-		return (
-			<div className="roles-listing-table">
-				<ErrorInPlace
-					error={toAPIError(
-						error,
-						'An unexpected error occurred while fetching roles.',
-					)}
-				/>
-			</div>
-		);
-	}
-
-	if (filteredRoles.length === 0) {
-		return (
-			<div className="roles-listing-table">
-				<div className="roles-table-empty">
-					{searchQuery ? 'No roles match your search.' : 'No roles found.'}
-				</div>
-			</div>
-		);
-	}
-
-	// todo: use table from periscope when its available for consumption
-	const renderRow = (role: RoletypesRoleDTO): JSX.Element => (
-		<div key={role.id} className="roles-table-row">
-			<div className="roles-table-cell roles-table-cell--name">
-				{role.name ?? '—'}
-			</div>
-			<div className="roles-table-cell roles-table-cell--description">
-				<LineClampedText
-					text={role.description ?? '—'}
-					tooltipProps={{ overlayClassName: 'roles-description-tooltip' }}
-				/>
-			</div>
-			<div className="roles-table-cell roles-table-cell--updated-at">
-				{formatTimestamp(role.updatedAt)}
-			</div>
-			<div className="roles-table-cell roles-table-cell--created-at">
-				{formatTimestamp(role.createdAt)}
-			</div>
-		</div>
-	);
-
-	return (
-		<div className="roles-listing-table">
-			<div className="roles-table-scroll-container">
-				<div className="roles-table-inner">
-					<div className="roles-table-header">
-						<div className="roles-table-header-cell roles-table-header-cell--name">
-							Name
-						</div>
-						<div className="roles-table-header-cell roles-table-header-cell--description">
-							Description
-						</div>
-						<div className="roles-table-header-cell roles-table-header-cell--updated-at">
-							Updated At
-						</div>
-						<div className="roles-table-header-cell roles-table-header-cell--created-at">
-							Created At
-						</div>
-					</div>
-
-					{paginatedItems.map((item) =>
-						item.type === 'section' ? (
-							<h3 key={`section-${item.label}`} className="roles-table-section-header">
-								{item.label}
-								{item.count !== undefined && (
-									<span className="roles-table-section-header__count">{item.count}</span>
-								)}
-							</h3>
-						) : (
-							renderRow(item.role)
-						),
-					)}
-				</div>
-			</div>
-
-			<Pagination
-				current={currentPage}
-				pageSize={PAGE_SIZE}
-				total={totalRoleCount}
-				showTotal={showPaginationItem}
-				showSizeChanger={false}
-				hideOnSinglePage
-				onChange={(page): void => setCurrentPage(page)}
-				className="roles-table-pagination"
-			/>
-		</div>
-	);
-}
-
-export default RolesListingTable;

frontend/src/container/RolesSettings/RolesSettings.styles.scss

@@ -1,238 +0,0 @@
-.roles-settings {
-	.roles-settings-header {
-		display: flex;
-		flex-direction: column;
-		gap: 4px;
-		width: 100%;
-		padding: 16px;
-
-		.roles-settings-header-title {
-			color: var(--text-base-white);
-			font-family: Inter;
-			font-style: normal;
-			font-size: 18px;
-			font-weight: 500;
-			line-height: 28px;
-			letter-spacing: -0.09px;
-		}
-
-		.roles-settings-header-description {
-			color: var(--foreground);
-			font-family: Inter;
-			font-style: normal;
-			font-size: 14px;
-			font-weight: 400;
-			line-height: 20px;
-			letter-spacing: -0.07px;
-		}
-	}
-
-	.roles-settings-content {
-		padding: 0 16px;
-	}
-
-	// todo: https://github.com/SigNoz/components/issues/116
-	.roles-search-wrapper {
-		input {
-			width: 100%;
-			background: var(--l3-background);
-			border: 1px solid var(--l3-border);
-			border-radius: 2px;
-			padding: 6px 6px 6px 8px;
-			font-family: Inter;
-			font-size: 14px;
-			font-weight: 400;
-			line-height: 18px;
-			letter-spacing: -0.07px;
-			color: var(--l1-foreground);
-			outline: none;
-			height: 32px;
-
-			&::placeholder {
-				color: var(--l3-foreground);
-			}
-
-			&:focus {
-				border-color: var(--input);
-			}
-		}
-	}
-}
-
-.roles-description-tooltip {
-	max-height: none;
-	overflow-y: visible;
-}
-
-.roles-listing-table {
-	margin-top: 12px;
-	border-radius: 4px;
-	overflow: hidden;
-}
-
-.roles-table-scroll-container {
-	overflow-x: auto;
-}
-
-.roles-table-inner {
-	min-width: 850px;
-}
-
-.roles-table-header {
-	display: flex;
-	align-items: center;
-	padding: 8px 16px;
-	gap: 24px;
-}
-
-.roles-table-header-cell {
-	font-family: Inter;
-	font-size: 11px;
-	font-weight: 600;
-	text-transform: uppercase;
-	letter-spacing: 0.44px;
-	color: var(--foreground);
-	line-height: 16px;
-
-	&--name {
-		flex: 0 0 180px;
-	}
-
-	&--description {
-		flex: 1;
-		min-width: 0;
-	}
-
-	&--created-at {
-		flex: 0 0 180px;
-		text-align: right;
-	}
-
-	&--updated-at {
-		flex: 0 0 180px;
-		text-align: right;
-	}
-}
-
-.roles-table-section-header {
-	display: flex;
-	align-items: center;
-	gap: 8px;
-	height: 32px;
-	padding: 0 16px;
-	background: rgba(171, 189, 255, 0.04);
-	border-top: 1px solid var(--secondary);
-	border-bottom: 1px solid var(--secondary);
-	font-family: Inter;
-	font-size: 12px;
-	font-weight: 400;
-	color: var(--foreground);
-	line-height: 16px;
-	margin: 0;
-
-	&__count {
-		display: inline-flex;
-		align-items: center;
-		justify-content: center;
-		min-width: 20px;
-		height: 18px;
-		padding: 0 6px;
-		border-radius: 9px;
-		background: var(--l3-background);
-		font-size: 12px;
-		font-weight: 500;
-		color: var(--foreground);
-		line-height: 1;
-	}
-}
-
-.roles-table-row {
-	display: flex;
-	align-items: center;
-	padding: 8px 16px;
-	background: rgba(171, 189, 255, 0.02);
-	border-bottom: 1px solid var(--secondary);
-	gap: 24px;
-}
-
-.roles-table-cell {
-	font-family: Inter;
-	font-size: 14px;
-	font-weight: 400;
-	color: var(--foreground);
-	line-height: 20px;
-
-	&--name {
-		flex: 0 0 180px;
-		font-weight: 500;
-	}
-
-	&--description {
-		flex: 1;
-		min-width: 0;
-		overflow: hidden;
-	}
-
-	&--created-at {
-		flex: 0 0 180px;
-		text-align: right;
-		white-space: nowrap;
-	}
-
-	&--updated-at {
-		flex: 0 0 180px;
-		text-align: right;
-		white-space: nowrap;
-	}
-}
-
-.roles-table-empty {
-	padding: 24px 16px;
-	text-align: center;
-	color: var(--foreground);
-	font-family: Inter;
-	font-size: 14px;
-	font-weight: 400;
-}
-
-.roles-table-pagination {
-	display: flex;
-	align-items: center;
-	justify-content: flex-end;
-	padding: 8px 16px;
-
-	.ant-pagination-total-text {
-		margin-right: auto;
-
-		.numbers {
-			font-family: Inter;
-			font-size: 12px;
-			color: var(--foreground);
-		}
-
-		.total {
-			font-family: Inter;
-			font-size: 12px;
-			color: var(--foreground);
-			opacity: 0.5;
-		}
-	}
-}
-
-.lightMode {
-	.roles-settings {
-		.roles-settings-header {
-			.roles-settings-header-title {
-				color: var(--text-base-black);
-			}
-		}
-	}
-
-	.roles-table-section-header {
-		background: rgba(0, 0, 0, 0.03);
-	}
-
-	.roles-table-row {
-		background: rgba(0, 0, 0, 0.01);
-	}
-}

frontend/src/container/RolesSettings/RolesSettings.tsx

@@ -1,34 +0,0 @@
-import { useState } from 'react';
-import { Input } from '@signozhq/input';
-
-import RolesListingTable from './RolesComponents/RolesListingTable';
-
-import './RolesSettings.styles.scss';
-
-function RolesSettings(): JSX.Element {
-	const [searchQuery, setSearchQuery] = useState('');
-
-	return (
-		<div className="roles-settings" data-testid="roles-settings">
-			<div className="roles-settings-header">
-				<h3 className="roles-settings-header-title">Roles</h3>
-				<p className="roles-settings-header-description">
-					Create and manage custom roles for your team.
-				</p>
-			</div>
-			<div className="roles-settings-content">
-				<div className="roles-search-wrapper">
-					<Input
-						type="search"
-						placeholder="Search for roles..."
-						value={searchQuery}
-						onChange={(e): void => setSearchQuery(e.target.value)}
-					/>
-				</div>
-				<RolesListingTable searchQuery={searchQuery} />
-			</div>
-		</div>
-	);
-}
-
-export default RolesSettings;

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

@@ -1,232 +0,0 @@
-import {
-	allRoles,
-	listRolesSuccessResponse,
-} from 'mocks-server/__mockdata__/roles';
-import { server } from 'mocks-server/server';
-import { rest } from 'msw';
-import { render, screen, userEvent } from 'tests/test-utils';
-
-import RolesSettings from '../RolesSettings';
-
-const rolesApiURL = 'http://localhost/api/v1/roles';
-
-describe('RolesSettings', () => {
-	afterEach(() => {
-		jest.clearAllMocks();
-	});
-
-	it('renders the header and search input', () => {
-		server.use(
-			rest.get(rolesApiURL, (_req, res, ctx) =>
-				res(ctx.status(200), ctx.json(listRolesSuccessResponse)),
-			),
-		);
-
-		render(<RolesSettings />);
-
-		expect(screen.getByText('Roles')).toBeInTheDocument();
-		expect(
-			screen.getByText('Create and manage custom roles for your team.'),
-		).toBeInTheDocument();
-		expect(
-			screen.getByPlaceholderText('Search for roles...'),
-		).toBeInTheDocument();
-	});
-
-	it('displays roles grouped by managed and custom sections', async () => {
-		server.use(
-			rest.get(rolesApiURL, (_req, res, ctx) =>
-				res(ctx.status(200), ctx.json(listRolesSuccessResponse)),
-			),
-		);
-
-		render(<RolesSettings />);
-
-		expect(await screen.findByText('signoz-admin')).toBeInTheDocument();
-
-		// Section headers
-		expect(screen.getByText('Managed roles')).toBeInTheDocument();
-		expect(screen.getByText('Custom roles')).toBeInTheDocument();
-
-		// Managed roles
-		expect(screen.getByText('signoz-admin')).toBeInTheDocument();
-		expect(screen.getByText('signoz-editor')).toBeInTheDocument();
-		expect(screen.getByText('signoz-viewer')).toBeInTheDocument();
-
-		// Custom roles
-		expect(screen.getByText('billing-manager')).toBeInTheDocument();
-		expect(screen.getByText('dashboard-creator')).toBeInTheDocument();
-
-		// Custom roles count badge
-		expect(screen.getByText('2')).toBeInTheDocument();
-
-		// Column headers
-		expect(screen.getByText('Name')).toBeInTheDocument();
-		expect(screen.getByText('Description')).toBeInTheDocument();
-		expect(screen.getByText('Updated At')).toBeInTheDocument();
-		expect(screen.getByText('Created At')).toBeInTheDocument();
-	});
-
-	it('filters roles by search query on name', async () => {
-		server.use(
-			rest.get(rolesApiURL, (_req, res, ctx) =>
-				res(ctx.status(200), ctx.json(listRolesSuccessResponse)),
-			),
-		);
-
-		render(<RolesSettings />);
-
-		expect(await screen.findByText('signoz-admin')).toBeInTheDocument();
-
-		const user = userEvent.setup({ pointerEventsCheck: 0 });
-		const searchInput = screen.getByPlaceholderText('Search for roles...');
-
-		await user.type(searchInput, 'billing');
-
-		expect(await screen.findByText('billing-manager')).toBeInTheDocument();
-		expect(screen.queryByText('signoz-admin')).not.toBeInTheDocument();
-		expect(screen.queryByText('signoz-editor')).not.toBeInTheDocument();
-		expect(screen.queryByText('dashboard-creator')).not.toBeInTheDocument();
-	});
-
-	it('filters roles by search query on description', async () => {
-		server.use(
-			rest.get(rolesApiURL, (_req, res, ctx) =>
-				res(ctx.status(200), ctx.json(listRolesSuccessResponse)),
-			),
-		);
-
-		render(<RolesSettings />);
-
-		expect(await screen.findByText('signoz-admin')).toBeInTheDocument();
-
-		const user = userEvent.setup({ pointerEventsCheck: 0 });
-		const searchInput = screen.getByPlaceholderText('Search for roles...');
-
-		await user.type(searchInput, 'read-only');
-
-		expect(await screen.findByText('signoz-viewer')).toBeInTheDocument();
-		expect(screen.queryByText('signoz-admin')).not.toBeInTheDocument();
-		expect(screen.queryByText('billing-manager')).not.toBeInTheDocument();
-	});
-
-	it('shows empty state when search matches nothing', async () => {
-		server.use(
-			rest.get(rolesApiURL, (_req, res, ctx) =>
-				res(ctx.status(200), ctx.json(listRolesSuccessResponse)),
-			),
-		);
-
-		render(<RolesSettings />);
-
-		expect(await screen.findByText('signoz-admin')).toBeInTheDocument();
-
-		const user = userEvent.setup({ pointerEventsCheck: 0 });
-		const searchInput = screen.getByPlaceholderText('Search for roles...');
-
-		await user.type(searchInput, 'nonexistentrole');
-
-		expect(
-			await screen.findByText('No roles match your search.'),
-		).toBeInTheDocument();
-	});
-
-	it('shows loading skeleton while fetching', () => {
-		server.use(
-			rest.get(rolesApiURL, (_req, res, ctx) =>
-				res(ctx.delay(200), ctx.status(200), ctx.json(listRolesSuccessResponse)),
-			),
-		);
-
-		render(<RolesSettings />);
-
-		expect(document.querySelector('.ant-skeleton')).toBeInTheDocument();
-	});
-
-	it('shows error state when API fails', async () => {
-		const errorMessage = 'Failed to fetch roles';
-		server.use(
-			rest.get(rolesApiURL, (_req, res, ctx) =>
-				res(
-					ctx.status(500),
-					ctx.json({
-						error: {
-							code: 'INTERNAL_ERROR',
-							message: errorMessage,
-							url: '',
-							errors: [],
-						},
-					}),
-				),
-			),
-		);
-
-		render(<RolesSettings />);
-
-		expect(await screen.findByText(errorMessage)).toBeInTheDocument();
-	});
-
-	it('shows empty state when API returns no roles', async () => {
-		server.use(
-			rest.get(rolesApiURL, (_req, res, ctx) =>
-				res(ctx.status(200), ctx.json({ status: 'success', data: [] })),
-			),
-		);
-
-		render(<RolesSettings />);
-
-		expect(await screen.findByText('No roles found.')).toBeInTheDocument();
-	});
-
-	it('renders descriptions for all roles', async () => {
-		server.use(
-			rest.get(rolesApiURL, (_req, res, ctx) =>
-				res(ctx.status(200), ctx.json(listRolesSuccessResponse)),
-			),
-		);
-
-		render(<RolesSettings />);
-
-		expect(await screen.findByText('signoz-admin')).toBeInTheDocument();
-
-		for (const role of allRoles) {
-			if (role.description) {
-				expect(screen.getByText(role.description)).toBeInTheDocument();
-			}
-		}
-	});
-
-	it('handles invalid dates gracefully by showing fallback', async () => {
-		const invalidRole = {
-			id: 'edge-0009',
-			createdAt: ('invalid-date' as unknown) as Date,
-			updatedAt: ('not-a-date' as unknown) as Date,
-			name: 'invalid-date-role',
-			description: 'Tests date parsing fallback.',
-			type: 'custom',
-			orgId: 'org-001',
-		};
-
-		server.use(
-			rest.get(rolesApiURL, (_req, res, ctx) =>
-				res(
-					ctx.status(200),
-					ctx.json({
-						status: 'success',
-						data: [invalidRole],
-					}),
-				),
-			),
-		);
-
-		render(<RolesSettings />);
-
-		expect(await screen.findByText('invalid-date-role')).toBeInTheDocument();
-
-		// Verify the "—" (em-dash) fallback is shown for both cells
-		const dashFallback = screen.getAllByText('—');
-		// In renderRow: name, description, updatedAt, createdAt.
-		// Total dashes expected: 2 (for both dates)
-		expect(dashFallback.length).toBeGreaterThanOrEqual(2);
-	});
-});

frontend/src/container/RolesSettings/index.tsx

@@ -1 +0,0 @@
-export { default } from './RolesSettings';

frontend/src/container/SideNav/menuItems.tsx

@@ -28,7 +28,6 @@ import {
 	ScrollText,
 	Search,
 	Settings,
-	Shield,
 	Slack,
 	Unplug,
 	User,
@@ -313,13 +312,6 @@ export const settingsMenuItems: SidebarItem[] = [
 		isEnabled: false,
 		itemKey: 'billing',
 	},
-	{
-		key: ROUTES.ROLES_SETTINGS,
-		label: 'Roles',
-		icon: <Shield size={16} />,
-		isEnabled: false,
-		itemKey: 'roles',
-	},
 	{
 		key: ROUTES.ORG_SETTINGS,
 		label: 'Members & SSO',

frontend/src/container/TopNav/DateTimeSelectionV2/constants.ts

@@ -159,7 +159,6 @@ export const routesToSkip = [
 	ROUTES.ERROR_DETAIL,
 	ROUTES.LOGS_PIPELINES,
 	ROUTES.BILLING,
-	ROUTES.ROLES_SETTINGS,
 	ROUTES.SUPPORT,
 	ROUTES.WORKSPACE_LOCKED,
 	ROUTES.WORKSPACE_SUSPENDED,

frontend/src/hooks/useCollapseSectionErrors.ts

@@ -1,61 +0,0 @@
-import { useMemo } from 'react';
-import { Form } from 'antd';
-
-export interface CollapseSectionErrors {
-	hasErrors: boolean;
-	errorMessages: string[];
-}
-
-/**
- * Detects validation errors in a form section
- * @param fieldNamePrefix - Field path prefix for the section
- * @param specificFields - Optional specific field prefixes to check (uses prefix matching)
- */
-export function useCollapseSectionErrors(
-	fieldNamePrefix: string[],
-	specificFields?: string[][],
-): CollapseSectionErrors {
-	const form = Form.useFormInstance();
-	// Refer: https://github.com/SigNoz/signoz/pull/10276#discussion_r2819372174
-	Form.useWatch([], form);
-
-	// eslint-disable-next-line sonarjs/cognitive-complexity
-	return useMemo(() => {
-		const fieldErrors = form.getFieldsError();
-		const messages: string[] = [];
-
-		if (specificFields?.length) {
-			fieldErrors.forEach((field) => {
-				const fieldPath = Array.isArray(field.name) ? field.name : [field.name];
-
-				const isMatch = specificFields.some((specificField) => {
-					if (fieldPath.length < specificField.length) {
-						return false;
-					}
-					return specificField.every((part, idx) => fieldPath[idx] === part);
-				});
-
-				if (isMatch && field.errors.length > 0) {
-					field.errors.forEach((error) => messages.push(error));
-				}
-			});
-		} else {
-			const prefixPath = fieldNamePrefix.join('.');
-
-			fieldErrors.forEach((field) => {
-				const fieldPath = Array.isArray(field.name)
-					? field.name.join('.')
-					: String(field.name);
-
-				if (fieldPath.startsWith(prefixPath) && field.errors.length > 0) {
-					field.errors.forEach((error) => messages.push(error));
-				}
-			});
-		}
-
-		return {
-			hasErrors: messages.length > 0,
-			errorMessages: messages,
-		};
-	}, [form, fieldNamePrefix, specificFields]);
-}

frontend/src/lib/uPlotV2/config/UPlotConfigBuilder.ts

@@ -7,16 +7,11 @@ import { merge } from 'lodash-es';
 import noop from 'lodash-es/noop';
 import uPlot, { Cursor, Hooks, Options } from 'uplot';
 
-import {
-	DEFAULT_CURSOR_CONFIG,
-	DEFAULT_HOVER_PROXIMITY_VALUE,
-	DEFAULT_PLOT_CONFIG,
-	STEP_INTERVAL_MULTIPLIER,
-} from '../constants';
-import { calculateWidthBasedOnStepInterval } from '../utils';
 import {
 	ConfigBuilder,
 	ConfigBuilderProps,
+	DEFAULT_CURSOR_CONFIG,
+	DEFAULT_PLOT_CONFIG,
 	LegendItem,
 	SelectionPreferencesSource,
 } from './types';
@@ -50,8 +45,6 @@ export class UPlotConfigBuilder extends ConfigBuilder<
 
 	private axes: Record<string, UPlotAxisBuilder> = {};
 
-	private stepInterval: number | undefined;
-
 	readonly scales: UPlotScaleBuilder[] = [];
 
 	private bands: uPlot.Band[] = [];
@@ -86,7 +79,6 @@ export class UPlotConfigBuilder extends ConfigBuilder<
 			tzDate,
 			selectionPreferencesSource,
 			shouldSaveSelectionPreference,
-			stepInterval,
 		} = args ?? {};
 		if (widgetId) {
 			this.widgetId = widgetId;
@@ -104,10 +96,6 @@ export class UPlotConfigBuilder extends ConfigBuilder<
 			this.shouldSaveSelectionPreference = shouldSaveSelectionPreference;
 		}
 
-		if (stepInterval) {
-			this.stepInterval = stepInterval;
-		}
-
 		this.onDragSelect = noop;
 		if (onDragSelect) {
 			this.onDragSelect = onDragSelect;
@@ -384,31 +372,6 @@ export class UPlotConfigBuilder extends ConfigBuilder<
 		return this.widgetId;
 	}
 
-	/**
-	 * Get cursor configuration
-	 */
-	getCursorConfig(): Cursor {
-		if (this.stepInterval) {
-			const cursorConfig = {
-				...DEFAULT_CURSOR_CONFIG,
-				hover: {
-					...DEFAULT_CURSOR_CONFIG.hover,
-					prox: this.stepInterval
-						? (uPlotInstance: uPlot): number => {
-								const width = calculateWidthBasedOnStepInterval({
-									uPlotInstance,
-									stepInterval: this.stepInterval ?? 0,
-								});
-								return width * STEP_INTERVAL_MULTIPLIER;
-						  }
-						: DEFAULT_HOVER_PROXIMITY_VALUE,
-				},
-			};
-			return merge({}, DEFAULT_CURSOR_CONFIG, cursorConfig, this.cursor);
-		}
-		return merge({}, DEFAULT_CURSOR_CONFIG, this.cursor);
-	}
-
 	/**
 	 * Build the final uPlot.Options configuration
 	 */
@@ -450,7 +413,7 @@ export class UPlotConfigBuilder extends ConfigBuilder<
 		config.hooks = this.hooks;
 		config.select = this.select;
 
-		config.cursor = this.getCursorConfig();
+		config.cursor = merge({}, DEFAULT_CURSOR_CONFIG, this.cursor);
 		config.tzDate = this.tzDate;
 		config.plugins = this.plugins.length > 0 ? this.plugins : undefined;
 		config.bands = this.bands.length > 0 ? this.bands : undefined;

frontend/src/lib/uPlotV2/config/UPlotSeriesBuilder.ts

@@ -1,7 +1,6 @@
 import { PANEL_TYPES } from 'constants/queryBuilder';
 import { themeColors } from 'constants/theme';
 import { generateColor } from 'lib/uPlotLib/utils/generateColor';
-import { calculateWidthBasedOnStepInterval } from 'lib/uPlotV2/utils';
 import uPlot, { Series } from 'uplot';
 
 import {
@@ -292,16 +291,21 @@ function getBarPathBuilder({
 			idx1: number,
 		): Series.Paths | null => {
 			let effectiveBarMaxWidth = barMaxWidth;
-			const widthBasedOnStepInterval = calculateWidthBasedOnStepInterval({
-				uPlotInstance: self,
-				stepInterval,
-			});
 
-			if (widthBasedOnStepInterval > 0) {
-				effectiveBarMaxWidth = Math.min(
-					effectiveBarMaxWidth,
-					widthBasedOnStepInterval,
-				);
+			const xScale = self.scales.x as uPlot.Scale | undefined;
+			if (xScale && typeof xScale.min === 'number') {
+				const start = xScale.min as number;
+				const end = start + stepInterval;
+				const startPx = self.valToPos(start, 'x');
+				const endPx = self.valToPos(end, 'x');
+				const intervalPx = Math.abs(endPx - startPx);
+
+				if (intervalPx > 0) {
+					effectiveBarMaxWidth =
+						typeof barMaxWidth === 'number'
+							? Math.min(barMaxWidth, intervalPx)
+							: intervalPx;
+				}
 			}
 
 			const barsCfgKey = `bars|${barAlignment}|${barWidthFactor}|${effectiveBarMaxWidth}`;

frontend/src/lib/uPlotV2/config/__tests__/UPlotConfigBuilder.test.ts

@@ -1,10 +1,6 @@
 import { PANEL_TYPES } from 'constants/queryBuilder';
 import uPlot from 'uplot';
 
-import {
-	DEFAULT_HOVER_PROXIMITY_VALUE,
-	STEP_INTERVAL_MULTIPLIER,
-} from '../../constants';
 import type { SeriesProps } from '../types';
 import { DrawStyle, SelectionPreferencesSource } from '../types';
 import { UPlotConfigBuilder } from '../UPlotConfigBuilder';
@@ -17,14 +13,6 @@ jest.mock(
 	}),
 );
 
-jest.mock('lib/uPlotV2/utils', () => ({
-	calculateWidthBasedOnStepInterval: jest.fn(),
-}));
-
-const calculateWidthBasedOnStepIntervalMock = jest.requireMock(
-	'lib/uPlotV2/utils',
-).calculateWidthBasedOnStepInterval as jest.Mock;
-
 const getStoredSeriesVisibilityMock = jest.requireMock(
 	'container/DashboardContainer/visualization/panels/utils/legendVisibilityUtils',
 ) as {
@@ -396,52 +384,6 @@ describe('UPlotConfigBuilder', () => {
 		expect(config.cursor?.points).toBeDefined();
 	});
 
-	describe('getCursorConfig', () => {
-		it('returns default cursor merged with custom cursor when no stepInterval', () => {
-			const builder = new UPlotConfigBuilder();
-
-			builder.setCursor({
-				drag: { setScale: false },
-			});
-
-			const cursorConfig = builder.getCursorConfig();
-
-			expect(cursorConfig.drag?.setScale).toBe(false);
-			expect(cursorConfig.hover?.prox).toBe(DEFAULT_HOVER_PROXIMITY_VALUE);
-			expect(cursorConfig.points).toBeDefined();
-		});
-
-		it('returns hover prox as DEFAULT_HOVER_PROXIMITY_VALUE when stepInterval is not set', () => {
-			const builder = new UPlotConfigBuilder();
-
-			const cursorConfig = builder.getCursorConfig();
-
-			expect(cursorConfig.hover?.prox).toBe(DEFAULT_HOVER_PROXIMITY_VALUE);
-		});
-
-		it('returns hover prox as function when stepInterval is set, computing width * multiplier', () => {
-			const stepInterval = 60;
-			const mockWidth = 100;
-			calculateWidthBasedOnStepIntervalMock.mockReturnValue(mockWidth);
-
-			const builder = new UPlotConfigBuilder({ stepInterval });
-			const cursorConfig = builder.getCursorConfig();
-
-			expect(typeof cursorConfig.hover?.prox).toBe('function');
-
-			const uPlotInstance = {} as uPlot;
-			const proxResult = (cursorConfig.hover!.prox as (u: uPlot) => number)(
-				uPlotInstance,
-			);
-
-			expect(calculateWidthBasedOnStepIntervalMock).toHaveBeenCalledWith({
-				uPlotInstance,
-				stepInterval,
-			});
-			expect(proxResult).toBe(mockWidth * STEP_INTERVAL_MULTIPLIER);
-		});
-	});
-
 	it('adds plugins and includes them in config', () => {
 		const builder = new UPlotConfigBuilder();
 		const plugin: uPlot.Plugin = {

frontend/src/lib/uPlotV2/config/types.ts

@@ -1,6 +1,6 @@
 import { PrecisionOption } from 'components/Graph/types';
 import { PANEL_TYPES } from 'constants/queryBuilder';
-import uPlot, { Series } from 'uplot';
+import uPlot, { Cursor, Options, Series } from 'uplot';
 
 import { ThresholdsDrawHookOptions } from '../hooks/types';
 
@@ -39,7 +39,6 @@ export interface ConfigBuilderProps {
 	tzDate?: uPlot.LocalDateFromUnix;
 	selectionPreferencesSource?: SelectionPreferencesSource;
 	shouldSaveSelectionPreference?: boolean;
-	stepInterval?: number;
 }
 
 /**
@@ -187,3 +186,47 @@ export interface LegendItem {
 	color: uPlot.Series['stroke'];
 	show: boolean;
 }
+
+export const DEFAULT_PLOT_CONFIG: Partial<Options> = {
+	focus: {
+		alpha: 0.3,
+	},
+	cursor: {
+		focus: {
+			prox: 30,
+		},
+	},
+	legend: {
+		show: false,
+	},
+	padding: [16, 16, 8, 8],
+	series: [],
+	hooks: {},
+};
+
+const POINTS_FILL_COLOR = '#FFFFFF';
+
+export const DEFAULT_CURSOR_CONFIG: Cursor = {
+	drag: { setScale: true },
+	points: {
+		one: true,
+		size: (u, seriesIdx) => (u.series[seriesIdx]?.points?.size ?? 0) * 3,
+		width: (_u, _seriesIdx, size) => size / 4,
+		stroke: (u, seriesIdx): string => {
+			const points = u.series[seriesIdx]?.points;
+			const strokeFn =
+				typeof points?.stroke === 'function' ? points.stroke : undefined;
+			const strokeValue =
+				strokeFn !== undefined
+					? strokeFn(u, seriesIdx)
+					: typeof points?.stroke === 'string'
+					? points.stroke
+					: '';
+			return `${strokeValue}90`;
+		},
+		fill: (): string => POINTS_FILL_COLOR,
+	},
+	focus: {
+		prox: 30,
+	},
+};

frontend/src/lib/uPlotV2/constants.ts

@@ -1,48 +0,0 @@
-import { Cursor, Options } from 'uplot';
-
-const POINTS_FILL_COLOR = '#FFFFFF';
-
-export const DEFAULT_HOVER_PROXIMITY_VALUE = 30; // only snap if within 30px horizontally
-export const DEFAULT_FOCUS_PROXIMITY_VALUE = 1e6;
-export const STEP_INTERVAL_MULTIPLIER = 3; // multiply the width computed by STEP_INTERVAL_MULTIPLIER to get the hover prox value
-
-export const DEFAULT_PLOT_CONFIG: Partial<Options> = {
-	focus: {
-		alpha: 0.3,
-	},
-	legend: {
-		show: false,
-	},
-	padding: [16, 16, 8, 8],
-	series: [],
-	hooks: {},
-};
-
-export const DEFAULT_CURSOR_CONFIG: Cursor = {
-	drag: { setScale: true },
-	points: {
-		one: true,
-		size: (u, seriesIdx) => (u.series[seriesIdx]?.points?.size ?? 0) * 3,
-		width: (_u, _seriesIdx, size) => size / 4,
-		stroke: (u, seriesIdx): string => {
-			const points = u.series[seriesIdx]?.points;
-			const strokeFn =
-				typeof points?.stroke === 'function' ? points.stroke : undefined;
-			const strokeValue =
-				strokeFn !== undefined
-					? strokeFn(u, seriesIdx)
-					: typeof points?.stroke === 'string'
-					? points.stroke
-					: '';
-			return `${strokeValue}90`;
-		},
-		fill: (): string => POINTS_FILL_COLOR,
-	},
-	focus: {
-		prox: DEFAULT_FOCUS_PROXIMITY_VALUE,
-	},
-	hover: {
-		prox: DEFAULT_HOVER_PROXIMITY_VALUE,
-		bias: 0,
-	},
-};

frontend/src/lib/uPlotV2/plugins/TooltipPlugin/tooltipController.ts

@@ -87,7 +87,7 @@ export function shouldShowTooltipForSync(
 export function shouldShowTooltipForInteraction(
 	controller: TooltipControllerState,
 ): boolean {
-	return controller.focusedSeriesIndex != null;
+	return controller.focusedSeriesIndex != null || controller.isAnySeriesActive;
 }
 
 export function updateHoverState(

frontend/src/lib/uPlotV2/utils/__tests__/index.test.ts

@@ -1,70 +0,0 @@
-import uPlot from 'uplot';
-
-import { calculateWidthBasedOnStepInterval } from '../index';
-
-describe('calculateWidthBasedOnStepInterval', () => {
-	it('returns pixel width between start and start+stepInterval when xScale exists with numeric min', () => {
-		const valToPos = jest
-			.fn()
-			.mockReturnValueOnce(100) // startPx for start
-			.mockReturnValueOnce(250); // endPx for start + stepInterval
-
-		const uPlotInstance = ({
-			scales: { x: { min: 1000 } },
-			valToPos,
-		} as unknown) as uPlot;
-
-		const result = calculateWidthBasedOnStepInterval({
-			uPlotInstance,
-			stepInterval: 60,
-		});
-
-		expect(valToPos).toHaveBeenCalledWith(1000, 'x');
-		expect(valToPos).toHaveBeenCalledWith(1060, 'x');
-		expect(result).toBe(150); // Math.abs(250 - 100)
-	});
-
-	it('returns absolute pixel width when endPx is less than startPx', () => {
-		const valToPos = jest.fn().mockReturnValueOnce(250).mockReturnValueOnce(100);
-
-		const uPlotInstance = ({
-			scales: { x: { min: 0 } },
-			valToPos,
-		} as unknown) as uPlot;
-
-		const result = calculateWidthBasedOnStepInterval({
-			uPlotInstance,
-			stepInterval: 60,
-		});
-
-		expect(result).toBe(150); // Math.abs(100 - 250)
-	});
-
-	it('returns 0 when xScale is undefined', () => {
-		const uPlotInstance = ({
-			scales: { x: undefined },
-			valToPos: jest.fn(),
-		} as unknown) as uPlot;
-
-		const result = calculateWidthBasedOnStepInterval({
-			uPlotInstance,
-			stepInterval: 60,
-		});
-
-		expect(result).toBe(0);
-	});
-
-	it('returns 0 when xScale.min is not a number', () => {
-		const uPlotInstance = ({
-			scales: { x: { min: undefined } },
-			valToPos: jest.fn(),
-		} as unknown) as uPlot;
-
-		const result = calculateWidthBasedOnStepInterval({
-			uPlotInstance,
-			stepInterval: 60,
-		});
-
-		expect(result).toBe(0);
-	});
-});

frontend/src/lib/uPlotV2/utils/index.ts

@@ -1,17 +0,0 @@
-export function calculateWidthBasedOnStepInterval({
-	uPlotInstance,
-	stepInterval,
-}: {
-	uPlotInstance: uPlot;
-	stepInterval: number;
-}): number {
-	const xScale = uPlotInstance.scales.x;
-	if (xScale && typeof xScale.min === 'number') {
-		const start = xScale.min as number;
-		const end = start + stepInterval;
-		const startPx = uPlotInstance.valToPos(start, 'x');
-		const endPx = uPlotInstance.valToPos(end, 'x');
-		return Math.abs(endPx - startPx);
-	}
-	return 0;
-}

frontend/src/mocks-server/__mockdata__/roles.ts

@@ -1,64 +0,0 @@
-import { RoletypesRoleDTO } from 'api/generated/services/sigNoz.schemas';
-
-const orgId = '019ba2bb-2fa1-7b24-8159-cfca08617ef9';
-
-export const managedRoles: RoletypesRoleDTO[] = [
-	{
-		id: '019c24aa-2248-756f-9833-984f1ab63819',
-		createdAt: new Date('2026-02-03T18:00:55.624356Z'),
-		updatedAt: new Date('2026-02-03T18:00:55.624356Z'),
-		name: 'signoz-admin',
-		description:
-			'Role assigned to users who have full administrative access to SigNoz resources.',
-		type: 'managed',
-		orgId,
-	},
-	{
-		id: '019c24aa-2248-757c-9faf-7b1e899751e0',
-		createdAt: new Date('2026-02-03T18:00:55.624359Z'),
-		updatedAt: new Date('2026-02-03T18:00:55.624359Z'),
-		name: 'signoz-editor',
-		description:
-			'Role assigned to users who can create, edit, and manage SigNoz resources but do not have full administrative privileges.',
-		type: 'managed',
-		orgId,
-	},
-	{
-		id: '019c24aa-2248-7585-a129-4188b3473c27',
-		createdAt: new Date('2026-02-03T18:00:55.624362Z'),
-		updatedAt: new Date('2026-02-03T18:00:55.624362Z'),
-		name: 'signoz-viewer',
-		description:
-			'Role assigned to users who have read-only access to SigNoz resources.',
-		type: 'managed',
-		orgId,
-	},
-];
-
-export const customRoles: RoletypesRoleDTO[] = [
-	{
-		id: '019c24aa-3333-0001-aaaa-111111111111',
-		createdAt: new Date('2026-02-10T10:30:00.000Z'),
-		updatedAt: new Date('2026-02-12T14:20:00.000Z'),
-		name: 'billing-manager',
-		description: 'Custom role for managing billing and invoices.',
-		type: 'custom',
-		orgId,
-	},
-	{
-		id: '019c24aa-3333-0002-bbbb-222222222222',
-		createdAt: new Date('2026-02-11T09:00:00.000Z'),
-		updatedAt: new Date('2026-02-13T11:45:00.000Z'),
-		name: 'dashboard-creator',
-		description: 'Custom role allowing users to create and manage dashboards.',
-		type: 'custom',
-		orgId,
-	},
-];
-
-export const allRoles: RoletypesRoleDTO[] = [...managedRoles, ...customRoles];
-
-export const listRolesSuccessResponse = {
-	status: 'success',
-	data: allRoles,
-};

frontend/src/pages/Settings/Settings.tsx

@@ -77,7 +77,6 @@ function SettingsPage(): JSX.Element {
 						...item,
 						isEnabled:
 							item.key === ROUTES.BILLING ||
-							item.key === ROUTES.ROLES_SETTINGS ||
 							item.key === ROUTES.INTEGRATIONS ||
 							item.key === ROUTES.CUSTOM_DOMAIN_SETTINGS ||
 							item.key === ROUTES.API_KEYS ||
@@ -108,7 +107,6 @@ function SettingsPage(): JSX.Element {
 						...item,
 						isEnabled:
 							item.key === ROUTES.BILLING ||
-							item.key === ROUTES.ROLES_SETTINGS ||
 							item.key === ROUTES.INTEGRATIONS ||
 							item.key === ROUTES.API_KEYS ||
 							item.key === ROUTES.ORG_SETTINGS ||
@@ -136,9 +134,7 @@ function SettingsPage(): JSX.Element {
 					updatedItems = updatedItems.map((item) => ({
 						...item,
 						isEnabled:
-							item.key === ROUTES.API_KEYS ||
-							item.key === ROUTES.ORG_SETTINGS ||
-							item.key === ROUTES.ROLES_SETTINGS
+							item.key === ROUTES.API_KEYS || item.key === ROUTES.ORG_SETTINGS
 								? true
 								: item.isEnabled,
 					}));

frontend/src/pages/Settings/config.tsx

@@ -12,7 +12,6 @@ import IngestionSettings from 'container/IngestionSettings/IngestionSettings';
 import MultiIngestionSettings from 'container/IngestionSettings/MultiIngestionSettings';
 import MySettings from 'container/MySettings';
 import OrganizationSettings from 'container/OrganizationSettings';
-import RolesSettings from 'container/RolesSettings';
 import { TFunction } from 'i18next';
 import {
 	Backpack,
@@ -25,7 +24,6 @@ import {
 	KeySquare,
 	Pencil,
 	Plus,
-	Shield,
 	User,
 } from 'lucide-react';
 import ChannelsEdit from 'pages/ChannelsEdit';
@@ -150,19 +148,6 @@ export const billingSettings = (t: TFunction): RouteTabProps['routes'] => [
 	},
 ];
 
-export const rolesSettings = (t: TFunction): RouteTabProps['routes'] => [
-	{
-		Component: RolesSettings,
-		name: (
-			<div className="periscope-tab">
-				<Shield size={16} /> {t('routes:roles').toString()}
-			</div>
-		),
-		route: ROUTES.ROLES_SETTINGS,
-		key: ROUTES.ROLES_SETTINGS,
-	},
-];
-
 export const keyboardShortcuts = (t: TFunction): RouteTabProps['routes'] => [
 	{
 		Component: Shortcuts,

frontend/src/pages/Settings/utils.ts

@@ -15,7 +15,6 @@ import {
 	multiIngestionSettings,
 	mySettings,
 	organizationSettings,
-	rolesSettings,
 } from './config';
 
 export const getRoutes = (
@@ -67,10 +66,6 @@ export const getRoutes = (
 		settings.push(...customDomainSettings(t), ...billingSettings(t));
 	}
 
-	if (isAdmin) {
-		settings.push(...rolesSettings(t));
-	}
-
 	settings.push(
 		...mySettings(t),
 		...createAlertChannels(t),

frontend/src/utils/errorUtils.ts

@@ -1,8 +1,3 @@
-import { ErrorResponseHandlerV2 } from 'api/ErrorResponseHandlerV2';
-import { AxiosError } from 'axios';
-import { ErrorV2Resp } from 'types/api';
-import APIError from 'types/api/error';
-
 /**
  * Extracts HTTP status code from various error types
  * @param error - The error object (could be APIError, AxiosError, or other error types)
@@ -33,25 +28,3 @@ export const isRetryableError = (error: any): boolean => {
 	// If no status code is available, default to retryable
 	return !statusCode || statusCode >= 500;
 };
-
-export function toAPIError(
-	error: unknown,
-	defaultMessage = 'An unexpected error occurred.',
-): APIError {
-	try {
-		ErrorResponseHandlerV2(error as AxiosError<ErrorV2Resp>);
-	} catch (apiError) {
-		if (apiError instanceof APIError) {
-			return apiError;
-		}
-	}
-	return new APIError({
-		httpStatusCode: 500,
-		error: {
-			code: 'UNKNOWN_ERROR',
-			message: defaultMessage,
-			url: '',
-			errors: [],
-		},
-	});
-}

frontend/src/utils/permission/index.ts

@@ -97,7 +97,6 @@ export const routePermission: Record<keyof typeof ROUTES, ROLES[]> = {
 	GET_STARTED_AZURE_MONITORING: ['ADMIN', 'EDITOR', 'VIEWER'],
 	WORKSPACE_LOCKED: ['ADMIN', 'EDITOR', 'VIEWER'],
 	WORKSPACE_SUSPENDED: ['ADMIN', 'EDITOR', 'VIEWER'],
-	ROLES_SETTINGS: ['ADMIN'],
 	BILLING: ['ADMIN'],
 	SUPPORT: ['ADMIN', 'EDITOR', 'VIEWER'],
 	SOMETHING_WENT_WRONG: ['ADMIN', 'EDITOR', 'VIEWER'],

frontend/yarn.lock

@@ -4479,19 +4479,6 @@
   dependencies:
     "@radix-ui/react-compose-refs" "1.1.2"
 
-"@radix-ui/react-switch@^1.1.4":
-  version "1.2.6"
-  resolved "https://registry.yarnpkg.com/@radix-ui/react-switch/-/react-switch-1.2.6.tgz#ff79acb831f0d5ea9216cfcc5b939912571358e3"
-  integrity sha512-bByzr1+ep1zk4VubeEVViV592vu2lHE2BZY5OnzehZqOOgogN80+mNtCqPkhn2gklJqOpxWgPoYTSnhBCqpOXQ==
-  dependencies:
-    "@radix-ui/primitive" "1.1.3"
-    "@radix-ui/react-compose-refs" "1.1.2"
-    "@radix-ui/react-context" "1.1.2"
-    "@radix-ui/react-primitive" "2.1.3"
-    "@radix-ui/react-use-controllable-state" "1.2.2"
-    "@radix-ui/react-use-previous" "1.1.1"
-    "@radix-ui/react-use-size" "1.1.1"
-
 "@radix-ui/react-tabs@1.0.4":
   version "1.0.4"
   resolved "https://registry.yarnpkg.com/@radix-ui/react-tabs/-/react-tabs-1.0.4.tgz#993608eec55a5d1deddd446fa9978d2bc1053da2"
@@ -5177,20 +5164,6 @@
     tailwind-merge "^2.5.2"
     tailwindcss-animate "^1.0.7"
 
-"@signozhq/switch@0.0.2":
-  version "0.0.2"
-  resolved "https://registry.yarnpkg.com/@signozhq/switch/-/switch-0.0.2.tgz#58003ce9c0cd1f2ad8266a7045182607ce51df76"
-  integrity sha512-3B3Y5dzIyepO6EQJ7agx97bPmwg1dcOY46q2lqviHnMxNk3Sv079nSNCaztjQlo0VR0qu2JgVXhWi5Lw9WBN8A==
-  dependencies:
-    "@radix-ui/react-icons" "^1.3.0"
-    "@radix-ui/react-slot" "^1.1.0"
-    "@radix-ui/react-switch" "^1.1.4"
-    class-variance-authority "^0.7.0"
-    clsx "^2.1.1"
-    lucide-react "^0.445.0"
-    tailwind-merge "^2.5.2"
-    tailwindcss-animate "^1.0.7"
-
 "@signozhq/table@0.3.7":
   version "0.3.7"
   resolved "https://registry.yarnpkg.com/@signozhq/table/-/table-0.3.7.tgz#895b710c02af124dfb5117e02bbc6d80ce062063"

pkg/apiserver/signozapiserver/metricsexplorer.go

@@ -10,26 +10,6 @@ import (
 )
 
 func (provider *provider) addMetricsExplorerRoutes(router *mux.Router) error {
-	if err := router.Handle("/api/v2/metrics", handler.New(
-		provider.authZ.ViewAccess(provider.metricsExplorerHandler.ListMetrics),
-		handler.OpenAPIDef{
-			ID:                  "ListMetrics",
-			Tags:                []string{"metrics"},
-			Summary:             "List metric names",
-			Description:         "This endpoint returns a list of distinct metric names within the specified time range",
-			Request:             nil,
-			RequestQuery:        new(metricsexplorertypes.ListMetricsParams),
-			RequestContentType:  "",
-			Response:            new(metricsexplorertypes.ListMetricsResponse),
-			ResponseContentType: "application/json",
-			SuccessStatusCode:   http.StatusOK,
-			ErrorStatusCodes:    []int{http.StatusBadRequest, http.StatusUnauthorized, http.StatusInternalServerError},
-			Deprecated:          false,
-			SecuritySchemes:     newSecuritySchemes(types.RoleViewer),
-		})).Methods(http.MethodGet).GetError(); err != nil {
-		return err
-	}
-
 	if err := router.Handle("/api/v2/metrics/stats", handler.New(
 		provider.authZ.ViewAccess(provider.metricsExplorerHandler.GetStats),
 		handler.OpenAPIDef{
@@ -68,27 +48,26 @@ func (provider *provider) addMetricsExplorerRoutes(router *mux.Router) error {
 		return err
 	}
 
-	if err := router.Handle("/api/v2/metrics/{metric_name}/attributes", handler.New(
+	if err := router.Handle("/api/v2/metrics/attributes", handler.New(
 		provider.authZ.ViewAccess(provider.metricsExplorerHandler.GetMetricAttributes),
 		handler.OpenAPIDef{
 			ID:                  "GetMetricAttributes",
 			Tags:                []string{"metrics"},
 			Summary:             "Get metric attributes",
 			Description:         "This endpoint returns attribute keys and their unique values for a specified metric",
-			Request:             nil,
-			RequestQuery:        new(metricsexplorertypes.MetricAttributesRequest),
-			RequestContentType:  "",
+			Request:             new(metricsexplorertypes.MetricAttributesRequest),
+			RequestContentType:  "application/json",
 			Response:            new(metricsexplorertypes.MetricAttributesResponse),
 			ResponseContentType: "application/json",
 			SuccessStatusCode:   http.StatusOK,
 			ErrorStatusCodes:    []int{http.StatusBadRequest, http.StatusUnauthorized, http.StatusInternalServerError},
 			Deprecated:          false,
 			SecuritySchemes:     newSecuritySchemes(types.RoleViewer),
-		})).Methods(http.MethodGet).GetError(); err != nil {
+		})).Methods(http.MethodPost).GetError(); err != nil {
 		return err
 	}
 
-	if err := router.Handle("/api/v2/metrics/{metric_name}/metadata", handler.New(
+	if err := router.Handle("/api/v2/metrics/metadata", handler.New(
 		provider.authZ.ViewAccess(provider.metricsExplorerHandler.GetMetricMetadata),
 		handler.OpenAPIDef{
 			ID:                  "GetMetricMetadata",
@@ -96,6 +75,7 @@ func (provider *provider) addMetricsExplorerRoutes(router *mux.Router) error {
 			Summary:             "Get metric metadata",
 			Description:         "This endpoint returns metadata information like metric description, unit, type, temporality, monotonicity for a specified metric",
 			Request:             nil,
+			RequestQuery:        new(metricsexplorertypes.MetricNameParams),
 			RequestContentType:  "",
 			Response:            new(metricsexplorertypes.MetricMetadata),
 			ResponseContentType: "application/json",
@@ -126,7 +106,7 @@ func (provider *provider) addMetricsExplorerRoutes(router *mux.Router) error {
 		return err
 	}
 
-	if err := router.Handle("/api/v2/metrics/{metric_name}/highlights", handler.New(
+	if err := router.Handle("/api/v2/metric/highlights", handler.New(
 		provider.authZ.ViewAccess(provider.metricsExplorerHandler.GetMetricHighlights),
 		handler.OpenAPIDef{
 			ID:                  "GetMetricHighlights",
@@ -134,6 +114,7 @@ func (provider *provider) addMetricsExplorerRoutes(router *mux.Router) error {
 			Summary:             "Get metric highlights",
 			Description:         "This endpoint returns highlights like number of datapoints, totaltimeseries, active time series, last received time for a specified metric",
 			Request:             nil,
+			RequestQuery:        new(metricsexplorertypes.MetricNameParams),
 			RequestContentType:  "",
 			Response:            new(metricsexplorertypes.MetricHighlightsResponse),
 			ResponseContentType: "application/json",
@@ -145,7 +126,7 @@ func (provider *provider) addMetricsExplorerRoutes(router *mux.Router) error {
 		return err
 	}
 
-	if err := router.Handle("/api/v2/metrics/{metric_name}/alerts", handler.New(
+	if err := router.Handle("/api/v2/metric/alerts", handler.New(
 		provider.authZ.ViewAccess(provider.metricsExplorerHandler.GetMetricAlerts),
 		handler.OpenAPIDef{
 			ID:                  "GetMetricAlerts",
@@ -153,6 +134,7 @@ func (provider *provider) addMetricsExplorerRoutes(router *mux.Router) error {
 			Summary:             "Get metric alerts",
 			Description:         "This endpoint returns associated alerts for a specified metric",
 			Request:             nil,
+			RequestQuery:        new(metricsexplorertypes.MetricNameParams),
 			RequestContentType:  "",
 			Response:            new(metricsexplorertypes.MetricAlertsResponse),
 			ResponseContentType: "application/json",
@@ -164,7 +146,7 @@ func (provider *provider) addMetricsExplorerRoutes(router *mux.Router) error {
 		return err
 	}
 
-	if err := router.Handle("/api/v2/metrics/{metric_name}/dashboards", handler.New(
+	if err := router.Handle("/api/v2/metric/dashboards", handler.New(
 		provider.authZ.ViewAccess(provider.metricsExplorerHandler.GetMetricDashboards),
 		handler.OpenAPIDef{
 			ID:                  "GetMetricDashboards",
@@ -172,6 +154,7 @@ func (provider *provider) addMetricsExplorerRoutes(router *mux.Router) error {
 			Summary:             "Get metric dashboards",
 			Description:         "This endpoint returns associated dashboards for a specified metric",
 			Request:             nil,
+			RequestQuery:        new(metricsexplorertypes.MetricNameParams),
 			RequestContentType:  "",
 			Response:            new(metricsexplorertypes.MetricDashboardsResponse),
 			ResponseContentType: "application/json",

pkg/http/handler/handler.go

@@ -7,7 +7,6 @@ import (
 	"github.com/SigNoz/signoz/pkg/errors"
 	"github.com/SigNoz/signoz/pkg/http/render"
 	"github.com/swaggest/openapi-go"
-	"github.com/swaggest/openapi-go/openapi3"
 )
 
 type ServeOpenAPIFunc func(openapi.OperationContext)
@@ -60,39 +59,7 @@ func (handler *handler) ServeOpenAPI(opCtx openapi.OperationContext) {
 	}
 
 	// Add request structure
-	reqOpts := []openapi.ContentOption{openapi.WithContentType(handler.openAPIDef.RequestContentType)}
-	if len(handler.openAPIDef.RequestExamples) > 0 {
-		reqOpts = append(reqOpts, openapi.WithCustomize(func(cor openapi.ContentOrReference) {
-			rbOrRef, ok := cor.(*openapi3.RequestBodyOrRef)
-			if !ok || rbOrRef.RequestBody == nil {
-				return
-			}
-			ct := handler.openAPIDef.RequestContentType
-			if ct == "" {
-				ct = "application/json"
-			}
-			mt, exists := rbOrRef.RequestBody.Content[ct]
-			if !exists {
-				return
-			}
-			if mt.Examples == nil {
-				mt.Examples = make(map[string]openapi3.ExampleOrRef)
-			}
-			for _, ex := range handler.openAPIDef.RequestExamples {
-				val := ex.Value
-				oaExample := openapi3.Example{Value: &val}
-				if ex.Summary != "" {
-					oaExample.WithSummary(ex.Summary)
-				}
-				if ex.Description != "" {
-					oaExample.WithDescription(ex.Description)
-				}
-				mt.Examples[ex.Name] = openapi3.ExampleOrRef{Example: &oaExample}
-			}
-			rbOrRef.RequestBody.Content[ct] = mt
-		}))
-	}
-	opCtx.AddReqStructure(handler.openAPIDef.Request, reqOpts...)
+	opCtx.AddReqStructure(handler.openAPIDef.Request, openapi.WithContentType(handler.openAPIDef.RequestContentType))
 
 	// Add request query structure
 	opCtx.AddReqStructure(handler.openAPIDef.RequestQuery)

pkg/http/handler/openapi.go

@@ -9,14 +9,6 @@ import (
 	"github.com/swaggest/rest/openapi"
 )
 
-// OpenAPIExample is a named example for an OpenAPI operation.
-type OpenAPIExample struct {
-	Name        string
-	Summary     string
-	Description string
-	Value       any
-}
-
 // Def is the definition of an OpenAPI operation
 type OpenAPIDef struct {
 	ID                  string
@@ -26,7 +18,6 @@ type OpenAPIDef struct {
 	Request             any
 	RequestQuery        any
 	RequestContentType  string
-	RequestExamples     []OpenAPIExample
 	Response            any
 	ResponseContentType string
 	SuccessStatusCode   int

pkg/modules/metricsexplorer/implmetricsexplorer/handler.go

@@ -13,14 +13,6 @@ import (
 	"github.com/gorilla/mux"
 )
 
-func extractMetricName(req *http.Request) (string, error) {
-	metricName := mux.Vars(req)["metric_name"]
-	if metricName == "" {
-		return "", errors.NewInvalidInputf(errors.CodeInvalidInput, "metric_name is required in URL path")
-	}
-	return metricName, nil
-}
-
 type handler struct {
 	module metricsexplorer.Module
 }
@@ -32,34 +24,6 @@ func NewHandler(m metricsexplorer.Module) metricsexplorer.Handler {
 	}
 }
 
-func (h *handler) ListMetrics(rw http.ResponseWriter, req *http.Request) {
-	claims, err := authtypes.ClaimsFromContext(req.Context())
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	var params metricsexplorertypes.ListMetricsParams
-	if err := binding.Query.BindQuery(req.URL.Query(), &params); err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	if err := params.Validate(); err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	orgID := valuer.MustNewUUID(claims.OrgID)
-	out, err := h.module.ListMetrics(req.Context(), orgID, &params)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	render.Success(rw, http.StatusOK, out)
-}
-
 func (h *handler) GetStats(rw http.ResponseWriter, req *http.Request) {
 	claims, err := authtypes.ClaimsFromContext(req.Context())
 	if err != nil {
@@ -150,23 +114,28 @@ func (h *handler) GetMetricMetadata(rw http.ResponseWriter, req *http.Request) {
 		return
 	}
 
-	metricName, err := extractMetricName(req)
-	if err != nil {
+	var params metricsexplorertypes.MetricNameParams
+	if err := binding.Query.BindQuery(req.URL.Query(), &params); err != nil {
 		render.Error(rw, err)
 		return
 	}
 
+	if params.MetricName == "" {
+		render.Error(rw, errors.NewInvalidInputf(errors.CodeInvalidInput, "metricName query parameter is required"))
+		return
+	}
+
 	orgID := valuer.MustNewUUID(claims.OrgID)
 
-	metadataMap, err := h.module.GetMetricMetadataMulti(req.Context(), orgID, []string{metricName})
+	metadataMap, err := h.module.GetMetricMetadataMulti(req.Context(), orgID, []string{params.MetricName})
 	if err != nil {
 		render.Error(rw, err)
 		return
 	}
 
-	metadata, ok := metadataMap[metricName]
+	metadata, ok := metadataMap[params.MetricName]
 	if !ok || metadata == nil {
-		render.Error(rw, errors.NewNotFoundf(errors.CodeNotFound, "metadata not found for metric %q", metricName))
+		render.Error(rw, errors.NewNotFoundf(errors.CodeNotFound, "metadata not found for metric %q", params.MetricName))
 		return
 	}
 
@@ -180,14 +149,19 @@ func (h *handler) GetMetricAlerts(rw http.ResponseWriter, req *http.Request) {
 		return
 	}
 
-	metricName, err := extractMetricName(req)
-	if err != nil {
+	var params metricsexplorertypes.MetricNameParams
+	if err := binding.Query.BindQuery(req.URL.Query(), &params); err != nil {
 		render.Error(rw, err)
 		return
 	}
 
+	if params.MetricName == "" {
+		render.Error(rw, errors.NewInvalidInputf(errors.CodeInvalidInput, "metricName query parameter is required"))
+		return
+	}
+
 	orgID := valuer.MustNewUUID(claims.OrgID)
-	out, err := h.module.GetMetricAlerts(req.Context(), orgID, metricName)
+	out, err := h.module.GetMetricAlerts(req.Context(), orgID, params.MetricName)
 	if err != nil {
 		render.Error(rw, err)
 		return
@@ -202,14 +176,19 @@ func (h *handler) GetMetricDashboards(rw http.ResponseWriter, req *http.Request)
 		return
 	}
 
-	metricName, err := extractMetricName(req)
-	if err != nil {
+	var params metricsexplorertypes.MetricNameParams
+	if err := binding.Query.BindQuery(req.URL.Query(), &params); err != nil {
 		render.Error(rw, err)
 		return
 	}
 
+	if params.MetricName == "" {
+		render.Error(rw, errors.NewInvalidInputf(errors.CodeInvalidInput, "metricName query parameter is required"))
+		return
+	}
+
 	orgID := valuer.MustNewUUID(claims.OrgID)
-	out, err := h.module.GetMetricDashboards(req.Context(), orgID, metricName)
+	out, err := h.module.GetMetricDashboards(req.Context(), orgID, params.MetricName)
 	if err != nil {
 		render.Error(rw, err)
 		return
@@ -224,14 +203,19 @@ func (h *handler) GetMetricHighlights(rw http.ResponseWriter, req *http.Request)
 		return
 	}
 
-	metricName, err := extractMetricName(req)
-	if err != nil {
+	var params metricsexplorertypes.MetricNameParams
+	if err := binding.Query.BindQuery(req.URL.Query(), &params); err != nil {
 		render.Error(rw, err)
 		return
 	}
 
+	if params.MetricName == "" {
+		render.Error(rw, errors.NewInvalidInputf(errors.CodeInvalidInput, "metricName query parameter is required"))
+		return
+	}
+
 	orgID := valuer.MustNewUUID(claims.OrgID)
-	highlights, err := h.module.GetMetricHighlights(req.Context(), orgID, metricName)
+	highlights, err := h.module.GetMetricHighlights(req.Context(), orgID, params.MetricName)
 	if err != nil {
 		render.Error(rw, err)
 		return
@@ -246,21 +230,8 @@ func (h *handler) GetMetricAttributes(rw http.ResponseWriter, req *http.Request)
 		return
 	}
 
-	metricName, err := extractMetricName(req)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
 	var in metricsexplorertypes.MetricAttributesRequest
-	if err := binding.Query.BindQuery(req.URL.Query(), &in); err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	in.MetricName = metricName
-
-	if err := in.Validate(); err != nil {
+	if err := binding.JSON.BindBody(req.Body, &in); err != nil {
 		render.Error(rw, err)
 		return
 	}

pkg/modules/metricsexplorer/implmetricsexplorer/module.go

@@ -56,88 +56,6 @@ func NewModule(ts telemetrystore.TelemetryStore, telemetryMetadataStore telemetr
 	}
 }
 
-func (m *module) ListMetrics(ctx context.Context, orgID valuer.UUID, params *metricsexplorertypes.ListMetricsParams) (*metricsexplorertypes.ListMetricsResponse, error) {
-	if err := params.Validate(); err != nil {
-		return nil, err
-	}
-
-	sb := sqlbuilder.NewSelectBuilder()
-	sb.Select("DISTINCT metric_name")
-
-	if params.Start != nil && params.End != nil {
-		start, end, distributedTsTable, _ := telemetrymetrics.WhichTSTableToUse(uint64(*params.Start), uint64(*params.End), nil)
-		sb.From(fmt.Sprintf("%s.%s", telemetrymetrics.DBName, distributedTsTable))
-		sb.Where(sb.Between("unix_milli", start, end))
-	} else {
-		sb.From(fmt.Sprintf("%s.%s", telemetrymetrics.DBName, telemetrymetrics.TimeseriesV41weekTableName))
-	}
-
-	sb.Where(sb.E("__normalized", false))
-
-	if params.Search != "" {
-		searchLower := strings.ToLower(params.Search)
-		searchLower = strings.ReplaceAll(searchLower, "%", "\\%")
-		searchLower = strings.ReplaceAll(searchLower, "_", "\\_")
-		sb.Where(sb.Like("lower(metric_name)", fmt.Sprintf("%%%s%%", searchLower)))
-	}
-
-	sb.OrderBy("metric_name ASC")
-	sb.Limit(params.Limit)
-
-	query, args := sb.BuildWithFlavor(sqlbuilder.ClickHouse)
-
-	valueCtx := ctxtypes.SetClickhouseMaxThreads(ctx, m.config.TelemetryStore.Threads)
-	db := m.telemetryStore.ClickhouseDB()
-	rows, err := db.Query(valueCtx, query, args...)
-	if err != nil {
-		return nil, errors.WrapInternalf(err, errors.CodeInternal, "failed to list metrics")
-	}
-	defer rows.Close()
-
-	metricNames := make([]string, 0)
-	for rows.Next() {
-		var name string
-		if err := rows.Scan(&name); err != nil {
-			return nil, errors.WrapInternalf(err, errors.CodeInternal, "failed to scan metric name")
-		}
-		metricNames = append(metricNames, name)
-	}
-
-	if err := rows.Err(); err != nil {
-		return nil, errors.WrapInternalf(err, errors.CodeInternal, "error iterating metric names")
-	}
-
-	if len(metricNames) == 0 {
-		return &metricsexplorertypes.ListMetricsResponse{
-			Metrics: []metricsexplorertypes.ListMetric{},
-		}, nil
-	}
-
-	metadata, err := m.GetMetricMetadataMulti(ctx, orgID, metricNames)
-	if err != nil {
-		return nil, err
-	}
-
-	metrics := make([]metricsexplorertypes.ListMetric, 0, len(metricNames))
-	for _, name := range metricNames {
-		metric := metricsexplorertypes.ListMetric{
-			MetricName: name,
-		}
-		if meta, ok := metadata[name]; ok && meta != nil {
-			metric.Description = meta.Description
-			metric.MetricType = meta.MetricType
-			metric.MetricUnit = meta.MetricUnit
-			metric.Temporality = meta.Temporality
-			metric.IsMonotonic = meta.IsMonotonic
-		}
-		metrics = append(metrics, metric)
-	}
-
-	return &metricsexplorertypes.ListMetricsResponse{
-		Metrics: metrics,
-	}, nil
-}
-
 func (m *module) GetStats(ctx context.Context, orgID valuer.UUID, req *metricsexplorertypes.StatsRequest) (*metricsexplorertypes.StatsResponse, error) {
 	if err := req.Validate(); err != nil {
 		return nil, err

pkg/modules/metricsexplorer/metricsexplorer.go

@@ -10,7 +10,6 @@ import (
 
 // Handler exposes HTTP handlers for the metrics module.
 type Handler interface {
-	ListMetrics(http.ResponseWriter, *http.Request)
 	GetStats(http.ResponseWriter, *http.Request)
 	GetTreemap(http.ResponseWriter, *http.Request)
 	GetMetricMetadata(http.ResponseWriter, *http.Request)
@@ -23,7 +22,6 @@ type Handler interface {
 
 // Module represents the metrics module interface.
 type Module interface {
-	ListMetrics(ctx context.Context, orgID valuer.UUID, params *metricsexplorertypes.ListMetricsParams) (*metricsexplorertypes.ListMetricsResponse, error)
 	GetStats(ctx context.Context, orgID valuer.UUID, req *metricsexplorertypes.StatsRequest) (*metricsexplorertypes.StatsResponse, error)
 	GetTreemap(ctx context.Context, orgID valuer.UUID, req *metricsexplorertypes.TreemapRequest) (*metricsexplorertypes.TreemapResponse, error)
 	GetMetricMetadataMulti(ctx context.Context, orgID valuer.UUID, metricNames []string) (map[string]*metricsexplorertypes.MetricMetadata, error)

pkg/modules/thirdpartyapi/translator.go

@@ -12,30 +12,60 @@ import (
 )
 
 const (
-	derivedKeyHTTPURL  = "http_url" // https://signoz.io/docs/traces-management/guides/derived-fields-spans/#http_url
-	derivedKeyHTTPHost = "http_host"
+	urlPathKeyLegacy       = "http.url"
+	serverAddressKeyLegacy = "net.peer.name"
+
+	urlPathKey       = "url.full"
+	serverAddressKey = "server.address"
 )
 
 var defaultStepInterval = 60 * time.Second
 
-var (
-	groupByKeyHTTPHost = qbtypes.GroupByKey{
-		TelemetryFieldKey: telemetrytypes.TelemetryFieldKey{
-			Name:          derivedKeyHTTPHost,
-			FieldDataType: telemetrytypes.FieldDataTypeString,
-			FieldContext:  telemetrytypes.FieldContextSpan,
-			Signal:        telemetrytypes.SignalTraces,
+type SemconvFieldMapping struct {
+	LegacyField  string
+	CurrentField string
+	FieldType    telemetrytypes.FieldDataType
+	Context      telemetrytypes.FieldContext
+}
+
+var dualSemconvGroupByKeys = map[string][]qbtypes.GroupByKey{
+	"server": {
+		{
+			TelemetryFieldKey: telemetrytypes.TelemetryFieldKey{
+				Name:          serverAddressKey,
+				FieldDataType: telemetrytypes.FieldDataTypeString,
+				FieldContext:  telemetrytypes.FieldContextAttribute,
+				Signal:        telemetrytypes.SignalTraces,
+			},
 		},
-	}
-	groupByKeyHTTPURL = qbtypes.GroupByKey{
-		TelemetryFieldKey: telemetrytypes.TelemetryFieldKey{
-			Name:          derivedKeyHTTPURL,
-			FieldDataType: telemetrytypes.FieldDataTypeString,
-			FieldContext:  telemetrytypes.FieldContextSpan,
-			Signal:        telemetrytypes.SignalTraces,
+		{
+			TelemetryFieldKey: telemetrytypes.TelemetryFieldKey{
+				Name:          serverAddressKeyLegacy,
+				FieldDataType: telemetrytypes.FieldDataTypeString,
+				FieldContext:  telemetrytypes.FieldContextAttribute,
+				Signal:        telemetrytypes.SignalTraces,
+			},
 		},
-	}
-)
+	},
+	"url": {
+		{
+			TelemetryFieldKey: telemetrytypes.TelemetryFieldKey{
+				Name:          urlPathKey,
+				FieldDataType: telemetrytypes.FieldDataTypeString,
+				FieldContext:  telemetrytypes.FieldContextAttribute,
+				Signal:        telemetrytypes.SignalTraces,
+			},
+		},
+		{
+			TelemetryFieldKey: telemetrytypes.TelemetryFieldKey{
+				Name:          urlPathKeyLegacy,
+				FieldDataType: telemetrytypes.FieldDataTypeString,
+				FieldContext:  telemetrytypes.FieldContextAttribute,
+				Signal:        telemetrytypes.SignalTraces,
+			},
+		},
+	},
+}
 
 func FilterIntermediateColumns(result *qbtypes.QueryRangeResponse) *qbtypes.QueryRangeResponse {
 	if result == nil || result.Data.Results == nil {
@@ -84,6 +114,103 @@ func FilterIntermediateColumns(result *qbtypes.QueryRangeResponse) *qbtypes.Quer
 	return result
 }
 
+func MergeSemconvColumns(result *qbtypes.QueryRangeResponse) *qbtypes.QueryRangeResponse {
+	if result == nil || result.Data.Results == nil {
+		return result
+	}
+
+	for _, res := range result.Data.Results {
+		scalarData, ok := res.(*qbtypes.ScalarData)
+		if !ok {
+			continue
+		}
+
+		serverAddressKeyIdx := -1
+		serverAddressKeyLegacyIdx := -1
+
+		for i, col := range scalarData.Columns {
+			if col.Name == serverAddressKey {
+				serverAddressKeyIdx = i
+			} else if col.Name == serverAddressKeyLegacy {
+				serverAddressKeyLegacyIdx = i
+			}
+		}
+
+		if serverAddressKeyIdx == -1 || serverAddressKeyLegacyIdx == -1 {
+			continue
+		}
+
+		var newRows [][]any
+		for _, row := range scalarData.Data {
+			if len(row) <= serverAddressKeyIdx || len(row) <= serverAddressKeyLegacyIdx {
+				continue
+			}
+
+			var serverName any
+			if isValidValue(row[serverAddressKeyIdx]) {
+				serverName = row[serverAddressKeyIdx]
+			} else if isValidValue(row[serverAddressKeyLegacyIdx]) {
+				serverName = row[serverAddressKeyLegacyIdx]
+			}
+
+			if serverName != nil {
+				newRow := make([]any, len(row)-1)
+				newRow[0] = serverName
+
+				targetIdx := 1
+				for i, val := range row {
+					if i != serverAddressKeyLegacyIdx && i != serverAddressKeyIdx {
+						if targetIdx < len(newRow) {
+							newRow[targetIdx] = val
+							targetIdx++
+						}
+					}
+				}
+				newRows = append(newRows, newRow)
+			}
+		}
+
+		newColumns := make([]*qbtypes.ColumnDescriptor, len(scalarData.Columns)-1)
+		targetIdx := 0
+		for i, col := range scalarData.Columns {
+			if i == serverAddressKeyIdx {
+				newCol := &qbtypes.ColumnDescriptor{
+					TelemetryFieldKey: telemetrytypes.TelemetryFieldKey{
+						Name:          serverAddressKeyLegacy,
+						FieldDataType: col.FieldDataType,
+						FieldContext:  col.FieldContext,
+						Signal:        col.Signal,
+					},
+					QueryName:        col.QueryName,
+					AggregationIndex: col.AggregationIndex,
+					Meta:             col.Meta,
+					Type:             col.Type,
+				}
+				newColumns[targetIdx] = newCol
+				targetIdx++
+			} else if i != serverAddressKeyLegacyIdx {
+				newColumns[targetIdx] = col
+				targetIdx++
+			}
+		}
+
+		scalarData.Columns = newColumns
+		scalarData.Data = newRows
+	}
+
+	return result
+}
+
+func isValidValue(val any) bool {
+	if val == nil {
+		return false
+	}
+	if str, ok := val.(string); ok {
+		return str != "" && str != "n/a"
+	}
+	return true
+}
+
 func FilterResponse(results []*qbtypes.QueryRangeResponse) []*qbtypes.QueryRangeResponse {
 	filteredResults := make([]*qbtypes.QueryRangeResponse, 0, len(results))
 
@@ -134,7 +261,7 @@ func FilterResponse(results []*qbtypes.QueryRangeResponse) []*qbtypes.QueryRange
 
 func shouldIncludeSeries(series *qbtypes.TimeSeries) bool {
 	for _, label := range series.Labels {
-		if label.Key.Name == derivedKeyHTTPHost {
+		if label.Key.Name == serverAddressKeyLegacy || label.Key.Name == serverAddressKey {
 			if strVal, ok := label.Value.(string); ok {
 				if net.ParseIP(strVal) != nil {
 					return false
@@ -147,10 +274,12 @@ func shouldIncludeSeries(series *qbtypes.TimeSeries) bool {
 
 func shouldIncludeRow(row *qbtypes.RawRow) bool {
 	if row.Data != nil {
-		if domainVal, ok := row.Data[derivedKeyHTTPHost]; ok {
-			if domainStr, ok := domainVal.(string); ok {
-				if net.ParseIP(domainStr) != nil {
-					return false
+		for _, key := range []string{serverAddressKeyLegacy, serverAddressKey} {
+			if domainVal, ok := row.Data[key]; ok {
+				if domainStr, ok := domainVal.(string); ok {
+					if net.ParseIP(domainStr) != nil {
+						return false
+					}
 				}
 			}
 		}
@@ -158,8 +287,8 @@ func shouldIncludeRow(row *qbtypes.RawRow) bool {
 	return true
 }
 
-func mergeGroupBy(base qbtypes.GroupByKey, additional []qbtypes.GroupByKey) []qbtypes.GroupByKey {
-	return append([]qbtypes.GroupByKey{base}, additional...)
+func mergeGroupBy(base, additional []qbtypes.GroupByKey) []qbtypes.GroupByKey {
+	return append(base, additional...)
 }
 
 func BuildDomainList(req *thirdpartyapitypes.ThirdPartyApiRequest) (*qbtypes.QueryRangeRequest, error) {
@@ -225,10 +354,10 @@ func buildEndpointsQuery(req *thirdpartyapitypes.ThirdPartyApiRequest) qbtypes.Q
 			Signal:       telemetrytypes.SignalTraces,
 			StepInterval: qbtypes.Step{Duration: defaultStepInterval},
 			Aggregations: []qbtypes.TraceAggregation{
-				{Expression: fmt.Sprintf("count_distinct(%s)", derivedKeyHTTPURL)},
+				{Expression: "count_distinct(http.url)"},
 			},
 			Filter:  buildBaseFilter(req.Filter),
-			GroupBy: mergeGroupBy(groupByKeyHTTPHost, req.GroupBy),
+			GroupBy: mergeGroupBy(dualSemconvGroupByKeys["server"], req.GroupBy),
 		},
 	}
 }
@@ -244,7 +373,7 @@ func buildLastSeenQuery(req *thirdpartyapitypes.ThirdPartyApiRequest) qbtypes.Qu
 				{Expression: "max(timestamp)"},
 			},
 			Filter:  buildBaseFilter(req.Filter),
-			GroupBy: mergeGroupBy(groupByKeyHTTPHost, req.GroupBy),
+			GroupBy: mergeGroupBy(dualSemconvGroupByKeys["server"], req.GroupBy),
 		},
 	}
 }
@@ -260,7 +389,7 @@ func buildRpsQuery(req *thirdpartyapitypes.ThirdPartyApiRequest) qbtypes.QueryEn
 				{Expression: "rate()"},
 			},
 			Filter:  buildBaseFilter(req.Filter),
-			GroupBy: mergeGroupBy(groupByKeyHTTPHost, req.GroupBy),
+			GroupBy: mergeGroupBy(dualSemconvGroupByKeys["server"], req.GroupBy),
 		},
 	}
 }
@@ -278,7 +407,7 @@ func buildErrorQuery(req *thirdpartyapitypes.ThirdPartyApiRequest) qbtypes.Query
 				{Expression: "count()"},
 			},
 			Filter:  filter,
-			GroupBy: mergeGroupBy(groupByKeyHTTPHost, req.GroupBy),
+			GroupBy: mergeGroupBy(dualSemconvGroupByKeys["server"], req.GroupBy),
 		},
 	}
 }
@@ -294,7 +423,7 @@ func buildTotalSpanQuery(req *thirdpartyapitypes.ThirdPartyApiRequest) qbtypes.Q
 				{Expression: "count()"},
 			},
 			Filter:  buildBaseFilter(req.Filter),
-			GroupBy: mergeGroupBy(groupByKeyHTTPHost, req.GroupBy),
+			GroupBy: mergeGroupBy(dualSemconvGroupByKeys["server"], req.GroupBy),
 		},
 	}
 }
@@ -310,7 +439,7 @@ func buildP99Query(req *thirdpartyapitypes.ThirdPartyApiRequest) qbtypes.QueryEn
 				{Expression: "p99(duration_nano)"},
 			},
 			Filter:  buildBaseFilter(req.Filter),
-			GroupBy: mergeGroupBy(groupByKeyHTTPHost, req.GroupBy),
+			GroupBy: mergeGroupBy(dualSemconvGroupByKeys["server"], req.GroupBy),
 		},
 	}
 }
@@ -333,10 +462,10 @@ func buildEndpointsInfoQuery(req *thirdpartyapitypes.ThirdPartyApiRequest) qbtyp
 			Signal:       telemetrytypes.SignalTraces,
 			StepInterval: qbtypes.Step{Duration: defaultStepInterval},
 			Aggregations: []qbtypes.TraceAggregation{
-				{Expression: fmt.Sprintf("rate(%s)", derivedKeyHTTPURL)},
+				{Expression: "rate(http.url)"},
 			},
 			Filter:  buildBaseFilter(req.Filter),
-			GroupBy: mergeGroupBy(groupByKeyHTTPURL, req.GroupBy),
+			GroupBy: mergeGroupBy(dualSemconvGroupByKeys["url"], req.GroupBy),
 		},
 	}
 }
@@ -390,7 +519,8 @@ func buildLastSeenInfoQuery(req *thirdpartyapitypes.ThirdPartyApiRequest) qbtype
 }
 
 func buildBaseFilter(additionalFilter *qbtypes.Filter) *qbtypes.Filter {
-	baseExpression := fmt.Sprintf("%s EXISTS AND kind_string = 'Client'", derivedKeyHTTPURL)
+	baseExpression := fmt.Sprintf("(%s EXISTS OR %s EXISTS) AND kind_string = 'Client'",
+		urlPathKeyLegacy, urlPathKey)
 
 	if additionalFilter != nil && additionalFilter.Expression != "" {
 		// even if it contains kind_string we add with an AND so it doesn't matter if the user is overriding it.

pkg/modules/thirdpartyapi/translator_test.go

@@ -1,9 +1,8 @@
 package thirdpartyapi
 
 import (
-	"testing"
-
 	"github.com/SigNoz/signoz/pkg/types/thirdpartyapitypes"
+	"testing"
 
 	qbtypes "github.com/SigNoz/signoz/pkg/types/querybuildertypes/querybuildertypesv5"
 	"github.com/SigNoz/signoz/pkg/types/telemetrytypes"
@@ -29,7 +28,7 @@ func TestFilterResponse(t *testing.T) {
 											{
 												Labels: []*qbtypes.Label{
 													{
-														Key:   telemetrytypes.TelemetryFieldKey{Name: derivedKeyHTTPHost},
+														Key:   telemetrytypes.TelemetryFieldKey{Name: "net.peer.name"},
 														Value: "192.168.1.1",
 													},
 												},
@@ -37,7 +36,7 @@ func TestFilterResponse(t *testing.T) {
 											{
 												Labels: []*qbtypes.Label{
 													{
-														Key:   telemetrytypes.TelemetryFieldKey{Name: derivedKeyHTTPHost},
+														Key:   telemetrytypes.TelemetryFieldKey{Name: "net.peer.name"},
 														Value: "example.com",
 													},
 												},
@@ -61,7 +60,7 @@ func TestFilterResponse(t *testing.T) {
 											{
 												Labels: []*qbtypes.Label{
 													{
-														Key:   telemetrytypes.TelemetryFieldKey{Name: derivedKeyHTTPHost},
+														Key:   telemetrytypes.TelemetryFieldKey{Name: "net.peer.name"},
 														Value: "example.com",
 													},
 												},
@@ -85,12 +84,12 @@ func TestFilterResponse(t *testing.T) {
 								Rows: []*qbtypes.RawRow{
 									{
 										Data: map[string]any{
-											derivedKeyHTTPHost: "192.168.1.1",
+											"net.peer.name": "192.168.1.1",
 										},
 									},
 									{
 										Data: map[string]any{
-											derivedKeyHTTPHost: "example.com",
+											"net.peer.name": "example.com",
 										},
 									},
 								},
@@ -107,7 +106,7 @@ func TestFilterResponse(t *testing.T) {
 								Rows: []*qbtypes.RawRow{
 									{
 										Data: map[string]any{
-											derivedKeyHTTPHost: "example.com",
+											"net.peer.name": "example.com",
 										},
 									},
 								},

pkg/querier/openapi.go

@@ -1,454 +0,0 @@
-package querier
-
-import (
-	"net/http"
-
-	"github.com/SigNoz/signoz/pkg/http/handler"
-	qbtypes "github.com/SigNoz/signoz/pkg/types/querybuildertypes/querybuildertypesv5"
-	"github.com/SigNoz/signoz/pkg/types/ctxtypes"
-)
-
-// QueryRangeV5OpenAPIDef is the OpenAPI definition for the /api/v5/query_range endpoint.
-var QueryRangeV5OpenAPIDef = handler.OpenAPIDef{
-	ID:                  "QueryRangeV5",
-	Tags:                []string{"query"},
-	Summary:             "Query range",
-	Description:         "Execute a composite query over a time range. Supports builder queries (traces, logs, metrics), formulas, trace operators, PromQL, and ClickHouse SQL.",
-	Request:             new(qbtypes.QueryRangeRequest),
-	RequestContentType:  "application/json",
-	RequestExamples:     queryRangeV5Examples,
-	Response:            new(qbtypes.QueryRangeResponse),
-	ResponseContentType: "application/json",
-	SuccessStatusCode:   http.StatusOK,
-	ErrorStatusCodes:    []int{http.StatusBadRequest},
-	SecuritySchemes: []handler.OpenAPISecurityScheme{
-		{Name: ctxtypes.AuthTypeAPIKey.StringValue(), Scopes: []string{"VIEWER"}},
-		{Name: ctxtypes.AuthTypeTokenizer.StringValue(), Scopes: []string{"VIEWER"}},
-	},
-}
-
-var queryRangeV5Examples = []handler.OpenAPIExample{
-	{
-		Name:    "traces_time_series",
-		Summary: "Time series: count spans grouped by service",
-		Value: map[string]any{
-			"schemaVersion": "v1",
-			"start":         1640995200000,
-			"end":           1640998800000,
-			"requestType":   "time_series",
-			"compositeQuery": map[string]any{
-				"queries": []any{
-					map[string]any{
-						"type": "builder_query",
-						"spec": map[string]any{
-							"name":   "A",
-							"signal": "traces",
-							"aggregations": []any{
-								map[string]any{"expression": "count()", "alias": "span_count"},
-							},
-							"stepInterval": "60s",
-							"filter":       map[string]any{"expression": "service.name = 'frontend'"},
-							"groupBy":      []any{map[string]any{"name": "service.name", "fieldContext": "resource"}},
-							"order":        []any{map[string]any{"key": map[string]any{"name": "span_count"}, "direction": "desc"}},
-							"limit":        10,
-						},
-					},
-				},
-			},
-		},
-	},
-	{
-		Name:    "logs_time_series",
-		Summary: "Time series: count error logs grouped by service",
-		Value: map[string]any{
-			"schemaVersion": "v1",
-			"start":         1640995200000,
-			"end":           1640998800000,
-			"requestType":   "time_series",
-			"compositeQuery": map[string]any{
-				"queries": []any{
-					map[string]any{
-						"type": "builder_query",
-						"spec": map[string]any{
-							"name":   "A",
-							"signal": "logs",
-							"aggregations": []any{
-								map[string]any{"expression": "count()", "alias": "log_count"},
-							},
-							"stepInterval": "60s",
-							"filter":       map[string]any{"expression": "severity_text = 'ERROR'"},
-							"groupBy":      []any{map[string]any{"name": "service.name", "fieldContext": "resource"}},
-							"order":        []any{map[string]any{"key": map[string]any{"name": "log_count"}, "direction": "desc"}},
-							"limit":        10,
-						},
-					},
-				},
-			},
-		},
-	},
-	{
-		Name:    "metrics_gauge_time_series",
-		Summary: "Time series: latest gauge value averaged across series",
-		Value: map[string]any{
-			"schemaVersion": "v1",
-			"start":         1640995200000,
-			"end":           1640998800000,
-			"requestType":   "time_series",
-			"compositeQuery": map[string]any{
-				"queries": []any{
-					map[string]any{
-						"type": "builder_query",
-						"spec": map[string]any{
-							"name":   "A",
-							"signal": "metrics",
-							"aggregations": []any{
-								map[string]any{"metricName": "system.cpu.utilization", "timeAggregation": "latest", "spaceAggregation": "avg"},
-							},
-							"stepInterval": "60s",
-							"groupBy":      []any{map[string]any{"name": "host.name", "fieldContext": "resource"}},
-						},
-					},
-				},
-			},
-		},
-	},
-	{
-		Name:    "metrics_rate_time_series",
-		Summary: "Time series: rate of cumulative counter",
-		Value: map[string]any{
-			"schemaVersion": "v1",
-			"start":         1640995200000,
-			"end":           1640998800000,
-			"requestType":   "time_series",
-			"compositeQuery": map[string]any{
-				"queries": []any{
-					map[string]any{
-						"type": "builder_query",
-						"spec": map[string]any{
-							"name":   "A",
-							"signal": "metrics",
-							"aggregations": []any{
-								map[string]any{"metricName": "http.server.duration.count", "timeAggregation": "rate", "spaceAggregation": "sum"},
-							},
-							"stepInterval": 120,
-							"groupBy":      []any{map[string]any{"name": "service.name", "fieldContext": "resource"}},
-						},
-					},
-				},
-			},
-		},
-	},
-	{
-		Name:    "metrics_histogram_time_series",
-		Summary: "Time series: p99 latency from histogram",
-		Value: map[string]any{
-			"schemaVersion": "v1",
-			"start":         1640995200000,
-			"end":           1640998800000,
-			"requestType":   "time_series",
-			"compositeQuery": map[string]any{
-				"queries": []any{
-					map[string]any{
-						"type": "builder_query",
-						"spec": map[string]any{
-							"name":   "A",
-							"signal": "metrics",
-							"aggregations": []any{
-								map[string]any{"metricName": "http.server.duration.bucket", "spaceAggregation": "p99"},
-							},
-							"stepInterval": "60s",
-							"groupBy":      []any{map[string]any{"name": "service.name", "fieldContext": "resource"}},
-						},
-					},
-				},
-			},
-		},
-	},
-	{
-		Name:    "logs_raw",
-		Summary: "Raw: fetch raw log records",
-		Value: map[string]any{
-			"schemaVersion": "v1",
-			"start":         1640995200000,
-			"end":           1640998800000,
-			"requestType":   "raw",
-			"compositeQuery": map[string]any{
-				"queries": []any{
-					map[string]any{
-						"type": "builder_query",
-						"spec": map[string]any{
-							"name":   "A",
-							"signal": "logs",
-							"filter": map[string]any{"expression": "severity_text = 'ERROR'"},
-							"selectFields": []any{
-								map[string]any{"name": "body", "fieldContext": "log"},
-								map[string]any{"name": "service.name", "fieldContext": "resource"},
-							},
-							"order": []any{
-								map[string]any{"key": map[string]any{"name": "timestamp", "fieldContext": "log"}, "direction": "desc"},
-								map[string]any{"key": map[string]any{"name": "id"}, "direction": "desc"},
-							},
-							"limit":  50,
-							"offset": 0,
-						},
-					},
-				},
-			},
-		},
-	},
-	{
-		Name:    "traces_raw",
-		Summary: "Raw: fetch raw span records",
-		Value: map[string]any{
-			"schemaVersion": "v1",
-			"start":         1640995200000,
-			"end":           1640998800000,
-			"requestType":   "raw",
-			"compositeQuery": map[string]any{
-				"queries": []any{
-					map[string]any{
-						"type": "builder_query",
-						"spec": map[string]any{
-							"name":   "A",
-							"signal": "traces",
-							"filter": map[string]any{"expression": "service.name = 'frontend' AND has_error = true"},
-							"selectFields": []any{
-								map[string]any{"name": "name", "fieldContext": "span"},
-								map[string]any{"name": "duration_nano", "fieldContext": "span"},
-							},
-							"order": []any{
-								map[string]any{"key": map[string]any{"name": "timestamp", "fieldContext": "span"}, "direction": "desc"},
-							},
-							"limit": 100,
-						},
-					},
-				},
-			},
-		},
-	},
-	{
-		Name:    "traces_scalar",
-		Summary: "Scalar: total span count",
-		Value: map[string]any{
-			"schemaVersion": "v1",
-			"start":         1640995200000,
-			"end":           1640998800000,
-			"requestType":   "scalar",
-			"compositeQuery": map[string]any{
-				"queries": []any{
-					map[string]any{
-						"type": "builder_query",
-						"spec": map[string]any{
-							"name":   "A",
-							"signal": "traces",
-							"aggregations": []any{
-								map[string]any{"expression": "count()", "alias": "span_count"},
-							},
-							"filter": map[string]any{"expression": "service.name = 'frontend'"},
-						},
-					},
-				},
-			},
-		},
-	},
-	{
-		Name:    "logs_scalar",
-		Summary: "Scalar: total error log count",
-		Value: map[string]any{
-			"schemaVersion": "v1",
-			"start":         1640995200000,
-			"end":           1640998800000,
-			"requestType":   "scalar",
-			"compositeQuery": map[string]any{
-				"queries": []any{
-					map[string]any{
-						"type": "builder_query",
-						"spec": map[string]any{
-							"name":   "A",
-							"signal": "logs",
-							"aggregations": []any{
-								map[string]any{"expression": "count()", "alias": "error_count"},
-							},
-							"filter": map[string]any{"expression": "severity_text = 'ERROR'"},
-						},
-					},
-				},
-			},
-		},
-	},
-	{
-		Name:    "metrics_scalar",
-		Summary: "Scalar: single reduced metric value",
-		Value: map[string]any{
-			"schemaVersion": "v1",
-			"start":         1640995200000,
-			"end":           1640998800000,
-			"requestType":   "scalar",
-			"compositeQuery": map[string]any{
-				"queries": []any{
-					map[string]any{
-						"type": "builder_query",
-						"spec": map[string]any{
-							"name":   "A",
-							"signal": "metrics",
-							"aggregations": []any{
-								map[string]any{"metricName": "http.server.duration.count", "timeAggregation": "rate", "spaceAggregation": "sum", "reduceTo": "sum"},
-							},
-							"stepInterval": "60s",
-						},
-					},
-				},
-			},
-		},
-	},
-	{
-		Name:    "formula",
-		Summary: "Formula: error rate from two trace queries",
-		Value: map[string]any{
-			"schemaVersion": "v1",
-			"start":         1640995200000,
-			"end":           1640998800000,
-			"requestType":   "time_series",
-			"compositeQuery": map[string]any{
-				"queries": []any{
-					map[string]any{
-						"type": "builder_query",
-						"spec": map[string]any{
-							"name":         "A",
-							"signal":       "traces",
-							"aggregations": []any{map[string]any{"expression": "countIf(has_error = true)"}},
-							"stepInterval": "60s",
-							"groupBy":      []any{map[string]any{"name": "service.name", "fieldContext": "resource"}},
-						},
-					},
-					map[string]any{
-						"type": "builder_query",
-						"spec": map[string]any{
-							"name":         "B",
-							"signal":       "traces",
-							"aggregations": []any{map[string]any{"expression": "count()"}},
-							"stepInterval": "60s",
-							"groupBy":      []any{map[string]any{"name": "service.name", "fieldContext": "resource"}},
-						},
-					},
-					map[string]any{
-						"type": "builder_formula",
-						"spec": map[string]any{
-							"name":       "error_rate",
-							"expression": "A / B * 100",
-						},
-					},
-				},
-			},
-		},
-	},
-	{
-		Name:    "promql",
-		Summary: "PromQL: request rate with UTF-8 metric name",
-		Value: map[string]any{
-			"schemaVersion": "v1",
-			"start":         1640995200000,
-			"end":           1640998800000,
-			"requestType":   "time_series",
-			"compositeQuery": map[string]any{
-				"queries": []any{
-					map[string]any{
-						"type": "promql",
-						"spec": map[string]any{
-							"name":  "request_rate",
-							"query": "sum(rate({\"http.server.duration.count\"}[5m])) by (\"service.name\")",
-							"step":  60,
-						},
-					},
-				},
-			},
-		},
-	},
-	{
-		Name:    "clickhouse_sql_traces_time_series",
-		Summary: "ClickHouse SQL: traces time series with resource filter",
-		Value: map[string]any{
-			"schemaVersion": "v1",
-			"start":         1640995200000,
-			"end":           1640998800000,
-			"requestType":   "time_series",
-			"compositeQuery": map[string]any{
-				"queries": []any{
-					map[string]any{
-						"type": "clickhouse_sql",
-						"spec": map[string]any{
-							"name": "span_rate",
-							"query": "WITH __resource_filter AS (" +
-								" SELECT fingerprint FROM signoz_traces.distributed_traces_v3_resource" +
-								" WHERE seen_at_ts_bucket_start >= $start_timestamp - 1800 AND seen_at_ts_bucket_start <= $end_timestamp" +
-								" ) SELECT toStartOfInterval(timestamp, INTERVAL 60 SECOND) AS ts, count() AS value" +
-								" FROM signoz_traces.distributed_signoz_index_v3" +
-								" WHERE resource_fingerprint GLOBAL IN (SELECT fingerprint FROM __resource_filter)" +
-								" AND timestamp >= $start_datetime AND timestamp <= $end_datetime" +
-								" AND ts_bucket_start >= $start_timestamp - 1800 AND ts_bucket_start <= $end_timestamp" +
-								" GROUP BY ts ORDER BY ts",
-						},
-					},
-				},
-			},
-		},
-	},
-	{
-		Name:    "clickhouse_sql_logs_raw",
-		Summary: "ClickHouse SQL: raw logs with resource filter",
-		Value: map[string]any{
-			"schemaVersion": "v1",
-			"start":         1640995200000,
-			"end":           1640998800000,
-			"requestType":   "raw",
-			"compositeQuery": map[string]any{
-				"queries": []any{
-					map[string]any{
-						"type": "clickhouse_sql",
-						"spec": map[string]any{
-							"name": "recent_errors",
-							"query": "WITH __resource_filter AS (" +
-								" SELECT fingerprint FROM signoz_logs.distributed_logs_v2_resource" +
-								" WHERE seen_at_ts_bucket_start >= $start_timestamp - 1800 AND seen_at_ts_bucket_start <= $end_timestamp" +
-								" ) SELECT timestamp, body" +
-								" FROM signoz_logs.distributed_logs_v2" +
-								" WHERE resource_fingerprint GLOBAL IN (SELECT fingerprint FROM __resource_filter)" +
-								" AND timestamp >= $start_timestamp_nano AND timestamp <= $end_timestamp_nano" +
-								" AND ts_bucket_start >= $start_timestamp - 1800 AND ts_bucket_start <= $end_timestamp" +
-								" AND severity_text = 'ERROR'" +
-								" ORDER BY timestamp DESC LIMIT 100",
-						},
-					},
-				},
-			},
-		},
-	},
-	{
-		Name:    "clickhouse_sql_traces_scalar",
-		Summary: "ClickHouse SQL: scalar aggregate with resource filter",
-		Value: map[string]any{
-			"schemaVersion": "v1",
-			"start":         1640995200000,
-			"end":           1640998800000,
-			"requestType":   "scalar",
-			"compositeQuery": map[string]any{
-				"queries": []any{
-					map[string]any{
-						"type": "clickhouse_sql",
-						"spec": map[string]any{
-							"name": "total_spans",
-							"query": "WITH __resource_filter AS (" +
-								" SELECT fingerprint FROM signoz_traces.distributed_traces_v3_resource" +
-								" WHERE seen_at_ts_bucket_start >= $start_timestamp - 1800 AND seen_at_ts_bucket_start <= $end_timestamp" +
-								" ) SELECT count() AS value" +
-								" FROM signoz_traces.distributed_signoz_index_v3" +
-								" WHERE resource_fingerprint GLOBAL IN (SELECT fingerprint FROM __resource_filter)" +
-								" AND timestamp >= $start_datetime AND timestamp <= $end_datetime" +
-								" AND ts_bucket_start >= $start_timestamp - 1800 AND ts_bucket_start <= $end_timestamp",
-						},
-					},
-				},
-			},
-		},
-	},
-}

pkg/query-service/app/http_handler.go

@@ -5001,6 +5001,7 @@ func (aH *APIHandler) getDomainList(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
+	result = thirdpartyapi.MergeSemconvColumns(result)
 	result = thirdpartyapi.FilterIntermediateColumns(result)
 
 	// Filter IP addresses if ShowIp is false
@@ -5057,6 +5058,7 @@ func (aH *APIHandler) getDomainInfo(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
+	result = thirdpartyapi.MergeSemconvColumns(result)
 	result = thirdpartyapi.FilterIntermediateColumns(result)
 
 	// Filter IP addresses if ShowIp is false

pkg/query-service/rules/base_rule.go

@@ -625,7 +625,7 @@ func (r *BaseRule) extractMetricAndGroupBys(ctx context.Context) (map[string][]s
 
 // FilterNewSeries filters out items that are too new based on metadata first_seen timestamps.
 // Returns the filtered series (old ones) excluding new series that are still within the grace period.
-func (r *BaseRule) FilterNewSeries(ctx context.Context, ts time.Time, series []*v3.Series) ([]*v3.Series, error) {
+func (r *BaseRule) FilterNewSeries(ctx context.Context, ts time.Time, series []*qbtypes.TimeSeries) ([]*qbtypes.TimeSeries, error) {
 	// Extract metric names and groupBy keys
 	metricToGroupedFields, err := r.extractMetricAndGroupBys(ctx)
 	if err != nil {
@@ -642,7 +642,7 @@ func (r *BaseRule) FilterNewSeries(ctx context.Context, ts time.Time, series []*
 	seriesIdxToLookupKeys := make(map[int][]telemetrytypes.MetricMetadataLookupKey) // series index -> lookup keys
 
 	for i := 0; i < len(series); i++ {
-		metricLabelMap := series[i].Labels
+		metricLabelMap := series[i].LabelsMap()
 
 		// Collect groupBy attribute-value pairs for this series
 		seriesKeys := make([]telemetrytypes.MetricMetadataLookupKey, 0)
@@ -689,7 +689,7 @@ func (r *BaseRule) FilterNewSeries(ctx context.Context, ts time.Time, series []*
 	}
 
 	// Filter series based on first_seen + delay
-	filteredSeries := make([]*v3.Series, 0, len(series))
+	filteredSeries := make([]*qbtypes.TimeSeries, 0, len(series))
 	evalTimeMs := ts.UnixMilli()
 	newGroupEvalDelayMs := r.newGroupEvalDelay.Milliseconds()
 
@@ -727,7 +727,7 @@ func (r *BaseRule) FilterNewSeries(ctx context.Context, ts time.Time, series []*
 		// Check if first_seen + delay has passed
 		if maxFirstSeen+newGroupEvalDelayMs > evalTimeMs {
 			// Still within grace period, skip this series
-			r.logger.InfoContext(ctx, "Skipping new series", "rule_name", r.Name(), "series_idx", i, "max_first_seen", maxFirstSeen, "eval_time_ms", evalTimeMs, "delay_ms", newGroupEvalDelayMs, "labels", series[i].Labels)
+			r.logger.InfoContext(ctx, "Skipping new series", "rule_name", r.Name(), "series_idx", i, "max_first_seen", maxFirstSeen, "eval_time_ms", evalTimeMs, "delay_ms", newGroupEvalDelayMs, "labels", series[i].LabelsMap())
 			continue
 		}
 

pkg/query-service/rules/base_rule_test.go

@@ -26,33 +26,33 @@ import (
 	"github.com/SigNoz/signoz/pkg/valuer"
 )
 
-// createTestSeries creates a *v3.Series with the given labels and optional points
+// createTestSeries creates a *qbtypes.TimeSeries with the given labels and optional values
 // so we don't exactly need the points in the series because the labels are used to determine if the series is new or old
 // we use the labels to create a lookup key for the series and then check the first_seen timestamp for the series in the metadata table
-func createTestSeries(labels map[string]string, points []v3.Point) *v3.Series {
+func createTestSeries(labels map[string]string, points []*qbtypes.TimeSeriesValue) *qbtypes.TimeSeries {
 	if points == nil {
-		points = []v3.Point{}
+		points = []*qbtypes.TimeSeriesValue{}
 	}
-	return &v3.Series{
-		Labels: labels,
-		Points: points,
+	lbls := make([]*qbtypes.Label, 0, len(labels))
+	for k, v := range labels {
+		lbls = append(lbls, &qbtypes.Label{Key: telemetrytypes.TelemetryFieldKey{Name: k}, Value: v})
+	}
+	return &qbtypes.TimeSeries{
+		Labels: lbls,
+		Values: points,
 	}
 }
 
-// seriesEqual compares two v3.Series by their labels
+// seriesEqual compares two *qbtypes.TimeSeries by their labels
 // Returns true if the series have the same labels (order doesn't matter)
-func seriesEqual(s1, s2 *v3.Series) bool {
-	if s1 == nil && s2 == nil {
-		return true
-	}
-	if s1 == nil || s2 == nil {
+func seriesEqual(s1, s2 *qbtypes.TimeSeries) bool {
+	m1 := s1.LabelsMap()
+	m2 := s2.LabelsMap()
+	if len(m1) != len(m2) {
 		return false
 	}
-	if len(s1.Labels) != len(s2.Labels) {
-		return false
-	}
-	for k, v := range s1.Labels {
-		if s2.Labels[k] != v {
+	for k, v := range m1 {
+		if m2[k] != v {
 			return false
 		}
 	}
@@ -149,11 +149,11 @@ func createPostableRule(compositeQuery *v3.CompositeQuery) ruletypes.PostableRul
 type filterNewSeriesTestCase struct {
 	name              string
 	compositeQuery    *v3.CompositeQuery
-	series            []*v3.Series
+	series            []*qbtypes.TimeSeries
 	firstSeenMap      map[telemetrytypes.MetricMetadataLookupKey]int64
 	newGroupEvalDelay valuer.TextDuration
 	evalTime          time.Time
-	expectedFiltered  []*v3.Series // series that should be in the final filtered result (old enough)
+	expectedFiltered  []*qbtypes.TimeSeries // series that should be in the final filtered result (old enough)
 	expectError       bool
 }
 
@@ -193,7 +193,7 @@ func TestBaseRule_FilterNewSeries(t *testing.T) {
 					},
 				},
 			},
-			series: []*v3.Series{
+			series: []*qbtypes.TimeSeries{
 				createTestSeries(map[string]string{"service_name": "svc-old", "env": "prod"}, nil),
 				createTestSeries(map[string]string{"service_name": "svc-new", "env": "prod"}, nil),
 				createTestSeries(map[string]string{"service_name": "svc-missing", "env": "stage"}, nil),
@@ -205,7 +205,7 @@ func TestBaseRule_FilterNewSeries(t *testing.T) {
 			),
 			newGroupEvalDelay: defaultNewGroupEvalDelay,
 			evalTime:          defaultEvalTime,
-			expectedFiltered: []*v3.Series{
+			expectedFiltered: []*qbtypes.TimeSeries{
 				createTestSeries(map[string]string{"service_name": "svc-old", "env": "prod"}, nil),
 				createTestSeries(map[string]string{"service_name": "svc-missing", "env": "stage"}, nil),
 			}, // svc-old and svc-missing should be included; svc-new is filtered out
@@ -227,7 +227,7 @@ func TestBaseRule_FilterNewSeries(t *testing.T) {
 					},
 				},
 			},
-			series: []*v3.Series{
+			series: []*qbtypes.TimeSeries{
 				createTestSeries(map[string]string{"service_name": "svc-new1", "env": "prod"}, nil),
 				createTestSeries(map[string]string{"service_name": "svc-new2", "env": "stage"}, nil),
 			},
@@ -237,7 +237,7 @@ func TestBaseRule_FilterNewSeries(t *testing.T) {
 			),
 			newGroupEvalDelay: defaultNewGroupEvalDelay,
 			evalTime:          defaultEvalTime,
-			expectedFiltered:  []*v3.Series{}, // all should be filtered out (new series)
+			expectedFiltered:  []*qbtypes.TimeSeries{}, // all should be filtered out (new series)
 		},
 		{
 			name: "all old series - ClickHouse query",
@@ -254,7 +254,7 @@ func TestBaseRule_FilterNewSeries(t *testing.T) {
 					},
 				},
 			},
-			series: []*v3.Series{
+			series: []*qbtypes.TimeSeries{
 				createTestSeries(map[string]string{"service_name": "svc-old1", "env": "prod"}, nil),
 				createTestSeries(map[string]string{"service_name": "svc-old2", "env": "stage"}, nil),
 			},
@@ -264,7 +264,7 @@ func TestBaseRule_FilterNewSeries(t *testing.T) {
 			),
 			newGroupEvalDelay: defaultNewGroupEvalDelay,
 			evalTime:          defaultEvalTime,
-			expectedFiltered: []*v3.Series{
+			expectedFiltered: []*qbtypes.TimeSeries{
 				createTestSeries(map[string]string{"service_name": "svc-old1", "env": "prod"}, nil),
 				createTestSeries(map[string]string{"service_name": "svc-old2", "env": "stage"}, nil),
 			}, // all should be included (old series)
@@ -292,13 +292,13 @@ func TestBaseRule_FilterNewSeries(t *testing.T) {
 					},
 				},
 			},
-			series: []*v3.Series{
+			series: []*qbtypes.TimeSeries{
 				createTestSeries(map[string]string{"service_name": "svc1", "env": "prod"}, nil),
 			},
 			firstSeenMap:      make(map[telemetrytypes.MetricMetadataLookupKey]int64),
 			newGroupEvalDelay: defaultNewGroupEvalDelay,
 			evalTime:          defaultEvalTime,
-			expectedFiltered: []*v3.Series{
+			expectedFiltered: []*qbtypes.TimeSeries{
 				createTestSeries(map[string]string{"service_name": "svc1", "env": "prod"}, nil),
 			}, // early return, no filtering - all series included
 		},
@@ -322,13 +322,13 @@ func TestBaseRule_FilterNewSeries(t *testing.T) {
 					},
 				},
 			},
-			series: []*v3.Series{
+			series: []*qbtypes.TimeSeries{
 				createTestSeries(map[string]string{"service_name": "svc1", "env": "prod"}, nil),
 			},
 			firstSeenMap:      make(map[telemetrytypes.MetricMetadataLookupKey]int64),
 			newGroupEvalDelay: defaultNewGroupEvalDelay,
 			evalTime:          defaultEvalTime,
-			expectedFiltered: []*v3.Series{
+			expectedFiltered: []*qbtypes.TimeSeries{
 				createTestSeries(map[string]string{"service_name": "svc1", "env": "prod"}, nil),
 			}, // early return, no filtering - all series included
 		},
@@ -358,13 +358,13 @@ func TestBaseRule_FilterNewSeries(t *testing.T) {
 					},
 				},
 			},
-			series: []*v3.Series{
+			series: []*qbtypes.TimeSeries{
 				createTestSeries(map[string]string{"status": "200"}, nil), // no service_name or env
 			},
 			firstSeenMap:      make(map[telemetrytypes.MetricMetadataLookupKey]int64),
 			newGroupEvalDelay: defaultNewGroupEvalDelay,
 			evalTime:          defaultEvalTime,
-			expectedFiltered: []*v3.Series{
+			expectedFiltered: []*qbtypes.TimeSeries{
 				createTestSeries(map[string]string{"status": "200"}, nil),
 			}, // series included as we can't decide if it's new or old
 		},
@@ -385,7 +385,7 @@ func TestBaseRule_FilterNewSeries(t *testing.T) {
 					},
 				},
 			},
-			series: []*v3.Series{
+			series: []*qbtypes.TimeSeries{
 				createTestSeries(map[string]string{"service_name": "svc-old", "env": "prod"}, nil),
 				createTestSeries(map[string]string{"service_name": "svc-no-metadata", "env": "prod"}, nil),
 			},
@@ -393,7 +393,7 @@ func TestBaseRule_FilterNewSeries(t *testing.T) {
 			// svc-no-metadata has no entry in firstSeenMap
 			newGroupEvalDelay: defaultNewGroupEvalDelay,
 			evalTime:          defaultEvalTime,
-			expectedFiltered: []*v3.Series{
+			expectedFiltered: []*qbtypes.TimeSeries{
 				createTestSeries(map[string]string{"service_name": "svc-old", "env": "prod"}, nil),
 				createTestSeries(map[string]string{"service_name": "svc-no-metadata", "env": "prod"}, nil),
 			}, // both should be included - svc-old is old, svc-no-metadata can't be decided
@@ -413,7 +413,7 @@ func TestBaseRule_FilterNewSeries(t *testing.T) {
 					},
 				},
 			},
-			series: []*v3.Series{
+			series: []*qbtypes.TimeSeries{
 				createTestSeries(map[string]string{"service_name": "svc-partial", "env": "prod"}, nil),
 			},
 			// Only provide metadata for service_name, not env
@@ -423,7 +423,7 @@ func TestBaseRule_FilterNewSeries(t *testing.T) {
 			},
 			newGroupEvalDelay: defaultNewGroupEvalDelay,
 			evalTime:          defaultEvalTime,
-			expectedFiltered: []*v3.Series{
+			expectedFiltered: []*qbtypes.TimeSeries{
 				createTestSeries(map[string]string{"service_name": "svc-partial", "env": "prod"}, nil),
 			}, // has some metadata, uses max first_seen which is old
 		},
@@ -453,11 +453,11 @@ func TestBaseRule_FilterNewSeries(t *testing.T) {
 					},
 				},
 			},
-			series:            []*v3.Series{},
+			series:            []*qbtypes.TimeSeries{},
 			firstSeenMap:      make(map[telemetrytypes.MetricMetadataLookupKey]int64),
 			newGroupEvalDelay: defaultNewGroupEvalDelay,
 			evalTime:          defaultEvalTime,
-			expectedFiltered:  []*v3.Series{},
+			expectedFiltered:  []*qbtypes.TimeSeries{},
 		},
 		{
 			name: "zero delay - Builder",
@@ -485,13 +485,13 @@ func TestBaseRule_FilterNewSeries(t *testing.T) {
 					},
 				},
 			},
-			series: []*v3.Series{
+			series: []*qbtypes.TimeSeries{
 				createTestSeries(map[string]string{"service_name": "svc1", "env": "prod"}, nil),
 			},
 			firstSeenMap:      createFirstSeenMap("request_total", defaultGroupByFields, defaultEvalTime, defaultDelay, true, "svc1", "prod"),
 			newGroupEvalDelay: valuer.TextDuration{}, // zero delay
 			evalTime:          defaultEvalTime,
-			expectedFiltered: []*v3.Series{
+			expectedFiltered: []*qbtypes.TimeSeries{
 				createTestSeries(map[string]string{"service_name": "svc1", "env": "prod"}, nil),
 			}, // with zero delay, all series pass
 		},
@@ -526,7 +526,7 @@ func TestBaseRule_FilterNewSeries(t *testing.T) {
 					},
 				},
 			},
-			series: []*v3.Series{
+			series: []*qbtypes.TimeSeries{
 				createTestSeries(map[string]string{"service_name": "svc1", "env": "prod"}, nil),
 			},
 			firstSeenMap: mergeFirstSeenMaps(
@@ -535,7 +535,7 @@ func TestBaseRule_FilterNewSeries(t *testing.T) {
 			),
 			newGroupEvalDelay: defaultNewGroupEvalDelay,
 			evalTime:          defaultEvalTime,
-			expectedFiltered: []*v3.Series{
+			expectedFiltered: []*qbtypes.TimeSeries{
 				createTestSeries(map[string]string{"service_name": "svc1", "env": "prod"}, nil),
 			},
 		},
@@ -565,7 +565,7 @@ func TestBaseRule_FilterNewSeries(t *testing.T) {
 					},
 				},
 			},
-			series: []*v3.Series{
+			series: []*qbtypes.TimeSeries{
 				createTestSeries(map[string]string{"service_name": "svc1", "env": "prod"}, nil),
 			},
 			// service_name is old, env is new - should use max (new)
@@ -575,7 +575,7 @@ func TestBaseRule_FilterNewSeries(t *testing.T) {
 			),
 			newGroupEvalDelay: defaultNewGroupEvalDelay,
 			evalTime:          defaultEvalTime,
-			expectedFiltered:  []*v3.Series{}, // max first_seen is new, so should be filtered out
+			expectedFiltered:  []*qbtypes.TimeSeries{}, // max first_seen is new, so should be filtered out
 		},
 		{
 			name: "Logs query - should skip filtering and return empty skip indexes",
@@ -600,14 +600,14 @@ func TestBaseRule_FilterNewSeries(t *testing.T) {
 					},
 				},
 			},
-			series: []*v3.Series{
+			series: []*qbtypes.TimeSeries{
 				createTestSeries(map[string]string{"service_name": "svc1"}, nil),
 				createTestSeries(map[string]string{"service_name": "svc2"}, nil),
 			},
 			firstSeenMap:      make(map[telemetrytypes.MetricMetadataLookupKey]int64),
 			newGroupEvalDelay: defaultNewGroupEvalDelay,
 			evalTime:          defaultEvalTime,
-			expectedFiltered: []*v3.Series{
+			expectedFiltered: []*qbtypes.TimeSeries{
 				createTestSeries(map[string]string{"service_name": "svc1"}, nil),
 				createTestSeries(map[string]string{"service_name": "svc2"}, nil),
 			}, // Logs queries should return early, no filtering - all included
@@ -635,14 +635,14 @@ func TestBaseRule_FilterNewSeries(t *testing.T) {
 					},
 				},
 			},
-			series: []*v3.Series{
+			series: []*qbtypes.TimeSeries{
 				createTestSeries(map[string]string{"service_name": "svc1"}, nil),
 				createTestSeries(map[string]string{"service_name": "svc2"}, nil),
 			},
 			firstSeenMap:      make(map[telemetrytypes.MetricMetadataLookupKey]int64),
 			newGroupEvalDelay: defaultNewGroupEvalDelay,
 			evalTime:          defaultEvalTime,
-			expectedFiltered: []*v3.Series{
+			expectedFiltered: []*qbtypes.TimeSeries{
 				createTestSeries(map[string]string{"service_name": "svc1"}, nil),
 				createTestSeries(map[string]string{"service_name": "svc2"}, nil),
 			}, // Traces queries should return early, no filtering - all included
@@ -724,14 +724,14 @@ func TestBaseRule_FilterNewSeries(t *testing.T) {
 			// Build a map to count occurrences of each unique label combination in expected series
 			expectedCounts := make(map[string]int)
 			for _, expected := range tt.expectedFiltered {
-				key := labelsKey(expected.Labels)
+				key := labelsKey(expected.LabelsMap())
 				expectedCounts[key]++
 			}
 
 			// Build a map to count occurrences of each unique label combination in filtered series
 			actualCounts := make(map[string]int)
 			for _, filtered := range filteredSeries {
-				key := labelsKey(filtered.Labels)
+				key := labelsKey(filtered.LabelsMap())
 				actualCounts[key]++
 			}
 

pkg/query-service/rules/prom_rule.go

@@ -12,19 +12,18 @@ import (
 	"github.com/SigNoz/signoz/pkg/query-service/formatter"
 	"github.com/SigNoz/signoz/pkg/query-service/interfaces"
 	"github.com/SigNoz/signoz/pkg/query-service/model"
-	v3 "github.com/SigNoz/signoz/pkg/query-service/model/v3"
 	qslabels "github.com/SigNoz/signoz/pkg/query-service/utils/labels"
 	"github.com/SigNoz/signoz/pkg/query-service/utils/times"
 	"github.com/SigNoz/signoz/pkg/query-service/utils/timestamp"
 	qbtypes "github.com/SigNoz/signoz/pkg/types/querybuildertypes/querybuildertypesv5"
 	"github.com/SigNoz/signoz/pkg/types/ruletypes"
+	"github.com/SigNoz/signoz/pkg/types/telemetrytypes"
 	"github.com/SigNoz/signoz/pkg/valuer"
 	"github.com/prometheus/prometheus/promql"
 )
 
 type PromRule struct {
 	*BaseRule
-	version    string
 	prometheus prometheus.Prometheus
 }
 
@@ -48,7 +47,6 @@ func NewPromRule(
 
 	p := PromRule{
 		BaseRule:   baseRule,
-		version:    postableRule.Version,
 		prometheus: prometheus,
 	}
 	p.logger = logger
@@ -83,48 +81,30 @@ func (r *PromRule) GetSelectedQuery() string {
 }
 
 func (r *PromRule) getPqlQuery() (string, error) {
-	if r.version == "v5" {
-		if len(r.ruleCondition.CompositeQuery.Queries) > 0 {
-			selectedQuery := r.GetSelectedQuery()
-			for _, item := range r.ruleCondition.CompositeQuery.Queries {
-				switch item.Type {
-				case qbtypes.QueryTypePromQL:
-					promQuery, ok := item.Spec.(qbtypes.PromQuery)
-					if !ok {
-						return "", errors.NewInvalidInputf(errors.CodeInvalidInput, "invalid promql query spec %T", item.Spec)
-					}
-					if promQuery.Name == selectedQuery {
-						return promQuery.Query, nil
-					}
+	if len(r.ruleCondition.CompositeQuery.Queries) > 0 {
+		selectedQuery := r.GetSelectedQuery()
+		for _, item := range r.ruleCondition.CompositeQuery.Queries {
+			switch item.Type {
+			case qbtypes.QueryTypePromQL:
+				promQuery, ok := item.Spec.(qbtypes.PromQuery)
+				if !ok {
+					return "", errors.NewInvalidInputf(errors.CodeInvalidInput, "invalid promql query spec %T", item.Spec)
+				}
+				if promQuery.Name == selectedQuery {
+					return promQuery.Query, nil
 				}
 			}
 		}
-		return "", fmt.Errorf("invalid promql rule setup")
 	}
-
-	if r.ruleCondition.CompositeQuery.QueryType == v3.QueryTypePromQL {
-		if len(r.ruleCondition.CompositeQuery.PromQueries) > 0 {
-			selectedQuery := r.GetSelectedQuery()
-			if promQuery, ok := r.ruleCondition.CompositeQuery.PromQueries[selectedQuery]; ok {
-				query := promQuery.Query
-				if query == "" {
-					return query, fmt.Errorf("a promquery needs to be set for this rule to function")
-				}
-				return query, nil
-			}
-		}
-	}
-
-	return "", fmt.Errorf("invalid promql rule query")
+	return "", fmt.Errorf("invalid promql rule setup")
 }
 
-func (r *PromRule) matrixToV3Series(res promql.Matrix) []*v3.Series {
-	v3Series := make([]*v3.Series, 0, len(res))
+func matrixToTimeSeries(res promql.Matrix) []*qbtypes.TimeSeries {
+	result := make([]*qbtypes.TimeSeries, 0, len(res))
 	for _, series := range res {
-		commonSeries := toCommonSeries(series)
-		v3Series = append(v3Series, &commonSeries)
+		result = append(result, promSeriesToTimeSeries(series))
 	}
-	return v3Series
+	return result
 }
 
 func (r *PromRule) buildAndRunQuery(ctx context.Context, ts time.Time) (ruletypes.Vector, error) {
@@ -143,31 +123,31 @@ func (r *PromRule) buildAndRunQuery(ctx context.Context, ts time.Time) (ruletype
 		return nil, err
 	}
 
-	matrixToProcess := r.matrixToV3Series(res)
+	seriesToProcess := matrixToTimeSeries(res)
 
-	hasData := len(matrixToProcess) > 0
+	hasData := len(seriesToProcess) > 0
 	if missingDataAlert := r.HandleMissingDataAlert(ctx, ts, hasData); missingDataAlert != nil {
 		return ruletypes.Vector{*missingDataAlert}, nil
 	}
 
 	// Filter out new series if newGroupEvalDelay is configured
 	if r.ShouldSkipNewGroups() {
-		filteredSeries, filterErr := r.BaseRule.FilterNewSeries(ctx, ts, matrixToProcess)
+		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, ", "error", filterErr, "rule_name", r.Name())
 		} else {
-			matrixToProcess = filteredSeries
+			seriesToProcess = filteredSeries
 		}
 	}
 
 	var resultVector ruletypes.Vector
 
-	for _, series := range matrixToProcess {
+	for _, series := range seriesToProcess {
 		if !r.Condition().ShouldEval(series) {
 			r.logger.InfoContext(
 				ctx, "not enough data points to evaluate series, skipping",
-				"rule_id", r.ID(), "num_points", len(series.Points), "required_points", r.Condition().RequiredNumPoints,
+				"rule_id", r.ID(), "num_points", len(series.Values), "required_points", r.Condition().RequiredNumPoints,
 			)
 			continue
 		}
@@ -454,26 +434,25 @@ func (r *PromRule) RunAlertQuery(ctx context.Context, qs string, start, end time
 	}
 }
 
-func toCommonSeries(series promql.Series) v3.Series {
-	commonSeries := v3.Series{
-		Labels:      make(map[string]string),
-		LabelsArray: make([]map[string]string, 0),
-		Points:      make([]v3.Point, 0),
+func promSeriesToTimeSeries(series promql.Series) *qbtypes.TimeSeries {
+	ts := &qbtypes.TimeSeries{
+		Labels: make([]*qbtypes.Label, 0, len(series.Metric)),
+		Values: make([]*qbtypes.TimeSeriesValue, 0, len(series.Floats)),
 	}
 
 	for _, lbl := range series.Metric {
-		commonSeries.Labels[lbl.Name] = lbl.Value
-		commonSeries.LabelsArray = append(commonSeries.LabelsArray, map[string]string{
-			lbl.Name: lbl.Value,
+		ts.Labels = append(ts.Labels, &qbtypes.Label{
+			Key:   telemetrytypes.TelemetryFieldKey{Name: lbl.Name},
+			Value: lbl.Value,
 		})
 	}
 
 	for _, f := range series.Floats {
-		commonSeries.Points = append(commonSeries.Points, v3.Point{
+		ts.Values = append(ts.Values, &qbtypes.TimeSeriesValue{
 			Timestamp: f.T,
 			Value:     f.F,
 		})
 	}
 
-	return commonSeries
+	return ts
 }

pkg/query-service/rules/prom_rule_test.go

@@ -20,6 +20,7 @@ import (
 	qslabels "github.com/SigNoz/signoz/pkg/query-service/utils/labels"
 	"github.com/SigNoz/signoz/pkg/telemetrystore"
 	"github.com/SigNoz/signoz/pkg/telemetrystore/telemetrystoretest"
+	qbtypes "github.com/SigNoz/signoz/pkg/types/querybuildertypes/querybuildertypesv5"
 	"github.com/SigNoz/signoz/pkg/types/ruletypes"
 	"github.com/SigNoz/signoz/pkg/valuer"
 )
@@ -47,9 +48,13 @@ func TestPromRuleEval(t *testing.T) {
 		RuleCondition: &ruletypes.RuleCondition{
 			CompositeQuery: &v3.CompositeQuery{
 				QueryType: v3.QueryTypePromQL,
-				PromQueries: map[string]*v3.PromQuery{
-					"A": {
-						Query: "dummy_query", // This is not used in the test
+				Queries: []qbtypes.QueryEnvelope{
+					{
+						Type: qbtypes.QueryTypePromQL,
+						Spec: qbtypes.PromQuery{
+							Name:  "A",
+							Query: "dummy_query", // This is not used in the test
+						},
 					},
 				},
 			},
@@ -62,7 +67,7 @@ func TestPromRuleEval(t *testing.T) {
 		compareOp            string
 		matchType            string
 		target               float64
-		expectedAlertSample  v3.Point
+		expectedAlertSample  float64
 		expectedVectorValues []float64 // Expected values in result vector
 	}{
 		// Test cases for Equals Always
@@ -80,7 +85,7 @@ func TestPromRuleEval(t *testing.T) {
 			compareOp:            "3", // Equals
 			matchType:            "2", // Always
 			target:               0.0,
-			expectedAlertSample:  v3.Point{Value: 0.0},
+			expectedAlertSample:  0.0,
 			expectedVectorValues: []float64{0.0},
 		},
 		{
@@ -145,7 +150,7 @@ func TestPromRuleEval(t *testing.T) {
 			compareOp:            "3", // Equals
 			matchType:            "1", // Once
 			target:               0.0,
-			expectedAlertSample:  v3.Point{Value: 0.0},
+			expectedAlertSample:  0.0,
 			expectedVectorValues: []float64{0.0},
 		},
 		{
@@ -162,7 +167,7 @@ func TestPromRuleEval(t *testing.T) {
 			compareOp:           "3", // Equals
 			matchType:           "1", // Once
 			target:              0.0,
-			expectedAlertSample: v3.Point{Value: 0.0},
+			expectedAlertSample: 0.0,
 		},
 		{
 			values: pql.Series{
@@ -178,7 +183,7 @@ func TestPromRuleEval(t *testing.T) {
 			compareOp:           "3", // Equals
 			matchType:           "1", // Once
 			target:              0.0,
-			expectedAlertSample: v3.Point{Value: 0.0},
+			expectedAlertSample: 0.0,
 		},
 		{
 			values: pql.Series{
@@ -211,7 +216,7 @@ func TestPromRuleEval(t *testing.T) {
 			compareOp:            "1", // Greater Than
 			matchType:            "2", // Always
 			target:               1.5,
-			expectedAlertSample:  v3.Point{Value: 2.0},
+			expectedAlertSample:  2.0,
 			expectedVectorValues: []float64{2.0},
 		},
 		{
@@ -228,7 +233,7 @@ func TestPromRuleEval(t *testing.T) {
 			compareOp:           "1", // Above
 			matchType:           "2", // Always
 			target:              2.0,
-			expectedAlertSample: v3.Point{Value: 3.0},
+			expectedAlertSample: 3.0,
 		},
 		{
 			values: pql.Series{
@@ -244,7 +249,7 @@ func TestPromRuleEval(t *testing.T) {
 			compareOp:           "2", // Below
 			matchType:           "2", // Always
 			target:              13.0,
-			expectedAlertSample: v3.Point{Value: 12.0},
+			expectedAlertSample: 12.0,
 		},
 		{
 			values: pql.Series{
@@ -276,7 +281,7 @@ func TestPromRuleEval(t *testing.T) {
 			compareOp:            "1", // Greater Than
 			matchType:            "1", // Once
 			target:               4.5,
-			expectedAlertSample:  v3.Point{Value: 10.0},
+			expectedAlertSample:  10.0,
 			expectedVectorValues: []float64{10.0},
 		},
 		{
@@ -339,7 +344,7 @@ func TestPromRuleEval(t *testing.T) {
 			compareOp:           "4", // Not Equals
 			matchType:           "2", // Always
 			target:              0.0,
-			expectedAlertSample: v3.Point{Value: 1.0},
+			expectedAlertSample: 1.0,
 		},
 		{
 			values: pql.Series{
@@ -371,7 +376,7 @@ func TestPromRuleEval(t *testing.T) {
 			compareOp:           "4", // Not Equals
 			matchType:           "1", // Once
 			target:              0.0,
-			expectedAlertSample: v3.Point{Value: 1.0},
+			expectedAlertSample: 1.0,
 		},
 		{
 			values: pql.Series{
@@ -402,7 +407,7 @@ func TestPromRuleEval(t *testing.T) {
 			compareOp:           "4", // Not Equals
 			matchType:           "1", // Once
 			target:              0.0,
-			expectedAlertSample: v3.Point{Value: 1.0},
+			expectedAlertSample: 1.0,
 		},
 		{
 			values: pql.Series{
@@ -418,7 +423,7 @@ func TestPromRuleEval(t *testing.T) {
 			compareOp:           "4", // Not Equals
 			matchType:           "1", // Once
 			target:              0.0,
-			expectedAlertSample: v3.Point{Value: 1.0},
+			expectedAlertSample: 1.0,
 		},
 		// Test cases for Less Than Always
 		{
@@ -435,7 +440,7 @@ func TestPromRuleEval(t *testing.T) {
 			compareOp:           "2", // Less Than
 			matchType:           "2", // Always
 			target:              4,
-			expectedAlertSample: v3.Point{Value: 1.5},
+			expectedAlertSample: 1.5,
 		},
 		{
 			values: pql.Series{
@@ -467,7 +472,7 @@ func TestPromRuleEval(t *testing.T) {
 			compareOp:           "2", // Less Than
 			matchType:           "1", // Once
 			target:              4,
-			expectedAlertSample: v3.Point{Value: 2.5},
+			expectedAlertSample: 2.5,
 		},
 		{
 			values: pql.Series{
@@ -499,7 +504,7 @@ func TestPromRuleEval(t *testing.T) {
 			compareOp:           "3", // Equals
 			matchType:           "3", // OnAverage
 			target:              6.0,
-			expectedAlertSample: v3.Point{Value: 6.0},
+			expectedAlertSample: 6.0,
 		},
 		{
 			values: pql.Series{
@@ -530,7 +535,7 @@ func TestPromRuleEval(t *testing.T) {
 			compareOp:           "4", // Not Equals
 			matchType:           "3", // OnAverage
 			target:              4.5,
-			expectedAlertSample: v3.Point{Value: 6.0},
+			expectedAlertSample: 6.0,
 		},
 		{
 			values: pql.Series{
@@ -561,7 +566,7 @@ func TestPromRuleEval(t *testing.T) {
 			compareOp:           "1", // Greater Than
 			matchType:           "3", // OnAverage
 			target:              4.5,
-			expectedAlertSample: v3.Point{Value: 6.0},
+			expectedAlertSample: 6.0,
 		},
 		{
 			values: pql.Series{
@@ -577,7 +582,7 @@ func TestPromRuleEval(t *testing.T) {
 			compareOp:           "2", // Less Than
 			matchType:           "3", // OnAverage
 			target:              12.0,
-			expectedAlertSample: v3.Point{Value: 6.0},
+			expectedAlertSample: 6.0,
 		},
 		// Test cases for InTotal
 		{
@@ -594,7 +599,7 @@ func TestPromRuleEval(t *testing.T) {
 			compareOp:           "3", // Equals
 			matchType:           "4", // InTotal
 			target:              30.0,
-			expectedAlertSample: v3.Point{Value: 30.0},
+			expectedAlertSample: 30.0,
 		},
 		{
 			values: pql.Series{
@@ -621,7 +626,7 @@ func TestPromRuleEval(t *testing.T) {
 			compareOp:           "4", // Not Equals
 			matchType:           "4", // InTotal
 			target:              9.0,
-			expectedAlertSample: v3.Point{Value: 10.0},
+			expectedAlertSample: 10.0,
 		},
 		{
 			values: pql.Series{
@@ -645,7 +650,7 @@ func TestPromRuleEval(t *testing.T) {
 			compareOp:           "1", // Greater Than
 			matchType:           "4", // InTotal
 			target:              10.0,
-			expectedAlertSample: v3.Point{Value: 20.0},
+			expectedAlertSample: 20.0,
 		},
 		{
 			values: pql.Series{
@@ -670,7 +675,7 @@ func TestPromRuleEval(t *testing.T) {
 			compareOp:           "2", // Less Than
 			matchType:           "4", // InTotal
 			target:              30.0,
-			expectedAlertSample: v3.Point{Value: 20.0},
+			expectedAlertSample: 20.0,
 		},
 		{
 			values: pql.Series{
@@ -708,7 +713,7 @@ func TestPromRuleEval(t *testing.T) {
 			assert.NoError(t, err)
 		}
 
-		resultVectors, err := rule.Threshold.Eval(toCommonSeries(c.values), rule.Unit(), ruletypes.EvalData{})
+		resultVectors, err := rule.Threshold.Eval(*promSeriesToTimeSeries(c.values), rule.Unit(), ruletypes.EvalData{})
 		assert.NoError(t, err)
 
 		// Compare full result vector with expected vector
@@ -724,12 +729,12 @@ func TestPromRuleEval(t *testing.T) {
 				if len(resultVectors) > 0 {
 					found := false
 					for _, sample := range resultVectors {
-						if sample.V == c.expectedAlertSample.Value {
+						if sample.V == c.expectedAlertSample {
 							found = true
 							break
 						}
 					}
-					assert.True(t, found, "Expected alert sample value %.2f not found in result vectors for case %d. Got values: %v", c.expectedAlertSample.Value, idx, actualValues)
+					assert.True(t, found, "Expected alert sample value %.2f not found in result vectors for case %d. Got values: %v", c.expectedAlertSample, idx, actualValues)
 				}
 			} else {
 				assert.Empty(t, resultVectors, "Expected no alert but got result vectors for case %d", idx)
@@ -754,9 +759,13 @@ func TestPromRuleUnitCombinations(t *testing.T) {
 		RuleCondition: &ruletypes.RuleCondition{
 			CompositeQuery: &v3.CompositeQuery{
 				QueryType: v3.QueryTypePromQL,
-				PromQueries: map[string]*v3.PromQuery{
-					"A": {
-						Query: "test_metric",
+				Queries: []qbtypes.QueryEnvelope{
+					{
+						Type: qbtypes.QueryTypePromQL,
+						Spec: qbtypes.PromQuery{
+							Name:  "A",
+							Query: "test_metric",
+						},
 					},
 				},
 			},
@@ -1013,9 +1022,13 @@ func _Enable_this_after_9146_issue_fix_is_merged_TestPromRuleNoData(t *testing.T
 		RuleCondition: &ruletypes.RuleCondition{
 			CompositeQuery: &v3.CompositeQuery{
 				QueryType: v3.QueryTypePromQL,
-				PromQueries: map[string]*v3.PromQuery{
-					"A": {
-						Query: "test_metric",
+				Queries: []qbtypes.QueryEnvelope{
+					{
+						Type: qbtypes.QueryTypePromQL,
+						Spec: qbtypes.PromQuery{
+							Name:  "A",
+							Query: "test_metric",
+						},
 					},
 				},
 			},
@@ -1124,9 +1137,13 @@ func TestMultipleThresholdPromRule(t *testing.T) {
 		RuleCondition: &ruletypes.RuleCondition{
 			CompositeQuery: &v3.CompositeQuery{
 				QueryType: v3.QueryTypePromQL,
-				PromQueries: map[string]*v3.PromQuery{
-					"A": {
-						Query: "test_metric",
+				Queries: []qbtypes.QueryEnvelope{
+					{
+						Type: qbtypes.QueryTypePromQL,
+						Spec: qbtypes.PromQuery{
+							Name:  "A",
+							Query: "test_metric",
+						},
 					},
 				},
 			},
@@ -1361,8 +1378,11 @@ func TestPromRule_NoData(t *testing.T) {
 			MatchType: ruletypes.AtleastOnce,
 			CompositeQuery: &v3.CompositeQuery{
 				QueryType: v3.QueryTypePromQL,
-				PromQueries: map[string]*v3.PromQuery{
-					"A": {Query: "test_metric"},
+				Queries: []qbtypes.QueryEnvelope{
+					{
+						Type: qbtypes.QueryTypePromQL,
+						Spec: qbtypes.PromQuery{Name: "A", Query: "test_metric"},
+					},
 				},
 			},
 			Thresholds: &ruletypes.RuleThresholdData{
@@ -1486,8 +1506,11 @@ func TestPromRule_NoData_AbsentFor(t *testing.T) {
 			Target:        &target,
 			CompositeQuery: &v3.CompositeQuery{
 				QueryType: v3.QueryTypePromQL,
-				PromQueries: map[string]*v3.PromQuery{
-					"A": {Query: "test_metric"},
+				Queries: []qbtypes.QueryEnvelope{
+					{
+						Type: qbtypes.QueryTypePromQL,
+						Spec: qbtypes.PromQuery{Name: "A", Query: "test_metric"},
+					},
 				},
 			},
 			Thresholds: &ruletypes.RuleThresholdData{
@@ -1635,8 +1658,11 @@ func TestPromRuleEval_RequireMinPoints(t *testing.T) {
 			MatchType: ruletypes.AtleastOnce,
 			CompositeQuery: &v3.CompositeQuery{
 				QueryType: v3.QueryTypePromQL,
-				PromQueries: map[string]*v3.PromQuery{
-					"A": {Query: "test_metric"},
+				Queries: []qbtypes.QueryEnvelope{
+					{
+						Type: qbtypes.QueryTypePromQL,
+						Spec: qbtypes.PromQuery{Name: "A", Query: "test_metric"},
+					},
 				},
 			},
 		},

pkg/query-service/rules/threshold_rule.go

@@ -1,38 +1,24 @@
 package rules
 
 import (
-	"bytes"
 	"context"
 	"encoding/json"
 	"fmt"
 	"log/slog"
-	"math"
 	"net/url"
-	"reflect"
-	"text/template"
 	"time"
 
 	"github.com/SigNoz/signoz/pkg/contextlinks"
-	"github.com/SigNoz/signoz/pkg/query-service/common"
 	"github.com/SigNoz/signoz/pkg/query-service/model"
-	"github.com/SigNoz/signoz/pkg/query-service/postprocess"
-	"github.com/SigNoz/signoz/pkg/transition"
 	"github.com/SigNoz/signoz/pkg/types/ruletypes"
 	"github.com/SigNoz/signoz/pkg/types/telemetrytypes"
 	"github.com/SigNoz/signoz/pkg/valuer"
 
-	"github.com/SigNoz/signoz/pkg/query-service/app/querier"
-	querierV2 "github.com/SigNoz/signoz/pkg/query-service/app/querier/v2"
-	"github.com/SigNoz/signoz/pkg/query-service/app/queryBuilder"
 	"github.com/SigNoz/signoz/pkg/query-service/interfaces"
-	v3 "github.com/SigNoz/signoz/pkg/query-service/model/v3"
 	"github.com/SigNoz/signoz/pkg/query-service/utils/labels"
-	querytemplate "github.com/SigNoz/signoz/pkg/query-service/utils/queryTemplate"
 	"github.com/SigNoz/signoz/pkg/query-service/utils/times"
 	"github.com/SigNoz/signoz/pkg/query-service/utils/timestamp"
 
-	logsv3 "github.com/SigNoz/signoz/pkg/query-service/app/logs/v3"
-	tracesV4 "github.com/SigNoz/signoz/pkg/query-service/app/traces/v4"
 	"github.com/SigNoz/signoz/pkg/query-service/formatter"
 
 	querierV5 "github.com/SigNoz/signoz/pkg/querier"
@@ -42,23 +28,9 @@ import (
 
 type ThresholdRule struct {
 	*BaseRule
-	// Ever since we introduced the new metrics query builder, the version is "v4"
-	// for all the rules
-	// if the version is "v3", then we use the old querier
-	// if the version is "v4", then we use the new querierV2
-	version string
 
-	// querier is used for alerts created before the introduction of new metrics query builder
-	querier interfaces.Querier
-	// querierV2 is used for alerts created after the introduction of new metrics query builder
-	querierV2 interfaces.Querier
-
-	// querierV5 is used for alerts migrated after the introduction of new query builder
+	// querierV5 is the query builder v5 querier used for all alert rule evaluation
 	querierV5 querierV5.Querier
-
-	// used for attribute metadata enrichment for logs and traces
-	logsKeys  map[string]v3.AttributeKey
-	spansKeys map[string]v3.AttributeKey
 }
 
 var _ Rule = (*ThresholdRule)(nil)
@@ -82,25 +54,10 @@ func NewThresholdRule(
 	}
 
 	t := ThresholdRule{
-		BaseRule: baseRule,
-		version:  p.Version,
+		BaseRule:   baseRule,
+		querierV5: querierV5,
 	}
 
-	querierOption := querier.QuerierOptions{
-		Reader:       reader,
-		Cache:        nil,
-		KeyGenerator: queryBuilder.NewKeyGenerator(),
-	}
-
-	querierOptsV2 := querierV2.QuerierOptions{
-		Reader:       reader,
-		Cache:        nil,
-		KeyGenerator: queryBuilder.NewKeyGenerator(),
-	}
-
-	t.querier = querier.NewQuerier(querierOption)
-	t.querierV2 = querierV2.NewQuerier(querierOptsV2)
-	t.querierV5 = querierV5
 	t.reader = reader
 	return &t, nil
 }
@@ -120,169 +77,9 @@ func (r *ThresholdRule) Type() ruletypes.RuleType {
 	return ruletypes.RuleTypeThreshold
 }
 
-func (r *ThresholdRule) prepareQueryRange(ctx context.Context, ts time.Time) (*v3.QueryRangeParamsV3, error) {
+func (r *ThresholdRule) prepareQueryRange(ctx context.Context, ts time.Time) (*qbtypes.QueryRangeRequest, error) {
 	r.logger.InfoContext(
-		ctx, "prepare query range request v4", "ts", ts.UnixMilli(), "eval_window", r.evalWindow.Milliseconds(), "eval_delay", r.evalDelay.Milliseconds(),
-	)
-
-	startTs, endTs := r.Timestamps(ts)
-	start, end := startTs.UnixMilli(), endTs.UnixMilli()
-
-	if r.ruleCondition.QueryType() == v3.QueryTypeClickHouseSQL {
-		params := &v3.QueryRangeParamsV3{
-			Start: start,
-			End:   end,
-			Step:  int64(math.Max(float64(common.MinAllowedStepInterval(start, end)), 60)),
-			CompositeQuery: &v3.CompositeQuery{
-				QueryType:         r.ruleCondition.CompositeQuery.QueryType,
-				PanelType:         r.ruleCondition.CompositeQuery.PanelType,
-				BuilderQueries:    make(map[string]*v3.BuilderQuery),
-				ClickHouseQueries: make(map[string]*v3.ClickHouseQuery),
-				PromQueries:       make(map[string]*v3.PromQuery),
-				Unit:              r.ruleCondition.CompositeQuery.Unit,
-			},
-			Variables: make(map[string]interface{}),
-			NoCache:   true,
-		}
-		querytemplate.AssignReservedVarsV3(params)
-		for name, chQuery := range r.ruleCondition.CompositeQuery.ClickHouseQueries {
-			if chQuery.Disabled {
-				continue
-			}
-			tmpl := template.New("clickhouse-query")
-			tmpl, err := tmpl.Parse(chQuery.Query)
-			if err != nil {
-				return nil, err
-			}
-			var query bytes.Buffer
-			err = tmpl.Execute(&query, params.Variables)
-			if err != nil {
-				return nil, err
-			}
-			params.CompositeQuery.ClickHouseQueries[name] = &v3.ClickHouseQuery{
-				Query:    query.String(),
-				Disabled: chQuery.Disabled,
-				Legend:   chQuery.Legend,
-			}
-		}
-		return params, nil
-	}
-
-	if r.ruleCondition.CompositeQuery != nil && r.ruleCondition.CompositeQuery.BuilderQueries != nil {
-		for _, q := range r.ruleCondition.CompositeQuery.BuilderQueries {
-			// If the step interval is less than the minimum allowed step interval, set it to the minimum allowed step interval
-			if minStep := common.MinAllowedStepInterval(start, end); q.StepInterval < minStep {
-				q.StepInterval = minStep
-			}
-
-			q.SetShiftByFromFunc()
-
-			if q.DataSource == v3.DataSourceMetrics {
-				// if the time range is greater than 1 day, and less than 1 week set the step interval to be multiple of 5 minutes
-				// if the time range is greater than 1 week, set the step interval to be multiple of 30 mins
-				if end-start >= 24*time.Hour.Milliseconds() && end-start < 7*24*time.Hour.Milliseconds() {
-					q.StepInterval = int64(math.Round(float64(q.StepInterval)/300)) * 300
-				} else if end-start >= 7*24*time.Hour.Milliseconds() {
-					q.StepInterval = int64(math.Round(float64(q.StepInterval)/1800)) * 1800
-				}
-			}
-		}
-	}
-
-	if r.ruleCondition.CompositeQuery.PanelType != v3.PanelTypeGraph {
-		r.ruleCondition.CompositeQuery.PanelType = v3.PanelTypeGraph
-	}
-
-	// default mode
-	return &v3.QueryRangeParamsV3{
-		Start:          start,
-		End:            end,
-		Step:           int64(math.Max(float64(common.MinAllowedStepInterval(start, end)), 60)),
-		CompositeQuery: r.ruleCondition.CompositeQuery,
-		Variables:      make(map[string]interface{}),
-		NoCache:        true,
-	}, nil
-}
-
-func (r *ThresholdRule) prepareLinksToLogs(ctx context.Context, ts time.Time, lbls labels.Labels) string {
-	if r.version == "v5" {
-		return r.prepareLinksToLogsV5(ctx, ts, lbls)
-	}
-
-	selectedQuery := r.GetSelectedQuery()
-
-	qr, err := r.prepareQueryRange(ctx, ts)
-	if err != nil {
-		return ""
-	}
-	start := time.UnixMilli(qr.Start)
-	end := time.UnixMilli(qr.End)
-
-	// TODO(srikanthccv): handle formula queries
-	if selectedQuery < "A" || selectedQuery > "Z" {
-		return ""
-	}
-
-	q := r.ruleCondition.CompositeQuery.BuilderQueries[selectedQuery]
-	if q == nil {
-		return ""
-	}
-
-	if q.DataSource != v3.DataSourceLogs {
-		return ""
-	}
-
-	queryFilter := []v3.FilterItem{}
-	if q.Filters != nil {
-		queryFilter = q.Filters.Items
-	}
-
-	filterItems := contextlinks.PrepareFilters(lbls.Map(), queryFilter, q.GroupBy, r.logsKeys)
-
-	return contextlinks.PrepareLinksToLogs(start, end, filterItems)
-}
-
-func (r *ThresholdRule) prepareLinksToTraces(ctx context.Context, ts time.Time, lbls labels.Labels) string {
-	if r.version == "v5" {
-		return r.prepareLinksToTracesV5(ctx, ts, lbls)
-	}
-
-	selectedQuery := r.GetSelectedQuery()
-
-	qr, err := r.prepareQueryRange(ctx, ts)
-	if err != nil {
-		return ""
-	}
-	start := time.UnixMilli(qr.Start)
-	end := time.UnixMilli(qr.End)
-
-	// TODO(srikanthccv): handle formula queries
-	if selectedQuery < "A" || selectedQuery > "Z" {
-		return ""
-	}
-
-	q := r.ruleCondition.CompositeQuery.BuilderQueries[selectedQuery]
-	if q == nil {
-		return ""
-	}
-
-	if q.DataSource != v3.DataSourceTraces {
-		return ""
-	}
-
-	queryFilter := []v3.FilterItem{}
-	if q.Filters != nil {
-		queryFilter = q.Filters.Items
-	}
-
-	filterItems := contextlinks.PrepareFilters(lbls.Map(), queryFilter, q.GroupBy, r.spansKeys)
-
-	return contextlinks.PrepareLinksToTraces(start, end, filterItems)
-}
-
-func (r *ThresholdRule) 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(),
+		ctx, "prepare query range request", "ts", ts.UnixMilli(), "eval_window", r.evalWindow.Milliseconds(), "eval_delay", r.evalDelay.Milliseconds(),
 	)
 
 	startTs, endTs := r.Timestamps(ts)
@@ -302,10 +99,10 @@ func (r *ThresholdRule) prepareQueryRangeV5(ctx context.Context, ts time.Time) (
 	return req, nil
 }
 
-func (r *ThresholdRule) prepareLinksToLogsV5(ctx context.Context, ts time.Time, lbls labels.Labels) string {
+func (r *ThresholdRule) prepareLinksToLogs(ctx context.Context, ts time.Time, lbls labels.Labels) string {
 	selectedQuery := r.GetSelectedQuery()
 
-	qr, err := r.prepareQueryRangeV5(ctx, ts)
+	qr, err := r.prepareQueryRange(ctx, ts)
 	if err != nil {
 		return ""
 	}
@@ -342,10 +139,10 @@ func (r *ThresholdRule) prepareLinksToLogsV5(ctx context.Context, ts time.Time,
 	return contextlinks.PrepareLinksToLogsV5(start, end, whereClause)
 }
 
-func (r *ThresholdRule) prepareLinksToTracesV5(ctx context.Context, ts time.Time, lbls labels.Labels) string {
+func (r *ThresholdRule) prepareLinksToTraces(ctx context.Context, ts time.Time, lbls labels.Labels) string {
 	selectedQuery := r.GetSelectedQuery()
 
-	qr, err := r.prepareQueryRangeV5(ctx, ts)
+	qr, err := r.prepareQueryRange(ctx, ts)
 	if err != nil {
 		return ""
 	}
@@ -391,115 +188,6 @@ func (r *ThresholdRule) buildAndRunQuery(ctx context.Context, orgID valuer.UUID,
 	if err != nil {
 		return nil, err
 	}
-	err = r.PopulateTemporality(ctx, orgID, params)
-	if err != nil {
-		return nil, fmt.Errorf("internal error while setting temporality")
-	}
-
-	if params.CompositeQuery.QueryType == v3.QueryTypeBuilder {
-		hasLogsQuery := false
-		hasTracesQuery := false
-		for _, query := range params.CompositeQuery.BuilderQueries {
-			if query.DataSource == v3.DataSourceLogs {
-				hasLogsQuery = true
-			}
-			if query.DataSource == v3.DataSourceTraces {
-				hasTracesQuery = true
-			}
-		}
-
-		if hasLogsQuery {
-			// check if any enrichment is required for logs if yes then enrich them
-			if logsv3.EnrichmentRequired(params) {
-				logsFields, apiErr := r.reader.GetLogFieldsFromNames(ctx, logsv3.GetFieldNames(params.CompositeQuery))
-				if apiErr != nil {
-					return nil, apiErr.ToError()
-				}
-				logsKeys := model.GetLogFieldsV3(ctx, params, logsFields)
-				r.logsKeys = logsKeys
-				logsv3.Enrich(params, logsKeys)
-			}
-		}
-
-		if hasTracesQuery {
-			spanKeys, err := r.reader.GetSpanAttributeKeysByNames(ctx, logsv3.GetFieldNames(params.CompositeQuery))
-			if err != nil {
-				return nil, err
-			}
-			r.spansKeys = spanKeys
-			tracesV4.Enrich(params, spanKeys)
-		}
-	}
-
-	var results []*v3.Result
-	var queryErrors map[string]error
-
-	if r.version == "v4" {
-		results, queryErrors, err = r.querierV2.QueryRange(ctx, orgID, params)
-	} else {
-		results, queryErrors, err = r.querier.QueryRange(ctx, orgID, params)
-	}
-
-	if err != nil {
-		r.logger.ErrorContext(ctx, "failed to get alert query range result", "rule_name", r.Name(), "error", err, "query_errors", queryErrors)
-		return nil, fmt.Errorf("internal error while querying")
-	}
-
-	if params.CompositeQuery.QueryType == v3.QueryTypeBuilder {
-		results, err = postprocess.PostProcessResult(results, params)
-		if err != nil {
-			r.logger.ErrorContext(ctx, "failed to post process result", "rule_name", r.Name(), "error", err)
-			return nil, fmt.Errorf("internal error while post processing")
-		}
-	}
-
-	selectedQuery := r.GetSelectedQuery()
-
-	var queryResult *v3.Result
-	for _, res := range results {
-		if res.QueryName == selectedQuery {
-			queryResult = res
-			break
-		}
-	}
-
-	hasData := queryResult != nil && len(queryResult.Series) > 0
-	if missingDataAlert := r.HandleMissingDataAlert(ctx, ts, hasData); missingDataAlert != nil {
-		return ruletypes.Vector{*missingDataAlert}, nil
-	}
-
-	var resultVector ruletypes.Vector
-
-	if queryResult == nil {
-		r.logger.WarnContext(ctx, "query result is nil", "rule_name", r.Name(), "query_name", selectedQuery)
-		return resultVector, nil
-	}
-
-	for _, series := range queryResult.Series {
-		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
-		}
-		resultSeries, err := r.Threshold.Eval(*series, r.Unit(), ruletypes.EvalData{
-			ActiveAlerts:  r.ActiveAlertsLabelFP(),
-			SendUnmatched: r.ShouldSendUnmatched(),
-		})
-		if err != nil {
-			return nil, err
-		}
-		resultVector = append(resultVector, resultSeries...)
-	}
-
-	return resultVector, nil
-}
-
-func (r *ThresholdRule) 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
-	}
-
-	var results []*v3.Result
 
 	v5Result, err := r.querierV5.QueryRange(ctx, orgID, params)
 	if err != nil {
@@ -507,26 +195,24 @@ func (r *ThresholdRule) buildAndRunQueryV5(ctx context.Context, orgID valuer.UUI
 		return nil, fmt.Errorf("internal error while querying")
 	}
 
-	for _, item := range v5Result.Data.Results {
-		if tsData, ok := item.(*qbtypes.TimeSeriesData); ok {
-			results = append(results, transition.ConvertV5TimeSeriesDataToV4Result(tsData))
-		} else {
-			// NOTE: should not happen but just to ensure we don't miss it if it happens for some reason
-			r.logger.WarnContext(ctx, "expected qbtypes.TimeSeriesData but got", "item_type", reflect.TypeOf(item))
-		}
-	}
-
 	selectedQuery := r.GetSelectedQuery()
 
-	var queryResult *v3.Result
-	for _, res := range results {
-		if res.QueryName == selectedQuery {
-			queryResult = res
+	var queryResult *qbtypes.TimeSeriesData
+	for _, item := range v5Result.Data.Results {
+		if tsData, ok := item.(*qbtypes.TimeSeriesData); ok && tsData.QueryName == selectedQuery {
+			queryResult = tsData
 			break
 		}
 	}
 
-	hasData := queryResult != nil && len(queryResult.Series) > 0
+	var allSeries []*qbtypes.TimeSeries
+	if queryResult != nil {
+		for _, bucket := range queryResult.Aggregations {
+			allSeries = append(allSeries, bucket.Series...)
+		}
+	}
+
+	hasData := len(allSeries) > 0
 	if missingDataAlert := r.HandleMissingDataAlert(ctx, ts, hasData); missingDataAlert != nil {
 		return ruletypes.Vector{*missingDataAlert}, nil
 	}
@@ -539,7 +225,7 @@ func (r *ThresholdRule) buildAndRunQueryV5(ctx context.Context, orgID valuer.UUI
 	}
 
 	// Filter out new series if newGroupEvalDelay is configured
-	seriesToProcess := queryResult.Series
+	seriesToProcess := allSeries
 	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
@@ -552,7 +238,7 @@ func (r *ThresholdRule) buildAndRunQueryV5(ctx context.Context, orgID valuer.UUI
 
 	for _, series := range seriesToProcess {
 		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)
+			r.logger.InfoContext(ctx, "not enough data points to evaluate series, skipping", "ruleid", r.ID(), "numPoints", len(series.Values), "requiredPoints", r.Condition().RequiredNumPoints)
 			continue
 		}
 		resultSeries, err := r.Threshold.Eval(*series, r.Unit(), ruletypes.EvalData{
@@ -573,16 +259,7 @@ func (r *ThresholdRule) Eval(ctx context.Context, ts time.Time) (int, error) {
 
 	valueFormatter := formatter.FromUnit(r.Unit())
 
-	var res ruletypes.Vector
-	var err error
-
-	if r.version == "v5" {
-		r.logger.InfoContext(ctx, "running v5 query")
-		res, err = r.buildAndRunQueryV5(ctx, r.orgID, ts)
-	} else {
-		r.logger.InfoContext(ctx, "running v4 query")
-		res, err = r.buildAndRunQuery(ctx, r.orgID, ts)
-	}
+	res, err := r.buildAndRunQuery(ctx, r.orgID, ts)
 
 	if err != nil {
 		return 0, err

pkg/signoz/openapi.go

@@ -1,10 +1,7 @@
 package signoz
 
 import (
-	"bytes"
 	"context"
-	"encoding/json"
-	"net/http"
 	"os"
 	"reflect"
 
@@ -25,13 +22,10 @@ import (
 	"github.com/SigNoz/signoz/pkg/modules/promote"
 	"github.com/SigNoz/signoz/pkg/modules/session"
 	"github.com/SigNoz/signoz/pkg/modules/user"
-	"github.com/SigNoz/signoz/pkg/querier"
 	"github.com/SigNoz/signoz/pkg/types/ctxtypes"
-	"github.com/gorilla/mux"
 	"github.com/swaggest/jsonschema-go"
 	"github.com/swaggest/openapi-go"
 	"github.com/swaggest/openapi-go/openapi3"
-	"gopkg.in/yaml.v2"
 )
 
 type OpenAPI struct {
@@ -63,10 +57,6 @@ func NewOpenAPI(ctx context.Context, instrumentation instrumentation.Instrumenta
 		return nil, err
 	}
 
-	// Register routes that live outside the APIServer modules
-	// so they are discovered by the OpenAPI walker.
-	registerQueryRoutes(apiserver.Router())
-
 	reflector := openapi3.NewReflector()
 	reflector.JSONSchemaReflector().DefaultOptions = append(reflector.JSONSchemaReflector().DefaultOptions, jsonschema.InterceptDefName(func(t reflect.Type, defaultDefName string) string {
 		if defaultDefName == "RenderSuccessResponse" {
@@ -100,67 +90,10 @@ func (openapi *OpenAPI) CreateAndWrite(path string) error {
 		return err
 	}
 
-	// The library's MarshalYAML does a JSON round-trip that converts all numbers
-	// to float64, causing large integers (e.g. epoch millisecond timestamps) to
-	// render in scientific notation (1.6409952e+12).
-	jsonData, err := openapi.reflector.Spec.MarshalJSON()
-	if err != nil {
-		return err
-	}
-
-	dec := json.NewDecoder(bytes.NewReader(jsonData))
-	dec.UseNumber()
-
-	var v any
-	if err := dec.Decode(&v); err != nil {
-		return err
-	}
-
-	convertJSONNumbers(v)
-
-	spec, err := yaml.Marshal(v)
+	spec, err := openapi.reflector.Spec.MarshalYAML()
 	if err != nil {
 		return err
 	}
 
 	return os.WriteFile(path, spec, 0o600)
 }
-
-// convertJSONNumbers recursively walks a decoded JSON structure and converts
-// json.Number values to int64 (preferred) or float64 so that YAML marshaling
-// renders them as plain numbers instead of quoted strings.
-func convertJSONNumbers(v interface{}) {
-	switch val := v.(type) {
-	case map[string]interface{}:
-		for k, elem := range val {
-			if n, ok := elem.(json.Number); ok {
-				if i, err := n.Int64(); err == nil {
-					val[k] = i
-				} else if f, err := n.Float64(); err == nil {
-					val[k] = f
-				}
-			} else {
-				convertJSONNumbers(elem)
-			}
-		}
-	case []interface{}:
-		for i, elem := range val {
-			if n, ok := elem.(json.Number); ok {
-				if i64, err := n.Int64(); err == nil {
-					val[i] = i64
-				} else if f, err := n.Float64(); err == nil {
-					val[i] = f
-				}
-			} else {
-				convertJSONNumbers(elem)
-			}
-		}
-	}
-}
-
-func registerQueryRoutes(router *mux.Router) {
-	router.Handle("/api/v5/query_range", handler.New(
-		func(http.ResponseWriter, *http.Request) {},
-		querier.QueryRangeV5OpenAPIDef,
-	)).Methods(http.MethodPost)
-}