fix: added fix for metric selection tooltip scroll issue

* fix: added fix for panel rerenders on interaction

* fix: fixed tsc issue

.gitignore

@@ -49,6 +49,7 @@ ee/query-service/tests/test-deploy/data/
 # local data
 *.backup
 *.db
+**/db
 /deploy/docker/clickhouse-setup/data/
 /deploy/docker-swarm/clickhouse-setup/data/
 bin/

.mockery.yml

@@ -1,10 +0,0 @@
-# Link to template variables: https://pkg.go.dev/github.com/vektra/mockery/v3/config#TemplateData
-template: testify
-packages:
-  github.com/SigNoz/signoz/pkg/alertmanager:
-    config:
-      all: true
-      dir: '{{.InterfaceDir}}/mocks'
-      filename: "mocks.go"
-      structname: 'Mock{{.InterfaceName}}'
-      pkgname: '{{.SrcPackageName}}mock'

Makefile

@@ -72,6 +72,12 @@ devenv-up: devenv-clickhouse devenv-signoz-otel-collector ## Start both clickhou
 	@echo "   - ClickHouse: http://localhost:8123"
 	@echo "   - Signoz OTel Collector: grpc://localhost:4317, http://localhost:4318"
 
+.PHONY: devenv-clickhouse-clean
+devenv-clickhouse-clean: ## Clean all ClickHouse data from filesystem
+	@echo "Removing ClickHouse data..."
+	@rm -rf .devenv/docker/clickhouse/fs/tmp/*
+	@echo "ClickHouse data cleaned!"
+
 ##############################################################
 # go commands
 ##############################################################

docs/api/openapi.yml

@@ -849,6 +849,71 @@ paths:
       summary: Deprecated create session by email password
       tags:
       - sessions
+  /api/v1/logs/promote_paths:
+    get:
+      deprecated: false
+      description: This endpoints promotes and indexes paths
+      operationId: ListPromotedAndIndexedPaths
+      responses:
+        "200":
+          content:
+            application/json:
+              schema:
+                properties:
+                  data:
+                    items:
+                      $ref: '#/components/schemas/PromotetypesPromotePath'
+                    nullable: true
+                    type: array
+                  status:
+                    type: string
+                type: object
+          description: OK
+        "400":
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/RenderErrorResponse'
+          description: Bad Request
+        "500":
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/RenderErrorResponse'
+          description: Internal Server Error
+      summary: Promote and index paths
+      tags:
+      - logs
+    post:
+      deprecated: false
+      description: This endpoints promotes and indexes paths
+      operationId: HandlePromoteAndIndexPaths
+      requestBody:
+        content:
+          application/json:
+            schema:
+              items:
+                $ref: '#/components/schemas/PromotetypesPromotePath'
+              nullable: true
+              type: array
+      responses:
+        "201":
+          description: Created
+        "400":
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/RenderErrorResponse'
+          description: Bad Request
+        "500":
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/RenderErrorResponse'
+          description: Internal Server Error
+      summary: Promote and index paths
+      tags:
+      - logs
   /api/v1/org/preferences:
     get:
       deprecated: false
@@ -2137,6 +2202,26 @@ components:
       type: object
     PreferencetypesValue:
       type: object
+    PromotetypesPromotePath:
+      properties:
+        indexes:
+          items:
+            $ref: '#/components/schemas/PromotetypesWrappedIndex'
+          type: array
+        path:
+          type: string
+        promote:
+          type: boolean
+      type: object
+    PromotetypesWrappedIndex:
+      properties:
+        column_type:
+          type: string
+        granularity:
+          type: integer
+        type:
+          type: string
+      type: object
     RenderErrorResponse:
       properties:
         error:

ee/query-service/rules/anomaly.go

@@ -247,8 +247,7 @@ func (r *AnomalyRule) buildAndRunQuery(ctx context.Context, orgID valuer.UUID, t
 			}
 		}
 		results, err := r.Threshold.Eval(*series, r.Unit(), ruletypes.EvalData{
-			ActiveAlerts:  r.ActiveAlertsLabelFP(),
-			SendUnmatched: r.ShouldSendUnmatched(),
+			ActiveAlerts: r.ActiveAlertsLabelFP(),
 		})
 		if err != nil {
 			return nil, err
@@ -300,8 +299,7 @@ func (r *AnomalyRule) buildAndRunQueryV5(ctx context.Context, orgID valuer.UUID,
 			}
 		}
 		results, err := r.Threshold.Eval(*series, r.Unit(), ruletypes.EvalData{
-			ActiveAlerts:  r.ActiveAlertsLabelFP(),
-			SendUnmatched: r.ShouldSendUnmatched(),
+			ActiveAlerts: r.ActiveAlertsLabelFP(),
 		})
 		if err != nil {
 			return nil, err

ee/query-service/rules/manager_test.go

@@ -1,589 +0,0 @@
-package rules
-
-import (
-	"context"
-	"encoding/json"
-	"math"
-	"strconv"
-	"testing"
-	"time"
-
-	"github.com/DATA-DOG/go-sqlmock"
-	alertmanagermock "github.com/SigNoz/signoz/pkg/alertmanager/mocks"
-	"github.com/SigNoz/signoz/pkg/cache"
-	"github.com/SigNoz/signoz/pkg/cache/cachetest"
-	"github.com/SigNoz/signoz/pkg/instrumentation/instrumentationtest"
-	"github.com/SigNoz/signoz/pkg/prometheus"
-	"github.com/SigNoz/signoz/pkg/prometheus/prometheustest"
-	"github.com/SigNoz/signoz/pkg/querier"
-	"github.com/SigNoz/signoz/pkg/querier/signozquerier"
-	"github.com/SigNoz/signoz/pkg/query-service/app/clickhouseReader"
-	v3 "github.com/SigNoz/signoz/pkg/query-service/model/v3"
-	qsRules "github.com/SigNoz/signoz/pkg/query-service/rules"
-	"github.com/SigNoz/signoz/pkg/sqlstore"
-	"github.com/SigNoz/signoz/pkg/sqlstore/sqlstoretest"
-	"github.com/SigNoz/signoz/pkg/telemetrystore"
-	"github.com/SigNoz/signoz/pkg/telemetrystore/telemetrystoretest"
-	"github.com/SigNoz/signoz/pkg/types/alertmanagertypes"
-	"github.com/SigNoz/signoz/pkg/types/metrictypes"
-	qbtypes "github.com/SigNoz/signoz/pkg/types/querybuildertypes/querybuildertypesv5"
-	ruletypes "github.com/SigNoz/signoz/pkg/types/ruletypes"
-	"github.com/SigNoz/signoz/pkg/types/telemetrytypes"
-	"github.com/SigNoz/signoz/pkg/valuer"
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/mock"
-	"github.com/stretchr/testify/require"
-	"go.uber.org/zap"
-
-	cmock "github.com/srikanthccv/ClickHouse-go-mock"
-)
-
-type queryMatcherAny struct {
-}
-
-func (m *queryMatcherAny) Match(x string, y string) error {
-	return nil
-}
-
-func TestManager_TestNotification_SendUnmatched_ThresholdRule(t *testing.T) {
-	target := 10.0
-	recovery := 5.0
-
-	buildRule := func() ruletypes.PostableRule {
-		return ruletypes.PostableRule{
-			AlertName: "test-alert",
-			AlertType: ruletypes.AlertTypeMetric,
-			RuleType:  ruletypes.RuleTypeThreshold,
-			Evaluation: &ruletypes.EvaluationEnvelope{Kind: ruletypes.RollingEvaluation, Spec: ruletypes.RollingWindow{
-				EvalWindow: ruletypes.Duration(5 * time.Minute),
-				Frequency:  ruletypes.Duration(1 * time.Minute),
-			}},
-			Labels: map[string]string{
-				"service.name": "frontend",
-			},
-			Annotations: map[string]string{
-				"value": "{{$value}}",
-			},
-			Version: "v5",
-			RuleCondition: &ruletypes.RuleCondition{
-				MatchType: ruletypes.AtleastOnce,
-				CompareOp: ruletypes.ValueIsAbove,
-				Target:    &target,
-				CompositeQuery: &v3.CompositeQuery{
-					QueryType: v3.QueryTypeBuilder,
-					Queries: []qbtypes.QueryEnvelope{
-						{
-							Type: qbtypes.QueryTypeBuilder,
-							Spec: qbtypes.QueryBuilderQuery[qbtypes.MetricAggregation]{
-								Name:         "A",
-								StepInterval: qbtypes.Step{Duration: 60 * time.Second},
-								Signal:       telemetrytypes.SignalMetrics,
-
-								Aggregations: []qbtypes.MetricAggregation{
-									{
-										MetricName:       "probe_success",
-										TimeAggregation:  metrictypes.TimeAggregationAvg,
-										SpaceAggregation: metrictypes.SpaceAggregationAvg,
-									},
-								},
-							},
-						},
-					},
-				},
-				Thresholds: &ruletypes.RuleThresholdData{
-					Kind: ruletypes.BasicThresholdKind,
-					Spec: ruletypes.BasicRuleThresholds{
-						{
-							Name:           "primary",
-							TargetValue:    &target,
-							RecoveryTarget: &recovery,
-							MatchType:      ruletypes.AtleastOnce,
-							CompareOp:      ruletypes.ValueIsAbove,
-						},
-					},
-				},
-			},
-			NotificationSettings: &ruletypes.NotificationSettings{},
-		}
-	}
-
-	type testCase struct {
-		name         string
-		values       [][]interface{}
-		expectAlerts int
-		expectValue  float64
-	}
-
-	cases := []testCase{
-		{
-			name: "return first valid point in case of test notification",
-			values: [][]interface{}{
-				{float64(3), "attr", time.Now()},
-				{float64(4), "attr", time.Now().Add(1 * time.Minute)},
-			},
-			expectAlerts: 1,
-			expectValue:  3,
-		},
-		{
-			name:         "No data in DB so no alerts fired",
-			values:       [][]interface{}{},
-			expectAlerts: 0,
-		},
-		{
-			name: "return first valid point in case of test notification skips NaN and Inf",
-			values: [][]interface{}{
-				{math.NaN(), "attr", time.Now()},
-				{math.Inf(1), "attr", time.Now().Add(1 * time.Minute)},
-				{float64(7), "attr", time.Now().Add(2 * time.Minute)},
-			},
-			expectAlerts: 1,
-			expectValue:  7,
-		},
-		{
-			name: "If found matching alert with given target value, return the alerting value rather than first valid point",
-			values: [][]interface{}{
-				{float64(1), "attr", time.Now()},
-				{float64(2), "attr", time.Now().Add(1 * time.Minute)},
-				{float64(3), "attr", time.Now().Add(2 * time.Minute)},
-				{float64(12), "attr", time.Now().Add(3 * time.Minute)},
-			},
-			expectAlerts: 1,
-			expectValue:  12,
-		},
-	}
-
-	for _, tc := range cases {
-		t.Run(tc.name, func(t *testing.T) {
-			rule := buildRule()
-
-			// Marshal rule to JSON as TestNotification expects
-			ruleBytes, err := json.Marshal(rule)
-			require.NoError(t, err)
-
-			// mocking the alertmanager + capturing the triggered test alerts
-			fAlert := alertmanagermock.NewMockAlertmanager(t)
-			// mock set notification config
-			fAlert.On("SetNotificationConfig", mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(nil)
-			// for saving temp alerts that are triggered via TestNotification
-			triggeredTestAlerts := []map[*alertmanagertypes.PostableAlert][]string{}
-			if tc.expectAlerts > 0 {
-				fAlert.On("TestAlert", mock.Anything, mock.Anything, mock.Anything, mock.Anything).Run(func(args mock.Arguments) {
-					triggeredTestAlerts = append(triggeredTestAlerts, args.Get(3).(map[*alertmanagertypes.PostableAlert][]string))
-				}).Return(nil).Times(tc.expectAlerts)
-			}
-
-			cacheObj, err := cachetest.New(cache.Config{
-				Provider: "memory",
-				Memory: cache.Memory{
-					NumCounters: 1000,
-					MaxCost:     1 << 20,
-				},
-			})
-			require.NoError(t, err)
-
-			orgID := valuer.GenerateUUID()
-
-			// Create SQLStore mock for SendAlerts function which queries organizations table
-			sqlStore := sqlstoretest.New(sqlstore.Config{Provider: "sqlite"}, sqlmock.QueryMatcherRegexp)
-			// Mock the organizations query that SendAlerts makes
-			// Bun generates: SELECT id FROM organizations LIMIT 1 (or SELECT "id" FROM "organizations" LIMIT 1)
-			orgRows := sqlStore.Mock().NewRows([]string{"id"}).AddRow(orgID.StringValue())
-			// Match bun's generated query pattern - bun may quote identifiers
-			sqlStore.Mock().ExpectQuery("SELECT (.+) FROM (.+)organizations(.+) LIMIT (.+)").WillReturnRows(orgRows)
-
-			telemetryStore := telemetrystoretest.New(telemetrystore.Config{}, &queryMatcherAny{})
-
-			// Set up mock data for telemetry store
-			cols := make([]cmock.ColumnType, 0)
-			cols = append(cols, cmock.ColumnType{Name: "value", Type: "Float64"})
-			cols = append(cols, cmock.ColumnType{Name: "attr", Type: "String"})
-			cols = append(cols, cmock.ColumnType{Name: "ts", Type: "DateTime"})
-
-			alertDataRows := cmock.NewRows(cols, tc.values)
-
-			mock := telemetryStore.Mock()
-
-			// Generate query arguments for the metric query
-			evalTime := time.Now().UTC()
-			evalWindow := 5 * time.Minute
-			evalDelay := time.Duration(0)
-			queryArgs := qsRules.GenerateMetricQueryCHArgs(
-				evalTime,
-				evalWindow,
-				evalDelay,
-				"probe_success",
-				metrictypes.Unspecified,
-			)
-
-			mock.ExpectQuery("*WITH __temporal_aggregation_cte*").
-				WithArgs(queryArgs...).
-				WillReturnRows(alertDataRows)
-
-			// Create reader with mocked telemetry store
-			readerCache, err := cachetest.New(cache.Config{
-				Provider: "memory",
-				Memory: cache.Memory{
-					NumCounters: 10 * 1000,
-					MaxCost:     1 << 26,
-				},
-			})
-			require.NoError(t, err)
-
-			options := clickhouseReader.NewOptions("", "", "archiveNamespace")
-			providerSettings := instrumentationtest.New().ToProviderSettings()
-			prometheus := prometheustest.New(context.Background(), providerSettings, prometheus.Config{}, telemetryStore)
-			reader := clickhouseReader.NewReader(
-				nil,
-				telemetryStore,
-				prometheus,
-				"",
-				time.Duration(time.Second),
-				nil,
-				readerCache,
-				options,
-			)
-
-			// Create mock querierV5 with test values
-			providerFactory := signozquerier.NewFactory(telemetryStore, prometheus, readerCache)
-			mockQuerier, err := providerFactory.New(context.Background(), providerSettings, querier.Config{})
-			require.NoError(t, err)
-
-			mgrOpts := &qsRules.ManagerOptions{
-				Logger:         zap.NewNop(),
-				SLogger:        instrumentationtest.New().Logger(),
-				Cache:          cacheObj,
-				Alertmanager:   fAlert,
-				Querier:        mockQuerier,
-				TelemetryStore: telemetryStore,
-				Reader:         reader,
-				SqlStore:       sqlStore, // SQLStore needed for SendAlerts to query organizations
-				// Custom Test Notification function
-				PrepareTestRuleFunc: TestNotification,
-			}
-
-			mgr, err := qsRules.NewManager(mgrOpts)
-			require.NoError(t, err)
-
-			count, apiErr := mgr.TestNotification(context.Background(), orgID, string(ruleBytes))
-			if apiErr != nil {
-				t.Logf("TestNotification error: %v, type: %s", apiErr.Err, apiErr.Typ)
-			}
-			require.Nil(t, apiErr)
-			assert.Equal(t, tc.expectAlerts, count)
-
-			if tc.expectAlerts > 0 {
-				// check if the alert has been triggered
-				require.Len(t, triggeredTestAlerts, 1)
-				var gotAlerts []*alertmanagertypes.PostableAlert
-				for a := range triggeredTestAlerts[0] {
-					gotAlerts = append(gotAlerts, a)
-				}
-				require.Len(t, gotAlerts, tc.expectAlerts)
-				// check if the alert has triggered with correct threshold value
-				if tc.expectValue != 0 {
-					assert.Equal(t, strconv.FormatFloat(tc.expectValue, 'f', -1, 64), gotAlerts[0].Annotations["value"])
-				}
-			} else {
-				// check if no alerts have been triggered
-				assert.Empty(t, triggeredTestAlerts)
-			}
-		})
-	}
-}
-
-func TestManager_TestNotification_SendUnmatched_PromRule(t *testing.T) {
-	target := 10.0
-
-	buildRule := func() ruletypes.PostableRule {
-		return ruletypes.PostableRule{
-			AlertName: "test-prom-alert",
-			AlertType: ruletypes.AlertTypeMetric,
-			RuleType:  ruletypes.RuleTypeProm,
-			Evaluation: &ruletypes.EvaluationEnvelope{Kind: ruletypes.RollingEvaluation, Spec: ruletypes.RollingWindow{
-				EvalWindow: ruletypes.Duration(5 * time.Minute),
-				Frequency:  ruletypes.Duration(1 * time.Minute),
-			}},
-			Labels: map[string]string{
-				"service.name": "frontend",
-			},
-			Annotations: map[string]string{
-				"value": "{{$value}}",
-			},
-			Version: "v5",
-			RuleCondition: &ruletypes.RuleCondition{
-				MatchType:     ruletypes.AtleastOnce,
-				SelectedQuery: "A",
-				CompareOp:     ruletypes.ValueIsAbove,
-				Target:        &target,
-				CompositeQuery: &v3.CompositeQuery{
-					QueryType: v3.QueryTypePromQL,
-					PanelType: v3.PanelTypeGraph,
-					Queries: []qbtypes.QueryEnvelope{
-						{
-							Type: qbtypes.QueryTypePromQL,
-							Spec: qbtypes.PromQuery{
-								Name:     "A",
-								Query:    "{\"test_metric\"}",
-								Disabled: false,
-								Stats:    false,
-							},
-						},
-					},
-				},
-				Thresholds: &ruletypes.RuleThresholdData{
-					Kind: ruletypes.BasicThresholdKind,
-					Spec: ruletypes.BasicRuleThresholds{
-						{
-							Name:        "primary",
-							TargetValue: &target,
-							MatchType:   ruletypes.AtleastOnce,
-							CompareOp:   ruletypes.ValueIsAbove,
-							Channels:    []string{"slack"},
-						},
-					},
-				},
-			},
-			NotificationSettings: &ruletypes.NotificationSettings{},
-		}
-	}
-
-	type testCase struct {
-		name   string
-		values []struct {
-			offset time.Duration // offset from baseTime (negative = in the past)
-			value  float64
-		}
-		expectAlerts int
-		expectValue  float64
-	}
-
-	cases := []testCase{
-		{
-			name: "return first valid point in case of test notification",
-			values: []struct {
-				offset time.Duration
-				value  float64
-			}{
-				{-4 * time.Minute, 3},
-				{-3 * time.Minute, 4},
-			},
-			expectAlerts: 1,
-			expectValue:  3,
-		},
-		{
-			name: "No data in DB so no alerts fired",
-			values: []struct {
-				offset time.Duration
-				value  float64
-			}{},
-			expectAlerts: 0,
-		},
-		{
-			name: "return first valid point in case of test notification skips NaN and Inf",
-			values: []struct {
-				offset time.Duration
-				value  float64
-			}{
-				{-4 * time.Minute, math.NaN()},
-				{-3 * time.Minute, math.Inf(1)},
-				{-2 * time.Minute, 7},
-			},
-			expectAlerts: 1,
-			expectValue:  7,
-		},
-		{
-			name: "If found matching alert with given target value, return the alerting value rather than first valid point",
-			values: []struct {
-				offset time.Duration
-				value  float64
-			}{
-				{-4 * time.Minute, 1},
-				{-3 * time.Minute, 2},
-				{-2 * time.Minute, 3},
-				{-1 * time.Minute, 12},
-			},
-			expectAlerts: 1,
-			expectValue:  12,
-		},
-	}
-
-	for _, tc := range cases {
-		t.Run(tc.name, func(t *testing.T) {
-			// Capture base time once per test case to ensure consistent timestamps
-			baseTime := time.Now().UTC()
-
-			rule := buildRule()
-
-			// Marshal rule to JSON as TestNotification expects
-			ruleBytes, err := json.Marshal(rule)
-			require.NoError(t, err)
-
-			// mocking the alertmanager + capturing the triggered test alerts
-			fAlert := alertmanagermock.NewMockAlertmanager(t)
-			// mock set notification config
-			fAlert.On("SetNotificationConfig", mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(nil)
-			// for saving temp alerts that are triggered via TestNotification
-			triggeredTestAlerts := []map[*alertmanagertypes.PostableAlert][]string{}
-			if tc.expectAlerts > 0 {
-				fAlert.On("TestAlert", mock.Anything, mock.Anything, mock.Anything, mock.Anything).Run(func(args mock.Arguments) {
-					triggeredTestAlerts = append(triggeredTestAlerts, args.Get(3).(map[*alertmanagertypes.PostableAlert][]string))
-				}).Return(nil).Times(tc.expectAlerts)
-			}
-
-			cacheObj, err := cachetest.New(cache.Config{
-				Provider: "memory",
-				Memory: cache.Memory{
-					NumCounters: 1000,
-					MaxCost:     1 << 20,
-				},
-			})
-			require.NoError(t, err)
-
-			orgID := valuer.GenerateUUID()
-
-			// Create SQLStore mock for SendAlerts function which queries organizations table
-			sqlStore := sqlstoretest.New(sqlstore.Config{Provider: "sqlite"}, sqlmock.QueryMatcherRegexp)
-			// Mock the organizations query that SendAlerts makes
-			orgRows := sqlStore.Mock().NewRows([]string{"id"}).AddRow(orgID.StringValue())
-			sqlStore.Mock().ExpectQuery("SELECT (.+) FROM (.+)organizations(.+) LIMIT (.+)").WillReturnRows(orgRows)
-
-			telemetryStore := telemetrystoretest.New(telemetrystore.Config{}, &queryMatcherAny{})
-
-			// Set up Prometheus-specific mock data
-			// Fingerprint columns for Prometheus queries
-			fingerprintCols := []cmock.ColumnType{
-				{Name: "fingerprint", Type: "UInt64"},
-				{Name: "any(labels)", Type: "String"},
-			}
-
-			// Samples columns for Prometheus queries
-			samplesCols := []cmock.ColumnType{
-				{Name: "metric_name", Type: "String"},
-				{Name: "fingerprint", Type: "UInt64"},
-				{Name: "unix_milli", Type: "Int64"},
-				{Name: "value", Type: "Float64"},
-				{Name: "flags", Type: "UInt32"},
-			}
-
-			// Calculate query time range similar to Prometheus rule tests
-			// TestNotification uses time.Now().UTC() for evaluation
-			// We calculate the query window based on current time to match what the actual evaluation will use
-			evalTime := baseTime
-			evalWindowMs := int64(5 * 60 * 1000) // 5 minutes in ms
-			evalTimeMs := evalTime.UnixMilli()
-			queryStart := ((evalTimeMs-2*evalWindowMs)/60000)*60000 + 1 // truncate to minute + 1ms
-			queryEnd := (evalTimeMs / 60000) * 60000                    // truncate to minute
-
-			// Create fingerprint data
-			fingerprint := uint64(12345)
-			labelsJSON := `{"__name__":"test_metric"}`
-			fingerprintData := [][]interface{}{
-				{fingerprint, labelsJSON},
-			}
-			fingerprintRows := cmock.NewRows(fingerprintCols, fingerprintData)
-
-			// Create samples data from test case values, calculating timestamps relative to baseTime
-			validSamplesData := make([][]interface{}, 0)
-			for _, v := range tc.values {
-				// Skip NaN and Inf values in the samples data
-				if math.IsNaN(v.value) || math.IsInf(v.value, 0) {
-					continue
-				}
-				// Calculate timestamp relative to baseTime
-				sampleTimestamp := baseTime.Add(v.offset).UnixMilli()
-				validSamplesData = append(validSamplesData, []interface{}{
-					"test_metric",
-					fingerprint,
-					sampleTimestamp,
-					v.value,
-					uint32(0), // flags - 0 means normal value
-				})
-			}
-			samplesRows := cmock.NewRows(samplesCols, validSamplesData)
-
-			mock := telemetryStore.Mock()
-
-			// Mock the fingerprint query (for Prometheus label matching)
-			mock.ExpectQuery("SELECT fingerprint, any").
-				WithArgs("test_metric", "__name__", "test_metric").
-				WillReturnRows(fingerprintRows)
-
-			// Mock the samples query (for Prometheus metric data)
-			mock.ExpectQuery("SELECT metric_name, fingerprint, unix_milli").
-				WithArgs(
-					"test_metric",
-					"test_metric",
-					"__name__",
-					"test_metric",
-					queryStart,
-					queryEnd,
-				).
-				WillReturnRows(samplesRows)
-
-			// Create reader with mocked telemetry store
-			readerCache, err := cachetest.New(cache.Config{
-				Provider: "memory",
-				Memory: cache.Memory{
-					NumCounters: 10 * 1000,
-					MaxCost:     1 << 26,
-				},
-			})
-			require.NoError(t, err)
-
-			options := clickhouseReader.NewOptions("", "", "archiveNamespace")
-			promProvider := prometheustest.New(context.Background(), instrumentationtest.New().ToProviderSettings(), prometheus.Config{}, telemetryStore)
-			reader := clickhouseReader.NewReader(
-				nil,
-				telemetryStore,
-				promProvider,
-				"",
-				time.Duration(time.Second),
-				nil,
-				readerCache,
-				options,
-			)
-
-			mgrOpts := &qsRules.ManagerOptions{
-				Logger:         zap.NewNop(),
-				SLogger:        instrumentationtest.New().Logger(),
-				Cache:          cacheObj,
-				Alertmanager:   fAlert,
-				TelemetryStore: telemetryStore,
-				Reader:         reader,
-				SqlStore:       sqlStore, // SQLStore needed for SendAlerts to query organizations
-				Prometheus:     promProvider,
-				// Custom Test Notification function
-				PrepareTestRuleFunc: TestNotification,
-			}
-
-			mgr, err := qsRules.NewManager(mgrOpts)
-			require.NoError(t, err)
-
-			count, apiErr := mgr.TestNotification(context.Background(), orgID, string(ruleBytes))
-			if apiErr != nil {
-				t.Logf("TestNotification error: %v, type: %s", apiErr.Err, apiErr.Typ)
-			}
-			require.Nil(t, apiErr)
-			assert.Equal(t, tc.expectAlerts, count)
-
-			if tc.expectAlerts > 0 {
-				// check if the alert has been triggered
-				require.Len(t, triggeredTestAlerts, 1)
-				var gotAlerts []*alertmanagertypes.PostableAlert
-				for a := range triggeredTestAlerts[0] {
-					gotAlerts = append(gotAlerts, a)
-				}
-				require.Len(t, gotAlerts, tc.expectAlerts)
-				// check if the alert has triggered with correct threshold value
-				if tc.expectValue != 0 && !math.IsNaN(tc.expectValue) && !math.IsInf(tc.expectValue, 0) {
-					assert.Equal(t, strconv.FormatFloat(tc.expectValue, 'f', -1, 64), gotAlerts[0].Annotations["value"])
-				}
-			} else {
-				// check if no alerts have been triggered
-				assert.Empty(t, triggeredTestAlerts)
-			}
-
-			promProvider.Close()
-		})
-	}
-}

frontend/src/AppRoutes/index.tsx

@@ -6,6 +6,7 @@ import logEvent from 'api/common/logEvent';
 import AppLoading from 'components/AppLoading/AppLoading';
 import { CmdKPalette } from 'components/cmdKPalette/cmdKPalette';
 import NotFound from 'components/NotFound';
+import { ShiftHoldOverlayController } from 'components/ShiftOverlay/ShiftHoldOverlayController';
 import Spinner from 'components/Spinner';
 import { FeatureKeys } from 'constants/features';
 import { LOCALSTORAGE } from 'constants/localStorage';
@@ -368,6 +369,9 @@ function App(): JSX.Element {
 							<NotificationProvider>
 								<ErrorModalProvider>
 									{isLoggedInState && <CmdKPalette userRole={user.role} />}
+									{isLoggedInState && (
+										<ShiftHoldOverlayController userRole={user.role} />
+									)}
 									<PrivateRoute>
 										<ResourceProvider>
 											<QueryBuilderProvider>

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

@@ -1,11 +1,15 @@
-.log-field-key {
-	padding-right: 5px;
+.log-field-container {
+	display: flex;
+	overflow: hidden;
+	width: 100%;
+	align-items: baseline;
+}
+.log-field-key,
+.log-field-key-colon {
 	color: var(--text-vanilla-400, #c0c1c3);
 	font-size: 14px;
 	font-style: normal;
 	font-weight: 400;
-	line-height: 18px; /* 128.571% */
-	letter-spacing: -0.07px;
 
 	&.small {
 		font-size: 11px;
@@ -22,6 +26,20 @@
 		line-height: 24px;
 	}
 }
