feat(metrics): reset-exact cumulative rate/increase via counter epochs

Cumulative counters gain an epoch-aware temporal aggregation pipeline
behind the per-org flag use_counter_epochs. The collector stamps every
cumulative monotonic sample with its normalized start_ts (epoch); within
an epoch the counter is monotone, so per-(bucket, epoch) min/max are
first/last observations and increase is the sum of per-epoch growth —
exact under any number of resets, identical at every step interval, and
computable from both the raw table and the 5m/30m rollups (which carry
per-epoch min/max as mergeable minMap/maxMap states; collector migration
1012).

start_ts = 0 rows (pre-rollout data, sources without a start time) flow
through the same statement with the legacy negative-diff semantics, so a
query over old data reproduces today's results, new data is reset-exact,
and ranges spanning the rollout seam the two per row with no watermark.
Multiple-temporality metrics become a union of the delta aggregation and
the epoch pipeline. The querier bucket-cache fingerprint includes the
pipeline state so legacy and epoch buckets never stitch.

Verification: tests/integration/testdata/counter_reset_epochs/ — a
one-day, 15-scenario dataset with three independent reference
implementations cross-asserted, then the builder-emitted SQL compared
row-for-row on ClickHouse (raw + rollup paths, pre/post-merge, 11 query
cases), plus whale-scale (50k series / 144M samples), shard-pushdown,
and layer-profile benchmarks. Design doc: docs/counter-reset-epochs.md.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

conf/example.yaml

@@ -9,11 +9,6 @@ global:
   # the path component (e.g. /signoz in https://example.com/signoz) is used
   # as the base path for all HTTP routes (both API and web frontend).
   external_url: <unset>
-  # origins (scheme://host[:port], no path) allowed as login redirect targets. include
-  # the origin the signoz ui is served on. when not configured, redirect targets are
-  # not validated.
-  # allowed_origins:
-  #   - https://signoz.example.com
   # the url where the SigNoz backend receives telemetry data (traces, metrics, logs) from instrumented applications.
   ingestion_url: <unset>
   # the url of the SigNoz MCP server. when unset, the MCP settings page is hidden in the frontend.

docs/api/openapi.yml

@@ -2596,6 +2596,19 @@ components:
         repeatVariable:
           type: string
       type: object
+    DashboardLink:
+      properties:
+        name:
+          type: string
+        renderVariables:
+          type: boolean
+        targetBlank:
+          type: boolean
+        tooltip:
+          type: string
+        url:
+          type: string
+      type: object
     DashboardtypesAxes:
       properties:
         isLogScale:
@@ -2734,7 +2747,6 @@ components:
         datasources:
           additionalProperties:
             $ref: '#/components/schemas/DashboardtypesDatasourceSpec'
-          nullable: true
           type: object
         display:
           $ref: '#/components/schemas/DashboardtypesDisplay'
@@ -2746,8 +2758,7 @@ components:
           type: array
         links:
           items:
-            $ref: '#/components/schemas/DashboardtypesLink'
-          nullable: true
+            $ref: '#/components/schemas/DashboardLink'
           type: array
         panels:
           additionalProperties:
@@ -3018,19 +3029,6 @@ components:
       - solid
       - dashed
       type: string
-    DashboardtypesLink:
-      properties:
-        name:
-          type: string
-        renderVariables:
-          type: boolean
-        targetBlank:
-          type: boolean
-        tooltip:
-          type: string
-        url:
-          type: string
-      type: object
     DashboardtypesListOrder:
       enum:
       - asc
@@ -3391,8 +3389,7 @@ components:
           $ref: '#/components/schemas/DashboardtypesDisplay'
         links:
           items:
-            $ref: '#/components/schemas/DashboardtypesLink'
-          nullable: true
+            $ref: '#/components/schemas/DashboardLink'
           type: array
         plugin:
           $ref: '#/components/schemas/DashboardtypesPanelPlugin'
@@ -6337,7 +6334,6 @@ components:
       - delta
       - cumulative
       - unspecified
-      - ""
       type: string
     MetrictypesTimeAggregation:
       enum:
@@ -6350,7 +6346,6 @@ components:
       - count_distinct
       - rate
       - increase
-      - ""
       type: string
     MetrictypesType:
       enum:
@@ -8558,7 +8553,6 @@ components:
       - resource
       - attribute
       - body
-      - ""
       type: string
     TelemetrytypesFieldDataType:
       enum:
@@ -8567,7 +8561,6 @@ components:
       - float64
       - int64
       - number
-      - ""
       type: string
     TelemetrytypesGettableFieldKeys:
       properties:
@@ -8599,12 +8592,10 @@ components:
       - traces
       - logs
       - metrics
-      - ""
       type: string
     TelemetrytypesSource:
       enum:
       - meter
-      - ""
       type: string
     TelemetrytypesTelemetryFieldKey:
       properties:

docs/counter-reset-epochs.md

