fix(uplot): stop the time-scale trim hiding data on short windows

Assisted-by: Claude Opus 5

frontend/src/components/LogDetail/LogHighlights/LogHighlights.module.scss

@@ -1,46 +0,0 @@
-.highlights {
-	display: grid;
-	grid-template-columns: repeat(4, minmax(0, 1fr));
-	gap: 12px 16px;
-	padding: 12px 0;
-
-	// Constrain each KeyValueLabel (the grid items) to its cell.
-	:global(.key-value-label) {
-		width: auto;
-		min-width: 0;
-		overflow: hidden;
-	}
-}
-
-.valueBadge {
-	--badge-font-size: 13px;
-	box-sizing: border-box;
-	max-width: 100%;
-	min-width: 0;
-}
-
-// Truncating text inside a badge
-.badgeText {
-	min-width: 0;
-	overflow: hidden;
-	text-overflow: ellipsis;
-	white-space: nowrap;
-}
-
-.serviceDot {
-	width: 6px;
-	height: 6px;
-	border-radius: 50%;
-	background: var(--accent-forest);
-	flex-shrink: 0;
-	margin-right: 4px;
-}
-
-.traceLink {
-	display: inline-block;
-	max-width: 100%;
-	overflow: hidden;
-	text-overflow: ellipsis;
-	white-space: nowrap;
-	color: var(--accent-primary);
-}

frontend/src/components/LogDetail/LogHighlights/LogHighlights.tsx

@@ -1,36 +0,0 @@
-import KeyValueLabel from 'periscope/components/KeyValueLabel';
-import { ILog } from 'types/api/logs/log';
-
-import { LOG_HIGHLIGHTS } from './config';
-import styles from './LogHighlights.module.scss';
-
-interface LogHighlightsProps {
-	log: ILog;
-}
-
-function LogHighlights({ log }: LogHighlightsProps): JSX.Element | null {
-	const fields = LOG_HIGHLIGHTS.map((field) => ({
-		key: field.key,
-		label: field.label,
-		value: field.render(log),
-	})).filter((field) => field.value != null);
-
-	if (fields.length === 0) {
-		return null;
-	}
-
-	return (
-		<div className={styles.highlights} data-testid="log-details-highlights">
-			{fields.map((field) => (
-				<KeyValueLabel
-					key={field.key}
-					badgeKey={field.label}
-					badgeValue={field.value}
-					direction="column"
-				/>
-			))}
-		</div>
-	);
-}
-
-export default LogHighlights;

frontend/src/components/LogDetail/LogHighlights/TraceIdField.tsx

@@ -1,23 +0,0 @@
-import { Link } from 'react-router-dom';
-
-import styles from './LogHighlights.module.scss';
-
-interface TraceIdFieldProps {
-	traceId: string;
-}
-
-function TraceIdField({ traceId }: TraceIdFieldProps): JSX.Element {
-	return (
-		<Link
-			to={{ pathname: `/trace/${traceId}` }}
-			target="_blank"
-			rel="noreferrer"
-			className={styles.traceLink}
-			title={traceId}
-		>
-			{traceId}
-		</Link>
-	);
-}
-
-export default TraceIdField;

frontend/src/components/LogDetail/LogHighlights/config.tsx

@@ -1,102 +0,0 @@
-import { ReactNode } from 'react';
-import { Badge, BadgeColor } from '@signozhq/ui/badge';
-import { LogType } from 'components/Logs/LogStateIndicator/LogStateIndicator';
-import { getLogIndicatorType } from 'components/Logs/LogStateIndicator/utils';
-import { ILog } from 'types/api/logs/log';
-
-import styles from './LogHighlights.module.scss';
-import TraceIdField from './TraceIdField';
-
-// Severity badge color mirrors the LogStateIndicator bar
-const SEVERITY_COLOR: Record<string, BadgeColor> = {
-	[LogType.TRACE]: 'forest',
-	[LogType.DEBUG]: 'aqua',
-	[LogType.INFO]: 'robin',
-	[LogType.WARN]: 'amber',
-	[LogType.ERROR]: 'cherry',
-	[LogType.FATAL]: 'sakura',
-};
-
-export interface LogHighlightConfig {
-	key: string;
-	label: string;
-	render: (log: ILog) => ReactNode | null;
-}
-
-// Resource/attribute lookup (keys like `service.name` live in resources_string,
-// occasionally attributes_string). Typed loosely as these are string maps.
-const getAttr = (log: ILog, key: string): string =>
-	(log.resources_string as unknown as Record<string, string>)?.[key] ||
-	(log.attributes_string as unknown as Record<string, string>)?.[key] ||
-	'';
-
-const valueBadge = (
-	value: string,
-	options?: { prefix?: ReactNode; color?: BadgeColor },
-): ReactNode => (
-	<Badge color={options?.color ?? 'vanilla'} className={styles.valueBadge}>
-		{options?.prefix}
-		<span className={styles.badgeText} title={value}>
-			{value}
-		</span>
-	</Badge>
-);
-
-export const LOG_HIGHLIGHTS: LogHighlightConfig[] = [
-	{
-		key: 'service',
-		label: 'SERVICE',
-		render: (log): ReactNode | null => {
-			const value = getAttr(log, 'service.name');
-			return value
-				? valueBadge(value, {
-						prefix: <span className={styles.serviceDot} />,
-					})
-				: null;
-		},
-	},
-	{
-		key: 'severity',
-		label: 'SEVERITY',
-		render: (log): ReactNode | null => {
-			if (!log.severity_text) {
-				return null;
-			}
-			return valueBadge(log.severity_text, {
-				color: SEVERITY_COLOR[getLogIndicatorType(log)] ?? 'vanilla',
-			});
-		},
-	},
-	{
-		key: 'namespace',
-		label: 'NAMESPACE',
-		render: (log): ReactNode | null => {
-			const value = getAttr(log, 'service.namespace');
-			return value ? valueBadge(value) : null;
-		},
-	},
-	{
-		key: 'environment',
-		label: 'ENVIRONMENT',
-		render: (log): ReactNode | null => {
-			const value = getAttr(log, 'deployment.environment');
-			return value ? valueBadge(value) : null;
-		},
-	},
-	{
-		key: 'traceId',
-		label: 'TRACE ID',
-		render: (log): ReactNode | null => {
-			const traceId = log.trace_id || log.traceId;
-			return traceId ? <TraceIdField traceId={traceId} /> : null;
-		},
-	},
-	{
-		key: 'spanId',
-		label: 'SPAN ID',
-		render: (log): ReactNode | null => {
-			const spanId = log.span_id || log.spanID;
-			return spanId ? valueBadge(spanId) : null;
-		},
-	},
-];

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

@@ -115,45 +115,6 @@ describe('LogDetail drawer — header (isLogDetailsV2)', () => {
 		expect(screen.queryByText('Open in Explorer')).not.toBeInTheDocument();
 	});
 
