test: add semantic convention phase one closure gate

.claude/rules/comments.md

@@ -1,11 +0,0 @@
-# Comments
-
-Applies to everything in the repo — code, config, workflows.
-
-- **No unnecessary comments.** Do not comment where the code is self-explanatory; never restate what the code already says.
-- **Document only** non-obvious behavior, constraints, formats, and edge cases.
-- **Rationale goes in prose, not source.** Why a version is pinned, why a job exists, how a subsystem fits together — that belongs in the README or the PR.
-- **Never remove pre-existing comments** when editing code. The bar above applies to comments you write, not comments already there.
-- **Never talk to the reviewer.** No comments about where a change came from, what was changed, or why the change is correct — that belongs in the PR description and is noise the moment it merges.
-
-Language rules build on this one: [`go-comments`](go-comments.md), [`py-comments`](py-comments.md).

.claude/rules/go-comments.md

@@ -1,12 +0,0 @@
----
-paths:
-  - "**/*.go"
----
-
-# Go comments
-
-The bar is the [`comments`](comments.md) rule: nothing where the code is self-explanatory.
-
-- **Names carry the meaning.** Make function, type, and variable names self-explanatory so the comment is unnecessary in the first place. If a comment is needed to explain what a function does, fix the name, not the comment.
-- **Godoc**: Skip comments that merely restate the identifier. Document only non-obvious behavior, constraints, formats, and edge cases.
-- **Generated code**: If the comment is emitted by an external codegen tool, leave it as-is — do not add or trim comments in generated files.

.claude/rules/pull-requests.md

@@ -1,7 +0,0 @@
-# Pull requests
-
-- **Follow the template** (`.github/pull_request_template.md`): fill in its headings (Description / Issues closed by this PR / Screenshots / Additional Information). Don't add sections the template doesn't have.
-- **Keep only the headings that apply.** Delete every heading that has nothing under it, along with its `<!--...-->` placeholder comment. The body must never contain an empty heading — if only Description applies, the body has exactly that one heading.
-- **Keep the description concise and human-readable.** A few plain bullets saying what changed and why, for a reviewer skimming it — not a wall of text, not a restatement of the diff, not generated boilerplate.
-- **Reference issues with `Closes #issue-number`** under "Issues closed by this PR" so they auto-close on merge. This goes in the PR description only — never in commit messages.
-- **AI assistance in commits may optionally be disclosed with an `Assisted-by:` trailer** naming the model (e.g. `Assisted-by: Claude Opus 4.5`) — do NOT use a `Co-authored-by:` trailer for this.

.claude/rules/py-comments.md

@@ -1,13 +0,0 @@
----
-paths:
-  - "**/*.py"
----
-
-# Python comments
-
-The bar is the [`comments`](comments.md) rule: nothing where the code is self-explanatory.
-
-- **Names carry the meaning.** Make function and variable names self-explanatory so the comment or docstring is unnecessary in the first place. If a docstring is needed to explain what a function does, fix the name, not the docstring.
-- **No file-level docstring.** The filename says what the module is for — `tool_bin.py` gets the tool binary. A module docstring restating that is noise, and a paragraph of design prose at the top of a file goes stale where nobody is looking. A constraint belongs next to the code it constrains, not in a preamble.
-- **Docstrings**: only when they say something the name and signature don't — drop them otherwise. Keep them short. A contract that genuinely needs a few lines (interacting flags, retry semantics, an edge case) is fine; a narrative is not.
-- **No song and dance.** Comment the constraint or the edge case. Not the narrative, not the rationale, not what the next line does.

.github/pull_request_template.md

@@ -1,13 +1,85 @@
-<!--A few plain bullets saying what changed and why, for a reviewer skimming it - not a wall of text, not a restatement of the diff, not generated boilerplate.-->
-#### Description
+## Pull Request
+
+---
+
+### 📄 Summary
+> Why does this change exist?  
+> What problem does it solve, and why is this the right approach?
+
+
+
+#### Screenshots / Screen Recordings (if applicable)
+> Include screenshots or screen recordings that clearly show the behavior before the change and the result after the change. This helps reviewers quickly understand the impact and verify the update.
+
 
-<!--Reference issues using `Closes #issue-number` to enable automatic closure on merge. -->
 #### Issues closed by this PR
+> Reference issues using `Closes #issue-number` to enable automatic closure on merge.
 
-<!--If applicable, include screenshots or screen recordings that clearly show the behavior before the change and the result after the change. -->
-#### Screenshots / Screen Recordings
+---
 
-<!--Anything reviewers should keep in mind while reviewing -->
-#### Additional Information
+### ✅ Change Type
+_Select all that apply_
 
-<!--Please delete paragraphs that you did not use before submitting.-->
+- [ ] ✨ Feature
+- [ ] 🐛 Bug fix
+- [ ] ♻️ Refactor
+- [ ] 🛠️ Infra / Tooling
+- [ ] 🧪 Test-only
+
+---
+
+### 🐛 Bug Context
+> Required if this PR fixes a bug
+
+#### Root Cause
+> What caused the issue?  
+> Regression, faulty assumption, edge case, refactor, etc.
+
+#### Fix Strategy
+> How does this PR address the root cause?
+
+---
+
+### 🧪 Testing Strategy
+> How was this change validated?
+
+- Tests added/updated:
+- Manual verification:
+- Edge cases covered:
+
+---
+
+### ⚠️ Risk & Impact Assessment
+> What could break? How do we recover?
+
+- Blast radius:
+- Potential regressions:
+- Rollback plan:
+
+---
+
+### 📝 Changelog
+> Fill only if this affects users, APIs, UI, or documented behavior  
+> Use **N/A** for internal or non-user-facing changes
+
+| Field | Value |
+|------|-------|
+| Deployment Type | Cloud / OSS / Enterprise |
+| Change Type | Feature / Bug Fix / Maintenance |
+| Description | User-facing summary |
+
+---
+
+### 📋 Checklist
+- [ ] Tests added or explicitly not required
+- [ ] Manually tested
+- [ ] Breaking changes documented
+- [ ] Backward compatibility considered
+
+---
+
+## 👀 Notes for Reviewers
+
+<!-- Anything reviewers should keep in mind while reviewing -->
+
+---

.github/workflows/goci.yaml

@@ -53,6 +53,21 @@ jobs:
     with:
       PRIMUS_REF: main
       GO_VERSION: 1.24
+  semconv-generated:
+    if: |
+      github.event_name == 'merge_group' ||
+      (github.event_name == 'pull_request' && ! github.event.pull_request.head.repo.fork && github.event.pull_request.user.login != 'dependabot[bot]' && ! contains(github.event.pull_request.labels.*.name, 'safe-to-test')) ||
+      (github.event_name == 'pull_request_target' && contains(github.event.pull_request.labels.*.name, 'safe-to-test'))
+    runs-on: ubuntu-latest
+    steps:
+      - name: self-checkout
+        uses: actions/checkout@v4
+      - name: go-install
+        uses: actions/setup-go@v5
+        with:
+          go-version: "1.24"
+      - name: check-semconv-generated-files
+        run: go run ./scripts/semconv -check
   build:
     if: |
       github.event_name == 'merge_group' ||

.gitignore

@@ -90,6 +90,8 @@ queries.active
 .devenv/**/tmp/**
 .qodo
 
+.dev
+
 ### Python ###
 # Byte-compiled / optimized / DLL files
 __pycache__/
@@ -229,6 +231,4 @@ cython_debug/
 # LSP config files
 pyrightconfig.json
 
-# dev
-.dev/
-.claude/worktrees/
+

Makefile

@@ -220,6 +220,10 @@ py-test-teardown: ## Tear down the shared SigNoz backend
 py-test: ## Runs integration tests
 	@cd tests && uv run pytest --basetemp=./tmp/ -vv --capture=no integration/tests/
 
+.PHONY: py-test-semconv-phase1
+py-test-semconv-phase1: py-test-setup ## Rebuild the shared stack and run the semantic-convention Phase 1 matrix
+	@cd tests && uv run pytest --basetemp=./tmp/ -vv --reuse --capture=no integration/tests/queriertraces/13_semconv_evolution.py
+
 .PHONY: py-clean
 py-clean: ## Clear all pycache and pytest cache from tests directory recursively
 	@echo ">> cleaning python cache files from tests directory"
@@ -233,6 +237,10 @@ py-clean: ## Clear all pycache and pytest cache from tests directory recursively
 ##############################################################
 # generate commands
 ##############################################################
+.PHONY: semconv-generate
+semconv-generate: ## Regenerate semantic-convention families for Go and TypeScript
+	@go run ./scripts/semconv
+
 .PHONY: gen-mocks
 gen-mocks:
 	@echo ">> Generating mocks"

docs/contributing/prometheus.md

@@ -1,377 +1,123 @@
 # PromQL Serving — clickhouseprometheusv2
 
-This document gives the context for `pkg/prometheus/clickhouseprometheusv2`.
-This package is the second-generation ClickHouse-backed Prometheus provider.
-The document tells you why the package exists. It tells you the correctness
-rules that shaped it. It shows how we prove that each construct does not
-change results. Keep these invariants when you change the provider. If your
-change breaks an invariant, flag it and discuss it first.
+This document is the subsystem context for `pkg/prometheus/clickhouseprometheusv2`,
+the second-generation ClickHouse-backed Prometheus provider. It explains why the
+package exists, the correctness constraints that shaped it, and how each fetch
+reduction is proven not to change results. Any change to the provider must keep
+these invariants; if a change would violate one, it must be flagged and
+discussed.
 
 ---
 
 ## Why a second provider
 
-The v1 provider (`pkg/prometheus/clickhouseprometheus`) serves the promql
-engine through the remote-read protobuf adapter. It fetches every raw sample
-of a query's union window. It serializes all of them and gives them to the
-engine. The cost follows the ingested data, not the question. This is how a
-dashboard of PromQL panels can take an instance down.
+The v1 provider (`pkg/prometheus/clickhouseprometheus`) serves the promql engine
+through the remote-read protobuf adapter: every raw sample of a query's union
+window is fetched, serialized, and handed to the engine. The cost is a function
+of ingested data, not of the question asked — which is how a dashboard of PromQL
+panels can take an instance down.
 
-In v2, each query runs in one of two ways. The classifier decides per query:
+In v2 the stock promql engine evaluates over a native `storage.Querier`: no
+translation layer, per-selector fetch windows, and fetch reductions that are
+provably invisible to the engine.
 
-- **Transpiled**: ClickHouse evaluates the query. Only final (or near-final)
-  per-group grid arrays come back. The statements use the
-  `timeSeries*ToGrid` aggregate functions. The supported ClickHouse floor is
-  25.6 or later, so these functions are assumed available.
-- **Engine**: the stock promql engine evaluates over this package's native
-  `storage.Querier`. Every shape that does not transpile takes this path.
-
-**The core rule: a PromQL result that differs from upstream Prometheus is a
-lost user. A construct that cannot reproduce engine semantics exactly falls
-back. It does not approximate.** The conformance suite
+**The core constraint: every reduction either preserves engine semantics exactly
+or is not performed.** A PromQL result that differs from upstream Prometheus is
+a lost user. The conformance suite
 (`tests/integration/tests/promqlconformance/`) replays Prometheus' own test
-corpus against both providers. It is the arbiter. The classification golden
-(`testdata/classification_golden.json`) freezes the route of each corpus
-expression. The rest of this document is the PromQL-to-SQL story. That
-mapping is where correctness is won or lost.
+corpus against both providers and is the arbiter.
 
 ---
 
-## The evaluation model the SQL must reproduce
-
-A PromQL range query is an instant query evaluated at each grid point
-`t_i = start + i*step`, for `i = 0..(end-start)/step`. At each `t_i`:
-
-- An instant selector resolves to the latest sample in the left-open
-  lookback window `(t_i - lookback, t_i]`. If that latest sample is a stale
-  marker, the selector resolves to nothing. Older real samples in the window
-  do not change this.
-- A range selector `[r]` collects every sample in `(t_i - r, t_i]`. Stale
-  markers are excluded.
-- `offset d` shifts both windows to `(t_i - d - w, t_i - d]`.
-
-The transpilation invariant follows from this model. Each transpiled
-construct produces one array per output series. The array has exactly one
-slot per grid point. Slot `i` holds the value at `t_i`. NULL means absent.
-This makes composition correct, not only convenient. The engine evaluates
-these operators independently per `t_i`. A representation that gets every
-slot right gets the whole query right. Spatial aggregation over arrays is
-sound because it combines values that belong to the same `t_i` by
-construction. Scan time maps slot `i` back to `t_i = start + i*step`
-(`toMatrix`). The sections below fill those slots with exactly the numbers
-the engine computes. We validated each equivalence against the vendored
-engine on live data before its shape entered the allowlist. An unproven
-shape stays on the engine path.
-
-## Classification: finding what a statement can answer
-
-`classify` walks the parsed AST and looks for "core units". A core unit is a
-maximal subtree of this shape:
-
-	[agg by/without (...)] [fn(] selector[range] [offset d] [)] [op scalar]...
-
-`classifyCore` peels that chain from the outside in. It takes an optional
-sum/min/max/avg/count aggregation. It then takes one allowlisted function or
-a bare instant selector. It then takes the selector with its offset. On the
-way out, it collects number-literal arithmetic, comparisons (including
-`bool`), and unary minus into a scalar-op pipeline. A node qualifies only if
-its type, arguments, and children are in the proven set. This is an
-allowlist. An overlooked construct becomes a fallback, not a wrong number.
-
-Three unit kinds come out. Each kind has its own SQL form:
-
-- `unitRange`: rate, irate, increase, delta, idelta over a range selector.
-- `unitInstant`: instant vector selection, bare or comparison-filtered.
-- `unitOverTime`: avg/min/max/sum/count/last `_over_time`.
-
-If the whole tree is one unit, the plan is "full". The statement's rows are
-the query result. Otherwise, `rewrite` cuts out each maximal unit and puts a
-synthetic selector `__signoz_transpiled_N__` in its place. The engine then
-runs the rewritten expression over the units' materialized results. This is
-a "hybrid" plan. `histogram_quantile`, `topk`, `or`/`and`/`unless`, and
-vector matching keep exact engine semantics. Their expensive inputs were
-aggregated server-side.
-
-Classification refuses a shape when it cannot guarantee exact semantics
-server-side:
-
-- The `@` modifier, anywhere.
-- Default-resolution subqueries. Their resolution is a server runtime
-  setting that the transpiler cannot see.
-- Duration expressions (`offset step()`, `[range()]`, ...), anywhere. The
-  engine resolves them into the selector's static fields only at evaluation
-  time. At classification time those fields hold zero values. A transpile
-  would silently use the wrong offset or range.
-- Steps or ranges that are not whole seconds. The grid functions take
-  whole-second parameters.
-- Grouping by `__name__`, or matching on it, in hybrid plans. The synthetic
-  name would leak into results.
-- Name-keeping units in hybrid plans. Bare and comparison-filtered instant
-  selectors and `last_over_time` keep their real `__name__` (`keepsName`).
-  Substitution would replace that name. These units transpile only as full
-  plans.
-- Every function outside the allowlist: changes, resets,
-  quantile_over_time, absent, native-histogram functions, and more.
-
-Units inside a fixed-resolution subquery evaluate on the subquery's own
-grid, not the query grid. That grid is the set of epoch-aligned multiples of
-the resolution strictly after `outerStart - offset - range`, ending at
-`outer end - offset`. This is the exact derivation the engine uses. A grid
-shifted by one step changes which samples every window sees.
-
-## From one unit to one statement
-
-`buildUnitSQL` renders each unit as one statement. For
-`sum by (pod) (rate(m{job="api"}[5m]))` the skeleton is:
-
-	SELECT g0, sumForEach(grid) AS grid FROM (
-	    SELECT any(series.g0) AS g0,
-	           timeSeriesRateToGrid(<start>, <end>, <step>, <range>)(fromUnixTimestamp64Milli(unix_milli), value) AS grid
-	    FROM signoz_metrics.distributed_samples_v4 AS points
-	    INNER JOIN (
-	        SELECT fingerprint, JSONExtractString(labels, 'pod') AS g0
-	        FROM signoz_metrics.time_series_v4
-	        WHERE <series predicates>
-	        GROUP BY fingerprint, g0
-	    ) AS series ON points.fingerprint = series.fingerprint
-	    WHERE metric_name = ? AND temporality IN ['Cumulative', 'Unspecified']
-	      AND unix_milli > <start - range> AND unix_milli <= <end>
-	      AND bitAnd(flags, 1) = 0
-	    GROUP BY points.fingerprint
-	) GROUP BY g0
-	SETTINGS allow_experimental_ts_to_grid_aggregate_function = 1
-
-Read it from the inside out.
-
-**The time window** is the selector's semantics, verbatim. Strict `>` on the
-lower bound and `<=` on the upper bound is the left-open `(t - w, t]` rule.
-The offset shifts the whole window. `bitAnd(flags, 1) = 0` drops stale
-markers. PromQL excludes them from range vectors.
-
-**The inner GROUP BY** computes one grid array per series.
-`timeSeriesRateToGrid(start, end, step, range)` is a parametric aggregate.
-It takes (timestamp, value) pairs and produces `Array(Nullable(Float64))`
-with one slot per grid point. It is correct because it implements the
-engine's `extrapolatedRate`, decision for decision: counter resets, the
-zero-point clamp, the extrapolation thresholds, the two-samples rule, and
-the left-open window. We verified this: we fed identical samples to both and
-compared slot for slot. The only observed difference is the last bit.
-ClickHouse's C++ and Go round the same formula differently. That is the
-floating-point floor, not a semantic gap. irate/delta/idelta map to their
-own `timeSeries*ToGrid` functions, with the same verification. `increase`
-has no function of its own. We emit
-`arrayMap(x -> x * <range seconds>, <rate expr>)`. This is exact by
-definition: `extrapolatedRate` computes the same extrapolated delta for both
-and divides by the range only when `isRate`. The multiplication reverses it
-exactly. The grid parameters render as literals, not bound args. They are
-aggregate-function parameters. The experimental gate rides as a SETTINGS
-clause on the statement itself, so telemetrystore hooks cannot remove it.
-
-The group key is functionally dependent on the fingerprint: one fingerprint
-is the hash of one labelset. So the inner query groups by the fingerprint
-alone and reads the key columns with `any()`. This is exact, and it makes
-the per-row hash key smaller.
-
-**The join** gives each series its group key, in one of two forms.
-`by (...)` extracts each listed label as a plain column
-(`JSONExtractString(labels, 'pod') AS g0`) and groups on the columns. The
-projection is a known short list, and the label names live in Go. To build,
-sort, and stringify every label pair per row would be waste. This is correct
-because column-tuple equality is label-set equality on the projection. An
-extracted `''` means the label is absent. That is Prometheus semantics for
-`by()` over missing labels. The empties are skipped when the columns turn
-back into labels. `without` and no-aggregation project a label set that
-varies per series. They get the canonical key: `toJSONString` of the sorted
-[label, value] pairs that the unit projects. `without` excludes the listed
-labels plus `__name__`. No-aggregation keeps everything; the name comes off
-in Go, per the engine's name-dropping rules. Here the sort is load-bearing.
-Stored JSON key order is not canonical across fingerprints. Two orderings of
-the same labels must land in one group. Empty values are filtered for the
-same absent-label reason. The same string parses back into the output label
-set (`labelsFromGroupKey`).
-
-**The outer GROUP BY** is the spatial aggregation. sum/min/max/avg/count
-by/without become the `-ForEach` combinators. Element-wise aggregation over
-grid arrays is the engine's per-`t_i` aggregation: slot `i` of every input
-array refers to the same `t_i`. The combinators skip NULLs. That is the
-engine aggregating only the series present at `t_i`. An index where every
-series is absent stays NULL. Two edges need explicit handling. First,
-`countForEach` wraps in a map of 0 back to NULL. A count over an all-absent
-index is an absent point, not 0. Second, a unit without aggregation still
-passes through `maxForEach`. That is the identity for the common
-one-fingerprint group. It is a deterministic NULL-skipping merge when a
-regex `__name__` selector collapses distinct metrics onto one projected
-label set. One caveat is inherent: the summation order over series differs
-from the engine's. Spatial aggregates can differ in the last ULP. Float
-addition is not associative. No ordering reproduces the engine's result
-bit-exactly from inside a GROUP BY.
-
-## Instant selectors: staleness needs two aggregates
-
-`unitInstant` uses window = lookback. It must reproduce the shadowing rule:
-the point is absent when the latest in-window sample is a stale marker.
-`timeSeriesLastToGrid` alone cannot express that. To skip stale rows in
-WHERE would resurrect the older real sample that the marker buried. So stale
-rows stay in the scan for this kind only. The grid expression compares three
-aggregates per slot:
-
-	arrayMap((tall, tok, vok) -> if(tall IS NULL OR tok IS NULL OR tall != tok, NULL, vok),
-	         timeSeriesLastToGrid(...)(ts, toFloat64(unix_milli)),                           -- last sample overall
-	         timeSeriesLastToGridIf(...)(ts, toFloat64(unix_milli), bitAnd(flags, 1) = 0),   -- last non-stale, its timestamp
-	         timeSeriesLastToGridIf(...)(ts, value, bitAnd(flags, 1) = 0))                   -- last non-stale, its value
-
-This is correct by cases on a slot's window. No samples at all: both
-timestamp aggregates are NULL, so the slot is NULL. That is absent, as the
-engine says. Latest sample non-stale: it is the latest overall and the
-latest non-stale. The timestamps agree. The slot takes its value. That is
-the engine's pick. Latest sample stale: the last-overall timestamp is the
-marker's. The last-non-stale timestamp is older, or NULL when the window
-holds only markers. They disagree. The slot is NULL. The marker shadows,
-exactly as the engine's rule says. Timestamps are unique per series (ingest
-dedups). So timestamp equality identifies "the same sample" without
-ambiguity. We probed the `-If` combinator against these experimental
-aggregates before we trusted it.
-
-## Windowed *_over_time: whole buckets instead of a grid function
-
-avg/min/max/sum/count `_over_time` aggregate every raw sample in the window.
-No `timeSeries*ToGrid` function computes them. (`last_over_time` is the
-exception. The last sample of a range vector is exactly
-`timeSeriesLastToGrid`. PromQL excludes stale markers from range vectors; we
-exclude them in WHERE.) These shapes transpile only when the range is a
-whole multiple of the step. Then the window needs no per-sample fan-out.
-With `W = range/step`, the window `(t_k - range, t_k]` is exactly the union
-of W step buckets. Both are left-open on the same boundaries. So bucket
-membership fully determines window membership. Each sample lands in exactly
-one bucket:
-
-	intDiv(unix_milli - <start> + <range> - 1, <step>)
-
-This is `ceil((ts - start)/step)` shifted by W-1, so the earliest in-window
-sample sits at 0. Slot k's window is buckets in `[k, k+W-1]`. The
-alternative fans each sample into all W windows that cover it. That
-multiplies rows by W. For a long range over a short step, that is a row
-explosion measured in billions. The bucketed form's row count is
-series × buckets: the size of the output, for any W.
-
-Each series aggregates in one group. The `-Resample` combinator
-(`sumResample`, `countResample`) holds the dense per-bucket partials inside
-one group state: a bucket count, plus the function's value aggregate (sum
-for sum/avg, min, max). An earlier form grouped by (series, bucket) and
-assembled with `groupArrayInsertAt`. At scale that made 37M hash groups, and
-per-thread partials scaled memory with the thread count. The slide then
-combines each slot's at-most-W bucket partials by direct aggregation
-(`arraySum(arraySlice(...))`). Window sums are added the way the engine adds
-them. There is no prefix-sum differencing: its large-minus-large
-cancellation would drift past the shadow tolerance on counter-sized values.
-This is correct per slot because the bucket union is the exact window
-multiset, and avg/min/max/sum/count are order-insensitive on a multiset
-(sum/avg up to summation order; see the float caveat above). A slot with
-zero window count is absent. min/max filter their slices on the bucket
-counts. An empty bucket's default can never look like a value: a real sample
-can legitimately be +Inf.
-
-Two shapes fall back to the engine path, which is exact: a range that does
-not divide the step, and a window wider than `maxWindowBuckets` buckets (the
-slide costs W combines per slot). A range narrower than the step needs
-neither gate: the windows are pairwise disjoint, one bucket per slot, no
-slide. That form is exact only together with the window-sliver predicate
-below.
-
-## Scalar ops, full plans, hybrid plans
-
-The scalar-op pipeline runs in Go on the returned arrays
-(`applyScalarOps`), slot by slot. Arithmetic operators compute. Comparisons
-filter: the slot keeps the vector-side value or becomes NULL. Under `bool`
-they return 0/1. This is trivially correct. It is the same float64 operation
-the engine applies, to the same slot value, in the same operator order the
-AST dictates. Go instead of another SQL layer changes where, not what.
-
-A full plan's arrays map straight to the result matrix. A hybrid plan
-materializes each unit's arrays as synthetic series under its
-`__signoz_transpiled_N__` name. The engine evaluates the rewritten
-expression over a storage that serves synthetic names from memory and
-everything else live. Substitution is sound because a unit's output is a
-plain instant vector to the engine: same values at same timestamps, under a
-different name. The name cannot matter. Plans that group by or match on
-`__name__` were refused at classification. Name-keeping units are never
-substituted. One subtlety makes it exact: we write stale markers at absent
-grid points. Without them, the engine's lookback would resurrect a point
-from up to `lookback` earlier. The marker encodes "absent here" the way the
-engine itself encodes it. Units evaluate concurrently. Each unit is one
-series lookup plus one grid statement. A step of 0 is an instant query: a
-single evaluation at `end`.
-
-A note on the window sliver: when the window is narrower than the step, the
-grid windows cover only `window/step` of the timeline. A sample in a gap
-belongs to no window. It cannot move any grid point, but the grid aggregate
-would buffer it. A WHERE predicate keeps only the in-window rows:
-`positiveModulo(selStart - unix_milli, step) < window`, with the scan capped
-at the last grid point. The lattice anchors at the selector start, because
-the end can sit off-lattice on unaligned grids. This cut a 36k-series
-one-week rate from 74s/28GiB to 16s/4.3GiB on fleet data. Over slivered
-rows, `timeSeriesLastToGrid`'s window widening is harmless, so instant
-selectors and `last_over_time` transpile at window < step too.
-
 ## Series lookup
 
-Both paths resolve matchers the same way, once per selector
-(`selectSeries`). The series tables hold one row per (fingerprint, bucket)
-at 1h/6h/1d/1w granularities. The shared schema package
-(`pkg/telemetryschema/metricstelemetryschema`) picks the table whose bucket
-fits the window. It rounds the window start down to the bucket boundary, so
-a window that begins mid-bucket still matches the bucket's row. How matchers
-become SQL, and why regexes are anchored, is documented at
-`applySeriesConditions`. Empty-valued labels come off at this boundary. An
-empty value means "label absent" in Prometheus, but stored attribute JSON
-can carry them.
+Matchers resolve to series once per selector (`selectSeries`) against the series
+tables, which hold one row per (fingerprint, bucket) at 1h/6h/1d/1w
+granularities. Table selection and window rounding delegate to the shared
+metrics schema package (`pkg/telemetryschema/metricstelemetryschema`); the
+window start rounds down to the bucket boundary so a window beginning mid-bucket
+still matches the bucket's row.
 
-## The engine path
+How matchers become SQL is documented at `applySeriesConditions`. The rules that
+carry semantics:
 
-Queries that do not transpile run in the stock engine over this package's
-`storage.Querier`. This is still not the v1 path. Samples are fetched per
-selector with the engine's per-selector hints, not the query-wide union
-window. So `foo / foo offset 1d` reads two narrow windows, not the widest
-one twice. Instant selectors of subquery-free queries fetch only the last
-sample per step bucket (`lastSamplePerStep`). Buckets anchor at the
-selector's first evaluation timestamp. The code recovers it from the hints
-as `hints.Start + lookback - 1ms`, the inverse of how the engine derives
-`hints.Start`. Bucket boundaries then coincide with evaluation timestamps.
-A non-final sample of a bucket can never be the latest sample in
-`(t - lookback, t]` for any grid `t`. Real timestamps are preserved, so the
-engine's own lookback and staleness handling stay exact. Range selectors
-always fetch raw: every sample feeds the range function. The subquery-free
-proof travels in the context as `prometheus.QueryTraits`. Subquery selectors
-evaluate at the subquery's step, while the hints carry the top-level step.
-Row assembly maps stale flags to the engine's StaleNaN. It merges series
-with identical label sets (`sortAndMerge`): the engine assumes storages
-never emit duplicates.
+- `__name__` matchers (all four types) translate to the `metric_name` column.
+- Every other matcher becomes a `JSONExtractString` condition on the labels
+  column. An equality matcher against `""` matches series *without* the label,
+  mirroring PromQL, because `JSONExtractString` returns `""` for missing keys.
+- Regexes are anchored (`^(?:...)$`) before they reach `match()`: PromQL
+  matchers match the whole value, ClickHouse `match()` searches for a
+  substring.
+- The series-lookup upper bound is inclusive (`unix_milli <= end`) because the
+  exporter floors registration rows to the bucket start: a series first
+  registered in the bucket beginning exactly at `end` would otherwise be
+  invisible while its samples are in range.
+
+Empty-valued labels come off at this boundary: an empty value means "label
+absent" in Prometheus, but stored attribute JSON can carry them.
+
+---
+
+## Sample fetch
+
+Samples are fetched per selector using the engine's per-selector hints, not the
+query-wide union window — `foo / foo offset 1d` reads two narrow windows
+instead of the widest one twice.
+
+**Last-sample-per-step reduction.** Instant selectors of subquery-free queries
+fetch only the last sample per step bucket. The engine resolves an instant
+selector at each grid timestamp `t` to the latest sample in the left-open
+lookback window `(t − lookback, t]`. Buckets anchor at the selector's first
+evaluation timestamp — recovered from the hints as
+`hints.Start + lookback − 1ms`, the inverse of how the engine derives
+`hints.Start` — so bucket boundaries coincide with evaluation timestamps, and a
+non-final sample of a bucket can never be the latest sample in
+`(t − lookback, t]` for any grid `t`. Real timestamps are preserved, so the
+engine's own lookback and staleness handling stay exact.
+
+Range selectors always fetch raw — every sample feeds the range function. The
+subquery-free proof travels in the context as `prometheus.QueryTraits`, because
+subquery selectors evaluate at the subquery's step while the hints carry the
+top-level step; call sites that do not attach traits get the conservative raw
+fetch.
+
+**Row assembly** maps stale flags to the engine's `StaleNaN` and merges series
+with identical label sets (`sortAndMerge`) — the engine assumes storages never
+emit duplicates. Duplicate timestamps pass through as stored: uniqueness is
+ingest's job, and v1 feeds them to the engine as-is over the same data.
+
+**The fingerprint filter is a shard-local semi-join.** The samples query
+restricts to the matched series by re-running the series predicates as an
+`IN (SELECT fingerprint FROM <local series table> ...)` subquery, not a GLOBAL
+broadcast of the matched set. ClickHouse materializes the subquery's set per
+shard before the scan, so it still engages the fingerprint primary-key column.
+Because the subquery re-executes the predicates after the lookup ran, it can
+match series registered in between; sample rows whose fingerprint the lookup
+never saw are skipped — the lookup is the read snapshot.
+
+---
 
 ## Sharding
 
-`samples_v4` and `time_series_v4` (and all their rollups) shard on the same
-key: `cityHash64(env, temporality, metric_name, fingerprint)`. So a series'
-samples and catalog rows live on the same shard. The transpiled statement
-exploits that. The distributed samples table at the top-level FROM makes
-ClickHouse rewrite the whole inner query per shard. The join against the
-shard-local series table and the per-series grid aggregation run next to
-the data. The initiator only merges aggregate states and applies the
-spatial `-ForEach` step. This is the same layout as the telemetrymetrics
-statement builder. The group-key join alone restricts the transpiled scan
-to the matched series. The engine path's samples fetch restricts by the
-same predicates as a shard-local semi-join, not a GLOBAL broadcast of the
-matched set. The temporality filter on every samples statement is a
-semantic no-op: the matched fingerprints already come from those
-temporalities. It engages the leading samples primary-key column.
-Delta-temporality series stay invisible to PromQL here, exactly as in v1.
-The rollout gate is parity with v1. To make Delta visible is its own change
-with its own semantics to design. A Delta stream fed to `rate()`
+`samples_v4` and `time_series_v4` (and all their rollups) shard on the same key
+— `cityHash64(env, temporality, metric_name, fingerprint)` — so a series'
+samples and catalog rows live on the same shard. The semi-join above exploits
+that: each shard filters by its own series rows, which are exactly the series
+of that shard's samples.
+
+The temporality filter on every samples statement
+(`temporality IN ['Cumulative', 'Unspecified']`) is a semantic no-op — the
+matched fingerprints already come from those temporalities — that engages the
+leading samples primary-key column.
+
+Delta-temporality series stay invisible to PromQL exactly as they are in v1:
+the rollout gate is parity with v1, and a Delta stream fed to `rate()`
 as-if-cumulative would be wrong, not just new.
 
+---
+
 ## Observability
 
 Every statement carries a `log_comment` with
-`code.namespace=clickhouse-prometheus-v2` and `code.function.name` naming
-the call site (`selectSeries`, `selectSamples`, `transpiledUnit`,
-`LabelValues`, `LabelNames`). This provider's work is attributable in
-`system.query_log` without guessing from query text.
+`code.namespace=clickhouse-prometheus-v2` and `code.function.name` naming the
+call site, so this provider's work is attributable in `system.query_log`.

frontend/src/AppRoutes/index.tsx

@@ -354,16 +354,6 @@ function App(): JSX.Element {
 					tunnel: window.signozBootData.settings.sentry.tunnel,
 					environment: process.env.ENVIRONMENT,
 					release: process.env.VERSION,
-					// A tab that outlived a deploy requests hashed assets the new build no longer
-					// has. `lazyRetry` recovers by reloading once, so this class is not worth
-					// reporting. The stylesheet message is Vite's own; the module ones are the
-					// same failure worded differently by Chromium, Firefox and Safari.
-					ignoreErrors: [
-						/Unable to preload CSS for/,
-						/Failed to fetch dynamically imported module/,
-						/error loading dynamically imported module/,
-						/Importing a module script failed/,
-					],
 					integrations: [
 						// Kept for the `transaction` tag used in routing, even though
 						// tracing is disabled. Ref: https://github.com/SigNoz/platform-pod/issues/2393#issuecomment-4603658055

frontend/src/constants/generated/semconvFamilies.gen.ts

@@ -0,0 +1,32 @@
+// Code generated by scripts/semconv. DO NOT EDIT.
+
+export type SemconvFamily = {
+	readonly current: string;
+	readonly old: readonly string[];
+	readonly kind: 'attribute' | 'metric';
+	readonly contexts: readonly string[];
+	readonly signals: readonly string[];
+	readonly applyToMetrics: readonly string[];
+	readonly valueMap: Readonly<Record<string, string>>;
+};
+
+export const SEMCONV_FAMILIES: readonly SemconvFamily[] = [
+	{
+		current: 'db.system.name',
+		old: ['db.system'],
+		kind: 'attribute',
+		contexts: [],
+		signals: [],
+		applyToMetrics: [],
+		valueMap: {},
+	},
+	{
+		current: 'deployment.environment.name',
+		old: ['deployment.environment'],
+		kind: 'attribute',
+		contexts: [],
+		signals: [],
+		applyToMetrics: [],
+		valueMap: {},
+	},
+] as const;

frontend/src/utils/lazyWithRetries.ts

@@ -16,14 +16,9 @@ export const lazyRetry = (componentImport: ComponentImport): Promise<any> =>
 				resolve(component);
 			})
 			.catch((error: Error) => {
-				// A stale chunk reference right after a deploy self-heals: one reload pulls a
-				// fresh index.html with the new hashed asset names. That reload is only
-				// once-only if the flag persists, so a failed write (sessionStorage blocked in
-				// an iframe, storage disabled) must not reload at all — it would loop forever.
-				if (
-					!hasRefreshed &&
-					setSessionStorageApi(SESSIONSTORAGE.RETRY_LAZY_REFRESHED, 'true')
-				) {
+				if (!hasRefreshed) {
+					setSessionStorageApi(SESSIONSTORAGE.RETRY_LAZY_REFRESHED, 'true');
+
 					window.location.reload();
 				}
 

go.mod

@@ -4,7 +4,7 @@ go 1.25.7
 
 require (
 	dario.cat/mergo v1.0.2
-	github.com/AfterShip/clickhouse-sql-parser v0.5.5
+	github.com/AfterShip/clickhouse-sql-parser v0.5.4
 	github.com/ClickHouse/clickhouse-go/v2 v2.44.0
 	github.com/DATA-DOG/go-sqlmock v1.5.2
 	github.com/SigNoz/clickhouse-go-mock v0.14.0

go.sum

@@ -66,8 +66,8 @@ dario.cat/mergo v1.0.2/go.mod h1:E/hbnu0NxMFBjpMIE34DRGLWqDy0g5FuKDhCb31ngxA=
 dmitri.shuralyov.com/gpu/mtl v0.0.0-20190408044501-666a987793e9/go.mod h1:H6x//7gZCb22OMCxBHrMx7a5I7Hp++hsVxbQ4BYO7hU=
 filippo.io/edwards25519 v1.2.0 h1:crnVqOiS4jqYleHd9vaKZ+HKtHfllngJIiOpNpoJsjo=
 filippo.io/edwards25519 v1.2.0/go.mod h1:xzAOLCNug/yB62zG1bQ8uziwrIqIuxhctzJT18Q77mc=
-github.com/AfterShip/clickhouse-sql-parser v0.5.5 h1:LCA23yAA4GgF73PoYXb67yzCdC4sXsj4geQz1Oij3U8=
-github.com/AfterShip/clickhouse-sql-parser v0.5.5/go.mod h1:Qi3qvPTfZb/aFwI5V4WFOahgjsLJa4MzVijIAfwOhDw=
+github.com/AfterShip/clickhouse-sql-parser v0.5.4 h1:yiCQaMq8EO+dpKdnpP9YYd/ne6MSuOXgsMsNL33NiTI=
+github.com/AfterShip/clickhouse-sql-parser v0.5.4/go.mod h1:Qi3qvPTfZb/aFwI5V4WFOahgjsLJa4MzVijIAfwOhDw=
 github.com/Azure/azure-sdk-for-go v68.0.0+incompatible h1:fcYLmCpyNYRnvJbPerq7U0hS+6+I79yEDJBqVNcqUzU=
 github.com/Azure/azure-sdk-for-go/sdk/azcore v1.21.0 h1:fou+2+WFTib47nS+nz/ozhEBnvU96bKHy6LjRsY4E28=
 github.com/Azure/azure-sdk-for-go/sdk/azcore v1.21.0/go.mod h1:t76Ruy8AHvUAC8GfMWJMa0ElSbuIcO03NLpynfbgsPA=

pkg/prometheus/clickhouseprometheusv2/classification_golden_test.go

@@ -1,162 +0,0 @@
-package clickhouseprometheusv2
-
-import (
-	"encoding/json"
-	"flag"
-	"fmt"
-	"os"
-	"path/filepath"
-	"sort"
-	"strings"
-	"testing"
-
-	"github.com/prometheus/prometheus/promql/parser"
-	"github.com/stretchr/testify/require"
-)
-
-var updateGolden = flag.Bool("update", false, "rewrite the classification golden file")
-
-const goldenFile = "testdata/classification_golden.json"
-
-// corpusFile is the conformance corpus that the integration suite replays.
-// The golden freezes the route of every expression in it.
-const corpusFile = "../../../tests/integration/testdata/promqltestcorpus/corpus.json"
-
-// TestClassificationGolden freezes the route of every conformance-corpus
-// expression: "full", "hybrid(<units>)", or "fallback: <reason>". The route
-// is a correctness surface of its own. A change that silently sends a shape
-// to the engine loses the pushdown. A change that silently transpiles an
-// unproven shape risks wrong numbers. Both must show as a diff of this file.
-// The corpus suite's clickhousev2 leg then judges the numbers.
-//
-// The golden keys on the expression alone. The corpus evaluates each
-// expression on several grids, and the test requires the route to be the
-// same on all of them. If a classifier change ever makes the route depend
-// on the grid, this test fails and the key must grow.
-//
-// Regenerate after an intended classifier change:
-//
-//	go test ./pkg/prometheus/clickhouseprometheusv2 -run TestClassificationGolden -update
-func TestClassificationGolden(t *testing.T) {
-	raw, err := os.ReadFile(corpusFile)
-	require.NoError(t, err)
-
-	var corpus struct {
-		Cases []struct {
-			Expr    string `json:"expr"`
-			StartMs int64  `json:"start_ms"`
-			EndMs   int64  `json:"end_ms"`
-			StepMs  int64  `json:"step_ms"`
-		} `json:"cases"`
-	}
-	require.NoError(t, json.Unmarshal(raw, &corpus))
-	require.NotEmpty(t, corpus.Cases)
-
-	promParser := parser.NewParser(parser.Options{})
-	routes := map[string]string{}
-	for _, c := range corpus.Cases {
-		expr, err := promParser.ParseExpr(c.Expr)
-		require.NoError(t, err, "corpus expression must parse: %q", c.Expr)
-
-		var route string
-		plan, ok := classify(expr, gridContext{startMs: c.StartMs, endMs: c.EndMs, stepMs: c.StepMs})
-		switch {
-		case ok && plan.full:
-			route = "full"
-		case ok:
-			route = fmt.Sprintf("hybrid(%d)", len(plan.units))
-		default:
-			route = "fallback: " + fallbackShape(expr)
-		}
-
-		if prev, seen := routes[c.Expr]; seen {
-			require.Equal(t, prev, route,
-				"route differs between grids for %q — the golden key must grow to include the grid", c.Expr)
-			continue
-		}
-		routes[c.Expr] = route
-	}
-
-	// json.MarshalIndent sorts map keys: the file is deterministic.
-	got, err := json.MarshalIndent(routes, "", "  ")
-	require.NoError(t, err)
-	got = append(got, '\n')
-
-	if *updateGolden {
-		require.NoError(t, os.MkdirAll(filepath.Dir(goldenFile), 0o755))
-		require.NoError(t, os.WriteFile(goldenFile, got, 0o644))
-		return
-	}
-
-	want, err := os.ReadFile(goldenFile)
-	require.NoError(t, err, "golden missing — generate it with -update")
-	require.Equal(t, string(want), string(got),
-		"classification route changed; if intended, regenerate with -update and explain the diff in review")
-}
-
-// fallbackShape buckets a non-transpilable query by why it stays on the engine
-// path, to separate "already served well" (instant selectors on the last-sample-per-step
-// path) from genuine compiler gaps.
-func fallbackShape(expr parser.Expr) string {
-	var hasMatrix, hasSubquery, hasAt, hasDurationExpr, overTime bool
-	rangeFns := map[string]bool{"rate": true, "increase": true, "delta": true, "irate": true, "idelta": true}
-	var unsupportedFns []string
-	parser.Inspect(expr, func(node parser.Node, _ []parser.Node) error {
-		switch n := node.(type) {
-		case *parser.MatrixSelector:
-			hasMatrix = true
-			if n.RangeExpr != nil {
-				hasDurationExpr = true
-			}
-		case *parser.SubqueryExpr:
-			hasSubquery = true
-			if n.RangeExpr != nil || n.StepExpr != nil || n.OriginalOffsetExpr != nil {
-				hasDurationExpr = true
-			}
-		case *parser.VectorSelector:
-			if n.Timestamp != nil || n.StartOrEnd != 0 {
-				hasAt = true
-			}
-			if n.OriginalOffsetExpr != nil {
-				hasDurationExpr = true
-			}
-		case *parser.Call:
-			if strings.HasSuffix(n.Func.Name, "_over_time") {
-				overTime = true
-			} else if !rangeFns[n.Func.Name] {
-				unsupportedFns = append(unsupportedFns, n.Func.Name)
-			}
-		}
-		return nil
-	})
-
-	switch {
-	case hasDurationExpr:
-		return "duration expression (resolved only at evaluation time)"
-	case hasSubquery:
-		return "subquery"
-	case hasAt:
-		return "@ modifier"
-	case overTime:
-		return "*_over_time range function"
-	case !hasMatrix:
-		return "instant-selector shape (last-sample-per-step engine path)"
-	case len(unsupportedFns) > 0:
-		return fmt.Sprintf("range shape with unsupported function(s): %s", strings.Join(dedupe(unsupportedFns), ",")) //nolint:makezero
-	default:
-		return "other range shape"
-	}
-}
-
-func dedupe(in []string) []string {
-	seen := map[string]bool{}
-	var out []string
-	for _, s := range in {
-		if !seen[s] {
-			seen[s] = true
-			out = append(out, s)
-		}
-	}
-	sort.Strings(out)
-	return out
-}

pkg/prometheus/clickhouseprometheusv2/provider.go

@@ -2,27 +2,27 @@ package clickhouseprometheusv2
 
 import (
 	"context"
-	"time"
 
 	"github.com/SigNoz/signoz/pkg/factory"
 	"github.com/SigNoz/signoz/pkg/prometheus"
 	"github.com/SigNoz/signoz/pkg/telemetrystore"
-	"github.com/prometheus/prometheus/promql"
 	"github.com/prometheus/prometheus/storage"
 )
 
+// provider ties the package together: its own engine and parser, and the
+// ClickHouse client behind the native storage.Querier. It stays unexported:
+// callers hold the prometheus.Prometheus interface, which is the boundary
+// between the two provider implementations.
 type provider struct {
 	settings factory.ScopedProviderSettings
 	engine   *prometheus.Engine
 	parser   prometheus.Parser
 	client   *client
-	executor *executor
 }
 
 var (
 	_ prometheus.Prometheus        = (*provider)(nil)
 	_ prometheus.StatementCapturer = (*provider)(nil)
-	_ prometheus.RangeExecutor     = (*provider)(nil)
 )
 
 func NewFactory(telemetryStore telemetrystore.TelemetryStore) factory.ProviderFactory[prometheus.Prometheus, prometheus.Config] {
@@ -43,14 +43,9 @@ func New(_ context.Context, providerSettings factory.ProviderSettings, config pr
 		engine:   engine,
 		parser:   parser,
 		client:   client,
-		executor: &executor{client: client, engine: engine, parser: parser},
 	}, nil
 }
 
-func (p *provider) TryExecuteRange(ctx context.Context, query string, start, end time.Time, step time.Duration) (promql.Matrix, bool, error) {
-	return p.executor.TryExecuteRange(ctx, query, start, end, step)
-}
-
 func (p *provider) Engine() *prometheus.Engine {
 	return p.engine
 }

pkg/prometheus/clickhouseprometheusv2/testdata/classification_golden.json

@@ -1,319 +0,0 @@
-{
-  "(metric1_total offset 2) ^ 2": "full",
-  "-metric_a or -metric_b": "hybrid(2)",
-  "-metric_total": "full",
-  "-{job=\"api\"}": "full",
-  "10 atan2 20": "fallback: instant-selector shape (last-sample-per-step engine path)",
-  "10 atan2 NaN": "fallback: instant-selector shape (last-sample-per-step engine path)",
-  "AVG(http_requests) BY (job)": "full",
-  "COUNT(http_requests) BY (job)": "full",
-  "MAX(http_requests) BY (job)": "full",
-  "MIN(http_requests) BY (job)": "full",
-  "SUM BY (group) (((http_requests{job=\"api-server\"})))": "full",
-  "SUM BY (group) (http_requests{job=\"api-server\"})": "full",
-  "SUM(http_requests)": "full",
-  "SUM(http_requests) BY (job)": "full",
-  "SUM(http_requests) BY (job, group)": "full",
-  "SUM(http_requests) BY (job, nonexistent)": "full",
-  "SUM(http_requests{instance=\"0\"}) BY(job)": "full",
-  "abs(-1 * http_requests{group=\"production\",job=\"api-server\"})": "hybrid(1)",
-  "acos(trig - 10.1)": "hybrid(1)",
-  "acosh(trig)": "fallback: instant-selector shape (last-sample-per-step engine path)",
-  "asin(trig - 10.1)": "hybrid(1)",
-  "asinh(trig)": "fallback: instant-selector shape (last-sample-per-step engine path)",
-  "atan(trig)": "fallback: instant-selector shape (last-sample-per-step engine path)",
-  "atanh(trig - 10.1)": "hybrid(1)",
-  "avg by (group) (data{test=\"nan\"})": "full",
-  "avg by (group) (data{test=\"neg_inf\"})": "full",
-  "avg by (group) (data{test=\"pos_inf\"})": "full",
-  "avg by (group) (http_requests{job=\"api-server\"})": "full",
-  "avg(data)": "full",
-  "avg(data{test=\"-big\"})": "full",
-  "avg(data{test=\"-inf\"})": "full",
-  "avg(data{test=\"-inf2\"})": "full",
-  "avg(data{test=\"-inf3\"})": "full",
-  "avg(data{test=\"big\"})": "full",
-  "avg(data{test=\"bigzero\"})": "full",
-  "avg(data{test=\"inf\"})": "full",
-  "avg(data{test=\"inf2\"})": "full",
-  "avg(data{test=\"inf3\"})": "full",
-  "avg(data{test=\"inf_inf\"})": "full",
-  "avg(data{test=\"nan\"})": "full",
-  "avg(data{test=\"ten\"})": "full",
-  "avg(foo) - 52": "full",
-  "avg(foo) == 52": "full",
-  "avg(topk(10, foo)) - 52": "fallback: instant-selector shape (last-sample-per-step engine path)",
-  "avg(topk(10, foo)) == 52": "fallback: instant-selector shape (last-sample-per-step engine path)",
-  "avg(topk(11, foo)) - 52": "fallback: instant-selector shape (last-sample-per-step engine path)",
-  "avg(topk(11, foo)) == 52": "fallback: instant-selector shape (last-sample-per-step engine path)",
-  "avg(topk(8, foo)) - 52": "fallback: instant-selector shape (last-sample-per-step engine path)",
-  "avg(topk(8, foo)) == 52": "fallback: instant-selector shape (last-sample-per-step engine path)",
-  "avg(topk(9, foo)) - 52": "fallback: instant-selector shape (last-sample-per-step engine path)",
-  "avg(topk(9, foo)) == 52": "fallback: instant-selector shape (last-sample-per-step engine path)",
-  "avg_over_time(foo[100s]) - 52": "full",
-  "avg_over_time(foo[100s]) == 52": "full",
-  "avg_over_time(foo[110s]) - 52": "full",
-  "avg_over_time(foo[110s]) == 52": "full",
-  "avg_over_time(foo[120s]) - 52": "full",
-  "avg_over_time(foo[120s]) == 52": "full",
-  "avg_over_time(foo[130s]) - 52": "full",
-  "avg_over_time(foo[130s]) == 52": "full",
-  "avg_over_time(metric10[1m])": "full",
-  "avg_over_time(metric11[1m])": "full",
-  "avg_over_time(metric1[1m])": "full",
-  "avg_over_time(metric2[1m])": "full",
-  "avg_over_time(metric3[1m])": "full",
-  "avg_over_time(metric4[1m])": "full",
-  "avg_over_time(metric5[1m])": "full",
-  "avg_over_time(metric6[1m])": "full",
-  "avg_over_time(metric7[1m])": "full",
-  "avg_over_time(metric8[1m])": "full",
-  "avg_over_time(metric9[1m])": "full",
-  "avg_over_time(metric[2m])": "full",
-  "avg_over_time(rate(http_requests_total[1m])[1m:1s])": "hybrid(1)",
-  "ceil(0.004 * http_requests{group=\"production\",job=\"api-server\"})": "hybrid(1)",
-  "changes(http_requests[1800])": "fallback: range shape with unsupported function(s): changes",
-  "changes(http_requests[30m])": "fallback: range shape with unsupported function(s): changes",
-  "changes(metric[1m])": "fallback: range shape with unsupported function(s): changes",
-  "changes(metric[5m])": "fallback: range shape with unsupported function(s): changes",
-  "changes(x[20m])": "fallback: range shape with unsupported function(s): changes",
-  "clamp(metric_total, 0, 100)": "fallback: instant-selector shape (last-sample-per-step engine path)",
-  "cos(trig)": "fallback: instant-selector shape (last-sample-per-step engine path)",
-  "cosh(trig)": "fallback: instant-selector shape (last-sample-per-step engine path)",
-  "count by (group) (http_requests{job=\"api-server\"})": "full",
-  "count by(namespace, pod, cpu) (node_cpu_seconds_total{cpu=~\".*\",job=\"node-exporter\",mode=\"idle\",namespace=\"observability\",pod=\"node-exporter-l454v\"}) * on(namespace, pod) group_left(node) node_namespace_pod:kube_pod_info:{namespace=\"observability\",pod=\"node-exporter-l454v\"}": "hybrid(1)",
-  "count_over_time(metric1_total[range()])": "fallback: duration expression (resolved only at evaluation time)",
-  "count_over_time(metric1_total[step()])": "fallback: duration expression (resolved only at evaluation time)",
-  "count_over_time(metric[10])": "full",
-  "count_over_time(metric[10s])": "full",
-  "count_over_time(metric[1m])": "full",
-  "count_over_time(metric[1s])": "full",
-  "count_over_time(metric[20])": "full",
-  "count_over_time(metric[20s])": "full",
-  "deg(trig - 10)": "hybrid(1)",
-  "deg(trig - 20)": "hybrid(1)",
-  "deg(trig)": "fallback: instant-selector shape (last-sample-per-step engine path)",
-  "delta(metric[1m])": "full",
-  "floor(0.004 * http_requests{group=\"production\",job=\"api-server\"})": "hybrid(1)",
-  "foo \u003e 2 or bar": "fallback: instant-selector shape (last-sample-per-step engine path)",
-  "http_requests_total{foo!=\"bar\", job=\"api-server\"}": "full",
-  "http_requests_total{foo!=\"bar\"}": "full",
-  "http_requests_total{foo!~\"bar\", job=\"api-server\", instance=\"1\", x!=\"y\", z=\"\", group!=\"\"}": "full",
-  "http_requests_total{foo!~\"bar\", job=\"api-server\"}": "full",
-  "http_requests_total{group!=\"canary\"}": "full",
-  "http_requests_total{group=\"production\",job=\"api-server\"} offset 5m": "full",
-  "http_requests_total{group=\"production\",job=~\"api-.+\"}": "full",
-  "http_requests_total{job!~\"api-.+\",group!=\"canary\"}": "full",
-  "http_requests_total{job=~\".+-server\",group!=\"canary\"}": "full",
-  "increase(http_requests_total[100m])": "full",
-  "increase(http_requests_total[30m])": "full",
-  "increase(http_requests_total[50m])": "full",
-  "increase(metric[1m])": "full",
-  "increase(metric[5m])": "full",
-  "label_join(series, \"idx\", \",\", \"label\", \"label\")": "fallback: instant-selector shape (last-sample-per-step engine path)",
-  "label_replace((((testmetric))), ((\"dst\")), ((\"value-$1\")), ((\"src\")), ((\"non-matching-regex\")))": "fallback: instant-selector shape (last-sample-per-step engine path)",
-  "label_replace(series, \"idx\", \"replaced\", \"idx\", \".*\")": "fallback: instant-selector shape (last-sample-per-step engine path)",
-  "label_replace(sum by (__name__) (rate(metric_total{env=\"2\"}[5m])), \"__name__\", \"$1\", \"__name__\", \"(.+)\")": "fallback: range shape with unsupported function(s): label_replace",
-  "label_replace(testmetric, \"dst\", \"\", \"dst\", \".*\")": "fallback: instant-selector shape (last-sample-per-step engine path)",
-  "label_replace(testmetric, \"dst\", \"$1-value-$2\", \"src\", \"(.*)-value-(.*)\")": "fallback: instant-selector shape (last-sample-per-step engine path)",
-  "label_replace(testmetric, \"dst\", \"destination-value-$1\", \"src\", \"source-value-(.*)\")": "fallback: instant-selector shape (last-sample-per-step engine path)",
-  "label_replace(testmetric, \"dst\", \"destination-value-$1\", \"src\", \"value-(.*)\")": "fallback: instant-selector shape (last-sample-per-step engine path)",
-  "label_replace(testmetric, \"dst\", \"value-$1\", \"nonexistent-src\", \"(.*)\")": "fallback: instant-selector shape (last-sample-per-step engine path)",
-  "label_replace(testmetric, \"dst\", \"value-$1\", \"nonexistent-src\", \"source-value-(.*)\")": "fallback: instant-selector shape (last-sample-per-step engine path)",
-  "label_replace(testmetric, \"dst\", \"value-$1\", \"src\", \"non-matching-regex\")": "fallback: instant-selector shape (last-sample-per-step engine path)",
-  "last_over_time(metric_total{env=\"1\"}[10m])": "full",
-  "max_over_time(metric_total{env=\"1\"}[10m])": "full",
-  "metric": "full",
-  "metric1 offset 15m or metric2 offset 45m": "fallback: instant-selector shape (last-sample-per-step engine path)",
-  "metric1_total offset +min(step(), 1s)^0": "fallback: duration expression (resolved only at evaluation time)",
-  "metric1_total offset -(min(step(), 1s))+8000": "fallback: duration expression (resolved only at evaluation time)",
-  "metric1_total offset -min(step(), 1s)+8000": "fallback: duration expression (resolved only at evaluation time)",
-  "metric1_total offset -min(step(), 1s)^0": "fallback: duration expression (resolved only at evaluation time)",
-  "metric1_total offset -step()*2": "fallback: duration expression (resolved only at evaluation time)",
-  "metric1_total offset 100 + 2": "full",
-  "metric1_total offset 2 ^ 2": "full",
-  "metric1_total offset STEP()": "fallback: duration expression (resolved only at evaluation time)",
-  "metric1_total offset max(3s,min(step(), 1s))+8000": "fallback: duration expression (resolved only at evaluation time)",
-  "metric1_total offset min(range(), 8s)": "fallback: duration expression (resolved only at evaluation time)",
-  "metric1_total offset min(step(), 1s)": "fallback: duration expression (resolved only at evaluation time)",
-  "metric1_total offset min(step(), 1s)+8000": "fallback: duration expression (resolved only at evaluation time)",
-  "metric1_total offset min(step(), 1s)^0": "fallback: duration expression (resolved only at evaluation time)",
-  "metric1_total offset range()": "fallback: duration expression (resolved only at evaluation time)",
-  "metric1_total offset step()": "fallback: duration expression (resolved only at evaluation time)",
-  "metric1_total offset step()*0": "fallback: duration expression (resolved only at evaluation time)",
-  "metric1_total offset step()^0": "fallback: duration expression (resolved only at evaluation time)",
-  "metricA + ignoring() metricB": "fallback: instant-selector shape (last-sample-per-step engine path)",
-  "metricA + metricB": "fallback: instant-selector shape (last-sample-per-step engine path)",
-  "metric_total * 2": "full",
-  "metric_total + another_metric_total": "fallback: instant-selector shape (last-sample-per-step engine path)",
-  "metric_total \u003c= another_metric_total": "fallback: instant-selector shape (last-sample-per-step engine path)",
-  "metric_total \u003c= bool another_metric_total": "fallback: instant-selector shape (last-sample-per-step engine path)",
-  "metric_total{env=\"1\"}": "full",
-  "min_over_time(metric_total[10s])": "full",
-  "min_over_time(metric_total[15s:10s])": "fallback: subquery",
-  "min_over_time(rate(metric_total[5m])[20m:1m])": "hybrid(1)",
-  "node_cpu % 2": "full",
-  "node_cpu * 2": "full",
-  "node_cpu * ignoring (role, mode) group_left (role) node_role": "fallback: instant-selector shape (last-sample-per-step engine path)",
-  "node_cpu * on (instance) group_left (role) node_role": "fallback: instant-selector shape (last-sample-per-step engine path)",
-  "node_cpu + 2": "full",
-  "node_cpu + on(dummy) group_left(foo) random*0": "hybrid(1)",
-  "node_cpu - 2": "full",
-  "node_cpu / 2": "full",
-  "node_cpu / ignoring (mode) group_left sum without (mode)(node_cpu)": "hybrid(1)",
-  "node_cpu / ignoring (mode) group_left(dummy) sum without (mode)(node_cpu)": "hybrid(1)",
-  "node_cpu / on (instance) group_left sum by (instance,job)(node_cpu)": "hybrid(1)",
-  "node_cpu \u003e on(job, instance) group_left(target) (threshold or on (job, instance) (sum by (job, instance)(node_cpu) * 0 + 1))": "hybrid(1)",
-  "node_cpu \u003e on(job, instance) group_left(target) threshold": "fallback: instant-selector shape (last-sample-per-step engine path)",
-  "node_cpu ^ 2": "full",
-  "node_role * ignoring (role) group_right (role) node_var": "fallback: instant-selector shape (last-sample-per-step engine path)",
-  "node_role * on (instance) group_right (role) node_var": "fallback: instant-selector shape (last-sample-per-step engine path)",
-  "node_var * ignoring (role) group_left (role) node_role": "fallback: instant-selector shape (last-sample-per-step engine path)",
-  "node_var * on (instance) group_left (role) node_role": "fallback: instant-selector shape (last-sample-per-step engine path)",
-  "other + fill": "fallback: instant-selector shape (last-sample-per-step engine path)",
-  "present_over_time(http_requests_total[10m])": "fallback: *_over_time range function",
-  "present_over_time(http_requests_total[16m])": "fallback: *_over_time range function",
-  "present_over_time(http_requests_total[5m])": "fallback: *_over_time range function",
-  "present_over_time(http_requests_total[6m])": "fallback: *_over_time range function",
-  "present_over_time(httpd_handshake_failures_total[1m])": "fallback: *_over_time range function",
-  "present_over_time(httpd_log_lines_total[30s])": "fallback: *_over_time range function",
-  "present_over_time(rate(http_requests_total[5m])[5m:1m])": "hybrid(1)",
-  "present_over_time({instance=\"127.0.0.1\"}[5m:5s])": "fallback: subquery",
-  "present_over_time({instance=\"127.0.0.1\"}[5m])": "fallback: *_over_time range function",
-  "present_over_time({job=\"grok\"}[20m])": "fallback: *_over_time range function",
-  "present_over_time({job=\"ingress\"}[4m])": "fallback: *_over_time range function",
-  "rad(trig - 10)": "hybrid(1)",
-  "rad(trig - 20)": "hybrid(1)",
-  "rad(trig)": "fallback: instant-selector shape (last-sample-per-step engine path)",
-  "random + on() metricA": "fallback: instant-selector shape (last-sample-per-step engine path)",
-  "rate(calculate_rate_offset_total[10m] offset 5m)": "full",
-  "rate(calculate_rate_window_total[50m])": "full",
-  "rate(http_requests_total[1m])": "full",
-  "rate(http_requests_total[40s]) - rate(http_requests_total[1m] offset 10000s)": "hybrid(2)",
-  "rate(http_requests_total{group=~\"((?i)PRO).*\"}[1m])": "full",
-  "rate(http_requests_total{group=~\"(?i:PRO).*\"}[1m])": "full",
-  "rate(http_requests_total{group=~\"(?i:PRODUCTION)\"}[1m])": "full",
-  "rate(http_requests_total{group=~\".*((?i)DUC).*\"}[1m])": "full",
-  "rate(http_requests_total{group=~\".*((?i)TION)\"}[1m])": "full",
-  "rate(http_requests_total{group=~\".*(?i:C).*\"}[1m])": "full",
-  "rate(http_requests_total{group=~\".*(?i:DUC).*\"}[1m])": "full",
-  "rate(http_requests_total{group=~\".*(?i:TION)\"}[1m])": "full",
-  "rate(http_requests_total{group=~\".*(?i:TION).*?\"}[1m])": "full",
-  "rate(http_requests_total{group=~\".*?(?i:PRO).*\"}[1m])": "full",
-  "rate(http_requests_total{group=~\".*ry\", instance=\"1\"}[1m])": "full",
-  "rate(http_requests_total{group=~\"pro.*\"}[1m:10s])": "fallback: subquery",
-  "rate(http_requests_total{group=~\"pro.*\"}[1m])": "full",
-  "rate(http_requests_total{instance!=\"3\"}[1m] offset 10000s)": "full",
-  "rate(metric_total[1m1s:10s])": "fallback: subquery",
-  "rate(metric_total[1m500ms:10s])": "fallback: subquery",
-  "rate(metric_total[1m])": "full",
-  "rate(metric_total[20s:10s])": "fallback: subquery",
-  "rate(metric_total[20s:5s])": "fallback: subquery",
-  "rate(metric_total{env=\"1\"}[10m])": "full",
-  "rate(sum_over_time((metric1_total+metric2_total+metric3_total)[30s:10s])[30s:10s])": "fallback: subquery",
-  "rate(sum_over_time(metric1_total[30s:10s])[50s:10s])": "fallback: subquery",
-  "rate(sum_over_time(metric2_total[30s:10s])[50s:10s])": "fallback: subquery",
-  "rate(sum_over_time(metric3_total[30s:10s])[50s:10s])": "fallback: subquery",
-  "rate(testcounter_reset_end_total[5m])": "full",
-  "rate(testcounter_reset_end_total[6m])": "full",
-  "rate(testcounter_reset_middle_total[50m])": "full",
-  "rate(testcounter_zero_cutoff_total[20m])": "full",
-  "requests * 2": "full",
-  "resets(metric[1m])": "fallback: range shape with unsupported function(s): resets",
-  "resets(metric[5m])": "fallback: range shape with unsupported function(s): resets",
-  "round(-1 * (0.004 * http_requests{group=\"production\",job=\"api-server\"}))": "hybrid(1)",
-  "round(-1 * (0.005 * http_requests{group=\"production\",job=\"api-server\"}))": "hybrid(1)",
-  "round(-1 * (1 + 0.005 * http_requests{group=\"production\",job=\"api-server\"}))": "hybrid(1)",
-  "round(-1 * (5.2 + 0.0005 * http_requests{group=\"production\",job=\"api-server\"}), 0.1)": "hybrid(1)",
-  "round(0.0005 * http_requests{group=\"production\",job=\"api-server\"}, 0.1)": "hybrid(1)",
-  "round(0.004 * http_requests{group=\"production\",job=\"api-server\"})": "hybrid(1)",
-  "round(0.005 * http_requests{group=\"production\",job=\"api-server\"})": "hybrid(1)",
-  "round(0.025 * http_requests{group=\"production\",job=\"api-server\"}, 5)": "hybrid(1)",
-  "round(0.045 * http_requests{group=\"production\",job=\"api-server\"}, 5)": "hybrid(1)",
-  "round(1 + 0.005 * http_requests{group=\"production\",job=\"api-server\"})": "hybrid(1)",
-  "round(2.1 + 0.0005 * http_requests{group=\"production\",job=\"api-server\"}, 0.1)": "hybrid(1)",
-  "round(5.2 + 0.0005 * http_requests{group=\"production\",job=\"api-server\"}, 0.1)": "hybrid(1)",
-  "round(metric_total)": "fallback: instant-selector shape (last-sample-per-step engine path)",
-  "sin(trig)": "fallback: instant-selector shape (last-sample-per-step engine path)",
-  "sinh(trig)": "fallback: instant-selector shape (last-sample-per-step engine path)",
-  "stddev (series)": "fallback: instant-selector shape (last-sample-per-step engine path)",
-  "stddev by (instance)(http_requests)": "fallback: instant-selector shape (last-sample-per-step engine path)",
-  "stddev by (label) (series)": "fallback: instant-selector shape (last-sample-per-step engine path)",
-  "stddev(http_requests)": "fallback: instant-selector shape (last-sample-per-step engine path)",
-  "stddev(series)": "fallback: instant-selector shape (last-sample-per-step engine path)",
-  "stddev_over_time(metric[1m])": "fallback: *_over_time range function",
-  "stdvar (series)": "fallback: instant-selector shape (last-sample-per-step engine path)",
-  "stdvar by (instance)(http_requests)": "fallback: instant-selector shape (last-sample-per-step engine path)",
-  "stdvar by (label) (series)": "fallback: instant-selector shape (last-sample-per-step engine path)",
-  "stdvar(http_requests)": "fallback: instant-selector shape (last-sample-per-step engine path)",
-  "stdvar(series)": "fallback: instant-selector shape (last-sample-per-step engine path)",
-  "stdvar_over_time(metric[1m])": "fallback: *_over_time range function",
-  "sum by () (http_requests{job=\"api-server\"})": "full",
-  "sum by (__name__) (metric_total{env=\"1\"} or rate(metric_total{env=\"2\"}[5m]))": "fallback: other range shape",
-  "sum by (__name__) (metric_total{env=\"1\"})": "fallback: instant-selector shape (last-sample-per-step engine path)",
-  "sum by (__name__) (metric_total{env=\"3\"} or rate(metric_total{env=\"2\"}[5m]))": "fallback: other range shape",
-  "sum by (__name__) (rate(metric_total{env=\"2\"}[5m]) or metric_total{env=\"1\"})": "fallback: other range shape",
-  "sum by (__name__) (rate(metric_total{env=\"2\"}[5m]))": "fallback: other range shape",
-  "sum by (__name__) (rate(metric_total{env=\"3\"}[5m]) or metric_total{env=\"1\"})": "fallback: other range shape",
-  "sum by (__name__, env) (metric_total{env=\"1\"})": "fallback: instant-selector shape (last-sample-per-step engine path)",
-  "sum by (group) (data{test=\"nan\"})": "full",
-  "sum by (group) (data{test=\"neg_inf\"})": "full",
-  "sum by (group) (data{test=\"pos_inf\"})": "full",
-  "sum by (group) (http_requests{job=\"api-server\"})": "full",
-  "sum by (mode, job)(node_cpu) / on (job) group_left sum by (job)(node_cpu)": "hybrid(2)",
-  "sum without () (http_requests{job=\"api-server\",group=\"production\"})": "full",
-  "sum without (instance) (http_requests{job=\"api-server\"} or foo)": "fallback: instant-selector shape (last-sample-per-step engine path)",
-  "sum without (instance) (http_requests{job=\"api-server\"})": "full",
-  "sum without (instance)(node_cpu) / ignoring (mode) group_left sum without (instance, mode)(node_cpu)": "hybrid(2)",
-  "sum(data{test=\"inf_inf\"})": "full",
-  "sum(data{test=\"ten\"})": "full",
-  "sum(http_requests) by (job) + min(http_requests) by (job) + max(http_requests) by (job) + avg(http_requests) by (job)": "hybrid(4)",
-  "sum(http_requests{job=\"api-server\"})": "full",
-  "sum(label_grouping_test) by (a, b)": "full",
-  "sum(sum by (group) (http_requests{job=\"api-server\"})) by (job)": "hybrid(1)",
-  "sum(sum by (mode, job)(node_cpu) / on (job) group_left sum by (job)(node_cpu))": "hybrid(2)",
-  "sum(sum without (instance)(node_cpu) / ignoring (mode) group_left sum without (instance, mode)(node_cpu))": "hybrid(2)",
-  "sum_over_time((metric1_total)[30:10] offset 3)": "fallback: subquery",
-  "sum_over_time((metric1_total)[30:10] offset 3s)": "fallback: subquery",
-  "sum_over_time((metric1_total)[30:10s] offset 3s)": "fallback: subquery",
-  "sum_over_time((metric1_total)[30s:10s] offset 3s)": "fallback: subquery",
-  "sum_over_time(bar[30s])": "full",
-  "sum_over_time(metric1_total[30:10] offset 3)": "fallback: subquery",
-  "sum_over_time(metric1_total[30s:10s] offset 10s)": "fallback: subquery",
-  "sum_over_time(metric1_total[30s:10s] offset 3s)": "fallback: subquery",
-  "sum_over_time(metric1_total[30s:10s] offset 5s)": "fallback: subquery",
-  "sum_over_time(metric1_total[30s:10s] offset 7s)": "fallback: subquery",
-  "sum_over_time(metric1_total[30s:10s] offset 9s)": "fallback: subquery",
-  "sum_over_time(metric1_total[30s:10s])": "fallback: subquery",
-  "sum_over_time(metric1_total[30s:5s])": "fallback: subquery",
-  "sum_over_time(metric[1000ms])": "full",
-  "sum_over_time(metric[1001ms])": "fallback: *_over_time range function",
-  "sum_over_time(metric[1002ms])": "fallback: *_over_time range function",
-  "sum_over_time(metric[1003ms])": "fallback: *_over_time range function",
-  "sum_over_time(metric[2000ms])": "full",
-  "sum_over_time(metric[2001ms])": "fallback: *_over_time range function",
-  "sum_over_time(metric[2002ms])": "fallback: *_over_time range function",
-  "sum_over_time(metric[2003ms])": "fallback: *_over_time range function",
-  "sum_over_time(metric[2m])": "full",
-  "sum_over_time(metric[3000ms])": "full",
-  "sum_over_time(metric[3001ms])": "fallback: *_over_time range function",
-  "sum_over_time(metric[3002ms])": "fallback: *_over_time range function",
-  "sum_over_time(metric[3003ms])": "fallback: *_over_time range function",
-  "sum_over_time(metric_total[50s:10s])": "fallback: subquery",
-  "sum_over_time(metric_total[50s:5s])": "fallback: subquery",
-  "sum_over_time(metric_total[60s:10s])": "fallback: subquery",
-  "tan(trig)": "fallback: instant-selector shape (last-sample-per-step engine path)",
-  "tanh(trig)": "fallback: instant-selector shape (last-sample-per-step engine path)",
-  "test_total \u003c bool test_smaller": "fallback: instant-selector shape (last-sample-per-step engine path)",
-  "test_total \u003c test_smaller": "fallback: instant-selector shape (last-sample-per-step engine path)",
-  "test_total \u003e bool test_smaller": "fallback: instant-selector shape (last-sample-per-step engine path)",
-  "test_total \u003e test_smaller": "fallback: instant-selector shape (last-sample-per-step engine path)",
-  "testmetric": "full",
-  "topk(10, sum by (__name__, env) (metric_total{env=\"1\"}))": "fallback: instant-selector shape (last-sample-per-step engine path)",
-  "topk(10, sum by (__name__, env) (rate(metric_total{env=\"1\"}[10m])))": "fallback: other range shape",
-  "trigy atan2 trigNaN": "fallback: instant-selector shape (last-sample-per-step engine path)",
-  "trigy atan2 trigx": "fallback: instant-selector shape (last-sample-per-step engine path)",
-  "x{y=\"testvalue\"}": "full",
-  "{__name__=~\".+\"}": "full",
-  "{job=~\".+-server\", job!~\"api-.+\"}": "full"
-}

pkg/prometheus/clickhouseprometheusv2/transpiler.go

@@ -1,470 +0,0 @@
-package clickhouseprometheusv2
-
-import (
-	"fmt"
-	"strings"
-
-	"github.com/prometheus/prometheus/model/labels"
-	"github.com/prometheus/prometheus/promql/parser"
-)
-
-// The transpiler turns allowlisted PromQL subtrees into single ClickHouse
-// statements on the timeSeries*ToGrid aggregate functions. Every other
-// shape falls back to the engine over this package's querier. See
-// docs/contributing/prometheus.md for the model, the allowlist, and the
-// correctness argument of each form.
-
-type rangeFn string
-
-const (
-	fnRate     rangeFn = "rate"
-	fnIncrease rangeFn = "increase"
-	fnDelta    rangeFn = "delta"
-	fnIRate    rangeFn = "irate"
-	fnIDelta   rangeFn = "idelta"
-)
-
-var gridFunction = map[rangeFn]string{
-	fnRate:     "timeSeriesRateToGrid",
-	fnIncrease: "timeSeriesRateToGrid", // increase == rate * range seconds, exactly (same factor algebra)
-	fnDelta:    "timeSeriesDeltaToGrid",
-	fnIRate:    "timeSeriesInstantRateToGrid",
-	fnIDelta:   "timeSeriesInstantDeltaToGrid",
-}
-
-// scalarOp runs in Go during assembly, with the same float64 operations
-// the engine uses.
-type scalarOp struct {
-	op           parser.ItemType
-	scalar       float64
-	scalarOnLeft bool
-	returnBool   bool
-}
-
-// Comparisons preserve the metric name; arithmetic drops it.
-func (o scalarOp) isComparison() bool {
-	return o.op.IsComparisonOperator()
-}
-
-type unitKind int
-
-const (
-	// unitRange: rate/increase/delta/irate/idelta over a matrix selector.
-	unitRange unitKind = iota
-	// unitInstant: a plain vector selector resolved per grid point with
-	// lookback and stale-marker shadowing.
-	unitInstant
-	// unitOverTime: avg/min/max/sum/count/last_over_time over a matrix
-	// selector (aggregation over the window's samples, stale rows excluded).
-	unitOverTime
-)
-
-// coreUnit is one transpilable subtree: selector [-> range function] ->
-// optional aggregation -> scalar-op pipeline.
-type coreUnit struct {
-	kind     unitKind
-	matchers []*labels.Matcher
-	offsetMs int64
-	fn       rangeFn // unitRange
-	overFn   string  // unitOverTime: avg|min|max|sum|count|last
-	rangeMs  int64   // unitRange/unitOverTime window
-
-	hasAgg   bool
-	aggOp    parser.ItemType // SUM MIN MAX AVG COUNT
-	by       bool
-	grouping []string
-
-	ops []scalarOp
-}
-
-// keepsName reports whether the unit's output series keep their real
-// __name__. Bare and comparison-filtered instant selectors keep it, and so
-// does last_over_time: they return the raw sample, name included. Range
-// functions, the other *_over_time functions, aggregations, arithmetic, and
-// bool comparisons all drop it. A bool comparison returns 0/1, not the
-// sample, so the engine drops the name there too. A unit that keeps the
-// name cannot become a synthetic series in a hybrid plan: the synthetic
-// name would replace the real one. It transpiles fine as a full plan, where
-// assembly emits the real names.
-func (u *coreUnit) keepsName() bool {
-	nameKeepingSelector := u.kind == unitInstant || (u.kind == unitOverTime && u.overFn == "last")
-	if !nameKeepingSelector || u.hasAgg {
-		return false
-	}
-	for _, op := range u.ops {
-		if !op.isComparison() || op.returnBool {
-			return false
-		}
-	}
-	return true
-}
-
-// gridContext is the evaluation grid a unit computes on. The query grid for
-// top-level units; for units inside subqueries, the subquery's own grid:
-// epoch-aligned multiples of its resolution covering the subquery window,
-// exactly as the engine derives it (engine.go, *parser.SubqueryExpr case).
-type gridContext struct {
-	startMs int64
-	endMs   int64
-	stepMs  int64
-}
-
-// subqueryGrid derives the inner grid for a subquery evaluated on outer:
-// interval S, end = outer end − offset, start = first multiple of S strictly
-// greater than outer start − offset − range.
-func subqueryGrid(outer gridContext, rangeMs, stepMs, offsetMs int64) gridContext {
-	lower := outer.startMs - offsetMs - rangeMs
-	start := stepMs * (lower / stepMs)
-	if start <= lower {
-		start += stepMs
-	}
-	return gridContext{startMs: start, endMs: outer.endMs - offsetMs, stepMs: stepMs}
-}
-
-type transpiledUnit struct {
-	core coreUnit
-	name string // __signoz_transpiled_<n>__
-	grid gridContext
-}
-
-type transpilePlan struct {
-	units []*transpiledUnit
-	grid  gridContext // the query's top-level grid
-	// full is set when the entire query is units[0]; otherwise rewritten
-	// holds the query with each unit replaced by a synthetic selector, to be
-	// evaluated by the engine over a hybrid storage.
-	full      bool
-	rewritten string
-}
-
-const syntheticNamePrefix = "__signoz_transpiled_"
-
-func syntheticName(i int) string {
-	return fmt.Sprintf("%s%d__", syntheticNamePrefix, i)
-}
-
-// classifyCore matches a subtree against the transpilable core shape.
-// stepMs gates second-granularity: the grid functions take whole-second step
-// and window parameters (grid *starts* are millisecond-precise).
-func classifyCore(node parser.Expr, stepMs int64) (*coreUnit, bool) {
-	unit := &coreUnit{}
-
-	expr := node
-	// Peel scalar ops and parens off the top, outermost first; ops apply in
-	// evaluation order, so prepend while peeling.
-	for {
-		switch n := expr.(type) {
-		case *parser.ParenExpr:
-			expr = n.Expr
-			continue
-		case *parser.UnaryExpr:
-			if n.Op != parser.SUB {
-				expr = n.Expr // unary '+' is a no-op
-				continue
-			}
-			// -x == -1 * x for every float64 (incl. NaN and signed zero).
-			unit.ops = append([]scalarOp{{op: parser.MUL, scalar: -1}}, unit.ops...)
-			expr = n.Expr
-			continue
-		case *parser.StepInvariantExpr:
-			// @-pinned expressions evaluate on a different grid.
-			return nil, false
-		case *parser.BinaryExpr:
-			lit, litOnLeft, ok := numberLiteralSide(n)
-			if !ok {
-				return nil, false
-			}
-			if !n.Op.IsOperator() && !n.Op.IsComparisonOperator() {
-				return nil, false
-			}
-			if n.Op == parser.ATAN2 {
-				// atan2 is arithmetic in PromQL but rarely used; keep the
-				// allowlist tight.
-				return nil, false
-			}
-			returnBool := n.ReturnBool
-			unit.ops = append([]scalarOp{{op: n.Op, scalar: lit, scalarOnLeft: litOnLeft, returnBool: returnBool}}, unit.ops...)
-			if litOnLeft {
-				expr = n.RHS
-			} else {
-				expr = n.LHS
-			}
-			continue
-		}
-		break
-	}
-
-	// Optional aggregation.
-	if agg, ok := expr.(*parser.AggregateExpr); ok {
-		switch agg.Op {
-		case parser.SUM, parser.MIN, parser.MAX, parser.AVG, parser.COUNT:
-		default:
-			return nil, false
-		}
-		for _, g := range agg.Grouping {
-			if g == metricNameLabel {
-				// by(__name__)/without(__name__) over synthetic or compiled
-				// output needs name bookkeeping the compiler doesn't do.
-				return nil, false
-			}
-		}
-		unit.hasAgg = true
-		unit.aggOp = agg.Op
-		unit.by = !agg.Without
-		unit.grouping = agg.Grouping
-		expr = agg.Expr
-		for {
-			if p, ok := expr.(*parser.ParenExpr); ok {
-				expr = p.Expr
-				continue
-			}
-			break
-		}
-	}
-
-	// The grid functions take whole-second steps; stepMs == 0 is an instant
-	// query (single-point grid).
-	if stepMs < 0 || stepMs%1000 != 0 {
-		return nil, false
-	}
-
-	// Bare instant selector: resolved per grid point with lookback and
-	// stale-marker shadowing (see compiler_sql.go).
-	if vs, ok := expr.(*parser.VectorSelector); ok {
-		// A duration expression (offset step(), offset range()*2, ...) is
-		// resolved into OriginalOffset only at evaluation time; at
-		// classification time the field still holds its zero value, so
-		// transpiling would silently use the wrong offset.
-		if vs.Timestamp != nil || vs.StartOrEnd != 0 || vs.Anchored || vs.Smoothed || vs.OriginalOffsetExpr != nil {
-			return nil, false
-		}
-		offsetMs := vs.OriginalOffset.Milliseconds()
-		if offsetMs < 0 {
-			return nil, false
-		}
-		unit.kind = unitInstant
-		unit.offsetMs = offsetMs
-		unit.matchers = vs.LabelMatchers
-		return unit, true
-	}
-
-	// Range or *_over_time function over a plain matrix selector.
-	call, ok := expr.(*parser.Call)
-	if !ok {
-		return nil, false
-	}
-	var fn rangeFn
-	var overFn string
-	switch call.Func.Name {
-	case "rate":
-		fn = fnRate
-	case "increase":
-		fn = fnIncrease
-	case "delta":
-		fn = fnDelta
-	case "irate":
-		fn = fnIRate
-	case "idelta":
-		fn = fnIDelta
-	case "avg_over_time", "min_over_time", "max_over_time", "sum_over_time", "count_over_time", "last_over_time":
-		overFn = strings.TrimSuffix(call.Func.Name, "_over_time")
-	default:
-		return nil, false
-	}
-	if len(call.Args) != 1 {
-		return nil, false
-	}
-	ms, ok := call.Args[0].(*parser.MatrixSelector)
-	if !ok {
-		return nil, false
-	}
-	vs, ok := ms.VectorSelector.(*parser.VectorSelector)
-	if !ok {
-		return nil, false
-	}
-	// Duration expressions resolve at evaluation time (see the instant
-	// selector case above); Range/OriginalOffset would be read as zero here.
-	if vs.Timestamp != nil || vs.StartOrEnd != 0 || vs.Anchored || vs.Smoothed || vs.OriginalOffsetExpr != nil || ms.RangeExpr != nil {
-		return nil, false
-	}
-
-	rangeMs := ms.Range.Milliseconds()
-	offsetMs := vs.OriginalOffset.Milliseconds()
-	if rangeMs <= 0 || rangeMs%1000 != 0 || offsetMs < 0 {
-		return nil, false
-	}
-
-	if overFn != "" {
-		unit.kind = unitOverTime
-		unit.overFn = overFn
-	} else {
-		unit.kind = unitRange
-		unit.fn = fn
-	}
-	unit.rangeMs = rangeMs
-	unit.offsetMs = offsetMs
-	unit.matchers = vs.LabelMatchers
-	return unit, true
-}
-
-// numberLiteralSide returns the number literal on one side of a binary
-// expression (peeling parens and unary minus), and which side it is on.
-func numberLiteralSide(b *parser.BinaryExpr) (float64, bool, bool) {
-	if v, ok := literalValue(b.LHS); ok {
-		return v, true, true
-	}
-	if v, ok := literalValue(b.RHS); ok {
-		return v, false, true
-	}
-	return 0, false, false
-}
-
-func literalValue(e parser.Expr) (float64, bool) {
-	neg := false
-	for {
-		switch n := e.(type) {
-		case *parser.ParenExpr:
-			e = n.Expr
-			continue
-		case *parser.StepInvariantExpr:
-			e = n.Expr
-			continue
-		case *parser.UnaryExpr:
-			if n.Op == parser.SUB {
-				neg = !neg
-			}
-			e = n.Expr
-			continue
-		case *parser.NumberLiteral:
-			if neg {
-				return -n.Val, true
-			}
-			return n.Val, true
-		default:
-			return 0, false
-		}
-	}
-}
-
-// classify builds the compile plan for a query: full when the root is a core
-// unit, hybrid when core units sit strictly below the root (including inside
-// fixed-resolution subqueries, computed on the subquery grid), none
-// otherwise.
-func classify(root parser.Expr, grid gridContext) (*transpilePlan, bool) {
-	if unit, ok := classifyCore(root, grid.stepMs); ok {
-		return &transpilePlan{
-			units: []*transpiledUnit{{core: *unit, name: syntheticName(0), grid: grid}},
-			grid:  grid,
-			full:  true,
-		}, true
-	}
-
-	plan := &transpilePlan{grid: grid}
-	rewritten := rewrite(root, grid, plan, false)
-	if len(plan.units) == 0 {
-		return nil, false
-	}
-	plan.rewritten = rewritten.String()
-	return plan, true
-}
-
-// rewrite walks top-down replacing maximal transpilable subtrees with synthetic
-// vector selectors. nameSensitive marks scopes where an ancestor's semantics
-// depend on __name__ (grouping or vector matching on it): synthetic series
-// carry a synthetic __name__, so substitution there would change results.
-// Fixed-resolution subqueries recurse with the subquery's own grid; scopes
-// whose evaluation grid is unknowable (@-pinned, default-resolution
-// subqueries) are not entered.
-func rewrite(node parser.Expr, grid gridContext, plan *transpilePlan, nameSensitive bool) parser.Expr {
-	if node == nil {
-		return nil
-	}
-
-	if !nameSensitive {
-		// Units whose output keeps the real __name__ (bare instant selectors)
-		// cannot be substituted: the synthetic name would replace it in the
-		// engine's output. They still compile as full plans.
-		if unit, ok := classifyCore(node, grid.stepMs); ok && !unit.keepsName() {
-			cu := &transpiledUnit{core: *unit, name: syntheticName(len(plan.units)), grid: grid}
-			plan.units = append(plan.units, cu)
-			return &parser.VectorSelector{
-				Name: cu.name,
-				LabelMatchers: []*labels.Matcher{
-					labels.MustNewMatcher(labels.MatchEqual, metricNameLabel, cu.name),
-				},
-				PosRange: node.PositionRange(),
-			}
-		}
-	}
-
-	switch n := node.(type) {
-	case *parser.ParenExpr:
-		n.Expr = rewrite(n.Expr, grid, plan, nameSensitive)
-	case *parser.UnaryExpr:
-		n.Expr = rewrite(n.Expr, grid, plan, nameSensitive)
-	case *parser.AggregateExpr:
-		sensitive := nameSensitive || groupingUsesName(n.Grouping)
-		n.Expr = rewrite(n.Expr, grid, plan, sensitive)
-		// n.Param is a scalar/string; nothing transpilable inside for our core.
-	case *parser.Call:
-		for i, arg := range n.Args {
-			n.Args[i] = rewrite(arg, grid, plan, nameSensitive)
-		}
-	case *parser.BinaryExpr:
-		sensitive := nameSensitive || vectorMatchingUsesName(n.VectorMatching)
-		n.LHS = rewrite(n.LHS, grid, plan, sensitive)
-		n.RHS = rewrite(n.RHS, grid, plan, sensitive)
-	case *parser.SubqueryExpr:
-		// The alert-smoothing idiom fn_over_time((expr)[R:S]) dominates real
-		// rule fleets; inner units evaluate on the subquery grid, and the
-		// engine does the smoothing over the synthetic series. Requires an
-		// explicit whole-second resolution (S == 0 needs the engine's
-		// default-interval function) and no @ pinning.
-		stepMs := n.Step.Milliseconds()
-		rangeMs := n.Range.Milliseconds()
-		offsetMs := n.OriginalOffset.Milliseconds()
-		if n.Timestamp == nil && n.StartOrEnd == 0 &&
-			n.RangeExpr == nil && n.StepExpr == nil && n.OriginalOffsetExpr == nil &&
-			stepMs > 0 && stepMs%1000 == 0 && rangeMs%1000 == 0 && offsetMs >= 0 {
-			inner := subqueryGrid(grid, rangeMs, stepMs, offsetMs)
-			n.Expr = rewrite(n.Expr, inner, plan, nameSensitive)
-		}
-	case *parser.StepInvariantExpr, *parser.MatrixSelector,
-		*parser.VectorSelector, *parser.NumberLiteral, *parser.StringLiteral:
-		// Leaves, or scopes substitution must not enter.
-	}
-	return node
-}
-
-func groupingUsesName(grouping []string) bool {
-	for _, g := range grouping {
-		if g == metricNameLabel {
-			return true
-		}
-	}
-	return false
-}
-
-func vectorMatchingUsesName(vm *parser.VectorMatching) bool {
-	if vm == nil {
-		return false
-	}
-	for _, l := range append(append([]string{}, vm.MatchingLabels...), vm.Include...) {
-		if l == metricNameLabel {
-			return true
-		}
-	}
-	// Default (all-labels) matching ignores __name__, and by()/ignoring()
-	// lists were checked above.
-	return false
-}
-
-// isSyntheticSelector reports whether matchers target a compiled unit.
-func isSyntheticSelector(matchers []*labels.Matcher) (string, bool) {
-	for _, m := range matchers {
-		if m.Name == metricNameLabel && m.Type == labels.MatchEqual && strings.HasPrefix(m.Value, syntheticNamePrefix) {
-			return m.Value, true
-		}
-	}
-	return "", false
-}

pkg/prometheus/clickhouseprometheusv2/transpiler_exec.go

@@ -1,541 +0,0 @@
-package clickhouseprometheusv2
-
-import (
-	"context"
-	"encoding/json"
-	"math"
-	"sort"
-	"time"
-
-	"github.com/SigNoz/signoz/pkg/errors"
-	"github.com/SigNoz/signoz/pkg/prometheus"
-	"github.com/prometheus/prometheus/model/labels"
-	promValue "github.com/prometheus/prometheus/model/value"
-	"github.com/prometheus/prometheus/promql"
-	"github.com/prometheus/prometheus/promql/parser"
-	"github.com/prometheus/prometheus/storage"
-	"golang.org/x/sync/errgroup"
-)
-
-type executor struct {
-	client *client
-	engine *prometheus.Engine
-	parser prometheus.Parser
-}
-
-// maxWindowBuckets caps range/step for the windowed *_over_time form.
-// Every grid slot combines that many bucket partials. The fleet's windows
-// sit well under the cap ([1m]..[17m] at 30-60s steps). Anything larger is
-// a long-range query whose step a dashboard scales up anyway. The engine
-// path serves the rest.
-const maxWindowBuckets = 64
-
-func (e *executor) TryExecuteRange(ctx context.Context, qs string, start, end time.Time, step time.Duration) (promql.Matrix, bool, error) {
-	expr, err := e.parser.ParseExpr(qs)
-	if err != nil {
-		// Let the engine path produce the (enhanced) parse error.
-		return nil, false, nil
-	}
-
-	plan, ok := classify(expr, queryGrid(start, end, step))
-	if !ok {
-		return nil, false, nil
-	}
-
-	// timeSeriesLastToGrid widens its window to max(window, step). We
-	// probed this: a sample aged (window, step] still fills the slot. The
-	// rate/delta family enforces the window strictly. The Last-style kinds
-	// used to fall back when window < step because of that widening. The
-	// window-sliver filter (see samplesConditions) makes the widening
-	// harmless there: samples exist only inside (t_k - window, t_k]
-	// slivers, so the widened window intersected with the data IS the
-	// lookback window. If a future ClickHouse stops widening, the
-	// unwidened window is the sliver too. Correct either way. A
-	// non-positive window still falls back: the sliver argument needs a
-	// real window to filter to.
-	//
-	// The windowed *_over_time form gates only the range >= step regime.
-	// It decomposes the window into whole step buckets (see windowedInner).
-	// That is exact only when the range is a multiple of the step. The
-	// per-slot slide costs range/step bucket combines; maxWindowBuckets
-	// bounds it, so a long-range short-step query cannot turn the slide
-	// into the bottleneck. range < step needs neither gate: the windows
-	// are disjoint slivers, aggregated one slot each, with no slide. Every
-	// miss falls back to the engine path, which is exact.
-	for _, unit := range plan.units {
-		stepMs := unit.grid.stepMs
-		if stepMs == 0 {
-			stepMs = 1000
-		}
-		switch {
-		case unit.core.kind == unitInstant || (unit.core.kind == unitOverTime && unit.core.overFn == "last"):
-			windowMs := unit.core.rangeMs
-			if unit.core.kind == unitInstant {
-				windowMs = e.client.lookbackMs
-			}
-			if windowMs <= 0 {
-				return nil, false, nil
-			}
-		case unit.core.kind == unitOverTime:
-			if unit.core.rangeMs < unit.grid.stepMs {
-				// Disjoint slivers: no divisibility or width requirement.
-				continue
-			}
-			if unit.core.rangeMs%stepMs != 0 || unit.core.rangeMs/stepMs > maxWindowBuckets {
-				return nil, false, nil
-			}
-		}
-	}
-
-	// Evaluate every unit concurrently on its own grid (the query grid, or a
-	// subquery grid); each is one series lookup plus one grid query.
-	results := make([][]transpiledSeries, len(plan.units))
-	eg, egCtx := errgroup.WithContext(ctx)
-	for i, unit := range plan.units {
-		eg.Go(func() error {
-			res, err := e.executeUnit(egCtx, &unit.core, unit.grid)
-			if err != nil {
-				return err
-			}
-			results[i] = res
-			return nil
-		})
-	}
-	if err := eg.Wait(); err != nil {
-		return nil, true, err
-	}
-
-	if plan.full {
-		g := plan.units[0].grid
-		return toMatrix(results[0], g.startMs, g.stepMs), true, nil
-	}
-
-	matrix, err := e.executeHybrid(ctx, plan, results)
-	if err != nil {
-		return nil, true, err
-	}
-	return matrix, true, nil
-}
-
-// A step of 0 is an instant query: a single evaluation at end, whatever
-// start was.
-func queryGrid(start, end time.Time, step time.Duration) gridContext {
-	startMs, endMs, stepMs := start.UnixMilli(), end.UnixMilli(), step.Milliseconds()
-	if stepMs == 0 {
-		startMs = endMs
-	}
-	return gridContext{startMs: startMs, endMs: endMs, stepMs: stepMs}
-}
-
-// transpiledSeries holds one value pointer per grid point; nil is absent.
-type transpiledSeries struct {
-	lset   labels.Labels
-	values []*float64
-}
-
-func (e *executor) executeUnit(ctx context.Context, unit *coreUnit, grid gridContext) ([]transpiledSeries, error) {
-	startMs, endMs, stepMs := grid.startMs, grid.endMs, grid.stepMs
-	windowMs := unit.rangeMs
-	if unit.kind == unitInstant {
-		windowMs = e.client.lookbackMs
-	}
-	dataStart := startMs - unit.offsetMs - windowMs
-	dataEnd := endMs - unit.offsetMs
-
-	seriesQuery, seriesArgs, err := buildSeriesQuery(dataStart, dataEnd, unit.matchers)
-	if err != nil {
-		return nil, err
-	}
-	lookup, err := e.client.selectSeries(ctx, seriesQuery, seriesArgs)
-	if err != nil {
-		return nil, err
-	}
-	if len(lookup.fingerprints) == 0 {
-		return nil, nil
-	}
-
-	query, args, err := buildUnitSQL(unit, lookup.metricNames, dataStart, dataEnd, startMs, endMs, stepMs, e.client.lookbackMs)
-	if err != nil {
-		return nil, err
-	}
-
-	rows, err := e.client.telemetryStore.ClickhouseDB().Query(e.client.withContext(ctx, "transpiledUnit"), query, args...)
-	if err != nil {
-		return nil, err
-	}
-	defer rows.Close()
-
-	// Name-dropping units keep __name__ in the SQL group key, so distinct
-	// metrics never merge server-side. The name comes off here. Two
-	// metrics can then share a labelset. The engine merges their samples
-	// into one series when they never overlap in time. It raises the
-	// duplicate-labelset error only when two samples land on the same
-	// evaluation timestamp. mergeSameLabelsetSeries reproduces exactly
-	// that.
-	stripName := !unit.hasAgg && !unit.keepsName()
-
-	// by (...) units return one plain column per grouped label. Everything
-	// else returns the single canonical JSON key (see groupKeyColumns).
-	keyNames := groupKeyColumns(unit)
-	keyVals := make([]string, max(len(keyNames), 1))
-	targets := make([]any, 0, len(keyVals)+1)
-	for i := range keyVals {
-		targets = append(targets, &keyVals[i])
-	}
-	var gridValues []*float64
-	targets = append(targets, &gridValues)
-
-	var out []transpiledSeries
-	for rows.Next() {
-		if err := rows.Scan(targets...); err != nil {
-			return nil, err
-		}
-		var lset labels.Labels
-		if keyNames != nil {
-			builder := labels.NewScratchBuilder(len(keyNames))
-			for i, name := range keyNames {
-				// An empty extracted value is the label being absent.
-				if keyVals[i] != "" {
-					builder.Add(name, keyVals[i])
-				}
-			}
-			builder.Sort()
-			lset = builder.Labels()
-		} else {
-			lset, err = labelsFromGroupKey(keyVals[0])
-			if err != nil {
-				return nil, err
-			}
-		}
-		if stripName {
-			lset = labels.NewBuilder(lset).Del(metricNameLabel).Labels()
-		}
-		values := make([]*float64, len(gridValues))
-		copy(values, gridValues)
-		applyScalarOps(unit.ops, values)
-		out = append(out, transpiledSeries{lset: lset, values: values})
-	}
-	if err := rows.Err(); err != nil {
-		return nil, err
-	}
-
-	if stripName {
-		if out, err = mergeSameLabelsetSeries(out); err != nil {
-			return nil, err
-		}
-	}
-	sort.Slice(out, func(i, j int) bool { return labels.Compare(out[i].lset, out[j].lset) < 0 })
-	return out, nil
-}
-
-// mergeSameLabelsetSeries combines series that a name strip left with
-// identical labelsets, slot by slot. The engine assembles its result matrix
-// by labelset. Post-strip twins whose points interleave in time are one
-// series to it. Two values on the same evaluation timestamp are its
-// duplicate-labelset error. v1 errors there too, so to silently pick one
-// value would be a divergence.
-func mergeSameLabelsetSeries(in []transpiledSeries) ([]transpiledSeries, error) {
-	index := make(map[uint64]int, len(in))
-	out := in[:0]
-	for _, s := range in {
-		hash := s.lset.Hash()
-		idx, ok := index[hash]
-		if ok && labels.Equal(out[idx].lset, s.lset) {
-			dst := out[idx].values
-			for k, v := range s.values {
-				if v == nil {
-					continue
-				}
-				if dst[k] != nil {
-					return nil, errors.NewInvalidInputf(errors.CodeInvalidInput, "vector cannot contain metrics with the same labelset")
-				}
-				dst[k] = v
-			}
-			continue
-		}
-		index[hash] = len(out)
-		out = append(out, s)
-	}
-	return out, nil
-}
-
-// labelsFromGroupKey parses the toJSONString'd sorted [key, value] pairs.
-func labelsFromGroupKey(gkey string) (labels.Labels, error) {
-	var pairs [][]string
-	if err := json.Unmarshal([]byte(gkey), &pairs); err != nil {
-		return labels.EmptyLabels(), errors.WrapInternalf(err, errors.CodeInternal, "malformed compiled group key %q", gkey)
-	}
-	builder := labels.NewScratchBuilder(len(pairs))
-	for _, p := range pairs {
-		if len(p) != 2 {
-			return labels.EmptyLabels(), errors.NewInternalf(errors.CodeInternal, "malformed compiled group key pair %q", gkey)
-		}
-		builder.Add(p[0], p[1])
-	}
-	builder.Sort()
-	return builder.Labels(), nil
-}
-
-// applyScalarOps applies the number-literal op pipeline in place, with the
-// same float64 arithmetic and comparison-filter semantics as the engine.
-func applyScalarOps(ops []scalarOp, values []*float64) {
-	for _, op := range ops {
-		for i, v := range values {
-			if v == nil {
-				continue
-			}
-			lhs, rhs := *v, op.scalar
-			if op.scalarOnLeft {
-				lhs, rhs = op.scalar, *v
-			}
-			switch op.op {
-			case parser.ADD:
-				res := lhs + rhs
-				values[i] = &res
-			case parser.SUB:
-				res := lhs - rhs
-				values[i] = &res
-			case parser.MUL:
-				res := lhs * rhs
-				values[i] = &res
-			case parser.DIV:
-				res := lhs / rhs
-				values[i] = &res
-			case parser.MOD:
-				res := math.Mod(lhs, rhs)
-				values[i] = &res
-			case parser.POW:
-				res := math.Pow(lhs, rhs)
-				values[i] = &res
-			default:
-				keep := compare(op.op, lhs, rhs)
-				switch {
-				case op.returnBool:
-					res := 0.0
-					if keep {
-						res = 1.0
-					}
-					values[i] = &res
-				case keep:
-					// Filter comparisons keep the vector-side value.
-					vec := *v
-					values[i] = &vec
-				default:
-					values[i] = nil
-				}
-			}
-		}
-	}
-}
-
-func compare(op parser.ItemType, lhs, rhs float64) bool {
-	switch op {
-	case parser.EQLC:
-		return lhs == rhs
-	case parser.NEQ:
-		return lhs != rhs
-	case parser.GTR:
-		return lhs > rhs
-	case parser.LSS:
-		return lhs < rhs
-	case parser.GTE:
-		return lhs >= rhs
-	case parser.LTE:
-		return lhs <= rhs
-	}
-	return false
-}
-
-// toMatrix converts a unit result to a promql matrix on the query grid.
-func toMatrix(series []transpiledSeries, startMs, stepMs int64) promql.Matrix {
-	matrix := make(promql.Matrix, 0, len(series))
-	for _, s := range series {
-		var floats []promql.FPoint
-		for i, v := range s.values {
-			if v == nil {
-				continue
-			}
-			floats = append(floats, promql.FPoint{T: startMs + int64(i)*stepMs, F: *v})
-		}
-		if len(floats) == 0 {
-			continue
-		}
-		matrix = append(matrix, promql.Series{Metric: s.lset, Floats: floats})
-	}
-	return matrix
-}
-
-// executeHybrid substitutes each unit's grids into the engine as synthetic
-// series. It evaluates the rewritten query over a storage that serves
-// synthetic selectors from memory and everything else from the live
-// querier. Absent grid points become stale markers, so the engine's
-// lookback cannot resurrect the previous grid point. Each unit's synthetic
-// samples sit on its own grid: the query grid, or the subquery grid for
-// units inside subqueries.
-func (e *executor) executeHybrid(ctx context.Context, plan *transpilePlan, results [][]transpiledSeries) (promql.Matrix, error) {
-	synthetic := make(map[string][]*series, len(plan.units))
-	staleMarker := math.Float64frombits(promValue.StaleNaN)
-
-	queryGrid := plan.grid
-
-	for i, unit := range plan.units {
-		g := unit.grid
-		gridLen := 1
-		if g.stepMs > 0 {
-			gridLen = int((g.endMs-g.startMs)/g.stepMs) + 1
-		}
-		list := make([]*series, 0, len(results[i]))
-		for _, cs := range results[i] {
-			builder := labels.NewBuilder(cs.lset)
-			builder.Set(metricNameLabel, unit.name)
-			s := &series{lset: builder.Labels()}
-			s.ts = make([]int64, 0, gridLen)
-			s.vs = make([]float64, 0, gridLen)
-			for idx := 0; idx < gridLen; idx++ {
-				t := g.startMs + int64(idx)*g.stepMs
-				var v float64
-				if idx < len(cs.values) && cs.values[idx] != nil {
-					v = *cs.values[idx]
-				} else {
-					v = staleMarker
-				}
-				s.ts = append(s.ts, t)
-				s.vs = append(s.vs, v)
-			}
-			list = append(list, s)
-		}
-		synthetic[unit.name] = list
-	}
-
-	hybrid := &hybridQueryable{client: e.client, synthetic: synthetic}
-
-	var qry promql.Query
-	var err error
-	if queryGrid.stepMs == 0 {
-		qry, err = e.engine.NewInstantQuery(ctx, hybrid, nil, plan.rewritten, time.UnixMilli(queryGrid.endMs))
-	} else {
-		qry, err = e.engine.NewRangeQuery(ctx, hybrid, nil, plan.rewritten, time.UnixMilli(queryGrid.startMs), time.UnixMilli(queryGrid.endMs), time.Duration(queryGrid.stepMs)*time.Millisecond)
-	}
-	if err != nil {
-		return nil, err
-	}
-	defer qry.Close()
-
-	res := qry.Exec(ctx)
-	if res.Err != nil {
-		return nil, res.Err
-	}
-
-	matrix, err := resultToMatrix(res)
-	if err != nil {
-		return nil, err
-	}
-
-	// Deep-copy before Close returns the result's slices to the engine pool,
-	// and drop the synthetic __name__ that filter comparisons preserve.
-	out := make(promql.Matrix, 0, len(matrix))
-	for _, s := range matrix {
-		lset := s.Metric
-		if name := lset.Get(metricNameLabel); len(name) >= len(syntheticNamePrefix) && name[:len(syntheticNamePrefix)] == syntheticNamePrefix {
-			builder := labels.NewBuilder(lset)
-			builder.Del(metricNameLabel)
-			lset = builder.Labels()
-		}
-		floats := make([]promql.FPoint, len(s.Floats))
-		copy(floats, s.Floats)
-		out = append(out, promql.Series{Metric: lset.Copy(), Floats: floats})
-	}
-	// The strip can leave twins: two units' outputs that only their
-	// synthetic names told apart (e.g. -metric_a or -metric_b, both {}
-	// once real names are dropped). The engine assembles its matrix by
-	// labelset. It merges such temporally-disjoint elements into one
-	// series. Reproduce that, with its duplicate error on same-timestamp
-	// overlap.
-	out, err = mergeMatrixByLabelset(out)
-	if err != nil {
-		return nil, err
-	}
-	sort.Slice(out, func(i, j int) bool { return labels.Compare(out[i].Metric, out[j].Metric) < 0 })
-	return out, nil
-}
-
-// mergeMatrixByLabelset merges series that share a labelset. It interleaves
-// their points in timestamp order. A timestamp present in both is the
-// engine's duplicate-labelset error.
-func mergeMatrixByLabelset(matrix promql.Matrix) (promql.Matrix, error) {
-	index := make(map[uint64]int, len(matrix))
-	out := matrix[:0]
-	for _, s := range matrix {
-		hash := s.Metric.Hash()
-		idx, ok := index[hash]
-		if ok && labels.Equal(out[idx].Metric, s.Metric) {
-			merged := make([]promql.FPoint, 0, len(out[idx].Floats)+len(s.Floats))
-			a, b := out[idx].Floats, s.Floats
-			for len(a) > 0 && len(b) > 0 {
-				switch {
-				case a[0].T < b[0].T:
-					merged, a = append(merged, a[0]), a[1:]
-				case b[0].T < a[0].T:
-					merged, b = append(merged, b[0]), b[1:]
-				default:
-					return nil, errors.NewInvalidInputf(errors.CodeInvalidInput, "vector cannot contain metrics with the same labelset")
-				}
-			}
-			out[idx].Floats = append(append(merged, a...), b...)
-			continue
-		}
-		index[hash] = len(out)
-		out = append(out, s)
-	}
-	return out, nil
-}
-
-func resultToMatrix(res *promql.Result) (promql.Matrix, error) {
-	switch v := res.Value.(type) {
-	case promql.Matrix:
-		return v, nil
-	case promql.Vector:
-		matrix := make(promql.Matrix, 0, len(v))
-		for _, s := range v {
-			matrix = append(matrix, promql.Series{Metric: s.Metric, Floats: []promql.FPoint{{T: s.T, F: s.F}}})
-		}
-		return matrix, nil
-	case promql.Scalar:
-		return promql.Matrix{{Metric: labels.EmptyLabels(), Floats: []promql.FPoint{{T: v.T, F: v.V}}}}, nil
-	default:
-		return nil, errors.NewInternalf(errors.CodeInternal, "unexpected hybrid result type %T", res.Value)
-	}
-}
-
-// hybridQueryable serves synthetic (compiled) selectors from memory and
-// everything else from the live storage.
-type hybridQueryable struct {
-	client    *client
-	synthetic map[string][]*series
-}
-
-func (h *hybridQueryable) Querier(mint, maxt int64) (storage.Querier, error) {
-	return &hybridQuerier{
-		querier:   querier{mint: mint, maxt: maxt, client: h.client},
-		synthetic: h.synthetic,
-	}, nil
-}
-
-type hybridQuerier struct {
-	querier
-	synthetic map[string][]*series
-}
-
-func (h *hybridQuerier) Select(ctx context.Context, sortSeries bool, hints *storage.SelectHints, matchers ...*labels.Matcher) storage.SeriesSet {
-	if name, ok := isSyntheticSelector(matchers); ok {
-		list := h.synthetic[name]
-		if sortSeries {
-			sorted := make([]*series, len(list))
-			copy(sorted, list)
-			sort.Slice(sorted, func(i, j int) bool { return labels.Compare(sorted[i].lset, sorted[j].lset) < 0 })
-			list = sorted
-		}
-		return newSeriesSet(list)
-	}
-	return h.querier.Select(ctx, sortSeries, hints, matchers...)
-}

pkg/prometheus/clickhouseprometheusv2/transpiler_sql.go

@@ -1,415 +0,0 @@
-package clickhouseprometheusv2
-
-import (
-	"fmt"
-	"strings"
-
-	"github.com/SigNoz/signoz/pkg/telemetryschema/metricstelemetryschema"
-	"github.com/huandu/go-sqlbuilder"
-)
-
-// experimental gate for the timeSeries*ToGrid aggregate functions; attached
-// as a SETTINGS clause so telemetrystore hooks cannot clobber it.
-const gridFunctionsSetting = "SETTINGS allow_experimental_ts_to_grid_aggregate_function = 1"
-
-var aggForEach = map[string]string{
-	"sum":   "sumForEach",
-	"min":   "minForEach",
-	"max":   "maxForEach",
-	"avg":   "avgForEach",
-	"count": "countForEach",
-}
-
-// buildUnitSQL renders the single ClickHouse statement that evaluates one
-// core unit over the [startMs, endMs] / stepMs grid. The inner level
-// computes per-series grids with a timeSeries*ToGrid aggregate, or with a
-// windowed aggregation for *_over_time. The outer level is the spatial
-// aggregation: -ForEach combinators grouped by the projected group key.
-//
-// The heavy level runs on the shards. The top-level FROM is the distributed
-// samples table. The group-key join partner is a subquery on the
-// shard-local time series table. So the shard rewrite executes the join and
-// the per-series aggregation next to the data. Fingerprint co-locality
-// makes this complete: samples and series shard on the same key. The
-// initiator only merges the per-series states and applies the spatial
-// -ForEach step. This is the same layout as the telemetrymetrics statement
-// builder. The windowed *_over_time form shares the frame but holds
-// per-bucket partials inside each series group (see windowedInner).
-//
-// The offset shifts the selector's data window. The grid indices map 1:1
-// onto the query grid: output ts = startMs + i*stepMs. Grid parameters
-// render as literals. They are aggregate-function parameters, not bindable
-// values.
-//
-// Statements nest builder-rendered SQL as text. So the returned args must
-// follow the position of each fragment in the final statement: ClickHouse
-// binds ? placeholders by position. A JOIN renders before WHERE, so a
-// joined subquery's args come before the outer query's condition args.
-//
-// Row shape: the group-key columns (see groupKeyColumns), then grid
-// Array(Nullable(Float64)). A NULL grid point is an absent point, the
-// engine's "no value here". The -ForEach combinators preserve it: an index
-// where every series is NULL aggregates to NULL, and countForEach's 0 maps
-// back to NULL.
-func buildUnitSQL(unit *coreUnit, metricNames []string, dataStart, dataEnd int64, startMs, endMs, stepMs, lookbackMs int64) (string, []any, error) {
-	selStart := startMs - unit.offsetMs
-	selEnd := endMs - unit.offsetMs
-	stepSec := stepMs / 1000
-	if stepSec == 0 {
-		// Instant query: start == end, so the grid has one point for any
-		// positive step.
-		stepSec = 1
-	}
-	windowMs := unit.rangeMs
-	if unit.kind == unitInstant {
-		windowMs = lookbackMs
-	}
-	windowSec := windowMs / 1000
-
-	adjustedTsStartU, _, _, localTsTable := metricstelemetryschema.WhichTSTableToUse(uint64(dataStart), uint64(dataEnd), false, nil)
-	adjustedTsStart := int64(adjustedTsStartU)
-	keyNames := groupKeyColumns(unit)
-
-	// seriesSub computes fingerprint -> group key columns. It reads the
-	// local series table when it rides inside the shard-rewritten samples
-	// query, and the distributed one when it joins at the initiator
-	// (windowed form).
-	seriesSub := func(table string) (string, []any, error) {
-		sub := sqlbuilder.NewSelectBuilder()
-		selects := []string{"fingerprint"}
-		if keyNames == nil {
-			selects = append(selects, groupKeyExpr(unit)+" AS gkey")
-		} else {
-			// by (...) grouping extracts exactly the listed labels as plain
-			// columns: no reason to build, sort and stringify every label
-			// pair per row when the projection is a known short list and
-			// the label names live in Go anyway.
-			for i, name := range keyNames {
-				selects = append(selects, fmt.Sprintf("JSONExtractString(labels, %s) AS g%d", sub.Var(name), i))
-			}
-		}
-		sub.Select(selects...)
-		sub.From(fmt.Sprintf("%s.%s", metricstelemetryschema.DBName, table))
-		if err := applySeriesConditions(sub, adjustedTsStart, dataEnd, unit.matchers); err != nil {
-			return "", nil, err
-		}
-		sub.GroupBy(append([]string{"fingerprint"}, keyColumnAliases(keyNames)...)...)
-		q, args := sub.BuildWithFlavor(sqlbuilder.ClickHouse)
-		return q, args, nil
-	}
-
-	// samplesConditions adds the samples-side WHERE. The group-key join
-	// restricts to the matched series; no fingerprint condition is added
-	// here.
-	samplesConditions := func(sb *sqlbuilder.SelectBuilder, excludeStale bool) {
-		switch len(metricNames) {
-		case 0:
-			// No name constraint derivable; correct but unable to use the
-			// metric_name primary-key prefix.
-		case 1:
-			sb.Where(sb.EQ("metric_name", metricNames[0]))
-		default:
-			sb.Where(sb.In("metric_name", sqlbuilder.List(metricNames)))
-		}
-		// temporality precedes metric_name in the samples primary key; the
-		// fingerprints already come from these temporalities, so this only
-		// helps granule pruning.
-		sb.Where("temporality IN ['Cumulative', 'Unspecified']")
-		// When the window is narrower than the step, the grid windows
-		// (t_k − window, t_k] cover only window/step of the timeline. A
-		// sample in a gap belongs to no window. It cannot move any grid
-		// point, but the grid aggregate buffers every row it is fed. This
-		// predicate keeps only the in-window rows. It cut a 36k-series
-		// one-week rate from 74s/28GiB to 16s/4.3GiB on fleet data: the
-		// read stays the same, and the aggregate input shrinks by the
-		// coverage ratio. The lattice anchors at selStart, because the end
-		// can sit off-lattice on unaligned grids. positiveModulo is
-		// necessary because samples above selStart make the dividend
-		// negative. The upper bound tightens to the last grid point: rows
-		// past it are equally windowless. When window >= step, the windows
-		// tile the timeline, and the plain bounds stay.
-		sliver := stepMs > 0 && windowMs > 0 && windowMs < stepMs
-		upper := selEnd
-		if sliver {
-			upper = selStart + (selEnd-selStart)/stepMs*stepMs
-		}
-		// Left-open window: a sample exactly at the window's lower boundary
-		// is never used (range selectors and lookback are both left-open).
-		sb.Where(sb.GT("unix_milli", selStart-windowMs), sb.LTE("unix_milli", upper))
-		if sliver {
-			sb.Where(fmt.Sprintf("positiveModulo(%s - unix_milli, %s) < %s",
-				sb.Var(selStart), sb.Var(stepMs), sb.Var(windowMs)))
-		}
-		if excludeStale {
-			// PromQL excludes stale markers from range vectors. Instant
-			// selectors need the stale rows for shadowing instead.
-			sb.Where("bitAnd(flags, 1) = 0")
-		}
-	}
-
-	keyCols := keyColumnAliases(keyNames)
-
-	// joinedInner builds the shard-side SELECT for the single-pass kinds:
-	// grid expression per (fingerprint, group key), group-key join against
-	// the local series table.
-	joinedInner := func(gridExpr string, excludeStale bool) (string, []any, error) {
-		seriesSQL, seriesArgs, err := seriesSub(localTsTable)
-		if err != nil {
-			return "", nil, err
-		}
-		sb := sqlbuilder.NewSelectBuilder()
-		selects := make([]string, 0, len(keyCols)+1)
-		// A fingerprint is the hash of one labelset, so every group-key
-		// column is functionally dependent on it: any() is exact, and
-		// grouping by the fingerprint alone spares hashing the joined
-		// string per sample row — measured -10-13% on a 1.9B-row rate.
-		for _, col := range keyCols {
-			selects = append(selects, fmt.Sprintf("any(series.%s) AS %s", col, col))
-		}
-		sb.Select(append(selects, gridExpr+" AS grid")...)
-		sb.From(fmt.Sprintf("%s.%s AS points", metricstelemetryschema.DBName, metricstelemetryschema.SamplesV4TableName))
-		sb.JoinWithOption(sqlbuilder.InnerJoin, fmt.Sprintf("(%s) AS series", seriesSQL), "points.fingerprint = series.fingerprint")
-		samplesConditions(sb, excludeStale)
-		sb.GroupBy("points.fingerprint")
-		q, args := sb.BuildWithFlavor(sqlbuilder.ClickHouse)
-		// The join text renders before WHERE: its args come first.
-		return q, append(seriesArgs, args...), nil
-	}
-
-	var inner string
-	var innerArgs []any
-	var err error
-	switch unit.kind {
-	case unitInstant:
-		// Instant selection with stale shadowing: the grid value is the last
-		// non-stale sample in (t-lookback, t], absent when the overall last
-		// sample in that window is a stale marker (verified semantics: the
-		// -If combinator applies to the grid aggregates, and NULL comparisons
-		// make a stale-latest point absent).
-		gridParams := fmt.Sprintf("(fromUnixTimestamp64Milli(%d), fromUnixTimestamp64Milli(%d), %d, %d)", selStart, selEnd, stepSec, windowSec)
-		gridExpr := fmt.Sprintf(
-			"arrayMap((tall, tok, vok) -> if(tall IS NULL OR tok IS NULL OR tall != tok, NULL, vok), timeSeriesLastToGrid%s(fromUnixTimestamp64Milli(unix_milli), toFloat64(unix_milli)), timeSeriesLastToGridIf%s(fromUnixTimestamp64Milli(unix_milli), toFloat64(unix_milli), bitAnd(flags, 1) = 0), timeSeriesLastToGridIf%s(fromUnixTimestamp64Milli(unix_milli), value, bitAnd(flags, 1) = 0))",
-			gridParams, gridParams, gridParams,
-		)
-		inner, innerArgs, err = joinedInner(gridExpr, false)
-	case unitOverTime:
-		if unit.overFn == "last" {
-			// last_over_time == last non-stale sample in the window: the
-			// stale rows are already excluded in WHERE.
-			gridExpr := fmt.Sprintf(
-				"timeSeriesLastToGrid(fromUnixTimestamp64Milli(%d), fromUnixTimestamp64Milli(%d), %d, %d)(fromUnixTimestamp64Milli(unix_milli), value)",
-				selStart, selEnd, stepSec, windowSec,
-			)
-			inner, innerArgs, err = joinedInner(gridExpr, true)
-			break
-		}
-		inner, innerArgs, err = windowedInner(unit, samplesConditions, seriesSub, keyCols, localTsTable, selStart, selEnd, stepMs, windowMs)
-	default: // unitRange
-		gridExpr := fmt.Sprintf(
-			"%s(fromUnixTimestamp64Milli(%d), fromUnixTimestamp64Milli(%d), %d, %d)(fromUnixTimestamp64Milli(unix_milli), value)",
-			gridFunction[unit.fn], selStart, selEnd, stepSec, windowSec,
-		)
-		if unit.fn == fnIncrease {
-			// increase == rate * range-seconds, exactly: extrapolatedRate
-			// divides by the range only when isRate.
-			gridExpr = fmt.Sprintf("arrayMap(x -> x * %d, %s)", windowSec, gridExpr)
-		}
-		inner, innerArgs, err = joinedInner(gridExpr, true)
-	}
-	if err != nil {
-		return "", nil, err
-	}
-
-	spatial := "maxForEach(grid)"
-	switch {
-	case !unit.hasAgg:
-		// Per-series output: one row per (labels-minus-__name__) group.
-		// Distinct fingerprints can collapse onto the same projected label
-		// set only via a regex __name__ selector over metrics with identical
-		// other labels; maxForEach is a deterministic NULL-skipping merge and
-		// the identity for the overwhelmingly common one-fingerprint group.
-	case unit.aggOp.String() == "count":
-		// count over an all-absent index is an absent point, not 0.
-		spatial = "arrayMap(c -> if(c = 0, NULL, toFloat64(c)), countForEach(grid))"
-	default:
-		spatial = fmt.Sprintf("%s(grid)", aggForEach[unit.aggOp.String()])
-	}
-
-	keyList := strings.Join(keyCols, ", ")
-	query := fmt.Sprintf("SELECT %s, %s AS grid FROM (%s) GROUP BY %s %s", keyList, spatial, inner, keyList, gridFunctionsSetting)
-	return query, innerArgs, nil
-}
-
-// groupKeyColumns returns the label names to extract as plain group-key
-// columns, or nil when the unit needs the canonical JSON key instead. Only
-// by (...) grouping qualifies: its projection is a known short list, so
-// extracting each label directly beats building, sorting and stringifying
-// every label pair per row. without and no-aggregation project a label SET
-// that varies per series — there the sorted-JSON key is load-bearing: the
-// sort is what makes two fingerprints with different stored JSON key order
-// land in one group, and the string carries the labels back out.
-func groupKeyColumns(unit *coreUnit) []string {
-	if unit.hasAgg && unit.by && len(unit.grouping) > 0 {
-		return unit.grouping
-	}
-	return nil
-}
-
-// keyColumnAliases names the group-key columns in every SELECT level: g0..gN
-// for direct extraction, the single canonical gkey otherwise.
-func keyColumnAliases(keyNames []string) []string {
-	if keyNames == nil {
-		return []string{"gkey"}
-	}
-	cols := make([]string, len(keyNames))
-	for i := range keyNames {
-		cols[i] = fmt.Sprintf("g%d", i)
-	}
-	return cols
-}
-
-// windowedInner builds the avg/min/max/sum/count _over_time form without
-// fanning samples out. It runs only when the range is a whole multiple of
-// the step (see the transpile gate), because then the window
-// (t_k - range, t_k] is exactly the union of W = range/step step buckets —
-// both are left-open on the same boundaries — so bucket membership fully
-// determines window membership. Fanning each sample into all W windows it
-// covers (ARRAY JOIN) multiplies rows by W, which at long ranges over short
-// steps is a row explosion measured in billions.
-//
-// The bucketing itself is the -Resample combinator: one group per (series,
-// group key) whose state is a fixed array of per-bucket aggregates, updated
-// in place per sample. Grouping by (series, bucket) instead — measured on a
-// 100k-series x 371-bucket workload — creates a 37M-entry hash aggregation
-// whose per-thread partial tables scale memory WITH max_threads (12 -> 48
-// GiB from 2 to 8 threads, dead at 16) and ships one row per group to the
-// initiator; the Resample form carries the same numbers in 100k compact
-// array states, like every other unit kind.
-//
-// The wrapper level slides the window: slot k combines buckets k..k+W-1 by
-// direct aggregation over at most W partials — no prefix-sum tricks, so no
-// large-minus-large cancellation against the engine's directly-summed
-// windows. A slot with zero window count is absent, which also keeps
-// min/max honest: their slices filter on the bucket counts, so an empty
-// bucket's zero-fill can never be mistaken for a value (a real sample can
-// legitimately be 0 or +Inf).
-func windowedInner(unit *coreUnit, samplesConditions func(*sqlbuilder.SelectBuilder, bool), seriesSub func(string) (string, []any, error), keyCols []string, localSeriesTable string, selStart, selEnd, stepMs, windowMs int64) (string, []any, error) {
-	effStepMs := stepMs
-	if effStepMs == 0 {
-		effStepMs = 1000
-	}
-	lastIdx := (selEnd - selStart) / effStepMs
-	gridLen := lastIdx + 1
-	w := windowMs / effStepMs
-	bucketLen := gridLen + w
-
-	// A window narrower than the step makes the windows (t_k - range, t_k]
-	// pairwise disjoint. There is nothing to slide. Each slot reads exactly
-	// its own window's aggregate. This is exact ONLY over sliver-filtered
-	// rows (samplesConditions adds the window<step predicate): the index
-	// below assigns every gap sample to the window above it, and the
-	// filter removes those samples. This needs a real step. Instant
-	// queries carry no sliver filter, so they keep the tiled form and its
-	// gates.
-	disjoint := stepMs > 0 && windowMs < stepMs
-	if disjoint {
-		w = 1
-		bucketLen = gridLen
-	}
-
-	seriesSQL, seriesArgs, err := seriesSub(localSeriesTable)
-	if err != nil {
-		return "", nil, err
-	}
-
-	// Bucket index, shifted so the earliest in-window sample lands at 0:
-	// jj = ceil((ts - selStart)/step) + W - 1, folded into one intDiv.
-	// Slot k's window is then buckets jj in [k, k+W-1]. In the disjoint
-	// form, the same ceil lands each in-window sample directly on its slot
-	// (W = 1). The numerator stays positive: the fetch floor is
-	// selStart - range > selStart - step.
-	jjShift := windowMs
-	if disjoint {
-		jjShift = effStepMs
-	}
-	jj := fmt.Sprintf("intDiv(unix_milli - %d + %d - 1, %d)", selStart, jjShift, effStepMs)
-	buckets := sqlbuilder.NewSelectBuilder()
-	selects := make([]string, 0, len(keyCols)+2)
-	// any() over the group key: exact because the key is functionally
-	// dependent on the fingerprint (see joinedInner).
-	for _, col := range keyCols {
-		selects = append(selects, fmt.Sprintf("any(series.%s) AS %s", col, col))
-	}
-	selects = append(selects, fmt.Sprintf("countResample(0, %d, 1)(value, %s) AS cnts", bucketLen, jj))
-	if unit.overFn != "count" {
-		selects = append(selects, fmt.Sprintf("%sResample(0, %d, 1)(value, %s) AS vals", map[string]string{
-			"avg": "sum",
-			"sum": "sum",
-			"min": "min",
-			"max": "max",
-		}[unit.overFn], bucketLen, jj))
-	}
-	buckets.Select(selects...)
-	buckets.From(fmt.Sprintf("%s.%s AS points", metricstelemetryschema.DBName, metricstelemetryschema.SamplesV4TableName))
-	buckets.JoinWithOption(sqlbuilder.InnerJoin, fmt.Sprintf("(%s) AS series", seriesSQL), "points.fingerprint = series.fingerprint")
-	samplesConditions(buckets, true)
-	buckets.GroupBy("points.fingerprint")
-	bucketsSQL, bucketsArgs := buckets.BuildWithFlavor(sqlbuilder.ClickHouse)
-
-	windowCnt := fmt.Sprintf("arraySum(arraySlice(cnts, k + 1, %d))", w)
-	var slot string
-	switch unit.overFn {
-	case "count":
-		slot = fmt.Sprintf("if(%s = 0, NULL, toFloat64(%s))", windowCnt, windowCnt)
-	case "sum":
-		slot = fmt.Sprintf("if(%s = 0, NULL, arraySum(arraySlice(vals, k + 1, %d)))", windowCnt, w)
-	case "avg":
-		slot = fmt.Sprintf("if(%s = 0, NULL, arraySum(arraySlice(vals, k + 1, %d)) / %s)", windowCnt, w, windowCnt)
-	case "min":
-		slot = fmt.Sprintf("if(%s = 0, NULL, arrayMin(arrayFilter((v, c) -> c > 0, arraySlice(vals, k + 1, %d), arraySlice(cnts, k + 1, %d))))", windowCnt, w, w)
-	case "max":
-		slot = fmt.Sprintf("if(%s = 0, NULL, arrayMax(arrayFilter((v, c) -> c > 0, arraySlice(vals, k + 1, %d), arraySlice(cnts, k + 1, %d))))", windowCnt, w, w)
-	}
-
-	keyList := strings.Join(keyCols, ", ")
-	inner := fmt.Sprintf(
-		"SELECT %s, arrayMap(k -> %s, range(toUInt64(%d))) AS grid FROM (%s)",
-		keyList, slot, gridLen, bucketsSQL,
-	)
-	return inner, append(seriesArgs, bucketsArgs...), nil
-}
-
-// groupKeyExpr renders the canonical JSON group key for the units whose
-// projected label SET varies per series (see groupKeyColumns): the sorted
-// [key, value] pairs of the projected labels, JSON-encoded.
-//   - by () with no labels: one constant group;
-//   - without (a, b): keep everything except the listed labels and __name__;
-//   - no aggregation: keep everything including __name__ — even when the
-//     unit drops the name from its OUTPUT, the key must keep it so distinct
-//     metrics never merge in SQL; executeUnit strips the name afterwards and
-//     turns a post-strip collision into the engine's duplicate-labelset
-//     error instead of a silently invented merge.
-func groupKeyExpr(unit *coreUnit) string {
-	// An empty label value means "label absent" in Prometheus; the stored
-	// labels JSON can carry empty attribute values, which must not become
-	// output labels or group keys.
-	pairs := "arraySort(JSONExtractKeysAndValues(labels, 'String'))"
-	if !unit.hasAgg {
-		return fmt.Sprintf("toJSONString(arrayFilter(p -> p.2 != '', %s))", pairs)
-	}
-	if unit.by {
-		// Non-empty by (...) never reaches here; groupKeyColumns extracts
-		// those labels as plain columns instead.
-		return "'[]'"
-	}
-	excluded := append([]string{metricNameLabel}, unit.grouping...)
-	return fmt.Sprintf("toJSONString(arrayFilter(p -> p.2 != '' AND p.1 NOT IN (%s), %s))", quotedList(excluded), pairs)
-}
-
-func quotedList(items []string) string {
-	quoted := make([]string, len(items))
-	for i, s := range items {
-		quoted[i] = "'" + strings.ReplaceAll(s, "'", "\\'") + "'"
-	}
-	return strings.Join(quoted, ", ")
-}

pkg/prometheus/clickhouseprometheusv2/transpiler_test.go

@@ -1,698 +0,0 @@
-package clickhouseprometheusv2
-
-import (
-	"context"
-	"testing"
-	"time"
-
-	"github.com/DATA-DOG/go-sqlmock"
-	cmock "github.com/SigNoz/clickhouse-go-mock"
-	"github.com/SigNoz/signoz/pkg/errors"
-	"github.com/SigNoz/signoz/pkg/factory"
-	"github.com/SigNoz/signoz/pkg/instrumentation/instrumentationtest"
-	"github.com/SigNoz/signoz/pkg/prometheus"
-	"github.com/SigNoz/signoz/pkg/telemetrystore"
-	"github.com/SigNoz/signoz/pkg/telemetrystore/telemetrystoretest"
-	"github.com/prometheus/prometheus/model/labels"
-	"github.com/prometheus/prometheus/promql"
-	"github.com/prometheus/prometheus/promql/parser"
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-)
-
-func newTestClient(t *testing.T) (*client, *telemetrystoretest.Provider) {
-	t.Helper()
-	store := telemetrystoretest.New(telemetrystore.Config{Provider: "clickhouse"}, sqlmock.QueryMatcherRegexp)
-	settings := factory.NewScopedProviderSettings(instrumentationtest.New().ToProviderSettings(), "clickhouseprometheusv2_test")
-	return newClient(settings, store, prometheus.Config{}), store
-}
-
-var seriesCols = []cmock.ColumnType{
-	{Name: "fingerprint", Type: "UInt64"},
-	{Name: "labels", Type: "String"},
-}
-
-func parse(t *testing.T, q string) parser.Expr {
-	t.Helper()
-	expr, err := parser.NewParser(parser.Options{}).ParseExpr(q)
-	require.NoError(t, err)
-	return expr
-}
-
-func TestClassifyFullShapes(t *testing.T) {
-	tests := []struct {
-		name  string
-		query string
-		check func(t *testing.T, u *coreUnit)
-	}{
-		{
-			name:  "sum by rate",
-			query: `sum by (pod) (rate(http_requests_total{job="api"}[5m]))`,
-			check: func(t *testing.T, u *coreUnit) {
-				assert.Equal(t, fnRate, u.fn)
-				assert.Equal(t, int64(300_000), u.rangeMs)
-				assert.True(t, u.hasAgg)
-				assert.True(t, u.by)
-				assert.Equal(t, []string{"pod"}, u.grouping)
-			},
-		},
-		{
-			name:  "bare increase with offset",
-			query: `increase(errors_total[10m] offset 30m)`,
-			check: func(t *testing.T, u *coreUnit) {
-				assert.Equal(t, fnIncrease, u.fn)
-				assert.Equal(t, int64(1_800_000), u.offsetMs)
-				assert.False(t, u.hasAgg)
-			},
-		},
-		{
-			name:  "avg without over delta",
-			query: `avg without (instance) (delta(gauge_metric[15m]))`,
-			check: func(t *testing.T, u *coreUnit) {
-				assert.Equal(t, fnDelta, u.fn)
-				assert.True(t, u.hasAgg)
-				assert.False(t, u.by)
-			},
-		},
-		{
-			name:  "scalar pipeline with comparison",
-			query: `sum(rate(x[5m])) * 100 > 5`,
-			check: func(t *testing.T, u *coreUnit) {
-				require.Len(t, u.ops, 2)
-				assert.Equal(t, parser.ItemType(parser.MUL), u.ops[0].op)
-				assert.Equal(t, 100.0, u.ops[0].scalar)
-				assert.Equal(t, parser.ItemType(parser.GTR), u.ops[1].op)
-			},
-		},
-		{
-			name:  "scalar on left with unary minus",
-			query: `-1 * sum(rate(x[5m]))`,
-			check: func(t *testing.T, u *coreUnit) {
-				require.Len(t, u.ops, 1)
-				assert.True(t, u.ops[0].scalarOnLeft)
-				assert.Equal(t, -1.0, u.ops[0].scalar)
-			},
-		},
-		{
-			name:  "bool comparison",
-			query: `sum(rate(x[5m])) >= bool 0.5`,
-			check: func(t *testing.T, u *coreUnit) {
-				require.Len(t, u.ops, 1)
-				assert.True(t, u.ops[0].returnBool)
-			},
-		},
-		{
-			name:  "irate utf8 name",
-			query: `sum by ("k8s.pod.name") (irate({"k8s.container.cpu.time"}[2m]))`,
-			check: func(t *testing.T, u *coreUnit) {
-				assert.Equal(t, fnIRate, u.fn)
-				assert.Equal(t, []string{"k8s.pod.name"}, u.grouping)
-			},
-		},
-		{
-			name:  "bare instant selector keeps name",
-			query: `up{job="api"}`,
-			check: func(t *testing.T, u *coreUnit) {
-				assert.Equal(t, unitInstant, u.kind)
-				assert.True(t, u.keepsName())
-			},
-		},
-		{
-			name:  "gauge aggregation",
-			query: `sum by (pod) (container_memory offset 5m)`,
-			check: func(t *testing.T, u *coreUnit) {
-				assert.Equal(t, unitInstant, u.kind)
-				assert.Equal(t, int64(300_000), u.offsetMs)
-				assert.True(t, u.hasAgg)
-				assert.False(t, u.keepsName())
-			},
-		},
-		{
-			name:  "gauge comparison keeps name",
-			query: `container_memory > 100`,
-			check: func(t *testing.T, u *coreUnit) {
-				assert.Equal(t, unitInstant, u.kind)
-				assert.True(t, u.keepsName())
-			},
-		},
-		{
-			name:  "gauge arithmetic drops name",
-			query: `container_memory / 1024`,
-			check: func(t *testing.T, u *coreUnit) {
-				assert.Equal(t, unitInstant, u.kind)
-				assert.False(t, u.keepsName())
-			},
-		},
-		{
-			name:  "avg_over_time",
-			query: `max by (node) (avg_over_time(load1[10m]))`,
-			check: func(t *testing.T, u *coreUnit) {
-				assert.Equal(t, unitOverTime, u.kind)
-				assert.Equal(t, "avg", u.overFn)
-				assert.Equal(t, int64(600_000), u.rangeMs)
-			},
-		},
-		{
-			name:  "last_over_time keeps name",
-			query: `last_over_time(load1[10m])`,
-			check: func(t *testing.T, u *coreUnit) {
-				assert.Equal(t, unitOverTime, u.kind)
-				assert.Equal(t, "last", u.overFn)
-				assert.True(t, u.keepsName())
-			},
-		},
-	}
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			plan, ok := classify(parse(t, tt.query), testGrid(60_000))
-			require.True(t, ok, "expected transpilable")
-			require.True(t, plan.full, "expected full compilation")
-			require.Len(t, plan.units, 1)
-			tt.check(t, &plan.units[0].core)
-		})
-	}
-}
-
-func TestClassifyFallbackShapes(t *testing.T) {
-	queries := []struct {
-		name  string
-		query string
-		step  int64
-	}{
-		{"default-resolution subquery", `max_over_time(rate(x[5m])[30m:])`, 60_000},
-		{"at modifier", `sum(rate(x[5m] @ 1609746000))`, 60_000},
-		{"at modifier on gauge", `sum(container_memory @ 1609746000)`, 60_000},
-		{"sub-second step", `sum(rate(x[5m]))`, 500},
-		{"sub-second range", `sum(rate(x[1500ms]))`, 60_000},
-		{"by __name__ full", `sum by (__name__) (rate({__name__=~"a|b"}[5m]))`, 60_000},
-		{"quantile_over_time unsupported", `quantile_over_time(0.9, load1[10m])`, 60_000},
-		// Duration expressions resolve into the selectors' static fields only
-		// at evaluation time; classification reads those fields as zero, so
-		// transpiling would silently use the wrong offset (caught by the
-		// conformance corpus' duration_expression.test cases). Offset
-		// expressions parse without the experimental-parser flag, so they do
-		// reach the transpiler; range-position expressions are rejected at
-		// parse (the RangeExpr/StepExpr guards are defense-in-depth).
-		{"duration expression offset on instant", `x offset step()`, 60_000},
-		{"duration expression offset arithmetic", `x offset -step()*2`, 60_000},
-		{"duration expression offset on range", `sum(rate(x[5m] offset max(3s, step())))`, 60_000},
-		{"duration expression subquery step", `max_over_time(rate(x[5m])[30m:step()])`, 60_000},
-	}
-	for _, tt := range queries {
-		t.Run(tt.name, func(t *testing.T) {
-			_, ok := classify(parse(t, tt.query), testGrid(tt.step))
-			assert.False(t, ok, "expected fallback for %s", tt.query)
-		})
-	}
-}
-
-func TestClassifyHybridShapes(t *testing.T) {
-	tests := []struct {
-		name          string
-		query         string
-		wantUnits     int
-		wantRewritten string
-	}{
-		{
-			name:          "histogram quantile",
-			query:         `histogram_quantile(0.95, sum by (le) (rate(http_bucket[5m])))`,
-			wantUnits:     1,
-			wantRewritten: `histogram_quantile(0.95, __signoz_transpiled_0__)`,
-		},
-		{
-			name:          "topk over compiled",
-			query:         `topk(5, sum by (pod) (rate(x[5m])))`,
-			wantUnits:     1,
-			wantRewritten: `topk(5, __signoz_transpiled_0__)`,
-		},
-		{
-			name:          "ratio of compiled units",
-			query:         `sum(rate(a[5m])) / sum(rate(b[5m]))`,
-			wantUnits:     2,
-			wantRewritten: `__signoz_transpiled_0__ / __signoz_transpiled_1__`,
-		},
-		{
-			name:          "or vector zero",
-			query:         `sum(rate(a[5m])) or vector(0)`,
-			wantUnits:     1,
-			wantRewritten: `__signoz_transpiled_0__ or vector(0)`,
-		},
-		{
-			name:          "quantile agg over compiled rate",
-			query:         `quantile(0.9, rate(x[5m]))`,
-			wantUnits:     1,
-			wantRewritten: `quantile(0.9, __signoz_transpiled_0__)`,
-		},
-		{
-			name:          "non-literal scalar side stays engine-side",
-			query:         `sum(rate(x[5m])) * scalar(y)`,
-			wantUnits:     1,
-			wantRewritten: `__signoz_transpiled_0__ * scalar(y)`,
-		},
-		{
-			name:          "compiled mixed with raw selector",
-			query:         `sum by (pod) (rate(a[5m])) / on (pod) group_left () b`,
-			wantUnits:     1,
-			wantRewritten: `__signoz_transpiled_0__ / on (pod) group_left () b`,
-		},
-	}
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			plan, ok := classify(parse(t, tt.query), testGrid(60_000))
-			require.True(t, ok)
-			assert.False(t, plan.full)
-			assert.Len(t, plan.units, tt.wantUnits)
-			assert.Equal(t, tt.wantRewritten, plan.rewritten)
-		})
-	}
-}
-
-func TestClassifyHybridGuards(t *testing.T) {
-	t.Run("no substitution under on(__name__)", func(t *testing.T) {
-		plan, ok := classify(parse(t, `sum(rate(a[5m])) * on (__name__) b`), testGrid(60_000))
-		_ = plan
-		assert.False(t, ok, "matching on __name__ must not see synthetic names")
-	})
-	t.Run("no substitution inside @-pinned subquery", func(t *testing.T) {
-		_, ok := classify(parse(t, `max_over_time(rate(x[5m])[30m:1m] @ 1609746000)`), testGrid(60_000))
-		assert.False(t, ok)
-	})
-}
-
-// The alert-smoothing idiom: units inside a fixed-resolution subquery
-// evaluate on the subquery grid — epoch-aligned multiples of the resolution,
-// starting strictly after (outer start - range), exactly as the engine
-// derives it.
-func TestClassifySubqueryUnits(t *testing.T) {
-	grid := gridContext{startMs: 1_700_000_030_000, endMs: 1_700_007_200_000, stepMs: 60_000}
-
-	plan, ok := classify(parse(t, `min_over_time((sum by (ns) (increase(x[5m])))[10m:5m]) > 0`), grid)
-	require.True(t, ok)
-	require.False(t, plan.full)
-	require.Len(t, plan.units, 1)
-	assert.Equal(t, `min_over_time(__signoz_transpiled_0__[10m:5m]) > 0`, plan.rewritten)
-
-	unit := plan.units[0]
-	// lower bound = outer start - range = 1_699_999_430_000; first multiple
-	// of 300_000 strictly greater is 1_699_999_500_000.
-	assert.Equal(t, int64(1_699_999_500_000), unit.grid.startMs)
-	assert.Equal(t, grid.endMs, unit.grid.endMs)
-	assert.Equal(t, int64(300_000), unit.grid.stepMs)
-	assert.Equal(t, fnIncrease, unit.core.fn)
-
-	t.Run("subquery offset shifts the grid", func(t *testing.T) {
-		plan, ok := classify(parse(t, `max_over_time((sum(rate(x[5m])))[10m:5m] offset 30m)`), grid)
-		require.True(t, ok)
-		require.Len(t, plan.units, 1)
-		// lower = start - offset - range = 1_699_997_630_000 -> first
-		// multiple of 300_000 above = 1_699_997_700_000; end shifts too.
-		assert.Equal(t, int64(1_699_997_700_000), plan.units[0].grid.startMs)
-		assert.Equal(t, grid.endMs-1_800_000, plan.units[0].grid.endMs)
-	})
-
-	t.Run("mollusk ratio-inside-subquery idiom", func(t *testing.T) {
-		q := `min_over_time(((sum by (a) (rate(m1[5m]))) / (avg by (a) (m2)))[5m:1m])`
-		plan, ok := classify(parse(t, q), grid)
-		require.True(t, ok)
-		// Both sides compile on the subquery grid: the rate side and the
-		// gauge aggregation side; the engine joins them and smooths.
-		require.Len(t, plan.units, 2)
-		assert.Equal(t, int64(60_000), plan.units[0].grid.stepMs)
-		assert.Equal(t, unitInstant, plan.units[1].core.kind)
-		assert.Contains(t, plan.rewritten, `__signoz_transpiled_0__ / __signoz_transpiled_1__`)
-	})
-}
-
-func TestBuildUnitSQL(t *testing.T) {
-	unit := &coreUnit{
-		fn:       fnRate,
-		rangeMs:  300_000,
-		hasAgg:   true,
-		aggOp:    parser.SUM,
-		by:       true,
-		grouping: []string{"pod"},
-		matchers: []*labels.Matcher{mustMatcher(t, labels.MatchEqual, "__name__", "http_requests_total")},
-	}
-	sql, args, err := buildUnitSQL(unit, []string{"http_requests_total"}, 1_699_999_700_000, 1_700_003_600_000, 1_700_000_000_000, 1_700_003_600_000, 60_000, 300_000)
-	require.NoError(t, err)
-
-	assert.Contains(t, sql, "timeSeriesRateToGrid(fromUnixTimestamp64Milli(1700000000000), fromUnixTimestamp64Milli(1700003600000), 60, 300)(fromUnixTimestamp64Milli(unix_milli), value)")
-	assert.Contains(t, sql, "unix_milli > ? AND unix_milli <= ?")
-	assert.Contains(t, sql, "bitAnd(flags, 1) = 0")
-	assert.Contains(t, sql, "sumForEach(grid)")
-	// The group-key join rides inside the shard query: distributed samples
-	// at the top level, the local series table in the join subquery, the
-	// grid aggregation grouped per (fingerprint, group key) shard-side.
-	assert.Contains(t, sql, "FROM signoz_metrics.distributed_samples_v4 AS points INNER JOIN (SELECT fingerprint,")
-	assert.Contains(t, sql, "FROM signoz_metrics.time_series_v4 WHERE")
-	// The group key is functionally dependent on the fingerprint (one
-	// labelset per fingerprint): any() is exact and the per-row hash key
-	// shrinks to the fingerprint alone.
-	assert.Contains(t, sql, "any(series.g0) AS g0")
-	assert.Contains(t, sql, "GROUP BY points.fingerprint)")
-	// No samples-side fingerprint condition: the group-key join restricts.
-	assert.NotContains(t, sql, "points.fingerprint IN (")
-	// by (pod) extracts the grouped label directly — no per-row JSON
-	// build/sort/stringify for a known projection.
-	assert.Contains(t, sql, "JSONExtractString(labels, ?) AS g0")
-	assert.NotContains(t, sql, "toJSONString")
-	assert.Contains(t, sql, "SETTINGS allow_experimental_ts_to_grid_aggregate_function = 1")
-	// Args follow placeholder order: the joined series subquery renders
-	// before the samples WHERE, and its select list ('pod') renders before
-	// its own conditions.
-	assert.Equal(t, []any{"pod", "http_requests_total", int64(1_699_999_200_000), int64(1_700_003_600_000), "http_requests_total", int64(1_699_999_700_000), int64(1_700_003_600_000)}, args)
-}
-
-func TestBuildUnitSQLIncreaseAndOffset(t *testing.T) {
-	unit := &coreUnit{
-		fn:       fnIncrease,
-		rangeMs:  600_000,
-		offsetMs: 1_800_000,
-		matchers: []*labels.Matcher{mustMatcher(t, labels.MatchEqual, "__name__", "errors_total")},
-	}
-	sql, _, err := buildUnitSQL(unit, nil, 1_699_997_600_000, 1_700_001_800_000, 1_700_000_000_000, 1_700_003_600_000, 60_000, 300_000)
-	require.NoError(t, err)
-
-	// Grid and window shift by the offset; increase multiplies rate by the
-	// range in seconds.
-	assert.Contains(t, sql, "fromUnixTimestamp64Milli(1699998200000), fromUnixTimestamp64Milli(1700001800000)")
-	assert.Contains(t, sql, "arrayMap(x -> x * 600, timeSeriesRateToGrid")
-	assert.Contains(t, sql, "maxForEach(grid)")
-}
-
-func TestBuildUnitSQLWindowSliver(t *testing.T) {
-	// rate[5m] on a 30m grid evaluates only a 5m sliver before each grid
-	// point — samples in the gaps belong to no window and would only be
-	// buffered by the grid aggregate. The WHERE must keep exactly the
-	// in-window rows: positiveModulo anchored at the selector start (end
-	// can sit off-lattice on unaligned grids, and samples above the start
-	// make the plain modulo dividend negative), and the scan capped at the
-	// last grid point — rows past it are equally windowless.
-	unit := &coreUnit{
-		fn:       fnRate,
-		rangeMs:  300_000,
-		hasAgg:   true,
-		aggOp:    parser.SUM,
-		by:       true,
-		grouping: []string{"pod"},
-		matchers: []*labels.Matcher{mustMatcher(t, labels.MatchEqual, "__name__", "http_requests_total")},
-	}
-	sql, args, err := buildUnitSQL(unit, []string{"http_requests_total"}, 1_699_999_700_000, 1_700_003_600_000, 1_700_000_000_000, 1_700_003_600_000, 1_800_000, 300_000)
-	require.NoError(t, err)
-
-	assert.Contains(t, sql, "positiveModulo(? - unix_milli, ?) < ?")
-	assert.Equal(t, []any{"pod", "http_requests_total", int64(1_699_999_200_000), int64(1_700_003_600_000), "http_requests_total", int64(1_699_999_700_000), int64(1_700_003_600_000), int64(1_700_000_000_000), int64(1_800_000), int64(300_000)}, args)
-
-	t.Run("off-lattice end caps the scan at the last grid point", func(t *testing.T) {
-		// end - start = 50m at a 30m step: the only grid points are start
-		// and start+30m; samples in the trailing 20m serve no window.
-		_, args, err := buildUnitSQL(unit, []string{"http_requests_total"}, 1_699_999_700_000, 1_700_003_000_000, 1_700_000_000_000, 1_700_003_000_000, 1_800_000, 300_000)
-		require.NoError(t, err)
-		assert.Contains(t, args, int64(1_700_001_800_000))
-	})
-
-	t.Run("window covering the step keeps plain bounds", func(t *testing.T) {
-		sql, _, err := buildUnitSQL(unit, []string{"http_requests_total"}, 1_699_999_700_000, 1_700_003_600_000, 1_700_000_000_000, 1_700_003_600_000, 60_000, 300_000)
-		require.NoError(t, err)
-		assert.NotContains(t, sql, "positiveModulo")
-	})
-}
-
-func TestBuildUnitSQLWindowedBucketsWithoutFanOut(t *testing.T) {
-	// The window is W = range/step whole buckets, so each sample lands in
-	// exactly one bucket via GROUP BY and the window slides over bucket
-	// partials — fanning samples into every covered window (ARRAY JOIN)
-	// multiplies rows by W, a row explosion at long ranges.
-	unit := &coreUnit{
-		kind:     unitOverTime,
-		overFn:   "avg",
-		rangeMs:  600_000,
-		matchers: []*labels.Matcher{mustMatcher(t, labels.MatchEqual, "__name__", "node_load1")},
-	}
-	sql, _, err := buildUnitSQL(unit, []string{"node_load1"}, 1_699_999_400_000, 1_700_003_600_000, 1_700_000_000_000, 1_700_003_600_000, 60_000, 600_000)
-	require.NoError(t, err)
-
-	assert.NotContains(t, sql, "ARRAY JOIN")
-	// One group per series with fixed per-bucket arrays (-Resample); the
-	// bucket index jj = ceil((ts - start)/step) + W - 1 folded into a single
-	// intDiv. Grouping by (series, bucket) instead measured 37M hash groups
-	// whose per-thread partials scale memory with max_threads.
-	assert.Contains(t, sql, "countResample(0, 71, 1)(value, intDiv(unix_milli - 1700000000000 + 600000 - 1, 60000)) AS cnts")
-	assert.Contains(t, sql, "sumResample(0, 71, 1)(value, intDiv(unix_milli - 1700000000000 + 600000 - 1, 60000)) AS vals")
-	assert.Contains(t, sql, "any(series.gkey) AS gkey")
-	assert.Contains(t, sql, "GROUP BY points.fingerprint)")
-	assert.NotContains(t, sql, "jj) AS jj")
-	assert.Contains(t, sql, "INNER JOIN (SELECT fingerprint,")
-	assert.Contains(t, sql, "FROM signoz_metrics.time_series_v4 WHERE")
-	// Slide: W = 10 buckets per slot, absent when the window count is 0.
-	assert.Contains(t, sql, "arraySum(arraySlice(cnts, k + 1, 10))")
-	assert.Contains(t, sql, "arraySum(arraySlice(vals, k + 1, 10))")
-}
-
-func TestBuildUnitSQLDisjointOverTime(t *testing.T) {
-	// avg_over_time[5m] on a 30m grid: the windows are pairwise disjoint,
-	// so there is no slide — one Resample bucket per grid slot, read
-	// directly. Exact only together with the window-sliver predicate, which
-	// removes the gap samples the ceil index would otherwise assign to the
-	// window above them.
-	unit := &coreUnit{
-		kind:     unitOverTime,
-		overFn:   "avg",
-		rangeMs:  300_000,
-		matchers: []*labels.Matcher{mustMatcher(t, labels.MatchEqual, "__name__", "node_load1")},
-	}
-	sql, _, err := buildUnitSQL(unit, []string{"node_load1"}, 1_699_999_700_000, 1_700_003_600_000, 1_700_000_000_000, 1_700_003_600_000, 1_800_000, 300_000)
-	require.NoError(t, err)
-
-	assert.NotContains(t, sql, "ARRAY JOIN")
-	// gridLen = 3 slots, bucket array the same length — no W tail.
-	assert.Contains(t, sql, "countResample(0, 3, 1)(value, intDiv(unix_milli - 1700000000000 + 1800000 - 1, 1800000)) AS cnts")
-	assert.Contains(t, sql, "sumResample(0, 3, 1)(value, intDiv(unix_milli - 1700000000000 + 1800000 - 1, 1800000)) AS vals")
-	// Single-bucket window: the slide degenerates to reading one slot.
-	assert.Contains(t, sql, "arraySum(arraySlice(cnts, k + 1, 1))")
-	// The sliver predicate is the correctness precondition of this form.
-	assert.Contains(t, sql, "positiveModulo(? - unix_milli, ?) < ?")
-}
-
-// TestDisjointWindowLattice brute-forces the disjoint-form arithmetic: a
-// sample survives the sliver predicate exactly when some grid window
-// contains it, and the ceil bucket index then lands it on that window's
-// slot. This is the pure-Go mirror of the SQL expressions — the predicate
-// in samplesConditions and jj in windowedInner — over random lattices,
-// including off-lattice ends and samples beyond the last grid point.
-func TestDisjointWindowLattice(t *testing.T) {
-	rng := func(seed *uint64) int64 {
-		*seed = *seed*6364136223846793005 + 1442695040888963407
-		return int64(*seed >> 33)
-	}
-	seed := uint64(42)
-	for trial := 0; trial < 2000; trial++ {
-		stepMs := 1_000 * (1 + rng(&seed)%3600)
-		windowMs := 1 + rng(&seed)%(stepMs-1) // strictly below the step
-		selStart := 1_700_000_000_000 + rng(&seed)%1_000_000
-		selEnd := selStart + rng(&seed)%(50*stepMs) // end may sit off-lattice
-		lastIdx := (selEnd - selStart) / stepMs
-		upper := selStart + lastIdx*stepMs
-
-		for i := 0; i < 50; i++ {
-			u := selStart - windowMs - stepMs + rng(&seed)%(selEnd-selStart+3*stepMs)
-
-			// Oracle: is u inside any window (t_k - window, t_k]?
-			inWindow := false
-			var slot int64 = -1
-			for k := int64(0); k <= lastIdx; k++ {
-				tk := selStart + k*stepMs
-				if u > tk-windowMs && u <= tk {
-					inWindow = true
-					slot = k
-					break
-				}
-			}
-
-			// The SQL: fetch bounds, then the sliver predicate
-			// positiveModulo(selStart - u, step) < window.
-			kept := u > selStart-windowMs && u <= upper
-			if kept {
-				pmod := (selStart - u) % stepMs
-				if pmod < 0 {
-					pmod += stepMs
-				}
-				kept = pmod < windowMs
-			}
-
-			require.Equal(t, inWindow, kept,
-				"sliver keep mismatch: u=%d selStart=%d step=%d window=%d", u, selStart, stepMs, windowMs)
-			if !kept {
-				continue
-			}
-			// jj = ceil((u - selStart)/step) via one intDiv; numerator is
-			// positive because u > selStart - window > selStart - step.
-			jj := (u - selStart + stepMs - 1) / stepMs
-			require.Equal(t, slot, jj,
-				"slot mismatch: u=%d selStart=%d step=%d window=%d", u, selStart, stepMs, windowMs)
-		}
-	}
-}
-
-func TestTryExecuteRange_WindowedGateFallsBack(t *testing.T) {
-	c, store := newTestClient(t)
-	e := &executor{client: c, parser: prometheus.NewParser()}
-
-	start := time.UnixMilli(1_700_000_000_000)
-	end := time.UnixMilli(1_700_003_600_000)
-
-	// 10m range at 90s step: the window is not a whole number of buckets.
-	_, ok, err := e.TryExecuteRange(context.Background(), `avg_over_time(up[10m])`, start, end, 90*time.Second)
-	require.NoError(t, err)
-	assert.False(t, ok, "range not divisible by step must not transpile")
-
-	// 1d range at 60s step: 1440 bucket combines per slot, over the cap.
-	_, ok, err = e.TryExecuteRange(context.Background(), `avg_over_time(up[1d])`, start, end, time.Minute)
-	require.NoError(t, err)
-	assert.False(t, ok, "range/step above maxWindowBuckets must not transpile")
-
-	// 1m range at 5m step: the windows are disjoint slivers — no
-	// divisibility or width requirement, so this transpiles.
-	store.Mock().ExpectQuery("SELECT fingerprint, any\\(labels\\)").WithArgs("up", int64(1_699_999_200_000), int64(1_700_003_600_000)).WillReturnRows(cmock.NewRows(seriesCols, [][]any{}))
-	_, ok, err = e.TryExecuteRange(context.Background(), `avg_over_time(up[1m])`, start, end, 5*time.Minute)
-	require.NoError(t, err)
-	assert.True(t, ok, "range below step is the disjoint form and must transpile")
-}
-
-func TestApplyScalarOps(t *testing.T) {
-	f := func(v float64) *float64 { return &v }
-
-	t.Run("arithmetic chain", func(t *testing.T) {
-		values := []*float64{f(2), nil, f(4)}
-		applyScalarOps([]scalarOp{{op: parser.MUL, scalar: 100}, {op: parser.ADD, scalar: 1}}, values)
-		require.NotNil(t, values[0])
-		assert.Equal(t, 201.0, *values[0])
-		assert.Nil(t, values[1])
-		assert.Equal(t, 401.0, *values[2])
-	})
-
-	t.Run("comparison filters points", func(t *testing.T) {
-		values := []*float64{f(1), f(10)}
-		applyScalarOps([]scalarOp{{op: parser.GTR, scalar: 5}}, values)
-		assert.Nil(t, values[0])
-		require.NotNil(t, values[1])
-		assert.Equal(t, 10.0, *values[1], "filter comparisons keep the original value")
-	})
-
-	t.Run("bool comparison emits 0/1", func(t *testing.T) {
-		values := []*float64{f(1), f(10)}
-		applyScalarOps([]scalarOp{{op: parser.GTR, scalar: 5, returnBool: true}}, values)
-		assert.Equal(t, 0.0, *values[0])
-		assert.Equal(t, 1.0, *values[1])
-	})
-
-	t.Run("scalar on left division", func(t *testing.T) {
-		values := []*float64{f(4)}
-		applyScalarOps([]scalarOp{{op: parser.DIV, scalar: 100, scalarOnLeft: true}}, values)
-		assert.Equal(t, 25.0, *values[0])
-	})
-}
-
-func TestLabelsFromGroupKey(t *testing.T) {
-	lset, err := labelsFromGroupKey(`[["pod","api-0"],["ns","prod"]]`)
-	require.NoError(t, err)
-	assert.Equal(t, "api-0", lset.Get("pod"))
-	assert.Equal(t, "prod", lset.Get("ns"))
-
-	empty, err := labelsFromGroupKey(`[]`)
-	require.NoError(t, err)
-	assert.True(t, empty.IsEmpty())
-}
-
-// testGrid is a 2h query grid ending on a round timestamp.
-func testGrid(stepMs int64) gridContext {
-	return gridContext{startMs: 1_700_000_000_000, endMs: 1_700_007_200_000, stepMs: stepMs}
-}
-
-// A bool comparison returns 0/1, not the sample, so the engine drops
-// __name__; keeping it would change downstream vector matching.
-func TestKeepsName_BoolComparisonDropsName(t *testing.T) {
-	plan, ok := classify(parse(t, `up > bool 0`), testGrid(60_000))
-	require.True(t, ok)
-	assert.False(t, plan.units[0].core.keepsName())
-
-	plan, ok = classify(parse(t, `up > 0`), testGrid(60_000))
-	require.True(t, ok)
-	assert.True(t, plan.units[0].core.keepsName())
-}
-
-// timeSeriesLastToGrid widens its window to max(window, step) — probed on
-// 25.12 — so Last-style units at window < step must fall back or they would
-// resurrect samples the engine's lookback already dropped.
-func TestTryExecuteRange_LastStyleWindowBelowStepTranspiles(t *testing.T) {
-	// These used to fall back because timeSeriesLastToGrid widens its window
-	// to max(window, step). Over sliver-filtered rows the widening is
-	// harmless — the widened window intersected with the data IS the
-	// lookback window — so the gate is gone and both shapes transpile. The
-	// mock returns no series: the point here is the routing, the value
-	// semantics are the parity suite's job.
-	c, store := newTestClient(t)
-	e := &executor{client: c, parser: prometheus.NewParser()}
-
-	start := time.UnixMilli(1_700_000_000_000)
-	end := time.UnixMilli(1_700_003_600_000)
-
-	store.Mock().ExpectQuery("SELECT fingerprint, any\\(labels\\)").WithArgs("up", int64(1_699_999_200_000), int64(1_700_003_600_000)).WillReturnRows(cmock.NewRows(seriesCols, [][]any{}))
-	_, ok, err := e.TryExecuteRange(context.Background(), `sum by (pod) (up)`, start, end, time.Hour)
-	require.NoError(t, err)
-	assert.True(t, ok, "instant selection at step > lookback must transpile")
-
-	store.Mock().ExpectQuery("SELECT fingerprint, any\\(labels\\)").WithArgs("up", int64(1_699_999_200_000), int64(1_700_003_600_000)).WillReturnRows(cmock.NewRows(seriesCols, [][]any{}))
-	_, ok, err = e.TryExecuteRange(context.Background(), `last_over_time(up[10m])`, start, end, time.Hour)
-	require.NoError(t, err)
-	assert.True(t, ok, "last_over_time at range < step must transpile")
-}
-
-// A nameless selector can span metrics whose series alternate in time (one
-// dies inside the lookback before the other appears); after the name drop
-// the engine merges them into ONE series and errors only when two samples
-// share an evaluation timestamp. Pinned by conformance cases
-// operators.test:994/997 (-{job="api"} over http_requests/http_errors).
-func TestMergeSameLabelsetSeries(t *testing.T) {
-	f := func(v float64) *float64 { return &v }
-	api := labels.FromStrings("job", "api")
-
-	out, err := mergeSameLabelsetSeries([]transpiledSeries{
-		{lset: api, values: []*float64{f(-2), nil}},
-		{lset: api, values: []*float64{nil, f(-4)}},
-		{lset: labels.FromStrings("job", "web"), values: []*float64{f(7), nil}},
-	})
-	require.NoError(t, err)
-	require.Len(t, out, 2)
-	assert.Equal(t, []*float64{f(-2), f(-4)}, out[0].values, "temporally disjoint twins must merge into one series")
-
-	_, err = mergeSameLabelsetSeries([]transpiledSeries{
-		{lset: api, values: []*float64{f(1), nil}},
-		{lset: api, values: []*float64{f(2), nil}},
-	})
-	require.Error(t, err, "two values on one evaluation timestamp is the engine's duplicate error")
-	assert.True(t, errors.Ast(err, errors.TypeInvalidInput))
-}
-
-// Hybrid twin case: stripping the synthetic __name__ can leave two engine
-// output series distinguishable only by those names (-metric_a or -metric_b:
-// both {} once real names are dropped). Pinned by conformance cases
-// name_label_dropping.test:137 and operators.test:1016.
-func TestMergeMatrixByLabelset(t *testing.T) {
-	empty := labels.EmptyLabels()
-
-	out, err := mergeMatrixByLabelset(promql.Matrix{
-		{Metric: empty, Floats: []promql.FPoint{{T: 0, F: -1}}},
-		{Metric: empty, Floats: []promql.FPoint{{T: 600_000, F: -4}}},
-	})
-	require.NoError(t, err)
-	require.Len(t, out, 1)
-	assert.Equal(t, []promql.FPoint{{T: 0, F: -1}, {T: 600_000, F: -4}}, out[0].Floats)
-
-	_, err = mergeMatrixByLabelset(promql.Matrix{
-		{Metric: empty, Floats: []promql.FPoint{{T: 0, F: -1}}},
-		{Metric: empty, Floats: []promql.FPoint{{T: 0, F: -3}}},
-	})
-	require.Error(t, err)
-	assert.True(t, errors.Ast(err, errors.TypeInvalidInput))
-}

pkg/prometheus/prometheus.go

@@ -1,9 +1,6 @@
 package prometheus
 
 import (
-	"context"
-	"time"
-
 	"github.com/prometheus/prometheus/promql"
 	"github.com/prometheus/prometheus/promql/parser"
 	"github.com/prometheus/prometheus/storage"
@@ -44,14 +41,3 @@ type StatementCapturer interface {
 // X-SigNoz-PromQL-Provider request header all use it, so they cannot drift
 // apart.
 const ProviderClickhouseV2 = "clickhousev2"
-
-// RangeExecutor is the optional capability of a provider that can evaluate
-// some range queries entirely inside the datastore. ok=false means the
-// query is not evaluable that way. The caller then runs the engine over the
-// provider's Storage, which is always exact. Only the clickhousev2 provider
-// implements this capability. When that provider is the only one, the
-// capability folds into Prometheus itself, and the engine-vs-datastore
-// decision becomes internal.
-type RangeExecutor interface {
-	TryExecuteRange(ctx context.Context, query string, start, end time.Time, step time.Duration) (promql.Matrix, bool, error)
-}

pkg/querier/promql_query.go

@@ -344,8 +344,8 @@ func (q *promqlQuery) Execute(ctx context.Context) (*qbv5.Result, error) {
 	}
 
 	// Accumulate ClickHouse-side scan stats across every storage query this
-	// evaluation issues (engine selectors or the compiled executor): progress
-	// options propagate to each ClickHouse query through the context.
+	// evaluation issues: progress options propagate to each ClickHouse query
+	// through the context.
 	var statsMu sync.Mutex
 	var rowsScanned, bytesScanned uint64
 	ctx = clickhouse.Context(ctx, clickhouse.WithProgress(func(p *clickhouse.Progress) {
@@ -371,23 +371,6 @@ func (q *promqlQuery) Execute(ctx context.Context) (*qbv5.Result, error) {
 		return q.toResult(matrix, nil, began, &statsMu, &rowsScanned, &bytesScanned), nil
 	}
 
-	// When the serving provider has the RangeExecutor capability
-	// (prometheus::provider: clickhousev2), serve the way the provider is
-	// designed to serve: transpiled when the shape allows. Without this the
-	// override would silently run the engine path only.
-	if re, ok := q.promEngine.(prometheus.RangeExecutor); ok {
-		matrix, served, err := re.TryExecuteRange(ctx, query, time.Unix(0, start), time.Unix(0, end), q.query.Step.Duration)
-		if err != nil {
-			if enhanced := tryEnhancePromQLExecError(err); enhanced != nil {
-				return nil, enhanced
-			}
-			return nil, err
-		}
-		if served {
-			return q.toResult(matrix, nil, began, &statsMu, &rowsScanned, &bytesScanned), nil
-		}
-	}
-
 	qry, err := q.promEngine.Engine().NewRangeQuery(
 		ctx,
 		q.promEngine.Storage(),

pkg/querier/promql_shadow.go

@@ -19,11 +19,11 @@ import (
 const shadowTimeout = 2 * time.Minute
 
 // runShadowCompare executes the query on the clickhousev2 provider exactly
-// as it would serve (transpiled when the shape allows, engine over the v2
-// querier otherwise), compares against the served result and logs the
-// outcome. Serving is never affected: this runs after the response, off the
-// request context, and only logs. The mismatch and failure logs are the
-// rollout evidence — serving cuts over to v2 only after they stay clean.
+// as it would serve (the engine over the v2 querier), compares against the
+// served result and logs the outcome. Serving is never affected: this runs
+// after the response, off the request context, and only logs. The mismatch
+// and failure logs are the rollout evidence — serving cuts over to v2 only
+// after they stay clean.
 func (q *promqlQuery) runShadowCompare(ctx context.Context, query string, startNs, endNs int64, served promql.Matrix, servedIn time.Duration) {
 	defer func() {
 		if r := recover(); r != nil {
@@ -45,7 +45,7 @@ func (q *promqlQuery) runShadowCompare(ctx context.Context, query string, startN
 
 	start, end := time.Unix(0, startNs), time.Unix(0, endNs)
 	began := time.Now()
-	shadow, transpiled, err := executeOnProvider(ctx, q.opts.shadow, query, start, end, q.query.Step.Duration)
+	shadow, err := executeOnProvider(ctx, q.opts.shadow, query, start, end, q.query.Step.Duration)
 	shadowIn := time.Since(began)
 
 	logAttrs := []any{
@@ -53,7 +53,6 @@ func (q *promqlQuery) runShadowCompare(ctx context.Context, query string, startN
 		slog.Int64("start_ms", startNs/int64(time.Millisecond)),
 		slog.Int64("end_ms", endNs/int64(time.Millisecond)),
 		slog.Duration("step", q.query.Step.Duration),
-		slog.Bool("transpiled", transpiled),
 		slog.Duration("served_in", servedIn),
 		slog.Duration("shadow_in", shadowIn),
 	}
@@ -80,39 +79,32 @@ func (q *promqlQuery) runShadowCompare(ctx context.Context, query string, startN
 	q.logger.DebugContext(ctx, "promql shadow comparison matched", logAttrs...)
 }
 
+// serveFromProvider evaluates the query the way the pinned provider would
+// serve it.
 func (q *promqlQuery) serveFromProvider(ctx context.Context, query string, startNs, endNs int64) (promql.Matrix, error) {
-	matrix, _, err := executeOnProvider(ctx, q.opts.serve, query, time.Unix(0, startNs), time.Unix(0, endNs), q.query.Step.Duration)
-	return matrix, err
+	return executeOnProvider(ctx, q.opts.serve, query, time.Unix(0, startNs), time.Unix(0, endNs), q.query.Step.Duration)
 }
 
-// The returned matrix is an owned copy.
-func executeOnProvider(ctx context.Context, prov prometheus.Prometheus, query string, start, end time.Time, step time.Duration) (promql.Matrix, bool, error) {
-	if re, ok := prov.(prometheus.RangeExecutor); ok {
-		matrix, served, err := re.TryExecuteRange(ctx, query, start, end, step)
-		if err != nil {
-			return nil, true, err
-		}
-		if served {
-			return matrix, true, nil
-		}
-	}
-
+// executeOnProvider evaluates the query the way the provider would serve it:
+// the engine over the provider's storage. The returned matrix is an owned
+// copy.
+func executeOnProvider(ctx context.Context, prov prometheus.Prometheus, query string, start, end time.Time, step time.Duration) (promql.Matrix, error) {
 	qry, err := prov.Engine().NewRangeQuery(ctx, prov.Storage(), nil, query, start, end, step)
 	if err != nil {
-		return nil, false, err
+		return nil, err
 	}
 	defer qry.Close()
 
 	res := qry.Exec(ctx)
 	if res.Err != nil {
-		return nil, false, res.Err
+		return nil, res.Err
 	}
 	matrix, err := res.Matrix()
 	if err != nil {
-		return nil, false, err
+		return nil, err
 	}
 	// Close returns the result's sample slices to the engine pool.
-	return copyMatrix(matrix), false, nil
+	return copyMatrix(matrix), nil
 }
 
 func copyMatrix(matrix promql.Matrix) promql.Matrix {

pkg/query-service/app/resource/resource_query_builder.go

@@ -6,6 +6,8 @@ import (
 
 	v3 "github.com/SigNoz/signoz/pkg/query-service/model/v3"
 	"github.com/SigNoz/signoz/pkg/query-service/utils"
+	"github.com/SigNoz/signoz/pkg/semconv"
+	"github.com/SigNoz/signoz/pkg/types/telemetrytypes"
 )
 
 var resourceLogOperators = map[v3.FilterOperator]string{
@@ -29,13 +31,61 @@ var resourceLogOperators = map[v3.FilterOperator]string{
 	v3.FilterOperatorNotILike:        "NOT ILIKE",
 }
 
+func resourceSemconvMembers(key string) []string {
+	return semconv.Members(semconv.KindAttribute, telemetrytypes.FieldKeySelector{
+		Name:         key,
+		Signal:       telemetrytypes.SignalTraces,
+		FieldContext: telemetrytypes.FieldContextResource,
+	})
+}
+
+func resourceValueExpression(key string) string {
+	members := resourceSemconvMembers(key)
+	if len(members) == 1 {
+		return fmt.Sprintf("simpleJSONExtractString(labels, '%s')", key)
+	}
+
+	values := make([]string, 0, len(members))
+	for _, member := range members {
+		values = append(values, fmt.Sprintf("NULLIF(simpleJSONExtractString(labels, '%s'), '')", member))
+	}
+	return "COALESCE(" + strings.Join(values, ", ") + ")"
+}
+
+func resourcePresenceExpression(key string, exists bool) string {
+	members := resourceSemconvMembers(key)
+	if len(members) == 1 {
+		if exists {
+			return fmt.Sprintf("simpleJSONHas(labels, '%s')", key)
+		}
+		return fmt.Sprintf("not simpleJSONHas(labels, '%s')", key)
+	}
+
+	conditions := make([]string, 0, len(members))
+	for _, member := range members {
+		if exists {
+			conditions = append(conditions, fmt.Sprintf("simpleJSONHas(labels, '%s')", member))
+		} else {
+			conditions = append(conditions, fmt.Sprintf("not simpleJSONHas(labels, '%s')", member))
+		}
+	}
+	separator := " OR "
+	if !exists {
+		separator = " AND "
+	}
+	return "(" + strings.Join(conditions, separator) + ")"
+}
+
 // buildResourceFilter builds a clickhouse filter string for resource labels
 func buildResourceFilter(logsOp string, key string, op v3.FilterOperator, value interface{}) string {
 	// for all operators except contains and like
-	searchKey := fmt.Sprintf("simpleJSONExtractString(labels, '%s')", key)
+	searchKey := resourceValueExpression(key)
 
 	// for contains and like it will be case insensitive
 	lowerSearchKey := fmt.Sprintf("simpleJSONExtractString(lower(labels), '%s')", key)
+	if len(resourceSemconvMembers(key)) > 1 {
+		lowerSearchKey = "lower(" + searchKey + ")"
+	}
 
 	chFmtVal := utils.ClickHouseFormattedValue(value)
 
@@ -43,9 +93,9 @@ func buildResourceFilter(logsOp string, key string, op v3.FilterOperator, value
 
 	switch op {
 	case v3.FilterOperatorExists:
-		return fmt.Sprintf("simpleJSONHas(labels, '%s')", key)
+		return resourcePresenceExpression(key, true)
 	case v3.FilterOperatorNotExists:
-		return fmt.Sprintf("not simpleJSONHas(labels, '%s')", key)
+		return resourcePresenceExpression(key, false)
 	case v3.FilterOperatorRegex, v3.FilterOperatorNotRegex:
 		return fmt.Sprintf(logsOp, searchKey, chFmtVal)
 	case v3.FilterOperatorContains, v3.FilterOperatorNotContains:
@@ -110,6 +160,38 @@ func buildIndexFilterForInOperator(key string, op v3.FilterOperator, value inter
 // we can use lower index for =, in etc but it's difficult to do it for !=, NIN etc
 // if as x != "ABC" we cannot predict something like "not lower(labels) like '%%x%%abc%%'". It has it be "not lower(labels) like '%%x%%ABC%%'"
 func buildResourceIndexFilter(key string, op v3.FilterOperator, value interface{}) string {
+	return buildResourceIndexFilterForKey(key, op, value, true)
+}
+
+func buildResourceIndexFilterForKey(key string, op v3.FilterOperator, value interface{}, resolveFamily bool) string {
+	members := []string{key}
+	if resolveFamily {
+		members = resourceSemconvMembers(key)
+	}
+	if len(members) > 1 {
+		switch op {
+		case v3.FilterOperatorNotEqual,
+			v3.FilterOperatorNotLike,
+			v3.FilterOperatorNotILike,
+			v3.FilterOperatorNotContains,
+			v3.FilterOperatorNotExists,
+			v3.FilterOperatorNotRegex,
+			v3.FilterOperatorNotIn:
+			return ""
+		}
+
+		conditions := make([]string, 0, len(members))
+		for _, member := range members {
+			if condition := buildResourceIndexFilterForKey(member, op, value, false); condition != "" {
+				conditions = append(conditions, condition)
+			}
+		}
+		if len(conditions) == 0 {
+			return ""
+		}
+		return "(" + strings.Join(conditions, " OR ") + ")"
+	}
+
 	// not using clickhouseFormattedValue as we don't wan't the quotes
 	strVal := fmt.Sprintf("%s", value)
 	fmtValEscapedForContains := utils.QuoteEscapedStringForContains(strVal, true)
@@ -206,14 +288,31 @@ func buildResourceFiltersFromGroupBy(groupBy []v3.AttributeKey) []string {
 		if attr.Type != v3.AttributeKeyTypeResource {
 			continue
 		}
-		conditions = append(conditions, fmt.Sprintf("(simpleJSONHas(labels, '%s') AND labels like '%%%s%%')", attr.Key, attr.Key))
+		members := resourceSemconvMembers(attr.Key)
+		if len(members) == 1 {
+			conditions = append(conditions, fmt.Sprintf("(simpleJSONHas(labels, '%s') AND labels like '%%%s%%')", attr.Key, attr.Key))
+			continue
+		}
+		indexConditions := make([]string, 0, len(members))
+		for _, member := range members {
+			indexConditions = append(indexConditions, fmt.Sprintf("labels like '%%%s%%'", member))
+		}
+		conditions = append(conditions, fmt.Sprintf("(%s AND (%s))", resourcePresenceExpression(attr.Key, true), strings.Join(indexConditions, " OR ")))
 	}
 	return conditions
 }
 
 func buildResourceFiltersFromAggregateAttribute(aggregateAttribute v3.AttributeKey) string {
 	if aggregateAttribute.Key != "" && aggregateAttribute.Type == v3.AttributeKeyTypeResource {
-		return fmt.Sprintf("(simpleJSONHas(labels, '%s') AND labels like '%%%s%%')", aggregateAttribute.Key, aggregateAttribute.Key)
+		members := resourceSemconvMembers(aggregateAttribute.Key)
+		if len(members) == 1 {
+			return fmt.Sprintf("(simpleJSONHas(labels, '%s') AND labels like '%%%s%%')", aggregateAttribute.Key, aggregateAttribute.Key)
+		}
+		indexConditions := make([]string, 0, len(members))
+		for _, member := range members {
+			indexConditions = append(indexConditions, fmt.Sprintf("labels like '%%%s%%'", member))
+		}
+		return fmt.Sprintf("(%s AND (%s))", resourcePresenceExpression(aggregateAttribute.Key, true), strings.Join(indexConditions, " OR "))
 	}
 
 	return ""

pkg/query-service/app/resource/resource_query_builder_test.go

@@ -5,6 +5,8 @@ import (
 	"testing"
 
 	v3 "github.com/SigNoz/signoz/pkg/query-service/model/v3"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func Test_buildResourceFilter(t *testing.T) {
@@ -552,3 +554,38 @@ func Test_buildResourceSubQuery(t *testing.T) {
 		})
 	}
 }
+
+func TestSemanticConventionResourceFamily(t *testing.T) {
+	const resolvedValue = "COALESCE(NULLIF(simpleJSONExtractString(labels, 'deployment.environment.name'), ''), NULLIF(simpleJSONExtractString(labels, 'deployment.environment'), ''))"
+
+	for _, requestedName := range []string{"deployment.environment.name", "deployment.environment"} {
+		t.Run(requestedName, func(t *testing.T) {
+			assert.Equal(t, resolvedValue+" = 'production'", buildResourceFilter("=", requestedName, v3.FilterOperatorEqual, "production"))
+			assert.Equal(t, "(simpleJSONHas(labels, 'deployment.environment.name') OR simpleJSONHas(labels, 'deployment.environment'))", buildResourceFilter("", requestedName, v3.FilterOperatorExists, nil))
+			assert.Equal(t, "(not simpleJSONHas(labels, 'deployment.environment.name') AND not simpleJSONHas(labels, 'deployment.environment'))", buildResourceFilter("", requestedName, v3.FilterOperatorNotExists, nil))
+			assert.Equal(t, "(labels like '%deployment.environment.name\":\"production%' OR labels like '%deployment.environment\":\"production%')", buildResourceIndexFilter(requestedName, v3.FilterOperatorEqual, "production"))
+			assert.Empty(t, buildResourceIndexFilter(requestedName, v3.FilterOperatorNotEqual, "production"), "negative family filter must not use a rejecting index hint")
+		})
+	}
+
+	filters, err := buildResourceFiltersFromFilterItems(&v3.FilterSet{Items: []v3.FilterItem{{
+		Key: v3.AttributeKey{
+			Key:      "deployment.environment.name",
+			DataType: v3.AttributeKeyDataTypeString,
+			Type:     v3.AttributeKeyTypeResource,
+		},
+		Operator: v3.FilterOperatorEqual,
+		Value:    "production",
+	}}})
+	require.NoError(t, err, "family filter items must build before their output is inspected")
+	wantFilters := []string{
+		resolvedValue + " = 'production'",
+		"(labels like '%deployment.environment.name\":\"production%' OR labels like '%deployment.environment\":\"production%')",
+	}
+	assert.Equal(t, wantFilters, filters)
+
+	wantPresence := "((simpleJSONHas(labels, 'deployment.environment.name') OR simpleJSONHas(labels, 'deployment.environment')) AND (labels like '%deployment.environment.name%' OR labels like '%deployment.environment%'))"
+	groupBy := buildResourceFiltersFromGroupBy([]v3.AttributeKey{{Key: "deployment.environment", Type: v3.AttributeKeyTypeResource}})
+	assert.Equal(t, []string{wantPresence}, groupBy)
+	assert.Equal(t, wantPresence, buildResourceFiltersFromAggregateAttribute(v3.AttributeKey{Key: "deployment.environment.name", Type: v3.AttributeKeyTypeResource}))
+}

pkg/query-service/app/services/map.go

@@ -6,16 +6,32 @@ import (
 
 	"github.com/ClickHouse/clickhouse-go/v2"
 	"github.com/SigNoz/signoz/pkg/query-service/model"
+	"github.com/SigNoz/signoz/pkg/semconv"
+	"github.com/SigNoz/signoz/pkg/types/telemetrytypes"
 )
 
 var (
-	columns = map[string]struct{}{
-		"deployment_environment": {},
-		"k8s_cluster_name":       {},
-		"k8s_namespace_name":     {},
-	}
+	columns = serviceMapColumns()
 )
 
+func serviceMapColumns() map[string]string {
+	columns := map[string]string{
+		"k8s_cluster_name":   "k8s_cluster_name",
+		"k8s_namespace_name": "k8s_namespace_name",
+	}
+
+	// Dependency-graph rows keep their historical physical column name. Both
+	// semantic-convention request spellings target that same derived column.
+	for _, member := range semconv.Members(semconv.KindAttribute, telemetrytypes.FieldKeySelector{
+		Name:         "deployment.environment.name",
+		Signal:       telemetrytypes.SignalTraces,
+		FieldContext: telemetrytypes.FieldContextResource,
+	}) {
+		columns[strings.ReplaceAll(member, ".", "_")] = "deployment_environment"
+	}
+	return columns
+}
+
 func BuildServiceMapQuery(tags []model.TagQuery) (string, []interface{}) {
 	var filterQuery string
 	var namedArgs []interface{}
@@ -24,39 +40,40 @@ func BuildServiceMapQuery(tags []model.TagQuery) (string, []interface{}) {
 		operator := tag.GetOperator()
 		value := tag.GetValues()
 
-		if _, ok := columns[key]; !ok {
+		column, ok := columns[key]
+		if !ok {
 			continue
 		}
 
 		switch operator {
 		case model.InOperator:
-			filterQuery += fmt.Sprintf(" AND %s IN @%s", key, key)
+			filterQuery += fmt.Sprintf(" AND %s IN @%s", column, key)
 			namedArgs = append(namedArgs, clickhouse.Named(key, value))
 		case model.NotInOperator:
-			filterQuery += fmt.Sprintf(" AND %s NOT IN @%s", key, key)
+			filterQuery += fmt.Sprintf(" AND %s NOT IN @%s", column, key)
 			namedArgs = append(namedArgs, clickhouse.Named(key, value))
 		case model.EqualOperator:
-			filterQuery += fmt.Sprintf(" AND %s = @%s", key, key)
+			filterQuery += fmt.Sprintf(" AND %s = @%s", column, key)
 			namedArgs = append(namedArgs, clickhouse.Named(key, value))
 		case model.NotEqualOperator:
-			filterQuery += fmt.Sprintf(" AND %s != @%s", key, key)
+			filterQuery += fmt.Sprintf(" AND %s != @%s", column, key)
 			namedArgs = append(namedArgs, clickhouse.Named(key, value))
 		case model.ContainsOperator:
-			filterQuery += fmt.Sprintf(" AND %s LIKE @%s", key, key)
+			filterQuery += fmt.Sprintf(" AND %s LIKE @%s", column, key)
 			namedArgs = append(namedArgs, clickhouse.Named(key, fmt.Sprintf("%%%s%%", value)))
 		case model.NotContainsOperator:
-			filterQuery += fmt.Sprintf(" AND %s NOT LIKE @%s", key, key)
+			filterQuery += fmt.Sprintf(" AND %s NOT LIKE @%s", column, key)
 			namedArgs = append(namedArgs, clickhouse.Named(key, fmt.Sprintf("%%%s%%", value)))
 		case model.StartsWithOperator:
-			filterQuery += fmt.Sprintf(" AND %s LIKE @%s", key, key)
+			filterQuery += fmt.Sprintf(" AND %s LIKE @%s", column, key)
 			namedArgs = append(namedArgs, clickhouse.Named(key, fmt.Sprintf("%s%%", value)))
 		case model.NotStartsWithOperator:
-			filterQuery += fmt.Sprintf(" AND %s NOT LIKE @%s", key, key)
+			filterQuery += fmt.Sprintf(" AND %s NOT LIKE @%s", column, key)
 			namedArgs = append(namedArgs, clickhouse.Named(key, fmt.Sprintf("%s%%", value)))
 		case model.ExistsOperator:
-			filterQuery += fmt.Sprintf(" AND %s IS NOT NULL", key)
+			filterQuery += fmt.Sprintf(" AND %s IS NOT NULL", column)
 		case model.NotExistsOperator:
-			filterQuery += fmt.Sprintf(" AND %s IS NULL", key)
+			filterQuery += fmt.Sprintf(" AND %s IS NULL", column)
 		}
 	}
 	return filterQuery, namedArgs

pkg/query-service/app/services/map_test.go

@@ -0,0 +1,35 @@
+package services
+
+import (
+	"testing"
+
+	"github.com/ClickHouse/clickhouse-go/v2/lib/driver"
+	"github.com/SigNoz/signoz/pkg/query-service/model"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestBuildServiceMapQueryAcceptsEnvironmentFamily(t *testing.T) {
+	for _, requestedName := range []string{"deployment.environment.name", "deployment.environment"} {
+		t.Run(requestedName, func(t *testing.T) {
+			tags := []model.TagQuery{model.NewTagQueryString(model.TagQueryParam{
+				Key:          requestedName,
+				StringValues: []string{"production"},
+				Operator:     model.InOperator,
+				TagType:      model.ResourceAttributeTagType,
+			})}
+
+			query, args := BuildServiceMapQuery(tags)
+			argName := "deployment_environment"
+			if requestedName == "deployment.environment.name" {
+				argName = "deployment_environment_name"
+			}
+			assert.Equal(t, " AND deployment_environment IN @"+argName, query)
+			require.Len(t, args, 1)
+			named, ok := args[0].(driver.NamedValue)
+			require.True(t, ok)
+			assert.Equal(t, argName, named.Name)
+			assert.Equal(t, []interface{}{"production"}, named.Value)
+		})
+	}
+}

pkg/querybuilder/clickhouse_sql.go

@@ -17,7 +17,6 @@ var (
 	CodeClickHouseSQLNotSingleStatement = errors.MustNewCode("clickhouse_sql_not_single_statement")
 	CodeClickHouseSQLNotSelect          = errors.MustNewCode("clickhouse_sql_not_select")
 	CodeClickHouseSQLTableFunction      = errors.MustNewCode("clickhouse_sql_table_function")
-	CodeClickHouseSQLReadingFunction    = errors.MustNewCode("clickhouse_sql_reading_function")
 	CodeClickHouseSQLInternalDatabase   = errors.MustNewCode("clickhouse_sql_internal_database")
 	CodeClickHouseSQLReadonlyOverride   = errors.MustNewCode("clickhouse_sql_readonly_override")
 )
@@ -44,25 +43,6 @@ var generatorTableFunctions = map[string]string{
 
 var generatorTableFunctionsMessage = "allowed table functions are " + strings.Join(slices.Sorted(maps.Values(generatorTableFunctions)), ", ")
 
-// readingFunctions reach a file, a model or the server binary while looking like ordinary
-// scalar functions. They name no table and no database, so neither of the rules above sees
-// them, and a wrapper that returns a number leaks what they read through the row count alone:
-// numbers(length(file(x))) yields one row per byte.
-//
-// Keyed by the lowercased name, since ClickHouse resolves function names case-insensitively.
-var readingFunctions = map[string]struct{}{
-	"file":                     {},
-	"catboostevaluate":         {},
-	"demangle":                 {},
-	"addresstoline":            {},
-	"addresstolinewithinlines": {},
-	"addresstosymbol":          {},
-}
-
-// A dictionary can be backed by HTTP, ODBC or another database, and every one of the 42
-// accessors carries this prefix.
-const dictionaryFunctionPrefix = "dict"
-
 // The parser's grammar has gaps against SQL that ClickHouse itself accepts.
 func ErrIfStatementIsNotValid(query string) (err error) {
 	defer func() {
@@ -89,23 +69,11 @@ func ErrIfStatementIsNotValid(query string) (err error) {
 
 	visitor := &chparser.DefaultASTVisitor{Visit: func(node chparser.Expr) error {
 		switch expr := node.(type) {
-		case *chparser.TableExpr:
-			// Source table functions remain usable in ClickHouse read-only mode, and only a
-			// table position can be one. The parser also types a call inside a table function's
-			// argument list as a TableFunctionExpr, so asking every one of those refuses the
-			// numbers(intDiv(...)) that every dashboard writes. What can read from an argument
-			// is caught by name below instead.
-			source := expr.Expr
-			if alias, ok := source.(*chparser.AliasExpr); ok {
-				source = alias.Expr
-			}
-
-			tableFunction, ok := source.(*chparser.TableFunctionExpr)
-			if !ok {
-				return nil
-			}
-
-			name := functionName(tableFunction.Name)
+		case *chparser.TableFunctionExpr:
+			// Source table functions remain usable in ClickHouse read-only mode. Arguments are
+			// visited before this, so a read smuggled into one is already refused by the time
+			// an allowed generator gets here.
+			name := chparser.Format(expr.Name)
 			if _, ok := generatorTableFunctions[strings.ToLower(name)]; ok {
 				return nil
 			}
@@ -114,25 +82,6 @@ func ErrIfStatementIsNotValid(query string) (err error) {
 				NewInvalidInputf(CodeClickHouseSQLTableFunction, "ClickHouse table functions are not allowed in SQL queries: %s", name).
 				WithAdditional(generatorTableFunctionsMessage)
 
-		case *chparser.FunctionExpr:
-			return errIfFunctionReads(expr.Name.Name)
-
-		case *chparser.TableFunctionExpr:
-			// Reached for a call in an argument list, and for a table position ahead of the
-			// TableExpr above, since a node is visited after its children.
-			return errIfFunctionReads(functionName(expr.Name))
-
-		case *chparser.Path:
-			// ClickHouse reads `x IN db.table` as a select from that table, and a qualified name
-			// on the right of IN is a Path rather than a TableIdentifier.
-			if len(expr.Fields) < 2 {
-				return nil
-			}
-
-			if _, ok := internalDatabases[strings.ToLower(expr.Fields[0].Name)]; ok {
-				return errors.NewInvalidInputf(CodeClickHouseSQLInternalDatabase, "the ClickHouse %s database is not allowed in SQL queries", expr.Fields[0].Name)
-			}
-
 		case *chparser.TableIdentifier:
 			// Reading these is unaffected by ClickHouse read-only mode.
 			if expr.Database == nil {
@@ -162,22 +111,3 @@ func LogIfStatementIsNotValid(ctx context.Context, logger *slog.Logger, query st
 		logger.WarnContext(ctx, "clickhouse sql is not valid", errors.Attr(err), slog.String("query", query))
 	}
 }
-
-func errIfFunctionReads(name string) error {
-	lowered := strings.ToLower(name)
-	if _, ok := readingFunctions[lowered]; !ok && !strings.HasPrefix(lowered, dictionaryFunctionPrefix) {
-		return nil
-	}
-
-	return errors.NewInvalidInputf(CodeClickHouseSQLReadingFunction, "ClickHouse functions that read outside the telemetry tables are not allowed in SQL queries: %s", name)
-}
-
-// The parser spells a call's name as an Ident everywhere it can. Reading the field rather than
-// formatting the node keeps the quoting out, so `numbers`(1) matches numbers.
-func functionName(expr chparser.Expr) string {
-	if ident, ok := expr.(*chparser.Ident); ok {
-		return ident.Name
-	}
-
-	return chparser.Format(expr)
-}

pkg/querybuilder/clickhouse_sql_test.go

@@ -7,7 +7,6 @@ import (
 	"github.com/SigNoz/signoz/pkg/errors"
 
 	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
 )
 
 func TestErrIfStatementIsNotValid_Pass(t *testing.T) {
@@ -15,12 +14,13 @@ func TestErrIfStatementIsNotValid_Pass(t *testing.T) {
 		name  string
 		query string
 	}{
+		// Shapes a telemetry read is allowed to take.
 		{"Select", "SELECT region AS r, zone FROM metrics WHERE metric_name = 'cpu' GROUP BY region, zone"},
 		{"TrailingSemicolon", "SELECT count() FROM signoz_logs.distributed_logs_v2;"},
 		{"CommonTableExpression", "WITH t AS (SELECT fingerprint FROM signoz_metrics.time_series_v4) SELECT * FROM t"},
 		{"Join", "SELECT * FROM t1 LEFT JOIN t2 ON t1.a = t2.b"},
 		{"GlobalIn", "SELECT a FROM t WHERE a GLOBAL IN (SELECT b FROM t2)"},
-		// https://github.com/AfterShip/clickhouse-sql-parser/pull/293
+		// GLOBAL parsed only when the join type was omitted, and only before IN. https://github.com/AfterShip/clickhouse-sql-parser/pull/293
 		{"GlobalLeftJoin", "SELECT * FROM t1 GLOBAL LEFT JOIN t2 ON t1.a = t2.a"},
 		{"GlobalNotIn", "SELECT a FROM t WHERE a GLOBAL NOT IN (SELECT b FROM t2)"},
 		{"Union", "SELECT * FROM t UNION ALL SELECT * FROM t2"},
@@ -29,34 +29,32 @@ func TestErrIfStatementIsNotValid_Pass(t *testing.T) {
 		{"UnrelatedSetting", "SELECT * FROM t SETTINGS max_threads = 4"},
 		{"TerminatedBlockComment", "SELECT /* keep me */ count() FROM t"},
 		{"BlockCommentMarkerInsideStringLiteral", "SELECT count() FROM t WHERE body = '/* not a comment'"},
-		// Looped forever before v0.5.2.
+		// The parser used to loop forever on this; it now reads the comment to the end of
+		// the input, so this doubles as a canary for that regression.
 		{"TrailingUnterminatedBlockComment", "SELECT count() FROM t /* unterminated"},
-		// Keyed on the database, not on the table name.
+		// The rule keys on the database, not on the table name.
 		{"TableNamedSystemInTelemetryDatabase", "SELECT * FROM signoz_logs.system"},
 		{"SignedLiteralAfterClosingParenSpaced", "SELECT (toUnixTimestamp(now()) - 3600)*1000000000"},
+		// order by interval
 		{"OrderByInterval", "SELECT toStartOfInterval(timestamp, INTERVAL 1 MINUTE) AS interval ORDER BY interval"},
 		{"OrderByIntervalAndDirection", "SELECT toStartOfInterval(timestamp, INTERVAL 1 MINUTE) AS `interval` ORDER BY `interval` ASC"},
-		// https://github.com/AfterShip/clickhouse-sql-parser/pull/296
+		// `interval` is a unit keyword, so unquoting it was rejected everywhere the parser
+		// expected a plain identifier. https://github.com/AfterShip/clickhouse-sql-parser/pull/296
 		{"OrderByUnquotedIntervalAsc", "SELECT toStartOfInterval(timestamp, INTERVAL 1 MINUTE) AS interval FROM t GROUP BY interval ORDER BY interval ASC"},
 		{"OrderByUnquotedIntervalDesc", "SELECT toStartOfInterval(timestamp, INTERVAL 1 MINUTE) AS interval FROM t GROUP BY interval ORDER BY interval DESC"},
 		{"UnquotedIntervalInGroupByTuple", "SELECT a FROM t GROUP BY (`service.name`, `service.version`, interval)"},
 		{"UnquotedIntervalProductionQuery", "SELECT toStartOfInterval(timestamp, INTERVAL 1 MINUTE) AS interval, resource_string_service$$name AS `service.name`, attributes_string['http.route'] AS `http.route`, quantile(0.95)(duration_nano) / 1000000000 AS value FROM signoz_traces.distributed_signoz_index_v3 WHERE resource_string_service$$name = 'svc-a' AND resources_string['deployment.environment'] = 'dev' AND attributes_string['http.route'] = '/v1' AND http_method = 'POST' AND timestamp BETWEEN toDateTime(1784601720) AND toDateTime(1784602620) AND ts_bucket_start BETWEEN 1784601720 - 1800 AND 1784602620 GROUP BY `service.name`, `http.route`, interval ORDER BY interval ASC"},
-		// The fix backtracks, so this bounds the cost. https://github.com/AfterShip/clickhouse-sql-parser/pull/296#issuecomment-5150316367
+		// Separating the two readings of INTERVAL needs backtracking as per the current implementation which could have performance regressions.
+		// https://github.com/AfterShip/clickhouse-sql-parser/pull/296#issuecomment-5150316367
 		{"UnquotedIntervalRepeatedThirtyTimes", "SELECT interval + interval + interval + interval + interval + interval + interval + interval + interval + interval + interval + interval + interval + interval + interval + interval + interval + interval + interval + interval + interval + interval + interval + interval + interval + interval + interval + interval + interval + interval AS total FROM t WHERE interval > 0 ORDER BY interval ASC"},
-		// `interval` was one of 37 such keywords. https://github.com/AfterShip/clickhouse-sql-parser/pull/305
-		{"UnquotedLimitInFunctionArgument", "SELECT sum(limit) FROM t"},
-		{"UnquotedLimitInArithmetic", "SELECT limit + 1 FROM t"},
-		{"UnquotedLimitInNegation", "SELECT abs(-limit) FROM t"},
-		{"UnquotedKeywordOperands", "SELECT sum(offset) + sum(format) + sum(settings) FROM t"},
-		{"UnquotedLimitProductionQuery", "WITH limit_value AS (SELECT cluster, region, value AS limit FROM t) SELECT region AS `Region`, sum(limit) AS `Capacity` FROM limit_value GROUP BY Region"},
 		{"SignedLiteralAfterClosingParenUnspaced", "SELECT now() AS ts, toFloat64(count()) AS value FROM ( SELECT attributes_string['TableName'] AS T, attributes_string['MissingId'] AS M, max(fromUnixTimestamp64Nano(timestamp)) AS last_seen, dateDiff('minute', min(fromUnixTimestamp64Nano(timestamp)), max(fromUnixTimestamp64Nano(timestamp))) AS age_min FROM signoz_logs.distributed_logs_v2 WHERE body='missing_map_record' AND timestamp >= (toUnixTimestamp(now())-3600)*1000000000 GROUP BY T, M ) WHERE age_min >= 20 AND last_seen >= now() - toIntervalMinute(8)"},
 		{"SignedLiteralAfterClosingParenMinimal", "SELECT (1)-1"},
 		{"TrimFunction", "SELECT trimBoth('/api/endpoint/', '/');"},
-		// https://github.com/AfterShip/clickhouse-sql-parser/pull/290
+		// The SQL-standard keyword-separated argument forms, which took commas only. https://github.com/AfterShip/clickhouse-sql-parser/pull/290
 		{"StandardTrimSyntax", "SELECT trim(BOTH ' ' FROM body) FROM t"},
 		{"StandardSubstringSyntax", "SELECT substring(body FROM 2 FOR 3) FROM t"},
 		{"StandardOverlaySyntax", "SELECT overlay(body PLACING 'x' FROM 2) FROM t"},
-		// The shape row generators get used for: a dense interval axis to CROSS JOIN a sparse series against.
+		// Row generators compute their rows from their arguments, so they read through nothing. This is the shape they get used for: a dense interval axis to CROSS JOIN a sparse series against.
 		{"NumbersTableFunction", "SELECT intervals.interval AS interval, active.cluster AS cluster, toFloat64(if(ts_data.has_data = 0, 0, 1)) AS value FROM ( SELECT DISTINCT JSONExtractString(labels, 'k8s.cluster.name') AS cluster FROM signoz_metrics.distributed_time_series_v4 WHERE metric_name = 'my_metric' AND unix_milli >= toUnixTimestamp(now() - INTERVAL 30 DAY) * 1000 HAVING cluster != '' ) AS active CROSS JOIN ( SELECT toStartOfInterval( toDateTime(toUnixTimestamp(now() - INTERVAL 30 MINUTE) + number * 60), INTERVAL 1 MINUTE ) AS interval FROM numbers(31) ) AS intervals LEFT JOIN ( SELECT toStartOfInterval( toDateTime(intDiv(s.unix_milli, 1000)), INTERVAL 1 MINUTE ) AS interval, JSONExtractString(ts.labels, 'k8s.cluster.name') AS cluster, 1 AS has_data FROM signoz_metrics.distributed_samples_v4 s INNER JOIN ( SELECT DISTINCT fingerprint, labels FROM signoz_metrics.distributed_time_series_v4 WHERE metric_name = 'my_metric' ) AS ts ON s.fingerprint = ts.fingerprint WHERE s.metric_name = 'my_metric' AND s.unix_milli >= toUnixTimestamp(now() - INTERVAL 30 MINUTE) * 1000 GROUP BY interval, cluster ) AS ts_data ON active.cluster = ts_data.cluster AND intervals.interval = ts_data.interval ORDER BY interval ASC"},
 		{"NumbersMtTableFunction", "SELECT * FROM numbers_mt(31)"},
 		{"ZerosTableFunction", "SELECT * FROM zeros(31)"},
@@ -65,16 +63,6 @@ func TestErrIfStatementIsNotValid_Pass(t *testing.T) {
 		{"GenerateSeriesSnakeCaseTableFunction", "SELECT * FROM generate_series(1, 10)"},
 		{"GeneratorTableFunctionUppercase", "SELECT * FROM NUMBERS(31)"},
 		{"GeneratorTableFunctionParenthesisedArgument", "SELECT * FROM NUMBERS((31))"},
-		// CAST in an argument was itself read as a table function. https://github.com/AfterShip/clickhouse-sql-parser/pull/307
-		{"CastInGeneratorTableFunctionArgument", "SELECT * FROM numbers(CAST(10 AS UInt64))"},
-		{"ScalarCallInGeneratorTableFunctionArgument", "SELECT * FROM numbers(intDiv(100, 2))"},
-		{"NestedScalarCallInGeneratorTableFunctionArgument", "SELECT * FROM numbers(greatest(1, intDiv(100, 2) + 1))"},
-		{"GeneratorTableFunctionProductionQuery", "WITH toInt64(1786029960000000000) AS start_ns, toInt64(1786031760000000000) AS end_ns, 300000000000 AS step_ns SELECT ts, toFloat64(sum(value)) AS value FROM (SELECT fromUnixTimestamp64Nano(start_ns + toInt64(number) * step_ns) AS ts, 0 AS value FROM numbers(greatest(1, intDiv(end_ns - start_ns, step_ns) + 1)) UNION ALL SELECT toStartOfInterval(fromUnixTimestamp64Nano(timestamp), INTERVAL 5 minute) AS ts, count() AS value FROM signoz_logs.distributed_logs_v2 WHERE timestamp >= 1786029960000000000 AND timestamp <= 1786031760000000000 GROUP BY ts) GROUP BY ts ORDER BY ts"},
-		// The allow list keys on the bare name, so quoting must not hide a generator from it.
-		{"BacktickQuotedGeneratorTableFunction", "SELECT * FROM `numbers`(31)"},
-		{"DoubleQuotedGeneratorTableFunction", "SELECT * FROM \"numbers\"(31)"},
-		// Reads nothing: format builds a string, and shares its name with a table function.
-		{"ScalarFunctionNamedAfterATableFunction", "SELECT format('{} {}', a, b) FROM t"},
 		{"GeneratorTableFunctionInJoin", "SELECT * FROM signoz_logs.distributed_logs_v2 AS l CROSS JOIN numbers(31) AS n"},
 		{"GeneratorTableFunctionInCommonTableExpression", "WITH axis AS (SELECT number FROM numbers(31)) SELECT * FROM axis"},
 		{"GeneratorTableFunctionInWhereSubquery", "SELECT * FROM t WHERE a IN (SELECT number FROM numbers(31))"},
@@ -83,7 +71,8 @@ func TestErrIfStatementIsNotValid_Pass(t *testing.T) {
 
 	for _, testCase := range testCases {
 		t.Run(testCase.name, func(t *testing.T) {
-			// Bounded because a parser that backtracks without memoising hangs rather than returning.
+			// Bounded rather than called directly: a parser that backtracks without memoising
+			// hangs instead of returning. Every case here parses in well under a millisecond.
 			errC := make(chan error, 1)
 			go func() { errC <- ErrIfStatementIsNotValid(testCase.query) }()
 
@@ -103,57 +92,46 @@ func TestErrIfStatementIsNotValid_Fail(t *testing.T) {
 		query        string
 		expectedCode errors.Code
 	}{
+		// Not a single statement, or not a statement at all.
 		{"Empty", "", CodeClickHouseSQLNotSingleStatement},
 		{"UnterminatedBlockCommentOnly", "/* x", CodeClickHouseSQLUnparseable},
 		{"Unparseable", "SELECT FROM WHERE", CodeClickHouseSQLUnparseable},
 		{"MultipleStatements", "SELECT 1; DROP TABLE signoz_logs.logs_v2", CodeClickHouseSQLNotSingleStatement},
+		// Parses, but is not a SELECT.
 		{"Drop", "DROP TABLE signoz_logs.logs_v2", CodeClickHouseSQLNotSelect},
 		{"Insert", "INSERT INTO signoz_logs.logs_v2 SELECT * FROM signoz_logs.logs_v2", CodeClickHouseSQLNotSelect},
 		{"AlterDelete", "ALTER TABLE signoz_logs.logs_v2 DELETE WHERE 1 = 1", CodeClickHouseSQLNotSelect},
 		{"CreateTable", "CREATE TABLE evil (a Int) ENGINE = Memory", CodeClickHouseSQLNotSelect},
 		{"Grant", "GRANT ALL ON *.* TO admin", CodeClickHouseSQLNotSelect},
 		{"Set", "SET readonly = 0", CodeClickHouseSQLNotSelect},
-		// Both panicked before v0.5.5. https://github.com/AfterShip/clickhouse-sql-parser/pull/306
-		{"UnparseableDefaultExpression", "CREATE TABLE t (a String DEFAULT foo(b FROM 2)) ENGINE = Memory", CodeClickHouseSQLUnparseable},
-		{"TrailingOperatorInDefaultExpression", "CREATE TABLE t (a String DEFAULT 1 +) ENGINE = Memory", CodeClickHouseSQLUnparseable},
-		// Rejected outright rather than classified.
+		// The parser still dereferences nil on a DEFAULT expression it cannot read, so the recover is what turns this into a rejection rather than a crash.
+		{"UnparseableDefaultExpression", "CREATE TABLE t (a String DEFAULT foo(b FROM 2)) ENGINE = Memory", CodeClickHouseSQLParserPanic},
+		// These the parser rejects outright rather than classifying.
 		{"ShowGrants", "SHOW GRANTS", CodeClickHouseSQLUnparseable},
 		{"IntoOutfile", "SELECT * FROM t INTO OUTFILE '/tmp/x.csv'", CodeClickHouseSQLUnparseable},
+		// Table functions, which read through something other than a telemetry table.
 		{"UrlTableFunction", "SELECT * FROM url('http://attacker.example/x', CSV, 'a String')", CodeClickHouseSQLTableFunction},
-		// file is also a scalar function, so the reading rule reaches it before the table rule does.
-		{"FileTableFunction", "SELECT * FROM file('/etc/passwd', CSV, 'a String')", CodeClickHouseSQLReadingFunction},
+		{"FileTableFunction", "SELECT * FROM file('/etc/passwd', CSV, 'a String')", CodeClickHouseSQLTableFunction},
 		{"ExecutableTableFunction", "SELECT * FROM executable('script.sh', CSV, 'a String')", CodeClickHouseSQLTableFunction},
 		{"TableFunctionInJoin", "SELECT * FROM t1 JOIN url('http://x', CSV, 'a String') u ON 1 = 1", CodeClickHouseSQLTableFunction},
 		{"TableFunctionInCommonTableExpression", "WITH c AS (SELECT * FROM url('http://x', CSV, 'a String')) SELECT * FROM c", CodeClickHouseSQLTableFunction},
-		{"TableFunctionInWhereSubquery", "SELECT * FROM t WHERE a IN (SELECT * FROM url('http://x', CSV, 'a String'))", CodeClickHouseSQLTableFunction},
+		{"TableFunctionInWhereSubquery", "SELECT * FROM t WHERE a IN (SELECT * FROM file('/etc/passwd', CSV, 'a String'))", CodeClickHouseSQLTableFunction},
 		{"TableFunctionInUnion", "SELECT * FROM t UNION ALL SELECT * FROM url('http://x', CSV, 'a String')", CodeClickHouseSQLTableFunction},
-		// Reach an internal database without naming one, so only the table-function rule sees them.
+		// These reach the internal databases without ever naming one, so the table-function rule is the only thing that sees them.
 		{"MergeTableFunction", "SELECT * FROM merge('system', '.*')", CodeClickHouseSQLTableFunction},
 		{"RemoteTableFunction", "SELECT * FROM remote('other-host', 'system.users')", CodeClickHouseSQLTableFunction},
 		{"ClusterTableFunction", "SELECT * FROM cluster('c', 'system.users')", CodeClickHouseSQLTableFunction},
-		// Pure, but excluded: generateRandom is unbounded, and values adds nothing over an array literal.
+		// Pure, but excluded: generateRandom streams rows the arguments do not bound, and values has no use here that an array literal does not already cover.
 		{"GenerateRandomTableFunction", "SELECT * FROM generateRandom('a UInt64')", CodeClickHouseSQLTableFunction},
 		{"ValuesTableFunction", "SELECT * FROM values('a UInt64', 1, 2)", CodeClickHouseSQLTableFunction},
-		// Arguments are visited first, so an allowed generator is not a wrapper to smuggle a read through.
+		// Arguments are visited before the table function itself, so allowing a generator does not give anyone a wrapper to smuggle a read through.
 		{"InternalDatabaseInsideAllowedTableFunction", "SELECT * FROM numbers((SELECT count() FROM system.users))", CodeClickHouseSQLInternalDatabase},
 		{"InternalDatabaseJoinedOntoAllowedTableFunction", "SELECT * FROM numbers(31) AS n JOIN system.users AS u ON 1 = 1", CodeClickHouseSQLInternalDatabase},
 		{"InternalDatabaseUnionedWithAllowedTableFunction", "SELECT number FROM numbers(31) UNION ALL SELECT name FROM system.users", CodeClickHouseSQLInternalDatabase},
 		{"RefusedTableFunctionJoinedOntoAllowedTableFunction", "SELECT * FROM numbers(31) AS n JOIN url('http://x', CSV, 'a String') AS u ON 1 = 1", CodeClickHouseSQLTableFunction},
-		{"RefusedTableFunctionInsideAllowedTableFunction", "SELECT * FROM numbers((SELECT count() FROM url('http://x', CSV, 'a String')))", CodeClickHouseSQLTableFunction},
+		{"RefusedTableFunctionInsideAllowedTableFunction", "SELECT * FROM numbers((SELECT count() FROM file('/etc/passwd', CSV, 'a String')))", CodeClickHouseSQLTableFunction},
 		{"InternalDatabaseInsideAllowedTableFunctionCommonTableExpression", "WITH axis AS (SELECT * FROM numbers((SELECT count() FROM system.users))) SELECT * FROM axis", CodeClickHouseSQLInternalDatabase},
-		// Read a file, a dictionary or the server binary without naming a table, so neither the table rule nor the database rule sees them. The row count alone is an oracle: numbers(length(file(x))) returns one row per byte.
-		{"ScalarFileFunction", "SELECT file('/etc/passwd')", CodeClickHouseSQLReadingFunction},
-		{"ScalarFileFunctionInWhere", "SELECT * FROM t WHERE length(file('/etc/passwd')) > 0", CodeClickHouseSQLReadingFunction},
-		{"ScalarFileFunctionInGeneratorTableFunctionArgument", "SELECT * FROM numbers(length(file('/etc/passwd')))", CodeClickHouseSQLReadingFunction},
-		{"DictionaryFunction", "SELECT dictGetUInt64('d', 'k', toUInt64(1))", CodeClickHouseSQLReadingFunction},
-		{"DictionaryFunctionUppercase", "SELECT DICTGETSTRING('d', 'k', toUInt64(1))", CodeClickHouseSQLReadingFunction},
-		{"DictionaryFunctionInGeneratorTableFunctionArgument", "SELECT * FROM numbers(dictGetUInt64('d', 'k', toUInt64(1)))", CodeClickHouseSQLReadingFunction},
-		{"IntrospectionFunction", "SELECT demangle(addressToSymbol(toUInt64(1)))", CodeClickHouseSQLReadingFunction},
-		{"ModelEvaluationFunction", "SELECT catboostEvaluate('/model.bin', 1)", CodeClickHouseSQLReadingFunction},
-		// ClickHouse reads `x IN table` as `x IN (SELECT * FROM table)`, and a qualified name there is a Path rather than a TableIdentifier.
-		{"InternalDatabaseInInOperator", "SELECT * FROM t WHERE a IN system.users", CodeClickHouseSQLInternalDatabase},
-		{"InternalDatabaseInGlobalInOperator", "SELECT * FROM t WHERE a GLOBAL IN system.users", CodeClickHouseSQLInternalDatabase},
-		{"InternalDatabaseInNotInOperator", "SELECT * FROM t WHERE a NOT IN system.users", CodeClickHouseSQLInternalDatabase},
+		// Internal databases, which hold grants and server metadata rather than telemetry.
 		{"SystemUsers", "SELECT * FROM system.users", CodeClickHouseSQLInternalDatabase},
 		{"SystemUppercase", "SELECT * FROM SYSTEM.USERS", CodeClickHouseSQLInternalDatabase},
 		{"SystemQuoted", "SELECT count() FROM `system`.`tables`", CodeClickHouseSQLInternalDatabase},
@@ -161,7 +139,7 @@ func TestErrIfStatementIsNotValid_Fail(t *testing.T) {
 		{"SystemInJoin", "SELECT * FROM signoz_logs.distributed_logs_v2 AS l JOIN system.users AS u ON 1 = 1", CodeClickHouseSQLInternalDatabase},
 		{"SystemInIntersect", "SELECT * FROM t INTERSECT SELECT * FROM system.users", CodeClickHouseSQLInternalDatabase},
 		{"InformationSchema", "SELECT * FROM information_schema.tables", CodeClickHouseSQLInternalDatabase},
-		// Takes precedence over the setting the caller applies.
+		// A query-level setting takes precedence over the one the caller applies.
 		{"ReadonlySettingOverride", "SELECT * FROM t SETTINGS readonly = 0", CodeClickHouseSQLReadonlyOverride},
 		{"ReadonlySettingOverrideAmongOthers", "SELECT * FROM t SETTINGS max_threads = 4, readonly = 0", CodeClickHouseSQLReadonlyOverride},
 	}
@@ -170,33 +148,7 @@ func TestErrIfStatementIsNotValid_Fail(t *testing.T) {
 		t.Run(testCase.name, func(t *testing.T) {
 			err := ErrIfStatementIsNotValid(testCase.query)
 
-			// Required rather than asserted: errors.Asc dereferences the error it is given.
-			require.Error(t, err)
-			assert.True(t, errors.Asc(err, testCase.expectedCode), "expected code %s, got %v", testCase.expectedCode, err)
-		})
-	}
-}
-
-func TestErrIfStatementIsNotValid_ShouldPassButFails(t *testing.T) {
-	testCases := []struct {
-		name         string
-		query        string
-		expectedCode errors.Code
-	}{
-		// The left operand commits the parser to a subquery, leaving the operator nowhere to bind. Parenthesising only the right operand is fine.
-		{"ParenthesisedUnionLeftOperand", "SELECT a FROM ((SELECT 1 AS a) UNION ALL (SELECT 2 AS a))", CodeClickHouseSQLUnparseable},
-		{"ParenthesisedExceptLeftOperand", "SELECT a FROM ((SELECT 1 AS a) EXCEPT (SELECT 2 AS a))", CodeClickHouseSQLUnparseable},
-		{"ParenthesisedUnionLeftOperandAtStatementLevel", "(SELECT 1 AS a) UNION ALL (SELECT 2 AS a)", CodeClickHouseSQLUnparseable},
-		// The one keyword PR 305 left behind, because ON also opens a join condition.
-		{"UnquotedOnAsColumnName", "SELECT on + 1 FROM t", CodeClickHouseSQLUnparseable},
-	}
-
-	for _, testCase := range testCases {
-		t.Run(testCase.name, func(t *testing.T) {
-			err := ErrIfStatementIsNotValid(testCase.query)
-
-			// Required rather than asserted: errors.Asc dereferences the error it is given.
-			require.Error(t, err)
+			assert.Error(t, err)
 			assert.True(t, errors.Asc(err, testCase.expectedCode), "expected code %s, got %v", testCase.expectedCode, err)
 		})
 	}

pkg/querybuilder/where_clause_visitor.go

@@ -10,6 +10,7 @@ import (
 
 	"github.com/SigNoz/signoz/pkg/errors"
 	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"
@@ -982,25 +983,78 @@ func assignIfEmpty(s *string, value string) {
 // 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{}
+	selector := telemetrytypes.FieldKeySelector{
+		Name:         field.Name,
+		Signal:       field.Signal,
+		FieldContext: field.FieldContext,
+	}
+	members := semconv.Members(semconv.KindAttribute, selector)
+	isFamily := len(members) > 1
+	fieldKeysForName := make([]*telemetrytypes.TelemetryFieldKey, 0)
+	indexByIdentity := make(map[string]int)
 
-	// 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)
+	appendMatches := func(lookupName string, memberName string, contextAlreadyMatched bool) {
+		for _, item := range fieldKeys[lookupName] {
+			if !contextAlreadyMatched && field.FieldContext != telemetrytypes.FieldContextUnspecified && field.FieldContext != item.FieldContext {
+				continue
+			}
+			if field.FieldDataType != telemetrytypes.FieldDataTypeUnspecified && field.FieldDataType != item.FieldDataType {
+				continue
+			}
+
+			// A wildcard lookup may have found a same-named field in a scope where
+			// this family does not apply. Keep exact names, but reject cross-member
+			// matches outside the generated family scope.
+			if memberName != field.Name {
+				itemSelector := telemetrytypes.FieldKeySelector{
+					Name:         field.Name,
+					Signal:       item.Signal,
+					FieldContext: item.FieldContext,
+				}
+				if !slices.Contains(semconv.Members(semconv.KindAttribute, itemSelector), memberName) {
+					continue
+				}
+			}
+
+			physicalMembers := item.SemconvMembers
+			if len(physicalMembers) == 0 {
+				physicalMembers = []string{memberName}
+			}
+			identity := item.Signal.StringValue() + ";" + item.FieldContext.StringValue() + ";" + item.FieldDataType.StringValue()
+			if isFamily {
+				if index, found := indexByIdentity[identity]; found {
+					for _, physicalMember := range physicalMembers {
+						if !slices.Contains(fieldKeysForName[index].SemconvMembers, physicalMember) {
+							fieldKeysForName[index].SemconvMembers = append(fieldKeysForName[index].SemconvMembers, physicalMember)
+						}
+					}
+					continue
+				}
+				indexByIdentity[identity] = len(fieldKeysForName)
+			}
+			resolved := *item
+			// The requested spelling is the response identity. Field mappers use
+			// it to resolve the available family members current-first.
+			if isFamily {
+				resolved.Name = field.Name
+				resolved.SemconvMembers = slices.Clone(physicalMembers)
+			}
+			fieldKeysForName = append(fieldKeysForName, &resolved)
 		}
 	}
 
-	// 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.
+	// Members are current-first, so metadata from the current key wins when
+	// both spellings describe the same signal/context/type.
+	for _, member := range members {
+		appendMatches(member, member, false)
+	}
+
+	// A context may have been split off a name that legitimately contained it
+	// (e.g. `attribute.key`); preserve that historical alternate reading for
+	// every family member.
 	if field.FieldContext != telemetrytypes.FieldContextUnspecified {
-		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)
-			}
+		for _, member := range members {
+			appendMatches(fmt.Sprintf("%s.%s", field.FieldContext.StringValue(), member), member, true)
 		}
 	}
 

pkg/querybuilder/where_clause_visitor_test.go

@@ -14,6 +14,7 @@ import (
 	"github.com/antlr4-go/antlr/v4"
 	sqlbuilder "github.com/huandu/go-sqlbuilder"
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 // TestPrepareWhereClause_EmptyVariableList ensures PrepareWhereClause errors when a variable has an empty list value.
@@ -685,6 +686,53 @@ func TestVisitKey(t *testing.T) {
 	}
 }
 
+func TestMatchingFieldKeysResolvesSemconvFamily(t *testing.T) {
+	current := &telemetrytypes.TelemetryFieldKey{
+		Name:          "deployment.environment.name",
+		Description:   "current metadata",
+		Signal:        telemetrytypes.SignalTraces,
+		FieldContext:  telemetrytypes.FieldContextResource,
+		FieldDataType: telemetrytypes.FieldDataTypeString,
+	}
+	old := &telemetrytypes.TelemetryFieldKey{
+		Name:          "deployment.environment",
+		Description:   "old metadata",
+		Signal:        telemetrytypes.SignalTraces,
+		FieldContext:  telemetrytypes.FieldContextResource,
+		FieldDataType: telemetrytypes.FieldDataTypeString,
+	}
+	fieldKeys := map[string][]*telemetrytypes.TelemetryFieldKey{
+		current.Name: {current},
+		old.Name:     {old},
+	}
+
+	for _, requestedName := range []string{current.Name, old.Name} {
+		requested := telemetrytypes.NewTelemetryFieldKey(
+			requestedName,
+			telemetrytypes.FieldContextResource,
+			telemetrytypes.FieldDataTypeString,
+		)
+		matches := MatchingFieldKeys(requested, fieldKeys)
+		require.Len(t, matches, 1, "family lookup must return one field before its metadata is inspected")
+		assert.Equal(t, requestedName, matches[0].Name)
+		assert.Equal(t, "current metadata", matches[0].Description)
+		assert.Equal(t, []string{current.Name, old.Name}, matches[0].SemconvMembers)
+	}
+
+	// A current-name query still resolves when metadata has seen only the old
+	// spelling. The returned name remains the request identity.
+	requested := telemetrytypes.NewTelemetryFieldKey(
+		current.Name,
+		telemetrytypes.FieldContextResource,
+		telemetrytypes.FieldDataTypeString,
+	)
+	matches := MatchingFieldKeys(requested, map[string][]*telemetrytypes.TelemetryFieldKey{old.Name: {old}})
+	require.Len(t, matches, 1, "family lookup must return one field before its metadata is inspected")
+	assert.Equal(t, current.Name, matches[0].Name)
+	assert.Equal(t, "old metadata", matches[0].Description)
+	assert.Equal(t, []string{old.Name}, matches[0].SemconvMembers)
+}
+
 // ---------------------------------------------------------------------------
 // TestVisitComparison
 // ---------------------------------------------------------------------------

pkg/semconv/families_gen.go

@@ -0,0 +1,22 @@
+// Code generated by scripts/semconv. DO NOT EDIT.
+
+package semconv
+
+var families = []Family{
+	{
+		Current:        "db.system.name",
+		Old:            []string{"db.system"},
+		Kind:           KindAttribute,
+		Contexts:       nil,
+		Signals:        nil,
+		ApplyToMetrics: nil,
+	},
+	{
+		Current:        "deployment.environment.name",
+		Old:            []string{"deployment.environment"},
+		Kind:           KindAttribute,
+		Contexts:       nil,
+		Signals:        nil,
+		ApplyToMetrics: nil,
+	},
+}

pkg/semconv/semconv.go

@@ -0,0 +1,127 @@
+package semconv
+
+import (
+	"slices"
+
+	"github.com/SigNoz/signoz/pkg/types/telemetrytypes"
+	"github.com/SigNoz/signoz/pkg/valuer"
+)
+
+//go:generate go run ../../scripts/semconv
+
+// Kind identifies whether a family describes an attribute or a metric name.
+type Kind struct {
+	valuer.String
+}
+
+// Family is one logical telemetry field. Old is ordered from the most recent
+// predecessor to the oldest one and therefore also defines fallback order.
+type Family struct {
+	Current        string
+	Old            []string
+	Kind           Kind
+	Contexts       []telemetrytypes.FieldContext
+	Signals        []telemetrytypes.Signal
+	ApplyToMetrics []string
+	ValueMap       map[string]string
+}
+
+var (
+	KindAttribute = Kind{String: valuer.NewString("attribute")}
+	KindMetric    = Kind{String: valuer.NewString("metric")}
+)
+
+var memberToFamilies, familyMembers = buildIndexes()
+
+// Enum returns the acceptable values for Kind.
+func (Kind) Enum() []any {
+	return []any{KindAttribute, KindMetric}
+}
+
+// Lookup returns the enabled family containing selector.Name for kind. The
+// returned family must not be modified.
+func Lookup(kind Kind, selector telemetrytypes.FieldKeySelector) (Family, bool) {
+	idx, ok := lookupIndex(kind, selector)
+	if !ok {
+		return Family{}, false
+	}
+	return families[idx], true
+}
+
+// Members returns the current name first, followed by historical names in
+// fallback order. A name outside an enabled family is returned unchanged. The
+// returned slice must not be modified.
+func Members(kind Kind, selector telemetrytypes.FieldKeySelector) []string {
+	idx, ok := lookupIndex(kind, selector)
+	if !ok {
+		return []string{selector.Name}
+	}
+	return familyMembers[idx]
+}
+
+// Current returns the current name for selector.Name, or the input name when
+// it does not belong to an enabled family.
+func Current(kind Kind, selector telemetrytypes.FieldKeySelector) string {
+	idx, ok := lookupIndex(kind, selector)
+	if !ok {
+		return selector.Name
+	}
+	return families[idx].Current
+}
+
+// All returns every enabled family. The returned slice and families must not be
+// modified.
+func All() []Family {
+	return families
+}
+
+func buildIndexes() (map[string][]int, [][]string) {
+	index := make(map[string][]int)
+	members := make([][]string, len(families))
+	for i, family := range families {
+		members[i] = make([]string, 0, len(family.Old)+1)
+		members[i] = append(members[i], family.Current)
+		members[i] = append(members[i], family.Old...)
+		index[family.Current] = append(index[family.Current], i)
+		for _, old := range family.Old {
+			index[old] = append(index[old], i)
+		}
+	}
+	return index, members
+}
+
+func lookupIndex(kind Kind, selector telemetrytypes.FieldKeySelector) (int, bool) {
+	for _, idx := range memberToFamilies[selector.Name] {
+		if matchesSelector(families[idx], kind, selector) {
+			return idx, true
+		}
+	}
+	return 0, false
+}
+
+func matchesSelector(family Family, kind Kind, selector telemetrytypes.FieldKeySelector) bool {
+	if family.Kind != kind {
+		return false
+	}
+
+	if selector.Signal != telemetrytypes.SignalUnspecified && len(family.Signals) > 0 {
+		if !slices.Contains(family.Signals, selector.Signal) {
+			return false
+		}
+	}
+
+	if selector.FieldContext != telemetrytypes.FieldContextUnspecified && len(family.Contexts) > 0 {
+		if !slices.Contains(family.Contexts, selector.FieldContext) {
+			return false
+		}
+	}
+
+	if selector.Signal == telemetrytypes.SignalMetrics && len(family.ApplyToMetrics) > 0 {
+		if selector.MetricContext == nil {
+			return false
+		}
+		return slices.Contains(family.ApplyToMetrics, selector.MetricContext.MetricName)
+	}
+
+	return true
+}

pkg/semconv/semconv_test.go

@@ -0,0 +1,49 @@
+package semconv
+
+import (
+	"testing"
+
+	"github.com/SigNoz/signoz/pkg/types/telemetrytypes"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestMembersReturnsCurrentBeforeHistoricalName(t *testing.T) {
+	selector := telemetrytypes.FieldKeySelector{
+		Name:         "deployment.environment",
+		Signal:       telemetrytypes.SignalTraces,
+		FieldContext: telemetrytypes.FieldContextResource,
+	}
+
+	assert.Equal(t,
+		[]string{"deployment.environment.name", "deployment.environment"},
+		Members(KindAttribute, selector),
+		"members should use current-first fallback order",
+	)
+}
+
+func TestCurrentReturnsCanonicalName(t *testing.T) {
+	selector := telemetrytypes.FieldKeySelector{
+		Name:         "deployment.environment",
+		Signal:       telemetrytypes.SignalTraces,
+		FieldContext: telemetrytypes.FieldContextResource,
+	}
+
+	assert.Equal(t,
+		"deployment.environment.name",
+		Current(KindAttribute, selector),
+		"historical name should resolve to the current family name",
+	)
+}
+
+func TestMembersReturnsInputWhenKindDoesNotMatch(t *testing.T) {
+	selector := telemetrytypes.FieldKeySelector{
+		Name:   "deployment.environment",
+		Signal: telemetrytypes.SignalTraces,
+	}
+
+	assert.Equal(t,
+		[]string{"deployment.environment"},
+		Members(KindMetric, selector),
+		"an attribute family must not match a metric-name lookup",
+	)
+}

pkg/signoz/provider.go

@@ -235,6 +235,7 @@ func NewSQLMigrationProviderFactories(
 		sqlmigration.NewFillDashboardSpecCollectionsFactory(sqlstore, dashboardStore),
 		sqlmigration.NewScrubEmailChannelTransportFactory(sqlstore),
 		sqlmigration.NewAddDashboardTuplesFactory(sqlstore),
+		sqlmigration.NewMigrateDeploymentEnvironmentQuickFilterFactory(),
 	)
 }
 

pkg/sqlmigration/108_migrate_deployment_environment_quick_filter.go

@@ -0,0 +1,127 @@
+package sqlmigration
+
+import (
+	"context"
+	"encoding/json"
+	"log/slog"
+	"time"
+
+	"github.com/SigNoz/signoz/pkg/factory"
+	"github.com/SigNoz/signoz/pkg/semconv"
+	"github.com/SigNoz/signoz/pkg/types/telemetrytypes"
+	"github.com/uptrace/bun"
+	"github.com/uptrace/bun/migrate"
+)
+
+const deploymentEnvironmentCurrent = "deployment.environment.name"
+
+type migrateDeploymentEnvironmentQuickFilter struct {
+	logger *slog.Logger
+}
+
+type semconvQuickFilterRow struct {
+	bun.BaseModel `bun:"table:quick_filter"`
+
+	ID     string `bun:"id"`
+	Filter string `bun:"filter"`
+}
+
+func NewMigrateDeploymentEnvironmentQuickFilterFactory() factory.ProviderFactory[SQLMigration, Config] {
+	return factory.NewProviderFactory(
+		factory.MustNewName("migrate_semconv_quick_filter"),
+		func(_ context.Context, settings factory.ProviderSettings, _ Config) (SQLMigration, error) {
+			return &migrateDeploymentEnvironmentQuickFilter{logger: settings.Logger}, nil
+		},
+	)
+}
+
+func (migration *migrateDeploymentEnvironmentQuickFilter) Register(migrations *migrate.Migrations) error {
+	return migrations.Register(migration.Up, migration.Down)
+}
+
+func deploymentEnvironmentOld() string {
+	members := semconv.Members(semconv.KindAttribute, telemetrytypes.FieldKeySelector{
+		Name:         deploymentEnvironmentCurrent,
+		Signal:       telemetrytypes.SignalTraces,
+		FieldContext: telemetrytypes.FieldContextResource,
+	})
+	if len(members) < 2 {
+		return deploymentEnvironmentCurrent
+	}
+	return members[1]
+}
+
+func rewriteQuickFilterSemconv(filterJSON, from, to string) (string, bool, error) {
+	var filters []map[string]any
+	if err := json.Unmarshal([]byte(filterJSON), &filters); err != nil {
+		return "", false, err
+	}
+
+	changed := false
+	for _, filter := range filters {
+		if key, ok := filter["key"].(string); ok && key == from {
+			filter["key"] = to
+			changed = true
+		}
+	}
+	if !changed {
+		return filterJSON, false, nil
+	}
+
+	rewritten, err := json.Marshal(filters)
+	if err != nil {
+		return "", false, err
+	}
+	return string(rewritten), true, nil
+}
+
+func (migration *migrateDeploymentEnvironmentQuickFilter) migrate(ctx context.Context, db *bun.DB, from, to string) error {
+	tx, err := db.BeginTx(ctx, nil)
+	if err != nil {
+		return err
+	}
+	defer func() { _ = tx.Rollback() }()
+
+	rows := make([]*semconvQuickFilterRow, 0)
+	if err := tx.NewSelect().
+		Model(&rows).
+		Where("signal IN (?)", bun.In([]string{"traces", "api_monitoring", "exceptions"})).
+		Scan(ctx); err != nil {
+		return err
+	}
+
+	for _, row := range rows {
+		rewritten, changed, err := rewriteQuickFilterSemconv(row.Filter, from, to)
+		if err != nil {
+			// Quick filters are user-editable. One malformed legacy row must not
+			// prevent the application from starting or block every other org's
+			// migration.
+			if migration.logger != nil {
+				migration.logger.WarnContext(ctx, "skipping quick filter with unreadable filter JSON",
+					slog.String("quick_filter_id", row.ID), slog.Any("error", err))
+			}
+			continue
+		}
+		if !changed {
+			continue
+		}
+		if _, err := tx.NewUpdate().
+			Model((*semconvQuickFilterRow)(nil)).
+			Set("filter = ?", rewritten).
+			Set("updated_at = ?", time.Now()).
+			Where("id = ?", row.ID).
+			Exec(ctx); err != nil {
+			return err
+		}
+	}
+
+	return tx.Commit()
+}
+
+func (migration *migrateDeploymentEnvironmentQuickFilter) Up(ctx context.Context, db *bun.DB) error {
+	return migration.migrate(ctx, db, deploymentEnvironmentOld(), deploymentEnvironmentCurrent)
+}
+
+func (migration *migrateDeploymentEnvironmentQuickFilter) Down(ctx context.Context, db *bun.DB) error {
+	return migration.migrate(ctx, db, deploymentEnvironmentCurrent, deploymentEnvironmentOld())
+}

pkg/sqlmigration/108_migrate_deployment_environment_quick_filter_test.go

@@ -0,0 +1,38 @@
+package sqlmigration
+
+import (
+	"encoding/json"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestRewriteQuickFilterSemconv(t *testing.T) {
+	oldName := deploymentEnvironmentOld()
+	input := `[{"key":"service.name","dataType":"string","type":"resource"},{"key":"` + oldName + `","dataType":"string","type":"resource","custom":true}]`
+
+	rewritten, changed, err := rewriteQuickFilterSemconv(input, oldName, deploymentEnvironmentCurrent)
+	require.NoError(t, err)
+	assert.True(t, changed)
+
+	var filters []map[string]any
+	require.NoError(t, json.Unmarshal([]byte(rewritten), &filters))
+	assert.Equal(t, "service.name", filters[0]["key"])
+	assert.Equal(t, deploymentEnvironmentCurrent, filters[1]["key"])
+	assert.Equal(t, true, filters[1]["custom"], "unknown filter properties must be preserved")
+
+	restored, changed, err := rewriteQuickFilterSemconv(rewritten, deploymentEnvironmentCurrent, oldName)
+	require.NoError(t, err)
+	assert.True(t, changed)
+	require.NoError(t, json.Unmarshal([]byte(restored), &filters))
+	assert.Equal(t, oldName, filters[1]["key"])
+}
+
+func TestRewriteQuickFilterSemconvNoop(t *testing.T) {
+	input := `[{"key":"service.name","dataType":"string","type":"resource"}]`
+	rewritten, changed, err := rewriteQuickFilterSemconv(input, deploymentEnvironmentOld(), deploymentEnvironmentCurrent)
+	require.NoError(t, err)
+	assert.False(t, changed)
+	assert.Equal(t, input, rewritten)
+}

pkg/statementbuilder/resourcefilter/condition_builder.go

@@ -44,6 +44,73 @@ func keyIndexFilter(key *telemetrytypes.TelemetryFieldKey) any {
 	return fmt.Sprintf(`%%%s%%`, key.Name)
 }
 
+func memberKey(key *telemetrytypes.TelemetryFieldKey, name string) *telemetrytypes.TelemetryFieldKey {
+	member := *key
+	member.Name = name
+	return &member
+}
+
+func keyIndexCondition(sb *sqlbuilder.SelectBuilder, column string, key *telemetrytypes.TelemetryFieldKey, members []string) string {
+	conditions := make([]string, 0, len(members))
+	for _, member := range members {
+		conditions = append(conditions, sb.Like(column, keyIndexFilter(memberKey(key, member))))
+	}
+	if len(conditions) == 1 {
+		return conditions[0]
+	}
+	return sb.Or(conditions...)
+}
+
+func valueIndexCondition(
+	sb *sqlbuilder.SelectBuilder,
+	column string,
+	key *telemetrytypes.TelemetryFieldKey,
+	members []string,
+	op qbtypes.FilterOperator,
+	value any,
+	caseInsensitive bool,
+) string {
+	conditions := make([]string, 0, len(members))
+	for _, member := range members {
+		patterns := valueForIndexFilter(op, memberKey(key, 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 []string, exists bool) string {
+	conditions := make([]string, 0, len(members))
+	for _, member := range members {
+		field := fmt.Sprintf("simpleJSONHas(%s, '%s')", column, member)
+		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,
@@ -115,8 +182,10 @@ func (b *defaultConditionBuilder) conditionForKey(
 	// as we have not changed the resource column in the resource fingerprint table.
 	column := columns[0]
 
-	keyIdxFilter := sb.Like(column.Name, keyIndexFilter(key))
-	valueForIndexFilter := valueForIndexFilter(op, key, value)
+	members := resourceSemconvMembers(key)
+	isFamily := len(members) > 1
+	keyIdxFilter := keyIndexCondition(sb, column.Name, key, members)
+	singleValueIndexFilter := valueForIndexFilter(op, memberKey(key, members[0]), value)
 
 	fieldName, err := b.fm.FieldFor(ctx, valuer.UUID{}, startNs, endNs, key)
 	if err != nil {
@@ -128,12 +197,15 @@ func (b *defaultConditionBuilder) conditionForKey(
 		return sb.And(
 			sb.E(fieldName, formattedValue),
 			keyIdxFilter,
-			sb.Like(column.Name, valueForIndexFilter),
+			valueIndexCondition(sb, column.Name, key, members, op, value, false),
 		), nil
 	case qbtypes.FilterOperatorNotEqual:
+		if isFamily {
+			return sb.NE(fieldName, formattedValue), nil
+		}
 		return sb.And(
 			sb.NE(fieldName, formattedValue),
-			sb.NotLike(column.Name, valueForIndexFilter),
+			sb.NotLike(column.Name, singleValueIndexFilter),
 		), nil
 	case qbtypes.FilterOperatorGreaterThan:
 		return sb.And(sb.GT(fieldName, formattedValue), keyIdxFilter), nil
@@ -148,7 +220,7 @@ func (b *defaultConditionBuilder) conditionForKey(
 		return sb.And(
 			sb.ILike(fieldName, formattedValue),
 			keyIdxFilter,
-			sb.ILike(column.Name, valueForIndexFilter),
+			valueIndexCondition(sb, column.Name, key, members, op, value, true),
 		), nil
 	case qbtypes.FilterOperatorNotLike, qbtypes.FilterOperatorNotILike:
 		// no index filter: as cannot apply `not contains x%y` as y can be somewhere else
@@ -185,13 +257,11 @@ func (b *defaultConditionBuilder) conditionForKey(
 			inConditions = append(inConditions, sb.E(fieldName, querybuilder.FormatValueForContains(v)))
 		}
 		mainCondition := sb.Or(inConditions...)
-		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...))
+		mainCondition = sb.And(
+			mainCondition,
+			keyIdxFilter,
+			valueIndexCondition(sb, column.Name, key, members, op, value, false),
+		)
 
 		return mainCondition, nil
 	case qbtypes.FilterOperatorNotIn:
@@ -204,8 +274,11 @@ func (b *defaultConditionBuilder) conditionForKey(
 			notInConditions = append(notInConditions, sb.NE(fieldName, querybuilder.FormatValueForContains(v)))
 		}
 		mainCondition := sb.And(notInConditions...)
+		if isFamily {
+			return mainCondition, nil
+		}
 		valConditions := make([]string, 0, len(values))
-		if valuesForIndexFilter, ok := valueForIndexFilter.([]string); ok {
+		if valuesForIndexFilter, ok := singleValueIndexFilter.([]string); ok {
 			for _, v := range valuesForIndexFilter {
 				valConditions = append(valConditions, sb.NotLike(column.Name, v))
 			}
@@ -215,13 +288,11 @@ func (b *defaultConditionBuilder) conditionForKey(
 
 	case qbtypes.FilterOperatorExists:
 		return sb.And(
-			sb.E(fmt.Sprintf("simpleJSONHas(%s, '%s')", column.Name, key.Name), true),
+			memberPresenceCondition(sb, column.Name, members, true),
 			keyIdxFilter,
 		), nil
 	case qbtypes.FilterOperatorNotExists:
-		return sb.And(
-			sb.NE(fmt.Sprintf("simpleJSONHas(%s, '%s')", column.Name, key.Name), true),
-		), nil
+		return memberPresenceCondition(sb, column.Name, members, false), nil
 
 	case qbtypes.FilterOperatorRegexp:
 		return sb.And(
@@ -237,7 +308,7 @@ func (b *defaultConditionBuilder) conditionForKey(
 		return sb.And(
 			sb.ILike(fieldName, fmt.Sprintf(`%%%s%%`, formattedValue)),
 			keyIdxFilter,
-			sb.ILike(column.Name, valueForIndexFilter),
+			valueIndexCondition(sb, column.Name, key, members, op, value, true),
 		), 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

@@ -198,6 +198,75 @@ func TestConditionBuilder(t *testing.T) {
 			expected:     "match(simpleJSONExtractString(labels, 'k8s.namespace.name'), ?) AND labels LIKE ?",
 			expectedArgs: []any{"ban.*", "%k8s.namespace.name%"},
 		},
+		{
+			name: "semantic convention family equality uses current-first fallback",
+			key: &telemetrytypes.TelemetryFieldKey{
+				Name:           "deployment.environment.name",
+				FieldContext:   telemetrytypes.FieldContextResource,
+				FieldDataType:  telemetrytypes.FieldDataTypeString,
+				SemconvMembers: []string{"deployment.environment.name", "deployment.environment"},
+			},
+			op:       qbtypes.FilterOperatorEqual,
+			value:    "production",
+			expected: "COALESCE(NULLIF(simpleJSONExtractString(labels, 'deployment.environment.name'), ''), NULLIF(simpleJSONExtractString(labels, 'deployment.environment'), '')) = ? AND (labels LIKE ? OR labels LIKE ?) AND (labels LIKE ? OR labels LIKE ?)",
+			expectedArgs: []any{
+				"production",
+				"%deployment.environment.name%",
+				"%deployment.environment%",
+				`%deployment.environment.name":"production%`,
+				`%deployment.environment":"production%`,
+			},
+		},
+		{
+			name: "old semantic convention request uses only current metadata member",
+			key: &telemetrytypes.TelemetryFieldKey{
+				Name:           "deployment.environment",
+				FieldContext:   telemetrytypes.FieldContextResource,
+				FieldDataType:  telemetrytypes.FieldDataTypeString,
+				SemconvMembers: []string{"deployment.environment.name"},
+			},
+			op:           qbtypes.FilterOperatorEqual,
+			value:        "production",
+			expected:     "simpleJSONExtractString(labels, 'deployment.environment.name') = ? AND labels LIKE ? AND labels LIKE ?",
+			expectedArgs: []any{"production", "%deployment.environment.name%", `%deployment.environment.name":"production%`},
+		},
+		{
+			name: "semantic convention family negative filter does not reject fallback rows",
+			key: &telemetrytypes.TelemetryFieldKey{
+				Name:           "deployment.environment",
+				FieldContext:   telemetrytypes.FieldContextResource,
+				FieldDataType:  telemetrytypes.FieldDataTypeString,
+				SemconvMembers: []string{"deployment.environment.name", "deployment.environment"},
+			},
+			op:           qbtypes.FilterOperatorNotEqual,
+			value:        "staging",
+			expected:     "COALESCE(NULLIF(simpleJSONExtractString(labels, 'deployment.environment.name'), ''), NULLIF(simpleJSONExtractString(labels, 'deployment.environment'), '')) <> ?",
+			expectedArgs: []any{"staging"},
+		},
+		{
+			name: "semantic convention family exists checks every member",
+			key: &telemetrytypes.TelemetryFieldKey{
+				Name:           "deployment.environment.name",
+				FieldContext:   telemetrytypes.FieldContextResource,
+				FieldDataType:  telemetrytypes.FieldDataTypeString,
+				SemconvMembers: []string{"deployment.environment.name", "deployment.environment"},
+			},
+			op:           qbtypes.FilterOperatorExists,
+			expected:     "(simpleJSONHas(labels, 'deployment.environment.name') = ? OR simpleJSONHas(labels, 'deployment.environment') = ?) AND (labels LIKE ? OR labels LIKE ?)",
+			expectedArgs: []any{true, true, "%deployment.environment.name%", "%deployment.environment%"},
+		},
+		{
+			name: "semantic convention family not exists checks every member",
+			key: &telemetrytypes.TelemetryFieldKey{
+				Name:           "deployment.environment",
+				FieldContext:   telemetrytypes.FieldContextResource,
+				FieldDataType:  telemetrytypes.FieldDataTypeString,
+				SemconvMembers: []string{"deployment.environment.name", "deployment.environment"},
+			},
+			op:           qbtypes.FilterOperatorNotExists,
+			expected:     "(simpleJSONHas(labels, 'deployment.environment.name') <> ? AND simpleJSONHas(labels, 'deployment.environment') <> ?)",
+			expectedArgs: []any{true, true},
+		},
 	}
 
 	fm := NewFieldMapper()

pkg/statementbuilder/resourcefilter/field_mapper.go

@@ -3,8 +3,10 @@ package resourcefilter
 import (
 	"context"
 	"fmt"
+	"strings"
 
 	schema "github.com/SigNoz/signoz-otel-collector/cmd/signozschemamigrator/schema_migrator"
+	"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"
@@ -32,6 +34,20 @@ func NewFieldMapper() *defaultFieldMapper {
 	return &defaultFieldMapper{}
 }
 
+func resourceSemconvMembers(key *telemetrytypes.TelemetryFieldKey) []string {
+	if key.FieldContext != telemetrytypes.FieldContextResource {
+		return []string{key.Name}
+	}
+	if len(key.SemconvMembers) > 0 {
+		return key.SemconvMembers
+	}
+	return semconv.Members(semconv.KindAttribute, telemetrytypes.FieldKeySelector{
+		Name:         key.Name,
+		Signal:       telemetrytypes.SignalTraces,
+		FieldContext: telemetrytypes.FieldContextResource,
+	})
+}
+
 func (m *defaultFieldMapper) getColumn(
 	_ context.Context,
 	_, _ uint64,
@@ -66,7 +82,15 @@ func (m *defaultFieldMapper) FieldFor(
 		return "", err
 	}
 	if key.FieldContext == telemetrytypes.FieldContextResource {
-		return fmt.Sprintf("simpleJSONExtractString(%s, '%s')", columns[0].Name, key.Name), nil
+		members := resourceSemconvMembers(key)
+		if len(members) > 1 {
+			values := make([]string, 0, len(members))
+			for _, member := range members {
+				values = append(values, fmt.Sprintf("NULLIF(simpleJSONExtractString(%s, '%s'), '')", columns[0].Name, member))
+			}
+			return "COALESCE(" + strings.Join(values, ", ") + ")", nil
+		}
+		return fmt.Sprintf("simpleJSONExtractString(%s, '%s')", columns[0].Name, members[0]), nil
 	}
 	return columns[0].Name, nil
 }

pkg/telemetrymetadata/backward_compat_keys.go

@@ -1,35 +0,0 @@
-package telemetrymetadata
-
-import "github.com/SigNoz/signoz/pkg/types/telemetrytypes"
-
-type BackwardCompatibleKeyMap map[string]string
-
-var (
-	TracesBackwardCompatKeys = BackwardCompatibleKeyMap{
-		"net.peer.name":  "server.address",
-		"server.address": "net.peer.name",
-		"http.url":       "url.full",
-		"url.full":       "http.url",
-	}
-
-	// LogsBackwardCompatKeys contains bidirectional mappings for logs.
-	// Currently empty, can be extended in the future.
-	LogsBackwardCompatKeys = BackwardCompatibleKeyMap{}
-
-	// MetricsBackwardCompatKeys contains bidirectional mappings for metrics.
-	// Currently empty, can be extended in the future.
-	MetricsBackwardCompatKeys = BackwardCompatibleKeyMap{}
-)
-
-func GetBackwardCompatKeysForSignal(signal telemetrytypes.Signal) BackwardCompatibleKeyMap {
-	switch signal {
-	case telemetrytypes.SignalTraces:
-		return TracesBackwardCompatKeys
-	case telemetrytypes.SignalLogs:
-		return LogsBackwardCompatKeys
-	case telemetrytypes.SignalMetrics:
-		return MetricsBackwardCompatKeys
-	default:
-		return BackwardCompatibleKeyMap{}
-	}
-}

pkg/telemetrymetadata/metadata.go

@@ -4,6 +4,7 @@ import (
 	"context"
 	"fmt"
 	"log/slog"
+	"slices"
 	"strings"
 	"time"
 
@@ -14,6 +15,7 @@ import (
 	"github.com/SigNoz/signoz/pkg/factory"
 	"github.com/SigNoz/signoz/pkg/flagger"
 	"github.com/SigNoz/signoz/pkg/querybuilder"
+	"github.com/SigNoz/signoz/pkg/semconv"
 	"github.com/SigNoz/signoz/pkg/telemetryschema/audittelemetryschema"
 	"github.com/SigNoz/signoz/pkg/telemetryschema/logstelemetryschema"
 	"github.com/SigNoz/signoz/pkg/telemetryschema/metertelemetryschema"
@@ -151,6 +153,102 @@ func (t *telemetryMetaStore) tracesTblStatementToFieldKeys(ctx context.Context)
 	return materialisedKeys, nil
 }
 
+func traceSemconvMembers(name string, fieldContext telemetrytypes.FieldContext) []string {
+	return semconv.Members(semconv.KindAttribute, telemetrytypes.FieldKeySelector{
+		Name:         name,
+		Signal:       telemetrytypes.SignalTraces,
+		FieldContext: fieldContext,
+	})
+}
+
+func traceSemconvDuplicateFactor() int {
+	factor := 1
+	for _, family := range semconv.All() {
+		if family.Kind != semconv.KindAttribute {
+			continue
+		}
+		if _, ok := semconv.Lookup(semconv.KindAttribute, telemetrytypes.FieldKeySelector{
+			Name:   family.Current,
+			Signal: telemetrytypes.SignalTraces,
+		}); ok {
+			factor = max(factor, len(family.Old)+1)
+		}
+	}
+	return factor
+}
+
+// canonicalizeTraceSemconvKeys presents one current-name key for each family.
+// If metadata contains both spellings, metadata attached to the current name
+// wins; otherwise the old entry is copied under the current response name.
+func canonicalizeTraceSemconvKeys(keys []*telemetrytypes.TelemetryFieldKey) []*telemetrytypes.TelemetryFieldKey {
+	result := make([]*telemetrytypes.TelemetryFieldKey, 0, len(keys))
+	indexByIdentity := make(map[string]int)
+	currentSourceByIdentity := make(map[string]bool)
+
+	for _, key := range keys {
+		if key.Signal != telemetrytypes.SignalTraces {
+			result = append(result, key)
+			continue
+		}
+
+		family, ok := semconv.Lookup(semconv.KindAttribute, telemetrytypes.FieldKeySelector{
+			Name:         key.Name,
+			Signal:       telemetrytypes.SignalTraces,
+			FieldContext: key.FieldContext,
+		})
+		if !ok {
+			result = append(result, key)
+			continue
+		}
+
+		resolved := *key
+		resolved.Name = family.Current
+		resolved.SemconvMembers = []string{key.Name}
+		identity := resolved.Name + ";" + resolved.Signal.StringValue() + ";" + resolved.FieldContext.StringValue() + ";" + resolved.FieldDataType.StringValue()
+		fromCurrent := key.Name == family.Current
+
+		if index, found := indexByIdentity[identity]; found {
+			physicalMembers := result[index].SemconvMembers
+			if fromCurrent && !currentSourceByIdentity[identity] {
+				result[index] = &resolved
+				currentSourceByIdentity[identity] = true
+			}
+			for _, member := range physicalMembers {
+				if !slices.Contains(result[index].SemconvMembers, member) {
+					result[index].SemconvMembers = append(result[index].SemconvMembers, member)
+				}
+			}
+			if !slices.Contains(result[index].SemconvMembers, key.Name) {
+				result[index].SemconvMembers = append(result[index].SemconvMembers, key.Name)
+			}
+			continue
+		}
+
+		indexByIdentity[identity] = len(result)
+		currentSourceByIdentity[identity] = fromCurrent
+		result = append(result, &resolved)
+	}
+
+	for _, key := range result {
+		if len(key.SemconvMembers) < 2 {
+			continue
+		}
+		present := make(map[string]bool, len(key.SemconvMembers))
+		for _, member := range key.SemconvMembers {
+			present[member] = true
+		}
+		ordered := make([]string, 0, len(key.SemconvMembers))
+		for _, member := range traceSemconvMembers(key.Name, key.FieldContext) {
+			if present[member] {
+				ordered = append(ordered, member)
+			}
+		}
+		key.SemconvMembers = ordered
+	}
+
+	return result
+}
+
 // getTracesKeys returns the keys from the spans that match the field selection criteria.
 func (t *telemetryMetaStore) getTracesKeys(ctx context.Context, fieldKeySelectors []*telemetrytypes.FieldKeySelector) ([]*telemetrytypes.TelemetryFieldKey, bool, error) {
 	ctx = ctxtypes.NewContextWithCommentVals(ctx, map[string]string{
@@ -202,10 +300,23 @@ func (t *telemetryMetaStore) getTracesKeys(ctx context.Context, fieldKeySelector
 
 		// key part of the selector
 		fieldKeyConds := []string{}
+		members := traceSemconvMembers(fieldKeySelector.Name, fieldKeySelector.FieldContext)
 		if fieldKeySelector.SelectorMatchType == telemetrytypes.FieldSelectorMatchTypeExact {
-			fieldKeyConds = append(fieldKeyConds, sb.E("tagKey", fieldKeySelector.Name))
+			if len(members) == 1 {
+				fieldKeyConds = append(fieldKeyConds, sb.E("tagKey", members[0]))
+			} else {
+				memberValues := make([]any, 0, len(members))
+				for _, member := range members {
+					memberValues = append(memberValues, member)
+				}
+				fieldKeyConds = append(fieldKeyConds, sb.In("tagKey", memberValues...))
+			}
 		} else {
-			fieldKeyConds = append(fieldKeyConds, sb.ILike("tagKey", "%"+escapeForLike(fieldKeySelector.Name)+"%"))
+			memberConditions := make([]string, 0, len(members))
+			for _, member := range members {
+				memberConditions = append(memberConditions, sb.ILike("tagKey", "%"+escapeForLike(member)+"%"))
+			}
+			fieldKeyConds = append(fieldKeyConds, sb.Or(memberConditions...))
 		}
 
 		searchTexts = append(searchTexts, fieldKeySelector.Name)
@@ -238,8 +349,10 @@ func (t *telemetryMetaStore) getTracesKeys(ctx context.Context, fieldKeySelector
 	mainSb.From(mainSb.BuilderAs(sb, "sub_query"))
 	mainSb.GroupBy("tag_key", "tag_type", "tag_data_type")
 	mainSb.OrderBy("priority")
-	// query one extra to check if we hit the limit
-	mainSb.Limit(limit + 1)
+	// Family members collapse after the database query. In the worst case each
+	// logical key occupies one row per family member, so fetch enough physical
+	// rows to return the requested logical page, plus one to detect truncation.
+	mainSb.Limit(limit*traceSemconvDuplicateFactor() + 1)
 
 	query, args := mainSb.BuildWithFlavor(sqlbuilder.ClickHouse)
 
@@ -249,14 +362,7 @@ func (t *telemetryMetaStore) getTracesKeys(ctx context.Context, fieldKeySelector
 	}
 	defer rows.Close()
 	keys := []*telemetrytypes.TelemetryFieldKey{}
-	rowCount := 0
 	for rows.Next() {
-		rowCount++
-		// reached the limit, we know there are more results
-		if rowCount > limit {
-			break
-		}
-
 		var name string
 		var fieldContext telemetrytypes.FieldContext
 		var fieldDataType telemetrytypes.FieldDataType
@@ -285,8 +391,11 @@ func (t *telemetryMetaStore) getTracesKeys(ctx context.Context, fieldKeySelector
 		return nil, false, errors.Wrap(rows.Err(), errors.TypeInternal, errors.CodeInternal, ErrFailedToGetTracesKeys.Error())
 	}
 
-	// hit the limit? (only counting DB results)
-	complete := rowCount <= limit
+	keys = canonicalizeTraceSemconvKeys(keys)
+	complete := len(keys) <= limit
+	if !complete {
+		keys = keys[:limit]
+	}
 
 	staticKeys := []string{"isRoot", "isEntryPoint"}
 	staticKeys = append(staticKeys, maps.Keys(tracestelemetryschema.IntrinsicFields)...)
@@ -1108,40 +1217,6 @@ func (t *telemetryMetaStore) getMeterSourceMetricKeys(ctx context.Context, field
 
 }
 
-// applyBackwardCompatibleKeys adds backward compatible key aliases to the map.
-func applyBackwardCompatibleKeys(mapOfKeys map[string][]*telemetrytypes.TelemetryFieldKey) {
-	// Get backward compatible keys for all signals
-	backwardCompatKeysBySignal := map[telemetrytypes.Signal]BackwardCompatibleKeyMap{
-		telemetrytypes.SignalTraces:  GetBackwardCompatKeysForSignal(telemetrytypes.SignalTraces),
-		telemetrytypes.SignalLogs:    GetBackwardCompatKeysForSignal(telemetrytypes.SignalLogs),
-		telemetrytypes.SignalMetrics: GetBackwardCompatKeysForSignal(telemetrytypes.SignalMetrics),
-	}
-
-	// Iterate over existing keys and add aliases if they exist in backward compat mapping
-	for srcKey, srcKeys := range mapOfKeys {
-		for _, srcKeyEntry := range srcKeys {
-			backwardCompatKeys := backwardCompatKeysBySignal[srcKeyEntry.Signal]
-			if backwardCompatKeys == nil {
-				continue
-			}
-
-			if aliasKey, ok := backwardCompatKeys[srcKey]; ok {
-				if _, aliasExists := mapOfKeys[aliasKey]; !aliasExists {
-					aliasKeyEntry := &telemetrytypes.TelemetryFieldKey{
-						Name:          aliasKey,
-						Signal:        srcKeyEntry.Signal,
-						FieldContext:  srcKeyEntry.FieldContext,
-						FieldDataType: srcKeyEntry.FieldDataType,
-					}
-					mapOfKeys[aliasKey] = []*telemetrytypes.TelemetryFieldKey{aliasKeyEntry}
-				}
-				// Found the alias for this signal, no need to check other entries
-				break
-			}
-		}
-	}
-}
-
 func enrichWithIntrinsicMetricKeys(keys map[string][]*telemetrytypes.TelemetryFieldKey, selectors []*telemetrytypes.FieldKeySelector) map[string][]*telemetrytypes.TelemetryFieldKey {
 	if len(selectors) == 0 {
 		return keys
@@ -1272,7 +1347,6 @@ func (t *telemetryMetaStore) GetKeys(ctx context.Context, orgID valuer.UUID, fie
 		mapOfKeys[key.Name] = append(mapOfKeys[key.Name], key)
 	}
 
-	applyBackwardCompatibleKeys(mapOfKeys)
 	mapOfKeys = enrichWithIntrinsicMetricKeys(mapOfKeys, selectors)
 	if t.fl.BooleanOrEmpty(ctx, flagger.FeatureEnableAIObservability, featuretypes.NewFlaggerEvaluationContext(orgID)) {
 		mapOfKeys = enrichWithGenAIKeys(mapOfKeys, selectors)
@@ -1353,7 +1427,6 @@ func (t *telemetryMetaStore) GetKeysMulti(ctx context.Context, orgID valuer.UUID
 		mapOfKeys[key.Name] = append(mapOfKeys[key.Name], key)
 	}
 
-	applyBackwardCompatibleKeys(mapOfKeys)
 	mapOfKeys = enrichWithIntrinsicMetricKeys(mapOfKeys, fieldKeySelectors)
 	if t.fl.BooleanOrEmpty(ctx, flagger.FeatureEnableAIObservability, featuretypes.NewFlaggerEvaluationContext(orgID)) {
 		mapOfKeys = enrichWithGenAIKeys(mapOfKeys, fieldKeySelectors)
@@ -1367,7 +1440,18 @@ func (t *telemetryMetaStore) GetKey(ctx context.Context, orgID valuer.UUID, fiel
 	if err != nil {
 		return nil, err
 	}
-	return keys[fieldKeySelector.Name], nil
+	members := semconv.Members(semconv.KindAttribute, *fieldKeySelector)
+	resolved := make([]*telemetrytypes.TelemetryFieldKey, 0)
+	seen := make(map[*telemetrytypes.TelemetryFieldKey]bool)
+	for _, member := range members {
+		for _, key := range keys[member] {
+			if !seen[key] {
+				resolved = append(resolved, key)
+				seen[key] = true
+			}
+		}
+	}
+	return resolved, nil
 }
 
 func (t *telemetryMetaStore) getRelatedValues(ctx context.Context, orgID valuer.UUID, fieldValueSelector *telemetrytypes.FieldValueSelector) ([]string, bool, error) {
@@ -1542,7 +1626,16 @@ func (t *telemetryMetaStore) getSpanFieldValues(ctx context.Context, fieldValueS
 	sb := sqlbuilder.Select("DISTINCT string_value, number_value").From(t.tracesDBName + "." + t.tracesFieldsTblName)
 
 	if fieldValueSelector.Name != "" {
-		sb.Where(sb.E("tag_key", fieldValueSelector.Name))
+		members := traceSemconvMembers(fieldValueSelector.Name, fieldValueSelector.FieldContext)
+		if len(members) == 1 {
+			sb.Where(sb.E("tag_key", members[0]))
+		} else {
+			memberValues := make([]any, 0, len(members))
+			for _, member := range members {
+				memberValues = append(memberValues, member)
+			}
+			sb.Where(sb.In("tag_key", memberValues...))
+		}
 	}
 
 	// now look at the field context

pkg/telemetrymetadata/metadata_query_test.go

@@ -12,6 +12,7 @@ import (
 	"github.com/SigNoz/signoz/pkg/telemetrystore"
 	"github.com/SigNoz/signoz/pkg/telemetrystore/telemetrystoretest"
 	"github.com/SigNoz/signoz/pkg/types/telemetrytypes"
+	"github.com/SigNoz/signoz/pkg/valuer"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
@@ -83,3 +84,83 @@ func TestGetFirstSeenFromMetricMetadata(t *testing.T) {
 		t.Errorf("there were unfulfilled expectations: %s", err)
 	}
 }
+
+func TestCanonicalizeTraceSemconvKeys(t *testing.T) {
+	oldResource := &telemetrytypes.TelemetryFieldKey{
+		Name:          "deployment.environment",
+		Description:   "old resource metadata",
+		Signal:        telemetrytypes.SignalTraces,
+		FieldContext:  telemetrytypes.FieldContextResource,
+		FieldDataType: telemetrytypes.FieldDataTypeString,
+	}
+	currentResource := &telemetrytypes.TelemetryFieldKey{
+		Name:          "deployment.environment.name",
+		Description:   "current resource metadata",
+		Signal:        telemetrytypes.SignalTraces,
+		FieldContext:  telemetrytypes.FieldContextResource,
+		FieldDataType: telemetrytypes.FieldDataTypeString,
+	}
+	oldAttribute := &telemetrytypes.TelemetryFieldKey{
+		Name:          "deployment.environment",
+		Signal:        telemetrytypes.SignalTraces,
+		FieldContext:  telemetrytypes.FieldContextAttribute,
+		FieldDataType: telemetrytypes.FieldDataTypeString,
+	}
+	oldLogResource := &telemetrytypes.TelemetryFieldKey{
+		Name:          "deployment.environment",
+		Signal:        telemetrytypes.SignalLogs,
+		FieldContext:  telemetrytypes.FieldContextResource,
+		FieldDataType: telemetrytypes.FieldDataTypeString,
+	}
+
+	result := canonicalizeTraceSemconvKeys([]*telemetrytypes.TelemetryFieldKey{
+		oldResource,
+		currentResource,
+		oldAttribute,
+		oldLogResource,
+	})
+
+	require.Len(t, result, 3)
+	assert.Equal(t, "deployment.environment.name", result[0].Name)
+	assert.Equal(t, "current resource metadata", result[0].Description)
+	assert.Equal(t, []string{"deployment.environment.name", "deployment.environment"}, result[0].SemconvMembers)
+	assert.Equal(t, "deployment.environment.name", result[1].Name)
+	assert.Equal(t, telemetrytypes.FieldContextAttribute, result[1].FieldContext)
+	assert.Equal(t, []string{"deployment.environment"}, result[1].SemconvMembers)
+	assert.Equal(t, "deployment.environment", result[2].Name, "phase 1 must not rewrite raw log metadata")
+}
+
+func TestGetSpanFieldValuesMergesSemconvFamily(t *testing.T) {
+	mockTelemetryStore := telemetrystoretest.New(telemetrystore.Config{}, &regexMatcher{})
+	mock := mockTelemetryStore.Mock()
+
+	metadata := NewTelemetryMetaStore(
+		instrumentationtest.New().ToProviderSettings(),
+		mockTelemetryStore,
+		flaggertest.New(t),
+	)
+
+	mock.ExpectQuery(`SELECT DISTINCT string_value, number_value FROM signoz_traces\.distributed_tag_attributes_v2 WHERE tag_key IN \(\?, \?\) AND tag_type = \? AND tag_data_type = \? LIMIT \?`).
+		WithArgs("deployment.environment.name", "deployment.environment", "resource", "string", 51).
+		WillReturnRows(cmock.NewRows([]cmock.ColumnType{
+			{Name: "string_value", Type: "String"},
+			{Name: "number_value", Type: "Float64"},
+		}, [][]any{
+			{"production", float64(0)},
+			{"staging", float64(0)},
+			{"production", float64(0)},
+		}))
+
+	values, complete, err := metadata.GetAllValues(context.Background(), valuer.UUID{}, &telemetrytypes.FieldValueSelector{
+		FieldKeySelector: &telemetrytypes.FieldKeySelector{
+			Signal:        telemetrytypes.SignalTraces,
+			FieldContext:  telemetrytypes.FieldContextResource,
+			FieldDataType: telemetrytypes.FieldDataTypeString,
+			Name:          "deployment.environment",
+		},
+	})
+	require.NoError(t, err)
+	assert.True(t, complete)
+	assert.Equal(t, []string{"production", "staging"}, values.StringValues)
+	assert.NoError(t, mock.ExpectationsWereMet(), "all expected metadata queries should be executed")
+}

pkg/telemetryschema/tracestelemetryschema/condition_builder.go

@@ -154,6 +154,15 @@ 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:
+		// A semantic-convention family is represented by one current-first value
+		// expression, but presence still has to inspect every physical member. In
+		// particular, using ExistsExpression below with the requested key would add
+		// a mapContains check for only that spelling and reject fallback-only rows.
+		if isTraceSemconvFamily(key) {
+			if fm, ok := c.fm.(*fieldMapper); ok {
+				return fm.existsExpressionFor(ctx, orgID, startNs, endNs, key, operator == qbtypes.FilterOperatorExists)
+			}
+		}
 		columns, err := c.fm.ColumnFor(ctx, orgID, startNs, endNs, key)
 		if err != nil {
 			return "", err

pkg/telemetryschema/tracestelemetryschema/condition_builder_test.go

@@ -210,6 +210,32 @@ func TestConditionFor(t *testing.T) {
 			expectedSQL:   "NOT mapContains(attributes_string, 'user.id')",
 			expectedError: nil,
 		},
+		{
+			name: "Equal operator - semantic convention family",
+			key: telemetrytypes.TelemetryFieldKey{
+				Name:           "deployment.environment.name",
+				FieldContext:   telemetrytypes.FieldContextAttribute,
+				FieldDataType:  telemetrytypes.FieldDataTypeString,
+				SemconvMembers: []string{"deployment.environment.name", "deployment.environment"},
+			},
+			operator:      qbtypes.FilterOperatorEqual,
+			value:         "production",
+			expectedSQL:   "(COALESCE(NULLIF(attributes_string['deployment.environment.name'], ''), NULLIF(attributes_string['deployment.environment'], '')) = ? AND ((mapContains(attributes_string, 'deployment.environment.name') OR mapContains(attributes_string, 'deployment.environment'))))",
+			expectedArgs:  []any{"production"},
+			expectedError: nil,
+		},
+		{
+			name: "Not Exists operator - semantic convention family",
+			key: telemetrytypes.TelemetryFieldKey{
+				Name:           "deployment.environment",
+				FieldContext:   telemetrytypes.FieldContextAttribute,
+				FieldDataType:  telemetrytypes.FieldDataTypeString,
+				SemconvMembers: []string{"deployment.environment.name", "deployment.environment"},
+			},
+			operator:      qbtypes.FilterOperatorNotExists,
+			expectedSQL:   "NOT (((mapContains(attributes_string, 'deployment.environment.name') OR mapContains(attributes_string, 'deployment.environment'))))",
+			expectedError: nil,
+		},
 		{
 			name: "Exists operator - json field",
 			key: telemetrytypes.TelemetryFieldKey{

pkg/telemetryschema/tracestelemetryschema/field_mapper.go

@@ -8,6 +8,7 @@ import (
 	schema "github.com/SigNoz/signoz-otel-collector/cmd/signozschemamigrator/schema_migrator"
 	"github.com/SigNoz/signoz/pkg/errors"
 	"github.com/SigNoz/signoz/pkg/querybuilder"
+	"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"
@@ -167,6 +168,32 @@ func NewFieldMapper() *fieldMapper {
 	return &fieldMapper{}
 }
 
+func traceSemconvMembers(key *telemetrytypes.TelemetryFieldKey) []string {
+	if key.FieldContext != telemetrytypes.FieldContextResource && key.FieldContext != telemetrytypes.FieldContextAttribute {
+		return []string{key.Name}
+	}
+	if len(key.SemconvMembers) > 0 {
+		return key.SemconvMembers
+	}
+	return semconv.Members(semconv.KindAttribute, telemetrytypes.FieldKeySelector{
+		Name:         key.Name,
+		Signal:       telemetrytypes.SignalTraces,
+		FieldContext: key.FieldContext,
+	})
+}
+
+func isTraceSemconvFamily(key *telemetrytypes.TelemetryFieldKey) bool {
+	if key.FieldContext != telemetrytypes.FieldContextResource && key.FieldContext != telemetrytypes.FieldContextAttribute {
+		return false
+	}
+	_, ok := semconv.Lookup(semconv.KindAttribute, telemetrytypes.FieldKeySelector{
+		Name:         key.Name,
+		Signal:       telemetrytypes.SignalTraces,
+		FieldContext: key.FieldContext,
+	})
+	return ok
+}
+
 func (m *fieldMapper) getColumn(
 	_ context.Context,
 	_, _ uint64,
@@ -291,10 +318,25 @@ func (m *fieldMapper) resolveColumnExprs(
 			if key.FieldContext != telemetrytypes.FieldContextResource {
 				return nil, nil, nil, errors.Newf(errors.TypeInvalidInput, errors.CodeInvalidInput, "only resource context fields are supported for json columns, got %s", key.FieldContext.String)
 			}
-			// have to add ::string as clickHouse throws an error :- data types Variant/Dynamic are not allowed in GROUP BY
-			// once clickHouse dependency is updated, we need to check if we can remove it.
-			exprs = append(exprs, fmt.Sprintf("%s.`%s`::String", columnName, key.Name))
-			existExprs = append(existExprs, fmt.Sprintf("%s.`%s` IS NOT NULL", columnName, key.Name))
+			members := traceSemconvMembers(key)
+			if len(members) > 1 {
+				values := make([]string, 0, len(members))
+				guards := make([]string, 0, len(members))
+				for _, member := range members {
+					// The String cast is required because ClickHouse does not allow
+					// Variant/Dynamic values in GROUP BY.
+					value := fmt.Sprintf("%s.`%s`::String", columnName, member)
+					values = append(values, fmt.Sprintf("NULLIF(%s, '')", value))
+					guards = append(guards, fmt.Sprintf("%s.`%s` IS NOT NULL", columnName, member))
+				}
+				exprs = append(exprs, "COALESCE("+strings.Join(values, ", ")+")")
+				existExprs = append(existExprs, "("+strings.Join(guards, " OR ")+")")
+			} else {
+				// have to add ::string as clickHouse throws an error :- data types Variant/Dynamic are not allowed in GROUP BY
+				// once ClickHouse is updated, check whether this cast can be removed.
+				exprs = append(exprs, fmt.Sprintf("%s.`%s`::String", columnName, members[0]))
+				existExprs = append(existExprs, fmt.Sprintf("%s.`%s` IS NOT NULL", columnName, members[0]))
+			}
 		case schema.ColumnTypeEnumString,
 			schema.ColumnTypeEnumUInt64,
 			schema.ColumnTypeEnumUInt32,
@@ -319,13 +361,35 @@ func (m *fieldMapper) resolveColumnExprs(
 
 			switch valueType := column.Type.(schema.MapColumnType).ValueType; valueType.GetType() {
 			case schema.ColumnTypeEnumString, schema.ColumnTypeEnumFloat64, schema.ColumnTypeEnumBool:
-				// a key could have been materialized, if so return the materialized column name
-				if key.Materialized {
-					exprs = append(exprs, telemetrytypes.FieldKeyToMaterializedColumnName(key))
-					existExprs = append(existExprs, telemetrytypes.FieldKeyToMaterializedColumnNameForExists(key))
+				members := traceSemconvMembers(key)
+				if len(members) > 1 {
+					guards := make([]string, 0, len(members))
+					for _, member := range members {
+						guards = append(guards, fmt.Sprintf("mapContains(%s, '%s')", columnName, member))
+					}
+					if valueType.GetType() == schema.ColumnTypeEnumString {
+						values := make([]string, 0, len(members))
+						for _, member := range members {
+							values = append(values, fmt.Sprintf("NULLIF(%s['%s'], '')", columnName, member))
+						}
+						exprs = append(exprs, "COALESCE("+strings.Join(values, ", ")+")")
+					} else {
+						branches := make([]string, 0, len(members)*2)
+						for i, member := range members {
+							branches = append(branches, guards[i], fmt.Sprintf("%s['%s']", columnName, member))
+						}
+						exprs = append(exprs, "multiIf("+strings.Join(branches, ", ")+", NULL)")
+					}
+					existExprs = append(existExprs, "("+strings.Join(guards, " OR ")+")")
+				} else if key.Materialized {
+					// a key could have been materialized, if so return the materialized column name
+					physicalKey := *key
+					physicalKey.Name = members[0]
+					exprs = append(exprs, telemetrytypes.FieldKeyToMaterializedColumnName(&physicalKey))
+					existExprs = append(existExprs, telemetrytypes.FieldKeyToMaterializedColumnNameForExists(&physicalKey))
 				} else {
-					exprs = append(exprs, fmt.Sprintf("%s['%s']", columnName, key.Name))
-					existExprs = append(existExprs, fmt.Sprintf("mapContains(%s, '%s')", columnName, key.Name))
+					exprs = append(exprs, fmt.Sprintf("%s['%s']", columnName, members[0]))
+					existExprs = append(existExprs, fmt.Sprintf("mapContains(%s, '%s')", columnName, members[0]))
 				}
 			default:
 				return nil, nil, nil, errors.NewInvalidInputf(errors.CodeInvalidInput, "value type %s is not supported for map column type %s", valueType, column.Type)
@@ -529,6 +593,25 @@ func (m *fieldMapper) existsExpressionFor(
 	key *telemetrytypes.TelemetryFieldKey,
 	exists bool,
 ) (string, error) {
+	if isTraceSemconvFamily(key) {
+		_, existExprs, _, err := m.resolveColumnExprs(ctx, tsStart, tsEnd, key)
+		if err != nil {
+			return "", err
+		}
+		if len(existExprs) == 0 {
+			return "", errors.NewInvalidInputf(errors.CodeInvalidInput, "no existence expression found for field %s", key.Name)
+		}
+		parts := make([]string, 0, len(existExprs))
+		for _, expression := range existExprs {
+			parts = append(parts, "("+expression+")")
+		}
+		combined := strings.Join(parts, " OR ")
+		if exists {
+			return combined, nil
+		}
+		return "NOT (" + combined + ")", nil
+	}
+
 	columns, err := m.getColumn(ctx, tsStart, tsEnd, key)
 	if err != nil {
 		return "", err

pkg/telemetryschema/tracestelemetryschema/field_mapper_test.go

@@ -80,7 +80,7 @@ func TestGetFieldKeyName(t *testing.T) {
 				Materialized:  true,
 				Evolutions:    mockEvolution,
 			},
-			expectedResult: "multiIf(resource.`deployment.environment` IS NOT NULL, resource.`deployment.environment`::String, `resource_string_deployment$$environment_exists`, `resource_string_deployment$$environment`, NULL)",
+			expectedResult: "multiIf((resource.`deployment.environment.name` IS NOT NULL OR resource.`deployment.environment` IS NOT NULL), COALESCE(NULLIF(resource.`deployment.environment.name`::String, ''), NULLIF(resource.`deployment.environment`::String, '')), (mapContains(resources_string, 'deployment.environment.name') OR mapContains(resources_string, 'deployment.environment')), COALESCE(NULLIF(resources_string['deployment.environment.name'], ''), NULLIF(resources_string['deployment.environment'], '')), NULL)",
 			expectedError:  nil,
 		},
 		{
@@ -120,6 +120,51 @@ func TestGetFieldKeyName(t *testing.T) {
 	}
 }
 
+func TestFieldForSemconvFamily(t *testing.T) {
+	ctx := context.Background()
+	fm := NewFieldMapper()
+	start := uint64(time.Date(2024, 6, 1, 0, 0, 0, 0, time.UTC).UnixNano())
+	end := uint64(time.Date(2024, 6, 5, 0, 0, 0, 0, time.UTC).UnixNano())
+
+	for _, requestedName := range []string{"deployment.environment.name", "deployment.environment"} {
+		attributeKey := telemetrytypes.TelemetryFieldKey{
+			Name:          requestedName,
+			FieldContext:  telemetrytypes.FieldContextAttribute,
+			FieldDataType: telemetrytypes.FieldDataTypeString,
+		}
+		attributeExpression, err := fm.FieldFor(ctx, valuer.UUID{}, start, end, &attributeKey)
+		require.NoError(t, err)
+		assert.Equal(t,
+			"COALESCE(NULLIF(attributes_string['deployment.environment.name'], ''), NULLIF(attributes_string['deployment.environment'], ''))",
+			attributeExpression,
+		)
+
+		resourceKey := telemetrytypes.TelemetryFieldKey{
+			Name:          requestedName,
+			FieldContext:  telemetrytypes.FieldContextResource,
+			FieldDataType: telemetrytypes.FieldDataTypeString,
+			Materialized:  true,
+			Evolutions:    MockEvolutionData(time.Date(2024, 6, 2, 0, 0, 0, 0, time.UTC)),
+		}
+		resourceExpression, err := fm.FieldFor(ctx, valuer.UUID{}, start, end, &resourceKey)
+		require.NoError(t, err)
+		assert.Equal(t,
+			"multiIf((resource.`deployment.environment.name` IS NOT NULL OR resource.`deployment.environment` IS NOT NULL), COALESCE(NULLIF(resource.`deployment.environment.name`::String, ''), NULLIF(resource.`deployment.environment`::String, '')), (mapContains(resources_string, 'deployment.environment.name') OR mapContains(resources_string, 'deployment.environment')), COALESCE(NULLIF(resources_string['deployment.environment.name'], ''), NULLIF(resources_string['deployment.environment'], '')), NULL)",
+			resourceExpression,
+		)
+	}
+
+	oldRequestWithCurrentOnlyMetadata := telemetrytypes.TelemetryFieldKey{
+		Name:           "deployment.environment",
+		FieldContext:   telemetrytypes.FieldContextAttribute,
+		FieldDataType:  telemetrytypes.FieldDataTypeString,
+		SemconvMembers: []string{"deployment.environment.name"},
+	}
+	expression, err := fm.FieldFor(ctx, valuer.UUID{}, start, end, &oldRequestWithCurrentOnlyMetadata)
+	require.NoError(t, err)
+	assert.Equal(t, "attributes_string['deployment.environment.name']", expression)
+}
+
 func TestFieldForResourceWithEvolution(t *testing.T) {
 	ctx := context.Background()
 	releaseTime := time.Date(2025, 1, 1, 0, 0, 0, 0, time.UTC)
@@ -176,7 +221,7 @@ func TestFieldForResourceWithEvolution(t *testing.T) {
 			},
 			tsStart:        uint64(time.Date(2025, 6, 1, 0, 0, 0, 0, time.UTC).UnixNano()),
 			tsEnd:          uint64(time.Date(2025, 7, 1, 0, 0, 0, 0, time.UTC).UnixNano()),
-			expectedResult: "resource.`deployment.environment`::String",
+			expectedResult: "COALESCE(NULLIF(resource.`deployment.environment.name`::String, ''), NULLIF(resource.`deployment.environment`::String, ''))",
 		},
 		{
 			name: "Window straddles release - materialized resource",
@@ -189,7 +234,7 @@ func TestFieldForResourceWithEvolution(t *testing.T) {
 			},
 			tsStart:        uint64(time.Date(2024, 6, 1, 0, 0, 0, 0, time.UTC).UnixNano()),
 			tsEnd:          uint64(time.Date(2025, 6, 1, 0, 0, 0, 0, time.UTC).UnixNano()),
-			expectedResult: "multiIf(resource.`deployment.environment` IS NOT NULL, resource.`deployment.environment`::String, `resource_string_deployment$$environment_exists`, `resource_string_deployment$$environment`, NULL)",
+			expectedResult: "multiIf((resource.`deployment.environment.name` IS NOT NULL OR resource.`deployment.environment` IS NOT NULL), COALESCE(NULLIF(resource.`deployment.environment.name`::String, ''), NULLIF(resource.`deployment.environment`::String, '')), (mapContains(resources_string, 'deployment.environment.name') OR mapContains(resources_string, 'deployment.environment')), COALESCE(NULLIF(resources_string['deployment.environment.name'], ''), NULLIF(resources_string['deployment.environment'], '')), NULL)",
 		},
 	}
 

pkg/types/quickfiltertypes/filter.go

@@ -141,7 +141,7 @@ func NewSignalFilterFromStorableQuickFilter(storableQuickFilter *StorableQuickFi
 func NewDefaultQuickFilter(orgID valuer.UUID) ([]*StorableQuickFilter, error) {
 	tracesFilters := []map[string]interface{}{
 		{"key": "duration_nano", "dataType": "float64", "type": "tag"},
-		{"key": "deployment.environment", "dataType": "string", "type": "resource"},
+		{"key": "deployment.environment.name", "dataType": "string", "type": "resource"},
 		{"key": "hasError", "dataType": "bool", "type": "tag"},
 		{"key": "service.name", "dataType": "string", "type": "resource"},
 		{"key": "name", "dataType": "string", "type": "tag"},
@@ -166,13 +166,13 @@ func NewDefaultQuickFilter(orgID valuer.UUID) ([]*StorableQuickFilter, error) {
 	}
 
 	apiMonitoringFilters := []map[string]interface{}{
-		{"key": "deployment.environment", "dataType": "string", "type": "resource"},
+		{"key": "deployment.environment.name", "dataType": "string", "type": "resource"},
 		{"key": "service.name", "dataType": "string", "type": "resource"},
 		{"key": "rpc.method", "dataType": "string", "type": "tag"},
 	}
 
 	exceptionsFilters := []map[string]interface{}{
-		{"key": "deployment.environment", "dataType": "string", "type": "resource"},
+		{"key": "deployment.environment.name", "dataType": "string", "type": "resource"},
 		{"key": "service.name", "dataType": "string", "type": "resource"},
 		{"key": "host.name", "dataType": "string", "type": "resource"},
 		{"key": "k8s.cluster.name", "dataType": "string", "type": "resource"},

pkg/types/quickfiltertypes/filter_test.go

@@ -0,0 +1,37 @@
+package quickfiltertypes
+
+import (
+	"encoding/json"
+	"testing"
+
+	v3 "github.com/SigNoz/signoz/pkg/query-service/model/v3"
+	"github.com/SigNoz/signoz/pkg/valuer"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestDefaultTraceQuickFiltersUseCurrentEnvironmentName(t *testing.T) {
+	filters, err := NewDefaultQuickFilter(valuer.GenerateUUID())
+	require.NoError(t, err)
+
+	traceSignals := map[string]bool{
+		SignalTraces.StringValue():        true,
+		SignalApiMonitoring.StringValue(): true,
+		SignalExceptions.StringValue():    true,
+	}
+	for _, filter := range filters {
+		if !traceSignals[filter.Signal.StringValue()] {
+			continue
+		}
+		var keys []v3.AttributeKey
+		require.NoError(t, json.Unmarshal([]byte(filter.Filter), &keys))
+		found := false
+		for _, key := range keys {
+			if key.Key == "deployment.environment.name" {
+				found = true
+			}
+			assert.NotEqual(t, "deployment.environment", key.Key)
+		}
+		assert.True(t, found, "missing environment quick filter for %s", filter.Signal.StringValue())
+	}
+}

pkg/types/telemetrytypes/field.go

@@ -47,7 +47,8 @@ type TelemetryFieldKey struct {
 	Indexes      []TelemetryFieldKeySkipIndex `json:"-"`
 	Materialized bool                         `json:"-"` // refers to promoted in case of body.... fields
 
-	Evolutions []*EvolutionEntry `json:"-"`
+	Evolutions     []*EvolutionEntry `json:"-"`
+	SemconvMembers []string          `json:"-"`
 }
 
 func (f *TelemetryFieldKey) KeyNameContainsArray() bool {
@@ -128,6 +129,7 @@ func (f *TelemetryFieldKey) OverrideMetadataFrom(src *TelemetryFieldKey) {
 	f.Materialized = src.Materialized
 	f.JSONPlan = src.JSONPlan
 	f.Evolutions = src.Evolutions
+	f.SemconvMembers = src.SemconvMembers
 }
 
 func (f *TelemetryFieldKey) Equal(key *TelemetryFieldKey) bool {

scripts/semconv/generate.go

@@ -0,0 +1,721 @@
+package main
+
+import (
+	"bytes"
+	"errors"
+	"flag"
+	"fmt"
+	"go/format"
+	"os"
+	"path/filepath"
+	"sort"
+	"strconv"
+	"strings"
+
+	"gopkg.in/yaml.v3"
+)
+
+const (
+	kindAttribute = "attribute"
+	kindMetric    = "metric"
+)
+
+type stringListFlag []string
+
+func (f *stringListFlag) String() string { return strings.Join(*f, ",") }
+func (f *stringListFlag) Set(value string) error {
+	*f = append(*f, value)
+	return nil
+}
+
+type schemaFile struct {
+	FileFormat string                   `yaml:"file_format"`
+	SchemaURL  string                   `yaml:"schema_url"`
+	Versions   map[string]schemaVersion `yaml:"versions"`
+}
+
+type schemaVersion struct {
+	All       changeSection `yaml:"all"`
+	Resources changeSection `yaml:"resources"`
+	Spans     changeSection `yaml:"spans"`
+	Logs      changeSection `yaml:"logs"`
+	Metrics   changeSection `yaml:"metrics"`
+}
+
+type changeSection struct {
+	Changes []schemaChange `yaml:"changes"`
+}
+
+type schemaChange struct {
+	RenameAttributes *attributeRename  `yaml:"rename_attributes"`
+	RenameMetrics    map[string]string `yaml:"rename_metrics"`
+}
+
+type attributeRename struct {
+	AttributeMap   map[string]string `yaml:"attribute_map"`
+	ApplyToMetrics []string          `yaml:"apply_to_metrics"`
+}
+
+type overlayFile struct {
+	DefaultEnabled bool `yaml:"default_enabled"`
+	// Families is keyed only by current name. One name cannot carry separate
+	// policies for attribute and metric families; set kind explicitly whenever
+	// a metric-name family is configured.
+	Families map[string]overlayFamily `yaml:"families"`
+}
+
+type overlayFamily struct {
+	Enabled           *bool             `yaml:"enabled"`
+	Kind              string            `yaml:"kind"`
+	Old               []string          `yaml:"old"`
+	AddOld            []string          `yaml:"add_old"`
+	ExcludeOld        []string          `yaml:"exclude_old"`
+	Contexts          []string          `yaml:"contexts"`
+	Signals           []string          `yaml:"signals"`
+	AddContexts       []string          `yaml:"add_contexts"`
+	AddSignals        []string          `yaml:"add_signals"`
+	ApplyToMetrics    []string          `yaml:"apply_to_metrics"`
+	AddApplyToMetrics []string          `yaml:"add_apply_to_metrics"`
+	ValueMap          map[string]string `yaml:"value_map"`
+}
+
+type edge struct {
+	old            string
+	current        string
+	kind           string
+	contexts       []string
+	signals        []string
+	allContexts    bool
+	allSignals     bool
+	applyToMetrics []string
+}
+
+type graphKey struct{ kind, name string }
+
+type generatedFamily struct {
+	Current        string
+	Old            []string
+	Kind           string
+	Contexts       []string
+	Signals        []string
+	ApplyToMetrics []string
+	ValueMap       map[string]string
+}
+
+func main() {
+	root, err := findRepoRoot()
+	if err != nil {
+		fatal(err)
+	}
+
+	var schemaPaths stringListFlag
+	flag.Var(&schemaPaths, "schema", "schema source (repeatable)")
+	overlayPath := flag.String("overlay", filepath.Join(root, "scripts/semconv/overlay.yaml"), "SigNoz overlay")
+	goOutput := flag.String("go-out", filepath.Join(root, "pkg/semconv/families_gen.go"), "generated Go output")
+	tsOutput := flag.String("ts-out", filepath.Join(root, "frontend/src/constants/generated/semconvFamilies.gen.ts"), "generated TypeScript output")
+	check := flag.Bool("check", false, "fail if generated files are stale")
+	flag.Parse()
+
+	if len(schemaPaths) == 0 {
+		schemaPaths = append(schemaPaths, filepath.Join(root, "scripts/semconv/schema-1.42.0.yaml"))
+	}
+
+	families, err := generate(schemaPaths, *overlayPath)
+	if err != nil {
+		fatal(err)
+	}
+	goBytes, err := renderGo(families)
+	if err != nil {
+		fatal(err)
+	}
+	tsBytes := renderTypeScript(families)
+
+	if *check {
+		if err := checkFile(*goOutput, goBytes); err != nil {
+			fatal(err)
+		}
+		if err := checkFile(*tsOutput, tsBytes); err != nil {
+			fatal(err)
+		}
+		return
+	}
+
+	if err := os.WriteFile(*goOutput, goBytes, 0o644); err != nil {
+		fatal(err)
+	}
+	if err := os.WriteFile(*tsOutput, tsBytes, 0o644); err != nil {
+		fatal(err)
+	}
+}
+
+func fatal(err error) {
+	fmt.Fprintln(os.Stderr, err)
+	os.Exit(1)
+}
+
+func findRepoRoot() (string, error) {
+	dir, err := os.Getwd()
+	if err != nil {
+		return "", err
+	}
+	for {
+		if _, err := os.Stat(filepath.Join(dir, "go.mod")); err == nil {
+			return dir, nil
+		}
+		parent := filepath.Dir(dir)
+		if parent == dir {
+			return "", errors.New("could not find repository root")
+		}
+		dir = parent
+	}
+}
+
+func generate(schemaPaths []string, overlayPath string) ([]generatedFamily, error) {
+	var schemas []schemaFile
+	for _, path := range schemaPaths {
+		data, err := os.ReadFile(path)
+		if err != nil {
+			return nil, fmt.Errorf("read schema %s: %w", path, err)
+		}
+		var schema schemaFile
+		if err := decodeKnownFields(data, &schema); err != nil {
+			return nil, fmt.Errorf("parse schema %s: %w", path, err)
+		}
+		schemas = append(schemas, schema)
+	}
+
+	overlayData, err := os.ReadFile(overlayPath)
+	if err != nil {
+		return nil, fmt.Errorf("read overlay: %w", err)
+	}
+	var overlay overlayFile
+	if err := decodeKnownFields(overlayData, &overlay); err != nil {
+		return nil, fmt.Errorf("parse overlay: %w", err)
+	}
+
+	return buildFamilies(schemas, overlay)
+}
+
+func decodeKnownFields(data []byte, target any) error {
+	decoder := yaml.NewDecoder(bytes.NewReader(data))
+	decoder.KnownFields(true)
+	return decoder.Decode(target)
+}
+
+func collectEdges(schemas []schemaFile) ([]edge, error) {
+	var edges []edge
+	for _, schema := range schemas {
+		versions := make([]string, 0, len(schema.Versions))
+		versionParts := make(map[string][3]int, len(schema.Versions))
+		for version := range schema.Versions {
+			parts, err := parseSchemaVersion(version)
+			if err != nil {
+				return nil, err
+			}
+			versions = append(versions, version)
+			versionParts[version] = parts
+		}
+		sort.Slice(versions, func(i, j int) bool {
+			return compareVersionParts(versionParts[versions[i]], versionParts[versions[j]]) < 0
+		})
+		for _, versionName := range versions {
+			version := schema.Versions[versionName]
+			var versionEdges []edge
+			sections := []struct {
+				name    string
+				section changeSection
+			}{
+				{name: "all", section: version.All},
+				{name: "resources", section: version.Resources},
+				{name: "spans", section: version.Spans},
+				{name: "logs", section: version.Logs},
+				{name: "metrics", section: version.Metrics},
+			}
+			for _, scoped := range sections {
+				contexts, signals, allContexts, allSignals, err := scopeForSection(scoped.name)
+				if err != nil {
+					return nil, err
+				}
+				for _, change := range scoped.section.Changes {
+					if change.RenameAttributes != nil {
+						for _, old := range sortedMapKeys(change.RenameAttributes.AttributeMap) {
+							versionEdges = append(versionEdges, edge{
+								old: old, current: change.RenameAttributes.AttributeMap[old], kind: kindAttribute,
+								contexts: contexts, signals: signals,
+								allContexts: allContexts, allSignals: allSignals,
+								applyToMetrics: change.RenameAttributes.ApplyToMetrics,
+							})
+						}
+					}
+					for _, old := range sortedMapKeys(change.RenameMetrics) {
+						versionEdges = append(versionEdges, edge{
+							old: old, current: change.RenameMetrics[old], kind: kindMetric,
+							contexts: []string{"metric"}, signals: []string{"metrics"},
+						})
+					}
+				}
+			}
+			if err := rejectSameVersionChains(versionName, versionEdges); err != nil {
+				return nil, err
+			}
+			edges = append(edges, versionEdges...)
+		}
+	}
+	return edges, nil
+}
+
+func rejectSameVersionChains(version string, edges []edge) error {
+	oldNames := make(map[graphKey]struct{}, len(edges))
+	for _, item := range edges {
+		oldNames[graphKey{kind: item.kind, name: item.old}] = struct{}{}
+	}
+	for _, item := range edges {
+		if _, ok := oldNames[graphKey{kind: item.kind, name: item.current}]; ok {
+			return fmt.Errorf(
+				"schema version %q contains a same-version %s rename chain through %q",
+				version,
+				item.kind,
+				item.current,
+			)
+		}
+	}
+	return nil
+}
+
+func parseSchemaVersion(version string) ([3]int, error) {
+	parts := strings.Split(version, ".")
+	if len(parts) != 3 {
+		return [3]int{}, fmt.Errorf("schema version %q must contain major, minor, and patch numbers", version)
+	}
+
+	var parsed [3]int
+	for i, part := range parts {
+		value, err := strconv.Atoi(part)
+		if err != nil || value < 0 {
+			return [3]int{}, fmt.Errorf("schema version %q contains invalid numeric component %q", version, part)
+		}
+		parsed[i] = value
+	}
+	return parsed, nil
+}
+
+func compareVersionParts(left, right [3]int) int {
+	for i := range left {
+		if left[i] < right[i] {
+			return -1
+		}
+		if left[i] > right[i] {
+			return 1
+		}
+	}
+	return 0
+}
+
+func scopeForSection(section string) (contexts, signals []string, allContexts, allSignals bool, err error) {
+	switch section {
+	case "all":
+		return nil, nil, true, true, nil
+	case "resources":
+		return []string{"resource"}, nil, false, true, nil
+	case "spans":
+		return []string{"attribute"}, []string{"traces"}, false, false, nil
+	case "logs":
+		return []string{"attribute"}, []string{"logs"}, false, false, nil
+	case "metrics":
+		return []string{"attribute"}, []string{"metrics"}, false, false, nil
+	default:
+		return nil, nil, false, false, fmt.Errorf("unsupported schema section %q", section)
+	}
+}
+
+func buildFamilies(schemas []schemaFile, overlay overlayFile) ([]generatedFamily, error) {
+	edges, err := collectEdges(schemas)
+	if err != nil {
+		return nil, err
+	}
+	next := make(map[graphKey]string)
+	for _, item := range edges {
+		key := graphKey{kind: item.kind, name: item.old}
+		if existing, ok := next[key]; ok && existing == item.current {
+			// Repeated entries are common in chained schema histories. Treat an
+			// identical edge as a no-op so it cannot sever a later edge in the
+			// same chain (A -> B, B -> C, then a repeated A -> B).
+			continue
+		}
+		// Schema history occasionally repeats an old name with a newer direct
+		// destination or rolls a rename back. Edges are collected
+		// oldest-to-newest, so the latest published current name must be a root.
+		delete(next, graphKey{kind: item.kind, name: item.current})
+		next[key] = item.current
+	}
+
+	type familyState struct {
+		family      generatedFamily
+		distance    map[string]int
+		allContexts bool
+		allSignals  bool
+	}
+	states := map[graphKey]*familyState{}
+	for _, item := range edges {
+		root, distance, err := rootFor(next, item.kind, item.old)
+		if err != nil {
+			return nil, err
+		}
+		key := graphKey{kind: item.kind, name: root}
+		state := states[key]
+		if state == nil {
+			state = &familyState{
+				family:   generatedFamily{Current: root, Kind: item.kind},
+				distance: map[string]int{},
+			}
+			states[key] = state
+		}
+		if prior, ok := state.distance[item.old]; !ok || distance < prior {
+			state.distance[item.old] = distance
+		}
+		state.allContexts = state.allContexts || item.allContexts
+		state.allSignals = state.allSignals || item.allSignals
+		state.family.Contexts = appendUnique(state.family.Contexts, item.contexts...)
+		state.family.Signals = appendUnique(state.family.Signals, item.signals...)
+		state.family.ApplyToMetrics = appendUnique(state.family.ApplyToMetrics, item.applyToMetrics...)
+	}
+
+	for _, state := range states {
+		for old := range state.distance {
+			if old != state.family.Current {
+				state.family.Old = append(state.family.Old, old)
+			}
+		}
+		sort.Slice(state.family.Old, func(i, j int) bool {
+			left, right := state.family.Old[i], state.family.Old[j]
+			if state.distance[left] != state.distance[right] {
+				return state.distance[left] < state.distance[right]
+			}
+			return left < right
+		})
+		if state.allContexts {
+			state.family.Contexts = nil
+		} else {
+			sort.Strings(state.family.Contexts)
+		}
+		if state.allSignals {
+			state.family.Signals = nil
+		} else {
+			sort.Strings(state.family.Signals)
+		}
+		sort.Strings(state.family.ApplyToMetrics)
+	}
+
+	for _, current := range sortedMapKeys(overlay.Families) {
+		policy := overlay.Families[current]
+		kind, err := normalizedOverlayKind(current, policy)
+		if err != nil {
+			return nil, err
+		}
+		policy.Kind = kind
+		overlay.Families[current] = policy
+		key := graphKey{kind: kind, name: current}
+		state := states[key]
+		if state == nil {
+			if len(policy.Old) == 0 {
+				return nil, fmt.Errorf(
+					"overlay family %q with kind %q is absent from schemas and has no old members",
+					current,
+					kind,
+				)
+			}
+			state = &familyState{
+				family:   generatedFamily{Current: current, Kind: kind, Old: append([]string(nil), policy.Old...)},
+				distance: map[string]int{},
+			}
+			states[key] = state
+		}
+		applyOverlay(&state.family, policy)
+	}
+
+	var result []generatedFamily
+	for key, state := range states {
+		policy, hasPolicy := overlay.Families[key.name]
+		enabled := overlay.DefaultEnabled
+		if hasPolicy && policy.Kind != key.kind {
+			hasPolicy = false
+		}
+		if hasPolicy && policy.Enabled != nil {
+			enabled = *policy.Enabled
+		}
+		if !enabled {
+			continue
+		}
+		if len(state.family.Old) == 0 {
+			return nil, fmt.Errorf(
+				"enabled family %q with kind %q has no old members",
+				state.family.Current,
+				state.family.Kind,
+			)
+		}
+		sort.Strings(state.family.Contexts)
+		sort.Strings(state.family.Signals)
+		sort.Strings(state.family.ApplyToMetrics)
+		result = append(result, state.family)
+	}
+
+	sort.Slice(result, func(i, j int) bool {
+		if result[i].Current != result[j].Current {
+			return result[i].Current < result[j].Current
+		}
+		return result[i].Kind < result[j].Kind
+	})
+	return result, nil
+}
+
+func rootFor(next map[graphKey]string, kind, name string) (string, int, error) {
+	seen := map[string]bool{}
+	distance := 0
+	for {
+		if seen[name] {
+			return "", 0, fmt.Errorf("rename cycle for %s %q", kind, name)
+		}
+		seen[name] = true
+		current, ok := next[graphKey{kind: kind, name: name}]
+		if !ok {
+			return name, distance, nil
+		}
+		name = current
+		distance++
+	}
+}
+
+func normalizedOverlayKind(current string, policy overlayFamily) (string, error) {
+	kind := policy.Kind
+	if kind == "" {
+		kind = kindAttribute
+	}
+	if kind != kindAttribute && kind != kindMetric {
+		return "", fmt.Errorf("overlay family %q has unsupported kind %q", current, kind)
+	}
+	return kind, nil
+}
+
+func applyOverlay(family *generatedFamily, policy overlayFamily) {
+	if policy.Kind != "" {
+		family.Kind = policy.Kind
+	}
+	if policy.Old != nil {
+		family.Old = append([]string(nil), policy.Old...)
+	}
+	family.Old = appendUnique(family.Old, policy.AddOld...)
+	if len(policy.ExcludeOld) > 0 {
+		excluded := make(map[string]bool, len(policy.ExcludeOld))
+		for _, old := range policy.ExcludeOld {
+			excluded[old] = true
+		}
+		family.Old = deleteMatching(family.Old, excluded)
+	}
+	if policy.Contexts != nil {
+		family.Contexts = append([]string(nil), policy.Contexts...)
+	}
+	if policy.Signals != nil {
+		family.Signals = append([]string(nil), policy.Signals...)
+	}
+	family.Contexts = appendUnique(family.Contexts, policy.AddContexts...)
+	family.Signals = appendUnique(family.Signals, policy.AddSignals...)
+	if policy.ApplyToMetrics != nil {
+		family.ApplyToMetrics = append([]string(nil), policy.ApplyToMetrics...)
+	}
+	family.ApplyToMetrics = appendUnique(family.ApplyToMetrics, policy.AddApplyToMetrics...)
+	if policy.ValueMap != nil {
+		family.ValueMap = make(map[string]string, len(policy.ValueMap))
+		for old, current := range policy.ValueMap {
+			family.ValueMap[old] = current
+		}
+	}
+}
+
+func appendUnique(values []string, additions ...string) []string {
+	seen := make(map[string]bool, len(values)+len(additions))
+	for _, value := range values {
+		seen[value] = true
+	}
+	for _, value := range additions {
+		if value == "" || seen[value] {
+			continue
+		}
+		seen[value] = true
+		values = append(values, value)
+	}
+	return values
+}
+
+func deleteMatching(values []string, excluded map[string]bool) []string {
+	result := values[:0]
+	for _, value := range values {
+		if !excluded[value] {
+			result = append(result, value)
+		}
+	}
+	return result
+}
+
+func renderGo(families []generatedFamily) ([]byte, error) {
+	var out bytes.Buffer
+	out.WriteString("// Code generated by scripts/semconv. DO NOT EDIT.\n\n")
+	out.WriteString("package semconv\n\n")
+	needsTelemetryTypes := false
+	for _, family := range families {
+		if len(family.Contexts) > 0 || len(family.Signals) > 0 {
+			needsTelemetryTypes = true
+			break
+		}
+	}
+	if needsTelemetryTypes {
+		out.WriteString("import \"github.com/SigNoz/signoz/pkg/types/telemetrytypes\"\n\n")
+	}
+	out.WriteString("var families = []Family{\n")
+	for _, family := range families {
+		contexts, err := goFieldContextSlice(family.Contexts)
+		if err != nil {
+			return nil, fmt.Errorf("render family %q: %w", family.Current, err)
+		}
+		signals, err := goSignalSlice(family.Signals)
+		if err != nil {
+			return nil, fmt.Errorf("render family %q: %w", family.Current, err)
+		}
+		out.WriteString("\t{\n")
+		fmt.Fprintf(&out, "\t\tCurrent: %s,\n", strconv.Quote(family.Current))
+		fmt.Fprintf(&out, "\t\tOld: %s,\n", goStringSlice(family.Old))
+		if family.Kind == kindMetric {
+			out.WriteString("\t\tKind: KindMetric,\n")
+		} else {
+			out.WriteString("\t\tKind: KindAttribute,\n")
+		}
+		fmt.Fprintf(&out, "\t\tContexts: %s,\n", contexts)
+		fmt.Fprintf(&out, "\t\tSignals: %s,\n", signals)
+		fmt.Fprintf(&out, "\t\tApplyToMetrics: %s,\n", goStringSlice(family.ApplyToMetrics))
+		if len(family.ValueMap) > 0 {
+			out.WriteString("\t\tValueMap: map[string]string{\n")
+			keys := sortedMapKeys(family.ValueMap)
+			for _, key := range keys {
+				fmt.Fprintf(&out, "\t\t\t%s: %s,\n", strconv.Quote(key), strconv.Quote(family.ValueMap[key]))
+			}
+			out.WriteString("\t\t},\n")
+		}
+		out.WriteString("\t},\n")
+	}
+	out.WriteString("}\n")
+	return format.Source(out.Bytes())
+}
+
+func goStringSlice(values []string) string {
+	if len(values) == 0 {
+		return "nil"
+	}
+	quoted := make([]string, len(values))
+	for i, value := range values {
+		quoted[i] = strconv.Quote(value)
+	}
+	return "[]string{" + strings.Join(quoted, ", ") + "}"
+}
+
+func goFieldContextSlice(values []string) (string, error) {
+	if len(values) == 0 {
+		return "nil", nil
+	}
+	constants := make([]string, len(values))
+	for i, value := range values {
+		switch value {
+		case "metric":
+			constants[i] = "telemetrytypes.FieldContextMetric"
+		case "resource":
+			constants[i] = "telemetrytypes.FieldContextResource"
+		case "attribute":
+			constants[i] = "telemetrytypes.FieldContextAttribute"
+		default:
+			return "", fmt.Errorf("unsupported field context %q", value)
+		}
+	}
+	return "[]telemetrytypes.FieldContext{" + strings.Join(constants, ", ") + "}", nil
+}
+
+func goSignalSlice(values []string) (string, error) {
+	if len(values) == 0 {
+		return "nil", nil
+	}
+	constants := make([]string, len(values))
+	for i, value := range values {
+		switch value {
+		case "traces":
+			constants[i] = "telemetrytypes.SignalTraces"
+		case "logs":
+			constants[i] = "telemetrytypes.SignalLogs"
+		case "metrics":
+			constants[i] = "telemetrytypes.SignalMetrics"
+		default:
+			return "", fmt.Errorf("unsupported signal %q", value)
+		}
+	}
+	return "[]telemetrytypes.Signal{" + strings.Join(constants, ", ") + "}", nil
+}
+
+func renderTypeScript(families []generatedFamily) []byte {
+	var out bytes.Buffer
+	out.WriteString("// Code generated by scripts/semconv. DO NOT EDIT.\n\n")
+	out.WriteString("export type SemconvFamily = {\n")
+	out.WriteString("\treadonly current: string;\n\treadonly old: readonly string[];\n")
+	out.WriteString("\treadonly kind: 'attribute' | 'metric';\n")
+	out.WriteString("\treadonly contexts: readonly string[];\n\treadonly signals: readonly string[];\n")
+	out.WriteString("\treadonly applyToMetrics: readonly string[];\n")
+	out.WriteString("\treadonly valueMap: Readonly<Record<string, string>>;\n};\n\n")
+	out.WriteString("export const SEMCONV_FAMILIES: readonly SemconvFamily[] = [\n")
+	for _, family := range families {
+		out.WriteString("\t{\n")
+		fmt.Fprintf(&out, "\t\tcurrent: %s,\n", tsString(family.Current))
+		fmt.Fprintf(&out, "\t\told: %s,\n", tsStringSlice(family.Old))
+		fmt.Fprintf(&out, "\t\tkind: %s,\n", tsString(family.Kind))
+		fmt.Fprintf(&out, "\t\tcontexts: %s,\n", tsStringSlice(family.Contexts))
+		fmt.Fprintf(&out, "\t\tsignals: %s,\n", tsStringSlice(family.Signals))
+		fmt.Fprintf(&out, "\t\tapplyToMetrics: %s,\n", tsStringSlice(family.ApplyToMetrics))
+		out.WriteString("\t\tvalueMap: {")
+		keys := sortedMapKeys(family.ValueMap)
+		for i, key := range keys {
+			if i > 0 {
+				out.WriteString(", ")
+			}
+			fmt.Fprintf(&out, "%s: %s", tsString(key), tsString(family.ValueMap[key]))
+		}
+		out.WriteString("},\n\t},\n")
+	}
+	out.WriteString("] as const;\n")
+	return out.Bytes()
+}
+
+func tsString(value string) string {
+	quoted := strconv.Quote(value)
+	return "'" + strings.ReplaceAll(quoted[1:len(quoted)-1], "'", `\'`) + "'"
+}
+func tsStringSlice(values []string) string {
+	quoted := make([]string, len(values))
+	for i, value := range values {
+		quoted[i] = tsString(value)
+	}
+	return "[" + strings.Join(quoted, ", ") + "]"
+}
+
+func sortedMapKeys[T any](values map[string]T) []string {
+	keys := make([]string, 0, len(values))
+	for key := range values {
+		keys = append(keys, key)
+	}
+	sort.Strings(keys)
+	return keys
+}
+
+func checkFile(path string, expected []byte) error {
+	actual, err := os.ReadFile(path)
+	if err != nil {
+		return fmt.Errorf("generated file %s is missing: run go run ./scripts/semconv", path)
+	}
+	if !bytes.Equal(actual, expected) {
+		return fmt.Errorf("generated file %s is stale: run go run ./scripts/semconv", path)
+	}
+	return nil
+}

scripts/semconv/generate_test.go

@@ -0,0 +1,366 @@
+package main
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestSchemaDecoderRejectsUnsupportedSection(t *testing.T) {
+	var schema schemaFile
+	err := decodeKnownFields([]byte(`
+versions:
+  1.0.0:
+    span_events:
+      changes:
+        - rename_events:
+            event_map:
+              old: current
+`), &schema)
+
+	assert.ErrorContains(t, err, "field span_events not found", "unsupported schema sections must fail generation")
+}
+
+func TestBuildFamiliesRejectsMalformedSchemaVersion(t *testing.T) {
+	var schema schemaFile
+	require.NoError(t, decodeKnownFields([]byte(`
+versions:
+  latest:
+    spans:
+      changes: []
+`), &schema), "test schema must decode")
+
+	_, err := buildFamilies([]schemaFile{schema}, overlayFile{})
+	assert.ErrorContains(t, err, `schema version "latest"`, "malformed versions must not be silently reordered")
+}
+
+func TestBuildFamiliesResolvesRenameChain(t *testing.T) {
+	var schema schemaFile
+	require.NoError(t, decodeKnownFields([]byte(`
+versions:
+  4.0.0:
+    spans:
+      changes:
+        - rename_attributes:
+            attribute_map:
+              a: b
+  3.0.0:
+    spans:
+      changes:
+        - rename_attributes:
+            attribute_map:
+              b: c
+              x: c
+  2.0.0:
+    spans:
+      changes:
+        - rename_attributes:
+            attribute_map:
+              a: b
+        - rename_attributes:
+            attribute_map:
+              a: b
+`), &schema), "test schema must decode")
+
+	enabled := true
+	families, err := buildFamilies([]schemaFile{schema}, overlayFile{Families: map[string]overlayFamily{
+		"c": {Enabled: &enabled},
+	}})
+	require.NoError(t, err)
+	assert.Equal(t, []generatedFamily{{
+		Current:  "c",
+		Old:      []string{"b", "x", "a"},
+		Kind:     kindAttribute,
+		Contexts: []string{"attribute"},
+		Signals:  []string{"traces"},
+	}}, families, "predecessors should be ordered by distance and then name")
+}
+
+func TestBuildFamiliesMapsSchemaSectionsToScopes(t *testing.T) {
+	var schema schemaFile
+	require.NoError(t, decodeKnownFields([]byte(`
+versions:
+  1.0.0:
+    resources:
+      changes:
+        - rename_attributes:
+            attribute_map:
+              resource.old: resource.current
+    logs:
+      changes:
+        - rename_attributes:
+            attribute_map:
+              log.old: log.current
+    metrics:
+      changes:
+        - rename_attributes:
+            attribute_map:
+              state: cpu.mode
+            apply_to_metrics: [system.cpu.time]
+        - rename_metrics:
+            old.metric: current.metric
+`), &schema), "test schema must decode")
+
+	enabled := true
+	families, err := buildFamilies([]schemaFile{schema}, overlayFile{Families: map[string]overlayFamily{
+		"resource.current": {Enabled: &enabled},
+		"log.current":      {Enabled: &enabled},
+		"cpu.mode":         {Enabled: &enabled},
+		"current.metric":   {Enabled: &enabled, Kind: kindMetric},
+	}})
+	require.NoError(t, err)
+	assert.Equal(t, []generatedFamily{
+		{
+			Current: "cpu.mode", Old: []string{"state"}, Kind: kindAttribute,
+			Contexts: []string{"attribute"}, Signals: []string{"metrics"},
+			ApplyToMetrics: []string{"system.cpu.time"},
+		},
+		{
+			Current: "current.metric", Old: []string{"old.metric"}, Kind: kindMetric,
+			Contexts: []string{"metric"}, Signals: []string{"metrics"},
+		},
+		{
+			Current: "log.current", Old: []string{"log.old"}, Kind: kindAttribute,
+			Contexts: []string{"attribute"}, Signals: []string{"logs"},
+		},
+		{
+			Current: "resource.current", Old: []string{"resource.old"}, Kind: kindAttribute,
+			Contexts: []string{"resource"},
+		},
+	}, families, "schema sections should produce their documented signal and context scopes")
+}
+
+func TestOverlayAddsFamilyWithoutSchemaHistory(t *testing.T) {
+	enabled := true
+	families, err := buildFamilies(nil, overlayFile{Families: map[string]overlayFamily{
+		"added.current": {
+			Enabled:  &enabled,
+			Old:      []string{"added.old"},
+			Contexts: []string{"resource"},
+			Signals:  []string{"traces"},
+		},
+	}})
+
+	require.NoError(t, err)
+	assert.Equal(t, []generatedFamily{{
+		Current:  "added.current",
+		Old:      []string{"added.old"},
+		Kind:     kindAttribute,
+		Contexts: []string{"resource"},
+		Signals:  []string{"traces"},
+	}}, families, "an explicit overlay family should not require schema history")
+}
+
+func TestOverlayOverridesGeneratedFamily(t *testing.T) {
+	var schema schemaFile
+	require.NoError(t, decodeKnownFields([]byte(`
+versions:
+  1.0.0:
+    spans:
+      changes:
+        - rename_attributes:
+            attribute_map:
+              old: current
+`), &schema), "test schema must decode")
+
+	enabled := true
+	families, err := buildFamilies([]schemaFile{schema}, overlayFile{Families: map[string]overlayFamily{
+		"current": {
+			Enabled:     &enabled,
+			AddOld:      []string{"older"},
+			ExcludeOld:  []string{"old"},
+			AddContexts: []string{"resource"},
+			AddSignals:  []string{"logs"},
+			ValueMap:    map[string]string{"legacy": "current"},
+		},
+	}})
+
+	require.NoError(t, err)
+	assert.Equal(t, []generatedFamily{{
+		Current:  "current",
+		Old:      []string{"older"},
+		Kind:     kindAttribute,
+		Contexts: []string{"attribute", "resource"},
+		Signals:  []string{"logs", "traces"},
+		ValueMap: map[string]string{"legacy": "current"},
+	}}, families, "overlay additions and exclusions should be applied to the generated family")
+}
+
+func TestOverlayDisablesFamilyWhenDefaultIsEnabled(t *testing.T) {
+	var schema schemaFile
+	require.NoError(t, decodeKnownFields([]byte(`
+versions:
+  1.0.0:
+    spans:
+      changes:
+        - rename_attributes:
+            attribute_map:
+              old: current
+`), &schema), "test schema must decode")
+
+	disabled := false
+	families, err := buildFamilies([]schemaFile{schema}, overlayFile{
+		DefaultEnabled: true,
+		Families: map[string]overlayFamily{
+			"current": {Enabled: &disabled},
+		},
+	})
+
+	require.NoError(t, err)
+	assert.Empty(t, families, "an explicitly disabled family must override default_enabled")
+}
+
+func TestRenderGoIsDeterministic(t *testing.T) {
+	families := []generatedFamily{{
+		Current: "current", Old: []string{"old"}, Kind: kindAttribute,
+		ValueMap: map[string]string{"b": "2", "a": "1"},
+	}}
+
+	first, err := renderGo(families)
+	require.NoError(t, err)
+	second, err := renderGo(families)
+	require.NoError(t, err)
+	assert.Equal(t, first, second, "Go generation must not depend on map iteration order")
+}
+
+func TestRenderGoUsesCanonicalTelemetryTypes(t *testing.T) {
+	families := []generatedFamily{{
+		Current: "current", Old: []string{"old"}, Kind: kindAttribute,
+		Contexts: []string{"resource"}, Signals: []string{"traces"},
+	}}
+
+	output, err := renderGo(families)
+	require.NoError(t, err)
+	assert.Contains(t, string(output), "telemetrytypes.FieldContextResource", "generated contexts should use telemetrytypes")
+	assert.Contains(t, string(output), "telemetrytypes.SignalTraces", "generated signals should use telemetrytypes")
+}
+
+func TestRenderTypeScriptIsDeterministic(t *testing.T) {
+	families := []generatedFamily{{
+		Current: "current", Old: []string{"old"}, Kind: kindAttribute,
+		ValueMap: map[string]string{"b": "2", "a": "1"},
+	}}
+
+	assert.Equal(t, renderTypeScript(families), renderTypeScript(families), "TypeScript generation must not depend on map iteration order")
+}
+
+func TestBuildFamiliesHandlesRenameRollback(t *testing.T) {
+	var schema schemaFile
+	require.NoError(t, decodeKnownFields([]byte(`
+versions:
+  2.0.0:
+    metrics:
+      changes:
+        - rename_metrics:
+            temporary: original
+  1.0.0:
+    metrics:
+      changes:
+        - rename_metrics:
+            original: temporary
+`), &schema), "test schema must decode")
+
+	enabled := true
+	families, err := buildFamilies([]schemaFile{schema}, overlayFile{Families: map[string]overlayFamily{
+		"original": {Enabled: &enabled, Kind: kindMetric},
+	}})
+
+	require.NoError(t, err)
+	assert.Equal(t, []generatedFamily{{
+		Current:  "original",
+		Old:      []string{"temporary"},
+		Kind:     kindMetric,
+		Contexts: []string{"metric"},
+		Signals:  []string{"metrics"},
+	}}, families, "the latest rollback destination should remain the family root")
+}
+
+func TestBuildFamiliesRejectsSameVersionRenameChain(t *testing.T) {
+	var schema schemaFile
+	require.NoError(t, decodeKnownFields([]byte(`
+versions:
+  1.0.0:
+    spans:
+      changes:
+        - rename_attributes:
+            attribute_map:
+              x: y
+              y: z
+`), &schema), "test schema must decode")
+
+	_, err := buildFamilies([]schemaFile{schema}, overlayFile{})
+	assert.ErrorContains(t, err, `same-version attribute rename chain through "y"`, "order-sensitive same-version chains must be rejected")
+}
+
+func TestBuildFamiliesRejectsOverlayFamilyWithoutHistory(t *testing.T) {
+	enabled := true
+	_, err := buildFamilies(nil, overlayFile{Families: map[string]overlayFamily{
+		"missing": {Enabled: &enabled},
+	}})
+
+	assert.ErrorContains(t, err, `overlay family "missing" with kind "attribute" is absent`, "an overlay cannot invent a family without old members")
+}
+
+func TestBuildFamiliesRejectsEnabledFamilyWithoutOldMembers(t *testing.T) {
+	var schema schemaFile
+	require.NoError(t, decodeKnownFields([]byte(`
+versions:
+  1.0.0:
+    spans:
+      changes:
+        - rename_attributes:
+            attribute_map:
+              old: current
+`), &schema), "test schema must decode")
+
+	enabled := true
+	_, err := buildFamilies([]schemaFile{schema}, overlayFile{Families: map[string]overlayFamily{
+		"current": {Enabled: &enabled, ExcludeOld: []string{"old"}},
+	}})
+	assert.ErrorContains(t, err, `enabled family "current" with kind "attribute" has no old members`, "exclude_old cannot empty an enabled family")
+}
+
+func TestOverlayKindDefaultsToAttribute(t *testing.T) {
+	var schema schemaFile
+	require.NoError(t, decodeKnownFields([]byte(`
+versions:
+  1.0.0:
+    spans:
+      changes:
+        - rename_attributes:
+            attribute_map:
+              attribute.old: shared.current
+    metrics:
+      changes:
+        - rename_metrics:
+            metric.old: shared.current
+`), &schema), "test schema must decode")
+
+	enabled := true
+	families, err := buildFamilies([]schemaFile{schema}, overlayFile{Families: map[string]overlayFamily{
+		"shared.current": {Enabled: &enabled},
+	}})
+
+	require.NoError(t, err)
+	assert.Equal(t, []generatedFamily{{
+		Current:  "shared.current",
+		Old:      []string{"attribute.old"},
+		Kind:     kindAttribute,
+		Contexts: []string{"attribute"},
+		Signals:  []string{"traces"},
+	}}, families, "a kind-less overlay policy should affect only the attribute family")
+}
+
+func TestCheckFileReportsStaleOutput(t *testing.T) {
+	path := filepath.Join(t.TempDir(), "generated.go")
+	require.NoError(t, os.WriteFile(path, []byte("old"), 0o600), "test output must be writable")
+
+	assert.ErrorContains(t, checkFile(path, []byte("new")), "is stale", "check mode must reject stale generated output")
+}
+
+func TestTypeScriptStringEscapesControlCharacters(t *testing.T) {
+	assert.Equal(t, `'line\n\t\x01\'\\end'`, tsString("line\n\t\x01'\\end"), "generated TypeScript strings must remain valid literals")
+}

scripts/semconv/overlay.yaml

@@ -0,0 +1,11 @@
+# SigNoz semantic-convention rollout policy.
+#
+# Families are keyed by their current OpenTelemetry name. Schema-derived
+# families are disabled by default so rollout remains explicit and reversible.
+default_enabled: false
+
+families:
+  deployment.environment.name:
+    enabled: true
+  db.system.name:
+    enabled: true

scripts/semconv/schema-1.42.0.yaml

@@ -0,0 +1,760 @@
+
+
+file_format: 1.1.0
+schema_url: https://opentelemetry.io/schemas/1.42.0
+versions:
+  1.42.0:
+    metrics:
+      changes:
+        - rename_metrics:
+            v8js.memory.heap.limit: v8js.memory.heap.space.size
+  1.41.1:
+  1.41.0:
+    metrics:
+      changes:
+        - rename_metrics:
+            k8s.container.cpu.limit: k8s.container.cpu.limit.desired
+            k8s.container.cpu.limit_utilization: k8s.container.cpu.limit.utilization
+            k8s.container.cpu.request: k8s.container.cpu.request.desired
+            k8s.container.cpu.request_utilization: k8s.container.cpu.request.utilization
+            k8s.container.memory.limit: k8s.container.memory.limit.desired
+            k8s.container.memory.request: k8s.container.memory.request.desired
+  1.40.0:
+    all:
+      changes:
+        - rename_attributes:
+            attribute_map:
+              feature_flag.evaluation.error.message: feature_flag.error.message
+    metrics:
+      changes:
+        - rename_metrics:
+            system.memory.shared: system.memory.linux.shared
+  1.39.0:
+    all:
+      changes:
+        - rename_attributes:
+            attribute_map:
+              linux.memory.slab.state: system.memory.linux.slab.state
+              peer.service: service.peer.name
+              rpc.connect_rpc.error_code: rpc.response.status_code
+              rpc.connect_rpc.request.metadata: rpc.request.metadata
+              rpc.connect_rpc.response.metadata: rpc.response.metadata
+              rpc.grpc.request.metadata: rpc.request.metadata
+              rpc.grpc.response.metadata: rpc.response.metadata
+              rpc.jsonrpc.request_id: jsonrpc.request.id
+              rpc.jsonrpc.version: jsonrpc.protocol.version
+              rpc.system: rpc.system.name
+    metrics:
+      changes:
+        - rename_metrics:
+            process.open_file_descriptor.count: process.unix.file_descriptor.count
+            system.linux.memory.available: system.memory.linux.available
+            system.linux.memory.slab.usage: system.memory.linux.slab.usage
+  1.38.0:
+    all:
+      changes:
+        - rename_attributes:
+            attribute_map:
+              process.context_switch_type: process.context_switch.type
+              process.paging.fault_type: system.paging.fault.type
+              system.cpu.logical_number: cpu.logical_number
+              system.paging.type: system.paging.fault.type
+              system.process.status: process.state
+              system.processes.status: process.state
+    metrics:
+      changes:
+        - rename_metrics:
+            k8s.cronjob.active_jobs: k8s.cronjob.job.active
+            k8s.daemonset.current_scheduled_nodes: k8s.daemonset.node.current_scheduled
+            k8s.daemonset.desired_scheduled_nodes: k8s.daemonset.node.desired_scheduled
+            k8s.daemonset.misscheduled_nodes: k8s.daemonset.node.misscheduled
+            k8s.daemonset.ready_nodes: k8s.daemonset.node.ready
+            k8s.deployment.available_pods: k8s.deployment.pod.available
+            k8s.deployment.desired_pods: k8s.deployment.pod.desired
+            k8s.hpa.current_pods: k8s.hpa.pod.current
+            k8s.hpa.desired_pods: k8s.hpa.pod.desired
+            k8s.hpa.max_pods: k8s.hpa.pod.max
+            k8s.hpa.min_pods: k8s.hpa.pod.min
+            k8s.job.active_pods: k8s.job.pod.active
+            k8s.job.desired_successful_pods: k8s.job.pod.desired_successful
+            k8s.job.failed_pods: k8s.job.pod.failed
+            k8s.job.max_parallel_pods: k8s.job.pod.max_parallel
+            k8s.job.successful_pods: k8s.job.pod.successful
+            k8s.node.allocatable.cpu: k8s.node.cpu.allocatable
+            k8s.node.allocatable.ephemeral_storage: k8s.node.ephemeral_storage.allocatable
+            k8s.node.allocatable.memory: k8s.node.memory.allocatable
+            k8s.node.allocatable.pods: k8s.node.pod.allocatable
+            k8s.replicaset.available_pods: k8s.replicaset.pod.available
+            k8s.replicaset.desired_pods: k8s.replicaset.pod.desired
+            k8s.replication_controller.available_pods: k8s.replicationcontroller.pod.available
+            k8s.replication_controller.desired_pods: k8s.replicationcontroller.pod.desired
+            k8s.replicationcontroller.available_pods: k8s.replicationcontroller.pod.available
+            k8s.replicationcontroller.desired_pods: k8s.replicationcontroller.pod.desired
+            k8s.statefulset.current_pods: k8s.statefulset.pod.current
+            k8s.statefulset.desired_pods: k8s.statefulset.pod.desired
+            k8s.statefulset.ready_pods: k8s.statefulset.pod.ready
+            k8s.statefulset.updated_pods: k8s.statefulset.pod.updated
+            v8js.heap.space.available_size: v8js.memory.heap.space.available_size
+            v8js.heap.space.physical_size: v8js.memory.heap.space.physical_size
+  1.37.0:
+    all:
+      changes:
+        - rename_attributes:
+            attribute_map:
+              android.state: android.app.state
+              container.runtime: container.runtime.name
+              enduser.role: user.roles
+              gen_ai.openai.request.service_tier: openai.request.service_tier
+              gen_ai.openai.response.service_tier: openai.response.service_tier
+              gen_ai.openai.response.system_fingerprint: openai.response.system_fingerprint
+              gen_ai.system: gen_ai.provider.name
+              ios.state: ios.app.state
+  1.36.0:
+  1.35.0:
+    all:
+      changes:
+        # https://github.com/open-telemetry/semantic-conventions/pull/1698
+        - rename_attributes:
+            attribute_map:
+              az.namespace: azure.resource_provider.namespace
+              az.service_request_id: azure.service.request.id
+    metrics:
+      changes:
+        # https://github.com/open-telemetry/semantic-conventions/issues/1800
+        - rename_metrics:
+            system.network.connections: system.network.connection.count
+  1.34.0:
+    metrics:
+      changes:
+        # https://github.com/open-telemetry/semantic-conventions/pull/2295
+        - rename_metrics:
+            cpu.time: system.cpu.time
+            cpu.utilization: system.cpu.utilization
+            cpu.frequency: system.cpu.frequency
+  1.33.0:
+    all:
+      changes:
+        # https://github.com/open-telemetry/semantic-conventions/pull/1982
+        - rename_attributes:
+            attribute_map:
+              feature_flag.provider_name: feature_flag.provider.name
+        # https://github.com/open-telemetry/semantic-conventions/pull/1994
+        - rename_attributes:
+            attribute_map:
+              feature_flag.evaluation.error.message: error.message
+  1.32.0:
+    all:
+      changes:
+        # https://github.com/open-telemetry/semantic-conventions/pull/1989
+        - rename_attributes:
+            attribute_map:
+              feature_flag.evaluation.reason: feature_flag.result.reason
+              feature_flag.variant: feature_flag.result.variant
+    metrics:
+      changes:
+        # https://github.com/open-telemetry/semantic-conventions/pull/2042
+        - rename_metrics:
+            otel.sdk.span.live.count: otel.sdk.span.live
+            otel.sdk.span.ended.count: otel.sdk.span.ended
+            otel.sdk.processor.span.processed.count: otel.sdk.processor.span.processed
+            otel.sdk.exporter.span.inflight.count: otel.sdk.exporter.span.inflight
+            otel.sdk.exporter.span.exported.count: otel.sdk.exporter.span.exported
+  1.31.0:
+    all:
+      changes:
+        # https://github.com/open-telemetry/semantic-conventions/pull/1880
+        - rename_attributes:
+            attribute_map:
+              android.state: android.app.state
+              io.state: ios.app.state
+    metrics:
+      changes:
+        - rename_metrics:
+            k8s.replication_controller.desired_pods: k8s.replicationcontroller.desired_pods
+            k8s.replication_controller.available_pods: k8s.replicationcontroller.available_pods
+        # https://github.com/open-telemetry/semantic-conventions/pull/1896
+        - rename_metrics:
+            system.cpu.time: cpu.time
+            system.cpu.utilization: cpu.utilization
+            system.cpu.frequency: cpu.frequency
+        # https://github.com/open-telemetry/semantic-conventions/pull/1896
+        - rename_attributes:
+            attribute_map:
+              system.cpu.logical_number: cpu.logical_number
+  1.30.0:
+    all:
+      changes:
+        # https://github.com/open-telemetry/semantic-conventions/pull/1632
+        - rename_attributes:
+            attribute_map:
+              gen_ai.openai.request.seed: gen_ai.request.seed
+              system.network.state: network.connection.state
+        # https://github.com/open-telemetry/semantic-conventions/pull/1624
+        - rename_attributes:
+            attribute_map:
+              code.function: code.function.name
+              code.filepath: code.file.path
+              code.lineno: code.line.number
+              code.column: code.column.number
+        # https://github.com/open-telemetry/semantic-conventions/pull/1734
+        - rename_attributes:
+            attribute_map:
+              db.system: db.system.name
+              db.cassandra.coordinator.dc: cassandra.coordinator.dc
+              db.cassandra.coordinator.id: cassandra.coordinator.id
+              db.cassandra.consistency_level: cassandra.consistency.level
+              db.cassandra.idempotence: cassandra.query.idempotent
+              db.cassandra.page_size: cassandra.page.size
+              db.cassandra.speculative_execution_count: cassandra.speculative_execution.count
+              db.cosmosdb.client_id: azure.client.id
+              db.cosmosdb.connection_mode: azure.cosmosdb.connection.mode
+              db.cosmosdb.consistency_level: azure.cosmosdb.consistency.level
+              db.cosmosdb.request_charge: azure.cosmosdb.operation.request_charge
+              db.cosmosdb.request_content_length: azure.cosmosdb.request.body.size
+              db.cosmosdb.regions_contacted: azure.cosmosdb.operation.contacted_regions
+              db.cosmosdb.sub_status_code: azure.cosmosdb.response.sub_status_code
+              db.elasticsearch.node.name: elasticsearch.node.name
+              # db.elasticsearch.path_parts is a template attribute, schema transformation
+              # does not support it, adding as a comment for consistency
+              # db.elasticsearch.path_parts.<key> -> db.operation.parameter.<key>
+    metrics:
+      changes:
+        - rename_metrics:
+            db.client.cosmosdb.operation.request_charge: azure.cosmosdb.client.operation.request_charge
+            db.client.cosmosdb.active_instance.count: azure.cosmosdb.client.active_instance.count
+
+  1.29.0:
+    all:
+      changes:
+        # https://github.com/open-telemetry/semantic-conventions/pull/1520
+        - rename_attributes:
+            attribute_map:
+              process.executable.build_id.profiling: process.executable.build_id.htlhash
+        # https://github.com/open-telemetry/semantic-conventions/pull/1383
+        - rename_attributes:
+            attribute_map:
+              vcs.repository.change.id: vcs.change.id
+              vcs.repository.change.title: vcs.change.title
+              vcs.repository.ref.name: vcs.ref.head.name
+              vcs.repository.ref.revision: vcs.ref.head.revision
+              vcs.repository.ref.type: vcs.ref.head.type
+    metrics:
+      changes:
+        # https://github.com/open-telemetry/semantic-conventions/pull/1492
+        - rename_attributes:
+            attribute_map:
+              system.device: network.interface.name
+            apply_to_metrics:
+              - container.network.io
+              - system.network.dropped
+              - system.network.errors
+              - system.network.io
+              - system.network.connections
+  1.28.0:
+    metrics:
+      changes:
+        # https://github.com/open-telemetry/semantic-conventions/pull/1422
+        - rename_metrics:
+            messaging.client.published.messages: messaging.client.sent.messages
+  1.27.0:
+    all:
+      changes:
+        # https://github.com/open-telemetry/semantic-conventions/pull/1216
+        - rename_attributes:
+            attribute_map:
+              tls.client.server_name: server.address
+        # https://github.com/open-telemetry/semantic-conventions/pull/1075
+        - rename_attributes:
+            attribute_map:
+              deployment.environment: deployment.environment.name
+        # https://github.com/open-telemetry/semantic-conventions/pull/1245
+        - rename_attributes:
+            attribute_map:
+              messaging.kafka.message.offset: messaging.kafka.offset
+        # https://github.com/open-telemetry/semantic-conventions/pull/815
+        - rename_attributes:
+            attribute_map:
+              messaging.kafka.consumer.group: messaging.consumer.group.name
+              messaging.rocketmq.client_group: messaging.consumer.group.name
+              messaging.eventhubs.consumer.group: messaging.consumer.group.name
+              messaging.servicebus.destination.subscription_name: messaging.destination.subscription.name
+        # https://github.com/open-telemetry/semantic-conventions/pull/1200
+        - rename_attributes:
+            attribute_map:
+              gen_ai.usage.completion_tokens: gen_ai.usage.output_tokens
+              gen_ai.usage.prompt_tokens: gen_ai.usage.input_tokens
+    spans:
+      changes:
+        # https://github.com/open-telemetry/semantic-conventions/pull/1002
+        - rename_attributes:
+            attribute_map:
+              db.elasticsearch.cluster.name: db.namespace
+    metrics:
+      changes:
+        # https://github.com/open-telemetry/semantic-conventions/pull/1125
+        - rename_attributes:
+            attribute_map:
+              db.client.connections.state: db.client.connection.state
+            apply_to_metrics:
+              - db.client.connection.count
+        - rename_attributes:
+            attribute_map:
+              db.client.connections.pool.name: db.client.connection.pool.name
+            apply_to_metrics:
+              - db.client.connection.count
+              - db.client.connection.idle.max
+              - db.client.connection.idle.min
+              - db.client.connection.max
+              - db.client.connection.pending_requests
+              - db.client.connection.timeouts
+              - db.client.connection.create_time
+              - db.client.connection.wait_time
+              - db.client.connection.use_time
+        # https://github.com/open-telemetry/semantic-conventions/pull/1006
+        - rename_metrics:
+            messaging.publish.messages: messaging.client.published.messages
+        # https://github.com/open-telemetry/semantic-conventions/pull/1026
+        - rename_attributes:
+            attribute_map:
+              system.cpu.state: cpu.mode
+              process.cpu.state: cpu.mode
+              container.cpu.state: cpu.mode
+            apply_to_metrics:
+              - system.cpu.time
+              - system.cpu.utilization
+              - process.cpu.time
+              - process.cpu.utilization
+              - container.cpu.time
+        # https://github.com/open-telemetry/semantic-conventions/pull/1265
+        - rename_metrics:
+            jvm.buffer.memory.usage: jvm.buffer.memory.used
+  1.26.0:
+    metrics:
+      changes:
+        # https://github.com/open-telemetry/semantic-conventions/pull/966
+        - rename_metrics:
+            db.client.connections.usage: db.client.connection.count
+            db.client.connections.idle.max: db.client.connection.idle.max
+            db.client.connections.idle.min: db.client.connection.idle.min
+            db.client.connections.max: db.client.connection.max
+            db.client.connections.pending_requests: db.client.connection.pending_requests
+            db.client.connections.timeouts: db.client.connection.timeouts
+        # https://github.com/open-telemetry/semantic-conventions/pull/948
+        - rename_attributes:
+            attribute_map:
+              messaging.client_id: messaging.client.id
+        # https://github.com/open-telemetry/semantic-conventions/pull/909
+        - rename_attributes:
+            attribute_map:
+              state: db.client.connections.state
+            apply_to_metrics:
+              - db.client.connections.usage
+        - rename_attributes:
+            attribute_map:
+              pool.name: db.client.connections.pool.name
+            apply_to_metrics:
+              - db.client.connections.usage
+              - db.client.connections.idle.max
+              - db.client.connections.idle.min
+              - db.client.connections.max
+              - db.client.connections.pending_requests
+              - db.client.connections.timeouts
+              - db.client.connections.create_time
+              - db.client.connections.wait_time
+              - db.client.connections.use_time
+    all:
+      changes:
+        # https://github:com/open-telemetry/semantic-conventions/pull/731/
+        - rename_attributes:
+            attribute_map:
+              enduser.id: user.id
+
+  1.25.0:
+    spans:
+      changes:
+        # https://github.com/open-telemetry/semantic-conventions/pull/911
+        - rename_attributes:
+            attribute_map:
+              db.name: db.namespace
+        # https://github.com/open-telemetry/semantic-conventions/pull/870
+        - rename_attributes:
+            attribute_map:
+              db.sql.table: db.collection.name
+              db.mongodb.collection: db.collection.name
+              db.cosmosdb.container: db.collection.name
+              db.cassandra.table: db.collection.name
+        # https://github.com/open-telemetry/semantic-conventions/pull/798
+        - rename_attributes:
+            attribute_map:
+              messaging.kafka.destination.partition: messaging.destination.partition.id
+        # https://github.com/open-telemetry/semantic-conventions/pull/875
+        - rename_attributes:
+            attribute_map:
+              db.operation: db.operation.name
+        # https://github.com/open-telemetry/semantic-conventions/pull/913
+        - rename_attributes:
+            attribute_map:
+              messaging.operation: messaging.operation.type
+        # https://github.com/open-telemetry/semantic-conventions/pull/866
+        - rename_attributes:
+            attribute_map:
+              db.statement: db.query.text
+    metrics:
+      changes:
+        # https://github.com/open-telemetry/semantic-conventions/pull/484
+        - rename_attributes:
+            attribute_map:
+              system.processes.status: system.process.status
+            apply_to_metrics:
+              - system.processes.count
+        - rename_metrics:
+            system.processes.count: system.process.count
+            system.processes.created: system.process.created
+        # https://github.com/open-telemetry/semantic-conventions/pull/625
+        - rename_attributes:
+            attribute_map:
+              container.labels: container.label
+              k8s.pod.labels: k8s.pod.label
+        # https://github.com/open-telemetry/semantic-conventions/pull/330
+        - rename_metrics:
+            process.threads: process.thread.count
+            process.open_file_descriptors: process.open_file_descriptor.count
+        - rename_attributes:
+            attribute_map:
+              state: process.cpu.state
+            apply_to_metrics:
+              - process.cpu.time
+              - process.cpu.utilization
+        - rename_attributes:
+            attribute_map:
+              direction: disk.io.direction
+            apply_to_metrics:
+              - process.disk.io
+        - rename_attributes:
+            attribute_map:
+              type: process.context_switch_type
+            apply_to_metrics:
+              - process.context_switches
+        - rename_attributes:
+            attribute_map:
+              direction: network.io.direction
+            apply_to_metrics:
+              - process.network.io
+        - rename_attributes:
+            attribute_map:
+              type: process.paging.fault_type
+            apply_to_metrics:
+              - process.paging.faults
+    all:
+      changes:
+        # https://github.com/open-telemetry/semantic-conventions/pull/854
+        - rename_attributes:
+            attribute_map:
+              message.type: rpc.message.type
+              message.id: rpc.message.id
+              message.compressed_size: rpc.message.compressed_size
+              message.uncompressed_size: rpc.message.uncompressed_size
+
+  1.24.0:
+    metrics:
+      changes:
+        # https://github.com/open-telemetry/semantic-conventions/pull/536
+        - rename_metrics:
+            jvm.memory.usage: jvm.memory.used
+            jvm.memory.usage_after_last_gc: jvm.memory.used_after_last_gc
+        # https://github.com/open-telemetry/semantic-conventions/pull/530
+        - rename_attributes:
+            attribute_map:
+              system.network.io.direction: network.io.direction
+              system.disk.io.direction: disk.io.direction
+  1.23.1:
+  1.23.0:
+    metrics:
+      changes:
+        # https://github.com/open-telemetry/semantic-conventions/pull/20
+        - rename_attributes:
+            attribute_map:
+              thread.daemon: jvm.thread.daemon
+            apply_to_metrics:
+              - jvm.thread.count
+  1.22.0:
+    spans:
+      changes:
+        # https://github.com/open-telemetry/semantic-conventions/pull/229
+        - rename_attributes:
+            attribute_map:
+              messaging.message.payload_size_bytes: messaging.message.body.size
+        # https://github.com/open-telemetry/opentelemetry-specification/pull/374
+        - rename_attributes:
+            attribute_map:
+              http.resend_count: http.request.resend_count
+    metrics:
+      changes:
+        # https://github.com/open-telemetry/semantic-conventions/pull/224
+        - rename_metrics:
+            http.client.duration: http.client.request.duration
+            http.server.duration: http.server.request.duration
+        # https://github.com/open-telemetry/semantic-conventions/pull/241
+        - rename_metrics:
+            process.runtime.jvm.memory.usage: jvm.memory.usage
+            process.runtime.jvm.memory.committed: jvm.memory.committed
+            process.runtime.jvm.memory.limit: jvm.memory.limit
+            process.runtime.jvm.memory.usage_after_last_gc: jvm.memory.usage_after_last_gc
+            process.runtime.jvm.gc.duration: jvm.gc.duration
+            # also https://github.com/open-telemetry/semantic-conventions/pull/252
+            process.runtime.jvm.threads.count: jvm.thread.count
+            # also https://github.com/open-telemetry/semantic-conventions/pull/252
+            process.runtime.jvm.classes.loaded: jvm.class.loaded
+            # also https://github.com/open-telemetry/semantic-conventions/pull/252
+            process.runtime.jvm.classes.unloaded: jvm.class.unloaded
+            # also https://github.com/open-telemetry/semantic-conventions/pull/252
+            # and https://github.com/open-telemetry/semantic-conventions/pull/60
+            process.runtime.jvm.classes.current_loaded: jvm.class.count
+            process.runtime.jvm.cpu.time: jvm.cpu.time
+            process.runtime.jvm.cpu.recent_utilization: jvm.cpu.recent_utilization
+            process.runtime.jvm.memory.init: jvm.memory.init
+            process.runtime.jvm.system.cpu.utilization: jvm.system.cpu.utilization
+            process.runtime.jvm.system.cpu.load_1m: jvm.system.cpu.load_1m
+            # https://github.com/open-telemetry/semantic-conventions/pull/253
+            process.runtime.jvm.buffer.usage: jvm.buffer.memory.usage
+            # https://github.com/open-telemetry/semantic-conventions/pull/253
+            process.runtime.jvm.buffer.limit: jvm.buffer.memory.limit
+            process.runtime.jvm.buffer.count: jvm.buffer.count
+        # https://github.com/open-telemetry/semantic-conventions/pull/20
+        - rename_attributes:
+            attribute_map:
+              type: jvm.memory.type
+              pool: jvm.memory.pool.name
+            apply_to_metrics:
+              - jvm.memory.usage
+              - jvm.memory.committed
+              - jvm.memory.limit
+              - jvm.memory.usage_after_last_gc
+              - jvm.memory.init
+        - rename_attributes:
+            attribute_map:
+              name: jvm.gc.name
+              action: jvm.gc.action
+            apply_to_metrics:
+              - jvm.gc.duration
+        - rename_attributes:
+            attribute_map:
+              daemon: thread.daemon
+            apply_to_metrics:
+              - jvm.threads.count
+        - rename_attributes:
+            attribute_map:
+              pool: jvm.buffer.pool.name
+            apply_to_metrics:
+              - jvm.buffer.memory.usage
+              - jvm.buffer.memory.limit
+              - jvm.buffer.count
+        # https://github.com/open-telemetry/semantic-conventions/pull/89
+        - rename_attributes:
+            attribute_map:
+              state: system.cpu.state
+              cpu: system.cpu.logical_number
+            apply_to_metrics:
+              - system.cpu.time
+              - system.cpu.utilization
+        - rename_attributes:
+            attribute_map:
+              state: system.memory.state
+            apply_to_metrics:
+              - system.memory.usage
+              - system.memory.utilization
+        - rename_attributes:
+            attribute_map:
+              state: system.paging.state
+            apply_to_metrics:
+              - system.paging.usage
+              - system.paging.utilization
+        - rename_attributes:
+            attribute_map:
+              type: system.paging.type
+              direction: system.paging.direction
+            apply_to_metrics:
+              - system.paging.faults
+              - system.paging.operations
+        - rename_attributes:
+            attribute_map:
+              device: system.device
+              direction: system.disk.direction
+            apply_to_metrics:
+              - system.disk.io
+              - system.disk.operations
+              - system.disk.io_time
+              - system.disk.operation_time
+              - system.disk.merged
+        - rename_attributes:
+            attribute_map:
+              device: system.device
+              state: system.filesystem.state
+              type: system.filesystem.type
+              mode: system.filesystem.mode
+              mountpoint: system.filesystem.mountpoint
+            apply_to_metrics:
+              - system.filesystem.usage
+              - system.filesystem.utilization
+        - rename_attributes:
+            attribute_map:
+              device: system.device
+              direction: system.network.direction
+              protocol: network.protocol
+              state: system.network.state
+            apply_to_metrics:
+              - system.network.dropped
+              - system.network.packets
+              - system.network.errors
+              - system.network.io
+              - system.network.connections
+        - rename_attributes:
+            attribute_map:
+              status: system.processes.status
+            apply_to_metrics:
+              - system.processes.count
+        # https://github.com/open-telemetry/semantic-conventions/pull/247
+        - rename_metrics:
+            http.server.request.size: http.server.request.body.size
+            http.server.response.size: http.server.response.body.size
+    resources:
+      changes:
+        # https://github.com/open-telemetry/semantic-conventions/pull/178
+        - rename_attributes:
+            attribute_map:
+              telemetry.auto.version: telemetry.distro.version
+  1.21.0:
+    spans:
+      changes:
+        # https://github.com/open-telemetry/opentelemetry-specification/pull/3336
+        - rename_attributes:
+            attribute_map:
+              messaging.kafka.client_id: messaging.client_id
+              messaging.rocketmq.client_id: messaging.client_id
+        # https://github.com/open-telemetry/opentelemetry-specification/pull/3402
+        - rename_attributes:
+            attribute_map:
+              # net.peer.(name|port) attributes were usually populated on client side
+              # so they should be usually translated to server.(address|port)
+              # net.host.* attributes were only populated on server side
+              net.host.name: server.address
+              net.host.port: server.port
+              # was only populated on client side
+              net.sock.peer.name: server.socket.domain
+              # net.sock.peer.(addr|port) mapping is not possible
+              # since they applied to both client and server side
+              # were only populated on server side
+              net.sock.host.addr: server.socket.address
+              net.sock.host.port: server.socket.port
+              http.client_ip: client.address
+        # https://github.com/open-telemetry/opentelemetry-specification/pull/3426
+        - rename_attributes:
+            attribute_map:
+              net.protocol.name: network.protocol.name
+              net.protocol.version: network.protocol.version
+              net.host.connection.type: network.connection.type
+              net.host.connection.subtype: network.connection.subtype
+              net.host.carrier.name: network.carrier.name
+              net.host.carrier.mcc: network.carrier.mcc
+              net.host.carrier.mnc: network.carrier.mnc
+              net.host.carrier.icc: network.carrier.icc
+        # https://github.com/open-telemetry/opentelemetry-specification/pull/3355
+        - rename_attributes:
+            attribute_map:
+              http.method: http.request.method
+              http.status_code: http.response.status_code
+              http.scheme: url.scheme
+              http.url: url.full
+              http.request_content_length: http.request.body.size
+              http.response_content_length: http.response.body.size
+    metrics:
+      changes:
+        # https://github.com/open-telemetry/semantic-conventions/pull/53
+        - rename_metrics:
+            process.runtime.jvm.cpu.utilization: process.runtime.jvm.cpu.recent_utilization
+  1.20.0:
+    spans:
+      changes:
+        # https://github.com/open-telemetry/opentelemetry-specification/pull/3272
+        - rename_attributes:
+            attribute_map:
+              net.app.protocol.name: net.protocol.name
+              net.app.protocol.version: net.protocol.version
+  1.19.0:
+    spans:
+      changes:
+        # https://github.com/open-telemetry/opentelemetry-specification/pull/3209
+        - rename_attributes:
+            attribute_map:
+              faas.execution: faas.invocation_id
+        # https://github.com/open-telemetry/opentelemetry-specification/pull/3188
+        - rename_attributes:
+            attribute_map:
+              faas.id: cloud.resource_id
+        # https://github.com/open-telemetry/opentelemetry-specification/pull/3190
+        - rename_attributes:
+            attribute_map:
+              http.user_agent: user_agent.original
+    resources:
+      changes:
+        # https://github.com/open-telemetry/opentelemetry-specification/pull/3190
+        - rename_attributes:
+            attribute_map:
+              browser.user_agent: user_agent.original
+  1.18.0:
+  1.17.0:
+    spans:
+      changes:
+        # https://github.com/open-telemetry/opentelemetry-specification/pull/2957
+        - rename_attributes:
+            attribute_map:
+              messaging.consumer_id: messaging.consumer.id
+              messaging.protocol: net.app.protocol.name
+              messaging.protocol_version: net.app.protocol.version
+              messaging.destination: messaging.destination.name
+              messaging.temp_destination: messaging.destination.temporary
+              messaging.destination_kind: messaging.destination.kind
+              messaging.message_id: messaging.message.id
+              messaging.conversation_id: messaging.message.conversation_id
+              messaging.message_payload_size_bytes: messaging.message.payload_size_bytes
+              messaging.message_payload_compressed_size_bytes: messaging.message.payload_compressed_size_bytes
+              messaging.rabbitmq.routing_key: messaging.rabbitmq.destination.routing_key
+              messaging.kafka.message_key: messaging.kafka.message.key
+              messaging.kafka.partition: messaging.kafka.destination.partition
+              messaging.kafka.tombstone: messaging.kafka.message.tombstone
+              messaging.rocketmq.message_type: messaging.rocketmq.message.type
+              messaging.rocketmq.message_tag: messaging.rocketmq.message.tag
+              messaging.rocketmq.message_keys: messaging.rocketmq.message.keys
+              messaging.kafka.consumer_group: messaging.kafka.consumer.group
+  1.16.0:
+  1.15.0:
+    spans:
+      changes:
+        # https://github.com/open-telemetry/opentelemetry-specification/pull/2743
+        - rename_attributes:
+            attribute_map:
+              http.retry_count: http.resend_count
+  1.14.0:
+  1.13.0:
+    spans:
+      changes:
+        # https://github.com/open-telemetry/opentelemetry-specification/pull/2614
+        - rename_attributes:
+            attribute_map:
+              net.peer.ip: net.sock.peer.addr
+              net.host.ip: net.sock.host.addr
+  1.12.0:
+  1.11.0:
+  1.10.0:
+  1.9.0:
+  1.8.0:
+    spans:
+      changes:
+        - rename_attributes:
+            attribute_map:
+              db.cassandra.keyspace: db.name
+              db.hbase.namespace: db.name
+  1.7.0:
+  1.6.1:
+  1.5.0:
+  1.4.0:

tests/integration/testdata/promqltestcorpus/known_divergences_v2.json

@@ -1,17 +1,4 @@
 {
-  "note": "Divergences of the clickhousev2 provider (pinned via X-SigNoz-PromQL-Provider) from the upstream reference engine, enforced exactly by 01_upstream_corpus.py in both directions. This ledger is the rollout scorecard for the provider swap: the default provider cannot be replaced by clickhousev2 while anything is listed here. Entries must carry the defect's cause and be REMOVED as the provider is fixed. Current class: the engine aggregates floats with Kahan compensated summation (sum, sum_over_time) and an overflow-free incremental mean (avg); ClickHouse's sumForEach/avgForEach/arraySum are naive, so extreme-magnitude corpus data (±1e100 cancellation, ±1.8e308 overflow) diverges on transpiled plans. Burn-down candidates: sumKahanForEach for the cancellation class; the overflow class needs an incremental-mean aggregate ClickHouse does not have.",
-  "divergences": {
-    "aggregators.test:651[base]": "avg over near-max-float64 values: engine's incremental mean never forms the overflowing sum; avgForEach sums then divides, overflowing to +Inf",
-    "aggregators.test:651[instant-coarse]": "same as aggregators.test:651[base] on the coarse-step grid variant",
-    "aggregators.test:654[base]": "avg over near-min-float64 values: engine's incremental mean never forms the overflowing sum; avgForEach overflows to -Inf",
-    "aggregators.test:654[instant-coarse]": "same as aggregators.test:654[base] on the coarse-step grid variant",
-    "aggregators.test:687[base]": "sum over {1e100, -1e100, small}: engine uses Kahan compensated summation; sumForEach's naive summation loses the small terms to cancellation and returns 0",
-    "aggregators.test:687[instant-coarse]": "same as aggregators.test:687[base] on the coarse-step grid variant",
-    "aggregators.test:695[base]": "avg over {1e100, -1e100, small}: same Kahan-vs-naive cancellation as aggregators.test:687, divided by count",
-    "aggregators.test:695[instant-coarse]": "same as aggregators.test:695[base] on the coarse-step grid variant",
-    "functions.test:1084[instant-coarse]": "sum_over_time over a window containing ±1e100: the disjoint coarse-step form's arraySum slide is naive summation, cancelling to 0 (the base variant's W>64 shape falls back to the engine and is exact)",
-    "functions.test:1087[instant-coarse]": "avg_over_time, same window and cancellation as functions.test:1084[instant-coarse]",
-    "functions.test:1149[base]": "avg_over_time over ±2.258e220-magnitude samples: engine's Kahan-compensated incremental mean cancels exactly to 0; the bucketed form's naive slide summation leaves a ~1e202 residue",
-    "functions.test:1149[instant-coarse]": "same as functions.test:1149[base] through the disjoint coarse-step form"
-  }
+  "note": "Divergences of the clickhousev2 provider (pinned via X-SigNoz-PromQL-Provider) from the upstream reference engine, enforced exactly by 01_upstream_corpus.py in both directions. This ledger is the rollout scorecard for the provider swap: the default provider cannot be replaced by clickhousev2 while anything is listed here. Entries must carry the defect's cause and be REMOVED as the provider is fixed.",
+  "divergences": {}
 }

tests/integration/tests/queriertraces/13_semconv_evolution.py

@@ -0,0 +1,239 @@
+"""Phase 1 end-to-end checks for semantic-convention name evolution.
+
+The fixture models a fleet split across SDK generations and deliberately includes
+a dual-emitting conflict. Both request spellings must address one logical field,
+with the current spelling winning when a row contains both.
+"""
+
+from collections.abc import Callable, Generator
+from datetime import UTC, datetime, timedelta
+from http import HTTPStatus
+from typing import Any
+
+import pytest
+import requests
+
+from fixtures import types
+from fixtures.auth import USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD
+from fixtures.querier import Aggregation, BuilderQuery, OrderBy, RequestType, TelemetryFieldKey, make_query_request
+from fixtures.traces import TraceIdGenerator, Traces, TracesKind, TracesStatusCode
+
+CURRENT = "deployment.environment.name"
+OLD = "deployment.environment"
+PREFIX = "semconv-phase1"
+
+PRODUCTION_SPANS = {
+    f"{PREFIX}-old",
+    f"{PREFIX}-current",
+    f"{PREFIX}-both",
+    f"{PREFIX}-conflict",
+}
+STAGING_SPANS = {f"{PREFIX}-staging"}
+MISSING_SPANS = {f"{PREFIX}-missing"}
+
+
+def _span(timestamp: datetime, suffix: str, environment: dict[str, str]) -> Traces:
+    service = f"{PREFIX}-{suffix}"
+    return Traces(
+        timestamp=timestamp,
+        duration=timedelta(milliseconds=10),
+        trace_id=TraceIdGenerator.trace_id(),
+        span_id=TraceIdGenerator.span_id(),
+        name=service,
+        kind=TracesKind.SPAN_KIND_SERVER,
+        status_code=TracesStatusCode.STATUS_CODE_OK,
+        resources={"service.name": service, **environment},
+        attributes=dict(environment),
+    )
+
+
+@pytest.fixture(name="semconv_phase1_data")
+def semconv_phase1_data(
+    insert_traces: Callable[[list[Traces]], None],
+    clickhouse: types.TestContainerClickhouse,
+) -> Generator[datetime]:
+    now = datetime.now(tz=UTC).replace(microsecond=0) - timedelta(minutes=2)
+    insert_traces(
+        [
+            _span(now - timedelta(seconds=5), "old", {OLD: "production"}),
+            _span(now - timedelta(seconds=4), "current", {CURRENT: "production"}),
+            _span(now - timedelta(seconds=3), "both", {OLD: "production", CURRENT: "production"}),
+            _span(now - timedelta(seconds=2), "conflict", {OLD: "staging", CURRENT: "production"}),
+            _span(now - timedelta(seconds=1), "staging", {OLD: "staging"}),
+            _span(now, "missing", {}),
+        ]
+    )
+
+    # Service-map rows are derived by the collector in production. Seed the
+    # derived table directly here so the backend alias allowlist is tested in
+    # isolation; the collector repository owns its write-path integration test.
+    for environment, suffix in (("production", "production"), ("staging", "staging")):
+        clickhouse.conn.command(
+            f"""
+            INSERT INTO signoz_traces.distributed_dependency_graph_minutes_v2
+                (src, dest, duration_quantiles_state, error_count, total_count, timestamp,
+                 deployment_environment, k8s_cluster_name, k8s_namespace_name)
+            SELECT
+                '{PREFIX}-map-{suffix}', '{PREFIX}-map-child',
+                quantilesState(0.5, 0.75, 0.9, 0.95, 0.99)(toFloat64(1000000)),
+                toUInt64(0), toUInt64(1), toDateTime({int(now.timestamp())}),
+                '{environment}', '', ''
+            """
+        )
+
+    yield now
+
+    cluster = clickhouse.env["SIGNOZ_TELEMETRYSTORE_CLICKHOUSE_CLUSTER"]
+    clickhouse.conn.command(
+        f"ALTER TABLE signoz_traces.dependency_graph_minutes_v2 ON CLUSTER '{cluster}' "
+        f"DELETE WHERE startsWith(src, '{PREFIX}-map-') SETTINGS mutations_sync = 1"
+    )
+
+
+def _result(response: requests.Response) -> dict[str, Any]:
+    assert response.status_code == HTTPStatus.OK, response.text
+    results = response.json()["data"]["data"]["results"]
+    assert len(results) == 1
+    return results[0]
+
+
+def _raw_names(
+    signoz: types.SigNoz,
+    token: str,
+    now: datetime,
+    expression: str,
+) -> set[str]:
+    response = make_query_request(
+        signoz,
+        token,
+        start_ms=int((now - timedelta(minutes=2)).timestamp() * 1000),
+        end_ms=int((now + timedelta(minutes=1)).timestamp() * 1000),
+        request_type=RequestType.RAW,
+        queries=[
+            BuilderQuery(
+                signal="traces",
+                name="A",
+                limit=100,
+                filter_expression=expression,
+                select_fields=[TelemetryFieldKey("span.name")],
+                order=[OrderBy(TelemetryFieldKey("timestamp"), "asc")],
+            ).to_dict()
+        ],
+    )
+    return {row["data"]["name"] for row in (_result(response).get("rows") or [])}
+
+
+def _metadata_values(signoz: types.SigNoz, token: str, name: str, context: str) -> set[str]:
+    response = requests.get(
+        signoz.self.host_configs["8080"].get("/api/v1/fields/values"),
+        timeout=5,
+        headers={"authorization": f"Bearer {token}"},
+        params={
+            "signal": "traces",
+            "name": name,
+            "fieldContext": context,
+            "fieldDataType": "string",
+        },
+    )
+    assert response.status_code == HTTPStatus.OK, response.text
+    return set(response.json()["data"]["values"].get("stringValues") or [])
+
+
+def test_semconv_phase1_mixed_sdk_generations(  # pylint: disable=too-many-statements
+    signoz: types.SigNoz,
+    create_user_admin: None,  # pylint: disable=unused-argument
+    get_token: Callable[[str, str], str],
+    semconv_phase1_data: datetime,
+) -> None:
+    now = semconv_phase1_data
+    token = get_token(USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD)
+
+    # Resource and span-attribute paths share the same matrix. Run every
+    # operator with both the saved-query (old) and current request spellings.
+    for context in ("resource", "attribute"):
+        for requested in (CURRENT, OLD):
+            field = f"{context}.{requested}"
+            assert _raw_names(signoz, token, now, f"{field} = 'production'") == PRODUCTION_SPANS
+            assert _raw_names(signoz, token, now, f"{field} = 'staging'") == STAGING_SPANS
+            assert _raw_names(signoz, token, now, f"{field} != 'production'") == STAGING_SPANS
+            assert _raw_names(signoz, token, now, f"{field} EXISTS") == PRODUCTION_SPANS | STAGING_SPANS
+            assert _raw_names(signoz, token, now, f"{field} NOT EXISTS") == MISSING_SPANS
+
+            grouped = make_query_request(
+                signoz,
+                token,
+                start_ms=int((now - timedelta(minutes=2)).timestamp() * 1000),
+                end_ms=int((now + timedelta(minutes=1)).timestamp() * 1000),
+                request_type=RequestType.SCALAR,
+                queries=[
+                    BuilderQuery(
+                        signal="traces",
+                        name="A",
+                        filter_expression=f"{field} EXISTS",
+                        aggregations=[Aggregation("count()")],
+                        group_by=[TelemetryFieldKey(requested, "string", context)],
+                        order=[OrderBy(TelemetryFieldKey(requested, "string", context), "asc")],
+                    ).to_dict()
+                ],
+            )
+            result = _result(grouped)
+            assert result["columns"][0]["name"] == requested, "response identity must match the request spelling"
+            assert result["data"] == [["production", 4], ["staging", 1]]
+
+        assert _metadata_values(signoz, token, CURRENT, context) == {"production", "staging"}
+        assert _metadata_values(signoz, token, OLD, context) == {"production", "staging"}
+
+    keys_response = requests.get(
+        signoz.self.host_configs["8080"].get("/api/v1/fields/keys"),
+        timeout=5,
+        headers={"authorization": f"Bearer {token}"},
+        params={"signal": "traces", "searchText": OLD},
+    )
+    assert keys_response.status_code == HTTPStatus.OK, keys_response.text
+    keys = keys_response.json()["data"]["keys"]
+    assert CURRENT in keys
+    assert OLD not in keys
+
+    start_ns = str(int((now - timedelta(minutes=2)).timestamp() * 1_000_000_000))
+    end_ns = str(int((now + timedelta(minutes=1)).timestamp() * 1_000_000_000))
+    for requested in (CURRENT, OLD):
+        services_response = requests.post(
+            signoz.self.host_configs["8080"].get("/api/v2/services"),
+            timeout=30,
+            headers={"authorization": f"Bearer {token}"},
+            json={
+                "start": start_ns,
+                "end": end_ns,
+                "tags": [
+                    {
+                        "Key": requested,
+                        "Operator": "In",
+                        "StringValues": ["production"],
+                        "TagType": "ResourceAttribute",
+                    }
+                ],
+            },
+        )
+        assert services_response.status_code == HTTPStatus.OK, services_response.text
+        services = {item["serviceName"] for item in services_response.json()["data"]}
+        assert services == PRODUCTION_SPANS
+
+        map_response = requests.post(
+            signoz.self.host_configs["8080"].get("/api/v1/dependency_graph"),
+            timeout=30,
+            headers={"authorization": f"Bearer {token}"},
+            json={
+                "start": start_ns,
+                "end": end_ns,
+                "tags": [
+                    {
+                        "key": requested,
+                        "operator": "In",
+                        "stringValues": ["production"],
+                        "tagType": "ResourceAttribute",
+                    }
+                ],
+            },
+        )
+        assert map_response.status_code == HTTPStatus.OK, map_response.text
+        assert {edge["parent"] for edge in map_response.json()} == {f"{PREFIX}-map-production"}