@@ -0,0 +1,332 @@
+# Counter-reset epochs: read side
+
+Status: implemented behind the per-org feature flag `use_counter_epochs`.
+Write side: `docs/counter-reset-epochs.md` in the signoz-otel-collector repo
+(`start_ts` normalizer, schema migration 1012).
+Verification: `tests/integration/testdata/counter_reset_epochs/`.
+
+## Summary
+
+Cumulative rate/increase in the v5 query builder gains a reset-exact pipeline.
+The collector stamps every cumulative monotonic sample with its **epoch** (the
+normalized OTLP `start_time_unix_nano`, ms, column `start_ts`; `0` = unknown).
+Within an epoch the counter is monotone, so per-(step bucket, epoch) min/max
+are the first/last observations and the increase over any window is the sum of
+per-epoch growth — exact under any number of resets, identical at every step
+interval, computable from the raw table and from the 5m/30m rollups (which
+carry per-epoch min/max as mergeable `minMap`/`maxMap` states).
+
+What this fixes, concretely (issues #6973, #7069, and the auto-vs-1d step
+inconsistency reports):
+
+| problem | legacy | epochs |
+|---|---|---|
+| reset inside a step bucket | undercounted (`max` hides it) | exact |
+| reset regrowing past the previous value | invisible, silent undercount | exact |
+| N resets inside a 1-day step | miscounted (one negative diff at most) | exact |
+| zoom consistency (auto vs 86400) | day totals disagree (harness: 3969 vs 242) | identical at every step |
+| rollup tables (5m/30m) | loss baked in at write | reset-exact from rollups |
+| first-ever data point | invisible (`nan`) | visible (counts from 0) |
+| two writers sharing a fingerprint | sawtooth garbage | each epoch tracked, growth summed |
+
+The irreducible losses (shared with created-timestamp-enabled Prometheus):
+growth between an epoch's last sample and its death, epochs that live and die
+between two exports, and broken-start-time sources — which degrade to exactly
+today's behavior, never worse.
+
+## The pipeline
+
+`buildTemporalAggCumulativeEpochs` (pkg/telemetrymetrics/epoch_statement.go)
+replaces the temporal aggregation CTE for cumulative rate/increase when the
+flag is on. Four layers, innermost first:
+
+```
+L1  per (fingerprint, bucket):    __first_by_epoch / __last_by_epoch maps
+      raw tables:   minMap/maxMap(map(start_ts, value)), stale rows filtered
+      5m/30m:       minMap(min_value_by_start_ts) / maxMap(max_value_by_start_ts);
+                    a bucket whose merged maps are empty (all rows pre-migration)
+                    falls back to the scalar min/max as key 0
+L2  per-series bucket window:     previous bucket ts + overall max, last known
+                                  key-0 value, ever-had-key-0, row numbers
+L3  ARRAY JOIN over epochs:       per-(series, epoch) lag, then the
+                                  contribution multiIf below
+L4  regroup per (series, bucket): increase = sum of finite contributions
+                                  (NaN if none); rate divides by the distance
+                                  to the series' previous bucket (step for the
+                                  first); buckets before the display start are
+                                  cut (they exist only as bases)
+```
+
+Spatial aggregation is untouched — epochs are summed inside the series before
+anything crosses series boundaries, which is why this does not repeat the
+start-time-in-fingerprint mistake (series identity never changes; no
+cardinality or billing impact).
+
+Contribution rules per (bucket, epoch) row, in `multiIf` branch order:
+
+| # | condition | contribution | meaning |
+|---|---|---|---|
+| 1 | epoch ≠ 0, seen in an earlier bucket | `last − previous last of this epoch` (clamped to `last` if negative) | continuation; the clamp only fires if upstream broke the monotonicity invariant |
+| 2 | epoch ≠ 0, first appearance, bucket has current/earlier key-0 rows | `last − (first ≥ seam ? seam : 0)`, seam = same-bucket key-0 value, else last key-0 value | the rollout seam: continuation subtracts the legacy value, a drop keeps base 0 |
+| 3 | epoch ≠ 0, first appearance, epoch born ≥ fetched-range start | `last` | the counter started from 0 inside the range; makes single-shot scripts visible |
+| 4 | epoch ≠ 0, first appearance, born before the range | `last − first` | only the growth visible inside the bucket; the pre-range part is unknowable |
+| 5 | epoch = 0, series' first bucket | `NaN` | legacy first-point behavior |
+| 6 | epoch = 0, value < previous bucket's overall max | `value` | legacy negative-diff rule |
+| 7 | epoch = 0, otherwise | `value − previous bucket's overall max` | legacy pair rule; "overall max" (not key-0-only) also seams the epoch→0 downgrade direction |
+
+## How queries behave across the rollout — the three regimes
+
+The **same statement** serves all three regimes; they differ only in which
+branches fire, row by row. There is no watermark, no config, no per-time-range
+switching.
+
+### Regime 1 — no rollout in range (all rows have `start_ts = 0`)
+
+Every row lands in the maps under key 0. Branches 5–7 are the only ones that
+fire, and they are exactly the legacy semantics (bucket max, `nan` first
+point, negative-diff clamp). Harness assertions A5/A6 prove byte-equality of
+results with the legacy pipeline on epoch-less and reset-free data, and the
+`l_*` query cases pin the legacy pipeline itself. Flag on + old data =
+identical charts.
+
+### Regime 2 — fully rolled out (every cumulative row has a real epoch)
+
+Maps carry real epochs; branches 1–4 fire. Per bucket, each epoch contributes
+its observed growth; a reset inside a bucket simply means two epochs
+contribute. The result is exact at every step: the harness's day totals at
+steps 60/300/1800/86400 are identical per scenario and equal the independent
+per-point truth (A1/A3), from raw and rollup tables alike.
+
+Worked example (the research doc's numbers), one series, buckets of 5m, reset
+at 11:38:01, epoch A pre-range, epoch B born 11:38:01:
+
+```
+bucket        maps {epoch: last}         contributions            increase
+11:30–11:35   {A: 90}                    A: rule 4 → 90−84 = 6         6
+11:35–11:40   {A: 107, B: 23}            A: rule 1 → 17; B: rule 3 → 23   40
+11:40–11:45   {B: 37}                    B: rule 1 → 37−23 = 14        14
+one 15m bucket {A: 107, B: 37}           A: 107−84 = 23; B: 37         60 = 6+40+14
+```
+
+### Regime 3 — the overlap (range spans the rollout boundary, or a mixed fleet)
+
+Old buckets are key-0, new buckets carry epochs, and a mid-bucket switch puts
+both in one bucket. The seam is branch 2: when an epoch first appears for a
+series that has key-0 history, its base is the nearest legacy value — the
+same-bucket key-0 value if the switch happened mid-bucket, otherwise the last
+key-0 value from earlier buckets — with the legacy pair rule applied (a drop
+at the seam keeps base 0, so a reset coinciding with the rollout is still
+counted correctly). Continuity: a counter at 100 under key-0 rows that
+continues at 101 under epoch rows contributes 1, not 101.
+
+The reverse seam (epoch → key-0, i.e. a collector rollback) flows through
+branch 7 against the previous bucket's overall max.
+
+Covered in the harness by `s06_transition` (key-0 half-day → epoch half-day →
+a real reset at 18:00), `s15_aggold` (rollup rows from before migration 1012,
+whose empty maps fall back to scalar min/max as key 0), and the mixed-bucket
+path inside s06. Exactness during the overlap is legacy-grade at the seam and
+epoch-grade everywhere else; it converges to regime 2 as old rows age out
+(30d TTL).
+
+One operational caveat (also in the collector doc): a series whose samples
+*alternate* between old and new collector **versions** for an extended period
+(LB across a half-upgraded fleet) can double-count across repeated key-0↔epoch
+seams. Upgrade a series' path atomically where possible and keep the
+version-mix window short. Replica count and load balancing among
+*same-version* collectors are not a concern: the normalizer only ever emits
+validated wire values or 0, so every replica assigns the same epoch to a
+spec-compliant series (see the collector doc's replica analysis).
+
+## Feature flag, caching, alerts
+
+- `use_counter_epochs` (registry default disabled). Routing:
+  temporality Cumulative + rate/increase → epoch pipeline; temporality
+  Multiple → a UNION of the delta fast aggregation and the epoch pipeline
+  (replacing the single multiplexed window expression, which could not be made
+  reset-exact); everything else (delta, gauges, Unspecified, latest/sum/avg/…)
+  is unchanged.
+- The querier's bucket-cache fingerprint gains `counterepochs=v1` for affected
+  specs when the flag is on, so cached legacy buckets and epoch buckets can
+  never stitch into one series. Flipping the flag is a cache-key change for
+  cumulative rate/increase queries only.
+- Threshold alert rules evaluate through the same v5 querier and pick the
+  pipeline up from the flag; PromQL and the v3/v4 builders are non-goals (see
+  below).
+
+## Verification
+
+`tests/integration/testdata/counter_reset_epochs/` — one-day dataset, 15
+scenarios (steady, mid-bucket reset, 11 resets/day, regrow-past-previous,
+pure-legacy, rollout transition, gap, single point, slow reporter, boundary
+reset, duplicates+out-of-order, two-writer overlap, UpDownCounter, pre-
+migration rollup rows, stale markers). Three independent implementations
+(bucket rules, legacy rules, per-point truth) cross-assert in
+`generate_dataset.py`; the builder-emitted SQL (goldens in
+`pkg/telemetrymetrics/testdata/`, emitter `TestEmitHarnessQueries`) is then
+compared row-for-row against them on ClickHouse 26.4 via `run.sh`: 11 query
+cases × pre/post-merge, raw and rollup paths, all passing. The harness runs
+the migration-1012 MV SQL verbatim, so collector-side rollup correctness is
+covered by the same run.
+
+## Performance
+
+Cost model: an L1 scan+aggregate identical in shape to legacy (maps have ~1
+entry per bucket — `1 + resets inside the bucket`; the write-side churn guard
+bounds the degenerate case), then `O(series × buckets)` window-layer work at a
+**~3–4× heavier per-window-row constant** than legacy's single window. The
+`ARRAY JOIN` itself is a flatMap over the already-collapsed set with ~1.0–1.05×
+expansion and is not the cost; micro-variants (tuple-free array join, stripping
+the entire seam machinery) were measured at noise to ~15%. Query cost scales
+with the *queried metric's* rows and series, not total ingest.
+
+Measured, clickhouse local on an M-series laptop (relative numbers are the
+point; `bench.sh` / `bench_large.sh` in the harness):
+
+Small metric — 2,000 series × 24h × 30s (5.76M rows, 576k window rows):
+
+| query | legacy | epochs | ratio |
+|---|---|---|---|
+| increase, step=300, raw | 0.51 s | 0.79 s | 1.5× |
+| increase, step=60, raw | 0.91 s | 2.24 s | 2.5× |
+
+Whale metric — 50,000 series × 24h × 30s (144M rows, 14.4M window rows), the
+realistic worst case for a single query at a ~1B samples/day tenant:
+
+| query | legacy | epochs | ratio |
+|---|---|---|---|
+| increase, step=300, raw | 5.4 s | 20.4 s | 3.8× |
+| increase, step=300, agg_5m | — | 16.6 s | windows dominate; rollups don't rescue this shape |
+| increase, step=1800, agg_30m (2.4M window rows) | — | 2.1 s | linear in window rows |
+| peak RSS (step=300 raw) | 2.7 GB | 4.3 GB | +60% |
+
+Interpretation: typical panels (≤ 5k series × ≤ 400 points ⇒ ≤ 2M window
+rows) pay ~1.5× and sub-second absolutes. Tenant-wide whale panels pay 3–4×
+on a query that is already slow under legacy, and the bucket cache makes the
+steady-state refresh incremental (only new buckets recompute), so the full
+cost is a first-load/backfill event. The flag is per-org, so whale-heavy
+tenants can hold until shard-local pushdown lands (below).
+
+### Where the cost lives (layer profile, whale case)
+
+Progressive-stage timings (`bench_profile.sh`, FORMAT Null, best-of-3; laptop
+numbers are noisy — read the shape, not the decimals):
+
+| stage | time | delta = layer cost |
+|---|---|---|
+| L1 legacy (scan 144M → 14.4M groups, scalar `max`) | ~5.0 s | baseline |
+| L1 epoch (same, `minMap`/`maxMap` states) | ~13–16 s | **map aggregation ≈ +8–11 s — the dominant cost** |
+| + L2 window | ~12 s (noise-overlapped) | |
+| + L3 explode + epoch window | ~18 s | window passes ≈ +5–6 s |
+| full epoch (+L4 regroup + spatial) | ~21 s | ≈ +2 s |
+| full legacy | ~6 s | legacy window ≈ +1 s |
+
+So roughly **half the overhead is the Map aggregate states in L1** (per-row
+1-entry map construction plus per-group Map-state merges — a hash-and-arrays
+operation where legacy does one float compare), ~a third is the two window
+passes over map-carrying rows, and the rest is the extra regroup. Two findings
+kill the obvious rewrites: a two-level L1 (scalar states grouped by
+`(series, bucket, start_ts)`, maps built over the 10×-smaller set) saves only
+~10% — the 144M-row group-by machinery costs what the allocations save — and
+the rollup path at step == bucket width (pure 1:1 map *merges*, zero map
+*construction*) is just as slow, so merge and construction cost about the
+same. The cost is the Map datatype in the aggregation/sort path, not any
+single expression. Hence the levers that actually work are the ones measured
+below (pushdown; rollups when step ≫ bucket; the bucket cache) rather than
+SQL micro-tuning. A per-bucket single-epoch scalar fast path would need
+per-group aggregation-strategy switching that SQL cannot express; if this
+stage ever needs another 2×, that is an engine-level (or two-plan pre-check)
+project.
+
+### Shard-local pushdown (measured)
+
+The sharding key hashes the fingerprint, so shards hold disjoint series — and
+nothing in L1–L4 crosses series until the spatial sum, which decomposes into
+per-shard partials. Simulated with 4 shard databases each holding a disjoint
+quarter of the whale dataset (per-shard wall time measured with the full
+machine, since real shards run in parallel on their own hardware;
+`bench_shard.sh`):
+
+| whale query, step=300, raw | single node (today) | per-shard wall (4 shards) | projected cluster wall |
+|---|---|---|---|
+| epoch pipeline | 20.4 s | 3.3–3.8 s | **~3.6 s** (5.9×) |
+| legacy pipeline | 5.4 s | 1.2 s | **~1.2 s** (4.6×) |
+
+The merged 4-shard partials equal the single-node output **exactly (276 rows,
+0 mismatches)** — empirical proof the decomposition is lossless, not
+approximate. Initiator merge is a GROUP BY over `shards × (buckets × groups)`
+rows (60 ms even in unoptimized python). Speedups are slightly superlinear
+because the per-shard window working set fits cache (the single-node run
+carried a 4.3 GB working set).
+
+Implementation shape: wrap the exact statement the builder emits today —
+with local table names; the time-series join already reads local tables —
+in `cluster('{cluster}', view(...))` and re-aggregate the group columns at
+the initiator. Requirements: the spatial aggregation must decompose
+(sum/min/max do; avg needs sum+count partials; the histogram-quantile path
+already sums per `le` before quantiling at the outermost level). This
+benefits the legacy pipeline equally and is the right lever for whale
+tenants regardless of epochs.
+
+Write side, from the ingest A/B (144M rows through the full MV chain, fresh
+db each):
+
+| | legacy MVs | migration-1012 MVs |
+|---|---|---|
+| ingest wall time | 34.7 s (4.1M rows/s) | 77.1 s (1.9M rows/s) |
+| agg_5m on disk | 66.5 MiB | 111.2 MiB (+67%) |
+| agg_30m on disk | 6.8 MiB | 13.1 MiB (+92%) |
+| samples_v4 on disk | 20.8 MiB | 20.8 MiB (+~0; `start_ts` delta-compresses away) |
+
+The rollup-MV stage of ingestion costs ~2.2× its previous CPU. At 1B
+samples/day (~12k rows/s average), even a single laptop-class node retains
+>100× headroom on this stage, but budget the MV share of ingest CPU
+accordingly on hot clusters. Rollup tables are a small fraction of metrics
+storage (raw dominates on real data), so the +67–92% there nets out to a few
+percent overall.
+
+## Audit notes (what was found and addressed, what remains)
+
+Found during the audit and fixed:
+
+- **Stale markers on the raw path**: legacy `max()` was immune to
+  no-recorded-value rows; `minMap` is not (a 0 would become an epoch's "first"
+  and overstate its first bucket). The epoch L1 filters `bitAnd(flags,1) = 0`
+  on raw/buffer tables, matching the rollup MVs (`s16_stale`).
+- **Stale markers vs the normalizer**: a marker's fake 0 would read as a
+  counter reset and mint a phantom epoch; markers now bypass the normalizer
+  entirely.
+- **Cache stitching**: the bucket-cache fingerprint ignored the pipeline
+  semantics; flag state is now part of the cache identity for affected specs.
+- **Lookback leak**: the epoch pipeline produces real values where legacy
+  produced `nan` (dropped), so the lookback bucket is cut explicitly from the
+  output; the delta side of the Multiple union reads only the display range
+  (this also fixes a pre-existing lookback-row leak in the legacy Multiple
+  path).
+
+Known limitations, by design:
+
+- **Step below the reporting interval**: with a one-step lookback, growth
+  between the last pre-range sample and the first in-range sample is
+  unattributable when the series reports less often than the step (s09 at
+  step=60). Legacy loses the same information (`nan` first point); Prometheus
+  returns nothing at all for such windows. The eventual fix is a
+  reporting-interval-aware lookback (existing TODO in
+  `pkg/querybuilder/time.go`).
+- **Unknown-epoch data stays legacy**: key-0 rows are zoom-inconsistent
+  exactly as today; nothing can recover epochs that were never recorded.
+- **Transition-hour rollup buckets** mixing pre- and post-migration rows use
+  the map rows plus scalar fallback approximately for the pre-migration part
+  (bounded to buckets written while the migration itself was running).
+- **Non-goals**: PromQL path (parity with the Prometheus engine is its
+  contract; the rollup schema was deliberately shaped so a future PromQL
+  rollup effort can derive its own value-pair-rule quantities from the same
+  maps), v3/v4 query builders, meter metrics, exponential histograms
+  (cumulative exp-hist is not ingested today).
+
+## Rollout order
+
+1. Collector schema migration 1012.
+2. Exporters: `enable_start_ts: true`.
+3. Per-org flag `use_counter_epochs` — safe immediately (regime 1 ≡ legacy);
+   full effect accrues as epoch data accumulates and the seam ages out.

ee/authz/openfgaauthz/provider.go

@@ -223,12 +223,17 @@ func (provider *provider) Update(ctx context.Context, orgID valuer.UUID, updated
 		return err
 	}
 
-	desiredTuples, err := authtypes.NewTuplesFromTransactionGroups(existingRole.Name, orgID, updatedRole.TransactionGroups)
+	existingGroups := authtypes.MustNewTransactionGroupsFromTuples(existingTuples)
+	additions, deletions := existingGroups.Diff(updatedRole.TransactionGroups)
+	additionTuples, err := authtypes.NewTuplesFromTransactionGroups(existingRole.Name, orgID, additions)
 	if err != nil {
 		return err
 	}
 
-	additionTuples, deletionTuples := authtypes.DiffTuples(existingTuples, desiredTuples)
+	deletionTuples, err := authtypes.NewTuplesFromTransactionGroups(existingRole.Name, orgID, deletions)
+	if err != nil {
+		return err
+	}
 
 	err = provider.Write(ctx, additionTuples, deletionTuples)
 	if err != nil {

ee/query-service/rules/manager_test.go

@@ -240,17 +240,17 @@ func TestManager_TestNotification_SendUnmatched_PromRule(t *testing.T) {
 					mock := mockStore.Mock()
 
 					// Mock the fingerprint query (for Prometheus label matching)
-					// args: $1=metric_name (the __name__ matcher maps onto the column)
 					mock.ExpectQuery("SELECT fingerprint, any").
-						WithArgs("test_metric").
+						WithArgs("test_metric", "__name__", "test_metric").
 						WillReturnRows(fingerprintRows)
 
 					// Mock the samples query (for Prometheus metric data)
-					// args: metric_name IN (discovered names), subquery metric_name, start, end
 					mock.ExpectQuery("SELECT metric_name, fingerprint, unix_milli").
 						WithArgs(
 							"test_metric",
 							"test_metric",
+							"__name__",
+							"test_metric",
 							queryStart,
 							queryEnd,
 						).

frontend/public/locales/en-GB/titles.json

@@ -62,7 +62,7 @@
 	"TRACES_FUNNELS_DETAIL": "SigNoz | Funnel",
 	"INTEGRATIONS_DETAIL": "SigNoz | Integration",
 	"PUBLIC_DASHBOARD": "SigNoz | Dashboard",
-	"AI_OBSERVABILITY_OVERVIEW": "SigNoz | AI Observability Overview",
-	"AI_OBSERVABILITY_CONFIGURATION": "SigNoz | AI Observability Configuration",
-	"AI_OBSERVABILITY_ATTRIBUTE_MAPPING": "SigNoz | AI Observability Attribute Mapping"
+	"LLM_OBSERVABILITY_OVERVIEW": "SigNoz | LLM Observability Overview",
+	"LLM_OBSERVABILITY_CONFIGURATION": "SigNoz | LLM Observability Configuration",
+	"LLM_OBSERVABILITY_ATTRIBUTE_MAPPING": "SigNoz | LLM Observability Attribute Mapping"
 }

frontend/public/locales/en/titles.json

@@ -87,7 +87,7 @@
 	"TRACES_FUNNELS_DETAIL": "SigNoz | Funnel",
 	"INTEGRATIONS_DETAIL": "SigNoz | Integration",
 	"PUBLIC_DASHBOARD": "SigNoz | Dashboard",
-	"AI_OBSERVABILITY_OVERVIEW": "SigNoz | AI Observability Overview",
-	"AI_OBSERVABILITY_CONFIGURATION": "SigNoz | AI Observability Configuration",
-	"AI_OBSERVABILITY_ATTRIBUTE_MAPPING": "SigNoz | AI Observability Attribute Mapping"
+	"LLM_OBSERVABILITY_OVERVIEW": "SigNoz | LLM Observability Overview",
+	"LLM_OBSERVABILITY_CONFIGURATION": "SigNoz | LLM Observability Configuration",
+	"LLM_OBSERVABILITY_ATTRIBUTE_MAPPING": "SigNoz | LLM Observability Attribute Mapping"
 }

frontend/src/AppRoutes/Private.tsx

@@ -134,8 +134,8 @@ function PrivateRoute({ children }: PrivateRouteProps): JSX.Element {
 	}
 
 	if (
-		(pathname.startsWith(`${ROUTES.AI_OBSERVABILITY_BASE}/`) ||
-			pathname === ROUTES.AI_OBSERVABILITY_BASE) &&
+		(pathname.startsWith(`${ROUTES.LLM_OBSERVABILITY_BASE}/`) ||
+			pathname === ROUTES.LLM_OBSERVABILITY_BASE) &&
 		!isAIObservabilityEnabled
 	) {
 		return <Redirect to={ROUTES.HOME} />;

frontend/src/AppRoutes/routes.ts

@@ -514,24 +514,24 @@ const routes: AppRoutes[] = [
 		isPrivate: true,
 	},
 	{
-		path: ROUTES.AI_OBSERVABILITY_ATTRIBUTE_MAPPING,
+		path: ROUTES.LLM_OBSERVABILITY_ATTRIBUTE_MAPPING,
 		exact: true,
 		component: LLMObservabilityPage,
-		key: 'AI_OBSERVABILITY_ATTRIBUTE_MAPPING',
+		key: 'LLM_OBSERVABILITY_ATTRIBUTE_MAPPING',
 		isPrivate: true,
 	},
 	{
-		path: ROUTES.AI_OBSERVABILITY_OVERVIEW,
+		path: ROUTES.LLM_OBSERVABILITY_OVERVIEW,
 		exact: true,
 		component: LLMObservabilityPage,
-		key: 'AI_OBSERVABILITY_OVERVIEW',
+		key: 'LLM_OBSERVABILITY_OVERVIEW',
 		isPrivate: true,
 	},
 	{
-		path: ROUTES.AI_OBSERVABILITY_CONFIGURATION,
+		path: ROUTES.LLM_OBSERVABILITY_CONFIGURATION,
 		exact: true,
 		component: LLMObservabilityPage,
-		key: 'AI_OBSERVABILITY_CONFIGURATION',
+		key: 'LLM_OBSERVABILITY_CONFIGURATION',
 		isPrivate: true,
 	},
 ];

frontend/src/api/ErrorResponseHandlerForGeneratedAPIs.ts

@@ -2,29 +2,6 @@ import { RenderErrorResponseDTO } from 'api/generated/services/sigNoz.schemas';
 import { AxiosError } from 'axios';
 import APIError from 'types/api/error';
 
-// The wire shape these handlers can actually rely on. The generated
-// RenderErrorResponseDTO marks code/message/url/errors as required, but the
-// server omits any of them even on valid errors (e.g. a 400 with just a
-// message), so a present `error` object is all the guard can guarantee.
-type ErrorEnvelope = {
-	error: {
-		code?: string;
-		message?: string;
-		url?: string;
-		errors?: { message?: string }[];
-	};
-};
-
-function isErrorEnvelope(data: unknown): data is ErrorEnvelope {
-	return (
-		typeof data === 'object' &&
-		data !== null &&
-		'error' in data &&
-		typeof (data as ErrorEnvelope).error === 'object' &&
-		(data as ErrorEnvelope).error !== null
-	);
-}
-
 // @deprecated Use convertToApiError instead
 export function ErrorResponseHandlerForGeneratedAPIs(
 	error: AxiosError<RenderErrorResponseDTO>,
@@ -33,29 +10,15 @@ export function ErrorResponseHandlerForGeneratedAPIs(
 	// The request was made and the server responded with a status code
 	// that falls out of the range of 2xx
 	if (response) {
-		// The body isn't guaranteed to be an error envelope — e.g. a gateway 5xx
-		// with an HTML/empty body during a deploy. Verify the shape before reading
-		// it; otherwise synthesize a consistent error from the status.
-		const data: unknown = response.data;
-		if (isErrorEnvelope(data)) {
-			const { code, message, url, errors } = data.error;
-			throw new APIError({
-				httpStatusCode: response.status || 500,
-				error: {
-					code: code ?? '',
-					message: message ?? '',
-					url: url ?? '',
-					errors: (errors ?? []).map((e) => ({ message: e.message ?? '' })),
-				},
-			});
-		}
 		throw new APIError({
 			httpStatusCode: response.status || 500,
 			error: {
-				code: 'UPSTREAM_UNAVAILABLE',
-				message: error.message || 'Something went wrong',
-				url: '',
-				errors: [],
+				code: response.data.error.code,
+				message: response.data.error.message,
+				url: response.data.error.url ?? '',
+				errors: (response.data.error.errors ?? []).map((e) => ({
+					message: e.message ?? '',
+				})),
 			},
 		});
 	}
@@ -99,7 +62,9 @@ export function convertToApiError(
 	return new APIError({
 		httpStatusCode: response?.status || error.status || 500,
 		error: {
-			code: errorData?.code || 'UPSTREAM_UNAVAILABLE',
+			code:
+				errorData?.code ||
+				String(response?.status || error.code || 'unknown_error'),
 			message:
 				errorData?.message ||
 				response?.statusText ||

frontend/src/api/ErrorResponseHandlerV2.ts

@@ -2,38 +2,19 @@ import { AxiosError } from 'axios';
 import { ErrorV2Resp } from 'types/api';
 import APIError from 'types/api/error';
 
-function isErrorV2Resp(data: unknown): data is ErrorV2Resp {
-	return (
-		typeof data === 'object' &&
-		data !== null &&
-		'error' in data &&
-		typeof (data as ErrorV2Resp).error?.code === 'string'
-	);
-}
-
 // reference - https://axios-http.com/docs/handling_errors
 export function ErrorResponseHandlerV2(error: AxiosError<ErrorV2Resp>): never {
 	const { response, request } = error;
 	// The request was made and the server responded with a status code
 	// that falls out of the range of 2xx
 	if (response) {
-		// response.data isn't guaranteed to be a V2 envelope (e.g. a gateway 5xx
-		// with an HTML/empty body during a deploy), so verify the shape first.
-		const data: unknown = response.data;
-		if (isErrorV2Resp(data)) {
-			const { code, message, url, errors } = data.error;
-			throw new APIError({
-				httpStatusCode: response.status || 500,
-				error: { code, message, url, errors },
-			});
-		}
 		throw new APIError({
 			httpStatusCode: response.status || 500,
 			error: {
-				code: 'UPSTREAM_UNAVAILABLE',
-				message: error.message || 'Something went wrong',
-				url: '',
-				errors: [],
+				code: response.data.error.code,
+				message: response.data.error.message,
+				url: response.data.error.url,
+				errors: response.data.error.errors,
 			},
 		});
 	}

frontend/src/api/__tests__/ErrorResponseHandlerV2.test.ts

@@ -1,126 +0,0 @@
-import { ErrorResponseHandlerV2 } from 'api/ErrorResponseHandlerV2';
-import { AxiosError } from 'axios';
-import { ErrorV2Resp } from 'types/api';
-import APIError from 'types/api/error';
-
-function asAxiosError(partial: Partial<AxiosError>): AxiosError<ErrorV2Resp> {
-	return partial as AxiosError<ErrorV2Resp>;
-}
-
-// ErrorResponseHandlerV2 always throws — capture the APIError so assertions stay
-// unconditional.
-function runHandler(error: AxiosError<ErrorV2Resp>): APIError {
-	try {
-		ErrorResponseHandlerV2(error);
-	} catch (thrown) {
-		return thrown as APIError;
-	}
-	throw new Error('expected ErrorResponseHandlerV2 to throw');
-}
-
-type ExpectedError = {
-	httpStatusCode: number;
-	code: string;
-	message: string;
-	errors: { message: string }[];
-};
-
-// One row per response shape the handler must normalize. New shapes (with
-// different bodies) can be added here without a new test block.
-const cases: {
-	name: string;
-	error: AxiosError<ErrorV2Resp>;
-	expected: ExpectedError;
-}[] = [
-	{
-		name: 'well-formed V2 error envelope',
-		error: asAxiosError({
-			message: 'Request failed with status code 400',
-			response: {
-				status: 400,
-				data: {
-					error: {
-						code: 'bad_request',
-						message: 'Invalid dashboard payload',
-						url: 'https://signoz.io/docs',
-						errors: [{ message: 'name is required' }, { message: 'name too long' }],
-					},
-				},
-			} as AxiosError['response'],
-		}),
-		expected: {
-			httpStatusCode: 400,
-			code: 'bad_request',
-			message: 'Invalid dashboard payload',
-			errors: [{ message: 'name is required' }, { message: 'name too long' }],
-		},
-	},
-	{
-		// Regression: during a deployment the gateway returns a 5xx with a
-		// non-envelope body. Reading response.data.error.code used to throw a
-		// TypeError from inside the handler itself. See engineering-pod#5760.
-		name: '5xx with a non-envelope HTML body',
-		error: asAxiosError({
-			message: 'Request failed with status code 503',
-			response: {
-				status: 503,
-				data: '<html><body>503 Service Temporarily Unavailable</body></html>',
-			} as AxiosError['response'],
-		}),
-		expected: {
-			httpStatusCode: 503,
-			code: 'UPSTREAM_UNAVAILABLE',
-			message: 'Request failed with status code 503',
-			errors: [],
-		},
-	},
-	{
-		name: '5xx with an empty body',
-		error: asAxiosError({
-			message: 'Request failed with status code 502',
-			response: {
-				status: 502,
-				data: undefined,
-			} as AxiosError['response'],
-		}),
-		expected: {
-			httpStatusCode: 502,
-			code: 'UPSTREAM_UNAVAILABLE',
-			message: 'Request failed with status code 502',
-			errors: [],
-		},
-	},
-	{
-		name: 'no response received (network error)',
-		error: asAxiosError({
-			message: 'Network Error',
-			code: 'ERR_NETWORK',
-			name: 'AxiosError',
-			request: {},
-		}),
-		expected: {
-			httpStatusCode: 500,
-			code: 'ERR_NETWORK',
-			message: 'Network Error',
-			errors: [],
-		},
-	},
-];
-
-describe('ErrorResponseHandlerV2', () => {
-	it.each(cases)(
-		'normalizes $name into a consistent APIError',
-		({ error, expected }) => {
-			const apiError = runHandler(error);
-
-			expect(apiError).toBeInstanceOf(APIError);
-			expect(apiError.getHttpStatusCode()).toBe(expected.httpStatusCode);
-			expect(apiError.getErrorCode()).toBe(expected.code);
-			expect(apiError.getErrorMessage()).toBe(expected.message);
-			// The sub-error messages feed several parts of the UI, so assert them.
-			expect(apiError.getErrorDetails().error.errors).toStrictEqual(
-				expected.errors,
-			);
-		},
-	);
-});

frontend/src/api/generated/services/sigNoz.schemas.ts

@@ -3300,6 +3300,29 @@ export interface DashboardGridLayoutSpecDTO {
 	repeatVariable?: string;
 }
 
+export interface DashboardLinkDTO {
+	/**
+	 * @type string
+	 */
+	name?: string;
+	/**
+	 * @type boolean
+	 */
+	renderVariables?: boolean;
+	/**
+	 * @type boolean
+	 */
+	targetBlank?: boolean;
+	/**
+	 * @type string
+	 */
+	tooltip?: string;
+	/**
+	 * @type string
+	 */
+	url?: string;
+}
+
 export interface DashboardtypesAxesDTO {
 	/**
 	 * @type boolean
@@ -3479,7 +3502,6 @@ export enum TelemetrytypesFieldContextDTO {
 	resource = 'resource',
 	attribute = 'attribute',
 	body = 'body',
-	'' = '',
 }
 export enum TelemetrytypesFieldDataTypeDTO {
 	string = 'string',
@@ -3487,13 +3509,11 @@ export enum TelemetrytypesFieldDataTypeDTO {
 	float64 = 'float64',
 	int64 = 'int64',
 	number = 'number',
-	'' = '',
 }
 export enum TelemetrytypesSignalDTO {
 	traces = 'traces',
 	logs = 'logs',
 	metrics = 'metrics',
-	'' = '',
 }
 export interface Querybuildertypesv5GroupByKeyDTO {
 	/**
@@ -3611,7 +3631,6 @@ export enum Querybuildertypesv5QueryBuilderQueryGithubComSigNozSignozPkgTypesQue
 }
 export enum TelemetrytypesSourceDTO {
 	meter = 'meter',
-	'' = '',
 }
 export interface Querybuildertypesv5QueryBuilderQueryGithubComSigNozSignozPkgTypesQuerybuildertypesQuerybuildertypesv5LogAggregationDTO {
 	/**
@@ -3711,7 +3730,6 @@ export enum MetrictypesTemporalityDTO {
 	delta = 'delta',
 	cumulative = 'cumulative',
 	unspecified = 'unspecified',
-	'' = '',
 }
 export enum MetrictypesTimeAggregationDTO {
 	latest = 'latest',
@@ -3723,7 +3741,6 @@ export enum MetrictypesTimeAggregationDTO {
 	count_distinct = 'count_distinct',
 	rate = 'rate',
 	increase = 'increase',
-	'' = '',
 }
 export interface Querybuildertypesv5MetricAggregationDTO {
 	comparisonSpaceAggregationParam?: MetrictypesComparisonSpaceAggregationParamDTO;
@@ -4017,16 +4034,10 @@ export interface DashboardtypesDatasourceSpecDTO {
 	plugin?: DashboardtypesDatasourcePluginDTO;
 }
 
-export type DashboardtypesDashboardSpecDTODatasourcesAnyOf = {
+export type DashboardtypesDashboardSpecDTODatasources = {
 	[key: string]: DashboardtypesDatasourceSpecDTO;
 };
 
-/**
- * @nullable
- */
-export type DashboardtypesDashboardSpecDTODatasources =
-	DashboardtypesDashboardSpecDTODatasourcesAnyOf | null;
-
 export enum DashboardtypesPanelKindDTO {
 	Panel = 'Panel',
 }
@@ -4041,29 +4052,6 @@ export interface DashboardtypesDisplayDTO {
 	name: string;
 }
 
-export interface DashboardtypesLinkDTO {
-	/**
-	 * @type string
-	 */
-	name?: string;
-	/**
-	 * @type boolean
-	 */
-	renderVariables?: boolean;
-	/**
-	 * @type boolean
-	 */
-	targetBlank?: boolean;
-	/**
-	 * @type string
-	 */
-	tooltip?: string;
-	/**
-	 * @type string
-	 */
-	url?: string;
-}
-
 export enum DashboardtypesPanelPluginVariantGithubComSigNozSignozPkgTypesDashboardtypesTimeSeriesPanelSpecDTOKind {
 	'signoz/TimeSeriesPanel' = 'signoz/TimeSeriesPanel',
 }
@@ -4625,9 +4613,9 @@ export interface DashboardtypesQueryDTO {
 export interface DashboardtypesPanelSpecDTO {
 	display: DashboardtypesDisplayDTO;
 	/**
-	 * @type array,null
+	 * @type array
 	 */
-	links?: DashboardtypesLinkDTO[] | null;
+	links?: DashboardLinkDTO[];
 	plugin: DashboardtypesPanelPluginDTO;
 	/**
 	 * @type array
@@ -4801,7 +4789,7 @@ export type DashboardtypesVariableDTO =
 
 export interface DashboardtypesDashboardSpecDTO {
 	/**
-	 * @type object,null
+	 * @type object
 	 */
 	datasources?: DashboardtypesDashboardSpecDTODatasources;
 	display: DashboardtypesDisplayDTO;
@@ -4814,9 +4802,9 @@ export interface DashboardtypesDashboardSpecDTO {
 	 */
 	layouts: DashboardtypesLayoutDTO[];
 	/**
-	 * @type array,null
+	 * @type array
 	 */
-	links?: DashboardtypesLinkDTO[] | null;
+	links?: DashboardLinkDTO[];
 	/**
 	 * @type object
 	 */

frontend/src/components/HeaderRightSection/HeaderRightSection.tsx

@@ -20,7 +20,7 @@ import { Globe, Inbox, SquarePen } from '@signozhq/icons';
 
 import AnnouncementsModal from './AnnouncementsModal';
 import FeedbackModal from './FeedbackModal';
-import ShareURLModal, { type ShareURLExtraOption } from './ShareURLModal';
+import ShareURLModal from './ShareURLModal';
 
 import './HeaderRightSection.styles.scss';
 import { Typography } from '@signozhq/ui/typography';
@@ -29,15 +29,12 @@ interface HeaderRightSectionProps {
 	enableAnnouncements: boolean;
 	enableShare: boolean;
 	enableFeedback: boolean;
-	/** Optional page-specific toggle for the share dialog (e.g. "Include variables"). */
-	shareModalExtraOption?: ShareURLExtraOption;
 }
 
 function HeaderRightSection({
 	enableAnnouncements,
 	enableShare,
 	enableFeedback,
-	shareModalExtraOption,
 }: HeaderRightSectionProps): JSX.Element | null {
 	const location = useLocation();
 
@@ -188,7 +185,7 @@ function HeaderRightSection({
 					rootClassName="header-section-popover-root"
 					className="shareable-link-popover"
 					placement="bottomRight"
-					content={<ShareURLModal extraOption={shareModalExtraOption} />}
+					content={<ShareURLModal />}
 					open={openShareURLModal}
 					destroyTooltipOnHide
 					arrow={false}

frontend/src/components/HeaderRightSection/ShareURLModal.tsx

@@ -24,22 +24,7 @@ const routesToBeSharedWithTime = [
 	ROUTES.METER_EXPLORER,
 ];
 
-/**
- * An optional, page-specific toggle in the share dialog (e.g. a dashboard's
- * "Include variables"). When enabled, `apply` mutates the URL params that go into
- * the shared link. Keeps this shared modal generic — the page owns what it adds.
- */
-export interface ShareURLExtraOption {
-	label: string;
-	defaultEnabled?: boolean;
-	apply: (params: URLSearchParams) => void;
-}
-
-interface ShareURLModalProps {
-	extraOption?: ShareURLExtraOption;
-}
-
-function ShareURLModal({ extraOption }: ShareURLModalProps): JSX.Element {
+function ShareURLModal(): JSX.Element {
 	const urlQuery = useUrlQuery();
 	const location = useLocation();
 	const { selectedTime } = useSelector<AppState, GlobalReducer>(
@@ -49,9 +34,6 @@ function ShareURLModal({ extraOption }: ShareURLModalProps): JSX.Element {
 	const [enableAbsoluteTime, setEnableAbsoluteTime] = useState(
 		selectedTime !== 'custom',
 	);
-	const [enableExtraOption, setEnableExtraOption] = useState(
-		extraOption?.defaultEnabled ?? false,
-	);
 
 	const startTime = urlQuery.get(QueryParams.startTime);
 	const endTime = urlQuery.get(QueryParams.endTime);
@@ -111,11 +93,6 @@ function ShareURLModal({ extraOption }: ShareURLModalProps): JSX.Element {
 			}
 		}
 
-		if (extraOption && enableExtraOption) {
-			extraOption.apply(urlQuery);
-			currentUrl = getAbsoluteUrl(`${location.pathname}?${urlQuery.toString()}`);
-		}
-
 		return currentUrl;
 	};
 
@@ -166,20 +143,6 @@ function ShareURLModal({ extraOption }: ShareURLModalProps): JSX.Element {
 				</>
 			)}
 
-			{extraOption && (
-				<div className="absolute-relative-time-toggler-container">
-					<Typography.Text className="absolute-relative-time-toggler-label">
-						{extraOption.label}
-					</Typography.Text>
-					<div className="absolute-relative-time-toggler">
-						<Switch
-							value={enableExtraOption}
-							onChange={(): void => setEnableExtraOption((prev) => !prev)}
-						/>
-					</div>
-				</div>
-			)}
-
 			<div className="share-link">
 				<div className="url-share-container">
 					<div className="url-share-container-header">

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

@@ -247,6 +247,11 @@
 						var(--l2-background)
 					) !important;
 
+					&,
+					.ͼ1a {
+						color: var(--query-builder-v2-color, var(--l2-foreground));
+					}
+
 					::-moz-selection {
 						background: var(
 							--query-builder-v2-selection-background-color,

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

@@ -293,6 +293,11 @@ $max-recents-shown: 5;
 				var(--l2-background)
 			) !important;
 
+			&,
+			.ͼ1a {
+				color: var(--query-builder-v2-color, var(--l2-foreground));
+			}
+
 			::-moz-selection {
 				background: var(
 					--query-builder-v2-selection-background-color,

frontend/src/constants/routes.ts

@@ -89,10 +89,10 @@ const ROUTES = {
 	AI_ASSISTANT_BASE: '/ai-assistant',
 	AI_ASSISTANT_ICON_PREVIEW: '/ai-assistant-icon-preview',
 	MCP_SERVER: '/settings/mcp-server',
-	AI_OBSERVABILITY_ATTRIBUTE_MAPPING: '/ai-observability/attribute-mapping',
-	AI_OBSERVABILITY_BASE: '/ai-observability',
-	AI_OBSERVABILITY_OVERVIEW: '/ai-observability/overview',
-	AI_OBSERVABILITY_CONFIGURATION: '/ai-observability/configuration',
+	LLM_OBSERVABILITY_ATTRIBUTE_MAPPING: '/llm-observability/attribute-mapping',
+	LLM_OBSERVABILITY_BASE: '/llm-observability',
+	LLM_OBSERVABILITY_OVERVIEW: '/llm-observability/overview',
+	LLM_OBSERVABILITY_CONFIGURATION: '/llm-observability/configuration',
 } as const;
 
 export default ROUTES;

frontend/src/container/LLMObservability/Overview/Overview.module.scss

@@ -9,4 +9,6 @@
 	:global([class*='dashboardPageHeader']) {
 		display: none;
 	}
+	// remove margin added by the hidden header to avoid extra whitespace at the top of the page
+	margin-top: calc(var(--spacing-8) * -1);
 }

frontend/src/container/LLMObservability/Settings/ModelPricing/ModelCostTabPanel/components/ModelCostDrawer/ModelCostDrawer.module.scss

@@ -18,7 +18,7 @@
 	--dialog-footer-padding: var(--spacing-8) var(--spacing-12);
 
 	display: flex;
-	overflow: hidden;
+	overflow-y: auto;
 
 	// The drawer body — children render inside [data-slot='drawer-description']
 	// (this is the @signozhq drawer, not antd, so .ant-drawer-body was a no-op).
@@ -27,8 +27,6 @@
 		flex-direction: column;
 		gap: var(--spacing-12);
 		padding: var(--spacing-10) var(--spacing-12);
-		min-height: 0;
-		overflow-y: auto;
 	}
 
 	[data-slot='select-content'] {

frontend/src/container/LLMObservability/Settings/ModelPricing/ModelCostTabPanel/components/ModelCostDrawer/components/ExtraPricingBuckets/ExtraPricingBuckets.module.scss

@@ -51,6 +51,7 @@
 	gap: var(--spacing-5);
 	padding: var(--spacing-6);
 	border-radius: 6px;
+	background: var(--l2-background);
 	border: 1px solid var(--l2-border);
 }
 

frontend/src/container/LLMObservability/Settings/ModelPricing/ModelCostTabPanel/components/ModelCostDrawer/components/PatternEditor/PatternEditor.module.scss

@@ -9,6 +9,7 @@
 .patternBox {
 	display: flex;
 	flex-direction: column;
+	gap: var(--spacing-6);
 	padding: var(--spacing-6);
 	border-radius: 6px;
 	border: 1px solid var(--l2-border);
@@ -17,14 +18,14 @@
 .patternChips {
 	display: flex;
 	flex-wrap: wrap;
-	gap: var(--spacing-0) var(--spacing-3);
+	gap: var(--spacing-3);
+	min-height: 28px;
 }
 
 .patternChip {
 	display: inline-flex;
 	align-items: center;
 	gap: var(--spacing-2);
-	margin-bottom: var(--spacing-4);
 }
 
 .patternChipRemove {

frontend/src/container/LLMObservability/Settings/ModelPricing/ModelCostTabPanel/components/ModelCostDrawer/components/SourceSelector/SourceSelector.module.scss

@@ -30,6 +30,7 @@
 		padding: var(--spacing-5) var(--spacing-6);
 		border-radius: var(--radius-2);
 		border: 1px solid transparent;
+		background: var(--l3-background);
 		margin: 0;
 		width: 100%;
 		// Include padding + border in the 100% width so the card fits inside
@@ -66,11 +67,16 @@
 
 		// Radix RadioGroupItem renders <button data-state="checked|unchecked">.
 		// Use :has() to highlight the wrapper card when its inner button is checked.
-		&:has(button[data-state='checked']) {
+		&.sourceRadioAuto:has(button[data-state='checked']) {
 			background: color-mix(in srgb, var(--accent-primary) 10%, transparent);
 			border-color: color-mix(in srgb, var(--accent-primary) 30%, transparent);
 		}
 
+		&.sourceRadioOverride:has(button[data-state='checked']) {
+			background: color-mix(in srgb, var(--accent-amber) 10%, transparent);
+			border-color: color-mix(in srgb, var(--accent-amber) 30%, transparent);
+		}
+
 		&:hover {
 			background: var(--l3-background-hover);
 		}

frontend/src/container/LLMObservability/Settings/ModelPricing/ModelCostTabPanel/components/ModelCostDrawer/components/SourceSelector/SourceSelector.tsx

@@ -60,7 +60,7 @@ function SourceSelector({
 			>
 				<RadioGroupItem
 					value="auto"
-					containerClassName={styles.sourceRadio}
+					containerClassName={cx(styles.sourceRadio, styles.sourceRadioAuto)}
 					testId="drawer-source-auto"
 					disabled={disableAuto}
 				>
@@ -73,7 +73,7 @@ function SourceSelector({
 				</RadioGroupItem>
 				<RadioGroupItem
 					value="override"
-					containerClassName={styles.sourceRadio}
+					containerClassName={cx(styles.sourceRadio, styles.sourceRadioOverride)}
 					testId="drawer-source-override"
 				>
 					<div className={styles.sourceRadioTitle}>User override</div>

frontend/src/container/LLMObservability/Settings/ModelPricing/UnpricedModelsTab/UnpricedModelsTab.module.scss

@@ -13,7 +13,6 @@
 	border: 1px solid color-mix(in srgb, var(--bg-amber-400) 30%, transparent);
 	background: color-mix(in srgb, var(--bg-amber-400) 8%, transparent);
 	color: var(--bg-amber-300, var(--bg-amber-400));
-	margin-top: var(--spacing-4);
 }
 
 .bannerIcon {

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

@@ -37,7 +37,7 @@ describe('LLMObservability (integration)', () => {
 
 	it('renders the overview panel and the tab bar on the overview route', () => {
 		render(<LLMObservability />, undefined, {
-			initialRoute: ROUTES.AI_OBSERVABILITY_OVERVIEW,
+			initialRoute: ROUTES.LLM_OBSERVABILITY_OVERVIEW,
 		});
 
 		expect(screen.getByTestId('llm-observability-tabs')).toBeInTheDocument();
@@ -55,32 +55,32 @@ describe('LLMObservability (integration)', () => {
 	it('navigates to the configuration route when the Model pricing tab is clicked', async () => {
 		const user = userEvent.setup({ pointerEventsCheck: 0 });
 		render(<LLMObservability />, undefined, {
-			initialRoute: ROUTES.AI_OBSERVABILITY_OVERVIEW,
+			initialRoute: ROUTES.LLM_OBSERVABILITY_OVERVIEW,
 		});
 
 		await user.click(screen.getByRole('tab', { name: 'Model pricing' }));
 
 		expect(safeNavigateMock).toHaveBeenCalledWith(
-			ROUTES.AI_OBSERVABILITY_CONFIGURATION,
+			ROUTES.LLM_OBSERVABILITY_CONFIGURATION,
 		);
 	});
 
 	it('navigates to the attribute mapping route when that tab is clicked', async () => {
 		const user = userEvent.setup({ pointerEventsCheck: 0 });
 		render(<LLMObservability />, undefined, {
-			initialRoute: ROUTES.AI_OBSERVABILITY_OVERVIEW,
+			initialRoute: ROUTES.LLM_OBSERVABILITY_OVERVIEW,
 		});
 
 		await user.click(screen.getByRole('tab', { name: 'Attribute Mapping' }));
 
 		expect(safeNavigateMock).toHaveBeenCalledWith(
-			ROUTES.AI_OBSERVABILITY_ATTRIBUTE_MAPPING,
+			ROUTES.LLM_OBSERVABILITY_ATTRIBUTE_MAPPING,
 		);
 	});
 
 	it('renders the attribute mapping page on the attribute mapping route', () => {
 		render(<LLMObservability />, undefined, {
-			initialRoute: ROUTES.AI_OBSERVABILITY_ATTRIBUTE_MAPPING,
+			initialRoute: ROUTES.LLM_OBSERVABILITY_ATTRIBUTE_MAPPING,
 		});
 
 		expect(
@@ -91,7 +91,7 @@ describe('LLMObservability (integration)', () => {
 	it('renders the model-pricing page on the configuration route', async () => {
 		setupList();
 		render(<LLMObservability />, undefined, {
-			initialRoute: ROUTES.AI_OBSERVABILITY_CONFIGURATION,
+			initialRoute: ROUTES.LLM_OBSERVABILITY_CONFIGURATION,
 		});
 
 		await waitFor(() =>

frontend/src/container/LLMObservability/hooks/useLLMObservabilityTabs.tsx

@@ -8,9 +8,9 @@ import LLMObservabilityAttributeMapping from '../AttributeMapping/LLMObservabili
 import Overview from '../Overview/Overview';
 import LLMObservabilityModelPricing from '../Settings/ModelPricing/LLMObservabilityModelPricing';
 
-const OVERVIEW_KEY = ROUTES.AI_OBSERVABILITY_OVERVIEW;
-const CONFIGURATION_KEY = ROUTES.AI_OBSERVABILITY_CONFIGURATION;
-const ATTRIBUTE_MAPPING_KEY = ROUTES.AI_OBSERVABILITY_ATTRIBUTE_MAPPING;
+const OVERVIEW_KEY = ROUTES.LLM_OBSERVABILITY_OVERVIEW;
+const CONFIGURATION_KEY = ROUTES.LLM_OBSERVABILITY_CONFIGURATION;
+const ATTRIBUTE_MAPPING_KEY = ROUTES.LLM_OBSERVABILITY_ATTRIBUTE_MAPPING;
 
 interface UseLLMObservabilityTabsResult {
 	items: TabItemProps[];

frontend/src/container/LogDetailedView/TableView.styles.scss

@@ -20,7 +20,6 @@
 		.ant-table-cell {
 			border: 1px solid var(--l1-border);
 			background: var(--l2-background);
-			vertical-align: top;
 		}
 
 		.attribute-name {
@@ -34,12 +33,12 @@
 		.attribute-pin {
 			cursor: pointer;
 
-			padding: 14px 8px 8px;
-			vertical-align: top;
+			padding: 0;
+			vertical-align: middle;
 			text-align: center;
 
 			.log-attribute-pin {
-				padding: 0;
+				padding: 8px;
 
 				display: flex;
 				justify-content: center;

frontend/src/container/LogDetailedView/TableView/TableViewActions.styles.scss

@@ -15,13 +15,11 @@
 	.ant-tree-node-content-wrapper {
 		user-select: text !important;
 		cursor: text !important;
-		min-width: 0;
 	}
 
 	.ant-tree-title {
 		user-select: text !important;
 		cursor: text !important;
-		overflow-wrap: anywhere;
 	}
 }
 

frontend/src/container/OnboardingV2Container/onboarding-configs/onboarding-config-with-links.ts

@@ -5262,24 +5262,6 @@ const onboardingConfigWithLinks = [
 			],
 		},
 	},
-	{
-		dataSource: 'temporal-cloud-metrics',
-		label: 'Temporal Cloud Metrics',
-		imgUrl: temporalUrl,
-		tags: ['metrics'],
-		module: 'metrics',
-		relatedSearchKeywords: [
-			'metrics',
-			'integrations',
-			'temporal',
-			'temporal cloud',
-			'temporal cloud metrics',
-			'temporal metrics',
-			'openmetrics',
-			'prometheus',
-		],
-		link: '/docs/integrations/temporal-cloud-metrics/',
-	},
 	{
 		dataSource: 'temporal',
 		label: 'Temporal',
@@ -5291,6 +5273,9 @@ const onboardingConfigWithLinks = [
 			'application performance monitoring',
 			'integrations',
 			'temporal',
+			'temporal cloud',
+			'temporal logs',
+			'temporal metrics',
 			'temporal traces',
 			'traces',
 			'tracing',
@@ -5299,6 +5284,12 @@ const onboardingConfigWithLinks = [
 			desc: 'What are you using ?',
 			type: 'select',
 			options: [
+				{
+					key: 'temporal-cloud',
+					label: 'Cloud Metrics',
+					imgUrl: temporalUrl,
+					link: '/docs/integrations/temporal-cloud-metrics/',
+				},
 				{
 					key: 'temporal-golang',
 					label: 'Go',

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

@@ -22,7 +22,7 @@ import {
 import { MetricAggregation } from 'types/api/v5/queryRange';
 import { DataSource } from 'types/common/queryBuilder';
 import { ExtendedSelectOption } from 'types/common/select';
-import { useSelectPopupContainer } from 'utils/selectPopupContainer';
+import { popupContainer } from 'utils/selectPopupContainer';
 
 import { selectStyle } from '../QueryBuilderSearch/config';
 import OptionRenderer from '../QueryBuilderSearch/OptionRenderer';
@@ -39,7 +39,6 @@ export const AggregatorFilter = memo(function AggregatorFilter({
 	signalSource,
 	setAttributeKeys,
 }: AgregatorFilterProps): JSX.Element {
-	const getPopupContainer = useSelectPopupContainer();
 	const queryClient = useQueryClient();
 	const [optionsData, setOptionsData] = useState<ExtendedSelectOption[]>([]);
 
@@ -290,7 +289,7 @@ export const AggregatorFilter = memo(function AggregatorFilter({
 
 	return (
 		<AutoComplete
-			getPopupContainer={getPopupContainer}
+			getPopupContainer={popupContainer}
 			placeholder={getPlaceholder()}
 			style={selectStyle}
 			filterOption={false}

frontend/src/container/QueryBuilder/filters/BuilderUnitsFilter/BuilderUnits.tsx

@@ -2,7 +2,7 @@ import { Select, SelectProps, Space } from 'antd';
 import { Typography } from '@signozhq/ui/typography';
 import { getCategorySelectOptionByName } from 'container/NewWidget/RightContainer/alertFomatCategories';
 import { useQueryBuilder } from 'hooks/queryBuilder/useQueryBuilder';
-import { useSelectPopupContainer } from 'utils/selectPopupContainer';
+import { popupContainer } from 'utils/selectPopupContainer';
 
 import { categoryToSupport } from './config';
 import { selectStyles } from './styles';
@@ -13,7 +13,6 @@ function BuilderUnitsFilter({
 	onChange,
 	yAxisUnit,
 }: IBuilderUnitsFilterProps): JSX.Element {
-	const getPopupContainer = useSelectPopupContainer();
 	const { currentQuery, handleOnUnitsChange } = useQueryBuilder();
 
 	const selectedValue = yAxisUnit || currentQuery?.unit;
@@ -37,7 +36,7 @@ function BuilderUnitsFilter({
 				Y-axis unit
 			</Typography.Text>
 			<Select
-				getPopupContainer={getPopupContainer}
+				getPopupContainer={popupContainer}
 				style={selectStyles}
 				onChange={onChangeHandler}
 				value={selectedValue}

frontend/src/container/QueryBuilder/filters/Formula/Having/HavingFilter.tsx

@@ -9,13 +9,12 @@ import {
 } from 'lib/query/transformQueryBuilderData';
 import { Having, HavingForm } from 'types/api/queryBuilder/queryBuilderData';
 import { SelectOption } from 'types/common/select';
-import { useSelectPopupContainer } from 'utils/selectPopupContainer';
+import { popupContainer } from 'utils/selectPopupContainer';
 
 import { getHavingObject, isValidHavingValue } from '../../utils';
 import { HavingFilterProps, HavingTagRenderProps } from './types';
 
 function HavingFilter({ formula, onChange }: HavingFilterProps): JSX.Element {
-	const getPopupContainer = useSelectPopupContainer();
 	const { having } = formula;
 	const [searchText, setSearchText] = useState<string>('');
 	const [localValues, setLocalValues] = useState<string[]>([]);
@@ -172,7 +171,7 @@ function HavingFilter({ formula, onChange }: HavingFilterProps): JSX.Element {
 
 	return (
 		<Select
-			getPopupContainer={getPopupContainer}
+			getPopupContainer={popupContainer}
 			autoClearSearchValue={false}
 			mode="multiple"
 			onSearch={handleSearch}

frontend/src/container/QueryBuilder/filters/Formula/OrderBy/OrderByFilter.tsx

@@ -2,7 +2,7 @@ import { useMemo } from 'react';
 import { Select, Spin } from 'antd';
 import { useGetAggregateKeys } from 'hooks/queryBuilder/useGetAggregateKeys';
 import { MetricAggregateOperator } from 'types/common/queryBuilder';
-import { useSelectPopupContainer } from 'utils/selectPopupContainer';
+import { popupContainer } from 'utils/selectPopupContainer';
 
 import { selectStyle } from '../../QueryBuilderSearch/config';
 import { OrderByProps } from './types';
@@ -13,7 +13,6 @@ function OrderByFilter({
 	onChange,
 	query,
 }: OrderByProps): JSX.Element {
-	const getPopupContainer = useSelectPopupContainer();
 	const {
 		debouncedSearchText,
 		createOptions,
@@ -65,7 +64,7 @@ function OrderByFilter({
 
 	return (
 		<Select
-			getPopupContainer={getPopupContainer}
+			getPopupContainer={popupContainer}
 			mode="tags"
 			style={selectStyle}
 			onSearch={handleSearchKeys}

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

@@ -21,7 +21,7 @@ import { isEqual, uniqWith } from 'lodash-es';
 import { BaseAutocompleteData } from 'types/api/queryBuilder/queryAutocompleteResponse';
 import { DataSource } from 'types/common/queryBuilder';
 import { SelectOption } from 'types/common/select';
-import { useSelectPopupContainer } from 'utils/selectPopupContainer';
+import { popupContainer } from 'utils/selectPopupContainer';
 
 import { selectStyle } from '../QueryBuilderSearch/config';
 import OptionRenderer from '../QueryBuilderSearch/OptionRenderer';
@@ -33,7 +33,6 @@ export const GroupByFilter = memo(function GroupByFilter({
 	disabled,
 	signalSource,
 }: GroupByFilterProps): JSX.Element {
-	const getPopupContainer = useSelectPopupContainer();
 	const queryClient = useQueryClient();
 	const [searchText, setSearchText] = useState<string>('');
 	const [optionsData, setOptionsData] = useState<
@@ -175,7 +174,7 @@ export const GroupByFilter = memo(function GroupByFilter({
 
 	return (
 		<Select
-			getPopupContainer={getPopupContainer}
+			getPopupContainer={popupContainer}
 			mode="tags"
 			style={selectStyle}
 			onSearch={handleSearchKeys}

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

@@ -16,7 +16,7 @@ import {
 import { Having, HavingForm } from 'types/api/queryBuilder/queryBuilderData';
 import { DataSource } from 'types/common/queryBuilder';
 import { SelectOption } from 'types/common/select';
-import { useSelectPopupContainer } from 'utils/selectPopupContainer';
+import { popupContainer } from 'utils/selectPopupContainer';
 
 import { getHavingObject, isValidHavingValue } from '../utils';
 // ** Types
@@ -27,7 +27,6 @@ export function HavingFilter({
 	query,
 	onChange,
 }: HavingFilterProps): JSX.Element {
-	const getPopupContainer = useSelectPopupContainer();
 	const { having } = query;
 	const [searchText, setSearchText] = useState<string>('');
 	const [options, setOptions] = useState<SelectOption<string, string>[]>([]);
@@ -232,7 +231,7 @@ export function HavingFilter({
 	return (
 		<>
 			<Select
-				getPopupContainer={getPopupContainer}
+				getPopupContainer={popupContainer}
 				autoClearSearchValue={false}
 				mode="multiple"
 				onSearch={handleSearch}

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

@@ -14,7 +14,7 @@ import {
 import { IBuilderQuery } from 'types/api/queryBuilder/queryBuilderData';
 import { MetricAggregation } from 'types/api/v5/queryRange';
 import { ExtendedSelectOption } from 'types/common/select';
-import { useSelectPopupContainer } from 'utils/selectPopupContainer';
+import { popupContainer } from 'utils/selectPopupContainer';
 
 import { selectStyle } from '../QueryBuilderSearch/config';
 import OptionRenderer from '../QueryBuilderSearch/OptionRenderer';
@@ -85,7 +85,6 @@ export const MetricNameSelector = memo(function MetricNameSelector({
 	signalSource,
 	'data-testid': dataTestId,
 }: MetricNameSelectorProps): JSX.Element {
-	const getPopupContainer = useSelectPopupContainer();
 	const currentMetricName =
 		(query.aggregations?.[0] as MetricAggregation)?.metricName ||
 		query.aggregateAttribute?.key ||
@@ -273,7 +272,7 @@ export const MetricNameSelector = memo(function MetricNameSelector({
 	return (
 		<AutoComplete
 			className="metric-name-selector"
-			getPopupContainer={getPopupContainer}
+			getPopupContainer={popupContainer}
 			style={selectStyle}
 			filterOption={false}
 			placeholder={placeholder}

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

@@ -3,7 +3,7 @@ import { Select, Spin } from 'antd';
 import { useGetAggregateKeys } from 'hooks/queryBuilder/useGetAggregateKeys';
 import { DataSource, MetricAggregateOperator } from 'types/common/queryBuilder';
 import { getParsedAggregationOptionsForOrderBy } from 'utils/aggregationConverter';
-import { useSelectPopupContainer } from 'utils/selectPopupContainer';
+import { popupContainer } from 'utils/selectPopupContainer';
 
 import { selectStyle } from '../QueryBuilderSearch/config';
 import { OrderByFilterProps } from './OrderByFilter.interfaces';
@@ -16,7 +16,6 @@ export function OrderByFilter({
 	entityVersion,
 	isNewQueryV2 = false,
 }: OrderByFilterProps): JSX.Element {
-	const getPopupContainer = useSelectPopupContainer();
 	const {
 		debouncedSearchText,
 		selectedValue,
@@ -79,7 +78,7 @@ export function OrderByFilter({
 
 	return (
 		<Select
-			getPopupContainer={getPopupContainer}
+			getPopupContainer={popupContainer}
 			mode="tags"
 			style={selectStyle}
 			onSearch={handleSearchKeys}

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

@@ -50,7 +50,7 @@ import {
 } from 'types/api/queryBuilder/queryBuilderData';
 import { DataSource } from 'types/common/queryBuilder';
 import { getUserOperatingSystem, UserOperatingSystem } from 'utils/getUserOS';
-import { useSelectPopupContainer } from 'utils/selectPopupContainer';
+import { popupContainer } from 'utils/selectPopupContainer';
 import { v4 as uuid } from 'uuid';
 
 import { FeatureKeys } from '../../../../constants/features';
@@ -95,7 +95,6 @@ function QueryBuilderSearch({
 	disableNavigationShortcuts,
 	entity,
 }: QueryBuilderSearchProps): JSX.Element {
-	const getPopupContainer = useSelectPopupContainer();
 	const { pathname } = useLocation();
 	const isLogsExplorerPage = useMemo(
 		() => pathname === ROUTES.LOGS_EXPLORER,
@@ -398,7 +397,7 @@ function QueryBuilderSearch({
 			<Select
 				data-testid={'qb-search-select'}
 				ref={selectRef}
-				getPopupContainer={getPopupContainer}
+				getPopupContainer={popupContainer}
 				transitionName=""
 				choiceTransitionName=""
 				virtual={false}

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

@@ -50,7 +50,7 @@ import {
 	TagFilter,
 } from 'types/api/queryBuilder/queryBuilderData';
 import { DataSource } from 'types/common/queryBuilder';
-import { useSelectPopupContainer } from 'utils/selectPopupContainer';
+import { popupContainer } from 'utils/selectPopupContainer';
 import { v4 as uuid } from 'uuid';
 
 import { selectStyle } from '../QueryBuilderSearch/config';
@@ -157,8 +157,6 @@ function QueryBuilderSearchV2(
 		selectProps,
 	} = props;
 
-	const getPopupContainer = useSelectPopupContainer();
-
 	const { registerShortcut, deregisterShortcut } = useKeyboardHotkeys();
 
 	const { handleRunQuery, currentQuery } = useQueryBuilder();
@@ -991,7 +989,7 @@ function QueryBuilderSearchV2(
 				{...selectProps}
 				data-testid={'qb-search-select'}
 				ref={selectRef}
-				{...(hasPopupContainer ? { getPopupContainer } : {})}
+				{...(hasPopupContainer ? { getPopupContainer: popupContainer } : {})}
 				{...(maxTagCount ? { maxTagCount } : {})}
 				key={queryTags.join('.')}
 				virtual={false}

frontend/src/container/SideNav/SideNav.tsx

@@ -47,7 +47,6 @@ import { useKeyboardHotkeys } from 'hooks/hotkeys/useKeyboardHotkeys';
 import useComponentPermission from 'hooks/useComponentPermission';
 import { useGetTenantLicense } from 'hooks/useGetTenantLicense';
 import { useIsAIAssistantEnabled } from 'hooks/useIsAIAssistantEnabled';
-import { useIsAIObservabilityEnabled } from 'hooks/useIsAIObservabilityEnabled';
 import { useNotifications } from 'hooks/useNotifications';
 import history from 'lib/history';
 import { isArray } from 'lodash-es';
@@ -254,7 +253,6 @@ function SideNav({ isPinned }: { isPinned: boolean }): JSX.Element {
 	const isAdmin = user.role === USER_ROLES.ADMIN;
 	const isEditor = user.role === USER_ROLES.EDITOR;
 	const isAIAssistantEnabled = useIsAIAssistantEnabled();
-	const isAIObservabilityEnabled = useIsAIObservabilityEnabled();
 	const aiAssistantActiveConversationId = useAIAssistantStore(
 		(s) => s.activeConversationId,
 	);
@@ -290,22 +288,15 @@ function SideNav({ isPinned }: { isPinned: boolean }): JSX.Element {
 		const shouldShowIntegrationsValue =
 			(isCloudUser || isEnterpriseSelfHostedUser) && (isAdmin || isEditor);
 
-		const isEnabledForItem = (item: SidebarItem): boolean | undefined => {
-			if (item.key === ROUTES.INTEGRATIONS) {
-				return shouldShowIntegrationsValue;
-			}
-			if (item.key === ROUTES.AI_OBSERVABILITY_OVERVIEW) {
-				return isAIObservabilityEnabled;
-			}
-			return item.isEnabled;
-		};
-
 		return defaultMoreMenuItems.map((item) => ({
 			...item,
 			isPinned: computedPinnedMenuItems.some(
 				(pinned) => pinned.itemKey === item.itemKey,
 			),
-			isEnabled: isEnabledForItem(item),
+			isEnabled:
+				item.key === ROUTES.INTEGRATIONS
+					? shouldShowIntegrationsValue
+					: item.isEnabled,
 		}));
 	}, [
 		computedPinnedMenuItems,
@@ -313,7 +304,6 @@ function SideNav({ isPinned }: { isPinned: boolean }): JSX.Element {
 		isEnterpriseSelfHostedUser,
 		isAdmin,
 		isEditor,
-		isAIObservabilityEnabled,
 	]);
 
 	// Track if we've done the initial sync (to avoid overwriting user actions during session)

frontend/src/container/SideNav/menuItems.tsx

@@ -36,7 +36,6 @@ import {
 	UserPlus,
 	Users,
 	Binoculars,
-	Brain,
 } from '@signozhq/icons';
 
 import {
@@ -289,16 +288,6 @@ export const defaultMoreMenuItems: SidebarItem[] = [
 		isEnabled: true,
 		itemKey: 'external-apis',
 	},
-	{
-		key: ROUTES.AI_OBSERVABILITY_OVERVIEW,
-		label: 'AI Observability',
-		icon: <Brain size={16} />,
-		isNew: true,
-		// Gated behind the `enable_ai_observability` feature flag in
-		// SideNav's `computedSecondaryMenuItems`; disabled by default.
-		isEnabled: false,
-		itemKey: 'ai-observability',
-	},
 	{
 		key: ROUTES.METER,
 		label: 'Cost Meter',
@@ -564,9 +553,7 @@ export const getUserSettingsDropdownMenuItems = ({
 		},
 	].filter(Boolean);
 
-/** Mapping of some newly added routes and their corresponding active sidebar menu key
-    This is used to highlight the correct menu item when the user navigates to a new route
-**/
+/** Mapping of some newly added routes and their corresponding active sidebar menu key */
 export const NEW_ROUTES_MENU_ITEM_KEY_MAP: Record<string, string> = {
 	[ROUTES.TRACE]: ROUTES.TRACES_EXPLORER,
 	[ROUTES.TRACE_EXPLORER]: ROUTES.TRACES_EXPLORER,
@@ -576,7 +563,6 @@ export const NEW_ROUTES_MENU_ITEM_KEY_MAP: Record<string, string> = {
 		ROUTES.INFRASTRUCTURE_MONITORING_HOSTS,
 	[ROUTES.API_MONITORING_BASE]: ROUTES.API_MONITORING,
 	[ROUTES.MESSAGING_QUEUES_BASE]: ROUTES.MESSAGING_QUEUES_OVERVIEW,
-	[ROUTES.AI_OBSERVABILITY_BASE]: ROUTES.AI_OBSERVABILITY_OVERVIEW,
 	// `getActiveMenuKeyFromPath` strips the URL down to its first segment;
 	// `/ai-assistant/<id>` reduces to `/ai-assistant`, which we point back
 	// to the AI Assistant menu item's concrete key.

frontend/src/container/TopNav/DateTimeSelectionV2/constants.ts

@@ -203,9 +203,9 @@ export const routesToSkip = [
 	ROUTES.METER_EXPLORER_VIEWS,
 	ROUTES.METRICS_EXPLORER_VOLUME_CONTROL,
 	ROUTES.SOMETHING_WENT_WRONG,
-	ROUTES.AI_OBSERVABILITY_OVERVIEW,
-	ROUTES.AI_OBSERVABILITY_CONFIGURATION,
-	ROUTES.AI_OBSERVABILITY_ATTRIBUTE_MAPPING,
+	ROUTES.LLM_OBSERVABILITY_OVERVIEW,
+	ROUTES.LLM_OBSERVABILITY_CONFIGURATION,
+	ROUTES.LLM_OBSERVABILITY_ATTRIBUTE_MAPPING,
 ];
 
 export const routesToDisable = [ROUTES.LOGS_EXPLORER, ROUTES.LIVE_LOGS];

frontend/src/lib/uPlotV2/components/UPlotChart/UPlotChart.tsx

@@ -126,15 +126,6 @@ export default function UPlotChart({
 		}
 	}, [isDataEmpty, destroyPlot]);
 
-	/**
-	 * Destroy the plot on unmount. Without this, uPlot's window-level
-	 * `dppxchange` listener keeps the instance (and its whole detached DOM
-	 * subtree) alive after the component is gone.
-	 */
-	const destroyPlotRef = useRef(destroyPlot);
-	destroyPlotRef.current = destroyPlot;
-	useEffect(() => (): void => destroyPlotRef.current(), []);
-
 	/**
 	 * Handle initialization and prop changes
 	 */

frontend/src/lib/uPlotV2/components/__tests__/UPlotChart.test.tsx

@@ -327,32 +327,6 @@ describe('UPlotChart', () => {
 			expect(firstInstance.destroy).toHaveBeenCalled();
 			expect(instances).toHaveLength(2);
 		});
-
-		it('destroys the instance and notifies callbacks on unmount', () => {
-			const plotRef = jest.fn();
-			const onDestroy = jest.fn();
-
-			const { unmount } = render(
-				<UPlotChart
-					config={createMockConfig()}
-					data={validData}
-					width={600}
-					height={400}
-					plotRef={plotRef}
-					onDestroy={onDestroy}
-				/>,
-				{ wrapper: Wrapper },
-			);
-
-			const firstInstance = instances[0];
-			plotRef.mockClear();
-
-			unmount();
-
-			expect(onDestroy).toHaveBeenCalledWith(firstInstance);
-			expect(firstInstance.destroy).toHaveBeenCalledTimes(1);
-			expect(plotRef).toHaveBeenCalledWith(null);
-		});
 	});
 
 	describe('spanGaps data transformation', () => {

frontend/src/pages/DashboardPageV2/DashboardContainer/DashboardSettings/Variables/variableFormModel.ts

@@ -16,13 +16,7 @@ import { sortBy } from 'lodash-es';
 export type VariableType = 'QUERY' | 'CUSTOM' | 'TEXT' | 'DYNAMIC';
 
 /** Telemetry signal — the generated enum (traces / logs / metrics). */
-// A query/variable signal is only logs/traces/metrics. TelemetrytypesSignalDTO
-// also carries the empty "any" value used on field keys, which is not a valid
-// query/variable signal, so exclude it here.
-export type TelemetrySignal =
-	| TelemetrytypesSignalDTO.logs
-	| TelemetrytypesSignalDTO.traces
-	| TelemetrytypesSignalDTO.metrics;
+export type TelemetrySignal = TelemetrytypesSignalDTO;
 
 /**
  * Signal selected in the dynamic-variable editor. `'all'` is UI-only (the

frontend/src/pages/DashboardPageV2/DashboardContainer/PanelEditor/ConfigPane/PanelTypeSwitcher/utils.ts

@@ -17,9 +17,6 @@ const SIGNAL_LABEL: Record<TelemetrytypesSignalDTO, string> = {
 	[TelemetrytypesSignalDTO.logs]: 'logs',
 	[TelemetrytypesSignalDTO.traces]: 'traces',
 	[TelemetrytypesSignalDTO.metrics]: 'metrics',
-	// The empty "any" signal only appears on field keys, never on a panel query;
-	// mapped for exhaustiveness.
-	[TelemetrytypesSignalDTO['']]: '',
 };
 
 /**

frontend/src/pages/DashboardPageV2/DashboardContainer/PanelEditor/ConfigPane/sectionRegistry.tsx

@@ -1,6 +1,6 @@
 import type { ComponentType } from 'react';
 import type {
-	DashboardtypesLinkDTO,
+	DashboardLinkDTO,
 	DashboardtypesAxesDTO,
 	DashboardtypesBarChartVisualizationDTO,
 	DashboardtypesHistogramBucketsDTO,
@@ -120,7 +120,7 @@ export const SECTION_REGISTRY: {
 	[SectionKind.ContextLinks]: {
 		Component: ContextLinksSection,
 		// Panel-level slice (spec.links), not under the plugin spec — no cast needed.
-		get: (spec): DashboardtypesLinkDTO[] | undefined => spec.links ?? undefined,
+		get: (spec): DashboardLinkDTO[] | undefined => spec.links,
 		update: (spec, links): PanelSpec => ({ ...spec, links }),
 	},
 	// One editor for every threshold variant (label / comparison / table); the kind's

frontend/src/pages/DashboardPageV2/DashboardContainer/PanelEditor/ConfigPane/sections/ContextLinksSection/ContextLinkDialog.tsx

@@ -5,7 +5,7 @@ import { DialogWrapper } from '@signozhq/ui/dialog';
 import { Switch } from '@signozhq/ui/switch';
 import { Typography } from '@signozhq/ui/typography';
 import { Input } from 'antd';
-import type { DashboardtypesLinkDTO } from 'api/generated/services/sigNoz.schemas';
+import type { DashboardLinkDTO } from 'api/generated/services/sigNoz.schemas';
 
 import type { UrlParam, VariableItem } from './types';
 import {
@@ -21,10 +21,10 @@ import styles from './ContextLinksSection.module.scss';
 interface ContextLinkDialogProps {
 	open: boolean;
 	/** The link being edited, or null when adding a new one. */
-	initialLink: DashboardtypesLinkDTO | null;
+	initialLink: DashboardLinkDTO | null;
 	variables: VariableItem[];
 	onOpenChange: (open: boolean) => void;
-	onSave: (link: DashboardtypesLinkDTO) => void;
+	onSave: (link: DashboardLinkDTO) => void;
 }
 
 const URL_ERROR = 'URL must start with http(s)://, /, or {{variable}}/';

frontend/src/pages/DashboardPageV2/DashboardContainer/PanelEditor/ConfigPane/sections/ContextLinksSection/ContextLinkListItem.tsx

@@ -1,12 +1,12 @@
 import { Pencil, Trash2 } from '@signozhq/icons';
 import { Button } from '@signozhq/ui/button';
 import { Typography } from '@signozhq/ui/typography';
-import type { DashboardtypesLinkDTO } from 'api/generated/services/sigNoz.schemas';
+import type { DashboardLinkDTO } from 'api/generated/services/sigNoz.schemas';
 
 import styles from './ContextLinksSection.module.scss';
 
 interface ContextLinkListItemProps {
-	link: DashboardtypesLinkDTO;
+	link: DashboardLinkDTO;
 	index: number;
 	onEdit: () => void;
 	onRemove: () => void;

frontend/src/pages/DashboardPageV2/DashboardContainer/PanelEditor/ConfigPane/sections/ContextLinksSection/ContextLinksSection.tsx

@@ -1,7 +1,7 @@
 import { useState } from 'react';
 import { Plus } from '@signozhq/icons';
 import { Button } from '@signozhq/ui/button';
-import type { DashboardtypesLinkDTO } from 'api/generated/services/sigNoz.schemas';
+import type { DashboardLinkDTO } from 'api/generated/services/sigNoz.schemas';
 import type {
 	SectionEditorProps,
 	SectionKind,
@@ -34,7 +34,7 @@ function ContextLinksSection({
 	const removeAt = (index: number): void =>
 		onChange(links.filter((_, i) => i !== index));
 
-	const handleSave = (link: DashboardtypesLinkDTO): void => {
+	const handleSave = (link: DashboardLinkDTO): void => {
 		onChange(
 			dialog.index === null
 				? [...links, link]

frontend/src/pages/DashboardPageV2/DashboardContainer/PanelEditor/ConfigPane/sections/ContextLinksSection/__tests__/ContextLinksSection.test.tsx

@@ -1,5 +1,5 @@
 import { fireEvent, render, screen } from '@testing-library/react';
-import type { DashboardtypesLinkDTO } from 'api/generated/services/sigNoz.schemas';
+import type { DashboardLinkDTO } from 'api/generated/services/sigNoz.schemas';
 
 import ContextLinksSection from '../ContextLinksSection';
 
@@ -12,11 +12,11 @@ jest.mock('../useContextLinkVariables', () => ({
 	],
 }));
 
-const LINKS: DashboardtypesLinkDTO[] = [
+const LINKS: DashboardLinkDTO[] = [
 	{ name: 'Docs', url: 'https://signoz.io', targetBlank: true },
 ];
 
-const lastCall = (fn: jest.Mock): DashboardtypesLinkDTO[] =>
+const lastCall = (fn: jest.Mock): DashboardLinkDTO[] =>
 	fn.mock.calls[fn.mock.calls.length - 1][0];
 
 describe('ContextLinksSection', () => {

frontend/src/pages/DashboardPageV2/DashboardContainer/PanelEditor/ConfigPane/sections/ThresholdsSection/ThresholdColorSelect.tsx

@@ -1,6 +1,5 @@
 import { ChevronDown } from '@signozhq/icons';
 import { ColorPicker } from 'antd';
-import { ThresholdColor } from 'pages/DashboardPageV2/DashboardContainer/Panels/types/threshold';
 
 import styles from './ThresholdsSection.module.scss';
 
@@ -12,11 +11,11 @@ interface ThresholdColorSelectProps {
 
 // Named presets from the SigNoz palette (cherry / amber / forest / robin). They surface
 // as quick swatches in the picker; the full picker below covers any custom color.
-const PRESETS: { label: string; value: ThresholdColor }[] = [
-	{ label: 'Red', value: ThresholdColor.RED },
-	{ label: 'Orange', value: ThresholdColor.ORANGE },
-	{ label: 'Green', value: ThresholdColor.GREEN },
-	{ label: 'Blue', value: ThresholdColor.BLUE },
+const PRESETS: { label: string; value: string }[] = [
+	{ label: 'Red', value: '#F1575F' },
+	{ label: 'Orange', value: '#F5B225' },
+	{ label: 'Green', value: '#2BB673' },
+	{ label: 'Blue', value: '#4E74F8' },
 ];
 
 /**

frontend/src/pages/DashboardPageV2/DashboardContainer/PanelEditor/ConfigPane/sections/ThresholdsSection/ThresholdsSection.tsx

@@ -12,7 +12,6 @@ import {
 	AnyThreshold,
 	ThresholdVariant,
 } from 'pages/DashboardPageV2/DashboardContainer/Panels/types/sections';
-import { ThresholdColor } from 'pages/DashboardPageV2/DashboardContainer/Panels/types/threshold';
 
 import type { TableColumnOption } from '../../../hooks/useTableColumns';
 import type { SectionEditorContext } from '../../sectionContext';
@@ -23,7 +22,7 @@ import TableThresholdRow from './rows/TableThresholdRow';
 import styles from './ThresholdsSection.module.scss';
 
 // New thresholds default to red (the first palette preset); the user recolors per rule.
-const DEFAULT_THRESHOLD_COLOR = ThresholdColor.RED;
+const DEFAULT_THRESHOLD_COLOR = '#F1575F';
 
 // Add-button testId per variant — kept stable so existing E2E/unit selectors hold.
 const ADD_TESTID: Record<ThresholdVariant, string> = {

frontend/src/pages/DashboardPageV2/DashboardContainer/PanelEditor/hooks/__tests__/usePanelEditorDraft.test.ts

@@ -73,25 +73,6 @@ describe('usePanelEditorDraft', () => {
 		expect(result.current.isSpecDirty).toBe(false);
 	});
 
-	it('flags spec-dirty when the seed differs from the saved baseline (View handoff)', () => {
-		// The editor opens on a handed-off, already-edited spec (`seed`) but compares
-		// against the persisted panel (`saved`) — so it starts dirty, not clean.
-		const seed = panel('Memory', 'usage');
-		const saved = panel('CPU', 'usage');
-
-		const { result } = renderHook(() => usePanelEditorDraft(seed, saved));
-
-		expect(result.current.isSpecDirty).toBe(true);
-	});
-
-	it('is clean when the seed matches the saved baseline', () => {
-		const { result } = renderHook(() =>
-			usePanelEditorDraft(panel('CPU', 'usage'), panel('CPU', 'usage')),
-		);
-
-		expect(result.current.isSpecDirty).toBe(false);
-	});
-
 	it('reset restores the spec and clears dirty after an edit', () => {
 		const { result } = renderHook(() => usePanelEditorDraft(panel()));
 

frontend/src/pages/DashboardPageV2/DashboardContainer/PanelEditor/hooks/__tests__/usePanelEditorQuerySync.integration.test.tsx

@@ -1,201 +0,0 @@
-import { renderHook, waitFor } from '@testing-library/react';
-import type {
-	DashboardtypesPanelDTO,
-	DashboardtypesQueryDTO,
-} from 'api/generated/services/sigNoz.schemas';
-import { QueryParams } from 'constants/query';
-import { initialQueriesMap, PANEL_TYPES } from 'constants/queryBuilder';
-import type { Query } from 'types/api/queryBuilder/queryBuilderData';
-import { DataSource } from 'types/common/queryBuilder';
-import { AllTheProviders } from 'tests/test-utils';
-
-import { toPerses } from '../../../queryV5/persesQueryAdapters';
-import { usePanelEditorQuerySync } from '../usePanelEditorQuerySync';
-
-// Exercises the REAL query builder provider (not mocks) so the dirty check is
-// verified against the builder's actual re-serialization — the "always dirty"
-// regression only reproduces with the real normalization in the loop.
-
-const panelType = PANEL_TYPES.TIME_SERIES;
-
-function makeSavedQueries(): DashboardtypesQueryDTO[] {
-	const base: Query = {
-		...initialQueriesMap[DataSource.METRICS],
-		builder: {
-			...initialQueriesMap[DataSource.METRICS].builder,
-			queryData: [
-				{
-					...initialQueriesMap[DataSource.METRICS].builder.queryData[0],
-					legend: 'cpu',
-				},
-			],
-		},
-	};
-	return toPerses(base, panelType);
-}
-
-function makePanel(queries: DashboardtypesQueryDTO[]): DashboardtypesPanelDTO {
-	return {
-		kind: 'Panel',
-		spec: {
-			display: { name: 'CPU' },
-			plugin: { kind: 'signoz/TimeSeriesPanel', spec: {} },
-			queries,
-		},
-	} as unknown as DashboardtypesPanelDTO;
-}
-
-describe('usePanelEditorQuerySync (real query builder)', () => {
-	it('an untouched existing panel is NOT query-dirty on mount', async () => {
-		const saved = makeSavedQueries();
-		const { result } = renderHook(
-			() =>
-				usePanelEditorQuerySync({
-					draft: makePanel(saved),
-					panelType,
-					setSpec: jest.fn(),
-					refetch: jest.fn(),
-					savedQueries: saved,
-				}),
-			{ wrapper: AllTheProviders },
-		);
-
-		// The builder force-resets to the saved query asynchronously; once settled the
-		// live query must serialize back to the saved queries → clean.
-		await waitFor(() => expect(result.current.isQueryDirty).toBe(false));
-		// And stays clean (no late re-stage flips it dirty).
-		expect(result.current.isQueryDirty).toBe(false);
-	});
-
-	it('an untouched panel with a minimal/older stored query is NOT dirty (drift fix)', async () => {
-		// An older saved query carries only a few fields; the builder re-emits many more
-		// (source, stepInterval, filter, spaceAggregation, …). Comparing raw would read
-		// this as always-dirty; the round-tripped baseline normalizes both sides.
-		const minimalSaved: DashboardtypesQueryDTO[] = [
-			{
-				kind: 'time_series',
-				spec: {
-					plugin: {
-						kind: 'signoz/CompositeQuery',
-						spec: {
-							queries: [
-								{
-									type: 'builder_query',
-									spec: {
-										name: 'A',
-										signal: 'metrics',
-										aggregations: [
-											{ metricName: 'system_cpu_time', timeAggregation: 'avg' },
-										],
-									},
-								},
-							],
-						},
-					},
-				},
-			},
-		] as unknown as DashboardtypesQueryDTO[];
-
-		const { result } = renderHook(
-			() =>
-				usePanelEditorQuerySync({
-					draft: makePanel(minimalSaved),
-					panelType,
-					setSpec: jest.fn(),
-					refetch: jest.fn(),
-					savedQueries: minimalSaved,
-				}),
-			{ wrapper: AllTheProviders },
-		);
-
-		await waitFor(() => expect(result.current.isQueryDirty).toBe(false));
-		expect(result.current.isQueryDirty).toBe(false);
-	});
-
-	it('retains an in-editor query edit carried in the URL across a refresh (and reads dirty)', async () => {
-		// Simulate a refresh mid-edit: the saved panel is unchanged, but the URL still
-		// carries the last-run (edited) query. The builder must hydrate from the URL —
-		// not discard it — so the edit survives, and it must read dirty against saved.
-		const saved = makeSavedQueries();
-		const editedInUrl: Query = {
-			...initialQueriesMap[DataSource.METRICS],
-			id: 'edited-in-url',
-			builder: {
-				...initialQueriesMap[DataSource.METRICS].builder,
-				queryData: [
-					{
-						...initialQueriesMap[DataSource.METRICS].builder.queryData[0],
-						legend: 'cpu-edited-in-url',
-					},
-				],
-			},
-		};
-		const params = new URLSearchParams();
-		params.set(
-			QueryParams.compositeQuery,
-			encodeURIComponent(JSON.stringify(editedInUrl)),
-		);
-		const setSpec = jest.fn();
-
-		const wrapper = ({
-			children,
-		}: {
-			children: React.ReactNode;
-		}): JSX.Element => (
-			<AllTheProviders initialRoute={`/?${params.toString()}`}>
-				{children}
-			</AllTheProviders>
-		);
-
-		const { result } = renderHook(
-			() =>
-				usePanelEditorQuerySync({
-					// The draft/preview open on the saved query…
-					draft: makePanel(saved),
-					panelType,
-					setSpec,
-					refetch: jest.fn(),
-					savedQueries: saved,
-				}),
-			{ wrapper },
-		);
-
-		// The URL edit is retained → dirty, and it's synced into the draft so the
-		// preview follows (setSpec called with the edited query).
-		await waitFor(() => expect(result.current.isQueryDirty).toBe(true));
-		expect(setSpec).toHaveBeenCalled();
-	});
-
-	it('is query-dirty when the draft carries an edit the saved panel does not (View handoff)', async () => {
-		const saved = makeSavedQueries();
-		const editedBase: Query = {
-			...initialQueriesMap[DataSource.METRICS],
-			builder: {
-				...initialQueriesMap[DataSource.METRICS].builder,
-				queryData: [
-					{
-						...initialQueriesMap[DataSource.METRICS].builder.queryData[0],
-						legend: 'cpu-edited',
-					},
-				],
-			},
-		};
-		const editedQueries = toPerses(editedBase, panelType);
-
-		const { result } = renderHook(
-			() =>
-				usePanelEditorQuerySync({
-					// The builder seeds from the draft (the handed-off edit)…
-					draft: makePanel(editedQueries),
-					panelType,
-					setSpec: jest.fn(),
-					refetch: jest.fn(),
-					// …but the baseline is the persisted panel.
-					savedQueries: saved,
-				}),
-			{ wrapper: AllTheProviders },
-		);
-
-		await waitFor(() => expect(result.current.isQueryDirty).toBe(true));
-	});
-});

frontend/src/pages/DashboardPageV2/DashboardContainer/PanelEditor/hooks/__tests__/usePanelEditorQuerySync.test.ts

@@ -95,7 +95,6 @@ describe('usePanelEditorQuerySync', () => {
 			draft?: DashboardtypesPanelDTO;
 			setSpec?: jest.Mock;
 			refetch?: jest.Mock;
-			savedQueries?: DashboardtypesPanelSpecDTO['queries'];
 		} = {},
 	): {
 		result: {
@@ -120,22 +119,20 @@ describe('usePanelEditorQuerySync', () => {
 				panelType: PANEL_TYPES.TIME_SERIES,
 				setSpec,
 				refetch,
-				savedQueries: opts.savedQueries,
 			}),
 		);
 		return { result, setSpec, refetch, rerender };
 	}
 
-	it('seeds the builder from the draft queries on mount (URL query, when present, wins)', () => {
+	it('force-resets the builder to the saved queries on mount (discards stale URL)', () => {
 		setup();
 		expect(mockFromPerses).toHaveBeenCalledWith(
 			SAVED_QUERIES,
 			PANEL_TYPES.TIME_SERIES,
 		);
-		// No forceReset: useShareBuilderUrl resets to the seed only when the URL carries
-		// no query, so an in-editor edit in the URL survives a refresh.
 		expect(mockUseShareBuilderUrl).toHaveBeenCalledWith({
 			defaultValue: SEED_V1,
+			forceReset: true,
 		});
 	});
 
@@ -345,127 +342,44 @@ describe('usePanelEditorQuerySync', () => {
 		});
 	});
 
-	describe('staged-query re-sync (browser back/forward)', () => {
-		it('commits the staged query into the draft when it re-stages', () => {
-			const state = builderState();
-			mockUseQueryBuilder.mockImplementation(() => state);
-
-			const { setSpec, rerender } = setup();
-			setSpec.mockClear();
-
-			// Browser Back re-stages a different query via initQueryBuilderData; the
-			// preview must follow it instead of keeping the last Run's result.
-			mockGetIsQueryModified.mockReturnValue(true);
-			state.stagedQuery = {
-				id: 'restaged',
-				queryType: 'builder',
-			} as unknown as Query;
-			rerender();
-
-			expect(setSpec).toHaveBeenCalledWith({
-				...makeDraft().spec,
-				queries: CONVERTED_QUERIES,
-			});
-		});
-
-		it('does not commit when only the live query changes (no re-stage)', () => {
-			const state = builderState({
-				currentQuery: { id: 'a', queryType: 'builder' } as Query,
-			});
-			mockUseQueryBuilder.mockImplementation(() => state);
-			mockGetIsQueryModified.mockReturnValue(true);
-
-			const { setSpec, rerender } = setup();
-			setSpec.mockClear();
-
-			// Live edit: currentQuery changes, staged query + structure unchanged.
-			state.currentQuery = { id: 'b', queryType: 'builder' } as Query;
-			rerender();
-
-			expect(setSpec).not.toHaveBeenCalled();
-		});
-	});
-
 	describe('query dirty + save', () => {
-		// isQueryDirty compares the live query to the SAVED queries at the V5 envelope
-		// level (toQueryEnvelopes is mocked identity). Drive it via an input-sensitive
-		// toPerses so the envelope comparison — not getIsQueryModified — decides.
-		const SAVED_BASELINE = [{ id: 'saved-baseline' }] as unknown as NonNullable<
-			DashboardtypesPanelSpecDTO['queries']
-		>;
-		const EDITED_ENVELOPES = [
-			{ id: 'edited-envelopes' },
-		] as unknown as NonNullable<DashboardtypesPanelSpecDTO['queries']>;
-		const editedQuery = { id: 'edited', queryType: 'builder' } as Query;
-		const unchangedQuery = { id: 'unchanged', queryType: 'builder' } as Query;
+		it('compares the live query against the builder baseline (first staged query), not the raw seed', () => {
+			mockGetIsQueryModified.mockReturnValue(true);
+			const { result } = setup();
 
-		beforeEach(() => {
-			mockToPerses.mockImplementation((query: Query) =>
-				query?.id === 'edited' ? EDITED_ENVELOPES : SAVED_BASELINE,
+			// Baseline is the builder's own normalized staged query — immune to the
+			// raw-seed vs builder-normalized serialization drift.
+			expect(mockGetIsQueryModified).toHaveBeenCalledWith(
+				expect.anything(),
+				STAGED_V1,
 			);
-		});
-
-		it('is query-dirty when the live query no longer serializes to the saved queries', () => {
-			mockUseQueryBuilder.mockReturnValue(
-				builderState({ currentQuery: editedQuery }),
-			);
-			const { result } = setup({ savedQueries: SAVED_BASELINE });
-
 			expect(result.current.isQueryDirty).toBe(true);
 		});
 
-		it('is not query-dirty when the live query still serializes to the saved queries', () => {
-			mockUseQueryBuilder.mockReturnValue(
-				builderState({ currentQuery: unchangedQuery }),
-			);
-			const { result } = setup({ savedQueries: SAVED_BASELINE });
+		it('is not query-dirty when the live query matches the baseline', () => {
+			mockGetIsQueryModified.mockReturnValue(false);
+			const { result } = setup();
 
 			expect(result.current.isQueryDirty).toBe(false);
 		});
 
 		it('buildSaveSpec bakes the live query in when dirty', () => {
-			mockUseQueryBuilder.mockReturnValue(
-				builderState({ currentQuery: editedQuery }),
-			);
-			const { result } = setup({ savedQueries: SAVED_BASELINE });
+			mockGetIsQueryModified.mockReturnValue(true);
+			const { result } = setup();
 			const { spec } = makeDraft();
 
 			expect(result.current.buildSaveSpec(spec)).toStrictEqual({
 				...spec,
-				queries: EDITED_ENVELOPES,
+				queries: CONVERTED_QUERIES,
 			});
 		});
 
 		it('buildSaveSpec returns the spec untouched when the query is unchanged', () => {
-			mockUseQueryBuilder.mockReturnValue(
-				builderState({ currentQuery: unchangedQuery }),
-			);
-			const { result } = setup({ savedQueries: SAVED_BASELINE });
+			mockGetIsQueryModified.mockReturnValue(false);
+			const { result } = setup();
 			const { spec } = makeDraft();
 
 			expect(result.current.buildSaveSpec(spec)).toBe(spec);
 		});
-
-		it('anchors the baseline to savedQueries, not the draft the builder seeds from (View handoff / refresh)', () => {
-			// The draft carries the View-mode edit (the builder seeds from it), but the
-			// baseline is the persisted panel: a live query equal to the edited draft
-			// still reads dirty against the saved queries.
-			mockUseQueryBuilder.mockReturnValue(
-				builderState({ currentQuery: editedQuery }),
-			);
-			const draft = makeDraft(EDITED_ENVELOPES);
-			const { result } = setup({ draft, savedQueries: SAVED_BASELINE });
-
-			expect(result.current.isQueryDirty).toBe(true);
-		});
-
-		it('falls back to the seed query as the baseline when there are no saved queries (new panel)', () => {
-			mockUseQueryBuilder.mockReturnValue(
-				builderState({ currentQuery: unchangedQuery }),
-			);
-			const { result } = setup();
-
-			expect(result.current.isQueryDirty).toBe(false);
-		});
 	});
 });

frontend/src/pages/DashboardPageV2/DashboardContainer/PanelEditor/hooks/usePanelEditSession.ts

@@ -23,12 +23,6 @@ import { usePanelTypeSwitch } from './usePanelTypeSwitch';
 interface UsePanelEditSessionArgs {
 	panel: DashboardtypesPanelDTO;
 	panelId: string;
-	/**
-	 * The persisted panel the dirty check compares against. Distinct from `panel` (the
-	 * seed), which may carry unsaved edits handed off from View mode. Omit for a new
-	 * panel or the drilldown modal, where the seed is the baseline.
-	 */
-	savedPanel?: DashboardtypesPanelDTO;
 	/** Per-view time window (epoch ms); omit to follow the dashboard's global window. */
 	time?: PanelQueryTimeOverride;
 	/** Serialize the live builder query into the spec on save even if unchanged (new panels). */
@@ -73,15 +67,12 @@ export interface UsePanelEditSessionReturn {
 export function usePanelEditSession({
 	panel,
 	panelId,
-	savedPanel,
 	time,
 	alwaysSerializeQuery = false,
 	seedQuerySignal = false,
 }: UsePanelEditSessionArgs): UsePanelEditSessionReturn {
-	const { draft, spec, setSpec, isSpecDirty, reset } = usePanelEditorDraft(
-		panel,
-		savedPanel,
-	);
+	const { draft, spec, setSpec, isSpecDirty, reset } =
+		usePanelEditorDraft(panel);
 
 	const panelKind = draft.spec.plugin.kind;
 	const panelDefinition = getPanelDefinition(panelKind);
@@ -102,7 +93,6 @@ export function usePanelEditSession({
 		refetch: query.refetch,
 		alwaysSerializeQuery,
 		signal: seedQuerySignal ? defaultSignal : undefined,
-		savedQueries: savedPanel?.spec.queries,
 	});
 
 	const { onChangePanelKind } = usePanelTypeSwitch({

frontend/src/pages/DashboardPageV2/DashboardContainer/PanelEditor/hooks/usePanelEditorDraft.ts

@@ -13,14 +13,9 @@ import type { PanelEditorDraftApi } from '../types';
  * preview renders it through the dashboard's renderer registry and the save hook
  * patches it without conversion. Everything the config pane edits flows through the
  * single `spec`/`setSpec` pair.
- *
- * `savedPanel` is the persisted panel the dirty check compares against — distinct from
- * `initialPanel` (the seed), which may carry unsaved edits handed off from View mode.
- * Defaults to the seed when there's no separate saved baseline (a new panel).
  */
 export function usePanelEditorDraft(
 	initialPanel: DashboardtypesPanelDTO,
-	savedPanel: DashboardtypesPanelDTO = initialPanel,
 ): PanelEditorDraftApi {
 	const [draft, setDraft] = useState<DashboardtypesPanelDTO>(initialPanel);
 
@@ -40,9 +35,9 @@ export function usePanelEditorDraft(
 		() =>
 			!isEqual(
 				{ ...draft, spec: { ...draft.spec, queries: null } },
-				{ ...savedPanel, spec: { ...savedPanel.spec, queries: null } },
+				{ ...initialPanel, spec: { ...initialPanel.spec, queries: null } },
 			),
-		[draft, savedPanel],
+		[draft, initialPanel],
 	);
 
 	return {

frontend/src/pages/DashboardPageV2/DashboardContainer/PanelEditor/hooks/usePanelEditorQuerySync.ts

@@ -1,8 +1,7 @@
-import { useCallback, useEffect, useMemo, useRef } from 'react';
+import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
 import type {
 	DashboardtypesPanelDTO,
 	DashboardtypesPanelSpecDTO,
-	DashboardtypesQueryDTO,
 	TelemetrytypesSignalDTO,
 } from 'api/generated/services/sigNoz.schemas';
 import { initialQueriesMap, PANEL_TYPES } from 'constants/queryBuilder';
@@ -28,12 +27,6 @@ interface UsePanelEditorQuerySyncArgs {
 	alwaysSerializeQuery?: boolean;
 	/** Signal to seed a new panel's builder with — the kind's first supported signal. */
 	signal?: TelemetrytypesSignalDTO;
-	/**
-	 * The persisted panel's queries — the dirty baseline. Distinct from `draft.spec.queries`,
-	 * which the builder seeds from and may carry unsaved edits handed off from View mode. Omit
-	 * for a new panel, where the seed query is the baseline.
-	 */
-	savedQueries?: DashboardtypesQueryDTO[];
 }
 
 interface UsePanelEditorQuerySyncApi {
@@ -60,31 +53,43 @@ export function usePanelEditorQuerySync({
 	refetch,
 	alwaysSerializeQuery = false,
 	signal,
-	savedQueries,
 }: UsePanelEditorQuerySyncArgs): UsePanelEditorQuerySyncApi {
 	const { currentQuery, stagedQuery, handleRunQuery } = useQueryBuilder();
 
-	const draftQueries = draft.spec.queries;
+	// Saved queries, captured once: seed the builder and serve as the restore target.
+	const savedQueries = draft.spec.queries;
 
-	// A new panel has no saved query: seed from the kind's first supported signal rather
-	// than `fromPerses`'s metrics default (which List doesn't support).
+	// A new panel has no saved query: seed from the kind's first supported signal
+	// instead of letting `fromPerses` fall back to the metrics default (which List
+	// doesn't support).
 	const seedQuery = useMemo(
 		() =>
-			draftQueries.length === 0 && signal
+			savedQueries.length === 0 && signal
 				? initialQueriesMap[signal]
-				: fromPerses(draftQueries, panelType),
-		[draftQueries, panelType, signal],
+				: fromPerses(savedQueries, panelType),
+		[savedQueries, panelType, signal],
 	);
-	// No forceReset: seed the builder only when the URL carries no query, so an
-	// in-editor edit in the URL survives a refresh / browser Back-Forward.
-	useShareBuilderUrl({ defaultValue: seedQuery });
+	// Force-reset the builder to the SAVED panel on first render only, discarding a
+	// stale URL query from a prior edit (else the QB/preview diverge and the dirty
+	// baseline is captured from the URL). After mount the URL syncs normally.
+	const isInitialRenderRef = useRef(true);
+	useShareBuilderUrl({
+		defaultValue: seedQuery,
+		forceReset: isInitialRenderRef.current,
+	});
+	useEffect(() => {
+		isInitialRenderRef.current = false;
+	}, []);
 
-	// Commit the live query into the draft (what the preview fetches).
+	// Commit the live query into the draft (what the preview fetches). The dirty
+	// check compares against the SAVED query (`seedQuery`), not the URL-synced
+	// staged query, which can carry stale state across a refresh and read a real
+	// switch as "unchanged". Returns whether the draft changed.
 	const commitQuery = useCallback(
 		(query: Query): boolean => {
 			const next = getIsQueryModified(query, seedQuery)
 				? toPerses(query, panelType)
-				: draftQueries;
+				: savedQueries;
 			// No-op guard at the V5 envelope level: equivalent wrappers (bare
 			// `signoz/BuilderQuery` vs `signoz/CompositeQuery`) unwrap to the same
 			// envelopes, so a structural compare would falsely dirty the draft.
@@ -95,7 +100,7 @@ export function usePanelEditorQuerySync({
 			setSpec({ ...draft.spec, queries: next });
 			return true;
 		},
-		[seedQuery, panelType, draftQueries, draft.spec, setSpec],
+		[seedQuery, panelType, savedQueries, draft.spec, setSpec],
 	);
 
 	// Latest query/commit, read by the structural-change effect without re-subscribing.
@@ -105,7 +110,7 @@ export function usePanelEditorQuerySync({
 	queryRef.current = currentQuery;
 
 	// Re-commit on a query-type/datasource switch so the preview refetches. Skip
-	// mount: the initial query is synced into the draft by the staged-query effect below.
+	// mount: the draft already holds the saved queries the builder is reset to.
 	const dataSources = useMemo(
 		() => (currentQuery.builder?.queryData ?? []).map((q) => q.dataSource),
 		[currentQuery.builder],
@@ -131,15 +136,6 @@ export function usePanelEditorQuerySync({
 		// eslint-disable-next-line react-hooks/exhaustive-deps -- structural change only
 	}, [currentQuery.queryType, dataSourceSignature]);
 
-	// Follow the staged (executed) query into the draft on a URL re-stage (mount
-	// hydration, browser Back/Forward) so the preview matches. Live edits touch only
-	// currentQuery, so they still wait for Run; commitQuery no-ops when unchanged.
-	useEffect(() => {
-		if (stagedQuery) {
-			commitRef.current(stagedQuery);
-		}
-	}, [stagedQuery]);
-
 	// Stage & Run / ⌘↵: stage, commit, and re-fetch when unchanged so it can be re-run.
 	const runQuery = useCallback((): void => {
 		handleRunQuery();
@@ -148,29 +144,20 @@ export function usePanelEditorQuerySync({
 		}
 	}, [handleRunQuery, commitQuery, currentQuery, refetch]);
 
-	// Dirty = the live query no longer serializes to the SAVED panel's query, compared at
-	// the V5 envelope level. Anchoring to `savedQueries` (not the builder-seed) keeps a
-	// handed-off / URL-restored edit reading as dirty; routing both sides through the same
-	// `fromPerses → toPerses` round-trip stops builder-added defaults (absent from an older
-	// stored query) reading an untouched panel as modified. New panel: fall back to seed.
-	const baselineEnvelopes = useMemo(
-		() =>
-			toQueryEnvelopes(
-				toPerses(
-					savedQueries ? fromPerses(savedQueries, panelType) : seedQuery,
-					panelType,
-				),
-			),
-		[savedQueries, seedQuery, panelType],
-	);
-	const isQueryDirty = useMemo(
-		() =>
-			!isEqual(
-				toQueryEnvelopes(toPerses(currentQuery, panelType)),
-				baselineEnvelopes,
-			),
-		[currentQuery, panelType, baselineEnvelopes],
-	);
+	// Dirty baseline: the builder's OWN normalized saved query (first non-null
+	// `stagedQuery` after the mount reset) — comparing builder-normalized to
+	// builder-normalized avoids serialization drift reading an untouched query as
+	// modified. In state (not a ref) so capture re-triggers `isQueryDirty`; captured
+	// once and never moved by Stage & Run, so it stays anchored to saved.
+	const [queryBaseline, setQueryBaseline] = useState<Query | null>(null);
+	useEffect(() => {
+		if (queryBaseline === null && stagedQuery) {
+			setQueryBaseline(stagedQuery);
+		}
+	}, [queryBaseline, stagedQuery]);
+
+	const isQueryDirty =
+		queryBaseline !== null && getIsQueryModified(currentQuery, queryBaseline);
 
 	const buildSaveSpec = useCallback(
 		(spec: DashboardtypesPanelSpecDTO): DashboardtypesPanelSpecDTO =>

frontend/src/pages/DashboardPageV2/DashboardContainer/PanelEditor/index.tsx

@@ -6,7 +6,6 @@ import {
 	useDefaultLayout,
 } from '@signozhq/ui/resizable';
 import { toast } from '@signozhq/ui/sonner';
-import { ConfigProvider } from 'antd';
 import {
 	type DashboardtypesPanelDTO,
 	TelemetrytypesSignalDTO,
@@ -42,22 +41,10 @@ import styles from './PanelEditor.module.scss';
 import logEvent from '@/api/common/logEvent';
 import { DashboardEvents } from '../../constants/events';
 
-// The query builder sits in an `overflow:hidden` resizable pane, so its Select
-// popups (group-by, order-by, having, …) clip when they open into the short pane.
-// Portal them to the document body; the query-builder filters honor this via
-// `useSelectPopupContainer`. Scoped to the full-page editor — the View modal keeps
-// its own `ConfigProvider` so popups stay inside the focus-trapped dialog.
-const getBodyPopupContainer = (): HTMLElement => document.body;
-
 interface PanelEditorContainerProps {
 	dashboardId: string;
 	panelId: string;
 	panel: DashboardtypesPanelDTO;
-	/**
-	 * The persisted panel the dirty check compares against. Distinct from `panel` (the
-	 * seed), which may carry unsaved edits handed off from View mode. Omit for a new panel.
-	 */
-	savedPanel?: DashboardtypesPanelDTO;
 	/** Creating a new panel (seeded default) vs editing an existing one. */
 	isNew?: boolean;
 	/** Target section for a new panel; falls back to the last/new section. */
@@ -81,7 +68,6 @@ function PanelEditorContainer({
 	dashboardId,
 	panelId,
 	panel,
-	savedPanel,
 	isNew = false,
 	layoutIndex,
 	isEditable,
@@ -105,7 +91,6 @@ function PanelEditorContainer({
 	} = usePanelEditSession({
 		panel,
 		panelId,
-		savedPanel,
 		alwaysSerializeQuery: isNew,
 		seedQuerySignal: true,
 	});
@@ -303,24 +288,22 @@ function PanelEditorContainer({
 							</ResizablePanel>
 							<ResizableHandle withHandle className={styles.handle} />
 							<ResizablePanel minSize="35%" maxSize="45%" defaultSize="40%">
-								<ConfigProvider getPopupContainer={getBodyPopupContainer}>
-									<PanelEditorQueryBuilder
-										panelKind={panelKind}
-										signal={listSignal}
-										isLoadingQueries={isFetching}
-										onStageRunQuery={runQuery}
-										onCancelQuery={cancelQuery}
-										footer={
-											isListPanel ? (
-												<ListColumnsEditor
-													spec={spec}
-													onChangeSpec={setSpec}
-													signal={listSignal}
-												/>
-											) : undefined
-										}
-									/>
-								</ConfigProvider>
+								<PanelEditorQueryBuilder
+									panelKind={panelKind}
+									signal={listSignal}
+									isLoadingQueries={isFetching}
+									onStageRunQuery={runQuery}
+									onCancelQuery={cancelQuery}
+									footer={
+										isListPanel ? (
+											<ListColumnsEditor
+												spec={spec}
+												onChangeSpec={setSpec}
+												signal={listSignal}
+											/>
+										) : undefined
+									}
+								/>
 							</ResizablePanel>
 						</ResizablePanelGroup>
 					</div>

frontend/src/pages/DashboardPageV2/DashboardContainer/Panels/types/sections.ts

@@ -1,5 +1,5 @@
 import type {
-	DashboardtypesLinkDTO,
+	DashboardLinkDTO,
 	DashboardtypesAxesDTO,
 	DashboardtypesBarChartVisualizationDTO,
 	DashboardtypesComparisonThresholdDTO,
@@ -89,7 +89,7 @@ export interface SectionSpecMap {
 	// the `controls` bag gates which fields each kind writes.
 	[SectionKind.Visualization]: DashboardtypesBarChartVisualizationDTO;
 	[SectionKind.Thresholds]: AnyThreshold[]; // spec.plugin.spec.thresholds (variant picks the editor)
-	[SectionKind.ContextLinks]: DashboardtypesLinkDTO[]; // spec.links (PANEL-level)
+	[SectionKind.ContextLinks]: DashboardLinkDTO[]; // spec.links (PANEL-level)
 	[SectionKind.Columns]: TelemetrytypesTelemetryFieldKeyDTO[]; // spec.plugin.spec.selectFields (List)
 }
 

frontend/src/pages/DashboardPageV2/DashboardContainer/Panels/types/threshold.ts

@@ -22,22 +22,6 @@ export interface ComparisonThresholdShape {
 	format?: DashboardtypesThresholdFormatDTO;
 }
 
-/** SigNoz threshold palette; single source of truth for the hex values. */
-export enum ThresholdColor {
-	RED = '#F1575F',
-	ORANGE = '#F5B225',
-	GREEN = '#2BB673',
-	BLUE = '#4E74F8',
-}
-
-/** Palette ordered most-dangerous first (preset order + alert-severity ranking). */
-export const THRESHOLD_COLOR_DANGER_ORDER: ThresholdColor[] = [
-	ThresholdColor.RED,
-	ThresholdColor.ORANGE,
-	ThresholdColor.GREEN,
-	ThresholdColor.BLUE,
-];
-
 /** Comparison operators a threshold can use, as evaluable symbols. */
 export type ThresholdComparisonOperator = '>' | '<' | '>=' | '<=' | '=' | '!=';
 

frontend/src/pages/DashboardPageV2/DashboardContainer/Panels/utils/drilldown/resolvePanelContextLinks.ts

@@ -1,4 +1,4 @@
-import type { DashboardtypesLinkDTO } from 'api/generated/services/sigNoz.schemas';
+import type { DashboardLinkDTO } from 'api/generated/services/sigNoz.schemas';
 import { resolveTexts } from 'hooks/dashboard/useContextVariables';
 
 import { resolveContextLinkUrl } from './resolveContextLinkUrl';
@@ -15,7 +15,7 @@ export interface ResolvedDrilldownLink {
  * label + URL, drops links without a URL, and skips substitution when `renderVariables === false`.
  */
 export function resolvePanelContextLinks(
-	links: DashboardtypesLinkDTO[] | undefined,
+	links: DashboardLinkDTO[] | undefined,
 	processedVariables: Record<string, string>,
 ): ResolvedDrilldownLink[] {
 	const usable = (links ?? []).filter((link) => !!link.url);

frontend/src/pages/DashboardPageV2/DashboardContainer/PanelsAndSectionsLayout/Panel/DrilldownMenu/DrilldownAggregateMenu.tsx

@@ -7,7 +7,7 @@ import {
 	Loader,
 	ScrollText,
 } from '@signozhq/icons';
-import type { DashboardtypesLinkDTO } from 'api/generated/services/sigNoz.schemas';
+import type { DashboardLinkDTO } from 'api/generated/services/sigNoz.schemas';
 import { getAggregateColumnHeader } from 'container/QueryTable/Drilldown/drilldownUtils';
 import ContextMenu from 'periscope/components/ContextMenu';
 import type { DrilldownContext } from 'pages/DashboardPageV2/DashboardContainer/Panels/types/drilldown';
@@ -27,7 +27,7 @@ interface DrilldownAggregateMenuProps {
 	/** While dashboard variables resolve, the actions show a spinner and are disabled. */
 	isResolving?: boolean;
 	/** Panel's context links; resolved against the clicked point + variables here. */
-	links: DashboardtypesLinkDTO[] | undefined;
+	links: DashboardLinkDTO[] | undefined;
 	/** Whether the clicked point exposes group-by fields to bind to dashboard variables. */
 	canSetDashboardVariables: boolean;
 	onViewLogs: () => void;

frontend/src/pages/DashboardPageV2/DashboardContainer/PanelsAndSectionsLayout/Panel/PanelStatus/__tests__/utils.test.ts

@@ -1,8 +1,6 @@
-import type {
-	Querybuildertypesv5QueryWarnDataDTO as WarningDTO,
-	RenderErrorResponseDTO,
-} from 'api/generated/services/sigNoz.schemas';
+import type { RenderErrorResponseDTO } from 'api/generated/services/sigNoz.schemas';
 import type { AxiosError } from 'axios';
+import type { Querybuildertypesv5QueryWarnDataDTO as WarningDTO } from 'api/generated/services/sigNoz.schemas';
 import { StatusCodes } from 'http-status-codes';
 
 import { panelStatusFromError, panelStatusFromWarning } from '../utils';
@@ -46,7 +44,7 @@ describe('panelStatusFromError', () => {
 
 	it('falls back to the error message when there is no structured body', () => {
 		expect(panelStatusFromError(new Error('boom'))).toStrictEqual({
-			code: 'UPSTREAM_UNAVAILABLE',
+			code: 'unknown_error',
 			message: 'boom',
 			docsUrl: undefined,
 			messages: [],

frontend/src/pages/DashboardPageV2/DashboardContainer/PanelsAndSectionsLayout/Panel/ViewPanelModal/ViewPanelModalContent.tsx

@@ -104,9 +104,7 @@ function ViewPanelModalContent({
 		logEvent(DashboardEvents.SWITCH_TO_EDIT_MODE, {
 			panelId: panelId,
 		});
-		openPanelEditor(panelId, {
-			handoffState: { editSpec: buildSaveSpec(draft.spec) },
-		});
+		openPanelEditor(panelId, { editSpec: buildSaveSpec(draft.spec) });
 	};
 
 	return (

frontend/src/pages/DashboardPageV2/DashboardContainer/PanelsAndSectionsLayout/Panel/hooks/useDrilldown.tsx

@@ -218,7 +218,7 @@ export function useDrilldown(
 				context={context}
 				query={v1Query}
 				isResolving={isResolving}
-				links={panel.spec.links ?? undefined}
+				links={panel.spec.links}
 				canSetDashboardVariables={dashboardVariables.hasFieldVariables}
 				onViewLogs={(): void => navigate('view_logs')}
 				onViewTraces={(): void => navigate('view_traces')}

frontend/src/pages/DashboardPageV2/DashboardContainer/PanelsAndSectionsLayout/Panel/hooks/useDrilldownDashboardVariables.tsx

@@ -105,8 +105,7 @@ export function useDrilldownDashboardVariables({
 				type: 'DYNAMIC',
 				multiSelect: true,
 				dynamicAttribute: fieldName,
-				// `||` (not `??`): an empty "any" signal maps to All, same as unset.
-				dynamicSignal: signal || DYNAMIC_SIGNAL_ALL,
+				dynamicSignal: signal ?? DYNAMIC_SIGNAL_ALL,
 			};
 			try {
 				await patchAsync(

frontend/src/pages/DashboardPageV2/DashboardContainer/PanelsAndSectionsLayout/Panel/utils/deriveAlertPrefill.ts

@@ -5,13 +5,11 @@ import type {
 	DashboardtypesPanelDTO,
 	DashboardtypesPanelPluginDTO,
 } from 'api/generated/services/sigNoz.schemas';
-import { normalizeOperator } from 'container/CreateAlertV2/context/conditionNormalizers';
 import {
 	AlertThresholdMatchType,
 	AlertThresholdOperator,
 	Threshold,
 } from 'container/CreateAlertV2/context/types';
-import { THRESHOLD_COLOR_DANGER_ORDER } from 'pages/DashboardPageV2/DashboardContainer/Panels/types/threshold';
 import type { MetricAggregation } from 'types/api/v5/queryRange';
 import type { Query } from 'types/api/queryBuilder/queryBuilderData';
 import { ReduceOperators } from 'types/common/queryBuilder';
@@ -23,6 +21,14 @@ export interface PanelAlertPrefill {
 	threshold?: Threshold;
 }
 
+// Most-dangerous first, matching the panel editor palette; unknown colors sort last.
+const THRESHOLD_COLOR_DANGER_ORDER = [
+	'#f1575f',
+	'#f5b225',
+	'#2bb673',
+	'#4e74f8',
+];
+
 interface NormalizedPanelThreshold {
 	color: string;
 	value: number;
@@ -87,12 +93,8 @@ function readPanelThresholds(
 	}
 }
 
-// Match case-insensitively (picker emits lowercase hex); unknown colors sort last.
 function colorRank(color: string): number {
-	const target = color.toLowerCase();
-	const index = THRESHOLD_COLOR_DANGER_ORDER.findIndex(
-		(paletteColor) => paletteColor.toLowerCase() === target,
-	);
+	const index = THRESHOLD_COLOR_DANGER_ORDER.indexOf(color.toLowerCase());
 	return index === -1 ? THRESHOLD_COLOR_DANGER_ORDER.length : index;
 }
 
@@ -104,17 +106,22 @@ function pickHighestDanger(
 	)[0];
 }
 
-// The alert UI has no inclusive operator; collapse "or equal" onto its strict variant.
 function panelOperatorToAlertOperator(
 	operator: DashboardtypesComparisonOperatorDTO | undefined,
 ): AlertThresholdOperator | undefined {
 	switch (operator) {
+		case 'above':
 		case 'above_or_equal':
-			return normalizeOperator('above');
+			return AlertThresholdOperator.IS_ABOVE;
+		case 'below':
 		case 'below_or_equal':
-			return normalizeOperator('below');
+			return AlertThresholdOperator.IS_BELOW;
+		case 'equal':
+			return AlertThresholdOperator.IS_EQUAL_TO;
+		case 'not_equal':
+			return AlertThresholdOperator.IS_NOT_EQUAL_TO;
 		default:
-			return normalizeOperator(operator);
+			return undefined;
 	}
 }
 

frontend/src/pages/DashboardPageV2/DashboardContainer/components/DashboardPageHeader/DashboardPageHeader.tsx

@@ -2,7 +2,6 @@ import { memo } from 'react';
 import HeaderRightSection from 'components/HeaderRightSection/HeaderRightSection';
 
 import DashboardPageBreadcrumbs from './DashboardPageBreadcrumbs';
-import { useShareVariablesOption } from './useShareVariablesOption';
 
 import styles from './DashboardPageHeader.module.scss';
 
@@ -15,16 +14,10 @@ function DashboardPageHeader({
 	title,
 	image,
 }: DashboardPageHeaderProps): JSX.Element {
-	const shareVariablesOption = useShareVariablesOption();
 	return (
 		<div className={styles.dashboardPageHeader}>
 			<DashboardPageBreadcrumbs title={title} image={image} />
-			<HeaderRightSection
-				enableAnnouncements={false}
-				enableShare
-				enableFeedback
-				shareModalExtraOption={shareVariablesOption}
-			/>
+			<HeaderRightSection enableAnnouncements={false} enableShare enableFeedback />
 		</div>
 	);
 }

frontend/src/pages/DashboardPageV2/DashboardContainer/components/DashboardPageHeader/useShareVariablesOption.ts

@@ -1,41 +0,0 @@
-import { useMemo } from 'react';
-import type { ShareURLExtraOption } from 'components/HeaderRightSection/ShareURLModal';
-
-import type { SelectedVariableValue } from '../../VariablesBar/selectionTypes';
-import {
-	ALL_SELECTED,
-	variablesUrlParser,
-} from '../../VariablesBar/utils/variablesUrlState';
-import { selectVariableValues } from '../../store/slices/variableSelectionSlice';
-import { useDashboardStore } from '../../store/useDashboardStore';
-
-/**
- * The share-dialog "Include variables" option: serializes the current variable
- * selection into the `?variables=` param (ALL encoded as the sentinel) so a shared
- * link reproduces it for the recipient — who hydrates it into local storage on load,
- * after which the param is cleared (see useSeedVariableSelection). Returns undefined
- * when there is nothing selected to share.
- */
-export function useShareVariablesOption(): ShareURLExtraOption | undefined {
-	const dashboardId = useDashboardStore((s) => s.dashboardId);
-	const selections = useDashboardStore(selectVariableValues(dashboardId ?? ''));
-
-	return useMemo(() => {
-		const names = Object.keys(selections);
-		if (names.length === 0) {
-			return undefined;
-		}
-		const urlShape: Record<string, SelectedVariableValue> = {};
-		names.forEach((name) => {
-			const selection = selections[name];
-			urlShape[name] = selection.allSelected ? ALL_SELECTED : selection.value;
-		});
-		const serialized = variablesUrlParser.serialize(urlShape);
-		return {
-			label: 'Include variables',
-			apply: (params): void => {
-				params.set('variables', serialized);
-			},
-		};
-	}, [selections]);
-}

frontend/src/pages/DashboardPageV2/DashboardContainer/hooks/__tests__/useCreatePanel.test.tsx

@@ -1,65 +0,0 @@
-import { act, renderHook } from '@testing-library/react';
-import { NANO_SECOND_MULTIPLIER } from 'store/globalTime';
-
-import { useCreatePanel } from '../useCreatePanel';
-
-const mockSafeNavigate = jest.fn();
-jest.mock('hooks/useSafeNavigate', () => ({
-	useSafeNavigate: (): { safeNavigate: jest.Mock } => ({
-		safeNavigate: mockSafeNavigate,
-	}),
-}));
-
-let mockGlobalTime = {
-	selectedTime: '30m',
-	minTime: 0,
-	maxTime: 0,
-};
-jest.mock('react-redux', () => ({
-	useSelector: (selector: (state: unknown) => unknown): unknown =>
-		selector({ globalTime: mockGlobalTime }),
-}));
-
-jest.mock('../../store/useDashboardStore', () => ({
-	useDashboardStore: (selector: (state: unknown) => unknown): unknown =>
-		selector({ dashboardId: 'dash-1' }),
-}));
-
-describe('useCreatePanel', () => {
-	beforeEach(() => {
-		jest.clearAllMocks();
-		mockGlobalTime = { selectedTime: '30m', minTime: 0, maxTime: 0 };
-	});
-
-	it('carries the relative time window onto the new-panel route', () => {
-		mockGlobalTime = { selectedTime: '6h', minTime: 0, maxTime: 0 };
-		const { result } = renderHook(() => useCreatePanel());
-		act(() => {
-			result.current.createPanel('timeSeries' as never, 2);
-		});
-
-		const [url] = mockSafeNavigate.mock.calls[0];
-		expect(url).toContain('/dashboard/dash-1/panel/new');
-		expect(url).toContain('panelKind=timeSeries');
-		expect(url).toContain('layoutIndex=2');
-		expect(url).toContain('relativeTime=6h');
-	});
-
-	it('carries a custom absolute window and never a stray relativeTime', () => {
-		mockGlobalTime = {
-			selectedTime: 'custom',
-			minTime: 1000 * NANO_SECOND_MULTIPLIER,
-			maxTime: 2000 * NANO_SECOND_MULTIPLIER,
-		};
-		const { result } = renderHook(() => useCreatePanel());
-		act(() => {
-			result.current.createPanel('timeSeries' as never, 2);
-		});
-
-		const [url] = mockSafeNavigate.mock.calls[0];
-		expect(url).toContain('startTime=1000');
-		expect(url).toContain('endTime=2000');
-		expect(url).not.toContain('relativeTime');
-		expect(url).not.toContain('&&');
-	});
-});

frontend/src/pages/DashboardPageV2/DashboardContainer/hooks/__tests__/useOpenPanelEditor.test.tsx

@@ -1,95 +0,0 @@
-import { renderHook } from '@testing-library/react';
-import { NANO_SECOND_MULTIPLIER } from 'store/globalTime';
-
-import { useOpenPanelEditor } from '../useOpenPanelEditor';
-
-const mockSafeNavigate = jest.fn();
-jest.mock('hooks/useSafeNavigate', () => ({
-	useSafeNavigate: (): { safeNavigate: jest.Mock } => ({
-		safeNavigate: mockSafeNavigate,
-	}),
-}));
-
-let mockGlobalTime = {
-	selectedTime: '30m',
-	minTime: 0,
-	maxTime: 0,
-};
-jest.mock('react-redux', () => ({
-	useSelector: (selector: (state: unknown) => unknown): unknown =>
-		selector({ globalTime: mockGlobalTime }),
-}));
-
-jest.mock('../../store/useDashboardStore', () => ({
-	useDashboardStore: (selector: (state: unknown) => unknown): unknown =>
-		selector({ dashboardId: 'dash-1' }),
-}));
-
-describe('useOpenPanelEditor', () => {
-	beforeEach(() => {
-		jest.clearAllMocks();
-		mockGlobalTime = { selectedTime: '30m', minTime: 0, maxTime: 0 };
-	});
-
-	it('carries the relative time window into the editor route', () => {
-		mockGlobalTime = { selectedTime: '6h', minTime: 0, maxTime: 0 };
-		const { result } = renderHook(() => useOpenPanelEditor());
-		result.current('panel-9');
-
-		expect(mockSafeNavigate).toHaveBeenCalledWith(
-			'/dashboard/dash-1/panel/panel-9?relativeTime=6h',
-			undefined,
-		);
-	});
-
-	it('carries a custom absolute window as a start/end ms pair', () => {
-		mockGlobalTime = {
-			selectedTime: 'custom',
-			minTime: 1000 * NANO_SECOND_MULTIPLIER,
-			maxTime: 2000 * NANO_SECOND_MULTIPLIER,
-		};
-		const { result } = renderHook(() => useOpenPanelEditor());
-		result.current('panel-9');
-
-		const [url] = mockSafeNavigate.mock.calls[0];
-		expect(url).toContain('startTime=1000');
-		expect(url).toContain('endTime=2000');
-		// A custom range must not also carry relativeTime (it would win on the editor).
-		expect(url).not.toContain('relativeTime');
-	});
-
-	it('omits the query string for an uninitialized custom window', () => {
-		mockGlobalTime = { selectedTime: 'custom', minTime: 0, maxTime: 0 };
-		const { result } = renderHook(() => useOpenPanelEditor());
-		result.current('panel-9');
-
-		expect(mockSafeNavigate).toHaveBeenCalledWith(
-			'/dashboard/dash-1/panel/panel-9',
-			undefined,
-		);
-	});
-
-	it('forwards handoff state as router location state', () => {
-		mockGlobalTime = { selectedTime: '1h', minTime: 0, maxTime: 0 };
-		const { result } = renderHook(() => useOpenPanelEditor());
-		const handoffState = { editSpec: { title: 'x' } } as never;
-		result.current('panel-9', { handoffState });
-
-		expect(mockSafeNavigate).toHaveBeenCalledWith(
-			'/dashboard/dash-1/panel/panel-9?relativeTime=1h',
-			{ state: handoffState },
-		);
-	});
-
-	it('merges search with the time window (leading ? tolerated)', () => {
-		mockGlobalTime = { selectedTime: '6h', minTime: 0, maxTime: 0 };
-		const { result } = renderHook(() => useOpenPanelEditor());
-		result.current('new', { search: '?panelKind=timeSeries&layoutIndex=2' });
-
-		const [url] = mockSafeNavigate.mock.calls[0];
-		expect(url).toContain('/dashboard/dash-1/panel/new?');
-		expect(url).toContain('panelKind=timeSeries');
-		expect(url).toContain('layoutIndex=2');
-		expect(url).toContain('relativeTime=6h');
-	});
-});

frontend/src/pages/DashboardPageV2/DashboardContainer/hooks/__tests__/useTimeSearchParams.test.ts

@@ -1,43 +0,0 @@
-import { renderHook } from '@testing-library/react';
-import { NANO_SECOND_MULTIPLIER } from 'store/globalTime';
-
-import { useTimeSearchParams } from '../useTimeSearchParams';
-
-let mockGlobalTime = {
-	selectedTime: '30m',
-	minTime: 0,
-	maxTime: 0,
-};
-jest.mock('react-redux', () => ({
-	useSelector: (selector: (state: unknown) => unknown): unknown =>
-		selector({ globalTime: mockGlobalTime }),
-}));
-
-describe('useTimeSearchParams', () => {
-	it('returns a relativeTime query string for a relative selection', () => {
-		mockGlobalTime = { selectedTime: '6h', minTime: 0, maxTime: 0 };
-		const { result } = renderHook(() => useTimeSearchParams());
-
-		expect(result.current).toBe('relativeTime=6h');
-	});
-
-	it('returns an absolute ms pair for a custom selection', () => {
-		mockGlobalTime = {
-			selectedTime: 'custom',
-			minTime: 1000 * NANO_SECOND_MULTIPLIER,
-			maxTime: 2000 * NANO_SECOND_MULTIPLIER,
-		};
-		const { result } = renderHook(() => useTimeSearchParams());
-
-		expect(result.current).toContain('startTime=1000');
-		expect(result.current).toContain('endTime=2000');
-		expect(result.current).not.toContain('relativeTime');
-	});
-
-	it('returns an empty string for an uninitialized custom window', () => {
-		mockGlobalTime = { selectedTime: 'custom', minTime: 0, maxTime: 0 };
-		const { result } = renderHook(() => useTimeSearchParams());
-
-		expect(result.current).toBe('');
-	});
-});

frontend/src/pages/DashboardPageV2/DashboardContainer/hooks/useCreatePanel.ts

@@ -1,8 +1,11 @@
 import { useCallback, useState } from 'react';
+import { generatePath } from 'react-router-dom';
+import ROUTES from 'constants/routes';
+import { useSafeNavigate } from 'hooks/useSafeNavigate';
 
 import { newPanelSearch, NEW_PANEL_ID } from '../PanelEditor/newPanelRoute';
 import type { PanelKind } from '../Panels/types/panelKind';
-import { useOpenPanelEditor } from './useOpenPanelEditor';
+import { useDashboardStore } from '../store/useDashboardStore';
 
 interface UseCreatePanelResult {
 	isPickerOpen: boolean;
@@ -21,7 +24,8 @@ interface UseCreatePanelResult {
  * until save.
  */
 export function useCreatePanel(): UseCreatePanelResult {
-	const openPanelEditor = useOpenPanelEditor();
+	const { safeNavigate } = useSafeNavigate();
+	const dashboardId = useDashboardStore((s) => s.dashboardId);
 
 	const [isPickerOpen, setIsPickerOpen] = useState(false);
 	// Captured on open, consumed on select.
@@ -39,12 +43,15 @@ export function useCreatePanel(): UseCreatePanelResult {
 	const createPanel = useCallback(
 		(panelKind: PanelKind, targetIndex?: number): void => {
 			setIsPickerOpen(false);
-			const target = targetIndex ?? layoutIndex;
-			openPanelEditor(NEW_PANEL_ID, {
-				search: newPanelSearch(panelKind, target),
+			const path = generatePath(ROUTES.DASHBOARD_PANEL_EDITOR, {
+				dashboardId,
+				panelId: NEW_PANEL_ID,
 			});
+			const target = targetIndex ?? layoutIndex;
+			// Variable selection is read from the persisted store, not the URL.
+			safeNavigate(`${path}${newPanelSearch(panelKind, target)}`);
 		},
-		[openPanelEditor, layoutIndex],
+		[safeNavigate, dashboardId, layoutIndex],
 	);
 
 	return {

frontend/src/pages/DashboardPageV2/DashboardContainer/hooks/useOpenPanelEditor.ts

@@ -5,39 +5,30 @@ import { useSafeNavigate } from 'hooks/useSafeNavigate';
 
 import type { PanelEditorHandoffState } from '../PanelEditor/panelEditorHandoff';
 import { useDashboardStore } from '../store/useDashboardStore';
-import { useTimeSearchParams } from './useTimeSearchParams';
 
-interface OpenPanelEditorOptions {
-	handoffState?: PanelEditorHandoffState;
-	/** Extra query merged into the editor URL (leading `?` optional). */
-	search?: string;
-}
-
-/** Opens the V2 panel editor, carrying the active time window in the URL. */
+/**
+ * Returns a callback that opens the V2 panel editor by navigating to its full-page route
+ * (`/dashboard/:dashboardId/panel/:panelId`). The dashboard id comes from the store, so any
+ * caller can open the editor with just the panel id. Variable selection is read from the
+ * persisted store (localStorage), not carried in the URL. The optional `handoffState` is
+ * passed as router location state — the View modal uses it to hand its drilldown-edited spec
+ * off to the editor (view → edit) so the editor opens on those edits rather than the saved
+ * panel.
+ */
 export function useOpenPanelEditor(): (
 	panelId: string,
-	options?: OpenPanelEditorOptions,
+	handoffState?: PanelEditorHandoffState,
 ) => void {
 	const { safeNavigate } = useSafeNavigate();
-	const timeSearch = useTimeSearchParams();
 	const dashboardId = useDashboardStore((s) => s.dashboardId);
 
 	return useCallback(
-		(panelId: string, options?: OpenPanelEditorOptions): void => {
-			const path = generatePath(ROUTES.DASHBOARD_PANEL_EDITOR, {
-				dashboardId,
-				panelId,
-			});
-			const params = new URLSearchParams(options?.search);
-			new URLSearchParams(timeSearch).forEach((value, key) => {
-				params.set(key, value);
-			});
-			const search = params.toString();
+		(panelId: string, handoffState?: PanelEditorHandoffState): void => {
 			safeNavigate(
-				search ? `${path}?${search}` : path,
-				options?.handoffState ? { state: options.handoffState } : undefined,
+				generatePath(ROUTES.DASHBOARD_PANEL_EDITOR, { dashboardId, panelId }),
+				handoffState ? { state: handoffState } : undefined,
 			);
 		},
-		[safeNavigate, dashboardId, timeSearch],
+		[safeNavigate, dashboardId],
 	);
 }

frontend/src/pages/DashboardPageV2/DashboardContainer/hooks/useTimeSearchParams.ts

@@ -1,20 +0,0 @@
-import { useMemo } from 'react';
-// eslint-disable-next-line no-restricted-imports -- global time still lives in redux
-import { useSelector } from 'react-redux';
-import { AppState } from 'store/reducers';
-import type { GlobalReducer } from 'types/reducer/globalTime';
-
-import { timeParamsFromGlobalTime } from '../utils/timeUrlParams';
-
-/** Active time window as a query string (no leading `?`), or `''` when unset. */
-export function useTimeSearchParams(): string {
-	const { selectedTime, minTime, maxTime } = useSelector<
-		AppState,
-		GlobalReducer
-	>((state) => state.globalTime);
-
-	return useMemo(
-		() => timeParamsFromGlobalTime({ selectedTime, minTime, maxTime }).toString(),
-		[selectedTime, minTime, maxTime],
-	);
-}

frontend/src/pages/DashboardPageV2/DashboardContainer/utils/__tests__/timeUrlParams.test.ts

@@ -1,51 +0,0 @@
-import { NANO_SECOND_MULTIPLIER } from 'store/globalTime';
-
-import { timeParamsFromGlobalTime } from '../timeUrlParams';
-
-describe('timeParamsFromGlobalTime', () => {
-	it('emits relativeTime for a relative selection', () => {
-		const params = timeParamsFromGlobalTime({
-			selectedTime: '6h',
-			minTime: 0,
-			maxTime: 0,
-		});
-
-		expect(params.get('relativeTime')).toBe('6h');
-		// Mutually exclusive: no absolute pair alongside a relative range.
-		expect(params.has('startTime')).toBe(false);
-		expect(params.has('endTime')).toBe(false);
-	});
-
-	it('emits an absolute ms pair for a custom selection (converting from ns)', () => {
-		const params = timeParamsFromGlobalTime({
-			selectedTime: 'custom',
-			minTime: 1000 * NANO_SECOND_MULTIPLIER,
-			maxTime: 2000 * NANO_SECOND_MULTIPLIER,
-		});
-
-		expect(params.get('startTime')).toBe('1000');
-		expect(params.get('endTime')).toBe('2000');
-		// A custom range must not carry a relativeTime that would win on the editor.
-		expect(params.has('relativeTime')).toBe(false);
-	});
-
-	it('carries a custom shorthand relative selection verbatim', () => {
-		const params = timeParamsFromGlobalTime({
-			selectedTime: '13m',
-			minTime: 0,
-			maxTime: 0,
-		});
-
-		expect(params.get('relativeTime')).toBe('13m');
-	});
-
-	it('emits nothing for an uninitialized custom window', () => {
-		const params = timeParamsFromGlobalTime({
-			selectedTime: 'custom',
-			minTime: 0,
-			maxTime: 0,
-		});
-
-		expect(params.toString()).toBe('');
-	});
-});

frontend/src/pages/DashboardPageV2/DashboardContainer/utils/timeUrlParams.ts

@@ -1,39 +0,0 @@
-import { QueryParams } from 'constants/query';
-import { NANO_SECOND_MULTIPLIER } from 'store/globalTime';
-import type { GlobalReducer } from 'types/reducer/globalTime';
-
-type GlobalTimeSelection = Pick<
-	GlobalReducer,
-	'selectedTime' | 'minTime' | 'maxTime'
->;
-
-/**
- * Time-window URL params for the active selection. Derived from Redux (what the picker and
- * panel queries read), not the URL: the legacy react-router and newer nuqs time writers fall
- * out of sync, leaving a stale `relativeTime` that `DateTimeSelectionV2` prefers over an
- * absolute range. Redux keeps them mutually exclusive (custom → start/end ms; else relativeTime).
- */
-export function timeParamsFromGlobalTime({
-	selectedTime,
-	minTime,
-	maxTime,
-}: GlobalTimeSelection): URLSearchParams {
-	const params = new URLSearchParams();
-
-	if (selectedTime === 'custom') {
-		if (minTime > 0 && maxTime > 0) {
-			params.set(
-				QueryParams.startTime,
-				String(Math.floor(minTime / NANO_SECOND_MULTIPLIER)),
-			);
-			params.set(
-				QueryParams.endTime,
-				String(Math.floor(maxTime / NANO_SECOND_MULTIPLIER)),
-			);
-		}
-	} else {
-		params.set(QueryParams.relativeTime, selectedTime);
-	}
-
-	return params;
-}

frontend/src/pages/DashboardPageV2/PanelEditorPage/PanelEditorPage.tsx

@@ -21,7 +21,6 @@ import {
 	parseNewPanelLayoutIndex,
 } from '../DashboardContainer/PanelEditor/newPanelRoute';
 import { useSyncVariablesForSuggestions } from '../DashboardContainer/hooks/useSyncVariablesForSuggestions';
-import { useTimeSearchParams } from '../DashboardContainer/hooks/useTimeSearchParams';
 import { createDefaultPanel } from '../DashboardContainer/patchOps';
 import { useDashboardStore } from '../DashboardContainer/store/useDashboardStore';
 import { useSeedVariableSelection } from '../DashboardContainer/VariablesBar/hooks/useSeedVariableSelection';
@@ -39,7 +38,6 @@ function PanelEditorPage(): JSX.Element {
 	}>();
 	const { search, state } = useLocation();
 	const { safeNavigate } = useSafeNavigate();
-	const timeSearch = useTimeSearchParams();
 
 	// Edits handed off from the View modal's drilldown — open the editor on these
 	// instead of the saved panel. Lost on refresh/new-tab, which falls back to saved.
@@ -107,11 +105,10 @@ function PanelEditorPage(): JSX.Element {
 	const layoutIndex = parseNewPanelLayoutIndex(search);
 
 	const backToDashboard = useCallback((): void => {
-		// Drop editor-only URL state (variables come from the persisted store), but carry
-		// time so a custom range picked in the editor isn't reset to the dashboard default.
-		const path = generatePath(ROUTES.DASHBOARD, { dashboardId });
-		safeNavigate(timeSearch ? `${path}?${timeSearch}` : path);
-	}, [safeNavigate, dashboardId, timeSearch]);
+		// Drop editor-only URL state (chiefly `compositeQuery`); the dashboard reads its
+		// variable selection from the persisted store, and time lives in Redux.
+		safeNavigate(generatePath(ROUTES.DASHBOARD, { dashboardId }));
+	}, [safeNavigate, dashboardId]);
 
 	if (isLoading) {
 		return <Spinner tip="Loading dashboard..." />;
@@ -140,7 +137,6 @@ function PanelEditorPage(): JSX.Element {
 			dashboardId={dashboardId}
 			panelId={panelId}
 			panel={panel}
-			savedPanel={existingPanel}
 			isNew={!!newKind}
 			layoutIndex={layoutIndex}
 			isEditable={isEditable}

frontend/src/utils/errorUtils.ts

@@ -42,12 +42,7 @@ export function toAPIError(
 	try {
 		ErrorResponseHandlerForGeneratedAPIs(error);
 	} catch (apiError) {
-		// UPSTREAM_UNAVAILABLE means the handler couldn't find a backend error code
-		// (non-envelope body); prefer the caller's context-specific defaultMessage.
-		if (
-			apiError instanceof APIError &&
-			apiError.getErrorCode() !== 'UPSTREAM_UNAVAILABLE'
-		) {
+		if (apiError instanceof APIError) {
 			return apiError;
 		}
 	}

frontend/src/utils/permission/index.ts

@@ -136,8 +136,8 @@ export const routePermission: Record<keyof typeof ROUTES, ROLES[]> = {
 	AI_ASSISTANT_ICON_PREVIEW: ['ADMIN', 'EDITOR', 'VIEWER'],
 	MCP_SERVER: ['ADMIN', 'EDITOR', 'VIEWER'],
 	AI_ASSISTANT_BASE: ['ADMIN', 'EDITOR', 'VIEWER'],
-	AI_OBSERVABILITY_ATTRIBUTE_MAPPING: ['ADMIN', 'EDITOR', 'VIEWER'],
-	AI_OBSERVABILITY_BASE: ['ADMIN', 'EDITOR', 'VIEWER'],
-	AI_OBSERVABILITY_OVERVIEW: ['ADMIN', 'EDITOR', 'VIEWER'],
-	AI_OBSERVABILITY_CONFIGURATION: ['ADMIN', 'EDITOR', 'VIEWER'],
+	LLM_OBSERVABILITY_ATTRIBUTE_MAPPING: ['ADMIN', 'EDITOR', 'VIEWER'],
+	LLM_OBSERVABILITY_BASE: ['ADMIN', 'EDITOR', 'VIEWER'],
+	LLM_OBSERVABILITY_OVERVIEW: ['ADMIN', 'EDITOR', 'VIEWER'],
+	LLM_OBSERVABILITY_CONFIGURATION: ['ADMIN', 'EDITOR', 'VIEWER'],
 };

frontend/src/utils/selectPopupContainer.ts

@@ -1,20 +1,5 @@
-import { ConfigProvider, SelectProps } from 'antd';
-// eslint-disable-next-line no-restricted-imports
-import { useContext } from 'react';
+import { SelectProps } from 'antd';
 
 export const popupContainer: SelectProps['getPopupContainer'] = (
 	trigger,
 ): HTMLElement => trigger.parentNode;
-
-/**
- * Popup container for query-builder Selects. Prefers a container supplied by an
- * ancestor antd `ConfigProvider` (set by hosts that render the builder inside a
- * clipped/portaled surface — e.g. the panel editor's `overflow:hidden` resizable
- * pane, or the View modal's focus-trapped dialog) and otherwise falls back to
- * `trigger.parentNode`, the app-wide default. No `ConfigProvider` container is set
- * app-wide, so surfaces that don't opt in keep the legacy behavior unchanged.
- */
-export function useSelectPopupContainer(): SelectProps['getPopupContainer'] {
-	const { getPopupContainer } = useContext(ConfigProvider.ConfigContext);
-	return getPopupContainer ?? popupContainer;
-}

pkg/flagger/flaggertest/flaggertest.go

@@ -27,6 +27,24 @@ func New(t *testing.T) flagger.Flagger {
 	return fl
 }
 
+// WithBooleans returns a Flagger with the given boolean flags overriding the
+// registry defaults.
+func WithBooleans(t *testing.T, flags map[string]bool) flagger.Flagger {
+	t.Helper()
+	registry := flagger.MustNewRegistry()
+	cfg := flagger.Config{}
+	cfg.Config.Boolean = flags
+	fl, err := flagger.New(
+		context.Background(),
+		instrumentationtest.New().ToProviderSettings(),
+		cfg,
+		registry,
+		configflagger.NewFactory(registry),
+	)
+	require.NoError(t, err)
+	return fl
+}
+
 // WithUseJSONBody returns a Flagger with use_json_body set to the given value.
 func WithUseJSONBody(t *testing.T, enabled bool) flagger.Flagger {
 	t.Helper()

pkg/flagger/registry.go

@@ -15,6 +15,7 @@ var (
 	FeatureEnableAIObservability  = featuretypes.MustNewName("enable_ai_observability")
 	FeatureEnableMetricsReduction = featuretypes.MustNewName("enable_metrics_reduction")
 	FeatureUseInfraMonitoringV2   = featuretypes.MustNewName("use_infra_monitoring_v2")
+	FeatureUseCounterEpochs       = featuretypes.MustNewName("use_counter_epochs")
 )
 
 func MustNewRegistry() featuretypes.Registry {
@@ -115,6 +116,14 @@ func MustNewRegistry() featuretypes.Registry {
 			DefaultVariant: featuretypes.MustNewName("disabled"),
 			Variants:       featuretypes.NewBooleanVariants(),
 		},
+		&featuretypes.Feature{
+			Name:           FeatureUseCounterEpochs,
+			Kind:           featuretypes.KindBoolean,
+			Stage:          featuretypes.StageExperimental,
+			Description:    "Controls whether cumulative rate/increase use the reset-exact start_ts epoch pipeline (requires collector schema migration 1012)",
+			DefaultVariant: featuretypes.MustNewName("disabled"),
+			Variants:       featuretypes.NewBooleanVariants(),
+		},
 	)
 	if err != nil {
 		panic(err)

pkg/global/config.go

@@ -12,15 +12,13 @@ import (
 
 var (
 	ErrCodeInvalidGlobalConfig = errors.MustNewCode("invalid_global_config")
-	ErrCodeOriginNotAllowed    = errors.MustNewCode("origin_not_allowed")
 )
 
 type Config struct {
-	ExternalURL    *url.URL   `mapstructure:"external_url"`
-	AllowedOrigins []*url.URL `mapstructure:"allowed_origins"`
-	IngestionURL   *url.URL   `mapstructure:"ingestion_url"`
-	MCPURL         *url.URL   `mapstructure:"mcp_url"`
-	AIAssistantURL *url.URL   `mapstructure:"ai_assistant_url"`
+	ExternalURL    *url.URL `mapstructure:"external_url"`
+	IngestionURL   *url.URL `mapstructure:"ingestion_url"`
+	MCPURL         *url.URL `mapstructure:"mcp_url"`
+	AIAssistantURL *url.URL `mapstructure:"ai_assistant_url"`
 }
 
 func NewConfigFactory() factory.ConfigFactory {
@@ -51,33 +49,9 @@ func (c Config) Validate() error {
 		}
 	}
 
-	for _, origin := range c.AllowedOrigins {
-		if origin == nil || origin.Scheme == "" || origin.Host == "" {
-			return errors.NewInvalidInputf(ErrCodeInvalidGlobalConfig, "global::allowed_origins entries must be of the form scheme://host[:port], got %q", origin)
-		}
-
-		if origin.Path != "" && origin.Path != "/" {
-			return errors.NewInvalidInputf(ErrCodeInvalidGlobalConfig, "global::allowed_origins entries must not contain a path, got %q", origin)
-		}
-	}
-
 	return nil
 }
 
-func (c Config) IsOriginAllowed(u *url.URL) bool {
-	if len(c.AllowedOrigins) == 0 {
-		return true
-	}
-
-	for _, origin := range c.AllowedOrigins {
-		if strings.EqualFold(origin.Scheme, u.Scheme) && strings.EqualFold(origin.Host, u.Host) {
-			return true
-		}
-	}
-
-	return false
-}
-
 func (c Config) ExternalPath() string {
 	if c.ExternalURL == nil || c.ExternalURL.Path == "" || c.ExternalURL.Path == "/" {
 		return ""

pkg/global/config_test.go

@@ -123,26 +123,6 @@ func TestValidate(t *testing.T) {
 			config: Config{ExternalURL: &url.URL{Path: "signoz"}},
 			fail:   true,
 		},
-		{
-			name:   "ValidAllowedOrigin",
-			config: Config{AllowedOrigins: []*url.URL{{Scheme: "https", Host: "signoz.example.com"}}},
-			fail:   false,
-		},
-		{
-			name:   "AllowedOriginWithoutScheme",
-			config: Config{AllowedOrigins: []*url.URL{{Host: "signoz.example.com"}}},
-			fail:   true,
-		},
-		{
-			name:   "AllowedOriginWithoutHost",
-			config: Config{AllowedOrigins: []*url.URL{{Scheme: "https"}}},
-			fail:   true,
-		},
-		{
-			name:   "AllowedOriginWithPath",
-			config: Config{AllowedOrigins: []*url.URL{{Scheme: "https", Host: "signoz.example.com", Path: "/login"}}},
-			fail:   true,
-		},
 	}
 
 	for _, tc := range testCases {
@@ -157,96 +137,3 @@ func TestValidate(t *testing.T) {
 		})
 	}
 }
-
-func TestIsOriginAllowedWhenUnconfigured(t *testing.T) {
-	testCases := []struct {
-		name   string
-		config Config
-	}{
-		{
-			name:   "Empty",
-			config: Config{},
-		},
-		{
-			name:   "ExternalURLDoesNotActivateValidation",
-			config: Config{ExternalURL: &url.URL{Scheme: "https", Host: "signoz.example.com"}},
-		},
-	}
-
-	for _, tc := range testCases {
-		t.Run(tc.name, func(t *testing.T) {
-			u, err := url.Parse("https://anything.example.com/login")
-			assert.NoError(t, err)
-			assert.True(t, tc.config.IsOriginAllowed(u))
-		})
-	}
-}
-
-func TestIsOriginAllowed(t *testing.T) {
-	config := Config{
-		AllowedOrigins: []*url.URL{
-			{Scheme: "https", Host: "signoz.example.com"},
-			{Scheme: "http", Host: "localhost:3301"},
-		},
-	}
-
-	testCases := []struct {
-		name     string
-		input    string
-		expected bool
-	}{
-		{
-			name:     "ConfiguredOrigin",
-			input:    "https://signoz.example.com/login",
-			expected: true,
-		},
-		{
-			name:     "ConfiguredOriginWithQuery",
-			input:    "http://localhost:3301/login?next=/dashboards",
-			expected: true,
-		},
-		{
-			name:     "CaseInsensitiveHost",
-			input:    "https://SigNoz.Example.Com/login",
-			expected: true,
-		},
-		{
-			name:     "UnknownHost",
-			input:    "https://attacker.example.com/login",
-			expected: false,
-		},
-		{
-			name:     "SchemeMismatch",
-			input:    "http://signoz.example.com/login",
-			expected: false,
-		},
-		{
-			name:     "PortMismatch",
-			input:    "https://signoz.example.com:8443/login",
-			expected: false,
-		},
-		{
-			name:     "SuffixConfusion",
-			input:    "https://evilsignoz.example.com/login",
-			expected: false,
-		},
-		{
-			name:     "UserInfoConfusion",
-			input:    "https://signoz.example.com@attacker.example.com/login",
-			expected: false,
-		},
-		{
-			name:     "SchemeRelative",
-			input:    "//attacker.example.com/login",
-			expected: false,
-		},
-	}
-
-	for _, tc := range testCases {
-		t.Run(tc.name, func(t *testing.T) {
-			u, err := url.Parse(tc.input)
-			assert.NoError(t, err)
-			assert.Equal(t, tc.expected, config.IsOriginAllowed(u))
-		})
-	}
-}

pkg/modules/rawdataexport/implrawdataexport/handler.go

@@ -6,7 +6,6 @@ import (
 	"fmt"
 	"io"
 	"net/http"
-	"reflect"
 	"slices"
 	"strconv"
 	"time"
@@ -286,13 +285,6 @@ func constructCSVRecordFromQueryResponse(data map[string]any, headerToIndexMappi
 	for key, value := range data {
 		if index, exists := headerToIndexMapping[key]; exists && value != nil {
 
-			if rv := reflect.ValueOf(value); rv.Kind() == reflect.Pointer {
-				if rv.IsNil() {
-					continue
-				}
-				value = rv.Elem().Interface()
-			}
-
 			var valueStr string
 			switch v := value.(type) {
 			case string:

pkg/modules/rulestatehistory/implrulestatehistory/condition_builder.go

@@ -21,15 +21,13 @@ func newConditionBuilder(fm qbtypes.FieldMapper) qbtypes.ConditionBuilder {
 	return &conditionBuilder{fm: fm}
 }
 
-// Rule state history has no resource sub-query, so options are unused.
 func (c *conditionBuilder) ConditionFor(
 	ctx context.Context,
 	orgID valuer.UUID,
 	startNs uint64,
 	endNs uint64,
 	key *telemetrytypes.TelemetryFieldKey,
-	fieldKeys map[string][]*telemetrytypes.TelemetryFieldKey,
-	_ qbtypes.ConditionBuilderOptions,
+	fieldKeysForName []*telemetrytypes.TelemetryFieldKey,
 	operator qbtypes.FilterOperator,
 	value any,
 	sb *sqlbuilder.SelectBuilder,
@@ -40,7 +38,7 @@ func (c *conditionBuilder) ConditionFor(
 		return nil, nil, err
 	}
 
-	keys, warning := querybuilder.ResolveKeys(key, querybuilder.MatchingFieldKeys(key, fieldKeys))
+	keys, warning := querybuilder.ResolveKeys(key, fieldKeysForName)
 	var warnings []string
 	if warning != "" {
 		warnings = append(warnings, warning)

pkg/modules/rulestatehistory/implrulestatehistory/field_mapper.go

@@ -64,7 +64,7 @@ func (m *fieldMapper) ColumnFor(ctx context.Context, _ valuer.UUID, _, _ uint64,
 	return []*schema.Column{col}, nil
 }
 
-func (m *fieldMapper) ColumnExpressionFor(ctx context.Context, orgID valuer.UUID, tsStart, tsEnd uint64, field *telemetrytypes.TelemetryFieldKey, _ telemetrytypes.FieldDataType, _ map[string][]*telemetrytypes.TelemetryFieldKey) (string, error) {
+func (m *fieldMapper) ColumnExpressionFor(ctx context.Context, orgID valuer.UUID, tsStart, tsEnd uint64, field *telemetrytypes.TelemetryFieldKey, _ map[string][]*telemetrytypes.TelemetryFieldKey) (string, error) {
 	colName, err := m.FieldFor(ctx, orgID, tsStart, tsEnd, field)
 	if err != nil {
 		return "", err

pkg/modules/session/implsession/module.go

@@ -12,7 +12,6 @@ import (
 	"github.com/SigNoz/signoz/pkg/authz"
 	"github.com/SigNoz/signoz/pkg/errors"
 	"github.com/SigNoz/signoz/pkg/factory"
-	"github.com/SigNoz/signoz/pkg/global"
 	"github.com/SigNoz/signoz/pkg/modules/authdomain"
 	"github.com/SigNoz/signoz/pkg/modules/organization"
 	"github.com/SigNoz/signoz/pkg/modules/session"
@@ -24,28 +23,26 @@ import (
 )
 
 type module struct {
-	settings     factory.ScopedProviderSettings
-	authNs       map[authtypes.AuthNProvider]authn.AuthN
-	userSetter   user.Setter
-	userGetter   user.Getter
-	authDomain   authdomain.Module
-	tokenizer    tokenizer.Tokenizer
-	orgGetter    organization.Getter
-	authz        authz.AuthZ
-	globalConfig global.Config
+	settings   factory.ScopedProviderSettings
+	authNs     map[authtypes.AuthNProvider]authn.AuthN
+	userSetter user.Setter
+	userGetter user.Getter
+	authDomain authdomain.Module
+	tokenizer  tokenizer.Tokenizer
+	orgGetter  organization.Getter
+	authz      authz.AuthZ
 }
 
-func NewModule(providerSettings factory.ProviderSettings, authNs map[authtypes.AuthNProvider]authn.AuthN, userSetter user.Setter, userGetter user.Getter, authDomain authdomain.Module, tokenizer tokenizer.Tokenizer, orgGetter organization.Getter, authz authz.AuthZ, globalConfig global.Config) session.Module {
+func NewModule(providerSettings factory.ProviderSettings, authNs map[authtypes.AuthNProvider]authn.AuthN, userSetter user.Setter, userGetter user.Getter, authDomain authdomain.Module, tokenizer tokenizer.Tokenizer, orgGetter organization.Getter, authz authz.AuthZ) session.Module {
 	return &module{
-		settings:     factory.NewScopedProviderSettings(providerSettings, "github.com/SigNoz/signoz/pkg/modules/session/implsession"),
-		authNs:       authNs,
-		userSetter:   userSetter,
-		userGetter:   userGetter,
-		authDomain:   authDomain,
-		tokenizer:    tokenizer,
-		orgGetter:    orgGetter,
-		authz:        authz,
-		globalConfig: globalConfig,
+		settings:   factory.NewScopedProviderSettings(providerSettings, "github.com/SigNoz/signoz/pkg/modules/session/implsession"),
+		authNs:     authNs,
+		userSetter: userSetter,
+		userGetter: userGetter,
+		authDomain: authDomain,
+		tokenizer:  tokenizer,
+		orgGetter:  orgGetter,
+		authz:      authz,
 	}
 }
 
@@ -143,10 +140,6 @@ func (module *module) CreateCallbackAuthNSession(ctx context.Context, authNProvi
 		return "", err
 	}
 
-	if callbackIdentity.State.URL.Host != "" && !module.globalConfig.IsOriginAllowed(callbackIdentity.State.URL) {
-		return "", errors.Newf(errors.TypeForbidden, global.ErrCodeOriginNotAllowed, "state redirect %q is not an allowed origin", callbackIdentity.State.URL.String())
-	}
-
 	authDomain, err := module.authDomain.GetByOrgIDAndID(ctx, callbackIdentity.OrgID, callbackIdentity.State.DomainID)
 	if err != nil {
 		return "", err
@@ -224,10 +217,6 @@ func (module *module) getOrgSessionContext(ctx context.Context, org *types.Organ
 		return nil, err
 	}
 
-	if !module.globalConfig.IsOriginAllowed(siteURL) {
-		return nil, errors.Newf(errors.TypeInvalidInput, global.ErrCodeOriginNotAllowed, "ref %q is not an allowed origin", siteURL.String())
-	}
-
 	loginURL, err := provider.LoginURL(ctx, siteURL, authDomain)
 	if err != nil {
 		return nil, err

pkg/prometheus/clickhouseprometheus/capture.go

@@ -56,21 +56,19 @@ func (c *captureClient) Read(ctx context.Context, query *prompb.Query, _ bool) (
 		}
 	}
 
-	// Without executing the series lookup, only an exact-name selector's
-	// metric name is known.
-	var metricNames []string
+	var metricName string
 	for _, matcher := range query.Matchers {
-		if matcher.Name == "__name__" && matcher.Type == prompb.LabelMatcher_EQ {
-			metricNames = []string{matcher.Value}
+		if matcher.Name == "__name__" {
+			metricName = matcher.Value
 		}
 	}
 
 	// Build the executing path's queries, but only record them.
-	sub, err := seriesLookupQuery(query, true)
+	subQuery, args, err := c.queryToClickhouseQuery(ctx, query, metricName, true)
 	if err != nil {
 		return nil, err
 	}
-	samplesQuery, samplesArgs := buildSamplesQuery(int64(query.StartTimestampMs), int64(query.EndTimestampMs), metricNames, sub)
+	samplesQuery, samplesArgs := buildSamplesQuery(int64(query.StartTimestampMs), int64(query.EndTimestampMs), metricName, subQuery, args)
 	c.recorder.record(samplesQuery, samplesArgs)
 
 	return storage.EmptySeriesSet(), nil

pkg/prometheus/clickhouseprometheus/client.go

@@ -4,7 +4,8 @@ import (
 	"context"
 	"fmt"
 	"math"
-	"sort"
+	"strconv"
+	"strings"
 	"sync"
 
 	"github.com/SigNoz/signoz/pkg/errors"
@@ -13,8 +14,6 @@ import (
 	"github.com/SigNoz/signoz/pkg/types/ctxtypes"
 	"github.com/SigNoz/signoz/pkg/types/instrumentationtypes"
 	"github.com/SigNoz/signoz/pkg/types/telemetrytypes"
-	"github.com/cespare/xxhash/v2"
-	"github.com/huandu/go-sqlbuilder"
 	promValue "github.com/prometheus/prometheus/model/value"
 	"github.com/prometheus/prometheus/prompb"
 	"github.com/prometheus/prometheus/storage"
@@ -56,13 +55,19 @@ func (client *client) Read(ctx context.Context, query *prompb.Query, sortSeries
 		}
 	}
 
-	lookup, err := seriesLookupQuery(query, false)
+	var metricName string
+	for _, matcher := range query.Matchers {
+		if matcher.Name == "__name__" {
+			metricName = matcher.Value
+		}
+	}
+
+	clickhouseQuery, args, err := client.queryToClickhouseQuery(ctx, query, metricName, false)
 	if err != nil {
 		return nil, err
 	}
-	lookupSQL, lookupArgs := lookup.BuildWithFlavor(sqlbuilder.ClickHouse)
 
-	fingerprints, metricNames, err := client.getFingerprintsFromClickhouseQuery(ctx, lookupSQL, lookupArgs)
+	fingerprints, err := client.getFingerprintsFromClickhouseQuery(ctx, clickhouseQuery, args)
 	if err != nil {
 		return nil, err
 	}
@@ -70,14 +75,13 @@ func (client *client) Read(ctx context.Context, query *prompb.Query, sortSeries
 		return remote.FromQueryResult(sortSeries, new(prompb.QueryResult)), nil
 	}
 
-	sub, err := seriesLookupQuery(query, true)
+	clickhouseSubQuery, args, err := client.queryToClickhouseQuery(ctx, query, metricName, true)
 	if err != nil {
 		return nil, err
 	}
-	samplesSQL, samplesArgs := buildSamplesQuery(int64(query.StartTimestampMs), int64(query.EndTimestampMs), metricNames, sub)
 
 	res := new(prompb.QueryResult)
-	timeseries, err := client.querySamples(ctx, samplesSQL, samplesArgs, fingerprints)
+	timeseries, err := client.querySamples(ctx, int64(query.StartTimestampMs), int64(query.EndTimestampMs), fingerprints, metricName, clickhouseSubQuery, args)
 	if err != nil {
 		return nil, err
 	}
@@ -121,147 +125,103 @@ func (c *client) ReadMultiple(ctx context.Context, queries []*prompb.Query, sort
 	return storage.NewMergeSeriesSet(sets, 0, storage.ChainedSeriesMerge), nil
 }
 
-// anchorRegex makes a pattern fully anchored, the way Prometheus compiles
-// matcher regexes; ClickHouse's match() would otherwise substring-match.
-func anchorRegex(pattern string) string {
-	return "^(?:" + pattern + ")$"
-}
-
-// seriesLookupQuery builds the time-series lookup. It returns a builder so
-// the samples query can embed it as a subquery with the args merged in
-// render order by the builder instead of hand-numbered placeholders.
-func seriesLookupQuery(query *prompb.Query, subQuery bool) (*sqlbuilder.SelectBuilder, error) {
-	sb := sqlbuilder.NewSelectBuilder()
+func (client *client) queryToClickhouseQuery(_ context.Context, query *prompb.Query, metricName string, subQuery bool) (string, []any, error) {
+	var clickHouseQuery string
+	var conditions []string
+	var argCount = 0
+	var selectString = "fingerprint, any(labels)"
 	if subQuery {
-		sb.Select("fingerprint")
-	} else {
-		sb.Select("fingerprint", "any(labels)")
+		argCount = 1
+		selectString = "fingerprint"
 	}
 
 	start, end, tableName := getStartAndEndAndTableName(query.StartTimestampMs, query.EndTimestampMs)
-	sb.From(databaseName + "." + tableName)
 
-	sb.Where("temporality IN ['Cumulative', 'Unspecified']")
-	// Inclusive upper bound: registration rows are hour-floored by the
-	// exporter, so a series first registered in the hour starting exactly at
-	// `end` would otherwise be invisible while its samples (<= end) are in
-	// range.
-	sb.Where(fmt.Sprintf("unix_milli >= %d AND unix_milli <= %d", start, end))
+	var args []any
+	conditions = append(conditions, fmt.Sprintf("metric_name = $%d", argCount+1))
+	conditions = append(conditions, "temporality IN ['Cumulative', 'Unspecified']")
+	conditions = append(conditions, fmt.Sprintf("unix_milli >= %d AND unix_milli < %d", start, end))
 
+	args = append(args, metricName)
 	for _, m := range query.Matchers {
-		if m.Name == "__name__" {
-			// __name__ maps onto the metric_name column per matcher type;
-			// reducing regex/negated/absent name matchers to one equality
-			// made such selectors silently return empty.
-			switch m.Type {
-			case prompb.LabelMatcher_EQ:
-				sb.Where(sb.E("metric_name", m.Value))
-			case prompb.LabelMatcher_NEQ:
-				sb.Where(sb.NE("metric_name", m.Value))
-			case prompb.LabelMatcher_RE:
-				sb.Where(fmt.Sprintf("match(metric_name, %s)", sb.Var(anchorRegex(m.Value))))
-			case prompb.LabelMatcher_NRE:
-				sb.Where(fmt.Sprintf("not match(metric_name, %s)", sb.Var(anchorRegex(m.Value))))
-			default:
-				return nil, errors.NewInvalidInputf(errors.CodeInvalidInput, "unsupported or invalid matcher type: %s", m.Type.String())
-			}
-			continue
-		}
 		switch m.Type {
 		case prompb.LabelMatcher_EQ:
-			sb.Where(fmt.Sprintf("JSONExtractString(labels, %s) = %s", sb.Var(m.Name), sb.Var(m.Value)))
+			conditions = append(conditions, fmt.Sprintf("JSONExtractString(labels, $%d) = $%d", argCount+2, argCount+3))
 		case prompb.LabelMatcher_NEQ:
-			sb.Where(fmt.Sprintf("JSONExtractString(labels, %s) != %s", sb.Var(m.Name), sb.Var(m.Value)))
+			conditions = append(conditions, fmt.Sprintf("JSONExtractString(labels, $%d) != $%d", argCount+2, argCount+3))
 		case prompb.LabelMatcher_RE:
-			sb.Where(fmt.Sprintf("match(JSONExtractString(labels, %s), %s)", sb.Var(m.Name), sb.Var(anchorRegex(m.Value))))
+			conditions = append(conditions, fmt.Sprintf("match(JSONExtractString(labels, $%d), $%d)", argCount+2, argCount+3))
 		case prompb.LabelMatcher_NRE:
-			sb.Where(fmt.Sprintf("not match(JSONExtractString(labels, %s), %s)", sb.Var(m.Name), sb.Var(anchorRegex(m.Value))))
+			conditions = append(conditions, fmt.Sprintf("not match(JSONExtractString(labels, $%d), $%d)", argCount+2, argCount+3))
 		default:
-			return nil, errors.NewInvalidInputf(errors.CodeInvalidInput, "unsupported or invalid matcher type: %s", m.Type.String())
+			return "", nil, errors.NewInvalidInputf(errors.CodeInvalidInput, "unsupported or invalid matcher type: %s", m.Type.String())
 		}
+		args = append(args, m.Name, m.Value)
+		argCount += 2
 	}
 
-	sb.GroupBy("fingerprint")
-	return sb, nil
+	whereClause := strings.Join(conditions, " AND ")
+
+	clickHouseQuery = fmt.Sprintf(`SELECT %s FROM %s.%s WHERE %s GROUP BY fingerprint`, selectString, databaseName, tableName, whereClause)
+
+	return clickHouseQuery, args, nil
 }
 
-func (client *client) getFingerprintsFromClickhouseQuery(ctx context.Context, query string, args []any) (map[uint64][]prompb.Label, []string, error) {
+func (client *client) getFingerprintsFromClickhouseQuery(ctx context.Context, query string, args []any) (map[uint64][]prompb.Label, error) {
 	ctx = client.withClickhousePrometheusContext(ctx, "getFingerprintsFromClickhouseQuery")
 	rows, err := client.telemetryStore.ClickhouseDB().Query(ctx, query, args...)
 	if err != nil {
-		return nil, nil, err
+		return nil, err
 	}
 	defer rows.Close()
 
 	fingerprints := make(map[uint64][]prompb.Label)
-	nameSet := make(map[string]struct{})
 
 	var fingerprint uint64
 	var labelString string
 	for rows.Next() {
 		if err = rows.Scan(&fingerprint, &labelString); err != nil {
-			return nil, nil, err
+			return nil, err
 		}
 
-		labels, metricName, err := unmarshalLabels(labelString)
+		labels, _, err := unmarshalLabels(labelString, fingerprint)
 		if err != nil {
-			return nil, nil, err
+			return nil, err
 		}
 
 		fingerprints[fingerprint] = labels
-		if metricName != "" {
-			nameSet[metricName] = struct{}{}
-		}
 	}
 
 	if err := rows.Err(); err != nil {
-		return nil, nil, err
+		return nil, err
 	}
 
-	metricNames := make([]string, 0, len(nameSet))
-	for name := range nameSet {
-		metricNames = append(metricNames, name)
-	}
-	sort.Strings(metricNames)
-
-	return fingerprints, metricNames, nil
+	return fingerprints, nil
 }
 
-// buildSamplesQuery renders the samples SQL for the series selected by
-// subQuery. The metric_name condition exists only for primary-key pruning;
-// the fingerprint filter already selects the right rows.
-//
-// Time bounds are inclusive on both ends because that is Prometheus's
-// storage contract: Select(mint, maxt) returns [start, end] and the engine
-// itself trims each evaluation window to left-open (T-window, T], so the
-// sample at exactly `end` belongs to the last point. This deliberately
-// differs from the query builder's `unix_milli < end`, which is correct for
-// its own model — toStartOfInterval buckets covering [t, t+step), where a
-// sample at `end` falls in an unrendered bucket and end-exclusive ranges
-// tile exactly across cached time slices.
-func buildSamplesQuery(start int64, end int64, metricNames []string, sub *sqlbuilder.SelectBuilder) (string, []any) {
-	sb := sqlbuilder.NewSelectBuilder()
-	sb.Select("metric_name", "fingerprint", "unix_milli", "value", "flags")
-	sb.From(databaseName + "." + distributedSamplesV4)
+// buildSamplesQuery renders the samples SQL (and args) that fetches data
+// points for the series selected by subQuery.
+func buildSamplesQuery(start int64, end int64, metricName string, subQuery string, args []any) (string, []any) {
+	argCount := len(args)
 
-	if len(metricNames) > 0 {
-		names := make([]any, len(metricNames))
-		for i, name := range metricNames {
-			names[i] = name
-		}
-		sb.Where(sb.In("metric_name", names...))
-	}
-	sb.Where(fmt.Sprintf("fingerprint GLOBAL IN (%s)", sb.Var(sub)))
-	sb.Where(sb.GTE("unix_milli", start), sb.LTE("unix_milli", end))
-	sb.OrderBy("fingerprint", "unix_milli")
+	query := fmt.Sprintf(`
+		SELECT metric_name, fingerprint, unix_milli, value, flags
+			FROM %s.%s
+			WHERE metric_name = $1 AND fingerprint GLOBAL IN (%s) AND unix_milli >= $%s AND unix_milli <= $%s ORDER BY fingerprint, unix_milli;`,
+		databaseName, distributedSamplesV4, subQuery, strconv.Itoa(argCount+2), strconv.Itoa(argCount+3))
+	query = strings.TrimSpace(query)
 
-	return sb.BuildWithFlavor(sqlbuilder.ClickHouse)
+	allArgs := append([]any{metricName}, args...)
+	allArgs = append(allArgs, start, end)
+	return query, allArgs
 }
 
-func (client *client) querySamples(ctx context.Context, query string, args []any, fingerprints map[uint64][]prompb.Label) ([]*prompb.TimeSeries, error) {
+func (client *client) querySamples(ctx context.Context, start int64, end int64, fingerprints map[uint64][]prompb.Label, metricName string, subQuery string, args []any) ([]*prompb.TimeSeries, error) {
 	ctx = client.withClickhousePrometheusContext(ctx, "querySamples")
 
-	rows, err := client.telemetryStore.ClickhouseDB().Query(ctx, query, args...)
+	query, allArgs := buildSamplesQuery(start, end, metricName, subQuery, args)
+
+	rows, err := client.telemetryStore.ClickhouseDB().Query(ctx, query, allArgs...)
 	if err != nil {
 		return nil, err
 	}
@@ -269,7 +229,6 @@ func (client *client) querySamples(ctx context.Context, query string, args []any
 
 	var res []*prompb.TimeSeries
 	var ts *prompb.TimeSeries
-	var metricName string
 	var fingerprint, prevFingerprint uint64
 	var timestampMs, prevTimestamp int64
 	var value float64
@@ -322,138 +281,7 @@ func (client *client) querySamples(ctx context.Context, query string, args []any
 		return nil, err
 	}
 
-	return mergeSeriesWithIdenticalLabels(res), nil
-}
-
-// mergeSeriesWithIdenticalLabels collapses series sharing one labelset into
-// one series each. Distinct fingerprints can map to one labelset: a label
-// value goes empty over a series' lifetime (#8563), the fingerprint
-// algorithm changes across exporter versions, or the env changes. The
-// engine treats the labelset as series identity — duplicates raise
-// "duplicate series", and #8563's workaround of injecting a synthetic
-// fingerprint label silently broke without() and vector matching. Merging
-// at the last point before hand-off keeps any future input-side label
-// normalization collision-safe. Grouping is by an order-insensitive 64-bit
-// hash so the common no-collision case costs one hash and one map insert
-// per series; hash-equal groups are confirmed by exact labelset equality
-// before any merge. Regression:
-// TestClient_QuerySamplesMergesIdenticalLabelSets and
-// tests/integration/tests/promqlconformance/02_fingerprint_probe.py.
-func mergeSeriesWithIdenticalLabels(series []*prompb.TimeSeries) []*prompb.TimeSeries {
-	if len(series) < 2 {
-		return series
-	}
-
-	groups := make(map[uint64][]*prompb.TimeSeries, len(series))
-	order := make([]uint64, 0, len(series))
-	for _, ts := range series {
-		key := labelsHash(ts.Labels)
-		if _, ok := groups[key]; !ok {
-			order = append(order, key)
-		}
-		groups[key] = append(groups[key], ts)
-	}
-	if len(order) == len(series) {
-		return series
-	}
-
-	res := make([]*prompb.TimeSeries, 0, len(order))
-	for _, key := range order {
-		group := groups[key]
-		if len(group) == 1 {
-			res = append(res, group[0])
-			continue
-		}
-		for _, sub := range splitByLabelSet(group) {
-			if len(sub) == 1 {
-				res = append(res, sub[0])
-				continue
-			}
-			res = append(res, mergeSamples(sub))
-		}
-	}
-	return res
-}
-
-var labelHashSep = []byte{0xff}
-
-// labelsHash combines per-label hashes commutatively, so the stored JSON's
-// key order (not canonical across fingerprints) needs no sort.
-func labelsHash(lbls []prompb.Label) uint64 {
-	var h uint64
-	var d xxhash.Digest
-	for _, l := range lbls {
-		d.Reset()
-		_, _ = d.WriteString(l.Name)
-		_, _ = d.Write(labelHashSep)
-		_, _ = d.WriteString(l.Value)
-		h += d.Sum64()
-	}
-	return h
-}
-
-// splitByLabelSet partitions a hash-equal group into sub-groups of exactly
-// equal labelsets, preserving input order; series that merely collide on the
-// 64-bit hash must not be merged.
-func splitByLabelSet(group []*prompb.TimeSeries) [][]*prompb.TimeSeries {
-	var out [][]*prompb.TimeSeries
-outer:
-	for _, ts := range group {
-		for i, sub := range out {
-			if labelSetsEqual(sub[0].Labels, ts.Labels) {
-				out[i] = append(out[i], ts)
-				continue outer
-			}
-		}
-		out = append(out, []*prompb.TimeSeries{ts})
-	}
-	return out
-}
-
-func labelSetsEqual(a, b []prompb.Label) bool {
-	if len(a) != len(b) {
-		return false
-	}
-	for _, la := range a {
-		found := false
-		for _, lb := range b {
-			if la.Name == lb.Name {
-				found = la.Value == lb.Value
-				break
-			}
-		}
-		if !found {
-			return false
-		}
-	}
-	return true
-}
-
-// mergeSamples k-way merges sample streams that share one labelset. On
-// equal timestamps the highest fingerprint wins: the input is in ascending
-// fingerprint order (samples SQL), keeping the choice deterministic.
-func mergeSamples(group []*prompb.TimeSeries) *prompb.TimeSeries {
-	merged := &prompb.TimeSeries{Labels: group[0].Labels}
-	idx := make([]int, len(group))
-	for {
-		minTs := int64(math.MaxInt64)
-		for i, ts := range group {
-			if idx[i] < len(ts.Samples) && ts.Samples[idx[i]].Timestamp < minTs {
-				minTs = ts.Samples[idx[i]].Timestamp
-			}
-		}
-		if minTs == math.MaxInt64 {
-			return merged
-		}
-		var chosen prompb.Sample
-		for i, ts := range group {
-			if idx[i] < len(ts.Samples) && ts.Samples[idx[i]].Timestamp == minTs {
-				chosen = ts.Samples[idx[i]]
-				idx[i]++
-			}
-		}
-		merged.Samples = append(merged.Samples, chosen)
-	}
+	return res, nil
 }
 
 func (client *client) queryRaw(ctx context.Context, query string, ts int64) (*prompb.QueryResult, error) {

pkg/prometheus/clickhouseprometheus/client_query_test.go

@@ -11,7 +11,6 @@ import (
 
 	"github.com/DATA-DOG/go-sqlmock"
 	"github.com/SigNoz/signoz/pkg/telemetrystore"
-	"github.com/huandu/go-sqlbuilder"
 	"github.com/prometheus/prometheus/prompb"
 	"github.com/stretchr/testify/assert"
 )
@@ -30,7 +29,7 @@ func TestClient_QuerySamples(t *testing.T) {
 		start              int64
 		end                int64
 		fingerprints       map[uint64][]prompb.Label
-		metricNames        []string
+		metricName         string
 		subQuery           string
 		args               []any
 		setupMock          func(mock cmock.ClickConnMockCommon, args ...any)
@@ -53,7 +52,7 @@ func TestClient_QuerySamples(t *testing.T) {
 					{Name: "instance", Value: "localhost:9091"},
 				},
 			},
-			metricNames:        []string{"cpu_usage"},
+			metricName:         "cpu_usage",
 			subQuery:           "SELECT metric_name, fingerprint, unix_milli, value, flags",
 			expectedTimeSeries: 2,
 			expectError:        false,
@@ -98,10 +97,10 @@ func TestClient_QuerySamples(t *testing.T) {
 			telemetryStore := telemetrystoretest.New(telemetrystore.Config{Provider: "clickhouse"}, sqlmock.QueryMatcherRegexp)
 			readClient := client{telemetryStore: telemetryStore}
 			if tt.setupMock != nil {
-				tt.setupMock(telemetryStore.Mock(), "cpu_usage", tt.start, tt.end)
+				tt.setupMock(telemetryStore.Mock(), tt.metricName, tt.start, tt.end)
 
 			}
-			result, err := readClient.querySamples(ctx, tt.subQuery, []any{"cpu_usage", tt.start, tt.end}, tt.fingerprints)
+			result, err := readClient.querySamples(ctx, tt.start, tt.end, tt.fingerprints, tt.metricName, tt.subQuery, tt.args)
 
 			if tt.expectError {
 				assert.Error(t, err)
@@ -116,68 +115,6 @@ func TestClient_QuerySamples(t *testing.T) {
 	}
 }
 
-// Regression for the duplicate-series class behind #8563: fingerprints
-// sharing one labelset must come back as one merged series, the higher
-// fingerprint winning equal timestamps.
-func TestClient_QuerySamplesMergesIdenticalLabelSets(t *testing.T) {
-	ctx := context.Background()
-	cols := []cmock.ColumnType{
-		{Name: "metric_name", Type: "String"},
-		{Name: "fingerprint", Type: "UInt64"},
-		{Name: "unix_milli", Type: "Int64"},
-		{Name: "value", Type: "Float64"},
-		{Name: "flags", Type: "UInt32"},
-	}
-
-	canary := []prompb.Label{
-		{Name: "__name__", Value: "requests"},
-		{Name: "group", Value: "canary"},
-	}
-	production := []prompb.Label{
-		{Name: "__name__", Value: "requests"},
-		{Name: "group", Value: "production"},
-	}
-	fingerprints := map[uint64][]prompb.Label{
-		100: canary,
-		200: canary,
-		300: production,
-	}
-
-	telemetryStore := telemetrystoretest.New(telemetrystore.Config{Provider: "clickhouse"}, sqlmock.QueryMatcherRegexp)
-	// Rows arrive ordered by (fingerprint, unix_milli), matching the SQL.
-	values := [][]any{
-		{"requests", uint64(100), int64(1000), float64(1.0), uint32(0)},
-		{"requests", uint64(100), int64(2000), float64(2.0), uint32(0)},
-		{"requests", uint64(200), int64(2000), float64(20.0), uint32(0)},
-		{"requests", uint64(200), int64(3000), float64(30.0), uint32(0)},
-		{"requests", uint64(300), int64(1500), float64(5.0), uint32(0)},
-	}
-	telemetryStore.Mock().ExpectQuery("SELECT metric_name, fingerprint, unix_milli, value, flags").
-		WithArgs("requests", int64(1000), int64(3000)).
-		WillReturnRows(cmock.NewRows(cols, values))
-
-	readClient := client{telemetryStore: telemetryStore}
-	result, err := readClient.querySamples(ctx, "SELECT metric_name, fingerprint, unix_milli, value, flags", []any{"requests", int64(1000), int64(3000)}, fingerprints)
-	require.NoError(t, err)
-
-	assert.Equal(t, []*prompb.TimeSeries{
-		{
-			Labels: canary,
-			Samples: []prompb.Sample{
-				{Timestamp: 1000, Value: 1.0},
-				{Timestamp: 2000, Value: 20.0},
-				{Timestamp: 3000, Value: 30.0},
-			},
-		},
-		{
-			Labels: production,
-			Samples: []prompb.Sample{
-				{Timestamp: 1500, Value: 5.0},
-			},
-		},
-	}, result)
-}
-
 func TestClient_getFingerprintsFromClickhouseQuery(t *testing.T) {
 	cols := []cmock.ColumnType{
 		{Name: "fingerprint", Type: "UInt64"},
@@ -201,7 +138,6 @@ func TestClient_getFingerprintsFromClickhouseQuery(t *testing.T) {
 		args       []any
 		setupMock  func(m cmock.ClickConnMockCommon, args ...any)
 		want       map[uint64][]prompb.Label
-		wantNames  []string
 		wantErr    bool
 	}{
 		{
@@ -215,30 +151,26 @@ func TestClient_getFingerprintsFromClickhouseQuery(t *testing.T) {
 
 			setupMock: func(m cmock.ClickConnMockCommon, args ...any) {
 				rows := [][]any{
-					{uint64(123), `{"__name__":"cpu_usage","t1":"s1","t2":"s2"}`},
-					{uint64(234), `{"__name__":"cpu_usage","t1":"s1","t2":"s2","empty":""}`},
+					{uint64(123), `{"t1":"s1","t2":"s2"}`},
+					{uint64(234), `{"t1":"s1","t2":"s2"}`},
 				}
 				m.ExpectQuery(`SELECT fingerprint,labels`).WithArgs(args...).WillReturnRows(
 					cmock.NewRows(cols, rows),
 				)
 			},
 
-			// No synthetic fingerprint label (#8563), empty-valued labels
-			// dropped: both fingerprints present one labelset for
-			// querySamples to merge.
 			want: map[uint64][]prompb.Label{
 				123: {
-					{Name: "__name__", Value: "cpu_usage"},
+					{Name: "fingerprint", Value: "123"},
 					{Name: "t1", Value: "s1"},
 					{Name: "t2", Value: "s2"},
 				},
 				234: {
-					{Name: "__name__", Value: "cpu_usage"},
+					{Name: "fingerprint", Value: "234"},
 					{Name: "t1", Value: "s1"},
 					{Name: "t2", Value: "s2"},
 				},
 			},
-			wantNames: []string{"cpu_usage"},
 		},
 	}
 
@@ -256,14 +188,13 @@ func TestClient_getFingerprintsFromClickhouseQuery(t *testing.T) {
 
 			c := client{telemetryStore: store}
 
-			got, gotNames, err := c.getFingerprintsFromClickhouseQuery(ctx, tc.subQuery, tc.args)
+			got, err := c.getFingerprintsFromClickhouseQuery(ctx, tc.subQuery, tc.args)
 			if tc.wantErr {
 				require.Error(t, err)
 				require.Nil(t, got)
 				return
 			}
 			require.NoError(t, err)
-			assert.Equal(t, tc.wantNames, gotNames, "discovered metric names mismatch")
 			require.Equal(t, len(tc.want), len(got), "fingerprint map length mismatch")
 			for fp, expLabels := range tc.want {
 				gotLabels, ok := got[fp]
@@ -277,106 +208,3 @@ func TestClient_getFingerprintsFromClickhouseQuery(t *testing.T) {
 		})
 	}
 }
-
-// Regression for nameless/regex-name selectors silently returning empty:
-// the old code reduced every __name__ matcher to `metric_name = <value>`
-// (empty string when absent). Regexes must come out anchored — Prometheus
-// matcher semantics, while ClickHouse match() substring-matches.
-func TestQueryToClickhouseQueryNameMatchers(t *testing.T) {
-	query := func(matchers ...*prompb.LabelMatcher) *prompb.Query {
-		return &prompb.Query{StartTimestampMs: 0, EndTimestampMs: 1000, Matchers: matchers}
-	}
-
-	tests := []struct {
-		name     string
-		query    *prompb.Query
-		contains []string
-		absent   []string
-		args     []any
-	}{
-		{
-			name:     "exact name",
-			query:    query(&prompb.LabelMatcher{Type: prompb.LabelMatcher_EQ, Name: "__name__", Value: "cpu_usage"}),
-			contains: []string{"metric_name = ?"},
-			args:     []any{"cpu_usage"},
-		},
-		{
-			name:     "regex name is anchored",
-			query:    query(&prompb.LabelMatcher{Type: prompb.LabelMatcher_RE, Name: "__name__", Value: ".+"}),
-			contains: []string{"match(metric_name, ?)"},
-			args:     []any{"^(?:.+)$"},
-		},
-		{
-			name: "nameless selector has no metric_name condition",
-			query: query(
-				&prompb.LabelMatcher{Type: prompb.LabelMatcher_EQ, Name: "job", Value: "api"},
-				&prompb.LabelMatcher{Type: prompb.LabelMatcher_NRE, Name: "group", Value: "can.*"},
-			),
-			contains: []string{
-				"JSONExtractString(labels, ?) = ?",
-				"not match(JSONExtractString(labels, ?), ?)",
-			},
-			absent: []string{"metric_name"},
-			args:   []any{"job", "api", "group", "^(?:can.*)$"},
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			lookup, err := seriesLookupQuery(tt.query, false)
-			require.NoError(t, err)
-			sql, args := lookup.BuildWithFlavor(sqlbuilder.ClickHouse)
-			for _, want := range tt.contains {
-				assert.Contains(t, sql, want)
-			}
-			for _, notWant := range tt.absent {
-				assert.NotContains(t, sql, notWant)
-			}
-			assert.Equal(t, tt.args, args)
-		})
-	}
-}
-
-// The samples query narrows by the metric names the lookup discovered and
-// embeds the series lookup as a subquery, the builder merging its args in
-// render order.
-func TestBuildSamplesQueryMetricNames(t *testing.T) {
-	sub := sqlbuilder.NewSelectBuilder()
-	sub.Select("fingerprint")
-	sub.From("t")
-	sub.Where(sub.E("k", "v"))
-
-	sql, args := buildSamplesQuery(5, 9, []string{"a_total", "b_total"}, sub)
-	assert.Contains(t, sql, "metric_name IN (?, ?)")
-	assert.Contains(t, sql, "fingerprint GLOBAL IN (SELECT fingerprint FROM t WHERE k = ?)")
-	assert.Contains(t, sql, "unix_milli >= ? AND unix_milli <= ?")
-	assert.Equal(t, []any{"a_total", "b_total", "v", int64(5), int64(9)}, args)
-
-	sub2 := sqlbuilder.NewSelectBuilder()
-	sub2.Select("fingerprint")
-	sub2.From("t")
-	sql, args = buildSamplesQuery(5, 9, nil, sub2)
-	assert.NotContains(t, sql, "metric_name IN")
-	assert.Equal(t, []any{int64(5), int64(9)}, args)
-}
-
-// Hash grouping must stay order-insensitive (stored JSON key order is not
-// canonical across fingerprints), and a 64-bit hash collision between
-// distinct labelsets must not merge them — splitByLabelSet is that guard.
-func TestLabelsHashAndCollisionSplit(t *testing.T) {
-	lbls := []prompb.Label{
-		{Name: "__name__", Value: "requests"},
-		{Name: "job", Value: "api"},
-		{Name: "instance", Value: "0"},
-	}
-	reversed := []prompb.Label{lbls[2], lbls[1], lbls[0]}
-	assert.Equal(t, labelsHash(lbls), labelsHash(reversed))
-
-	a := &prompb.TimeSeries{Labels: []prompb.Label{{Name: "job", Value: "x"}}}
-	b := &prompb.TimeSeries{Labels: []prompb.Label{{Name: "job", Value: "y"}}}
-	c := &prompb.TimeSeries{Labels: []prompb.Label{{Name: "job", Value: "x"}}}
-	got := splitByLabelSet([]*prompb.TimeSeries{a, b, c})
-	require.Len(t, got, 2)
-	assert.Equal(t, []*prompb.TimeSeries{a, c}, got[0])
-	assert.Equal(t, []*prompb.TimeSeries{b}, got[1])
-}

pkg/prometheus/clickhouseprometheus/json.go

@@ -2,15 +2,14 @@ package clickhouseprometheus
 
 import (
 	"encoding/json"
+	"strconv"
 
+	"github.com/SigNoz/signoz/pkg/prometheus"
 	"github.com/prometheus/prometheus/prompb"
 )
 
 // Unmarshals JSON into Prometheus labels. It does not preserve order.
-// Empty-valued labels are dropped: Prometheus treats them as absent, and
-// keeping them lets two fingerprints present duplicate labelsets to the
-// engine (the incident behind #8563).
-func unmarshalLabels(s string) ([]prompb.Label, string, error) {
+func unmarshalLabels(s string, fingerprint uint64) ([]prompb.Label, string, error) {
 	var metricName string
 	m := make(map[string]string)
 	if err := json.Unmarshal([]byte(s), &m); err != nil {
@@ -18,9 +17,6 @@ func unmarshalLabels(s string) ([]prompb.Label, string, error) {
 	}
 	res := make([]prompb.Label, 0, len(m))
 	for n, v := range m {
-		if v == "" {
-			continue
-		}
 		if n == "__name__" {
 			metricName = v
 		}
@@ -30,5 +26,9 @@ func unmarshalLabels(s string) ([]prompb.Label, string, error) {
 			Value: v,
 		})
 	}
+	res = append(res, prompb.Label{
+		Name:  prometheus.FingerprintAsPromLabelName,
+		Value: strconv.FormatUint(fingerprint, 10),
+	})
 	return res, metricName, nil
 }

pkg/prometheus/clickhouseprometheus/merge_test.go

@@ -1,82 +0,0 @@
-package clickhouseprometheus
-
-import (
-	"testing"
-
-	"github.com/prometheus/prometheus/prompb"
-	"github.com/stretchr/testify/assert"
-)
-
-func mkSeries(value string, samples ...prompb.Sample) *prompb.TimeSeries {
-	return &prompb.TimeSeries{
-		Labels:  []prompb.Label{{Name: "job", Value: value}},
-		Samples: samples,
-	}
-}
-
-func TestMergeSeriesWithIdenticalLabels(t *testing.T) {
-	s := func(ts int64, v float64) prompb.Sample { return prompb.Sample{Timestamp: ts, Value: v} }
-
-	t.Run("empty and single series pass through untouched", func(t *testing.T) {
-		assert.Nil(t, mergeSeriesWithIdenticalLabels(nil))
-		one := []*prompb.TimeSeries{mkSeries("a", s(1, 1))}
-		got := mergeSeriesWithIdenticalLabels(one)
-		assert.Equal(t, one, got)
-	})
-
-	t.Run("no collisions returns the input slice as is", func(t *testing.T) {
-		in := []*prompb.TimeSeries{mkSeries("a", s(1, 1)), mkSeries("b", s(1, 2))}
-		got := mergeSeriesWithIdenticalLabels(in)
-		// same backing slice: the fast path must not rebuild anything
-		assert.Equal(t, &in[0], &got[0])
-	})
-
-	t.Run("disjoint streams concatenate in timestamp order", func(t *testing.T) {
-		// the #8563 shape: the series transitioned fingerprints at a point
-		// in time, so the streams do not overlap at all
-		got := mergeSeriesWithIdenticalLabels([]*prompb.TimeSeries{
-			mkSeries("a", s(1, 1), s(2, 2)),
-			mkSeries("a", s(3, 3), s(4, 4)),
-		})
-		assert.Equal(t, []prompb.Sample{s(1, 1), s(2, 2), s(3, 3), s(4, 4)}, got[0].Samples)
-	})
-
-	t.Run("three fingerprints one labelset", func(t *testing.T) {
-		got := mergeSeriesWithIdenticalLabels([]*prompb.TimeSeries{
-			mkSeries("a", s(1, 1), s(4, 4)),
-			mkSeries("a", s(2, 2)),
-			mkSeries("a", s(3, 3)),
-		})
-		assert.Len(t, got, 1)
-		assert.Equal(t, []prompb.Sample{s(1, 1), s(2, 2), s(3, 3), s(4, 4)}, got[0].Samples)
-	})
-
-	t.Run("equal timestamps everywhere keep the last stream's value", func(t *testing.T) {
-		// input is in ascending fingerprint order; the highest wins each tie
-		got := mergeSeriesWithIdenticalLabels([]*prompb.TimeSeries{
-			mkSeries("a", s(1, 1), s(2, 1)),
-			mkSeries("a", s(1, 9), s(2, 9)),
-		})
-		assert.Equal(t, []prompb.Sample{s(1, 9), s(2, 9)}, got[0].Samples)
-	})
-
-	t.Run("zero-sample series in a group is harmless", func(t *testing.T) {
-		got := mergeSeriesWithIdenticalLabels([]*prompb.TimeSeries{
-			mkSeries("a"),
-			mkSeries("a", s(1, 1)),
-		})
-		assert.Len(t, got, 1)
-		assert.Equal(t, []prompb.Sample{s(1, 1)}, got[0].Samples)
-	})
-
-	t.Run("colliding and distinct series interleave without cross-talk", func(t *testing.T) {
-		got := mergeSeriesWithIdenticalLabels([]*prompb.TimeSeries{
-			mkSeries("a", s(1, 1)),
-			mkSeries("b", s(1, 2)),
-			mkSeries("a", s(2, 3)),
-		})
-		assert.Len(t, got, 2)
-		assert.Equal(t, []prompb.Sample{s(1, 1), s(2, 3)}, got[0].Samples)
-		assert.Equal(t, []prompb.Sample{s(1, 2)}, got[1].Samples)
-	})
-}

pkg/prometheus/label.go

@@ -0,0 +1,39 @@
+package prometheus
+
+import (
+	"github.com/SigNoz/signoz/pkg/errors"
+	"github.com/prometheus/prometheus/model/labels"
+	"github.com/prometheus/prometheus/promql"
+)
+
+const FingerprintAsPromLabelName string = "fingerprint"
+
+func RemoveExtraLabels(res *promql.Result, labelsToRemove ...string) error {
+	if len(labelsToRemove) == 0 || res == nil {
+		return nil
+	}
+
+	switch res.Value.(type) {
+	case promql.Vector:
+		value := res.Value.(promql.Vector)
+		for i := range value {
+			b := labels.NewBuilder(value[i].Metric)
+			b.Del(labelsToRemove...)
+			newLabels := b.Labels()
+			value[i].Metric = newLabels
+		}
+	case promql.Matrix:
+		value := res.Value.(promql.Matrix)
+		for i := range value {
+			b := labels.NewBuilder(value[i].Metric)
+			b.Del(labelsToRemove...)
+			newLabels := b.Labels()
+			value[i].Metric = newLabels
+		}
+	case promql.Scalar:
+		return nil
+	default:
+		return errors.NewInternalf(errors.CodeInternal, "rule result is not a vector or scalar or matrix")
+	}
+	return nil
+}

pkg/prometheus/prometheustest/utils_test.go

@@ -0,0 +1,107 @@
+package prometheustest
+
+import (
+	"testing"
+
+	"github.com/SigNoz/signoz/pkg/prometheus"
+	"github.com/prometheus/prometheus/model/labels"
+	"github.com/prometheus/prometheus/promql"
+)
+
+func TestRemoveExtraLabels(t *testing.T) {
+
+	tests := []struct {
+		name    string
+		res     *promql.Result
+		remove  []string
+		wantErr bool
+		verify  func(t *testing.T, result *promql.Result, removed []string)
+	}{
+		{
+			name: "vector – label removed",
+			res: &promql.Result{
+				Value: promql.Vector{
+					promql.Sample{
+						Metric: labels.FromStrings(
+							"__name__", "http_requests_total",
+							"job", "demo",
+							"drop_me", "dropped",
+						),
+					},
+				},
+			},
+			remove: []string{"drop_me"},
+			verify: func(t *testing.T, result *promql.Result, removed []string) {
+				k := result.Value.(promql.Vector)
+				for _, str := range removed {
+					get := k[0].Metric.Get(str)
+					if get != "" {
+						t.Fatalf("label not removed")
+					}
+				}
+			},
+		},
+		{
+			name: "scalar – nothing to strip",
+			res: &promql.Result{
+				Value: promql.Scalar{V: 99, T: 1},
+			},
+			remove: []string{"irrelevant"},
+			verify: func(t *testing.T, result *promql.Result, removed []string) {
+				sc := result.Value.(promql.Scalar)
+				if sc.V != 99 || sc.T != 1 {
+					t.Fatalf("scalar unexpectedly modified: got %+v", sc)
+				}
+			},
+		},
+		{
+			name: "matrix – label removed",
+			res: &promql.Result{
+				Value: promql.Matrix{
+					promql.Series{
+						Metric: labels.FromStrings(
+							"__name__", "http_requests_total",
+							"pod", "p0",
+							"drop_me", "dropped",
+						),
+						Floats: []promql.FPoint{{T: 0, F: 1}, {T: 1, F: 2}},
+					},
+					promql.Series{
+						Metric: labels.FromStrings(
+							"__name__", "http_requests_total",
+							"pod", "p0",
+							"drop_me", "dropped",
+						),
+						Floats: []promql.FPoint{{T: 0, F: 1}, {T: 1, F: 2}},
+					},
+				},
+			},
+			remove: []string{"drop_me"},
+			verify: func(t *testing.T, result *promql.Result, removed []string) {
+				mat := result.Value.(promql.Matrix)
+				for _, str := range removed {
+					for _, k := range mat {
+						if k.Metric.Get(str) != "" {
+							t.Fatalf("label not removed")
+						}
+					}
+				}
+			},
+		},
+	}
+
+	for _, tc := range tests {
+		t.Run(tc.name, func(t *testing.T) {
+			err := prometheus.RemoveExtraLabels(tc.res, tc.remove...)
+			if tc.wantErr && err == nil {
+				t.Fatalf("expected error, got nil")
+			}
+			if !tc.wantErr && err != nil {
+				t.Fatalf("unexpected error: %v", err)
+			}
+			if tc.verify != nil {
+				tc.verify(t, tc.res, tc.remove)
+			}
+		})
+	}
+}

pkg/querier/builder_query.go

@@ -15,6 +15,7 @@ import (
 	"github.com/SigNoz/signoz/pkg/telemetrytraces"
 	"github.com/SigNoz/signoz/pkg/types/ctxtypes"
 	"github.com/SigNoz/signoz/pkg/types/instrumentationtypes"
+	"github.com/SigNoz/signoz/pkg/types/metrictypes"
 	qbtypes "github.com/SigNoz/signoz/pkg/types/querybuildertypes/querybuildertypesv5"
 	"github.com/SigNoz/signoz/pkg/types/telemetrytypes"
 	"github.com/SigNoz/signoz/pkg/valuer"
@@ -42,6 +43,23 @@ var _ qbtypes.StatementProvider = (*builderQuery[any])(nil)
 
 type builderConfig struct {
 	logTraceIDWindowPaddingMS uint64
+	// fingerprintSuffix distinguishes cache entries produced by semantically
+	// different pipelines for the same spec (e.g. the counter-epoch rollout)
+	fingerprintSuffix string
+}
+
+// metricSpecUsesCounterEpochs reports whether the epoch pipeline would change
+// this spec's results: cumulative (or mixed) rate/increase aggregations.
+func metricSpecUsesCounterEpochs(spec qbtypes.QueryBuilderQuery[qbtypes.MetricAggregation]) bool {
+	for _, agg := range spec.Aggregations {
+		if agg.Temporality == metrictypes.Delta || agg.Temporality == metrictypes.Unspecified {
+			continue
+		}
+		if agg.TimeAggregation == metrictypes.TimeAggregationRate || agg.TimeAggregation == metrictypes.TimeAggregationIncrease {
+			return true
+		}
+	}
+	return false
 }
 
 func newBuilderQuery[T any](
@@ -171,6 +189,10 @@ func (q *builderQuery[T]) Fingerprint() string {
 		parts = append(parts, fmt.Sprintf("shiftby=%d", q.spec.ShiftBy))
 	}
 
+	if q.builderConfig.fingerprintSuffix != "" {
+		parts = append(parts, q.builderConfig.fingerprintSuffix)
+	}
+
 	return strings.Join(parts, "&")
 }