-	it('renders Highlights for fields present on the log, omitting absent ones', () => {
-		const logWithMeta = {
-			...mockLog,
-			severity_text: 'ERROR',
-			trace_id: 'trace-abc',
-			resources_string: {
-				'service.name': 'checkout',
-				'deployment.environment': 'production',
-			},
-		} as unknown as ILog;
-
-		renderDrawer({ log: logWithMeta });
-
-		const highlights = screen.getByTestId('log-details-highlights');
-		expect(highlights).toHaveTextContent('SEVERITY');
-		expect(highlights).toHaveTextContent('ERROR');
-		expect(highlights).toHaveTextContent('SERVICE');
-		expect(highlights).toHaveTextContent('checkout');
-		expect(highlights).toHaveTextContent('ENVIRONMENT');
-		expect(highlights).toHaveTextContent('production');
-		expect(highlights).toHaveTextContent('TRACE ID');
-		// Absent fields are omitted (no namespace / span id on this log).
-		expect(highlights).not.toHaveTextContent('NAMESPACE');
-		expect(highlights).not.toHaveTextContent('SPAN ID');
-	});
-
-	it('links the trace id highlight to the trace detail in a new tab', () => {
-		const logWithTrace = {
-			...mockLog,
-			trace_id: 'trace-abc',
-		} as unknown as ILog;
-
-		renderDrawer({ log: logWithTrace });
-
-		const link = screen.getByRole('link', { name: 'trace-abc' });
-		expect(link).toHaveAttribute('target', '_blank');
-		expect(link.getAttribute('href')).toContain('/trace/trace-abc');
-	});
-
 	it('navigates to the next / previous log with the Down / Up arrow keys', async () => {
 		const user = userEvent.setup({ pointerEventsCheck: 0 });
 		const logs = [makeLog('log-0'), makeLog('log-1'), makeLog('log-2')];

frontend/src/components/LogDetail/index.tsx

@@ -55,7 +55,6 @@ import { isLogDetailsV2, RESOURCE_KEYS, VIEW_TYPES, VIEWS } from './constants';
 import { LogDetailInnerProps, LogDetailProps } from './LogDetail.interfaces';
 import LogDetailsHeader from './LogDetailsHeader/LogDetailsHeader';
 import { useLogNavigation } from './LogDetailsHeader/useLogNavigation';
-import LogHighlights from './LogHighlights/LogHighlights';
 
 import './LogDetails.styles.scss';
 
@@ -400,8 +399,6 @@ function LogDetailInner({
 					<div className="log-overflow-shadow">&nbsp;</div>
 				</div>
 
-				{isLogDetailsV2 && <LogHighlights log={log} />}
-
 				<div className="tabs-and-search">
 					<ToggleGroupSimple
 						type="single"

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

@@ -27,6 +27,7 @@ export interface BaseConfigBuilderProps {
 	panelType: PANEL_TYPES;
 	minTimeScale?: number;
 	maxTimeScale?: number;
+	useExactTimeRange?: boolean;
 	stepInterval?: number;
 	isLogScale?: boolean;
 	yAxisUnit?: string;
@@ -46,6 +47,7 @@ export function buildBaseConfig({
 	thresholds,
 	minTimeScale,
 	maxTimeScale,
+	useExactTimeRange,
 	stepInterval,
 	isLogScale,
 	yAxisUnit,
@@ -88,6 +90,7 @@ export function buildBaseConfig({
 		time: true,
 		min: minTimeScale,
 		max: maxTimeScale,
+		useExactTimeRange,
 		logBase: isLogScale ? 10 : undefined,
 		distribution: isLogScale
 			? DistributionType.Logarithmic

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

@@ -42,6 +42,7 @@ export class UPlotScaleBuilder extends ConfigBuilder<
 			logBase = 10,
 			padMinBy = 0,
 			padMaxBy = 0.05,
+			useExactTimeRange = false,
 		} = this.props;
 
 		// Special handling for time scales (X axis)
@@ -58,14 +59,20 @@ export class UPlotScaleBuilder extends ConfigBuilder<
 
 			// Align max time to "endTime - 1 minute", rounded down to minute precision
 			// This matches legacy getXAxisScale behavior and avoids empty space at the right edge
-			const oneMinuteAgoTimestamp = (maxTime - 60) * 1000;
-			const currentDate = new Date(oneMinuteAgoTimestamp);
+			if (!useExactTimeRange) {
+				const oneMinuteAgoTimestamp = (maxTime - 60) * 1000;
+				const currentDate = new Date(oneMinuteAgoTimestamp);
 
-			currentDate.setSeconds(0);
-			currentDate.setMilliseconds(0);
+				currentDate.setSeconds(0);
+				currentDate.setMilliseconds(0);
 
-			const unixTimestampSeconds = Math.floor(currentDate.getTime() / 1000);
-			maxTime = unixTimestampSeconds;
+				const unixTimestampSeconds = Math.floor(currentDate.getTime() / 1000);
+
+				// Trimming past min inverts the range, which uPlot draws as an empty plot.
+				if (unixTimestampSeconds > minTime) {
+					maxTime = unixTimestampSeconds;
+				}
+			}
 
 			return {
 				[scaleKey]: {

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

@@ -79,6 +79,44 @@ describe('UPlotScaleBuilder', () => {
 		expect(resolvedMax).toBe(expectedMax);
 	});
 
+	it('plots min/max as given when useExactTimeRange is set', () => {
+		const min = 1_700_000_000;
+		const max = 1_700_000_630;
+
+		const builder = new UPlotScaleBuilder(
+			createScaleProps({
+				scaleKey: 'x',
+				time: true,
+				min,
+				max,
+				useExactTimeRange: true,
+			}),
+		);
+
+		const config = builder.getConfig();
+
+		expect(config.x.range).toStrictEqual([min, max]);
+	});
+
+	it('keeps the requested end when the window is shorter than the trim', () => {
+		// 23 second window: trimming a minute off the end would put max before min.
+		const min = 1_786_527_160;
+		const max = 1_786_527_183;
+
+		const builder = new UPlotScaleBuilder(
+			createScaleProps({
+				scaleKey: 'x',
+				time: true,
+				min,
+				max,
+			}),
+		);
+
+		const config = builder.getConfig();
+
+		expect(config.x.range).toStrictEqual([min, max]);
+	});
+
 	it('falls back to getFallbackMinMaxTimeStamp when time scale has no min/max', () => {
 		getFallbackMinMaxSpy.mockReturnValue({
 			fallbackMin: 100,

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

@@ -97,6 +97,8 @@ export interface ScaleProps {
 	auto?: boolean;
 	logBase?: uPlot.Scale.LogBase;
 	distribution?: DistributionType;
+	/** Plots a time scale's `min`/`max` as given, skipping the trim below. */
+	useExactTimeRange?: boolean;
 }
 
 export enum DisconnectedValuesMode {

pkg/flagger/registry.go

@@ -3,17 +3,16 @@ package flagger
 import "github.com/SigNoz/signoz/pkg/types/featuretypes"
 
 var (
-	FeatureUseSpanMetrics            = featuretypes.MustNewName("use_span_metrics")
-	FeatureKafkaSpanEval             = featuretypes.MustNewName("kafka_span_eval")
-	FeatureHideRootUser              = featuretypes.MustNewName("hide_root_user")
-	FeatureGetMetersFromZeus         = featuretypes.MustNewName("get_meters_from_zeus")
-	FeaturePutMetersInZeus           = featuretypes.MustNewName("put_meters_in_zeus")
-	FeatureUseMeterReporter          = featuretypes.MustNewName("use_meter_reporter")
-	FeatureUseJSONBody               = featuretypes.MustNewName("use_json_body")
-	FeatureEnableAIObservability     = featuretypes.MustNewName("enable_ai_observability")
-	FeatureEnableMetricsReduction    = featuretypes.MustNewName("enable_metrics_reduction")
+	FeatureUseSpanMetrics         = featuretypes.MustNewName("use_span_metrics")
+	FeatureKafkaSpanEval          = featuretypes.MustNewName("kafka_span_eval")
+	FeatureHideRootUser           = featuretypes.MustNewName("hide_root_user")
+	FeatureGetMetersFromZeus      = featuretypes.MustNewName("get_meters_from_zeus")
+	FeaturePutMetersInZeus        = featuretypes.MustNewName("put_meters_in_zeus")
+	FeatureUseMeterReporter       = featuretypes.MustNewName("use_meter_reporter")
+	FeatureUseJSONBody            = featuretypes.MustNewName("use_json_body")
+	FeatureEnableAIObservability  = featuretypes.MustNewName("enable_ai_observability")
+	FeatureEnableMetricsReduction = featuretypes.MustNewName("enable_metrics_reduction")
 	FeatureUsePrometheusClickhouseV2 = featuretypes.MustNewName("use_prometheus_clickhouse_v2")
-	FeatureResolveSemconvFamilies    = featuretypes.MustNewName("resolve_semconv_families")
 )
 
 func MustNewRegistry() featuretypes.Registry {
@@ -98,14 +97,6 @@ func MustNewRegistry() featuretypes.Registry {
 			DefaultVariant: featuretypes.MustNewName("disabled"),
 			Variants:       featuretypes.NewBooleanVariants(),
 		},
-		&featuretypes.Feature{
-			Name:           FeatureResolveSemconvFamilies,
-			Kind:           featuretypes.KindBoolean,
-			Stage:          featuretypes.StageExperimental,
-			Description:    "Controls whether trace queries resolve a semantic-convention name to all the spellings of its family",
-			DefaultVariant: featuretypes.MustNewName("disabled"),
-			Variants:       featuretypes.NewBooleanVariants(),
-		},
 	)
 	if err != nil {
 		panic(err)

pkg/modules/rulestatehistory/implrulestatehistory/condition_builder.go

@@ -40,10 +40,7 @@ func (c *conditionBuilder) ConditionFor(
 		return nil, nil, err
 	}
 
-	// Rule state history fields have no family support, so every logical field
-	// is single-member and flattens losslessly to its physical key.
-	resolved, warning := querybuilder.ResolveLogicalFields(key, querybuilder.MatchingLogicalFields(ctx, orgID, nil, key, fieldKeys))
-	keys := querybuilder.SingleKeys(resolved)
+	keys, warning := querybuilder.ResolveKeys(key, querybuilder.MatchingFieldKeys(key, fieldKeys))
 	var warnings []string
 	if warning != "" {
 		warnings = append(warnings, warning)

pkg/modules/rulestatehistory/implrulestatehistory/field_mapper.go

@@ -6,7 +6,6 @@ import (
 	"strings"
 
 	schema "github.com/SigNoz/signoz-otel-collector/cmd/signozschemamigrator/schema_migrator"
-	"github.com/SigNoz/signoz/pkg/querybuilder"
 	qbtypes "github.com/SigNoz/signoz/pkg/types/querybuildertypes/querybuildertypesv5"
 	"github.com/SigNoz/signoz/pkg/types/telemetrytypes"
 	"github.com/SigNoz/signoz/pkg/valuer"
@@ -52,7 +51,7 @@ func (m *fieldMapper) FieldFor(ctx context.Context, _ valuer.UUID, _, _ uint64,
 		return "", err
 	}
 	if col.Name == "labels" && key.Name != "labels" {
-		return fmt.Sprintf("JSONExtractString(labels, %s)", querybuilder.ClickHouseStringLiteral(key.Name)), nil
+		return fmt.Sprintf("JSONExtractString(labels, '%s')", strings.ReplaceAll(key.Name, "'", "\\'")), nil
 	}
 	return col.Name, nil
 }
@@ -65,23 +64,6 @@ func (m *fieldMapper) ColumnFor(ctx context.Context, _ valuer.UUID, _, _ uint64,
 	return []*schema.Column{col}, nil
 }
 
-// ExistsFor implements the per-key existence primitive of qbtypes.FieldMapper.
-// Real columns always exist; labels are checked for key membership.
-func (m *fieldMapper) ExistsFor(ctx context.Context, _ valuer.UUID, _, _ uint64, key *telemetrytypes.TelemetryFieldKey, exists bool) (string, error) {
-	col, err := m.getColumn(ctx, key)
-	if err != nil {
-		return "", err
-	}
-	if col.Name != "labels" || key.Name == "labels" {
-		return "true", nil
-	}
-	pred := fmt.Sprintf("has(JSONExtractKeys(labels), %s)", querybuilder.ClickHouseStringLiteral(key.Name))
-	if exists {
-		return pred, nil
-	}
-	return "not " + pred, nil
-}
-
 func (m *fieldMapper) ColumnExpressionFor(ctx context.Context, orgID valuer.UUID, tsStart, tsEnd uint64, field *telemetrytypes.TelemetryFieldKey, _ telemetrytypes.FieldDataType, _ map[string][]*telemetrytypes.TelemetryFieldKey) (string, error) {
 	colName, err := m.FieldFor(ctx, orgID, tsStart, tsEnd, field)
 	if err != nil {

pkg/querybuilder/clickhouse_quote.go

@@ -1,17 +0,0 @@
-package querybuilder
-
-import "strings"
-
-// ClickHouseStringLiteral quotes a value for a ClickHouse string literal.
-func ClickHouseStringLiteral(value string) string {
-	escaped := strings.ReplaceAll(value, `\`, `\\`)
-	escaped = strings.ReplaceAll(escaped, `'`, `\'`)
-	return "'" + escaped + "'"
-}
-
-// ClickHouseIdentifier quotes a value for a ClickHouse identifier.
-func ClickHouseIdentifier(value string) string {
-	escaped := strings.ReplaceAll(value, `\`, `\\`)
-	escaped = strings.ReplaceAll(escaped, "`", "\\`")
-	return "`" + escaped + "`"
-}

pkg/querybuilder/clickhouse_quote_test.go

@@ -1,17 +0,0 @@
-package querybuilder
-
-import (
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-)
-
-func TestClickHouseQuoting(t *testing.T) {
-	t.Run("string literal", func(t *testing.T) {
-		assert.Equal(t, `'name\'\\); SELECT 1 --'`, ClickHouseStringLiteral(`name'\); SELECT 1 --`))
-	})
-
-	t.Run("identifier", func(t *testing.T) {
-		assert.Equal(t, "`name\\`\\\\); SELECT 1 --`", ClickHouseIdentifier("name`\\); SELECT 1 --"))
-	})
-}

pkg/querybuilder/family_selectors.go

@@ -1,64 +0,0 @@
-package querybuilder
-
-import (
-	"context"
-
-	"github.com/SigNoz/signoz/pkg/flagger"
-	"github.com/SigNoz/signoz/pkg/semconv"
-	"github.com/SigNoz/signoz/pkg/types/featuretypes"
-	"github.com/SigNoz/signoz/pkg/types/telemetrytypes"
-	"github.com/SigNoz/signoz/pkg/valuer"
-)
-
-// semconvFamiliesEnabled evaluates the resolve_semconv_families flag for the
-// org. A nil flagger means off, so a caller without family support stays
-// literal by default.
-func semconvFamiliesEnabled(ctx context.Context, orgID valuer.UUID, fl flagger.Flagger) bool {
-	if fl == nil {
-		return false
-	}
-	return fl.BooleanOrEmpty(ctx, flagger.FeatureResolveSemconvFamilies, featuretypes.NewFlaggerEvaluationContext(orgID))
-}
-
-// ExpandKeySelectorsForFamilies adds selectors for the other members of each
-// semantic-convention family that a selector names. The metadata fetched for
-// a query then contains each spelling that MatchingLogicalFields can group.
-// This function is the prefetch of the resolution layer: statement builders
-// call it after they derive the selectors, and the metadata store stays
-// family-blind (autocomplete responses keep the literal spelling that the
-// user typed). It does nothing when the resolve_semconv_families flag is off
-// for the org. Only trace selectors expand today, because that matches the
-// family support. Fuzzy (search-style) selectors never expand.
-func ExpandKeySelectorsForFamilies(ctx context.Context, orgID valuer.UUID, fl flagger.Flagger, selectors []*telemetrytypes.FieldKeySelector) []*telemetrytypes.FieldKeySelector {
-	if !semconvFamiliesEnabled(ctx, orgID, fl) {
-		return selectors
-	}
-
-	out := selectors
-	seen := make(map[string]bool, len(selectors))
-	for _, selector := range selectors {
-		seen[selector.Name] = true
-	}
-
-	for _, selector := range selectors {
-		if selector.Signal != telemetrytypes.SignalTraces ||
-			selector.SelectorMatchType == telemetrytypes.FieldSelectorMatchTypeFuzzy {
-			continue
-		}
-		members := semconv.Members(semconv.KindAttribute, telemetrytypes.FieldKeySelector{
-			Name:         selector.Name,
-			Signal:       selector.Signal,
-			FieldContext: selector.FieldContext,
-		})
-		for _, member := range members {
-			if seen[member] {
-				continue
-			}
-			seen[member] = true
-			expanded := *selector
-			expanded.Name = member
-			out = append(out, &expanded)
-		}
-	}
-	return out
-}

pkg/querybuilder/key_resolution.go

@@ -21,25 +21,24 @@ const (
 	hasTokenFunctionDocURL       = "https://signoz.io/docs/userguide/functions-reference/#hastoken-function"
 )
 
-// ResolveLogicalFields picks which logical fields a filter term builds conditions
-// for. With 0 or 1 field it returns the input unchanged and no warning. When a
-// name is ambiguous (several logical fields — a family is one field and never
-// ambiguous with itself) it returns a warning; a resource+attribute mix defaults
-// to the resource fields (the common intent), noted in the warning.
-func ResolveLogicalFields(field *telemetrytypes.TelemetryFieldKey, logicalFields []*telemetrytypes.LogicalField) ([]*telemetrytypes.LogicalField, string) {
-	if len(logicalFields) <= 1 {
-		return logicalFields, ""
+// ResolveKeys picks which matching field keys a filter term builds conditions for.
+// With 0 or 1 match it returns the input unchanged and no warning. When a name is
+// ambiguous it returns a warning; a resource+attribute mix defaults to the resource
+// keys (the common intent), noted in the warning.
+func ResolveKeys(field *telemetrytypes.TelemetryFieldKey, fieldKeysForName []*telemetrytypes.TelemetryFieldKey) ([]*telemetrytypes.TelemetryFieldKey, string) {
+	if len(fieldKeysForName) <= 1 {
+		return fieldKeysForName, ""
 	}
 
 	warning := fmt.Sprintf(
 		"Key `%s` is ambiguous, found %d different combinations of field context / data type: %v.",
 		field.Name,
-		len(logicalFields),
-		logicalFields,
+		len(fieldKeysForName),
+		fieldKeysForName,
 	)
 
 	hasResource, hasAttribute := false, false
-	for _, item := range logicalFields {
+	for _, item := range fieldKeysForName {
 		switch item.FieldContext {
 		case telemetrytypes.FieldContextResource:
 			hasResource = true
@@ -50,40 +49,18 @@ func ResolveLogicalFields(field *telemetrytypes.TelemetryFieldKey, logicalFields
 
 	// when there is both resource and attribute context, default to resource only
 	if hasResource && hasAttribute {
-		filtered := make([]*telemetrytypes.LogicalField, 0, len(logicalFields))
-		for _, item := range logicalFields {
+		filteredKeys := make([]*telemetrytypes.TelemetryFieldKey, 0, len(fieldKeysForName))
+		for _, item := range fieldKeysForName {
 			if item.FieldContext == telemetrytypes.FieldContextResource {
-				filtered = append(filtered, item)
+				filteredKeys = append(filteredKeys, item)
 			}
 		}
-		logicalFields = filtered
+		fieldKeysForName = filteredKeys
 		warning += " " + "Using `resource` context by default. To query attributes explicitly, " +
 			fmt.Sprintf("use the fully qualified name (e.g., 'attribute.%s')", field.Name)
 	}
 
-	return logicalFields, warning
-}
-
-// WrapAsLogicalFields wraps physical keys (candidate or synthesized) as
-// single-member logical fields addressed by the requested spelling.
-func WrapAsLogicalFields(requestedName string, keys []*telemetrytypes.TelemetryFieldKey) []*telemetrytypes.LogicalField {
-	fields := make([]*telemetrytypes.LogicalField, 0, len(keys))
-	for _, key := range keys {
-		fields = append(fields, telemetrytypes.SingleLogicalField(requestedName, key))
-	}
-	return fields
-}
-
-// SingleKeys flattens logical fields to their single members. It is the
-// adapter for signals whose fields are single-member by construction (every
-// signal without family support); their condition builders keep compiling per
-// physical key.
-func SingleKeys(fields []*telemetrytypes.LogicalField) []*telemetrytypes.TelemetryFieldKey {
-	keys := make([]*telemetrytypes.TelemetryFieldKey, 0, len(fields))
-	for _, field := range fields {
-		keys = append(keys, field.Single())
-	}
-	return keys
+	return fieldKeysForName, warning
 }
 
 // NewKeyNotFoundError builds the error a condition builder returns when a filter term

pkg/querybuilder/logical_expr.go

@@ -1,94 +0,0 @@
-package querybuilder
-
-import (
-	"context"
-	"fmt"
-	"strings"
-
-	qbtypes "github.com/SigNoz/signoz/pkg/types/querybuildertypes/querybuildertypesv5"
-	"github.com/SigNoz/signoz/pkg/types/telemetrytypes"
-	"github.com/SigNoz/signoz/pkg/valuer"
-)
-
-// The two functions below are the only place family expressions are built.
-// They compose exclusively from the mapper's per-key primitives (FieldFor,
-// ExistsFor), so every member honors its own storage: materialized columns,
-// evolutions, and JSON plans ride the member keys, and a signal supports
-// families the moment its primitives are correct.
-
-// LogicalValueExpr returns the value expression for a resolved logical field:
-// the member's own expression for a single-member field, and a current-first
-// merge across the members' expressions for a family.
-func LogicalValueExpr(
-	ctx context.Context,
-	orgID valuer.UUID,
-	tsStart, tsEnd uint64,
-	fm qbtypes.FieldMapper,
-	logical *telemetrytypes.LogicalField,
-) (string, error) {
-	if !logical.IsFamily() {
-		return fm.FieldFor(ctx, orgID, tsStart, tsEnd, logical.Single())
-	}
-
-	memberExprs := make([]string, 0, len(logical.Members))
-	for _, member := range logical.Members {
-		expr, err := fm.FieldFor(ctx, orgID, tsStart, tsEnd, member)
-		if err != nil {
-			return "", err
-		}
-		memberExprs = append(memberExprs, expr)
-	}
-
-	if logical.FieldDataType == telemetrytypes.FieldDataTypeString {
-		// The trailing '' keeps single-key semantics for rows without any
-		// member: string maps read '' for an absent key, and negative
-		// operators must keep including such rows (see AddDefaultExistsFilter).
-		values := make([]string, 0, len(memberExprs))
-		for _, expr := range memberExprs {
-			values = append(values, fmt.Sprintf("NULLIF(%s, '')", expr))
-		}
-		return "COALESCE(" + strings.Join(values, ", ") + ", '')", nil
-	}
-
-	// Numeric and boolean maps return zero for an absent key. If a family of
-	// either type is enabled, this tail must become zero too.
-	branches := make([]string, 0, len(logical.Members)*2)
-	for i, member := range logical.Members {
-		guard, err := fm.ExistsFor(ctx, orgID, tsStart, tsEnd, member, true)
-		if err != nil {
-			return "", err
-		}
-		branches = append(branches, guard, memberExprs[i])
-	}
-	return "multiIf(" + strings.Join(branches, ", ") + ", NULL)", nil
-}
-
-// LogicalExistsExpr returns the existence predicate for a resolved logical
-// field: the member's own predicate for a single-member field, presence of
-// any member for a family.
-func LogicalExistsExpr(
-	ctx context.Context,
-	orgID valuer.UUID,
-	tsStart, tsEnd uint64,
-	fm qbtypes.FieldMapper,
-	logical *telemetrytypes.LogicalField,
-	exists bool,
-) (string, error) {
-	if !logical.IsFamily() {
-		return fm.ExistsFor(ctx, orgID, tsStart, tsEnd, logical.Single(), exists)
-	}
-
-	guards := make([]string, 0, len(logical.Members))
-	for _, member := range logical.Members {
-		guard, err := fm.ExistsFor(ctx, orgID, tsStart, tsEnd, member, true)
-		if err != nil {
-			return "", err
-		}
-		guards = append(guards, guard)
-	}
-	combined := "(" + strings.Join(guards, " OR ") + ")"
-	if exists {
-		return combined, nil
-	}
-	return "NOT " + combined, nil
-}

pkg/querybuilder/logical_expr_test.go

@@ -1,95 +0,0 @@
-package querybuilder
-
-import (
-	"context"
-	"testing"
-
-	schema "github.com/SigNoz/signoz-otel-collector/cmd/signozschemamigrator/schema_migrator"
-	qbtypes "github.com/SigNoz/signoz/pkg/types/querybuildertypes/querybuildertypesv5"
-	"github.com/SigNoz/signoz/pkg/types/telemetrytypes"
-	"github.com/SigNoz/signoz/pkg/valuer"
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-)
-
-// stubFieldMapper provides just the two per-key primitives the shared
-// composition builds on; the remaining FieldMapper methods are unused here.
-type stubFieldMapper struct{}
-
-func (stubFieldMapper) FieldFor(_ context.Context, _ valuer.UUID, _, _ uint64, key *telemetrytypes.TelemetryFieldKey) (string, error) {
-	return "value(" + key.Name + ")", nil
-}
-
-func (stubFieldMapper) ExistsFor(_ context.Context, _ valuer.UUID, _, _ uint64, key *telemetrytypes.TelemetryFieldKey, exists bool) (string, error) {
-	if exists {
-		return "has(" + key.Name + ")", nil
-	}
-	return "NOT has(" + key.Name + ")", nil
-}
-
-func (stubFieldMapper) ColumnFor(context.Context, valuer.UUID, uint64, uint64, *telemetrytypes.TelemetryFieldKey) ([]*schema.Column, error) {
-	return nil, qbtypes.ErrColumnNotFound
-}
-
-func (stubFieldMapper) ColumnExpressionFor(context.Context, valuer.UUID, uint64, uint64, *telemetrytypes.TelemetryFieldKey, telemetrytypes.FieldDataType, map[string][]*telemetrytypes.TelemetryFieldKey) (string, error) {
-	return "", qbtypes.ErrColumnNotFound
-}
-
-func (stubFieldMapper) CandidateKeys(context.Context, valuer.UUID, *telemetrytypes.TelemetryFieldKey, any, map[string][]*telemetrytypes.TelemetryFieldKey) []*telemetrytypes.TelemetryFieldKey {
-	return nil
-}
-
-func stringFamily(names ...string) *telemetrytypes.LogicalField {
-	members := make([]*telemetrytypes.TelemetryFieldKey, 0, len(names))
-	for _, name := range names {
-		members = append(members, &telemetrytypes.TelemetryFieldKey{Name: name, FieldDataType: telemetrytypes.FieldDataTypeString})
-	}
-	return &telemetrytypes.LogicalField{Name: names[0], FieldDataType: telemetrytypes.FieldDataTypeString, Members: members}
-}
-
-func TestLogicalValueExprSingleMemberDelegatesToFieldFor(t *testing.T) {
-	logical := telemetrytypes.SingleLogicalField("a", &telemetrytypes.TelemetryFieldKey{Name: "a"})
-	expr, err := LogicalValueExpr(context.Background(), valuer.UUID{}, 0, 0, stubFieldMapper{}, logical)
-	require.NoError(t, err)
-	assert.Equal(t, "value(a)", expr)
-}
-
-func TestLogicalValueExprStringFamilyMergesCurrentFirst(t *testing.T) {
-	expr, err := LogicalValueExpr(context.Background(), valuer.UUID{}, 0, 0, stubFieldMapper{}, stringFamily("current", "old"))
-	require.NoError(t, err)
-	// The trailing '' preserves keyless-row semantics for negative operators.
-	assert.Equal(t, "COALESCE(NULLIF(value(current), ''), NULLIF(value(old), ''), '')", expr)
-}
-
-func TestLogicalValueExprNumericFamilyGuardsEveryMember(t *testing.T) {
-	logical := &telemetrytypes.LogicalField{
-		Name:          "current",
-		FieldDataType: telemetrytypes.FieldDataTypeNumber,
-		Members: []*telemetrytypes.TelemetryFieldKey{
-			{Name: "current", FieldDataType: telemetrytypes.FieldDataTypeNumber},
-			{Name: "old", FieldDataType: telemetrytypes.FieldDataTypeNumber},
-		},
-	}
-	expr, err := LogicalValueExpr(context.Background(), valuer.UUID{}, 0, 0, stubFieldMapper{}, logical)
-	require.NoError(t, err)
-	assert.Equal(t, "multiIf(has(current), value(current), has(old), value(old), NULL)", expr)
-}
-
-func TestLogicalExistsExprSingleMemberDelegatesToExistsFor(t *testing.T) {
-	logical := telemetrytypes.SingleLogicalField("a", &telemetrytypes.TelemetryFieldKey{Name: "a"})
-	expr, err := LogicalExistsExpr(context.Background(), valuer.UUID{}, 0, 0, stubFieldMapper{}, logical, false)
-	require.NoError(t, err)
-	assert.Equal(t, "NOT has(a)", expr)
-}
-
-func TestLogicalExistsExprFamilyIsAnyMemberPresence(t *testing.T) {
-	family := stringFamily("current", "old")
-
-	expr, err := LogicalExistsExpr(context.Background(), valuer.UUID{}, 0, 0, stubFieldMapper{}, family, true)
-	require.NoError(t, err)
-	assert.Equal(t, "(has(current) OR has(old))", expr)
-
-	expr, err = LogicalExistsExpr(context.Background(), valuer.UUID{}, 0, 0, stubFieldMapper{}, family, false)
-	require.NoError(t, err)
-	assert.Equal(t, "NOT (has(current) OR has(old))", expr)
-}

pkg/querybuilder/logical_fields_test.go

@@ -1,239 +0,0 @@
-package querybuilder
-
-import (
-	"context"
-	"testing"
-
-	"github.com/SigNoz/signoz/pkg/flagger"
-	"github.com/SigNoz/signoz/pkg/flagger/flaggertest"
-	"github.com/SigNoz/signoz/pkg/types/telemetrytypes"
-	"github.com/SigNoz/signoz/pkg/valuer"
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-)
-
-// familiesOn returns a flagger with resolve_semconv_families on.
-func familiesOn(t *testing.T) flagger.Flagger {
-	return flaggertest.WithBooleanFlags(t, map[string]bool{
-		flagger.FeatureResolveSemconvFamilies.String(): true,
-	})
-}
-
-func memberNames(logical *telemetrytypes.LogicalField) []string {
-	names := make([]string, 0, len(logical.Members))
-	for _, member := range logical.Members {
-		names = append(names, member.Name)
-	}
-	return names
-}
-
-// The deployment.environment(.name) family (enabled in pkg/semconv) drives the
-// grouping tests below.
-
-// With the resolve_semconv_families flag off, matches stay single-member and
-// selectors stay literal, even when the metadata map has both spellings.
-func TestFamiliesOffByDefault(t *testing.T) {
-	fieldKeys := map[string][]*telemetrytypes.TelemetryFieldKey{
-		"deployment.environment.name": {{
-			Name:          "deployment.environment.name",
-			Signal:        telemetrytypes.SignalTraces,
-			FieldContext:  telemetrytypes.FieldContextResource,
-			FieldDataType: telemetrytypes.FieldDataTypeString,
-		}},
-		"deployment.environment": {{
-			Name:          "deployment.environment",
-			Signal:        telemetrytypes.SignalTraces,
-			FieldContext:  telemetrytypes.FieldContextResource,
-			FieldDataType: telemetrytypes.FieldDataTypeString,
-		}},
-	}
-
-	fields := MatchingLogicalFields(context.Background(), valuer.UUID{}, flaggertest.New(t), &telemetrytypes.TelemetryFieldKey{Name: "deployment.environment.name"}, fieldKeys)
-	require.Len(t, fields, 1)
-	assert.False(t, fields[0].IsFamily())
-	assert.Equal(t, []string{"deployment.environment.name"}, memberNames(fields[0]))
-
-	selectors := []*telemetrytypes.FieldKeySelector{
-		{Name: "deployment.environment.name", Signal: telemetrytypes.SignalTraces, SelectorMatchType: telemetrytypes.FieldSelectorMatchTypeExact},
-	}
-	assert.Len(t, ExpandKeySelectorsForFamilies(context.Background(), valuer.UUID{}, flaggertest.New(t), selectors), 1)
-}
-
-func TestMatchingLogicalFieldsGroupsFamilyMembers(t *testing.T) {
-	fieldKeys := map[string][]*telemetrytypes.TelemetryFieldKey{
-		"deployment.environment.name": {{
-			Name:          "deployment.environment.name",
-			Signal:        telemetrytypes.SignalTraces,
-			FieldContext:  telemetrytypes.FieldContextResource,
-			FieldDataType: telemetrytypes.FieldDataTypeString,
-		}},
-		"deployment.environment": {{
-			Name:          "deployment.environment",
-			Signal:        telemetrytypes.SignalTraces,
-			FieldContext:  telemetrytypes.FieldContextResource,
-			FieldDataType: telemetrytypes.FieldDataTypeString,
-		}},
-	}
-
-	for _, requested := range []string{"deployment.environment.name", "deployment.environment"} {
-		fields := MatchingLogicalFields(context.Background(), valuer.UUID{}, familiesOn(t), &telemetrytypes.TelemetryFieldKey{Name: requested}, fieldKeys)
-		require.Len(t, fields, 1, "a family is one logical field, requested via %s", requested)
-		logical := fields[0]
-		assert.Equal(t, requested, logical.Name, "response identity is the requested spelling")
-		assert.Equal(t, telemetrytypes.FieldContextResource, logical.FieldContext)
-		assert.True(t, logical.IsFamily())
-		assert.Equal(t, []string{"deployment.environment.name", "deployment.environment"}, memberNames(logical),
-			"members are current-first regardless of the requested spelling")
-	}
-}
-
-// Member precedence is the family's current-first order, not lookup arrival
-// order: a current-name key found only under its context-prefixed spelling
-// arrives in the second lookup pass yet must still sort first.
-func TestMatchingLogicalFieldsOrdersMembersByFamilyRank(t *testing.T) {
-	fieldKeys := map[string][]*telemetrytypes.TelemetryFieldKey{
-		"deployment.environment": {{
-			Name:          "deployment.environment",
-			Signal:        telemetrytypes.SignalTraces,
-			FieldContext:  telemetrytypes.FieldContextResource,
-			FieldDataType: telemetrytypes.FieldDataTypeString,
-		}},
-		"resource.deployment.environment.name": {{
-			Name:          "resource.deployment.environment.name",
-			Signal:        telemetrytypes.SignalTraces,
-			FieldContext:  telemetrytypes.FieldContextResource,
-			FieldDataType: telemetrytypes.FieldDataTypeString,
-		}},
-	}
-
-	fields := MatchingLogicalFields(context.Background(), valuer.UUID{}, familiesOn(t), &telemetrytypes.TelemetryFieldKey{
-		Name:         "deployment.environment.name",
-		FieldContext: telemetrytypes.FieldContextResource,
-	}, fieldKeys)
-
-	require.Len(t, fields, 1)
-	assert.Equal(t, []string{"resource.deployment.environment.name", "deployment.environment"}, memberNames(fields[0]))
-}
-
-// Non-trace signals have no family support: the requested spelling stays
-// literal, and a family member name never pulls in its siblings.
-func TestMatchingLogicalFieldsKeepsLogsLiteral(t *testing.T) {
-	logsKey := func(name string) *telemetrytypes.TelemetryFieldKey {
-		return &telemetrytypes.TelemetryFieldKey{
-			Name:          name,
-			Signal:        telemetrytypes.SignalLogs,
-			FieldContext:  telemetrytypes.FieldContextResource,
-			FieldDataType: telemetrytypes.FieldDataTypeString,
-		}
-	}
-	fieldKeys := map[string][]*telemetrytypes.TelemetryFieldKey{
-		"deployment.environment.name": {logsKey("deployment.environment.name")},
-		"deployment.environment":      {logsKey("deployment.environment")},
-	}
-
-	fields := MatchingLogicalFields(context.Background(), valuer.UUID{}, familiesOn(t), &telemetrytypes.TelemetryFieldKey{Name: "deployment.environment.name"}, fieldKeys)
-	require.Len(t, fields, 1)
-	assert.False(t, fields[0].IsFamily())
-	assert.Equal(t, []string{"deployment.environment.name"}, memberNames(fields[0]))
-}
-
-// A family and a genuine same-name collision stack cleanly: the family stays
-// one logical field, the collision adds another, and resource preference keeps
-// the family as a unit.
-func TestResolveLogicalFieldsKeepsFamilyThroughAmbiguity(t *testing.T) {
-	fieldKeys := map[string][]*telemetrytypes.TelemetryFieldKey{
-		"deployment.environment.name": {
-			{
-				Name:          "deployment.environment.name",
-				Signal:        telemetrytypes.SignalTraces,
-				FieldContext:  telemetrytypes.FieldContextResource,
-				FieldDataType: telemetrytypes.FieldDataTypeString,
-			},
-			{
-				Name:          "deployment.environment.name",
-				Signal:        telemetrytypes.SignalTraces,
-				FieldContext:  telemetrytypes.FieldContextAttribute,
-				FieldDataType: telemetrytypes.FieldDataTypeString,
-			},
-		},
-		"deployment.environment": {{
-			Name:          "deployment.environment",
-			Signal:        telemetrytypes.SignalTraces,
-			FieldContext:  telemetrytypes.FieldContextResource,
-			FieldDataType: telemetrytypes.FieldDataTypeString,
-		}},
-	}
-
-	requested := &telemetrytypes.TelemetryFieldKey{Name: "deployment.environment.name"}
-	fields := MatchingLogicalFields(context.Background(), valuer.UUID{}, familiesOn(t), requested, fieldKeys)
-	require.Len(t, fields, 2, "resource family + attribute collision")
-
-	resolved, warning := ResolveLogicalFields(requested, fields)
-	assert.NotEmpty(t, warning)
-	require.Len(t, resolved, 1)
-	assert.Equal(t, telemetrytypes.FieldContextResource, resolved[0].FieldContext)
-	assert.Equal(t, []string{"deployment.environment.name", "deployment.environment"}, memberNames(resolved[0]))
-}
-
-// Members of a family with different data types never merge: the identity
-// (signal, context, data type) separates them into distinct logical fields.
-func TestMatchingLogicalFieldsNeverMergesAcrossDataTypes(t *testing.T) {
-	fieldKeys := map[string][]*telemetrytypes.TelemetryFieldKey{
-		"deployment.environment.name": {{
-			Name:          "deployment.environment.name",
-			Signal:        telemetrytypes.SignalTraces,
-			FieldContext:  telemetrytypes.FieldContextResource,
-			FieldDataType: telemetrytypes.FieldDataTypeString,
-		}},
-		"deployment.environment": {{
-			Name:          "deployment.environment",
-			Signal:        telemetrytypes.SignalTraces,
-			FieldContext:  telemetrytypes.FieldContextResource,
-			FieldDataType: telemetrytypes.FieldDataTypeNumber,
-		}},
-	}
-
-	fields := MatchingLogicalFields(context.Background(), valuer.UUID{}, familiesOn(t), &telemetrytypes.TelemetryFieldKey{Name: "deployment.environment.name"}, fieldKeys)
-	require.Len(t, fields, 2)
-	for _, logical := range fields {
-		assert.False(t, logical.IsFamily())
-	}
-}
-
-func TestExpandKeySelectorsForFamilies(t *testing.T) {
-	selectors := []*telemetrytypes.FieldKeySelector{
-		{Name: "deployment.environment.name", Signal: telemetrytypes.SignalTraces, SelectorMatchType: telemetrytypes.FieldSelectorMatchTypeExact},
-		{Name: "service.name", Signal: telemetrytypes.SignalTraces, SelectorMatchType: telemetrytypes.FieldSelectorMatchTypeExact},
-		{Name: "deployment.environment.name", Signal: telemetrytypes.SignalLogs, SelectorMatchType: telemetrytypes.FieldSelectorMatchTypeExact},
-	}
-
-	expanded := ExpandKeySelectorsForFamilies(context.Background(), valuer.UUID{}, familiesOn(t), selectors)
-
-	names := make([]string, 0, len(expanded))
-	for _, selector := range expanded {
-		names = append(names, selector.Name)
-	}
-	assert.Equal(t, []string{
-		"deployment.environment.name",
-		"service.name",
-		"deployment.environment.name",
-		"deployment.environment",
-	}, names, "one sibling selector for the trace family member; logs and non-family names untouched")
-
-	sibling := expanded[len(expanded)-1]
-	assert.Equal(t, telemetrytypes.SignalTraces, sibling.Signal)
-	assert.Equal(t, telemetrytypes.FieldSelectorMatchTypeExact, sibling.SelectorMatchType)
-}
-
-func TestExpandKeySelectorsForFamiliesDeduplicatesAndSkipsFuzzy(t *testing.T) {
-	both := []*telemetrytypes.FieldKeySelector{
-		{Name: "deployment.environment.name", Signal: telemetrytypes.SignalTraces, SelectorMatchType: telemetrytypes.FieldSelectorMatchTypeExact},
-		{Name: "deployment.environment", Signal: telemetrytypes.SignalTraces, SelectorMatchType: telemetrytypes.FieldSelectorMatchTypeExact},
-	}
-	assert.Len(t, ExpandKeySelectorsForFamilies(context.Background(), valuer.UUID{}, familiesOn(t), both), 2, "both spellings already referenced")
-
-	fuzzy := []*telemetrytypes.FieldKeySelector{
-		{Name: "deployment.environment.name", Signal: telemetrytypes.SignalTraces, SelectorMatchType: telemetrytypes.FieldSelectorMatchTypeFuzzy},
-	}
-	assert.Len(t, ExpandKeySelectorsForFamilies(context.Background(), valuer.UUID{}, familiesOn(t), fuzzy), 1, "fuzzy (search-style) selectors never expand")
-}

pkg/querybuilder/where_clause_visitor.go

@@ -9,9 +9,7 @@ import (
 	"strings"
 
 	"github.com/SigNoz/signoz/pkg/errors"
-	"github.com/SigNoz/signoz/pkg/flagger"
 	grammar "github.com/SigNoz/signoz/pkg/parser/filterquery/grammar"
-	"github.com/SigNoz/signoz/pkg/semconv"
 	qbtypes "github.com/SigNoz/signoz/pkg/types/querybuildertypes/querybuildertypesv5"
 	"github.com/SigNoz/signoz/pkg/types/telemetrytypes"
 	"github.com/SigNoz/signoz/pkg/valuer"
@@ -29,7 +27,6 @@ const stringMatchingOperatorDocURL = "https://signoz.io/docs/userguide/operators
 type filterExpressionVisitor struct {
 	context            context.Context
 	orgID              valuer.UUID
-	fl                 flagger.Flagger
 	fieldMapper        qbtypes.FieldMapper
 	conditionBuilder   qbtypes.ConditionBuilder
 	warnings           []string
@@ -51,11 +48,8 @@ type filterExpressionVisitor struct {
 }
 
 type FilterExprVisitorOpts struct {
-	Context context.Context
-	OrgID   valuer.UUID
-	// Flagger evaluates the resolve_semconv_families flag during resolution.
-	// A nil Flagger keeps resolution literal.
-	Flagger            flagger.Flagger
+	Context            context.Context
+	OrgID              valuer.UUID
 	Logger             *slog.Logger
 	FieldMapper        qbtypes.FieldMapper
 	ConditionBuilder   qbtypes.ConditionBuilder
@@ -74,7 +68,6 @@ func newFilterExpressionVisitor(opts FilterExprVisitorOpts) *filterExpressionVis
 	return &filterExpressionVisitor{
 		context:            opts.Context,
 		orgID:              opts.OrgID,
-		fl:                 opts.Flagger,
 		fieldMapper:        opts.FieldMapper,
 		conditionBuilder:   opts.ConditionBuilder,
 		fieldKeys:          opts.FieldKeys,
@@ -367,7 +360,7 @@ func (v *filterExpressionVisitor) VisitPrimary(ctx *grammar.PrimaryContext) any
 				return ErrorConditionLiteral
 			}
 		}
-		conds, ok := v.buildConditions(v.fullTextColumn, []*telemetrytypes.LogicalField{telemetrytypes.SingleLogicalField(v.fullTextColumn.Name, v.fullTextColumn)}, qbtypes.FilterOperatorRegexp, FormatFullTextSearch(searchText))
+		conds, ok := v.buildConditions(v.fullTextColumn, []*telemetrytypes.TelemetryFieldKey{v.fullTextColumn}, qbtypes.FilterOperatorRegexp, FormatFullTextSearch(searchText))
 		if !ok {
 			return ErrorConditionLiteral
 		}
@@ -386,7 +379,7 @@ func (v *filterExpressionVisitor) VisitPrimary(ctx *grammar.PrimaryContext) any
 // VisitComparison handles all comparison operators.
 func (v *filterExpressionVisitor) VisitComparison(ctx *grammar.ComparisonContext) any {
 	key := v.Visit(ctx.Key()).(*telemetrytypes.TelemetryFieldKey)
-	matching := MatchingLogicalFields(v.context, v.orgID, v.fl, key, v.fieldKeys)
+	matching := MatchingFieldKeys(key, v.fieldKeys)
 
 	// Handle EXISTS specially
 	if ctx.EXISTS() != nil {
@@ -682,7 +675,7 @@ func (v *filterExpressionVisitor) VisitFullText(ctx *grammar.FullTextContext) an
 		v.errors = append(v.errors, "full text search is not supported")
 		return ErrorConditionLiteral
 	}
-	conds, ok := v.buildConditions(v.fullTextColumn, []*telemetrytypes.LogicalField{telemetrytypes.SingleLogicalField(v.fullTextColumn.Name, v.fullTextColumn)}, qbtypes.FilterOperatorRegexp, FormatFullTextSearch(text))
+	conds, ok := v.buildConditions(v.fullTextColumn, []*telemetrytypes.TelemetryFieldKey{v.fullTextColumn}, qbtypes.FilterOperatorRegexp, FormatFullTextSearch(text))
 	if !ok {
 		return ErrorConditionLiteral
 	}
@@ -737,7 +730,7 @@ func (v *filterExpressionVisitor) VisitFunctionCall(ctx *grammar.FunctionCallCon
 		return ErrorConditionLiteral
 	}
 
-	conds, ok := v.buildConditions(key, MatchingLogicalFields(v.context, v.orgID, v.fl, key, v.fieldKeys), operator, value)
+	conds, ok := v.buildConditions(key, MatchingFieldKeys(key, v.fieldKeys), operator, value)
 	if !ok {
 		return ErrorConditionLiteral
 	}
@@ -929,7 +922,7 @@ func (v *filterExpressionVisitor) VisitKey(ctx *grammar.KeyContext) any {
 
 // buildConditions invokes the condition builder for a filter term, folding its
 // warnings/errors into visitor state; returns false if an error was recorded.
-func (v *filterExpressionVisitor) buildConditions(key *telemetrytypes.TelemetryFieldKey, matching []*telemetrytypes.LogicalField, op qbtypes.FilterOperator, value any) ([]string, bool) {
+func (v *filterExpressionVisitor) buildConditions(key *telemetrytypes.TelemetryFieldKey, matching []*telemetrytypes.TelemetryFieldKey, op qbtypes.FilterOperator, value any) ([]string, bool) {
 	conds, warns, err := v.conditionBuilder.ConditionFor(v.context, v.orgID, v.startNs, v.endNs, key, v.fieldKeys, qbtypes.ConditionBuilderOptions{SkipResourceFilter: v.skipResourceFilter}, op, value, v.builder)
 	if err != nil {
 		_, _, _, _, errURL, _ := errors.Unwrapb(err)
@@ -986,161 +979,30 @@ func assignIfEmpty(s *string, value string) {
 	}
 }
 
-// familyMemberNames returns the physical spellings to look up for the
-// referenced key: the semantic-convention family members (current-first) when
-// the resolve_semconv_families flag is on for the org and the key can resolve
-// to traces, else just the requested name. Only trace field mappers understand
-// families today; logs and metrics keep the requested spelling until theirs
-// land.
-func familyMemberNames(ctx context.Context, orgID valuer.UUID, fl flagger.Flagger, field *telemetrytypes.TelemetryFieldKey) []string {
-	if !semconvFamiliesEnabled(ctx, orgID, fl) {
-		return []string{field.Name}
-	}
-	if field.Signal != telemetrytypes.SignalUnspecified && field.Signal != telemetrytypes.SignalTraces {
-		return []string{field.Name}
-	}
-	return semconv.Members(semconv.KindAttribute, telemetrytypes.FieldKeySelector{
-		Name:         field.Name,
-		Signal:       telemetrytypes.SignalTraces,
-		FieldContext: field.FieldContext,
-	})
-}
+// MatchingFieldKeys returns the field keys from the map that match the given key,
+// honoring any context/data type the user specified.
+func MatchingFieldKeys(field *telemetrytypes.TelemetryFieldKey, fieldKeys map[string][]*telemetrytypes.TelemetryFieldKey) []*telemetrytypes.TelemetryFieldKey {
+	fieldKeysForName := []*telemetrytypes.TelemetryFieldKey{}
 
-// MatchingLogicalFields resolves the referenced key against the metadata map
-// into logical fields, honoring any context/data type the user specified.
-//
-// Physical keys that are members of one semantic-convention family (traces
-// only today) group into one logical field per (signal, context, data type)
-// identity, members ordered current-first. Every other matching key becomes
-// its own single-member logical field. Ambiguity is the length of the
-// returned slice: one family is one element and is never ambiguous with
-// itself, but the slice can hold several logical fields — including several
-// family fields, one per identity, when the family exists under more than
-// one context or data type. Members alias the metadata map entries; nothing
-// is copied or mutated.
-//
-// Family grouping only happens when the resolve_semconv_families flag is on
-// for the org. A nil flagger means off: every match then stays a
-// single-member logical field.
-func MatchingLogicalFields(ctx context.Context, orgID valuer.UUID, fl flagger.Flagger, field *telemetrytypes.TelemetryFieldKey, fieldKeys map[string][]*telemetrytypes.TelemetryFieldKey) []*telemetrytypes.LogicalField {
-	members := familyMemberNames(ctx, orgID, fl, field)
-	matches := collectMemberMatches(field, members, fieldKeys)
-	return groupIntoLogicalFields(field.Name, len(members) > 1, matches)
-}
-
-// memberMatch pairs a metadata entry with the family rank of the member name
-// it matched under. The stored name of a context-prefixed match differs from
-// the member name, so the rank must travel with the match.
-type memberMatch struct {
-	key  *telemetrytypes.TelemetryFieldKey
-	rank int
-}
-
-// matchesRequestedIdentity reports whether the entry fits the context and data
-// type that the request specified; unspecified matches any. A context-prefixed
-// lookup already matched the context through the lookup key itself.
-func matchesRequestedIdentity(field, item *telemetrytypes.TelemetryFieldKey, contextMatched bool) bool {
-	if !contextMatched && field.FieldContext != telemetrytypes.FieldContextUnspecified && field.FieldContext != item.FieldContext {
-		return false
-	}
-	if field.FieldDataType != telemetrytypes.FieldDataTypeUnspecified && field.FieldDataType != item.FieldDataType {
-		return false
-	}
-	return true
-}
-
-// inFamilyScope reports whether a match found under a sibling member name is
-// legitimate: the entry must be trace metadata, and the member must be in the
-// family of the requested name for the entry's context. A member lookup can
-// otherwise find a same-named field in a scope where the family does not
-// apply.
-func inFamilyScope(field, item *telemetrytypes.TelemetryFieldKey, memberName string) bool {
-	if item.Signal != telemetrytypes.SignalTraces {
-		return false
-	}
-	return slices.Contains(semconv.Members(semconv.KindAttribute, telemetrytypes.FieldKeySelector{
-		Name:         field.Name,
-		Signal:       telemetrytypes.SignalTraces,
-		FieldContext: item.FieldContext,
-	}), memberName)
-}
-
-// collectMemberMatches finds the metadata entries for every member spelling:
-// first under the member names, then under their context-prefixed spellings
-// (a context can be a legitimate part of a stored name, e.g. `attribute.key`).
-func collectMemberMatches(field *telemetrytypes.TelemetryFieldKey, members []string, fieldKeys map[string][]*telemetrytypes.TelemetryFieldKey) []memberMatch {
-	matches := make([]memberMatch, 0)
-	collect := func(lookupName string, rank int, memberName string, contextMatched bool) {
-		for _, item := range fieldKeys[lookupName] {
-			if !matchesRequestedIdentity(field, item, contextMatched) {
-				continue
-			}
-			if memberName != field.Name && !inFamilyScope(field, item, memberName) {
-				continue
-			}
-			matches = append(matches, memberMatch{key: item, rank: rank})
+	// match by name; keep items whose context and data type match (unspecified matches any)
+	for _, item := range fieldKeys[field.Name] {
+		if (field.FieldContext == telemetrytypes.FieldContextUnspecified || field.FieldContext == item.FieldContext) &&
+			(field.FieldDataType == telemetrytypes.FieldDataTypeUnspecified || field.FieldDataType == item.FieldDataType) {
+			fieldKeysForName = append(fieldKeysForName, item)
 		}
 	}
 
-	for rank, member := range members {
-		collect(member, rank, member, false)
-	}
+	// A context may have been split off a name that legitimately contained it (e.g.
+	// `attribute.key`); also look up the context-prefixed name so both readings resolve.
 	if field.FieldContext != telemetrytypes.FieldContextUnspecified {
-		for rank, member := range members {
-			collect(fmt.Sprintf("%s.%s", field.FieldContext.StringValue(), member), rank, member, true)
-		}
-	}
-	return matches
-}
-
-// groupIntoLogicalFields turns matches into logical fields. Trace entries in
-// family mode group by their (signal, context, data type) identity; every
-// other entry becomes its own single-member field. Members sort by family
-// rank at the end: precedence is a property of the family, not of the order
-// in which the lookups found the members.
-func groupIntoLogicalFields(requestedName string, familyMode bool, matches []memberMatch) []*telemetrytypes.LogicalField {
-	fields := make([]*telemetrytypes.LogicalField, 0, len(matches))
-	groups := make(map[string]*telemetrytypes.LogicalField)
-	ranks := make(map[*telemetrytypes.TelemetryFieldKey]int)
-
-	for _, match := range matches {
-		if !familyMode || match.key.Signal != telemetrytypes.SignalTraces {
-			fields = append(fields, telemetrytypes.SingleLogicalField(requestedName, match.key))
-			continue
-		}
-
-		identity := match.key.Signal.StringValue() + ";" + match.key.FieldContext.StringValue() + ";" + match.key.FieldDataType.StringValue()
-		group, ok := groups[identity]
-		if !ok {
-			group = &telemetrytypes.LogicalField{
-				Name:          requestedName,
-				Signal:        match.key.Signal,
-				FieldContext:  match.key.FieldContext,
-				FieldDataType: match.key.FieldDataType,
+		contextPrefixedFieldName := fmt.Sprintf("%s.%s", field.FieldContext.StringValue(), field.Name)
+		for _, item := range fieldKeys[contextPrefixedFieldName] {
+			// Context already matched via the lookup key; only data type needs checking.
+			if field.FieldDataType == telemetrytypes.FieldDataTypeUnspecified || item.FieldDataType == field.FieldDataType {
+				fieldKeysForName = append(fieldKeysForName, item)
 			}
-			groups[identity] = group
-			fields = append(fields, group)
 		}
-		if groupHasMemberNamed(group, match.key.Name) {
-			continue
-		}
-		ranks[match.key] = match.rank
-		group.Members = append(group.Members, match.key)
 	}
 
-	for _, logical := range fields {
-		slices.SortStableFunc(logical.Members, func(a, b *telemetrytypes.TelemetryFieldKey) int {
-			return ranks[a] - ranks[b]
-		})
-	}
-	return fields
-}
-
-func groupHasMemberNamed(group *telemetrytypes.LogicalField, name string) bool {
-	for _, member := range group.Members {
-		if member.Name == name {
-			return true
-		}
-	}
-	return false
+	return fieldKeysForName
 }

pkg/querybuilder/where_clause_visitor_test.go

@@ -588,11 +588,9 @@ func TestVisitKey(t *testing.T) {
 
 			// VisitKey only parses; the condition builder matches, resolves ambiguity
 			// and decides not-found handling. Replay that here against the generic
-			// builder behavior (error unless the key is ignored). The test maps carry
-			// no signal, so every logical field is single-member and flattens losslessly.
-			matching := MatchingLogicalFields(context.Background(), valuer.UUID{}, nil, key, tt.fieldKeys)
-			resolved, warning := ResolveLogicalFields(key, matching)
-			keys := SingleKeys(resolved)
+			// builder behavior (error unless the key is ignored).
+			matching := MatchingFieldKeys(key, tt.fieldKeys)
+			keys, warning := ResolveKeys(key, matching)
 
 			var gotErrors []string
 			var gotMainErrURL, gotMainWrnURL string
@@ -768,8 +766,7 @@ func (b *resourceConditionBuilder) ConditionFor(
 		return nil, nil, nil
 	}
 
-	resolved, warning := ResolveLogicalFields(key, MatchingLogicalFields(context.Background(), valuer.UUID{}, nil, key, fieldKeys))
-	keys := SingleKeys(resolved)
+	keys, warning := ResolveKeys(key, MatchingFieldKeys(key, fieldKeys))
 	var warnings []string
 	if warning != "" {
 		warnings = append(warnings, warning)
@@ -811,8 +808,7 @@ func (b *conditionBuilder) ConditionFor(
 		return []string{fmt.Sprintf("%s_cond", key.Name)}, nil, nil
 	}
 
-	resolved, warning := ResolveLogicalFields(key, MatchingLogicalFields(context.Background(), valuer.UUID{}, nil, key, fieldKeys))
-	keys := SingleKeys(resolved)
+	keys, warning := ResolveKeys(key, MatchingFieldKeys(key, fieldKeys))
 	var warnings []string
 	if warning != "" {
 		warnings = append(warnings, warning)

pkg/statementbuilder/resourcefilter/condition_builder.go

@@ -5,7 +5,6 @@ import (
 	"fmt"
 
 	"github.com/SigNoz/signoz/pkg/errors"
-	"github.com/SigNoz/signoz/pkg/flagger"
 	"github.com/SigNoz/signoz/pkg/querybuilder"
 	qbtypes "github.com/SigNoz/signoz/pkg/types/querybuildertypes/querybuildertypesv5"
 	"github.com/SigNoz/signoz/pkg/types/telemetrytypes"
@@ -15,15 +14,12 @@ import (
 
 type defaultConditionBuilder struct {
 	fm qbtypes.FieldMapper
-	// fl evaluates the resolve_semconv_families flag during resolution.
-	// A nil flagger keeps resolution literal.
-	fl flagger.Flagger
 }
 
 var _ qbtypes.ConditionBuilder = (*defaultConditionBuilder)(nil)
 
-func NewConditionBuilder(fm qbtypes.FieldMapper, fl flagger.Flagger) *defaultConditionBuilder {
-	return &defaultConditionBuilder{fm: fm, fl: fl}
+func NewConditionBuilder(fm qbtypes.FieldMapper) *defaultConditionBuilder {
+	return &defaultConditionBuilder{fm: fm}
 }
 
 func valueForIndexFilter(op qbtypes.FilterOperator, key *telemetrytypes.TelemetryFieldKey, value any) any {
@@ -48,74 +44,10 @@ func keyIndexFilter(key *telemetrytypes.TelemetryFieldKey) any {
 	return fmt.Sprintf(`%%%s%%`, key.Name)
 }
 
-// The three helpers below take the members of one logical field. With a single
-// member they render exactly the pre-family shapes; a family widens key/value
-// index hints to any-member and presence to any-member (all-absent when negated).
-
-func keyIndexCondition(sb *sqlbuilder.SelectBuilder, column string, members []*telemetrytypes.TelemetryFieldKey) string {
-	conditions := make([]string, 0, len(members))
-	for _, member := range members {
-		conditions = append(conditions, sb.Like(column, keyIndexFilter(member)))
-	}
-	if len(conditions) == 1 {
-		return conditions[0]
-	}
-	return sb.Or(conditions...)
-}
-
-func valueIndexCondition(
-	sb *sqlbuilder.SelectBuilder,
-	column string,
-	members []*telemetrytypes.TelemetryFieldKey,
-	op qbtypes.FilterOperator,
-	value any,
-	caseInsensitive bool,
-) string {
-	conditions := make([]string, 0, len(members))
-	for _, member := range members {
-		patterns := valueForIndexFilter(op, member, value)
-		switch values := patterns.(type) {
-		case []string:
-			for _, pattern := range values {
-				conditions = append(conditions, sb.Like(column, pattern))
-			}
-		default:
-			if caseInsensitive {
-				conditions = append(conditions, sb.ILike(column, values))
-			} else {
-				conditions = append(conditions, sb.Like(column, values))
-			}
-		}
-	}
-	if len(conditions) == 1 {
-		return conditions[0]
-	}
-	return sb.Or(conditions...)
-}
-
-func memberPresenceCondition(sb *sqlbuilder.SelectBuilder, column string, members []*telemetrytypes.TelemetryFieldKey, exists bool) string {
-	conditions := make([]string, 0, len(members))
-	for _, member := range members {
-		field := fmt.Sprintf("simpleJSONHas(%s, '%s')", column, member.Name)
-		if exists {
-			conditions = append(conditions, sb.E(field, true))
-		} else {
-			conditions = append(conditions, sb.NE(field, true))
-		}
-	}
-	if exists {
-		if len(conditions) == 1 {
-			return conditions[0]
-		}
-		return sb.Or(conditions...)
-	}
-	return sb.And(conditions...)
-}
-
 // SkipResourceFilter is not applicable here: the fingerprint table only stores resource attributes.
 func (b *defaultConditionBuilder) ConditionFor(
 	ctx context.Context,
-	orgID valuer.UUID,
+	_ valuer.UUID,
 	startNs uint64,
 	endNs uint64,
 	key *telemetrytypes.TelemetryFieldKey,
@@ -125,7 +57,7 @@ func (b *defaultConditionBuilder) ConditionFor(
 	value any,
 	sb *sqlbuilder.SelectBuilder,
 ) ([]string, []string, error) {
-	matches := querybuilder.MatchingLogicalFields(ctx, orgID, b.fl, key, fieldKeys)
+	matches := querybuilder.MatchingFieldKeys(key, fieldKeys)
 
 	// has/hasAny/hasAll/hasToken are logs-body-only functions; they never apply to the
 	// resource fingerprint table, so skip them (the main query still evaluates them).
@@ -133,21 +65,21 @@ func (b *defaultConditionBuilder) ConditionFor(
 		return nil, nil, nil
 	}
 
-	logicalFields, warning := querybuilder.ResolveLogicalFields(key, matches)
+	keys, warning := querybuilder.ResolveKeys(key, matches)
 	var warnings []string
 	if warning != "" {
 		warnings = append(warnings, warning)
 	}
 
-	conds := make([]string, 0, len(logicalFields))
-	for _, logical := range logicalFields {
-		// the resource fingerprint table only stores resource attributes; fields from
+	conds := make([]string, 0, len(keys))
+	for _, k := range keys {
+		// the resource fingerprint table only stores resource attributes; keys from
 		// any other context contribute no condition and are omitted. An empty result
 		// (including an unknown key) lets the caller skip this filter entirely.
-		if logical.FieldContext != telemetrytypes.FieldContextResource {
+		if k.FieldContext != telemetrytypes.FieldContextResource {
 			continue
 		}
-		cond, err := b.conditionForLogicalField(ctx, orgID, startNs, endNs, logical, op, value, sb)
+		cond, err := b.conditionForKey(ctx, startNs, endNs, k, op, value, sb)
 		if err != nil {
 			return nil, nil, err
 		}
@@ -156,12 +88,11 @@ func (b *defaultConditionBuilder) ConditionFor(
 	return conds, warnings, nil
 }
 
-func (b *defaultConditionBuilder) conditionForLogicalField(
+func (b *defaultConditionBuilder) conditionForKey(
 	ctx context.Context,
-	orgID valuer.UUID,
 	startNs uint64,
 	endNs uint64,
-	logical *telemetrytypes.LogicalField,
+	key *telemetrytypes.TelemetryFieldKey,
 	op qbtypes.FilterOperator,
 	value any,
 	sb *sqlbuilder.SelectBuilder,
@@ -171,9 +102,7 @@ func (b *defaultConditionBuilder) conditionForLogicalField(
 	// as we store resource values as string
 	formattedValue := querybuilder.FormatValueForContains(value)
 
-	// Every resource-context key maps to the labels column, so any member
-	// resolves the column for the whole field.
-	columns, err := b.fm.ColumnFor(ctx, orgID, startNs, endNs, logical.Single())
+	columns, err := b.fm.ColumnFor(ctx, valuer.UUID{}, startNs, endNs, key)
 	if err != nil {
 		return "", err
 	}
@@ -186,12 +115,10 @@ func (b *defaultConditionBuilder) conditionForLogicalField(
 	// as we have not changed the resource column in the resource fingerprint table.
 	column := columns[0]
 
-	members := logical.Members
-	isFamily := logical.IsFamily()
-	keyIdxFilter := keyIndexCondition(sb, column.Name, members)
-	singleValueIndexFilter := valueForIndexFilter(op, members[0], value)
+	keyIdxFilter := sb.Like(column.Name, keyIndexFilter(key))
+	valueForIndexFilter := valueForIndexFilter(op, key, value)
 
-	fieldName, err := querybuilder.LogicalValueExpr(ctx, orgID, startNs, endNs, b.fm, logical)
+	fieldName, err := b.fm.FieldFor(ctx, valuer.UUID{}, startNs, endNs, key)
 	if err != nil {
 		return "", err
 	}
@@ -201,17 +128,12 @@ func (b *defaultConditionBuilder) conditionForLogicalField(
 		return sb.And(
 			sb.E(fieldName, formattedValue),
 			keyIdxFilter,
-			valueIndexCondition(sb, column.Name, members, op, value, false),
+			sb.Like(column.Name, valueForIndexFilter),
 		), nil
 	case qbtypes.FilterOperatorNotEqual:
-		if isFamily {
-			// A negated value-index hint would drop rows where another member
-			// holds the value; the fingerprint scan is small enough without it.
-			return sb.NE(fieldName, formattedValue), nil
-		}
 		return sb.And(
 			sb.NE(fieldName, formattedValue),
-			sb.NotLike(column.Name, singleValueIndexFilter),
+			sb.NotLike(column.Name, valueForIndexFilter),
 		), nil
 	case qbtypes.FilterOperatorGreaterThan:
 		return sb.And(sb.GT(fieldName, formattedValue), keyIdxFilter), nil
@@ -226,7 +148,7 @@ func (b *defaultConditionBuilder) conditionForLogicalField(
 		return sb.And(
 			sb.ILike(fieldName, formattedValue),
 			keyIdxFilter,
-			valueIndexCondition(sb, column.Name, members, op, value, true),
+			sb.ILike(column.Name, valueForIndexFilter),
 		), nil
 	case qbtypes.FilterOperatorNotLike, qbtypes.FilterOperatorNotILike:
 		// no index filter: as cannot apply `not contains x%y` as y can be somewhere else
@@ -263,11 +185,13 @@ func (b *defaultConditionBuilder) conditionForLogicalField(
 			inConditions = append(inConditions, sb.E(fieldName, querybuilder.FormatValueForContains(v)))
 		}
 		mainCondition := sb.Or(inConditions...)
-		mainCondition = sb.And(
-			mainCondition,
-			keyIdxFilter,
-			valueIndexCondition(sb, column.Name, members, op, value, false),
-		)
+		valConditions := make([]string, 0, len(values))
+		if valuesForIndexFilter, ok := valueForIndexFilter.([]string); ok {
+			for _, v := range valuesForIndexFilter {
+				valConditions = append(valConditions, sb.Like(column.Name, v))
+			}
+		}
+		mainCondition = sb.And(mainCondition, keyIdxFilter, sb.Or(valConditions...))
 
 		return mainCondition, nil
 	case qbtypes.FilterOperatorNotIn:
@@ -280,13 +204,8 @@ func (b *defaultConditionBuilder) conditionForLogicalField(
 			notInConditions = append(notInConditions, sb.NE(fieldName, querybuilder.FormatValueForContains(v)))
 		}
 		mainCondition := sb.And(notInConditions...)
-		if isFamily {
-			// A negated value-index hint would drop rows where another member
-			// holds the value; the fingerprint scan is small enough without it.
-			return mainCondition, nil
-		}
 		valConditions := make([]string, 0, len(values))
-		if valuesForIndexFilter, ok := singleValueIndexFilter.([]string); ok {
+		if valuesForIndexFilter, ok := valueForIndexFilter.([]string); ok {
 			for _, v := range valuesForIndexFilter {
 				valConditions = append(valConditions, sb.NotLike(column.Name, v))
 			}
@@ -296,11 +215,13 @@ func (b *defaultConditionBuilder) conditionForLogicalField(
 
 	case qbtypes.FilterOperatorExists:
 		return sb.And(
-			memberPresenceCondition(sb, column.Name, members, true),
+			sb.E(fmt.Sprintf("simpleJSONHas(%s, '%s')", column.Name, key.Name), true),
 			keyIdxFilter,
 		), nil
 	case qbtypes.FilterOperatorNotExists:
-		return memberPresenceCondition(sb, column.Name, members, false), nil
+		return sb.And(
+			sb.NE(fmt.Sprintf("simpleJSONHas(%s, '%s')", column.Name, key.Name), true),
+		), nil
 
 	case qbtypes.FilterOperatorRegexp:
 		return sb.And(
@@ -316,7 +237,7 @@ func (b *defaultConditionBuilder) conditionForLogicalField(
 		return sb.And(
 			sb.ILike(fieldName, fmt.Sprintf(`%%%s%%`, formattedValue)),
 			keyIdxFilter,
-			valueIndexCondition(sb, column.Name, members, op, value, true),
+			sb.ILike(column.Name, valueForIndexFilter),
 		), nil
 	case qbtypes.FilterOperatorNotContains:
 		// no index filter: as cannot apply `not contains x%y` as y can be somewhere else

pkg/statementbuilder/resourcefilter/condition_builder_test.go

@@ -2,7 +2,6 @@ package resourcefilter
 
 import (
 	"context"
-	"github.com/SigNoz/signoz/pkg/flagger/flaggertest"
 	"testing"
 
 	qbtypes "github.com/SigNoz/signoz/pkg/types/querybuildertypes/querybuildertypesv5"
@@ -202,7 +201,7 @@ func TestConditionBuilder(t *testing.T) {
 	}
 
 	fm := NewFieldMapper()
-	conditionBuilder := NewConditionBuilder(fm, flaggertest.New(t))
+	conditionBuilder := NewConditionBuilder(fm)
 
 	for _, tc := range testCases {
 		sb := sqlbuilder.NewSelectBuilder()

pkg/statementbuilder/resourcefilter/family_test.go

@@ -1,141 +0,0 @@
-package resourcefilter
-
-import (
-	"context"
-	"testing"
-
-	"github.com/SigNoz/signoz/pkg/flagger"
-	"github.com/SigNoz/signoz/pkg/flagger/flaggertest"
-	qbtypes "github.com/SigNoz/signoz/pkg/types/querybuildertypes/querybuildertypesv5"
-	"github.com/SigNoz/signoz/pkg/types/telemetrytypes"
-	"github.com/SigNoz/signoz/pkg/valuer"
-	"github.com/huandu/go-sqlbuilder"
-	"github.com/stretchr/testify/require"
-)
-
-// The tests below run against the deployment.environment(.name) family with
-// the resolve_semconv_families flag on, and with both spellings present in
-// the metadata map as trace resource attributes.
-
-func TestFamilyEqualWidensIndexHintsToAnyMember(t *testing.T) {
-	cb := NewConditionBuilder(NewFieldMapper(), flaggertest.WithBooleanFlags(t, map[string]bool{flagger.FeatureResolveSemconvFamilies.String(): true}))
-	fieldKeys := map[string][]*telemetrytypes.TelemetryFieldKey{
-		"deployment.environment.name": {{
-			Name:          "deployment.environment.name",
-			Signal:        telemetrytypes.SignalTraces,
-			FieldContext:  telemetrytypes.FieldContextResource,
-			FieldDataType: telemetrytypes.FieldDataTypeString,
-		}},
-		"deployment.environment": {{
-			Name:          "deployment.environment",
-			Signal:        telemetrytypes.SignalTraces,
-			FieldContext:  telemetrytypes.FieldContextResource,
-			FieldDataType: telemetrytypes.FieldDataTypeString,
-		}},
-	}
-
-	sb := sqlbuilder.NewSelectBuilder()
-	conds, _, err := cb.ConditionFor(context.Background(), valuer.UUID{}, 0, 0,
-		&telemetrytypes.TelemetryFieldKey{Name: "deployment.environment.name"},
-		fieldKeys, qbtypes.ConditionBuilderOptions{}, qbtypes.FilterOperatorEqual, "production", sb)
-	require.NoError(t, err)
-	require.Len(t, conds, 1)
-	sb.Where(conds...)
-	sql, args := sb.BuildWithFlavor(sqlbuilder.ClickHouse)
-	require.Equal(t, "WHERE (COALESCE(NULLIF(simpleJSONExtractString(labels, 'deployment.environment.name'), ''), NULLIF(simpleJSONExtractString(labels, 'deployment.environment'), ''), '') = ? AND (labels LIKE ? OR labels LIKE ?) AND (labels LIKE ? OR labels LIKE ?))", sql)
-	require.Equal(t, []any{"production", "%deployment.environment.name%", "%deployment.environment%", "%deployment.environment.name\":\"production%", "%deployment.environment\":\"production%"}, args)
-}
-
-func TestFamilyNotEqualDropsNegatedValueHint(t *testing.T) {
-	cb := NewConditionBuilder(NewFieldMapper(), flaggertest.WithBooleanFlags(t, map[string]bool{flagger.FeatureResolveSemconvFamilies.String(): true}))
-	fieldKeys := map[string][]*telemetrytypes.TelemetryFieldKey{
-		"deployment.environment.name": {{
-			Name:          "deployment.environment.name",
-			Signal:        telemetrytypes.SignalTraces,
-			FieldContext:  telemetrytypes.FieldContextResource,
-			FieldDataType: telemetrytypes.FieldDataTypeString,
-		}},
-		"deployment.environment": {{
-			Name:          "deployment.environment",
-			Signal:        telemetrytypes.SignalTraces,
-			FieldContext:  telemetrytypes.FieldContextResource,
-			FieldDataType: telemetrytypes.FieldDataTypeString,
-		}},
-	}
-
-	sb := sqlbuilder.NewSelectBuilder()
-	conds, _, err := cb.ConditionFor(context.Background(), valuer.UUID{}, 0, 0,
-		&telemetrytypes.TelemetryFieldKey{Name: "deployment.environment.name"},
-		fieldKeys, qbtypes.ConditionBuilderOptions{}, qbtypes.FilterOperatorNotEqual, "production", sb)
-	require.NoError(t, err)
-	require.Len(t, conds, 1)
-	sb.Where(conds...)
-	sql, args := sb.BuildWithFlavor(sqlbuilder.ClickHouse)
-	require.Equal(t, "WHERE COALESCE(NULLIF(simpleJSONExtractString(labels, 'deployment.environment.name'), ''), NULLIF(simpleJSONExtractString(labels, 'deployment.environment'), ''), '') <> ?", sql)
-	require.Equal(t, []any{"production"}, args)
-}
-
-func TestFamilyExistsIsAnyMemberPresence(t *testing.T) {
-	cb := NewConditionBuilder(NewFieldMapper(), flaggertest.WithBooleanFlags(t, map[string]bool{flagger.FeatureResolveSemconvFamilies.String(): true}))
-	fieldKeys := map[string][]*telemetrytypes.TelemetryFieldKey{
-		"deployment.environment.name": {{
-			Name:          "deployment.environment.name",
-			Signal:        telemetrytypes.SignalTraces,
-			FieldContext:  telemetrytypes.FieldContextResource,
-			FieldDataType: telemetrytypes.FieldDataTypeString,
-		}},
-		"deployment.environment": {{
-			Name:          "deployment.environment",
-			Signal:        telemetrytypes.SignalTraces,
-			FieldContext:  telemetrytypes.FieldContextResource,
-			FieldDataType: telemetrytypes.FieldDataTypeString,
-		}},
-	}
-
-	sb := sqlbuilder.NewSelectBuilder()
-	conds, _, err := cb.ConditionFor(context.Background(), valuer.UUID{}, 0, 0,
-		&telemetrytypes.TelemetryFieldKey{Name: "deployment.environment.name"},
-		fieldKeys, qbtypes.ConditionBuilderOptions{}, qbtypes.FilterOperatorExists, nil, sb)
-	require.NoError(t, err)
-	require.Len(t, conds, 1)
-	sb.Where(conds...)
-	sql, args := sb.BuildWithFlavor(sqlbuilder.ClickHouse)
-	require.Equal(t, "WHERE ((simpleJSONHas(labels, 'deployment.environment.name') = ? OR simpleJSONHas(labels, 'deployment.environment') = ?) AND (labels LIKE ? OR labels LIKE ?))", sql)
-	require.Equal(t, []any{true, true, "%deployment.environment.name%", "%deployment.environment%"}, args)
-
-	sb = sqlbuilder.NewSelectBuilder()
-	conds, _, err = cb.ConditionFor(context.Background(), valuer.UUID{}, 0, 0,
-		&telemetrytypes.TelemetryFieldKey{Name: "deployment.environment.name"},
-		fieldKeys, qbtypes.ConditionBuilderOptions{}, qbtypes.FilterOperatorNotExists, nil, sb)
-	require.NoError(t, err)
-	require.Len(t, conds, 1)
-	sb.Where(conds...)
-	sql, args = sb.BuildWithFlavor(sqlbuilder.ClickHouse)
-	require.Equal(t, "WHERE (simpleJSONHas(labels, 'deployment.environment.name') <> ? AND simpleJSONHas(labels, 'deployment.environment') <> ?)", sql)
-	require.Equal(t, []any{true, true}, args)
-}
-
-// With only one member in metadata the SQL keeps the exact pre-family shape,
-// including the negated value hint on !=.
-func TestSingleMemberShapesUnchanged(t *testing.T) {
-	cb := NewConditionBuilder(NewFieldMapper(), flaggertest.WithBooleanFlags(t, map[string]bool{flagger.FeatureResolveSemconvFamilies.String(): true}))
-	fieldKeys := map[string][]*telemetrytypes.TelemetryFieldKey{
-		"deployment.environment.name": {{
-			Name:          "deployment.environment.name",
-			Signal:        telemetrytypes.SignalTraces,
-			FieldContext:  telemetrytypes.FieldContextResource,
-			FieldDataType: telemetrytypes.FieldDataTypeString,
-		}},
-	}
-
-	sb := sqlbuilder.NewSelectBuilder()
-	conds, _, err := cb.ConditionFor(context.Background(), valuer.UUID{}, 0, 0,
-		&telemetrytypes.TelemetryFieldKey{Name: "deployment.environment.name"},
-		fieldKeys, qbtypes.ConditionBuilderOptions{}, qbtypes.FilterOperatorNotEqual, "production", sb)
-	require.NoError(t, err)
-	require.Len(t, conds, 1)
-	sb.Where(conds...)
-	sql, args := sb.BuildWithFlavor(sqlbuilder.ClickHouse)
-	require.Equal(t, "WHERE (simpleJSONExtractString(labels, 'deployment.environment.name') <> ? AND labels NOT LIKE ?)", sql)
-	require.Equal(t, []any{"production", "%deployment.environment.name\":\"production%"}, args)
-}

pkg/statementbuilder/resourcefilter/field_mapper.go

@@ -71,33 +71,6 @@ func (m *defaultFieldMapper) FieldFor(
 	return columns[0].Name, nil
 }
 
-// ExistsFor reports key presence in the fingerprint labels JSON. Only resource
-// context keys have a presence notion here; anything else is a real column and
-// always present.
-func (m *defaultFieldMapper) ExistsFor(
-	ctx context.Context,
-	_ valuer.UUID,
-	tsStart, tsEnd uint64,
-	key *telemetrytypes.TelemetryFieldKey,
-	exists bool,
-) (string, error) {
-	columns, err := m.getColumn(ctx, tsStart, tsEnd, key)
-	if err != nil {
-		return "", err
-	}
-	if key.FieldContext != telemetrytypes.FieldContextResource {
-		if exists {
-			return "true", nil
-		}
-		return "false", nil
-	}
-	pred := fmt.Sprintf("simpleJSONHas(%s, '%s')", columns[0].Name, key.Name)
-	if exists {
-		return pred, nil
-	}
-	return "NOT " + pred, nil
-}
-
 func (m *defaultFieldMapper) ColumnExpressionFor(
 	ctx context.Context,
 	orgID valuer.UUID,

pkg/statementbuilder/resourcefilter/statement_builder.go

@@ -47,7 +47,7 @@ func New[T any](
 ) *resourceFilterStatementBuilder[T] {
 	set := factory.NewScopedProviderSettings(settings, "github.com/SigNoz/signoz/pkg/statementbuilder/resourcefilter")
 	fm := NewFieldMapper()
-	cb := NewConditionBuilder(fm, fl)
+	cb := NewConditionBuilder(fm)
 	return &resourceFilterStatementBuilder[T]{
 		logger:           set.Logger(),
 		dbName:           dbName,
@@ -99,7 +99,7 @@ func (b *resourceFilterStatementBuilder[T]) Build(
 	q.Select("fingerprint")
 	q.From(fmt.Sprintf("%s.%s", b.dbName, b.tableName))
 
-	keySelectors := querybuilder.ExpandKeySelectorsForFamilies(ctx, orgID, b.flagger, b.getKeySelectors(query))
+	keySelectors := b.getKeySelectors(query)
 	keys, _, err := b.metadataStore.GetKeysMulti(ctx, orgID, keySelectors)
 	if err != nil {
 		return nil, err
@@ -164,7 +164,6 @@ func (b *resourceFilterStatementBuilder[T]) addConditions(
 		filterWhereClause, err := querybuilder.PrepareWhereClause(query.Filter.Expression, querybuilder.FilterExprVisitorOpts{
 			Context:            ctx,
 			OrgID:              orgID,
-			Flagger:            b.flagger,
 			Logger:             b.logger,
 			FieldMapper:        b.fieldMapper,
 			ConditionBuilder:   b.conditionBuilder,

pkg/statementbuilder/scopedtracesstatementbuilder/statement_builder.go

@@ -38,7 +38,6 @@ type scopedTraceStatementBuilder struct {
 	scope                     TraceScope
 	traceStmtBuilder          qbtypes.StatementBuilder[qbtypes.TraceAggregation]
 	resourceFilterStmtBuilder qbtypes.StatementBuilder[qbtypes.TraceAggregation]
-	fl                        flagger.Flagger
 }
 
 var _ qbtypes.StatementBuilder[qbtypes.TraceAggregation] = (*scopedTraceStatementBuilder)(nil)
@@ -60,8 +59,8 @@ func NewFactory(
 			if err != nil {
 				return nil, err
 			}
-			fm := tracestelemetryschema.NewFieldMapper(fl)
-			cb := tracestelemetryschema.NewConditionBuilder(fm, fl)
+			fm := tracestelemetryschema.NewFieldMapper()
+			cb := tracestelemetryschema.NewConditionBuilder(fm)
 			return NewScopedTraceStatementBuilder(settings, metadataStore, fm, cb, scope, traceStmtBuilder, fl), nil
 		},
 	)
@@ -99,7 +98,6 @@ func NewScopedTraceStatementBuilder(
 		scope:                     scope,
 		traceStmtBuilder:          traceStmtBuilder,
 		resourceFilterStmtBuilder: resourceFilterStmtBuilder,
-		fl:                        fl,
 	}
 }
 
@@ -268,7 +266,7 @@ func (b *scopedTraceStatementBuilder) fetchKeys(ctx context.Context, orgID value
 			SelectorMatchType: telemetrytypes.FieldSelectorMatchTypeExact,
 		})
 	}
-	keys, _, err := b.metadataStore.GetKeysMulti(ctx, orgID, querybuilder.ExpandKeySelectorsForFamilies(ctx, orgID, b.fl, selectors))
+	keys, _, err := b.metadataStore.GetKeysMulti(ctx, orgID, selectors)
 	return keys, err
 }
 
@@ -444,14 +442,13 @@ func (b *scopedTraceStatementBuilder) resolveSpanPredicate(ctx context.Context,
 	for i := range selectors {
 		selectors[i].Signal = telemetrytypes.SignalTraces
 	}
-	keys, _, err := b.metadataStore.GetKeysMulti(ctx, orgID, querybuilder.ExpandKeySelectorsForFamilies(ctx, orgID, b.fl, selectors))
+	keys, _, err := b.metadataStore.GetKeysMulti(ctx, orgID, selectors)
 	if err != nil {
 		return "", nil, "", err
 	}
 	prepared, err := querybuilder.PrepareWhereClause(expr, querybuilder.FilterExprVisitorOpts{
 		Context:          ctx,
 		OrgID:            orgID,
-		Flagger:          b.fl,
 		Logger:           b.logger,
 		FieldMapper:      b.fm,
 		ConditionBuilder: b.cb,

pkg/statementbuilder/tracesstatementbuilder/statement_builder.go

@@ -31,7 +31,6 @@ type traceQueryStatementBuilder struct {
 	cb                             qbtypes.ConditionBuilder
 	resourceFilterResolver         *resourcefilter.ResourceFingerprintResolver[qbtypes.TraceAggregation]
 	aggExprRewriter                qbtypes.AggExprRewriter
-	fl                             flagger.Flagger
 	skipResourceFingerprintEnabled bool
 }
 
@@ -48,8 +47,8 @@ func NewFactory(
 	return factory.NewProviderFactory(
 		factory.MustNewName("traces"),
 		func(_ context.Context, settings factory.ProviderSettings, cfg statementbuilder.Config) (qbtypes.StatementBuilder[qbtypes.TraceAggregation], error) {
-			fm := tracestelemetryschema.NewFieldMapper(fl)
-			cb := tracestelemetryschema.NewConditionBuilder(fm, fl)
+			fm := tracestelemetryschema.NewFieldMapper()
+			cb := tracestelemetryschema.NewConditionBuilder(fm)
 			aggExprRewriter := querybuilder.NewAggExprRewriter(settings, nil, fm, cb, fl)
 			return NewTraceQueryStatementBuilder(
 				settings, metadataStore, fm, cb, aggExprRewriter, telemetryStore, fl,
@@ -92,7 +91,6 @@ func NewTraceQueryStatementBuilder(
 		cb:                             conditionBuilder,
 		resourceFilterResolver:         resourceFilterResolver,
 		aggExprRewriter:                aggExprRewriter,
-		fl:                             flagger,
 		skipResourceFingerprintEnabled: skipResourceFingerprintEnable,
 	}
 }
@@ -121,7 +119,7 @@ func (b *traceQueryStatementBuilder) Build(
 
 	// We modify SelectFields above (injecting default fields), and those default
 	// fields can carry keys that need evolutions, so fetch keys after that.
-	keySelectors := querybuilder.ExpandKeySelectorsForFamilies(ctx, orgID, b.fl, getKeySelectors(query))
+	keySelectors := getKeySelectors(query)
 
 	keys, _, err := b.metadataStore.GetKeysMulti(ctx, orgID, keySelectors)
 	if err != nil {
@@ -797,7 +795,6 @@ func (b *traceQueryStatementBuilder) addFilterCondition(
 		preparedWhereClause, err = querybuilder.PrepareWhereClause(query.Filter.Expression, querybuilder.FilterExprVisitorOpts{
 			Context:            ctx,
 			OrgID:              orgID,
-			Flagger:            b.fl,
 			Logger:             b.logger,
 			FieldMapper:        b.fm,
 			ConditionBuilder:   b.cb,

pkg/statementbuilder/tracesstatementbuilder/stmt_builder_test.go

@@ -8,7 +8,6 @@ import (
 
 	cmock "github.com/SigNoz/clickhouse-go-mock"
 	"github.com/SigNoz/signoz/pkg/errors"
-	"github.com/SigNoz/signoz/pkg/flagger"
 	"github.com/SigNoz/signoz/pkg/flagger/flaggertest"
 	"github.com/SigNoz/signoz/pkg/instrumentation/instrumentationtest"
 	"github.com/SigNoz/signoz/pkg/querybuilder"
@@ -377,8 +376,8 @@ func TestStatementBuilder(t *testing.T) {
 	}
 
 	fl := flaggertest.New(t)
-	fm := tracestelemetryschema.NewFieldMapper(fl)
-	cb := tracestelemetryschema.NewConditionBuilder(fm, fl)
+	fm := tracestelemetryschema.NewFieldMapper()
+	cb := tracestelemetryschema.NewConditionBuilder(fm)
 	mockMetadataStore := telemetrytypestest.NewMockMetadataStore()
 	mockMetadataStore.KeysMap = tracestelemetryschema.BuildCompleteFieldKeyMap(releaseTime)
 	aggExprRewriter := querybuilder.NewAggExprRewriter(instrumentationtest.New().ToProviderSettings(), nil, fm, cb, fl)
@@ -678,8 +677,8 @@ func TestStatementBuilderListQuery(t *testing.T) {
 	}
 
 	fl := flaggertest.New(t)
-	fm := tracestelemetryschema.NewFieldMapper(fl)
-	cb := tracestelemetryschema.NewConditionBuilder(fm, fl)
+	fm := tracestelemetryschema.NewFieldMapper()
+	cb := tracestelemetryschema.NewConditionBuilder(fm)
 	mockMetadataStore := telemetrytypestest.NewMockMetadataStore()
 	mockMetadataStore.KeysMap = tracestelemetryschema.BuildCompleteFieldKeyMap(releaseTime)
 	aggExprRewriter := querybuilder.NewAggExprRewriter(instrumentationtest.New().ToProviderSettings(), nil, fm, cb, fl)
@@ -805,8 +804,8 @@ func TestStatementBuilderListQueryWithCorruptData(t *testing.T) {
 	for _, c := range cases {
 		t.Run(c.name, func(t *testing.T) {
 			fl := flaggertest.New(t)
-			fm := tracestelemetryschema.NewFieldMapper(fl)
-			cb := tracestelemetryschema.NewConditionBuilder(fm, fl)
+			fm := tracestelemetryschema.NewFieldMapper()
+			cb := tracestelemetryschema.NewConditionBuilder(fm)
 			mockMetadataStore := telemetrytypestest.NewMockMetadataStore()
 			mockMetadataStore.KeysMap = c.keysMap
 			if mockMetadataStore.KeysMap == nil {
@@ -880,8 +879,8 @@ func TestStatementBuilderGroupByResourceEvolution(t *testing.T) {
 	}
 
 	fl := flaggertest.New(t)
-	fm := tracestelemetryschema.NewFieldMapper(fl)
-	cb := tracestelemetryschema.NewConditionBuilder(fm, fl)
+	fm := tracestelemetryschema.NewFieldMapper()
+	cb := tracestelemetryschema.NewConditionBuilder(fm)
 	mockMetadataStore := telemetrytypestest.NewMockMetadataStore()
 	mockMetadataStore.KeysMap = tracestelemetryschema.BuildCompleteFieldKeyMap(releaseTime)
 	aggExprRewriter := querybuilder.NewAggExprRewriter(instrumentationtest.New().ToProviderSettings(), nil, fm, cb, fl)
@@ -1047,8 +1046,8 @@ func TestStatementBuilderTraceQuery(t *testing.T) {
 	}
 
 	fl := flaggertest.New(t)
-	fm := tracestelemetryschema.NewFieldMapper(fl)
-	cb := tracestelemetryschema.NewConditionBuilder(fm, fl)
+	fm := tracestelemetryschema.NewFieldMapper()
+	cb := tracestelemetryschema.NewConditionBuilder(fm)
 	mockMetadataStore := telemetrytypestest.NewMockMetadataStore()
 	mockMetadataStore.KeysMap = tracestelemetryschema.BuildCompleteFieldKeyMap(releaseTime)
 	aggExprRewriter := querybuilder.NewAggExprRewriter(instrumentationtest.New().ToProviderSettings(), nil, fm, cb, fl)
@@ -1685,8 +1684,8 @@ func newSkipResourceFingerprintBuilder(
 	t.Helper()
 
 	fl := flaggertest.New(t)
-	fm := tracestelemetryschema.NewFieldMapper(fl)
-	cb := tracestelemetryschema.NewConditionBuilder(fm, fl)
+	fm := tracestelemetryschema.NewFieldMapper()
+	cb := tracestelemetryschema.NewConditionBuilder(fm)
 	mockMetadataStore := telemetrytypestest.NewMockMetadataStore()
 	releaseTime := time.Date(2025, 5, 22, 22, 0, 0, 0, time.UTC)
 	mockMetadataStore.KeysMap = tracestelemetryschema.BuildCompleteFieldKeyMap(releaseTime)
@@ -1715,8 +1714,8 @@ func TestStatementBuilderGroupByUnseenKey(t *testing.T) {
 	releaseTime := time.Date(2025, 5, 22, 22, 0, 0, 0, time.UTC)
 
 	fl := flaggertest.New(t)
-	fm := tracestelemetryschema.NewFieldMapper(fl)
-	cb := tracestelemetryschema.NewConditionBuilder(fm, fl)
+	fm := tracestelemetryschema.NewFieldMapper()
+	cb := tracestelemetryschema.NewConditionBuilder(fm)
 	mockMetadataStore := telemetrytypestest.NewMockMetadataStore()
 	mockMetadataStore.KeysMap = tracestelemetryschema.BuildCompleteFieldKeyMap(releaseTime)
 	aggExprRewriter := querybuilder.NewAggExprRewriter(instrumentationtest.New().ToProviderSettings(), nil, fm, cb, fl)
@@ -1757,8 +1756,8 @@ func TestStatementBuilderAggregationUnseenKey(t *testing.T) {
 	releaseTime := time.Date(2025, 5, 22, 22, 0, 0, 0, time.UTC)
 
 	fl := flaggertest.New(t)
-	fm := tracestelemetryschema.NewFieldMapper(fl)
-	cb := tracestelemetryschema.NewConditionBuilder(fm, fl)
+	fm := tracestelemetryschema.NewFieldMapper()
+	cb := tracestelemetryschema.NewConditionBuilder(fm)
 	mockMetadataStore := telemetrytypestest.NewMockMetadataStore()
 	mockMetadataStore.KeysMap = tracestelemetryschema.BuildCompleteFieldKeyMap(releaseTime)
 	aggExprRewriter := querybuilder.NewAggExprRewriter(instrumentationtest.New().ToProviderSettings(), nil, fm, cb, fl)
@@ -1788,72 +1787,3 @@ func TestStatementBuilderAggregationUnseenKey(t *testing.T) {
 	assert.Contains(t, q.Query, "attributes_number['error.type']")
 	assert.Contains(t, q.Query, "attributes_bool['error.type']")
 }
-
-// TestStatementBuilderSemconvFamilies builds the same family-member filter
-// with the resolve_semconv_families flag on and off. On: the resource filter
-// merges both spellings and widens the index hints to any member. Off: the
-// query uses only the requested spelling, so users see no change.
-func TestStatementBuilderSemconvFamilies(t *testing.T) {
-	releaseTime := time.Date(2025, 5, 22, 22, 0, 0, 0, time.UTC)
-	query := qbtypes.QueryBuilderQuery[qbtypes.TraceAggregation]{
-		Signal:       telemetrytypes.SignalTraces,
-		StepInterval: qbtypes.Step{Duration: 30 * time.Second},
-		Aggregations: []qbtypes.TraceAggregation{{Expression: "count()"}},
-		Filter: &qbtypes.Filter{
-			Expression: "deployment.environment.name = 'production'",
-		},
-	}
-
-	cases := []struct {
-		name     string
-		flag     bool
-		expected qbtypes.Statement
-	}{
-		{
-			name: "flag on merges both spellings",
-			flag: true,
-			expected: qbtypes.Statement{
-				Query: "WITH __resource_filter AS (SELECT fingerprint FROM signoz_traces.distributed_traces_v3_resource WHERE (COALESCE(NULLIF(simpleJSONExtractString(labels, 'deployment.environment.name'), ''), NULLIF(simpleJSONExtractString(labels, 'deployment.environment'), ''), '') = ? AND (labels LIKE ? OR labels LIKE ?) AND (labels LIKE ? OR labels LIKE ?)) AND seen_at_ts_bucket_start >= ? AND seen_at_ts_bucket_start <= ? GROUP BY fingerprint) SELECT count() AS __result_0 FROM signoz_traces.distributed_signoz_index_v3 WHERE resource_fingerprint GLOBAL IN (SELECT fingerprint FROM __resource_filter) AND timestamp >= ? AND timestamp < ? AND ts_bucket_start >= ? AND ts_bucket_start <= ? ORDER BY __result_0 DESC",
-				Args:  []any{"production", "%deployment.environment.name%", "%deployment.environment%", "%deployment.environment.name\":\"production%", "%deployment.environment\":\"production%", uint64(1747945619), uint64(1747983448), "1747947419000000000", "1747983448000000000", uint64(1747945619), uint64(1747983448)},
-			},
-		},
-		{
-			name: "flag off keeps the literal spelling",
-			flag: false,
-			expected: qbtypes.Statement{
-				Query: "WITH __resource_filter AS (SELECT fingerprint FROM signoz_traces.distributed_traces_v3_resource WHERE (simpleJSONExtractString(labels, 'deployment.environment.name') = ? AND labels LIKE ? AND labels LIKE ?) AND seen_at_ts_bucket_start >= ? AND seen_at_ts_bucket_start <= ? GROUP BY fingerprint) SELECT count() AS __result_0 FROM signoz_traces.distributed_signoz_index_v3 WHERE resource_fingerprint GLOBAL IN (SELECT fingerprint FROM __resource_filter) AND timestamp >= ? AND timestamp < ? AND ts_bucket_start >= ? AND ts_bucket_start <= ? ORDER BY __result_0 DESC",
-				Args:  []any{"production", "%deployment.environment.name%", "%deployment.environment.name\":\"production%", uint64(1747945619), uint64(1747983448), "1747947419000000000", "1747983448000000000", uint64(1747945619), uint64(1747983448)},
-			},
-		},
-	}
-
-	for _, c := range cases {
-		t.Run(c.name, func(t *testing.T) {
-			fl := flaggertest.WithBooleanFlags(t, map[string]bool{
-				flagger.FeatureResolveSemconvFamilies.String(): c.flag,
-			})
-			fm := tracestelemetryschema.NewFieldMapper(fl)
-			cb := tracestelemetryschema.NewConditionBuilder(fm, fl)
-			mockMetadataStore := telemetrytypestest.NewMockMetadataStore()
-			mockMetadataStore.KeysMap = tracestelemetryschema.BuildCompleteFieldKeyMap(releaseTime)
-			aggExprRewriter := querybuilder.NewAggExprRewriter(instrumentationtest.New().ToProviderSettings(), nil, fm, cb, fl)
-
-			statementBuilder := NewTraceQueryStatementBuilder(
-				instrumentationtest.New().ToProviderSettings(),
-				mockMetadataStore,
-				fm,
-				cb,
-				aggExprRewriter,
-				nil,
-				fl,
-				false,
-				100000,
-			)
-
-			q, err := statementBuilder.Build(context.Background(), valuer.UUID{}, 1747947419000, 1747983448000, qbtypes.RequestTypeScalar, query, nil)
-			require.NoError(t, err)
-			require.Equal(t, c.expected.Query, q.Query)
-			require.Equal(t, c.expected.Args, q.Args)
-		})
-	}
-}

pkg/statementbuilder/tracesstatementbuilder/trace_operator_cte_builder.go

@@ -212,7 +212,7 @@ func (b *traceOperatorCTEBuilder) buildQueryCTE(ctx context.Context, queryName s
 		return cteName, nil
 	}
 
-	keySelectors := querybuilder.ExpandKeySelectorsForFamilies(ctx, b.orgID, b.stmtBuilder.fl, getKeySelectors(*query))
+	keySelectors := getKeySelectors(*query)
 	b.stmtBuilder.logger.DebugContext(ctx, "Key selectors for query", slog.String("query_name", queryName), slog.Any("key_selectors", keySelectors))
 	keys, _, err := b.stmtBuilder.metadataStore.GetKeysMulti(ctx, b.orgID, keySelectors)
 	if err != nil {
@@ -265,7 +265,6 @@ func (b *traceOperatorCTEBuilder) buildQueryCTE(ctx context.Context, queryName s
 			querybuilder.FilterExprVisitorOpts{
 				Context:            ctx,
 				OrgID:              b.orgID,
-				Flagger:            b.stmtBuilder.fl,
 				Logger:             b.stmtBuilder.logger,
 				FieldMapper:        b.stmtBuilder.fm,
 				ConditionBuilder:   b.stmtBuilder.cb,
@@ -443,7 +442,7 @@ func (b *traceOperatorCTEBuilder) buildFinalQuery(ctx context.Context, selectFro
 		}
 	}
 
-	keySelectors := querybuilder.ExpandKeySelectorsForFamilies(ctx, b.orgID, b.stmtBuilder.fl, b.getKeySelectors())
+	keySelectors := b.getKeySelectors()
 	keys, _, err := b.stmtBuilder.metadataStore.GetKeysMulti(ctx, b.orgID, keySelectors)
 	if err != nil {
 		return nil, err

pkg/statementbuilder/tracesstatementbuilder/trace_operator_cte_builder_test.go

@@ -20,8 +20,8 @@ func newTestTraceOperatorStatementBuilder(t *testing.T) *traceOperatorStatementB
 	t.Helper()
 	releaseTime := time.Date(2025, 5, 22, 22, 0, 0, 0, time.UTC)
 	fl := flaggertest.New(t)
-	fm := tracestelemetryschema.NewFieldMapper(fl)
-	cb := tracestelemetryschema.NewConditionBuilder(fm, fl)
+	fm := tracestelemetryschema.NewFieldMapper()
+	cb := tracestelemetryschema.NewConditionBuilder(fm)
 	mockMetadataStore := telemetrytypestest.NewMockMetadataStore()
 	mockMetadataStore.KeysMap = tracestelemetryschema.BuildCompleteFieldKeyMap(releaseTime)
 	aggExprRewriter := querybuilder.NewAggExprRewriter(instrumentationtest.New().ToProviderSettings(), nil, fm, cb, fl)

pkg/statementbuilder/tracesstatementbuilder/trace_operator_statement_builder.go

@@ -25,7 +25,6 @@ type traceOperatorStatementBuilder struct {
 	traceStmtBuilder          qbtypes.StatementBuilder[qbtypes.TraceAggregation]
 	resourceFilterStmtBuilder qbtypes.StatementBuilder[qbtypes.TraceAggregation]
 	aggExprRewriter           qbtypes.AggExprRewriter
-	fl                        flagger.Flagger
 }
 
 var _ qbtypes.TraceOperatorStatementBuilder = (*traceOperatorStatementBuilder)(nil)
@@ -42,8 +41,8 @@ func NewOperatorFactory(
 	return factory.NewProviderFactory(
 		factory.MustNewName("traceoperator"),
 		func(_ context.Context, settings factory.ProviderSettings, cfg statementbuilder.Config) (qbtypes.TraceOperatorStatementBuilder, error) {
-			fm := tracestelemetryschema.NewFieldMapper(fl)
-			cb := tracestelemetryschema.NewConditionBuilder(fm, fl)
+			fm := tracestelemetryschema.NewFieldMapper()
+			cb := tracestelemetryschema.NewConditionBuilder(fm)
 			aggExprRewriter := querybuilder.NewAggExprRewriter(settings, nil, fm, cb, fl)
 			traceStmtBuilder := NewTraceQueryStatementBuilder(
 				settings, metadataStore, fm, cb, aggExprRewriter, telemetryStore, fl,
@@ -86,7 +85,6 @@ func NewTraceOperatorStatementBuilder(
 		traceStmtBuilder:          traceStmtBuilder,
 		resourceFilterStmtBuilder: resourceFilterStmtBuilder,
 		aggExprRewriter:           aggExprRewriter,
-		fl:                        flagger,
 	}
 }
 

pkg/statementbuilder/tracesstatementbuilder/trace_time_range_test.go

@@ -21,9 +21,8 @@ import (
 func TestTraceTimeRangeOptimization(t *testing.T) {
 	releaseTime := time.Date(2025, 5, 22, 22, 0, 0, 0, time.UTC)
 
-	fl := flaggertest.New(t)
-	fm := tracestelemetryschema.NewFieldMapper(fl)
-	cb := tracestelemetryschema.NewConditionBuilder(fm, fl)
+	fm := tracestelemetryschema.NewFieldMapper()
+	cb := tracestelemetryschema.NewConditionBuilder(fm)
 	mockMetadataStore := telemetrytypestest.NewMockMetadataStore()
 
 	mockMetadataStore.KeysMap = tracestelemetryschema.BuildCompleteFieldKeyMap(releaseTime)
@@ -40,6 +39,7 @@ func TestTraceTimeRangeOptimization(t *testing.T) {
 		Signal:        telemetrytypes.SignalTraces,
 	}}
 
+	fl := flaggertest.New(t)
 	aggExprRewriter := querybuilder.NewAggExprRewriter(instrumentationtest.New().ToProviderSettings(), nil, fm, cb, fl)
 
 	statementBuilder := NewTraceQueryStatementBuilder(

pkg/telemetrymetadata/condition_builder.go

@@ -38,11 +38,8 @@ func (c *conditionBuilder) ConditionFor(
 		return nil, nil, err
 	}
 
-	// an unknown key simply yields no condition rather than an error. Metadata
-	// fields have no family support, so every logical field is single-member
-	// and flattens losslessly to its physical key.
-	resolved, warning := querybuilder.ResolveLogicalFields(key, querybuilder.MatchingLogicalFields(ctx, orgID, nil, key, fieldKeys))
-	keys := querybuilder.SingleKeys(resolved)
+	// an unknown key simply yields no condition rather than an error.
+	keys, warning := querybuilder.ResolveKeys(key, querybuilder.MatchingFieldKeys(key, fieldKeys))
 	var warnings []string
 	if warning != "" {
 		warnings = append(warnings, warning)

pkg/telemetrymetadata/field_mapper.go

@@ -58,19 +58,6 @@ func (m *fieldMapper) ColumnFor(ctx context.Context, _ valuer.UUID, tsStart, tsE
 	return columns, nil
 }
 
-// ExistsFor implements the per-key existence primitive of qbtypes.FieldMapper.
-func (m *fieldMapper) ExistsFor(ctx context.Context, _ valuer.UUID, tsStart, tsEnd uint64, key *telemetrytypes.TelemetryFieldKey, exists bool) (string, error) {
-	columns, err := m.getColumn(ctx, tsStart, tsEnd, key)
-	if err != nil {
-		return "", err
-	}
-	pred := fmt.Sprintf("mapContains(%s, '%s')", columns[0].Name, key.Name)
-	if exists {
-		return pred, nil
-	}
-	return "NOT " + pred, nil
-}
-
 func (m *fieldMapper) FieldFor(ctx context.Context, _ valuer.UUID, startNs, endNs uint64, key *telemetrytypes.TelemetryFieldKey) (string, error) {
 	columns, err := m.getColumn(ctx, startNs, endNs, key)
 	if err != nil {

pkg/telemetryschema/audittelemetryschema/condition_builder.go

@@ -139,10 +139,7 @@ func (c *conditionBuilder) ConditionFor(
 		return nil, nil, err
 	}
 
-	// Audit fields have no family support, so every logical field is
-	// single-member and flattens losslessly to its physical key.
-	resolved, warning := querybuilder.ResolveLogicalFields(key, querybuilder.MatchingLogicalFields(ctx, orgID, nil, key, fieldKeys))
-	keys := querybuilder.SingleKeys(resolved)
+	keys, warning := querybuilder.ResolveKeys(key, querybuilder.MatchingFieldKeys(key, fieldKeys))
 	var warnings []string
 	if warning != "" {
 		warnings = append(warnings, warning)

pkg/telemetryschema/audittelemetryschema/field_mapper.go

@@ -97,19 +97,6 @@ func (m *fieldMapper) ColumnFor(ctx context.Context, _ valuer.UUID, _, _ uint64,
 	return m.getColumn(ctx, key)
 }
 
-// ExistsFor implements the per-key existence primitive of qbtypes.FieldMapper.
-func (m *fieldMapper) ExistsFor(ctx context.Context, orgID valuer.UUID, tsStart, tsEnd uint64, key *telemetrytypes.TelemetryFieldKey, exists bool) (string, error) {
-	fieldExpression, err := m.FieldFor(ctx, orgID, tsStart, tsEnd, key)
-	if err != nil {
-		return "", err
-	}
-	columns, err := m.getColumn(ctx, key)
-	if err != nil {
-		return "", err
-	}
-	return querybuilder.ExistsExpression(columns, key, tsStart, tsEnd, fieldExpression, exists)
-}
-
 func (m *fieldMapper) ColumnExpressionFor(
 	ctx context.Context,
 	orgID valuer.UUID,

pkg/telemetryschema/logstelemetryschema/condition_builder.go

@@ -452,7 +452,7 @@ func (c *conditionBuilder) ConditionFor(
 	value any,
 	sb *sqlbuilder.SelectBuilder,
 ) ([]string, []string, error) {
-	matches := querybuilder.MatchingLogicalFields(ctx, orgID, nil, key, fieldKeys)
+	matches := querybuilder.MatchingFieldKeys(key, fieldKeys)
 	skipResourceFilter := options.SkipResourceFilter
 
 	// search() resolves its own (optional) scope; handle it before key resolution.
@@ -460,10 +460,7 @@ func (c *conditionBuilder) ConditionFor(
 		return c.conditionForSearch(ctx, orgID, key, value, sb)
 	}
 
-	// Logs fields have no family support yet, so every logical field is
-	// single-member and flattens losslessly to its physical key.
-	resolved, warning := querybuilder.ResolveLogicalFields(key, matches)
-	keys := querybuilder.SingleKeys(resolved)
+	keys, warning := querybuilder.ResolveKeys(key, matches)
 	var warnings []string
 	if warning != "" {
 		warnings = append(warnings, warning)

pkg/telemetryschema/logstelemetryschema/field_mapper.go

@@ -279,7 +279,7 @@ func (m *fieldMapper) ColumnExpressionFor(
 		}
 		var stmts []string
 		for _, key := range candidates {
-			guard, err := m.ExistsFor(ctx, orgID, tsStart, tsEnd, key, true)
+			guard, err := m.existsExpressionFor(ctx, orgID, tsStart, tsEnd, key, true)
 			if err != nil {
 				return "", err
 			}
@@ -308,7 +308,7 @@ func (m *fieldMapper) ColumnExpressionFor(
 		if !m.membershipGuarded(ctx, orgID, tsStart, tsEnd, candidates[0]) {
 			return m.FieldFor(ctx, orgID, tsStart, tsEnd, candidates[0])
 		}
-		guard, err := m.ExistsFor(ctx, orgID, tsStart, tsEnd, candidates[0], true)
+		guard, err := m.existsExpressionFor(ctx, orgID, tsStart, tsEnd, candidates[0], true)
 		if err != nil {
 			return "", err
 		}
@@ -326,7 +326,7 @@ func (m *fieldMapper) ColumnExpressionFor(
 
 	var stmts []string
 	for _, key := range candidates {
-		guard, err := m.ExistsFor(ctx, orgID, tsStart, tsEnd, key, true)
+		guard, err := m.existsExpressionFor(ctx, orgID, tsStart, tsEnd, key, true)
 		if err != nil {
 			return "", err
 		}
@@ -569,8 +569,7 @@ func (m *fieldMapper) membershipGuarded(ctx context.Context, orgID valuer.UUID,
 	return columnType == schema.ColumnTypeEnumMap || columnType == schema.ColumnTypeEnumJSON
 }
 
-// ExistsFor implements the per-key existence primitive of qbtypes.FieldMapper.
-func (m *fieldMapper) ExistsFor(
+func (m *fieldMapper) existsExpressionFor(
 	ctx context.Context,
 	orgID valuer.UUID,
 	tsStart, tsEnd uint64,

pkg/telemetryschema/metricstelemetryschema/condition_builder.go

@@ -162,9 +162,7 @@ func (c *conditionBuilder) ConditionFor(
 		return nil, nil, err
 	}
 
-	// Metric labels have no family support, so every logical field is
-	// single-member and flattens losslessly to its physical key.
-	keys := querybuilder.SingleKeys(querybuilder.MatchingLogicalFields(ctx, orgID, nil, key, fieldKeys))
+	keys := querybuilder.MatchingFieldKeys(key, fieldKeys)
 	var warnings []string
 	if len(keys) == 0 {
 		if _, isColumn := timeSeriesV4Columns[key.Name]; isColumn {

pkg/telemetryschema/metricstelemetryschema/field_mapper.go

@@ -97,18 +97,6 @@ func (m *fieldMapper) ColumnFor(ctx context.Context, _ valuer.UUID, tsStart, tsE
 	return m.getColumn(ctx, tsStart, tsEnd, key)
 }
 
-// ExistsFor implements the per-key existence primitive of qbtypes.FieldMapper.
-// Intrinsic fields always exist; labels are checked for key membership.
-func (m *fieldMapper) ExistsFor(_ context.Context, _ valuer.UUID, _, _ uint64, key *telemetrytypes.TelemetryFieldKey, exists bool) (string, error) {
-	if slices.Contains(IntrinsicFields, key.Name) {
-		return "true", nil
-	}
-	if exists {
-		return fmt.Sprintf("has(JSONExtractKeys(labels), '%s')", key.Name), nil
-	}
-	return fmt.Sprintf("not has(JSONExtractKeys(labels), '%s')", key.Name), nil
-}
-
 func (m *fieldMapper) ColumnExpressionFor(
 	ctx context.Context,
 	orgID valuer.UUID,

pkg/telemetryschema/tracestelemetryschema/condition_builder.go

@@ -9,7 +9,6 @@ import (
 	"time"
 
 	"github.com/SigNoz/signoz/pkg/errors"
-	"github.com/SigNoz/signoz/pkg/flagger"
 	"github.com/SigNoz/signoz/pkg/querybuilder"
 	qbtypes "github.com/SigNoz/signoz/pkg/types/querybuildertypes/querybuildertypesv5"
 	"github.com/SigNoz/signoz/pkg/types/telemetrytypes"
@@ -20,15 +19,12 @@ import (
 
 type conditionBuilder struct {
 	fm qbtypes.FieldMapper
-	// fl evaluates the resolve_semconv_families flag during resolution.
-	// A nil flagger keeps resolution literal.
-	fl flagger.Flagger
 }
 
 var _ qbtypes.ConditionBuilder = (*conditionBuilder)(nil)
 
-func NewConditionBuilder(fm qbtypes.FieldMapper, fl flagger.Flagger) *conditionBuilder {
-	return &conditionBuilder{fm: fm, fl: fl}
+func NewConditionBuilder(fm qbtypes.FieldMapper) *conditionBuilder {
+	return &conditionBuilder{fm: fm}
 }
 
 func (c *conditionBuilder) conditionFor(
@@ -36,7 +32,7 @@ func (c *conditionBuilder) conditionFor(
 	orgID valuer.UUID,
 	startNs uint64,
 	endNs uint64,
-	logical *telemetrytypes.LogicalField,
+	key *telemetrytypes.TelemetryFieldKey,
 	operator qbtypes.FilterOperator,
 	value any,
 	sb *sqlbuilder.SelectBuilder,
@@ -46,13 +42,13 @@ func (c *conditionBuilder) conditionFor(
 		value = querybuilder.FormatValueForContains(value)
 	}
 
-	fieldExpression, err := querybuilder.LogicalValueExpr(ctx, orgID, startNs, endNs, c.fm, logical)
+	fieldExpression, err := c.fm.FieldFor(ctx, orgID, startNs, endNs, key)
 	if err != nil {
 		return "", err
 	}
 
 	// TODO(srikanthccv): maybe extend this to every possible attribute
-	if logical.Name == "duration_nano" || logical.Name == "durationNano" { // QoL improvement
+	if key.Name == "duration_nano" || key.Name == "durationNano" { // QoL improvement
 		switch v := value.(type) {
 		case string:
 			if duration, err := time.ParseDuration(v); err == nil {
@@ -69,9 +65,7 @@ func (c *conditionBuilder) conditionFor(
 		}
 	}
 
-	// Coercion switches only on the data type, which every member shares, so
-	// the first member stands in for the field.
-	fieldExpression, value = querybuilder.DataTypeCollisionHandledFieldName(logical.Single(), value, fieldExpression, operator)
+	fieldExpression, value = querybuilder.DataTypeCollisionHandledFieldName(key, value, fieldExpression, operator)
 
 	// regular operators
 	switch operator {
@@ -160,7 +154,11 @@ func (c *conditionBuilder) conditionFor(
 	// in the query builder, `exists` and `not exists` are used for
 	// key membership checks, so depending on the column type, the condition changes
 	case qbtypes.FilterOperatorExists, qbtypes.FilterOperatorNotExists:
-		pred, err := querybuilder.LogicalExistsExpr(ctx, orgID, startNs, endNs, c.fm, logical, operator == qbtypes.FilterOperatorExists)
+		columns, err := c.fm.ColumnFor(ctx, orgID, startNs, endNs, key)
+		if err != nil {
+			return "", err
+		}
+		pred, err := querybuilder.ExistsExpression(columns, key, startNs, endNs, fieldExpression, operator == qbtypes.FilterOperatorExists)
 		if err != nil {
 			return "", err
 		}
@@ -212,10 +210,10 @@ func (c *conditionBuilder) ConditionFor(
 		return nil, nil, err
 	}
 
-	matches := querybuilder.MatchingLogicalFields(ctx, orgID, c.fl, key, fieldKeys)
+	matches := querybuilder.MatchingFieldKeys(key, fieldKeys)
 	skipResourceFilter := options.SkipResourceFilter
 
-	logicalFields, warning := querybuilder.ResolveLogicalFields(key, matches)
+	keys, warning := querybuilder.ResolveKeys(key, matches)
 	var warnings []string
 	if warning != "" {
 		warnings = append(warnings, warning)
@@ -223,10 +221,10 @@ func (c *conditionBuilder) ConditionFor(
 	// A bare key that names a real column filters on the column too — first. When metadata
 	// only knows the name under other contexts, prepend the column and keep metadata matches
 	// only where their type is consistent with it (a corrupt entry can't degrade the column).
-	if key.FieldContext == telemetrytypes.FieldContextUnspecified && len(logicalFields) > 0 {
+	if key.FieldContext == telemetrytypes.FieldContextUnspecified && len(keys) > 0 {
 		hasColumn := false
-		for _, logical := range logicalFields {
-			if logical.FieldContext == telemetrytypes.FieldContextSpan {
+		for _, k := range keys {
+			if k.FieldContext == telemetrytypes.FieldContextSpan {
 				hasColumn = true
 				break
 			}
@@ -234,49 +232,49 @@ func (c *conditionBuilder) ConditionFor(
 		if !hasColumn {
 			probe := telemetrytypes.NewTelemetryFieldKey(key.Name, telemetrytypes.FieldContextSpan, key.FieldDataType)
 			if cols, colErr := c.fm.ColumnFor(ctx, orgID, startNs, endNs, probe); colErr == nil && len(cols) > 0 {
-				combined := make([]*telemetrytypes.LogicalField, 0, len(logicalFields)+1)
-				combined = append(combined, telemetrytypes.SingleLogicalField(key.Name, probe))
-				for _, logical := range logicalFields {
-					if columnMatchesDataType(cols[0], logical.FieldDataType) {
-						combined = append(combined, logical)
+				combined := make([]*telemetrytypes.TelemetryFieldKey, 0, len(keys)+1)
+				combined = append(combined, probe)
+				for _, k := range keys {
+					if columnMatchesDataType(cols[0], k.FieldDataType) {
+						combined = append(combined, k)
 					}
 				}
-				logicalFields = combined
+				keys = combined
 			}
 		}
 	}
 
 	synthesized := false
-	if len(logicalFields) == 0 {
+	if len(keys) == 0 {
 		// Not in metadata. CandidateKeys resolves it: fold contexts (span/trace) get the
 		// metadata map so it can honor a real column, correct to a stripped-name metadata
 		// match, or synthesize; strict contexts pass nil and keep their synthesize path.
-		logicalFields = querybuilder.WrapAsLogicalFields(key.Name, c.fm.CandidateKeys(ctx, orgID, key, value, candidateLookupKeys(key, fieldKeys)))
-		if len(logicalFields) == 0 {
+		keys = c.fm.CandidateKeys(ctx, orgID, key, value, candidateLookupKeys(key, fieldKeys))
+		if len(keys) == 0 {
 			return nil, warnings, querybuilder.NewKeyNotFoundError(key.Name)
 		}
 		synthesized = true
 		warnings = append(warnings, querybuilder.NewKeyNotFoundWarning(key.Name))
 	}
 
-	// When a resource sub-query already covers the term, drop resource fields from the main
+	// When a resource sub-query already covers the term, drop resource keys from the main
 	// query. Synthesized keys are exempt: the sub-query skips keys absent from metadata.
 	if skipResourceFilter && !synthesized {
-		filtered := make([]*telemetrytypes.LogicalField, 0, len(logicalFields))
-		for _, logical := range logicalFields {
-			if logical.FieldContext != telemetrytypes.FieldContextResource {
-				filtered = append(filtered, logical)
+		filtered := make([]*telemetrytypes.TelemetryFieldKey, 0, len(keys))
+		for _, k := range keys {
+			if k.FieldContext != telemetrytypes.FieldContextResource {
+				filtered = append(filtered, k)
 			}
 		}
 		if len(filtered) == 0 {
 			return nil, warnings, nil
 		}
-		logicalFields = filtered
+		keys = filtered
 	}
 
-	conds := make([]string, 0, len(logicalFields))
-	for _, logical := range logicalFields {
-		cond, err := c.conditionForLogicalField(ctx, orgID, startNs, endNs, logical, operator, value, sb)
+	conds := make([]string, 0, len(keys))
+	for _, k := range keys {
+		cond, err := c.conditionForKey(ctx, orgID, startNs, endNs, k, operator, value, sb)
 		if err != nil {
 			return nil, nil, err
 		}
@@ -285,28 +283,28 @@ func (c *conditionBuilder) ConditionFor(
 	return conds, warnings, nil
 }
 
-func (c *conditionBuilder) conditionForLogicalField(
+func (c *conditionBuilder) conditionForKey(
 	ctx context.Context,
 	orgID valuer.UUID,
 	startNs uint64,
 	endNs uint64,
-	logical *telemetrytypes.LogicalField,
+	key *telemetrytypes.TelemetryFieldKey,
 	operator qbtypes.FilterOperator,
 	value any,
 	sb *sqlbuilder.SelectBuilder,
 ) (string, error) {
-	if c.isSpanScopeField(logical.Name) {
-		return c.buildSpanScopeCondition(logical.Single(), operator, value, startNs)
+	if c.isSpanScopeField(key.Name) {
+		return c.buildSpanScopeCondition(key, operator, value, startNs)
 	}
 
-	condition, err := c.conditionFor(ctx, orgID, startNs, endNs, logical, operator, value, sb)
+	condition, err := c.conditionFor(ctx, orgID, startNs, endNs, key, operator, value, sb)
 	if err != nil {
 		return "", err
 	}
 
 	if operator.AddDefaultExistsFilter() {
 		// skip adding exists filter for intrinsic fields
-		field, _ := c.fm.FieldFor(ctx, orgID, startNs, endNs, logical.Single())
+		field, _ := c.fm.FieldFor(ctx, orgID, startNs, endNs, key)
 		if slices.Contains(maps.Keys(IntrinsicFields), field) ||
 			slices.Contains(maps.Keys(IntrinsicFieldsDeprecated), field) ||
 			slices.Contains(maps.Keys(CalculatedFields), field) ||
@@ -314,7 +312,7 @@ func (c *conditionBuilder) conditionForLogicalField(
 			return condition, nil
 		}
 
-		existsCondition, err := c.conditionFor(ctx, orgID, startNs, endNs, logical, qbtypes.FilterOperatorExists, nil, sb)
+		existsCondition, err := c.conditionFor(ctx, orgID, startNs, endNs, key, qbtypes.FilterOperatorExists, nil, sb)
 		if err != nil {
 			return "", err
 		}

pkg/telemetryschema/tracestelemetryschema/condition_builder_test.go

@@ -2,7 +2,6 @@ package tracestelemetryschema
 
 import (
 	"context"
-	"github.com/SigNoz/signoz/pkg/flagger/flaggertest"
 	"testing"
 	"time"
 
@@ -289,8 +288,8 @@ func TestConditionFor(t *testing.T) {
 		},
 	}
 
-	fm := NewFieldMapper(flaggertest.New(t))
-	conditionBuilder := NewConditionBuilder(fm, flaggertest.New(t))
+	fm := NewFieldMapper()
+	conditionBuilder := NewConditionBuilder(fm)
 
 	for _, tc := range testCases {
 		sb := sqlbuilder.NewSelectBuilder()
@@ -376,8 +375,8 @@ func TestConditionForResourceWithEvolution(t *testing.T) {
 		},
 	}
 
-	fm := NewFieldMapper(flaggertest.New(t))
-	conditionBuilder := NewConditionBuilder(fm, flaggertest.New(t))
+	fm := NewFieldMapper()
+	conditionBuilder := NewConditionBuilder(fm)
 
 	for _, tc := range testCases {
 		sb := sqlbuilder.NewSelectBuilder()
@@ -396,8 +395,8 @@ func TestConditionForResourceWithEvolution(t *testing.T) {
 // user input and queries anyway, emitting a warning instead of failing.
 func TestConditionForSynthesizedKeys(t *testing.T) {
 	ctx := context.Background()
-	fm := NewFieldMapper(flaggertest.New(t))
-	cb := NewConditionBuilder(fm, flaggertest.New(t))
+	fm := NewFieldMapper()
+	cb := NewConditionBuilder(fm)
 
 	// no metadata matches -> the builder must synthesize from user input
 	var noMatches map[string][]*telemetrytypes.TelemetryFieldKey

pkg/telemetryschema/tracestelemetryschema/family_test.go

@@ -1,243 +0,0 @@
-package tracestelemetryschema
-
-import (
-	"context"
-	"testing"
-	"time"
-
-	"github.com/SigNoz/signoz/pkg/flagger"
-	"github.com/SigNoz/signoz/pkg/flagger/flaggertest"
-	qbtypes "github.com/SigNoz/signoz/pkg/types/querybuildertypes/querybuildertypesv5"
-	"github.com/SigNoz/signoz/pkg/types/telemetrytypes"
-	"github.com/SigNoz/signoz/pkg/valuer"
-	"github.com/huandu/go-sqlbuilder"
-	"github.com/stretchr/testify/require"
-)
-
-// familyFlagOn returns a flagger with resolve_semconv_families on.
-func familyFlagOn(t *testing.T) flagger.Flagger {
-	return flaggertest.WithBooleanFlags(t, map[string]bool{
-		flagger.FeatureResolveSemconvFamilies.String(): true,
-	})
-}
-
-// The tests below run against the deployment.environment(.name) family as
-// trace resource attributes with the canonical evolution timeline, inside the
-// JSON-column window. The single-member value expression at this range is
-//
-//	multiIf(resource.`<name>` IS NOT NULL, resource.`<name>`::String,
-//	        mapContains(resources_string, '<name>'), resources_string['<name>'], NULL)
-//
-// and the family expressions below compose it per member.
-
-func TestConditionForFamilyMergesMembersCurrentFirst(t *testing.T) {
-	releaseTime := time.Date(2025, 5, 22, 22, 0, 0, 0, time.UTC)
-	startNs, endNs := uint64(1747947419000000000), uint64(1747983448000000000)
-	fieldKeys := map[string][]*telemetrytypes.TelemetryFieldKey{
-		"deployment.environment.name": {{
-			Name:          "deployment.environment.name",
-			Signal:        telemetrytypes.SignalTraces,
-			FieldContext:  telemetrytypes.FieldContextResource,
-			FieldDataType: telemetrytypes.FieldDataTypeString,
-			Evolutions:    MockEvolutionData(releaseTime),
-		}},
-		"deployment.environment": {{
-			Name:          "deployment.environment",
-			Signal:        telemetrytypes.SignalTraces,
-			FieldContext:  telemetrytypes.FieldContextResource,
-			FieldDataType: telemetrytypes.FieldDataTypeString,
-			Evolutions:    MockEvolutionData(releaseTime),
-		}},
-	}
-	fl := familyFlagOn(t)
-	cb := NewConditionBuilder(NewFieldMapper(fl), fl)
-
-	// The requested spelling is the old name; precedence must still be
-	// current-first.
-	sb := sqlbuilder.NewSelectBuilder()
-	conds, warnings, err := cb.ConditionFor(context.Background(), valuer.UUID{}, startNs, endNs,
-		&telemetrytypes.TelemetryFieldKey{Name: "deployment.environment"},
-		fieldKeys, qbtypes.ConditionBuilderOptions{}, qbtypes.FilterOperatorEqual, "production", sb)
-	require.NoError(t, err)
-	require.Empty(t, warnings, "a family is one logical field, never ambiguous with itself")
-	require.Len(t, conds, 1)
-
-	sb.Where(conds...)
-	sql, args := sb.BuildWithFlavor(sqlbuilder.ClickHouse)
-	require.Equal(t, "WHERE (COALESCE(NULLIF(multiIf(resource.`deployment.environment.name` IS NOT NULL, resource.`deployment.environment.name`::String, mapContains(resources_string, 'deployment.environment.name'), resources_string['deployment.environment.name'], NULL), ''), NULLIF(multiIf(resource.`deployment.environment` IS NOT NULL, resource.`deployment.environment`::String, mapContains(resources_string, 'deployment.environment'), resources_string['deployment.environment'], NULL), ''), '') = ? AND (multiIf(resource.`deployment.environment.name` IS NOT NULL, resource.`deployment.environment.name`::String, mapContains(resources_string, 'deployment.environment.name'), resources_string['deployment.environment.name'], NULL) IS NOT NULL OR multiIf(resource.`deployment.environment` IS NOT NULL, resource.`deployment.environment`::String, mapContains(resources_string, 'deployment.environment'), resources_string['deployment.environment'], NULL) IS NOT NULL))", sql)
-	require.Equal(t, []any{"production"}, args)
-}
-
-func TestConditionForFamilyNegativeKeepsKeylessRows(t *testing.T) {
-	releaseTime := time.Date(2025, 5, 22, 22, 0, 0, 0, time.UTC)
-	startNs, endNs := uint64(1747947419000000000), uint64(1747983448000000000)
-	fieldKeys := map[string][]*telemetrytypes.TelemetryFieldKey{
-		"deployment.environment.name": {{
-			Name:          "deployment.environment.name",
-			Signal:        telemetrytypes.SignalTraces,
-			FieldContext:  telemetrytypes.FieldContextResource,
-			FieldDataType: telemetrytypes.FieldDataTypeString,
-			Evolutions:    MockEvolutionData(releaseTime),
-		}},
-		"deployment.environment": {{
-			Name:          "deployment.environment",
-			Signal:        telemetrytypes.SignalTraces,
-			FieldContext:  telemetrytypes.FieldContextResource,
-			FieldDataType: telemetrytypes.FieldDataTypeString,
-			Evolutions:    MockEvolutionData(releaseTime),
-		}},
-	}
-	fl := familyFlagOn(t)
-	cb := NewConditionBuilder(NewFieldMapper(fl), fl)
-
-	sb := sqlbuilder.NewSelectBuilder()
-	conds, _, err := cb.ConditionFor(context.Background(), valuer.UUID{}, startNs, endNs,
-		&telemetrytypes.TelemetryFieldKey{Name: "deployment.environment.name"},
-		fieldKeys, qbtypes.ConditionBuilderOptions{}, qbtypes.FilterOperatorNotEqual, "production", sb)
-	require.NoError(t, err)
-	require.Len(t, conds, 1)
-
-	// The trailing '' makes rows without any member read '' (single-key map
-	// semantics), so `!=` keeps including them; no exists filter is added.
-	sb.Where(conds...)
-	sql, args := sb.BuildWithFlavor(sqlbuilder.ClickHouse)
-	require.Equal(t, "WHERE COALESCE(NULLIF(multiIf(resource.`deployment.environment.name` IS NOT NULL, resource.`deployment.environment.name`::String, mapContains(resources_string, 'deployment.environment.name'), resources_string['deployment.environment.name'], NULL), ''), NULLIF(multiIf(resource.`deployment.environment` IS NOT NULL, resource.`deployment.environment`::String, mapContains(resources_string, 'deployment.environment'), resources_string['deployment.environment'], NULL), ''), '') <> ?", sql)
-	require.Equal(t, []any{"production"}, args)
-}
-
-func TestConditionForFamilyExists(t *testing.T) {
-	releaseTime := time.Date(2025, 5, 22, 22, 0, 0, 0, time.UTC)
-	startNs, endNs := uint64(1747947419000000000), uint64(1747983448000000000)
-	fieldKeys := map[string][]*telemetrytypes.TelemetryFieldKey{
-		"deployment.environment.name": {{
-			Name:          "deployment.environment.name",
-			Signal:        telemetrytypes.SignalTraces,
-			FieldContext:  telemetrytypes.FieldContextResource,
-			FieldDataType: telemetrytypes.FieldDataTypeString,
-			Evolutions:    MockEvolutionData(releaseTime),
-		}},
-		"deployment.environment": {{
-			Name:          "deployment.environment",
-			Signal:        telemetrytypes.SignalTraces,
-			FieldContext:  telemetrytypes.FieldContextResource,
-			FieldDataType: telemetrytypes.FieldDataTypeString,
-			Evolutions:    MockEvolutionData(releaseTime),
-		}},
-	}
-	fl := familyFlagOn(t)
-	cb := NewConditionBuilder(NewFieldMapper(fl), fl)
-
-	sb := sqlbuilder.NewSelectBuilder()
-	conds, _, err := cb.ConditionFor(context.Background(), valuer.UUID{}, startNs, endNs,
-		&telemetrytypes.TelemetryFieldKey{Name: "deployment.environment.name"},
-		fieldKeys, qbtypes.ConditionBuilderOptions{}, qbtypes.FilterOperatorNotExists, nil, sb)
-	require.NoError(t, err)
-	require.Len(t, conds, 1)
-
-	sb.Where(conds...)
-	sql, _ := sb.BuildWithFlavor(sqlbuilder.ClickHouse)
-	require.Equal(t, "WHERE NOT (multiIf(resource.`deployment.environment.name` IS NOT NULL, resource.`deployment.environment.name`::String, mapContains(resources_string, 'deployment.environment.name'), resources_string['deployment.environment.name'], NULL) IS NOT NULL OR multiIf(resource.`deployment.environment` IS NOT NULL, resource.`deployment.environment`::String, mapContains(resources_string, 'deployment.environment'), resources_string['deployment.environment'], NULL) IS NOT NULL)", sql)
-}
-
-// With the flag off, both spellings can be in the metadata map and the
-// condition still uses only the requested key. Users see no change until the
-// flag is on.
-func TestConditionForFamilyOffByDefault(t *testing.T) {
-	releaseTime := time.Date(2025, 5, 22, 22, 0, 0, 0, time.UTC)
-	startNs, endNs := uint64(1747947419000000000), uint64(1747983448000000000)
-	fieldKeys := map[string][]*telemetrytypes.TelemetryFieldKey{
-		"deployment.environment.name": {{
-			Name:          "deployment.environment.name",
-			Signal:        telemetrytypes.SignalTraces,
-			FieldContext:  telemetrytypes.FieldContextResource,
-			FieldDataType: telemetrytypes.FieldDataTypeString,
-			Evolutions:    MockEvolutionData(releaseTime),
-		}},
-		"deployment.environment": {{
-			Name:          "deployment.environment",
-			Signal:        telemetrytypes.SignalTraces,
-			FieldContext:  telemetrytypes.FieldContextResource,
-			FieldDataType: telemetrytypes.FieldDataTypeString,
-			Evolutions:    MockEvolutionData(releaseTime),
-		}},
-	}
-	fl := flaggertest.New(t)
-	cb := NewConditionBuilder(NewFieldMapper(fl), fl)
-
-	sb := sqlbuilder.NewSelectBuilder()
-	conds, _, err := cb.ConditionFor(context.Background(), valuer.UUID{}, startNs, endNs,
-		&telemetrytypes.TelemetryFieldKey{Name: "deployment.environment.name"},
-		fieldKeys, qbtypes.ConditionBuilderOptions{}, qbtypes.FilterOperatorEqual, "production", sb)
-	require.NoError(t, err)
-	require.Len(t, conds, 1)
-
-	sb.Where(conds...)
-	sql, args := sb.BuildWithFlavor(sqlbuilder.ClickHouse)
-	require.Equal(t, "WHERE (multiIf(resource.`deployment.environment.name` IS NOT NULL, resource.`deployment.environment.name`::String, mapContains(resources_string, 'deployment.environment.name'), resources_string['deployment.environment.name'], NULL) = ? AND multiIf(resource.`deployment.environment.name` IS NOT NULL, resource.`deployment.environment.name`::String, mapContains(resources_string, 'deployment.environment.name'), resources_string['deployment.environment.name'], NULL) IS NOT NULL)", sql)
-	require.Equal(t, []any{"production"}, args)
-}
-
-// With only one member in metadata the condition is the exact single-key
-// shape: composition only appears when metadata proves a second member.
-func TestConditionForSingleMemberIsUnchanged(t *testing.T) {
-	releaseTime := time.Date(2025, 5, 22, 22, 0, 0, 0, time.UTC)
-	startNs, endNs := uint64(1747947419000000000), uint64(1747983448000000000)
-	fieldKeys := map[string][]*telemetrytypes.TelemetryFieldKey{
-		"deployment.environment.name": {{
-			Name:          "deployment.environment.name",
-			Signal:        telemetrytypes.SignalTraces,
-			FieldContext:  telemetrytypes.FieldContextResource,
-			FieldDataType: telemetrytypes.FieldDataTypeString,
-			Evolutions:    MockEvolutionData(releaseTime),
-		}},
-		"deployment.environment": {{
-			Name:          "deployment.environment",
-			Signal:        telemetrytypes.SignalTraces,
-			FieldContext:  telemetrytypes.FieldContextResource,
-			FieldDataType: telemetrytypes.FieldDataTypeString,
-			Evolutions:    MockEvolutionData(releaseTime),
-		}},
-	}
-	delete(fieldKeys, "deployment.environment")
-	fl := familyFlagOn(t)
-	cb := NewConditionBuilder(NewFieldMapper(fl), fl)
-
-	sb := sqlbuilder.NewSelectBuilder()
-	conds, _, err := cb.ConditionFor(context.Background(), valuer.UUID{}, startNs, endNs,
-		&telemetrytypes.TelemetryFieldKey{Name: "deployment.environment.name"},
-		fieldKeys, qbtypes.ConditionBuilderOptions{}, qbtypes.FilterOperatorEqual, "production", sb)
-	require.NoError(t, err)
-	require.Len(t, conds, 1)
-
-	sb.Where(conds...)
-	sql, args := sb.BuildWithFlavor(sqlbuilder.ClickHouse)
-	require.Equal(t, "WHERE (multiIf(resource.`deployment.environment.name` IS NOT NULL, resource.`deployment.environment.name`::String, mapContains(resources_string, 'deployment.environment.name'), resources_string['deployment.environment.name'], NULL) = ? AND multiIf(resource.`deployment.environment.name` IS NOT NULL, resource.`deployment.environment.name`::String, mapContains(resources_string, 'deployment.environment.name'), resources_string['deployment.environment.name'], NULL) IS NOT NULL)", sql)
-	require.Equal(t, []any{"production"}, args)
-}
-
-func TestColumnExpressionForFamilyGroupBy(t *testing.T) {
-	releaseTime := time.Date(2025, 5, 22, 22, 0, 0, 0, time.UTC)
-	startNs, endNs := uint64(1747947419000000000), uint64(1747983448000000000)
-	fieldKeys := map[string][]*telemetrytypes.TelemetryFieldKey{
-		"deployment.environment.name": {{
-			Name:          "deployment.environment.name",
-			Signal:        telemetrytypes.SignalTraces,
-			FieldContext:  telemetrytypes.FieldContextResource,
-			FieldDataType: telemetrytypes.FieldDataTypeString,
-			Evolutions:    MockEvolutionData(releaseTime),
-		}},
-		"deployment.environment": {{
-			Name:          "deployment.environment",
-			Signal:        telemetrytypes.SignalTraces,
-			FieldContext:  telemetrytypes.FieldContextResource,
-			FieldDataType: telemetrytypes.FieldDataTypeString,
-			Evolutions:    MockEvolutionData(releaseTime),
-		}},
-	}
-	fm := NewFieldMapper(familyFlagOn(t))
-
-	expr, err := fm.ColumnExpressionFor(context.Background(), valuer.UUID{}, startNs, endNs,
-		&telemetrytypes.TelemetryFieldKey{Name: "deployment.environment.name"}, telemetrytypes.FieldDataTypeString, fieldKeys)
-	require.NoError(t, err)
-	require.Equal(t, "multiIf((multiIf(resource.`deployment.environment.name` IS NOT NULL, resource.`deployment.environment.name`::String, mapContains(resources_string, 'deployment.environment.name'), resources_string['deployment.environment.name'], NULL) IS NOT NULL OR multiIf(resource.`deployment.environment` IS NOT NULL, resource.`deployment.environment`::String, mapContains(resources_string, 'deployment.environment'), resources_string['deployment.environment'], NULL) IS NOT NULL), COALESCE(NULLIF(multiIf(resource.`deployment.environment.name` IS NOT NULL, resource.`deployment.environment.name`::String, mapContains(resources_string, 'deployment.environment.name'), resources_string['deployment.environment.name'], NULL), ''), NULLIF(multiIf(resource.`deployment.environment` IS NOT NULL, resource.`deployment.environment`::String, mapContains(resources_string, 'deployment.environment'), resources_string['deployment.environment'], NULL), ''), ''), NULL)", expr)
-}

pkg/telemetryschema/tracestelemetryschema/field_mapper.go

@@ -7,7 +7,6 @@ import (
 
 	schema "github.com/SigNoz/signoz-otel-collector/cmd/signozschemamigrator/schema_migrator"
 	"github.com/SigNoz/signoz/pkg/errors"
-	"github.com/SigNoz/signoz/pkg/flagger"
 	"github.com/SigNoz/signoz/pkg/querybuilder"
 	qbtypes "github.com/SigNoz/signoz/pkg/types/querybuildertypes/querybuildertypesv5"
 	"github.com/SigNoz/signoz/pkg/types/telemetrytypes"
@@ -160,16 +159,12 @@ var (
 	}
 )
 
-type fieldMapper struct {
-	// fl evaluates the resolve_semconv_families flag during resolution.
-	// A nil flagger keeps resolution literal.
-	fl flagger.Flagger
-}
+type fieldMapper struct{}
 
 var _ qbtypes.FieldMapper = (*fieldMapper)(nil)
 
-func NewFieldMapper(fl flagger.Flagger) *fieldMapper {
-	return &fieldMapper{fl: fl}
+func NewFieldMapper() *fieldMapper {
+	return &fieldMapper{}
 }
 
 func (m *fieldMapper) getColumn(
@@ -341,68 +336,6 @@ func (m *fieldMapper) resolveColumnExprs(
 	return exprs, existExprs, columns, nil
 }
 
-// logicalForResolvedColumn upgrades a directly-resolvable key (the FieldFor
-// probe succeeded) to its family when the metadata map proves membership;
-// otherwise the key stays a single-member logical field.
-func (m *fieldMapper) logicalForResolvedColumn(ctx context.Context, orgID valuer.UUID, field *telemetrytypes.TelemetryFieldKey, keys map[string][]*telemetrytypes.TelemetryFieldKey) *telemetrytypes.LogicalField {
-	for _, logical := range querybuilder.MatchingLogicalFields(ctx, orgID, m.fl, field, keys) {
-		if logical.IsFamily() &&
-			logical.FieldContext == field.FieldContext &&
-			(field.FieldDataType == telemetrytypes.FieldDataTypeUnspecified || logical.FieldDataType == field.FieldDataType) {
-			return logical
-		}
-	}
-	return telemetrytypes.SingleLogicalField(field.Name, field)
-}
-
-// upgradeToFamilies swaps single-member candidates for their family when the
-// metadata map proves membership. Candidate order and every non-family
-// candidate stay exactly as the legacy flow produced them; sibling candidates
-// of an already-emitted family are dropped rather than duplicated.
-func (m *fieldMapper) upgradeToFamilies(ctx context.Context, orgID valuer.UUID, field *telemetrytypes.TelemetryFieldKey, candidates []*telemetrytypes.LogicalField, keys map[string][]*telemetrytypes.TelemetryFieldKey) []*telemetrytypes.LogicalField {
-	var families []*telemetrytypes.LogicalField
-	for _, logical := range querybuilder.MatchingLogicalFields(ctx, orgID, m.fl, field, keys) {
-		if logical.IsFamily() {
-			families = append(families, logical)
-		}
-	}
-	if len(families) == 0 {
-		return candidates
-	}
-
-	out := make([]*telemetrytypes.LogicalField, 0, len(candidates))
-	emitted := make(map[*telemetrytypes.LogicalField]bool)
-	for _, candidate := range candidates {
-		var family *telemetrytypes.LogicalField
-		for _, fam := range families {
-			if fam.FieldContext != candidate.FieldContext || fam.FieldDataType != candidate.FieldDataType {
-				continue
-			}
-			memberOfFamily := candidate.Single().Name == field.Name
-			for _, member := range fam.Members {
-				if member.Name == candidate.Single().Name {
-					memberOfFamily = true
-					break
-				}
-			}
-			if memberOfFamily {
-				family = fam
-				break
-			}
-		}
-		if family == nil {
-			out = append(out, candidate)
-			continue
-		}
-		if emitted[family] {
-			continue
-		}
-		emitted[family] = true
-		out = append(out, family)
-	}
-	return out
-}
-
 // ColumnExpressionFor returns the bare (unaliased) SQL expression for the field, resolving
 // unknown keys via CandidateKeys and wrapping guardable columns with exists-guard multiIfs
 // so an absent key yields NULL.
@@ -415,23 +348,18 @@ func (m *fieldMapper) ColumnExpressionFor(
 	keys map[string][]*telemetrytypes.TelemetryFieldKey,
 ) (string, error) {
 
-	// Resolve the candidate logical field(s).
-	var candidates []*telemetrytypes.LogicalField
+	// Resolve the candidate column(s).
+	var candidates []*telemetrytypes.TelemetryFieldKey
 	switch _, err := m.FieldFor(ctx, orgID, startNs, endNs, field); {
 	case err == nil:
-		// A directly-resolvable key upgrades to its family when the metadata
-		// map proves membership; otherwise it stays single-member.
-		candidates = []*telemetrytypes.LogicalField{m.logicalForResolvedColumn(ctx, orgID, field, keys)}
+		candidates = []*telemetrytypes.TelemetryFieldKey{field}
 	case errors.Is(err, qbtypes.ErrColumnNotFound):
-		// The legacy candidate flow, unchanged: column (when the bare name is
-		// one) plus metadata matches, else synthesized type-variant keys. The
-		// family step below only swaps candidates for their family; it never
-		// changes candidate order or non-family behavior.
-		raw := m.CandidateKeys(ctx, orgID, field, nil, keys)
-		if len(raw) == 0 {
+		// column (when the bare name is one) plus metadata matches, else synthesized
+		// type-variant keys.
+		candidates = m.CandidateKeys(ctx, orgID, field, nil, keys)
+		if len(candidates) == 0 {
 			return "", errors.Wrapf(err, errors.TypeInvalidInput, errors.CodeInvalidInput, "field `%s` not found", field.Name).WithSuggestions(errors.NewSuggestionsOnLevenshteinDistance(field.Name, errors.NounKeys, maps.Keys(keys))...)
 		}
-		candidates = m.upgradeToFamilies(ctx, orgID, field, querybuilder.WrapAsLogicalFields(field.Name, raw), keys)
 	default:
 		return "", err
 	}
@@ -445,21 +373,21 @@ func (m *fieldMapper) ColumnExpressionFor(
 			dummyValue = 0.0
 		}
 		stmts := make([]string, 0, len(candidates)*2)
-		for _, logical := range candidates {
-			value, err := querybuilder.LogicalValueExpr(ctx, orgID, startNs, endNs, m, logical)
+		for _, key := range candidates {
+			value, err := m.FieldFor(ctx, orgID, startNs, endNs, key)
 			if err != nil {
 				return "", err
 			}
-			guard, err := querybuilder.LogicalExistsExpr(ctx, orgID, startNs, endNs, m, logical, true)
+			guard, err := m.existsExpressionFor(ctx, orgID, startNs, endNs, key, true)
 			if err != nil {
 				return "", err
 			}
 			coerced := value
 			// a time column keeps its native type; coercing it would yield seconds
-			if temporal, err := m.logicalIsTemporal(ctx, startNs, endNs, logical); err != nil {
+			if temporal, err := m.columnIsTemporal(ctx, startNs, endNs, key); err != nil {
 				return "", err
 			} else if !temporal {
-				coerced, _ = querybuilder.DataTypeCollisionHandledFieldName(logical.Single(), dummyValue, value, qbtypes.FilterOperatorUnknown)
+				coerced, _ = querybuilder.DataTypeCollisionHandledFieldName(key, dummyValue, value, qbtypes.FilterOperatorUnknown)
 			}
 			stmts = append(stmts, guard, coerced)
 		}
@@ -467,14 +395,13 @@ func (m *fieldMapper) ColumnExpressionFor(
 	}
 
 	if len(candidates) == 1 {
-		logical := candidates[0]
-		value, err := querybuilder.LogicalValueExpr(ctx, orgID, startNs, endNs, m, logical)
+		value, err := m.FieldFor(ctx, orgID, startNs, endNs, candidates[0])
 		if err != nil {
 			return "", err
 		}
-		exprs, existExprs, _, _ := m.resolveColumnExprs(ctx, startNs, endNs, logical.Single())
-		if !logical.IsFamily() && len(exprs) == 1 && len(existExprs) == 1 {
-			guard, err := querybuilder.LogicalExistsExpr(ctx, orgID, startNs, endNs, m, logical, true)
+		exprs, existExprs, _, _ := m.resolveColumnExprs(ctx, startNs, endNs, candidates[0])
+		if len(exprs) == 1 && len(existExprs) == 1 {
+			guard, err := m.existsExpressionFor(ctx, orgID, startNs, endNs, candidates[0], true)
 			if err != nil {
 				return "", err
 			}
@@ -486,12 +413,12 @@ func (m *fieldMapper) ColumnExpressionFor(
 	// Multiple candidates (collision / synth): multiIf picks the first that exists,
 	// stringified so branches share a type.
 	args := make([]string, 0, len(candidates))
-	for _, logical := range candidates {
-		value, err := querybuilder.LogicalValueExpr(ctx, orgID, startNs, endNs, m, logical)
+	for _, key := range candidates {
+		value, err := m.FieldFor(ctx, orgID, startNs, endNs, key)
 		if err != nil {
 			return "", err
 		}
-		guard, err := querybuilder.LogicalExistsExpr(ctx, orgID, startNs, endNs, m, logical, true)
+		guard, err := m.existsExpressionFor(ctx, orgID, startNs, endNs, key, true)
 		if err != nil {
 			return "", err
 		}
@@ -500,15 +427,6 @@ func (m *fieldMapper) ColumnExpressionFor(
 	return fmt.Sprintf("multiIf(%s, NULL)", strings.Join(args, ", ")), nil
 }
 
-// logicalIsTemporal reports whether the logical field resolves to a single time
-// column. A family is attribute-backed and never temporal.
-func (m *fieldMapper) logicalIsTemporal(ctx context.Context, startNs, endNs uint64, logical *telemetrytypes.LogicalField) (bool, error) {
-	if logical.IsFamily() {
-		return false, nil
-	}
-	return m.columnIsTemporal(ctx, startNs, endNs, logical.Single())
-}
-
 // columnIsTemporal reports whether key resolves to a single time column, after evolution
 // selection. Multiple columns mean an attribute-map union, which is never temporal.
 func (m *fieldMapper) columnIsTemporal(ctx context.Context, startNs, endNs uint64, key *telemetrytypes.TelemetryFieldKey) (bool, error) {
@@ -604,8 +522,7 @@ func (m *fieldMapper) CandidateKeys(ctx context.Context, _ valuer.UUID, field *t
 	return nil
 }
 
-// ExistsFor implements the per-key existence primitive of qbtypes.FieldMapper.
-func (m *fieldMapper) ExistsFor(
+func (m *fieldMapper) existsExpressionFor(
 	ctx context.Context,
 	orgID valuer.UUID,
 	tsStart, tsEnd uint64,

pkg/telemetryschema/tracestelemetryschema/field_mapper_test.go

@@ -2,7 +2,6 @@ package tracestelemetryschema
 
 import (
 	"context"
-	"github.com/SigNoz/signoz/pkg/flagger/flaggertest"
 	"testing"
 	"time"
 
@@ -108,7 +107,7 @@ func TestGetFieldKeyName(t *testing.T) {
 
 	for _, tc := range testCases {
 		t.Run(tc.name, func(t *testing.T) {
-			fm := NewFieldMapper(flaggertest.New(t))
+			fm := NewFieldMapper()
 			result, err := fm.FieldFor(ctx, valuer.UUID{}, uint64(time.Date(2024, 6, 1, 0, 0, 0, 0, time.UTC).UnixNano()), uint64(time.Date(2024, 6, 5, 0, 0, 0, 0, time.UTC).UnixNano()), &tc.key)
 
 			if tc.expectedError != nil {
@@ -196,7 +195,7 @@ func TestFieldForResourceWithEvolution(t *testing.T) {
 
 	for _, tc := range testCases {
 		t.Run(tc.name, func(t *testing.T) {
-			fm := NewFieldMapper(flaggertest.New(t))
+			fm := NewFieldMapper()
 			result, err := fm.FieldFor(ctx, valuer.UUID{}, tc.tsStart, tc.tsEnd, &tc.key)
 			require.NoError(t, err)
 			assert.Equal(t, tc.expectedResult, result)
@@ -256,7 +255,7 @@ func TestColumnExpressionForTemporalColumn(t *testing.T) {
 
 	for _, tc := range testCases {
 		t.Run(tc.name, func(t *testing.T) {
-			fm := NewFieldMapper(flaggertest.New(t))
+			fm := NewFieldMapper()
 			result, err := fm.ColumnExpressionFor(ctx, valuer.UUID{}, tsStart, tsEnd, &tc.key, tc.requiredDataType, nil)
 			require.NoError(t, err)
 			assert.Equal(t, tc.expectedResult, result)
@@ -284,7 +283,7 @@ func TestColumnExpressionForTimestampAttributeCollision(t *testing.T) {
 		},
 	}
 
-	fm := NewFieldMapper(flaggertest.New(t))
+	fm := NewFieldMapper()
 
 	t.Run("bare timestamp resolves to the intrinsic column alone", func(t *testing.T) {
 		bare := telemetrytypes.TelemetryFieldKey{Name: "timestamp"}

pkg/telemetryschema/tracestelemetryschema/span_scope_simple_test.go

@@ -2,7 +2,6 @@ package tracestelemetryschema
 
 import (
 	"context"
-	"github.com/SigNoz/signoz/pkg/flagger/flaggertest"
 	"testing"
 
 	"github.com/SigNoz/signoz/pkg/instrumentation/instrumentationtest"
@@ -15,8 +14,8 @@ import (
 
 func TestSpanScopeFilterExpression(t *testing.T) {
 	// Test that span scope fields work in filter expressions
-	fm := NewFieldMapper(flaggertest.New(t))
-	cb := NewConditionBuilder(fm, flaggertest.New(t))
+	fm := NewFieldMapper()
+	cb := NewConditionBuilder(fm)
 
 	tests := []struct {
 		name              string
@@ -129,8 +128,8 @@ func TestSpanScopeWithResourceFilter(t *testing.T) {
 			// For now, just verify the expression parses correctly
 			// In a real implementation, we'd need to check that the resource filter
 			// is properly skipped when span scope fields are present
-			fm := NewFieldMapper(flaggertest.New(t))
-			cb := NewConditionBuilder(fm, flaggertest.New(t))
+			fm := NewFieldMapper()
+			cb := NewConditionBuilder(fm)
 
 			// Prepare field keys for the test
 			fieldKeys := make(map[string][]*telemetrytypes.TelemetryFieldKey)

pkg/telemetryschema/tracestelemetryschema/test_data.go

@@ -113,21 +113,6 @@ func BuildCompleteFieldKeyMap(releaseTime time.Time) map[string][]*telemetrytype
 				FieldDataType: telemetrytypes.FieldDataTypeBool,
 			},
 		},
-		// both spellings of an enabled semantic-convention family
-		"deployment.environment.name": {
-			{
-				Name:          "deployment.environment.name",
-				FieldContext:  telemetrytypes.FieldContextResource,
-				FieldDataType: telemetrytypes.FieldDataTypeString,
-			},
-		},
-		"deployment.environment": {
-			{
-				Name:          "deployment.environment",
-				FieldContext:  telemetrytypes.FieldContextResource,
-				FieldDataType: telemetrytypes.FieldDataTypeString,
-			},
-		},
 	}
 	for _, keys := range keysMap {
 		for _, key := range keys {

pkg/types/querybuildertypes/querybuildertypesv5/qb.go

@@ -18,14 +18,7 @@ var (
 	ErrUnsupportedOperator = errors.NewInvalidInputf(errors.CodeInvalidInput, "unsupported operator")
 )
 
-// FieldMapper is a signal's storage dialect: given a resolved physical key, it
-// renders how this signal's tables express that key — its value (FieldFor),
-// its presence (ExistsFor), and its backing columns (ColumnFor) — honoring
-// materialization and column-generation choices carried on the key.
-//
-// ColumnExpressionFor and CandidateKeys additionally carry per-signal
-// resolution behavior (unknown-name fallback, candidate ordering); they
-// predate the resolution layer and are slated to move behind it.
+// FieldMapper maps the telemetry field key to the table field name.
 type FieldMapper interface {
 	// FieldFor returns the field name for the given key.
 	FieldFor(ctx context.Context, orgID valuer.UUID, tsStart, tsEnd uint64, key *telemetrytypes.TelemetryFieldKey) (string, error)
@@ -41,11 +34,6 @@ type FieldMapper interface {
 	// the name (or `{context}.{name}`) first, else synthesized type-variant keys for sources
 	// that support it, else nil (caller errors). value is the filter operand, nil otherwise.
 	CandidateKeys(ctx context.Context, orgID valuer.UUID, field *telemetrytypes.TelemetryFieldKey, value any, keys map[string][]*telemetrytypes.TelemetryFieldKey) []*telemetrytypes.TelemetryFieldKey
-	// ExistsFor returns the existence predicate for a single physical key (negated when
-	// exists is false), self-contained and arg-free so it can guard column expressions.
-	// It is the per-member primitive querybuilder.LogicalExistsExpr and the numeric branch
-	// of querybuilder.LogicalValueExpr compose family expressions from.
-	ExistsFor(ctx context.Context, orgID valuer.UUID, tsStart, tsEnd uint64, key *telemetrytypes.TelemetryFieldKey, exists bool) (string, error)
 }
 
 // ConditionBuilder builds the conditions for a filter term. The builder owns key resolution:

pkg/types/telemetrytypes/logical_field.go

@@ -1,78 +0,0 @@
-package telemetrytypes
-
-import "strings"
-
-// LogicalField is one queryable field. Its Name is the spelling that the
-// request used. Its Members are the physical keys that store the field.
-// LogicalField is the output type of name resolution: resolution changes a
-// referenced name into logical fields, and compilers make SQL from them.
-//
-// A []*LogicalField shows ambiguity. Ambiguity means that possibly different
-// fields have the same name. Each logical field in the slice gets its own
-// condition. The operator tells the compiler how to connect the conditions.
-//
-// One LogicalField with more than one member shows a semantic-convention
-// family. A family is one field that has more than one spelling. The members
-// are in current-first order. The compiler merges the members into one
-// expression, and the current name wins.
-//
-// Members always has one entry or more. A field that is not a family has
-// exactly one member. The members point to the metadata map entries. Do not
-// change the members.
-type LogicalField struct {
-	// Name is the spelling that the request used. Aliases, series labels,
-	// and warnings use this spelling. Because of this, the response shows
-	// the same spelling as the request.
-	Name string
-
-	// Signal, FieldContext, and FieldDataType are the identity that all
-	// members share. Members with a different signal, field context, or
-	// data type are parts of different logical fields.
-	Signal        Signal
-	FieldContext  FieldContext
-	FieldDataType FieldDataType
-
-	// Members are the physical keys that store this field, in current-first
-	// order. Each member has its own physical data (Materialized,
-	// Evolutions, JSONPlan, ...). A per-member accessor does not need data
-	// from the other members.
-	Members []*TelemetryFieldKey
-}
-
-// SingleLogicalField makes a logical field that has one physical key.
-func SingleLogicalField(name string, key *TelemetryFieldKey) *LogicalField {
-	return &LogicalField{
-		Name:          name,
-		Signal:        key.Signal,
-		FieldContext:  key.FieldContext,
-		FieldDataType: key.FieldDataType,
-		Members:       []*TelemetryFieldKey{key},
-	}
-}
-
-// Single returns the only member of a single-member field. A decision that
-// uses only the shared identity can also use Single on a family. This is
-// safe because all members have the same signal, context, and data type.
-func (l *LogicalField) Single() *TelemetryFieldKey {
-	return l.Members[0]
-}
-
-// IsFamily returns true when the field has more than one physical member.
-func (l *LogicalField) IsFamily() bool {
-	return len(l.Members) > 1
-}
-
-// String implements fmt.Stringer. A single-member field prints as its
-// member. Because of this, a message made from the field and a message made
-// from the key are the same. A family prints its shared identity and its
-// member spellings.
-func (l *LogicalField) String() string {
-	if len(l.Members) == 1 {
-		return l.Members[0].String()
-	}
-	names := make([]string, 0, len(l.Members))
-	for _, member := range l.Members {
-		names = append(names, member.Name)
-	}
-	return l.Name + "(" + l.FieldContext.StringValue() + ", " + l.FieldDataType.StringValue() + ", members: " + strings.Join(names, ", ") + ")"
-}

pkg/types/telemetrytypes/logical_field_test.go

@@ -1,50 +0,0 @@
-package telemetrytypes
-
-import (
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-)
-
-func TestSingleLogicalFieldSharesIdentityAndAliasesKey(t *testing.T) {
-	key := &TelemetryFieldKey{
-		Name:          "service.name",
-		Signal:        SignalTraces,
-		FieldContext:  FieldContextResource,
-		FieldDataType: FieldDataTypeString,
-	}
-
-	logical := SingleLogicalField("resource.service.name", key)
-
-	assert.Equal(t, "resource.service.name", logical.Name, "the identity is the spelling that the request used, not the stored spelling")
-	assert.Equal(t, key.Signal, logical.Signal)
-	assert.Equal(t, key.FieldContext, logical.FieldContext)
-	assert.Equal(t, key.FieldDataType, logical.FieldDataType)
-	assert.False(t, logical.IsFamily())
-	assert.Same(t, key, logical.Single(), "the member points to the key; there is no copy")
-}
-
-func TestStringDelegatesForSingleMember(t *testing.T) {
-	key := &TelemetryFieldKey{
-		Name:          "service.name",
-		FieldContext:  FieldContextResource,
-		FieldDataType: FieldDataTypeString,
-	}
-	assert.Equal(t, key.String(), SingleLogicalField(key.Name, key).String(),
-		"a message made from a single-member field must be the same as a message made from the key")
-}
-
-func TestStringListsFamilyMembers(t *testing.T) {
-	logical := &LogicalField{
-		Name:          "deployment.environment.name",
-		Signal:        SignalTraces,
-		FieldContext:  FieldContextResource,
-		FieldDataType: FieldDataTypeString,
-		Members: []*TelemetryFieldKey{
-			{Name: "deployment.environment.name"},
-			{Name: "deployment.environment"},
-		},
-	}
-	assert.True(t, logical.IsFamily())
-	assert.Equal(t, "deployment.environment.name(resource, string, members: deployment.environment.name, deployment.environment)", logical.String())
-}