Merge branch 'main' into fix/delete-rule

.devenv/docker/clickhouse/compose.yaml

@@ -42,7 +42,7 @@ services:
       timeout: 5s
       retries: 3
   schema-migrator-sync:
-    image: signoz/signoz-schema-migrator:v0.129.8
+    image: signoz/signoz-schema-migrator:v0.129.7
     container_name: schema-migrator-sync
     command:
       - sync
@@ -55,7 +55,7 @@ services:
         condition: service_healthy
     restart: on-failure
   schema-migrator-async:
-    image: signoz/signoz-schema-migrator:v0.129.8
+    image: signoz/signoz-schema-migrator:v0.129.7
     container_name: schema-migrator-async
     command:
       - async

.github/workflows/build-enterprise.yaml

@@ -107,6 +107,7 @@ jobs:
         -X github.com/SigNoz/signoz/pkg/version.branch=${{ needs.prepare.outputs.branch }}
         -X github.com/SigNoz/signoz/ee/zeus.url=https://api.signoz.cloud
         -X github.com/SigNoz/signoz/ee/zeus.deprecatedURL=https://license.signoz.io
+        -X github.com/SigNoz/signoz/ee/query-service/constants.ZeusURL=https://api.signoz.cloud
         -X github.com/SigNoz/signoz/ee/query-service/constants.LicenseSignozIo=https://license.signoz.io/api/v1
         -X github.com/SigNoz/signoz/pkg/analytics.key=9kRrJ7oPCGPEJLF6QjMPLt5bljFhRQBr'
       DOCKER_BASE_IMAGES: '{"alpine": "alpine:3.20.3"}'

.github/workflows/build-staging.yaml

@@ -106,6 +106,7 @@ jobs:
         -X github.com/SigNoz/signoz/pkg/version.branch=${{ needs.prepare.outputs.branch }}
         -X github.com/SigNoz/signoz/ee/zeus.url=https://api.staging.signoz.cloud
         -X github.com/SigNoz/signoz/ee/zeus.deprecatedURL=https://license.staging.signoz.cloud
+        -X github.com/SigNoz/signoz/ee/query-service/constants.ZeusURL=https://api.staging.signoz.cloud
         -X github.com/SigNoz/signoz/ee/query-service/constants.LicenseSignozIo=https://license.staging.signoz.cloud/api/v1
         -X github.com/SigNoz/signoz/pkg/analytics.key=9kRrJ7oPCGPEJLF6QjMPLt5bljFhRQBr'
       DOCKER_BASE_IMAGES: '{"alpine": "alpine:3.20.3"}'

.github/workflows/integrationci.yaml

@@ -17,7 +17,6 @@ jobs:
           - bootstrap
           - passwordauthn
           - callbackauthn
-          - cloudintegrations
           - querier
           - ttl
         sqlstore-provider:

cmd/enterprise/.goreleaser.yaml

@@ -31,6 +31,7 @@ builds:
       - -X github.com/SigNoz/signoz/pkg/version.branch={{ .Branch }}
       - -X github.com/SigNoz/signoz/ee/zeus.url=https://api.signoz.cloud
       - -X github.com/SigNoz/signoz/ee/zeus.deprecatedURL=https://license.signoz.io
+      - -X github.com/SigNoz/signoz/ee/query-service/constants.ZeusURL=https://api.signoz.cloud
       - -X github.com/SigNoz/signoz/ee/query-service/constants.LicenseSignozIo=https://license.signoz.io/api/v1
       - -X github.com/SigNoz/signoz/pkg/analytics.key=9kRrJ7oPCGPEJLF6QjMPLt5bljFhRQBr
     mod_timestamp: "{{ .CommitTimestamp }}"

deploy/docker-swarm/docker-compose.ha.yaml

@@ -176,7 +176,7 @@ services:
       # - ../common/clickhouse/storage.xml:/etc/clickhouse-server/config.d/storage.xml
   signoz:
     !!merge <<: *db-depend
-    image: signoz/signoz:v0.100.0
+    image: signoz/signoz:v0.99.0
     command:
       - --config=/root/config/prometheus.yml
     ports:
@@ -209,7 +209,7 @@ services:
       retries: 3
   otel-collector:
     !!merge <<: *db-depend
-    image: signoz/signoz-otel-collector:v0.129.8
+    image: signoz/signoz-otel-collector:v0.129.7
     command:
       - --config=/etc/otel-collector-config.yaml
       - --manager-config=/etc/manager-config.yaml
@@ -233,7 +233,7 @@ services:
       - signoz
   schema-migrator:
     !!merge <<: *common
-    image: signoz/signoz-schema-migrator:v0.129.8
+    image: signoz/signoz-schema-migrator:v0.129.7
     deploy:
       restart_policy:
         condition: on-failure

deploy/docker-swarm/docker-compose.yaml

@@ -117,7 +117,7 @@ services:
       # - ../common/clickhouse/storage.xml:/etc/clickhouse-server/config.d/storage.xml
   signoz:
     !!merge <<: *db-depend
-    image: signoz/signoz:v0.100.0
+    image: signoz/signoz:v0.99.0
     command:
       - --config=/root/config/prometheus.yml
     ports:
@@ -150,7 +150,7 @@ services:
       retries: 3
   otel-collector:
     !!merge <<: *db-depend
-    image: signoz/signoz-otel-collector:v0.129.8
+    image: signoz/signoz-otel-collector:v0.129.7
     command:
       - --config=/etc/otel-collector-config.yaml
       - --manager-config=/etc/manager-config.yaml
@@ -176,7 +176,7 @@ services:
       - signoz
   schema-migrator:
     !!merge <<: *common
-    image: signoz/signoz-schema-migrator:v0.129.8
+    image: signoz/signoz-schema-migrator:v0.129.7
     deploy:
       restart_policy:
         condition: on-failure

deploy/docker/docker-compose.ha.yaml

@@ -179,7 +179,7 @@ services:
       # - ../common/clickhouse/storage.xml:/etc/clickhouse-server/config.d/storage.xml
   signoz:
     !!merge <<: *db-depend
-    image: signoz/signoz:${VERSION:-v0.100.0}
+    image: signoz/signoz:${VERSION:-v0.99.0}
     container_name: signoz
     command:
       - --config=/root/config/prometheus.yml
@@ -213,7 +213,7 @@ services:
   # TODO: support otel-collector multiple replicas. Nginx/Traefik for loadbalancing?
   otel-collector:
     !!merge <<: *db-depend
-    image: signoz/signoz-otel-collector:${OTELCOL_TAG:-v0.129.8}
+    image: signoz/signoz-otel-collector:${OTELCOL_TAG:-v0.129.7}
     container_name: signoz-otel-collector
     command:
       - --config=/etc/otel-collector-config.yaml
@@ -239,7 +239,7 @@ services:
         condition: service_healthy
   schema-migrator-sync:
     !!merge <<: *common
-    image: signoz/signoz-schema-migrator:${OTELCOL_TAG:-v0.129.8}
+    image: signoz/signoz-schema-migrator:${OTELCOL_TAG:-v0.129.7}
     container_name: schema-migrator-sync
     command:
       - sync
@@ -250,7 +250,7 @@ services:
         condition: service_healthy
   schema-migrator-async:
     !!merge <<: *db-depend
-    image: signoz/signoz-schema-migrator:${OTELCOL_TAG:-v0.129.8}
+    image: signoz/signoz-schema-migrator:${OTELCOL_TAG:-v0.129.7}
     container_name: schema-migrator-async
     command:
       - async

deploy/docker/docker-compose.yaml

@@ -111,7 +111,7 @@ services:
       # - ../common/clickhouse/storage.xml:/etc/clickhouse-server/config.d/storage.xml
   signoz:
     !!merge <<: *db-depend
-    image: signoz/signoz:${VERSION:-v0.100.0}
+    image: signoz/signoz:${VERSION:-v0.99.0}
     container_name: signoz
     command:
       - --config=/root/config/prometheus.yml
@@ -144,7 +144,7 @@ services:
       retries: 3
   otel-collector:
     !!merge <<: *db-depend
-    image: signoz/signoz-otel-collector:${OTELCOL_TAG:-v0.129.8}
+    image: signoz/signoz-otel-collector:${OTELCOL_TAG:-v0.129.7}
     container_name: signoz-otel-collector
     command:
       - --config=/etc/otel-collector-config.yaml
@@ -166,7 +166,7 @@ services:
         condition: service_healthy
   schema-migrator-sync:
     !!merge <<: *common
-    image: signoz/signoz-schema-migrator:${OTELCOL_TAG:-v0.129.8}
+    image: signoz/signoz-schema-migrator:${OTELCOL_TAG:-v0.129.7}
     container_name: schema-migrator-sync
     command:
       - sync
@@ -178,7 +178,7 @@ services:
     restart: on-failure
   schema-migrator-async:
     !!merge <<: *db-depend
-    image: signoz/signoz-schema-migrator:${OTELCOL_TAG:-v0.129.8}
+    image: signoz/signoz-schema-migrator:${OTELCOL_TAG:-v0.129.7}
     container_name: schema-migrator-async
     command:
       - async

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

@@ -10,6 +10,7 @@ import (
 	"strings"
 	"time"
 
+	"github.com/SigNoz/signoz/ee/query-service/constants"
 	"github.com/SigNoz/signoz/pkg/errors"
 	"github.com/SigNoz/signoz/pkg/http/render"
 	"github.com/SigNoz/signoz/pkg/modules/user"
@@ -76,7 +77,7 @@ func (ah *APIHandler) CloudIntegrationsGenerateConnectionParams(w http.ResponseW
 		return
 	}
 
-	ingestionUrl, signozApiUrl, apiErr := ah.getIngestionUrlAndSigNozAPIUrl(r.Context(), license.Key)
+	ingestionUrl, signozApiUrl, apiErr := getIngestionUrlAndSigNozAPIUrl(r.Context(), license.Key)
 	if apiErr != nil {
 		RespondError(w, basemodel.WrapApiError(
 			apiErr, "couldn't deduce ingestion url and signoz api url",
@@ -185,37 +186,48 @@ func (ah *APIHandler) getOrCreateCloudIntegrationUser(
 	return cloudIntegrationUser, nil
 }
 
-func (ah *APIHandler) getIngestionUrlAndSigNozAPIUrl(ctx context.Context, licenseKey string) (
+func getIngestionUrlAndSigNozAPIUrl(ctx context.Context, licenseKey string) (
 	string, string, *basemodel.ApiError,
 ) {
-	// TODO: remove this struct from here
+	url := fmt.Sprintf(
+		"%s%s",
+		strings.TrimSuffix(constants.ZeusURL, "/"),
+		"/v2/deployments/me",
+	)
+
 	type deploymentResponse struct {
-		Name        string `json:"name"`
-		ClusterInfo struct {
-			Region struct {
-				DNS string `json:"dns"`
-			} `json:"region"`
-		} `json:"cluster"`
+		Status string `json:"status"`
+		Error  string `json:"error"`
+		Data   struct {
+			Name string `json:"name"`
+
+			ClusterInfo struct {
+				Region struct {
+					DNS string `json:"dns"`
+				} `json:"region"`
+			} `json:"cluster"`
+		} `json:"data"`
 	}
 
-	respBytes, err := ah.Signoz.Zeus.GetDeployment(ctx, licenseKey)
-	if err != nil {
+	resp, apiErr := requestAndParseResponse[deploymentResponse](
+		ctx, url, map[string]string{"X-Signoz-Cloud-Api-Key": licenseKey}, nil,
+	)
+
+	if apiErr != nil {
+		return "", "", basemodel.WrapApiError(
+			apiErr, "couldn't query for deployment info",
+		)
+	}
+
+	if resp.Status != "success" {
 		return "", "", basemodel.InternalError(fmt.Errorf(
-			"couldn't query for deployment info: error: %w", err,
+			"couldn't query for deployment info: status: %s, error: %s",
+			resp.Status, resp.Error,
 		))
 	}
 
-	resp := new(deploymentResponse)
-
-	err = json.Unmarshal(respBytes, resp)
-	if err != nil {
-		return "", "", basemodel.InternalError(fmt.Errorf(
-			"couldn't unmarshal deployment info response: error: %w", err,
-		))
-	}
-
-	regionDns := resp.ClusterInfo.Region.DNS
-	deploymentName := resp.Name
+	regionDns := resp.Data.ClusterInfo.Region.DNS
+	deploymentName := resp.Data.Name
 
 	if len(regionDns) < 1 || len(deploymentName) < 1 {
 		// Fail early if actual response structure and expectation here ever diverge

ee/query-service/constants/constants.go

@@ -10,6 +10,9 @@ var SaasSegmentKey = GetOrDefaultEnv("SIGNOZ_SAAS_SEGMENT_KEY", "")
 var FetchFeatures = GetOrDefaultEnv("FETCH_FEATURES", "false")
 var ZeusFeaturesURL = GetOrDefaultEnv("ZEUS_FEATURES_URL", "ZeusFeaturesURL")
 
+// this is set via build time variable
+var ZeusURL = "https://api.signoz.cloud"
+
 func GetOrDefaultEnv(key string, fallback string) string {
 	v := os.Getenv(key)
 	if len(v) == 0 {

ee/sqlstore/postgressqlstore/formatter.go

@@ -1,153 +0,0 @@
-package postgressqlstore
-
-import (
-	"strings"
-
-	"github.com/SigNoz/signoz/pkg/sqlstore"
-	"github.com/uptrace/bun/schema"
-)
-
-type formatter struct {
-	bunf schema.Formatter
-}
-
-func newFormatter(dialect schema.Dialect) sqlstore.SQLFormatter {
-	return &formatter{bunf: schema.NewFormatter(dialect)}
-}
-
-func (f *formatter) JSONExtractString(column, path string) []byte {
-	var sql []byte
-	sql = f.bunf.AppendIdent(sql, column)
-	sql = append(sql, f.convertJSONPathToPostgres(path)...)
-	return sql
-}
-
-func (f *formatter) JSONType(column, path string) []byte {
-	var sql []byte
-	sql = append(sql, "jsonb_typeof("...)
-	sql = f.bunf.AppendIdent(sql, column)
-	sql = append(sql, f.convertJSONPathToPostgresWithMode(path, false)...)
-	sql = append(sql, ')')
-	return sql
-}
-
-func (f *formatter) JSONIsArray(column, path string) []byte {
-	var sql []byte
-	sql = append(sql, f.JSONType(column, path)...)
-	sql = append(sql, " = "...)
-	sql = schema.Append(f.bunf, sql, "array")
-	return sql
-}
-
-func (f *formatter) JSONArrayElements(column, path, alias string) ([]byte, []byte) {
-	var sql []byte
-	sql = append(sql, "jsonb_array_elements("...)
-	sql = f.bunf.AppendIdent(sql, column)
-	sql = append(sql, f.convertJSONPathToPostgresWithMode(path, false)...)
-	sql = append(sql, ") AS "...)
-	sql = f.bunf.AppendIdent(sql, alias)
-
-	return sql, []byte(alias)
-}
-
-func (f *formatter) JSONArrayOfStrings(column, path, alias string) ([]byte, []byte) {
-	var sql []byte
-	sql = append(sql, "jsonb_array_elements_text("...)
-	sql = f.bunf.AppendIdent(sql, column)
-	sql = append(sql, f.convertJSONPathToPostgresWithMode(path, false)...)
-	sql = append(sql, ") AS "...)
-	sql = f.bunf.AppendIdent(sql, alias)
-
-	return sql, append([]byte(alias), "::text"...)
-}
-
-func (f *formatter) JSONKeys(column, path, alias string) ([]byte, []byte) {
-	var sql []byte
-	sql = append(sql, "jsonb_each("...)
-	sql = f.bunf.AppendIdent(sql, column)
-	sql = append(sql, f.convertJSONPathToPostgresWithMode(path, false)...)
-	sql = append(sql, ") AS "...)
-	sql = f.bunf.AppendIdent(sql, alias)
-
-	return sql, append([]byte(alias), ".key"...)
-}
-
-func (f *formatter) JSONArrayAgg(expression string) []byte {
-	var sql []byte
-	sql = append(sql, "jsonb_agg("...)
-	sql = append(sql, expression...)
-	sql = append(sql, ')')
-	return sql
-}
-
-func (f *formatter) JSONArrayLiteral(values ...string) []byte {
-	var sql []byte
-	sql = append(sql, "jsonb_build_array("...)
-	for idx, value := range values {
-		if idx > 0 {
-			sql = append(sql, ", "...)
-		}
-		sql = schema.Append(f.bunf, sql, value)
-	}
-	sql = append(sql, ')')
-	return sql
-}
-
-func (f *formatter) TextToJsonColumn(column string) []byte {
-	var sql []byte
-	sql = f.bunf.AppendIdent(sql, column)
-	sql = append(sql, "::jsonb"...)
-	return sql
-}
-
-func (f *formatter) convertJSONPathToPostgres(jsonPath string) []byte {
-	return f.convertJSONPathToPostgresWithMode(jsonPath, true)
-}
-
-func (f *formatter) convertJSONPathToPostgresWithMode(jsonPath string, asText bool) []byte {
-	path := strings.TrimPrefix(strings.TrimPrefix(jsonPath, "$"), ".")
-
-	if path == "" {
-		return nil
-	}
-
-	parts := strings.Split(path, ".")
-
-	var validParts []string
-	for _, part := range parts {
-		if part != "" {
-			validParts = append(validParts, part)
-		}
-	}
-
-	if len(validParts) == 0 {
-		return nil
-	}
-
-	var result []byte
-
-	for idx, part := range validParts {
-		if idx == len(validParts)-1 {
-			if asText {
-				result = append(result, "->>"...)
-			} else {
-				result = append(result, "->"...)
-			}
-			result = schema.Append(f.bunf, result, part)
-			return result
-		}
-
-		result = append(result, "->"...)
-		result = schema.Append(f.bunf, result, part)
-	}
-
-	return result
-}
-
-func (f *formatter) LowerExpression(expression string) []byte {
-	var sql []byte
-	sql = append(sql, "lower("...)
-	sql = append(sql, expression...)
-	sql = append(sql, ')')
-	return sql
-}

ee/sqlstore/postgressqlstore/formatter_test.go

@@ -1,500 +0,0 @@
-package postgressqlstore
-
-import (
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/uptrace/bun/dialect/pgdialect"
-)
-
-func TestJSONExtractString(t *testing.T) {
-	tests := []struct {
-		name     string
-		column   string
-		path     string
-		expected string
-	}{
-		{
-			name:     "simple path",
-			column:   "data",
-			path:     "$.field",
-			expected: `"data"->>'field'`,
-		},
-		{
-			name:     "nested path",
-			column:   "metadata",
-			path:     "$.user.name",
-			expected: `"metadata"->'user'->>'name'`,
-		},
-		{
-			name:     "deeply nested path",
-			column:   "json_col",
-			path:     "$.level1.level2.level3",
-			expected: `"json_col"->'level1'->'level2'->>'level3'`,
-		},
-		{
-			name:     "root path",
-			column:   "json_col",
-			path:     "$",
-			expected: `"json_col"`,
-		},
-		{
-			name:     "empty path",
-			column:   "data",
-			path:     "",
-			expected: `"data"`,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			f := newFormatter(pgdialect.New())
-			got := string(f.JSONExtractString(tt.column, tt.path))
-			assert.Equal(t, tt.expected, got)
-		})
-	}
-}
-
-func TestJSONType(t *testing.T) {
-	tests := []struct {
-		name     string
-		column   string
-		path     string
-		expected string
-	}{
-		{
-			name:     "simple path",
-			column:   "data",
-			path:     "$.field",
-			expected: `jsonb_typeof("data"->'field')`,
-		},
-		{
-			name:     "nested path",
-			column:   "metadata",
-			path:     "$.user.age",
-			expected: `jsonb_typeof("metadata"->'user'->'age')`,
-		},
-		{
-			name:     "root path",
-			column:   "json_col",
-			path:     "$",
-			expected: `jsonb_typeof("json_col")`,
-		},
-		{
-			name:     "empty path",
-			column:   "data",
-			path:     "",
-			expected: `jsonb_typeof("data")`,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			f := newFormatter(pgdialect.New())
-			got := string(f.JSONType(tt.column, tt.path))
-			assert.Equal(t, tt.expected, got)
-		})
-	}
-}
-
-func TestJSONIsArray(t *testing.T) {
-	tests := []struct {
-		name     string
-		column   string
-		path     string
-		expected string
-	}{
-		{
-			name:     "simple path",
-			column:   "data",
-			path:     "$.items",
-			expected: `jsonb_typeof("data"->'items') = 'array'`,
-		},
-		{
-			name:     "nested path",
-			column:   "metadata",
-			path:     "$.user.tags",
-			expected: `jsonb_typeof("metadata"->'user'->'tags') = 'array'`,
-		},
-		{
-			name:     "root path",
-			column:   "json_col",
-			path:     "$",
-			expected: `jsonb_typeof("json_col") = 'array'`,
-		},
-		{
-			name:     "empty path",
-			column:   "data",
-			path:     "",
-			expected: `jsonb_typeof("data") = 'array'`,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			f := newFormatter(pgdialect.New())
-			got := string(f.JSONIsArray(tt.column, tt.path))
-			assert.Equal(t, tt.expected, got)
-		})
-	}
-}
-
-func TestJSONArrayElements(t *testing.T) {
-	tests := []struct {
-		name     string
-		column   string
-		path     string
-		alias    string
-		expected string
-	}{
-		{
-			name:     "root path with dollar sign",
-			column:   "data",
-			path:     "$",
-			alias:    "elem",
-			expected: `jsonb_array_elements("data") AS "elem"`,
-		},
-		{
-			name:     "root path empty",
-			column:   "data",
-			path:     "",
-			alias:    "elem",
-			expected: `jsonb_array_elements("data") AS "elem"`,
-		},
-		{
-			name:     "nested path",
-			column:   "metadata",
-			path:     "$.items",
-			alias:    "item",
-			expected: `jsonb_array_elements("metadata"->'items') AS "item"`,
-		},
-		{
-			name:     "deeply nested path",
-			column:   "json_col",
-			path:     "$.user.tags",
-			alias:    "tag",
-			expected: `jsonb_array_elements("json_col"->'user'->'tags') AS "tag"`,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			f := newFormatter(pgdialect.New())
-			got, _ := f.JSONArrayElements(tt.column, tt.path, tt.alias)
-			assert.Equal(t, tt.expected, string(got))
-		})
-	}
-}
-
-func TestJSONArrayOfStrings(t *testing.T) {
-	tests := []struct {
-		name     string
-		column   string
-		path     string
-		alias    string
-		expected string
-	}{
-		{
-			name:     "root path with dollar sign",
-			column:   "data",
-			path:     "$",
-			alias:    "str",
-			expected: `jsonb_array_elements_text("data") AS "str"`,
-		},
-		{
-			name:     "root path empty",
-			column:   "data",
-			path:     "",
-			alias:    "str",
-			expected: `jsonb_array_elements_text("data") AS "str"`,
-		},
-		{
-			name:     "nested path",
-			column:   "metadata",
-			path:     "$.strings",
-			alias:    "s",
-			expected: `jsonb_array_elements_text("metadata"->'strings') AS "s"`,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			f := newFormatter(pgdialect.New())
-			got, _ := f.JSONArrayOfStrings(tt.column, tt.path, tt.alias)
-			assert.Equal(t, tt.expected, string(got))
-		})
-	}
-}
-
-func TestJSONKeys(t *testing.T) {
-	tests := []struct {
-		name     string
-		column   string
-		path     string
-		alias    string
-		expected string
-	}{
-		{
-			name:     "root path with dollar sign",
-			column:   "data",
-			path:     "$",
-			alias:    "k",
-			expected: `jsonb_each("data") AS "k"`,
-		},
-		{
-			name:     "root path empty",
-			column:   "data",
-			path:     "",
-			alias:    "k",
-			expected: `jsonb_each("data") AS "k"`,
-		},
-		{
-			name:     "nested path",
-			column:   "metadata",
-			path:     "$.object",
-			alias:    "key",
-			expected: `jsonb_each("metadata"->'object') AS "key"`,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			f := newFormatter(pgdialect.New())
-			got, _ := f.JSONKeys(tt.column, tt.path, tt.alias)
-			assert.Equal(t, tt.expected, string(got))
-		})
-	}
-}
-
-func TestJSONArrayAgg(t *testing.T) {
-	tests := []struct {
-		name       string
-		expression string
-		expected   string
-	}{
-		{
-			name:       "simple column",
-			expression: "id",
-			expected:   "jsonb_agg(id)",
-		},
-		{
-			name:       "expression with function",
-			expression: "DISTINCT name",
-			expected:   "jsonb_agg(DISTINCT name)",
-		},
-		{
-			name:       "complex expression",
-			expression: "data->>'field'",
-			expected:   "jsonb_agg(data->>'field')",
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			f := newFormatter(pgdialect.New())
-			got := string(f.JSONArrayAgg(tt.expression))
-			assert.Equal(t, tt.expected, got)
-		})
-	}
-}
-
-func TestJSONArrayLiteral(t *testing.T) {
-	tests := []struct {
-		name     string
-		values   []string
-		expected string
-	}{
-		{
-			name:     "empty array",
-			values:   []string{},
-			expected: "jsonb_build_array()",
-		},
-		{
-			name:     "single value",
-			values:   []string{"value1"},
-			expected: "jsonb_build_array('value1')",
-		},
-		{
-			name:     "multiple values",
-			values:   []string{"value1", "value2", "value3"},
-			expected: "jsonb_build_array('value1', 'value2', 'value3')",
-		},
-		{
-			name:     "values with special characters",
-			values:   []string{"test", "with space", "with-dash"},
-			expected: "jsonb_build_array('test', 'with space', 'with-dash')",
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			f := newFormatter(pgdialect.New())
-			got := string(f.JSONArrayLiteral(tt.values...))
-			assert.Equal(t, tt.expected, got)
-		})
-	}
-}
-
-func TestConvertJSONPathToPostgresWithMode(t *testing.T) {
-	tests := []struct {
-		name     string
-		jsonPath string
-		asText   bool
-		expected string
-	}{
-		{
-			name:     "simple path as text",
-			jsonPath: "$.field",
-			asText:   true,
-			expected: "->>'field'",
-		},
-		{
-			name:     "simple path as json",
-			jsonPath: "$.field",
-			asText:   false,
-			expected: "->'field'",
-		},
-		{
-			name:     "nested path as text",
-			jsonPath: "$.user.name",
-			asText:   true,
-			expected: "->'user'->>'name'",
-		},
-		{
-			name:     "nested path as json",
-			jsonPath: "$.user.name",
-			asText:   false,
-			expected: "->'user'->'name'",
-		},
-		{
-			name:     "deeply nested as text",
-			jsonPath: "$.a.b.c.d",
-			asText:   true,
-			expected: "->'a'->'b'->'c'->>'d'",
-		},
-		{
-			name:     "root path",
-			jsonPath: "$",
-			asText:   true,
-			expected: "",
-		},
-		{
-			name:     "empty path",
-			jsonPath: "",
-			asText:   true,
-			expected: "",
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			f := newFormatter(pgdialect.New()).(*formatter)
-			got := string(f.convertJSONPathToPostgresWithMode(tt.jsonPath, tt.asText))
-			assert.Equal(t, tt.expected, got)
-		})
-	}
-}
-
-func TestTextToJsonColumn(t *testing.T) {
-	tests := []struct {
-		name     string
-		column   string
-		expected string
-	}{
-		{
-			name:     "simple column name",
-			column:   "data",
-			expected: `"data"::jsonb`,
-		},
-		{
-			name:     "column with underscore",
-			column:   "user_data",
-			expected: `"user_data"::jsonb`,
-		},
-		{
-			name:     "column with special characters",
-			column:   "json-col",
-			expected: `"json-col"::jsonb`,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			f := newFormatter(pgdialect.New())
-			got := string(f.TextToJsonColumn(tt.column))
-			assert.Equal(t, tt.expected, got)
-		})
-	}
-}
-
-func TestLowerExpression(t *testing.T) {
-	tests := []struct {
-		name     string
-		expr     string
-		expected string
-	}{
-		{
-			name:     "simple column name",
-			expr:     "name",
-			expected: "lower(name)",
-		},
-		{
-			name:     "quoted column identifier",
-			expr:     `"column_name"`,
-			expected: `lower("column_name")`,
-		},
-		{
-			name:     "jsonb text extraction",
-			expr:     "data->>'field'",
-			expected: "lower(data->>'field')",
-		},
-		{
-			name:     "nested jsonb extraction",
-			expr:     "metadata->'user'->>'name'",
-			expected: "lower(metadata->'user'->>'name')",
-		},
-		{
-			name:     "jsonb_typeof expression",
-			expr:     "jsonb_typeof(data->'field')",
-			expected: "lower(jsonb_typeof(data->'field'))",
-		},
-		{
-			name:     "string concatenation",
-			expr:     "first_name || ' ' || last_name",
-			expected: "lower(first_name || ' ' || last_name)",
-		},
-		{
-			name:     "CAST expression",
-			expr:     "CAST(value AS TEXT)",
-			expected: "lower(CAST(value AS TEXT))",
-		},
-		{
-			name:     "COALESCE expression",
-			expr:     "COALESCE(name, 'default')",
-			expected: "lower(COALESCE(name, 'default'))",
-		},
-		{
-			name:     "subquery column",
-			expr:     "users.email",
-			expected: "lower(users.email)",
-		},
-		{
-			name:     "quoted identifier with special chars",
-			expr:     `"user-name"`,
-			expected: `lower("user-name")`,
-		},
-		{
-			name:     "jsonb to text cast",
-			expr:     "data::text",
-			expected: "lower(data::text)",
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			f := newFormatter(pgdialect.New())
-			got := string(f.LowerExpression(tt.expr))
-			assert.Equal(t, tt.expected, got)
-		})
-	}
-}

ee/sqlstore/postgressqlstore/provider.go

@@ -15,11 +15,10 @@ import (
 )
 
 type provider struct {
-	settings  factory.ScopedProviderSettings
-	sqldb     *sql.DB
-	bundb     *sqlstore.BunDB
-	dialect   *dialect
-	formatter sqlstore.SQLFormatter
+	settings factory.ScopedProviderSettings
+	sqldb    *sql.DB
+	bundb    *sqlstore.BunDB
+	dialect  *dialect
 }
 
 func NewFactory(hookFactories ...factory.ProviderFactory[sqlstore.SQLStoreHook, sqlstore.Config]) factory.ProviderFactory[sqlstore.SQLStore, sqlstore.Config] {
@@ -56,14 +55,11 @@ func New(ctx context.Context, providerSettings factory.ProviderSettings, config
 
 	sqldb := stdlib.OpenDBFromPool(pool)
 
-	pgDialect := pgdialect.New()
-	bunDB := sqlstore.NewBunDB(settings, sqldb, pgDialect, hooks)
 	return &provider{
-		settings:  settings,
-		sqldb:     sqldb,
-		bundb:     bunDB,
-		dialect:   new(dialect),
-		formatter: newFormatter(bunDB.Dialect()),
+		settings: settings,
+		sqldb:    sqldb,
+		bundb:    sqlstore.NewBunDB(settings, sqldb, pgdialect.New(), hooks),
+		dialect:  new(dialect),
 	}, nil
 }
 
@@ -79,10 +75,6 @@ func (provider *provider) Dialect() sqlstore.SQLDialect {
 	return provider.dialect
 }
 
-func (provider *provider) Formatter() sqlstore.SQLFormatter {
-	return provider.formatter
-}
-
 func (provider *provider) BunDBCtx(ctx context.Context) bun.IDB {
 	return provider.bundb.BunDBCtx(ctx)
 }

frontend/src/api/trace/getSpanPercentiles.ts

@@ -1,28 +0,0 @@
-import { ApiBaseInstance } from 'api';
-import { ErrorResponseHandlerV2 } from 'api/ErrorResponseHandlerV2';
-import { AxiosError } from 'axios';
-import { ErrorV2Resp, SuccessResponseV2 } from 'types/api';
-import {
-	GetSpanPercentilesProps,
-	GetSpanPercentilesResponseDataProps,
-} from 'types/api/trace/getSpanPercentiles';
-
-const getSpanPercentiles = async (
-	props: GetSpanPercentilesProps,
-): Promise<SuccessResponseV2<GetSpanPercentilesResponseDataProps>> => {
-	try {
-		const response = await ApiBaseInstance.post('/span_percentile', {
-			...props,
-		});
-
-		return {
-			httpStatusCode: response.status,
-			data: response.data.data,
-		};
-	} catch (error) {
-		ErrorResponseHandlerV2(error as AxiosError<ErrorV2Resp>);
-		throw error;
-	}
-};
-
-export default getSpanPercentiles;

frontend/src/api/v5/queryRange/getQueryRange.ts

@@ -11,7 +11,7 @@ import {
 export const getQueryRangeV5 = async (
 	props: QueryRangePayloadV5,
 	version: string,
-	signal?: AbortSignal,
+	signal: AbortSignal,
 	headers?: Record<string, string>,
 ): Promise<SuccessResponseV2<MetricRangePayloadV5>> => {
 	try {

frontend/src/components/LogDetail/LogDetails.styles.scss

@@ -132,9 +132,9 @@
 			justify-content: center;
 		}
 
-		.log-detail-drawer__actions {
+		.json-action-btn {
 			display: flex;
-			gap: 4px;
+			gap: 8px;
 		}
 	}
 

frontend/src/components/LogDetail/index.tsx

@@ -319,35 +319,31 @@ function LogDetailInner({
 					</Radio.Button>
 				</Radio.Group>
 
-				<div className="log-detail-drawer__actions">
-					{selectedView === VIEW_TYPES.CONTEXT && (
-						<Tooltip
-							title="Show Filters"
-							placement="topLeft"
-							aria-label="Show Filters"
-						>
-							<Button
-								className="action-btn"
-								icon={<Filter size={16} />}
-								onClick={handleFilterVisible}
-							/>
-						</Tooltip>
-					)}
-
-					<Tooltip
-						title={selectedView === VIEW_TYPES.JSON ? 'Copy JSON' : 'Copy Log Link'}
-						placement="topLeft"
-						aria-label={
-							selectedView === VIEW_TYPES.JSON ? 'Copy JSON' : 'Copy Log Link'
-						}
-					>
+				{selectedView === VIEW_TYPES.JSON && (
+					<div className="json-action-btn">
 						<Button
 							className="action-btn"
 							icon={<Copy size={16} />}
-							onClick={selectedView === VIEW_TYPES.JSON ? handleJSONCopy : onLogCopy}
+							onClick={handleJSONCopy}
 						/>
-					</Tooltip>
-				</div>
+					</div>
+				)}
+
+				{selectedView === VIEW_TYPES.CONTEXT && (
+					<Button
+						className="action-btn"
+						icon={<Filter size={16} />}
+						onClick={handleFilterVisible}
+					/>
+				)}
+
+				<Tooltip title="Copy Log Link" placement="left" aria-label="Copy Log Link">
+					<Button
+						className="action-btn"
+						icon={<Copy size={16} />}
+						onClick={onLogCopy}
+					/>
+				</Tooltip>
 			</div>
 			{isFilterVisible && contextQuery?.builder.queryData[0] && (
 				<div className="log-detail-drawer-query-container">
@@ -387,8 +383,7 @@ function LogDetailInner({
 					podName={log.resources_string?.[RESOURCE_KEYS.POD_NAME] || ''}
 					nodeName={log.resources_string?.[RESOURCE_KEYS.NODE_NAME] || ''}
 					hostName={log.resources_string?.[RESOURCE_KEYS.HOST_NAME] || ''}
-					timestamp={log.timestamp.toString()}
-					dataSource={DataSource.LOGS}
+					logLineTimestamp={log.timestamp.toString()}
 				/>
 			)}
 		</Drawer>

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

@@ -398,7 +398,7 @@
 	}
 
 	.qb-search-container {
-		.metrics-container {
+		.metrics-select-container {
 			margin-bottom: 12px;
 		}
 	}

frontend/src/components/QueryBuilderV2/QueryBuilderV2.tsx

@@ -22,8 +22,6 @@ export const QueryBuilderV2 = memo(function QueryBuilderV2({
 	showOnlyWhereClause = false,
 	showTraceOperator = false,
 	version,
-	onSignalSourceChange,
-	signalSourceChangeEnabled = false,
 }: QueryBuilderProps): JSX.Element {
 	const {
 		currentQuery,
@@ -177,8 +175,6 @@ export const QueryBuilderV2 = memo(function QueryBuilderV2({
 							queryVariant={config?.queryVariant || 'dropdown'}
 							showOnlyWhereClause={showOnlyWhereClause}
 							isListViewPanel={isListViewPanel}
-							onSignalSourceChange={onSignalSourceChange || ((): void => {})}
-							signalSourceChangeEnabled={signalSourceChangeEnabled}
 						/>
 					) : (
 						currentQuery.builder.queryData.map((query, index) => (
@@ -197,9 +193,7 @@ export const QueryBuilderV2 = memo(function QueryBuilderV2({
 								queryVariant={config?.queryVariant || 'dropdown'}
 								showOnlyWhereClause={showOnlyWhereClause}
 								isListViewPanel={isListViewPanel}
-								signalSource={query.source as 'meter' | ''}
-								onSignalSourceChange={onSignalSourceChange || ((): void => {})}
-								signalSourceChangeEnabled={signalSourceChangeEnabled}
+								signalSource={config?.signalSource || ''}
 							/>
 						))
 					)}

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

@@ -1,14 +1,5 @@
-.metrics-source-select-container {
+.metrics-select-container {
 	margin-bottom: 8px;
-	display: flex;
-	flex-direction: row;
-	align-items: flex-start;
-	gap: 8px;
-	width: 100%;
-
-	.source-selector {
-		width: 120px;
-	}
 
 	.ant-select-selector {
 		width: 100%;
@@ -51,7 +42,7 @@
 }
 
 .lightMode {
-	.metrics-source-select-container {
+	.metrics-select-container {
 		.ant-select-selector {
 			border: 1px solid var(--bg-vanilla-300) !important;
 			background: var(--bg-vanilla-100);

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

@@ -1,39 +1,21 @@
 import './MetricsSelect.styles.scss';
 
-import { Select } from 'antd';
-import {
-	initialQueriesMap,
-	initialQueryMeterWithType,
-	PANEL_TYPES,
-} from 'constants/queryBuilder';
 import { AggregatorFilter } from 'container/QueryBuilder/filters';
-import { useQueryBuilder } from 'hooks/queryBuilder/useQueryBuilder';
 import { useQueryOperations } from 'hooks/queryBuilder/useQueryBuilderOperations';
-import { memo, useCallback, useMemo, useState } from 'react';
+import { memo, useCallback, useState } from 'react';
 import { BaseAutocompleteData } from 'types/api/queryBuilder/queryAutocompleteResponse';
 import { IBuilderQuery } from 'types/api/queryBuilder/queryBuilderData';
-import { DataSource } from 'types/common/queryBuilder';
-import { SelectOption } from 'types/common/select';
-
-export const SOURCE_OPTIONS: SelectOption<string, string>[] = [
-	{ value: 'metrics', label: 'Metrics' },
-	{ value: 'meter', label: 'Meter' },
-];
 
 export const MetricsSelect = memo(function MetricsSelect({
 	query,
 	index,
 	version,
 	signalSource,
-	onSignalSourceChange,
-	signalSourceChangeEnabled = false,
 }: {
 	query: IBuilderQuery;
 	index: number;
 	version: string;
 	signalSource: 'meter' | '';
-	onSignalSourceChange: (value: string) => void;
-	signalSourceChangeEnabled: boolean;
 }): JSX.Element {
 	const [attributeKeys, setAttributeKeys] = useState<BaseAutocompleteData[]>([]);
 
@@ -49,67 +31,8 @@ export const MetricsSelect = memo(function MetricsSelect({
 		},
 		[handleChangeAggregatorAttribute, attributeKeys],
 	);
-
-	const { updateAllQueriesOperators, handleSetQueryData } = useQueryBuilder();
-
-	const source = useMemo(
-		() => (signalSource === 'meter' ? 'meter' : 'metrics'),
-		[signalSource],
-	);
-
-	const defaultMeterQuery = useMemo(
-		() =>
-			updateAllQueriesOperators(
-				initialQueryMeterWithType,
-				PANEL_TYPES.BAR,
-				DataSource.METRICS,
-				'meter' as 'meter' | '',
-			),
-		[updateAllQueriesOperators],
-	);
-
-	const defaultMetricsQuery = useMemo(
-		() =>
-			updateAllQueriesOperators(
-				initialQueriesMap.metrics,
-				PANEL_TYPES.BAR,
-				DataSource.METRICS,
-				'',
-			),
-		[updateAllQueriesOperators],
-	);
-
-	const handleSignalSourceChange = (value: string): void => {
-		onSignalSourceChange(value);
-		handleSetQueryData(
-			index,
-			value === 'meter'
-				? {
-						...defaultMeterQuery.builder.queryData[0],
-						source: 'meter',
-						queryName: query.queryName,
-				  }
-				: {
-						...defaultMetricsQuery.builder.queryData[0],
-						source: '',
-						queryName: query.queryName,
-				  },
-		);
-	};
-
 	return (
-		<div className="metrics-source-select-container">
-			{signalSourceChangeEnabled && (
-				<Select
-					className="source-selector"
-					placeholder="Source"
-					options={SOURCE_OPTIONS}
-					value={source}
-					defaultValue="metrics"
-					onChange={handleSignalSourceChange}
-				/>
-			)}
-
+		<div className="metrics-select-container">
 			<AggregatorFilter
 				onChange={handleAggregatorAttributeChange}
 				query={query}

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

@@ -33,13 +33,7 @@ export const QueryV2 = memo(function QueryV2({
 	showOnlyWhereClause = false,
 	signalSource = '',
 	isMultiQueryAllowed = false,
-	onSignalSourceChange,
-	signalSourceChangeEnabled = false,
-}: QueryProps & {
-	ref: React.RefObject<HTMLDivElement>;
-	onSignalSourceChange: (value: string) => void;
-	signalSourceChangeEnabled: boolean;
-}): JSX.Element {
+}: QueryProps & { ref: React.RefObject<HTMLDivElement> }): JSX.Element {
 	const { cloneQuery, panelType } = useQueryBuilder();
 
 	const showFunctions = query?.functions?.length > 0;
@@ -213,14 +207,12 @@ export const QueryV2 = memo(function QueryV2({
 					<div className="qb-elements-container">
 						<div className="qb-search-container">
 							{dataSource === DataSource.METRICS && (
-								<div className="metrics-container">
+								<div className="metrics-select-container">
 									<MetricsSelect
 										query={query}
 										index={index}
 										version={ENTITY_VERSION_V5}
 										signalSource={signalSource as 'meter' | ''}
-										onSignalSourceChange={onSignalSourceChange}
-										signalSourceChangeEnabled={signalSourceChangeEnabled}
 									/>
 								</div>
 							)}
@@ -266,7 +258,7 @@ export const QueryV2 = memo(function QueryV2({
 								panelType={panelType}
 								query={query}
 								index={index}
-								key={`metrics-aggregate-section-${query.queryName}-${query.dataSource}-${signalSource}`}
+								key={`metrics-aggregate-section-${query.queryName}-${query.dataSource}`}
 								version="v4"
 								signalSource={signalSource as 'meter' | ''}
 							/>

frontend/src/constants/dateTimeFormats.ts

@@ -24,7 +24,6 @@ export const DATE_TIME_FORMATS = {
 	TIME_SECONDS: 'HH:mm:ss',
 	TIME_UTC: 'HH:mm:ss (UTC Z)',
 	TIME_UTC_MS: 'HH:mm:ss.SSS (UTC Z)',
-	TIME_SPAN_PERCENTILE: 'HH:mm:ss MMM DD',
 
 	// Short date formats
 	DATE_SHORT: 'MM/DD',

frontend/src/constants/reactQueryKeys.ts

@@ -90,7 +90,4 @@ export const REACT_QUERY_KEY = {
 
 	// Routing Policies Query Keys
 	GET_ROUTING_POLICIES: 'GET_ROUTING_POLICIES',
-
-	// Span Percentiles Query Keys
-	GET_SPAN_PERCENTILES: 'GET_SPAN_PERCENTILES',
 } as const;

frontend/src/constants/userPreferences.ts

@@ -3,5 +3,4 @@ export const USER_PREFERENCES = {
 	NAV_SHORTCUTS: 'nav_shortcuts',
 	LAST_SEEN_CHANGELOG_VERSION: 'last_seen_changelog_version',
 	SPAN_DETAILS_PINNED_ATTRIBUTES: 'span_details_pinned_attributes',
-	SPAN_PERCENTILE_RESOURCE_ATTRIBUTES: 'span_percentile_resource_attributes',
 };

frontend/src/container/ApiMonitoring/Explorer/Domains/DomainDetails/TopErrors.tsx

@@ -1,10 +1,8 @@
 import { LoadingOutlined } from '@ant-design/icons';
 import { Spin, Switch, Table, Tooltip, Typography } from 'antd';
-import { getQueryRangeV5 } from 'api/v5/queryRange/getQueryRange';
-import { MetricRangePayloadV5, ScalarData } from 'api/v5/v5';
 import { useNavigateToExplorer } from 'components/CeleryTask/useNavigateToExplorer';
 import { withErrorBoundary } from 'components/ErrorBoundaryHOC';
-import { ENTITY_VERSION_V4, ENTITY_VERSION_V5 } from 'constants/app';
+import { DEFAULT_ENTITY_VERSION, ENTITY_VERSION_V4 } from 'constants/app';
 import { REACT_QUERY_KEY } from 'constants/reactQueryKeys';
 import {
 	END_POINT_DETAILS_QUERY_KEYS_ARRAY,
@@ -13,12 +11,13 @@ import {
 	getTopErrorsColumnsConfig,
 	getTopErrorsCoRelationQueryFilters,
 	getTopErrorsQueryPayload,
+	TopErrorsResponseRow,
 } from 'container/ApiMonitoring/utils';
 import { GetMetricQueryRange } from 'lib/dashboard/getQueryResults';
 import { Info } from 'lucide-react';
 import { useMemo, useState } from 'react';
-import { QueryFunctionContext, useQueries, useQuery } from 'react-query';
-import { SuccessResponse, SuccessResponseV2 } from 'types/api';
+import { useQueries } from 'react-query';
+import { SuccessResponse } from 'types/api';
 import { MetricRangePayloadProps } from 'types/api/metrics/getQueryRange';
 import { DataTypes } from 'types/api/queryBuilder/queryAutocompleteResponse';
 import { IBuilderQuery } from 'types/api/queryBuilder/queryBuilderData';
@@ -47,7 +46,7 @@ function TopErrors({
 		true,
 	);
 
-	const queryPayload = useMemo(
+	const queryPayloads = useMemo(
 		() =>
 			getTopErrorsQueryPayload(
 				domainName,
@@ -83,34 +82,37 @@ function TopErrors({
 		],
 	);
 
+	const topErrorsDataQueries = useQueries(
+		queryPayloads.map((payload) => ({
+			queryKey: [
+				REACT_QUERY_KEY.GET_TOP_ERRORS_BY_DOMAIN,
+				payload,
+				DEFAULT_ENTITY_VERSION,
+				showStatusCodeErrors,
+			],
+			queryFn: (): Promise<SuccessResponse<MetricRangePayloadProps>> =>
+				GetMetricQueryRange(payload, DEFAULT_ENTITY_VERSION),
+			enabled: !!payload,
+			staleTime: 0,
+			cacheTime: 0,
+		})),
+	);
+
+	const topErrorsDataQuery = topErrorsDataQueries[0];
 	const {
 		data: topErrorsData,
 		isLoading,
 		isRefetching,
 		isError,
 		refetch,
-	} = useQuery({
-		queryKey: [
-			REACT_QUERY_KEY.GET_TOP_ERRORS_BY_DOMAIN,
-			queryPayload,
-			ENTITY_VERSION_V5,
-			showStatusCodeErrors,
-		],
-		queryFn: ({
-			signal,
-		}: QueryFunctionContext): Promise<SuccessResponseV2<MetricRangePayloadV5>> =>
-			getQueryRangeV5(queryPayload, ENTITY_VERSION_V5, signal),
-		enabled: !!queryPayload,
-		staleTime: 0,
-		cacheTime: 0,
-	});
+	} = topErrorsDataQuery;
 
 	const topErrorsColumnsConfig = useMemo(() => getTopErrorsColumnsConfig(), []);
 
 	const formattedTopErrorsData = useMemo(
 		() =>
 			formatTopErrorsDataForTable(
-				topErrorsData?.data?.data?.data?.results[0] as ScalarData,
+				topErrorsData?.payload?.data?.result as TopErrorsResponseRow[],
 			),
 		[topErrorsData],
 	);

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

@@ -8,6 +8,7 @@ import {
 	endPointStatusCodeColumns,
 	extractPortAndEndpoint,
 	formatDataForTable,
+	formatTopErrorsDataForTable,
 	getAllEndpointsWidgetData,
 	getCustomFiltersForBarChart,
 	getEndPointDetailsQueryPayload,
@@ -22,6 +23,8 @@ import {
 	getStatusCodeBarChartWidgetData,
 	getTopErrorsColumnsConfig,
 	getTopErrorsCoRelationQueryFilters,
+	getTopErrorsQueryPayload,
+	TopErrorsResponseRow,
 } from '../utils';
 import { APIMonitoringColumnsMock } from './mock';
 
@@ -341,6 +344,49 @@ describe('API Monitoring Utils', () => {
 		});
 	});
 
+	describe('formatTopErrorsDataForTable', () => {
+		it('should format top errors data correctly', () => {
+			// Arrange
+			const inputData = [
+				{
+					metric: {
+						[SPAN_ATTRIBUTES.URL_PATH]: '/api/test',
+						[SPAN_ATTRIBUTES.RESPONSE_STATUS_CODE]: '500',
+						status_message: 'Internal Server Error',
+					},
+					values: [[1000000100, '10']],
+					queryName: 'A',
+					legend: 'Test Legend',
+				},
+			];
+
+			// Act
+			const result = formatTopErrorsDataForTable(
+				inputData as TopErrorsResponseRow[],
+			);
+
+			// Assert
+			expect(result).toBeDefined();
+			expect(result.length).toBe(1);
+
+			// Check first item is formatted correctly
+			expect(result[0].endpointName).toBe('/api/test');
+			expect(result[0].statusCode).toBe('500');
+			expect(result[0].statusMessage).toBe('Internal Server Error');
+			expect(result[0].count).toBe('10');
+			expect(result[0].key).toBeDefined();
+		});
+
+		it('should handle empty input', () => {
+			// Act
+			const result = formatTopErrorsDataForTable(undefined);
+
+			// Assert
+			expect(result).toBeDefined();
+			expect(result).toEqual([]);
+		});
+	});
+
 	describe('getTopErrorsColumnsConfig', () => {
 		it('should return column configuration with expected fields', () => {
 			// Act
@@ -407,6 +453,72 @@ describe('API Monitoring Utils', () => {
 		});
 	});
 
+	describe('getTopErrorsQueryPayload', () => {
+		it('should create correct query payload with filters', () => {
+			// Arrange
+			const domainName = 'test-domain';
+			const start = 1000000000;
+			const end = 1000010000;
+			const filters = {
+				items: [
+					{
+						id: 'test-filter',
+						key: {
+							dataType: DataTypes.String,
+							key: 'test-key',
+							type: '',
+						},
+						op: '=',
+						value: 'test-value',
+					},
+				],
+				op: 'AND',
+			};
+
+			// Act
+			const result = getTopErrorsQueryPayload(
+				domainName,
+				start,
+				end,
+				filters as IBuilderQuery['filters'],
+			);
+
+			// Assert
+			expect(result).toBeDefined();
+			expect(result.length).toBeGreaterThan(0);
+
+			// Verify query params
+			expect(result[0].start).toBe(start);
+			expect(result[0].end).toBe(end);
+
+			// Verify correct structure
+			expect(result[0].graphType).toBeDefined();
+			expect(result[0].query).toBeDefined();
+			expect(result[0].query.builder).toBeDefined();
+			expect(result[0].query.builder.queryData).toBeDefined();
+
+			// Verify domain filter is included
+			const queryData = result[0].query.builder.queryData[0];
+			expect(queryData.filters).toBeDefined();
+
+			// Check for domain filter
+			const domainFilter = queryData.filters?.items?.find(
+				// eslint-disable-next-line sonarjs/no-identical-functions
+				(item) =>
+					item.key &&
+					item.key.key === SPAN_ATTRIBUTES.SERVER_NAME &&
+					item.value === domainName,
+			);
+			expect(domainFilter).toBeDefined();
+
+			// Check that custom filters were included
+			const testFilter = queryData.filters?.items?.find(
+				(item) => item.id === 'test-filter',
+			);
+			expect(testFilter).toBeDefined();
+		});
+	});
+
 	// Add new tests for EndPointDetails utility functions
 	describe('extractPortAndEndpoint', () => {
 		it('should extract port and endpoint from a valid URL', () => {

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

@@ -1,6 +1,14 @@
+import { fireEvent, render, screen, within } from '@testing-library/react';
 import { useNavigateToExplorer } from 'components/CeleryTask/useNavigateToExplorer';
-import { rest, server } from 'mocks-server/server';
-import { fireEvent, render, screen, waitFor, within } from 'tests/test-utils';
+import { REACT_QUERY_KEY } from 'constants/reactQueryKeys';
+import {
+	formatTopErrorsDataForTable,
+	getEndPointDetailsQueryPayload,
+	getTopErrorsColumnsConfig,
+	getTopErrorsCoRelationQueryFilters,
+	getTopErrorsQueryPayload,
+} from 'container/ApiMonitoring/utils';
+import { useQueries } from 'react-query';
 import { DataSource } from 'types/common/queryBuilder';
 
 import TopErrors from '../Explorer/Domains/DomainDetails/TopErrors';
@@ -27,15 +35,28 @@ jest.mock(
 	}),
 );
 
+// Mock dependencies
+jest.mock('react-query', () => ({
+	...jest.requireActual('react-query'),
+	useQueries: jest.fn(),
+}));
+
 jest.mock('components/CeleryTask/useNavigateToExplorer', () => ({
 	useNavigateToExplorer: jest.fn(),
 }));
 
-describe('TopErrors', () => {
-	const TABLE_BODY_SELECTOR = '.ant-table-tbody';
-	const V5_QUERY_RANGE_API_PATH = '*/api/v5/query_range';
+jest.mock('container/ApiMonitoring/utils', () => ({
+	END_POINT_DETAILS_QUERY_KEYS_ARRAY: ['key1', 'key2', 'key3', 'key4', 'key5'],
+	formatTopErrorsDataForTable: jest.fn(),
+	getEndPointDetailsQueryPayload: jest.fn(),
+	getTopErrorsColumnsConfig: jest.fn(),
+	getTopErrorsCoRelationQueryFilters: jest.fn(),
+	getTopErrorsQueryPayload: jest.fn(),
+}));
 
+describe('TopErrors', () => {
 	const mockProps = {
+		// eslint-disable-next-line sonarjs/no-duplicate-string
 		domainName: 'test-domain',
 		timeRange: {
 			startTime: 1000000000,
@@ -47,72 +68,75 @@ describe('TopErrors', () => {
 		},
 	};
 
-	// Helper function to wait for table data to load
-	const waitForTableDataToLoad = async (
-		container: HTMLElement,
-	): Promise<void> => {
-		await waitFor(() => {
-			const tableBody = container.querySelector(TABLE_BODY_SELECTOR);
-			expect(tableBody).not.toBeNull();
-			if (tableBody) {
-				expect(
-					within(tableBody as HTMLElement).queryByText('/api/test'),
-				).toBeInTheDocument();
-			}
-		});
-	};
-
+	// Setup basic mocks
 	beforeEach(() => {
 		jest.clearAllMocks();
 
-		// Mock useNavigateToExplorer
-		(useNavigateToExplorer as jest.Mock).mockReturnValue(jest.fn());
+		// Mock getTopErrorsColumnsConfig
+		(getTopErrorsColumnsConfig as jest.Mock).mockReturnValue([
+			{
+				title: 'Endpoint',
+				dataIndex: 'endpointName',
+				key: 'endpointName',
+			},
+			{
+				title: 'Status Code',
+				dataIndex: 'statusCode',
+				key: 'statusCode',
+			},
+			{
+				title: 'Status Message',
+				dataIndex: 'statusMessage',
+				key: 'statusMessage',
+			},
+			{
+				title: 'Count',
+				dataIndex: 'count',
+				key: 'count',
+			},
+		]);
 
-		// Mock V5 API endpoint for top errors
-		server.use(
-			rest.post(V5_QUERY_RANGE_API_PATH, (_req, res, ctx) =>
-				res(
-					ctx.status(200),
-					ctx.json({
+		// Mock useQueries
+		(useQueries as jest.Mock).mockImplementation((queryConfigs) => {
+			// For topErrorsDataQueries
+			if (
+				queryConfigs.length === 1 &&
+				queryConfigs[0].queryKey &&
+				queryConfigs[0].queryKey[0] === REACT_QUERY_KEY.GET_TOP_ERRORS_BY_DOMAIN
+			) {
+				return [
+					{
 						data: {
-							data: {
-								results: [
-									{
-										columns: [
-											{
-												name: 'http.url',
-												fieldDataType: 'string',
-												fieldContext: 'attribute',
+							payload: {
+								data: {
+									result: [
+										{
+											metric: {
+												'http.url': '/api/test',
+												status_code: '500',
+												// eslint-disable-next-line sonarjs/no-duplicate-string
+												status_message: 'Internal Server Error',
 											},
-											{
-												name: 'response_status_code',
-												fieldDataType: 'string',
-												fieldContext: 'span',
-											},
-											{
-												name: 'status_message',
-												fieldDataType: 'string',
-												fieldContext: 'span',
-											},
-											{ name: 'count()', fieldDataType: 'int64', fieldContext: '' },
-										],
-										// eslint-disable-next-line sonarjs/no-duplicate-string
-										data: [['/api/test', '500', 'Internal Server Error', 10]],
-									},
-								],
+											values: [[1000000100, '10']],
+											queryName: 'A',
+											legend: 'Test Legend',
+										},
+									],
+								},
 							},
 						},
-					}),
-				),
-			),
-		);
+						isLoading: false,
+						isRefetching: false,
+						isError: false,
+						refetch: jest.fn(),
+					},
+				];
+			}
 
-		// Mock V4 API endpoint for dropdown data
-		server.use(
-			rest.post('*/api/v1/query_range', (_req, res, ctx) =>
-				res(
-					ctx.status(200),
-					ctx.json({
+			// For endPointDropDownDataQueries
+			return [
+				{
+					data: {
 						payload: {
 							data: {
 								result: [
@@ -129,13 +153,62 @@ describe('TopErrors', () => {
 								],
 							},
 						},
-					}),
-				),
-			),
-		);
+					},
+					isLoading: false,
+					isRefetching: false,
+					isError: false,
+				},
+			];
+		});
+
+		// Mock formatTopErrorsDataForTable
+		(formatTopErrorsDataForTable as jest.Mock).mockReturnValue([
+			{
+				key: '1',
+				endpointName: '/api/test',
+				statusCode: '500',
+				statusMessage: 'Internal Server Error',
+				count: 10,
+			},
+		]);
+
+		// Mock getTopErrorsQueryPayload
+		(getTopErrorsQueryPayload as jest.Mock).mockReturnValue([
+			{
+				queryName: 'TopErrorsQuery',
+				start: mockProps.timeRange.startTime,
+				end: mockProps.timeRange.endTime,
+				step: 60,
+			},
+		]);
+
+		// Mock getEndPointDetailsQueryPayload
+		(getEndPointDetailsQueryPayload as jest.Mock).mockReturnValue([
+			{},
+			{},
+			{
+				queryName: 'EndpointDropdownQuery',
+				start: mockProps.timeRange.startTime,
+				end: mockProps.timeRange.endTime,
+				step: 60,
+			},
+		]);
+
+		// Mock useNavigateToExplorer
+		(useNavigateToExplorer as jest.Mock).mockReturnValue(jest.fn());
+
+		// Mock getTopErrorsCoRelationQueryFilters
+		(getTopErrorsCoRelationQueryFilters as jest.Mock).mockReturnValue({
+			items: [
+				{ id: 'test1', key: { key: 'domain' }, op: '=', value: 'test-domain' },
+				{ id: 'test2', key: { key: 'endpoint' }, op: '=', value: '/api/test' },
+				{ id: 'test3', key: { key: 'status' }, op: '=', value: '500' },
+			],
+			op: 'AND',
+		});
 	});
 
-	it('renders component correctly', async () => {
+	it('renders component correctly', () => {
 		// eslint-disable-next-line react/jsx-props-no-spreading
 		const { container } = render(<TopErrors {...mockProps} />);
 
@@ -143,11 +216,10 @@ describe('TopErrors', () => {
 		expect(screen.getByText('Errors with Status Message')).toBeInTheDocument();
 		expect(screen.getByText('Status Message Exists')).toBeInTheDocument();
 
-		// Wait for data to load
-		await waitForTableDataToLoad(container);
-
 		// Find the table row and verify content
-		const tableBody = container.querySelector(TABLE_BODY_SELECTOR);
+		const tableBody = container.querySelector('.ant-table-tbody');
+		expect(tableBody).not.toBeNull();
+
 		if (tableBody) {
 			const row = within(tableBody as HTMLElement).getByRole('row');
 			expect(within(row).getByText('/api/test')).toBeInTheDocument();
@@ -156,40 +228,35 @@ describe('TopErrors', () => {
 		}
 	});
 
-	it('renders error state when API fails', async () => {
-		// Mock API to return error
-		server.use(
-			rest.post(V5_QUERY_RANGE_API_PATH, (_req, res, ctx) =>
-				res(ctx.status(500), ctx.json({ error: 'Internal Server Error' })),
-			),
-		);
+	it('renders error state when isError is true', () => {
+		// Mock useQueries to return isError: true
+		(useQueries as jest.Mock).mockImplementationOnce(() => [
+			{
+				isError: true,
+				refetch: jest.fn(),
+			},
+		]);
 
 		// eslint-disable-next-line react/jsx-props-no-spreading
 		render(<TopErrors {...mockProps} />);
 
-		// Wait for error state
-		await waitFor(() => {
-			expect(
-				screen.getByText('Uh-oh :/ We ran into an error.'),
-			).toBeInTheDocument();
-		});
-
+		// Error state should be shown with the actual text displayed in the UI
+		expect(
+			screen.getByText('Uh-oh :/ We ran into an error.'),
+		).toBeInTheDocument();
 		expect(screen.getByText('Please refresh this panel.')).toBeInTheDocument();
 		expect(screen.getByText('Refresh this panel')).toBeInTheDocument();
 	});
 
-	it('handles row click correctly', async () => {
+	it('handles row click correctly', () => {
 		const navigateMock = jest.fn();
 		(useNavigateToExplorer as jest.Mock).mockReturnValue(navigateMock);
 
 		// eslint-disable-next-line react/jsx-props-no-spreading
 		const { container } = render(<TopErrors {...mockProps} />);
 
-		// Wait for data to load
-		await waitForTableDataToLoad(container);
-
 		// Find and click on the table cell containing the endpoint
-		const tableBody = container.querySelector(TABLE_BODY_SELECTOR);
+		const tableBody = container.querySelector('.ant-table-tbody');
 		expect(tableBody).not.toBeNull();
 
 		if (tableBody) {
@@ -200,28 +267,11 @@ describe('TopErrors', () => {
 
 		// Check if navigateToExplorer was called with correct params
 		expect(navigateMock).toHaveBeenCalledWith({
-			filters: expect.arrayContaining([
-				expect.objectContaining({
-					key: expect.objectContaining({ key: 'http.url' }),
-					op: '=',
-					value: '/api/test',
-				}),
-				expect.objectContaining({
-					key: expect.objectContaining({ key: 'has_error' }),
-					op: '=',
-					value: 'true',
-				}),
-				expect.objectContaining({
-					key: expect.objectContaining({ key: 'net.peer.name' }),
-					op: '=',
-					value: 'test-domain',
-				}),
-				expect.objectContaining({
-					key: expect.objectContaining({ key: 'response_status_code' }),
-					op: '=',
-					value: '500',
-				}),
-			]),
+			filters: [
+				{ id: 'test1', key: { key: 'domain' }, op: '=', value: 'test-domain' },
+				{ id: 'test2', key: { key: 'endpoint' }, op: '=', value: '/api/test' },
+				{ id: 'test3', key: { key: 'status' }, op: '=', value: '500' },
+			],
 			dataSource: DataSource.TRACES,
 			startTime: mockProps.timeRange.startTime,
 			endTime: mockProps.timeRange.endTime,
@@ -229,34 +279,24 @@ describe('TopErrors', () => {
 		});
 	});
 
-	it('updates endpoint filter when dropdown value changes', async () => {
+	it('updates endpoint filter when dropdown value changes', () => {
 		// eslint-disable-next-line react/jsx-props-no-spreading
 		render(<TopErrors {...mockProps} />);
 
-		// Wait for initial load
-		await waitFor(() => {
-			expect(screen.getByRole('combobox')).toBeInTheDocument();
-		});
-
 		// Find the dropdown
 		const dropdown = screen.getByRole('combobox');
 
 		// Mock the change
 		fireEvent.change(dropdown, { target: { value: '/api/new-endpoint' } });
 
-		// Component should re-render with new filter
-		expect(dropdown).toBeInTheDocument();
+		// Check if getTopErrorsQueryPayload was called with updated parameters
+		expect(getTopErrorsQueryPayload).toHaveBeenCalled();
 	});
 
-	it('handles status message toggle correctly', async () => {
+	it('handles status message toggle correctly', () => {
 		// eslint-disable-next-line react/jsx-props-no-spreading
 		render(<TopErrors {...mockProps} />);
 
-		// Wait for initial load
-		await waitFor(() => {
-			expect(screen.getByRole('switch')).toBeInTheDocument();
-		});
-
 		// Find the toggle switch
 		const toggle = screen.getByRole('switch');
 		expect(toggle).toBeInTheDocument();
@@ -267,104 +307,69 @@ describe('TopErrors', () => {
 		// Click the toggle to turn it off
 		fireEvent.click(toggle);
 
+		// Check if getTopErrorsQueryPayload was called with showStatusCodeErrors=false
+		expect(getTopErrorsQueryPayload).toHaveBeenCalledWith(
+			mockProps.domainName,
+			mockProps.timeRange.startTime,
+			mockProps.timeRange.endTime,
+			expect.any(Object),
+			false,
+		);
+
 		// Title should change
-		await waitFor(() => {
-			expect(screen.getByText('All Errors')).toBeInTheDocument();
-		});
+		expect(screen.getByText('All Errors')).toBeInTheDocument();
 
 		// Click the toggle to turn it back on
 		fireEvent.click(toggle);
 
+		// Check if getTopErrorsQueryPayload was called with showStatusCodeErrors=true
+		expect(getTopErrorsQueryPayload).toHaveBeenCalledWith(
+			mockProps.domainName,
+			mockProps.timeRange.startTime,
+			mockProps.timeRange.endTime,
+			expect.any(Object),
+			true,
+		);
+
 		// Title should change back
-		await waitFor(() => {
-			expect(screen.getByText('Errors with Status Message')).toBeInTheDocument();
-		});
+		expect(screen.getByText('Errors with Status Message')).toBeInTheDocument();
 	});
 
-	it('includes toggle state in query key for cache busting', async () => {
+	it('includes toggle state in query key for cache busting', () => {
 		// eslint-disable-next-line react/jsx-props-no-spreading
 		render(<TopErrors {...mockProps} />);
 
-		// Wait for initial load
-		await waitFor(() => {
-			expect(screen.getByRole('switch')).toBeInTheDocument();
-		});
-
 		const toggle = screen.getByRole('switch');
 
+		// Initial query should include showStatusCodeErrors=true
+		expect(useQueries).toHaveBeenCalledWith(
+			expect.arrayContaining([
+				expect.objectContaining({
+					queryKey: expect.arrayContaining([
+						REACT_QUERY_KEY.GET_TOP_ERRORS_BY_DOMAIN,
+						expect.any(Object),
+						expect.any(String),
+						true,
+					]),
+				}),
+			]),
+		);
+
 		// Click toggle
 		fireEvent.click(toggle);
 
-		// Wait for title to change, indicating query was refetched with new key
-		await waitFor(() => {
-			expect(screen.getByText('All Errors')).toBeInTheDocument();
-		});
-
-		// The fact that data refetches when toggle changes proves the query key includes the toggle state
-		expect(toggle).toBeInTheDocument();
-	});
-
-	it('sends query_range v5 API call with required filters including has_error', async () => {
-		let capturedRequest: any;
-
-		// Override the v5 API mock to capture the request
-		server.use(
-			rest.post(V5_QUERY_RANGE_API_PATH, async (req, res, ctx) => {
-				capturedRequest = await req.json();
-				return res(
-					ctx.status(200),
-					ctx.json({
-						data: {
-							data: {
-								results: [
-									{
-										columns: [
-											{
-												name: 'http.url',
-												fieldDataType: 'string',
-												fieldContext: 'attribute',
-											},
-											{
-												name: 'response_status_code',
-												fieldDataType: 'string',
-												fieldContext: 'span',
-											},
-											{
-												name: 'status_message',
-												fieldDataType: 'string',
-												fieldContext: 'span',
-											},
-											{ name: 'count()', fieldDataType: 'int64', fieldContext: '' },
-										],
-										data: [['/api/test', '500', 'Internal Server Error', 10]],
-									},
-								],
-							},
-						},
-					}),
-				);
-			}),
+		// Query should be called with showStatusCodeErrors=false in key
+		expect(useQueries).toHaveBeenCalledWith(
+			expect.arrayContaining([
+				expect.objectContaining({
+					queryKey: expect.arrayContaining([
+						REACT_QUERY_KEY.GET_TOP_ERRORS_BY_DOMAIN,
+						expect.any(Object),
+						expect.any(String),
+						false,
+					]),
+				}),
+			]),
 		);
-
-		// eslint-disable-next-line react/jsx-props-no-spreading
-		render(<TopErrors {...mockProps} />);
-
-		// Wait for the API call to be made
-		await waitFor(() => {
-			expect(capturedRequest).toBeDefined();
-		});
-
-		// Extract the filter expression from the captured request
-		const filterExpression =
-			capturedRequest.compositeQuery.queries[0].spec.filter.expression;
-
-		// Verify all required filters are present
-		expect(filterExpression).toContain(`kind_string = 'Client'`);
-		expect(filterExpression).toContain(`(http.url EXISTS OR url.full EXISTS)`);
-		expect(filterExpression).toContain(
-			`(net.peer.name = 'test-domain' OR server.address = 'test-domain')`,
-		);
-		expect(filterExpression).toContain(`has_error = true`);
-		expect(filterExpression).toContain(`status_message EXISTS`); // toggle is on by default
 	});
 });

frontend/src/container/ApiMonitoring/utils.tsx

@@ -2,7 +2,6 @@
 import { Color } from '@signozhq/design-tokens';
 import { Progress, Tag, Tooltip } from 'antd';
 import { ColumnType } from 'antd/es/table';
-import { convertFiltersToExpressionWithExistingQuery } from 'components/QueryBuilderV2/utils';
 import {
 	FiltersType,
 	IQuickFiltersConfig,
@@ -28,11 +27,6 @@ import {
 	OrderByPayload,
 	TagFilterItem,
 } from 'types/api/queryBuilder/queryBuilderData';
-import {
-	ColumnDescriptor,
-	QueryRangePayloadV5,
-	ScalarData,
-} from 'types/api/v5/queryRange';
 import { QueryData } from 'types/api/widgets/getQuery';
 import { EQueryType } from 'types/common/dashboard';
 import { DataSource } from 'types/common/queryBuilder';
@@ -46,9 +40,6 @@ import {
 	EndPointsResponseRow,
 } from './types';
 
-export const isEmptyFilterValue = (value: unknown): boolean =>
-	value === '' || value === null || value === undefined || value === 'n/a';
-
 export const ApiMonitoringQuickFiltersConfig: IQuickFiltersConfig[] = [
 	{
 		type: FiltersType.CHECKBOX,
@@ -825,100 +816,153 @@ export const getEndPointsQueryPayload = (
 	];
 };
 
-// eslint-disable-next-line sonarjs/cognitive-complexity
-function buildFilterExpression(
-	domainName: string,
-	filters: IBuilderQuery['filters'],
-	showStatusCodeErrors: boolean,
-): string {
-	const baseFilterParts = [
-		`kind_string = 'Client'`,
-		`(http.url EXISTS OR url.full EXISTS)`,
-		`(net.peer.name = '${domainName}' OR server.address = '${domainName}')`,
-		`has_error = true`,
-	];
-	if (showStatusCodeErrors) {
-		baseFilterParts.push('status_message EXISTS');
-	}
-	const filterExpression = baseFilterParts.join(' AND ');
-	if (!filters) {
-		return filterExpression;
-	}
-	const { filter } = convertFiltersToExpressionWithExistingQuery(
-		filters,
-		filterExpression,
-	);
-	return filter.expression;
-}
-
 export const getTopErrorsQueryPayload = (
 	domainName: string,
 	start: number,
 	end: number,
 	filters: IBuilderQuery['filters'],
 	showStatusCodeErrors = true,
-): QueryRangePayloadV5 => {
-	const filterExpression = buildFilterExpression(
-		domainName,
-		filters,
-		showStatusCodeErrors,
-	);
-
-	return {
-		schemaVersion: 'v1',
-		start,
-		end,
-		requestType: 'scalar',
-		compositeQuery: {
-			queries: [
-				{
-					type: 'builder_query',
-					spec: {
-						name: 'A',
-						signal: 'traces',
-						stepInterval: 60,
+): GetQueryResultsProps[] => [
+	{
+		selectedTime: 'GLOBAL_TIME',
+		graphType: PANEL_TYPES.TABLE,
+		query: {
+			builder: {
+				queryData: [
+					{
+						dataSource: DataSource.TRACES,
+						queryName: 'A',
+						aggregateOperator: 'count',
+						aggregateAttribute: {
+							id: '------false',
+							dataType: DataTypes.String,
+							key: '',
+							type: '',
+						},
+						timeAggregation: 'rate',
+						spaceAggregation: 'sum',
+						functions: [],
+						filters: {
+							op: 'AND',
+							items: [
+								{
+									id: '04da97bd',
+									key: {
+										key: 'kind_string',
+										dataType: DataTypes.String,
+										type: '',
+									},
+									op: '=',
+									value: 'Client',
+								},
+								{
+									id: 'b1af6bdb',
+									key: {
+										key: SPAN_ATTRIBUTES.URL_PATH,
+										dataType: DataTypes.String,
+										type: 'tag',
+									},
+									op: 'exists',
+									value: '',
+								},
+								...(showStatusCodeErrors
+									? [
+											{
+												id: '75d65388',
+												key: {
+													key: 'status_message',
+													dataType: DataTypes.String,
+													type: '',
+												},
+												op: 'exists',
+												value: '',
+											},
+									  ]
+									: []),
+								{
+									id: '4872bf91',
+									key: {
+										key: SPAN_ATTRIBUTES.SERVER_NAME,
+										dataType: DataTypes.String,
+										type: 'tag',
+									},
+									op: '=',
+									value: domainName,
+								},
+								{
+									id: 'ab4c885d',
+									key: {
+										key: 'has_error',
+										dataType: DataTypes.bool,
+										type: '',
+									},
+									op: '=',
+									value: true,
+								},
+								...(filters?.items || []),
+							],
+						},
+						expression: 'A',
 						disabled: false,
-						aggregations: [{ expression: 'count()' }],
-						filter: { expression: filterExpression },
+						stepInterval: 60,
+						having: [],
+						limit: 10,
+						orderBy: [
+							{
+								columnName: 'timestamp',
+								order: 'desc',
+							},
+						],
 						groupBy: [
 							{
-								name: 'http.url',
-								fieldDataType: 'string',
-								fieldContext: 'attribute',
+								key: SPAN_ATTRIBUTES.URL_PATH,
+								dataType: DataTypes.String,
+								type: 'tag',
 							},
 							{
-								name: 'url.full',
-								fieldDataType: 'string',
-								fieldContext: 'attribute',
+								dataType: DataTypes.String,
+								key: 'response_status_code',
+								type: '',
+								id: 'response_status_code--string----true',
 							},
 							{
-								name: 'response_status_code',
-								fieldDataType: 'string',
-								fieldContext: 'span',
-							},
-							{
-								name: 'status_message',
-								fieldDataType: 'string',
-								fieldContext: 'span',
-							},
-						],
-						limit: 10,
-						order: [
-							{
-								key: {
-									name: 'count()',
-								},
-								direction: 'desc',
+								key: 'status_message',
+								dataType: DataTypes.String,
+								type: '',
 							},
 						],
+						legend: '',
+						reduceTo: 'avg',
 					},
+				],
+				queryFormulas: [],
+				queryTraceOperator: [],
+			},
+			clickhouse_sql: [
+				{
+					disabled: false,
+					legend: '',
+					name: 'A',
+					query: '',
 				},
 			],
+			id: '315b15fa-ff0c-442f-89f8-2bf4fb1af2f2',
+			promql: [
+				{
+					disabled: false,
+					legend: '',
+					name: 'A',
+					query: '',
+				},
+			],
+			queryType: EQueryType.QUERY_BUILDER,
 		},
-		formatOptions: { formatTableResultForUI: true, fillGaps: false },
 		variables: {},
-	};
-};
+		start,
+		end,
+		step: 240,
+	},
+];
 
 export interface EndPointsTableRowData {
 	key: string;
@@ -1198,55 +1242,63 @@ export const formatEndPointsDataForTable = (
 	return formattedData;
 };
 
-export type TopErrorsResponseRow = ScalarData;
+export interface TopErrorsResponseRow {
+	metric: {
+		[SPAN_ATTRIBUTES.URL_PATH]: string;
+		[SPAN_ATTRIBUTES.RESPONSE_STATUS_CODE]: string;
+		status_message: string;
+	};
+	values: [number, string][];
+	queryName: string;
+	legend: string;
+}
 
 export interface TopErrorsTableRowData {
 	key: string;
 	endpointName: string;
 	statusCode: string;
 	statusMessage: string;
-	count: string;
-}
-
-/**
- * Returns '-' if value is empty, otherwise returns value as string
- */
-export function getDisplayValue(value: unknown): string {
-	return isEmptyFilterValue(value) ? '-' : String(value);
+	count: number | string;
 }
 
 export const formatTopErrorsDataForTable = (
-	scalarResult: TopErrorsResponseRow | undefined,
+	data: TopErrorsResponseRow[] | undefined,
 ): TopErrorsTableRowData[] => {
-	if (!scalarResult?.data) return [];
+	if (!data) return [];
 
-	const columns = scalarResult.columns || [];
-	const rows = scalarResult.data || [];
-
-	return rows.map((rowData: unknown[]) => {
-		const rowObj: Record<string, unknown> = {};
-		columns.forEach((col: ColumnDescriptor, index: number) => {
-			rowObj[col.name] = rowData[index];
-		});
-
-		return {
-			key: v4(),
-			endpointName: getDisplayValue(
-				rowObj[SPAN_ATTRIBUTES.URL_PATH] || rowObj['url.full'],
-			),
-			statusCode: getDisplayValue(rowObj[SPAN_ATTRIBUTES.RESPONSE_STATUS_CODE]),
-			statusMessage: getDisplayValue(rowObj.status_message),
-			count: getDisplayValue(rowObj.__result_0),
-		};
-	});
+	return data.map((row) => ({
+		key: v4(),
+		endpointName:
+			row.metric[SPAN_ATTRIBUTES.URL_PATH] === 'n/a' ||
+			row.metric[SPAN_ATTRIBUTES.URL_PATH] === undefined
+				? '-'
+				: row.metric[SPAN_ATTRIBUTES.URL_PATH],
+		statusCode:
+			row.metric[SPAN_ATTRIBUTES.RESPONSE_STATUS_CODE] === 'n/a' ||
+			row.metric[SPAN_ATTRIBUTES.RESPONSE_STATUS_CODE] === undefined
+				? '-'
+				: row.metric[SPAN_ATTRIBUTES.RESPONSE_STATUS_CODE],
+		statusMessage:
+			row.metric.status_message === 'n/a' ||
+			row.metric.status_message === undefined
+				? '-'
+				: row.metric.status_message,
+		count:
+			row.values &&
+			row.values[0] &&
+			row.values[0][1] !== undefined &&
+			row.values[0][1] !== 'n/a'
+				? row.values[0][1]
+				: '-',
+	}));
 };
 
 export const getTopErrorsCoRelationQueryFilters = (
 	domainName: string,
 	endPointName: string,
 	statusCode: string,
-): IBuilderQuery['filters'] => {
-	const items: TagFilterItem[] = [
+): IBuilderQuery['filters'] => ({
+	items: [
 		{
 			id: 'ea16470b',
 			key: {
@@ -1278,10 +1330,7 @@ export const getTopErrorsCoRelationQueryFilters = (
 			op: '=',
 			value: domainName,
 		},
-	];
-
-	if (statusCode !== '-') {
-		items.push({
+		{
 			id: 'f6891e27',
 			key: {
 				key: 'response_status_code',
@@ -1291,14 +1340,10 @@ export const getTopErrorsCoRelationQueryFilters = (
 			},
 			op: '=',
 			value: statusCode,
-		});
-	}
-
-	return {
-		items,
-		op: 'AND',
-	};
-};
+		},
+	],
+	op: 'AND',
+});
 
 export const getTopErrorsColumnsConfig = (): ColumnType<TopErrorsTableRowData>[] => [
 	{

frontend/src/container/CreateAlertV2/AlertCondition/AlertThreshold.tsx

@@ -11,14 +11,12 @@ import { v4 } from 'uuid';
 
 import { useCreateAlertState } from '../context';
 import {
-	INITIAL_EVALUATION_WINDOW_STATE,
 	INITIAL_INFO_THRESHOLD,
 	INITIAL_RANDOM_THRESHOLD,
 	INITIAL_WARNING_THRESHOLD,
 	THRESHOLD_MATCH_TYPE_OPTIONS,
 	THRESHOLD_OPERATOR_OPTIONS,
 } from '../context/constants';
-import { AlertThresholdMatchType } from '../context/types';
 import EvaluationSettings from '../EvaluationSettings/EvaluationSettings';
 import ThresholdItem from './ThresholdItem';
 import { AnomalyAndThresholdProps, UpdateThreshold } from './types';
@@ -40,12 +38,12 @@ function AlertThreshold({
 		alertState,
 		thresholdState,
 		setThresholdState,
-		setEvaluationWindow,
 		notificationSettings,
 		setNotificationSettings,
 	} = useCreateAlertState();
 
 	const { currentQuery } = useQueryBuilder();
+
 	const queryNames = getQueryNames(currentQuery);
 
 	useEffect(() => {
@@ -162,54 +160,6 @@ function AlertThreshold({
 		}),
 	);
 
-	const handleSetEvaluationDetailsForMeter = (): void => {
-		setEvaluationWindow({
-			type: 'SET_INITIAL_STATE_FOR_METER',
-		});
-
-		setThresholdState({
-			type: 'SET_MATCH_TYPE',
-			payload: AlertThresholdMatchType.IN_TOTAL,
-		});
-	};
-
-	const handleSelectedQueryChange = (value: string): void => {
-		// loop through currenttQuery and find the query that matches the selected query
-		const query = currentQuery?.builder?.queryData.find(
-			(query) => query.queryName === value,
-		);
-
-		const currentSelectedQuery = currentQuery?.builder?.queryData.find(
-			(query) => query.queryName === thresholdState.selectedQuery,
-		);
-
-		const newSelectedQuerySource = query?.source || '';
-		const currentSelectedQuerySource = currentSelectedQuery?.source || '';
-
-		if (newSelectedQuerySource === currentSelectedQuerySource) {
-			setThresholdState({
-				type: 'SET_SELECTED_QUERY',
-				payload: value,
-			});
-
-			return;
-		}
-
-		if (newSelectedQuerySource === 'meter') {
-			handleSetEvaluationDetailsForMeter();
-		} else {
-			setEvaluationWindow({
-				type: 'SET_INITIAL_STATE',
-				payload: INITIAL_EVALUATION_WINDOW_STATE,
-			});
-		}
-
-		setThresholdState({
-			type: 'SET_SELECTED_QUERY',
-			payload: value,
-		});
-	};
-
 	return (
 		<div
 			className={classNames(
@@ -225,7 +175,12 @@ function AlertThreshold({
 					</Typography.Text>
 					<Select
 						value={thresholdState.selectedQuery}
-						onChange={handleSelectedQueryChange}
+						onChange={(value): void => {
+							setThresholdState({
+								type: 'SET_SELECTED_QUERY',
+								payload: value,
+							});
+						}}
 						style={{ width: 80 }}
 						options={queryNames}
 						data-testid="alert-threshold-query-select"

frontend/src/container/CreateAlertV2/EvaluationSettings/EvaluationSettings.tsx

@@ -10,7 +10,6 @@ import { getEvaluationWindowTypeText, getTimeframeText } from './utils';
 
 function EvaluationSettings(): JSX.Element {
 	const { evaluationWindow, setEvaluationWindow } = useCreateAlertState();
-
 	const [
 		isEvaluationWindowPopoverOpen,
 		setIsEvaluationWindowPopoverOpen,

frontend/src/container/CreateAlertV2/context/index.tsx

@@ -24,11 +24,7 @@ import {
 	INITIAL_EVALUATION_WINDOW_STATE,
 	INITIAL_NOTIFICATION_SETTINGS_STATE,
 } from './constants';
-import {
-	AlertThresholdMatchType,
-	ICreateAlertContextProps,
-	ICreateAlertProviderProps,
-} from './types';
+import { ICreateAlertContextProps, ICreateAlertProviderProps } from './types';
 import {
 	advancedOptionsReducer,
 	alertCreationReducer,
@@ -71,7 +67,6 @@ export function CreateAlertProvider(
 	const { currentQuery, redirectWithQueryBuilderData } = useQueryBuilder();
 	const location = useLocation();
 	const queryParams = new URLSearchParams(location.search);
-	const thresholdsFromURL = queryParams.get(QueryParams.thresholds);
 
 	const [alertType, setAlertType] = useState<AlertTypes>(() => {
 		if (isEditMode) {
@@ -127,28 +122,7 @@ export function CreateAlertProvider(
 		setThresholdState({
 			type: 'RESET',
 		});
-
-		if (thresholdsFromURL) {
-			try {
-				const thresholds = JSON.parse(thresholdsFromURL);
-				setThresholdState({
-					type: 'SET_THRESHOLDS',
-					payload: thresholds,
-				});
-			} catch (error) {
-				console.error('Error parsing thresholds from URL:', error);
-			}
-
-			setEvaluationWindow({
-				type: 'SET_INITIAL_STATE_FOR_METER',
-			});
-
-			setThresholdState({
-				type: 'SET_MATCH_TYPE',
-				payload: AlertThresholdMatchType.IN_TOTAL,
-			});
-		}
-	}, [alertType, thresholdsFromURL]);
+	}, [alertType]);
 
 	useEffect(() => {
 		if (isEditMode && initialAlertState) {

frontend/src/container/CreateAlertV2/context/types.ts

@@ -237,7 +237,6 @@ export type EvaluationWindowAction =
 	  }
 	| { type: 'SET_EVALUATION_CADENCE_MODE'; payload: EvaluationCadenceMode }
 	| { type: 'SET_INITIAL_STATE'; payload: EvaluationWindowState }
-	| { type: 'SET_INITIAL_STATE_FOR_METER' }
 	| { type: 'RESET' };
 
 export type EvaluationCadenceMode = 'default' | 'custom' | 'rrule';

frontend/src/container/CreateAlertV2/context/utils.tsx

@@ -1,5 +1,3 @@
-import { UTC_TIMEZONE } from 'components/CustomTimePicker/timezoneUtils';
-import { UniversalYAxisUnit } from 'components/YAxisUnitSelector/types';
 import { QueryParams } from 'constants/query';
 import {
 	alertDefaults,
@@ -13,7 +11,6 @@ import { AlertDef } from 'types/api/alerts/def';
 import { Query } from 'types/api/queryBuilder/queryBuilderData';
 import { DataSource } from 'types/common/queryBuilder';
 
-import { CumulativeWindowTimeframes } from '../EvaluationSettings/types';
 import {
 	INITIAL_ADVANCED_OPTIONS_STATE,
 	INITIAL_ALERT_STATE,
@@ -213,18 +210,6 @@ export const evaluationWindowReducer = (
 			return INITIAL_EVALUATION_WINDOW_STATE;
 		case 'SET_INITIAL_STATE':
 			return action.payload;
-		case 'SET_INITIAL_STATE_FOR_METER':
-			return {
-				...state,
-				windowType: 'cumulative',
-				timeframe: CumulativeWindowTimeframes.CURRENT_DAY,
-				startingAt: {
-					time: '00:00:00',
-					number: '0',
-					timezone: UTC_TIMEZONE.value,
-					unit: UniversalYAxisUnit.MINUTES,
-				},
-			};
 		default:
 			return state;
 	}

frontend/src/container/FormAlertRules/QuerySection.tsx

@@ -36,7 +36,6 @@ function QuerySection({
 	// init namespace for translations
 	const { t } = useTranslation('alerts');
 	const [currentTab, setCurrentTab] = useState(queryCategory);
-	const [signalSource, setSignalSource] = useState<string>('metrics');
 
 	const handleQueryCategoryChange = (queryType: string): void => {
 		setQueryCategory(queryType as EQueryType);
@@ -49,17 +48,12 @@ function QuerySection({
 
 	const isDarkMode = useIsDarkMode();
 
-	const handleSignalSourceChange = (value: string): void => {
-		setSignalSource(value);
-	};
-
 	const renderMetricUI = (): JSX.Element => (
 		<QueryBuilderV2
 			panelType={panelType}
 			config={{
 				queryVariant: 'static',
 				initialDataSource: ALERTS_DATA_SOURCE_MAP[alertType],
-				signalSource: signalSource === 'meter' ? 'meter' : '',
 			}}
 			showTraceOperator={alertType === AlertTypes.TRACES_BASED_ALERT}
 			showFunctions={
@@ -68,8 +62,6 @@ function QuerySection({
 				alertType === AlertTypes.LOGS_BASED_ALERT
 			}
 			version={alertDef.version || 'v3'}
-			onSignalSourceChange={handleSignalSourceChange}
-			signalSourceChangeEnabled
 		/>
 	);
 

frontend/src/container/GeneralSettings/GeneralSettings.tsx

@@ -137,7 +137,8 @@ function GeneralSettings({
 		if (logsCurrentTTLValues) {
 			setLogsTotalRetentionPeriod(logsCurrentTTLValues.default_ttl_days * 24);
 			setLogsS3RetentionPeriod(
-				logsCurrentTTLValues.cold_storage_ttl_days
+				logsCurrentTTLValues.cold_storage_ttl_days &&
+					logsCurrentTTLValues.cold_storage_ttl_days > 0
 					? logsCurrentTTLValues.cold_storage_ttl_days * 24
 					: null,
 			);

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

@@ -94,9 +94,6 @@ const mockDisksWithoutS3: IDiskType[] = [
 ];
 
 describe('GeneralSettings - S3 Logs Retention', () => {
-	const BUTTON_SELECTOR = 'button[type="button"]';
-	const PRIMARY_BUTTON_CLASS = 'ant-btn-primary';
-
 	beforeEach(() => {
 		jest.clearAllMocks();
 		(setRetentionApiV2 as jest.Mock).mockResolvedValue({
@@ -158,10 +155,10 @@ describe('GeneralSettings - S3 Logs Retention', () => {
 			await user.type(s3Input, '5');
 
 			// Find the save button in the Logs card
-			const buttons = logsCard?.querySelectorAll(BUTTON_SELECTOR);
+			const buttons = logsCard?.querySelectorAll('button[type="button"]');
 			// The primary button should be the save button
 			const saveButton = Array.from(buttons || []).find((btn) =>
-				btn.className.includes(PRIMARY_BUTTON_CLASS),
+				btn.className.includes('ant-btn-primary'),
 			) as HTMLButtonElement;
 
 			expect(saveButton).toBeInTheDocument();
@@ -265,9 +262,9 @@ describe('GeneralSettings - S3 Logs Retention', () => {
 			await user.type(totalInput, '60');
 
 			// Find the save button
-			const buttons = logsCard?.querySelectorAll(BUTTON_SELECTOR);
+			const buttons = logsCard?.querySelectorAll('button[type="button"]');
 			const saveButton = Array.from(buttons || []).find((btn) =>
-				btn.className.includes(PRIMARY_BUTTON_CLASS),
+				btn.className.includes('ant-btn-primary'),
 			) as HTMLButtonElement;
 
 			expect(saveButton).toBeInTheDocument();
@@ -332,59 +329,4 @@ describe('GeneralSettings - S3 Logs Retention', () => {
 			expect(dropdowns?.[1]).toHaveTextContent('Days');
 		});
 	});
-
-	describe('Test 4: Save Button State with S3 Disabled', () => {
-		it('should disable save button when cold_storage_ttl_days is -1 and no changes made', async () => {
-			const user = userEvent.setup({ pointerEventsCheck: 0 });
-
-			render(
-				<GeneralSettings
-					metricsTtlValuesPayload={mockMetricsRetention}
-					tracesTtlValuesPayload={mockTracesRetention}
-					logsTtlValuesPayload={mockLogsRetentionWithoutS3}
-					getAvailableDiskPayload={mockDisksWithS3}
-					metricsTtlValuesRefetch={jest.fn()}
-					tracesTtlValuesRefetch={jest.fn()}
-					logsTtlValuesRefetch={jest.fn()}
-				/>,
-			);
-
-			// Find the Logs card
-			const logsCard = screen.getByText('Logs').closest('.ant-card');
-			expect(logsCard).toBeInTheDocument();
-
-			// Find the save button
-			const buttons = logsCard?.querySelectorAll(BUTTON_SELECTOR);
-			const saveButton = Array.from(buttons || []).find((btn) =>
-				btn.className.includes(PRIMARY_BUTTON_CLASS),
-			) as HTMLButtonElement;
-
-			expect(saveButton).toBeInTheDocument();
-
-			// Verify save button is disabled on initial load (no changes, S3 disabled with -1)
-			expect(saveButton).toBeDisabled();
-
-			// Find the total retention input
-			const inputs = logsCard?.querySelectorAll('input[type="text"]');
-			const totalInput = inputs?.[0] as HTMLInputElement;
-
-			// Change total retention value to trigger button enable
-			await user.clear(totalInput);
-			await user.type(totalInput, '60');
-
-			// Button should now be enabled after change
-			await waitFor(() => {
-				expect(saveButton).not.toBeDisabled();
-			});
-
-			// Revert to original value (30 days displays as 1 Month)
-			await user.clear(totalInput);
-			await user.type(totalInput, '1');
-
-			// Button should be disabled again (back to original state)
-			await waitFor(() => {
-				expect(saveButton).toBeDisabled();
-			});
-		});
-	});
 });

frontend/src/container/GeneralSettings/utils.ts

@@ -46,7 +46,8 @@ export const convertHoursValueToRelevantUnit = (
 	availableUnits?: ITimeUnit[],
 ): ITimeUnitConversion => {
 	const unitsToConsider = availableUnits?.length ? availableUnits : TimeUnits;
-	if (value >= 0) {
+
+	if (value) {
 		for (let idx = unitsToConsider.length - 1; idx >= 0; idx -= 1) {
 			const timeUnit = unitsToConsider[idx];
 			const convertedValue = timeUnit.multiplier * value;
@@ -61,7 +62,7 @@ export const convertHoursValueToRelevantUnit = (
 	}
 
 	// Fallback to the first available unit
-	return { value: -1, timeUnitValue: unitsToConsider[0].value };
+	return { value, timeUnitValue: unitsToConsider[0].value };
 };
 
 export const convertHoursValueToRelevantUnitString = (

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

@@ -324,7 +324,6 @@ function FullView({
 									panelType={selectedPanelType}
 									version={selectedDashboard?.data?.version || 'v3'}
 									isListViewPanel={selectedPanelType === PANEL_TYPES.LIST}
-									signalSourceChangeEnabled
 									// filterConfigs={filterConfigs}
 									// queryComponents={queryComponents}
 								/>

frontend/src/container/Home/Home.styles.scss

@@ -423,7 +423,6 @@
 			display: flex;
 			flex-direction: row;
 			gap: 14px;
-			align-items: flex-start;
 
 			.section-icon {
 				display: flex;
@@ -462,6 +461,7 @@
 			flex-direction: column;
 			gap: 14px;
 
+			width: 150px;
 			justify-content: flex-end;
 
 			.ant-btn {

frontend/src/container/IngestionSettings/IngestionSettings.styles.scss

@@ -418,11 +418,6 @@
 								font-size: 12px;
 								font-weight: 600;
 							}
-
-							.set-alert-btn {
-								cursor: pointer;
-								margin-left: 24px;
-							}
 						}
 					}
 

frontend/src/container/IngestionSettings/MultiIngestionSettings.tsx

@@ -19,7 +19,6 @@ import {
 	TablePaginationConfig,
 	TableProps as AntDTableProps,
 	Tag,
-	Tooltip,
 	Typography,
 } from 'antd';
 import { NotificationInstance } from 'antd/es/notification/interface';
@@ -35,20 +34,15 @@ import { getYAxisFormattedValue } from 'components/Graph/yAxisConfig';
 import Tags from 'components/Tags/Tags';
 import { SOMETHING_WENT_WRONG } from 'constants/api';
 import { DATE_TIME_FORMATS } from 'constants/dateTimeFormats';
-import { QueryParams } from 'constants/query';
-import { initialQueryMeterWithType } from 'constants/queryBuilder';
-import ROUTES from 'constants/routes';
-import { INITIAL_ALERT_THRESHOLD_STATE } from 'container/CreateAlertV2/context/constants';
 import dayjs from 'dayjs';
 import { useGetDeploymentsData } from 'hooks/CustomDomain/useGetDeploymentsData';
 import { useGetAllIngestionsKeys } from 'hooks/IngestionKeys/useGetAllIngestionKeys';
 import useDebouncedFn from 'hooks/useDebouncedFunction';
 import { useGetTenantLicense } from 'hooks/useGetTenantLicense';
 import { useNotifications } from 'hooks/useNotifications';
-import { cloneDeep, isNil, isUndefined } from 'lodash-es';
+import { isNil, isUndefined } from 'lodash-es';
 import {
 	ArrowUpRight,
-	BellPlus,
 	CalendarClock,
 	Check,
 	Copy,
@@ -66,7 +60,6 @@ import { useTimezone } from 'providers/Timezone';
 import { ChangeEvent, useEffect, useState } from 'react';
 import { useTranslation } from 'react-i18next';
 import { useMutation } from 'react-query';
-import { useHistory } from 'react-router-dom';
 import { useCopyToClipboard } from 'react-use';
 import { ErrorResponse } from 'types/api';
 import {
@@ -78,7 +71,6 @@ import {
 	IngestionKeyProps,
 	PaginationProps,
 } from 'types/api/ingestionKeys/types';
-import { MeterAggregateOperator } from 'types/common/queryBuilder';
 import { USER_ROLES } from 'types/roles';
 import { getDaysUntilExpiry } from 'utils/timeUtils';
 
@@ -178,8 +170,6 @@ function MultiIngestionSettings(): JSX.Element {
 
 	const { isEnterpriseSelfHostedUser } = useGetTenantLicense();
 
-	const history = useHistory();
-
 	const [
 		hasCreateLimitForIngestionKeyError,
 		setHasCreateLimitForIngestionKeyError,
@@ -704,68 +694,6 @@ function MultiIngestionSettings(): JSX.Element {
 
 	const { formatTimezoneAdjustedTimestamp } = useTimezone();
 
-	const handleCreateAlert = (
-		APIKey: IngestionKeyProps,
-		signal: LimitProps,
-	): void => {
-		let metricName = '';
-
-		switch (signal.signal) {
-			case 'metrics':
-				metricName = 'signoz.meter.metric.datapoint.count';
-				break;
-			case 'traces':
-				metricName = 'signoz.meter.span.size';
-				break;
-			case 'logs':
-				metricName = 'signoz.meter.log.size';
-				break;
-			default:
-				return;
-		}
-
-		const threshold =
-			signal.signal === 'metrics'
-				? signal.config?.day?.count || 0
-				: signal.config?.day?.size || 0;
-
-		const query = {
-			...initialQueryMeterWithType,
-			builder: {
-				...initialQueryMeterWithType.builder,
-				queryData: [
-					{
-						...initialQueryMeterWithType.builder.queryData[0],
-						aggregations: [
-							{
-								...initialQueryMeterWithType.builder.queryData[0].aggregations?.[0],
-								metricName,
-								timeAggregation: MeterAggregateOperator.INCREASE,
-								spaceAggregation: MeterAggregateOperator.SUM,
-							},
-						],
-						filter: {
-							expression: `signoz.workspace.key.id='${APIKey.id}'`,
-						},
-					},
-				],
-			},
-		};
-
-		const stringifiedQuery = JSON.stringify(query);
-
-		const thresholds = cloneDeep(INITIAL_ALERT_THRESHOLD_STATE.thresholds);
-		thresholds[0].thresholdValue = threshold;
-
-		const URL = `${ROUTES.ALERTS_NEW}?showNewCreateAlertsPage=true&${
-			QueryParams.compositeQuery
-		}=${encodeURIComponent(stringifiedQuery)}&${
-			QueryParams.thresholds
-		}=${encodeURIComponent(JSON.stringify(thresholds))}`;
-
-		history.push(URL);
-	};
-
 	const columns: AntDTableProps<IngestionKeyProps>['columns'] = [
 		{
 			title: 'Ingestion Key',
@@ -1255,27 +1183,6 @@ function MultiIngestionSettings(): JSX.Element {
 																					</>
 																				))}
 																		</div>
-
-																		{((signalCfg.usesSize &&
-																			limit?.config?.day?.size !== undefined) ||
-																			(signalCfg.usesCount &&
-																				limit?.config?.day?.count !== undefined)) && (
-																			<Tooltip
-																				title="Set alert on this limit"
-																				placement="top"
-																				arrow={false}
-																			>
-																				<Button
-																					icon={<BellPlus size={14} color={Color.BG_CHERRY_400} />}
-																					className="set-alert-btn periscope-btn ghost"
-																					type="text"
-																					data-testid={`set-alert-btn-${signalName}`}
-																					onClick={(): void =>
-																						handleCreateAlert(APIKey, limitsDict[signalName])
-																					}
-																				/>
-																			</Tooltip>
-																		)}
 																	</div>
 
 																	{/* SECOND limit usage/limit */}

frontend/src/container/IngestionSettings/__tests__/MultiIngestionSettings.test.tsx

@@ -1,60 +1,10 @@
-import { QueryParams } from 'constants/query';
-import { rest, server } from 'mocks-server/server';
-import { render, screen, userEvent, waitFor } from 'tests/test-utils';
-import { LimitProps } from 'types/api/ingestionKeys/limits/types';
-import {
-	AllIngestionKeyProps,
-	IngestionKeyProps,
-} from 'types/api/ingestionKeys/types';
+import { render, screen } from 'tests/test-utils';
 
 import MultiIngestionSettings from '../MultiIngestionSettings';
 
-// Extend the existing types to include limits with proper structure
-interface TestIngestionKeyProps extends Omit<IngestionKeyProps, 'limits'> {
-	limits?: LimitProps[];
-}
-
-interface TestAllIngestionKeyProps extends Omit<AllIngestionKeyProps, 'data'> {
-	data: TestIngestionKeyProps[];
-}
-
-// Mock useHistory.push to capture navigation URL used by MultiIngestionSettings
-const mockPush = jest.fn() as jest.MockedFunction<(path: string) => void>;
-jest.mock('react-router-dom', () => {
-	// eslint-disable-next-line @typescript-eslint/no-var-requires
-	const actual = jest.requireActual('react-router-dom');
-	return {
-		...actual,
-		useHistory: (): { push: typeof mockPush } => ({ push: mockPush }),
-	};
-});
-
-// Mock deployments data hook to avoid unrelated network calls in this page
-jest.mock(
-	'hooks/CustomDomain/useGetDeploymentsData',
-	(): Record<string, unknown> => ({
-		useGetDeploymentsData: (): {
-			data: undefined;
-			isLoading: boolean;
-			isFetching: boolean;
-			isError: boolean;
-		} => ({
-			data: undefined,
-			isLoading: false,
-			isFetching: false,
-			isError: false,
-		}),
-	}),
-);
-
-const TEST_CREATED_UPDATED = '2024-01-01T00:00:00Z';
-const TEST_EXPIRES_AT = '2030-01-01T00:00:00Z';
-const TEST_WORKSPACE_ID = 'w1';
-const INGESTION_SETTINGS_ROUTE = '/ingestion-settings';
-
 describe('MultiIngestionSettings Page', () => {
 	beforeEach(() => {
-		mockPush.mockClear();
+		render(<MultiIngestionSettings />);
 	});
 
 	afterEach(() => {
@@ -62,10 +12,6 @@ describe('MultiIngestionSettings Page', () => {
 	});
 
 	it('renders MultiIngestionSettings page without crashing', () => {
-		render(<MultiIngestionSettings />, undefined, {
-			initialRoute: INGESTION_SETTINGS_ROUTE,
-		});
-
 		expect(screen.getByText('Ingestion Keys')).toBeInTheDocument();
 
 		expect(
@@ -81,181 +27,4 @@ describe('MultiIngestionSettings Page', () => {
 		expect(aboutKeyslink).toHaveClass('learn-more');
 		expect(aboutKeyslink).toHaveAttribute('rel', 'noreferrer');
 	});
-
-	it('navigates to create alert with metrics count threshold', async () => {
-		const user = userEvent.setup({ pointerEventsCheck: 0 });
-
-		// Arrange API response with a metrics daily count limit so the alert button is visible
-		const response: TestAllIngestionKeyProps = {
-			status: 'success',
-			data: [
-				{
-					name: 'Key One',
-					expires_at: TEST_EXPIRES_AT,
-					value: 'secret',
-					workspace_id: TEST_WORKSPACE_ID,
-					id: 'k1',
-					created_at: TEST_CREATED_UPDATED,
-					updated_at: TEST_CREATED_UPDATED,
-					tags: [],
-					limits: [
-						{
-							id: 'l1',
-							signal: 'metrics',
-							config: { day: { count: 1000 } },
-						},
-					],
-				},
-			],
-			_pagination: { page: 1, per_page: 10, pages: 1, total: 1 },
-		};
-
-		server.use(
-			rest.get('*/workspaces/me/keys*', (_req, res, ctx) =>
-				res(ctx.status(200), ctx.json(response)),
-			),
-		);
-
-		// Render with initial route to test navigation
-		render(<MultiIngestionSettings />, undefined, {
-			initialRoute: INGESTION_SETTINGS_ROUTE,
-		});
-		// Wait for ingestion key to load and expand the row to show limits
-		await screen.findByText('Key One');
-		const expandButton = screen.getByRole('button', { name: /right Key One/i });
-		await user.click(expandButton);
-
-		// Wait for limits section to render and click metrics alert button by test id
-		await screen.findByText('LIMITS');
-		const metricsAlertBtn = (await screen.findByTestId(
-			'set-alert-btn-metrics',
-		)) as HTMLButtonElement;
-		await user.click(metricsAlertBtn);
-
-		// Wait for navigation to occur
-		await waitFor(() => {
-			expect(mockPush).toHaveBeenCalledTimes(1);
-		});
-
-		// Assert: navigation occurred with correct query parameters
-		const navigationCall = mockPush.mock.calls[0][0] as string;
-
-		// Check URL contains alerts/new route
-		expect(navigationCall).toContain('/alerts/new');
-		expect(navigationCall).toContain('showNewCreateAlertsPage=true');
-
-		// Parse query parameters
-		const urlParams = new URLSearchParams(navigationCall.split('?')[1]);
-
-		const thresholds = JSON.parse(urlParams.get(QueryParams.thresholds) || '{}');
-		expect(thresholds).toBeDefined();
-		expect(thresholds[0].thresholdValue).toBe(1000);
-
-		// Verify compositeQuery parameter exists and contains correct data
-		const compositeQuery = JSON.parse(
-			urlParams.get(QueryParams.compositeQuery) || '{}',
-		);
-		expect(compositeQuery.builder).toBeDefined();
-		expect(compositeQuery.builder.queryData).toBeDefined();
-
-		// Check that the query contains the correct filter expression for the key
-		const firstQueryData = compositeQuery.builder.queryData[0];
-		expect(firstQueryData.filter.expression).toContain(
-			"signoz.workspace.key.id='k1'",
-		);
-
-		// Verify metric name for metrics signal
-		expect(firstQueryData.aggregations[0].metricName).toBe(
-			'signoz.meter.metric.datapoint.count',
-		);
-	});
-
-	it('navigates to create alert for logs with size threshold', async () => {
-		const user = userEvent.setup({ pointerEventsCheck: 0 });
-
-		// Arrange API response with a logs daily size limit so the alert button is visible
-		const response: TestAllIngestionKeyProps = {
-			status: 'success',
-			data: [
-				{
-					name: 'Key Two',
-					expires_at: TEST_EXPIRES_AT,
-					value: 'secret',
-					workspace_id: TEST_WORKSPACE_ID,
-					id: 'k2',
-					created_at: TEST_CREATED_UPDATED,
-					updated_at: TEST_CREATED_UPDATED,
-					tags: [],
-					limits: [
-						{
-							id: 'l2',
-							signal: 'logs',
-							config: { day: { size: 2048 } },
-						},
-					],
-				},
-			],
-			_pagination: { page: 1, per_page: 10, pages: 1, total: 1 },
-		};
-
-		server.use(
-			rest.get('*/workspaces/me/keys*', (_req, res, ctx) =>
-				res(ctx.status(200), ctx.json(response)),
-			),
-		);
-
-		render(<MultiIngestionSettings />, undefined, {
-			initialRoute: INGESTION_SETTINGS_ROUTE,
-		});
-
-		// Wait for ingestion key to load and expand the row to show limits
-		await screen.findByText('Key Two');
-		const expandButton = screen.getByRole('button', { name: /right Key Two/i });
-		await user.click(expandButton);
-
-		// Wait for limits section to render and click logs alert button by test id
-		await screen.findByText('LIMITS');
-		const logsAlertBtn = (await screen.findByTestId(
-			'set-alert-btn-logs',
-		)) as HTMLButtonElement;
-		await user.click(logsAlertBtn);
-
-		// Wait for navigation to occur
-		await waitFor(() => {
-			expect(mockPush).toHaveBeenCalledTimes(1);
-		});
-
-		// Assert: navigation occurred with correct query parameters
-		const navigationCall = mockPush.mock.calls[0][0] as string;
-
-		// Check URL contains alerts/new route
-		expect(navigationCall).toContain('/alerts/new');
-		expect(navigationCall).toContain('showNewCreateAlertsPage=true');
-
-		// Parse query parameters
-		const urlParams = new URLSearchParams(navigationCall.split('?')[1]);
-
-		// Verify thresholds parameter
-		const thresholds = JSON.parse(urlParams.get(QueryParams.thresholds) || '{}');
-		expect(thresholds).toBeDefined();
-		expect(thresholds[0].thresholdValue).toBe(2048);
-
-		// Verify compositeQuery parameter exists and contains correct data
-		const compositeQuery = JSON.parse(
-			urlParams.get(QueryParams.compositeQuery) || '{}',
-		);
-		expect(compositeQuery.builder).toBeDefined();
-		expect(compositeQuery.builder.queryData).toBeDefined();
-
-		// Check that the query contains the correct filter expression for the key
-		const firstQueryData = compositeQuery.builder.queryData[0];
-		expect(firstQueryData.filter.expression).toContain(
-			"signoz.workspace.key.id='k2'",
-		);
-
-		// Verify metric name for logs signal
-		expect(firstQueryData.aggregations[0].metricName).toBe(
-			'signoz.meter.log.size',
-		);
-	});
 });

frontend/src/container/LogDetailedView/InfraMetrics/InfraMetrics.tsx

@@ -1,11 +1,9 @@
 import './InfraMetrics.styles.scss';
 
-import { Empty } from 'antd';
+import { Empty, Radio } from 'antd';
 import { RadioChangeEvent } from 'antd/lib';
-import SignozRadioGroup from 'components/SignozRadioGroup/SignozRadioGroup';
 import { History, Table } from 'lucide-react';
-import { useMemo, useState } from 'react';
-import { DataSource } from 'types/common/queryBuilder';
+import { useState } from 'react';
 
 import { VIEW_TYPES } from './constants';
 import NodeMetrics from './NodeMetrics';
@@ -16,8 +14,7 @@ interface MetricsDataProps {
 	nodeName: string;
 	hostName: string;
 	clusterName: string;
-	timestamp: string;
-	dataSource: DataSource.LOGS | DataSource.TRACES;
+	logLineTimestamp: string;
 }
 
 function InfraMetrics({
@@ -25,56 +22,22 @@ function InfraMetrics({
 	nodeName,
 	hostName,
 	clusterName,
-	timestamp,
-	dataSource = DataSource.LOGS,
+	logLineTimestamp,
 }: MetricsDataProps): JSX.Element {
 	const [selectedView, setSelectedView] = useState<string>(() =>
 		podName ? VIEW_TYPES.POD : VIEW_TYPES.NODE,
 	);
 
-	const viewOptions = useMemo(() => {
-		const options = [
-			{
-				label: (
-					<div className="view-title">
-						<Table size={14} />
-						Node
-					</div>
-				),
-				value: VIEW_TYPES.NODE,
-			},
-		];
-
-		if (podName) {
-			options.push({
-				label: (
-					<div className="view-title">
-						<History size={14} />
-						Pod
-					</div>
-				),
-				value: VIEW_TYPES.POD,
-			});
-		}
-
-		return options;
-	}, [podName]);
-
 	const handleModeChange = (e: RadioChangeEvent): void => {
 		setSelectedView(e.target.value);
 	};
 
 	if (!podName && !nodeName && !hostName) {
-		const emptyStateDescription =
-			dataSource === DataSource.TRACES
-				? 'No data available. Please select a span containing a pod, node, or host attributes to view metrics.'
-				: 'No data available. Please select a valid log line containing a pod, node, or host attributes to view metrics.';
-
 		return (
 			<div className="empty-container">
 				<Empty
 					image={Empty.PRESENTED_IMAGE_SIMPLE}
-					description={emptyStateDescription}
+					description="No data available. Please select a valid log line containing a pod, node, or host attributes to view metrics."
 				/>
 			</div>
 		);
@@ -82,26 +45,46 @@ function InfraMetrics({
 
 	return (
 		<div className="infra-metrics-container">
-			<SignozRadioGroup
-				value={selectedView}
-				onChange={handleModeChange}
+			<Radio.Group
 				className="views-tabs"
-				options={viewOptions}
-			/>
+				onChange={handleModeChange}
+				value={selectedView}
+			>
+				<Radio.Button
+					className={selectedView === VIEW_TYPES.NODE ? 'selected_view tab' : 'tab'}
+					value={VIEW_TYPES.NODE}
+				>
+					<div className="view-title">
+						<Table size={14} />
+						Node
+					</div>
+				</Radio.Button>
+				{podName && (
+					<Radio.Button
+						className={selectedView === VIEW_TYPES.POD ? 'selected_view tab' : 'tab'}
+						value={VIEW_TYPES.POD}
+					>
+						<div className="view-title">
+							<History size={14} />
+							Pod
+						</div>
+					</Radio.Button>
+				)}
+			</Radio.Group>
 			{/* TODO(Rahul): Make a common config driven component for this and other infra metrics components */}
 			{selectedView === VIEW_TYPES.NODE && (
 				<NodeMetrics
 					nodeName={nodeName}
 					clusterName={clusterName}
 					hostName={hostName}
-					timestamp={timestamp}
+					logLineTimestamp={logLineTimestamp}
 				/>
 			)}
 			{selectedView === VIEW_TYPES.POD && podName && (
 				<PodMetrics
 					podName={podName}
 					clusterName={clusterName}
-					timestamp={timestamp}
+					logLineTimestamp={logLineTimestamp}
 				/>
 			)}
 		</div>

frontend/src/container/LogDetailedView/InfraMetrics/NodeMetrics.tsx

@@ -29,15 +29,15 @@ function NodeMetrics({
 	nodeName,
 	clusterName,
 	hostName,
-	timestamp,
+	logLineTimestamp,
 }: {
 	nodeName: string;
 	clusterName: string;
 	hostName: string;
-	timestamp: string;
+	logLineTimestamp: string;
 }): JSX.Element {
 	const { start, end, verticalLineTimestamp } = useMemo(() => {
-		const logTimestamp = dayjs(timestamp);
+		const logTimestamp = dayjs(logLineTimestamp);
 		const now = dayjs();
 		const startTime = logTimestamp.subtract(3, 'hour');
 
@@ -50,7 +50,7 @@ function NodeMetrics({
 			end: endTime.unix(),
 			verticalLineTimestamp: logTimestamp.unix(),
 		};
-	}, [timestamp]);
+	}, [logLineTimestamp]);
 
 	const { featureFlags } = useAppContext();
 	const dotMetricsEnabled =

frontend/src/container/LogDetailedView/InfraMetrics/PodMetrics.tsx

@@ -23,14 +23,14 @@ import { getPodQueryPayload, podWidgetInfo } from './constants';
 function PodMetrics({
 	podName,
 	clusterName,
-	timestamp,
+	logLineTimestamp,
 }: {
 	podName: string;
 	clusterName: string;
-	timestamp: string;
+	logLineTimestamp: string;
 }): JSX.Element {
 	const { start, end, verticalLineTimestamp } = useMemo(() => {
-		const logTimestamp = dayjs(timestamp);
+		const logTimestamp = dayjs(logLineTimestamp);
 		const now = dayjs();
 		const startTime = logTimestamp.subtract(3, 'hour');
 
@@ -43,7 +43,7 @@ function PodMetrics({
 			end: endTime.unix(),
 			verticalLineTimestamp: logTimestamp.unix(),
 		};
-	}, [timestamp]);
+	}, [logLineTimestamp]);
 
 	const legendScrollPositionRef = useRef<{
 		scrollTop: number;

frontend/src/container/MeterExplorer/Explorer/Explorer.tsx

@@ -33,7 +33,6 @@ function Explorer(): JSX.Element {
 		handleRunQuery,
 		stagedQuery,
 		updateAllQueriesOperators,
-		handleSetQueryData,
 		currentQuery,
 	} = useQueryBuilder();
 	const { safeNavigate } = useSafeNavigate();
@@ -51,15 +50,6 @@ function Explorer(): JSX.Element {
 		[updateAllQueriesOperators],
 	);
 
-	useEffect(() => {
-		handleSetQueryData(0, {
-			...initialQueryMeterWithType.builder.queryData[0],
-			source: 'meter',
-		});
-
-		// eslint-disable-next-line react-hooks/exhaustive-deps
-	}, []);
-
 	const exportDefaultQuery = useMemo(
 		() =>
 			updateAllQueriesOperators(

frontend/src/container/MetricsExplorer/Summary/Summary.tsx

@@ -290,6 +290,13 @@ function Summary(): JSX.Element {
 		],
 	);
 
+	console.log({
+		isMetricsListDataEmpty,
+		isMetricsTreeMapDataEmpty,
+		treeMapData,
+		sec: treeMapData?.payload?.data[heatmapView],
+	});
+
 	return (
 		<Sentry.ErrorBoundary fallback={<ErrorBoundaryFallback />}>
 			<div className="metrics-explorer-summary-tab">

frontend/src/container/NewDashboard/DashboardDescription/__tests__/DashboardDescription.test.tsx

@@ -1,4 +1,3 @@
-/* eslint-disable sonarjs/no-identical-functions */
 import { getNonIntegrationDashboardById } from 'mocks-server/__mockdata__/dashboards';
 import { server } from 'mocks-server/server';
 import { rest } from 'msw';
@@ -8,16 +7,6 @@ import { fireEvent, render, screen, waitFor } from 'tests/test-utils';
 
 import DashboardDescription from '..';
 
-interface MockSafeNavigateReturn {
-	safeNavigate: jest.MockedFunction<(url: string) => void>;
-}
-
-const DASHBOARD_TEST_ID = 'dashboard-title';
-const DASHBOARD_TITLE_TEXT = 'thor';
-const DASHBOARD_PATH = '/dashboard/4';
-
-const mockSafeNavigate = jest.fn();
-
 jest.mock('react-router-dom', () => ({
 	...jest.requireActual('react-router-dom'),
 	useLocation: jest.fn(),
@@ -37,24 +26,20 @@ jest.mock(
 );
 
 jest.mock('hooks/useSafeNavigate', () => ({
-	useSafeNavigate: (): MockSafeNavigateReturn => ({
-		safeNavigate: mockSafeNavigate,
+	useSafeNavigate: (): any => ({
+		safeNavigate: jest.fn(),
 	}),
 }));
 
 describe('Dashboard landing page actions header tests', () => {
-	beforeEach(() => {
-		mockSafeNavigate.mockClear();
-	});
-
 	it('unlock dashboard should be disabled for integrations created dashboards', async () => {
 		const mockLocation = {
-			pathname: `${process.env.FRONTEND_API_ENDPOINT}${DASHBOARD_PATH}`,
+			pathname: `${process.env.FRONTEND_API_ENDPOINT}/dashboard/4`,
 			search: '',
 		};
 		(useLocation as jest.Mock).mockReturnValue(mockLocation);
 		const { getByTestId } = render(
-			<MemoryRouter initialEntries={[DASHBOARD_PATH]}>
+			<MemoryRouter initialEntries={['/dashboard/4']}>
 				<DashboardProvider>
 					<DashboardDescription
 						handle={{
@@ -69,9 +54,7 @@ describe('Dashboard landing page actions header tests', () => {
 		);
 
 		await waitFor(() =>
-			expect(getByTestId(DASHBOARD_TEST_ID)).toHaveTextContent(
-				DASHBOARD_TITLE_TEXT,
-			),
+			expect(getByTestId('dashboard-title')).toHaveTextContent('thor'),
 		);
 
 		const dashboardSettingsTrigger = getByTestId('options');
@@ -82,10 +65,9 @@ describe('Dashboard landing page actions header tests', () => {
 
 		await waitFor(() => expect(lockUnlockButton).toBeDisabled());
 	});
-
 	it('unlock dashboard should not be disabled for non integration created dashboards', async () => {
 		const mockLocation = {
-			pathname: `${process.env.FRONTEND_API_ENDPOINT}${DASHBOARD_PATH}`,
+			pathname: `${process.env.FRONTEND_API_ENDPOINT}/dashboard/4`,
 			search: '',
 		};
 		(useLocation as jest.Mock).mockReturnValue(mockLocation);
@@ -95,7 +77,7 @@ describe('Dashboard landing page actions header tests', () => {
 			),
 		);
 		const { getByTestId } = render(
-			<MemoryRouter initialEntries={[DASHBOARD_PATH]}>
+			<MemoryRouter initialEntries={['/dashboard/4']}>
 				<DashboardProvider>
 					<DashboardDescription
 						handle={{
@@ -110,9 +92,7 @@ describe('Dashboard landing page actions header tests', () => {
 		);
 
 		await waitFor(() =>
-			expect(getByTestId(DASHBOARD_TEST_ID)).toHaveTextContent(
-				DASHBOARD_TITLE_TEXT,
-			),
+			expect(getByTestId('dashboard-title')).toHaveTextContent('thor'),
 		);
 
 		const dashboardSettingsTrigger = getByTestId('options');
@@ -123,58 +103,4 @@ describe('Dashboard landing page actions header tests', () => {
 
 		await waitFor(() => expect(lockUnlockButton).not.toBeDisabled());
 	});
-
-	it('should navigate to dashboard list with correct params and exclude variables', async () => {
-		const dashboardUrlWithVariables = `${DASHBOARD_PATH}?variables=%7B%22var1%22%3A%22value1%22%7D&otherParam=test`;
-		const mockLocation = {
-			pathname: DASHBOARD_PATH,
-			search: '?variables=%7B%22var1%22%3A%22value1%22%7D&otherParam=test',
-		};
-
-		(useLocation as jest.Mock).mockReturnValue(mockLocation);
-
-		const { getByText } = render(
-			<MemoryRouter initialEntries={[dashboardUrlWithVariables]}>
-				<DashboardProvider>
-					<DashboardDescription
-						handle={{
-							active: false,
-							enter: (): Promise<void> => Promise.resolve(),
-							exit: (): Promise<void> => Promise.resolve(),
-							node: { current: null },
-						}}
-					/>
-				</DashboardProvider>
-			</MemoryRouter>,
-		);
-
-		await waitFor(() =>
-			expect(screen.getByTestId(DASHBOARD_TEST_ID)).toHaveTextContent(
-				DASHBOARD_TITLE_TEXT,
-			),
-		);
-
-		// Click the dashboard breadcrumb to navigate back to list
-		const dashboardButton = getByText('Dashboard /');
-		fireEvent.click(dashboardButton);
-
-		// Verify navigation was called with correct URL
-		expect(mockSafeNavigate).toHaveBeenCalledWith(
-			'/dashboard?columnKey=updatedAt&order=descend&page=1&search=',
-		);
-
-		// Ensure the URL contains only essential dashboard list params
-		const calledUrl = mockSafeNavigate.mock.calls[0][0] as string;
-		const urlParams = new URLSearchParams(calledUrl.split('?')[1]);
-
-		// Should have essential dashboard list params
-		expect(urlParams.get('columnKey')).toBe('updatedAt');
-		expect(urlParams.get('order')).toBe('descend');
-		expect(urlParams.get('page')).toBe('1');
-		expect(urlParams.get('search')).toBe('');
-
-		// Should NOT have variables or other dashboard-specific params
-		expect(urlParams.has('variables')).toBeFalsy();
-		expect(urlParams.has('relativeTime')).toBeFalsy();
-	});
 });

frontend/src/container/NewDashboard/DashboardDescription/index.tsx

@@ -13,6 +13,7 @@ import {
 } from 'antd';
 import logEvent from 'api/common/logEvent';
 import HeaderRightSection from 'components/HeaderRightSection/HeaderRightSection';
+import { QueryParams } from 'constants/query';
 import { PANEL_GROUP_TYPES, PANEL_TYPES } from 'constants/queryBuilder';
 import ROUTES from 'constants/routes';
 import { DeleteButton } from 'container/ListOfDashboard/TableComponents/DeleteButton';
@@ -21,6 +22,7 @@ import { useUpdateDashboard } from 'hooks/dashboard/useUpdateDashboard';
 import useComponentPermission from 'hooks/useComponentPermission';
 import { useNotifications } from 'hooks/useNotifications';
 import { useSafeNavigate } from 'hooks/useSafeNavigate';
+import useUrlQuery from 'hooks/useUrlQuery';
 import { isEmpty } from 'lodash-es';
 import {
 	Check,
@@ -114,6 +116,8 @@ function DashboardDescription(props: DashboardDescriptionProps): JSX.Element {
 
 	const updateDashboardMutation = useUpdateDashboard();
 
+	const urlQuery = useUrlQuery();
+
 	const { user } = useAppContext();
 	const [editDashboard] = useComponentPermission(['edit_dashboard'], user.role);
 	const [isDashboardSettingsOpen, setIsDashbordSettingsOpen] = useState<boolean>(
@@ -287,13 +291,13 @@ function DashboardDescription(props: DashboardDescriptionProps): JSX.Element {
 	}
 
 	function goToListPage(): void {
-		const urlParams = new URLSearchParams();
-		urlParams.set('columnKey', listSortOrder.columnKey as string);
-		urlParams.set('order', listSortOrder.order as string);
-		urlParams.set('page', listSortOrder.pagination as string);
-		urlParams.set('search', listSortOrder.search as string);
+		urlQuery.set('columnKey', listSortOrder.columnKey as string);
+		urlQuery.set('order', listSortOrder.order as string);
+		urlQuery.set('page', listSortOrder.pagination as string);
+		urlQuery.set('search', listSortOrder.search as string);
+		urlQuery.delete(QueryParams.relativeTime);
 
-		const generatedUrl = `${ROUTES.ALL_DASHBOARD}?${urlParams.toString()}`;
+		const generatedUrl = `${ROUTES.ALL_DASHBOARD}?${urlQuery.toString()}`;
 		safeNavigate(generatedUrl);
 	}
 

frontend/src/container/NewWidget/LeftContainer/QuerySection/index.tsx

@@ -168,7 +168,6 @@ function QuerySection({
 							version={selectedDashboard?.data?.version || 'v3'}
 							isListViewPanel={selectedGraph === PANEL_TYPES.LIST}
 							queryComponents={queryComponents}
-							signalSourceChangeEnabled
 						/>
 					</div>
 				),

frontend/src/container/OnboardingV2Container/AddDataSource/AddDataSource.tsx

@@ -347,7 +347,6 @@ function OnboardingAddDataSource(): JSX.Element {
 			`${ONBOARDING_V3_ANALYTICS_EVENTS_MAP?.BASE}: ${ONBOARDING_V3_ANALYTICS_EVENTS_MAP?.DATA_SOURCE_SEARCHED}`,
 			{
 				searchedDataSource: query,
-				resultCount: filteredDataSources.length,
 			},
 		);
 	}, 300);

frontend/src/container/QueryBuilder/QueryBuilder.interfaces.ts

@@ -35,8 +35,6 @@ export type QueryBuilderProps = {
 	showTraceOperator?: boolean;
 	version: string;
 	onChangeTraceView?: (view: TraceView) => void;
-	onSignalSourceChange?: (value: string) => void;
-	signalSourceChangeEnabled?: boolean;
 };
 
 export enum TraceView {

frontend/src/container/QueryBuilder/filters/AggregatorFilter/AggregatorFilter.tsx

@@ -52,10 +52,6 @@ export const AggregatorFilter = memo(function AggregatorFilter({
 		(query.aggregations?.[0] as MetricAggregation)?.metricName || '',
 	);
 
-	useEffect(() => {
-		setSearchText('');
-	}, [signalSource]);
-
 	const debouncedSearchText = useMemo(() => {
 		// eslint-disable-next-line @typescript-eslint/naming-convention, @typescript-eslint/no-unused-vars
 		const [_, value] = getAutocompleteValueAndType(searchText);
@@ -71,7 +67,6 @@ export const AggregatorFilter = memo(function AggregatorFilter({
 			queryAggregation.timeAggregation,
 			query.dataSource,
 			index,
-			signalSource,
 		],
 		async () =>
 			getAggregateAttribute({
@@ -105,7 +100,6 @@ export const AggregatorFilter = memo(function AggregatorFilter({
 				setOptionsData(options);
 				setAttributeKeys?.(data?.payload?.attributeKeys || []);
 			},
-			keepPreviousData: false,
 		},
 	);
 
@@ -170,11 +164,8 @@ export const AggregatorFilter = memo(function AggregatorFilter({
 				queryAggregation.timeAggregation,
 				query.dataSource,
 				index,
-				signalSource,
 			])?.payload?.attributeKeys || [];
-
 		setAttributeKeys?.(attributeKeys);
-
 		return attributeKeys;
 	}, [
 		debouncedValue,
@@ -182,7 +173,6 @@ export const AggregatorFilter = memo(function AggregatorFilter({
 		query.dataSource,
 		queryClient,
 		index,
-		signalSource,
 		setAttributeKeys,
 	]);
 

frontend/src/container/SideNav/menuItems.tsx

@@ -271,7 +271,7 @@ export const defaultMoreMenuItems: SidebarItem[] = [
 		icon: <ChartArea size={16} />,
 		isNew: false,
 		isEnabled: true,
-		isBeta: false,
+		isBeta: true,
 		itemKey: 'meter-explorer',
 	},
 	{

frontend/src/container/SpanDetailsDrawer/SpanDetailsDrawer.styles.scss

@@ -55,353 +55,6 @@
 			flex-direction: column;
 			gap: 8px;
 
-			.span-name-wrapper {
-				display: flex;
-				justify-content: space-between;
-				align-items: center;
-
-				.loading-spinner-container {
-					padding: 4px 8px;
-					line-height: 18px; /* 128.571% */
-					letter-spacing: -0.07px;
-
-					display: inline-flex;
-				}
-
-				.span-percentile-value-container {
-					.span-percentile-value {
-						color: var(--text-sakura-400, #f56c87);
-						font-variant-numeric: lining-nums tabular-nums stacked-fractions
-							slashed-zero;
-						font-feature-settings: 'dlig' on, 'salt' on;
-
-						border-radius: 0 50px 50px 0;
-
-						font-family: Inter;
-						font-size: 14px;
-						font-style: normal;
-						font-weight: 400;
-						min-width: 48px;
-						padding-left: 8px;
-						padding-right: 8px;
-
-						border-left: 1px solid var(--bg-slate-400);
-
-						cursor: pointer;
-
-						display: inline-flex;
-						align-items: center;
-						word-break: normal;
-						gap: 6px;
-					}
-
-					&.span-percentile-value-container-open {
-						.span-percentile-value {
-							border: 1px solid var(--bg-slate-400);
-							background: var(--bg-slate-400);
-						}
-					}
-				}
-			}
-
-			.span-percentiles-container {
-				display: flex;
-				flex-direction: column;
-				position: relative;
-
-				fill: linear-gradient(
-					139deg,
-					rgba(18, 19, 23, 0.32) 0%,
-					rgba(18, 19, 23, 0.36) 98.68%
-				);
-
-				stroke-width: 1px;
-				stroke: var(--bg-slate-500, #161922);
-				filter: drop-shadow(2px 4px 16px rgba(0, 0, 0, 0.2));
-				backdrop-filter: blur(20px);
-				border: 1px solid var(--bg-slate-500);
-				border-radius: 4px;
-
-				.span-percentiles-header {
-					display: flex;
-					align-items: center;
-					justify-content: space-between;
-					gap: 8px;
-					padding: 8px 12px 8px 12px;
-					border-bottom: 1px solid var(--bg-slate-500);
-
-					.span-percentiles-header-text {
-						display: flex;
-						align-items: center;
-						gap: 8px;
-						cursor: pointer;
-					}
-				}
-
-				.span-percentile-content {
-					display: flex;
-					flex-direction: column;
-					gap: 8px;
-					padding: 8px;
-
-					.span-percentile-content-title {
-						.span-percentile-value {
-							color: var(--text-sakura-400, #f56c87);
-							font-variant-numeric: lining-nums tabular-nums stacked-fractions
-								slashed-zero;
-							font-feature-settings: 'dlig' on, 'salt' on;
-						}
-
-						.span-percentile-value-loader {
-							display: inline-flex;
-							align-items: flex-end;
-							justify-content: flex-end;
-							margin-right: 4px;
-							margin-left: 4px;
-							line-height: 18px;
-						}
-					}
-
-					.span-percentile-timerange {
-						width: 100%;
-
-						.span-percentile-timerange-select {
-							width: 100%;
-							margin-top: 8px;
-							margin-bottom: 16px;
-
-							.ant-select-selector {
-								border-radius: 50px;
-								border: 1px solid var(--bg-slate-400, #1d212d);
-								background: var(--bg-slate-500, #161922);
-								color: var(--bg-vanilla-400);
-								font-family: Inter;
-								font-size: 12px;
-								font-style: normal;
-								font-weight: 400;
-								line-height: 20px; /* 142.857% */
-								letter-spacing: 0.28px;
-
-								height: 32px;
-							}
-						}
-					}
-
-					.span-percentile-values-table {
-						.span-percentile-values-table-header-row {
-							display: flex;
-							align-items: center;
-							justify-content: space-between;
-							gap: 8px;
-
-							.span-percentile-values-table-header {
-								color: var(--text-vanilla-400);
-								text-align: right;
-								font-family: Inter;
-								font-size: 11px;
-								font-style: normal;
-								font-weight: 500;
-								line-height: 20px; /* 181.818% */
-								text-transform: uppercase;
-							}
-						}
-
-						.span-percentile-values-table-data-rows {
-							margin-top: 8px;
-							display: flex;
-							flex-direction: column;
-							gap: 4px;
-
-							.span-percentile-values-table-data-rows-skeleton {
-								display: flex;
-								flex-direction: column;
-								gap: 4px;
-
-								.ant-skeleton-title {
-									width: 100% !important;
-									margin-top: 0px !important;
-								}
-
-								.ant-skeleton-paragraph {
-									margin-top: 8px;
-
-									& > li + li {
-										margin-top: 10px;
-										width: 100% !important;
-									}
-								}
-							}
-						}
-
-						.span-percentile-values-table-data-row {
-							display: flex;
-							align-items: center;
-							justify-content: space-between;
-							gap: 12px;
-							padding: 0px 4px;
-
-							.span-percentile-values-table-data-row-key {
-								flex: 0 0 auto;
-								color: var(--text-vanilla-100);
-								text-align: right;
-								font-variant-numeric: lining-nums tabular-nums slashed-zero;
-								font-feature-settings: 'dlig' on, 'salt' on;
-								font-family: Inter;
-								font-size: 12px;
-								font-style: normal;
-								font-weight: 500;
-								line-height: 20px; /* 166.667% */
-							}
-
-							.span-percentile-values-table-data-row-value {
-								color: var(--text-vanilla-400);
-								font-variant-numeric: lining-nums tabular-nums stacked-fractions
-									slashed-zero;
-								font-feature-settings: 'dlig' on, 'salt' on, 'ss02' on;
-								font-family: Inter;
-								font-size: 12px;
-								font-style: normal;
-								font-weight: 400;
-								line-height: 20px; /* 166.667% */
-							}
-
-							.dashed-line {
-								flex: 1;
-								height: 0; /* line only */
-								margin: 0 8px;
-								border-top: 1px dashed var(--bg-slate-300);
-
-								/* Use border image to control dash length & spacing */
-								border-top-width: 1px;
-								border-top-style: solid; /* temporary solid for image */
-								border-image: repeating-linear-gradient(
-										to right,
-										#1d212d 0,
-										#1d212d 10px,
-										transparent 10px,
-										transparent 20px
-									)
-									1 stretch;
-							}
-						}
-
-						.current-span-percentile-row {
-							border-radius: 2px;
-							background: rgba(78, 116, 248, 0.2);
-
-							.span-percentile-values-table-data-row-key {
-								color: var(--text-robin-300);
-							}
-
-							.dashed-line {
-								flex: 1;
-								height: 0; /* line only */
-								margin: 0 8px;
-								border-top: 1px dashed #abbdff;
-
-								/* Use border image to control dash length & spacing */
-								border-top-width: 1px;
-								border-top-style: solid; /* temporary solid for image */
-								border-image: repeating-linear-gradient(
-										to right,
-										#abbdff 0,
-										#abbdff 10px,
-										transparent 10px,
-										transparent 20px
-									)
-									1 stretch;
-							}
-
-							.span-percentile-values-table-data-row-value {
-								color: var(--text-robin-400);
-							}
-						}
-					}
-				}
-
-				.resource-attributes-select-container {
-					overflow: hidden;
-					width: calc(100% + 16px);
-
-					position: absolute;
-					top: 32px;
-					left: -8px;
-					z-index: 1000;
-
-					.resource-attributes-select-container-header {
-						.resource-attributes-select-container-input {
-							border-radius: 0px;
-							border: none !important;
-							box-shadow: none !important;
-							height: 36px;
-
-							border-bottom: 1px solid var(--bg-slate-400) !important;
-						}
-					}
-
-					border-radius: 4px;
-					border: 1px solid var(--bg-slate-400, #1d212d);
-					background: linear-gradient(
-						139deg,
-						rgba(18, 19, 23, 1) 0%,
-						rgba(18, 19, 23, 1) 98.68%
-					);
-					box-shadow: 4px 10px 16px 2px rgba(0, 0, 0, 0.2);
-					backdrop-filter: blur(20px);
-
-					.ant-select {
-						width: 100%;
-					}
-
-					.resource-attributes-items {
-						height: 200px;
-						overflow-y: auto;
-
-						&::-webkit-scrollbar {
-							width: 0.3rem;
-							height: 0.3rem;
-						}
-
-						&::-webkit-scrollbar-track {
-							background: transparent;
-						}
-
-						&::-webkit-scrollbar-thumb {
-							background: var(--bg-slate-300);
-						}
-
-						&::-webkit-scrollbar-thumb:hover {
-							background: var(--bg-slate-200);
-						}
-					}
-
-					.resource-attributes-select-item {
-						display: flex;
-						align-items: center;
-						gap: 8px;
-						padding: 8px 12px 8px 12px;
-
-						.resource-attributes-select-item-checkbox {
-							.ant-checkbox-disabled {
-								background-color: var(--bg-robin-500);
-								color: var(--bg-vanilla-100);
-							}
-
-							.resource-attributes-select-item-value {
-								color: var(--bg-vanilla-100);
-
-								font-family: Inter;
-								font-size: 13px;
-								font-style: normal;
-								font-weight: 400;
-								line-height: 20px; /* 142.857% */
-								letter-spacing: -0.07px;
-							}
-						}
-					}
-				}
-			}
-
 			.attribute-key {
 				color: var(--bg-vanilla-400);
 				font-family: Inter;
@@ -415,6 +68,7 @@
 
 			.value-wrapper {
 				display: flex;
+				padding: 2px 8px;
 				align-items: center;
 				width: fit-content;
 				max-width: 100%;
@@ -423,7 +77,6 @@
 				background: var(--bg-slate-500);
 
 				.attribute-value {
-					padding: 2px 8px;
 					color: var(--bg-vanilla-400);
 					font-family: 'Inter';
 					font-size: 14px;
@@ -547,44 +200,6 @@
 	}
 }
 
-.span-percentile-tooltip {
-	.ant-tooltip-content {
-		width: 300px;
-		max-width: 300px;
-	}
-
-	.span-percentile-tooltip-text {
-		color: var(--text-vanilla-400);
-		font-variant-numeric: lining-nums tabular-nums stacked-fractions ordinal
-			slashed-zero;
-		font-feature-settings: 'dlig' on, 'salt' on;
-		font-family: Inter;
-		font-size: 12px;
-		font-style: normal;
-		font-weight: 400;
-		line-height: 20px; /* 166.667% */
-		letter-spacing: -0.06px;
-
-		.span-percentile-tooltip-text-percentile {
-			color: var(--text-sakura-500);
-			font-variant-numeric: lining-nums tabular-nums stacked-fractions slashed-zero;
-			font-feature-settings: 'dlig' on, 'salt' on;
-			font-family: Inter;
-			font-size: 12px;
-		}
-
-		.span-percentile-tooltip-text-link {
-			color: var(--text-vanilla-400);
-			text-align: right;
-			font-family: Inter;
-			font-size: 12px;
-			font-style: normal;
-			font-weight: 500;
-			line-height: 20px; /* 166.667% */
-		}
-	}
-}
-
 .span-details-drawer-docked {
 	width: 48px;
 	flex: 0 48px !important;
@@ -593,7 +208,6 @@
 		justify-content: center;
 	}
 }
-
 .resizable-handle {
 	box-sizing: border-box;
 	border: 2px solid transparent;
@@ -620,173 +234,6 @@
 
 		.description {
 			.item {
-				.span-name-wrapper {
-					.span-percentile-value-container {
-						&.span-percentile-value-container-open {
-							.span-percentile-value {
-								border: 1px solid var(--bg-vanilla-200);
-								background: var(--bg-vanilla-200);
-							}
-						}
-					}
-
-					.span-percentile-value {
-						color: var(--text-sakura-400, #f56c87);
-						border-left: 1px solid var(--bg-slate-300);
-					}
-				}
-
-				.span-percentiles-container {
-					fill: linear-gradient(
-						139deg,
-						rgba(18, 19, 23, 0.32) 0%,
-						rgba(18, 19, 23, 0.36) 98.68%
-					);
-
-					stroke-width: 1px;
-					stroke: var(--bg-slate-500);
-					filter: drop-shadow(2px 4px 16px rgba(0, 0, 0, 0.2));
-					backdrop-filter: blur(20px);
-					border: 1px solid var(--bg-vanilla-300);
-					border-radius: 4px;
-
-					.span-percentiles-header {
-						border-bottom: 1px solid var(--bg-vanilla-300);
-					}
-
-					.span-percentile-content {
-						.span-percentile-content-title {
-							.span-percentile-value {
-								color: var(--text-sakura-400, #f56c87);
-							}
-						}
-
-						.span-percentile-timerange {
-							.span-percentile-timerange-select {
-								.ant-select-selector {
-									border: 1px solid var(--bg-vanilla-300);
-									background: var(--bg-vanilla-300);
-									color: var(--text-slate-300);
-								}
-							}
-						}
-
-						.span-percentile-values-table {
-							.span-percentile-values-table-header-row {
-								.span-percentile-values-table-header {
-									color: var(--text-vanilla-400);
-								}
-							}
-
-							.span-percentile-values-table-data-row {
-								.span-percentile-values-table-data-row-key {
-									color: var(--text-ink-100);
-								}
-
-								.span-percentile-values-table-data-row-value {
-									color: var(--text-ink-400);
-								}
-
-								.dashed-line {
-									flex: 1;
-									height: 0; /* line only */
-									margin: 0 8px;
-									border-top: 1px dashed var(--bg-slate-300);
-
-									/* Use border image to control dash length & spacing */
-									border-top-width: 1px;
-									border-top-style: solid; /* temporary solid for image */
-									border-image: repeating-linear-gradient(
-											to right,
-											var(--bg-slate-300) 0,
-											var(--bg-slate-300) 10px,
-											transparent 10px,
-											transparent 20px
-										)
-										1 stretch;
-								}
-							}
-
-							.current-span-percentile-row {
-								border-radius: 2px;
-								background: rgba(78, 116, 248, 0.2);
-
-								.span-percentile-values-table-data-row-key {
-									color: var(--text-robin-300, #95acfb);
-								}
-
-								.dashed-line {
-									border-top: 1px dashed #abbdff;
-
-									/* Use border image to control dash length & spacing */
-									border-top-width: 1px;
-									border-top-style: solid; /* temporary solid for image */
-									border-image: repeating-linear-gradient(
-											to right,
-											#abbdff 0,
-											#abbdff 10px,
-											transparent 10px,
-											transparent 20px
-										)
-										1 stretch;
-								}
-
-								.span-percentile-values-table-data-row-value {
-									color: var(--text-robin-400);
-								}
-							}
-						}
-					}
-
-					.resource-attributes-select-container {
-						.resource-attributes-select-container-header {
-							.resource-attributes-select-container-input {
-								border: none !important;
-								box-shadow: none !important;
-								height: 36px;
-
-								border-bottom: 1px solid var(--bg-vanilla-400) !important;
-								background: var(--bg-vanilla-300);
-								color: var(--text-ink-400);
-							}
-						}
-
-						border-radius: 4px;
-						border: 1px solid var(--bg-vanilla-300);
-						background: var(--bg-vanilla-300);
-						box-shadow: 0 3px 6px -4px rgba(0, 0, 0, 0.12),
-							0 6px 16px 0 rgba(0, 0, 0, 0.08), 0 9px 28px 8px rgba(0, 0, 0, 0.05);
-						backdrop-filter: blur(20px);
-
-						.resource-attributes-items {
-							&::-webkit-scrollbar-track {
-								background: transparent;
-							}
-
-							&::-webkit-scrollbar-thumb {
-								background: var(--bg-slate-300);
-							}
-
-							&::-webkit-scrollbar-thumb:hover {
-								background: var(--bg-slate-200);
-							}
-						}
-
-						.resource-attributes-select-item {
-							.resource-attributes-select-item-checkbox {
-								.ant-checkbox-disabled {
-									background-color: var(--bg-robin-500);
-									color: var(--text-ink-100);
-								}
-
-								.resource-attributes-select-item-value {
-									color: var(--text-ink-100);
-								}
-							}
-						}
-					}
-				}
-
 				.attribute-key {
 					color: var(--bg-ink-400);
 				}

frontend/src/container/SpanDetailsDrawer/SpanDetailsDrawer.tsx

@@ -1,54 +1,14 @@
 import './SpanDetailsDrawer.styles.scss';
 
-import {
-	Button,
-	Checkbox,
-	Input,
-	Select,
-	Skeleton,
-	Tabs,
-	TabsProps,
-	Tooltip,
-	Typography,
-} from 'antd';
+import { Button, Tabs, TabsProps, Tooltip, Typography } from 'antd';
 import { RadioChangeEvent } from 'antd/lib';
-import getSpanPercentiles from 'api/trace/getSpanPercentiles';
-import getUserPreference from 'api/v1/user/preferences/name/get';
-import updateUserPreference from 'api/v1/user/preferences/name/update';
 import LogsIcon from 'assets/AlertHistory/LogsIcon';
 import { getYAxisFormattedValue } from 'components/Graph/yAxisConfig';
 import SignozRadioGroup from 'components/SignozRadioGroup/SignozRadioGroup';
-import { DATE_TIME_FORMATS } from 'constants/dateTimeFormats';
-import { REACT_QUERY_KEY } from 'constants/reactQueryKeys';
 import { themeColors } from 'constants/theme';
-import { USER_PREFERENCES } from 'constants/userPreferences';
-import dayjs from 'dayjs';
-import useClickOutside from 'hooks/useClickOutside';
 import { generateColor } from 'lib/uPlotLib/utils/generateColor';
-import {
-	Anvil,
-	BarChart2,
-	Bookmark,
-	Check,
-	ChevronDown,
-	ChevronUp,
-	Link2,
-	Loader2,
-	PanelRight,
-	PlusIcon,
-	Search,
-} from 'lucide-react';
-import { AnimatePresence, motion } from 'motion/react';
-import {
-	Dispatch,
-	SetStateAction,
-	useCallback,
-	useEffect,
-	useMemo,
-	useRef,
-	useState,
-} from 'react';
-import { useMutation, useQuery } from 'react-query';
+import { Anvil, Bookmark, Link2, PanelRight, Search } from 'lucide-react';
+import { Dispatch, SetStateAction, useCallback, useState } from 'react';
 import { Span } from 'types/api/trace/getTraceV2';
 import { formatEpochTimestamp } from 'utils/timeUtils';
 
@@ -57,7 +17,6 @@ import { RelatedSignalsViews } from './constants';
 import Events from './Events/Events';
 import LinkedSpans from './LinkedSpans/LinkedSpans';
 import SpanRelatedSignals from './SpanRelatedSignals/SpanRelatedSignals';
-import { hasInfraMetadata } from './utils';
 
 interface ISpanDetailsDrawerProps {
 	isSpanDetailsDocked: boolean;
@@ -67,45 +26,6 @@ interface ISpanDetailsDrawerProps {
 	traceEndTime: number;
 }
 
-const timerangeOptions = [
-	{
-		label: '1 hour',
-		value: 1,
-	},
-	{
-		label: '2 hours',
-		value: 2,
-	},
-	{
-		label: '3 hours',
-		value: 3,
-	},
-	{
-		label: '6 hours',
-		value: 6,
-	},
-	{
-		label: '12 hours',
-		value: 12,
-	},
-	{
-		label: '24 hours',
-		value: 24,
-	},
-];
-
-interface IResourceAttribute {
-	key: string;
-	value: string;
-	isSelected: boolean;
-}
-
-const DEFAULT_RESOURCE_ATTRIBUTES = {
-	serviceName: 'service.name',
-	name: 'name',
-};
-
-// eslint-disable-next-line sonarjs/cognitive-complexity
 function SpanDetailsDrawer(props: ISpanDetailsDrawerProps): JSX.Element {
 	const {
 		isSpanDetailsDocked,
@@ -119,60 +39,12 @@ function SpanDetailsDrawer(props: ISpanDetailsDrawerProps): JSX.Element {
 	const [shouldAutoFocusSearch, setShouldAutoFocusSearch] = useState<boolean>(
 		false,
 	);
-	const [isSpanPercentilesOpen, setIsSpanPercentilesOpen] = useState<boolean>(
-		false,
-	);
 	const [isRelatedSignalsOpen, setIsRelatedSignalsOpen] = useState<boolean>(
 		false,
 	);
 	const [activeDrawerView, setActiveDrawerView] = useState<RelatedSignalsViews>(
 		RelatedSignalsViews.LOGS,
 	);
-
-	const [selectedTimeRange, setSelectedTimeRange] = useState<number>(1);
-	const [
-		resourceAttributesSearchQuery,
-		setResourceAttributesSearchQuery,
-	] = useState<string>('');
-
-	const [spanPercentileData, setSpanPercentileData] = useState<{
-		percentile: number;
-		description: string;
-		percentiles: Record<string, number>;
-	} | null>(null);
-
-	const [
-		showResourceAttributesSelector,
-		setShowResourceAttributesSelector,
-	] = useState<boolean>(false);
-
-	const [selectedResourceAttributes, setSelectedResourceAttributes] = useState<
-		Record<string, string>
-	>({});
-
-	const [spanResourceAttributes, updateSpanResourceAttributes] = useState<
-		IResourceAttribute[]
-	>([] as IResourceAttribute[]);
-
-	const [initialWaitCompleted, setInitialWaitCompleted] = useState<boolean>(
-		false,
-	);
-
-	const [
-		shouldFetchSpanPercentilesData,
-		setShouldFetchSpanPercentilesData,
-	] = useState<boolean>(false);
-
-	const [
-		shouldUpdateUserPreference,
-		setShouldUpdateUserPreference,
-	] = useState<boolean>(false);
-
-	const handleTimeRangeChange = useCallback((value: number): void => {
-		setShouldFetchSpanPercentilesData(true);
-		setSelectedTimeRange(value);
-	}, []);
-
 	const color = generateColor(
 		selectedSpan?.serviceName || '',
 		themeColors.traceDetailColors,
@@ -188,35 +60,6 @@ function SpanDetailsDrawer(props: ISpanDetailsDrawerProps): JSX.Element {
 		setIsRelatedSignalsOpen(false);
 	}, []);
 
-	const relatedSignalsOptions = useMemo(() => {
-		const baseOptions = [
-			{
-				label: (
-					<div className="view-title">
-						<LogsIcon width={14} height={14} />
-						Logs
-					</div>
-				),
-				value: RelatedSignalsViews.LOGS,
-			},
-		];
-
-		// Only show Infra option if span has infrastructure metadata
-		if (hasInfraMetadata(selectedSpan)) {
-			baseOptions.push({
-				label: (
-					<div className="view-title">
-						<BarChart2 size={14} />
-						Metrics
-					</div>
-				),
-				value: RelatedSignalsViews.INFRA,
-			});
-		}
-
-		return baseOptions;
-	}, [selectedSpan]);
-
 	function getItems(span: Span, startTime: number): TabsProps['items'] {
 		return [
 			{
@@ -280,277 +123,6 @@ function SpanDetailsDrawer(props: ISpanDetailsDrawerProps): JSX.Element {
 		];
 	}
 
-	const resourceAttributesSelectorRef = useRef<HTMLDivElement | null>(null);
-
-	useClickOutside({
-		ref: resourceAttributesSelectorRef,
-		onClickOutside: () => {
-			if (resourceAttributesSelectorRef.current) {
-				setShowResourceAttributesSelector(false);
-			}
-		},
-		eventType: 'mousedown',
-	});
-
-	const spanPercentileTooltipText = useMemo(
-		() => (
-			<div className="span-percentile-tooltip-text">
-				<Typography.Text>
-					This span duration is{' '}
-					<span className="span-percentile-tooltip-text-percentile">
-						p{Math.floor(spanPercentileData?.percentile || 0)}
-					</span>{' '}
-					out of the distribution for this resource evaluated for {selectedTimeRange}{' '}
-					hour(s) since the span start time.
-				</Typography.Text>
-				<br />
-				<br />
-				<Typography.Text className="span-percentile-tooltip-text-link">
-					Click to learn more
-				</Typography.Text>
-			</div>
-		),
-		[spanPercentileData?.percentile, selectedTimeRange],
-	);
-
-	const endTime = useMemo(
-		() => Math.floor(Number(selectedSpan?.timestamp) / 1000) * 1000,
-		[selectedSpan?.timestamp],
-	);
-
-	const startTime = useMemo(
-		() =>
-			dayjs(selectedSpan?.timestamp)
-				.subtract(Number(selectedTimeRange), 'hour')
-				.unix() * 1000,
-		[selectedSpan?.timestamp, selectedTimeRange],
-	);
-
-	const { mutate: updateUserPreferenceMutation } = useMutation(
-		updateUserPreference,
-	);
-
-	// TODO: Span percentile should be eventually moved to context and not fetched on every span change
-	const {
-		data: userSelectedResourceAttributes,
-		isError: isErrorUserSelectedResourceAttributes,
-	} = useQuery({
-		queryFn: () =>
-			getUserPreference({
-				name: USER_PREFERENCES.SPAN_PERCENTILE_RESOURCE_ATTRIBUTES,
-			}),
-		queryKey: [
-			'getUserPreferenceByPreferenceName',
-			USER_PREFERENCES.SPAN_PERCENTILE_RESOURCE_ATTRIBUTES,
-			selectedSpan?.spanId,
-		],
-		enabled: selectedSpan !== null && selectedSpan?.tagMap !== undefined,
-	});
-
-	const {
-		isLoading: isLoadingSpanPercentilesData,
-		isFetching: isFetchingSpanPercentilesData,
-		data,
-		refetch: refetchSpanPercentilesData,
-		isError: isErrorSpanPercentilesData,
-	} = useQuery({
-		queryFn: () =>
-			getSpanPercentiles({
-				start: startTime || 0,
-				end: endTime || 0,
-				spanDuration: selectedSpan?.durationNano || 0,
-				serviceName: selectedSpan?.serviceName || '',
-				name: selectedSpan?.name || '',
-				resourceAttributes: selectedResourceAttributes,
-			}),
-		queryKey: [
-			REACT_QUERY_KEY.GET_SPAN_PERCENTILES,
-			selectedSpan?.spanId,
-			startTime,
-			endTime,
-		],
-		enabled:
-			selectedSpan !== null &&
-			shouldFetchSpanPercentilesData &&
-			!showResourceAttributesSelector &&
-			initialWaitCompleted,
-		onSuccess: (response) => {
-			if (response.httpStatusCode !== 200) {
-				return;
-			}
-
-			if (shouldUpdateUserPreference) {
-				updateUserPreferenceMutation({
-					name: USER_PREFERENCES.SPAN_PERCENTILE_RESOURCE_ATTRIBUTES,
-					value: [...Object.keys(selectedResourceAttributes)],
-				});
-
-				setShouldUpdateUserPreference(false);
-			}
-		},
-		keepPreviousData: false,
-		cacheTime: 0, // no cache
-	});
-
-	// Prod Req - Wait for 2 seconds before fetching span percentile data on initial load
-	useEffect(() => {
-		setSpanPercentileData(null);
-		setIsSpanPercentilesOpen(false);
-		setInitialWaitCompleted(false);
-
-		const timer = setTimeout(() => {
-			setInitialWaitCompleted(true);
-		}, 2000); // 2-second delay
-
-		return (): void => {
-			// clean the old state around span percentile data
-			clearTimeout(timer); // Cleanup on re-run or unmount
-		};
-	}, [selectedSpan?.spanId]);
-
-	useEffect(() => {
-		if (data?.httpStatusCode !== 200) {
-			setSpanPercentileData(null);
-
-			return;
-		}
-
-		if (data) {
-			const percentileData = {
-				percentile: data?.data?.position?.percentile || 0,
-				description: data?.data?.position?.description || '',
-				percentiles: data?.data?.percentiles || {},
-			};
-
-			setSpanPercentileData(percentileData);
-		}
-	}, [data]);
-
-	useEffect(() => {
-		if (userSelectedResourceAttributes) {
-			const userSelectedResourceAttributesList = (userSelectedResourceAttributes
-				?.data?.value as string[]).map((attribute: string) => attribute);
-
-			let selectedResourceAttributesMap: Record<string, string> = {};
-
-			userSelectedResourceAttributesList.forEach((attribute: string) => {
-				selectedResourceAttributesMap[attribute] =
-					selectedSpan?.tagMap?.[attribute] || '';
-			});
-
-			// filter out the attributes that are not in the selectedSpan?.tagMap
-			selectedResourceAttributesMap = Object.fromEntries(
-				Object.entries(selectedResourceAttributesMap).filter(
-					([key]) => selectedSpan?.tagMap?.[key] !== undefined,
-				),
-			);
-
-			const resourceAttributes = Object.entries(selectedSpan?.tagMap || {}).map(
-				([key, value]) => ({
-					key,
-					value,
-					isSelected:
-						key === DEFAULT_RESOURCE_ATTRIBUTES.serviceName ||
-						key === DEFAULT_RESOURCE_ATTRIBUTES.name ||
-						(key in selectedResourceAttributesMap &&
-							selectedResourceAttributesMap[key] !== '' &&
-							selectedResourceAttributesMap[key] !== undefined),
-				}),
-			);
-
-			// selected resources should be at the top of the list
-			const selectedResourceAttributes = resourceAttributes.filter(
-				(resourceAttribute) => resourceAttribute.isSelected,
-			);
-
-			const unselectedResourceAttributes = resourceAttributes.filter(
-				(resourceAttribute) => !resourceAttribute.isSelected,
-			);
-
-			const sortedResourceAttributes = [
-				...selectedResourceAttributes,
-				...unselectedResourceAttributes,
-			];
-
-			updateSpanResourceAttributes(sortedResourceAttributes);
-
-			setSelectedResourceAttributes(
-				selectedResourceAttributesMap as Record<string, string>,
-			);
-
-			setShouldFetchSpanPercentilesData(true);
-		}
-
-		if (isErrorUserSelectedResourceAttributes) {
-			const resourceAttributes = Object.entries(selectedSpan?.tagMap || {}).map(
-				([key, value]) => ({
-					key,
-					value,
-					isSelected:
-						key === DEFAULT_RESOURCE_ATTRIBUTES.serviceName ||
-						key === DEFAULT_RESOURCE_ATTRIBUTES.name,
-				}),
-			);
-
-			updateSpanResourceAttributes(resourceAttributes);
-
-			setShouldFetchSpanPercentilesData(true);
-		}
-	}, [
-		userSelectedResourceAttributes,
-		isErrorUserSelectedResourceAttributes,
-		selectedSpan?.tagMap,
-	]);
-
-	const handleResourceAttributeChange = useCallback(
-		(key: string, value: string, isSelected: boolean): void => {
-			updateSpanResourceAttributes((prev) =>
-				prev.map((resourceAttribute) =>
-					resourceAttribute.key === key
-						? { ...resourceAttribute, isSelected }
-						: resourceAttribute,
-				),
-			);
-
-			const newSelectedResourceAttributes = { ...selectedResourceAttributes };
-
-			if (isSelected) {
-				newSelectedResourceAttributes[key] = value;
-			} else {
-				delete newSelectedResourceAttributes[key];
-			}
-
-			setSelectedResourceAttributes(newSelectedResourceAttributes);
-
-			setShouldFetchSpanPercentilesData(true);
-
-			setShouldUpdateUserPreference(true);
-		},
-		[selectedResourceAttributes],
-	);
-
-	useEffect(() => {
-		if (
-			shouldFetchSpanPercentilesData &&
-			!showResourceAttributesSelector &&
-			initialWaitCompleted
-		) {
-			refetchSpanPercentilesData();
-
-			setShouldFetchSpanPercentilesData(false);
-		}
-		// eslint-disable-next-line react-hooks/exhaustive-deps
-	}, [
-		shouldFetchSpanPercentilesData,
-		showResourceAttributesSelector,
-		initialWaitCompleted,
-	]);
-
-	const loadingSpanPercentilesData =
-		isLoadingSpanPercentilesData || isFetchingSpanPercentilesData;
-
-	const spanPercentileValue = Math.floor(spanPercentileData?.percentile || 0);
-
 	return (
 		<>
 			<section className="header">
@@ -571,244 +143,13 @@ function SpanDetailsDrawer(props: ISpanDetailsDrawerProps): JSX.Element {
 					<section className="description">
 						<div className="item">
 							<Typography.Text className="attribute-key">span name</Typography.Text>
-
-							<div className="value-wrapper span-name-wrapper">
-								<Tooltip title={selectedSpan.name}>
+							<Tooltip title={selectedSpan.name}>
+								<div className="value-wrapper">
 									<Typography.Text className="attribute-value" ellipsis>
 										{selectedSpan.name}
 									</Typography.Text>
-								</Tooltip>
-
-								{loadingSpanPercentilesData && (
-									<div className="loading-spinner-container">
-										<Loader2 size={16} className="animate-spin" />
-									</div>
-								)}
-
-								{!loadingSpanPercentilesData && spanPercentileData && (
-									<Tooltip
-										title={isSpanPercentilesOpen ? '' : spanPercentileTooltipText}
-										placement="bottomRight"
-										overlayClassName="span-percentile-tooltip"
-										arrow={false}
-									>
-										<div
-											className={`span-percentile-value-container ${
-												isSpanPercentilesOpen
-													? 'span-percentile-value-container-open'
-													: 'span-percentile-value-container-closed'
-											}`}
-										>
-											<Typography.Text
-												className="span-percentile-value"
-												onClick={(): void => setIsSpanPercentilesOpen((prev) => !prev)}
-												disabled={loadingSpanPercentilesData}
-											>
-												<span className="span-percentile-value-text">
-													p{spanPercentileValue}
-												</span>
-
-												{!isSpanPercentilesOpen && (
-													<ChevronDown size={16} className="span-percentile-value-icon" />
-												)}
-												{isSpanPercentilesOpen && (
-													<ChevronUp size={16} className="span-percentile-value-icon" />
-												)}
-											</Typography.Text>
-										</div>
-									</Tooltip>
-								)}
-							</div>
-
-							<AnimatePresence initial={false}>
-								{isSpanPercentilesOpen && !isErrorSpanPercentilesData && (
-									<motion.div
-										initial={{ height: 0, opacity: 0 }}
-										animate={{ height: 'auto', opacity: 1 }}
-										exit={{ height: 0, opacity: 0 }}
-										key="box"
-									>
-										<div className="span-percentiles-container">
-											<div className="span-percentiles-header">
-												<Typography.Text
-													className="span-percentiles-header-text"
-													onClick={(): void => setIsSpanPercentilesOpen((prev) => !prev)}
-												>
-													<ChevronDown size={16} /> Span Percentile
-												</Typography.Text>
-
-												{showResourceAttributesSelector ? (
-													<Check
-														data-testid="check-icon"
-														size={16}
-														className="cursor-pointer span-percentiles-header-icon"
-														onClick={(): void => setShowResourceAttributesSelector(false)}
-													/>
-												) : (
-													<PlusIcon
-														data-testid="plus-icon"
-														size={16}
-														className="cursor-pointer span-percentiles-header-icon"
-														onClick={(): void => setShowResourceAttributesSelector(true)}
-													/>
-												)}
-											</div>
-
-											{showResourceAttributesSelector && (
-												<div
-													className="resource-attributes-select-container"
-													ref={resourceAttributesSelectorRef}
-												>
-													<div className="resource-attributes-select-container-header">
-														<Input
-															placeholder="Search resource attributes"
-															className="resource-attributes-select-container-input"
-															value={resourceAttributesSearchQuery}
-															onChange={(e): void =>
-																setResourceAttributesSearchQuery(e.target.value as string)
-															}
-														/>
-													</div>
-
-													<div className="resource-attributes-items">
-														{spanResourceAttributes
-															.filter((resourceAttribute) =>
-																resourceAttribute.key
-																	.toLowerCase()
-																	.includes(resourceAttributesSearchQuery.toLowerCase()),
-															)
-															.map((resourceAttribute) => (
-																<div
-																	className="resource-attributes-select-item"
-																	key={resourceAttribute.key}
-																>
-																	<div className="resource-attributes-select-item-checkbox">
-																		<Checkbox
-																			checked={resourceAttribute.isSelected}
-																			onChange={(e): void => {
-																				handleResourceAttributeChange(
-																					resourceAttribute.key,
-																					resourceAttribute.value,
-																					e.target.checked,
-																				);
-																			}}
-																			disabled={
-																				resourceAttribute.key === 'service.name' ||
-																				resourceAttribute.key === 'name'
-																			}
-																		>
-																			<div className="resource-attributes-select-item-value">
-																				{resourceAttribute.key}
-																			</div>
-																		</Checkbox>
-																	</div>
-																</div>
-															))}
-													</div>
-												</div>
-											)}
-
-											<div className="span-percentile-content">
-												<Typography.Text className="span-percentile-content-title">
-													This span duration is{' '}
-													{!isLoadingSpanPercentilesData &&
-													!isFetchingSpanPercentilesData &&
-													spanPercentileData ? (
-														<span className="span-percentile-value">
-															p{Math.floor(spanPercentileData?.percentile || 0)}
-														</span>
-													) : (
-														<span className="span-percentile-value-loader">
-															<Loader2 size={12} className="animate-spin" />
-														</span>
-													)}{' '}
-													out of the distribution for this resource evaluated for{' '}
-													{selectedTimeRange} hour(s) since the span start time.
-												</Typography.Text>
-
-												<div className="span-percentile-timerange">
-													<Select
-														labelInValue
-														placeholder="Select timerange"
-														className="span-percentile-timerange-select"
-														value={{
-															label: `${selectedTimeRange}h : ${dayjs(selectedSpan?.timestamp)
-																.subtract(selectedTimeRange, 'hour')
-																.format(DATE_TIME_FORMATS.TIME_SPAN_PERCENTILE)} - ${dayjs(
-																selectedSpan?.timestamp,
-															).format(DATE_TIME_FORMATS.TIME_SPAN_PERCENTILE)}`,
-															value: selectedTimeRange,
-														}}
-														onChange={(value): void => {
-															handleTimeRangeChange(Number(value.value));
-														}}
-														options={timerangeOptions}
-													/>
-												</div>
-
-												<div className="span-percentile-values-table">
-													<div className="span-percentile-values-table-header-row">
-														<Typography.Text className="span-percentile-values-table-header">
-															Percentile
-														</Typography.Text>
-
-														<Typography.Text className="span-percentile-values-table-header">
-															Duration
-														</Typography.Text>
-													</div>
-
-													<div className="span-percentile-values-table-data-rows">
-														{isLoadingSpanPercentilesData || isFetchingSpanPercentilesData ? (
-															<Skeleton
-																active
-																paragraph={{ rows: 3 }}
-																className="span-percentile-values-table-data-rows-skeleton"
-															/>
-														) : (
-															<>
-																{Object.entries(spanPercentileData?.percentiles || {}).map(
-																	([percentile, duration]) => (
-																		<div
-																			className="span-percentile-values-table-data-row"
-																			key={percentile}
-																		>
-																			<Typography.Text className="span-percentile-values-table-data-row-key">
-																				{percentile}
-																			</Typography.Text>
-
-																			<div className="dashed-line" />
-
-																			<Typography.Text className="span-percentile-values-table-data-row-value">
-																				{getYAxisFormattedValue(`${duration / 1000000}`, 'ms')}
-																			</Typography.Text>
-																		</div>
-																	),
-																)}
-
-																<div className="span-percentile-values-table-data-row current-span-percentile-row">
-																	<Typography.Text className="span-percentile-values-table-data-row-key">
-																		p{Math.floor(spanPercentileData?.percentile || 0)}
-																	</Typography.Text>
-
-																	<div className="dashed-line" />
-
-																	<Typography.Text className="span-percentile-values-table-data-row-value">
-																		(this span){' '}
-																		{getYAxisFormattedValue(
-																			`${selectedSpan.durationNano / 1000000}`,
-																			'ms',
-																		)}
-																	</Typography.Text>
-																</div>
-															</>
-														)}
-													</div>
-												</div>
-											</div>
-										</div>
-									</motion.div>
-								)}
-							</AnimatePresence>
+								</div>
+							</Tooltip>
 						</div>
 						<div className="item">
 							<Typography.Text className="attribute-key">span id</Typography.Text>
@@ -885,7 +226,17 @@ function SpanDetailsDrawer(props: ISpanDetailsDrawerProps): JSX.Element {
 							<div className="related-signals-section">
 								<SignozRadioGroup
 									value=""
-									options={relatedSignalsOptions}
+									options={[
+										{
+											label: (
+												<div className="view-title">
+													<LogsIcon width={14} height={14} />
+													Logs
+												</div>
+											),
+											value: RelatedSignalsViews.LOGS,
+										},
+									]}
 									onChange={handleRelatedSignalsChange}
 									className="related-signals-radio"
 								/>

frontend/src/container/SpanDetailsDrawer/SpanRelatedSignals/SpanRelatedSignals.styles.scss

@@ -30,11 +30,6 @@
 		display: flex;
 		flex-direction: column;
 	}
-	.view-title {
-		display: flex;
-		align-items: center;
-		gap: 8px;
-	}
 
 	.views-tabs-container {
 		padding: 16px 15px;
@@ -93,10 +88,28 @@
 		}
 	}
 
-	.infra-metrics-container {
-		padding-inline: 16px;
-		.infra-metrics-card {
-			border: 1px solid var(--bg-slate-400);
+	.infra-placeholder {
+		height: 50vh;
+		width: 100%;
+		display: flex;
+		justify-content: center;
+		align-items: center;
+		padding: 2rem;
+		box-sizing: border-box;
+
+		.infra-placeholder-content {
+			text-align: center;
+			color: var(--bg-slate-400);
+
+			svg {
+				margin-bottom: 1rem;
+				color: var(--bg-slate-400);
+			}
+
+			.ant-typography {
+				font-size: 16px;
+				color: var(--bg-slate-400);
+			}
 		}
 	}
 }

frontend/src/container/SpanDetailsDrawer/SpanRelatedSignals/SpanRelatedSignals.tsx

@@ -11,20 +11,17 @@ import {
 	initialQueryState,
 } from 'constants/queryBuilder';
 import ROUTES from 'constants/routes';
-import InfraMetrics from 'container/LogDetailedView/InfraMetrics/InfraMetrics';
 import { getEmptyLogsListConfig } from 'container/LogsExplorerList/utils';
-import dayjs from 'dayjs';
 import { useIsDarkMode } from 'hooks/useDarkMode';
-import { BarChart2, Compass, X } from 'lucide-react';
+import { Compass, X } from 'lucide-react';
 import { useCallback, useMemo, useState } from 'react';
 import { BaseAutocompleteData } from 'types/api/queryBuilder/queryAutocompleteResponse';
 import { Span } from 'types/api/trace/getTraceV2';
-import { DataSource, LogsAggregatorOperator } from 'types/common/queryBuilder';
+import { LogsAggregatorOperator } from 'types/common/queryBuilder';
 
 import { RelatedSignalsViews } from '../constants';
 import SpanLogs from '../SpanLogs/SpanLogs';
 import { useSpanContextLogs } from '../SpanLogs/useSpanContextLogs';
-import { hasInfraMetadata } from '../utils';
 
 const FIVE_MINUTES_IN_MS = 5 * 60 * 1000;
 
@@ -50,21 +47,6 @@ function SpanRelatedSignals({
 	);
 	const isDarkMode = useIsDarkMode();
 
-	// Extract infrastructure metadata from span attributes
-	const infraMetadata = useMemo(() => {
-		// Only return metadata if span has infrastructure metadata
-		if (!hasInfraMetadata(selectedSpan)) {
-			return null;
-		}
-
-		return {
-			clusterName: selectedSpan.tagMap['k8s.cluster.name'] || '',
-			podName: selectedSpan.tagMap['k8s.pod.name'] || '',
-			nodeName: selectedSpan.tagMap['k8s.node.name'] || '',
-			hostName: selectedSpan.tagMap['host.name'] || '',
-			spanTimestamp: dayjs(selectedSpan.timestamp).format(),
-		};
-	}, [selectedSpan]);
 	const {
 		logs,
 		isLoading,
@@ -86,34 +68,10 @@ function SpanRelatedSignals({
 		setSelectedView(e.target.value);
 	}, []);
 
-	const tabOptions = useMemo(() => {
-		const baseOptions = [
-			{
-				label: (
-					<div className="view-title">
-						<LogsIcon width={14} height={14} />
-						Logs
-					</div>
-				),
-				value: RelatedSignalsViews.LOGS,
-			},
-		];
-
-		// Add Infra option if infrastructure metadata is available
-		if (infraMetadata) {
-			baseOptions.push({
-				label: (
-					<div className="view-title">
-						<BarChart2 size={14} />
-						Metrics
-					</div>
-				),
-				value: RelatedSignalsViews.INFRA,
-			});
-		}
-
-		return baseOptions;
-	}, [infraMetadata]);
+	const handleClose = useCallback((): void => {
+		setSelectedView(RelatedSignalsViews.LOGS);
+		onClose();
+	}, [onClose]);
 
 	const handleExplorerPageRedirect = useCallback((): void => {
 		const startTimeMs = traceStartTime - FIVE_MINUTES_IN_MS;
@@ -187,7 +145,7 @@ function SpanRelatedSignals({
 				</>
 			}
 			placement="right"
-			onClose={onClose}
+			onClose={handleClose}
 			open={isOpen}
 			style={{
 				overscrollBehavior: 'contain',
@@ -202,7 +160,35 @@ function SpanRelatedSignals({
 					<div className="views-tabs-container">
 						<SignozRadioGroup
 							value={selectedView}
-							options={tabOptions}
+							options={[
+								{
+									label: (
+										<div className="view-title">
+											<LogsIcon width={14} height={14} />
+											Logs
+										</div>
+									),
+									value: RelatedSignalsViews.LOGS,
+								},
+								// {
+								// 	label: (
+								// 		<div className="view-title">
+								// 			<LogsIcon width={14} height={14} />
+								// 			Metrics
+								// 		</div>
+								// 	),
+								// 	value: RelatedSignalsViews.METRICS,
+								// },
+								// {
+								// 	label: (
+								// 		<div className="view-title">
+								// 			<Server size={14} />
+								// 			Infra
+								// 		</div>
+								// 	),
+								// 	value: RelatedSignalsViews.INFRA,
+								// },
+							]}
 							onChange={handleTabChange}
 							className="related-signals-radio"
 						/>
@@ -211,7 +197,6 @@ function SpanRelatedSignals({
 								icon={<Compass size={18} />}
 								className="open-in-explorer"
 								onClick={handleExplorerPageRedirect}
-								data-testid="open-in-explorer-button"
 							>
 								Open in Logs Explorer
 							</Button>
@@ -235,17 +220,6 @@ function SpanRelatedSignals({
 							emptyStateConfig={!hasTraceIdLogs ? emptyStateConfig : undefined}
 						/>
 					)}
-
-					{selectedView === RelatedSignalsViews.INFRA && infraMetadata && (
-						<InfraMetrics
-							clusterName={infraMetadata.clusterName}
-							podName={infraMetadata.podName}
-							nodeName={infraMetadata.nodeName}
-							hostName={infraMetadata.hostName}
-							timestamp={infraMetadata.spanTimestamp}
-							dataSource={DataSource.TRACES}
-						/>
-					)}
 				</div>
 			)}
 		</Drawer>

frontend/src/container/SpanDetailsDrawer/__tests__/SpanDetailsDrawer.infraMetrics.test.tsx

@@ -1,502 +0,0 @@
-import ROUTES from 'constants/routes';
-import { GetMetricQueryRange } from 'lib/dashboard/getQueryResults';
-import { server } from 'mocks-server/server';
-import { QueryBuilderContext } from 'providers/QueryBuilder';
-import { fireEvent, render, screen, waitFor } from 'tests/test-utils';
-import { DataSource } from 'types/common/queryBuilder';
-
-import SpanDetailsDrawer from '../SpanDetailsDrawer';
-import {
-	expectedHostOnlyMetadata,
-	expectedInfraMetadata,
-	expectedNodeOnlyMetadata,
-	expectedPodOnlyMetadata,
-	mockEmptyMetricsResponse,
-	mockNodeMetricsResponse,
-	mockPodMetricsResponse,
-	mockSpanWithHostOnly,
-	mockSpanWithInfraMetadata,
-	mockSpanWithNodeOnly,
-	mockSpanWithoutInfraMetadata,
-	mockSpanWithPodOnly,
-} from './infraMetricsTestData';
-
-// Mock external dependencies
-jest.mock('react-router-dom', () => ({
-	...jest.requireActual('react-router-dom'),
-	useLocation: (): { pathname: string } => ({
-		pathname: `${ROUTES.TRACE_DETAIL}`,
-	}),
-}));
-
-const mockSafeNavigate = jest.fn();
-jest.mock('hooks/useSafeNavigate', () => ({
-	useSafeNavigate: (): any => ({
-		safeNavigate: mockSafeNavigate,
-	}),
-}));
-
-const mockUpdateAllQueriesOperators = jest.fn().mockReturnValue({
-	builder: {
-		queryData: [
-			{
-				dataSource: 'logs',
-				queryName: 'A',
-				aggregateOperator: 'noop',
-				filters: { items: [], op: 'AND' },
-				expression: 'A',
-				disabled: false,
-				orderBy: [{ columnName: 'timestamp', order: 'desc' }],
-				groupBy: [],
-				limit: null,
-				having: [],
-			},
-		],
-		queryFormulas: [],
-	},
-	queryType: 'builder',
-});
-
-jest.mock('hooks/queryBuilder/useQueryBuilder', () => ({
-	useQueryBuilder: (): any => ({
-		updateAllQueriesOperators: mockUpdateAllQueriesOperators,
-		currentQuery: {
-			builder: {
-				queryData: [
-					{
-						dataSource: 'logs',
-						queryName: 'A',
-						filters: { items: [], op: 'AND' },
-					},
-				],
-			},
-		},
-	}),
-}));
-
-const mockWindowOpen = jest.fn();
-Object.defineProperty(window, 'open', {
-	writable: true,
-	value: mockWindowOpen,
-});
-
-// Mock uplot to avoid rendering issues
-jest.mock('uplot', () => {
-	const paths = {
-		spline: jest.fn(),
-		bars: jest.fn(),
-	};
-	const uplotMock = jest.fn(() => ({
-		paths,
-	}));
-	return {
-		paths,
-		default: uplotMock,
-	};
-});
-
-// Mock GetMetricQueryRange to track API calls
-jest.mock('lib/dashboard/getQueryResults', () => ({
-	GetMetricQueryRange: jest.fn(),
-}));
-
-// Mock generateColor
-jest.mock('lib/uPlotLib/utils/generateColor', () => ({
-	generateColor: jest.fn().mockReturnValue('#1f77b4'),
-}));
-
-// Mock OverlayScrollbar
-jest.mock(
-	'components/OverlayScrollbar/OverlayScrollbar',
-	() =>
-		// eslint-disable-next-line func-names, @typescript-eslint/explicit-function-return-type, react/display-name
-		function ({ children }: any) {
-			return <div data-testid="overlay-scrollbar">{children}</div>;
-		},
-);
-
-// Mock Virtuoso
-jest.mock('react-virtuoso', () => ({
-	Virtuoso: jest.fn(({ data, itemContent }) => (
-		<div data-testid="virtuoso">
-			{data?.map((item: any, index: number) => (
-				<div key={item.id || index} data-testid={`log-item-${item.id}`}>
-					{itemContent(index, item)}
-				</div>
-			))}
-		</div>
-	)),
-}));
-
-// Mock InfraMetrics component for focused testing
-jest.mock(
-	'container/LogDetailedView/InfraMetrics/InfraMetrics',
-	() =>
-		// eslint-disable-next-line func-names, @typescript-eslint/explicit-function-return-type, react/display-name
-		function MockInfraMetrics({
-			podName,
-			nodeName,
-			hostName,
-			clusterName,
-			timestamp,
-			dataSource,
-		}: any) {
-			return (
-				<div data-testid="infra-metrics">
-					<div data-testid="infra-pod-name">{podName}</div>
-					<div data-testid="infra-node-name">{nodeName}</div>
-					<div data-testid="infra-host-name">{hostName}</div>
-					<div data-testid="infra-cluster-name">{clusterName}</div>
-					<div data-testid="infra-timestamp">{timestamp}</div>
-					<div data-testid="infra-data-source">{dataSource}</div>
-				</div>
-			);
-		},
-);
-
-// Mock PreferenceContextProvider
-jest.mock('providers/preferences/context/PreferenceContextProvider', () => ({
-	PreferenceContextProvider: ({ children }: any): JSX.Element => (
-		<div>{children}</div>
-	),
-}));
-
-describe('SpanDetailsDrawer - Infra Metrics', () => {
-	// eslint-disable-next-line @typescript-eslint/no-explicit-any, sonarjs/no-unused-collection
-	let apiCallHistory: any[] = [];
-
-	beforeEach(() => {
-		jest.clearAllMocks();
-		apiCallHistory = [];
-		mockSafeNavigate.mockClear();
-		mockWindowOpen.mockClear();
-		mockUpdateAllQueriesOperators.mockClear();
-
-		// Setup API call tracking for infra metrics
-		(GetMetricQueryRange as jest.Mock).mockImplementation((query) => {
-			apiCallHistory.push(query);
-
-			// Return mock responses for different query types
-			if (
-				query?.query?.builder?.queryData?.[0]?.filters?.items?.some(
-					(item: any) => item.key?.key === 'k8s_pod_name',
-				)
-			) {
-				return Promise.resolve(mockPodMetricsResponse);
-			}
-
-			if (
-				query?.query?.builder?.queryData?.[0]?.filters?.items?.some(
-					(item: any) => item.key?.key === 'k8s_node_name',
-				)
-			) {
-				return Promise.resolve(mockNodeMetricsResponse);
-			}
-
-			return Promise.resolve(mockEmptyMetricsResponse);
-		});
-	});
-
-	afterEach(() => {
-		server.resetHandlers();
-	});
-
-	// Mock QueryBuilder context value
-	const mockQueryBuilderContextValue = {
-		currentQuery: {
-			builder: {
-				queryData: [
-					{
-						dataSource: 'logs',
-						queryName: 'A',
-						filters: { items: [], op: 'AND' },
-					},
-				],
-			},
-		},
-		stagedQuery: {
-			builder: {
-				queryData: [
-					{
-						dataSource: 'logs',
-						queryName: 'A',
-						filters: { items: [], op: 'AND' },
-					},
-				],
-			},
-		},
-		updateAllQueriesOperators: mockUpdateAllQueriesOperators,
-		panelType: 'list',
-		redirectWithQuery: jest.fn(),
-		handleRunQuery: jest.fn(),
-		handleStageQuery: jest.fn(),
-		resetQuery: jest.fn(),
-	};
-
-	const renderSpanDetailsDrawer = (props = {}): void => {
-		render(
-			<QueryBuilderContext.Provider value={mockQueryBuilderContextValue as any}>
-				<SpanDetailsDrawer
-					isSpanDetailsDocked={false}
-					setIsSpanDetailsDocked={jest.fn()}
-					selectedSpan={mockSpanWithInfraMetadata}
-					traceStartTime={1640995200000} // 2022-01-01 00:00:00
-					traceEndTime={1640995260000} // 2022-01-01 00:01:00
-					// eslint-disable-next-line react/jsx-props-no-spreading
-					{...props}
-				/>
-			</QueryBuilderContext.Provider>,
-		);
-	};
-
-	it('should detect infra metadata from span attributes', async () => {
-		renderSpanDetailsDrawer();
-
-		// Click on metrics tab
-		const infraMetricsButton = screen.getByRole('radio', { name: /metrics/i });
-		expect(infraMetricsButton).toBeInTheDocument();
-
-		fireEvent.click(infraMetricsButton);
-
-		// Wait for infra metrics to load
-		await waitFor(() => {
-			// eslint-disable-next-line sonarjs/no-duplicate-string
-			expect(screen.getByTestId('infra-metrics')).toBeInTheDocument();
-		});
-
-		// Verify metadata extraction
-		// eslint-disable-next-line sonarjs/no-duplicate-string
-		expect(screen.getByTestId('infra-pod-name')).toHaveTextContent(
-			expectedInfraMetadata.podName,
-		);
-		// eslint-disable-next-line sonarjs/no-duplicate-string
-		expect(screen.getByTestId('infra-node-name')).toHaveTextContent(
-			expectedInfraMetadata.nodeName,
-		);
-		// eslint-disable-next-line sonarjs/no-duplicate-string
-		expect(screen.getByTestId('infra-host-name')).toHaveTextContent(
-			expectedInfraMetadata.hostName,
-		);
-		// eslint-disable-next-line sonarjs/no-duplicate-string
-		expect(screen.getByTestId('infra-cluster-name')).toHaveTextContent(
-			expectedInfraMetadata.clusterName,
-		);
-		expect(screen.getByTestId('infra-data-source')).toHaveTextContent(
-			DataSource.TRACES,
-		);
-	});
-
-	it('should not show infra tab when span lacks infra metadata', async () => {
-		render(
-			<QueryBuilderContext.Provider value={mockQueryBuilderContextValue as any}>
-				<SpanDetailsDrawer
-					isSpanDetailsDocked={false}
-					setIsSpanDetailsDocked={jest.fn()}
-					selectedSpan={mockSpanWithoutInfraMetadata}
-					traceStartTime={1640995200000}
-					traceEndTime={1640995260000}
-				/>
-			</QueryBuilderContext.Provider>,
-		);
-
-		// Should NOT show infra tab, only logs tab
-		expect(
-			screen.queryByRole('radio', { name: /metrics/i }),
-		).not.toBeInTheDocument();
-		expect(screen.getByRole('radio', { name: /logs/i })).toBeInTheDocument();
-	});
-
-	it('should show infra tab when span has infra metadata', async () => {
-		renderSpanDetailsDrawer();
-
-		// Should show both logs and infra tabs
-		expect(screen.getByRole('radio', { name: /metrics/i })).toBeInTheDocument();
-		expect(screen.getByRole('radio', { name: /logs/i })).toBeInTheDocument();
-	});
-
-	it('should handle pod-only metadata correctly', async () => {
-		render(
-			<QueryBuilderContext.Provider value={mockQueryBuilderContextValue as any}>
-				<SpanDetailsDrawer
-					isSpanDetailsDocked={false}
-					setIsSpanDetailsDocked={jest.fn()}
-					selectedSpan={mockSpanWithPodOnly}
-					traceStartTime={1640995200000}
-					traceEndTime={1640995260000}
-				/>
-			</QueryBuilderContext.Provider>,
-		);
-
-		// Click on infra tab
-		const infraMetricsButton = screen.getByRole('radio', { name: /metrics/i });
-		fireEvent.click(infraMetricsButton);
-
-		await waitFor(() => {
-			expect(screen.getByTestId('infra-metrics')).toBeInTheDocument();
-		});
-
-		// Verify pod-only metadata
-		expect(screen.getByTestId('infra-pod-name')).toHaveTextContent(
-			expectedPodOnlyMetadata.podName,
-		);
-		expect(screen.getByTestId('infra-cluster-name')).toHaveTextContent(
-			expectedPodOnlyMetadata.clusterName,
-		);
-		expect(screen.getByTestId('infra-node-name')).toHaveTextContent(
-			expectedPodOnlyMetadata.nodeName,
-		);
-		expect(screen.getByTestId('infra-host-name')).toHaveTextContent(
-			expectedPodOnlyMetadata.hostName,
-		);
-	});
-
-	it('should handle node-only metadata correctly', async () => {
-		render(
-			<QueryBuilderContext.Provider value={mockQueryBuilderContextValue as any}>
-				<SpanDetailsDrawer
-					isSpanDetailsDocked={false}
-					setIsSpanDetailsDocked={jest.fn()}
-					selectedSpan={mockSpanWithNodeOnly}
-					traceStartTime={1640995200000}
-					traceEndTime={1640995260000}
-				/>
-			</QueryBuilderContext.Provider>,
-		);
-
-		// Click on infra tab
-		const infraMetricsButton = screen.getByRole('radio', { name: /metrics/i });
-		fireEvent.click(infraMetricsButton);
-
-		await waitFor(() => {
-			expect(screen.getByTestId('infra-metrics')).toBeInTheDocument();
-		});
-
-		// Verify node-only metadata
-		expect(screen.getByTestId('infra-node-name')).toHaveTextContent(
-			expectedNodeOnlyMetadata.nodeName,
-		);
-		expect(screen.getByTestId('infra-pod-name')).toHaveTextContent(
-			expectedNodeOnlyMetadata.podName,
-		);
-		expect(screen.getByTestId('infra-cluster-name')).toHaveTextContent(
-			expectedNodeOnlyMetadata.clusterName,
-		);
-		expect(screen.getByTestId('infra-host-name')).toHaveTextContent(
-			expectedNodeOnlyMetadata.hostName,
-		);
-	});
-
-	it('should handle host-only metadata correctly', async () => {
-		render(
-			<QueryBuilderContext.Provider value={mockQueryBuilderContextValue as any}>
-				<SpanDetailsDrawer
-					isSpanDetailsDocked={false}
-					setIsSpanDetailsDocked={jest.fn()}
-					selectedSpan={mockSpanWithHostOnly}
-					traceStartTime={1640995200000}
-					traceEndTime={1640995260000}
-				/>
-			</QueryBuilderContext.Provider>,
-		);
-
-		// Click on infra tab
-		const infraMetricsButton = screen.getByRole('radio', { name: /metrics/i });
-		fireEvent.click(infraMetricsButton);
-
-		await waitFor(() => {
-			expect(screen.getByTestId('infra-metrics')).toBeInTheDocument();
-		});
-
-		// Verify host-only metadata
-		expect(screen.getByTestId('infra-host-name')).toHaveTextContent(
-			expectedHostOnlyMetadata.hostName,
-		);
-		expect(screen.getByTestId('infra-pod-name')).toHaveTextContent(
-			expectedHostOnlyMetadata.podName,
-		);
-		expect(screen.getByTestId('infra-node-name')).toHaveTextContent(
-			expectedHostOnlyMetadata.nodeName,
-		);
-		expect(screen.getByTestId('infra-cluster-name')).toHaveTextContent(
-			expectedHostOnlyMetadata.clusterName,
-		);
-	});
-
-	it('should switch between logs and infra tabs correctly', async () => {
-		renderSpanDetailsDrawer();
-
-		// Initially should show logs tab content
-		const logsButton = screen.getByRole('radio', { name: /logs/i });
-		const infraMetricsButton = screen.getByRole('radio', { name: /metrics/i });
-
-		expect(logsButton).toBeInTheDocument();
-		expect(infraMetricsButton).toBeInTheDocument();
-
-		// Ensure logs tab is active and wait for content to load
-		fireEvent.click(logsButton);
-
-		await waitFor(() => {
-			// eslint-disable-next-line sonarjs/no-duplicate-string
-			expect(screen.getByTestId('open-in-explorer-button')).toBeInTheDocument();
-		});
-
-		// Click on infra tab
-		fireEvent.click(infraMetricsButton);
-
-		await waitFor(() => {
-			expect(screen.getByTestId('infra-metrics')).toBeInTheDocument();
-		});
-
-		// Should not show logs content anymore
-		expect(
-			screen.queryByTestId('open-in-explorer-button'),
-		).not.toBeInTheDocument();
-
-		// Switch back to logs tab
-		fireEvent.click(logsButton);
-
-		// Should not show infra metrics anymore
-		await waitFor(() => {
-			expect(screen.queryByTestId('infra-metrics')).not.toBeInTheDocument();
-		});
-
-		// Verify logs content is shown again
-		await waitFor(() => {
-			expect(screen.getByTestId('open-in-explorer-button')).toBeInTheDocument();
-		});
-	});
-
-	it('should pass correct data source and handle multiple infra identifiers', async () => {
-		renderSpanDetailsDrawer();
-
-		// Should show infra tab when span has any of: clusterName, podName, nodeName, hostName
-		expect(screen.getByRole('radio', { name: /metrics/i })).toBeInTheDocument();
-
-		// Click on infra tab
-		const infraMetricsButton = screen.getByRole('radio', { name: /metrics/i });
-		fireEvent.click(infraMetricsButton);
-
-		await waitFor(() => {
-			expect(screen.getByTestId('infra-metrics')).toBeInTheDocument();
-		});
-
-		// Verify TRACES data source is passed
-		expect(screen.getByTestId('infra-data-source')).toHaveTextContent(
-			DataSource.TRACES,
-		);
-
-		// All infra identifiers should be passed through
-		expect(screen.getByTestId('infra-pod-name')).toHaveTextContent(
-			'test-pod-abc123',
-		);
-		expect(screen.getByTestId('infra-node-name')).toHaveTextContent(
-			'test-node-456',
-		);
-		expect(screen.getByTestId('infra-host-name')).toHaveTextContent(
-			'test-host.example.com',
-		);
-		expect(screen.getByTestId('infra-cluster-name')).toHaveTextContent(
-			'test-cluster',
-		);
-	});
-});

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

@@ -1,8 +1,3 @@
-/* eslint-disable sonarjs/no-duplicate-string */
-/* eslint-disable sonarjs/no-identical-functions */
-
-import getSpanPercentiles from 'api/trace/getSpanPercentiles';
-import getUserPreference from 'api/v1/user/preferences/name/get';
 import { QueryParams } from 'constants/query';
 import ROUTES from 'constants/routes';
 import { GetMetricQueryRange } from 'lib/dashboard/getQueryResults';
@@ -15,8 +10,6 @@ import {
 	userEvent,
 	waitFor,
 } from 'tests/test-utils';
-import { SuccessResponseV2 } from 'types/api';
-import { GetSpanPercentilesResponseDataProps } from 'types/api/trace/getSpanPercentiles';
 
 import SpanDetailsDrawer from '../SpanDetailsDrawer';
 import {
@@ -31,17 +24,11 @@ import {
 	mockSpanLogsResponse,
 } from './mockData';
 
-// Get typed mocks
-const mockGetSpanPercentiles = jest.mocked(getSpanPercentiles);
-const mockGetUserPreference = jest.mocked(getUserPreference);
-const mockSafeNavigate = jest.fn();
-
 // Mock external dependencies
 jest.mock('react-router-dom', () => ({
 	...jest.requireActual('react-router-dom'),
-	useLocation: (): { pathname: string; search: string } => ({
+	useLocation: (): { pathname: string } => ({
 		pathname: `${ROUTES.TRACE_DETAIL}`,
-		search: 'trace_id=test-trace-id',
 	}),
 }));
 
@@ -51,8 +38,9 @@ jest.mock('@signozhq/button', () => ({
 	),
 }));
 
+const mockSafeNavigate = jest.fn();
 jest.mock('hooks/useSafeNavigate', () => ({
-	useSafeNavigate: (): { safeNavigate: jest.MockedFunction<() => void> } => ({
+	useSafeNavigate: (): any => ({
 		safeNavigate: mockSafeNavigate,
 	}),
 }));
@@ -80,10 +68,7 @@ const mockUpdateAllQueriesOperators = jest.fn().mockReturnValue({
 });
 
 jest.mock('hooks/queryBuilder/useQueryBuilder', () => ({
-	useQueryBuilder: (): {
-		updateAllQueriesOperators: jest.MockedFunction<() => any>;
-		currentQuery: any;
-	} => ({
+	useQueryBuilder: (): any => ({
 		updateAllQueriesOperators: mockUpdateAllQueriesOperators,
 		currentQuery: {
 			builder: {
@@ -128,46 +113,26 @@ jest.mock('lib/uPlotLib/utils/generateColor', () => ({
 	generateColor: jest.fn().mockReturnValue('#1f77b4'),
 }));
 
-// Mock getSpanPercentiles API
-jest.mock('api/trace/getSpanPercentiles', () => ({
-	__esModule: true,
-	default: jest.fn(),
-}));
-
-// Mock getUserPreference API
-jest.mock('api/v1/user/preferences/name/get', () => ({
-	__esModule: true,
-	default: jest.fn(),
-}));
-
 jest.mock(
 	'components/OverlayScrollbar/OverlayScrollbar',
 	() =>
 		// eslint-disable-next-line func-names, @typescript-eslint/explicit-function-return-type, react/display-name
-		function ({ children }: { children: React.ReactNode }) {
+		function ({ children }: any) {
 			return <div data-testid="overlay-scrollbar">{children}</div>;
 		},
 );
 
 // Mock Virtuoso to avoid complex virtualization
 jest.mock('react-virtuoso', () => ({
-	Virtuoso: jest.fn(
-		({
-			data,
-			itemContent,
-		}: {
-			data: any[];
-			itemContent: (index: number, item: any) => React.ReactNode;
-		}) => (
-			<div data-testid="virtuoso">
-				{data?.map((item: any, index: number) => (
-					<div key={item.id || index} data-testid={`log-item-${item.id}`}>
-						{itemContent(index, item)}
-					</div>
-				))}
-			</div>
-		),
-	),
+	Virtuoso: jest.fn(({ data, itemContent }) => (
+		<div data-testid="virtuoso">
+			{data?.map((item: any, index: number) => (
+				<div key={item.id || index} data-testid={`log-item-${item.id}`}>
+					{itemContent(index, item)}
+				</div>
+			))}
+		</div>
+	)),
 }));
 
 // Mock RawLogView component
@@ -180,12 +145,7 @@ jest.mock(
 			onLogClick,
 			isHighlighted,
 			helpTooltip,
-		}: {
-			data: any;
-			onLogClick: (data: any, event: React.MouseEvent) => void;
-			isHighlighted: boolean;
-			helpTooltip: string;
-		}) {
+		}: any) {
 			return (
 				// eslint-disable-next-line jsx-a11y/click-events-have-key-events, jsx-a11y/no-static-element-interactions
 				<div
@@ -204,11 +164,9 @@ jest.mock(
 
 // Mock PreferenceContextProvider
 jest.mock('providers/preferences/context/PreferenceContextProvider', () => ({
-	PreferenceContextProvider: ({
-		children,
-	}: {
-		children: React.ReactNode;
-	}): JSX.Element => <div>{children}</div>,
+	PreferenceContextProvider: ({ children }: any): JSX.Element => (
+		<div>{children}</div>
+	),
 }));
 
 // Mock QueryBuilder context value
@@ -259,51 +217,6 @@ const renderSpanDetailsDrawer = (props = {}): void => {
 	);
 };
 
-// Constants for repeated strings
-const SEARCH_RESOURCE_ATTRIBUTES_PLACEHOLDER = 'Search resource attributes';
-const P75_TEXT = 'p75';
-const SPAN_PERCENTILE_TEXT = 'Span Percentile';
-
-// Mock data for span percentiles
-const mockSpanPercentileResponse = {
-	httpStatusCode: 200 as const,
-	data: {
-		percentiles: {
-			p50: 500000000, // 500ms in nanoseconds
-			p90: 1000000000, // 1s in nanoseconds
-			p95: 1500000000, // 1.5s in nanoseconds
-			p99: 2000000000, // 2s in nanoseconds
-		},
-		position: {
-			percentile: 75.5,
-			description: 'This span is in the 75th percentile',
-		},
-	},
-};
-
-const mockUserPreferenceResponse = {
-	statusCode: 200,
-	httpStatusCode: 200,
-	error: null,
-	message: 'Success',
-	data: {
-		name: 'span_percentile_resource_attributes',
-		description: 'Resource attributes for span percentile calculation',
-		valueType: 'array',
-		defaultValue: [],
-		value: ['service.name', 'name', 'http.method'],
-		allowedValues: [],
-		allowedScopes: [],
-		createdAt: '2023-01-01T00:00:00Z',
-		updatedAt: '2023-01-01T00:00:00Z',
-	},
-};
-
-const mockSpanPercentileErrorResponse = ({
-	httpStatusCode: 500,
-	data: null,
-} as unknown) as SuccessResponseV2<GetSpanPercentilesResponseDataProps>;
-
 describe('SpanDetailsDrawer', () => {
 	let apiCallHistory: any = {};
 
@@ -318,14 +231,12 @@ describe('SpanDetailsDrawer', () => {
 		mockSafeNavigate.mockClear();
 		mockWindowOpen.mockClear();
 		mockUpdateAllQueriesOperators.mockClear();
-		mockGetSpanPercentiles.mockClear();
-		mockGetUserPreference.mockClear();
 
 		// Setup API call tracking
 		(GetMetricQueryRange as jest.Mock).mockImplementation((query) => {
 			// Determine response based on v5 filter expressions
-			const filterExpression = (query as any)?.query?.builder?.queryData?.[0]
-				?.filter?.expression;
+			const filterExpression =
+				query.query?.builder?.queryData?.[0]?.filter?.expression;
 
 			if (!filterExpression) return Promise.resolve(mockEmptyLogsResponse);
 
@@ -410,17 +321,17 @@ describe('SpanDetailsDrawer', () => {
 		} = apiCallHistory;
 
 		// 1. Span logs query (trace_id + span_id)
-		expect((spanQuery as any).query.builder.queryData[0].filter.expression).toBe(
+		expect(spanQuery.query.builder.queryData[0].filter.expression).toBe(
 			expectedSpanFilterExpression,
 		);
 
 		// 2. Before logs query (trace_id + id < first_span_log_id)
-		expect(
-			(beforeQuery as any).query.builder.queryData[0].filter.expression,
-		).toBe(expectedBeforeFilterExpression);
+		expect(beforeQuery.query.builder.queryData[0].filter.expression).toBe(
+			expectedBeforeFilterExpression,
+		);
 
 		// 3. After logs query (trace_id + id > last_span_log_id)
-		expect((afterQuery as any).query.builder.queryData[0].filter.expression).toBe(
+		expect(afterQuery.query.builder.queryData[0].filter.expression).toBe(
 			expectedAfterFilterExpression,
 		);
 
@@ -449,19 +360,13 @@ describe('SpanDetailsDrawer', () => {
 		} = apiCallHistory;
 
 		// Verify ordering: span query should use 'desc' (default)
-		expect((spanQuery as any).query.builder.queryData[0].orderBy[0].order).toBe(
-			'desc',
-		);
+		expect(spanQuery.query.builder.queryData[0].orderBy[0].order).toBe('desc');
 
 		// Before query should use 'desc' (default)
-		expect((beforeQuery as any).query.builder.queryData[0].orderBy[0].order).toBe(
-			'desc',
-		);
+		expect(beforeQuery.query.builder.queryData[0].orderBy[0].order).toBe('desc');
 
 		// After query should use 'asc' for chronological order
-		expect((afterQuery as any).query.builder.queryData[0].orderBy[0].order).toBe(
-			'asc',
-		);
+		expect(afterQuery.query.builder.queryData[0].orderBy[0].order).toBe('asc');
 	});
 
 	it('should navigate to logs explorer with span filters when span log is clicked', async () => {
@@ -622,435 +527,6 @@ describe('SpanDetailsDrawer', () => {
 		expect(contextLogAfter).toHaveClass('log-context');
 		expect(contextLogBefore).not.toHaveAttribute('title');
 	});
-
-	// Span Percentile Tests
-	describe('Span Percentile Functionality', () => {
-		beforeEach(() => {
-			// Setup default mocks for percentile tests
-			mockGetUserPreference.mockResolvedValue(mockUserPreferenceResponse);
-			mockGetSpanPercentiles.mockResolvedValue(mockSpanPercentileResponse);
-		});
-
-		it('should display span percentile value after successful API call', async () => {
-			renderSpanDetailsDrawer();
-
-			// Wait for the 2-second delay and API call to complete
-			await waitFor(
-				() => {
-					expect(screen.getByText(P75_TEXT)).toBeInTheDocument();
-				},
-				{ timeout: 3000 },
-			);
-		});
-
-		it('should show loading spinner while fetching percentile data', async () => {
-			// Mock a delayed response
-			mockGetSpanPercentiles.mockImplementation(
-				() =>
-					new Promise((resolve) => {
-						setTimeout(() => resolve(mockSpanPercentileResponse), 1000);
-					}),
-			);
-
-			renderSpanDetailsDrawer();
-
-			// Wait for loading spinner to appear (it's visible as a div with class loading-spinner-container)
-			await waitFor(
-				() => {
-					const spinnerContainer = document.querySelector(
-						'.loading-spinner-container',
-					);
-					expect(spinnerContainer).toBeInTheDocument();
-				},
-				{ timeout: 3000 },
-			);
-		});
-
-		it('should expand percentile details when percentile value is clicked', async () => {
-			renderSpanDetailsDrawer();
-
-			// Wait for percentile data to load
-			await waitFor(
-				() => {
-					expect(screen.getByText(P75_TEXT)).toBeInTheDocument();
-				},
-				{ timeout: 3000 },
-			);
-
-			// Click on the percentile value to expand details
-			const percentileValue = screen.getByText(P75_TEXT);
-			fireEvent.click(percentileValue);
-
-			// Verify percentile details are expanded
-			await waitFor(() => {
-				expect(screen.getByText(SPAN_PERCENTILE_TEXT)).toBeInTheDocument();
-				// Look for the text that's actually rendered
-				expect(screen.getByText(/This span duration is/)).toBeInTheDocument();
-				expect(
-					screen.getByText(/out of the distribution for this resource/),
-				).toBeInTheDocument();
-			});
-		});
-
-		it('should display percentile table with correct values', async () => {
-			renderSpanDetailsDrawer();
-
-			// Wait for percentile data to load
-			await waitFor(
-				() => {
-					expect(screen.getByText(P75_TEXT)).toBeInTheDocument();
-				},
-				{ timeout: 3000 },
-			);
-
-			const percentileValue = screen.getByText(P75_TEXT);
-			fireEvent.click(percentileValue);
-
-			// Wait for the percentile details to expand
-			await waitFor(() => {
-				expect(screen.getByText(SPAN_PERCENTILE_TEXT)).toBeInTheDocument();
-			});
-
-			// Wait for the table to be visible (it might take a moment to render)
-			await waitFor(
-				() => {
-					expect(screen.getByText('Percentile')).toBeInTheDocument();
-					expect(screen.getByText('Duration')).toBeInTheDocument();
-				},
-				{ timeout: 5000 },
-			);
-
-			// Verify percentile values are displayed
-			expect(screen.getByText('p50')).toBeInTheDocument();
-			expect(screen.getByText('p90')).toBeInTheDocument();
-			expect(screen.getByText('p95')).toBeInTheDocument();
-			expect(screen.getByText('p99')).toBeInTheDocument();
-
-			// Verify current span row - use getAllByText since there are multiple p75 elements
-			expect(screen.getAllByText(P75_TEXT)).toHaveLength(3); // Should appear in value, expanded details, and table
-
-			// Verify the table has the current span indicator (there are multiple occurrences)
-			expect(screen.getAllByText(/this span/i).length).toBeGreaterThan(0);
-		});
-
-		it('should allow time range selection and trigger API call', async () => {
-			renderSpanDetailsDrawer();
-
-			// Wait for percentile data to load and expand
-			await waitFor(
-				() => {
-					expect(screen.getByText(P75_TEXT)).toBeInTheDocument();
-				},
-				{ timeout: 3000 },
-			);
-
-			const percentileValue = screen.getByText(P75_TEXT);
-			fireEvent.click(percentileValue);
-
-			// Wait for percentile details to expand
-			await waitFor(() => {
-				expect(screen.getByText(SPAN_PERCENTILE_TEXT)).toBeInTheDocument();
-			});
-
-			// Find the time range selector and verify it exists
-			const timeRangeSelector = screen.getByRole('combobox');
-			expect(timeRangeSelector).toBeInTheDocument();
-
-			// Verify the default time range is displayed
-			expect(screen.getByText(/1.*hour/i)).toBeInTheDocument();
-
-			// Verify API was called with default parameters
-			await waitFor(() => {
-				expect(mockGetSpanPercentiles).toHaveBeenCalledWith(
-					expect.objectContaining({
-						start: expect.any(Number),
-						end: expect.any(Number),
-						spanDuration: mockSpan.durationNano,
-						serviceName: mockSpan.serviceName,
-						name: mockSpan.name,
-						resourceAttributes: expect.any(Object),
-					}),
-				);
-			});
-		});
-
-		it('should show resource attributes selector when plus icon is clicked', async () => {
-			renderSpanDetailsDrawer();
-
-			// Wait for percentile data to load and expand
-			await waitFor(
-				() => {
-					expect(screen.getByText(P75_TEXT)).toBeInTheDocument();
-				},
-				{ timeout: 3000 },
-			);
-
-			const percentileValue = screen.getByText(P75_TEXT);
-			fireEvent.click(percentileValue);
-
-			// Wait for percentile details to expand
-			await waitFor(() => {
-				expect(screen.getByText(SPAN_PERCENTILE_TEXT)).toBeInTheDocument();
-			});
-
-			// Click the plus icon using test ID
-			const plusIcon = screen.getByTestId('plus-icon');
-			fireEvent.click(plusIcon);
-
-			// Verify resource attributes selector is shown
-			await waitFor(() => {
-				expect(
-					screen.getByPlaceholderText(SEARCH_RESOURCE_ATTRIBUTES_PLACEHOLDER),
-				).toBeInTheDocument();
-			});
-		});
-
-		it('should filter resource attributes based on search query', async () => {
-			renderSpanDetailsDrawer();
-
-			// Wait for percentile data to load and expand
-			await waitFor(
-				() => {
-					expect(screen.getByText(P75_TEXT)).toBeInTheDocument();
-				},
-				{ timeout: 3000 },
-			);
-
-			const percentileValue = screen.getByText(P75_TEXT);
-			fireEvent.click(percentileValue);
-
-			// Wait for percentile details to expand and show resource attributes
-			await waitFor(() => {
-				expect(screen.getByText(SPAN_PERCENTILE_TEXT)).toBeInTheDocument();
-			});
-
-			const plusIcon = screen.getByTestId('plus-icon');
-			fireEvent.click(plusIcon);
-
-			await waitFor(() => {
-				expect(
-					screen.getByPlaceholderText(SEARCH_RESOURCE_ATTRIBUTES_PLACEHOLDER),
-				).toBeInTheDocument();
-			});
-
-			// Type in search query
-			const searchInput = screen.getByPlaceholderText(
-				SEARCH_RESOURCE_ATTRIBUTES_PLACEHOLDER,
-			);
-			fireEvent.change(searchInput, { target: { value: 'http' } });
-
-			// Verify only matching attributes are shown (use getAllByText for all since they appear in multiple places)
-			expect(screen.getAllByText('http.method').length).toBeGreaterThan(0);
-			expect(screen.getAllByText('http.url').length).toBeGreaterThan(0);
-			expect(screen.getAllByText('http.status_code').length).toBeGreaterThan(0);
-		});
-
-		it('should handle resource attribute selection and trigger API call', async () => {
-			renderSpanDetailsDrawer();
-
-			// Wait for percentile data to load and expand
-			await waitFor(
-				() => {
-					expect(screen.getByText(P75_TEXT)).toBeInTheDocument();
-				},
-				{ timeout: 3000 },
-			);
-
-			const percentileValue = screen.getByText(P75_TEXT);
-			fireEvent.click(percentileValue);
-
-			// Wait for percentile details to expand and show resource attributes
-			await waitFor(() => {
-				expect(screen.getByText(SPAN_PERCENTILE_TEXT)).toBeInTheDocument();
-			});
-
-			const plusIcon = screen.getByTestId('plus-icon');
-			fireEvent.click(plusIcon);
-
-			await waitFor(() => {
-				expect(
-					screen.getByPlaceholderText(SEARCH_RESOURCE_ATTRIBUTES_PLACEHOLDER),
-				).toBeInTheDocument();
-			});
-
-			// Find and click a checkbox for a resource attribute
-			const httpMethodCheckbox = screen.getByRole('checkbox', {
-				name: /http\.method/i,
-			});
-			fireEvent.click(httpMethodCheckbox);
-
-			// Verify API was called with updated resource attributes
-			await waitFor(() => {
-				expect(mockGetSpanPercentiles).toHaveBeenCalledWith(
-					expect.objectContaining({
-						resourceAttributes: expect.objectContaining({
-							'http.method': 'GET',
-						}),
-					}),
-				);
-			});
-		});
-
-		it('should handle API error gracefully', async () => {
-			// Mock API error
-			mockGetSpanPercentiles.mockResolvedValue(mockSpanPercentileErrorResponse);
-
-			renderSpanDetailsDrawer();
-
-			// Wait for the 2-second delay
-			await waitFor(
-				() => {
-					// Verify no percentile value is displayed on error
-					expect(screen.queryByText(/p\d+/)).not.toBeInTheDocument();
-				},
-				{ timeout: 3000 },
-			);
-		});
-
-		it('should not display percentile value when API returns non-200 status', async () => {
-			// Mock API response with non-200 status
-			mockGetSpanPercentiles.mockResolvedValue(({
-				httpStatusCode: 500 as const,
-				data: null,
-			} as unknown) as Awaited<ReturnType<typeof getSpanPercentiles>>);
-
-			renderSpanDetailsDrawer();
-
-			// Wait for the 2-second delay
-			await waitFor(
-				() => {
-					// Verify no percentile value is displayed
-					expect(screen.queryByText(/p\d+/)).not.toBeInTheDocument();
-				},
-				{ timeout: 3000 },
-			);
-		});
-
-		it('should display tooltip with correct content', async () => {
-			renderSpanDetailsDrawer();
-
-			// Wait for percentile data to load
-			await waitFor(
-				() => {
-					expect(screen.getByText(P75_TEXT)).toBeInTheDocument();
-				},
-				{ timeout: 3000 },
-			);
-
-			// Hover over the percentile value to show tooltip
-			const percentileValue = screen.getByText(P75_TEXT);
-			fireEvent.mouseEnter(percentileValue);
-
-			// Verify tooltip content - use more flexible text matching
-			await waitFor(() => {
-				expect(screen.getByText(/This span duration is/)).toBeInTheDocument();
-				expect(screen.getByText(/out of the distribution/)).toBeInTheDocument();
-				expect(
-					screen.getByText(/evaluated for 1 hour\(s\) since the span start time/),
-				).toBeInTheDocument();
-				expect(screen.getByText('Click to learn more')).toBeInTheDocument();
-			});
-		});
-
-		it('should handle empty percentile data gracefully', async () => {
-			// Mock empty percentile response
-			mockGetSpanPercentiles.mockResolvedValue({
-				httpStatusCode: 200,
-				data: {
-					percentiles: {},
-					position: {
-						percentile: 0,
-						description: '',
-					},
-				},
-			});
-
-			renderSpanDetailsDrawer();
-
-			// Wait for the 2-second delay
-			await waitFor(
-				() => {
-					// Verify p0 is displayed for empty data
-					expect(screen.getByText('p0')).toBeInTheDocument();
-				},
-				{ timeout: 3000 },
-			);
-		});
-
-		it('should call API with correct parameters', async () => {
-			renderSpanDetailsDrawer();
-
-			// Wait for API call to be made
-			await waitFor(
-				() => {
-					expect(mockGetSpanPercentiles).toHaveBeenCalled();
-				},
-				{ timeout: 3000 },
-			);
-
-			// Verify API was called with correct parameters
-			expect(mockGetSpanPercentiles).toHaveBeenCalledWith({
-				start: expect.any(Number),
-				end: expect.any(Number),
-				spanDuration: mockSpan.durationNano,
-				serviceName: mockSpan.serviceName,
-				name: mockSpan.name,
-				resourceAttributes: expect.any(Object),
-			});
-		});
-
-		it('should handle user preference loading', async () => {
-			renderSpanDetailsDrawer();
-
-			// Verify getUserPreference was called
-			await waitFor(() => {
-				expect(mockGetUserPreference).toHaveBeenCalledWith({
-					name: 'span_percentile_resource_attributes',
-				});
-			});
-		});
-
-		it('should close resource attributes selector when check icon is clicked', async () => {
-			const user = userEvent.setup({ pointerEventsCheck: 0 });
-			renderSpanDetailsDrawer();
-
-			// Wait for percentile data to load and expand
-			await waitFor(
-				() => {
-					expect(screen.getByText(P75_TEXT)).toBeInTheDocument();
-				},
-				{ timeout: 3000 },
-			);
-
-			const percentileValue = screen.getByText(P75_TEXT);
-			await user.click(percentileValue);
-
-			// Wait for percentile details to expand and show resource attributes
-			await waitFor(() => {
-				expect(screen.getByText(SPAN_PERCENTILE_TEXT)).toBeInTheDocument();
-			});
-
-			const plusIcon = screen.getByTestId('plus-icon');
-			await user.click(plusIcon);
-
-			await waitFor(() => {
-				expect(
-					screen.getByPlaceholderText(SEARCH_RESOURCE_ATTRIBUTES_PLACEHOLDER),
-				).toBeInTheDocument();
-			});
-
-			// Click the check icon to close the selector
-			const checkIcon = screen.getByTestId('check-icon');
-			await user.click(checkIcon);
-
-			// Verify resource attributes selector is hidden
-			await waitFor(() => {
-				expect(
-					screen.queryByPlaceholderText(SEARCH_RESOURCE_ATTRIBUTES_PLACEHOLDER),
-				).not.toBeInTheDocument();
-			});
-		});
-	});
 });
 
 describe('SpanDetailsDrawer - Search Visibility User Flows', () => {

frontend/src/container/SpanDetailsDrawer/__tests__/infraMetricsTestData.ts

@@ -1,169 +0,0 @@
-import { Span } from 'types/api/trace/getTraceV2';
-
-// Constants
-const TEST_TRACE_ID = 'test-trace-id';
-const TEST_CLUSTER_NAME = 'test-cluster';
-const TEST_POD_NAME = 'test-pod-abc123';
-const TEST_NODE_NAME = 'test-node-456';
-const TEST_HOST_NAME = 'test-host.example.com';
-
-// Mock span with infrastructure metadata (pod + node + host)
-export const mockSpanWithInfraMetadata: Span = {
-	spanId: 'infra-span-id',
-	traceId: TEST_TRACE_ID,
-	// eslint-disable-next-line sonarjs/no-duplicate-string
-	name: 'api-service',
-	serviceName: 'api-service',
-	timestamp: 1640995200000000, // 2022-01-01 00:00:00 in microseconds
-	durationNano: 2000000000, // 2 seconds in nanoseconds
-	spanKind: 'server',
-	statusCodeString: 'STATUS_CODE_OK',
-	statusMessage: '',
-	parentSpanId: '',
-	references: [],
-	event: [],
-	tagMap: {
-		'k8s.cluster.name': TEST_CLUSTER_NAME,
-		'k8s.pod.name': TEST_POD_NAME,
-		'k8s.node.name': TEST_NODE_NAME,
-		'host.name': TEST_HOST_NAME,
-		'service.name': 'api-service',
-		'http.method': 'GET',
-	},
-	hasError: false,
-	rootSpanId: '',
-	kind: 0,
-	rootName: '',
-	hasChildren: false,
-	hasSibling: false,
-	subTreeNodeCount: 0,
-	level: 0,
-};
-
-// Mock span with only pod metadata
-export const mockSpanWithPodOnly: Span = {
-	...mockSpanWithInfraMetadata,
-	spanId: 'pod-only-span-id',
-	tagMap: {
-		'k8s.cluster.name': TEST_CLUSTER_NAME,
-		'k8s.pod.name': TEST_POD_NAME,
-		'service.name': 'api-service',
-	},
-};
-
-// Mock span with only node metadata
-export const mockSpanWithNodeOnly: Span = {
-	...mockSpanWithInfraMetadata,
-	spanId: 'node-only-span-id',
-	tagMap: {
-		'k8s.node.name': TEST_NODE_NAME,
-		'service.name': 'api-service',
-	},
-};
-
-// Mock span with only host metadata
-export const mockSpanWithHostOnly: Span = {
-	...mockSpanWithInfraMetadata,
-	spanId: 'host-only-span-id',
-	tagMap: {
-		'host.name': TEST_HOST_NAME,
-		'service.name': 'api-service',
-	},
-};
-
-// Mock span without any infrastructure metadata
-export const mockSpanWithoutInfraMetadata: Span = {
-	...mockSpanWithInfraMetadata,
-	spanId: 'no-infra-span-id',
-	tagMap: {
-		'service.name': 'api-service',
-		'http.method': 'GET',
-		'http.status_code': '200',
-	},
-};
-
-// Mock infrastructure metrics API responses
-export const mockPodMetricsResponse = {
-	payload: {
-		data: {
-			newResult: {
-				data: {
-					result: [
-						{
-							metric: { pod_name: TEST_POD_NAME },
-							values: [
-								[1640995200, '0.5'], // CPU usage
-								[1640995260, '0.6'],
-							],
-						},
-					],
-				},
-			},
-		},
-	},
-};
-
-export const mockNodeMetricsResponse = {
-	payload: {
-		data: {
-			newResult: {
-				data: {
-					result: [
-						{
-							metric: { node_name: TEST_NODE_NAME },
-							values: [
-								[1640995200, '2.1'], // Memory usage
-								[1640995260, '2.3'],
-							],
-						},
-					],
-				},
-			},
-		},
-	},
-};
-
-export const mockEmptyMetricsResponse = {
-	payload: {
-		data: {
-			newResult: {
-				data: {
-					result: [],
-				},
-			},
-		},
-	},
-};
-
-// Expected infrastructure metadata extractions
-export const expectedInfraMetadata = {
-	clusterName: TEST_CLUSTER_NAME,
-	podName: TEST_POD_NAME,
-	nodeName: TEST_NODE_NAME,
-	hostName: TEST_HOST_NAME,
-};
-
-export const expectedPodOnlyMetadata = {
-	clusterName: TEST_CLUSTER_NAME,
-	podName: TEST_POD_NAME,
-	nodeName: '',
-	hostName: '',
-	// eslint-disable-next-line sonarjs/no-duplicate-string
-	spanTimestamp: '2022-01-01T00:00:00.000Z',
-};
-
-export const expectedNodeOnlyMetadata = {
-	clusterName: '',
-	podName: '',
-	nodeName: TEST_NODE_NAME,
-	hostName: '',
-	spanTimestamp: '2022-01-01T00:00:00.000Z',
-};
-
-export const expectedHostOnlyMetadata = {
-	clusterName: '',
-	podName: '',
-	nodeName: '',
-	hostName: TEST_HOST_NAME,
-	spanTimestamp: '2022-01-01T00:00:00.000Z',
-};

frontend/src/container/SpanDetailsDrawer/constants.ts

@@ -1,11 +1,11 @@
 export enum RelatedSignalsViews {
 	LOGS = 'logs',
 	// METRICS = 'metrics',
-	INFRA = 'infra',
+	// INFRA = 'infra',
 }
 
 export const RELATED_SIGNALS_VIEW_TYPES = {
 	LOGS: RelatedSignalsViews.LOGS,
 	// METRICS: RelatedSignalsViews.METRICS,
-	INFRA: RelatedSignalsViews.INFRA,
+	// INFRA: RelatedSignalsViews.INFRA,
 };

frontend/src/container/SpanDetailsDrawer/utils.ts

@@ -1,22 +0,0 @@
-import { Span } from 'types/api/trace/getTraceV2';
-
-/**
- * Infrastructure metadata keys that indicate infra signals are available
- */
-export const INFRA_METADATA_KEYS = [
-	'k8s.cluster.name',
-	'k8s.pod.name',
-	'k8s.node.name',
-	'host.name',
-] as const;
-
-/**
- * Checks if a span has any infrastructure metadata attributes
- * @param span - The span to check for infrastructure metadata
- * @returns true if the span has at least one infrastructure metadata key, false otherwise
- */
-export function hasInfraMetadata(span: Span | undefined): boolean {
-	if (!span?.tagMap) return false;
-
-	return INFRA_METADATA_KEYS.some((key) => span.tagMap?.[key]);
-}

frontend/src/container/TraceMetadata/TraceMetadata.tsx

@@ -35,21 +35,21 @@ function TraceMetadata(props: ITraceMetadataProps): JSX.Element {
 		totalSpans,
 		notFound,
 	} = props;
-
-	const handlePreviousBtnClick = (): void => {
-		if (window.history.length > 1) {
-			history.goBack();
-		} else {
-			history.push(ROUTES.TRACES_EXPLORER);
-		}
-	};
-
 	return (
 		<div className="trace-metadata">
 			<section className="metadata-info">
 				<div className="first-row">
-					<Button className="previous-btn" onClick={handlePreviousBtnClick}>
-						<ArrowLeft size={14} />
+					<Button className="previous-btn">
+						<ArrowLeft
+							size={14}
+							onClick={(): void => {
+								if (window.history.length > 1) {
+									history.goBack();
+								} else {
+									history.push(ROUTES.TRACES_EXPLORER);
+								}
+							}}
+						/>
 					</Button>
 					<div className="trace-name">
 						<DraftingCompass size={14} className="drafting" />

frontend/src/hooks/dashboard/useVariablesFromUrl.tsx

@@ -18,6 +18,7 @@ interface UseVariablesFromUrlReturn {
 		name: string,
 		selectedValue: IDashboardVariable['selectedValue'],
 	) => void;
+	clearUrlVariables: () => void;
 }
 
 const useVariablesFromUrl = (): UseVariablesFromUrlReturn => {
@@ -67,6 +68,15 @@ const useVariablesFromUrl = (): UseVariablesFromUrlReturn => {
 		[history, urlQuery],
 	);
 
+	const clearUrlVariables = useCallback((): void => {
+		const params = new URLSearchParams(urlQuery.toString());
+		params.delete(QueryParams.variables);
+
+		history.replace({
+			search: params.toString(),
+		});
+	}, [history, urlQuery]);
+
 	const updateUrlVariable = useCallback(
 		(name: string, selectedValue: IDashboardVariable['selectedValue']): void => {
 			const currentVariables = getUrlVariables();
@@ -85,6 +95,7 @@ const useVariablesFromUrl = (): UseVariablesFromUrlReturn => {
 		getUrlVariables,
 		setUrlVariables,
 		updateUrlVariable,
+		clearUrlVariables,
 	};
 };
 

frontend/src/lib/uPlotLib/getUplotChartOptions.ts

@@ -285,11 +285,10 @@ export const getUPlotChartOptions = ({
 		cursor: {
 			lock: false,
 			focus: {
-				prox: 25,
+				prox: 1e6,
 				bias: 1,
 			},
 			points: {
-				one: true,
 				size: (u, seriesIdx): number => u.series[seriesIdx].points.size * 3,
 				width: (u, seriesIdx, size): number => size / 4,
 				stroke: (u, seriesIdx): string =>
@@ -395,25 +394,14 @@ export const getUPlotChartOptions = ({
 		hooks: {
 			draw: [
 				(u): void => {
-					if (isAnomalyRule || !thresholds?.length) {
+					if (isAnomalyRule) {
 						return;
 					}
 
-					const { ctx } = u;
-					const { left: plotLeft, width: plotWidth } = u.bbox;
-					const plotRight = plotLeft + plotWidth;
-					const canvasHeight = ctx.canvas.height;
-					const threshold90Percent = canvasHeight * 0.9;
-
-					// Single save/restore for all thresholds
-					ctx.save();
-					ctx.lineWidth = 2;
-					ctx.setLineDash([10, 5]);
-
-					for (let i = 0; i < thresholds.length; i++) {
-						const threshold = thresholds[i];
+					thresholds?.forEach((threshold) => {
 						if (threshold.thresholdValue !== undefined) {
-							const color = threshold.thresholdColor || 'red';
+							const { ctx } = u;
+							ctx.save();
 							const yPos = u.valToPos(
 								convertValue(
 									threshold.thresholdValue,
@@ -423,28 +411,35 @@ export const getUPlotChartOptions = ({
 								'y',
 								true,
 							);
-
-							// Draw threshold line
-							ctx.strokeStyle = color;
+							ctx.strokeStyle = threshold.thresholdColor || 'red';
+							ctx.lineWidth = 2;
+							ctx.setLineDash([10, 5]);
 							ctx.beginPath();
+							const plotLeft = u.bbox.left; // left edge of the plot area
+							const plotRight = plotLeft + u.bbox.width; // right edge of the plot area
 							ctx.moveTo(plotLeft, yPos);
 							ctx.lineTo(plotRight, yPos);
 							ctx.stroke();
-
-							// Draw threshold label if present
+							// Text configuration
 							if (threshold.thresholdLabel) {
-								const textWidth = ctx.measureText(threshold.thresholdLabel).width;
-								const textX = plotRight - textWidth - 20;
+								const text = threshold.thresholdLabel;
+								const textX = plotRight - ctx.measureText(text).width - 20;
+								const canvasHeight = ctx.canvas.height;
 								const yposHeight = canvasHeight - yPos;
-								const textY = yposHeight > threshold90Percent ? yPos + 15 : yPos - 15;
-
-								ctx.fillStyle = color;
-								ctx.fillText(threshold.thresholdLabel, textX, textY);
+								const isHeightGreaterThan90Percent = canvasHeight * 0.9 < yposHeight;
+								// Adjust textY based on the condition
+								let textY;
+								if (isHeightGreaterThan90Percent) {
+									textY = yPos + 15; // Below the threshold line
+								} else {
+									textY = yPos - 15; // Above the threshold line
+								}
+								ctx.fillStyle = threshold.thresholdColor || 'red';
+								ctx.fillText(text, textX, textY);
 							}
+							ctx.restore();
 						}
-					}
-
-					ctx.restore();
+					});
 				},
 			],
 			setSelect: [
@@ -560,22 +555,19 @@ export const getUPlotChartOptions = ({
 								// Get the current text content
 								const legendText = seriesLabels[index];
 
-								// Use DocumentFragment to batch DOM operations
-								const fragment = document.createDocumentFragment();
+								// Clear the th content and rebuild it
+								thElement.innerHTML = '';
 
 								// Add back the marker
 								if (markerClone) {
-									fragment.appendChild(markerClone);
+									thElement.appendChild(markerClone);
 								}
 
 								// Create text wrapper
 								const textSpan = document.createElement('span');
 								textSpan.className = 'legend-text';
 								textSpan.textContent = legendText;
-								fragment.appendChild(textSpan);
-
-								// Replace the children in a single operation
-								thElement.replaceChildren(fragment);
+								thElement.appendChild(textSpan);
 
 								// Setup tooltip functionality - check truncation on hover
 								let tooltipElement: HTMLElement | null = null;

frontend/src/lib/uPlotLib/plugins/tooltipPlugin.ts

@@ -38,31 +38,6 @@ function getTooltipBaseValue(
 	return data[index][idx];
 }
 
-function sortTooltipContentBasedOnValue(
-	tooltipDataObj: Record<string, UplotTooltipDataProps>,
-): Record<string, UplotTooltipDataProps> {
-	const entries = Object.entries(tooltipDataObj);
-
-	// Separate focused and non-focused entries in a single pass
-	const focusedEntries: [string, UplotTooltipDataProps][] = [];
-	const nonFocusedEntries: [string, UplotTooltipDataProps][] = [];
-
-	for (let i = 0; i < entries.length; i++) {
-		const entry = entries[i];
-		if (entry[1].focus) {
-			focusedEntries.push(entry);
-		} else {
-			nonFocusedEntries.push(entry);
-		}
-	}
-
-	// Sort non-focused entries by value (descending)
-	nonFocusedEntries.sort((a, b) => b[1].value - a[1].value);
-
-	// Combine with focused entries on top
-	return Object.fromEntries(focusedEntries.concat(nonFocusedEntries));
-}
-
 const generateTooltipContent = (
 	seriesList: any[],
 	data: any[],
@@ -82,31 +57,23 @@ const generateTooltipContent = (
 ): HTMLElement => {
 	const container = document.createElement('div');
 	container.classList.add('tooltip-container');
+	const overlay = document.getElementById('overlay');
 	let tooltipCount = 0;
 
 	let tooltipTitle = '';
 	const formattedData: Record<string, UplotTooltipDataProps> = {};
 	const duplicatedLegendLabels: Record<string, true> = {};
 
-	// Pre-build a label-to-series map for O(1) lookup instead of O(n) search
-	let seriesColorMap: Map<string, string> | null = null;
-	if (isBillingUsageGraphs && series) {
-		seriesColorMap = new Map();
-		for (let i = 0; i < series.length; i++) {
-			const item = series[i];
-			if (item.label) {
-				const fillColor = get(item, '_fill');
-				if (fillColor) {
-					seriesColorMap.set(item.label, fillColor);
-				}
-			}
-		}
+	function sortTooltipContentBasedOnValue(
+		tooltipDataObj: Record<string, UplotTooltipDataProps>,
+	): Record<string, UplotTooltipDataProps> {
+		const entries = Object.entries(tooltipDataObj);
+		entries.sort((a, b) => b[1].value - a[1].value);
+		return Object.fromEntries(entries);
 	}
 
 	if (Array.isArray(series) && series.length > 0) {
-		for (let index = 0; index < series.length; index++) {
-			const item = series[index];
-
+		series.forEach((item, index) => {
 			if (index === 0) {
 				if (isBillingUsageGraphs) {
 					tooltipTitle = dayjs(data[0][idx] * 1000)
@@ -147,12 +114,15 @@ const generateTooltipContent = (
 						isDarkMode ? themeColors.chartcolors : themeColors.lightModeColor,
 					);
 
-				// O(1) lookup instead of O(n) search for billing graph colors
-				if (isBillingUsageGraphs && seriesColorMap) {
-					const billingColor = seriesColorMap.get(label);
-					if (billingColor) {
-						color = billingColor;
-					}
+				// in case of billing graph pick colors from the series options
+				if (isBillingUsageGraphs) {
+					let clr;
+					series.forEach((item) => {
+						if (item.label === label) {
+							clr = get(item, '_fill');
+						}
+					});
+					color = clr ?? color;
 				}
 
 				let tooltipItemLabel = label;
@@ -160,7 +130,10 @@ const generateTooltipContent = (
 				if (Number.isFinite(value)) {
 					const tooltipValue = getToolTipValue(value, yAxisUnit, decimalPrecision);
 					const dataIngestedFormated = getToolTipValue(dataIngested);
-					if (duplicatedLegendLabels[label] || label in formattedData) {
+					if (
+						duplicatedLegendLabels[label] ||
+						Object.prototype.hasOwnProperty.call(formattedData, label)
+					) {
 						duplicatedLegendLabels[label] = true;
 						const tempDataObj = formattedData[label];
 
@@ -197,11 +170,15 @@ const generateTooltipContent = (
 					formattedData[tooltipItemLabel] = dataObj;
 				}
 			}
-		}
+		});
 	}
 
-	// Early return if no valid data points - avoids unnecessary DOM manipulation
+	// Show tooltip only if atleast only series has a value at the hovered timestamp
 	if (tooltipCount <= 0) {
+		if (overlay && overlay.style.display === 'block') {
+			overlay.style.display = 'none';
+		}
+
 		return container;
 	}
 
@@ -210,42 +187,48 @@ const generateTooltipContent = (
 		UplotTooltipDataProps
 	> = sortTooltipContentBasedOnValue(formattedData);
 
-	const headerDiv = document.createElement('div');
-	headerDiv.classList.add('tooltip-content-row', 'tooltip-content-header');
-	headerDiv.textContent = isHistogramGraphs ? '' : tooltipTitle;
-	container.appendChild(headerDiv);
+	const div = document.createElement('div');
+	div.classList.add('tooltip-content-row');
+	div.textContent = isHistogramGraphs ? '' : tooltipTitle;
+	div.classList.add('tooltip-content-header');
+	container.appendChild(div);
 
-	// Use DocumentFragment for better performance when adding multiple elements
-	const fragment = document.createDocumentFragment();
+	const sortedKeys = Object.keys(sortedData);
 
-	const sortedValues = Object.values(sortedData);
+	if (Array.isArray(sortedKeys) && sortedKeys.length > 0) {
+		sortedKeys.forEach((key) => {
+			if (sortedData[key]) {
+				const { textContent, color, focus } = sortedData[key];
+				const div = document.createElement('div');
+				div.classList.add('tooltip-content-row');
+				div.classList.add('tooltip-content');
+				const squareBox = document.createElement('div');
+				squareBox.classList.add('pointSquare');
 
-	for (let i = 0; i < sortedValues.length; i++) {
-		const { textContent, color, focus } = sortedValues[i];
+				squareBox.style.borderColor = color;
 
-		const div = document.createElement('div');
-		div.classList.add('tooltip-content-row', 'tooltip-content');
+				const text = document.createElement('div');
+				text.classList.add('tooltip-data-point');
 
-		const squareBox = document.createElement('div');
-		squareBox.classList.add('pointSquare');
-		squareBox.style.borderColor = color;
+				text.textContent = textContent;
+				text.style.color = color;
 
-		const text = document.createElement('div');
-		text.classList.add('tooltip-data-point');
-		text.textContent = textContent;
-		text.style.color = color;
+				if (focus) {
+					text.classList.add('focus');
+				} else {
+					text.classList.remove('focus');
+				}
 
-		if (focus) {
-			text.classList.add('focus');
-		}
+				div.appendChild(squareBox);
+				div.appendChild(text);
 
-		div.appendChild(squareBox);
-		div.appendChild(text);
-		fragment.appendChild(div);
+				container.appendChild(div);
+			}
+		});
 	}
 
-	if (fragment.hasChildNodes()) {
-		container.appendChild(fragment);
+	if (overlay && overlay.style.display === 'none') {
+		overlay.style.display = 'block';
 	}
 
 	return container;
@@ -283,148 +266,80 @@ const tooltipPlugin = ({
 ToolTipPluginProps): any => {
 	let over: HTMLElement;
 	let bound: HTMLElement;
-	// Cache bounding box to avoid recalculating on every cursor move
-	let cachedBBox: DOMRect | null = null;
-	let isActive = false;
-	let overlay: HTMLElement | null = null;
+	let bLeft: any;
+	let bTop: any;
 
-	// Pre-compute apiResult once
-	const apiResult = apiResponse?.data?.result || [];
-
-	// Sync bounds and cache the result
 	const syncBounds = (): void => {
-		if (over) {
-			cachedBBox = over.getBoundingClientRect();
-		}
+		const bbox = over.getBoundingClientRect();
+		bLeft = bbox.left;
+		bTop = bbox.top;
 	};
 
-	// Create overlay once and reuse it
-	const initOverlay = (): void => {
-		if (!overlay) {
-			overlay = document.getElementById('overlay');
-			if (!overlay) {
-				overlay = document.createElement('div');
-				overlay.id = 'overlay';
-				overlay.style.cssText = 'display: none; position: absolute;';
-				document.body.appendChild(overlay);
-			}
-		}
-	};
+	let overlay = document.getElementById('overlay');
 
-	const showOverlay = (): void => {
-		if (overlay && overlay.style.display === 'none') {
-			overlay.style.display = 'block';
-		}
-	};
+	if (!overlay) {
+		overlay = document.createElement('div');
+		overlay.id = 'overlay';
+		overlay.style.display = 'none';
+		overlay.style.position = 'absolute';
+		document.body.appendChild(overlay);
+	}
 
-	const hideOverlay = (): void => {
-		if (overlay && overlay.style.display === 'block') {
-			overlay.style.display = 'none';
-		}
-	};
-
-	const plotEnter = (): void => {
-		isActive = true;
-		showOverlay();
-	};
-
-	const plotLeave = (): void => {
-		isActive = false;
-		hideOverlay();
-	};
-
-	// Cleanup function to remove event listeners
-	const cleanup = (): void => {
-		if (over) {
-			over.removeEventListener('mouseenter', plotEnter);
-			over.removeEventListener('mouseleave', plotLeave);
-		}
-	};
+	const apiResult = apiResponse?.data?.result || [];
 
 	return {
 		hooks: {
 			init: (u: any): void => {
 				over = u?.over;
 				bound = over;
-
-				// Initialize overlay once during init
-				initOverlay();
-
-				// Initial bounds sync
-				syncBounds();
-
-				over.addEventListener('mouseenter', plotEnter);
-				over.addEventListener('mouseleave', plotLeave);
+				over.onmouseenter = (): void => {
+					if (overlay) {
+						overlay.style.display = 'block';
+					}
+				};
+				over.onmouseleave = (): void => {
+					if (overlay) {
+						overlay.style.display = 'none';
+					}
+				};
 			},
 			setSize: (): void => {
-				// Re-sync bounds when size changes
 				syncBounds();
 			},
-			// Cache bounding box on syncRect for better performance
-			syncRect: (u: any, rect: DOMRect): void => {
-				cachedBBox = rect;
-			},
 			setCursor: (u: {
 				cursor: { left: any; top: any; idx: any };
 				data: any[];
 				series: uPlot.Options['series'];
 			}): void => {
-				if (!overlay) {
-					return;
-				}
+				if (overlay) {
+					overlay.textContent = '';
+					const { left, top, idx } = u.cursor;
 
-				const { left, top, idx } = u.cursor;
-
-				// Early return if not active or no valid index
-				if (!isActive || !Number.isInteger(idx)) {
-					if (isActive) {
-						// Clear tooltip content efficiently using replaceChildren
-						overlay.replaceChildren();
+					if (Number.isInteger(idx)) {
+						const anchor = { left: left + bLeft, top: top + bTop };
+						const content = generateTooltipContent(
+							apiResult,
+							u.data,
+							idx,
+							isDarkMode,
+							yAxisUnit,
+							decimalPrecision,
+							u.series,
+							isBillingUsageGraphs,
+							isHistogramGraphs,
+							isMergedSeries,
+							stackBarChart,
+							timezone,
+							colorMapping,
+							query,
+						);
+						if (customTooltipElement) {
+							content.appendChild(customTooltipElement);
+						}
+						overlay.appendChild(content);
+						placement(overlay, anchor, 'right', 'start', { bound });
 					}
-					return;
 				}
-
-				// Use cached bounding box if available
-				const bbox = cachedBBox || over.getBoundingClientRect();
-				const anchor = {
-					left: left + bbox.left,
-					top: top + bbox.top,
-				};
-
-				const content = generateTooltipContent(
-					apiResult,
-					u.data,
-					idx,
-					isDarkMode,
-					yAxisUnit,
-					decimalPrecision,
-					u.series,
-					isBillingUsageGraphs,
-					isHistogramGraphs,
-					isMergedSeries,
-					stackBarChart,
-					timezone,
-					colorMapping,
-					query,
-				);
-
-				// Only show tooltip if there's actual content
-				if (content.children.length > 1) {
-					if (customTooltipElement) {
-						content.appendChild(customTooltipElement);
-					}
-					// Clear and set new content in one operation
-					overlay.replaceChildren(content);
-					placement(overlay, anchor, 'right', 'start', { bound });
-					showOverlay();
-				} else {
-					hideOverlay();
-				}
-			},
-			destroy: (): void => {
-				// Cleanup on destroy
-				cleanup();
-				hideOverlay();
 			},
 		},
 	};

frontend/src/providers/Dashboard/Dashboard.tsx

@@ -202,7 +202,11 @@ export function DashboardProvider({
 		updateLocalStorageDashboardVariables,
 	} = useDashboardVariablesFromLocalStorage(dashboardId);
 
-	const { getUrlVariables, updateUrlVariable } = useVariablesFromUrl();
+	const {
+		getUrlVariables,
+		updateUrlVariable,
+		clearUrlVariables,
+	} = useVariablesFromUrl();
 
 	const updatedTimeRef = useRef<Dayjs | null>(null); // Using ref to store the updated time
 	const modalRef = useRef<any>(null);
@@ -214,6 +218,14 @@ export function DashboardProvider({
 
 	const [isDashboardFetching, setIsDashboardFetching] = useState<boolean>(false);
 
+	// Clear variable configs when not on dashboard pages
+	useEffect(() => {
+		const isOnDashboardPage = !!isDashboardPage || !!isDashboardWidgetPage;
+		if (!isOnDashboardPage) {
+			clearUrlVariables();
+		}
+	}, [isDashboardPage, isDashboardWidgetPage, clearUrlVariables]);
+
 	const mergeDBWithLocalStorage = (
 		data: Dashboard,
 		localStorageVariables: any,

frontend/src/providers/Dashboard/__tests__/Dashboard.test.tsx

@@ -121,6 +121,7 @@ function renderWithDashboardProvider(
 // Mock URL variables hook
 const mockGetUrlVariables = jest.fn();
 const mockUpdateUrlVariable = jest.fn();
+const mockClearUrlVariables = jest.fn();
 const mockSetUrlVariables = jest.fn();
 
 jest.mock('hooks/dashboard/useVariablesFromUrl', () => ({
@@ -128,6 +129,7 @@ jest.mock('hooks/dashboard/useVariablesFromUrl', () => ({
 	default: jest.fn(() => ({
 		getUrlVariables: mockGetUrlVariables,
 		updateUrlVariable: mockUpdateUrlVariable,
+		clearUrlVariables: mockClearUrlVariables,
 		setUrlVariables: mockSetUrlVariables,
 	})),
 }));
@@ -522,6 +524,16 @@ describe('Dashboard Provider - URL Variables Integration', () => {
 				expect(parsedVariables.environment.allSelected).toBe(false);
 			});
 		});
+
+		it('should clear URL variables when not on dashboard page', async () => {
+			mockUseRouteMatch.mockReturnValue(null); // Not on dashboard page
+
+			renderWithDashboardProvider('/other-page', null);
+
+			await waitFor(() => {
+				expect(mockClearUrlVariables).toHaveBeenCalled();
+			});
+		});
 	});
 
 	describe('Variable Value Normalization', () => {

frontend/src/types/api/trace/getSpanPercentiles.ts

@@ -1,21 +0,0 @@
-export interface GetSpanPercentilesProps {
-	start: number;
-	end: number;
-	spanDuration: number;
-	serviceName: string;
-	name: string;
-	resourceAttributes: Record<string, string>;
-}
-
-export interface GetSpanPercentilesResponseDataProps {
-	percentiles: Record<string, number>;
-	position: {
-		percentile: number;
-		description: string;
-	};
-}
-
-export interface GetSpanPercentilesResponsePayloadProps {
-	status: string;
-	data: GetSpanPercentilesResponseDataProps;
-}

pkg/modules/spanpercentile/implspanpercentile/module.go

@@ -99,9 +99,9 @@ func transformToSpanPercentileResponse(queryResult *qbtypes.QueryRangeResponse)
 		return nil, errors.New(errors.TypeNotFound, errors.CodeNotFound, "no spans found matching the specified criteria")
 	}
 
-	description := fmt.Sprintf("slower than %.1f%% of spans", position)
+	description := fmt.Sprintf("faster than %.1f%% of spans", position)
 	if position < 50 {
-		description = fmt.Sprintf("faster than %.1f%% of spans", 100-position)
+		description = fmt.Sprintf("slower than %.1f%% of spans", 100-position)
 	}
 
 	return &spanpercentiletypes.SpanPercentileResponse{

pkg/modules/user/impluser/module.go

@@ -374,12 +374,18 @@ func (module *Module) GetOrCreateUser(ctx context.Context, user *types.User, opt
 		return existingUser, nil
 	}
 
-	err = module.CreateUser(ctx, user, opts...)
+	newUser, err := types.NewUser(user.DisplayName, user.Email, user.Role, user.OrgID)
 	if err != nil {
 		return nil, err
 	}
 
-	return user, nil
+	err = module.CreateUser(ctx, newUser, opts...)
+	if err != nil {
+		return nil, err
+	}
+
+	return newUser, nil
+
 }
 
 func (m *Module) CreateAPIKey(ctx context.Context, apiKey *types.StorableAPIKey) error {

pkg/query-service/app/clickhouseReader/reader.go

@@ -1860,7 +1860,6 @@ func (r *ClickHouseReader) GetCustomRetentionTTL(ctx context.Context, orgID stri
 			response.DefaultTTLDays = 15
 			response.TTLConditions = []model.CustomRetentionRule{}
 			response.Status = constants.StatusFailed
-			response.ColdStorageTTLDays = -1
 			return response, nil
 		}
 
@@ -1895,7 +1894,6 @@ func (r *ClickHouseReader) GetCustomRetentionTTL(ctx context.Context, orgID stri
 		response.ExpectedLogsTime = ttlResult.ExpectedLogsTime
 		response.ExpectedLogsMoveTime = ttlResult.ExpectedLogsMoveTime
 		response.Status = ttlResult.Status
-		response.ColdStorageTTLDays = -1
 		if ttlResult.LogsTime > 0 {
 			response.DefaultTTLDays = ttlResult.LogsTime / 24
 		}

pkg/query-service/app/http_handler.go

@@ -816,6 +816,10 @@ func (aH *APIHandler) createDowntimeSchedule(w http.ResponseWriter, r *http.Requ
 		return
 	}
 
+	if len(schedule.RuleIDs) == 0 {
+		schedule.SilenceAll = true
+	}
+
 	_, err = aH.ruleManager.MaintenanceStore().CreatePlannedMaintenance(r.Context(), schedule)
 	if err != nil {
 		render.Error(w, err)
@@ -843,6 +847,10 @@ func (aH *APIHandler) editDowntimeSchedule(w http.ResponseWriter, r *http.Reques
 		return
 	}
 
+	if len(schedule.RuleIDs) == 0 {
+		schedule.SilenceAll = true
+	}
+
 	err = aH.ruleManager.MaintenanceStore().EditPlannedMaintenance(r.Context(), schedule, id)
 	if err != nil {
 		render.Error(w, err)

pkg/ruler/rulestore/rulestoretest/rule.go

@@ -79,6 +79,10 @@ func (m *MockSQLRuleStore) ExpectEditRule(rule *ruletypes.Rule) {
 
 // ExpectDeleteRule sets up SQL expectations for DeleteRule operation
 func (m *MockSQLRuleStore) ExpectDeleteRule(ruleID valuer.UUID) {
+	plannedMaintenancePattern := `DELETE FROM "planned_maintenance_rule".+WHERE \(rule_id = '` + ruleID.StringValue() + `'\)`
+	m.mock.ExpectExec(plannedMaintenancePattern).
+		WillReturnResult(sqlmock.NewResult(0, 1))
+
 	expectedPattern := `DELETE FROM "rule".+WHERE \(id = '` + ruleID.StringValue() + `'\)`
 	m.mock.ExpectExec(expectedPattern).
 		WillReturnResult(sqlmock.NewResult(1, 1))

pkg/ruler/rulestore/sqlrulestore/maintenance.go

@@ -78,6 +78,7 @@ func (r *maintenance) CreatePlannedMaintenance(ctx context.Context, maintenance
 		Description: maintenance.Description,
 		Schedule:    maintenance.Schedule,
 		OrgID:       claims.OrgID,
+		SilenceAll:  maintenance.SilenceAll,
 	}
 
 	maintenanceRules := make([]*ruletypes.StorablePlannedMaintenanceRule, 0)
@@ -163,6 +164,7 @@ func (r *maintenance) EditPlannedMaintenance(ctx context.Context, maintenance ru
 		Description: maintenance.Description,
 		Schedule:    maintenance.Schedule,
 		OrgID:       claims.OrgID,
+		SilenceAll:  maintenance.SilenceAll,
 	}
 
 	storablePlannedMaintenanceRules := make([]*ruletypes.StorablePlannedMaintenanceRule, 0)

pkg/ruler/rulestore/sqlrulestore/rule.go

@@ -44,6 +44,7 @@ func (r *rule) EditRule(ctx context.Context, storedRule *ruletypes.Rule, cb func
 			NewUpdate().
 			Model(storedRule).
 			Where("id = ?", storedRule.ID.StringValue()).
+			Where("deleted = ?", false).
 			Exec(ctx)
 		if err != nil {
 			return err
@@ -58,8 +59,20 @@ func (r *rule) DeleteRule(ctx context.Context, id valuer.UUID, cb func(context.C
 		_, err := r.sqlstore.
 			BunDBCtx(ctx).
 			NewDelete().
-			Model(new(ruletypes.Rule)).
+			Model(new(ruletypes.StorablePlannedMaintenanceRule)).
+			Where("rule_id = ?", id.StringValue()).
+			Exec(ctx)
+		if err != nil {
+			return err
+		}
+
+		_, err = r.sqlstore.
+			BunDBCtx(ctx).
+			NewUpdate().
+			Model((*ruletypes.Rule)(nil)).
+			Set("deleted = ?", true).
 			Where("id = ?", id.StringValue()).
+			Where("deleted = ?", false).
 			Exec(ctx)
 		if err != nil {
 			return err
@@ -79,7 +92,7 @@ func (r *rule) GetStoredRules(ctx context.Context, orgID string) ([]*ruletypes.R
 		BunDB().
 		NewSelect().
 		Model(&rules).
-		Where("org_id = ?", orgID).
+		Where("org_id = ?", orgID).Where("deleted = ?", false).
 		Scan(ctx)
 	if err != nil {
 		return rules, err
@@ -94,7 +107,7 @@ func (r *rule) GetStoredRule(ctx context.Context, id valuer.UUID) (*ruletypes.Ru
 		BunDB().
 		NewSelect().
 		Model(rule).
-		Where("id = ?", id.StringValue()).
+		Where("id = ?", id.StringValue()).Where("deleted = ?", false).
 		Scan(ctx)
 	if err != nil {
 		return nil, err

pkg/signoz/provider.go

@@ -138,6 +138,7 @@ func NewSQLMigrationProviderFactories(
 		sqlmigration.NewUpdateTTLSettingForCustomRetentionFactory(sqlstore, sqlschema),
 		sqlmigration.NewAddRoutePolicyFactory(sqlstore, sqlschema),
 		sqlmigration.NewAddAuthTokenFactory(sqlstore, sqlschema),
+		sqlmigration.NewAddSilenceAllColumnFactory(sqlstore, sqlschema),
 	)
 }
 

pkg/sqlmigration/051_add_silence_all_column.go

@@ -0,0 +1,155 @@
+package sqlmigration
+
+import (
+	"context"
+	"github.com/SigNoz/signoz/pkg/errors"
+	"github.com/SigNoz/signoz/pkg/factory"
+	"github.com/SigNoz/signoz/pkg/sqlschema"
+	"github.com/SigNoz/signoz/pkg/sqlstore"
+	"github.com/SigNoz/signoz/pkg/types"
+	"github.com/SigNoz/signoz/pkg/valuer"
+	"github.com/uptrace/bun"
+	"github.com/uptrace/bun/migrate"
+	"log/slog"
+)
+
+type addSilenceAllColumn struct {
+	sqlstore  sqlstore.SQLStore
+	sqlschema sqlschema.SQLSchema
+	logger    *slog.Logger
+}
+
+type plannedMaintenance struct {
+	bun.BaseModel `bun:"table:planned_maintenance"`
+	types.Identifiable
+	SilenceAll bool `bun:"silence_all,type:boolean"`
+}
+
+type plannedMaintenanceRule struct {
+	bun.BaseModel `bun:"table:planned_maintenance_rule"`
+	types.Identifiable
+	PlannedMaintenanceID valuer.UUID `bun:"planned_maintenance_id,type:text"`
+	RuleID               valuer.UUID `bun:"rule_id,type:text"`
+}
+
+func NewAddSilenceAllColumnFactory(sqlstore sqlstore.SQLStore, sqlschema sqlschema.SQLSchema) factory.ProviderFactory[SQLMigration, Config] {
+	return factory.NewProviderFactory(factory.MustNewName("add_silence_all_column"), func(ctx context.Context, providerSettings factory.ProviderSettings, config Config) (SQLMigration, error) {
+		return newAddSilenceAllColumn(ctx, providerSettings, config, sqlstore, sqlschema)
+	})
+}
+
+func newAddSilenceAllColumn(_ context.Context, settings factory.ProviderSettings, _ Config, sqlstore sqlstore.SQLStore, sqlschema sqlschema.SQLSchema) (SQLMigration, error) {
+	return &addSilenceAllColumn{
+		sqlstore:  sqlstore,
+		sqlschema: sqlschema,
+		logger:    settings.Logger,
+	}, nil
+}
+
+func (migration *addSilenceAllColumn) Register(migrations *migrate.Migrations) error {
+	if err := migrations.Register(migration.Up, migration.Down); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (migration *addSilenceAllColumn) Up(ctx context.Context, db *bun.DB) error {
+	table, _, err := migration.sqlschema.GetTable(ctx, sqlschema.TableName("planned_maintenance"))
+	if err != nil {
+		return err
+	}
+
+	for _, column := range table.Columns {
+		if column.Name == "silence_all" {
+			return nil
+		}
+	}
+
+	var joinTableBackup []plannedMaintenanceRule
+	err = db.NewSelect().
+		Model(&joinTableBackup).
+		Scan(ctx)
+	if err != nil {
+		return errors.NewInternalf(errors.CodeInternal, "failed to backup planned_maintenance_rule data: %v", err)
+	}
+
+	maintenanceIDsMap := make(map[string]bool)
+	for _, record := range joinTableBackup {
+		maintenanceIDsMap[record.PlannedMaintenanceID.StringValue()] = true
+	}
+	var maintenanceIDsWithRules []string
+	for id := range maintenanceIDsMap {
+		maintenanceIDsWithRules = append(maintenanceIDsWithRules, id)
+	}
+
+	tx, err := db.BeginTx(ctx, nil)
+	if err != nil {
+		return err
+	}
+
+	defer func() {
+		_ = tx.Rollback()
+	}()
+
+	sqls := [][]byte{}
+
+	column := &sqlschema.Column{
+		Name:     "silence_all",
+		DataType: sqlschema.DataTypeBoolean,
+		Nullable: false,
+		Default:  "false",
+	}
+
+	columnSQLs := migration.sqlschema.Operator().AddColumn(table, nil, column, nil)
+	sqls = append(sqls, columnSQLs...)
+
+	for _, sqlStmt := range sqls {
+		if _, err := tx.ExecContext(ctx, string(sqlStmt)); err != nil {
+			return err
+		}
+	}
+
+	if len(joinTableBackup) > 0 {
+		_, err = tx.NewInsert().
+			Model(&joinTableBackup).
+			Exec(ctx)
+		if err != nil {
+			return errors.NewInternalf(errors.CodeInternal, "failed to restore planned_maintenance_rule data: %v", err)
+		}
+	}
+
+	err = migration.backfillSilenceAll(ctx, tx, maintenanceIDsWithRules)
+	if err != nil {
+		return err
+	}
+
+	if err := tx.Commit(); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (migration *addSilenceAllColumn) backfillSilenceAll(ctx context.Context, tx bun.Tx, maintenanceIDsWithRules []string) error {
+	if len(maintenanceIDsWithRules) == 0 {
+		_, err := tx.NewUpdate().
+			Model((*plannedMaintenance)(nil)).
+			Set("silence_all = ?", true).
+			Where("1 = 1").
+			Exec(ctx)
+		return err
+	}
+
+	_, err := tx.NewUpdate().
+		Model((*plannedMaintenance)(nil)).
+		Set("silence_all = ?", true).
+		Where("id NOT IN (?)", bun.In(maintenanceIDsWithRules)).
+		Exec(ctx)
+
+	return err
+}
+
+func (migration *addSilenceAllColumn) Down(ctx context.Context, db *bun.DB) error {
+	return nil
+}

pkg/sqlstore/sqlitesqlstore/formatter.go

@@ -1,107 +0,0 @@
-package sqlitesqlstore
-
-import (
-	"github.com/SigNoz/signoz/pkg/sqlstore"
-	"github.com/uptrace/bun/schema"
-)
-
-type formatter struct {
-	bunf schema.Formatter
-}
-
-func newFormatter(dialect schema.Dialect) sqlstore.SQLFormatter {
-	return &formatter{bunf: schema.NewFormatter(dialect)}
-}
-
-func (f *formatter) JSONExtractString(column, path string) []byte {
-	var sql []byte
-	sql = append(sql, "json_extract("...)
-	sql = f.bunf.AppendIdent(sql, column)
-	sql = append(sql, ", "...)
-	sql = schema.Append(f.bunf, sql, path)
-	sql = append(sql, ")"...)
-	return sql
-}
-
-func (f *formatter) JSONType(column, path string) []byte {
-	var sql []byte
-	sql = append(sql, "json_type("...)
-	sql = f.bunf.AppendIdent(sql, column)
-	sql = append(sql, ", "...)
-	sql = schema.Append(f.bunf, sql, path)
-	sql = append(sql, ")"...)
-	return sql
-}
-
-func (f *formatter) JSONIsArray(column, path string) []byte {
-	var sql []byte
-	sql = append(sql, f.JSONType(column, path)...)
-	sql = append(sql, " = "...)
-	sql = schema.Append(f.bunf, sql, "array")
-	return sql
-}
-
-func (f *formatter) JSONArrayElements(column, path, alias string) ([]byte, []byte) {
-	var sql []byte
-	sql = append(sql, "json_each("...)
-	sql = f.bunf.AppendIdent(sql, column)
-	if path != "$" && path != "" {
-		sql = append(sql, ", "...)
-		sql = schema.Append(f.bunf, sql, path)
-	}
-	sql = append(sql, ") AS "...)
-	sql = f.bunf.AppendIdent(sql, alias)
-
-	return sql, append([]byte(alias), ".value"...)
-}
-
-func (f *formatter) JSONArrayOfStrings(column, path, alias string) ([]byte, []byte) {
-	return f.JSONArrayElements(column, path, alias)
-}
-
-func (f *formatter) JSONKeys(column, path, alias string) ([]byte, []byte) {
-	var sql []byte
-	sql = append(sql, "json_each("...)
-	sql = f.bunf.AppendIdent(sql, column)
-	if path != "$" && path != "" {
-		sql = append(sql, ", "...)
-		sql = schema.Append(f.bunf, sql, path)
-	}
-	sql = append(sql, ") AS "...)
-	sql = f.bunf.AppendIdent(sql, alias)
-
-	return sql, append([]byte(alias), ".key"...)
-}
-
-func (f *formatter) JSONArrayAgg(expression string) []byte {
-	var sql []byte
-	sql = append(sql, "json_group_array("...)
-	sql = append(sql, expression...)
-	sql = append(sql, ')')
-	return sql
-}
-
-func (f *formatter) JSONArrayLiteral(values ...string) []byte {
-	var sql []byte
-	sql = append(sql, "json_array("...)
-	for idx, value := range values {
-		if idx > 0 {
-			sql = append(sql, ", "...)
-		}
-		sql = schema.Append(f.bunf, sql, value)
-	}
-	sql = append(sql, ')')
-	return sql
-}
-
-func (f *formatter) TextToJsonColumn(column string) []byte {
-	return f.bunf.AppendIdent([]byte{}, column)
-}
-
-func (f *formatter) LowerExpression(expression string) []byte {
-	var sql []byte
-	sql = append(sql, "lower("...)
-	sql = append(sql, expression...)
-	sql = append(sql, ')')
-	return sql
-}

pkg/sqlstore/sqlitesqlstore/formatter_test.go

@@ -1,422 +0,0 @@
-package sqlitesqlstore
-
-import (
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/uptrace/bun/dialect/sqlitedialect"
-)
-
-func TestJSONExtractString(t *testing.T) {
-	tests := []struct {
-		name     string
-		column   string
-		path     string
-		expected string
-	}{
-		{
-			name:     "simple path",
-			column:   "data",
-			path:     "$.field",
-			expected: `json_extract("data", '$.field')`,
-		},
-		{
-			name:     "nested path",
-			column:   "metadata",
-			path:     "$.user.name",
-			expected: `json_extract("metadata", '$.user.name')`,
-		},
-		{
-			name:     "root path",
-			column:   "json_col",
-			path:     "$",
-			expected: `json_extract("json_col", '$')`,
-		},
-		{
-			name:     "root path",
-			column:   "json_col",
-			path:     "",
-			expected: `json_extract("json_col", '')`,
-		},
-		{
-			name:     "array index path",
-			column:   "items",
-			path:     "$.list[0]",
-			expected: `json_extract("items", '$.list[0]')`,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			f := newFormatter(sqlitedialect.New())
-			got := string(f.JSONExtractString(tt.column, tt.path))
-			assert.Equal(t, tt.expected, got)
-		})
-	}
-}
-
-func TestJSONType(t *testing.T) {
-	tests := []struct {
-		name     string
-		column   string
-		path     string
-		expected string
-	}{
-		{
-			name:     "simple path",
-			column:   "data",
-			path:     "$.field",
-			expected: `json_type("data", '$.field')`,
-		},
-		{
-			name:     "nested path",
-			column:   "metadata",
-			path:     "$.user.age",
-			expected: `json_type("metadata", '$.user.age')`,
-		},
-		{
-			name:     "root path",
-			column:   "json_col",
-			path:     "$",
-			expected: `json_type("json_col", '$')`,
-		},
-		{
-			name:     "root path",
-			column:   "json_col",
-			path:     "",
-			expected: `json_type("json_col", '')`,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			f := newFormatter(sqlitedialect.New())
-			got := string(f.JSONType(tt.column, tt.path))
-			assert.Equal(t, tt.expected, got)
-		})
-	}
-}
-
-func TestJSONIsArray(t *testing.T) {
-	tests := []struct {
-		name     string
-		column   string
-		path     string
-		expected string
-	}{
-		{
-			name:     "simple path",
-			column:   "data",
-			path:     "$.items",
-			expected: `json_type("data", '$.items') = 'array'`,
-		},
-		{
-			name:     "nested path",
-			column:   "metadata",
-			path:     "$.user.tags",
-			expected: `json_type("metadata", '$.user.tags') = 'array'`,
-		},
-		{
-			name:     "root path",
-			column:   "json_col",
-			path:     "$",
-			expected: `json_type("json_col", '$') = 'array'`,
-		},
-		{
-			name:     "root path",
-			column:   "json_col",
-			path:     "",
-			expected: `json_type("json_col", '') = 'array'`,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			f := newFormatter(sqlitedialect.New())
-			got := string(f.JSONIsArray(tt.column, tt.path))
-			assert.Equal(t, tt.expected, got)
-		})
-	}
-}
-
-func TestJSONArrayElements(t *testing.T) {
-	tests := []struct {
-		name     string
-		column   string
-		path     string
-		alias    string
-		expected string
-	}{
-		{
-			name:     "root path with dollar sign",
-			column:   "data",
-			path:     "$",
-			alias:    "elem",
-			expected: `json_each("data") AS "elem"`,
-		},
-		{
-			name:     "root path empty",
-			column:   "data",
-			path:     "",
-			alias:    "elem",
-			expected: `json_each("data") AS "elem"`,
-		},
-		{
-			name:     "nested path",
-			column:   "metadata",
-			path:     "$.items",
-			alias:    "item",
-			expected: `json_each("metadata", '$.items') AS "item"`,
-		},
-		{
-			name:     "deeply nested path",
-			column:   "json_col",
-			path:     "$.user.tags",
-			alias:    "tag",
-			expected: `json_each("json_col", '$.user.tags') AS "tag"`,
-		},
-		{
-			name:     "nested path",
-			column:   "metadata",
-			path:     "",
-			alias:    "item",
-			expected: `json_each("metadata") AS "item"`,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			f := newFormatter(sqlitedialect.New())
-			got, _ := f.JSONArrayElements(tt.column, tt.path, tt.alias)
-			assert.Equal(t, tt.expected, string(got))
-		})
-	}
-}
-
-func TestJSONArrayOfStrings(t *testing.T) {
-	tests := []struct {
-		name     string
-		column   string
-		path     string
-		alias    string
-		expected string
-	}{
-		{
-			name:     "root path with dollar sign",
-			column:   "data",
-			path:     "$",
-			alias:    "str",
-			expected: `json_each("data") AS "str"`,
-		},
-		{
-			name:     "root path empty",
-			column:   "data",
-			path:     "",
-			alias:    "str",
-			expected: `json_each("data") AS "str"`,
-		},
-		{
-			name:     "nested path",
-			column:   "metadata",
-			path:     "$.strings",
-			alias:    "s",
-			expected: `json_each("metadata", '$.strings') AS "s"`,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			f := newFormatter(sqlitedialect.New())
-			got, _ := f.JSONArrayOfStrings(tt.column, tt.path, tt.alias)
-			assert.Equal(t, tt.expected, string(got))
-		})
-	}
-}
-
-func TestJSONKeys(t *testing.T) {
-	tests := []struct {
-		name     string
-		column   string
-		path     string
-		alias    string
-		expected string
-	}{
-		{
-			name:     "root path with dollar sign",
-			column:   "data",
-			path:     "$",
-			alias:    "k",
-			expected: `json_each("data") AS "k"`,
-		},
-		{
-			name:     "root path empty",
-			column:   "data",
-			path:     "",
-			alias:    "k",
-			expected: `json_each("data") AS "k"`,
-		},
-		{
-			name:     "nested path",
-			column:   "metadata",
-			path:     "$.object",
-			alias:    "key",
-			expected: `json_each("metadata", '$.object') AS "key"`,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			f := newFormatter(sqlitedialect.New())
-			got, _ := f.JSONKeys(tt.column, tt.path, tt.alias)
-			assert.Equal(t, tt.expected, string(got))
-		})
-	}
-}
-
-func TestJSONArrayAgg(t *testing.T) {
-	tests := []struct {
-		name       string
-		expression string
-		expected   string
-	}{
-		{
-			name:       "simple column",
-			expression: "id",
-			expected:   "json_group_array(id)",
-		},
-		{
-			name:       "expression with function",
-			expression: "DISTINCT name",
-			expected:   "json_group_array(DISTINCT name)",
-		},
-		{
-			name:       "complex expression",
-			expression: "json_extract(data, '$.field')",
-			expected:   "json_group_array(json_extract(data, '$.field'))",
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			f := newFormatter(sqlitedialect.New())
-			got := string(f.JSONArrayAgg(tt.expression))
-			assert.Equal(t, tt.expected, got)
-		})
-	}
-}
-
-func TestJSONArrayLiteral(t *testing.T) {
-	tests := []struct {
-		name     string
-		values   []string
-		expected string
-	}{
-		{
-			name:     "empty array",
-			values:   []string{},
-			expected: "json_array()",
-		},
-		{
-			name:     "single value",
-			values:   []string{"value1"},
-			expected: "json_array('value1')",
-		},
-		{
-			name:     "multiple values",
-			values:   []string{"value1", "value2", "value3"},
-			expected: "json_array('value1', 'value2', 'value3')",
-		},
-		{
-			name:     "values with special characters",
-			values:   []string{"test", "with space", "with-dash"},
-			expected: "json_array('test', 'with space', 'with-dash')",
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			f := newFormatter(sqlitedialect.New())
-			got := string(f.JSONArrayLiteral(tt.values...))
-			assert.Equal(t, tt.expected, got)
-		})
-	}
-}
-
-func TestTextToJsonColumn(t *testing.T) {
-	tests := []struct {
-		name     string
-		column   string
-		expected string
-	}{
-		{
-			name:     "simple column name",
-			column:   "data",
-			expected: `"data"`,
-		},
-		{
-			name:     "column with underscore",
-			column:   "user_data",
-			expected: `"user_data"`,
-		},
-		{
-			name:     "column with special characters",
-			column:   "json-col",
-			expected: `"json-col"`,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			f := newFormatter(sqlitedialect.New())
-			got := string(f.TextToJsonColumn(tt.column))
-			assert.Equal(t, tt.expected, got)
-		})
-	}
-}
-
-func TestLowerExpression(t *testing.T) {
-	tests := []struct {
-		name     string
-		expr     string
-		expected string
-	}{
-		{
-			name:     "json_extract expression",
-			expr:     "json_extract(data, '$.field')",
-			expected: "lower(json_extract(data, '$.field'))",
-		},
-		{
-			name:     "nested json_extract",
-			expr:     "json_extract(metadata, '$.user.name')",
-			expected: "lower(json_extract(metadata, '$.user.name'))",
-		},
-		{
-			name:     "json_type expression",
-			expr:     "json_type(data, '$.field')",
-			expected: "lower(json_type(data, '$.field'))",
-		},
-		{
-			name:     "string concatenation",
-			expr:     "first_name || ' ' || last_name",
-			expected: "lower(first_name || ' ' || last_name)",
-		},
-		{
-			name:     "CAST expression",
-			expr:     "CAST(value AS TEXT)",
-			expected: "lower(CAST(value AS TEXT))",
-		},
-		{
-			name:     "COALESCE expression",
-			expr:     "COALESCE(name, 'default')",
-			expected: "lower(COALESCE(name, 'default'))",
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			f := newFormatter(sqlitedialect.New())
-			got := string(f.LowerExpression(tt.expr))
-			assert.Equal(t, tt.expected, got)
-		})
-	}
-}

pkg/sqlstore/sqlitesqlstore/provider.go

@@ -17,11 +17,10 @@ import (
 )
 
 type provider struct {
-	settings  factory.ScopedProviderSettings
-	sqldb     *sql.DB
-	bundb     *sqlstore.BunDB
-	dialect   *dialect
-	formatter sqlstore.SQLFormatter
+	settings factory.ScopedProviderSettings
+	sqldb    *sql.DB
+	bundb    *sqlstore.BunDB
+	dialect  *dialect
 }
 
 func NewFactory(hookFactories ...factory.ProviderFactory[sqlstore.SQLStoreHook, sqlstore.Config]) factory.ProviderFactory[sqlstore.SQLStore, sqlstore.Config] {
@@ -55,14 +54,11 @@ func New(ctx context.Context, providerSettings factory.ProviderSettings, config
 	settings.Logger().InfoContext(ctx, "connected to sqlite", "path", config.Sqlite.Path)
 	sqldb.SetMaxOpenConns(config.Connection.MaxOpenConns)
 
-	sqliteDialect := sqlitedialect.New()
-	bunDB := sqlstore.NewBunDB(settings, sqldb, sqliteDialect, hooks)
 	return &provider{
-		settings:  settings,
-		sqldb:     sqldb,
-		bundb:     bunDB,
-		dialect:   new(dialect),
-		formatter: newFormatter(bunDB.Dialect()),
+		settings: settings,
+		sqldb:    sqldb,
+		bundb:    sqlstore.NewBunDB(settings, sqldb, sqlitedialect.New(), hooks),
+		dialect:  new(dialect),
 	}, nil
 }
 
@@ -78,10 +74,6 @@ func (provider *provider) Dialect() sqlstore.SQLDialect {
 	return provider.dialect
 }
 
-func (provider *provider) Formatter() sqlstore.SQLFormatter {
-	return provider.formatter
-}
-
 func (provider *provider) BunDBCtx(ctx context.Context) bun.IDB {
 	return provider.bundb.BunDBCtx(ctx)
 }

pkg/sqlstore/sqlstore.go

@@ -20,8 +20,6 @@ type SQLStore interface {
 	// Returns the dialect of the database.
 	Dialect() SQLDialect
 
-	Formatter() SQLFormatter
-
 	// RunInTxCtx runs the given callback in a transaction. It creates and injects a new context with the transaction.
 	// If a transaction is present in the context, it will be used.
 	RunInTxCtx(ctx context.Context, opts *SQLStoreTxOptions, cb func(ctx context.Context) error) error
@@ -88,35 +86,3 @@ type SQLDialect interface {
 	// as an argument.
 	ToggleForeignKeyConstraint(ctx context.Context, bun *bun.DB, enable bool) error
 }
-
-type SQLFormatter interface {
-	// JSONExtractString takes a JSON path (e.g., "$.labels.severity")
-	JSONExtractString(column, path string) []byte
-
-	// JSONType used to determine the type of the value extracted from the path
-	JSONType(column, path string) []byte
-
-	// JSONIsArray used to check whether the value is array or not
-	JSONIsArray(column, path string) []byte
-
-	// JSONArrayElements returns query as well as columns alias to be used for select and where clause
-	JSONArrayElements(column, path, alias string) ([]byte, []byte)
-
-	// JSONArrayOfStrings returns query as well as columns alias to be used for select and where clause
-	JSONArrayOfStrings(column, path, alias string) ([]byte, []byte)
-
-	// JSONArrayAgg aggregates values into a JSON array
-	JSONArrayAgg(expression string) []byte
-
-	// JSONArrayLiteral creates a literal JSON array from the given string values
-	JSONArrayLiteral(values ...string) []byte
-
-	// JSONKeys return extracted key from json as well as alias to be used for select and where clause
-	JSONKeys(column, path, alias string) ([]byte, []byte)
-
-	// TextToJsonColumn converts a text column to JSON type
-	TextToJsonColumn(column string) []byte
-
-	// LowerExpression wraps any SQL expression with lower() function for case-insensitive operations
-	LowerExpression(expression string) []byte
-}

pkg/sqlstore/sqlstoretest/formatter.go

@@ -1,107 +0,0 @@
-package sqlstoretest
-
-import (
-	"github.com/SigNoz/signoz/pkg/sqlstore"
-	"github.com/uptrace/bun/schema"
-)
-
-type formatter struct {
-	bunf schema.Formatter
-}
-
-func newFormatter(dialect schema.Dialect) sqlstore.SQLFormatter {
-	return &formatter{bunf: schema.NewFormatter(dialect)}
-}
-
-func (f *formatter) JSONExtractString(column, path string) []byte {
-	var sql []byte
-	sql = append(sql, "json_extract("...)
-	sql = f.bunf.AppendIdent(sql, column)
-	sql = append(sql, ", "...)
-	sql = schema.Append(f.bunf, sql, path)
-	sql = append(sql, ")"...)
-	return sql
-}
-
-func (f *formatter) JSONType(column, path string) []byte {
-	var sql []byte
-	sql = append(sql, "json_type("...)
-	sql = f.bunf.AppendIdent(sql, column)
-	sql = append(sql, ", "...)
-	sql = schema.Append(f.bunf, sql, path)
-	sql = append(sql, ")"...)
-	return sql
-}
-
-func (f *formatter) JSONIsArray(column, path string) []byte {
-	var sql []byte
-	sql = append(sql, f.JSONType(column, path)...)
-	sql = append(sql, " = "...)
-	sql = schema.Append(f.bunf, sql, "array")
-	return sql
-}
-
-func (f *formatter) JSONArrayElements(column, path, alias string) ([]byte, []byte) {
-	var sql []byte
-	sql = append(sql, "json_each("...)
-	sql = f.bunf.AppendIdent(sql, column)
-	if path != "$" && path != "" {
-		sql = append(sql, ", "...)
-		sql = schema.Append(f.bunf, sql, path)
-	}
-	sql = append(sql, ") AS "...)
-	sql = f.bunf.AppendIdent(sql, alias)
-
-	return sql, append([]byte(alias), ".value"...)
-}
-
-func (f *formatter) JSONArrayOfStrings(column, path, alias string) ([]byte, []byte) {
-	return f.JSONArrayElements(column, path, alias)
-}
-
-func (f *formatter) JSONKeys(column, path, alias string) ([]byte, []byte) {
-	var sql []byte
-	sql = append(sql, "json_each("...)
-	sql = f.bunf.AppendIdent(sql, column)
-	if path != "$" && path != "" {
-		sql = append(sql, ", "...)
-		sql = schema.Append(f.bunf, sql, path)
-	}
-	sql = append(sql, ") AS "...)
-	sql = f.bunf.AppendIdent(sql, alias)
-
-	return sql, append([]byte(alias), ".key"...)
-}
-
-func (f *formatter) JSONArrayAgg(expression string) []byte {
-	var sql []byte
-	sql = append(sql, "json_group_array("...)
-	sql = append(sql, expression...)
-	sql = append(sql, ')')
-	return sql
-}
-
-func (f *formatter) JSONArrayLiteral(values ...string) []byte {
-	var sql []byte
-	sql = append(sql, "json_array("...)
-	for idx, value := range values {
-		if idx > 0 {
-			sql = append(sql, ", "...)
-		}
-		sql = schema.Append(f.bunf, sql, value)
-	}
-	sql = append(sql, ')')
-	return sql
-}
-
-func (f *formatter) TextToJsonColumn(column string) []byte {
-	return f.bunf.AppendIdent([]byte{}, column)
-}
-
-func (f *formatter) LowerExpression(expression string) []byte {
-	var sql []byte
-	sql = append(sql, "lower("...)
-	sql = append(sql, expression...)
-	sql = append(sql, ')')
-	return sql
-}

pkg/sqlstore/sqlstoretest/provider.go

@@ -15,11 +15,10 @@ import (
 var _ sqlstore.SQLStore = (*Provider)(nil)
 
 type Provider struct {
-	db        *sql.DB
-	mock      sqlmock.Sqlmock
-	bunDB     *bun.DB
-	dialect   *dialect
-	formatter sqlstore.SQLFormatter
+	db      *sql.DB
+	mock    sqlmock.Sqlmock
+	bunDB   *bun.DB
+	dialect *dialect
 }
 
 func New(config sqlstore.Config, matcher sqlmock.QueryMatcher) *Provider {
@@ -39,11 +38,10 @@ func New(config sqlstore.Config, matcher sqlmock.QueryMatcher) *Provider {
 	}
 
 	return &Provider{
-		db:        db,
-		mock:      mock,
-		bunDB:     bunDB,
-		dialect:   new(dialect),
-		formatter: newFormatter(bunDB.Dialect()),
+		db:      db,
+		mock:    mock,
+		bunDB:   bunDB,
+		dialect: new(dialect),
 	}
 }
 
@@ -63,8 +61,6 @@ func (provider *Provider) Dialect() sqlstore.SQLDialect {
 	return provider.dialect
 }
 
-func (provider *Provider) Formatter() sqlstore.SQLFormatter { return provider.formatter }
-
 func (provider *Provider) BunDBCtx(ctx context.Context) bun.IDB {
 	return provider.bunDB
 }

pkg/types/ruletypes/maintenance.go

@@ -24,6 +24,7 @@ type StorablePlannedMaintenance struct {
 	Description string    `bun:"description,type:text"`
 	Schedule    *Schedule `bun:"schedule,type:text,notnull"`
 	OrgID       string    `bun:"org_id,type:text"`
+	SilenceAll  bool      `bun:"silence_all,type:boolean"`
 }
 
 type GettablePlannedMaintenance struct {
@@ -38,6 +39,7 @@ type GettablePlannedMaintenance struct {
 	UpdatedBy   string    `json:"updatedBy"`
 	Status      string    `json:"status"`
 	Kind        string    `json:"kind"`
+	SilenceAll  bool      `json:"silenceAll"`
 }
 
 type StorablePlannedMaintenanceRule struct {
@@ -64,7 +66,7 @@ func (m *GettablePlannedMaintenance) ShouldSkip(ruleID string, now time.Time) bo
 		}
 	}
 	// If no alert ids, then skip all alerts
-	if len(m.RuleIDs) == 0 {
+	if m.SilenceAll {
 		found = true
 	}
 
@@ -295,6 +297,7 @@ func (m GettablePlannedMaintenance) MarshalJSON() ([]byte, error) {
 		UpdatedBy   string    `json:"updatedBy" db:"updated_by"`
 		Status      string    `json:"status"`
 		Kind        string    `json:"kind"`
+		SilenceAll  bool      `json:"silenceAll" db:"silence_all"`
 	}{
 		Id:          m.Id,
 		Name:        m.Name,
@@ -307,6 +310,7 @@ func (m GettablePlannedMaintenance) MarshalJSON() ([]byte, error) {
 		UpdatedBy:   m.UpdatedBy,
 		Status:      status,
 		Kind:        kind,
+		SilenceAll:  m.SilenceAll,
 	})
 }
 
@@ -328,6 +332,7 @@ func (m *GettablePlannedMaintenanceRule) ConvertGettableMaintenanceRuleToGettabl
 		UpdatedAt:   m.UpdatedAt,
 		CreatedBy:   m.CreatedBy,
 		UpdatedBy:   m.UpdatedBy,
+		SilenceAll:  m.SilenceAll,
 	}
 }
 

pkg/types/ruletypes/maintenance_test.go

@@ -21,6 +21,7 @@ func TestShouldSkipMaintenance(t *testing.T) {
 		{
 			name: "only-on-saturday",
 			maintenance: &GettablePlannedMaintenance{
+				SilenceAll: true,
 				Schedule: &Schedule{
 					Timezone: "Europe/London",
 					Recurrence: &Recurrence{
@@ -38,6 +39,7 @@ func TestShouldSkipMaintenance(t *testing.T) {
 		{
 			name: "weekly-across-midnight-previous-day",
 			maintenance: &GettablePlannedMaintenance{
+				SilenceAll: true,
 				Schedule: &Schedule{
 					Timezone: "UTC",
 					Recurrence: &Recurrence{
@@ -55,6 +57,7 @@ func TestShouldSkipMaintenance(t *testing.T) {
 		{
 			name: "weekly-across-midnight-previous-day",
 			maintenance: &GettablePlannedMaintenance{
+				SilenceAll: true,
 				Schedule: &Schedule{
 					Timezone: "UTC",
 					Recurrence: &Recurrence{
@@ -72,6 +75,7 @@ func TestShouldSkipMaintenance(t *testing.T) {
 		{
 			name: "weekly-across-midnight-previous-day",
 			maintenance: &GettablePlannedMaintenance{
+				SilenceAll: true,
 				Schedule: &Schedule{
 					Timezone: "UTC",
 					Recurrence: &Recurrence{
@@ -89,6 +93,7 @@ func TestShouldSkipMaintenance(t *testing.T) {
 		{
 			name: "weekly-across-midnight-previous-day-not-in-repeaton",
 			maintenance: &GettablePlannedMaintenance{
+				SilenceAll: true,
 				Schedule: &Schedule{
 					Timezone: "UTC",
 					Recurrence: &Recurrence{
@@ -106,6 +111,7 @@ func TestShouldSkipMaintenance(t *testing.T) {
 		{
 			name: "daily-maintenance-across-midnight",
 			maintenance: &GettablePlannedMaintenance{
+				SilenceAll: true,
 				Schedule: &Schedule{
 					Timezone: "UTC",
 					Recurrence: &Recurrence{
@@ -122,6 +128,7 @@ func TestShouldSkipMaintenance(t *testing.T) {
 		{
 			name: "at-start-time-boundary",
 			maintenance: &GettablePlannedMaintenance{
+				SilenceAll: true,
 				Schedule: &Schedule{
 					Timezone: "UTC",
 					Recurrence: &Recurrence{
@@ -138,6 +145,7 @@ func TestShouldSkipMaintenance(t *testing.T) {
 		{
 			name: "at-end-time-boundary",
 			maintenance: &GettablePlannedMaintenance{
+				SilenceAll: true,
 				Schedule: &Schedule{
 					Timezone: "UTC",
 					Recurrence: &Recurrence{
@@ -154,6 +162,7 @@ func TestShouldSkipMaintenance(t *testing.T) {
 		{
 			name: "monthly-multi-day-duration",
 			maintenance: &GettablePlannedMaintenance{
+				SilenceAll: true,
 				Schedule: &Schedule{
 					Timezone: "UTC",
 					Recurrence: &Recurrence{
@@ -170,6 +179,7 @@ func TestShouldSkipMaintenance(t *testing.T) {
 		{
 			name: "weekly-multi-day-duration",
 			maintenance: &GettablePlannedMaintenance{
+				SilenceAll: true,
 				Schedule: &Schedule{
 					Timezone: "UTC",
 					Recurrence: &Recurrence{
@@ -187,6 +197,7 @@ func TestShouldSkipMaintenance(t *testing.T) {
 		{
 			name: "monthly-crosses-to-next-month",
 			maintenance: &GettablePlannedMaintenance{
+				SilenceAll: true,
 				Schedule: &Schedule{
 					Timezone: "UTC",
 					Recurrence: &Recurrence{
@@ -203,6 +214,7 @@ func TestShouldSkipMaintenance(t *testing.T) {
 		{
 			name: "timezone-offset-test",
 			maintenance: &GettablePlannedMaintenance{
+				SilenceAll: true,
 				Schedule: &Schedule{
 					Timezone: "America/New_York", // UTC-5 or UTC-4 depending on DST
 					Recurrence: &Recurrence{
@@ -219,6 +231,7 @@ func TestShouldSkipMaintenance(t *testing.T) {
 		{
 			name: "daily-maintenance-time-outside-window",
 			maintenance: &GettablePlannedMaintenance{
+				SilenceAll: true,
 				Schedule: &Schedule{
 					Timezone: "UTC",
 					Recurrence: &Recurrence{
@@ -235,6 +248,7 @@ func TestShouldSkipMaintenance(t *testing.T) {
 		{
 			name: "recurring-maintenance-with-past-end-date",
 			maintenance: &GettablePlannedMaintenance{
+				SilenceAll: true,
 				Schedule: &Schedule{
 					Timezone: "UTC",
 					Recurrence: &Recurrence{
@@ -252,6 +266,7 @@ func TestShouldSkipMaintenance(t *testing.T) {
 		{
 			name: "monthly-maintenance-spans-month-end",
 			maintenance: &GettablePlannedMaintenance{
+				SilenceAll: true,
 				Schedule: &Schedule{
 					Timezone: "UTC",
 					Recurrence: &Recurrence{
@@ -268,6 +283,7 @@ func TestShouldSkipMaintenance(t *testing.T) {
 		{
 			name: "weekly-empty-repeaton",
 			maintenance: &GettablePlannedMaintenance{
+				SilenceAll: true,
 				Schedule: &Schedule{
 					Timezone: "UTC",
 					Recurrence: &Recurrence{
@@ -285,6 +301,7 @@ func TestShouldSkipMaintenance(t *testing.T) {
 		{
 			name: "monthly-maintenance-february-fewer-days",
 			maintenance: &GettablePlannedMaintenance{
+				SilenceAll: true,
 				Schedule: &Schedule{
 					Timezone: "UTC",
 					Recurrence: &Recurrence{
@@ -300,6 +317,7 @@ func TestShouldSkipMaintenance(t *testing.T) {
 		{
 			name: "daily-maintenance-crosses-midnight",
 			maintenance: &GettablePlannedMaintenance{
+				SilenceAll: true,
 				Schedule: &Schedule{
 					Timezone: "UTC",
 					Recurrence: &Recurrence{
@@ -315,6 +333,7 @@ func TestShouldSkipMaintenance(t *testing.T) {
 		{
 			name: "monthly-maintenance-crosses-month-end",
 			maintenance: &GettablePlannedMaintenance{
+				SilenceAll: true,
 				Schedule: &Schedule{
 					Timezone: "UTC",
 					Recurrence: &Recurrence{
@@ -330,6 +349,7 @@ func TestShouldSkipMaintenance(t *testing.T) {
 		{
 			name: "monthly-maintenance-crosses-month-end-and-duration-is-2-days",
 			maintenance: &GettablePlannedMaintenance{
+				SilenceAll: true,
 				Schedule: &Schedule{
 					Timezone: "UTC",
 					Recurrence: &Recurrence{
@@ -345,6 +365,7 @@ func TestShouldSkipMaintenance(t *testing.T) {
 		{
 			name: "weekly-maintenance-crosses-midnight",
 			maintenance: &GettablePlannedMaintenance{
+				SilenceAll: true,
 				Schedule: &Schedule{
 					Timezone: "UTC",
 					Recurrence: &Recurrence{
@@ -361,6 +382,7 @@ func TestShouldSkipMaintenance(t *testing.T) {
 		{
 			name: "monthly-maintenance-crosses-month-end-and-duration-is-2-days",
 			maintenance: &GettablePlannedMaintenance{
+				SilenceAll: true,
 				Schedule: &Schedule{
 					Timezone: "UTC",
 					Recurrence: &Recurrence{
@@ -376,6 +398,7 @@ func TestShouldSkipMaintenance(t *testing.T) {
 		{
 			name: "daily-maintenance-crosses-midnight",
 			maintenance: &GettablePlannedMaintenance{
+				SilenceAll: true,
 				Schedule: &Schedule{
 					Timezone: "UTC",
 					Recurrence: &Recurrence{
@@ -391,6 +414,7 @@ func TestShouldSkipMaintenance(t *testing.T) {
 		{
 			name: "monthly-maintenance-crosses-month-end-and-duration-is-2-hours",
 			maintenance: &GettablePlannedMaintenance{
+				SilenceAll: true,
 				Schedule: &Schedule{
 					Timezone: "UTC",
 					Recurrence: &Recurrence{
@@ -406,6 +430,7 @@ func TestShouldSkipMaintenance(t *testing.T) {
 		{
 			name: "fixed planned maintenance start <= ts <= end",
 			maintenance: &GettablePlannedMaintenance{
+				SilenceAll: true,
 				Schedule: &Schedule{
 					Timezone:  "UTC",
 					StartTime: time.Now().UTC().Add(-time.Hour),
@@ -418,6 +443,7 @@ func TestShouldSkipMaintenance(t *testing.T) {
 		{
 			name: "fixed planned maintenance start >= ts",
 			maintenance: &GettablePlannedMaintenance{
+				SilenceAll: true,
 				Schedule: &Schedule{
 					Timezone:  "UTC",
 					StartTime: time.Now().UTC().Add(time.Hour),
@@ -430,6 +456,7 @@ func TestShouldSkipMaintenance(t *testing.T) {
 		{
 			name: "fixed planned maintenance ts < start",
 			maintenance: &GettablePlannedMaintenance{
+				SilenceAll: true,
 				Schedule: &Schedule{
 					Timezone:  "UTC",
 					StartTime: time.Now().UTC().Add(time.Hour),
@@ -442,6 +469,7 @@ func TestShouldSkipMaintenance(t *testing.T) {
 		{
 			name: "recurring maintenance, repeat sunday, saturday, weekly for 24 hours, in Us/Eastern timezone",
 			maintenance: &GettablePlannedMaintenance{
+				SilenceAll: true,
 				Schedule: &Schedule{
 					Timezone: "US/Eastern",
 					Recurrence: &Recurrence{
@@ -458,6 +486,7 @@ func TestShouldSkipMaintenance(t *testing.T) {
 		{
 			name: "recurring maintenance, repeat daily from 12:00 to 14:00",
 			maintenance: &GettablePlannedMaintenance{
+				SilenceAll: true,
 				Schedule: &Schedule{
 					Timezone: "UTC",
 					Recurrence: &Recurrence{
@@ -473,6 +502,7 @@ func TestShouldSkipMaintenance(t *testing.T) {
 		{
 			name: "recurring maintenance, repeat daily from 12:00 to 14:00",
 			maintenance: &GettablePlannedMaintenance{
+				SilenceAll: true,
 				Schedule: &Schedule{
 					Timezone: "UTC",
 					Recurrence: &Recurrence{
@@ -488,6 +518,7 @@ func TestShouldSkipMaintenance(t *testing.T) {
 		{
 			name: "recurring maintenance, repeat daily from 12:00 to 14:00",
 			maintenance: &GettablePlannedMaintenance{
+				SilenceAll: true,
 				Schedule: &Schedule{
 					Timezone: "UTC",
 					Recurrence: &Recurrence{
@@ -503,6 +534,7 @@ func TestShouldSkipMaintenance(t *testing.T) {
 		{
 			name: "recurring maintenance, repeat weekly on monday from 12:00 to 14:00",
 			maintenance: &GettablePlannedMaintenance{
+				SilenceAll: true,
 				Schedule: &Schedule{
 					Timezone: "UTC",
 					Recurrence: &Recurrence{
@@ -519,6 +551,7 @@ func TestShouldSkipMaintenance(t *testing.T) {
 		{
 			name: "recurring maintenance, repeat weekly on monday from 12:00 to 14:00",
 			maintenance: &GettablePlannedMaintenance{
+				SilenceAll: true,
 				Schedule: &Schedule{
 					Timezone: "UTC",
 					Recurrence: &Recurrence{
@@ -535,6 +568,7 @@ func TestShouldSkipMaintenance(t *testing.T) {
 		{
 			name: "recurring maintenance, repeat weekly on monday from 12:00 to 14:00",
 			maintenance: &GettablePlannedMaintenance{
+				SilenceAll: true,
 				Schedule: &Schedule{
 					Timezone: "UTC",
 					Recurrence: &Recurrence{
@@ -551,6 +585,7 @@ func TestShouldSkipMaintenance(t *testing.T) {
 		{
 			name: "recurring maintenance, repeat weekly on monday from 12:00 to 14:00",
 			maintenance: &GettablePlannedMaintenance{
+				SilenceAll: true,
 				Schedule: &Schedule{
 					Timezone: "UTC",
 					Recurrence: &Recurrence{
@@ -567,6 +602,7 @@ func TestShouldSkipMaintenance(t *testing.T) {
 		{
 			name: "recurring maintenance, repeat weekly on monday from 12:00 to 14:00",
 			maintenance: &GettablePlannedMaintenance{
+				SilenceAll: true,
 				Schedule: &Schedule{
 					Timezone: "UTC",
 					Recurrence: &Recurrence{
@@ -583,6 +619,7 @@ func TestShouldSkipMaintenance(t *testing.T) {
 		{
 			name: "recurring maintenance, repeat monthly on 4th from 12:00 to 14:00",
 			maintenance: &GettablePlannedMaintenance{
+				SilenceAll: true,
 				Schedule: &Schedule{
 					Timezone: "UTC",
 					Recurrence: &Recurrence{
@@ -598,6 +635,7 @@ func TestShouldSkipMaintenance(t *testing.T) {
 		{
 			name: "recurring maintenance, repeat monthly on 4th from 12:00 to 14:00",
 			maintenance: &GettablePlannedMaintenance{
+				SilenceAll: true,
 				Schedule: &Schedule{
 					Timezone: "UTC",
 					Recurrence: &Recurrence{
@@ -613,6 +651,7 @@ func TestShouldSkipMaintenance(t *testing.T) {
 		{
 			name: "recurring maintenance, repeat monthly on 4th from 12:00 to 14:00",
 			maintenance: &GettablePlannedMaintenance{
+				SilenceAll: true,
 				Schedule: &Schedule{
 					Timezone: "UTC",
 					Recurrence: &Recurrence{
@@ -634,3 +673,144 @@ func TestShouldSkipMaintenance(t *testing.T) {
 		}
 	}
 }
+
+func TestSilenceAllFunctionality(t *testing.T) {
+	cases := []struct {
+		name        string
+		maintenance *GettablePlannedMaintenance
+		ruleID      string
+		ts          time.Time
+		skip        bool
+	}{
+		{
+			name: "SilenceAll=true with specific ruleIDs - should silence rule in list during maintenance window",
+			maintenance: &GettablePlannedMaintenance{
+				RuleIDs:    []string{"rule-1", "rule-2"},
+				SilenceAll: true,
+				Schedule: &Schedule{
+					Timezone: "UTC",
+					Recurrence: &Recurrence{
+						StartTime:  time.Date(2024, 1, 1, 12, 0, 0, 0, time.UTC),
+						Duration:   Duration(time.Hour * 2),
+						RepeatType: RepeatTypeDaily,
+					},
+				},
+			},
+			ruleID: "rule-1",
+			ts:     time.Date(2024, 1, 1, 12, 30, 0, 0, time.UTC),
+			skip:   true,
+		},
+		{
+			name: "SilenceAll=true with specific ruleIDs - should silence rule NOT in list during maintenance window",
+			maintenance: &GettablePlannedMaintenance{
+				RuleIDs:    []string{"rule-1", "rule-2"},
+				SilenceAll: true,
+				Schedule: &Schedule{
+					Timezone: "UTC",
+					Recurrence: &Recurrence{
+						StartTime:  time.Date(2024, 1, 1, 12, 0, 0, 0, time.UTC),
+						Duration:   Duration(time.Hour * 2),
+						RepeatType: RepeatTypeDaily,
+					},
+				},
+			},
+			ruleID: "rule-3",
+			ts:     time.Date(2024, 1, 1, 12, 30, 0, 0, time.UTC),
+			skip:   true,
+		},
+		{
+			name: "SilenceAll=false with specific ruleIDs - should silence rule in list during maintenance window",
+			maintenance: &GettablePlannedMaintenance{
+				RuleIDs:    []string{"rule-1", "rule-2"},
+				SilenceAll: false,
+				Schedule: &Schedule{
+					Timezone: "UTC",
+					Recurrence: &Recurrence{
+						StartTime:  time.Date(2024, 1, 1, 12, 0, 0, 0, time.UTC),
+						Duration:   Duration(time.Hour * 2),
+						RepeatType: RepeatTypeDaily,
+					},
+				},
+			},
+			ruleID: "rule-1",
+			ts:     time.Date(2024, 1, 1, 12, 30, 0, 0, time.UTC),
+			skip:   true,
+		},
+		{
+			name: "SilenceAll=true with empty ruleIDs - should silence all rules during maintenance window",
+			maintenance: &GettablePlannedMaintenance{
+				RuleIDs:    []string{},
+				SilenceAll: true,
+				Schedule: &Schedule{
+					Timezone: "UTC",
+					Recurrence: &Recurrence{
+						StartTime:  time.Date(2024, 1, 1, 12, 0, 0, 0, time.UTC),
+						Duration:   Duration(time.Hour * 2),
+						RepeatType: RepeatTypeDaily,
+					},
+				},
+			},
+			ruleID: "any-rule",
+			ts:     time.Date(2024, 1, 1, 12, 30, 0, 0, time.UTC),
+			skip:   true,
+		},
+		{
+			name: "SilenceAll=false with empty ruleIDs - should not silence any rules",
+			maintenance: &GettablePlannedMaintenance{
+				RuleIDs:    []string{},
+				SilenceAll: false,
+				Schedule: &Schedule{
+					Timezone: "UTC",
+					Recurrence: &Recurrence{
+						StartTime:  time.Date(2024, 1, 1, 12, 0, 0, 0, time.UTC),
+						Duration:   Duration(time.Hour * 2),
+						RepeatType: RepeatTypeDaily,
+					},
+				},
+			},
+			ruleID: "any-rule",
+			ts:     time.Date(2024, 1, 1, 12, 30, 0, 0, time.UTC),
+			skip:   false,
+		},
+		{
+			name: "SilenceAll=true with fixed maintenance window - should not skip outside window",
+			maintenance: &GettablePlannedMaintenance{
+				RuleIDs:    []string{},
+				SilenceAll: true,
+				Schedule: &Schedule{
+					Timezone:  "UTC",
+					StartTime: time.Date(2024, 1, 1, 12, 0, 0, 0, time.UTC),
+					EndTime:   time.Date(2024, 1, 1, 14, 0, 0, 0, time.UTC),
+				},
+			},
+			ruleID: "any-rule",
+			ts:     time.Date(2024, 1, 1, 15, 0, 0, 0, time.UTC),
+			skip:   false,
+		},
+		{
+			name: "SilenceAll=false with nil ruleIDs - should not silence any rules",
+			maintenance: &GettablePlannedMaintenance{
+				RuleIDs:    nil,
+				SilenceAll: false,
+				Schedule: &Schedule{
+					Timezone: "UTC",
+					Recurrence: &Recurrence{
+						StartTime:  time.Date(2024, 1, 1, 12, 0, 0, 0, time.UTC),
+						Duration:   Duration(time.Hour * 2),
+						RepeatType: RepeatTypeDaily,
+					},
+				},
+			},
+			ruleID: "any-rule",
+			ts:     time.Date(2024, 1, 1, 12, 30, 0, 0, time.UTC),
+			skip:   false,
+		},
+	}
+
+	for idx, c := range cases {
+		result := c.maintenance.ShouldSkip(c.ruleID, c.ts)
+		if result != c.skip {
+			t.Errorf("skip %v, got %v, case:%d - %s", c.skip, result, idx, c.name)
+		}
+	}
+}

pkg/types/ruletypes/threshold.go

@@ -103,7 +103,7 @@ func (r BasicRuleThresholds) ShouldAlert(series v3.Series, unit string) (Vector,
 	for _, threshold := range thresholds {
 		smpl, shouldAlert := threshold.shouldAlert(series, unit)
 		if shouldAlert {
-			smpl.Target = *threshold.TargetValue
+			smpl.Target = threshold.target(unit)
 			smpl.TargetUnit = threshold.TargetUnit
 			resultVector = append(resultVector, smpl)
 		}

pkg/types/ruletypes/threshold_test.go

@@ -1,294 +0,0 @@
-package ruletypes
-
-import (
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-
-	v3 "github.com/SigNoz/signoz/pkg/query-service/model/v3"
-)
-
-func TestBasicRuleThresholdShouldAlert_UnitConversion(t *testing.T) {
-	target := 100.0
-
-	tests := []struct {
-		name        string
-		threshold   BasicRuleThreshold
-		series      v3.Series
-		ruleUnit    string
-		shouldAlert bool
-	}{
-		{
-			name: "milliseconds to seconds conversion - should alert",
-			threshold: BasicRuleThreshold{
-				Name:        "test",
-				TargetValue: &target, // 100ms
-				TargetUnit:  "ms",
-				MatchType:   AtleastOnce,
-				CompareOp:   ValueIsAbove,
-			},
-			series: v3.Series{
-				Labels: map[string]string{"service": "test"},
-				Points: []v3.Point{
-					{Value: 0.15, Timestamp: 1000}, // 150ms in seconds
-				},
-			},
-			ruleUnit:    "s",
-			shouldAlert: true,
-		},
-		{
-			name: "milliseconds to seconds conversion - should not alert",
-			threshold: BasicRuleThreshold{
-				Name:        "test",
-				TargetValue: &target, // 100ms
-				TargetUnit:  "ms",
-				MatchType:   AtleastOnce,
-				CompareOp:   ValueIsAbove,
-			},
-			series: v3.Series{
-				Labels: map[string]string{"service": "test"},
-				Points: []v3.Point{
-					{Value: 0.05, Timestamp: 1000}, // 50ms in seconds
-				},
-			},
-			ruleUnit:    "s",
-			shouldAlert: false,
-		},
-		{
-			name: "seconds to milliseconds conversion - should alert",
-			threshold: BasicRuleThreshold{
-				Name:        "test",
-				TargetValue: &target, // 100s
-				TargetUnit:  "s",
-				MatchType:   AtleastOnce,
-				CompareOp:   ValueIsAbove,
-			},
-			series: v3.Series{
-				Labels: map[string]string{"service": "test"},
-				Points: []v3.Point{
-					{Value: 150000, Timestamp: 1000}, // 150000ms = 150s
-				},
-			},
-			ruleUnit:    "ms",
-			shouldAlert: true,
-		},
-		// Binary byte conversions
-		{
-			name: "bytes to kibibytes conversion - should alert",
-			threshold: BasicRuleThreshold{
-				Name:        "test",
-				TargetValue: &target, // 100 bytes
-				TargetUnit:  "bytes",
-				MatchType:   AtleastOnce,
-				CompareOp:   ValueIsAbove,
-			},
-			series: v3.Series{
-				Labels: map[string]string{"service": "test"},
-				Points: []v3.Point{
-					{Value: 0.15, Timestamp: 1000}, // 0.15KiB ≈ 153.6 bytes
-				},
-			},
-			ruleUnit:    "kbytes",
-			shouldAlert: true,
-		},
-		{
-			name: "kibibytes to mebibytes conversion - should alert",
-			threshold: BasicRuleThreshold{
-				Name:        "test",
-				TargetValue: &target, // 100KiB
-				TargetUnit:  "kbytes",
-				MatchType:   AtleastOnce,
-				CompareOp:   ValueIsAbove,
-			},
-			series: v3.Series{
-				Labels: map[string]string{"service": "test"},
-				Points: []v3.Point{
-					{Value: 0.15, Timestamp: 1000},
-				},
-			},
-			ruleUnit:    "mbytes",
-			shouldAlert: true,
-		},
-		// ValueIsBelow with unit conversion
-		{
-			name: "milliseconds to seconds with ValueIsBelow - should alert",
-			threshold: BasicRuleThreshold{
-				Name:        "test",
-				TargetValue: &target, // 100ms
-				TargetUnit:  "ms",
-				MatchType:   AtleastOnce,
-				CompareOp:   ValueIsBelow,
-			},
-			series: v3.Series{
-				Labels: map[string]string{"service": "test"},
-				Points: []v3.Point{
-					{Value: 0.05, Timestamp: 1000}, // 50ms in seconds
-				},
-			},
-			ruleUnit:    "s",
-			shouldAlert: true,
-		},
-		{
-			name: "milliseconds to seconds with OnAverage - should alert",
-			threshold: BasicRuleThreshold{
-				Name:        "test",
-				TargetValue: &target, // 100ms
-				TargetUnit:  "ms",
-				MatchType:   OnAverage,
-				CompareOp:   ValueIsAbove,
-			},
-			series: v3.Series{
-				Labels: map[string]string{"service": "test"},
-				Points: []v3.Point{
-					{Value: 0.08, Timestamp: 1000}, // 80ms
-					{Value: 0.12, Timestamp: 2000}, // 120ms
-					{Value: 0.15, Timestamp: 3000}, // 150ms
-				},
-			},
-			ruleUnit:    "s",
-			shouldAlert: true,
-		},
-		{
-			name: "decimal megabytes to gigabytes with InTotal - should alert",
-			threshold: BasicRuleThreshold{
-				Name:        "test",
-				TargetValue: &target, // 100MB
-				TargetUnit:  "decmbytes",
-				MatchType:   InTotal,
-				CompareOp:   ValueIsAbove,
-			},
-			series: v3.Series{
-				Labels: map[string]string{"service": "test"},
-				Points: []v3.Point{
-					{Value: 0.04, Timestamp: 1000}, // 40MB
-					{Value: 0.05, Timestamp: 2000}, // 50MB
-					{Value: 0.03, Timestamp: 3000}, // 30MB
-				},
-			},
-			ruleUnit:    "decgbytes",
-			shouldAlert: true,
-		},
-		{
-			name: "milliseconds to seconds with AllTheTimes - should alert",
-			threshold: BasicRuleThreshold{
-				Name:        "test",
-				TargetValue: &target, // 100ms
-				TargetUnit:  "ms",
-				MatchType:   AllTheTimes,
-				CompareOp:   ValueIsAbove,
-			},
-			series: v3.Series{
-				Labels: map[string]string{"service": "test"},
-				Points: []v3.Point{
-					{Value: 0.11, Timestamp: 1000}, // 110ms
-					{Value: 0.12, Timestamp: 2000}, // 120ms
-					{Value: 0.15, Timestamp: 3000}, // 150ms
-				},
-			},
-			ruleUnit:    "s",
-			shouldAlert: true,
-		},
-		{
-			name: "kilobytes to megabytes with Last - should not alert",
-			threshold: BasicRuleThreshold{
-				Name:        "test",
-				TargetValue: &target, // 100kB
-				TargetUnit:  "deckbytes",
-				MatchType:   Last,
-				CompareOp:   ValueIsAbove,
-			},
-			series: v3.Series{
-				Labels: map[string]string{"service": "test"},
-				Points: []v3.Point{
-					{Value: 0.15, Timestamp: 1000}, // 150kB
-					{Value: 0.05, Timestamp: 2000}, // 50kB (last value)
-				},
-			},
-			ruleUnit:    "decmbytes",
-			shouldAlert: false,
-		},
-		// Mixed units - bytes/second rate conversions
-		{
-			name: "bytes per second to kilobytes per second - should alert",
-			threshold: BasicRuleThreshold{
-				Name:        "test",
-				TargetValue: &target, // 100 bytes/s
-				TargetUnit:  "Bps",
-				MatchType:   AtleastOnce,
-				CompareOp:   ValueIsAbove,
-			},
-			series: v3.Series{
-				Labels: map[string]string{"service": "test"},
-				Points: []v3.Point{
-					{Value: 0.15, Timestamp: 1000},
-				},
-			},
-			ruleUnit:    "KBs",
-			shouldAlert: true,
-		},
-		// Same unit (no conversion needed)
-		{
-			name: "same unit - no conversion needed - should alert",
-			threshold: BasicRuleThreshold{
-				Name:        "test",
-				TargetValue: &target, // 100ms
-				TargetUnit:  "ms",
-				MatchType:   AtleastOnce,
-				CompareOp:   ValueIsAbove,
-			},
-			series: v3.Series{
-				Labels: map[string]string{"service": "test"},
-				Points: []v3.Point{
-					{Value: 150, Timestamp: 1000}, // 150ms
-				},
-			},
-			ruleUnit:    "ms",
-			shouldAlert: true,
-		},
-		// Empty unit (unitless) - no conversion
-		{
-			name: "empty unit - no conversion - should alert",
-			threshold: BasicRuleThreshold{
-				Name:        "test",
-				TargetValue: &target, // 100 (unitless)
-				TargetUnit:  "",
-				MatchType:   AtleastOnce,
-				CompareOp:   ValueIsAbove,
-			},
-			series: v3.Series{
-				Labels: map[string]string{"service": "test"},
-				Points: []v3.Point{
-					{Value: 150, Timestamp: 1000}, // 150 (unitless)
-				},
-			},
-			ruleUnit:    "",
-			shouldAlert: true,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			thresholds := BasicRuleThresholds{tt.threshold}
-			vector, err := thresholds.ShouldAlert(tt.series, tt.ruleUnit)
-			assert.NoError(t, err)
-
-			alert := len(vector) > 0
-			assert.Equal(t, tt.shouldAlert, alert)
-
-			if tt.shouldAlert && alert {
-				sample := vector[0]
-
-				hasThresholdLabel := false
-				for _, label := range sample.Metric {
-					if label.Name == LabelThresholdName && label.Value == "test" {
-						hasThresholdLabel = true
-						break
-					}
-				}
-				assert.True(t, hasThresholdLabel)
-				assert.Equal(t, *tt.threshold.TargetValue, sample.Target)
-				assert.Equal(t, tt.threshold.TargetUnit, sample.TargetUnit)
-			}
-		})
-	}
-}

tests/integration/fixtures/http.py

@@ -74,63 +74,6 @@ def zeus(
     )
 
 
-@pytest.fixture(name="gateway", scope="package")
-def gateway(
-    network: Network,
-    request: pytest.FixtureRequest,
-    pytestconfig: pytest.Config,
-) -> types.TestContainerDocker:
-    """
-    Package-scoped fixture for running gateway
-    """
-
-    def create() -> types.TestContainerDocker:
-        container = WireMockContainer(image="wiremock/wiremock:2.35.1-1", secure=False)
-        container.with_exposed_ports(8080)
-        container.with_network(network)
-        container.start()
-
-        return types.TestContainerDocker(
-            id=container.get_wrapped_container().id,
-            host_configs={
-                "8080": types.TestContainerUrlConfig(
-                    "http",
-                    container.get_container_host_ip(),
-                    container.get_exposed_port(8080),
-                )
-            },
-            container_configs={
-                "8080": types.TestContainerUrlConfig(
-                    "http", container.get_wrapped_container().name, 8080
-                )
-            },
-        )
-
-    def delete(container: types.TestContainerDocker):
-        client = docker.from_env()
-        try:
-            client.containers.get(container_id=container.id).stop()
-            client.containers.get(container_id=container.id).remove(v=True)
-        except docker.errors.NotFound:
-            logger.info(
-                "Skipping removal of Gateway, Gateway(%s) not found. Maybe it was manually removed?",
-                {"id": container.id},
-            )
-
-    def restore(cache: dict) -> types.TestContainerDocker:
-        return types.TestContainerDocker.from_cache(cache)
-
-    return dev.wrap(
-        request,
-        pytestconfig,
-        "gateway",
-        lambda: types.TestContainerDocker(id="", host_configs={}, container_configs={}),
-        create,
-        delete,
-        restore,
-    )
-
-
 @pytest.fixture(name="make_http_mocks", scope="function")
 def make_http_mocks() -> Callable[[types.TestContainerDocker, List[Mapping]], None]:
     def _make_http_mocks(

tests/integration/fixtures/signoz.py

@@ -20,7 +20,6 @@ logger = setup_logger(__name__)
 def signoz(  # pylint: disable=too-many-arguments,too-many-positional-arguments
     network: Network,
     zeus: types.TestContainerDocker,
-    gateway: types.TestContainerDocker,
     sqlstore: types.TestContainerSQL,
     clickhouse: types.TestContainerClickhouse,
     request: pytest.FixtureRequest,
@@ -57,7 +56,6 @@ def signoz(  # pylint: disable=too-many-arguments,too-many-positional-arguments
                 "SIGNOZ_WEB_DIRECTORY": "/root/web",
                 "SIGNOZ_INSTRUMENTATION_LOGS_LEVEL": "debug",
                 "SIGNOZ_PROMETHEUS_ACTIVE__QUERY__TRACKER_ENABLED": False,
-                "SIGNOZ_GATEWAY_URL": gateway.container_configs["8080"].base(),
             }
             | sqlstore.env
             | clickhouse.env
@@ -123,7 +121,6 @@ def signoz(  # pylint: disable=too-many-arguments,too-many-positional-arguments
             sqlstore=sqlstore,
             telemetrystore=clickhouse,
             zeus=zeus,
-            gateway=gateway,
         )
 
     def delete(container: types.SigNoz) -> None:
@@ -144,7 +141,6 @@ def signoz(  # pylint: disable=too-many-arguments,too-many-positional-arguments
             sqlstore=sqlstore,
             telemetrystore=clickhouse,
             zeus=zeus,
-            gateway=gateway,
         )
 
     return dev.wrap(
@@ -160,7 +156,6 @@ def signoz(  # pylint: disable=too-many-arguments,too-many-positional-arguments
             sqlstore=sqlstore,
             telemetrystore=clickhouse,
             zeus=zeus,
-            gateway=gateway,
         ),
         create=create,
         delete=delete,

tests/integration/fixtures/types.py

@@ -127,13 +127,12 @@ class SigNoz:
     sqlstore: TestContainerSQL
     telemetrystore: TestContainerClickhouse
     zeus: TestContainerDocker
-    gateway: TestContainerDocker
 
     def __cache__(self) -> dict:
         return self.self.__cache__()
 
     def __log__(self) -> str:
-        return f"SigNoz(self={self.self.__log__()}, sqlstore={self.sqlstore.__log__()}, telemetrystore={self.telemetrystore.__log__()}, zeus={self.zeus.__log__()}, gateway={self.gateway.__log__()})"
+        return f"SigNoz(self={self.self.__log__()}, sqlstore={self.sqlstore.__log__()}, telemetrystore={self.telemetrystore.__log__()}, zeus={self.zeus.__log__()})"
 
 
 @dataclass

tests/integration/src/cloudintegrations/a_get_connection_params.py

@@ -1,161 +0,0 @@
-from http import HTTPStatus
-from typing import Callable
-
-import requests
-from wiremock.client import (
-    HttpMethods,
-    Mapping,
-    MappingRequest,
-    MappingResponse,
-    WireMockMatchers,
-)
-
-from fixtures import types
-from fixtures.auth import add_license
-from fixtures.logger import setup_logger
-
-logger = setup_logger(__name__)
-
-
-def test_generate_connection_params(
-    signoz: types.SigNoz,
-    create_user_admin: types.Operation,  # pylint: disable=unused-argument
-    make_http_mocks: Callable[[types.TestContainerDocker, list], None],
-    get_token: Callable[[str, str], str],
-) -> None:
-    """Test to generate connection parameters for AWS SigNoz cloud integration."""
-    # Get authentication token for admin user
-    admin_token = get_token("admin@integration.test", "password123Z$")
-
-    add_license(signoz, make_http_mocks, get_token)
-
-    cloud_provider = "aws"
-
-    # Mock the deployment info query and ingestion key operations
-    make_http_mocks(
-        signoz.zeus,
-        [
-            Mapping(
-                request=MappingRequest(
-                    method=HttpMethods.GET,
-                    url="/v2/deployments/me",
-                    headers={
-                        "X-Signoz-Cloud-Api-Key": {
-                            WireMockMatchers.EQUAL_TO: "secret-key"
-                        }
-                    },
-                ),
-                response=MappingResponse(
-                    status=200,
-                    json_body={
-                        "status": "success",
-                        "data": {
-                            "name": "test-deployment",
-                            "cluster": {"region": {"dns": "test.signoz.cloud"}},
-                        },
-                    },
-                ),
-                persistent=False,
-            )
-        ],
-    )
-
-    make_http_mocks(
-        signoz.gateway,
-        [
-            # Mock the ingestion keys search endpoint
-            Mapping(
-                request=MappingRequest(
-                    method=HttpMethods.GET,
-                    url="/v1/workspaces/me/keys/search?name=aws-integration",
-                ),
-                response=MappingResponse(
-                    status=200,
-                    json_body={"status": "success", "data": []},
-                ),
-                persistent=False,
-            ),
-            # Mock the ingestion key creation endpoint
-            Mapping(
-                request=MappingRequest(
-                    method=HttpMethods.POST,
-                    url="/v1/workspaces/me/keys",
-                    json_body={
-                        "name": "aws-integration",
-                        "tags": ["integration", "aws"],
-                    },
-                    headers={
-                        "X-Signoz-Cloud-Api-Key": {
-                            WireMockMatchers.EQUAL_TO: "secret-key"
-                        },
-                        "X-Consumer-Username": {
-                            WireMockMatchers.EQUAL_TO: "lid:00000000-0000-0000-0000-000000000000"
-                        },
-                        "X-Consumer-Groups": {WireMockMatchers.EQUAL_TO: "ns:default"},
-                    },
-                ),
-                response=MappingResponse(
-                    status=200,
-                    json_body={
-                        "status": "success",
-                        "data": {
-                            "name": "aws-integration",
-                            "value": "test-ingestion-key-123456",
-                        },
-                        "error": "",
-                    },
-                ),
-                persistent=False,
-            ),
-        ],
-    )
-
-    endpoint = f"/api/v1/cloud-integrations/{cloud_provider}/accounts/generate-connection-params"
-
-    response = requests.get(
-        signoz.self.host_configs["8080"].get(endpoint),
-        headers={"Authorization": f"Bearer {admin_token}"},
-        timeout=10,
-    )
-
-    # Assert successful response
-    assert (
-        response.status_code == HTTPStatus.OK
-    ), f"Expected 200, got {response.status_code}: {response.text}"
-
-    # Parse response JSON
-    response_data = response.json()
-
-    # Assert response structure contains expected data
-    assert "data" in response_data, "Response should contain 'data' field"
-
-    # Assert required fields in the response data
-    expected_fields = [
-        "ingestion_url",
-        "ingestion_key",
-        "signoz_api_url",
-        "signoz_api_key",
-    ]
-
-    for field in expected_fields:
-        assert (
-            field in response_data["data"]
-        ), f"Response data should contain '{field}' field"
-
-    # Assert values for the returned fields
-    data = response_data["data"]
-
-    # ingestion_key is created by the mocked gateway and should match
-    assert data["ingestion_key"] == "test-ingestion-key-123456", (
-        "ingestion_key should match the mocked ingestion key"
-    )
-
-    # ingestion_url should be https://ingest.test.signoz.cloud based on the mocked deployment DNS
-    assert data["ingestion_url"] == "https://ingest.test.signoz.cloud", (
-        "ingestion_url should be https://ingest.test.signoz.cloud"
-    )
-
-    # signoz_api_url should be https://test-deployment.test.signoz.cloud based on the mocked deployment name and DNS
-    assert data["signoz_api_url"] == "https://test-deployment.test.signoz.cloud", (
-        "signoz_api_url should be https://test-deployment.test.signoz.cloud"
-    )