fix: added fix for metric selection tooltip scroll issue

docs/api/openapi.yml

@@ -853,7 +853,7 @@ paths:
     get:
       deprecated: false
       description: This endpoints promotes and indexes paths
-      operationId: PromotePaths
+      operationId: ListPromotedAndIndexedPaths
       responses:
         "200":
           content:
@@ -883,13 +883,11 @@ paths:
           description: Internal Server Error
       summary: Promote and index paths
       tags:
-      - promoted_paths
       - logs
-      - json_logs
     post:
       deprecated: false
       description: This endpoints promotes and indexes paths
-      operationId: PromotePaths
+      operationId: HandlePromoteAndIndexPaths
       requestBody:
         content:
           application/json:
@@ -915,9 +913,7 @@ paths:
           description: Internal Server Error
       summary: Promote and index paths
       tags:
-      - promoted_paths
       - logs
-      - json_logs
   /api/v1/org/preferences:
     get:
       deprecated: false

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/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>

pkg/apiserver/signozapiserver/promote.go

@@ -10,8 +10,8 @@ import (
 
 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:                  "PromotePaths",
-		Tags:                []string{"promoted_paths", "logs", "json_logs"},
+		ID:                  "HandlePromoteAndIndexPaths",
+		Tags:                []string{"logs"},
 		Summary:             "Promote and index paths",
 		Description:         "This endpoints promotes and indexes paths",
 		Request:             new([]*promotetypes.PromotePath),
@@ -25,8 +25,8 @@ func (provider *provider) addPromoteRoutes(router *mux.Router) error {
 	}
 
 	if err := router.Handle("/api/v1/logs/promote_paths", handler.New(provider.authZ.ViewAccess(provider.promoteHandler.ListPromotedAndIndexedPaths), handler.OpenAPIDef{
-		ID:                  "PromotePaths",
-		Tags:                []string{"promoted_paths", "logs", "json_logs"},
+		ID:                  "ListPromotedAndIndexedPaths",
+		Tags:                []string{"logs"},
 		Summary:             "Promote and index paths",
 		Description:         "This endpoints promotes and indexes paths",
 		Request:             nil,

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

@@ -245,7 +245,7 @@ func (t *telemetryMetaStore) ListLogsJSONIndexes(ctx context.Context, filters ..
 	}
 	defer rows.Close()
 
-	indexesMap := make(map[string][]schemamigrator.Index)
+	indexes := make(map[string][]schemamigrator.Index)
 	for rows.Next() {
 		var name string
 		var typeFull string
@@ -254,7 +254,7 @@ func (t *telemetryMetaStore) ListLogsJSONIndexes(ctx context.Context, filters ..
 		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,
@@ -262,7 +262,7 @@ func (t *telemetryMetaStore) ListLogsJSONIndexes(ctx context.Context, filters ..
 		})
 	}
 
-	return indexesMap, nil
+	return indexes, nil
 }
 
 func (t *telemetryMetaStore) ListPromotedPaths(ctx context.Context, paths ...string) (map[string]struct{}, error) {

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