+.log-field-key {
+	line-height: 18px; /* 128.571% */
+	letter-spacing: -0.07px;
+	white-space: nowrap;
+	display: inline-block;
+	max-width: 20vw;
+	text-overflow: ellipsis;
+	overflow: hidden;
+	margin: 0;
+}
+.log-field-key-colon {
+	min-width: 0.8rem;
+	flex-shrink: 0;
+}
 .log-value {
 	color: var(--text-vanilla-400, #c0c1c3);
 	font-size: 14px;
@@ -158,7 +176,8 @@
 }
 
 .lightMode {
-	.log-field-key {
+	.log-field-key,
+	.log-field-key-colon {
 		color: var(--text-slate-400);
 	}
 	.log-value {
@@ -170,3 +189,10 @@
 		}
 	}
 }
+
+.dark {
+	.log-field-key,
+	.log-field-key-colon {
+		color: rgba(255, 255, 255, 0.45);
+	}
+}

frontend/src/components/Logs/ListLogView/index.tsx

@@ -25,13 +25,7 @@ import LogLinesActionButtons from '../LogLinesActionButtons/LogLinesActionButton
 import LogStateIndicator from '../LogStateIndicator/LogStateIndicator';
 import { getLogIndicatorType } from '../LogStateIndicator/utils';
 // styles
-import {
-	Container,
-	LogContainer,
-	LogText,
-	Text,
-	TextContainer,
-} from './styles';
+import { Container, LogContainer, LogText } from './styles';
 import { isValidLogField } from './util';
 
 interface LogFieldProps {
@@ -58,16 +52,18 @@ function LogGeneralField({
 	);
 
 	return (
-		<TextContainer>
-			<Text ellipsis type="secondary" className={cx('log-field-key', fontSize)}>
-				{`${fieldKey} : `}
-			</Text>
+		<div className="log-field-container">
+			<p className={cx('log-field-key', fontSize)} title={fieldKey}>
+				{fieldKey}
+			</p>
+			<span className={cx('log-field-key-colon', fontSize)}>&nbsp;:&nbsp;</span>
 			<LogText
 				dangerouslySetInnerHTML={html}
 				className={cx('log-value', fontSize)}
+				title={fieldValue}
 				linesPerRow={linesPerRow > 1 ? linesPerRow : undefined}
 			/>
-		</TextContainer>
+		</div>
 	);
 }
 

frontend/src/components/Logs/ListLogView/styles.ts

@@ -1,5 +1,5 @@
 /* eslint-disable no-nested-ternary */
-import { Card, Typography } from 'antd';
+import { Card } from 'antd';
 import { FontSize } from 'container/OptionsMenu/types';
 import styled from 'styled-components';
 import { getActiveLogBackground } from 'utils/logs';
@@ -46,19 +46,6 @@ export const Container = styled(Card)<{
 			getActiveLogBackground($isActiveLog, $isDarkMode, $logType)}
 `;
 
-export const Text = styled(Typography.Text)`
-	&&& {
-		min-width: 2.5rem;
-		white-space: nowrap;
-	}
-`;
-
-export const TextContainer = styled.div`
-	display: flex;
-	overflow: hidden;
-	width: 100%;
-`;
-
 export const LogContainer = styled.div<LogContainerProps>`
 	margin-left: 0.5rem;
 	display: flex;

frontend/src/components/ShiftOverlay/ShiftHoldOverlayController.tsx

@@ -0,0 +1,27 @@
+import { createShortcutActions } from '../../constants/shortcutActions';
+import { useCmdK } from '../../providers/cmdKProvider';
+import { ShiftOverlay } from './ShiftOverlay';
+import { useShiftHoldOverlay } from './useShiftHoldOverlay';
+
+type UserRole = 'ADMIN' | 'EDITOR' | 'AUTHOR' | 'VIEWER';
+export function ShiftHoldOverlayController({
+	userRole,
+}: {
+	userRole: UserRole;
+}): JSX.Element | null {
+	const { open: isCmdKOpen } = useCmdK();
+	const noop = (): void => undefined;
+
+	const actions = createShortcutActions({
+		navigate: noop,
+		handleThemeChange: noop,
+	});
+
+	const visible = useShiftHoldOverlay({
+		isModalOpen: isCmdKOpen,
+	});
+
+	return (
+		<ShiftOverlay visible={visible} actions={actions} userRole={userRole} />
+	);
+}

frontend/src/components/ShiftOverlay/ShiftOverlay.tsx

@@ -0,0 +1,77 @@
+import './shiftOverlay.scss';
+
+import { useMemo } from 'react';
+import ReactDOM from 'react-dom';
+
+import { formatShortcut } from './formatShortcut';
+
+export type UserRole = 'ADMIN' | 'EDITOR' | 'AUTHOR' | 'VIEWER';
+export type CmdAction = {
+	id: string;
+	name: string;
+	shortcut?: string[];
+	keywords?: string;
+	section?: string;
+	roles?: UserRole[];
+	perform: () => void;
+};
+
+interface ShortcutProps {
+	label: string;
+	keyHint: React.ReactNode;
+}
+
+function Shortcut({ label, keyHint }: ShortcutProps): JSX.Element {
+	return (
+		<div className="shift-overlay__item">
+			<span className="shift-overlay__label">{label}</span>
+			<kbd className="shift-overlay__kbd">{keyHint}</kbd>
+		</div>
+	);
+}
+
+interface ShiftOverlayProps {
+	visible: boolean;
+	actions: CmdAction[];
+	userRole: UserRole;
+}
+
+export function ShiftOverlay({
+	visible,
+	actions,
+	userRole,
+}: ShiftOverlayProps): JSX.Element | null {
+	const navigationActions = useMemo(() => {
+		// RBAC filter: show action if no roles set OR current user role is included
+		const permitted = actions.filter(
+			(a) => !a.roles || a.roles.includes(userRole),
+		);
+
+		// Navigation only + must have shortcut
+		return permitted.filter(
+			(a) =>
+				a.section?.toLowerCase() === 'navigation' &&
+				a.shortcut &&
+				a.shortcut.length > 0,
+		);
+	}, [actions, userRole]);
+
+	if (!visible || navigationActions.length === 0) {
+		return null;
+	}
+
+	return ReactDOM.createPortal(
+		<div className="shift-overlay">
+			<div className="shift-overlay__panel">
+				{navigationActions.map((action) => (
+					<Shortcut
+						key={action.id}
+						label={action.name.replace(/^Go to\s+/i, '')}
+						keyHint={formatShortcut(action.shortcut)}
+					/>
+				))}
+			</div>
+		</div>,
+		document.body,
+	);
+}

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

@@ -0,0 +1,102 @@
+import '@testing-library/jest-dom';
+
+import { render, screen } from '@testing-library/react';
+
+import type { CmdAction } from '../ShiftOverlay';
+import { ShiftOverlay } from '../ShiftOverlay';
+
+jest.mock('../formatShortcut', () => ({
+	formatShortcut: (shortcut: string[]): string => shortcut.join('+'),
+}));
+
+const baseActions: CmdAction[] = [
+	{
+		id: '1',
+		name: 'Go to Traces',
+		section: 'navigation',
+		shortcut: ['Shift', 'T'],
+		perform: jest.fn(),
+	},
+	{
+		id: '2',
+		name: 'Go to Metrics',
+		section: 'navigation',
+		shortcut: ['Shift', 'M'],
+		roles: ['ADMIN'], // ✅ now UserRole[]
+		perform: jest.fn(),
+	},
+	{
+		id: '3',
+		name: 'Create Alert',
+		section: 'actions',
+		shortcut: ['A'],
+		perform: jest.fn(),
+	},
+	{
+		id: '4',
+		name: 'Go to Logs',
+		section: 'navigation',
+		perform: jest.fn(),
+	},
+];
+
+describe('ShiftOverlay', () => {
+	it('renders nothing when not visible', () => {
+		const { container } = render(
+			<ShiftOverlay visible={false} actions={baseActions} userRole="ADMIN" />,
+		);
+
+		expect(container.firstChild).toBeNull();
+	});
+
+	it('renders nothing when no navigation shortcuts exist', () => {
+		const { container } = render(
+			<ShiftOverlay
+				visible
+				actions={[
+					{
+						id: 'x',
+						name: 'Create Alert',
+						section: 'actions',
+						perform: jest.fn(),
+					},
+				]}
+				userRole="ADMIN"
+			/>,
+		);
+
+		expect(container.firstChild).toBeNull();
+	});
+
+	it('renders navigation shortcuts in a portal', () => {
+		render(<ShiftOverlay visible actions={baseActions} userRole="ADMIN" />);
+
+		expect(document.body.querySelector('.shift-overlay')).toBeInTheDocument();
+
+		expect(screen.getByText('Traces')).toBeInTheDocument();
+		expect(screen.getByText('Metrics')).toBeInTheDocument();
+
+		expect(screen.getByText('Shift+T')).toBeInTheDocument();
+		expect(screen.getByText('Shift+M')).toBeInTheDocument();
+	});
+
+	it('applies RBAC filtering correctly', () => {
+		render(<ShiftOverlay visible actions={baseActions} userRole="VIEWER" />);
+
+		expect(screen.getByText('Traces')).toBeInTheDocument();
+		expect(screen.queryByText('Metrics')).not.toBeInTheDocument();
+	});
+
+	it('strips "Go to" prefix from labels', () => {
+		render(<ShiftOverlay visible actions={baseActions} userRole="ADMIN" />);
+
+		expect(screen.getByText('Traces')).toBeInTheDocument();
+		expect(screen.queryByText('Go to Traces')).not.toBeInTheDocument();
+	});
+
+	it('does not render actions without shortcuts', () => {
+		render(<ShiftOverlay visible actions={baseActions} userRole="ADMIN" />);
+
+		expect(screen.queryByText('Logs')).not.toBeInTheDocument();
+	});
+});

frontend/src/components/ShiftOverlay/__tests__/useShiftHoldOverlay.test.tsx

@@ -0,0 +1,144 @@
+import { act, renderHook } from '@testing-library/react';
+
+import { useShiftHoldOverlay } from '../useShiftHoldOverlay';
+
+jest.useFakeTimers();
+
+function pressShift(target: EventTarget = window): void {
+	const event = new KeyboardEvent('keydown', {
+		key: 'Shift',
+		bubbles: true,
+	});
+	Object.defineProperty(event, 'target', { value: target });
+	window.dispatchEvent(event);
+}
+
+function releaseShift(): void {
+	window.dispatchEvent(
+		new KeyboardEvent('keyup', {
+			key: 'Shift',
+			bubbles: true,
+		}),
+	);
+}
+
+describe('useShiftHoldOverlay', () => {
+	afterEach(() => {
+		jest.clearAllTimers();
+	});
+
+	it('shows overlay after holding Shift for 600ms', () => {
+		const { result } = renderHook(() => useShiftHoldOverlay({}));
+
+		act(() => {
+			pressShift();
+			jest.advanceTimersByTime(600);
+		});
+
+		expect(result.current).toBe(true);
+	});
+
+	it('does not show overlay if Shift is released early', () => {
+		const { result } = renderHook(() => useShiftHoldOverlay({}));
+
+		act(() => {
+			pressShift();
+			jest.advanceTimersByTime(300);
+			releaseShift();
+			jest.advanceTimersByTime(600);
+		});
+
+		expect(result.current).toBe(false);
+	});
+
+	it('hides overlay on Shift key release', () => {
+		const { result } = renderHook(() => useShiftHoldOverlay({}));
+
+		act(() => {
+			pressShift();
+			jest.advanceTimersByTime(600);
+		});
+
+		expect(result.current).toBe(true);
+
+		act(() => {
+			releaseShift();
+		});
+
+		expect(result.current).toBe(false);
+	});
+
+	it('does not activate when modal is open', () => {
+		const { result } = renderHook(() =>
+			useShiftHoldOverlay({ isModalOpen: true }),
+		);
+
+		act(() => {
+			pressShift();
+			jest.advanceTimersByTime(600);
+		});
+
+		expect(result.current).toBe(false);
+	});
+
+	it('does not activate in typing context (input)', () => {
+		const input = document.createElement('input');
+		document.body.appendChild(input);
+
+		const { result } = renderHook(() => useShiftHoldOverlay({}));
+
+		act(() => {
+			pressShift(input);
+			jest.advanceTimersByTime(600);
+		});
+
+		expect(result.current).toBe(false);
+
+		document.body.removeChild(input);
+	});
+
+	it('cleans up on window blur', () => {
+		const { result } = renderHook(() => useShiftHoldOverlay({}));
+
+		act(() => {
+			pressShift();
+			jest.advanceTimersByTime(600);
+		});
+
+		expect(result.current).toBe(true);
+
+		act(() => {
+			window.dispatchEvent(new Event('blur'));
+		});
+
+		expect(result.current).toBe(false);
+	});
+
+	it('cleans up on document visibility change', () => {
+		const { result } = renderHook(() => useShiftHoldOverlay({}));
+
+		act(() => {
+			pressShift();
+			jest.advanceTimersByTime(600);
+		});
+
+		expect(result.current).toBe(true);
+
+		act(() => {
+			document.dispatchEvent(new Event('visibilitychange'));
+		});
+
+		expect(result.current).toBe(false);
+	});
+
+	it('does nothing when disabled', () => {
+		const { result } = renderHook(() => useShiftHoldOverlay({ disabled: true }));
+
+		act(() => {
+			pressShift();
+			jest.advanceTimersByTime(600);
+		});
+
+		expect(result.current).toBe(false);
+	});
+});

frontend/src/components/ShiftOverlay/formatShortcut.tsx

@@ -0,0 +1,44 @@
+import './shiftOverlay.scss';
+
+import { ArrowUp, ChevronUp, Command, Option } from 'lucide-react';
+import { ReactNode } from 'react';
+
+export function formatShortcut(shortcut?: string[]): ReactNode {
+	if (!shortcut || shortcut.length === 0) return null;
+
+	const combo = shortcut.find((s) => typeof s === 'string' && s.trim());
+	if (!combo) return null;
+
+	return combo.split('+').map((key) => {
+		const k = key.trim().toLowerCase();
+
+		let node: ReactNode;
+		switch (k) {
+			case 'shift':
+				node = <ArrowUp size={14} />;
+				break;
+			case 'cmd':
+			case 'meta':
+				node = <Command size={14} />;
+				break;
+			case 'alt':
+				node = <Option size={14} />;
+				break;
+			case 'ctrl':
+			case 'control':
+				node = <ChevronUp size={14} />;
+				break;
+			case 'arrowup':
+				node = <ArrowUp size={14} />;
+				break;
+			default:
+				node = k.toUpperCase();
+		}
+
+		return (
+			<span key={`shortcut-${k}`} className="shift-overlay__key">
+				{node}
+			</span>
+		);
+	});
+}

frontend/src/components/ShiftOverlay/shiftOverlay.scss

@@ -0,0 +1,75 @@
+.shift-overlay {
+	position: fixed;
+	bottom: 20px;
+	left: 50%;
+	transform: translateX(-50%);
+	z-index: 9999;
+	pointer-events: none;
+
+	&__panel {
+		display: flex;
+		gap: 20px;
+		padding: 8px 12px;
+
+		background: var(--bg-ink-500);
+		color: var(--bg-vanilla-300);
+
+		border-radius: 8px;
+		font-size: 13px;
+		line-height: 1.2;
+
+		box-shadow: 0 6px 20px var(--bg-ink-500);
+		animation: shift-overlay-fade-in 120ms ease-out;
+	}
+
+	&__item {
+		display: flex;
+		align-items: center;
+		gap: 6px;
+		white-space: nowrap;
+	}
+
+	&__label {
+		opacity: 0.9;
+	}
+
+	&__kbd {
+		font-family: monospace;
+		font-size: 12px;
+		padding: 2px 6px;
+		display: flex;
+
+		border-radius: 4px;
+		background: var(--bg-slate-100);
+	}
+
+	&__key {
+		display: inline-flex;
+		align-items: center;
+		justify-content: center;
+
+		min-width: 15px;
+		height: 20px;
+
+		border-radius: 4px;
+
+		background-color: var(--bg-slate-100);
+
+		font-size: 12px;
+		font-weight: 500;
+		line-height: 1;
+		color: var(--bg-vanilla-300);
+		flex-shrink: 0;
+	}
+}
+
+@keyframes shift-overlay-fade-in {
+	from {
+		opacity: 0;
+		transform: translateY(-4px);
+	}
+	to {
+		opacity: 1;
+		transform: translateY(0);
+	}
+}

frontend/src/components/ShiftOverlay/useShiftHoldOverlay.ts

@@ -0,0 +1,87 @@
+import { useEffect, useRef, useState } from 'react';
+
+const HOLD_DELAY_MS = 500;
+
+function isTypingContext(target: EventTarget | null): boolean {
+	if (!(target instanceof HTMLElement)) return false;
+
+	const tag = target.tagName;
+	return tag === 'INPUT' || tag === 'TEXTAREA' || target.isContentEditable;
+}
+
+interface UseShiftHoldOverlayOptions {
+	disabled?: boolean;
+	isModalOpen?: boolean;
+}
+
+export function useShiftHoldOverlay({
+	disabled = false,
+	isModalOpen = false,
+}: UseShiftHoldOverlayOptions): boolean {
+	const [visible, setVisible] = useState<boolean>(false);
+
+	const timerRef = useRef<number | null>(null);
+	const isHoldingRef = useRef<boolean>(false);
+
+	useEffect((): (() => void) | void => {
+		if (disabled) return;
+
+		function cleanup(): void {
+			isHoldingRef.current = false;
+
+			if (timerRef.current !== null) {
+				window.clearTimeout(timerRef.current);
+				timerRef.current = null;
+			}
+
+			setVisible(false);
+		}
+
+		function onKeyDown(e: KeyboardEvent): void {
+			if (e.key !== 'Shift') return;
+			if (e.repeat) return;
+
+			// Suppress in bad contexts
+			if (
+				isModalOpen ||
+				e.metaKey ||
+				e.ctrlKey ||
+				e.altKey ||
+				isTypingContext(e.target)
+			) {
+				return;
+			}
+
+			isHoldingRef.current = true;
+
+			timerRef.current = window.setTimeout(() => {
+				if (isHoldingRef.current) {
+					setVisible(true);
+				}
+			}, HOLD_DELAY_MS);
+		}
+
+		function onKeyUp(e: KeyboardEvent): void {
+			if (e.key !== 'Shift') return;
+			cleanup();
+		}
+
+		function onBlur(): void {
+			cleanup();
+		}
+
+		window.addEventListener('keydown', onKeyDown);
+		window.addEventListener('keyup', onKeyUp);
+		window.addEventListener('blur', onBlur);
+		document.addEventListener('visibilitychange', cleanup);
+
+		return (): void => {
+			window.removeEventListener('keydown', onKeyDown);
+			window.removeEventListener('keyup', onKeyUp);
+			window.removeEventListener('blur', onBlur);
+			document.removeEventListener('visibilitychange', cleanup);
+		};
+	}, [disabled, isModalOpen]);
+
+	return visible;
+}

frontend/src/components/cmdKPalette/__test__/cmdkPalette.test.tsx

@@ -159,7 +159,6 @@ describe('CmdKPalette', () => {
 
 		expect(screen.getByText(HOME_LABEL)).toBeInTheDocument();
 		expect(screen.getByText('Go to Dashboards')).toBeInTheDocument();
-		expect(screen.getByText('Open Sidebar')).toBeInTheDocument();
 		expect(screen.getByText('Switch to Dark Mode')).toBeInTheDocument();
 	});
 

frontend/src/components/cmdKPalette/cmdKPalette.tsx

@@ -9,34 +9,12 @@ import {
 	CommandList,
 	CommandShortcut,
 } from '@signozhq/command';
-import setLocalStorageApi from 'api/browser/localstorage/set';
 import logEvent from 'api/common/logEvent';
-import updateUserPreference from 'api/v1/user/preferences/name/update';
-import { AxiosError } from 'axios';
-import ROUTES from 'constants/routes';
-import { USER_PREFERENCES } from 'constants/userPreferences';
 import { useThemeMode } from 'hooks/useDarkMode';
-import { THEME_MODE } from 'hooks/useDarkMode/constant';
-import { useNotifications } from 'hooks/useNotifications';
 import history from 'lib/history';
-import {
-	BellDot,
-	BugIcon,
-	DraftingCompass,
-	Expand,
-	HardDrive,
-	Home,
-	LayoutGrid,
-	ListMinus,
-	ScrollText,
-	Settings,
-} from 'lucide-react';
 import React, { useEffect } from 'react';
-import { useMutation } from 'react-query';
-import { UserPreference } from 'types/api/preferences/preference';
-import { showErrorNotification } from 'utils/error';
 
-import { useAppContext } from '../../providers/App/App';
+import { createShortcutActions } from '../../constants/shortcutActions';
 import { useCmdK } from '../../providers/cmdKProvider';
 
 type CmdAction = {
@@ -58,19 +36,8 @@ export function CmdKPalette({
 }): JSX.Element | null {
 	const { open, setOpen } = useCmdK();
 
-	const { updateUserPreferenceInContext } = useAppContext();
-	const { notifications } = useNotifications();
 	const { setAutoSwitch, setTheme, theme } = useThemeMode();
 
-	const { mutate: updateUserPreferenceMutation } = useMutation(
-		updateUserPreference,
-		{
-			onError: (error) => {
-				showErrorNotification(notifications, error as AxiosError);
-			},
-		},
-	);
-
 	// toggle palette with ⌘/Ctrl+K
 	function handleGlobalCmdK(
 		e: KeyboardEvent,
@@ -111,164 +78,10 @@ export function CmdKPalette({
 		history.push(key);
 	}
 
-	function handleOpenSidebar(): void {
-		setLocalStorageApi(USER_PREFERENCES.SIDENAV_PINNED, 'true');
-		const save = { name: USER_PREFERENCES.SIDENAV_PINNED, value: true };
-		updateUserPreferenceInContext(save as UserPreference);
-		updateUserPreferenceMutation({
-			name: USER_PREFERENCES.SIDENAV_PINNED,
-			value: true,
-		});
-	}
-
-	function handleCloseSidebar(): void {
-		setLocalStorageApi(USER_PREFERENCES.SIDENAV_PINNED, 'false');
-		const save = { name: USER_PREFERENCES.SIDENAV_PINNED, value: false };
-		updateUserPreferenceInContext(save as UserPreference);
-		updateUserPreferenceMutation({
-			name: USER_PREFERENCES.SIDENAV_PINNED,
-			value: false,
-		});
-	}
-
-	const actions: CmdAction[] = [
-		{
-			id: 'home',
-			name: 'Go to Home',
-			shortcut: ['shift + h'],
-			keywords: 'home',
-			section: 'Navigation',
-			icon: <Home size={14} />,
-			roles: ['ADMIN', 'EDITOR', 'AUTHOR', 'VIEWER'],
-			perform: (): void => onClickHandler(ROUTES.HOME),
-		},
-		{
-			id: 'dashboards',
-			name: 'Go to Dashboards',
-			shortcut: ['shift + d'],
-			keywords: 'dashboards',
-			section: 'Navigation',
-			icon: <LayoutGrid size={14} />,
-			roles: ['ADMIN', 'EDITOR', 'AUTHOR', 'VIEWER'],
-			perform: (): void => onClickHandler(ROUTES.ALL_DASHBOARD),
-		},
-		{
-			id: 'services',
-			name: 'Go to Services',
-			shortcut: ['shift + s'],
-			keywords: 'services monitoring',
-			section: 'Navigation',
-			icon: <HardDrive size={14} />,
-			roles: ['ADMIN', 'EDITOR', 'AUTHOR', 'VIEWER'],
-			perform: (): void => onClickHandler(ROUTES.APPLICATION),
-		},
-		{
-			id: 'traces',
-			name: 'Go to Traces',
-			shortcut: ['shift + t'],
-			keywords: 'traces',
-			section: 'Navigation',
-			icon: <DraftingCompass size={14} />,
-			roles: ['ADMIN', 'EDITOR', 'AUTHOR', 'VIEWER'],
-			perform: (): void => onClickHandler(ROUTES.TRACES_EXPLORER),
-		},
-		{
-			id: 'logs',
-			name: 'Go to Logs',
-			shortcut: ['shift + l'],
-			keywords: 'logs',
-			section: 'Navigation',
-			icon: <ScrollText size={14} />,
-			roles: ['ADMIN', 'EDITOR', 'AUTHOR', 'VIEWER'],
-			perform: (): void => onClickHandler(ROUTES.LOGS),
-		},
-		{
-			id: 'alerts',
-			name: 'Go to Alerts',
-			shortcut: ['shift + a'],
-			keywords: 'alerts',
-			section: 'Navigation',
-			icon: <BellDot size={14} />,
-			roles: ['ADMIN', 'EDITOR', 'AUTHOR', 'VIEWER'],
-			perform: (): void => onClickHandler(ROUTES.LIST_ALL_ALERT),
-		},
-		{
-			id: 'exceptions',
-			name: 'Go to Exceptions',
-			shortcut: ['shift + e'],
-			keywords: 'exceptions errors',
-			section: 'Navigation',
-			icon: <BugIcon size={14} />,
-			roles: ['ADMIN', 'EDITOR', 'AUTHOR', 'VIEWER'],
-			perform: (): void => onClickHandler(ROUTES.ALL_ERROR),
-		},
-		{
-			id: 'messaging-queues',
-			name: 'Go to Messaging Queues',
-			shortcut: ['shift + m'],
-			keywords: 'messaging queues mq',
-			section: 'Navigation',
-			icon: <ListMinus size={14} />,
-			roles: ['ADMIN', 'EDITOR', 'AUTHOR', 'VIEWER'],
-			perform: (): void => onClickHandler(ROUTES.MESSAGING_QUEUES_OVERVIEW),
-		},
-		{
-			id: 'my-settings',
-			name: 'Go to Account Settings',
-			keywords: 'account settings',
-			section: 'Navigation',
-			icon: <Settings size={14} />,
-			roles: ['ADMIN', 'EDITOR', 'AUTHOR', 'VIEWER'],
-			perform: (): void => onClickHandler(ROUTES.MY_SETTINGS),
-		},
-
-		// Settings
-		{
-			id: 'open-sidebar',
-			name: 'Open Sidebar',
-			keywords: 'sidebar navigation menu expand',
-			section: 'Settings',
-			icon: <Expand size={14} />,
-			roles: ['ADMIN', 'EDITOR', 'AUTHOR', 'VIEWER'],
-			perform: (): void => handleOpenSidebar(),
-		},
-		{
-			id: 'collapse-sidebar',
-			name: 'Collapse Sidebar',
-			keywords: 'sidebar navigation menu collapse',
-			section: 'Settings',
-			icon: <Expand size={14} />,
-			roles: ['ADMIN', 'EDITOR', 'AUTHOR', 'VIEWER'],
-			perform: (): void => handleCloseSidebar(),
-		},
-		{
-			id: 'dark-mode',
-			name: 'Switch to Dark Mode',
-			keywords: 'theme dark mode appearance',
-			section: 'Settings',
-			icon: <Expand size={14} />,
-			roles: ['ADMIN', 'EDITOR', 'AUTHOR', 'VIEWER'],
-			perform: (): void => handleThemeChange(THEME_MODE.DARK),
-		},
-		{
-			id: 'light-mode',
-			name: 'Switch to Light Mode [Beta]',
-			keywords: 'theme light mode appearance',
-			section: 'Settings',
-			icon: <Expand size={14} />,
-			roles: ['ADMIN', 'EDITOR', 'AUTHOR', 'VIEWER'],
-			perform: (): void => handleThemeChange(THEME_MODE.LIGHT),
-		},
-		{
-			id: 'system-theme',
-			name: 'Switch to System Theme',
-			keywords: 'system theme appearance',
-			section: 'Settings',
-			icon: <Expand size={14} />,
-			roles: ['ADMIN', 'EDITOR', 'AUTHOR', 'VIEWER'],
-			perform: (): void => handleThemeChange(THEME_MODE.SYSTEM),
-		},
-	];
+	const actions = createShortcutActions({
+		navigate: onClickHandler,
+		handleThemeChange,
+	});
 
 	// RBAC filter: show action if no roles set OR current user role is included
 	const permitted = actions.filter(

frontend/src/constants/shortcutActions.tsx

@@ -0,0 +1,263 @@
+import ROUTES from 'constants/routes';
+import { GlobalShortcutsName } from 'constants/shortcuts/globalShortcuts';
+import { THEME_MODE } from 'hooks/useDarkMode/constant';
+import {
+	BarChart2,
+	BellDot,
+	BugIcon,
+	Compass,
+	DraftingCompass,
+	Expand,
+	HardDrive,
+	Home,
+	LayoutGrid,
+	ListMinus,
+	ScrollText,
+	Settings,
+	TowerControl,
+	Workflow,
+} from 'lucide-react';
+import React from 'react';
+
+export type UserRole = 'ADMIN' | 'EDITOR' | 'AUTHOR' | 'VIEWER';
+
+export type CmdAction = {
+	id: string;
+	name: string;
+	shortcut?: string[];
+	keywords?: string;
+	section?: string;
+	icon?: React.ReactNode;
+	roles?: UserRole[];
+	perform: () => void;
+};
+
+type ActionDeps = {
+	navigate: (path: string) => void;
+	handleThemeChange: (mode: string) => void;
+};
+
+export function createShortcutActions(deps: ActionDeps): CmdAction[] {
+	const { navigate, handleThemeChange } = deps;
+
+	return [
+		{
+			id: 'home',
+			name: 'Go to Home',
+			shortcut: [GlobalShortcutsName.NavigateToHome],
+			keywords: 'home',
+			section: 'Navigation',
+			icon: <Home size={14} />,
+			roles: ['ADMIN', 'EDITOR', 'VIEWER'],
+			perform: (): void => navigate(ROUTES.HOME),
+		},
+		{
+			id: 'dashboards',
+			name: 'Go to Dashboards',
+			shortcut: [GlobalShortcutsName.NavigateToDashboards],
+			keywords: 'dashboards',
+			section: 'Navigation',
+			icon: <LayoutGrid size={14} />,
+			roles: ['ADMIN', 'EDITOR', 'VIEWER'],
+			perform: (): void => navigate(ROUTES.ALL_DASHBOARD),
+		},
+		{
+			id: 'services',
+			name: 'Go to Services',
+			shortcut: [GlobalShortcutsName.NavigateToServices],
+			keywords: 'services monitoring',
+			section: 'Navigation',
+			icon: <HardDrive size={14} />,
+			roles: ['ADMIN', 'EDITOR', 'VIEWER'],
+			perform: (): void => navigate(ROUTES.APPLICATION),
+		},
+		{
+			id: 'alerts',
+			name: 'Go to Alerts',
+			shortcut: [GlobalShortcutsName.NavigateToAlerts],
+			keywords: 'alerts',
+			section: 'Navigation',
+			icon: <BellDot size={14} />,
+			roles: ['ADMIN', 'EDITOR', 'VIEWER'],
+			perform: (): void => navigate(ROUTES.LIST_ALL_ALERT),
+		},
+		{
+			id: 'exceptions',
+			name: 'Go to Exceptions',
+			shortcut: [GlobalShortcutsName.NavigateToExceptions],
+			keywords: 'exceptions errors',
+			section: 'Navigation',
+			icon: <BugIcon size={14} />,
+			roles: ['ADMIN', 'EDITOR', 'VIEWER'],
+			perform: (): void => navigate(ROUTES.ALL_ERROR),
+		},
+		{
+			id: 'messaging-queues',
+			name: 'Go to Messaging Queues',
+			shortcut: [GlobalShortcutsName.NavigateToMessagingQueues],
+			keywords: 'messaging queues mq',
+			section: 'Navigation',
+			icon: <ListMinus size={14} />,
+			roles: ['ADMIN', 'EDITOR', 'VIEWER'],
+			perform: (): void => navigate(ROUTES.MESSAGING_QUEUES_OVERVIEW),
+		},
+
+		// logs
+		{
+			id: 'logs',
+			name: 'Go to Logs',
+			shortcut: [GlobalShortcutsName.NavigateToLogs],
+			keywords: 'logs',
+			section: 'Logs',
+			icon: <ScrollText size={14} />,
+			roles: ['ADMIN', 'EDITOR', 'VIEWER'],
+			perform: (): void => navigate(ROUTES.LOGS),
+		},
+		{
+			id: 'logs',
+			name: 'Go to Logs Pipelines',
+			shortcut: [GlobalShortcutsName.NavigateToLogsPipelines],
+			keywords: 'logs pipelines',
+			section: 'Logs',
+			icon: <Workflow size={14} />,
+			roles: ['ADMIN', 'EDITOR', 'VIEWER'],
+			perform: (): void => navigate(ROUTES.LOGS_PIPELINES),
+		},
+		{
+			id: 'logs',
+			name: 'Go to Logs Views',
+			shortcut: [GlobalShortcutsName.NavigateToLogsViews],
+			keywords: 'logs views',
+			section: 'Logs',
+			icon: <TowerControl size={14} />,
+			roles: ['ADMIN', 'EDITOR', 'VIEWER'],
+			perform: (): void => navigate(ROUTES.LOGS_SAVE_VIEWS),
+		},
+
+		// metrics
+		{
+			id: 'metrics-summary',
+			name: 'Go to Metrics Summary',
+			shortcut: [GlobalShortcutsName.NavigateToMetricsSummary],
+			keywords: 'metrics summary',
+			section: 'Metrics',
+			icon: <BarChart2 size={14} />,
+			roles: ['ADMIN', 'EDITOR', 'VIEWER'],
+			perform: (): void => navigate(ROUTES.METRICS_EXPLORER),
+		},
+		{
+			id: 'metrics-explorer',
+			name: 'Go to Metrics Explorer',
+			shortcut: [GlobalShortcutsName.NavigateToMetricsExplorer],
+			keywords: 'metrics explorer',
+			section: 'Metrics',
+			icon: <Compass size={14} />,
+			roles: ['ADMIN', 'EDITOR', 'VIEWER'],
+			perform: (): void => navigate(ROUTES.METRICS_EXPLORER_EXPLORER),
+		},
+		{
+			id: 'metrics-views',
+			name: 'Go to Metrics Views',
+			shortcut: [GlobalShortcutsName.NavigateToMetricsViews],
+			keywords: 'metrics views',
+			section: 'Metrics',
+			icon: <TowerControl size={14} />,
+			roles: ['ADMIN', 'EDITOR', 'VIEWER'],
+			perform: (): void => navigate(ROUTES.METRICS_EXPLORER_VIEWS),
+		},
+
+		// Traces
+		{
+			id: 'traces',
+			name: 'Go to Traces',
+			shortcut: [GlobalShortcutsName.NavigateToTraces],
+			keywords: 'traces',
+			section: 'Traces',
+			icon: <DraftingCompass size={14} />,
+			roles: ['ADMIN', 'EDITOR', 'VIEWER'],
+			perform: (): void => navigate(ROUTES.TRACES_EXPLORER),
+		},
+		{
+			id: 'traces-funnel',
+			name: 'Go to Traces Funnels',
+			shortcut: [GlobalShortcutsName.NavigateToTracesFunnel],
+			keywords: 'traces funnel',
+			section: 'Traces',
+			icon: <DraftingCompass size={14} />,
+			roles: ['ADMIN', 'EDITOR', 'VIEWER'],
+			perform: (): void => navigate(ROUTES.TRACES_FUNNELS),
+		},
+
+		// Common actions
+		{
+			id: 'dark-mode',
+			name: 'Switch to Dark Mode',
+			keywords: 'theme dark mode appearance',
+			section: 'Common',
+			icon: <Expand size={14} />,
+			roles: ['ADMIN', 'EDITOR', 'VIEWER'],
+			perform: (): void => handleThemeChange(THEME_MODE.DARK),
+		},
+		{
+			id: 'light-mode',
+			name: 'Switch to Light Mode [Beta]',
+			keywords: 'theme light mode appearance',
+			section: 'Common',
+			icon: <Expand size={14} />,
+			roles: ['ADMIN', 'EDITOR', 'VIEWER'],
+			perform: (): void => handleThemeChange(THEME_MODE.LIGHT),
+		},
+		{
+			id: 'system-theme',
+			name: 'Switch to System Theme',
+			keywords: 'system theme appearance',
+			section: 'Common',
+			icon: <Expand size={14} />,
+			roles: ['ADMIN', 'EDITOR', 'VIEWER'],
+			perform: (): void => handleThemeChange(THEME_MODE.SYSTEM),
+		},
+
+		// settings sub-pages
+		{
+			id: 'my-settings',
+			name: 'Go to Account Settings',
+			shortcut: [GlobalShortcutsName.NavigateToSettings],
+			keywords: 'account settings',
+			section: 'Settings',
+			icon: <Settings size={14} />,
+			roles: ['ADMIN', 'EDITOR', 'VIEWER'],
+			perform: (): void => navigate(ROUTES.MY_SETTINGS),
+		},
+		{
+			id: 'my-settings-ingestion',
+			name: 'Go to Account Settings Ingestion',
+			shortcut: [GlobalShortcutsName.NavigateToSettingsIngestion],
+			keywords: 'account settings',
+			section: 'Settings',
+			icon: <Settings size={14} />,
+			roles: ['ADMIN', 'EDITOR'],
+			perform: (): void => navigate(ROUTES.INGESTION_SETTINGS),
+		},
+
+		{
+			id: 'my-settings-billing',
+			name: 'Go to Account Settings Billing',
+			shortcut: [GlobalShortcutsName.NavigateToSettingsBilling],
+			keywords: 'account settings billing',
+			section: 'Settings',
+			icon: <Settings size={14} />,
+			roles: ['ADMIN', 'EDITOR'],
+			perform: (): void => navigate(ROUTES.BILLING),
+		},
+		{
+			id: 'my-settings-api-keys',
+			name: 'Go to Account Settings API Keys',
+			shortcut: [GlobalShortcutsName.NavigateToSettingsAPIKeys],
+			keywords: 'account settings api keys',
+			section: 'Settings',
+			icon: <Settings size={14} />,
+			roles: ['ADMIN', 'EDITOR'],
+			perform: (): void => navigate(ROUTES.API_KEYS),
+		},
+	];
+}

frontend/src/constants/shortcuts/globalShortcuts.ts

@@ -1,25 +1,57 @@
 export const GlobalShortcuts = {
-	NavigateToServices: 's+shift',
-	NavigateToTraces: 't+shift',
-	NavigateToLogs: 'l+shift',
-	NavigateToDashboards: 'd+shift',
-	NavigateToAlerts: 'a+shift',
-	NavigateToExceptions: 'e+shift',
-	NavigateToMessagingQueues: 'm+shift',
-	ToggleSidebar: 'b+shift',
-	NavigateToHome: 'h+shift',
+	NavigateToServices: 'shift+s',
+	NavigateToDashboards: 'shift+d',
+	NavigateToAlerts: 'shift+a',
+	NavigateToExceptions: 'shift+e',
+	NavigateToMessagingQueues: 'shift+q',
+	ToggleSidebar: 'shift+b',
+	NavigateToHome: 'shift+h',
+
+	// logs
+	NavigateToLogs: 'shift+l',
+	NavigateToLogsPipelines: 'shift+l+p',
+	NavigateToLogsViews: 'shift+l+v',
+
+	// traces
+	NavigateToTraces: 'shift+t',
+	NavigateToTracesFunnel: 'shift+t+f',
+	NavigateToTracesViews: 'shift+t+v',
+
+	// metrics
+	NavigateToMetricsSummary: 'shift+m',
+	NavigateToMetricsExplorer: 'shift+m+e',
+	NavigateToMetricsViews: 'shift+m+v',
+
+	// settings
+	NavigateToSettings: 'shift+g',
+	NavigateToSettingsIngestion: 'shift+g+i',
+	NavigateToSettingsBilling: 'shift+g+b',
+	NavigateToSettingsAPIKeys: 'shift+g+k',
+	NavigateToSettingsNotificationChannels: 'shift+g+n',
 };
 
 export const GlobalShortcutsName = {
 	NavigateToServices: 'shift+s',
 	NavigateToTraces: 'shift+t',
-	NavigateToLogs: 'shift+l',
 	NavigateToDashboards: 'shift+d',
 	NavigateToAlerts: 'shift+a',
 	NavigateToExceptions: 'shift+e',
-	NavigateToMessagingQueues: 'shift+m',
+	NavigateToMessagingQueues: 'shift+q',
 	ToggleSidebar: 'shift+b',
 	NavigateToHome: 'shift+h',
+	NavigateToTracesFunnel: 'shift+t+f',
+	NavigateToTracesViews: 'shift+t+v',
+	NavigateToMetricsSummary: 'shift+m',
+	NavigateToMetricsExplorer: 'shift+m+e',
+	NavigateToMetricsViews: 'shift+m+v',
+	NavigateToSettings: 'shift+g',
+	NavigateToSettingsIngestion: 'shift+g+i',
+	NavigateToSettingsBilling: 'shift+g+b',
+	NavigateToSettingsAPIKeys: 'shift+g+k',
+	NavigateToSettingsNotificationChannels: 'shift+g+n',
+	NavigateToLogs: 'shift+l',
+	NavigateToLogsPipelines: 'shift+l+p',
+	NavigateToLogsViews: 'shift+l+v',
 };
 
 export const GlobalShortcutsDescription = {
@@ -32,4 +64,17 @@ export const GlobalShortcutsDescription = {
 	NavigateToExceptions: 'Navigate to Exceptions List',
 	NavigateToMessagingQueues: 'Navigate to Messaging Queues',
 	ToggleSidebar: 'Toggle sidebar visibility',
+	NavigateToTracesFunnel: 'Navigate to Traces Funnel',
+	NavigateToTracesViews: 'Navigate to Traces Views',
+	NavigateToMetricsSummary: 'Navigate to Metrics Summary',
+	NavigateToMetricsExplorer: 'Navigate to Metrics Explorer',
+	NavigateToMetricsViews: 'Navigate to Metrics Views',
+	NavigateToSettings: 'Navigate to Settings',
+	NavigateToSettingsIngestion: 'Navigate to Ingestion Settings',
+	NavigateToSettingsBilling: 'Navigate to Billing Settings',
+	NavigateToSettingsAPIKeys: 'Navigate to API Keys Settings',
+	NavigateToSettingsNotificationChannels:
+		'Navigate to Notification Channels Settings',
+	NavigateToLogsPipelines: 'Navigate to Logs Pipelines',
+	NavigateToLogsViews: 'Navigate to Logs Views',
 };

frontend/src/container/AppLayout/__tests__/sidebar-toggle-shortcut.test.tsx

@@ -10,6 +10,20 @@ import {
 import { QueryClient, QueryClientProvider } from 'react-query';
 
 // Mock dependencies
+jest.mock('providers/cmdKProvider', () => ({
+	useCmdK: (): {
+		open: boolean;
+		setOpen: React.Dispatch<React.SetStateAction<boolean>>;
+		openCmdK: () => void;
+		closeCmdK: () => void;
+	} => ({
+		open: false,
+		setOpen: jest.fn(),
+		openCmdK: jest.fn(),
+		closeCmdK: jest.fn(),
+	}),
+}));
+
 jest.mock('api/common/logEvent', () => jest.fn());
 
 // Mock the AppContext
@@ -63,7 +77,7 @@ describe('Sidebar Toggle Shortcut', () => {
 
 	describe('Global Shortcuts Constants', () => {
 		it('should have the correct shortcut key combination', () => {
-			expect(GlobalShortcuts.ToggleSidebar).toBe('b+shift');
+			expect(GlobalShortcuts.ToggleSidebar).toBe('shift+b');
 		});
 	});
 

frontend/src/container/GridCardLayout/GridCard/WidgetGraphComponent.tsx

@@ -67,7 +67,6 @@ function WidgetGraphComponent({
 }: WidgetGraphComponentProps): JSX.Element {
 	const { safeNavigate } = useSafeNavigate();
 	const [deleteModal, setDeleteModal] = useState(false);
-	const [hovered, setHovered] = useState(false);
 	const { notifications } = useNotifications();
 	const { pathname, search } = useLocation();
 
@@ -316,18 +315,6 @@ function WidgetGraphComponent({
 			style={{
 				height: '100%',
 			}}
-			onMouseOver={(): void => {
-				setHovered(true);
-			}}
-			onFocus={(): void => {
-				setHovered(true);
-			}}
-			onMouseOut={(): void => {
-				setHovered(false);
-			}}
-			onBlur={(): void => {
-				setHovered(false);
-			}}
 			id={widget.id}
 			className="widget-graph-component-container"
 		>
@@ -377,7 +364,6 @@ function WidgetGraphComponent({
 
 			<div className="drag-handle">
 				<WidgetHeader
-					parentHover={hovered}
 					title={widget?.title}
 					widget={widget}
 					onView={handleOnView}

frontend/src/container/GridCardLayout/GridCardLayout.styles.scss

@@ -99,6 +99,12 @@
 			height: calc(100% - 30px);
 		}
 	}
+
+	&:hover {
+		.widget-header-more-options {
+			visibility: visible;
+		}
+	}
 }
 
 .widget-full-view {

frontend/src/container/GridCardLayout/WidgetHeader/WidgetHeader.styles.scss

@@ -51,10 +51,6 @@
 	visibility: visible;
 }
 
-.widget-header-hover {
-	visibility: visible;
-}
-
 .widget-api-actions {
 	padding-right: 0.25rem;
 }

frontend/src/container/GridCardLayout/WidgetHeader/__tests__/WidgetHeader.test.tsx

@@ -181,7 +181,6 @@ describe('WidgetHeader', () => {
 				title={TEST_WIDGET_TITLE}
 				widget={mockWidget}
 				onView={mockOnView}
-				parentHover={false}
 				queryResponse={mockQueryResponse}
 				isWarning={false}
 				isFetchingResponse={false}
@@ -204,7 +203,6 @@ describe('WidgetHeader', () => {
 				title="Empty Widget"
 				widget={emptyWidget}
 				onView={mockOnView}
-				parentHover={false}
 				queryResponse={mockQueryResponse}
 				isWarning={false}
 				isFetchingResponse={false}
@@ -227,7 +225,6 @@ describe('WidgetHeader', () => {
 				title={TABLE_WIDGET_TITLE}
 				widget={tableWidget}
 				onView={mockOnView}
-				parentHover={false}
 				queryResponse={mockQueryResponse}
 				isWarning={false}
 				isFetchingResponse={false}
@@ -255,7 +252,6 @@ describe('WidgetHeader', () => {
 				title={TABLE_WIDGET_TITLE}
 				widget={tableWidget}
 				onView={mockOnView}
-				parentHover={false}
 				queryResponse={mockQueryResponse}
 				isWarning={false}
 				isFetchingResponse={false}
@@ -298,7 +294,6 @@ describe('WidgetHeader', () => {
 				title={TEST_WIDGET_TITLE}
 				widget={mockWidget}
 				onView={mockOnView}
-				parentHover={false}
 				queryResponse={errorResponse}
 				isWarning={false}
 				isFetchingResponse={false}
@@ -340,7 +335,6 @@ describe('WidgetHeader', () => {
 				title={TEST_WIDGET_TITLE}
 				widget={mockWidget}
 				onView={mockOnView}
-				parentHover={false}
 				queryResponse={warningResponse}
 				isWarning
 				isFetchingResponse={false}
@@ -370,7 +364,6 @@ describe('WidgetHeader', () => {
 				title={TEST_WIDGET_TITLE}
 				widget={mockWidget}
 				onView={mockOnView}
-				parentHover={false}
 				queryResponse={fetchingResponse}
 				isWarning={false}
 				isFetchingResponse
@@ -389,7 +382,6 @@ describe('WidgetHeader', () => {
 				title={TEST_WIDGET_TITLE}
 				widget={mockWidget}
 				onView={mockOnView}
-				parentHover={false}
 				queryResponse={mockQueryResponse}
 				isWarning={false}
 				isFetchingResponse={false}
@@ -414,7 +406,6 @@ describe('WidgetHeader', () => {
 				title={TABLE_WIDGET_TITLE}
 				widget={tableWidget}
 				onView={mockOnView}
-				parentHover={false}
 				queryResponse={mockQueryResponse}
 				isWarning={false}
 				isFetchingResponse={false}
@@ -433,7 +424,6 @@ describe('WidgetHeader', () => {
 				title={TEST_WIDGET_TITLE}
 				widget={mockWidget}
 				onView={mockOnView}
-				parentHover={false}
 				queryResponse={mockQueryResponse}
 				isWarning={false}
 				isFetchingResponse={false}
@@ -454,7 +444,6 @@ describe('WidgetHeader', () => {
 				title={TEST_WIDGET_TITLE}
 				widget={mockWidget}
 				onView={mockOnView}
-				parentHover={false}
 				queryResponse={mockQueryResponse}
 				isWarning={false}
 				isFetchingResponse={false}

frontend/src/container/GridCardLayout/WidgetHeader/index.tsx

@@ -48,7 +48,6 @@ interface IWidgetHeaderProps {
 	onView: VoidFunction;
 	onDelete?: VoidFunction;
 	onClone?: VoidFunction;
-	parentHover: boolean;
 	queryResponse: UseQueryResult<
 		SuccessResponse<MetricRangePayloadProps, unknown> & {
 			warning?: Warning;
@@ -69,7 +68,6 @@ function WidgetHeader({
 	onView,
 	onDelete,
 	onClone,
-	parentHover,
 	queryResponse,
 	threshold,
 	headerMenuList,
@@ -315,8 +313,6 @@ function WidgetHeader({
 								<MoreOutlined
 									data-testid="widget-header-options"
 									className={`widget-header-more-options ${
-										parentHover ? 'widget-header-hover' : ''
-									} ${
 										globalSearchAvailable ? 'widget-header-more-options-visible' : ''
 									}`}
 								/>

frontend/src/container/LogDetailedView/BodyTitleRenderer.tsx

@@ -92,14 +92,14 @@ function BodyTitleRenderer({
 
 			if (isObject) {
 				// For objects/arrays, stringify the entire structure
-				copyText = `"${cleanedKey}": ${JSON.stringify(value, null, 2)}`;
+				copyText = JSON.stringify(value, null, 2);
 			} else if (parentIsArray) {
-				// For array elements, copy just the value
-				copyText = `"${cleanedKey}": ${value}`;
+				// array elements
+				copyText = `${value}`;
 			} else {
-				// For primitive values, format as JSON key-value pair
-				const valueStr = typeof value === 'string' ? `"${value}"` : String(value);
-				copyText = `"${cleanedKey}": ${valueStr}`;
+				// primitive values
+				const valueStr = typeof value === 'string' ? value : String(value);
+				copyText = valueStr;
 			}
 
 			setCopy(copyText);

frontend/src/container/LogDetailedView/TableView/TableViewActions.tsx

@@ -60,7 +60,8 @@ const BodyContent: React.FC<{
 	fieldData: Record<string, string>;
 	record: DataType;
 	bodyHtml: { __html: string };
-}> = React.memo(({ fieldData, record, bodyHtml }) => {
+	textToCopy: string;
+}> = React.memo(({ fieldData, record, bodyHtml, textToCopy }) => {
 	const { isLoading, treeData, error } = useAsyncJSONProcessing(
 		fieldData.value,
 		record.field === 'body',
@@ -92,11 +93,13 @@ const BodyContent: React.FC<{
 
 	if (record.field === 'body') {
 		return (
-			<span
-				style={{ color: Color.BG_SIENNA_400, whiteSpace: 'pre-wrap', tabSize: 4 }}
-			>
-				<span dangerouslySetInnerHTML={bodyHtml} />
-			</span>
+			<CopyClipboardHOC entityKey="body" textToCopy={textToCopy}>
+				<span
+					style={{ color: Color.BG_SIENNA_400, whiteSpace: 'pre-wrap', tabSize: 4 }}
+				>
+					<span dangerouslySetInnerHTML={bodyHtml} />
+				</span>
+			</CopyClipboardHOC>
 		);
 	}
 
@@ -172,7 +175,12 @@ export default function TableViewActions(
 		switch (record.field) {
 			case 'body':
 				return (
-					<BodyContent fieldData={fieldData} record={record} bodyHtml={bodyHtml} />
+					<BodyContent
+						fieldData={fieldData}
+						record={record}
+						bodyHtml={bodyHtml}
+						textToCopy={textToCopy}
+					/>
 				);
 
 			case 'timestamp':
@@ -194,6 +202,7 @@ export default function TableViewActions(
 		record,
 		fieldData,
 		bodyHtml,
+		textToCopy,
 		formatTimezoneAdjustedTimestamp,
 		cleanTimestamp,
 	]);
@@ -202,7 +211,12 @@ export default function TableViewActions(
 	if (record.field === 'body') {
 		return (
 			<div className={cx('value-field', isOpen ? 'open-popover' : '')}>
-				<BodyContent fieldData={fieldData} record={record} bodyHtml={bodyHtml} />
+				<BodyContent
+					fieldData={fieldData}
+					record={record}
+					bodyHtml={bodyHtml}
+					textToCopy={textToCopy}
+				/>
 				{!isListViewPanel && !RESTRICTED_SELECTED_FIELDS.includes(fieldFilterKey) && (
 					<span className="action-btn">
 						<Tooltip title="Filter for value">

frontend/src/container/LogDetailedView/TableView/__test__/TableViewActions.test.tsx

@@ -1,16 +1,54 @@
-import { render, screen } from '@testing-library/react';
+import { fireEvent, render, screen } from '@testing-library/react';
 import { RESTRICTED_SELECTED_FIELDS } from 'container/LogsFilters/config';
 
 import TableViewActions from '../TableViewActions';
+import useAsyncJSONProcessing from '../useAsyncJSONProcessing';
+
+// Mock data for tests
+let mockCopyToClipboard: jest.Mock;
+let mockNotificationsSuccess: jest.Mock;
 
 // Mock the components and hooks
 jest.mock('components/Logs/CopyClipboardHOC', () => ({
 	__esModule: true,
-	default: ({ children }: { children: React.ReactNode }): JSX.Element => (
-		<div className="CopyClipboardHOC">{children}</div>
+	default: ({
+		children,
+		textToCopy,
+		entityKey,
+	}: {
+		children: React.ReactNode;
+		textToCopy: string;
+		entityKey: string;
+	}): JSX.Element => (
+		// eslint-disable-next-line jsx-a11y/click-events-have-key-events
+		<div
+			className="CopyClipboardHOC"
+			data-testid={`copy-clipboard-${entityKey}`}
+			data-text-to-copy={textToCopy}
+			onClick={(): void => {
+				if (mockCopyToClipboard) {
+					mockCopyToClipboard(textToCopy);
+				}
+				if (mockNotificationsSuccess) {
+					mockNotificationsSuccess({
+						message: `${entityKey} copied to clipboard`,
+						key: `${entityKey} copied to clipboard`,
+					});
+				}
+			}}
+			role="button"
+			tabIndex={0}
+		>
+			{children}
+		</div>
 	),
 }));
 
+jest.mock('../useAsyncJSONProcessing', () => ({
+	__esModule: true,
+	default: jest.fn(),
+}));
+
 jest.mock('providers/Timezone', () => ({
 	useTimezone: (): {
 		formatTimezoneAdjustedTimestamp: (timestamp: string) => string;
@@ -53,6 +91,19 @@ describe('TableViewActions', () => {
 		onGroupByAttribute: jest.fn(),
 	};
 
+	beforeEach(() => {
+		mockCopyToClipboard = jest.fn();
+		mockNotificationsSuccess = jest.fn();
+
+		// Default mock for useAsyncJSONProcessing
+		const mockUseAsyncJSONProcessing = jest.mocked(useAsyncJSONProcessing);
+		mockUseAsyncJSONProcessing.mockReturnValue({
+			isLoading: false,
+			treeData: null,
+			error: null,
+		});
+	});
+
 	it('should render without crashing', () => {
 		render(
 			<TableViewActions
@@ -127,4 +178,60 @@ describe('TableViewActions', () => {
 			container.querySelector(ACTION_BUTTON_TEST_ID),
 		).not.toBeInTheDocument();
 	});
+
+	it('should copy non-JSON body text without quotes when user clicks on body', () => {
+		// Setup: body field with surrounding quotes
+		const bodyValueWithQuotes =
+			'"FeatureFlag \'kafkaQueueProblems\' is enabled, sleeping 1 second"';
+		const expectedCopiedText =
+			"FeatureFlag 'kafkaQueueProblems' is enabled, sleeping 1 second";
+
+		const bodyProps = {
+			fieldData: {
+				field: 'body',
+				value: bodyValueWithQuotes,
+			},
+			record: {
+				key: 'body-key',
+				field: 'body',
+				value: bodyValueWithQuotes,
+			},
+			isListViewPanel: false,
+			isfilterInLoading: false,
+			isfilterOutLoading: false,
+			onClickHandler: jest.fn(),
+			onGroupByAttribute: jest.fn(),
+		};
+
+		// Render component with body field
+		render(
+			<TableViewActions
+				fieldData={bodyProps.fieldData}
+				record={bodyProps.record}
+				isListViewPanel={bodyProps.isListViewPanel}
+				isfilterInLoading={bodyProps.isfilterInLoading}
+				isfilterOutLoading={bodyProps.isfilterOutLoading}
+				onClickHandler={bodyProps.onClickHandler}
+				onGroupByAttribute={bodyProps.onGroupByAttribute}
+			/>,
+		);
+
+		// Find the clickable copy area for body
+		const copyArea = screen.getByTestId('copy-clipboard-body');
+
+		// Verify it has the correct text to copy (without quotes)
+		expect(copyArea).toHaveAttribute('data-text-to-copy', expectedCopiedText);
+
+		// Action: User clicks on body content
+		fireEvent.click(copyArea);
+
+		// Assert: Text was copied without surrounding quotes
+		expect(mockCopyToClipboard).toHaveBeenCalledWith(expectedCopiedText);
+
+		// Assert: Success notification shown
+		expect(mockNotificationsSuccess).toHaveBeenCalledWith({
+			message: 'body copied to clipboard',
+			key: 'body copied to clipboard',
+		});
+	});
 });

frontend/src/container/LogDetailedView/__tests__/BodyTitleRenderer.test.tsx

@@ -51,7 +51,7 @@ describe('BodyTitleRenderer', () => {
 		await user.click(screen.getByText('name'));
 
 		await waitFor(() => {
-			expect(mockSetCopy).toHaveBeenCalledWith('"user.name": "John"');
+			expect(mockSetCopy).toHaveBeenCalledWith('John');
 			expect(mockNotification).toHaveBeenCalledWith(
 				expect.objectContaining({
 					message: expect.stringContaining('user.name'),
@@ -75,7 +75,7 @@ describe('BodyTitleRenderer', () => {
 		await user.click(screen.getByText('0'));
 
 		await waitFor(() => {
-			expect(mockSetCopy).toHaveBeenCalledWith('"items[*].0": arrayElement');
+			expect(mockSetCopy).toHaveBeenCalledWith('arrayElement');
 		});
 	});
 
@@ -96,9 +96,8 @@ describe('BodyTitleRenderer', () => {
 
 		await waitFor(() => {
 			const callArg = mockSetCopy.mock.calls[0][0];
-			expect(callArg).toContain('"user.metadata":');
-			expect(callArg).toContain('"id": 123');
-			expect(callArg).toContain('"active": true');
+			const expectedJson = JSON.stringify(testObject, null, 2);
+			expect(callArg).toBe(expectedJson);
 			expect(mockNotification).toHaveBeenCalledWith(
 				expect.objectContaining({
 					message: expect.stringContaining('object copied'),

frontend/src/container/QueryBuilder/filters/QueryBuilderSearch/OptionRenderer.styles.scss

@@ -0,0 +1,16 @@
+.selectOptionContainer {
+	display: flex;
+	gap: 8px;
+	justify-content: space-between;
+	align-items: center;
+	overflow-x: auto;
+
+	&::-webkit-scrollbar {
+		width: 0.2rem;
+		height: 0.2rem;
+	}
+}
+
+.option-renderer-tooltip {
+	pointer-events: none;
+}

frontend/src/container/QueryBuilder/filters/QueryBuilderSearch/OptionRenderer.tsx

@@ -1,4 +1,4 @@
-import './QueryBuilderSearch.styles.scss';
+import './OptionRenderer.styles.scss';
 
 import { Tooltip } from 'antd';
 
@@ -13,7 +13,11 @@ function OptionRenderer({
 	return (
 		<span className="option">
 			{type ? (
-				<Tooltip title={`${value}`} placement="topLeft">
+				<Tooltip
+					title={`${value}`}
+					placement="topLeft"
+					rootClassName="option-renderer-tooltip"
+				>
 					<div className="selectOptionContainer">
 						<div className="option-value">{value}</div>
 						<div className="option-meta-data-container">
@@ -29,7 +33,11 @@ function OptionRenderer({
 					</div>
 				</Tooltip>
 			) : (
-				<Tooltip title={label} placement="topLeft">
+				<Tooltip
+					title={label}
+					placement="topLeft"
+					rootClassName="option-renderer-tooltip"
+				>
 					<span>{label}</span>
 				</Tooltip>
 			)}

frontend/src/container/QueryBuilder/filters/QueryBuilderSearch/QueryBuilderSearch.styles.scss

@@ -5,19 +5,6 @@
 	gap: 12px;
 }
 
-.selectOptionContainer {
-	display: flex;
-	gap: 8px;
-	justify-content: space-between;
-	align-items: center;
-	overflow-x: auto;
-
-	&::-webkit-scrollbar {
-		width: 0.2rem;
-		height: 0.2rem;
-	}
-}
-
 .logs-popup {
 	&.hide-scroll {
 		.rc-virtual-list-holder {

frontend/src/container/QueryTable/__test__/mocks.ts

@@ -363,7 +363,6 @@ export const WidgetHeaderProps: any = {
 		title: 'Table - Panel',
 		yAxisUnit: 'none',
 	},
-	parentHover: false,
 	queryResponse: {
 		status: 'success',
 		isLoading: false,

frontend/src/container/SideNav/SideNav.tsx

@@ -679,7 +679,42 @@ function SideNav({ isPinned }: { isPinned: boolean }): JSX.Element {
 		registerShortcut(GlobalShortcuts.NavigateToExceptions, () =>
 			onClickHandler(ROUTES.ALL_ERROR, null),
 		);
-
+		registerShortcut(GlobalShortcuts.NavigateToTracesFunnel, () =>
+			onClickHandler(ROUTES.TRACES_FUNNELS, null),
+		);
+		registerShortcut(GlobalShortcuts.NavigateToTracesViews, () =>
+			onClickHandler(ROUTES.TRACES_SAVE_VIEWS, null),
+		);
+		registerShortcut(GlobalShortcuts.NavigateToMetricsSummary, () =>
+			onClickHandler(ROUTES.METRICS_EXPLORER, null),
+		);
+		registerShortcut(GlobalShortcuts.NavigateToMetricsExplorer, () =>
+			onClickHandler(ROUTES.METRICS_EXPLORER_EXPLORER, null),
+		);
+		registerShortcut(GlobalShortcuts.NavigateToMetricsViews, () =>
+			onClickHandler(ROUTES.METRICS_EXPLORER_VIEWS, null),
+		);
+		registerShortcut(GlobalShortcuts.NavigateToSettings, () =>
+			onClickHandler(ROUTES.SETTINGS, null),
+		);
+		registerShortcut(GlobalShortcuts.NavigateToSettingsIngestion, () =>
+			onClickHandler(ROUTES.INGESTION_SETTINGS, null),
+		);
+		registerShortcut(GlobalShortcuts.NavigateToSettingsBilling, () =>
+			onClickHandler(ROUTES.BILLING, null),
+		);
+		registerShortcut(GlobalShortcuts.NavigateToSettingsAPIKeys, () =>
+			onClickHandler(ROUTES.API_KEYS, null),
+		);
+		registerShortcut(GlobalShortcuts.NavigateToSettingsNotificationChannels, () =>
+			onClickHandler(ROUTES.ALL_CHANNELS, null),
+		);
+		registerShortcut(GlobalShortcuts.NavigateToLogsPipelines, () =>
+			onClickHandler(ROUTES.LOGS_PIPELINES, null),
+		);
+		registerShortcut(GlobalShortcuts.NavigateToLogsViews, () =>
+			onClickHandler(ROUTES.LOGS_SAVE_VIEWS, null),
+		);
 		return (): void => {
 			deregisterShortcut(GlobalShortcuts.NavigateToHome);
 			deregisterShortcut(GlobalShortcuts.NavigateToServices);
@@ -689,6 +724,18 @@ function SideNav({ isPinned }: { isPinned: boolean }): JSX.Element {
 			deregisterShortcut(GlobalShortcuts.NavigateToAlerts);
 			deregisterShortcut(GlobalShortcuts.NavigateToExceptions);
 			deregisterShortcut(GlobalShortcuts.NavigateToMessagingQueues);
+			deregisterShortcut(GlobalShortcuts.NavigateToTracesFunnel);
+			deregisterShortcut(GlobalShortcuts.NavigateToMetricsSummary);
+			deregisterShortcut(GlobalShortcuts.NavigateToMetricsExplorer);
+			deregisterShortcut(GlobalShortcuts.NavigateToMetricsViews);
+			deregisterShortcut(GlobalShortcuts.NavigateToSettings);
+			deregisterShortcut(GlobalShortcuts.NavigateToSettingsIngestion);
+			deregisterShortcut(GlobalShortcuts.NavigateToSettingsBilling);
+			deregisterShortcut(GlobalShortcuts.NavigateToSettingsAPIKeys);
+			deregisterShortcut(GlobalShortcuts.NavigateToSettingsNotificationChannels);
+			deregisterShortcut(GlobalShortcuts.NavigateToLogsPipelines);
+			deregisterShortcut(GlobalShortcuts.NavigateToLogsViews);
+			deregisterShortcut(GlobalShortcuts.NavigateToTracesViews);
 		};
 	}, [deregisterShortcut, onClickHandler, registerShortcut]);
 

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

@@ -5,16 +5,20 @@
 	&-virtuoso {
 		background: rgba(171, 189, 255, 0.04);
 	}
-	&-list-container .logs-loading-skeleton {
+	&-list-container {
 		height: 100%;
-		border: 1px solid var(--bg-slate-500);
-		border-top: none;
-		color: var(--bg-vanilla-400);
-		display: flex;
-		flex-direction: column;
-		align-items: center;
-		justify-content: center;
-		padding: 8px 0;
+
+		.logs-loading-skeleton {
+			height: 100%;
+			border: 1px solid var(--bg-slate-500);
+			border-top: none;
+			color: var(--bg-vanilla-400);
+			display: flex;
+			flex-direction: column;
+			align-items: center;
+			justify-content: center;
+			padding: 8px 0;
+		}
 	}
 
 	&-empty-content {

frontend/src/hooks/hotkeys/__tests__/useKeyboardHotkeys.test.tsx

@@ -1,11 +1,18 @@
 import { render } from '@testing-library/react';
 import userEvent from '@testing-library/user-event';
+import { useEffect } from 'react';
 
 import {
 	KeyboardHotkeysProvider,
 	useKeyboardHotkeys,
 } from '../useKeyboardHotkeys';
 
+jest.mock('../../../providers/cmdKProvider', () => ({
+	useCmdK: (): { open: boolean } => ({
+		open: false,
+	}),
+}));
+
 function TestComponentWithRegister({
 	handleShortcut,
 }: {
@@ -13,14 +20,13 @@ function TestComponentWithRegister({
 }): JSX.Element {
 	const { registerShortcut } = useKeyboardHotkeys();
 
-	registerShortcut('a', handleShortcut);
+	useEffect(() => {
+		registerShortcut('a', handleShortcut);
+	}, [registerShortcut, handleShortcut]);
 
-	return (
-		<div>
-			<span>Test Component</span>
-		</div>
-	);
+	return <span>Test Component</span>;
 }
+
 function TestComponentWithDeRegister({
 	handleShortcut,
 }: {
@@ -28,21 +34,18 @@ function TestComponentWithDeRegister({
 }): JSX.Element {
 	const { registerShortcut, deregisterShortcut } = useKeyboardHotkeys();
 
-	registerShortcut('b', handleShortcut);
+	useEffect(() => {
+		registerShortcut('b', handleShortcut);
+		deregisterShortcut('b');
+	}, [registerShortcut, deregisterShortcut, handleShortcut]);
 
-	// Deregister the shortcut before triggering it
-	deregisterShortcut('b');
-
-	return (
-		<div>
-			<span>Test Component</span>
-		</div>
-	);
+	return <span>Test Component</span>;
 }
 
 describe('KeyboardHotkeysProvider', () => {
 	it('registers and triggers shortcuts correctly', async () => {
 		const handleShortcut = jest.fn();
+		const user = userEvent.setup();
 
 		render(
 			<KeyboardHotkeysProvider>
@@ -50,15 +53,15 @@ describe('KeyboardHotkeysProvider', () => {
 			</KeyboardHotkeysProvider>,
 		);
 
-		// Trigger the registered shortcut
-		await userEvent.keyboard('a');
+		// fires on keyup
+		await user.keyboard('{a}');
 
-		// Assert that the handleShortcut function has been called
-		expect(handleShortcut).toHaveBeenCalled();
+		expect(handleShortcut).toHaveBeenCalledTimes(1);
 	});
 
-	it('deregisters shortcuts correctly', () => {
+	it('does not trigger deregistered shortcuts', async () => {
 		const handleShortcut = jest.fn();
+		const user = userEvent.setup();
 
 		render(
 			<KeyboardHotkeysProvider>
@@ -66,10 +69,8 @@ describe('KeyboardHotkeysProvider', () => {
 			</KeyboardHotkeysProvider>,
 		);
 
-		// Try to trigger the deregistered shortcut
-		userEvent.keyboard('b');
+		await user.keyboard('{b}');
 
-		// Assert that the handleShortcut function has NOT been called
 		expect(handleShortcut).not.toHaveBeenCalled();
 	});
 });

frontend/src/hooks/hotkeys/useKeyboardHotkeys.tsx

@@ -8,20 +8,21 @@ import {
 	useRef,
 } from 'react';
 
+import { useCmdK } from '../../providers/cmdKProvider';
+
 interface KeyboardHotkeysContextReturnValue {
 	/**
-	 * @param keyCombination provide the string for which the subsequent callback should be triggered. Example 'ctrl+a'
+	 * @param keyCombo provide the string for which the subsequent callback should be triggered. Example 'ctrl+a'
 	 * @param callback the callback that should be triggered when the above key combination is being pressed
 	 * @returns void
 	 */
-	registerShortcut: (keyCombination: string, callback: () => void) => void;
-
+	registerShortcut: (keyCombo: string, callback: () => void) => void;
 	/**
 	 *
-	 * @param keyCombination provide the string for which we want to deregister the callback
+	 * @param keyCombo provide the string for which we want to deregister the callback
 	 * @returns void
 	 */
-	deregisterShortcut: (keyCombination: string) => void;
+	deregisterShortcut: (keyCombo: string) => void;
 }
 
 const KeyboardHotkeysContext = createContext<KeyboardHotkeysContextReturnValue>(
@@ -33,7 +34,7 @@ const KeyboardHotkeysContext = createContext<KeyboardHotkeysContextReturnValue>(
 
 const IGNORE_INPUTS = ['input', 'textarea', 'cm-editor']; // Inputs in which hotkey events will be ignored
 
-const useKeyboardHotkeys = (): KeyboardHotkeysContextReturnValue => {
+export function useKeyboardHotkeys(): KeyboardHotkeysContextReturnValue {
 	const context = useContext(KeyboardHotkeysContext);
 	if (!context) {
 		throw new Error(
@@ -42,21 +43,45 @@ const useKeyboardHotkeys = (): KeyboardHotkeysContextReturnValue => {
 	}
 
 	return context;
-};
+}
 
-function KeyboardHotkeysProvider({
+/**
+ * Normalize a set of keys into a stable combo
+ * { shift, m, e } → "e+m+shift"
+ */
+function normalizeChord(keys: Set<string>): string {
+	return Array.from(keys).sort().join('+');
+}
+
+/**
+ * Normalize registration strings
+ * "shift+m+e" → "e+m+shift"
+ */
+function normalizeComboString(combo: string): string {
+	return normalizeChord(new Set(combo.split('+')));
+}
+
+export function KeyboardHotkeysProvider({
 	children,
 }: {
 	children: JSX.Element;
 }): JSX.Element {
+	const { open: cmdKOpen } = useCmdK();
 	const shortcuts = useRef<Record<string, () => void>>({});
+	const pressedKeys = useRef<Set<string>>(new Set());
 
-	const handleKeyPress = (event: KeyboardEvent): void => {
-		const { key, ctrlKey, altKey, shiftKey, metaKey, target } = event;
+	// A detected valid shortcut waiting to fire
+	const pendingCombo = useRef<string | null>(null);
 
+	// Tracks whether user extended the combo
+	const wasExtended = useRef(false);
+
+	const handleKeyDown = (event: KeyboardEvent): void => {
+		if (event.repeat) return;
+
+		const target = event.target as HTMLElement;
 		const isCodeMirrorEditor =
 			(target as HTMLElement).closest('.cm-editor') !== null;
-
 		if (
 			IGNORE_INPUTS.includes((target as HTMLElement).tagName.toLowerCase()) ||
 			isCodeMirrorEditor
@@ -64,61 +89,110 @@ function KeyboardHotkeysProvider({
 			return;
 		}
 
-		// https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent/metaKey
-		const modifiers = { ctrlKey, altKey, shiftKey, metaKey };
+		const key = event.key?.toLowerCase();
+		if (!key) return; // Skip if key is undefined
 
-		let shortcutKey = `${key.toLowerCase()}`;
+		// If a pending combo exists and a new key is pressed → extension
+		if (pendingCombo.current && !pressedKeys.current.has(key)) {
+			wasExtended.current = true;
+		}
 
-		const isAltKey = `${modifiers.altKey ? '+alt' : ''}`;
-		const isShiftKey = `${modifiers.shiftKey ? '+shift' : ''}`;
+		pressedKeys.current.add(key);
 
-		// ctrl and cmd have the same functionality for mac and windows parity
-		const isMetaKey = `${modifiers.metaKey || modifiers.ctrlKey ? '+meta' : ''}`;
+		if (event.shiftKey) pressedKeys.current.add('shift');
+		if (event.metaKey || event.ctrlKey) pressedKeys.current.add('meta');
+		if (event.altKey) pressedKeys.current.add('alt');
 
-		shortcutKey = shortcutKey + isAltKey + isShiftKey + isMetaKey;
+		const combo = normalizeChord(pressedKeys.current);
 
-		if (shortcuts.current[shortcutKey]) {
+		if (shortcuts.current[combo]) {
 			event.preventDefault();
-			event.stopImmediatePropagation();
-
-			shortcuts.current[shortcutKey]();
+			event.stopPropagation();
+			pendingCombo.current = combo;
+			wasExtended.current = false;
 		}
 	};
 
-	useEffect(() => {
-		document.addEventListener('keydown', handleKeyPress);
+	const handleKeyUp = (event: KeyboardEvent): void => {
+		const key = event.key?.toLowerCase();
+		if (!key) return; // Skip if key is undefined
+
+		pressedKeys.current.delete(key);
+
+		if (!event.shiftKey) pressedKeys.current.delete('shift');
+		if (!event.metaKey && !event.ctrlKey) pressedKeys.current.delete('meta');
+		if (!event.altKey) pressedKeys.current.delete('alt');
+
+		if (!pendingCombo.current) return;
+
+		// Fire only if user did NOT extend the combo
+		if (!wasExtended.current) {
+			event.preventDefault();
+			try {
+				shortcuts.current[pendingCombo.current]?.();
+			} catch (error) {
+				console.error('Error executing hotkey callback:', error);
+			}
+		}
+
+		pendingCombo.current = null;
+		wasExtended.current = false;
+	};
+
+	useEffect((): (() => void) => {
+		document.addEventListener('keydown', handleKeyDown);
+		document.addEventListener('keyup', handleKeyUp);
+
+		const reset = (): void => {
+			pressedKeys.current.clear();
+			pendingCombo.current = null;
+			wasExtended.current = false;
+		};
+
+		window.addEventListener('blur', reset);
+
 		return (): void => {
-			document.removeEventListener('keydown', handleKeyPress);
+			document.removeEventListener('keydown', handleKeyDown);
+			document.removeEventListener('keyup', handleKeyUp);
+			window.removeEventListener('blur', reset);
 		};
 	}, []);
 
+	useEffect(() => {
+		if (!cmdKOpen) {
+			// Reset when palette closes
+			pressedKeys.current.clear();
+			pendingCombo.current = null;
+			wasExtended.current = false;
+		}
+	}, [cmdKOpen]);
+
 	const registerShortcut = useCallback(
-		(keyCombination: string, callback: () => void): void => {
-			if (!shortcuts.current[keyCombination]) {
-				shortcuts.current[keyCombination] = callback;
-			} else if (process.env.NODE_ENV === 'development') {
-				throw new Error(
-					`This shortcut is already present in current scope :- ${keyCombination}`,
-				);
+		(keyCombo: string, callback: () => void): void => {
+			const normalized = normalizeComboString(keyCombo);
+
+			if (!shortcuts.current[normalized]) {
+				shortcuts.current[normalized] = callback;
+				return;
+			}
+
+			const message = `This shortcut is already present in current scope :- ${keyCombo}`;
+
+			if (process.env.NODE_ENV === 'development') {
+				throw new Error(message);
 			} else {
-				console.error(
-					`This shortcut is already present in current scope :- ${keyCombination}`,
-				);
+				console.error(message);
 			}
 		},
-		[shortcuts],
+		[],
 	);
 
-	const deregisterShortcut = useCallback(
-		(keyCombination: string): void => {
-			if (shortcuts.current[keyCombination]) {
-				unset(shortcuts.current, keyCombination);
-			}
-		},
-		[shortcuts],
-	);
+	const deregisterShortcut = useCallback((keyCombo: string) => {
+		const normalized = normalizeComboString(keyCombo);
+		unset(shortcuts.current, normalized);
+	}, []);
 
-	const contextValue = useMemo(
+	const ctxValue = useMemo(
 		() => ({
 			registerShortcut,
 			deregisterShortcut,
@@ -127,10 +201,8 @@ function KeyboardHotkeysProvider({
 	);
 
 	return (
-		<KeyboardHotkeysContext.Provider value={contextValue}>
+		<KeyboardHotkeysContext.Provider value={ctxValue}>
 			{children}
 		</KeyboardHotkeysContext.Provider>
 	);
 }
-
-export { KeyboardHotkeysProvider, useKeyboardHotkeys };

frontend/src/pages/TraceDetailV2/NoData/NoData.tsx

@@ -15,7 +15,7 @@ function NoData(): JSX.Element {
 				<Typography.Text className="not-found-text-1">
 					Uh-oh! We cannot show the selected trace.
 					<span className="not-found-text-2">
-						This can happen in either of the two scenraios -
+						This can happen in either of the two scenarios -
 					</span>
 				</Typography.Text>
 			</section>

go.mod

@@ -53,7 +53,7 @@ require (
 	github.com/smartystreets/goconvey v1.8.1
 	github.com/soheilhy/cmux v0.1.5
 	github.com/spf13/cobra v1.10.1
-	github.com/srikanthccv/ClickHouse-go-mock v0.13.0
+	github.com/srikanthccv/ClickHouse-go-mock v0.12.0
 	github.com/stretchr/testify v1.11.1
 	github.com/swaggest/jsonschema-go v0.3.78
 	github.com/swaggest/rest v0.2.75

go.sum

@@ -962,8 +962,8 @@ github.com/spf13/pflag v1.0.10/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3A
 github.com/spf13/viper v1.13.0/go.mod h1:Icm2xNL3/8uyh/wFuB1jI7TiTNKp8632Nwegu+zgdYw=
 github.com/spf13/viper v1.20.1 h1:ZMi+z/lvLyPSCoNtFCpqjy0S4kPbirhpTMwl8BkW9X4=
 github.com/spf13/viper v1.20.1/go.mod h1:P9Mdzt1zoHIG8m2eZQinpiBjo6kCmZSKBClNNqjJvu4=
-github.com/srikanthccv/ClickHouse-go-mock v0.13.0 h1:/b7DQphGkh29ocNtLh4DGmQxQYA0CfHz65Wy2zAH2GM=
-github.com/srikanthccv/ClickHouse-go-mock v0.13.0/go.mod h1:LiiyBUdXNwB/1DE9rgK/8q9qjVYsTzg6WXQ/3mU3TeY=
+github.com/srikanthccv/ClickHouse-go-mock v0.12.0 h1:KUzaWTwuqMc2uf5FylM/oAcTFdE2DdZjvISm9V0/NAA=
+github.com/srikanthccv/ClickHouse-go-mock v0.12.0/go.mod h1:1oUmLtXEXOyS0EEWVKlKEfLfv9y02agCMAvD3tVnhlo=
 github.com/stoewer/go-strcase v1.3.0 h1:g0eASXYtp+yvN9fK8sH94oCIk0fau9uV1/ZdJ0AVEzs=
 github.com/stoewer/go-strcase v1.3.0/go.mod h1:fAH5hQ5pehh+j3nZfvwdk2RgEgQjAoM8wodgtPmh1xo=
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=

pkg/apiserver/signozapiserver/promote.go

@@ -0,0 +1,43 @@
+package signozapiserver
+
+import (
+	"net/http"
+
+	"github.com/SigNoz/signoz/pkg/http/handler"
+	"github.com/SigNoz/signoz/pkg/types/promotetypes"
+	"github.com/gorilla/mux"
+)
+
+func (provider *provider) addPromoteRoutes(router *mux.Router) error {
+	if err := router.Handle("/api/v1/logs/promote_paths", handler.New(provider.authZ.EditAccess(provider.promoteHandler.HandlePromoteAndIndexPaths), handler.OpenAPIDef{
+		ID:                  "HandlePromoteAndIndexPaths",
+		Tags:                []string{"logs"},
+		Summary:             "Promote and index paths",
+		Description:         "This endpoints promotes and indexes paths",
+		Request:             new([]*promotetypes.PromotePath),
+		RequestContentType:  "application/json",
+		Response:            nil,
+		ResponseContentType: "",
+		SuccessStatusCode:   http.StatusCreated,
+		ErrorStatusCodes:    []int{http.StatusBadRequest},
+	})).Methods(http.MethodPost).GetError(); err != nil {
+		return err
+	}
+
+	if err := router.Handle("/api/v1/logs/promote_paths", handler.New(provider.authZ.ViewAccess(provider.promoteHandler.ListPromotedAndIndexedPaths), handler.OpenAPIDef{
+		ID:                  "ListPromotedAndIndexedPaths",
+		Tags:                []string{"logs"},
+		Summary:             "Promote and index paths",
+		Description:         "This endpoints promotes and indexes paths",
+		Request:             nil,
+		RequestContentType:  "",
+		Response:            new([]*promotetypes.PromotePath),
+		ResponseContentType: "",
+		SuccessStatusCode:   http.StatusOK,
+		ErrorStatusCodes:    []int{http.StatusBadRequest},
+	})).Methods(http.MethodGet).GetError(); err != nil {
+		return err
+	}
+
+	return nil
+}

pkg/apiserver/signozapiserver/provider.go

@@ -12,6 +12,7 @@ import (
 	"github.com/SigNoz/signoz/pkg/modules/authdomain"
 	"github.com/SigNoz/signoz/pkg/modules/organization"
 	"github.com/SigNoz/signoz/pkg/modules/preference"
+	"github.com/SigNoz/signoz/pkg/modules/promote"
 	"github.com/SigNoz/signoz/pkg/modules/session"
 	"github.com/SigNoz/signoz/pkg/modules/user"
 	"github.com/SigNoz/signoz/pkg/types"
@@ -30,6 +31,7 @@ type provider struct {
 	authDomainHandler authdomain.Handler
 	preferenceHandler preference.Handler
 	globalHandler     global.Handler
+	promoteHandler    promote.Handler
 }
 
 func NewFactory(
@@ -41,9 +43,10 @@ func NewFactory(
 	authDomainHandler authdomain.Handler,
 	preferenceHandler preference.Handler,
 	globalHandler global.Handler,
+	promoteHandler promote.Handler,
 ) factory.ProviderFactory[apiserver.APIServer, apiserver.Config] {
 	return factory.NewProviderFactory(factory.MustNewName("signoz"), func(ctx context.Context, providerSettings factory.ProviderSettings, config apiserver.Config) (apiserver.APIServer, error) {
-		return newProvider(ctx, providerSettings, config, orgGetter, authz, orgHandler, userHandler, sessionHandler, authDomainHandler, preferenceHandler, globalHandler)
+		return newProvider(ctx, providerSettings, config, orgGetter, authz, orgHandler, userHandler, sessionHandler, authDomainHandler, preferenceHandler, globalHandler, promoteHandler)
 	})
 }
 
@@ -59,6 +62,7 @@ func newProvider(
 	authDomainHandler authdomain.Handler,
 	preferenceHandler preference.Handler,
 	globalHandler global.Handler,
+	promoteHandler promote.Handler,
 ) (apiserver.APIServer, error) {
 	settings := factory.NewScopedProviderSettings(providerSettings, "github.com/SigNoz/signoz/pkg/apiserver/signozapiserver")
 	router := mux.NewRouter().UseEncodedPath()
@@ -73,6 +77,7 @@ func newProvider(
 		authDomainHandler: authDomainHandler,
 		preferenceHandler: preferenceHandler,
 		globalHandler:     globalHandler,
+		promoteHandler:    promoteHandler,
 	}
 
 	provider.authZ = middleware.NewAuthZ(settings.Logger(), orgGetter, authz)
@@ -113,6 +118,10 @@ func (provider *provider) AddToRouter(router *mux.Router) error {
 		return err
 	}
 
+	if err := provider.addPromoteRoutes(router); err != nil {
+		return err
+	}
+
 	return nil
 }
 

pkg/errors/errors.go

@@ -209,6 +209,11 @@ func NewUnexpectedf(code Code, format string, args ...any) *base {
 	return Newf(TypeInvalidInput, code, format, args...)
 }
 
+// NewMethodNotAllowedf is a wrapper around Newf with TypeMethodNotAllowed.
+func NewMethodNotAllowedf(code Code, format string, args ...any) *base {
+	return Newf(TypeMethodNotAllowed, code, format, args...)
+}
+
 // WrapTimeoutf is a wrapper around Wrapf with TypeTimeout.
 func WrapTimeoutf(cause error, code Code, format string, args ...any) *base {
 	return Wrapf(cause, TypeTimeout, code, format, args...)

pkg/modules/promote/implpromote/handler.go

@@ -0,0 +1,60 @@
+package implpromote
+
+import (
+	"net/http"
+
+	"github.com/SigNoz/signoz/pkg/errors"
+	"github.com/SigNoz/signoz/pkg/http/binding"
+	"github.com/SigNoz/signoz/pkg/http/render"
+	"github.com/SigNoz/signoz/pkg/modules/promote"
+	"github.com/SigNoz/signoz/pkg/types/authtypes"
+	"github.com/SigNoz/signoz/pkg/types/promotetypes"
+)
+
+type handler struct {
+	module promote.Module
+}
+
+func NewHandler(module promote.Module) promote.Handler {
+	return &handler{module: module}
+}
+
+func (h *handler) HandlePromoteAndIndexPaths(w http.ResponseWriter, r *http.Request) {
+	// TODO(Nitya): Use in multi tenant setup
+	_, err := authtypes.ClaimsFromContext(r.Context())
+	if err != nil {
+		render.Error(w, errors.NewInternalf(errors.CodeInternal, "failed to get org id from context"))
+		return
+	}
+
+	var req []*promotetypes.PromotePath
+	if err := binding.JSON.BindBody(r.Body, &req); err != nil {
+		render.Error(w, err)
+		return
+	}
+
+	err = h.module.PromoteAndIndexPaths(r.Context(), req...)
+	if err != nil {
+		render.Error(w, err)
+		return
+	}
+
+	render.Success(w, http.StatusCreated, nil)
+}
+
+func (h *handler) ListPromotedAndIndexedPaths(w http.ResponseWriter, r *http.Request) {
+	// TODO(Nitya): Use in multi tenant setup
+	_, err := authtypes.ClaimsFromContext(r.Context())
+	if err != nil {
+		render.Error(w, errors.NewInternalf(errors.CodeInternal, "failed to get org id from context"))
+		return
+	}
+
+	paths, err := h.module.ListPromotedAndIndexedPaths(r.Context())
+	if err != nil {
+		render.Error(w, err)
+		return
+	}
+
+	render.Success(w, http.StatusOK, paths)
+}

pkg/modules/promote/implpromote/module.go

@@ -0,0 +1,201 @@
+package implpromote
+
+import (
+	"context"
+	"maps"
+	"slices"
+	"strings"
+
+	schemamigrator "github.com/SigNoz/signoz-otel-collector/cmd/signozschemamigrator/schema_migrator"
+	"github.com/SigNoz/signoz/pkg/errors"
+	"github.com/SigNoz/signoz/pkg/modules/promote"
+	"github.com/SigNoz/signoz/pkg/telemetrylogs"
+	"github.com/SigNoz/signoz/pkg/telemetrystore"
+	"github.com/SigNoz/signoz/pkg/types/promotetypes"
+	"github.com/SigNoz/signoz/pkg/types/telemetrytypes"
+)
+
+var (
+	CodeFailedToCreateIndex        = errors.MustNewCode("failed_to_create_index_promoted_paths")
+	CodeFailedToQueryPromotedPaths = errors.MustNewCode("failed_to_query_promoted_paths")
+)
+
+type module struct {
+	metadataStore  telemetrytypes.MetadataStore
+	telemetryStore telemetrystore.TelemetryStore
+}
+
+func NewModule(metadataStore telemetrytypes.MetadataStore, telemetrystore telemetrystore.TelemetryStore) promote.Module {
+	return &module{metadataStore: metadataStore, telemetryStore: telemetrystore}
+}
+
+func (m *module) ListPromotedAndIndexedPaths(ctx context.Context) ([]promotetypes.PromotePath, error) {
+	logsIndexes, err := m.metadataStore.ListLogsJSONIndexes(ctx)
+	if err != nil {
+		return nil, err
+	}
+	// Flatten the map values (which are slices) into a single slice
+	indexes := slices.Concat(slices.Collect(maps.Values(logsIndexes))...)
+
+	aggr := map[string][]promotetypes.WrappedIndex{}
+	for _, index := range indexes {
+		path, columnType, err := schemamigrator.UnfoldJSONSubColumnIndexExpr(index.Expression)
+		if err != nil {
+			return nil, err
+		}
+
+		// clean backticks from the path
+		path = strings.ReplaceAll(path, "`", "")
+
+		aggr[path] = append(aggr[path], promotetypes.WrappedIndex{
+			ColumnType:  columnType,
+			Type:        index.Type,
+			Granularity: index.Granularity,
+		})
+	}
+	promotedPaths, err := m.listPromotedPaths(ctx)
+	if err != nil {
+		return nil, err
+	}
+
+	response := []promotetypes.PromotePath{}
+	for _, path := range promotedPaths {
+		fullPath := telemetrylogs.BodyPromotedColumnPrefix + path
+		path = telemetrylogs.BodyJSONStringSearchPrefix + path
+		item := promotetypes.PromotePath{
+			Path:    path,
+			Promote: true,
+		}
+		indexes, ok := aggr[fullPath]
+		if ok {
+			item.Indexes = indexes
+			delete(aggr, fullPath)
+		}
+		response = append(response, item)
+	}
+
+	// add the paths that are not promoted but have indexes
+	for path, indexes := range aggr {
+		path := strings.TrimPrefix(path, telemetrylogs.BodyJSONColumnPrefix)
+		path = telemetrylogs.BodyJSONStringSearchPrefix + path
+		response = append(response, promotetypes.PromotePath{
+			Path:    path,
+			Indexes: indexes,
+		})
+	}
+	return response, nil
+}
+
+func (m *module) listPromotedPaths(ctx context.Context) ([]string, error) {
+	paths, err := m.metadataStore.ListPromotedPaths(ctx)
+	if err != nil {
+		return nil, err
+	}
+	return slices.Collect(maps.Keys(paths)), nil
+}
+
+// PromotePaths inserts provided JSON paths into the promoted paths table for logs queries.
+func (m *module) PromotePaths(ctx context.Context, paths []string) error {
+	if len(paths) == 0 {
+		return errors.NewInvalidInputf(errors.CodeInvalidInput, "paths cannot be empty")
+	}
+
+	return m.metadataStore.PromotePaths(ctx, paths...)
+}
+
+// createIndexes creates string ngram + token filter indexes on JSON path subcolumns for LIKE queries.
+func (m *module) createIndexes(ctx context.Context, indexes []schemamigrator.Index) error {
+	if len(indexes) == 0 {
+		return nil
+	}
+
+	for _, index := range indexes {
+		alterStmt := schemamigrator.AlterTableAddIndex{
+			Database: telemetrylogs.DBName,
+			Table:    telemetrylogs.LogsV2LocalTableName,
+			Index:    index,
+		}
+		op := alterStmt.OnCluster(m.telemetryStore.Cluster())
+		if err := m.telemetryStore.ClickhouseDB().Exec(ctx, op.ToSQL()); err != nil {
+			return errors.WrapInternalf(err, CodeFailedToCreateIndex, "failed to create index")
+		}
+	}
+
+	return nil
+}
+
+// PromoteAndIndexPaths handles promoting paths and creating indexes in one call.
+func (m *module) PromoteAndIndexPaths(
+	ctx context.Context,
+	paths ...*promotetypes.PromotePath,
+) error {
+	if len(paths) == 0 {
+		return errors.NewInvalidInputf(errors.CodeInvalidInput, "paths cannot be empty")
+	}
+
+	pathsStr := []string{}
+	// validate the paths
+	for _, path := range paths {
+		if err := path.ValidateAndSetDefaults(); err != nil {
+			return err
+		}
+		pathsStr = append(pathsStr, path.Path)
+	}
+
+	existingPromotedPaths, err := m.metadataStore.ListPromotedPaths(ctx, pathsStr...)
+	if err != nil {
+		return err
+	}
+
+	var toInsert []string
+	indexes := []schemamigrator.Index{}
+	for _, it := range paths {
+		if it.Promote {
+			if _, promoted := existingPromotedPaths[it.Path]; !promoted {
+				toInsert = append(toInsert, it.Path)
+			}
+		}
+		if len(it.Indexes) > 0 {
+			parentColumn := telemetrylogs.LogsV2BodyJSONColumn
+			// if the path is already promoted or is being promoted, add it to the promoted column
+			if _, promoted := existingPromotedPaths[it.Path]; promoted || it.Promote {
+				parentColumn = telemetrylogs.LogsV2BodyPromotedColumn
+			}
+
+			for _, index := range it.Indexes {
+				var typeIndex schemamigrator.IndexType
+				switch {
+				case strings.HasPrefix(index.Type, string(schemamigrator.IndexTypeNGramBF)):
+					typeIndex = schemamigrator.IndexTypeNGramBF
+				case strings.HasPrefix(index.Type, string(schemamigrator.IndexTypeTokenBF)):
+					typeIndex = schemamigrator.IndexTypeTokenBF
+				case strings.HasPrefix(index.Type, string(schemamigrator.IndexTypeMinMax)):
+					typeIndex = schemamigrator.IndexTypeMinMax
+				default:
+					return errors.NewInvalidInputf(errors.CodeInvalidInput, "invalid index type: %s", index.Type)
+				}
+				indexes = append(indexes, schemamigrator.Index{
+					Name:        schemamigrator.JSONSubColumnIndexName(parentColumn, it.Path, index.JSONDataType.StringValue(), typeIndex),
+					Expression:  schemamigrator.JSONSubColumnIndexExpr(parentColumn, it.Path, index.JSONDataType.StringValue()),
+					Type:        index.Type,
+					Granularity: index.Granularity,
+				})
+			}
+		}
+	}
+
+	if len(toInsert) > 0 {
+		err := m.PromotePaths(ctx, toInsert)
+		if err != nil {
+			return err
+		}
+	}
+
+	if len(indexes) > 0 {
+		if err := m.createIndexes(ctx, indexes); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}

pkg/modules/promote/promote.go

@@ -0,0 +1,18 @@
+package promote
+
+import (
+	"context"
+	"net/http"
+
+	"github.com/SigNoz/signoz/pkg/types/promotetypes"
+)
+
+type Module interface {
+	ListPromotedAndIndexedPaths(ctx context.Context) ([]promotetypes.PromotePath, error)
+	PromoteAndIndexPaths(ctx context.Context, paths ...*promotetypes.PromotePath) error
+}
+
+type Handler interface {
+	HandlePromoteAndIndexPaths(w http.ResponseWriter, r *http.Request)
+	ListPromotedAndIndexedPaths(w http.ResponseWriter, r *http.Request)
+}

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

@@ -43,6 +43,7 @@ import (
 	"github.com/SigNoz/signoz/pkg/query-service/app/traces/tracedetail"
 	"github.com/SigNoz/signoz/pkg/query-service/common"
 	"github.com/SigNoz/signoz/pkg/query-service/constants"
+
 	chErrors "github.com/SigNoz/signoz/pkg/query-service/errors"
 	"github.com/SigNoz/signoz/pkg/query-service/metrics"
 	"github.com/SigNoz/signoz/pkg/query-service/model"

pkg/query-service/app/http_handler.go

@@ -555,6 +555,7 @@ func (aH *APIHandler) RegisterRoutes(router *mux.Router, am *middleware.AuthZ) {
 	router.HandleFunc("/api/v1/settings/ttl", am.ViewAccess(aH.getTTL)).Methods(http.MethodGet)
 	router.HandleFunc("/api/v2/settings/ttl", am.AdminAccess(aH.setCustomRetentionTTL)).Methods(http.MethodPost)
 	router.HandleFunc("/api/v2/settings/ttl", am.ViewAccess(aH.getCustomRetentionTTL)).Methods(http.MethodGet)
+
 	router.HandleFunc("/api/v1/settings/apdex", am.AdminAccess(aH.Signoz.Handlers.Apdex.Set)).Methods(http.MethodPost)
 	router.HandleFunc("/api/v1/settings/apdex", am.ViewAccess(aH.Signoz.Handlers.Apdex.Get)).Methods(http.MethodGet)
 

pkg/query-service/app/logs/v4/query_builder_test.go

@@ -5,6 +5,7 @@ import (
 
 	"github.com/SigNoz/signoz/pkg/query-service/constants"
 	v3 "github.com/SigNoz/signoz/pkg/query-service/model/v3"
+	"github.com/stretchr/testify/assert"
 )
 
 func Test_getClickhouseKey(t *testing.T) {
@@ -1210,9 +1211,8 @@ func TestPrepareLogsQuery(t *testing.T) {
 				t.Errorf("PrepareLogsQuery() error = %v, wantErr %v", err, tt.wantErr)
 				return
 			}
-			if got != tt.want {
-				t.Errorf("PrepareLogsQuery() = %v, want %v", got, tt.want)
-			}
+
+			assert.Equal(t, tt.want, got)
 		})
 	}
 }

pkg/query-service/rules/base_rule.go

@@ -191,13 +191,6 @@ func (r *BaseRule) currentAlerts() []*ruletypes.Alert {
 	return alerts
 }
 
-// ShouldSendUnmatched returns true if the rule should send unmatched samples
-// during alert evaluation, even if they don't match the rule condition.
-// This is useful in testing the rule.
-func (r *BaseRule) ShouldSendUnmatched() bool {
-	return r.sendUnmatched
-}
-
 // ActiveAlertsLabelFP returns a map of active alert labels fingerprint and
 // the fingerprint is computed using the QueryResultLables.Hash() method.
 // We use the QueryResultLables instead of labels as these labels are raw labels

pkg/query-service/rules/manager_test.go

@@ -1,577 +0,0 @@
-package rules
-
-import (
-	"context"
-	"encoding/json"
-	"math"
-	"strconv"
-	"testing"
-	"time"
-
-	"github.com/DATA-DOG/go-sqlmock"
-	alertmanagermock "github.com/SigNoz/signoz/pkg/alertmanager/mocks"
-	"github.com/SigNoz/signoz/pkg/cache"
-	"github.com/SigNoz/signoz/pkg/cache/cachetest"
-	"github.com/SigNoz/signoz/pkg/instrumentation/instrumentationtest"
-	"github.com/SigNoz/signoz/pkg/prometheus"
-	"github.com/SigNoz/signoz/pkg/prometheus/prometheustest"
-	"github.com/SigNoz/signoz/pkg/querier"
-	"github.com/SigNoz/signoz/pkg/querier/signozquerier"
-	"github.com/SigNoz/signoz/pkg/query-service/app/clickhouseReader"
-	v3 "github.com/SigNoz/signoz/pkg/query-service/model/v3"
-	"github.com/SigNoz/signoz/pkg/sqlstore"
-	"github.com/SigNoz/signoz/pkg/sqlstore/sqlstoretest"
-	"github.com/SigNoz/signoz/pkg/telemetrystore"
-	"github.com/SigNoz/signoz/pkg/telemetrystore/telemetrystoretest"
-	"github.com/SigNoz/signoz/pkg/types/alertmanagertypes"
-	"github.com/SigNoz/signoz/pkg/types/metrictypes"
-	qbtypes "github.com/SigNoz/signoz/pkg/types/querybuildertypes/querybuildertypesv5"
-	ruletypes "github.com/SigNoz/signoz/pkg/types/ruletypes"
-	"github.com/SigNoz/signoz/pkg/types/telemetrytypes"
-	"github.com/SigNoz/signoz/pkg/valuer"
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/mock"
-	"github.com/stretchr/testify/require"
-	"go.uber.org/zap"
-
-	cmock "github.com/srikanthccv/ClickHouse-go-mock"
-)
-
-func TestManager_TestNotification_SendUnmatched_ThresholdRule(t *testing.T) {
-	target := 10.0
-	recovery := 5.0
-
-	buildRule := func() ruletypes.PostableRule {
-		return ruletypes.PostableRule{
-			AlertName: "test-alert",
-			AlertType: ruletypes.AlertTypeMetric,
-			RuleType:  ruletypes.RuleTypeThreshold,
-			Evaluation: &ruletypes.EvaluationEnvelope{Kind: ruletypes.RollingEvaluation, Spec: ruletypes.RollingWindow{
-				EvalWindow: ruletypes.Duration(5 * time.Minute),
-				Frequency:  ruletypes.Duration(1 * time.Minute),
-			}},
-			Labels: map[string]string{
-				"service.name": "frontend",
-			},
-			Annotations: map[string]string{
-				"value": "{{$value}}",
-			},
-			Version: "v5",
-			RuleCondition: &ruletypes.RuleCondition{
-				MatchType: ruletypes.AtleastOnce,
-				CompareOp: ruletypes.ValueIsAbove,
-				Target:    &target,
-				CompositeQuery: &v3.CompositeQuery{
-					QueryType: v3.QueryTypeBuilder,
-					Queries: []qbtypes.QueryEnvelope{
-						{
-							Type: qbtypes.QueryTypeBuilder,
-							Spec: qbtypes.QueryBuilderQuery[qbtypes.MetricAggregation]{
-								Name:         "A",
-								StepInterval: qbtypes.Step{Duration: 60 * time.Second},
-								Signal:       telemetrytypes.SignalMetrics,
-
-								Aggregations: []qbtypes.MetricAggregation{
-									{
-										MetricName:       "probe_success",
-										TimeAggregation:  metrictypes.TimeAggregationAvg,
-										SpaceAggregation: metrictypes.SpaceAggregationAvg,
-									},
-								},
-							},
-						},
-					},
-				},
-				Thresholds: &ruletypes.RuleThresholdData{
-					Kind: ruletypes.BasicThresholdKind,
-					Spec: ruletypes.BasicRuleThresholds{
-						{
-							Name:           "primary",
-							TargetValue:    &target,
-							RecoveryTarget: &recovery,
-							MatchType:      ruletypes.AtleastOnce,
-							CompareOp:      ruletypes.ValueIsAbove,
-						},
-					},
-				},
-			},
-			NotificationSettings: &ruletypes.NotificationSettings{},
-		}
-	}
-
-	type testCase struct {
-		name         string
-		values       [][]interface{}
-		expectAlerts int
-		expectValue  float64
-	}
-
-	cases := []testCase{
-		{
-			name: "return first valid point in case of test notification",
-			values: [][]interface{}{
-				{float64(3), "attr", time.Now()},
-				{float64(4), "attr", time.Now().Add(1 * time.Minute)},
-			},
-			expectAlerts: 1,
-			expectValue:  3,
-		},
-		{
-			name:         "No data in DB so no alerts fired",
-			values:       [][]interface{}{},
-			expectAlerts: 0,
-		},
-		{
-			name: "return first valid point in case of test notification skips NaN and Inf",
-			values: [][]interface{}{
-				{math.NaN(), "attr", time.Now()},
-				{math.Inf(1), "attr", time.Now().Add(1 * time.Minute)},
-				{float64(7), "attr", time.Now().Add(2 * time.Minute)},
-			},
-			expectAlerts: 1,
-			expectValue:  7,
-		},
-		{
-			name: "If found matching alert with given target value, return the alerting value rather than first valid point",
-			values: [][]interface{}{
-				{float64(1), "attr", time.Now()},
-				{float64(2), "attr", time.Now().Add(1 * time.Minute)},
-				{float64(3), "attr", time.Now().Add(2 * time.Minute)},
-				{float64(12), "attr", time.Now().Add(3 * time.Minute)},
-			},
-			expectAlerts: 1,
-			expectValue:  12,
-		},
-	}
-
-	for _, tc := range cases {
-		t.Run(tc.name, func(t *testing.T) {
-			rule := buildRule()
-
-			// Marshal rule to JSON as TestNotification expects
-			ruleBytes, err := json.Marshal(rule)
-			require.NoError(t, err)
-
-			// mocking the alertmanager + capturing the triggered test alerts
-			fAlert := alertmanagermock.NewMockAlertmanager(t)
-			// mock set notification config
-			fAlert.On("SetNotificationConfig", mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(nil)
-			// for saving temp alerts that are triggered via TestNotification
-			triggeredTestAlerts := []map[*alertmanagertypes.PostableAlert][]string{}
-			if tc.expectAlerts > 0 {
-				fAlert.On("TestAlert", mock.Anything, mock.Anything, mock.Anything, mock.Anything).Run(func(args mock.Arguments) {
-					triggeredTestAlerts = append(triggeredTestAlerts, args.Get(3).(map[*alertmanagertypes.PostableAlert][]string))
-				}).Return(nil).Times(tc.expectAlerts)
-			}
-
-			cacheObj, err := cachetest.New(cache.Config{
-				Provider: "memory",
-				Memory: cache.Memory{
-					NumCounters: 1000,
-					MaxCost:     1 << 20,
-				},
-			})
-			require.NoError(t, err)
-
-			orgID := valuer.GenerateUUID()
-
-			// Create SQLStore mock for SendAlerts function which queries organizations table
-			sqlStore := sqlstoretest.New(sqlstore.Config{Provider: "sqlite"}, sqlmock.QueryMatcherRegexp)
-			// Mock the organizations query that SendAlerts makes
-			// Bun generates: SELECT id FROM organizations LIMIT 1 (or SELECT "id" FROM "organizations" LIMIT 1)
-			orgRows := sqlStore.Mock().NewRows([]string{"id"}).AddRow(orgID.StringValue())
-			// Match bun's generated query pattern - bun may quote identifiers
-			sqlStore.Mock().ExpectQuery("SELECT (.+) FROM (.+)organizations(.+) LIMIT (.+)").WillReturnRows(orgRows)
-
-			telemetryStore := telemetrystoretest.New(telemetrystore.Config{}, &queryMatcherAny{})
-
-			// Set up mock data for telemetry store
-			cols := make([]cmock.ColumnType, 0)
-			cols = append(cols, cmock.ColumnType{Name: "value", Type: "Float64"})
-			cols = append(cols, cmock.ColumnType{Name: "attr", Type: "String"})
-			cols = append(cols, cmock.ColumnType{Name: "ts", Type: "DateTime"})
-
-			alertDataRows := cmock.NewRows(cols, tc.values)
-
-			mock := telemetryStore.Mock()
-
-			// Generate query arguments for the metric query
-			evalTime := time.Now().UTC()
-			evalWindow := 5 * time.Minute
-			evalDelay := time.Duration(0)
-			queryArgs := GenerateMetricQueryCHArgs(
-				evalTime,
-				evalWindow,
-				evalDelay,
-				"probe_success",
-				metrictypes.Unspecified,
-			)
-
-			mock.ExpectQuery("*WITH __temporal_aggregation_cte*").
-				WithArgs(queryArgs...).
-				WillReturnRows(alertDataRows)
-
-			// Create reader with mocked telemetry store
-			readerCache, err := cachetest.New(cache.Config{
-				Provider: "memory",
-				Memory: cache.Memory{
-					NumCounters: 10 * 1000,
-					MaxCost:     1 << 26,
-				},
-			})
-			require.NoError(t, err)
-
-			options := clickhouseReader.NewOptions("", "", "archiveNamespace")
-			providerSettings := instrumentationtest.New().ToProviderSettings()
-			prometheus := prometheustest.New(context.Background(), providerSettings, prometheus.Config{}, telemetryStore)
-			reader := clickhouseReader.NewReader(
-				nil,
-				telemetryStore,
-				prometheus,
-				"",
-				time.Duration(time.Second),
-				nil,
-				readerCache,
-				options,
-			)
-
-			// Create mock querierV5 with test values
-			providerFactory := signozquerier.NewFactory(telemetryStore, prometheus, readerCache)
-			mockQuerier, err := providerFactory.New(context.Background(), providerSettings, querier.Config{})
-			require.NoError(t, err)
-
-			mgrOpts := &ManagerOptions{
-				Logger:         zap.NewNop(),
-				SLogger:        instrumentationtest.New().Logger(),
-				Cache:          cacheObj,
-				Alertmanager:   fAlert,
-				Querier:        mockQuerier,
-				TelemetryStore: telemetryStore,
-				Reader:         reader,
-				SqlStore:       sqlStore, // SQLStore needed for SendAlerts to query organizations
-			}
-
-			mgr, err := NewManager(mgrOpts)
-			require.NoError(t, err)
-
-			count, apiErr := mgr.TestNotification(context.Background(), orgID, string(ruleBytes))
-			if apiErr != nil {
-				t.Logf("TestNotification error: %v, type: %s", apiErr.Err, apiErr.Typ)
-			}
-			require.Nil(t, apiErr)
-			assert.Equal(t, tc.expectAlerts, count)
-
-			if tc.expectAlerts > 0 {
-				// check if the alert has been triggered
-				require.Len(t, triggeredTestAlerts, 1)
-				var gotAlerts []*alertmanagertypes.PostableAlert
-				for a := range triggeredTestAlerts[0] {
-					gotAlerts = append(gotAlerts, a)
-				}
-				require.Len(t, gotAlerts, tc.expectAlerts)
-				// check if the alert has triggered with correct threshold value
-				if tc.expectValue != 0 {
-					assert.Equal(t, strconv.FormatFloat(tc.expectValue, 'f', -1, 64), gotAlerts[0].Annotations["value"])
-				}
-			} else {
-				// check if no alerts have been triggered
-				assert.Empty(t, triggeredTestAlerts)
-			}
-		})
-	}
-}
-
-func TestManager_TestNotification_SendUnmatched_PromRule(t *testing.T) {
-	target := 10.0
-
-	buildRule := func() ruletypes.PostableRule {
-		return ruletypes.PostableRule{
-			AlertName: "test-prom-alert",
-			AlertType: ruletypes.AlertTypeMetric,
-			RuleType:  ruletypes.RuleTypeProm,
-			Evaluation: &ruletypes.EvaluationEnvelope{Kind: ruletypes.RollingEvaluation, Spec: ruletypes.RollingWindow{
-				EvalWindow: ruletypes.Duration(5 * time.Minute),
-				Frequency:  ruletypes.Duration(1 * time.Minute),
-			}},
-			Labels: map[string]string{
-				"service.name": "frontend",
-			},
-			Annotations: map[string]string{
-				"value": "{{$value}}",
-			},
-			Version: "v5",
-			RuleCondition: &ruletypes.RuleCondition{
-				MatchType:     ruletypes.AtleastOnce,
-				SelectedQuery: "A",
-				CompareOp:     ruletypes.ValueIsAbove,
-				Target:        &target,
-				CompositeQuery: &v3.CompositeQuery{
-					QueryType: v3.QueryTypePromQL,
-					PanelType: v3.PanelTypeGraph,
-					Queries: []qbtypes.QueryEnvelope{
-						{
-							Type: qbtypes.QueryTypePromQL,
-							Spec: qbtypes.PromQuery{
-								Name:     "A",
-								Query:    "{\"test_metric\"}",
-								Disabled: false,
-								Stats:    false,
-							},
-						},
-					},
-				},
-				Thresholds: &ruletypes.RuleThresholdData{
-					Kind: ruletypes.BasicThresholdKind,
-					Spec: ruletypes.BasicRuleThresholds{
-						{
-							Name:        "primary",
-							TargetValue: &target,
-							MatchType:   ruletypes.AtleastOnce,
-							CompareOp:   ruletypes.ValueIsAbove,
-							Channels:    []string{"slack"},
-						},
-					},
-				},
-			},
-			NotificationSettings: &ruletypes.NotificationSettings{},
-		}
-	}
-
-	type testCase struct {
-		name   string
-		values []struct {
-			offset time.Duration // offset from baseTime (negative = in the past)
-			value  float64
-		}
-		expectAlerts int
-		expectValue  float64
-	}
-
-	cases := []testCase{
-		{
-			name: "return first valid point in case of test notification",
-			values: []struct {
-				offset time.Duration
-				value  float64
-			}{
-				{-4 * time.Minute, 3},
-				{-3 * time.Minute, 4},
-			},
-			expectAlerts: 1,
-			expectValue:  3,
-		},
-		{
-			name: "No data in DB so no alerts fired",
-			values: []struct {
-				offset time.Duration
-				value  float64
-			}{},
-			expectAlerts: 0,
-		},
-		{
-			name: "return first valid point in case of test notification skips NaN and Inf",
-			values: []struct {
-				offset time.Duration
-				value  float64
-			}{
-				{-4 * time.Minute, math.NaN()},
-				{-3 * time.Minute, math.Inf(1)},
-				{-2 * time.Minute, 7},
-			},
-			expectAlerts: 1,
-			expectValue:  7,
-		},
-		{
-			name: "If found matching alert with given target value, return the alerting value rather than first valid point",
-			values: []struct {
-				offset time.Duration
-				value  float64
-			}{
-				{-4 * time.Minute, 1},
-				{-3 * time.Minute, 2},
-				{-2 * time.Minute, 3},
-				{-1 * time.Minute, 12},
-			},
-			expectAlerts: 1,
-			expectValue:  12,
-		},
-	}
-
-	for _, tc := range cases {
-		t.Run(tc.name, func(t *testing.T) {
-			// Capture base time once per test case to ensure consistent timestamps
-			baseTime := time.Now().UTC()
-
-			rule := buildRule()
-
-			// Marshal rule to JSON as TestNotification expects
-			ruleBytes, err := json.Marshal(rule)
-			require.NoError(t, err)
-
-			// mocking the alertmanager + capturing the triggered test alerts
-			fAlert := alertmanagermock.NewMockAlertmanager(t)
-			// mock set notification config
-			fAlert.On("SetNotificationConfig", mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(nil)
-			// for saving temp alerts that are triggered via TestNotification
-			triggeredTestAlerts := []map[*alertmanagertypes.PostableAlert][]string{}
-			if tc.expectAlerts > 0 {
-				fAlert.On("TestAlert", mock.Anything, mock.Anything, mock.Anything, mock.Anything).Run(func(args mock.Arguments) {
-					triggeredTestAlerts = append(triggeredTestAlerts, args.Get(3).(map[*alertmanagertypes.PostableAlert][]string))
-				}).Return(nil).Times(tc.expectAlerts)
-			}
-
-			cacheObj, err := cachetest.New(cache.Config{
-				Provider: "memory",
-				Memory: cache.Memory{
-					NumCounters: 1000,
-					MaxCost:     1 << 20,
-				},
-			})
-			require.NoError(t, err)
-
-			orgID := valuer.GenerateUUID()
-
-			// Create SQLStore mock for SendAlerts function which queries organizations table
-			sqlStore := sqlstoretest.New(sqlstore.Config{Provider: "sqlite"}, sqlmock.QueryMatcherRegexp)
-			// Mock the organizations query that SendAlerts makes
-			orgRows := sqlStore.Mock().NewRows([]string{"id"}).AddRow(orgID.StringValue())
-			sqlStore.Mock().ExpectQuery("SELECT (.+) FROM (.+)organizations(.+) LIMIT (.+)").WillReturnRows(orgRows)
-
-			telemetryStore := telemetrystoretest.New(telemetrystore.Config{}, &queryMatcherAny{})
-
-			// Set up Prometheus-specific mock data
-			// Fingerprint columns for Prometheus queries
-			fingerprintCols := []cmock.ColumnType{
-				{Name: "fingerprint", Type: "UInt64"},
-				{Name: "any(labels)", Type: "String"},
-			}
-
-			// Samples columns for Prometheus queries
-			samplesCols := []cmock.ColumnType{
-				{Name: "metric_name", Type: "String"},
-				{Name: "fingerprint", Type: "UInt64"},
-				{Name: "unix_milli", Type: "Int64"},
-				{Name: "value", Type: "Float64"},
-				{Name: "flags", Type: "UInt32"},
-			}
-
-			// Calculate query time range similar to Prometheus rule tests
-			// TestNotification uses time.Now().UTC() for evaluation
-			// We calculate the query window based on current time to match what the actual evaluation will use
-			evalTime := baseTime
-			evalWindowMs := int64(5 * 60 * 1000) // 5 minutes in ms
-			evalTimeMs := evalTime.UnixMilli()
-			queryStart := ((evalTimeMs-2*evalWindowMs)/60000)*60000 + 1 // truncate to minute + 1ms
-			queryEnd := (evalTimeMs / 60000) * 60000                    // truncate to minute
-
-			// Create fingerprint data
-			fingerprint := uint64(12345)
-			labelsJSON := `{"__name__":"test_metric"}`
-			fingerprintData := [][]interface{}{
-				{fingerprint, labelsJSON},
-			}
-			fingerprintRows := cmock.NewRows(fingerprintCols, fingerprintData)
-
-			// Create samples data from test case values, calculating timestamps relative to baseTime
-			validSamplesData := make([][]interface{}, 0)
-			for _, v := range tc.values {
-				// Skip NaN and Inf values in the samples data
-				if math.IsNaN(v.value) || math.IsInf(v.value, 0) {
-					continue
-				}
-				// Calculate timestamp relative to baseTime
-				sampleTimestamp := baseTime.Add(v.offset).UnixMilli()
-				validSamplesData = append(validSamplesData, []interface{}{
-					"test_metric",
-					fingerprint,
-					sampleTimestamp,
-					v.value,
-					uint32(0), // flags - 0 means normal value
-				})
-			}
-			samplesRows := cmock.NewRows(samplesCols, validSamplesData)
-
-			mock := telemetryStore.Mock()
-
-			// Mock the fingerprint query (for Prometheus label matching)
-			mock.ExpectQuery("SELECT fingerprint, any").
-				WithArgs("test_metric", "__name__", "test_metric").
-				WillReturnRows(fingerprintRows)
-
-			// Mock the samples query (for Prometheus metric data)
-			mock.ExpectQuery("SELECT metric_name, fingerprint, unix_milli").
-				WithArgs(
-					"test_metric",
-					"test_metric",
-					"__name__",
-					"test_metric",
-					queryStart,
-					queryEnd,
-				).
-				WillReturnRows(samplesRows)
-
-			// Create reader with mocked telemetry store
-			readerCache, err := cachetest.New(cache.Config{
-				Provider: "memory",
-				Memory: cache.Memory{
-					NumCounters: 10 * 1000,
-					MaxCost:     1 << 26,
-				},
-			})
-			require.NoError(t, err)
-
-			options := clickhouseReader.NewOptions("", "", "archiveNamespace")
-			promProvider := prometheustest.New(context.Background(), instrumentationtest.New().ToProviderSettings(), prometheus.Config{}, telemetryStore)
-			reader := clickhouseReader.NewReader(
-				nil,
-				telemetryStore,
-				promProvider,
-				"",
-				time.Duration(time.Second),
-				nil,
-				readerCache,
-				options,
-			)
-
-			mgrOpts := &ManagerOptions{
-				Logger:         zap.NewNop(),
-				SLogger:        instrumentationtest.New().Logger(),
-				Cache:          cacheObj,
-				Alertmanager:   fAlert,
-				TelemetryStore: telemetryStore,
-				Reader:         reader,
-				SqlStore:       sqlStore, // SQLStore needed for SendAlerts to query organizations
-				Prometheus:     promProvider,
-			}
-
-			mgr, err := NewManager(mgrOpts)
-			require.NoError(t, err)
-
-			count, apiErr := mgr.TestNotification(context.Background(), orgID, string(ruleBytes))
-			if apiErr != nil {
-				t.Logf("TestNotification error: %v, type: %s", apiErr.Err, apiErr.Typ)
-			}
-			require.Nil(t, apiErr)
-			assert.Equal(t, tc.expectAlerts, count)
-
-			if tc.expectAlerts > 0 {
-				// check if the alert has been triggered
-				require.Len(t, triggeredTestAlerts, 1)
-				var gotAlerts []*alertmanagertypes.PostableAlert
-				for a := range triggeredTestAlerts[0] {
-					gotAlerts = append(gotAlerts, a)
-				}
-				require.Len(t, gotAlerts, tc.expectAlerts)
-				// check if the alert has triggered with correct threshold value
-				if tc.expectValue != 0 && !math.IsNaN(tc.expectValue) && !math.IsInf(tc.expectValue, 0) {
-					assert.Equal(t, strconv.FormatFloat(tc.expectValue, 'f', -1, 64), gotAlerts[0].Annotations["value"])
-				}
-			} else {
-				// check if no alerts have been triggered
-				assert.Empty(t, triggeredTestAlerts)
-			}
-
-			promProvider.Close()
-		})
-	}
-}

pkg/query-service/rules/prom_rule.go

@@ -138,8 +138,7 @@ func (r *PromRule) buildAndRunQuery(ctx context.Context, ts time.Time) (ruletype
 	var resultVector ruletypes.Vector
 	for _, series := range res {
 		resultSeries, err := r.Threshold.Eval(toCommonSeries(series), r.Unit(), ruletypes.EvalData{
-			ActiveAlerts:  r.ActiveAlertsLabelFP(),
-			SendUnmatched: r.ShouldSendUnmatched(),
+			ActiveAlerts: r.ActiveAlertsLabelFP(),
 		})
 		if err != nil {
 			return nil, err

pkg/query-service/rules/threshold_rule.go

@@ -489,8 +489,7 @@ func (r *ThresholdRule) buildAndRunQuery(ctx context.Context, orgID valuer.UUID,
 			}
 		}
 		resultSeries, err := r.Threshold.Eval(*series, r.Unit(), ruletypes.EvalData{
-			ActiveAlerts:  r.ActiveAlertsLabelFP(),
-			SendUnmatched: r.ShouldSendUnmatched(),
+			ActiveAlerts: r.ActiveAlertsLabelFP(),
 		})
 		if err != nil {
 			return nil, err
@@ -569,8 +568,7 @@ func (r *ThresholdRule) buildAndRunQueryV5(ctx context.Context, orgID valuer.UUI
 			}
 		}
 		resultSeries, err := r.Threshold.Eval(*series, r.Unit(), ruletypes.EvalData{
-			ActiveAlerts:  r.ActiveAlertsLabelFP(),
-			SendUnmatched: r.ShouldSendUnmatched(),
+			ActiveAlerts: r.ActiveAlertsLabelFP(),
 		})
 		if err != nil {
 			return nil, err

pkg/query-service/rules/threshold_rule_test.go

@@ -2,7 +2,6 @@ package rules
 
 import (
 	"context"
-	"math"
 	"strings"
 	"testing"
 	"time"
@@ -1520,283 +1519,6 @@ func TestThresholdRuleEval_MatchPlusCompareOps(t *testing.T) {
 
 }
 
-// TestThresholdRuleEval_SendUnmatchedBypassesRecovery tests the case where the sendUnmatched is true and the recovery target is met.
-// In this case, the rule should return the first sample as sendUnmatched is supposed to be used in tests and in case of tests
-// recovery target is expected to be present. This test make sure this behavior is working as expected.
-func TestThresholdRuleEval_SendUnmatchedBypassesRecovery(t *testing.T) {
-	target := 10.0
-	recovery := 4.0
-
-	postableRule := ruletypes.PostableRule{
-		AlertName: "Send unmatched bypass recovery",
-		AlertType: ruletypes.AlertTypeMetric,
-		RuleType:  ruletypes.RuleTypeThreshold,
-		Evaluation: &ruletypes.EvaluationEnvelope{Kind: ruletypes.RollingEvaluation, Spec: ruletypes.RollingWindow{
-			EvalWindow: ruletypes.Duration(5 * time.Minute),
-			Frequency:  ruletypes.Duration(1 * time.Minute),
-		}},
-		RuleCondition: &ruletypes.RuleCondition{
-			CompositeQuery: &v3.CompositeQuery{
-				QueryType: v3.QueryTypeBuilder,
-				BuilderQueries: map[string]*v3.BuilderQuery{
-					"A": {
-						QueryName:    "A",
-						StepInterval: 60,
-						AggregateAttribute: v3.AttributeKey{
-							Key: "probe_success",
-						},
-						AggregateOperator: v3.AggregateOperatorNoOp,
-						DataSource:        v3.DataSourceMetrics,
-						Expression:        "A",
-					},
-				},
-			},
-		},
-	}
-
-	postableRule.RuleCondition.Thresholds = &ruletypes.RuleThresholdData{
-		Kind: ruletypes.BasicThresholdKind,
-		Spec: ruletypes.BasicRuleThresholds{
-			{
-				Name:           "primary",
-				TargetValue:    &target,
-				RecoveryTarget: &recovery,
-				MatchType:      ruletypes.AtleastOnce,
-				CompareOp:      ruletypes.ValueIsAbove,
-			},
-		},
-	}
-
-	logger := instrumentationtest.New().Logger()
-	rule, err := NewThresholdRule("69", valuer.GenerateUUID(), &postableRule, nil, nil, logger, WithEvalDelay(2*time.Minute))
-	require.NoError(t, err)
-
-	now := time.Now()
-	series := v3.Series{
-		Points: []v3.Point{
-			{Timestamp: now.UnixMilli(), Value: 3},
-			{Timestamp: now.Add(time.Minute).UnixMilli(), Value: 4},
-			{Timestamp: now.Add(2 * time.Minute).UnixMilli(), Value: 5},
-		},
-		Labels: map[string]string{
-			"service.name": "frontend",
-		},
-		LabelsArray: []map[string]string{
-			{
-				"service.name": "frontend",
-			},
-		},
-	}
-
-	alertLabels := ruletypes.PrepareSampleLabelsForRule(series.Labels, "primary")
-	activeAlerts := map[uint64]struct{}{alertLabels.Hash(): {}}
-
-	resultVectors, err := rule.Threshold.Eval(series, rule.Unit(), ruletypes.EvalData{
-		ActiveAlerts:  activeAlerts,
-		SendUnmatched: true,
-	})
-	require.NoError(t, err)
-	require.Len(t, resultVectors, 1, "expected unmatched sample to be returned")
-
-	smpl := resultVectors[0]
-	assert.Equal(t, float64(3), smpl.V)
-	assert.False(t, smpl.IsRecovering, "unmatched path should not mark sample as recovering")
-	assert.Equal(t, float64(4), *smpl.RecoveryTarget, "unmatched path should set recovery target")
-	assert.InDelta(t, target, smpl.Target, 0.01)
-	assert.Equal(t, "primary", smpl.Metric.Get(ruletypes.LabelThresholdName))
-}
-
-func intPtr(v int) *int {
-	return &v
-}
-
-// TestThresholdRuleEval_SendUnmatchedVariants tests the different variants of sendUnmatched behavior.
-// It tests the case where sendUnmatched is true, false.
-func TestThresholdRuleEval_SendUnmatchedVariants(t *testing.T) {
-	target := 10.0
-	recovery := 5.0
-	postableRule := ruletypes.PostableRule{
-		AlertName: "Send unmatched variants",
-		AlertType: ruletypes.AlertTypeMetric,
-		RuleType:  ruletypes.RuleTypeThreshold,
-		Evaluation: &ruletypes.EvaluationEnvelope{Kind: ruletypes.RollingEvaluation, Spec: ruletypes.RollingWindow{
-			EvalWindow: ruletypes.Duration(5 * time.Minute),
-			Frequency:  ruletypes.Duration(1 * time.Minute),
-		}},
-		RuleCondition: &ruletypes.RuleCondition{
-			CompositeQuery: &v3.CompositeQuery{
-				QueryType: v3.QueryTypeBuilder,
-				BuilderQueries: map[string]*v3.BuilderQuery{
-					"A": {
-						QueryName:    "A",
-						StepInterval: 60,
-						AggregateAttribute: v3.AttributeKey{
-							Key: "probe_success",
-						},
-						AggregateOperator: v3.AggregateOperatorNoOp,
-						DataSource:        v3.DataSourceMetrics,
-						Expression:        "A",
-					},
-				},
-			},
-		},
-	}
-
-	now := time.Now()
-
-	tests := []recoveryTestCase{
-		{
-			description: "sendUnmatched returns first valid point",
-			values: v3.Series{
-				Points: []v3.Point{
-					{Timestamp: now.UnixMilli(), Value: 3},
-					{Timestamp: now.Add(time.Minute).UnixMilli(), Value: 4},
-				},
-				Labels: map[string]string{
-					"service.name": "frontend",
-				},
-				LabelsArray: []map[string]string{
-					{
-						"service.name": "frontend",
-					},
-				},
-			},
-			compareOp:      string(ruletypes.ValueIsAbove),
-			matchType:      string(ruletypes.AtleastOnce),
-			target:         target,
-			recoveryTarget: &recovery,
-			thresholdName:  "primary",
-			// Since sendUnmatched is true, the rule should return the first valid point
-			// even if it doesn't match the rule condition with current target value of 10.0
-			sendUnmatched:       true,
-			expectSamples:       intPtr(1),
-			expectedSampleValue: 3,
-		},
-		{
-			description: "sendUnmatched false suppresses unmatched",
-			values: v3.Series{
-				Points: []v3.Point{
-					{Timestamp: now.UnixMilli(), Value: 3},
-					{Timestamp: now.Add(time.Minute).UnixMilli(), Value: 4},
-				},
-				Labels: map[string]string{
-					"service.name": "frontend",
-				},
-				LabelsArray: []map[string]string{
-					{
-						"service.name": "frontend",
-					},
-				},
-			},
-			compareOp:      string(ruletypes.ValueIsAbove),
-			matchType:      string(ruletypes.AtleastOnce),
-			target:         target,
-			recoveryTarget: &recovery,
-			thresholdName:  "primary",
-			// Since sendUnmatched is false, the rule should not return any samples
-			sendUnmatched: false,
-			expectSamples: intPtr(0),
-		},
-		{
-			description: "sendUnmatched skips NaN and uses next point",
-			values: v3.Series{
-				Points: []v3.Point{
-					{Timestamp: now.UnixMilli(), Value: math.NaN()},
-					{Timestamp: now.Add(time.Minute).UnixMilli(), Value: math.Inf(1)},
-					{Timestamp: now.Add(2 * time.Minute).UnixMilli(), Value: 7},
-				},
-				Labels: map[string]string{
-					"service.name": "frontend",
-				},
-				LabelsArray: []map[string]string{
-					{
-						"service.name": "frontend",
-					},
-				},
-			},
-			compareOp:      string(ruletypes.ValueIsAbove),
-			matchType:      string(ruletypes.AtleastOnce),
-			target:         target,
-			recoveryTarget: &recovery,
-			thresholdName:  "primary",
-			// Since sendUnmatched is true, the rule should return the first valid point
-			// even if it doesn't match the rule condition with current target value of 10.0
-			sendUnmatched:       true,
-			expectSamples:       intPtr(1),
-			expectedSampleValue: 7,
-		},
-	}
-
-	for _, tc := range tests {
-		runEvalTests(t, postableRule, []recoveryTestCase{tc})
-	}
-}
-
-// TestThresholdRuleEval_RecoveryNotMetSendUnmatchedFalse tests the case where the recovery target is not met and sendUnmatched is false.
-// In this case, the rule should not return any samples as no alert is active plus the recovery target is not met.
-func TestThresholdRuleEval_RecoveryNotMetSendUnmatchedFalse(t *testing.T) {
-	target := 10.0
-	recovery := 5.0
-
-	now := time.Now()
-	postableRule := ruletypes.PostableRule{
-		AlertName: "Recovery not met sendUnmatched false",
-		AlertType: ruletypes.AlertTypeMetric,
-		RuleType:  ruletypes.RuleTypeThreshold,
-		Evaluation: &ruletypes.EvaluationEnvelope{Kind: ruletypes.RollingEvaluation, Spec: ruletypes.RollingWindow{
-			EvalWindow: ruletypes.Duration(5 * time.Minute),
-			Frequency:  ruletypes.Duration(1 * time.Minute),
-		}},
-		RuleCondition: &ruletypes.RuleCondition{
-			CompositeQuery: &v3.CompositeQuery{
-				QueryType: v3.QueryTypeBuilder,
-				BuilderQueries: map[string]*v3.BuilderQuery{
-					"A": {
-						QueryName:    "A",
-						StepInterval: 60,
-						AggregateAttribute: v3.AttributeKey{
-							Key: "probe_success",
-						},
-						AggregateOperator: v3.AggregateOperatorNoOp,
-						DataSource:        v3.DataSourceMetrics,
-						Expression:        "A",
-					},
-				},
-			},
-		},
-	}
-
-	tc := recoveryTestCase{
-		description: "recovery target present but not met, sendUnmatched false",
-		values: v3.Series{
-			Points: []v3.Point{
-				{Timestamp: now.UnixMilli(), Value: 3},
-				{Timestamp: now.Add(time.Minute).UnixMilli(), Value: 4},
-			},
-			Labels: map[string]string{
-				"service.name": "frontend",
-			},
-			LabelsArray: []map[string]string{
-				{
-					"service.name": "frontend",
-				},
-			},
-		},
-		compareOp:              string(ruletypes.ValueIsAbove),
-		matchType:              string(ruletypes.AtleastOnce),
-		target:                 target,
-		recoveryTarget:         &recovery,
-		thresholdName:          "primary",
-		sendUnmatched:          false,
-		expectSamples:          intPtr(0),
-		activeAlerts:           nil, // will auto-calc
-		expectedTarget:         target,
-		expectedRecoveryTarget: recovery,
-	}
-
-	runEvalTests(t, postableRule, []recoveryTestCase{tc})
-}
-
 func runEvalTests(t *testing.T, postableRule ruletypes.PostableRule, testCases []recoveryTestCase) {
 	logger := instrumentationtest.New().Logger()
 	for _, c := range testCases {
@@ -1855,21 +1577,12 @@ func runEvalTests(t *testing.T, postableRule ruletypes.PostableRule, testCases [
 			}
 
 			evalData := ruletypes.EvalData{
-				ActiveAlerts:  activeAlerts,
-				SendUnmatched: c.sendUnmatched,
+				ActiveAlerts: activeAlerts,
 			}
 
 			resultVectors, err := rule.Threshold.Eval(values, rule.Unit(), evalData)
 			assert.NoError(t, err)
 
-			if c.expectSamples != nil {
-				assert.Equal(t, *c.expectSamples, len(resultVectors), "sample count mismatch")
-				if *c.expectSamples > 0 {
-					assert.InDelta(t, c.expectedSampleValue, resultVectors[0].V, 0.01, "sample value mismatch")
-				}
-				return
-			}
-
 			// Verify results
 			if c.expectAlert || c.expectRecovery {
 				// Either a new alert fires or recovery happens - both return result vectors

pkg/query-service/rules/threshold_rule_test_data.go

@@ -27,10 +27,6 @@ type recoveryTestCase struct {
 	expectedTarget         float64
 	expectedRecoveryTarget float64
 	thresholdName          string // for hash calculation
-	// Optional fields for SendUnmatched scenarios
-	sendUnmatched       bool    // whether to set EvalData.SendUnmatched
-	expectSamples       *int    // if set, assert exact sample count
-	expectedSampleValue float64 // used when expectSamples is set
 }
 
 // thresholdExpectation defines expected behavior for a single threshold in multi-threshold tests

pkg/query-service/rules/utils.go

@@ -1,79 +0,0 @@
-package rules
-
-import (
-	"time"
-
-	"github.com/SigNoz/signoz/pkg/types/metrictypes"
-)
-
-// GenerateMetricQueryCHArgs generates query arguments for metric queries used in tests.
-// It calculates the time range, builds time series CTE args, temporal aggregation args,
-// and spatial aggregation args to match the actual query builder behavior.
-func GenerateMetricQueryCHArgs(
-	evalTime time.Time,
-	evalWindow time.Duration,
-	evalDelay time.Duration,
-	metricName string,
-	temporality metrictypes.Temporality,
-) []interface{} {
-	// Calculate time range
-	startTime := evalTime.Add(-evalWindow)
-	endTime := evalTime
-
-	startMs := startTime.UnixMilli()
-	endMs := endTime.UnixMilli()
-
-	// Apply eval delay if present
-	if evalDelay > 0 {
-		startMs = startMs - int64(evalDelay.Milliseconds())
-		endMs = endMs - int64(evalDelay.Milliseconds())
-	}
-
-	// Round to nearest minute
-	startMs = startMs - (startMs % (60 * 1000))
-	endMs = endMs - (endMs % (60 * 1000))
-
-	start := uint64(startMs)
-	end := uint64(endMs)
-
-	// Step1: Build time series CTE args
-
-	// Adjust start time to nearest hour
-	oneHourInMilliseconds := uint64(time.Hour.Milliseconds())
-	// start time for filtering signoz_metrics.time_series_v4 with start time
-	timeSeriesCTEStartTime := start - (start % oneHourInMilliseconds)
-
-	queryArgs := []interface{}{
-		metricName,
-		timeSeriesCTEStartTime,
-		end,
-	}
-
-	// Add temporality if specified
-	if temporality == metrictypes.Unknown {
-		temporality = metrictypes.Unspecified
-	}
-	if temporality != metrictypes.Unknown {
-		queryArgs = append(queryArgs, temporality.StringValue())
-	}
-
-	// Add normalized flag
-	queryArgs = append(queryArgs, false)
-
-	// Step2: Add temporal aggregation args
-	// build args for filtering signoz_metrics.distributed_samples_v4 table
-	temporalAggArgs := []interface{}{
-		metricName,
-		start,
-		end,
-	}
-	queryArgs = append(queryArgs, temporalAggArgs...)
-
-	// Add spatial aggregation args
-	spatialAggArgs := []interface{}{
-		0, // isNaN check
-	}
-	queryArgs = append(queryArgs, spatialAggArgs...)
-
-	return queryArgs
-}

pkg/signoz/module.go

@@ -20,6 +20,8 @@ import (
 	"github.com/SigNoz/signoz/pkg/modules/organization/implorganization"
 	"github.com/SigNoz/signoz/pkg/modules/preference"
 	"github.com/SigNoz/signoz/pkg/modules/preference/implpreference"
+	"github.com/SigNoz/signoz/pkg/modules/promote"
+	"github.com/SigNoz/signoz/pkg/modules/promote/implpromote"
 	"github.com/SigNoz/signoz/pkg/modules/quickfilter"
 	"github.com/SigNoz/signoz/pkg/modules/quickfilter/implquickfilter"
 	"github.com/SigNoz/signoz/pkg/modules/rawdataexport"
@@ -65,6 +67,7 @@ type Modules struct {
 	Services        services.Module
 	SpanPercentile  spanpercentile.Module
 	MetricsExplorer metricsexplorer.Module
+	Promote         promote.Module
 }
 
 func NewModules(
@@ -108,5 +111,6 @@ func NewModules(
 		SpanPercentile:  implspanpercentile.NewModule(querier, providerSettings),
 		Services:        implservices.NewModule(querier, telemetryStore),
 		MetricsExplorer: implmetricsexplorer.NewModule(telemetryStore, telemetryMetadataStore, cache, ruleStore, dashboard, providerSettings, config.MetricsExplorer),
+		Promote:         implpromote.NewModule(telemetryMetadataStore, telemetryStore),
 	}
 }

pkg/signoz/openapi.go

@@ -14,6 +14,7 @@ import (
 	"github.com/SigNoz/signoz/pkg/modules/authdomain"
 	"github.com/SigNoz/signoz/pkg/modules/organization"
 	"github.com/SigNoz/signoz/pkg/modules/preference"
+	"github.com/SigNoz/signoz/pkg/modules/promote"
 	"github.com/SigNoz/signoz/pkg/modules/session"
 	"github.com/SigNoz/signoz/pkg/modules/user"
 	"github.com/SigNoz/signoz/pkg/types/ctxtypes"
@@ -38,6 +39,7 @@ func NewOpenAPI(ctx context.Context, instrumentation instrumentation.Instrumenta
 		struct{ authdomain.Handler }{},
 		struct{ preference.Handler }{},
 		struct{ global.Handler }{},
+		struct{ promote.Handler }{},
 	).New(ctx, instrumentation.ToProviderSettings(), apiserver.Config{})
 	if err != nil {
 		return nil, err

pkg/signoz/provider.go

@@ -24,6 +24,7 @@ import (
 	"github.com/SigNoz/signoz/pkg/modules/organization"
 	"github.com/SigNoz/signoz/pkg/modules/organization/implorganization"
 	"github.com/SigNoz/signoz/pkg/modules/preference/implpreference"
+	"github.com/SigNoz/signoz/pkg/modules/promote/implpromote"
 	"github.com/SigNoz/signoz/pkg/modules/session/implsession"
 	"github.com/SigNoz/signoz/pkg/modules/user"
 	"github.com/SigNoz/signoz/pkg/modules/user/impluser"
@@ -234,6 +235,7 @@ func NewAPIServerProviderFactories(orgGetter organization.Getter, authz authz.Au
 			implauthdomain.NewHandler(modules.AuthDomain),
 			implpreference.NewHandler(modules.Preference),
 			signozglobal.NewHandler(global),
+			implpromote.NewHandler(modules.Promote),
 		),
 	)
 }

pkg/telemetrylogs/json_access_pb.go

@@ -0,0 +1,149 @@
+package telemetrylogs
+
+import (
+	"context"
+	"slices"
+	"strings"
+
+	"github.com/SigNoz/signoz/pkg/errors"
+	qbtypes "github.com/SigNoz/signoz/pkg/types/querybuildertypes/querybuildertypesv5"
+	"github.com/SigNoz/signoz/pkg/types/telemetrytypes"
+)
+
+var (
+	CodePlanIndexOutOfBounds = errors.MustNewCode("plan_index_out_of_bounds")
+)
+
+type JSONAccessPlanBuilder struct {
+	key        *telemetrytypes.TelemetryFieldKey
+	value      any
+	op         qbtypes.FilterOperator
+	parts      []string
+	getTypes   func(ctx context.Context, path string) ([]telemetrytypes.JSONDataType, error)
+	isPromoted bool
+}
+
+// buildPlan recursively builds the path plan tree
+func (pb *JSONAccessPlanBuilder) buildPlan(ctx context.Context, index int, parent *telemetrytypes.JSONAccessNode, isDynArrChild bool) (*telemetrytypes.JSONAccessNode, error) {
+	if index >= len(pb.parts) {
+		return nil, errors.NewInvalidInputf(CodePlanIndexOutOfBounds, "index is out of bounds")
+	}
+
+	part := pb.parts[index]
+	pathSoFar := strings.Join(pb.parts[:index+1], ArraySep)
+	isTerminal := index == len(pb.parts)-1
+
+	// Calculate progression parameters based on parent's values
+	var maxTypes, maxPaths int
+	if isDynArrChild {
+		// Child of Dynamic array - reset progression to base values (16, 256)
+		// This happens when we switch from Array(Dynamic) to Array(JSON)
+		maxTypes = 16
+		maxPaths = 256
+	} else if parent != nil {
+		// Child of JSON array - use parent's progression divided by 2 and 4
+		maxTypes = parent.MaxDynamicTypes / 2
+		maxPaths = parent.MaxDynamicPaths / 4
+		if maxTypes < 0 {
+			maxTypes = 0
+		}
+		if maxPaths < 0 {
+			maxPaths = 0
+		}
+	}
+
+	types, err := pb.getTypes(ctx, pathSoFar)
+	if err != nil {
+		return nil, err
+	}
+
+	// Create node for this path segment
+	node := &telemetrytypes.JSONAccessNode{
+		Name:            part,
+		IsTerminal:      isTerminal,
+		AvailableTypes:  types,
+		Branches:        make(map[telemetrytypes.JSONAccessBranchType]*telemetrytypes.JSONAccessNode),
+		Parent:          parent,
+		MaxDynamicTypes: maxTypes,
+		MaxDynamicPaths: maxPaths,
+	}
+
+	hasJSON := slices.Contains(node.AvailableTypes, telemetrytypes.ArrayJSON)
+	hasDynamic := slices.Contains(node.AvailableTypes, telemetrytypes.ArrayDynamic)
+
+	// Configure terminal if this is the last part
+	if isTerminal {
+		valueType, _ := inferDataType(pb.value, pb.op, pb.key)
+		node.TerminalConfig = &telemetrytypes.TerminalConfig{
+			Key:       pb.key,
+			ElemType:  *pb.key.JSONDataType,
+			ValueType: telemetrytypes.MappingFieldDataTypeToJSONDataType[valueType],
+		}
+	} else {
+		if hasJSON {
+			node.Branches[telemetrytypes.BranchJSON], err = pb.buildPlan(ctx, index+1, node, false)
+			if err != nil {
+				return nil, err
+			}
+		}
+		if hasDynamic {
+			node.Branches[telemetrytypes.BranchDynamic], err = pb.buildPlan(ctx, index+1, node, true)
+			if err != nil {
+				return nil, err
+			}
+		}
+	}
+
+	return node, nil
+}
+
+// PlanJSON builds a tree structure representing the complete JSON path traversal
+// that precomputes all possible branches and their types
+func PlanJSON(ctx context.Context, key *telemetrytypes.TelemetryFieldKey, op qbtypes.FilterOperator,
+	value any,
+	getTypes func(ctx context.Context, path string) ([]telemetrytypes.JSONDataType, error),
+) (telemetrytypes.JSONAccessPlan, error) {
+	// if path is empty, return nil
+	if key.Name == "" {
+		return nil, errors.NewInvalidInputf(errors.CodeInvalidInput, "path is empty")
+	}
+
+	// TODO: PlanJSON requires the Start and End of the Query to select correct column between promoted and body_json using
+	// creation time in distributed_promoted_paths
+	path := strings.ReplaceAll(key.Name, ArrayAnyIndex, ArraySep)
+	parts := strings.Split(path, ArraySep)
+
+	pb := &JSONAccessPlanBuilder{
+		key:        key,
+		op:         op,
+		value:      value,
+		parts:      parts,
+		getTypes:   getTypes,
+		isPromoted: key.Materialized,
+	}
+	plans := telemetrytypes.JSONAccessPlan{}
+
+	node, err := pb.buildPlan(ctx, 0,
+		telemetrytypes.NewRootJSONAccessNode(LogsV2BodyJSONColumn,
+			32, 0),
+		false,
+	)
+	if err != nil {
+		return nil, err
+	}
+	plans = append(plans, node)
+
+	if pb.isPromoted {
+		node, err := pb.buildPlan(ctx, 0,
+			telemetrytypes.NewRootJSONAccessNode(LogsV2BodyPromotedColumn,
+				32, 1024),
+			true,
+		)
+		if err != nil {
+			return nil, err
+		}
+		plans = append(plans, node)
+	}
+
+	return plans, nil
+}

pkg/telemetrylogs/json_access_pb_test.go

@@ -0,0 +1,880 @@
+package telemetrylogs
+
+import (
+	"context"
+	"testing"
+
+	qbtypes "github.com/SigNoz/signoz/pkg/types/querybuildertypes/querybuildertypesv5"
+	"github.com/SigNoz/signoz/pkg/types/telemetrytypes"
+	"github.com/stretchr/testify/require"
+	"gopkg.in/yaml.v3"
+)
+
+// ============================================================================
+// Helper Functions for Test Data Creation
+// ============================================================================
+
+// makeKey creates a TelemetryFieldKey for testing
+func makeKey(name string, dataType telemetrytypes.JSONDataType, materialized bool) *telemetrytypes.TelemetryFieldKey {
+	return &telemetrytypes.TelemetryFieldKey{
+		Name:         name,
+		JSONDataType: &dataType,
+		Materialized: materialized,
+	}
+}
+
+// makeGetTypes creates a getTypes function from a map of path -> types
+func makeGetTypes(typesMap map[string][]telemetrytypes.JSONDataType) func(ctx context.Context, path string) ([]telemetrytypes.JSONDataType, error) {
+	return func(_ context.Context, path string) ([]telemetrytypes.JSONDataType, error) {
+		return typesMap[path], nil
+	}
+}
+
+// ============================================================================
+// Helper Functions for Node Validation
+// ============================================================================
+
+// jsonAccessTestNode is a test-only, YAML-friendly view of JSONAccessNode.
+// It intentionally omits Parent to avoid cycles and only keeps the fields
+// that are useful for understanding / asserting the plan structure.
+type jsonAccessTestNode struct {
+	Name            string                         `yaml:"name"`
+	Column          string                         `yaml:"column,omitempty"`
+	IsTerminal      bool                           `yaml:"isTerminal,omitempty"`
+	MaxDynamicTypes int                            `yaml:"maxDynamicTypes,omitempty"`
+	MaxDynamicPaths int                            `yaml:"maxDynamicPaths,omitempty"`
+	ElemType        string                         `yaml:"elemType,omitempty"`
+	ValueType       string                         `yaml:"valueType,omitempty"`
+	AvailableTypes  []string                       `yaml:"availableTypes,omitempty"`
+	Branches        map[string]*jsonAccessTestNode `yaml:"branches,omitempty"`
+}
+
+// toTestNode converts a JSONAccessNode tree into jsonAccessTestNode so that
+// it can be serialized to YAML for easy visual comparison in tests.
+func toTestNode(n *telemetrytypes.JSONAccessNode) *jsonAccessTestNode {
+	if n == nil {
+		return nil
+	}
+
+	out := &jsonAccessTestNode{
+		Name:            n.Name,
+		IsTerminal:      n.IsTerminal,
+		MaxDynamicTypes: n.MaxDynamicTypes,
+		MaxDynamicPaths: n.MaxDynamicPaths,
+	}
+
+	// Column information for top-level plan nodes: their parent is the root,
+	// whose parent is nil.
+	if n.Parent != nil && n.Parent.Parent == nil {
+		out.Column = n.Parent.Name
+	}
+
+	// AvailableTypes as strings (using StringValue for stable representation)
+	if len(n.AvailableTypes) > 0 {
+		out.AvailableTypes = make([]string, 0, len(n.AvailableTypes))
+		for _, t := range n.AvailableTypes {
+			out.AvailableTypes = append(out.AvailableTypes, t.StringValue())
+		}
+	}
+
+	// Terminal config
+	if n.TerminalConfig != nil {
+		out.ElemType = n.TerminalConfig.ElemType.StringValue()
+		out.ValueType = n.TerminalConfig.ValueType.StringValue()
+	}
+
+	// Branches
+	if len(n.Branches) > 0 {
+		out.Branches = make(map[string]*jsonAccessTestNode, len(n.Branches))
+		for bt, child := range n.Branches {
+			out.Branches[bt.StringValue()] = toTestNode(child)
+		}
+	}
+
+	return out
+}
+
+// plansToYAML converts a slice of JSONAccessNode plans to a YAML string that
+// can be compared against a per-test expectedTree.
+func plansToYAML(t *testing.T, plans []*telemetrytypes.JSONAccessNode) string {
+	t.Helper()
+
+	testNodes := make([]*jsonAccessTestNode, 0, len(plans))
+	for _, p := range plans {
+		testNodes = append(testNodes, toTestNode(p))
+	}
+
+	got, err := yaml.Marshal(testNodes)
+	require.NoError(t, err)
+	return string(got)
+}
+
+// ============================================================================
+// Test Cases for Node Methods
+// ============================================================================
+
+func TestNode_Alias(t *testing.T) {
+	tests := []struct {
+		name     string
+		node     *telemetrytypes.JSONAccessNode
+		expected string
+	}{
+		{
+			name:     "Root node returns name as-is",
+			node:     telemetrytypes.NewRootJSONAccessNode(LogsV2BodyJSONColumn, 32, 0),
+			expected: LogsV2BodyJSONColumn,
+		},
+		{
+			name: "Node without parent returns backticked name",
+			node: &telemetrytypes.JSONAccessNode{
+				Name:   "user",
+				Parent: nil,
+			},
+			expected: "`user`",
+		},
+		{
+			name: "Node with root parent uses dot separator",
+			node: &telemetrytypes.JSONAccessNode{
+				Name:   "age",
+				Parent: telemetrytypes.NewRootJSONAccessNode(LogsV2BodyJSONColumn, 32, 0),
+			},
+			expected: "`" + LogsV2BodyJSONColumn + ".age`",
+		},
+		{
+			name: "Node with non-root parent uses array separator",
+			node: &telemetrytypes.JSONAccessNode{
+				Name: "name",
+				Parent: &telemetrytypes.JSONAccessNode{
+					Name:   "education",
+					Parent: telemetrytypes.NewRootJSONAccessNode(LogsV2BodyJSONColumn, 32, 0),
+				},
+			},
+			expected: "`" + LogsV2BodyJSONColumn + ".education[].name`",
+		},
+		{
+			name: "Nested array path with multiple levels",
+			node: &telemetrytypes.JSONAccessNode{
+				Name: "type",
+				Parent: &telemetrytypes.JSONAccessNode{
+					Name: "awards",
+					Parent: &telemetrytypes.JSONAccessNode{
+						Name:   "education",
+						Parent: telemetrytypes.NewRootJSONAccessNode(LogsV2BodyJSONColumn, 32, 0),
+					},
+				},
+			},
+			expected: "`" + LogsV2BodyJSONColumn + ".education[].awards[].type`",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			result := tt.node.Alias()
+			require.Equal(t, tt.expected, result)
+		})
+	}
+}
+
+func TestNode_FieldPath(t *testing.T) {
+	tests := []struct {
+		name     string
+		node     *telemetrytypes.JSONAccessNode
+		expected string
+	}{
+		{
+			name: "Simple field path from root",
+			node: &telemetrytypes.JSONAccessNode{
+				Name:   "user",
+				Parent: telemetrytypes.NewRootJSONAccessNode(LogsV2BodyJSONColumn, 32, 0),
+			},
+			// FieldPath() always wraps the field name in backticks
+			expected: LogsV2BodyJSONColumn + ".`user`",
+		},
+		{
+			name: "Field path with backtick-required key",
+			node: &telemetrytypes.JSONAccessNode{
+				Name:   "user-name", // requires backtick
+				Parent: telemetrytypes.NewRootJSONAccessNode(LogsV2BodyJSONColumn, 32, 0),
+			},
+			expected: LogsV2BodyJSONColumn + ".`user-name`",
+		},
+		{
+			name: "Nested field path",
+			node: &telemetrytypes.JSONAccessNode{
+				Name: "age",
+				Parent: &telemetrytypes.JSONAccessNode{
+					Name:   "user",
+					Parent: telemetrytypes.NewRootJSONAccessNode(LogsV2BodyJSONColumn, 32, 0),
+				},
+			},
+			// FieldPath() always wraps the field name in backticks
+			expected: "`" + LogsV2BodyJSONColumn + ".user`.`age`",
+		},
+		{
+			name: "Array element field path",
+			node: &telemetrytypes.JSONAccessNode{
+				Name: "name",
+				Parent: &telemetrytypes.JSONAccessNode{
+					Name:   "education",
+					Parent: telemetrytypes.NewRootJSONAccessNode(LogsV2BodyJSONColumn, 32, 0),
+				},
+			},
+			// FieldPath() always wraps the field name in backticks
+			expected: "`" + LogsV2BodyJSONColumn + ".education`.`name`",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			result := tt.node.FieldPath()
+			require.Equal(t, tt.expected, result)
+		})
+	}
+}
+
+// ============================================================================
+// Test Cases for PlanJSON
+// ============================================================================
+
+func TestPlanJSON_BasicStructure(t *testing.T) {
+	_, getTypes := testTypeSet()
+
+	tests := []struct {
+		name         string
+		key          *telemetrytypes.TelemetryFieldKey
+		expectErr    bool
+		expectedYAML string
+	}{
+		{
+			name: "Simple path not promoted",
+			key:  makeKey("user.name", telemetrytypes.String, false),
+			expectedYAML: `
+- name: user.name
+  column: body_json
+  availableTypes:
+    - String
+  maxDynamicTypes: 16
+  isTerminal: true
+  elemType: String
+  valueType: String
+`,
+		},
+		{
+			name: "Simple path promoted",
+			key:  makeKey("user.name", telemetrytypes.String, true),
+			expectedYAML: `
+- name: user.name
+  column: body_json
+  availableTypes:
+    - String
+  maxDynamicTypes: 16
+  isTerminal: true
+  elemType: String
+  valueType: String
+- name: user.name
+  column: body_json_promoted
+  availableTypes:
+    - String
+  maxDynamicTypes: 16
+  maxDynamicPaths: 256
+  isTerminal: true
+  elemType: String
+  valueType: String
+`,
+		},
+		{
+			name:         "Empty path returns error",
+			key:          makeKey("", telemetrytypes.String, false),
+			expectErr:    true,
+			expectedYAML: "",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			plans, err := PlanJSON(context.Background(), tt.key, qbtypes.FilterOperatorEqual, "John", getTypes)
+			if tt.expectErr {
+				require.Error(t, err)
+				require.Nil(t, plans)
+				return
+			}
+			require.NoError(t, err)
+			got := plansToYAML(t, plans)
+			require.YAMLEq(t, tt.expectedYAML, got)
+		})
+	}
+}
+
+func TestPlanJSON_ArrayPaths(t *testing.T) {
+	_, getTypes := testTypeSet()
+
+	tests := []struct {
+		name         string
+		path         string
+		expectedYAML string
+	}{
+		{
+			name: "Single array level - JSON branch only",
+			path: "education[].name",
+			expectedYAML: `
+- name: education
+  column: body_json
+  availableTypes:
+    - Array(JSON)
+  maxDynamicTypes: 16
+  branches:
+    json:
+      name: name
+      availableTypes:
+        - String
+      maxDynamicTypes: 8
+      isTerminal: true
+      elemType: String
+      valueType: String
+`,
+		},
+		{
+			name: "Single array level - both JSON and Dynamic branches",
+			path: "education[].awards[].type",
+			expectedYAML: `
+- name: education
+  column: body_json
+  availableTypes:
+    - Array(JSON)
+  maxDynamicTypes: 16
+  branches:
+    json:
+      name: awards
+      availableTypes:
+        - Array(Dynamic)
+        - Array(JSON)
+      maxDynamicTypes: 8
+      branches:
+        json:
+          name: type
+          availableTypes:
+            - String
+          maxDynamicTypes: 4
+          isTerminal: true
+          elemType: String
+          valueType: String
+        dynamic:
+          name: type
+          availableTypes:
+            - String
+          maxDynamicTypes: 16
+          maxDynamicPaths: 256
+          isTerminal: true
+          elemType: String
+          valueType: String
+`,
+		},
+		{
+			name: "Deeply nested array path",
+			path: "interests[].entities[].reviews[].entries[].metadata[].positions[].name",
+			expectedYAML: `
+- name: interests
+  column: body_json
+  availableTypes:
+    - Array(JSON)
+  maxDynamicTypes: 16
+  branches:
+    json:
+      name: entities
+      availableTypes:
+        - Array(JSON)
+      maxDynamicTypes: 8
+      branches:
+        json:
+          name: reviews
+          availableTypes:
+            - Array(JSON)
+          maxDynamicTypes: 4
+          branches:
+            json:
+              name: entries
+              availableTypes:
+                - Array(JSON)
+              maxDynamicTypes: 2
+              branches:
+                json:
+                  name: metadata
+                  availableTypes:
+                    - Array(JSON)
+                  maxDynamicTypes: 1
+                  branches:
+                    json:
+                      name: positions
+                      availableTypes:
+                        - Array(JSON)
+                      branches:
+                        json:
+                          name: name
+                          availableTypes:
+                            - String
+                          isTerminal: true
+                          elemType: String
+                          valueType: String
+`,
+		},
+		{
+			name: "ArrayAnyIndex replacement [*] to []",
+			path: "education[*].name",
+			expectedYAML: `
+- name: education
+  column: body_json
+  availableTypes:
+    - Array(JSON)
+  maxDynamicTypes: 16
+  branches:
+    json:
+      name: name
+      availableTypes:
+        - String
+      maxDynamicTypes: 8
+      isTerminal: true
+      elemType: String
+      valueType: String
+`,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			key := makeKey(tt.path, telemetrytypes.String, false)
+			plans, err := PlanJSON(context.Background(), key, qbtypes.FilterOperatorEqual, "John", getTypes)
+			require.NoError(t, err)
+			require.NotNil(t, plans)
+			require.Len(t, plans, 1)
+			got := plansToYAML(t, plans)
+			require.YAMLEq(t, tt.expectedYAML, got)
+		})
+	}
+}
+
+func TestPlanJSON_PromotedVsNonPromoted(t *testing.T) {
+	_, getTypes := testTypeSet()
+	path := "education[].awards[].type"
+	value := "sports"
+
+	t.Run("Non-promoted plan", func(t *testing.T) {
+		key := makeKey(path, telemetrytypes.String, false)
+		plans, err := PlanJSON(context.Background(), key, qbtypes.FilterOperatorEqual, value, getTypes)
+		require.NoError(t, err)
+		require.Len(t, plans, 1)
+
+		expectedYAML := `
+- name: education
+  column: body_json
+  availableTypes:
+    - Array(JSON)
+  maxDynamicTypes: 16
+  branches:
+    json:
+      name: awards
+      availableTypes:
+        - Array(Dynamic)
+        - Array(JSON)
+      maxDynamicTypes: 8
+      branches:
+        json:
+          name: type
+          availableTypes:
+            - String
+          maxDynamicTypes: 4
+          isTerminal: true
+          elemType: String
+          valueType: String
+        dynamic:
+          name: type
+          availableTypes:
+            - String
+          maxDynamicTypes: 16
+          maxDynamicPaths: 256
+          isTerminal: true
+          elemType: String
+          valueType: String
+`
+		got := plansToYAML(t, plans)
+		require.YAMLEq(t, expectedYAML, got)
+	})
+
+	t.Run("Promoted plan", func(t *testing.T) {
+		key := makeKey(path, telemetrytypes.String, true)
+		plans, err := PlanJSON(context.Background(), key, qbtypes.FilterOperatorEqual, value, getTypes)
+		require.NoError(t, err)
+		require.Len(t, plans, 2)
+
+		expectedYAML := `
+- name: education
+  column: body_json
+  availableTypes:
+    - Array(JSON)
+  maxDynamicTypes: 16
+  branches:
+    json:
+      name: awards
+      availableTypes:
+        - Array(Dynamic)
+        - Array(JSON)
+      maxDynamicTypes: 8
+      branches:
+        json:
+          name: type
+          availableTypes:
+            - String
+          maxDynamicTypes: 4
+          isTerminal: true
+          elemType: String
+          valueType: String
+        dynamic:
+          name: type
+          availableTypes:
+            - String
+          maxDynamicTypes: 16
+          maxDynamicPaths: 256
+          isTerminal: true
+          elemType: String
+          valueType: String
+- name: education
+  column: body_json_promoted
+  availableTypes:
+    - Array(JSON)
+  maxDynamicTypes: 16
+  maxDynamicPaths: 256
+  branches:
+    json:
+      name: awards
+      availableTypes:
+        - Array(Dynamic)
+        - Array(JSON)
+      maxDynamicTypes: 8
+      maxDynamicPaths: 64
+      branches:
+        json:
+          name: type
+          availableTypes:
+            - String
+          maxDynamicTypes: 4
+          maxDynamicPaths: 16
+          isTerminal: true
+          elemType: String
+          valueType: String
+        dynamic:
+          name: type
+          availableTypes:
+            - String
+          maxDynamicTypes: 16
+          maxDynamicPaths: 256
+          isTerminal: true
+          elemType: String
+          valueType: String
+`
+		got := plansToYAML(t, plans)
+		require.YAMLEq(t, expectedYAML, got)
+	})
+}
+
+func TestPlanJSON_EdgeCases(t *testing.T) {
+	_, getTypes := testTypeSet()
+
+	tests := []struct {
+		name         string
+		path         string
+		value        any
+		expectedYAML string
+	}{
+		{
+			name:  "Path with no available types",
+			path:  "unknown.path",
+			value: "test",
+			expectedYAML: `
+- name: unknown.path
+  column: body_json
+  maxDynamicTypes: 16
+  isTerminal: true
+  elemType: String
+  valueType: String
+`,
+		},
+		{
+			name:  "Very deep nesting - validates progression doesn't go negative",
+			path:  "interests[].entities[].reviews[].entries[].metadata[].positions[].name",
+			value: "Engineer",
+			expectedYAML: `
+- name: interests
+  column: body_json
+  availableTypes:
+    - Array(JSON)
+  maxDynamicTypes: 16
+  branches:
+    json:
+      name: entities
+      availableTypes:
+        - Array(JSON)
+      maxDynamicTypes: 8
+      branches:
+        json:
+          name: reviews
+          availableTypes:
+            - Array(JSON)
+          maxDynamicTypes: 4
+          branches:
+            json:
+              name: entries
+              availableTypes:
+                - Array(JSON)
+              maxDynamicTypes: 2
+              branches:
+                json:
+                  name: metadata
+                  availableTypes:
+                    - Array(JSON)
+                  maxDynamicTypes: 1
+                  branches:
+                    json:
+                      name: positions
+                      availableTypes:
+                        - Array(JSON)
+                      branches:
+                        json:
+                          name: name
+                          availableTypes:
+                            - String
+                          isTerminal: true
+                          elemType: String
+                          valueType: String
+`,
+		},
+		{
+			name:  "Path with mixed scalar and array types",
+			path:  "education[].type",
+			value: "high_school",
+			expectedYAML: `
+- name: education
+  column: body_json
+  availableTypes:
+    - Array(JSON)
+  maxDynamicTypes: 16
+  branches:
+    json:
+      name: type
+      availableTypes:
+        - String
+        - Int64
+      maxDynamicTypes: 8
+      isTerminal: true
+      elemType: String
+      valueType: String
+`,
+		},
+		{
+			name:  "Exists with only array types available",
+			path:  "education",
+			value: nil,
+			expectedYAML: `
+- name: education
+  column: body_json
+  availableTypes:
+    - Array(JSON)
+  maxDynamicTypes: 16
+  isTerminal: true
+  elemType: Array(JSON)
+`,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			// Choose key type based on path; operator does not affect the tree shape asserted here.
+			keyType := telemetrytypes.String
+			switch tt.path {
+			case "education":
+				keyType = telemetrytypes.ArrayJSON
+			case "education[].type":
+				keyType = telemetrytypes.String
+			}
+			key := makeKey(tt.path, keyType, false)
+			plans, err := PlanJSON(context.Background(), key, qbtypes.FilterOperatorEqual, tt.value, getTypes)
+			require.NoError(t, err)
+			got := plansToYAML(t, plans)
+			require.YAMLEq(t, tt.expectedYAML, got)
+		})
+	}
+}
+
+func TestPlanJSON_TreeStructure(t *testing.T) {
+	_, getTypes := testTypeSet()
+	path := "education[].awards[].participated[].team[].branch"
+	key := makeKey(path, telemetrytypes.String, false)
+	plans, err := PlanJSON(context.Background(), key, qbtypes.FilterOperatorEqual, "John", getTypes)
+	require.NoError(t, err)
+	require.Len(t, plans, 1)
+
+	expectedYAML := `
+- name: education
+  column: body_json
+  availableTypes:
+    - Array(JSON)
+  maxDynamicTypes: 16
+  branches:
+    json:
+      name: awards
+      availableTypes:
+        - Array(Dynamic)
+        - Array(JSON)
+      maxDynamicTypes: 8
+      branches:
+        json:
+          name: participated
+          availableTypes:
+            - Array(Dynamic)
+            - Array(JSON)
+          maxDynamicTypes: 4
+          branches:
+            json:
+              name: team
+              availableTypes:
+                - Array(JSON)
+              maxDynamicTypes: 2
+              branches:
+                json:
+                  name: branch
+                  availableTypes:
+                    - String
+                  maxDynamicTypes: 1
+                  isTerminal: true
+                  elemType: String
+                  valueType: String
+            dynamic:
+              name: team
+              availableTypes:
+                - Array(JSON)
+              maxDynamicTypes: 16
+              maxDynamicPaths: 256
+              branches:
+                json:
+                  name: branch
+                  availableTypes:
+                    - String
+                  maxDynamicTypes: 8
+                  maxDynamicPaths: 64
+                  isTerminal: true
+                  elemType: String
+                  valueType: String
+        dynamic:
+          name: participated
+          availableTypes:
+            - Array(Dynamic)
+            - Array(JSON)
+          maxDynamicTypes: 16
+          maxDynamicPaths: 256
+          branches:
+            json:
+              name: team
+              availableTypes:
+                - Array(JSON)
+              maxDynamicTypes: 8
+              maxDynamicPaths: 64
+              branches:
+                json:
+                  name: branch
+                  availableTypes:
+                    - String
+                  maxDynamicTypes: 4
+                  maxDynamicPaths: 16
+                  isTerminal: true
+                  elemType: String
+                  valueType: String
+            dynamic:
+              name: team
+              availableTypes:
+                - Array(JSON)
+              maxDynamicTypes: 16
+              maxDynamicPaths: 256
+              branches:
+                json:
+                  name: branch
+                  availableTypes:
+                    - String
+                  maxDynamicTypes: 8
+                  maxDynamicPaths: 64
+                  isTerminal: true
+                  elemType: String
+                  valueType: String
+`
+
+	got := plansToYAML(t, plans)
+	require.YAMLEq(t, expectedYAML, got)
+}
+
+// ============================================================================
+// Test Data Setup
+// ============================================================================
+
+// testTypeSet returns a map of path->types and a getTypes function for testing
+// This represents the type information available in the test JSON structure
+//
+// TODO(Piyush): Remove this unparam nolint
+// nolint:unparam
+func testTypeSet() (map[string][]telemetrytypes.JSONDataType, func(ctx context.Context, path string) ([]telemetrytypes.JSONDataType, error)) {
+	types := map[string][]telemetrytypes.JSONDataType{
+		"user.name":                                           {telemetrytypes.String},
+		"user.age":                                            {telemetrytypes.Int64, telemetrytypes.String},
+		"user.height":                                         {telemetrytypes.Float64},
+		"education":                                           {telemetrytypes.ArrayJSON},
+		"education[].name":                                    {telemetrytypes.String},
+		"education[].type":                                    {telemetrytypes.String, telemetrytypes.Int64},
+		"education[].internal_type":                           {telemetrytypes.String},
+		"education[].metadata.location":                       {telemetrytypes.String},
+		"education[].parameters":                              {telemetrytypes.ArrayFloat64, telemetrytypes.ArrayDynamic},
+		"education[].duration":                                {telemetrytypes.String},
+		"education[].mode":                                    {telemetrytypes.String},
+		"education[].year":                                    {telemetrytypes.Int64},
+		"education[].field":                                   {telemetrytypes.String},
+		"education[].awards":                                  {telemetrytypes.ArrayDynamic, telemetrytypes.ArrayJSON},
+		"education[].awards[].name":                           {telemetrytypes.String},
+		"education[].awards[].rank":                           {telemetrytypes.Int64},
+		"education[].awards[].medal":                          {telemetrytypes.String},
+		"education[].awards[].type":                           {telemetrytypes.String},
+		"education[].awards[].semester":                       {telemetrytypes.Int64},
+		"education[].awards[].participated":                   {telemetrytypes.ArrayDynamic, telemetrytypes.ArrayJSON},
+		"education[].awards[].participated[].type":            {telemetrytypes.String},
+		"education[].awards[].participated[].field":           {telemetrytypes.String},
+		"education[].awards[].participated[].project_type":    {telemetrytypes.String},
+		"education[].awards[].participated[].project_name":    {telemetrytypes.String},
+		"education[].awards[].participated[].race_type":       {telemetrytypes.String},
+		"education[].awards[].participated[].team_based":      {telemetrytypes.Bool},
+		"education[].awards[].participated[].team_name":       {telemetrytypes.String},
+		"education[].awards[].participated[].team":            {telemetrytypes.ArrayJSON},
+		"education[].awards[].participated[].team[].name":     {telemetrytypes.String},
+		"education[].awards[].participated[].team[].branch":   {telemetrytypes.String},
+		"education[].awards[].participated[].team[].semester": {telemetrytypes.Int64},
+		"interests":                                                                  {telemetrytypes.ArrayJSON},
+		"interests[].type":                                                           {telemetrytypes.String},
+		"interests[].entities":                                                       {telemetrytypes.ArrayJSON},
+		"interests[].entities.application_date":                                      {telemetrytypes.String},
+		"interests[].entities[].reviews":                                             {telemetrytypes.ArrayJSON},
+		"interests[].entities[].reviews[].given_by":                                  {telemetrytypes.String},
+		"interests[].entities[].reviews[].remarks":                                   {telemetrytypes.String},
+		"interests[].entities[].reviews[].weight":                                    {telemetrytypes.Float64},
+		"interests[].entities[].reviews[].passed":                                    {telemetrytypes.Bool},
+		"interests[].entities[].reviews[].type":                                      {telemetrytypes.String},
+		"interests[].entities[].reviews[].analysis_type":                             {telemetrytypes.Int64},
+		"interests[].entities[].reviews[].entries":                                   {telemetrytypes.ArrayJSON},
+		"interests[].entities[].reviews[].entries[].subject":                         {telemetrytypes.String},
+		"interests[].entities[].reviews[].entries[].status":                          {telemetrytypes.String},
+		"interests[].entities[].reviews[].entries[].metadata":                        {telemetrytypes.ArrayJSON},
+		"interests[].entities[].reviews[].entries[].metadata[].company":              {telemetrytypes.String},
+		"interests[].entities[].reviews[].entries[].metadata[].experience":           {telemetrytypes.Int64},
+		"interests[].entities[].reviews[].entries[].metadata[].unit":                 {telemetrytypes.String},
+		"interests[].entities[].reviews[].entries[].metadata[].positions":            {telemetrytypes.ArrayJSON},
+		"interests[].entities[].reviews[].entries[].metadata[].positions[].name":     {telemetrytypes.String},
+		"interests[].entities[].reviews[].entries[].metadata[].positions[].duration": {telemetrytypes.Int64, telemetrytypes.Float64},
+		"interests[].entities[].reviews[].entries[].metadata[].positions[].unit":     {telemetrytypes.String},
+		"interests[].entities[].reviews[].entries[].metadata[].positions[].ratings":  {telemetrytypes.ArrayInt64, telemetrytypes.ArrayString},
+		"message": {telemetrytypes.String},
+	}
+
+	return types, makeGetTypes(types)
+}

pkg/telemetrymetadata/body_json_metadata.go

@@ -7,7 +7,6 @@ import (
 	"strings"
 	"time"
 
-	"github.com/ClickHouse/clickhouse-go/v2"
 	"github.com/ClickHouse/clickhouse-go/v2/lib/chcol"
 	schemamigrator "github.com/SigNoz/signoz-otel-collector/cmd/signozschemamigrator/schema_migrator"
 	"github.com/SigNoz/signoz-otel-collector/constants"
@@ -15,7 +14,6 @@ import (
 	"github.com/SigNoz/signoz/pkg/errors"
 	"github.com/SigNoz/signoz/pkg/querybuilder"
 	"github.com/SigNoz/signoz/pkg/telemetrylogs"
-	"github.com/SigNoz/signoz/pkg/telemetrystore"
 	"github.com/SigNoz/signoz/pkg/types/telemetrytypes"
 	"github.com/huandu/go-sqlbuilder"
 )
@@ -34,6 +32,10 @@ var (
 	CodeFailScanVariant         = errors.MustNewCode("fail_scan_variant")
 	CodeFailBuildJSONPathsQuery = errors.MustNewCode("fail_build_json_paths_query")
 	CodeNoPathsToQueryIndexes   = errors.MustNewCode("no_paths_to_query_indexes_provided")
+
+	CodeFailedToPrepareBatch = errors.MustNewCode("failed_to_prepare_batch_promoted_paths")
+	CodeFailedToSendBatch    = errors.MustNewCode("failed_to_send_batch_promoted_paths")
+	CodeFailedToAppendPath   = errors.MustNewCode("failed_to_append_path_promoted_paths")
 )
 
 // GetBodyJSONPaths extracts body JSON paths from the path_types table
@@ -48,7 +50,7 @@ var (
 // TODO(Piyush): Remove this lint skip
 //
 // nolint:unused
-func getBodyJSONPaths(ctx context.Context, telemetryStore telemetrystore.TelemetryStore,
+func (t *telemetryMetaStore) getBodyJSONPaths(ctx context.Context,
 	fieldKeySelectors []*telemetrytypes.FieldKeySelector) ([]*telemetrytypes.TelemetryFieldKey, bool, error) {
 
 	query, args, limit, err := buildGetBodyJSONPathsQuery(fieldKeySelectors)
@@ -56,7 +58,7 @@ func getBodyJSONPaths(ctx context.Context, telemetryStore telemetrystore.Telemet
 		return nil, false, err
 	}
 
-	rows, err := telemetryStore.ClickhouseDB().Query(ctx, query, args...)
+	rows, err := t.telemetrystore.ClickhouseDB().Query(ctx, query, args...)
 	if err != nil {
 		return nil, false, errors.WrapInternalf(err, CodeFailExtractBodyJSONKeys, "failed to extract body JSON keys")
 	}
@@ -96,12 +98,12 @@ func getBodyJSONPaths(ctx context.Context, telemetryStore telemetrystore.Telemet
 		return nil, false, errors.WrapInternalf(rows.Err(), CodeFailIterateBodyJSONKeys, "error iterating body JSON keys")
 	}
 
-	promoted, err := GetPromotedPaths(ctx, telemetryStore.ClickhouseDB(), paths...)
+	promoted, err := t.GetPromotedPaths(ctx, paths...)
 	if err != nil {
 		return nil, false, err
 	}
 
-	indexes, err := getJSONPathIndexes(ctx, telemetryStore, paths...)
+	indexes, err := t.getJSONPathIndexes(ctx, paths...)
 	if err != nil {
 		return nil, false, err
 	}
@@ -163,7 +165,7 @@ func buildGetBodyJSONPathsQuery(fieldKeySelectors []*telemetrytypes.FieldKeySele
 // TODO(Piyush): Remove this lint skip
 //
 // nolint:unused
-func getJSONPathIndexes(ctx context.Context, telemetryStore telemetrystore.TelemetryStore, paths ...string) (map[string][]telemetrytypes.JSONDataTypeIndex, error) {
+func (t *telemetryMetaStore) getJSONPathIndexes(ctx context.Context, paths ...string) (map[string][]telemetrytypes.JSONDataTypeIndex, error) {
 	filteredPaths := []string{}
 	for _, path := range paths {
 		if strings.Contains(path, telemetrylogs.ArraySep) || strings.Contains(path, telemetrylogs.ArrayAnyIndex) {
@@ -176,7 +178,7 @@ func getJSONPathIndexes(ctx context.Context, telemetryStore telemetrystore.Telem
 	}
 
 	// list indexes for the paths
-	indexesMap, err := ListLogsJSONIndexes(ctx, telemetryStore, filteredPaths...)
+	indexesMap, err := t.ListLogsJSONIndexes(ctx, filteredPaths...)
 	if err != nil {
 		return nil, errors.WrapInternalf(err, CodeFailLoadLogsJSONIndexes, "failed to list JSON path indexes")
 	}
@@ -215,7 +217,6 @@ func getJSONPathIndexes(ctx context.Context, telemetryStore telemetrystore.Telem
 }
 
 func buildListLogsJSONIndexesQuery(cluster string, filters ...string) (string, []any) {
-	// This aggregates all types per path and gets the max last_seen, then applies LIMIT
 	sb := sqlbuilder.Select(
 		"name", "type_full", "expr", "granularity",
 	).From(fmt.Sprintf("clusterAllReplicas('%s', %s)", cluster, SkipIndexTableName))
@@ -236,15 +237,15 @@ func buildListLogsJSONIndexesQuery(cluster string, filters ...string) (string, [
 	return sb.BuildWithFlavor(sqlbuilder.ClickHouse)
 }
 
-func ListLogsJSONIndexes(ctx context.Context, telemetryStore telemetrystore.TelemetryStore, filters ...string) (map[string][]schemamigrator.Index, error) {
-	query, args := buildListLogsJSONIndexesQuery(telemetryStore.Cluster(), filters...)
-	rows, err := telemetryStore.ClickhouseDB().Query(ctx, query, args...)
+func (t *telemetryMetaStore) ListLogsJSONIndexes(ctx context.Context, filters ...string) (map[string][]schemamigrator.Index, error) {
+	query, args := buildListLogsJSONIndexesQuery(t.telemetrystore.Cluster(), filters...)
+	rows, err := t.telemetrystore.ClickhouseDB().Query(ctx, query, args...)
 	if err != nil {
 		return nil, errors.WrapInternalf(err, CodeFailLoadLogsJSONIndexes, "failed to load string indexed columns")
 	}
 	defer rows.Close()
 
-	indexesMap := make(map[string][]schemamigrator.Index)
+	indexes := make(map[string][]schemamigrator.Index)
 	for rows.Next() {
 		var name string
 		var typeFull string
@@ -253,7 +254,7 @@ func ListLogsJSONIndexes(ctx context.Context, telemetryStore telemetrystore.Tele
 		if err := rows.Scan(&name, &typeFull, &expr, &granularity); err != nil {
 			return nil, errors.WrapInternalf(err, CodeFailLoadLogsJSONIndexes, "failed to scan string indexed column")
 		}
-		indexesMap[name] = append(indexesMap[name], schemamigrator.Index{
+		indexes[name] = append(indexes[name], schemamigrator.Index{
 			Name:        name,
 			Type:        typeFull,
 			Expression:  expr,
@@ -261,12 +262,19 @@ func ListLogsJSONIndexes(ctx context.Context, telemetryStore telemetrystore.Tele
 		})
 	}
 
-	return indexesMap, nil
+	return indexes, nil
 }
 
-func ListPromotedPaths(ctx context.Context, conn clickhouse.Conn) (map[string]struct{}, error) {
-	query := fmt.Sprintf("SELECT path FROM %s.%s", DBName, PromotedPathsTableName)
-	rows, err := conn.Query(ctx, query)
+func (t *telemetryMetaStore) ListPromotedPaths(ctx context.Context, paths ...string) (map[string]struct{}, error) {
+	sb := sqlbuilder.Select("path").From(fmt.Sprintf("%s.%s", DBName, PromotedPathsTableName))
+	pathConditions := []string{}
+	for _, path := range paths {
+		pathConditions = append(pathConditions, sb.Equal("path", path))
+	}
+	sb.Where(sb.Or(pathConditions...))
+	query, args := sb.BuildWithFlavor(sqlbuilder.ClickHouse)
+
+	rows, err := t.telemetrystore.ClickhouseDB().Query(ctx, query, args...)
 	if err != nil {
 		return nil, errors.WrapInternalf(err, CodeFailLoadPromotedPaths, "failed to load promoted paths")
 	}
@@ -285,14 +293,14 @@ func ListPromotedPaths(ctx context.Context, conn clickhouse.Conn) (map[string]st
 }
 
 // TODO(Piyush): Remove this if not used in future
-func ListJSONValues(ctx context.Context, conn clickhouse.Conn, path string, limit int) (*telemetrytypes.TelemetryFieldValues, bool, error) {
+func (t *telemetryMetaStore) ListJSONValues(ctx context.Context, path string, limit int) (*telemetrytypes.TelemetryFieldValues, bool, error) {
 	path = CleanPathPrefixes(path)
 
 	if strings.Contains(path, telemetrylogs.ArraySep) || strings.Contains(path, telemetrylogs.ArrayAnyIndex) {
 		return nil, false, errors.NewInvalidInputf(errors.CodeInvalidInput, "array paths are not supported")
 	}
 
-	promoted, err := IsPathPromoted(ctx, conn, path)
+	promoted, err := t.IsPathPromoted(ctx, path)
 	if err != nil {
 		return nil, false, err
 	}
@@ -325,7 +333,7 @@ func ListJSONValues(ctx context.Context, conn clickhouse.Conn, path string, limi
 	contextWithTimeout, cancel := context.WithTimeout(ctx, 5*time.Second)
 	defer cancel()
 	query, args := sb.BuildWithFlavor(sqlbuilder.ClickHouse)
-	rows, err := conn.Query(contextWithTimeout, query, args...)
+	rows, err := t.telemetrystore.ClickhouseDB().Query(contextWithTimeout, query, args...)
 	if err != nil {
 		if errors.Is(err, context.DeadlineExceeded) {
 			return nil, false, errors.WrapTimeoutf(err, errors.CodeTimeout, "query timed out").WithAdditional("failed to list JSON values")
@@ -447,10 +455,10 @@ func derefValue(v any) any {
 }
 
 // IsPathPromoted checks if a specific path is promoted
-func IsPathPromoted(ctx context.Context, conn clickhouse.Conn, path string) (bool, error) {
+func (t *telemetryMetaStore) IsPathPromoted(ctx context.Context, path string) (bool, error) {
 	split := strings.Split(path, telemetrylogs.ArraySep)
 	query := fmt.Sprintf("SELECT 1 FROM %s.%s WHERE path = ? LIMIT 1", DBName, PromotedPathsTableName)
-	rows, err := conn.Query(ctx, query, split[0])
+	rows, err := t.telemetrystore.ClickhouseDB().Query(ctx, query, split[0])
 	if err != nil {
 		return false, errors.WrapInternalf(err, CodeFailCheckPathPromoted, "failed to check if path %s is promoted", path)
 	}
@@ -460,7 +468,7 @@ func IsPathPromoted(ctx context.Context, conn clickhouse.Conn, path string) (boo
 }
 
 // GetPromotedPaths checks if a specific path is promoted
-func GetPromotedPaths(ctx context.Context, conn clickhouse.Conn, paths ...string) (*utils.ConcurrentSet[string], error) {
+func (t *telemetryMetaStore) GetPromotedPaths(ctx context.Context, paths ...string) (*utils.ConcurrentSet[string], error) {
 	sb := sqlbuilder.Select("path").From(fmt.Sprintf("%s.%s", DBName, PromotedPathsTableName))
 	pathConditions := []string{}
 	for _, path := range paths {
@@ -469,7 +477,7 @@ func GetPromotedPaths(ctx context.Context, conn clickhouse.Conn, paths ...string
 	sb.Where(sb.Or(pathConditions...))
 
 	query, args := sb.BuildWithFlavor(sqlbuilder.ClickHouse)
-	rows, err := conn.Query(ctx, query, args...)
+	rows, err := t.telemetrystore.ClickhouseDB().Query(ctx, query, args...)
 	if err != nil {
 		return nil, errors.WrapInternalf(err, CodeFailCheckPathPromoted, "failed to get promoted paths")
 	}
@@ -494,3 +502,29 @@ func CleanPathPrefixes(path string) string {
 	path = strings.TrimPrefix(path, telemetrylogs.BodyPromotedColumnPrefix)
 	return path
 }
+
+func (t *telemetryMetaStore) PromotePaths(ctx context.Context, paths ...string) error {
+	batch, err := t.telemetrystore.ClickhouseDB().PrepareBatch(ctx,
+		fmt.Sprintf("INSERT INTO %s.%s (path, created_at) VALUES", DBName,
+			PromotedPathsTableName))
+	if err != nil {
+		return errors.WrapInternalf(err, CodeFailedToPrepareBatch, "failed to prepare batch")
+	}
+
+	nowMs := uint64(time.Now().UnixMilli())
+	for _, p := range paths {
+		trimmed := strings.TrimSpace(p)
+		if trimmed == "" {
+			continue
+		}
+		if err := batch.Append(trimmed, nowMs); err != nil {
+			_ = batch.Abort()
+			return errors.WrapInternalf(err, CodeFailedToAppendPath, "failed to append path")
+		}
+	}
+
+	if err := batch.Send(); err != nil {
+		return errors.WrapInternalf(err, CodeFailedToSendBatch, "failed to send batch")
+	}
+	return nil
+}

pkg/types/dashboardtypes/dashboard.go

@@ -349,7 +349,7 @@ func (dashboard *Dashboard) GetWidgetQuery(startTime, endTime uint64, widgetInde
 		return nil, errors.Wrapf(err, errors.TypeInvalidInput, ErrCodeDashboardInvalidData, "invalid dashboard data")
 	}
 
-	if len(data.Widgets) < int(widgetIndex)+1 {
+	if widgetIndex < 0 || int(widgetIndex) >= len(data.Widgets) {
 		return nil, errors.Newf(errors.TypeInvalidInput, ErrCodeDashboardInvalidInput, "widget with index %v doesn't exist", widgetIndex)
 	}
 

pkg/types/promotetypes/types.go

@@ -0,0 +1,76 @@
+package promotetypes
+
+import (
+	"strings"
+
+	"github.com/SigNoz/signoz-otel-collector/constants"
+	"github.com/SigNoz/signoz-otel-collector/pkg/keycheck"
+	"github.com/SigNoz/signoz/pkg/errors"
+	"github.com/SigNoz/signoz/pkg/telemetrylogs"
+	"github.com/SigNoz/signoz/pkg/types/telemetrytypes"
+)
+
+type WrappedIndex struct {
+	JSONDataType telemetrytypes.JSONDataType `json:"-"`
+	ColumnType   string                      `json:"column_type"`
+	Type         string                      `json:"type"`
+	Granularity  int                         `json:"granularity"`
+}
+
+type PromotePath struct {
+	Path    string `json:"path"`
+	Promote bool   `json:"promote,omitempty"`
+
+	Indexes []WrappedIndex `json:"indexes,omitempty"`
+}
+
+func (i *PromotePath) ValidateAndSetDefaults() error {
+	if i.Path == "" {
+		return errors.Newf(errors.TypeInvalidInput, errors.CodeInvalidInput, "path is required")
+	}
+
+	if strings.Contains(i.Path, " ") {
+		return errors.Newf(errors.TypeInvalidInput, errors.CodeInvalidInput, "path cannot contain spaces")
+	}
+
+	if strings.Contains(i.Path, telemetrylogs.ArraySep) || strings.Contains(i.Path, telemetrylogs.ArrayAnyIndex) {
+		return errors.Newf(errors.TypeInvalidInput, errors.CodeInvalidInput, "array paths can not be promoted or indexed")
+	}
+
+	if strings.HasPrefix(i.Path, constants.BodyJSONColumnPrefix) || strings.HasPrefix(i.Path, constants.BodyPromotedColumnPrefix) {
+		return errors.Newf(errors.TypeInvalidInput, errors.CodeInvalidInput, "`%s`, `%s` don't add these prefixes to the path", constants.BodyJSONColumnPrefix, constants.BodyPromotedColumnPrefix)
+	}
+
+	if !strings.HasPrefix(i.Path, telemetrylogs.BodyJSONStringSearchPrefix) {
+		return errors.Newf(errors.TypeInvalidInput, errors.CodeInvalidInput, "path must start with `body.`")
+	}
+
+	// remove the "body." prefix from the path
+	i.Path = strings.TrimPrefix(i.Path, telemetrylogs.BodyJSONStringSearchPrefix)
+
+	isCardinal := keycheck.IsCardinal(i.Path)
+	if isCardinal {
+		return errors.Newf(errors.TypeInvalidInput, errors.CodeInvalidInput, "cardinal paths can not be promoted or indexed")
+	}
+
+	for idx, index := range i.Indexes {
+		if index.Type == "" {
+			return errors.Newf(errors.TypeInvalidInput, errors.CodeInvalidInput, "index type is required")
+		}
+		if index.Granularity <= 0 {
+			return errors.Newf(errors.TypeInvalidInput, errors.CodeInvalidInput, "index granularity must be greater than 0")
+		}
+
+		jsonDataType, ok := telemetrytypes.MappingStringToJSONDataType[index.ColumnType]
+		if !ok {
+			return errors.Newf(errors.TypeInvalidInput, errors.CodeInvalidInput, "invalid column type: %s", index.ColumnType)
+		}
+		if !jsonDataType.IndexSupported {
+			return errors.Newf(errors.TypeInvalidInput, errors.CodeInvalidInput, "index is not supported for column type: %s", index.ColumnType)
+		}
+
+		i.Indexes[idx].JSONDataType = jsonDataType
+	}
+
+	return nil
+}

pkg/types/ruletypes/threshold.go

@@ -63,11 +63,6 @@ type EvalData struct {
 	// used to check if a sample is part of an active alert
 	// when evaluating the recovery threshold.
 	ActiveAlerts map[uint64]struct{}
-
-	// SendUnmatched is a flag to return samples
-	// even if they don't match the rule condition.
-	// This is useful in testing the rule.
-	SendUnmatched bool
 }
 
 // HasActiveAlert checks if the given sample figerprint is active
@@ -136,24 +131,6 @@ func (r BasicRuleThresholds) Eval(series v3.Series, unit string, evalData EvalDa
 			smpl.TargetUnit = threshold.TargetUnit
 			resultVector = append(resultVector, smpl)
 			continue
-		} else if evalData.SendUnmatched {
-			// Sanitise the series points to remove any NaN or Inf values
-			series.Points = removeGroupinSetPoints(series)
-			if len(series.Points) == 0 {
-				continue
-			}
-			// prepare the sample with the first point of the series
-			smpl := Sample{
-				Point:      Point{T: series.Points[0].Timestamp, V: series.Points[0].Value},
-				Metric:     PrepareSampleLabelsForRule(series.Labels, threshold.Name),
-				Target:     *threshold.TargetValue,
-				TargetUnit: threshold.TargetUnit,
-			}
-			if threshold.RecoveryTarget != nil {
-				smpl.RecoveryTarget = threshold.RecoveryTarget
-			}
-			resultVector = append(resultVector, smpl)
-			continue
 		}
 
 		// Prepare alert hash from series labels and threshold name if recovery target option was provided

pkg/types/telemetrytypes/json_access_plan.go

@@ -0,0 +1,82 @@
+package telemetrytypes
+
+import (
+	"fmt"
+	"strings"
+
+	"github.com/SigNoz/signoz-otel-collector/exporter/jsontypeexporter"
+	"github.com/SigNoz/signoz/pkg/valuer"
+)
+
+type JSONAccessBranchType struct {
+	valuer.String
+}
+
+var (
+	BranchJSON    = JSONAccessBranchType{valuer.NewString("json")}
+	BranchDynamic = JSONAccessBranchType{valuer.NewString("dynamic")}
+)
+
+type JSONAccessPlan = []*JSONAccessNode
+
+type TerminalConfig struct {
+	Key       *TelemetryFieldKey
+	ElemType  JSONDataType
+	ValueType JSONDataType
+}
+
+// Node is now a tree structure representing the complete JSON path traversal
+// that precomputes all possible branches and their types
+type JSONAccessNode struct {
+	// Node information
+	Name       string
+	IsTerminal bool
+	isRoot     bool // marked true for only body_json and body_json_promoted
+
+	// Precomputed type information (single source of truth)
+	AvailableTypes []JSONDataType
+
+	// Array type branches (Array(JSON) vs Array(Dynamic))
+	Branches map[JSONAccessBranchType]*JSONAccessNode
+
+	// Terminal configuration
+	TerminalConfig *TerminalConfig
+
+	// Parent reference for traversal
+	Parent *JSONAccessNode
+
+	// JSON progression parameters (precomputed during planning)
+	MaxDynamicTypes int
+	MaxDynamicPaths int
+}
+
+func NewRootJSONAccessNode(name string, maxDynamicTypes, maxDynamicPaths int) *JSONAccessNode {
+	return &JSONAccessNode{
+		Name:            name,
+		isRoot:          true,
+		MaxDynamicTypes: maxDynamicTypes,
+		MaxDynamicPaths: maxDynamicPaths,
+	}
+}
+
+func (n *JSONAccessNode) Alias() string {
+	if n.isRoot {
+		return n.Name
+	} else if n.Parent == nil {
+		return fmt.Sprintf("`%s`", n.Name)
+	}
+
+	parentAlias := strings.TrimLeft(n.Parent.Alias(), "`")
+	parentAlias = strings.TrimRight(parentAlias, "`")
+
+	sep := jsontypeexporter.ArraySeparator
+	if n.Parent.isRoot {
+		sep = "."
+	}
+	return fmt.Sprintf("`%s%s%s`", parentAlias, sep, n.Name)
+}
+
+func (n *JSONAccessNode) FieldPath() string {
+	key := "`" + n.Name + "`"
+	return n.Parent.Alias() + "." + key
+}

pkg/types/telemetrytypes/store.go

@@ -3,6 +3,7 @@ package telemetrytypes
 import (
 	"context"
 
+	schemamigrator "github.com/SigNoz/signoz-otel-collector/cmd/signozschemamigrator/schema_migrator"
 	"github.com/SigNoz/signoz/pkg/types/metrictypes"
 )
 
@@ -30,4 +31,13 @@ type MetadataStore interface {
 
 	// FetchTemporalityMulti fetches the temporality for multiple metrics
 	FetchTemporalityMulti(ctx context.Context, metricNames ...string) (map[string]metrictypes.Temporality, error)
+
+	// ListLogsJSONIndexes lists the JSON indexes for the logs table.
+	ListLogsJSONIndexes(ctx context.Context, filters ...string) (map[string][]schemamigrator.Index, error)
+
+	// ListPromotedPaths lists the promoted paths.
+	ListPromotedPaths(ctx context.Context, paths ...string) (map[string]struct{}, error)
+
+	// PromotePaths promotes the paths.
+	PromotePaths(ctx context.Context, paths ...string) error
 }

pkg/types/telemetrytypes/telemetrytypestest/metadata_store.go

@@ -4,6 +4,7 @@ import (
 	"context"
 	"strings"
 
+	schemamigrator "github.com/SigNoz/signoz-otel-collector/cmd/signozschemamigrator/schema_migrator"
 	"github.com/SigNoz/signoz/pkg/types/metrictypes"
 	"github.com/SigNoz/signoz/pkg/types/telemetrytypes"
 )
@@ -11,19 +12,23 @@ import (
 // MockMetadataStore implements the MetadataStore interface for testing purposes
 type MockMetadataStore struct {
 	// Maps to store test data
-	KeysMap          map[string][]*telemetrytypes.TelemetryFieldKey
-	RelatedValuesMap map[string][]string
-	AllValuesMap     map[string]*telemetrytypes.TelemetryFieldValues
-	TemporalityMap   map[string]metrictypes.Temporality
+	KeysMap            map[string][]*telemetrytypes.TelemetryFieldKey
+	RelatedValuesMap   map[string][]string
+	AllValuesMap       map[string]*telemetrytypes.TelemetryFieldValues
+	TemporalityMap     map[string]metrictypes.Temporality
+	PromotedPathsMap   map[string]struct{}
+	LogsJSONIndexesMap map[string][]schemamigrator.Index
 }
 
 // NewMockMetadataStore creates a new instance of MockMetadataStore with initialized maps
 func NewMockMetadataStore() *MockMetadataStore {
 	return &MockMetadataStore{
-		KeysMap:          make(map[string][]*telemetrytypes.TelemetryFieldKey),
-		RelatedValuesMap: make(map[string][]string),
-		AllValuesMap:     make(map[string]*telemetrytypes.TelemetryFieldValues),
-		TemporalityMap:   make(map[string]metrictypes.Temporality),
+		KeysMap:            make(map[string][]*telemetrytypes.TelemetryFieldKey),
+		RelatedValuesMap:   make(map[string][]string),
+		AllValuesMap:       make(map[string]*telemetrytypes.TelemetryFieldValues),
+		TemporalityMap:     make(map[string]metrictypes.Temporality),
+		PromotedPathsMap:   make(map[string]struct{}),
+		LogsJSONIndexesMap: make(map[string][]schemamigrator.Index),
 	}
 }
 
@@ -284,3 +289,21 @@ func (m *MockMetadataStore) FetchTemporalityMulti(ctx context.Context, metricNam
 func (m *MockMetadataStore) SetTemporality(metricName string, temporality metrictypes.Temporality) {
 	m.TemporalityMap[metricName] = temporality
 }
+
+// PromotePaths promotes the paths.
+func (m *MockMetadataStore) PromotePaths(ctx context.Context, paths ...string) error {
+	for _, path := range paths {
+		m.PromotedPathsMap[path] = struct{}{}
+	}
+	return nil
+}
+
+// ListPromotedPaths lists the promoted paths.
+func (m *MockMetadataStore) ListPromotedPaths(ctx context.Context, paths ...string) (map[string]struct{}, error) {
+	return m.PromotedPathsMap, nil
+}
+
+// ListLogsJSONIndexes lists the JSON indexes for the logs table.
+func (m *MockMetadataStore) ListLogsJSONIndexes(ctx context.Context, filters ...string) (map[string][]schemamigrator.Index, error) {
+	return m.LogsJSONIndexesMap, nil
+}

tests/integration/src/dashboard/a_public_dashboard.py

@@ -101,3 +101,145 @@ def test_create_and_get_public_dashboard(
         )
         tuple_row = tuple_result.fetchone()
         assert tuple_row is not None
+
+
+def test_public_dashboard_widget_query_range(
+    signoz: SigNoz,
+    create_user_admin: Operation,  # pylint: disable=unused-argument
+    get_token: Callable[[str, str], str],
+):
+    admin_token = get_token(USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD)
+
+    dashboard_req = {
+        "title": "Test Widget Query Range Dashboard",
+        "description": "For testing widget query range",
+        "version": "v5",
+        "widgets": [
+            {
+                "id": "6990c9d8-57ad-492f-8c63-039081e30d02",
+                "panelTypes": "graph",
+                "query": {
+                    "builder": {
+                        "queryData": [
+                            {
+                                "aggregations": [
+                                    {
+                                        "metricName": "container.cpu.time",
+                                        "reduceTo": "avg",
+                                        "spaceAggregation": "sum",
+                                        "temporality": "",
+                                        "timeAggregation": "rate",
+                                    }
+                                ],
+                                "dataSource": "metrics",
+                                "disabled": False,
+                                "expression": "A",
+                                "filter": {
+                                    "expression": ""
+                                },
+                                "functions": [],
+                                "groupBy": [],
+                                "having": {
+                                    "expression": ""
+                                },
+                                "legend": "",
+                                "limit": 10,
+                                "orderBy": [],
+                                "queryName": "A",
+                                "source": "",
+                                "stepInterval": 10
+                            }
+                        ],
+                        "queryFormulas": [],
+                        "queryTraceOperator": []
+                    },
+                    "clickhouse_sql": [
+                        {
+                            "disabled": False,
+                            "legend": "",
+                            "name": "A",
+                            "query": ""
+                        }
+                    ],
+                    "id": "80f12506-ef72-4013-8282-2713c8114c9e",
+                    "promql": [
+                        {
+                            "disabled": False,
+                            "legend": "",
+                            "name": "A",
+                            "query": ""
+                        }
+                    ],
+                    "queryType": "builder"
+                },
+            }
+        ],
+    }
+    create_response = requests.post(
+        signoz.self.host_configs["8080"].get("/api/v1/dashboards"),
+        json=dashboard_req,
+        headers={"Authorization": f"Bearer {admin_token}"},
+        timeout=2,
+    )
+    assert create_response.status_code == HTTPStatus.CREATED
+    data = create_response.json()["data"]
+    dashboard_id = data["id"]
+
+
+    # create public dashboard
+    response = requests.post(
+        signoz.self.host_configs["8080"].get(
+            f"/api/v1/dashboards/{dashboard_id}/public"
+        ),
+        json={
+            "timeRangeEnabled": False,
+            "defaultTimeRange": "10s",
+        },
+        headers={"Authorization": f"Bearer {admin_token}"},
+        timeout=2,
+    )
+
+    assert response.status_code == HTTPStatus.CREATED
+    assert "id" in response.json()["data"]
+
+    response = requests.get(
+        signoz.self.host_configs["8080"].get(
+            f"/api/v1/dashboards/{dashboard_id}/public"
+        ),
+        headers={"Authorization": f"Bearer {admin_token}"},
+        timeout=2,
+    )
+
+    assert response.status_code == HTTPStatus.OK
+    assert response.json()["status"] == "success"
+    public_path = response.json()["data"]["publicPath"]
+    public_dashboard_id = public_path.split("/public/dashboard/")[-1] 
+
+    
+    
+    resp = requests.get(
+        signoz.self.host_configs["8080"].get(
+        f"/api/v1/public/dashboards/{public_dashboard_id}/widgets/0/query_range"
+        ),
+        timeout=2,
+    )
+    print(resp.json())
+    assert resp.status_code == HTTPStatus.OK
+    assert resp.json().get("status") == "success"
+
+    
+    resp = requests.get(
+        signoz.self.host_configs["8080"].get(
+        f"/api/v1/public/dashboards/{public_dashboard_id}/widgets/-1/query_range"
+        ),
+        timeout=2,
+    )
+    assert resp.status_code == HTTPStatus.BAD_REQUEST
+
+    resp = requests.get(
+        signoz.self.host_configs["8080"].get(
+        f"/api/v1/public/dashboards/{public_dashboard_id}/widgets/1/query_range"
+        ),
+        timeout=2,
+    )
+    assert resp.status_code == HTTPStatus.BAD_REQUEST