chore(querybuilder): compile every signal through one storage contract

Each signal had its own copy of name resolution, the guard rule, and the
column renderer, and each copy made its own choices. The semantic
convention families made the differences visible: the same family fold
had to be written seven times, and the guards did not agree.

A storage now answers only what the compiler cannot know: one read per
field key (the bare SQL, the membership test in both polarities, what an
absent row reads, and whether the read keeps its type or filters only),
the fallback for a key metadata does not report, its traits, and one
override for a storage with its own condition language. Resolution, the
condition builder, and the column expression builder live in
querybuilder and are written one time.

- Storage replaces FieldMapper and ConditionBuilder for traces, logs,
  metrics, audit, rule state history, the resource fingerprint, and the
  related-values metadata.
- Absent says how a field key reads when a row does not carry it, and
  every guard derives from it. A sentinel read takes the exists guard on
  positive operators and in the column stages. A NULL read and a table
  column take none. A declared keyless contract (metrics labels, rule
  state labels) takes none.
- QueryInfo carries the org, the time range, the signal, the queried
  metric, and the query-path flags, evaluated one time per builder stage.
- LogicalField carries ValueMaps, so a family member's stored vocabulary
  translates to the current one in every read.
- The not-found warning fires only when every fallback key is a guess.
  A key under a signal's own context matches that context first, then
  resolves as if it had no context.

Three results change, because the one guard rule contradicts the old
SQL:

- A table column takes no guard in the group by, order by, and
  aggregation-argument stages. Zero-duration spans enter percentiles and
  averages, and an empty severity is its own group, not the NULL group.
- A scope map attribute takes the default exists guard in logs and
  audit, like an attribute; `scope.x = ''` no longer matches every row
  without the key.
- An audit raw select reads NULL for an absent map attribute, like logs
  and traces, instead of the empty string.

Assisted-by: Claude Fable 5.1
Claude-Session: https://claude.ai/code/session_01RSnZFLSfyi5S4QYQDcxHeW

.claude/opencode.json

@@ -1,7 +0,0 @@
-{
-  "$schema": "https://opencode.ai/config.json",
-  "lsp": true,
-  "experimental": {
-    "disable_paste_summary": true
-  }
-}

.claude/rules/comments.md

@@ -7,6 +7,5 @@ Applies to everything in the repo — code, config, workflows.
 - **Rationale goes in prose, not source.** Why a version is pinned, why a job exists, how a subsystem fits together — that belongs in the README or the PR.
 - **Never remove pre-existing comments** when editing code. The bar above applies to comments you write, not comments already there.
 - **Never talk to the reviewer.** No comments about where a change came from, what was changed, or why the change is correct — that belongs in the PR description and is noise the moment it merges.
-- **Less is more.** When writing something intended for human consumption, (comment, commit message, reply to prompt) use as few words as possible. Pick every word meticulously to reduce the volume to a strict minimum. Be down to the point. Less is more.
 
 Language rules build on this one: [`go-comments`](go-comments.md), [`py-comments`](py-comments.md).

.claude/rules/go-contrib.md

@@ -1,16 +0,0 @@
----
-paths:
-  - "**/*.go"
----
-
-# Contribution guidelines
-
-- When making Go changes, always ensure they follow the contributing guildelines in [`docs/contributing/go/`](../../docs/contributing/go/).
-- Look for existing patterns in the codebase for any change before implementing the changes.
-- If any API contract is modified, generate the OpenAPI specs with `make gen-openapi-specs`.
-- Always keep the OpenAPI spec generated in a separate commit, so the whole commit can be dropped in case of conflicts during merge. Do not try to resolve conflict in generated files, instead just generate them again.
-- Avoid breaking function calls unncessarily into multilines for couple of arguments.
-- Try to keep most computational only logic in types package itself related to a domain type, use modules as the orchestraction layer cordinating different layers and all db queries in store layer. Check the serviceaccount modules for inspiration when confused.
-- When defining types, keep the structure of file to have any constants and variables first, then exported types and exported methods and then finally the unexported types and methods.
-- Never import types or other modules in migration files, duplicate the required type or method to keep migration free from changes.
-- Always run the gofmt tool for formating beforing commiting any changes.

.claude/rules/pull-requests.md

@@ -2,10 +2,6 @@
 
 - **Follow the template** (`.github/pull_request_template.md`): fill in its headings (Description / Issues closed by this PR / Screenshots / Additional Information). Don't add sections the template doesn't have.
 - **Keep only the headings that apply.** Delete every heading that has nothing under it, along with its `<!--...-->` placeholder comment. The body must never contain an empty heading — if only Description applies, the body has exactly that one heading.
-- **Keep the description concise and human-readable.** A few non repetitive bullets saying what changed and why, for a reviewer skimming it — not a wall of text, not a restatement of the diff, not generated boilerplate and not the user agent conversation details.
+- **Keep the description concise and human-readable.** A few plain bullets saying what changed and why, for a reviewer skimming it — not a wall of text, not a restatement of the diff, not generated boilerplate.
 - **Reference issues with `Closes #issue-number`** under "Issues closed by this PR" so they auto-close on merge. This goes in the PR description only — never in commit messages.
-- **Breaking changes can be added in additional information section** if any.
 - **AI assistance in commits may optionally be disclosed with an `Assisted-by:` trailer** naming the model (e.g. `Assisted-by: Claude Opus 4.5`) — do NOT use a `Co-authored-by:` trailer for this.
-- **Keep the commit body short and human readable** focused on decision made if any. Commit body must not re-iterate the changes done, skip if title is sufficient in conveying the change.
-- **Use convensional commit format** for commits and PR title.
-- **Do not amend the commits once pushed.** Always create a new commit once changes are pushed to remote.

.github/CODEOWNERS

@@ -15,10 +15,6 @@
 .github @therealpandey
 go.mod @therealpandey
 
-# Security
-
-/SECURITY.md @therealpandey
-
 # Scaffold Owners
 
 /pkg/config/ @therealpandey

.gitignore

@@ -232,4 +232,3 @@ pyrightconfig.json
 # dev
 .dev/
 .claude/worktrees/
-.claude/settings.local.json

Makefile

@@ -81,13 +81,10 @@ devenv-clickhouse-clean: ## Clean all ClickHouse data from filesystem
 ##############################################################
 # go commands
 ##############################################################
-SIGNOZ_SQLSTORE_SQLITE_PATH ?= signoz.db
-SIGNOZ_APISERVER_ADDRESS    ?= 0.0.0.0:8080
-
 .PHONY: go-run-enterprise
 go-run-enterprise: ## Runs the enterprise go backend server
 	@SIGNOZ_INSTRUMENTATION_LOGS_LEVEL=debug \
-	SIGNOZ_SQLSTORE_SQLITE_PATH=$(SIGNOZ_SQLSTORE_SQLITE_PATH) \
+	SIGNOZ_SQLSTORE_SQLITE_PATH=signoz.db \
 	SIGNOZ_WEB_ENABLED=false \
 	SIGNOZ_TOKENIZER_JWT_SECRET=secret \
 	SIGNOZ_ALERTMANAGER_PROVIDER=signoz \
@@ -104,7 +101,7 @@ go-test: ## Runs go unit tests
 .PHONY: go-run-community
 go-run-community: ## Runs the community go backend server
 	@SIGNOZ_INSTRUMENTATION_LOGS_LEVEL=debug \
-	SIGNOZ_SQLSTORE_SQLITE_PATH=$(SIGNOZ_SQLSTORE_SQLITE_PATH) \
+	SIGNOZ_SQLSTORE_SQLITE_PATH=signoz.db \
 	SIGNOZ_WEB_ENABLED=false \
 	SIGNOZ_TOKENIZER_JWT_SECRET=secret \
 	SIGNOZ_ALERTMANAGER_PROVIDER=signoz \
@@ -114,28 +111,6 @@ go-run-community: ## Runs the community go backend server
 	go run -race \
 		$(GO_BUILD_CONTEXT_COMMUNITY)/*.go server
 
-.PHONY: go-stop
-go-stop: ## Stops the go backend server listening on SIGNOZ_APISERVER_ADDRESS, waiting for it to release every port it holds
-	@PORT=$(lastword $(subst :, ,$(SIGNOZ_APISERVER_ADDRESS))); \
-	PIDS=$$(lsof -ti tcp:$$PORT); \
-	if [ -z "$$PIDS" ]; then \
-		echo "No signoz server running on port $$PORT."; \
-		echo "If it's running on a different port, rerun as: make go-stop SIGNOZ_APISERVER_ADDRESS=host:port"; \
-		exit 0; \
-	fi; \
-	kill $$PIDS 2>/dev/null; \
-	for i in $$(seq 1 10); do \
-		alive=$$(for p in $$PIDS; do kill -0 $$p 2>/dev/null && echo $$p; done); \
-		[ -z "$$alive" ] && break; \
-		sleep 1; \
-	done; \
-	alive=$$(for p in $$PIDS; do kill -0 $$p 2>/dev/null && echo $$p; done); \
-	if [ -n "$$alive" ]; then \
-		echo "Graceful shutdown did not finish in 10s, sending SIGKILL to $$alive"; \
-		kill -9 $$alive 2>/dev/null; \
-	fi; \
-	echo "Stopped signoz server on port $$PORT (pid $$PIDS)"
-
 .PHONY: go-build-community $(GO_BUILD_ARCHS_COMMUNITY)
 go-build-community: ## Builds the go backend server for community
 go-build-community: $(GO_BUILD_ARCHS_COMMUNITY)
@@ -266,8 +241,3 @@ semconv-generate: ## Regenerate semantic-convention families for Go and TypeScri
 gen-mocks:
 	@echo ">> Generating mocks"
 	@mockery --config .mockery.yml
-
-.PHONY: gen-openapi-specs
-gen-openapi-specs:
-	@go run cmd/enterprise/*.go generate openapi
-	cd frontend && pnpm generate:api && cd -

SECURITY.md

@@ -1,26 +1,17 @@
 # Security Policy
 
-SigNoz is looking forward to working with security researchers across the world to keep SigNoz and our users safe. If you have found an issue in our systems/applications, please report it to us privately.
+SigNoz is looking forward to working with security researchers across the world to keep SigNoz and our users safe. If you have found an issue in our systems/applications, please reach out to us.
 
 ## Supported Versions
-
-We always recommend using the latest version of SigNoz to ensure you get all security updates.
+We always recommend using the latest version of SigNoz to ensure you get all security updates
 
 ## Reporting a Vulnerability
 
 If you believe you have found a security vulnerability within SigNoz, please let us know right away. We'll try and fix the problem as soon as possible.
 
-**Do not report vulnerabilities using public GitHub issues, discussions, or pull requests.**
+**Do not report vulnerabilities using public GitHub issues**. Instead, email <security@signoz.io> with a detailed account of the issue. Please submit one issue per email, this helps us triage vulnerabilities.
 
-Instead, report it privately through GitHub's private vulnerability reporting:
-
-1. Go to the [**Security** tab](https://github.com/SigNoz/signoz/security) of this repository.
-2. Click **Report a vulnerability**, or use [this link](https://github.com/SigNoz/signoz/security/advisories/new).
-3. Describe the issue with as much detail as you can — affected version, impact, and steps to reproduce help us triage faster. Please submit one report per vulnerability.
-
-This opens a private advisory visible only to you and the SigNoz maintainers. We'll respond there, keep you updated as we work on a fix, and coordinate disclosure. If the report is valid we'll credit you on the published advisory and request a CVE.
-
-If you're unable to use GitHub's private reporting, you can email <security@signoz.io> instead.
+Once we've received your email we'll keep you updated as we fix the vulnerability.
 
 ## Thanks
 

conf/example.yaml

@@ -138,12 +138,6 @@ sqlstore:
 
 ##################### APIServer #####################
 apiserver:
-  # The TCP address the API server listens on, in the form "host:port".
-  address: 0.0.0.0:8080
-  # Maximum duration for reading an entire request, including the body.
-  read_timeout: 60s
-  # Keep at 0; any value cuts off streaming endpoints (livetail, SSE, export_raw_data).
-  write_timeout: 0
   timeout:
     # Default request timeout.
     default: 60s

docs/contributing/development.md

@@ -83,13 +83,7 @@ This command:
 
    You should see: `{"status":"ok"}`
 
-3. Stop it when you're done:
-   ```bash
-   make go-stop
-   ```
-
-> 💡 **Tip**: The API server runs at `http://localhost:8080/` by default. You can configure this using `apiserver.address` configuration option. See
-> [running more than one instance](#how-do-i-run-more-than-one-instance) if you need that for agentic testing.
+> 💡 **Tip**: The API server runs at `http://localhost:8080/` by default
 
 ### 4. Setting up the Frontend
 
@@ -125,36 +119,6 @@ To verify everything is working correctly:
 3. **Check Backend**: `curl http://localhost:8080/api/v1/health` (should return `{"status":"ok"}`)
 4. **Check Frontend**: Open `http://localhost:3301` in your browser
 
-## How do I run more than one instance?
-
-Handy when you keep several branches checked out as separate git worktrees. Every port
-and path below is read from the environment, so set them on the `make` call:
-
-```bash
-SIGNOZ_APISERVER_ADDRESS=0.0.0.0:8081 \
-SIGNOZ_SQLSTORE_SQLITE_PATH=/path/to/main/sqlite.db \
-SIGNOZ_INSTRUMENTATION_METRICS_READERS_PULL_EXPORTER_PROMETHEUS_PORT=9091 \
-make go-run-community
-```
-
-| Variable | Default | Why you'd change it |
-| --- | --- | --- |
-| `SIGNOZ_APISERVER_ADDRESS` | `0.0.0.0:8080` | Address the API server listens on |
-| `SIGNOZ_SQLSTORE_SQLITE_PATH` | `signoz.db` in worktree | To reuse same database |
-| `SIGNOZ_INSTRUMENTATION_METRICS_READERS_PULL_EXPORTER_PROMETHEUS_PORT` | `9090` | Bound by the Prometheus metrics exporter on startup |
-
-Point the frontend at whichever backend you want, in `frontend/.env`:
-
-```env
-VITE_FRONTEND_API_ENDPOINT=http://localhost:8081
-```
-
-Stop an instance using the address it was started on:
-
-```bash
-make go-stop SIGNOZ_APISERVER_ADDRESS=0.0.0.0:8081
-```
-
 ## How to send test data?
 
 You can now send telemetry data to your local SigNoz instance:

docs/contributing/query-range.md

@@ -54,50 +54,93 @@ The `fieldContexts` map includes aliases (`tag` -> `attribute`, `spanfield` -> `
 
 ## The Abstraction Stack
 
-The query pipeline is built from four interfaces that compose vertically. Each layer has a single responsibility. Each layer depends only on the layers below it. This layering is intentional and must be preserved.
+The query pipeline has three layers. The generic layer is written one time, in `pkg/querybuilder`. A storage is written one time per signal. The statement builders compose them. Each layer depends only on the layer below it. This layering is intentional and must be preserved.
 
 ```
-StatementBuilder          <- Orchestrates everything into executable SQL
-  ├── AggExprRewriter     <- Rewrites aggregation expressions (maps field refs to columns)
-  ├── ConditionBuilder    <- Builds WHERE predicates (field + operator + value -> SQL)
-  └── FieldMapper         <- Maps TelemetryFieldKey -> ClickHouse column expression
+StatementBuilder                <- Composes one query into executable SQL
+  ├── AggExprRewriter           <- Rewrites aggregation expressions through the generic layer
+  ├── filter visitor            <- Parses the filter expression and compiles it one term at a time
+  └── querybuilder (generic)    <- Resolution, the condition builder, the column expression builder
+        └── Storage             <- What one signal's tables can answer about one field key
 ```
 
-### FieldMapper
+### Storage
 
-**Contract:** Given a `TelemetryFieldKey`, return a ClickHouse column expression that yields the value for that field when used in a SELECT.
+**Contract:** `qbtypes.Storage` in `pkg/types/querybuildertypes/querybuildertypesv5/qb.go`. One implementation per signal: traces, logs, metrics, audit, rule state history, the resource fingerprint sub-query, and the related-values metadata.
 
-**Principle:** This is the *only* place where field-to-column translation happens. No other layer should contain knowledge of how fields map to storage. If you need a column expression, go through the FieldMapper.
+A storage answers four questions and nothing else:
 
-**Why:** The user says `http.request.method`. ClickHouse might store it as `attributes_string['http.request.method']`, or as a materialized column `` `attribute_string_http$$request$$method` ``, or via a JSON access path in a body column. This variation is entirely contained within the FieldMapper. Everything above it is storage-agnostic.
+- `Read(key)`: one call for one field key. It returns the bare SQL read (no alias, no guard, no cast), the membership test (`Presence`, arg-free so it can sit inside guards) and its negation in the storage's own form (`Absence`), what a row without the key reads (`Absent`, below), whether the stage cast must leave the native type alone (`KeepType`: time columns, metrics labels), and whether the key filters but cannot be selected (`FilterOnly`: the legacy string body). It honors the materialization and the evolutions the key carries.
+- `Fallback(key, operator, value)`: the field keys that could hold a key metadata does not report: column aliases, the type variants of a map read, body paths, and virtual keys that compile to structural predicates (a span search scope, a full-text search over a scope).
+- `Traits()`: the storage's part in the resource fingerprint split, whether it supports body functions, what it does with an unknown key, and which contexts mean "this signal's own record".
+- `Compile`: the one override, for a storage with its own condition language (the body JSON language in logs, the index hints of the resource fingerprint, the polarity form of the related values, the String-typed labels of metrics). Every other storage returns `querybuilder.SharedCondition`.
 
-### ConditionBuilder
+**Principle:** A storage describes its field keys. It never decides a guard, an ambiguity, a warning, or the shape of a fold. Those decisions are derived one time, in the generic layer, from those descriptions.
 
-**Contract:** Given a field key, an operator, and a value, produce a valid SQL predicate for a WHERE clause.
+### Absent
 
-**Dependency:** Uses FieldMapper for the left-hand side of the condition.
+`Read` returns the field's `Absent`: what a row without the field reads. It is a property of the read, not of the column. `resource.x::String` reads the empty string for an absent row, the multi-era fold `multiIf(..., NULL)` reads NULL, and a table column always reads a real value. Every guard derives from it:
 
-**Principle:** The ConditionBuilder owns all the complexity of operator semantics, i.e type casting, array operators (`hasAny`/`hasAll` vs `=`), existence checks, and negative operator behavior. This complexity must not leak upward into the StatementBuilder.
+| WhenAbsent | Absent row reads | Positive filter | Raw select | Multi-candidate column | Field keys |
+|---|---|---|---|---|---|
+| `AlwaysPresent` | a real value | no guard | no guard | no branch, ends the candidate list | table columns |
+| `AbsentIsSentinel` | `''`, 0, false, and that is not a value | exists guard | exists guard | presence branch | map attributes, cast JSON paths, string families |
+| `AbsentIsNull` | NULL | no guard | no guard | presence branch | multi-era folds, body JSON paths, numeric families |
+| `AbsentIsValue` | `''`, and that is the keyless contract | no guard | no guard | no presence branch | metrics labels, rule state history labels |
 
-### AggExprRewriter
+### The generic layer
 
-**Contract:** Given a user-facing aggregation expression like `sum(duration_nano)`, resolve field references within it and produce valid ClickHouse SQL.
+`pkg/querybuilder` needs two inputs, made one time per request:
 
-**Dependency:** Uses FieldMapper to resolve field names within expressions.
+- The metadata keys: `keys := metadataStore.GetKeysMulti(...)`, the field keys the metadata store reports for the query's names, as `map[name][]*TelemetryFieldKey`.
+- `q := querybuilder.NewQueryInfo(ctx, orgID, fl, signal, metric, startNs, endNs)`: the time range every read needs, the signal and the queried metric that family admission needs, and the query-path flags (`FamiliesOn`, `BodyJSONOn`), evaluated one time.
 
-**Principle:** Aggregation expressions are user-authored strings that contain field references. The rewriter parses them, identifies field references, resolves each through the FieldMapper, and reassembles the expression.
+The functions, from the outside in:
 
-### StatementBuilder
+| Function | Does |
+|---|---|
+| `PrepareWhereClause(query, opts)` | The filter visitor. Parses the filter grammar and compiles each term through `RejectsBodyFunction`, `Resolve`, and `Condition`. Returns the WHERE clause, the warnings, and the cost-guard flag. |
+| `NewAggExprRewriter(settings, fullTextColumn, storage, fl, signal)` | Parses an aggregation expression such as `sum(duration_nano)` and resolves each field reference through `ResolveColumn`. |
+| `ResolveColumn(ctx, q, storage, key, target, metadata)` | `Resolve` with `FilterOperatorUnknown`, then `Column`. The column stages (raw select, order by, group by, aggregation arguments) call it. |
+| `Resolve(ctx, q, storage, key, operator, value, metadata)` | One requested key to its meanings in this storage (see "A resolved key"). |
+| `Condition(ctx, q, storage, resolved, dropResourceFields, operator, value, sb)` | A resolved key to the conditions of one filter term: the split narrows the fields, and each field compiles through `storage.Compile`. |
+| `Conditions(...)` | `RejectsBodyFunction`, `Resolve`, and `Condition` in one call, for callers outside the visitor: the related-values metadata, the scoped traces predicate resolver, tests. |
+| `Column(ctx, q, storage, resolved, target)` | A resolved key to one bare column expression. The caller aliases. |
+| `RejectsBodyFunction(traits, operator)` | Before resolution: a storage without body functions (`has`, `hasAny`, `hasAll`, `hasToken`, `search`) errors; the fingerprint side of a split skips the term, because the main query evaluates it. After resolution, `Condition` errors when `has`, `hasAny`, `hasAll`, or `hasToken` lands on a map-backed key (resource, attribute, scope), before the split could drop it. |
+| `SharedCondition(...)` | The `Compile` of every storage without its own condition language: `LogicalRead`, the shared data-type collision cast, `OperatorCondition`, then the guard rule. |
+| `OperatorCondition(...)` | The operator switch over an already cast read. A storage with its own cast policy composes with it. |
+| `LogicalRead(...)` | The only place family expressions are built. A single-member field reads through its member. A family merges the member reads current-first (`COALESCE(NULLIF(m1, ''), NULLIF(m2, ''), '')` for strings, `multiIf` with a NULL tail for numbers), ORs the member presence tests, and reads for a row without any member what the merge's tail reads. A member with a value map reads through `TransformRead`. `NOT EXISTS` is the read's `Absence`, the storage's own negated form. |
 
-**Contract:** Given a complete `QueryBuilderQuery`, a time range, and a request type, produces an executable SQL statement.
+### A resolved key
 
-**Dependency:** Uses all three abstractions above.
+`Resolve` turns one requested key into a `Resolved` value. It is the only thing the condition builder and the column expression builder receive. Compile it with the operator and value it was resolved with: the stage is the operand, and a nil value means a column or presence use.
 
-**Principle:** This is the composition layer. It does not contain field mapping logic, condition building logic, or expression rewriting logic. It orchestrates the other abstractions. If you find storage-specific logic creeping into the StatementBuilder, push it down into the appropriate abstraction.
+```go
+type Resolved struct {
+	Key          *TelemetryFieldKey // the spelling the request used
+	Fields       []*LogicalField    // its meanings in this storage, one per interpretation
+	FromFallback bool               // the fields came from the storage's Fallback, not from metadata matches
+	Ambiguous    bool               // the matches held several interpretations
+	Skipped      bool               // the storage contributes nothing for this key
+	Warnings     []string           // the warnings to surface: ambiguity, not-found
+}
+```
+
+A `LogicalField` is one meaning: one name, context, and data type, backed by one or more physical members. A family (one field with several spellings) is one logical field with several members, current spelling first. Ambiguity (one name, different fields) is several logical fields.
+
+The resolution order is the same for every storage and every stage:
+
+1. **Own context.** A key under one of the storage's own contexts (`span.x`, `log.x`) matches its own context first. Only when nothing matches does it look up as if it had no context, so `span.http.method` corrects to the attribute. Strict contexts (`resource.`, `attribute.`, `scope.`, `body.`) are honored as written.
+2. **Matches.** The metadata keys under the key's spellings, grouped into families when the flag is on. Each combination of context and data type is one interpretation.
+3. **Ambiguity.** A filter settles several interpretations by resource over attribute, with a warning. A column stage keeps every interpretation in metadata order and folds them, so a select or a group by sees the value wherever it is.
+4. **Intrinsic column first**, bare keys only. A column every row has leads the list, whether metadata reports it or the storage's `Fallback` does. A `Fallback` column key carries the data type its column reads as (`querybuilder.ColumnDataType`), and a same-named metadata key of a contradicting type drops; a time column has no field data type and merges none. A metadata gap degrades to the correct column, never to a corrupt metadata key.
+5. **Fallback.** With no match, the storage's fallback keys for the key. When the storage ignores unknown keys (a side query whose main query owns the error), the key is `Skipped`. Otherwise a key nothing can serve is an error with suggestions. The not-found warning fires only when every fallback key is a guess, that is, none of them is always present.
+
+The condition builder then applies the fingerprint split (`MainOfSplit` drops the resource fields the sub-query serves and keeps fallback keys; `FingerprintOfSplit` keeps resource fields only), compiles each field, and the visitor joins the per-field conditions by the operator's polarity. The column expression builder reads each field through `LogicalRead`, casts for the coerced stages unless the read keeps its type, guards by `Absent`, and renders one candidate bare or several as `multiIf(..., NULL)`. A filter-only candidate drops; the error surfaces only when none remains.
 
 ### Invariant: No layer skipping
 
-The StatementBuilder must not call FieldMapper directly to build conditions, it goes through the ConditionBuilder. The AggExprRewriter must not hardcode column names, it goes through the FieldMapper. Skipping layers creates hidden coupling and makes the system fragile to storage changes.
+A statement builder must not spell a column or a condition. It calls `ResolveColumn` and the filter visitor. A storage must not decide a guard or an ambiguity. It declares `Absent` and answers the four questions. Skipping layers recreates the per-signal copies the contract removed.
 
 ---
 
@@ -119,14 +162,15 @@ Only additive/counting aggregations (`count`, `count_distinct`, `sum`, `rate`) d
 
 **Enforcement:** `GetQueriesSupportingZeroDefault` determines which queries can default to zero. The `FormulaEvaluator` consumes this via `canDefaultZero`. Changes to aggregation handling must preserve this distinction.
 
-### Constraint: Existence semantics differ for positive vs negative operators
+### Constraint: The exists guard derives from the operator and from the field
 
-- **Positive operators** (`=`, `>`, `LIKE`, `IN`, etc.) implicitly assert field existence. `http.method = GET` means "the field exists AND equals GET".
-- **Negative operators** (`!=`, `NOT IN`, `NOT LIKE`, etc.) do **not** add an existence check. `http.method != GET` includes records where the field doesn't exist at all.
+- **Positive operators** (`=`, `>`, `LIKE`, `IN`, etc.) implicitly assert field existence for a field that reads a sentinel when absent. `http.method = GET` on a map attribute means "the field exists AND equals GET".
+- **Negative operators** (`!=`, `NOT IN`, `NOT LIKE`, etc.) never add an existence check. `http.method != GET` includes records where the field doesn't exist at all.
+- A field that reads NULL when absent, and a table column, take no guard on any operator: the comparison already excludes the absent row, or there is no absent row.
 
-**Why:** The user's intent with negative operators is ambiguous. Rather than guess, we take the broader interpretation. Users can add an explicit `EXISTS` filter if they want the narrower one. This is documented in `AddDefaultExistsFilter`.
+**Why:** The user's intent with negative operators is ambiguous. Rather than guess, we take the broader interpretation. Users can add an explicit `EXISTS` filter if they want the narrower one. The operator side is declared in `AddDefaultExistsFilter`; the field side is the `Absent` a storage returns from `Exists`.
 
-**Consequence:** Any new operator must declare its existence behavior in `AddDefaultExistsFilter`. Do not add operators without considering this.
+**Consequence:** Any new operator must declare its existence behavior in `AddDefaultExistsFilter`. Any new read must declare what an absent row reads. Never add a guard by hand in a storage.
 
 ### Constraint: Post-processing functions operate on result sets, not in SQL
 
@@ -188,11 +232,11 @@ The `MetadataStore` interface provides runtime field discovery and type resoluti
 
 The same name can map to multiple `TelemetryFieldKey` variants (different contexts, different types). The metadata store returns *all* variants. Resolution to a single field happens during query building, using the query's signal and any explicit context/type hints from the user.
 
-**Consequence:** Code that calls `GetKey` or `GetKeys` must handle multiple results. Do not assume a name maps to a single field.
+**Consequence:** Code that calls `GetKey` or `GetKeys` must handle multiple results. Do not assume a name maps to a single field. `querybuilder.Resolve` is where the variants settle: it returns every interpretation as a `LogicalField`, marks the result `Ambiguous`, and carries the warning.
 
 ### Principle: Materialized fields are a performance optimization, not a semantic distinction
 
-A materialized field and its non-materialized equivalent represent the same logical field. The `Materialized` flag tells the FieldMapper to generate a simpler column expression. The user should never need to know whether a field is materialized.
+A materialized field and its non-materialized equivalent represent the same logical field. The `Materialized` flag tells the storage's `Read` to generate a simpler column expression. The user should never need to know whether a field is materialized.
 
 ### Principle: JSON body fields require access plans
 
@@ -203,14 +247,14 @@ Fields inside JSON body columns (`body.response.errors[].code`) need pre-compute
 ## Summary of Inviolable Rules
 
 1. **User-facing types never contain ClickHouse column names or SQL fragments.**
-2. **Field-to-column translation only happens in FieldMapper.**
+2. **Field-to-column translation only happens in a Storage (`Read`, `Fallback`).**
 3. **Normalization happens once at the API boundary, never deeper.**
 4. **Historical aliases in fieldContexts and fieldDataTypes must not be removed.**
 5. **Formula evaluation stays in Go — do not push it into ClickHouse JOINs.**
 6. **Zero-defaulting is aggregation-type-dependent — do not universally default to zero.**
-7. **Positive operators imply existence, negative operators do not.**
+7. **The exists guard derives from `AddDefaultExistsFilter` and `Absent`; positive operators guard sentinel reads, negative operators never guard.**
 8. **Post-processing functions operate on Go result sets, not in SQL.**
 9. **All user-facing types reject unknown JSON fields with suggestions.**
 10. **Validation rules are gated by request type.**
 11. **Query names must be unique within a composite query.**
-12. **The four-layer abstraction stack (FieldMapper -> ConditionBuilder -> AggExprRewriter -> StatementBuilder) must not be bypassed or flattened.**
+12. **The three-layer abstraction stack (Storage -> querybuilder generic layer -> StatementBuilder) must not be bypassed or flattened. A storage describes its field keys; the generic layer decides.**

ee/query-service/app/server.go

@@ -3,29 +3,56 @@ package app
 import (
 	"context"
 	"fmt"
+	"net"
+	"net/http"
+	"slices"
+
+	"go.opentelemetry.io/contrib/instrumentation/github.com/gorilla/mux/otelmux"
+	"go.opentelemetry.io/otel/propagation"
+
+	"github.com/SigNoz/signoz/pkg/errors"
+
+	"github.com/gorilla/handlers"
+
+	"github.com/rs/cors"
+	"github.com/soheilhy/cmux"
 
 	"github.com/SigNoz/signoz/ee/query-service/app/api"
 	"github.com/SigNoz/signoz/ee/query-service/usage"
 	"github.com/SigNoz/signoz/pkg/http/middleware"
 	"github.com/SigNoz/signoz/pkg/signoz"
+	"github.com/SigNoz/signoz/pkg/web"
 
 	"log/slog"
 
 	"github.com/SigNoz/signoz/pkg/query-service/agentConf"
+	baseapp "github.com/SigNoz/signoz/pkg/query-service/app"
 	"github.com/SigNoz/signoz/pkg/query-service/app/clickhouseReader"
 	"github.com/SigNoz/signoz/pkg/query-service/app/integrations"
 	"github.com/SigNoz/signoz/pkg/query-service/app/logparsingpipeline"
 	"github.com/SigNoz/signoz/pkg/query-service/app/opamp"
 	opAmpModel "github.com/SigNoz/signoz/pkg/query-service/app/opamp/model"
 	baseconst "github.com/SigNoz/signoz/pkg/query-service/constants"
+	"github.com/SigNoz/signoz/pkg/query-service/healthcheck"
+	"github.com/SigNoz/signoz/pkg/query-service/utils"
 )
 
-// Server runs auxiliary servers (opamp) alongside the signoz apiserver
+// Server runs HTTP, Mux and a grpc server
 type Server struct {
+	config signoz.Config
+	signoz *signoz.SigNoz
+
+	// public http router
+	httpConn     net.Listener
+	httpServer   *http.Server
+	httpHostPort string
+
 	opampServer *opamp.Server
 
 	// Usage manager
 	usageManager *usage.Manager
+
+	unavailableChannel chan healthcheck.Status
 }
 
 // NewServer creates and initializes Server
@@ -100,11 +127,57 @@ func NewServer(config signoz.Config, signoz *signoz.SigNoz) (*Server, error) {
 		return nil, err
 	}
 
-	// Register the legacy query-service routes on the apiserver router. The
-	// apiserver owns the HTTP server and applies the middleware chain at serve
-	// time, so these routes get the same treatment as the apiserver routes.
-	r := signoz.APIServer.Router()
-	am := middleware.NewAuthZ(signoz.Instrumentation.Logger(), signoz.Modules.OrgGetter, signoz.Authz)
+	s := &Server{
+		config:             config,
+		signoz:             signoz,
+		httpHostPort:       baseconst.HTTPHostPort,
+		unavailableChannel: make(chan healthcheck.Status),
+		usageManager:       usageManager,
+	}
+
+	httpServer, err := s.createPublicServer(apiHandler, signoz.Web)
+
+	if err != nil {
+		return nil, err
+	}
+
+	s.httpServer = httpServer
+
+	s.opampServer = opamp.InitializeServer(
+		&opAmpModel.AllAgents, agentConfMgr, signoz.Instrumentation,
+	)
+
+	return s, nil
+}
+
+// HealthCheckStatus returns health check status channel a client can subscribe to
+func (s Server) HealthCheckStatus() chan healthcheck.Status {
+	return s.unavailableChannel
+}
+
+func (s *Server) createPublicServer(apiHandler *api.APIHandler, web web.Web) (*http.Server, error) {
+	r := baseapp.NewRouter()
+	am := middleware.NewAuthZ(s.signoz.Instrumentation.Logger(), s.signoz.Modules.OrgGetter, s.signoz.Authz)
+
+	r.Use(middleware.NewRecovery(s.signoz.Instrumentation.Logger()).Wrap)
+	r.Use(otelmux.Middleware(
+		"apiserver",
+		otelmux.WithMeterProvider(s.signoz.Instrumentation.MeterProvider()),
+		otelmux.WithTracerProvider(s.signoz.Instrumentation.TracerProvider()),
+		otelmux.WithPropagators(propagation.NewCompositeTextMapPropagator(propagation.Baggage{}, propagation.TraceContext{})),
+		otelmux.WithFilter(func(r *http.Request) bool {
+			return !slices.Contains([]string{"/api/v1/health"}, r.URL.Path)
+		}),
+	))
+	r.Use(middleware.NewIdentN(s.signoz.IdentNResolver, s.signoz.Sharder, s.signoz.Instrumentation.Logger()).Wrap)
+	r.Use(middleware.NewTimeout(s.signoz.Instrumentation.Logger(),
+		s.config.APIServer.Timeout.ExcludedRoutes,
+		s.config.APIServer.Timeout.Default,
+		s.config.APIServer.Timeout.Max,
+	).Wrap)
+	r.Use(middleware.NewResource(s.signoz.Instrumentation.Logger()).Wrap)
+	r.Use(middleware.NewAudit(s.signoz.Instrumentation.Logger(), s.config.APIServer.Logging.ExcludedRoutes, s.signoz.Auditor).Wrap)
+	r.Use(middleware.NewComment().Wrap)
 
 	apiHandler.RegisterRoutes(r, am)
 	apiHandler.RegisterLogsRoutes(r, am)
@@ -115,29 +188,107 @@ func NewServer(config signoz.Config, signoz *signoz.SigNoz) (*Server, error) {
 	apiHandler.RegisterThirdPartyApiRoutes(r, am)
 	apiHandler.RegisterTraceFunnelsRoutes(r, am)
 
-	s := &Server{
-		usageManager: usageManager,
+	err := s.signoz.APIServer.AddToRouter(r)
+	if err != nil {
+		return nil, err
 	}
 
-	s.opampServer = opamp.InitializeServer(
-		&opAmpModel.AllAgents, agentConfMgr, signoz.Instrumentation,
-	)
+	c := cors.New(cors.Options{
+		AllowedOrigins: []string{"*"},
+		AllowedMethods: []string{"GET", "DELETE", "POST", "PUT", "PATCH", "OPTIONS"},
+		AllowedHeaders: []string{"Accept", "Authorization", "Content-Type", "cache-control"},
+	})
 
-	return s, nil
+	handler := c.Handler(r)
+
+	handler = handlers.CompressHandler(handler)
+
+	err = web.AddToRouter(r)
+	if err != nil {
+		return nil, err
+	}
+
+	routePrefix := s.config.Global.ExternalPath()
+	if routePrefix != "" {
+		prefixed := http.StripPrefix(routePrefix, handler)
+		handler = http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
+			switch req.URL.Path {
+			case "/api/v1/health", "/api/v2/healthz", "/api/v2/readyz", "/api/v2/livez":
+				r.ServeHTTP(w, req)
+				return
+			}
+
+			prefixed.ServeHTTP(w, req)
+		})
+	}
+
+	return &http.Server{
+		Handler: handler,
+	}, nil
 }
 
-// Start starts the opamp websocket server. The HTTP API server is started by
-// the signoz registry.
-func (s *Server) Start(ctx context.Context) error {
-	slog.Info("Starting OpAmp Websocket server", "addr", baseconst.OpAmpWsEndpoint)
-	if err := s.opampServer.Start(baseconst.OpAmpWsEndpoint); err != nil {
+// initListeners initialises listeners of the server
+func (s *Server) initListeners() error {
+	// listen on public port
+	var err error
+	publicHostPort := s.httpHostPort
+	if publicHostPort == "" {
+		return fmt.Errorf("baseconst.HTTPHostPort is required")
+	}
+
+	s.httpConn, err = net.Listen("tcp", publicHostPort)
+	if err != nil {
 		return err
 	}
 
+	slog.Info(fmt.Sprintf("Query server started listening on %s...", s.httpHostPort))
+
+	return nil
+}
+
+// Start listening on http and private http port concurrently
+func (s *Server) Start(ctx context.Context) error {
+	err := s.initListeners()
+	if err != nil {
+		return err
+	}
+
+	var httpPort int
+	if port, err := utils.GetPort(s.httpConn.Addr()); err == nil {
+		httpPort = port
+	}
+
+	go func() {
+		slog.Info("Starting HTTP server", "port", httpPort, "addr", s.httpHostPort)
+
+		switch err := s.httpServer.Serve(s.httpConn); err {
+		case nil, http.ErrServerClosed, cmux.ErrListenerClosed:
+			// normal exit, nothing to do
+		default:
+			slog.Error("Could not start HTTP server", errors.Attr(err))
+		}
+		s.unavailableChannel <- healthcheck.Unavailable
+	}()
+
+	go func() {
+		slog.Info("Starting OpAmp Websocket server", "addr", baseconst.OpAmpWsEndpoint)
+		err := s.opampServer.Start(baseconst.OpAmpWsEndpoint)
+		if err != nil {
+			slog.Error("opamp ws server failed to start", errors.Attr(err))
+			s.unavailableChannel <- healthcheck.Unavailable
+		}
+	}()
+
 	return nil
 }
 
 func (s *Server) Stop(ctx context.Context) error {
+	if s.httpServer != nil {
+		if err := s.httpServer.Shutdown(ctx); err != nil {
+			return err
+		}
+	}
+
 	s.opampServer.Stop()
 
 	// stop usage manager

frontend/src/components/QuickFilters/FilterRenderers/Checkbox/Checkbox.test.tsx

@@ -143,7 +143,7 @@ describe('CheckboxFilter - User Flows', () => {
 		render(
 			<CheckboxFilter
 				filter={mockFilter}
-				pageSource={QuickFiltersSource.LOGS_EXPLORER}
+				source={QuickFiltersSource.LOGS_EXPLORER}
 			/>,
 		);
 
@@ -178,7 +178,7 @@ describe('CheckboxFilter - User Flows', () => {
 		render(
 			<CheckboxFilter
 				filter={mockFilter}
-				pageSource={QuickFiltersSource.LOGS_EXPLORER}
+				source={QuickFiltersSource.LOGS_EXPLORER}
 			/>,
 		);
 
@@ -218,7 +218,7 @@ describe('CheckboxFilter - User Flows', () => {
 		render(
 			<CheckboxFilter
 				filter={mockFilter}
-				pageSource={QuickFiltersSource.LOGS_EXPLORER}
+				source={QuickFiltersSource.LOGS_EXPLORER}
 			/>,
 		);
 
@@ -281,7 +281,7 @@ describe('CheckboxFilter - User Flows', () => {
 		render(
 			<CheckboxFilter
 				filter={mockFilter}
-				pageSource={QuickFiltersSource.LOGS_EXPLORER}
+				source={QuickFiltersSource.LOGS_EXPLORER}
 			/>,
 		);
 
@@ -339,7 +339,7 @@ describe('CheckboxFilter - User Flows', () => {
 		render(
 			<CheckboxFilter
 				filter={mockFilter}
-				pageSource={QuickFiltersSource.LOGS_EXPLORER}
+				source={QuickFiltersSource.LOGS_EXPLORER}
 			/>,
 		);
 
@@ -397,7 +397,7 @@ describe('CheckboxFilter - User Flows', () => {
 		render(
 			<CheckboxFilter
 				filter={mockFilter}
-				pageSource={QuickFiltersSource.LOGS_EXPLORER}
+				source={QuickFiltersSource.LOGS_EXPLORER}
 			/>,
 		);
 
@@ -449,7 +449,7 @@ describe('CheckboxFilter - User Flows', () => {
 		render(
 			<CheckboxFilter
 				filter={mockFilter}
-				pageSource={QuickFiltersSource.LOGS_EXPLORER}
+				source={QuickFiltersSource.LOGS_EXPLORER}
 			/>,
 		);
 

frontend/src/components/QuickFilters/FilterRenderers/Checkbox/Checkbox.tsx

@@ -27,17 +27,17 @@ const SOURCES_WITH_EMPTY_STATE_ENABLED = [QuickFiltersSource.LOGS_EXPLORER];
 
 interface ICheckboxProps {
 	filter: IQuickFiltersConfig;
-	pageSource: QuickFiltersSource;
+	source: QuickFiltersSource;
 	onFilterChange?: (query: Query) => void;
 	onQuickFilterChange?: (data: QuickFilterChangeEventData) => void;
 }
 
 // eslint-disable-next-line sonarjs/cognitive-complexity
 export default function CheckboxFilter(props: ICheckboxProps): JSX.Element {
-	const { pageSource, filter, onFilterChange, onQuickFilterChange } = props;
+	const { source, filter, onFilterChange, onQuickFilterChange } = props;
 	const [searchText, setSearchText] = useState<string>('');
 
-	const activeQueryIndex = useActiveQueryIndex(pageSource);
+	const activeQueryIndex = useActiveQueryIndex(source);
 
 	const {
 		isOpen,
@@ -49,7 +49,7 @@ export default function CheckboxFilter(props: ICheckboxProps): JSX.Element {
 
 	const { attributeValues, isLoading } = useCheckboxFilterValues({
 		filter,
-		pageSource,
+		source,
 		searchText,
 		isOpen,
 	});
@@ -59,7 +59,7 @@ export default function CheckboxFilter(props: ICheckboxProps): JSX.Element {
 
 	const { onChange, onClear } = useCheckboxFilterActions({
 		filter,
-		pageSource,
+		source,
 		attributeValues,
 		activeQueryIndex,
 		onFilterChange,
@@ -88,7 +88,7 @@ export default function CheckboxFilter(props: ICheckboxProps): JSX.Element {
 	);
 
 	const isEmptyStateWithDocsEnabled =
-		SOURCES_WITH_EMPTY_STATE_ENABLED.includes(pageSource) &&
+		SOURCES_WITH_EMPTY_STATE_ENABLED.includes(source) &&
 		!searchText &&
 		!attributeValues.length;
 

frontend/src/components/QuickFilters/FilterRenderers/Checkbox/checkboxFilterQuery.test.ts

@@ -97,7 +97,7 @@ interface ToggleAction {
 	isOnlyOrAllClicked?: boolean;
 	previousState?: CheckedState;
 	sectionType?: SectionType;
-	pageSource?: QuickFiltersSource;
+	source?: QuickFiltersSource;
 	attributeValues?: string[];
 }
 
@@ -117,7 +117,7 @@ function runToggle(c: ToggleCase): { items: SimpleItem[]; expression: string } {
 		currentQuery: buildQuery(initialItems, initialExpression),
 		activeQueryIndex: 0,
 		filter: { attributeKey: { key: KEY, type: 'tag' } } as never,
-		pageSource: c.action.pageSource ?? QuickFiltersSource.LOGS_EXPLORER,
+		source: c.action.source ?? QuickFiltersSource.LOGS_EXPLORER,
 		attributeValues: c.action.attributeValues ?? ['a', 'b', 'c'],
 		value: c.action.value,
 		checked: c.action.checked,
@@ -162,7 +162,7 @@ const TOGGLE_CASES: ToggleCase[] = [
 		action: {
 			value: 'a',
 			checked: false,
-			pageSource: QuickFiltersSource.INFRA_MONITORING,
+			source: QuickFiltersSource.INFRA_MONITORING,
 		},
 		// `nin` is what the source asks for, but re-deriving the expression
 		// normalises it. Nothing observes the difference: both infra pages send
@@ -313,7 +313,7 @@ const TOGGLE_CASES: ToggleCase[] = [
 		action: {
 			value: 'b',
 			checked: false,
-			pageSource: QuickFiltersSource.INFRA_MONITORING,
+			source: QuickFiltersSource.INFRA_MONITORING,
 		},
 		expected: {
 			items: [{ key: KEY, op: 'not in', value: ['a', 'b'] }],

frontend/src/components/QuickFilters/FilterRenderers/Checkbox/checkboxFilterQuery.ts

@@ -47,8 +47,8 @@ const SOURCES_WITH_SHORT_OPERATORS = [QuickFiltersSource.INFRA_MONITORING];
  * Returns the correct NOT_IN operator value based on source.
  * InfraMonitoring backend expects 'nin', others expect 'not in'.
  */
-export function getNotInOperator(pageSource: QuickFiltersSource): string {
-	if (SOURCES_WITH_SHORT_OPERATORS.includes(pageSource)) {
+export function getNotInOperator(source: QuickFiltersSource): string {
+	if (SOURCES_WITH_SHORT_OPERATORS.includes(source)) {
 		return 'nin';
 	}
 	return getOperatorValue('NOT_IN');
@@ -172,7 +172,7 @@ export function applyCheckboxToggle({
 	currentQuery,
 	activeQueryIndex,
 	filter,
-	pageSource,
+	source,
 	attributeValues,
 	value,
 	checked,
@@ -183,7 +183,7 @@ export function applyCheckboxToggle({
 	currentQuery: Query;
 	activeQueryIndex: number;
 	filter: IQuickFiltersConfig;
-	pageSource: QuickFiltersSource;
+	source: QuickFiltersSource;
 	attributeValues: string[];
 	value: string;
 	checked: boolean;
@@ -278,7 +278,7 @@ export function applyCheckboxToggle({
 							if (sectionType === SectionType.RELATED) {
 								const newFilter: TagFilterItem = {
 									id: uuid(),
-									op: getNotInOperator(pageSource),
+									op: getNotInOperator(source),
 									key: filter.attributeKey,
 									value,
 								};
@@ -418,7 +418,7 @@ export function applyCheckboxToggle({
 						if (!checked) {
 							const newFilter = {
 								...currentFilter,
-								op: getNotInOperator(pageSource),
+								op: getNotInOperator(source),
 								value: [currentFilter.value as string, value],
 							};
 							query.filters.items = query.filters.items.map((item) => {
@@ -442,7 +442,7 @@ export function applyCheckboxToggle({
 			// checked=true → user wants to select (IN), checked=false → exclude (NOT IN)
 			const newFilterItem: TagFilterItem = {
 				id: uuid(),
-				op: checked ? getOperatorValue(OPERATORS.IN) : getNotInOperator(pageSource),
+				op: checked ? getOperatorValue(OPERATORS.IN) : getNotInOperator(source),
 				key: filter.attributeKey,
 				value,
 			};

frontend/src/components/QuickFilters/FilterRenderers/Checkbox/useActiveQueryIndex.ts

@@ -10,18 +10,18 @@ import { useQueryBuilder } from 'hooks/queryBuilder/useQueryBuilder';
  * In ListView most sources use index 0; TRACES_EXPLORER and every non-ListView
  * mode track the last focused query.
  */
-function useActiveQueryIndex(pageSource: QuickFiltersSource): number {
+function useActiveQueryIndex(source: QuickFiltersSource): number {
 	const { lastUsedQuery, panelType } = useQueryBuilder();
 	const isListView = panelType === PANEL_TYPES.LIST;
 
 	return useMemo(() => {
 		if (isListView) {
-			return pageSource === QuickFiltersSource.TRACES_EXPLORER
+			return source === QuickFiltersSource.TRACES_EXPLORER
 				? lastUsedQuery || 0
 				: 0;
 		}
 		return lastUsedQuery || 0;
-	}, [isListView, pageSource, lastUsedQuery]);
+	}, [isListView, source, lastUsedQuery]);
 }
 
 export default useActiveQueryIndex;

frontend/src/components/QuickFilters/FilterRenderers/Checkbox/useCheckboxFilterActions.ts

@@ -16,7 +16,7 @@ import { SectionType } from './v2/itemRules';
 
 interface UseCheckboxFilterActionsProps {
 	filter: IQuickFiltersConfig;
-	pageSource: QuickFiltersSource;
+	source: QuickFiltersSource;
 	attributeValues: string[];
 	activeQueryIndex: number;
 	onFilterChange?: ((query: Query) => void) | null;
@@ -40,7 +40,7 @@ interface UseCheckboxFilterActionsReturn {
  */
 function useCheckboxFilterActions({
 	filter,
-	pageSource,
+	source,
 	attributeValues,
 	activeQueryIndex,
 	onFilterChange,
@@ -67,7 +67,7 @@ function useCheckboxFilterActions({
 			currentQuery,
 			activeQueryIndex,
 			filter,
-			pageSource,
+			source,
 			attributeValues,
 			value,
 			checked,

frontend/src/components/QuickFilters/FilterRenderers/Checkbox/useCheckboxFilterValues.tsx

@@ -11,7 +11,7 @@ import { DataSource } from 'types/common/queryBuilder';
 
 interface UseCheckboxFilterValuesProps {
 	filter: IQuickFiltersConfig;
-	pageSource: QuickFiltersSource;
+	source: QuickFiltersSource;
 	searchText: string;
 	isOpen: boolean;
 }
@@ -23,7 +23,7 @@ interface UseCheckboxFilterValuesReturn {
 
 function useCheckboxFilterValues({
 	filter,
-	pageSource,
+	source,
 	searchText,
 	isOpen,
 }: UseCheckboxFilterValuesProps): UseCheckboxFilterValuesReturn {
@@ -38,7 +38,7 @@ function useCheckboxFilterValues({
 			searchText: searchText ?? '',
 		},
 		{
-			enabled: isOpen && pageSource !== QuickFiltersSource.METER_EXPLORER,
+			enabled: isOpen && source !== QuickFiltersSource.METER_EXPLORER,
 			keepPreviousData: true,
 		},
 	);
@@ -49,7 +49,7 @@ function useCheckboxFilterValues({
 			signal: filter.dataSource || DataSource.LOGS,
 			signalSource: 'meter',
 			options: {
-				enabled: isOpen && pageSource === QuickFiltersSource.METER_EXPLORER,
+				enabled: isOpen && source === QuickFiltersSource.METER_EXPLORER,
 				keepPreviousData: true,
 			},
 		});
@@ -57,7 +57,7 @@ function useCheckboxFilterValues({
 	const attributeValues: string[] = useMemo(() => {
 		const dataType = filter.attributeKey.dataType || DataTypes.String;
 
-		if (pageSource === QuickFiltersSource.METER_EXPLORER && keyValueSuggestions) {
+		if (source === QuickFiltersSource.METER_EXPLORER && keyValueSuggestions) {
 			// Process the response data
 			const responseData = keyValueSuggestions?.data as any;
 			const values = responseData.data?.values || {};
@@ -88,12 +88,7 @@ function useCheckboxFilterValues({
 		return (data?.payload?.[key] || []).filter(
 			(val) => val !== undefined && val !== null,
 		);
-	}, [
-		data?.payload,
-		filter.attributeKey.dataType,
-		keyValueSuggestions,
-		pageSource,
-	]);
+	}, [data?.payload, filter.attributeKey.dataType, keyValueSuggestions, source]);
 
 	return {
 		attributeValues,

frontend/src/components/QuickFilters/FilterRenderers/Checkbox/v2/CheckboxFilterV2.testUtils.tsx

@@ -1,5 +1,4 @@
 import { render, RenderResult } from 'tests/test-utils';
-import { TelemetrytypesSignalDTO } from 'api/generated/services/sigNoz.schemas';
 import { server, rest } from 'mocks-server/server';
 import { DataTypes } from 'types/api/queryBuilder/queryAutocompleteResponse';
 import { DataSource } from 'types/common/queryBuilder';
@@ -26,7 +25,6 @@ export const DEFAULT_FILTER: IQuickFiltersConfig = {
 };
 
 export const DEFAULT_USE_FIELD_APIS: QuickFilterCheckboxUseFieldApis = {
-	signal: TelemetrytypesSignalDTO.traces,
 	startUnixMilli: 1700000000000,
 	endUnixMilli: 1700003600000,
 	existingQuery: null,
@@ -36,7 +34,6 @@ export function mockFieldsValuesAPI(response: {
 	relatedValues?: (string | null)[];
 	stringValues?: (string | null)[];
 	numberValues?: (number | null)[];
-	boolValues?: (boolean | null)[];
 }): void {
 	server.use(
 		rest.get('http://localhost/api/v1/fields/values', (_, res, ctx) =>
@@ -49,7 +46,6 @@ export function mockFieldsValuesAPI(response: {
 							relatedValues: response.relatedValues ?? [],
 							stringValues: response.stringValues ?? [],
 							numberValues: response.numberValues ?? [],
-							boolValues: response.boolValues ?? [],
 						},
 					},
 				}),
@@ -72,13 +68,6 @@ export function setupServer(): void {
 	afterAll(() => server.close());
 }
 
-// Components read currentQuery for the checkbox state and stagedQuery for the
-// values fetch; in the app both are set by the same URL sync, so tests pass one
-// query as both.
-export function buildQueryBuilderOverrides(query: unknown): never {
-	return { currentQuery: query, stagedQuery: query } as unknown as never;
-}
-
 export interface FilterItemConfig {
 	op: string;
 	value: string | string[];
@@ -101,7 +90,7 @@ export function renderWithFilter(
 	return render(
 		<CheckboxFilterV2
 			filter={DEFAULT_FILTER}
-			pageSource={QuickFiltersSource.TRACES_EXPLORER}
+			source={QuickFiltersSource.TRACES_EXPLORER}
 			useFieldApis={{
 				...DEFAULT_USE_FIELD_APIS,
 				existingQuery: 'service.name = "api"',
@@ -110,16 +99,18 @@ export function renderWithFilter(
 		/>,
 		undefined,
 		{
-			queryBuilderOverrides: buildQueryBuilderOverrides({
-				builder: {
-					queryData: [
-						{
-							filters: { items, op: 'AND' },
-							filter: { expression: 'service.name = "api"' },
-						},
-					],
+			queryBuilderOverrides: {
+				currentQuery: {
+					builder: {
+						queryData: [
+							{
+								filters: { items, op: 'AND' },
+								filter: { expression: 'service.name = "api"' },
+							},
+						],
+					},
 				},
-			}),
+			} as never,
 		},
 	);
 }

frontend/src/components/QuickFilters/FilterRenderers/Checkbox/v2/CheckboxFilterV2.tsx

@@ -32,7 +32,7 @@ import styles from './CheckboxFilterV2.module.scss';
 
 interface CheckboxFilterV2Props {
 	filter: IQuickFiltersConfig;
-	pageSource: QuickFiltersSource;
+	source: QuickFiltersSource;
 	onFilterChange?: (query: Query) => void;
 	onQuickFilterChange?: (data: QuickFilterChangeEventData) => void;
 	useFieldApis: QuickFilterCheckboxUseFieldApis;
@@ -41,18 +41,13 @@ interface CheckboxFilterV2Props {
 export default function CheckboxFilterV2(
 	props: CheckboxFilterV2Props,
 ): JSX.Element {
-	const {
-		pageSource,
-		filter,
-		onFilterChange,
-		onQuickFilterChange,
-		useFieldApis,
-	} = props;
+	const { source, filter, onFilterChange, onQuickFilterChange, useFieldApis } =
+		props;
 	const [searchText, setSearchText] = useState<string>('');
 	const [userToggleState, setUserToggleState] = useState<boolean | null>(null);
 
 	const { currentQuery } = useQueryBuilder();
-	const activeQueryIndex = useActiveQueryIndex(pageSource);
+	const activeQueryIndex = useActiveQueryIndex(source);
 
 	const {
 		isOpen,
@@ -79,8 +74,6 @@ export default function CheckboxFilterV2(
 		searchText,
 		existingQuery,
 		metricNamespace: useFieldApis.metricNamespace,
-		signal: useFieldApis.signal,
-		source: useFieldApis.source,
 		startUnixMilli: useFieldApis.startUnixMilli,
 		endUnixMilli: useFieldApis.endUnixMilli,
 		enabled: isOpen,
@@ -109,7 +102,7 @@ export default function CheckboxFilterV2(
 
 	const { onChange, onClear } = useCheckboxFilterActions({
 		filter,
-		pageSource,
+		source,
 		attributeValues,
 		activeQueryIndex,
 		onFilterChange,
@@ -160,7 +153,6 @@ export default function CheckboxFilterV2(
 		isSomeFilterPresentForCurrentAttribute,
 		isNotInOperator,
 		hasExistingQuery,
-		isRelatedValuesSupported: useFieldApis.existingQuery !== null,
 		visibleItemsCount,
 		relatedExclusions,
 	});

frontend/src/components/QuickFilters/FilterRenderers/Checkbox/v2/__tests__/CheckboxFilterV2.existingQuery.test.tsx

@@ -6,7 +6,6 @@ import { QuickFiltersSource } from '../../../../types';
 
 import CheckboxFilterV2 from '../CheckboxFilterV2';
 import {
-	buildQueryBuilderOverrides,
 	DEFAULT_FILTER,
 	DEFAULT_USE_FIELD_APIS,
 	setupServer,
@@ -50,7 +49,7 @@ describe('CheckboxFilterV2 - existingQuery calculation', () => {
 			render(
 				<CheckboxFilterV2
 					filter={DEFAULT_FILTER}
-					pageSource={QuickFiltersSource.TRACES_EXPLORER}
+					source={QuickFiltersSource.TRACES_EXPLORER}
 					useFieldApis={{
 						...DEFAULT_USE_FIELD_APIS,
 						existingQuery: 'custom.query = "value"',
@@ -58,16 +57,18 @@ describe('CheckboxFilterV2 - existingQuery calculation', () => {
 				/>,
 				undefined,
 				{
-					queryBuilderOverrides: buildQueryBuilderOverrides({
-						builder: {
-							queryData: [
-								{
-									filters: { items: [], op: 'AND' },
-									filter: { expression: 'should.be.ignored = "yes"' },
-								},
-							],
+					queryBuilderOverrides: {
+						currentQuery: {
+							builder: {
+								queryData: [
+									{
+										filters: { items: [], op: 'AND' },
+										filter: { expression: 'should.be.ignored = "yes"' },
+									},
+								],
+							},
 						},
-					}),
+					} as never,
 				},
 			);
 
@@ -82,7 +83,7 @@ describe('CheckboxFilterV2 - existingQuery calculation', () => {
 			render(
 				<CheckboxFilterV2
 					filter={DEFAULT_FILTER}
-					pageSource={QuickFiltersSource.TRACES_EXPLORER}
+					source={QuickFiltersSource.TRACES_EXPLORER}
 					useFieldApis={{
 						...DEFAULT_USE_FIELD_APIS,
 						existingQuery: null,
@@ -90,16 +91,18 @@ describe('CheckboxFilterV2 - existingQuery calculation', () => {
 				/>,
 				undefined,
 				{
-					queryBuilderOverrides: buildQueryBuilderOverrides({
-						builder: {
-							queryData: [
-								{
-									filters: { items: [], op: 'AND' },
-									filter: { expression: 'should.be.ignored = "yes"' },
-								},
-							],
+					queryBuilderOverrides: {
+						currentQuery: {
+							builder: {
+								queryData: [
+									{
+										filters: { items: [], op: 'AND' },
+										filter: { expression: 'should.be.ignored = "yes"' },
+									},
+								],
+							},
 						},
-					}),
+					} as never,
 				},
 			);
 
@@ -116,30 +119,32 @@ describe('CheckboxFilterV2 - existingQuery calculation', () => {
 			render(
 				<CheckboxFilterV2
 					filter={DEFAULT_FILTER}
-					pageSource={QuickFiltersSource.TRACES_EXPLORER}
+					source={QuickFiltersSource.TRACES_EXPLORER}
 					useFieldApis={USE_FIELD_APIS_AUTO_DERIVE}
 				/>,
 				undefined,
 				{
-					queryBuilderOverrides: buildQueryBuilderOverrides({
-						builder: {
-							queryData: [
-								{
-									filters: {
-										items: [
-											{
-												key: { key: 'service.name', dataType: 'string', type: 'tag' },
-												op: '=',
-												value: 'from-v3-items',
-											},
-										],
-										op: 'AND',
+					queryBuilderOverrides: {
+						currentQuery: {
+							builder: {
+								queryData: [
+									{
+										filters: {
+											items: [
+												{
+													key: { key: 'service.name', dataType: 'string', type: 'tag' },
+													op: '=',
+													value: 'from-v3-items',
+												},
+											],
+											op: 'AND',
+										},
+										filter: { expression: 'v5.expression = "preferred"' },
 									},
-									filter: { expression: 'v5.expression = "preferred"' },
-								},
-							],
+								],
+							},
 						},
-					}),
+					} as never,
 				},
 			);
 
@@ -154,21 +159,23 @@ describe('CheckboxFilterV2 - existingQuery calculation', () => {
 			render(
 				<CheckboxFilterV2
 					filter={DEFAULT_FILTER}
-					pageSource={QuickFiltersSource.TRACES_EXPLORER}
+					source={QuickFiltersSource.TRACES_EXPLORER}
 					useFieldApis={USE_FIELD_APIS_AUTO_DERIVE}
 				/>,
 				undefined,
 				{
-					queryBuilderOverrides: buildQueryBuilderOverrides({
-						builder: {
-							queryData: [
-								{
-									filters: { items: [], op: 'AND' },
-									filter: { expression: 'only.v5 = "expression"' },
-								},
-							],
+					queryBuilderOverrides: {
+						currentQuery: {
+							builder: {
+								queryData: [
+									{
+										filters: { items: [], op: 'AND' },
+										filter: { expression: 'only.v5 = "expression"' },
+									},
+								],
+							},
 						},
-					}),
+					} as never,
 				},
 			);
 
@@ -185,29 +192,31 @@ describe('CheckboxFilterV2 - existingQuery calculation', () => {
 			render(
 				<CheckboxFilterV2
 					filter={DEFAULT_FILTER}
-					pageSource={QuickFiltersSource.TRACES_EXPLORER}
+					source={QuickFiltersSource.TRACES_EXPLORER}
 					useFieldApis={USE_FIELD_APIS_AUTO_DERIVE}
 				/>,
 				undefined,
 				{
-					queryBuilderOverrides: buildQueryBuilderOverrides({
-						builder: {
-							queryData: [
-								{
-									filters: {
-										items: [
-											{
-												key: { key: 'service.name', dataType: 'string', type: 'tag' },
-												op: '=',
-												value: 'api-service',
-											},
-										],
-										op: 'AND',
+					queryBuilderOverrides: {
+						currentQuery: {
+							builder: {
+								queryData: [
+									{
+										filters: {
+											items: [
+												{
+													key: { key: 'service.name', dataType: 'string', type: 'tag' },
+													op: '=',
+													value: 'api-service',
+												},
+											],
+											op: 'AND',
+										},
 									},
-								},
-							],
+								],
+							},
 						},
-					}),
+					} as never,
 				},
 			);
 
@@ -222,34 +231,36 @@ describe('CheckboxFilterV2 - existingQuery calculation', () => {
 			render(
 				<CheckboxFilterV2
 					filter={DEFAULT_FILTER}
-					pageSource={QuickFiltersSource.TRACES_EXPLORER}
+					source={QuickFiltersSource.TRACES_EXPLORER}
 					useFieldApis={USE_FIELD_APIS_AUTO_DERIVE}
 				/>,
 				undefined,
 				{
-					queryBuilderOverrides: buildQueryBuilderOverrides({
-						builder: {
-							queryData: [
-								{
-									filters: {
-										items: [
-											{
-												key: { key: 'service.name', dataType: 'string', type: 'tag' },
-												op: '=',
-												value: 'api',
-											},
-											{
-												key: { key: 'env', dataType: 'string', type: 'tag' },
-												op: '=',
-												value: 'prod',
-											},
-										],
-										op: 'AND',
+					queryBuilderOverrides: {
+						currentQuery: {
+							builder: {
+								queryData: [
+									{
+										filters: {
+											items: [
+												{
+													key: { key: 'service.name', dataType: 'string', type: 'tag' },
+													op: '=',
+													value: 'api',
+												},
+												{
+													key: { key: 'env', dataType: 'string', type: 'tag' },
+													op: '=',
+													value: 'prod',
+												},
+											],
+											op: 'AND',
+										},
 									},
-								},
-							],
+								],
+							},
 						},
-					}),
+					} as never,
 				},
 			);
 
@@ -264,20 +275,22 @@ describe('CheckboxFilterV2 - existingQuery calculation', () => {
 			render(
 				<CheckboxFilterV2
 					filter={DEFAULT_FILTER}
-					pageSource={QuickFiltersSource.TRACES_EXPLORER}
+					source={QuickFiltersSource.TRACES_EXPLORER}
 					useFieldApis={USE_FIELD_APIS_AUTO_DERIVE}
 				/>,
 				undefined,
 				{
-					queryBuilderOverrides: buildQueryBuilderOverrides({
-						builder: {
-							queryData: [
-								{
-									filters: { items: [], op: 'AND' },
-								},
-							],
+					queryBuilderOverrides: {
+						currentQuery: {
+							builder: {
+								queryData: [
+									{
+										filters: { items: [], op: 'AND' },
+									},
+								],
+							},
 						},
-					}),
+					} as never,
 				},
 			);
 

frontend/src/components/QuickFilters/FilterRenderers/Checkbox/v2/__tests__/CheckboxFilterV2.interactions.test.tsx

@@ -7,7 +7,6 @@ import { QuickFiltersSource } from '../../../../types';
 
 import CheckboxFilterV2 from '../CheckboxFilterV2';
 import {
-	buildQueryBuilderOverrides,
 	DEFAULT_FILTER,
 	DEFAULT_USE_FIELD_APIS,
 	getFilterFromCall,
@@ -52,7 +51,7 @@ describe('CheckboxFilterV2 - interactions', () => {
 			render(
 				<CheckboxFilterV2
 					filter={DEFAULT_FILTER}
-					pageSource={QuickFiltersSource.TRACES_EXPLORER}
+					source={QuickFiltersSource.TRACES_EXPLORER}
 					useFieldApis={DEFAULT_USE_FIELD_APIS}
 				/>,
 			);
@@ -118,7 +117,7 @@ describe('CheckboxFilterV2 - interactions', () => {
 			render(
 				<CheckboxFilterV2
 					filter={DEFAULT_FILTER}
-					pageSource={QuickFiltersSource.TRACES_EXPLORER}
+					source={QuickFiltersSource.TRACES_EXPLORER}
 					useFieldApis={{
 						...DEFAULT_USE_FIELD_APIS,
 						existingQuery: 'service.name = "api"',
@@ -126,16 +125,18 @@ describe('CheckboxFilterV2 - interactions', () => {
 				/>,
 				undefined,
 				{
-					queryBuilderOverrides: buildQueryBuilderOverrides({
-						builder: {
-							queryData: [
-								{
-									filters: { items: [], op: 'AND' },
-									filter: { expression: 'service.name = "api"' },
-								},
-							],
+					queryBuilderOverrides: {
+						currentQuery: {
+							builder: {
+								queryData: [
+									{
+										filters: { items: [], op: 'AND' },
+										filter: { expression: 'service.name = "api"' },
+									},
+								],
+							},
 						},
-					}),
+					} as never,
 				},
 			);
 
@@ -182,7 +183,7 @@ describe('CheckboxFilterV2 - interactions', () => {
 			render(
 				<CheckboxFilterV2
 					filter={DEFAULT_FILTER}
-					pageSource={QuickFiltersSource.TRACES_EXPLORER}
+					source={QuickFiltersSource.TRACES_EXPLORER}
 					useFieldApis={{
 						...DEFAULT_USE_FIELD_APIS,
 						existingQuery: 'service.name = "api"',
@@ -229,7 +230,7 @@ describe('CheckboxFilterV2 - interactions', () => {
 			render(
 				<CheckboxFilterV2
 					filter={DEFAULT_FILTER}
-					pageSource={QuickFiltersSource.TRACES_EXPLORER}
+					source={QuickFiltersSource.TRACES_EXPLORER}
 					useFieldApis={DEFAULT_USE_FIELD_APIS}
 				/>,
 			);
@@ -271,7 +272,7 @@ describe('CheckboxFilterV2 - interactions', () => {
 			render(
 				<CheckboxFilterV2
 					filter={DEFAULT_FILTER}
-					pageSource={QuickFiltersSource.TRACES_EXPLORER}
+					source={QuickFiltersSource.TRACES_EXPLORER}
 					useFieldApis={{
 						...DEFAULT_USE_FIELD_APIS,
 						existingQuery: 'service.name = "api"',
@@ -333,7 +334,7 @@ describe('CheckboxFilterV2 - interactions', () => {
 			render(
 				<CheckboxFilterV2
 					filter={DEFAULT_FILTER}
-					pageSource={QuickFiltersSource.TRACES_EXPLORER}
+					source={QuickFiltersSource.TRACES_EXPLORER}
 					useFieldApis={{
 						...DEFAULT_USE_FIELD_APIS,
 						existingQuery: 'service.name = "api"',
@@ -379,7 +380,7 @@ describe('CheckboxFilterV2 - interactions', () => {
 			render(
 				<CheckboxFilterV2
 					filter={DEFAULT_FILTER}
-					pageSource={QuickFiltersSource.TRACES_EXPLORER}
+					source={QuickFiltersSource.TRACES_EXPLORER}
 					useFieldApis={DEFAULT_USE_FIELD_APIS}
 				/>,
 			);
@@ -407,7 +408,7 @@ describe('CheckboxFilterV2 - interactions', () => {
 			render(
 				<CheckboxFilterV2
 					filter={{ ...DEFAULT_FILTER, defaultOpen: false }}
-					pageSource={QuickFiltersSource.TRACES_EXPLORER}
+					source={QuickFiltersSource.TRACES_EXPLORER}
 					useFieldApis={DEFAULT_USE_FIELD_APIS}
 				/>,
 			);
@@ -433,7 +434,7 @@ describe('CheckboxFilterV2 - interactions', () => {
 			render(
 				<CheckboxFilterV2
 					filter={DEFAULT_FILTER}
-					pageSource={QuickFiltersSource.TRACES_EXPLORER}
+					source={QuickFiltersSource.TRACES_EXPLORER}
 					useFieldApis={DEFAULT_USE_FIELD_APIS}
 				/>,
 			);
@@ -459,7 +460,7 @@ describe('CheckboxFilterV2 - interactions', () => {
 			render(
 				<CheckboxFilterV2
 					filter={DEFAULT_FILTER}
-					pageSource={QuickFiltersSource.TRACES_EXPLORER}
+					source={QuickFiltersSource.TRACES_EXPLORER}
 					useFieldApis={DEFAULT_USE_FIELD_APIS}
 				/>,
 			);
@@ -484,29 +485,31 @@ describe('CheckboxFilterV2 - interactions', () => {
 			render(
 				<CheckboxFilterV2
 					filter={DEFAULT_FILTER}
-					pageSource={QuickFiltersSource.TRACES_EXPLORER}
+					source={QuickFiltersSource.TRACES_EXPLORER}
 					useFieldApis={DEFAULT_USE_FIELD_APIS}
 				/>,
 				undefined,
 				{
-					queryBuilderOverrides: buildQueryBuilderOverrides({
-						builder: {
-							queryData: [
-								{
-									filters: {
-										items: [
-											{
-												key: { key: 'deployment.environment' },
-												op: 'in',
-												value: ['production'],
-											},
-										],
-										op: 'AND',
+					queryBuilderOverrides: {
+						currentQuery: {
+							builder: {
+								queryData: [
+									{
+										filters: {
+											items: [
+												{
+													key: { key: 'deployment.environment' },
+													op: 'in',
+													value: ['production'],
+												},
+											],
+											op: 'AND',
+										},
 									},
-								},
-							],
+								],
+							},
 						},
-					}),
+					} as never,
 				},
 			);
 
@@ -523,7 +526,7 @@ describe('CheckboxFilterV2 - interactions', () => {
 			render(
 				<CheckboxFilterV2
 					filter={DEFAULT_FILTER}
-					pageSource={QuickFiltersSource.TRACES_EXPLORER}
+					source={QuickFiltersSource.TRACES_EXPLORER}
 					useFieldApis={DEFAULT_USE_FIELD_APIS}
 				/>,
 			);
@@ -546,30 +549,32 @@ describe('CheckboxFilterV2 - interactions', () => {
 			render(
 				<CheckboxFilterV2
 					filter={DEFAULT_FILTER}
-					pageSource={QuickFiltersSource.TRACES_EXPLORER}
+					source={QuickFiltersSource.TRACES_EXPLORER}
 					useFieldApis={DEFAULT_USE_FIELD_APIS}
 					onFilterChange={onFilterChange}
 				/>,
 				undefined,
 				{
-					queryBuilderOverrides: buildQueryBuilderOverrides({
-						builder: {
-							queryData: [
-								{
-									filters: {
-										items: [
-											{
-												key: { key: 'deployment.environment' },
-												op: 'in',
-												value: ['production'],
-											},
-										],
-										op: 'AND',
+					queryBuilderOverrides: {
+						currentQuery: {
+							builder: {
+								queryData: [
+									{
+										filters: {
+											items: [
+												{
+													key: { key: 'deployment.environment' },
+													op: 'in',
+													value: ['production'],
+												},
+											],
+											op: 'AND',
+										},
 									},
-								},
-							],
+								],
+							},
 						},
-					}),
+					} as never,
 				},
 			);
 
@@ -593,7 +598,7 @@ describe('CheckboxFilterV2 - interactions', () => {
 			render(
 				<CheckboxFilterV2
 					filter={DEFAULT_FILTER}
-					pageSource={QuickFiltersSource.TRACES_EXPLORER}
+					source={QuickFiltersSource.TRACES_EXPLORER}
 					useFieldApis={DEFAULT_USE_FIELD_APIS}
 					onFilterChange={onFilterChange}
 				/>,
@@ -632,7 +637,7 @@ describe('CheckboxFilterV2 - interactions', () => {
 			expect(filter?.value).toBe('valueA');
 		});
 
-		it('adds to NOT IN when unchecking a non-excluded (other) item', async () => {
+		it('converts NOT IN to IN when toggling unchecked (other) item', async () => {
 			const user = userEvent.setup();
 			const onFilterChange = jest.fn();
 
@@ -641,70 +646,18 @@ describe('CheckboxFilterV2 - interactions', () => {
 				stringValues: ['valueB'],
 			});
 
-			// valueB is not excluded, so under NOT IN [valueA] it is still included
-			// and renders checked. Unchecking it excludes it too → NOT IN [A, B].
+			// Clicking unchecked "Other" item with NOT IN filter should convert to IN [B]
 			renderWithFilter(onFilterChange, { op: 'not in', value: ['valueA'] });
 
 			const rowB = await screen.findByTestId('checkbox-value-row-valueB');
-			expect(rowB).toHaveAttribute('data-state', 'checked');
+			expect(rowB).toHaveAttribute('data-state', 'unchecked');
 
 			await user.click(within(rowB).getByRole('checkbox'));
 
 			expect(onFilterChange).toHaveBeenCalledTimes(1);
 			const filter = getFilterFromCall(onFilterChange);
-			expect(filter?.op).toBe('not in');
-			expect(filter?.value).toStrictEqual(['valueA', 'valueB']);
-		});
-
-		it('adds to NOT IN when unchecking a non-excluded item without related values', async () => {
-			const user = userEvent.setup();
-			const onFilterChange = jest.fn();
-
-			mockFieldsValuesAPI({
-				stringValues: ['valueA', 'valueB'],
-			});
-
-			// Without related values the display follows the clause: valueB is not
-			// excluded, so it renders checked; unchecking it excludes it too.
-			render(
-				<CheckboxFilterV2
-					filter={DEFAULT_FILTER}
-					pageSource={QuickFiltersSource.TRACES_EXPLORER}
-					useFieldApis={DEFAULT_USE_FIELD_APIS}
-					onFilterChange={onFilterChange}
-				/>,
-				undefined,
-				{
-					queryBuilderOverrides: buildQueryBuilderOverrides({
-						builder: {
-							queryData: [
-								{
-									filters: {
-										items: [
-											{
-												key: { key: 'deployment.environment' },
-												op: 'not in',
-												value: ['valueA'],
-											},
-										],
-										op: 'AND',
-									},
-								},
-							],
-						},
-					}),
-				},
-			);
-
-			const rowB = await screen.findByTestId('checkbox-value-row-valueB');
-			expect(rowB).toHaveAttribute('data-state', 'checked');
-
-			await user.click(within(rowB).getByRole('checkbox'));
-
-			expect(onFilterChange).toHaveBeenCalledTimes(1);
-			const filter = getFilterFromCall(onFilterChange);
-			expect(filter?.op).toBe('not in');
-			expect(filter?.value).toStrictEqual(['valueA', 'valueB']);
+			expect(filter?.op).toBe('in');
+			expect(filter?.value).toBe('valueB');
 		});
 
 		it('accumulates both values in IN when toggling checked (related) then unchecked (other)', async () => {
@@ -803,7 +756,7 @@ describe('CheckboxFilterV2 - interactions', () => {
 			render(
 				<CheckboxFilterV2
 					filter={{ ...DEFAULT_FILTER, customRendererForValue: customRenderer }}
-					pageSource={QuickFiltersSource.TRACES_EXPLORER}
+					source={QuickFiltersSource.TRACES_EXPLORER}
 					useFieldApis={DEFAULT_USE_FIELD_APIS}
 				/>,
 			);

frontend/src/components/QuickFilters/FilterRenderers/Checkbox/v2/__tests__/CheckboxFilterV2.itemRules.test.tsx

@@ -5,7 +5,6 @@ import { QuickFiltersSource } from '../../../../types';
 
 import CheckboxFilterV2 from '../CheckboxFilterV2';
 import {
-	buildQueryBuilderOverrides,
 	DEFAULT_FILTER,
 	DEFAULT_USE_FIELD_APIS,
 	mockFieldsValuesAPI,
@@ -15,88 +14,6 @@ import {
 setupServer();
 
 describe('CheckboxFilterV2 - item rules', () => {
-	describe('related values unsupported (existingQuery: null)', () => {
-		it('renders a single flat section even when the api returns related values', async () => {
-			mockFieldsValuesAPI({
-				relatedValues: ['production'],
-				stringValues: ['staging'],
-			});
-
-			render(
-				<CheckboxFilterV2
-					filter={DEFAULT_FILTER}
-					pageSource={QuickFiltersSource.TRACES_EXPLORER}
-					useFieldApis={DEFAULT_USE_FIELD_APIS}
-				/>,
-			);
-
-			const productionRow = await screen.findByTestId(
-				'checkbox-value-row-production',
-			);
-			expect(productionRow).toHaveAttribute('data-state', 'checked');
-			expect(screen.getByTestId('checkbox-value-row-staging')).toHaveAttribute(
-				'data-state',
-				'checked',
-			);
-
-			expect(
-				screen.queryByTestId('section-divider-related'),
-			).not.toBeInTheDocument();
-			expect(
-				screen.queryByTestId('section-divider-all-values'),
-			).not.toBeInTheDocument();
-		});
-
-		it('splits clause values and the rest into selected and all values sections', async () => {
-			mockFieldsValuesAPI({
-				stringValues: ['production', 'staging'],
-			});
-
-			render(
-				<CheckboxFilterV2
-					filter={DEFAULT_FILTER}
-					pageSource={QuickFiltersSource.TRACES_EXPLORER}
-					useFieldApis={DEFAULT_USE_FIELD_APIS}
-				/>,
-				undefined,
-				{
-					queryBuilderOverrides: buildQueryBuilderOverrides({
-						builder: {
-							queryData: [
-								{
-									filters: {
-										items: [
-											{
-												key: { key: 'deployment.environment' },
-												op: 'in',
-												value: ['production'],
-											},
-										],
-										op: 'AND',
-									},
-								},
-							],
-						},
-					}),
-				},
-			);
-
-			const productionRow = await screen.findByTestId(
-				'checkbox-value-row-production',
-			);
-			expect(productionRow).toHaveAttribute('data-state', 'checked');
-			expect(screen.getByTestId('checkbox-value-row-staging')).toHaveAttribute(
-				'data-state',
-				'unchecked',
-			);
-
-			expect(screen.getByTestId('section-divider-all-values')).toBeInTheDocument();
-			expect(
-				screen.queryByTestId('section-divider-related'),
-			).not.toBeInTheDocument();
-		});
-	});
-
 	describe('no existing query', () => {
 		it('all values show as checked with no badge when no query exists', async () => {
 			mockFieldsValuesAPI({
@@ -106,7 +23,7 @@ describe('CheckboxFilterV2 - item rules', () => {
 			render(
 				<CheckboxFilterV2
 					filter={DEFAULT_FILTER}
-					pageSource={QuickFiltersSource.TRACES_EXPLORER}
+					source={QuickFiltersSource.TRACES_EXPLORER}
 					useFieldApis={DEFAULT_USE_FIELD_APIS}
 				/>,
 			);
@@ -140,7 +57,7 @@ describe('CheckboxFilterV2 - item rules', () => {
 			render(
 				<CheckboxFilterV2
 					filter={DEFAULT_FILTER}
-					pageSource={QuickFiltersSource.TRACES_EXPLORER}
+					source={QuickFiltersSource.TRACES_EXPLORER}
 					useFieldApis={{
 						...DEFAULT_USE_FIELD_APIS,
 						existingQuery: 'service.name = "api"',
@@ -148,16 +65,18 @@ describe('CheckboxFilterV2 - item rules', () => {
 				/>,
 				undefined,
 				{
-					queryBuilderOverrides: buildQueryBuilderOverrides({
-						builder: {
-							queryData: [
-								{
-									filters: { items: [], op: 'AND' },
-									filter: { expression: 'service.name = "api"' },
-								},
-							],
+					queryBuilderOverrides: {
+						currentQuery: {
+							builder: {
+								queryData: [
+									{
+										filters: { items: [], op: 'AND' },
+										filter: { expression: 'service.name = "api"' },
+									},
+								],
+							},
 						},
-					}),
+					} as never,
 				},
 			);
 
@@ -185,7 +104,7 @@ describe('CheckboxFilterV2 - item rules', () => {
 			render(
 				<CheckboxFilterV2
 					filter={DEFAULT_FILTER}
-					pageSource={QuickFiltersSource.TRACES_EXPLORER}
+					source={QuickFiltersSource.TRACES_EXPLORER}
 					useFieldApis={{
 						...DEFAULT_USE_FIELD_APIS,
 						existingQuery: 'service.name = "api"',
@@ -193,16 +112,18 @@ describe('CheckboxFilterV2 - item rules', () => {
 				/>,
 				undefined,
 				{
-					queryBuilderOverrides: buildQueryBuilderOverrides({
-						builder: {
-							queryData: [
-								{
-									filters: { items: [], op: 'AND' },
-									filter: { expression: 'service.name = "api"' },
-								},
-							],
+					queryBuilderOverrides: {
+						currentQuery: {
+							builder: {
+								queryData: [
+									{
+										filters: { items: [], op: 'AND' },
+										filter: { expression: 'service.name = "api"' },
+									},
+								],
+							},
 						},
-					}),
+					} as never,
 				},
 			);
 
@@ -221,7 +142,7 @@ describe('CheckboxFilterV2 - item rules', () => {
 			render(
 				<CheckboxFilterV2
 					filter={DEFAULT_FILTER}
-					pageSource={QuickFiltersSource.TRACES_EXPLORER}
+					source={QuickFiltersSource.TRACES_EXPLORER}
 					useFieldApis={{
 						...DEFAULT_USE_FIELD_APIS,
 						existingQuery: 'service.name = "api"',
@@ -229,25 +150,27 @@ describe('CheckboxFilterV2 - item rules', () => {
 				/>,
 				undefined,
 				{
-					queryBuilderOverrides: buildQueryBuilderOverrides({
-						builder: {
-							queryData: [
-								{
-									filters: {
-										items: [
-											{
-												key: { key: 'deployment.environment' },
-												op: 'in',
-												value: ['production'],
-											},
-										],
-										op: 'AND',
+					queryBuilderOverrides: {
+						currentQuery: {
+							builder: {
+								queryData: [
+									{
+										filters: {
+											items: [
+												{
+													key: { key: 'deployment.environment' },
+													op: 'in',
+													value: ['production'],
+												},
+											],
+											op: 'AND',
+										},
+										filter: { expression: 'service.name = "api"' },
 									},
-									filter: { expression: 'service.name = "api"' },
-								},
-							],
+								],
+							},
 						},
-					}),
+					} as never,
 				},
 			);
 
@@ -273,29 +196,31 @@ describe('CheckboxFilterV2 - item rules', () => {
 			render(
 				<CheckboxFilterV2
 					filter={DEFAULT_FILTER}
-					pageSource={QuickFiltersSource.TRACES_EXPLORER}
+					source={QuickFiltersSource.TRACES_EXPLORER}
 					useFieldApis={DEFAULT_USE_FIELD_APIS}
 				/>,
 				undefined,
 				{
-					queryBuilderOverrides: buildQueryBuilderOverrides({
-						builder: {
-							queryData: [
-								{
-									filters: {
-										items: [
-											{
-												key: { key: 'deployment.environment' },
-												op: 'in',
-												value: ['production'],
-											},
-										],
-										op: 'AND',
+					queryBuilderOverrides: {
+						currentQuery: {
+							builder: {
+								queryData: [
+									{
+										filters: {
+											items: [
+												{
+													key: { key: 'deployment.environment' },
+													op: 'in',
+													value: ['production'],
+												},
+											],
+											op: 'AND',
+										},
 									},
-								},
-							],
+								],
+							},
 						},
-					}),
+					} as never,
 				},
 			);
 
@@ -321,33 +246,34 @@ describe('CheckboxFilterV2 - item rules', () => {
 			render(
 				<CheckboxFilterV2
 					filter={DEFAULT_FILTER}
-					pageSource={QuickFiltersSource.TRACES_EXPLORER}
+					source={QuickFiltersSource.TRACES_EXPLORER}
 					useFieldApis={DEFAULT_USE_FIELD_APIS}
 				/>,
 				undefined,
 				{
-					queryBuilderOverrides: buildQueryBuilderOverrides({
-						builder: {
-							queryData: [
-								{
-									filters: {
-										items: [
-											{
-												key: { key: 'deployment.environment' },
-												op: 'not in',
-												value: ['production'],
-											},
-										],
-										op: 'AND',
+					queryBuilderOverrides: {
+						currentQuery: {
+							builder: {
+								queryData: [
+									{
+										filters: {
+											items: [
+												{
+													key: { key: 'deployment.environment' },
+													op: 'not in',
+													value: ['production'],
+												},
+											],
+											op: 'AND',
+										},
 									},
-								},
-							],
+								],
+							},
 						},
-					}),
+					} as never,
 				},
 			);
 
-			// The excluded value renders unchecked.
 			const productionRow = await screen.findByTestId(
 				'checkbox-value-row-production',
 			);
@@ -356,9 +282,8 @@ describe('CheckboxFilterV2 - item rules', () => {
 				within(productionRow).queryByTestId(/^badge-/),
 			).not.toBeInTheDocument();
 
-			// The non-excluded value is still included by NOT IN, so it stays checked.
 			const stagingRow = screen.getByTestId('checkbox-value-row-staging');
-			expect(stagingRow).toHaveAttribute('data-state', 'checked');
+			expect(stagingRow).toHaveAttribute('data-state', 'unchecked');
 			expect(within(stagingRow).queryByTestId(/^badge-/)).not.toBeInTheDocument();
 		});
 	});
@@ -373,7 +298,7 @@ describe('CheckboxFilterV2 - item rules', () => {
 			render(
 				<CheckboxFilterV2
 					filter={DEFAULT_FILTER}
-					pageSource={QuickFiltersSource.TRACES_EXPLORER}
+					source={QuickFiltersSource.TRACES_EXPLORER}
 					useFieldApis={{
 						...DEFAULT_USE_FIELD_APIS,
 						existingQuery: 'service.name = "api"',
@@ -381,25 +306,27 @@ describe('CheckboxFilterV2 - item rules', () => {
 				/>,
 				undefined,
 				{
-					queryBuilderOverrides: buildQueryBuilderOverrides({
-						builder: {
-							queryData: [
-								{
-									filters: {
-										items: [
-											{
-												key: { key: 'deployment.environment' },
-												op: 'in',
-												value: ['selected-value'],
-											},
-										],
-										op: 'AND',
+					queryBuilderOverrides: {
+						currentQuery: {
+							builder: {
+								queryData: [
+									{
+										filters: {
+											items: [
+												{
+													key: { key: 'deployment.environment' },
+													op: 'in',
+													value: ['selected-value'],
+												},
+											],
+											op: 'AND',
+										},
+										filter: { expression: 'service.name = "api"' },
 									},
-									filter: { expression: 'service.name = "api"' },
-								},
-							],
+								],
+							},
 						},
-					}),
+					} as never,
 				},
 			);
 
@@ -424,7 +351,7 @@ describe('CheckboxFilterV2 - item rules', () => {
 			render(
 				<CheckboxFilterV2
 					filter={DEFAULT_FILTER}
-					pageSource={QuickFiltersSource.TRACES_EXPLORER}
+					source={QuickFiltersSource.TRACES_EXPLORER}
 					useFieldApis={{
 						...DEFAULT_USE_FIELD_APIS,
 						existingQuery: 'service.name = "api"',
@@ -432,16 +359,18 @@ describe('CheckboxFilterV2 - item rules', () => {
 				/>,
 				undefined,
 				{
-					queryBuilderOverrides: buildQueryBuilderOverrides({
-						builder: {
-							queryData: [
-								{
-									filters: { items: [], op: 'AND' },
-									filter: { expression: 'service.name = "api"' },
-								},
-							],
+					queryBuilderOverrides: {
+						currentQuery: {
+							builder: {
+								queryData: [
+									{
+										filters: { items: [], op: 'AND' },
+										filter: { expression: 'service.name = "api"' },
+									},
+								],
+							},
 						},
-					}),
+					} as never,
 				},
 			);
 
@@ -466,7 +395,7 @@ describe('CheckboxFilterV2 - item rules', () => {
 			render(
 				<CheckboxFilterV2
 					filter={DEFAULT_FILTER}
-					pageSource={QuickFiltersSource.TRACES_EXPLORER}
+					source={QuickFiltersSource.TRACES_EXPLORER}
 					useFieldApis={{
 						...DEFAULT_USE_FIELD_APIS,
 						existingQuery: 'service.name = "api"',
@@ -474,25 +403,27 @@ describe('CheckboxFilterV2 - item rules', () => {
 				/>,
 				undefined,
 				{
-					queryBuilderOverrides: buildQueryBuilderOverrides({
-						builder: {
-							queryData: [
-								{
-									filters: {
-										items: [
-											{
-												key: { key: 'deployment.environment' },
-												op: 'in',
-												value: ['selected-env'],
-											},
-										],
-										op: 'AND',
+					queryBuilderOverrides: {
+						currentQuery: {
+							builder: {
+								queryData: [
+									{
+										filters: {
+											items: [
+												{
+													key: { key: 'deployment.environment' },
+													op: 'in',
+													value: ['selected-env'],
+												},
+											],
+											op: 'AND',
+										},
+										filter: { expression: 'service.name = "api"' },
 									},
-									filter: { expression: 'service.name = "api"' },
-								},
-							],
+								],
+							},
 						},
-					}),
+					} as never,
 				},
 			);
 
@@ -521,7 +452,7 @@ describe('CheckboxFilterV2 - item rules', () => {
 			render(
 				<CheckboxFilterV2
 					filter={DEFAULT_FILTER}
-					pageSource={QuickFiltersSource.TRACES_EXPLORER}
+					source={QuickFiltersSource.TRACES_EXPLORER}
 					useFieldApis={{
 						...DEFAULT_USE_FIELD_APIS,
 						existingQuery: 'service.name = "api"',
@@ -529,25 +460,27 @@ describe('CheckboxFilterV2 - item rules', () => {
 				/>,
 				undefined,
 				{
-					queryBuilderOverrides: buildQueryBuilderOverrides({
-						builder: {
-							queryData: [
-								{
-									filters: {
-										items: [
-											{
-												key: { key: 'deployment.environment' },
-												op: 'not in',
-												value: ['excluded-env'],
-											},
-										],
-										op: 'AND',
+					queryBuilderOverrides: {
+						currentQuery: {
+							builder: {
+								queryData: [
+									{
+										filters: {
+											items: [
+												{
+													key: { key: 'deployment.environment' },
+													op: 'not in',
+													value: ['excluded-env'],
+												},
+											],
+											op: 'AND',
+										},
+										filter: { expression: 'service.name = "api"' },
 									},
-									filter: { expression: 'service.name = "api"' },
-								},
-							],
+								],
+							},
 						},
-					}),
+					} as never,
 				},
 			);
 

frontend/src/components/QuickFilters/FilterRenderers/Checkbox/v2/__tests__/CheckboxFilterV2.states.test.tsx

@@ -24,7 +24,7 @@ describe('CheckboxFilterV2 - states', () => {
 			render(
 				<CheckboxFilterV2
 					filter={DEFAULT_FILTER}
-					pageSource={QuickFiltersSource.TRACES_EXPLORER}
+					source={QuickFiltersSource.TRACES_EXPLORER}
 					useFieldApis={DEFAULT_USE_FIELD_APIS}
 				/>,
 			);
@@ -46,7 +46,7 @@ describe('CheckboxFilterV2 - states', () => {
 			render(
 				<CheckboxFilterV2
 					filter={closedFilter}
-					pageSource={QuickFiltersSource.TRACES_EXPLORER}
+					source={QuickFiltersSource.TRACES_EXPLORER}
 					useFieldApis={DEFAULT_USE_FIELD_APIS}
 				/>,
 			);
@@ -103,7 +103,7 @@ describe('CheckboxFilterV2 - states', () => {
 			render(
 				<CheckboxFilterV2
 					filter={DEFAULT_FILTER}
-					pageSource={QuickFiltersSource.TRACES_EXPLORER}
+					source={QuickFiltersSource.TRACES_EXPLORER}
 					useFieldApis={DEFAULT_USE_FIELD_APIS}
 				/>,
 			);
@@ -132,7 +132,7 @@ describe('CheckboxFilterV2 - states', () => {
 			render(
 				<CheckboxFilterV2
 					filter={DEFAULT_FILTER}
-					pageSource={QuickFiltersSource.TRACES_EXPLORER}
+					source={QuickFiltersSource.TRACES_EXPLORER}
 					useFieldApis={DEFAULT_USE_FIELD_APIS}
 				/>,
 			);
@@ -151,7 +151,7 @@ describe('CheckboxFilterV2 - states', () => {
 			render(
 				<CheckboxFilterV2
 					filter={DEFAULT_FILTER}
-					pageSource={QuickFiltersSource.TRACES_EXPLORER}
+					source={QuickFiltersSource.TRACES_EXPLORER}
 					useFieldApis={DEFAULT_USE_FIELD_APIS}
 				/>,
 			);
@@ -171,7 +171,7 @@ describe('CheckboxFilterV2 - states', () => {
 			render(
 				<CheckboxFilterV2
 					filter={DEFAULT_FILTER}
-					pageSource={QuickFiltersSource.TRACES_EXPLORER}
+					source={QuickFiltersSource.TRACES_EXPLORER}
 					useFieldApis={DEFAULT_USE_FIELD_APIS}
 				/>,
 			);
@@ -194,7 +194,7 @@ describe('CheckboxFilterV2 - states', () => {
 			render(
 				<CheckboxFilterV2
 					filter={DEFAULT_FILTER}
-					pageSource={QuickFiltersSource.TRACES_EXPLORER}
+					source={QuickFiltersSource.TRACES_EXPLORER}
 					useFieldApis={DEFAULT_USE_FIELD_APIS}
 				/>,
 			);

frontend/src/components/QuickFilters/FilterRenderers/Checkbox/v2/__tests__/itemRules.test.ts

@@ -8,7 +8,6 @@ describe('itemRules', () => {
 				isInRelatedValues: true,
 				isNotInOperator: false,
 				hasExistingQuery: false,
-				isRelatedValuesSupported: true,
 				hasFilterForThisKey: false,
 			};
 
@@ -24,7 +23,6 @@ describe('itemRules', () => {
 				isInRelatedValues: true,
 				isNotInOperator: false,
 				hasExistingQuery: true,
-				isRelatedValuesSupported: true,
 				hasFilterForThisKey: true,
 			};
 
@@ -40,7 +38,6 @@ describe('itemRules', () => {
 				isInRelatedValues: false,
 				isNotInOperator: true,
 				hasExistingQuery: true,
-				isRelatedValuesSupported: true,
 				hasFilterForThisKey: true,
 			};
 
@@ -51,46 +48,12 @@ describe('itemRules', () => {
 			expect(result.checkedState).toBe('unchecked');
 		});
 
-		it('NOT IN filter, value not excluded, not related → all_values, checked', () => {
-			const ctx: ItemContext = {
-				isSelectedOnFilter: false,
-				isInRelatedValues: false,
-				isNotInOperator: true,
-				hasExistingQuery: true,
-				isRelatedValuesSupported: true,
-				hasFilterForThisKey: true,
-			};
-
-			const result = deriveItemConfig(ctx);
-
-			expect(result.section).toBe(SectionType.ALL_VALUES);
-			expect(result.badge).toBeNull();
-			expect(result.checkedState).toBe('checked');
-		});
-
-		it('NOT IN filter, value not excluded but related → related wins, checked', () => {
-			const ctx: ItemContext = {
-				isSelectedOnFilter: false,
-				isInRelatedValues: true,
-				isNotInOperator: true,
-				hasExistingQuery: true,
-				isRelatedValuesSupported: true,
-				hasFilterForThisKey: true,
-			};
-
-			const result = deriveItemConfig(ctx);
-
-			expect(result.section).toBe(SectionType.RELATED);
-			expect(result.checkedState).toBe('checked');
-		});
-
 		it('has query, not selected, in related → section related, checked', () => {
 			const ctx: ItemContext = {
 				isSelectedOnFilter: false,
 				isInRelatedValues: true,
 				isNotInOperator: false,
 				hasExistingQuery: true,
-				isRelatedValuesSupported: true,
 				hasFilterForThisKey: false,
 			};
 
@@ -107,7 +70,6 @@ describe('itemRules', () => {
 				isInRelatedValues: true,
 				isNotInOperator: false,
 				hasExistingQuery: true,
-				isRelatedValuesSupported: true,
 				hasFilterForThisKey: true,
 			};
 
@@ -124,7 +86,6 @@ describe('itemRules', () => {
 				isInRelatedValues: false,
 				isNotInOperator: false,
 				hasExistingQuery: true,
-				isRelatedValuesSupported: true,
 				hasFilterForThisKey: false,
 			};
 
@@ -141,7 +102,6 @@ describe('itemRules', () => {
 				isInRelatedValues: false,
 				isNotInOperator: false,
 				hasExistingQuery: true,
-				isRelatedValuesSupported: true,
 				hasFilterForThisKey: true,
 			};
 
@@ -158,7 +118,6 @@ describe('itemRules', () => {
 				isInRelatedValues: false,
 				isNotInOperator: false,
 				hasExistingQuery: false,
-				isRelatedValuesSupported: true,
 				hasFilterForThisKey: true,
 			};
 
@@ -169,70 +128,4 @@ describe('itemRules', () => {
 			expect(result.checkedState).toBe('checked');
 		});
 	});
-
-	describe('deriveItemConfig with related values unsupported', () => {
-		const baseCtx: Omit<ItemContext, 'isSelectedOnFilter' | 'isNotInOperator'> = {
-			isInRelatedValues: false,
-			hasExistingQuery: true,
-			hasFilterForThisKey: true,
-			isRelatedValuesSupported: false,
-		};
-
-		it('no filter on this key → selected, checked, even with an existing query', () => {
-			const result = deriveItemConfig({
-				...baseCtx,
-				hasFilterForThisKey: false,
-				isSelectedOnFilter: false,
-				isNotInOperator: false,
-			});
-
-			expect(result.section).toBe(SectionType.SELECTED);
-			expect(result.checkedState).toBe('checked');
-		});
-
-		it('excluded by NOT IN → selected, unchecked', () => {
-			const result = deriveItemConfig({
-				...baseCtx,
-				isSelectedOnFilter: true,
-				isNotInOperator: true,
-			});
-
-			expect(result.section).toBe(SectionType.SELECTED);
-			expect(result.checkedState).toBe('unchecked');
-		});
-
-		it('selected by IN → selected, checked', () => {
-			const result = deriveItemConfig({
-				...baseCtx,
-				isSelectedOnFilter: true,
-				isNotInOperator: false,
-			});
-
-			expect(result.section).toBe(SectionType.SELECTED);
-			expect(result.checkedState).toBe('checked');
-		});
-
-		it('NOT IN complement → all_values, checked, related values ignored', () => {
-			const result = deriveItemConfig({
-				...baseCtx,
-				isSelectedOnFilter: false,
-				isNotInOperator: true,
-			});
-
-			expect(result.section).toBe(SectionType.ALL_VALUES);
-			expect(result.checkedState).toBe('checked');
-		});
-
-		it('IN complement → all_values, unchecked, never related', () => {
-			const result = deriveItemConfig({
-				...baseCtx,
-				isInRelatedValues: true,
-				isSelectedOnFilter: false,
-				isNotInOperator: false,
-			});
-
-			expect(result.section).toBe(SectionType.ALL_VALUES);
-			expect(result.checkedState).toBe('unchecked');
-		});
-	});
 });

frontend/src/components/QuickFilters/FilterRenderers/Checkbox/v2/__tests__/useSectionedValues.test.ts

@@ -17,7 +17,6 @@ describe('useSectionedValues', () => {
 		isSomeFilterPresentForCurrentAttribute: false,
 		isNotInOperator: false,
 		hasExistingQuery: false,
-		isRelatedValuesSupported: true,
 		visibleItemsCount: 10,
 		relatedExclusions: [] as string[],
 	};
@@ -27,7 +26,6 @@ describe('useSectionedValues', () => {
 			useSectionedValues({
 				...baseInput,
 				hasExistingQuery: false,
-				isRelatedValuesSupported: true,
 				isSomeFilterPresentForCurrentAttribute: false,
 			}),
 		);
@@ -45,7 +43,6 @@ describe('useSectionedValues', () => {
 			useSectionedValues({
 				...baseInput,
 				hasExistingQuery: true,
-				isRelatedValuesSupported: true,
 				isSomeFilterPresentForCurrentAttribute: false,
 			}),
 		);
@@ -74,7 +71,6 @@ describe('useSectionedValues', () => {
 			useSectionedValues({
 				...baseInput,
 				hasExistingQuery: true,
-				isRelatedValuesSupported: true,
 				isSomeFilterPresentForCurrentAttribute: true,
 				currentFilterState: { val1: true, val2: false, val3: false },
 			}),
@@ -92,7 +88,6 @@ describe('useSectionedValues', () => {
 			useSectionedValues({
 				...baseInput,
 				hasExistingQuery: true,
-				isRelatedValuesSupported: true,
 				isSomeFilterPresentForCurrentAttribute: true,
 				isNotInOperator: true,
 				currentFilterState: { val1: false, val2: true, val3: true },
@@ -115,7 +110,6 @@ describe('useSectionedValues', () => {
 				relatedValues: ['zebra', 'apple', 'mango'],
 				allValues: ['zebra', 'apple', 'mango'],
 				hasExistingQuery: false,
-				isRelatedValuesSupported: true,
 				isSomeFilterPresentForCurrentAttribute: false,
 			}),
 		);
@@ -132,7 +126,6 @@ describe('useSectionedValues', () => {
 				useSectionedValues({
 					...baseInput,
 					hasExistingQuery: true,
-					isRelatedValuesSupported: true,
 					isSomeFilterPresentForCurrentAttribute: true,
 					currentFilterState: { val1: true },
 				}),
@@ -150,7 +143,6 @@ describe('useSectionedValues', () => {
 					relatedValues: [],
 					allValues: [],
 					hasExistingQuery: true,
-					isRelatedValuesSupported: true,
 					isSomeFilterPresentForCurrentAttribute: false,
 					currentFilterState: {},
 				}),
@@ -167,7 +159,6 @@ describe('useSectionedValues', () => {
 					relatedValues: [],
 					allValues: ['other1', 'other2', 'other3'],
 					hasExistingQuery: true,
-					isRelatedValuesSupported: true,
 					isSomeFilterPresentForCurrentAttribute: false,
 				}),
 			);
@@ -187,7 +178,6 @@ describe('useSectionedValues', () => {
 					relatedValues: ['pod-a-1', 'pod-b-1', 'pod-c-1'],
 					allValues: ['pod-a-2', 'pod-b-2', 'pod-c-2'],
 					hasExistingQuery: true,
-					isRelatedValuesSupported: true,
 					isSomeFilterPresentForCurrentAttribute: false,
 				}),
 			);
@@ -228,7 +218,6 @@ describe('useSectionedValues', () => {
 					currentFilterState: { newValue: true },
 					isSomeFilterPresentForCurrentAttribute: true,
 					hasExistingQuery: true,
-					isRelatedValuesSupported: true,
 					// stale API data kept via keepPreviousData
 					relatedValues: ['oldSelected', 'otherRelated'],
 					allValues: ['newValue'],
@@ -257,7 +246,6 @@ describe('useSectionedValues', () => {
 					currentFilterState: { newValue: true },
 					isSomeFilterPresentForCurrentAttribute: true,
 					hasExistingQuery: true,
-					isRelatedValuesSupported: true,
 					// oldSelected was just de-selected; the rest are genuinely related
 					relatedValues: ['oldSelected', 'relatedA', 'relatedB', 'relatedC'],
 					allValues: ['newValue'],
@@ -287,7 +275,6 @@ describe('useSectionedValues', () => {
 					currentFilterState: { newValue: true },
 					isSomeFilterPresentForCurrentAttribute: true,
 					hasExistingQuery: true,
-					isRelatedValuesSupported: true,
 					relatedValues: ['oldSelected', 'otherRelated'],
 					allValues: ['newValue'],
 					relatedExclusions: ['oldSelected'],
@@ -306,7 +293,6 @@ describe('useSectionedValues', () => {
 					currentFilterState: { newValue: true },
 					isSomeFilterPresentForCurrentAttribute: true,
 					hasExistingQuery: true,
-					isRelatedValuesSupported: true,
 					relatedValues: ['oldSelected', 'otherRelated'],
 					allValues: ['newValue'],
 					relatedExclusions: [],
@@ -328,7 +314,6 @@ describe('useSectionedValues', () => {
 					relatedValues: ['related1'],
 					allValues: ['all1'],
 					hasExistingQuery: true,
-					isRelatedValuesSupported: true,
 					isSomeFilterPresentForCurrentAttribute: true,
 					currentFilterState: { selected1: true },
 				}),
@@ -352,7 +337,6 @@ describe('useSectionedValues', () => {
 					relatedValues: ['r1', 'r2', 'r3', 'r4', 'r5'],
 					allValues: ['a1', 'a2', 'a3', 'a4', 'a5'],
 					hasExistingQuery: true,
-					isRelatedValuesSupported: true,
 					isSomeFilterPresentForCurrentAttribute: false,
 					visibleItemsCount: 100,
 				}),
@@ -371,7 +355,6 @@ describe('useSectionedValues', () => {
 					relatedValues: ['r1', 'r2', 'r3'],
 					allValues: ['a1', 'a2', 'a3'],
 					hasExistingQuery: true,
-					isRelatedValuesSupported: true,
 					isSomeFilterPresentForCurrentAttribute: false,
 					visibleItemsCount: 4,
 				}),

frontend/src/components/QuickFilters/FilterRenderers/Checkbox/v2/itemRules.ts

@@ -24,7 +24,6 @@ export interface ItemContext {
 	isNotInOperator: boolean;
 	hasExistingQuery: boolean;
 	hasFilterForThisKey: boolean;
-	isRelatedValuesSupported: boolean;
 }
 
 export interface DerivedItem extends ItemConfig {
@@ -36,7 +35,7 @@ interface ItemRule {
 	config: ItemConfig;
 }
 
-const RELATED_SUPPORTED_RULES: ItemRule[] = [
+const ITEM_RULES: ItemRule[] = [
 	// No existing query and no filter → all checked (selected section)
 	{
 		condition: (ctx): boolean =>
@@ -74,16 +73,6 @@ const RELATED_SUPPORTED_RULES: ItemRule[] = [
 			checkedState: 'checked',
 		},
 	},
-	// filterKey present in query with NOT IN and value not in the list → checked
-	{
-		condition: (ctx): boolean =>
-			ctx.hasFilterForThisKey && ctx.isNotInOperator && !ctx.isSelectedOnFilter,
-		config: {
-			section: SectionType.ALL_VALUES,
-			badge: null,
-			checkedState: 'checked',
-		},
-	},
 	// All values (has existing query but not related) → unchecked
 	{
 		condition: (ctx): boolean => ctx.hasExistingQuery,
@@ -95,54 +84,6 @@ const RELATED_SUPPORTED_RULES: ItemRule[] = [
 	},
 ];
 
-const RELATED_UNSUPPORTED_RULES: ItemRule[] = [
-	// No filter on this key → included by default
-	{
-		condition: (ctx): boolean => !ctx.hasFilterForThisKey,
-		config: {
-			section: SectionType.SELECTED,
-			badge: null,
-			checkedState: 'checked',
-		},
-	},
-	// Explicitly excluded by NOT IN
-	{
-		condition: (ctx): boolean => ctx.isSelectedOnFilter && ctx.isNotInOperator,
-		config: {
-			section: SectionType.SELECTED,
-			badge: null,
-			checkedState: 'unchecked',
-		},
-	},
-	// Explicitly selected by IN
-	{
-		condition: (ctx): boolean => ctx.isSelectedOnFilter && !ctx.isNotInOperator,
-		config: {
-			section: SectionType.SELECTED,
-			badge: null,
-			checkedState: 'checked',
-		},
-	},
-	// Not listed in the key's NOT IN clause → not excluded, still in results
-	{
-		condition: (ctx): boolean => ctx.isNotInOperator,
-		config: {
-			section: SectionType.ALL_VALUES,
-			badge: null,
-			checkedState: 'checked',
-		},
-	},
-	// Not listed in the key's IN clause → filtered out of results
-	{
-		condition: (): boolean => true,
-		config: {
-			section: SectionType.ALL_VALUES,
-			badge: null,
-			checkedState: 'unchecked',
-		},
-	},
-];
-
 // Fallback when no rule matches
 const DEFAULT_CONFIG: ItemConfig = {
 	section: SectionType.SELECTED,
@@ -151,10 +92,7 @@ const DEFAULT_CONFIG: ItemConfig = {
 };
 
 export function deriveItemConfig(ctx: ItemContext): ItemConfig {
-	const rules = ctx.isRelatedValuesSupported
-		? RELATED_SUPPORTED_RULES
-		: RELATED_UNSUPPORTED_RULES;
-	for (const rule of rules) {
+	for (const rule of ITEM_RULES) {
 		if (rule.condition(ctx)) {
 			return rule.config;
 		}

frontend/src/components/QuickFilters/FilterRenderers/Checkbox/v2/useExistingQuery.tsx

@@ -17,7 +17,7 @@ export function useExistingQuery({
 	useFieldApis,
 	activeQueryIndex,
 }: UseExistingQueryParams): UseExistingQueryResult {
-	const { stagedQuery } = useQueryBuilder();
+	const { currentQuery } = useQueryBuilder();
 
 	const existingQuery = useMemo(() => {
 		if (useFieldApis.existingQuery === null) {
@@ -28,7 +28,7 @@ export function useExistingQuery({
 			return useFieldApis.existingQuery;
 		}
 
-		const queryData = stagedQuery?.builder.queryData?.[activeQueryIndex];
+		const queryData = currentQuery.builder.queryData?.[activeQueryIndex];
 
 		// Prefer V5 filter.expression
 		if (queryData?.filter?.expression) {
@@ -43,7 +43,7 @@ export function useExistingQuery({
 		return undefined;
 	}, [
 		useFieldApis.existingQuery,
-		stagedQuery?.builder.queryData,
+		currentQuery.builder.queryData,
 		activeQueryIndex,
 	]);
 
@@ -51,11 +51,11 @@ export function useExistingQuery({
 	// This is separate from existingQuery because existingQuery can be explicitly
 	// disabled (null) while filters still exist in the query for UI purposes
 	const hasExistingQuery = useMemo(() => {
-		const queryData = stagedQuery?.builder.queryData?.[activeQueryIndex];
+		const queryData = currentQuery.builder.queryData?.[activeQueryIndex];
 		const hasV3Items = (queryData?.filters?.items?.length ?? 0) > 0;
 		const hasV5Expression = !!queryData?.filter?.expression;
 		return hasV3Items || hasV5Expression || !!existingQuery;
-	}, [stagedQuery?.builder.queryData, activeQueryIndex, existingQuery]);
+	}, [currentQuery.builder.queryData, activeQueryIndex, existingQuery]);
 
 	return { existingQuery, hasExistingQuery };
 }

frontend/src/components/QuickFilters/FilterRenderers/Checkbox/v2/useFieldValues.tsx

@@ -1,10 +1,8 @@
 import { useMemo } from 'react';
 import { useGetFieldsValues } from 'api/generated/services/fields';
-import {
-	TelemetrytypesSignalDTO,
-	TelemetrytypesSourceDTO,
-} from 'api/generated/services/sigNoz.schemas';
+import { TelemetrytypesSignalDTO } from 'api/generated/services/sigNoz.schemas';
 import { IQuickFiltersConfig } from 'components/QuickFilters/types';
+import { DataSource } from 'types/common/queryBuilder';
 import { FIELD_API_CACHE_TIME } from 'constants/queryCacheTime';
 
 interface UseFieldValuesProps {
@@ -12,8 +10,6 @@ interface UseFieldValuesProps {
 	searchText: string;
 	existingQuery?: string;
 	metricNamespace?: string;
-	signal?: TelemetrytypesSignalDTO;
-	source?: TelemetrytypesSourceDTO;
 	startUnixMilli?: number;
 	endUnixMilli?: number;
 	enabled: boolean;
@@ -26,25 +22,33 @@ interface UseFieldValuesReturn {
 	isFetching: boolean;
 }
 
+export const DATA_SOURCE_TO_SIGNAL: Record<
+	DataSource,
+	TelemetrytypesSignalDTO
+> = {
+	[DataSource.METRICS]: TelemetrytypesSignalDTO.metrics,
+	[DataSource.TRACES]: TelemetrytypesSignalDTO.traces,
+	[DataSource.LOGS]: TelemetrytypesSignalDTO.logs,
+};
+
 export function useFieldValues({
 	filter,
 	searchText,
 	existingQuery,
 	metricNamespace,
-	signal,
-	source,
 	startUnixMilli,
 	endUnixMilli,
 	enabled,
 }: UseFieldValuesProps): UseFieldValuesReturn {
 	const { data, isLoading, isFetching } = useGetFieldsValues(
 		{
-			signal,
+			signal: filter.dataSource
+				? DATA_SOURCE_TO_SIGNAL[filter.dataSource]
+				: undefined,
 			name: filter.attributeKey.key,
 			searchText,
 			existingQuery,
 			metricNamespace,
-			source,
 			startUnixMilli,
 			// This field does not affect the backend but I wanted to keep it here
 			// in case we add the support in the future
@@ -88,12 +92,8 @@ export function useFieldValues({
 			values.numberValues
 				?.filter((value): value is number => value !== null && value !== undefined)
 				.map((value) => value.toString()) || [];
-		const boolValues =
-			values.boolValues
-				?.filter((value): value is boolean => value !== null && value !== undefined)
-				.map((value) => value.toString()) || [];
 
-		return [...stringValues, ...numberValues, ...boolValues];
+		return [...stringValues, ...numberValues];
 	}, [data]);
 
 	return { relatedValues, allValues, isLoading, isFetching };

frontend/src/components/QuickFilters/FilterRenderers/Checkbox/v2/useSectionedValues.ts

@@ -10,7 +10,6 @@ interface SectionedValuesInput {
 	isSomeFilterPresentForCurrentAttribute: boolean;
 	isNotInOperator: boolean;
 	hasExistingQuery: boolean;
-	isRelatedValuesSupported: boolean;
 	visibleItemsCount: number;
 	relatedExclusions: string[];
 }
@@ -66,7 +65,6 @@ export function useSectionedValues({
 	isSomeFilterPresentForCurrentAttribute,
 	isNotInOperator,
 	hasExistingQuery,
-	isRelatedValuesSupported,
 	visibleItemsCount,
 	relatedExclusions,
 }: SectionedValuesInput): SectionedValuesOutput {
@@ -97,7 +95,6 @@ export function useSectionedValues({
 			isNotInOperator,
 			hasExistingQuery,
 			hasFilterForThisKey: isSomeFilterPresentForCurrentAttribute,
-			isRelatedValuesSupported,
 		});
 	}, [
 		relatedValues,
@@ -106,7 +103,6 @@ export function useSectionedValues({
 		isSomeFilterPresentForCurrentAttribute,
 		isNotInOperator,
 		hasExistingQuery,
-		isRelatedValuesSupported,
 		relatedExclusions,
 	]);
 

frontend/src/components/QuickFilters/QuickFilters.tsx

@@ -47,10 +47,10 @@ export default function QuickFilters(props: IQuickFiltersProps): JSX.Element {
 		className,
 		config,
 		handleFilterVisibilityChange,
-		pageSource,
+		source,
 		onFilterChange,
 		onQuickFilterChange,
-		quickFilterSignal,
+		signal,
 		showFilterCollapse = true,
 		showQueryName = true,
 		useFieldApis,
@@ -67,7 +67,7 @@ export default function QuickFilters(props: IQuickFiltersProps): JSX.Element {
 		customFilters,
 		refetchCustomFilters,
 		isCustomFiltersLoading,
-	} = useFilterConfig({ signal: quickFilterSignal, config });
+	} = useFilterConfig({ signal, config });
 
 	const {
 		currentQuery,
@@ -105,7 +105,7 @@ export default function QuickFilters(props: IQuickFiltersProps): JSX.Element {
 
 	// Show dropdown in ListView only for TRACES_EXPLORER source
 	const shouldShowDropdownInListView =
-		isListView && pageSource === QuickFiltersSource.TRACES_EXPLORER;
+		isListView && source === QuickFiltersSource.TRACES_EXPLORER;
 
 	const showAnnouncementTooltip = useMemo(() => {
 		const localStorageValue = getLocalStorageKey(
@@ -119,12 +119,12 @@ export default function QuickFilters(props: IQuickFiltersProps): JSX.Element {
 
 	const activeQueryIndex = useMemo(() => {
 		if (isListView) {
-			return pageSource === QuickFiltersSource.TRACES_EXPLORER
+			return source === QuickFiltersSource.TRACES_EXPLORER
 				? lastUsedQuery || 0
 				: 0;
 		}
 		return lastUsedQuery || 0;
-	}, [isListView, pageSource, lastUsedQuery]);
+	}, [isListView, source, lastUsedQuery]);
 
 	// clear all the filters for the query which is in sync with filters
 	const handleReset = (): void => {
@@ -281,7 +281,7 @@ export default function QuickFilters(props: IQuickFiltersProps): JSX.Element {
 
 	const renderContent = (): JSX.Element => (
 		<>
-			{pageSource === QuickFiltersSource.API_MONITORING && (
+			{source === QuickFiltersSource.API_MONITORING && (
 				<div className="api-quick-filters-header">
 					<Typography.Text>Show IP addresses</Typography.Text>
 					<Switch
@@ -303,7 +303,7 @@ export default function QuickFilters(props: IQuickFiltersProps): JSX.Element {
 							return useFieldApis ? (
 								<CheckboxV2
 									key={filter.attributeKey.key}
-									pageSource={pageSource}
+									source={source}
 									filter={filter}
 									onFilterChange={onFilterChange}
 									onQuickFilterChange={onQuickFilterChange}
@@ -312,7 +312,7 @@ export default function QuickFilters(props: IQuickFiltersProps): JSX.Element {
 							) : (
 								<Checkbox
 									key={filter.attributeKey.key}
-									pageSource={pageSource}
+									source={source}
 									filter={filter}
 									onFilterChange={onFilterChange}
 									onQuickFilterChange={onQuickFilterChange}
@@ -333,7 +333,7 @@ export default function QuickFilters(props: IQuickFiltersProps): JSX.Element {
 							return useFieldApis ? (
 								<CheckboxV2
 									key={filter.attributeKey.key}
-									pageSource={pageSource}
+									source={source}
 									filter={filter}
 									onFilterChange={onFilterChange}
 									onQuickFilterChange={onQuickFilterChange}
@@ -342,7 +342,7 @@ export default function QuickFilters(props: IQuickFiltersProps): JSX.Element {
 							) : (
 								<Checkbox
 									key={filter.attributeKey.key}
-									pageSource={pageSource}
+									source={source}
 									filter={filter}
 									onFilterChange={onFilterChange}
 									onQuickFilterChange={onQuickFilterChange}
@@ -364,7 +364,7 @@ export default function QuickFilters(props: IQuickFiltersProps): JSX.Element {
 	return (
 		<div className="quick-filters-container">
 			<div className="quick-filters">
-				{pageSource !== QuickFiltersSource.INFRA_MONITORING && (
+				{source !== QuickFiltersSource.INFRA_MONITORING && (
 					<section className="header">
 						{renderLeftActions()}
 						{renderRightActions()}
@@ -394,7 +394,7 @@ export default function QuickFilters(props: IQuickFiltersProps): JSX.Element {
 				>
 					{isSettingsOpen && (
 						<QuickFiltersSettings
-							signal={quickFilterSignal}
+							signal={signal}
 							setIsSettingsOpen={setIsSettingsOpen}
 							customFilters={customFilters}
 							refetchCustomFilters={refetchCustomFilters}
@@ -408,7 +408,7 @@ export default function QuickFilters(props: IQuickFiltersProps): JSX.Element {
 
 QuickFilters.defaultProps = {
 	onFilterChange: null,
-	quickFilterSignal: '',
+	signal: '',
 	config: [],
 	showFilterCollapse: true,
 	showQueryName: true,

frontend/src/components/QuickFilters/QuickFiltersSettings/OtherFilters.tsx

@@ -1,11 +1,10 @@
 import { useMemo } from 'react';
 import { Button, Skeleton } from 'antd';
 import { useGetFieldsKeys } from 'api/generated/services/fields';
-import {
-	TelemetrytypesSignalDTO,
-	TelemetrytypesSourceDTO,
-} from 'api/generated/services/sigNoz.schemas';
+import { TelemetrytypesSourceDTO } from 'api/generated/services/sigNoz.schemas';
 import OverlayScrollbar from 'components/OverlayScrollbar/OverlayScrollbar';
+import { DATA_SOURCE_TO_SIGNAL } from 'components/QuickFilters/FilterRenderers/Checkbox/v2/useFieldValues';
+import { SIGNAL_DATA_SOURCE_MAP } from 'components/QuickFilters/QuickFiltersSettings/constants';
 import { SignalType } from 'components/QuickFilters/types';
 import { buildCompositeKey } from 'container/OptionsMenu/utils';
 import {
@@ -14,14 +13,6 @@ import {
 	TelemetryFieldKey,
 } from 'types/api/v5/queryRange';
 
-const SIGNAL_TYPE_TO_SIGNAL: Record<SignalType, TelemetrytypesSignalDTO> = {
-	[SignalType.LOGS]: TelemetrytypesSignalDTO.logs,
-	[SignalType.TRACES]: TelemetrytypesSignalDTO.traces,
-	[SignalType.EXCEPTIONS]: TelemetrytypesSignalDTO.traces,
-	[SignalType.API_MONITORING]: TelemetrytypesSignalDTO.traces,
-	[SignalType.METER_EXPLORER]: TelemetrytypesSignalDTO.metrics,
-};
-
 function OtherFiltersSkeleton(): JSX.Element {
 	return (
 		<>
@@ -54,7 +45,9 @@ function OtherFilters({
 	const { data, isFetching } = useGetFieldsKeys(
 		{
 			searchText: inputValue,
-			signal: signal ? SIGNAL_TYPE_TO_SIGNAL[signal] : undefined,
+			signal: signal
+				? DATA_SOURCE_TO_SIGNAL[SIGNAL_DATA_SOURCE_MAP[signal]]
+				: undefined,
 			source: isMeterDataSource ? TelemetrytypesSourceDTO.meter : undefined,
 		},
 		{ query: { enabled: !!signal } },

frontend/src/components/QuickFilters/hooks/useSignalFieldApis.ts

@@ -1,32 +0,0 @@
-import { useMemo } from 'react';
-// eslint-disable-next-line no-restricted-imports
-import { useSelector } from 'react-redux';
-import {
-	TelemetrytypesSignalDTO,
-	TelemetrytypesSourceDTO,
-} from 'api/generated/services/sigNoz.schemas';
-import { NANO_SECOND_MULTIPLIER } from 'store/globalTime';
-import { AppState } from 'store/reducers';
-import { GlobalReducer } from 'types/reducer/globalTime';
-
-import { QuickFilterCheckboxUseFieldApis } from '../types';
-
-export function useSignalFieldApis(
-	signal: TelemetrytypesSignalDTO,
-	source?: TelemetrytypesSourceDTO,
-): QuickFilterCheckboxUseFieldApis {
-	const { minTime, maxTime } = useSelector<AppState, GlobalReducer>(
-		(state) => state.globalTime,
-	);
-
-	return useMemo(
-		() => ({
-			signal,
-			source,
-			startUnixMilli: Math.floor(minTime / NANO_SECOND_MULTIPLIER),
-			endUnixMilli: Math.floor(maxTime / NANO_SECOND_MULTIPLIER),
-			existingQuery: null,
-		}),
-		[signal, source, minTime, maxTime],
-	);
-}

frontend/src/components/QuickFilters/tests/QuickFilters.test.tsx

@@ -72,46 +72,46 @@ const setupServer = (): void => {
 };
 
 function TestQuickFilters({
-	quickFilterSignal = SignalType.LOGS,
+	signal = SignalType.LOGS,
 	config = QuickFiltersConfig,
 }: {
-	quickFilterSignal?: SignalType;
+	signal?: SignalType;
 	config?: IQuickFiltersConfig[];
 }): JSX.Element {
 	return (
 		<QuickFilters
-			pageSource={QuickFiltersSource.EXCEPTIONS}
+			source={QuickFiltersSource.EXCEPTIONS}
 			config={config}
 			handleFilterVisibilityChange={handleFilterVisibilityChange}
-			quickFilterSignal={quickFilterSignal}
+			signal={signal}
 		/>
 	);
 }
 
 TestQuickFilters.defaultProps = {
-	quickFilterSignal: '',
+	signal: '',
 	config: QuickFiltersConfig,
 };
 
 function TestQuickFiltersApiMonitoring({
-	quickFilterSignal = SignalType.LOGS,
+	signal = SignalType.LOGS,
 	config = QuickFiltersConfig,
 }: {
-	quickFilterSignal?: SignalType;
+	signal?: SignalType;
 	config?: IQuickFiltersConfig[];
 }): JSX.Element {
 	return (
 		<QuickFilters
-			pageSource={QuickFiltersSource.API_MONITORING}
+			source={QuickFiltersSource.API_MONITORING}
 			config={config}
 			handleFilterVisibilityChange={handleFilterVisibilityChange}
-			quickFilterSignal={quickFilterSignal}
+			signal={signal}
 		/>
 	);
 }
 
 TestQuickFiltersApiMonitoring.defaultProps = {
-	quickFilterSignal: '',
+	signal: '',
 	config: QuickFiltersConfig,
 };
 
@@ -310,7 +310,7 @@ describe('Quick Filters with custom filters', () => {
 	it('loads the custom filters correctly', async () => {
 		const user = userEvent.setup({ pointerEventsCheck: 0 });
 
-		render(<TestQuickFilters quickFilterSignal={SIGNAL} />);
+		render(<TestQuickFilters signal={SIGNAL} />);
 
 		expect(screen.getByText('Filters for')).toBeInTheDocument();
 		expect(screen.getByText(QUERY_NAME)).toBeInTheDocument();
@@ -370,7 +370,7 @@ describe('Quick Filters with custom filters', () => {
 			),
 		);
 
-		render(<TestQuickFilters quickFilterSignal={SIGNAL} />);
+		render(<TestQuickFilters signal={SIGNAL} />);
 		await screen.findByText(FILTER_SERVICE_NAME);
 
 		const icon = await screen.findByTestId(SETTINGS_ICON_TEST_ID);
@@ -398,7 +398,7 @@ describe('Quick Filters with custom filters', () => {
 	it('adds a filter from OTHER FILTERS to ADDED FILTERS when clicked', async () => {
 		const user = userEvent.setup({ pointerEventsCheck: 0 });
 
-		render(<TestQuickFilters quickFilterSignal={SIGNAL} />);
+		render(<TestQuickFilters signal={SIGNAL} />);
 		await screen.findByText(FILTER_SERVICE_NAME);
 
 		const icon = await screen.findByTestId(SETTINGS_ICON_TEST_ID);
@@ -419,7 +419,7 @@ describe('Quick Filters with custom filters', () => {
 	it('removes a filter from ADDED FILTERS and moves it to OTHER FILTERS', async () => {
 		const user = userEvent.setup({ pointerEventsCheck: 0 });
 
-		render(<TestQuickFilters quickFilterSignal={SIGNAL} />);
+		render(<TestQuickFilters signal={SIGNAL} />);
 		await screen.findByText(FILTER_SERVICE_NAME);
 
 		const icon = await screen.findByTestId(SETTINGS_ICON_TEST_ID);
@@ -448,7 +448,7 @@ describe('Quick Filters with custom filters', () => {
 	it('restores original filter state on Discard', async () => {
 		const user = userEvent.setup({ pointerEventsCheck: 0 });
 
-		render(<TestQuickFilters quickFilterSignal={SIGNAL} />);
+		render(<TestQuickFilters signal={SIGNAL} />);
 		await screen.findByText(FILTER_SERVICE_NAME);
 
 		const icon = await screen.findByTestId(SETTINGS_ICON_TEST_ID);
@@ -490,7 +490,7 @@ describe('Quick Filters with custom filters', () => {
 	it('saves the updated filters by calling PUT with correct payload', async () => {
 		const user = userEvent.setup({ pointerEventsCheck: 0 });
 
-		render(<TestQuickFilters quickFilterSignal={SIGNAL} />);
+		render(<TestQuickFilters signal={SIGNAL} />);
 		await screen.findByText(FILTER_SERVICE_NAME);
 
 		const icon = await screen.findByTestId(SETTINGS_ICON_TEST_ID);
@@ -527,9 +527,7 @@ describe('Quick Filters with custom filters', () => {
 			pointerEventsCheck: 0,
 		});
 
-		const { getByTestId } = render(
-			<TestQuickFilters quickFilterSignal={SIGNAL} />,
-		);
+		const { getByTestId } = render(<TestQuickFilters signal={SIGNAL} />);
 		await screen.findByText(FILTER_SERVICE_NAME);
 		expect(screen.getByText('Duration')).toBeInTheDocument();
 
@@ -593,14 +591,14 @@ describe('Quick Filters refetch behavior', () => {
 			}),
 		);
 
-		const { unmount } = render(<TestQuickFilters quickFilterSignal={SIGNAL} />);
+		const { unmount } = render(<TestQuickFilters signal={SIGNAL} />);
 		await expect(
 			screen.findByText(FILTER_SERVICE_NAME),
 		).resolves.toBeInTheDocument();
 
 		unmount();
 
-		render(<TestQuickFilters quickFilterSignal={SIGNAL} />);
+		render(<TestQuickFilters signal={SIGNAL} />);
 		await expect(
 			screen.findByText(FILTER_SERVICE_NAME),
 		).resolves.toBeInTheDocument();
@@ -618,7 +616,7 @@ describe('Quick Filters refetch behavior', () => {
 			}),
 		);
 
-		render(<TestQuickFilters quickFilterSignal={undefined} />);
+		render(<TestQuickFilters signal={undefined} />);
 
 		await waitFor(() => expect(getCalls).toBe(0));
 	});
@@ -639,7 +637,7 @@ describe('Quick Filters refetch behavior', () => {
 		);
 
 		const user = userEvent.setup({ pointerEventsCheck: 0 });
-		render(<TestQuickFilters quickFilterSignal={SIGNAL} />);
+		render(<TestQuickFilters signal={SIGNAL} />);
 
 		await expect(
 			screen.findByText(FILTER_SERVICE_NAME),
@@ -691,7 +689,7 @@ describe('Quick Filters refetch behavior', () => {
 		);
 
 		const user = userEvent.setup({ pointerEventsCheck: 0 });
-		render(<TestQuickFilters quickFilterSignal={SIGNAL} />);
+		render(<TestQuickFilters signal={SIGNAL} />);
 
 		await expect(
 			screen.findByText(FILTER_SERVICE_NAME),
@@ -722,7 +720,7 @@ describe('Quick Filters refetch behavior', () => {
 			),
 		);
 
-		render(<TestQuickFilters quickFilterSignal={SIGNAL} config={[]} />);
+		render(<TestQuickFilters signal={SIGNAL} config={[]} />);
 
 		await expect(
 			screen.findByText('No filters found'),

frontend/src/components/QuickFilters/types.ts

@@ -1,7 +1,3 @@
-import {
-	TelemetrytypesSignalDTO,
-	TelemetrytypesSourceDTO,
-} from 'api/generated/services/sigNoz.schemas';
 import { BaseAutocompleteData } from 'types/api/queryBuilder/queryAutocompleteResponse';
 import { Query } from 'types/api/queryBuilder/queryBuilderData';
 import { DataSource } from 'types/common/queryBuilder';
@@ -55,10 +51,10 @@ export interface QuickFilterChangeEventData {
 export interface IQuickFiltersProps {
 	config: IQuickFiltersConfig[];
 	handleFilterVisibilityChange: () => void;
-	pageSource: QuickFiltersSource;
+	source: QuickFiltersSource;
 	onFilterChange?: (query: Query) => void;
 	onQuickFilterChange?: (data: QuickFilterChangeEventData) => void;
-	quickFilterSignal?: SignalType;
+	signal?: SignalType;
 	className?: string;
 	showFilterCollapse?: boolean;
 	showQueryName?: boolean;
@@ -78,9 +74,6 @@ export enum QuickFiltersSource {
  * Opt-in: fetch values from the /v1/fields/values API instead of /v3/autocomplete/attribute_values
  */
 export type QuickFilterCheckboxUseFieldApis = {
-	/** Telemetry signal and source sent to the fields APIs, declared by the page. */
-	signal?: TelemetrytypesSignalDTO;
-	source?: TelemetrytypesSourceDTO;
 	startUnixMilli: number;
 	endUnixMilli: number;
 	/**

frontend/src/components/QuickFilters/utils.tsx

@@ -8,7 +8,6 @@ import { FiltersType, IQuickFiltersConfig, SignalType } from './types';
 const FILTER_TITLE_MAP: Record<string, string> = {
 	duration_nano: 'Duration',
 	hasError: 'Has Error (Status)',
-	has_error: 'Has Error (Status)',
 };
 
 const FILTER_TYPE_MAP: Record<string, FiltersType> = {

frontend/src/container/ApiMonitoring/Explorer/Explorer.tsx

@@ -3,8 +3,6 @@ import * as Sentry from '@sentry/react';
 import logEvent from 'api/common/logEvent';
 import cx from 'classnames';
 import QuickFilters from 'components/QuickFilters/QuickFilters';
-import { TelemetrytypesSignalDTO } from 'api/generated/services/sigNoz.schemas';
-import { useSignalFieldApis } from 'components/QuickFilters/hooks/useSignalFieldApis';
 import { QuickFiltersSource, SignalType } from 'components/QuickFilters/types';
 import ErrorBoundaryFallback from 'pages/ErrorBoundaryFallback/ErrorBoundaryFallback';
 
@@ -13,10 +11,6 @@ import DomainList from './Domains/DomainList';
 import './Explorer.styles.scss';
 
 function Explorer(): JSX.Element {
-	const quickFilterFieldApis = useSignalFieldApis(
-		TelemetrytypesSignalDTO.traces,
-	);
-
 	useEffect(() => {
 		logEvent('API Monitoring: Landing page visited', {});
 	}, []);
@@ -27,12 +21,11 @@ function Explorer(): JSX.Element {
 				<section className="api-quick-filter-left-section">
 					<QuickFilters
 						className="qf-api-monitoring"
-						pageSource={QuickFiltersSource.API_MONITORING}
-						quickFilterSignal={SignalType.API_MONITORING}
+						source={QuickFiltersSource.API_MONITORING}
+						signal={SignalType.API_MONITORING}
 						showFilterCollapse={false}
 						showQueryName={false}
 						handleFilterVisibilityChange={(): void => {}}
-						useFieldApis={quickFilterFieldApis}
 					/>
 				</section>
 				<DomainList />

frontend/src/container/InfraMonitoringHostsV2/Hosts.tsx

@@ -1,4 +1,3 @@
-import { TelemetrytypesSignalDTO } from 'api/generated/services/sigNoz.schemas';
 import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
 import { Button, Tooltip } from 'antd';
 import { Typography } from '@signozhq/ui/typography';
@@ -244,11 +243,10 @@ function Hosts(): JSX.Element {
 										</Tooltip>
 									</div>
 									<QuickFilters
-										pageSource={QuickFiltersSource.INFRA_MONITORING}
+										source={QuickFiltersSource.INFRA_MONITORING}
 										config={getHostsQuickFiltersConfig()}
 										handleFilterVisibilityChange={handleFilterVisibilityChange}
 										useFieldApis={{
-											signal: TelemetrytypesSignalDTO.metrics,
 											metricNamespace:
 												METRIC_NAMESPACE_BY_ENTITY[InfraMonitoringEntity.HOSTS],
 											startUnixMilli,

frontend/src/container/InfraMonitoringK8sV2/InfraMonitoringK8s.tsx

@@ -1,4 +1,3 @@
-import { TelemetrytypesSignalDTO } from 'api/generated/services/sigNoz.schemas';
 import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
 import * as Sentry from '@sentry/react';
 import { Button } from '@signozhq/ui/button';
@@ -90,7 +89,6 @@ export default function InfraMonitoringK8s(): JSX.Element {
 
 	const getUseFieldApis = useCallback(
 		(entity: InfraMonitoringEntity): QuickFilterCheckboxUseFieldApis => ({
-			signal: TelemetrytypesSignalDTO.metrics,
 			metricNamespace: METRIC_NAMESPACE_BY_ENTITY[entity],
 			startUnixMilli,
 			endUnixMilli,
@@ -321,7 +319,7 @@ export default function InfraMonitoringK8s(): JSX.Element {
 										</div>
 										{selectedCategoryConfig && (
 											<QuickFilters
-												pageSource={QuickFiltersSource.INFRA_MONITORING}
+												source={QuickFiltersSource.INFRA_MONITORING}
 												config={selectedCategoryConfig}
 												handleFilterVisibilityChange={handleFilterVisibilityChange}
 												useFieldApis={selectedCategoryUseFieldApis}

frontend/src/container/LLMObservability/Explorer/Controls/Controls.module.scss

@@ -1,14 +0,0 @@
-.container {
-	display: flex;
-	align-items: center;
-	justify-content: flex-end;
-	gap: 0.3rem;
-	margin: 8px 0;
-}
-
-.optionsTrigger {
-	display: flex;
-	align-items: center;
-	gap: 4px;
-	cursor: pointer;
-}

frontend/src/container/LLMObservability/Explorer/Controls/index.tsx

@@ -1,82 +0,0 @@
-import { memo, useState } from 'react';
-import { useTranslation } from 'react-i18next';
-import { Settings } from '@signozhq/icons';
-import FieldsSelector from 'components/FieldsSelector';
-import Controls, { ControlsProps } from 'container/Controls';
-import { OptionsMenuConfig } from 'container/OptionsMenu/types';
-import useQueryPagination from 'hooks/queryPagination/useQueryPagination';
-import { DataSource } from 'types/common/queryBuilder';
-
-import styles from './Controls.module.scss';
-
-function TraceExplorerControls({
-	isLoading,
-	totalCount,
-	perPageOptions,
-	config,
-	showSizeChanger = true,
-}: TraceExplorerControlsProps): JSX.Element | null {
-	const { t } = useTranslation(['trace']);
-	const [isFieldsSelectorOpen, setIsFieldsSelectorOpen] = useState(false);
-
-	const {
-		pagination,
-		handleCountItemsPerPageChange,
-		handleNavigateNext,
-		handleNavigatePrevious,
-	} = useQueryPagination(totalCount, perPageOptions);
-
-	return (
-		<div className={styles.container}>
-			{config?.fieldsSelector && (
-				<>
-					<div
-						className={styles.optionsTrigger}
-						onClick={(): void => setIsFieldsSelectorOpen(true)}
-					>
-						{t('options_menu.options')}
-						<Settings size="md" />
-					</div>
-					<FieldsSelector
-						isOpen={isFieldsSelectorOpen}
-						title="Edit columns"
-						fields={config.fieldsSelector.value}
-						onFieldsChange={config.fieldsSelector.onFieldsChange}
-						onClose={(): void => setIsFieldsSelectorOpen(false)}
-						signal={DataSource.TRACES}
-					/>
-				</>
-			)}
-
-			<Controls
-				isLoading={isLoading}
-				totalCount={totalCount}
-				offset={pagination.offset}
-				countPerPage={pagination.limit}
-				perPageOptions={perPageOptions}
-				handleCountItemsPerPageChange={handleCountItemsPerPageChange}
-				handleNavigateNext={handleNavigateNext}
-				handleNavigatePrevious={handleNavigatePrevious}
-				showSizeChanger={showSizeChanger}
-			/>
-		</div>
-	);
-}
-
-TraceExplorerControls.defaultProps = {
-	config: null,
-};
-
-type TraceExplorerControlsProps = Pick<
-	ControlsProps,
-	'isLoading' | 'totalCount' | 'perPageOptions'
-> & {
-	config?: OptionsMenuConfig | null;
-	showSizeChanger?: boolean;
-};
-
-TraceExplorerControls.defaultProps = {
-	showSizeChanger: true,
-};
-
-export default memo(TraceExplorerControls);

frontend/src/container/LLMObservability/Explorer/Explorer.tsx

@@ -260,8 +260,8 @@ function Explorer(): JSX.Element {
 				<Card className="filter" hidden={!isOpen}>
 					<QuickFilters
 						className="qf-traces-explorer"
-						pageSource={QuickFiltersSource.TRACES_EXPLORER}
-						quickFilterSignal={SignalType.TRACES}
+						source={QuickFiltersSource.TRACES_EXPLORER}
+						signal={SignalType.TRACES}
 						handleFilterVisibilityChange={(): void => {
 							setOpen(!isOpen);
 						}}

frontend/src/container/LLMObservability/Explorer/ListView/utils.tsx

@@ -1,168 +0,0 @@
-import { Link } from 'react-router-dom';
-import type { TableColumnsType as ColumnsType } from 'antd';
-import { Badge } from '@signozhq/ui/badge';
-import { Typography } from '@signozhq/ui/typography';
-import { TelemetryFieldKey } from 'api/v5/v5';
-import type { TracesTableRow } from '../TracesTable/getFieldColumn';
-import { DATE_TIME_FORMATS } from 'constants/dateTimeFormats';
-import ROUTES from 'constants/routes';
-import { buildCompositeKey } from 'container/OptionsMenu/utils';
-import { getMs } from 'container/Trace/Filters/Panel/PanelBody/Duration/util';
-import { formUrlParams } from 'container/TraceDetail/utils';
-import { TimestampInput } from 'hooks/useTimezoneFormatter/useTimezoneFormatter';
-import { RowData } from 'lib/query/createTableColumnsFromQuery';
-import LineClampedText from 'periscope/components/LineClampedText/LineClampedText';
-import { ILog } from 'types/api/logs/log';
-import { QueryDataV3 } from 'types/api/widgets/getQuery';
-
-export function BlockLink({
-	children,
-	to,
-	openInNewTab,
-}: {
-	children: React.ReactNode;
-	to: string;
-	openInNewTab: boolean;
-}): any {
-	// Display block to make the whole cell clickable
-	return (
-		<Link
-			to={to}
-			style={{ display: 'block' }}
-			target={openInNewTab ? '_blank' : '_self'}
-		>
-			{children}
-		</Link>
-	);
-}
-
-export const transformDataWithDate = (
-	data: QueryDataV3[],
-): Omit<ILog, 'timestamp'>[] =>
-	data[0]?.list?.map(({ data, timestamp }) => ({ ...data, date: timestamp })) ||
-	[];
-
-export const getTraceLink = (record: Record<string, unknown>): string => {
-	function readId(value: unknown): string {
-		if (typeof value === 'string' || typeof value === 'number') {
-			return String(value);
-		}
-		return '';
-	}
-
-	const traceId = readId(record.traceID) || readId(record.trace_id);
-	const spanId = readId(record.spanID) || readId(record.span_id);
-
-	return `${ROUTES.TRACE}/${traceId}${formUrlParams({
-		spanId,
-		levelUp: 0,
-		levelDown: 0,
-	})}`;
-};
-
-export const getListColumns = (
-	selectedColumns: TelemetryFieldKey[],
-	formatTimezoneAdjustedTimestamp: (
-		input: TimestampInput,
-		format?: string,
-	) => string | number,
-): ColumnsType<RowData> => {
-	const initialColumns: ColumnsType<RowData> = [
-		{
-			dataIndex: 'date',
-			key: 'date',
-			title: 'Timestamp',
-			width: 145,
-			render: (value, item): JSX.Element => {
-				const date =
-					typeof value === 'string'
-						? formatTimezoneAdjustedTimestamp(
-								value,
-								DATE_TIME_FORMATS.ISO_DATETIME_MS,
-							)
-						: formatTimezoneAdjustedTimestamp(
-								value / 1e6,
-								DATE_TIME_FORMATS.ISO_DATETIME_MS,
-							);
-				return (
-					<BlockLink to={getTraceLink(item)} openInNewTab={false}>
-						<Typography.Text>{date}</Typography.Text>
-					</BlockLink>
-				);
-			},
-		},
-	];
-
-	const columns: ColumnsType<RowData> =
-		selectedColumns.map((props) => {
-			const name = props?.name || (props as any)?.key;
-			const fieldContext = props?.fieldContext || (props as any)?.type;
-			return {
-				title: name,
-				dataIndex: name,
-				key: buildCompositeKey(name, fieldContext),
-				width: 145,
-				render: (value, item): JSX.Element => {
-					if (value === '') {
-						return (
-							<BlockLink to={getTraceLink(item)} openInNewTab={false}>
-								<Typography data-testid={name}>N/A</Typography>
-							</BlockLink>
-						);
-					}
-
-					if (
-						name === 'httpMethod' ||
-						name === 'responseStatusCode' ||
-						name === 'response_status_code' ||
-						name === 'http_method'
-					) {
-						return (
-							<BlockLink to={getTraceLink(item)} openInNewTab={false}>
-								<Badge data-testid={name} color="sakura" variant="outline">
-									{value}
-								</Badge>
-							</BlockLink>
-						);
-					}
-
-					if (name === 'durationNano' || name === 'duration_nano') {
-						return (
-							<BlockLink to={getTraceLink(item)} openInNewTab={false}>
-								<Typography data-testid={name}>{getMs(value)}ms</Typography>
-							</BlockLink>
-						);
-					}
-
-					return (
-						<BlockLink to={getTraceLink(item)} openInNewTab={false}>
-							<Typography data-testid={name}>
-								<LineClampedText text={value} lines={3} />
-							</Typography>
-						</BlockLink>
-					);
-				},
-				responsive: ['md'],
-			};
-		}) || [];
-
-	return [...initialColumns, ...columns];
-};
-
-// Reshapes the query-range list payload into table rows. `id` mirrors span_id so
-// TanStack sees genuine row changes on orderBy toggles instead of falling back to
-// positional ids; `timestamp` is lifted from the wrapping ListItem.
-export const transformSpanRows = (data: QueryDataV3[]): TracesTableRow[] => {
-	const list = data[0]?.list;
-	if (!list) {
-		return [];
-	}
-	return list.map((item) => {
-		const row = item.data as Record<string, unknown>;
-		return {
-			...row,
-			timestamp: item.timestamp,
-			id: row.span_id,
-		};
-	}) as TracesTableRow[];
-};

frontend/src/container/LLMObservability/Explorer/TraceLoading/TraceLoading.styles.scss

@@ -1,19 +0,0 @@
-.loading-traces {
-	padding: 24px 0;
-	height: 240px;
-
-	display: flex;
-	justify-content: center;
-	align-items: flex-start;
-
-	.loading-traces-content {
-		display: flex;
-		align-items: flex-start;
-		flex-direction: column;
-
-		.loading-gif {
-			height: 72px;
-			margin-left: -24px;
-		}
-	}
-}

frontend/src/container/LLMObservability/Explorer/TraceLoading/TraceLoading.tsx

@@ -1,22 +0,0 @@
-import { useTranslation } from 'react-i18next';
-import { Typography } from '@signozhq/ui/typography';
-import { DataSource } from 'types/common/queryBuilder';
-
-import loadingPlaneUrl from '@/assets/Icons/loading-plane.gif';
-
-import './TraceLoading.styles.scss';
-
-export function TracesLoading(): JSX.Element {
-	const { t } = useTranslation('common');
-	return (
-		<div className="loading-traces">
-			<div className="loading-traces-content">
-				<img className="loading-gif" src={loadingPlaneUrl} alt="wait-icon" />
-
-				<Typography>
-					{t('pending_data_placeholder', { dataSource: DataSource.TRACES })}
-				</Typography>
-			</div>
-		</div>
-	);
-}

frontend/src/container/LLMObservability/Explorer/TracesTable/FieldCell.tsx

@@ -1,77 +0,0 @@
-import { generatePath, Link } from 'react-router-dom';
-import { Badge } from '@signozhq/ui/badge';
-import TanStackTable from 'components/TanStackTableView';
-import { DATE_TIME_FORMATS } from 'constants/dateTimeFormats';
-import ROUTES from 'constants/routes';
-import { getMs } from 'container/Trace/Filters/Panel/PanelBody/Duration/util';
-import { useTimezone } from 'providers/Timezone';
-
-import {
-	DURATION_FIELD_NAMES,
-	STATUS_FIELD_NAMES,
-	TIMESTAMP_FIELD_NAMES,
-	TRACE_ID_FIELD_NAMES,
-} from './constants';
-import { stringifyCellValue } from './utils';
-
-type FieldCellProps = {
-	name: string;
-	value: unknown;
-};
-
-function FieldCell({ name, value }: FieldCellProps): JSX.Element {
-	const { formatTimezoneAdjustedTimestamp } = useTimezone();
-
-	if (TIMESTAMP_FIELD_NAMES.has(name)) {
-		const ts = value as string | number;
-		const formatted =
-			typeof ts === 'string'
-				? formatTimezoneAdjustedTimestamp(ts, DATE_TIME_FORMATS.ISO_DATETIME_MS)
-				: formatTimezoneAdjustedTimestamp(
-						ts / 1e6,
-						DATE_TIME_FORMATS.ISO_DATETIME_MS,
-					);
-		const text = String(formatted);
-		return <TanStackTable.Text title={text}>{text}</TanStackTable.Text>;
-	}
-
-	if (value === '' || value == null) {
-		return <TanStackTable.Text data-testid={name}>-</TanStackTable.Text>;
-	}
-
-	const text = stringifyCellValue(value);
-
-	if (TRACE_ID_FIELD_NAMES.has(name)) {
-		return (
-			<Link
-				to={generatePath(ROUTES.TRACE_DETAIL, { id: text })}
-				data-testid="trace-id"
-				onClick={(e): void => e.stopPropagation()}
-			>
-				{text}
-			</Link>
-		);
-	}
-
-	if (STATUS_FIELD_NAMES.has(name)) {
-		return (
-			<Badge data-testid={name} color="sakura" variant="outline">
-				{text}
-			</Badge>
-		);
-	}
-
-	if (DURATION_FIELD_NAMES.has(name)) {
-		return (
-			<TanStackTable.Text data-testid={name}>{getMs(text)}ms</TanStackTable.Text>
-		);
-	}
-
-	return (
-		<TanStackTable.Text data-testid={name} title={text}>
-			{text}
-		</TanStackTable.Text>
-	);
-}
-
-export default FieldCell;

frontend/src/container/LLMObservability/Explorer/TracesTable/TracesTable.module.scss

@@ -1,26 +0,0 @@
-.tableWrapper {
-	flex: 1;
-	min-height: 0;
-	display: flex;
-	flex-direction: column;
-}
-
-.tracesTable {
-	--tanstack-table-row-height: 54px;
-	--tanstack-table-header-height: 54px;
-
-	--tanstack-cell-padding-top-override: 5px;
-	--tanstack-cell-padding-bottom-override: 5px;
-	--tanstack-cell-padding-right-override: 15px;
-
-	--tanstack-cell-padding-left-override: 15px;
-	--tanstack-cell-header-padding-left-override: 5px;
-
-	--tanstack-cell-header-padding-left-first-column: 15px;
-
-	--tanstack-plain-body-line-clamp: 1;
-
-	--tanstack-table-cell-bg: var(--l2-background);
-	--tanstack-table-header-cell-bg: var(--l1-background-hover);
-	--tanstack-table-row-hover-bg: var(--l1-background-hover);
-}

frontend/src/container/LLMObservability/Explorer/TracesTable/TracesTable.tsx

@@ -1,116 +0,0 @@
-import { useCallback } from 'react';
-import { useHistory } from 'react-router-dom';
-import ErrorInPlace from 'components/ErrorInPlace/ErrorInPlace';
-import TanStackTable from 'components/TanStackTableView';
-import type {
-	CellTypographySize,
-	TableColumnDef,
-} from 'components/TanStackTableView/types';
-import EmptyLogsSearch from 'container/EmptyLogsSearch/EmptyLogsSearch';
-import NoLogs from 'container/NoLogs/NoLogs';
-import { TracesLoading } from '../TraceLoading/TraceLoading';
-import APIError from 'types/api/error';
-import { DataSource, PanelTypeKeys } from 'types/common/queryBuilder';
-import { getAbsoluteUrl } from 'utils/basePath';
-
-import type { TracesTableRow } from './getFieldColumn';
-import styles from './TracesTable.module.scss';
-
-export type TracesTableProps = {
-	data: TracesTableRow[];
-	columns: TableColumnDef<TracesTableRow>[];
-	columnStorageKey?: string;
-	respectColumnOrder?: boolean;
-	panelType: PanelTypeKeys;
-	/** Builds the trace-detail href for a row; drives row click + cmd/ctrl-click. */
-	getRowHref: (row: TracesTableRow) => string;
-	isLoading: boolean;
-	isFetching: boolean;
-	isError: boolean;
-	error: APIError | Error | null;
-	isFilterApplied: boolean;
-	onColumnOrderChange?: (cols: TableColumnDef<TracesTableRow>[]) => void;
-	onColumnRemove?: (columnId: string) => void;
-	cellTypographySize?: CellTypographySize;
-};
-
-function TracesTable({
-	data,
-	columns,
-	columnStorageKey,
-	respectColumnOrder = false,
-	panelType,
-	getRowHref,
-	isLoading,
-	isFetching,
-	isError,
-	error,
-	isFilterApplied,
-	onColumnOrderChange,
-	onColumnRemove,
-	cellTypographySize = 'medium',
-}: TracesTableProps): JSX.Element {
-	const history = useHistory();
-
-	const isDataAbsent =
-		!isLoading && !isFetching && !isError && data.length === 0;
-
-	const handleRowClick = useCallback(
-		(row: TracesTableRow): void => {
-			history.push(getRowHref(row));
-		},
-		[history, getRowHref],
-	);
-
-	const handleRowClickNewTab = useCallback(
-		(row: TracesTableRow): void => {
-			window.open(getAbsoluteUrl(getRowHref(row)), '_blank', 'noopener');
-		},
-		[getRowHref],
-	);
-
-	return (
-		<>
-			{isError && error && <ErrorInPlace error={error as APIError} />}
-
-			{(isLoading || (isFetching && data.length === 0)) && <TracesLoading />}
-
-			{isDataAbsent && !isFilterApplied && (
-				<NoLogs dataSource={DataSource.TRACES} />
-			)}
-
-			{isDataAbsent && isFilterApplied && (
-				<EmptyLogsSearch dataSource={DataSource.TRACES} panelType={panelType} />
-			)}
-
-			{!isError && data.length !== 0 && (
-				<div className={styles.tableWrapper}>
-					<TanStackTable<TracesTableRow>
-						data={data}
-						columns={columns}
-						className={styles.tracesTable}
-						columnStorageKey={columnStorageKey}
-						respectColumnOrder={respectColumnOrder}
-						isLoading={isFetching}
-						cellTypographySize={cellTypographySize}
-						onColumnOrderChange={onColumnOrderChange}
-						onColumnRemove={onColumnRemove}
-						onRowClick={handleRowClick}
-						onRowClickNewTab={handleRowClickNewTab}
-						getRowTestId={(row): string => `traces-table-row-${row.id}`}
-					/>
-				</div>
-			)}
-		</>
-	);
-}
-
-TracesTable.defaultProps = {
-	columnStorageKey: undefined,
-	respectColumnOrder: false,
-	onColumnOrderChange: undefined,
-	onColumnRemove: undefined,
-	cellTypographySize: 'medium',
-};
-
-export default TracesTable;

frontend/src/container/LLMObservability/Explorer/TracesTable/constants.ts

@@ -1,18 +0,0 @@
-// Field-name allowlists that drive signal-specific cell rendering. Both legacy
-// camelCase and snake_case variants are listed because the API has shipped both.
-export const TIMESTAMP_FIELD_NAMES = new Set(['timestamp']);
-
-export const STATUS_FIELD_NAMES = new Set([
-	'httpMethod',
-	'http_method',
-	'http.method',
-	'http.request.method',
-	'responseStatusCode',
-	'response_status_code',
-	'http.status_code',
-	'http.response.status_code',
-]);
-
-export const DURATION_FIELD_NAMES = new Set(['durationNano', 'duration_nano']);
-
-export const TRACE_ID_FIELD_NAMES = new Set(['traceID', 'trace_id']);

frontend/src/container/LLMObservability/Explorer/TracesTable/getFieldColumn.tsx

@@ -1,26 +0,0 @@
-import { TelemetryFieldKey } from 'api/v5/v5';
-import type { TableColumnDef } from 'components/TanStackTableView/types';
-import { buildCompositeKey } from 'container/OptionsMenu/utils';
-
-import { TIMESTAMP_FIELD_NAMES } from './constants';
-import FieldCell from './FieldCell';
-
-export type TracesTableRow = { id: string } & Record<string, unknown>;
-
-export function getFieldColumn(
-	field: TelemetryFieldKey,
-): TableColumnDef<TracesTableRow> {
-	const { name, fieldContext, fieldDataType } = field;
-	const isTimestamp = TIMESTAMP_FIELD_NAMES.has(name);
-
-	return {
-		id: buildCompositeKey(name, fieldContext, fieldDataType),
-		header: name,
-		accessorFn: (row): unknown => row[name],
-		enableMove: !isTimestamp,
-		enableRemove: !isTimestamp,
-		canBeHidden: !isTimestamp,
-		width: { min: 192 },
-		cell: ({ value }): JSX.Element => <FieldCell name={name} value={value} />,
-	};
-}

frontend/src/container/LLMObservability/Explorer/TracesTable/utils.ts

@@ -1,12 +0,0 @@
-export function stringifyCellValue(value: unknown): string {
-	if (value == null) {
-		return '';
-	}
-	if (typeof value === 'string') {
-		return value;
-	}
-	if (typeof value === 'number' || typeof value === 'boolean') {
-		return String(value);
-	}
-	return JSON.stringify(value);
-}

frontend/src/container/LLMObservability/Explorer/TracesView/configs.ts

@@ -1,6 +1,9 @@
 import { TelemetryFieldKey } from 'api/v5/v5';
 import type { TableColumnDef } from 'components/TanStackTableView/types';
-import { getFieldColumn, TracesTableRow } from '../TracesTable/getFieldColumn';
+import {
+	getFieldColumn,
+	TracesTableRow,
+} from 'container/TracesExplorer/TracesTable/getFieldColumn';
 import { DEFAULT_PER_PAGE_OPTIONS } from 'hooks/queryPagination';
 
 export const PER_PAGE_OPTIONS: number[] = [10, ...DEFAULT_PER_PAGE_OPTIONS];

frontend/src/container/LLMObservability/Explorer/aiActions.ts

@@ -1,235 +0,0 @@
-/**
- * AI Assistant page-action factories for the Traces Explorer.
- *
- * Mirrors the logs equivalents — each factory closes over live page
- * state/callbacks so `execute()` always operates on the current query, and
- * the page component instantiates them via `useMemo` + `usePageActions`.
- *
- * See `pages/LogsExplorer/aiActions.ts` for the rationale behind writing
- * BOTH `filters.items` and `filter.expression` and then re-using the same
- * URL parser shape via `redirectWithQueryBuilderData`.
- */
-
-import { convertFiltersToExpression } from 'components/QueryBuilderV2/utils';
-import {
-	aiFilterToTagFilterItem,
-	FILTER_OP_ENUM,
-	FILTER_VALUE_DESCRIPTION,
-	FilterDeps,
-	replaceFirstQueryData,
-} from 'container/AIAssistant/pageActions/builderQueryHelpers';
-import {
-	ActionResult,
-	PageAction,
-} from 'container/AIAssistant/pageActions/types';
-import {
-	IBuilderQuery,
-	TagFilterItem,
-} from 'types/api/queryBuilder/queryBuilderData';
-
-interface AIFilter {
-	key: string;
-	op: string;
-	value: string;
-}
-
-interface RunQueryParams {
-	filters: AIFilter[];
-}
-
-interface AddFilterParams {
-	key: string;
-	op: string;
-	value: string;
-}
-
-type TracesView = 'list' | 'timeseries' | 'table' | 'trace';
-
-interface ChangeViewParams {
-	view: TracesView;
-}
-
-interface SaveViewParams {
-	name: string;
-}
-
-/**
- * Replace all active span filters and navigate to the updated query URL
- * (which makes the WHERE clause reflect the new filters and triggers a re-run).
- */
-export function tracesRunQueryAction(
-	deps: FilterDeps,
-): PageAction<RunQueryParams> {
-	return {
-		id: 'traces.runQuery',
-		description: 'Replace the active trace filters and re-run the query',
-		parameters: {
-			type: 'object',
-			properties: {
-				filters: {
-					type: 'array',
-					description: 'Replacement filter list',
-					items: {
-						type: 'object',
-						properties: {
-							key: {
-								type: 'string',
-								description: 'Attribute key, e.g. service.name, http.status_code',
-							},
-							op: {
-								type: 'string',
-								enum: [...FILTER_OP_ENUM],
-							},
-							value: {
-								type: 'string',
-								description: FILTER_VALUE_DESCRIPTION,
-							},
-						},
-						required: ['key', 'op', 'value'],
-					},
-				},
-			},
-			required: ['filters'],
-		},
-		autoApply: true,
-		execute: async ({ filters }): Promise<ActionResult> => {
-			const baseQuery = deps.currentQuery.builder.queryData[0];
-			if (!baseQuery) {
-				throw new Error('No active query found in Traces Explorer.');
-			}
-
-			const tagItems = filters.map(aiFilterToTagFilterItem);
-			const newFilters = { items: tagItems, op: 'AND' };
-			const updatedBuilderQuery: IBuilderQuery = {
-				...baseQuery,
-				filters: newFilters,
-				filter: convertFiltersToExpression(newFilters),
-			};
-
-			deps.handleSetQueryData(0, updatedBuilderQuery);
-			deps.redirectWithQueryBuilderData(
-				replaceFirstQueryData(deps.currentQuery, updatedBuilderQuery),
-			);
-
-			return {
-				summary: `Query updated with ${filters.length} filter(s) and re-run.`,
-			};
-		},
-		getContext: (): Record<string, unknown> => ({
-			filters:
-				deps.currentQuery.builder.queryData[0]?.filters?.items?.map(
-					(f: TagFilterItem) => ({
-						key: f.key?.key,
-						op: f.op,
-						value: f.value,
-					}),
-				) ?? [],
-		}),
-	};
-}
-
-/**
- * Append a single filter to the existing trace query and navigate to the
- * updated URL.
- */
-export function tracesAddFilterAction(
-	deps: FilterDeps,
-): PageAction<AddFilterParams> {
-	return {
-		id: 'traces.addFilter',
-		description: 'Add a single filter to the current trace query and re-run',
-		parameters: {
-			type: 'object',
-			properties: {
-				key: {
-					type: 'string',
-					description: 'Attribute key, e.g. service.name, http.status_code',
-				},
-				op: {
-					type: 'string',
-					enum: [...FILTER_OP_ENUM],
-				},
-				value: {
-					type: 'string',
-					description: FILTER_VALUE_DESCRIPTION,
-				},
-			},
-			required: ['key', 'op', 'value'],
-		},
-		autoApply: true,
-		execute: async ({ key, op, value }): Promise<ActionResult> => {
-			const baseQuery = deps.currentQuery.builder.queryData[0];
-			if (!baseQuery) {
-				throw new Error('No active query found in Traces Explorer.');
-			}
-
-			const existing = baseQuery.filters?.items ?? [];
-			const newItem = aiFilterToTagFilterItem({ key, op, value });
-			const newFilters = { items: [...existing, newItem], op: 'AND' };
-			const updatedBuilderQuery: IBuilderQuery = {
-				...baseQuery,
-				filters: newFilters,
-				filter: convertFiltersToExpression(newFilters),
-			};
-
-			deps.handleSetQueryData(0, updatedBuilderQuery);
-			deps.redirectWithQueryBuilderData(
-				replaceFirstQueryData(deps.currentQuery, updatedBuilderQuery),
-			);
-
-			return { summary: `Filter added: ${key} ${op} "${value}". Query re-run.` };
-		},
-	};
-}
-
-/**
- * Switch the traces explorer between list / timeseries / table / trace views.
- */
-export function tracesChangeViewAction(deps: {
-	onChangeView: (view: TracesView) => void;
-}): PageAction<ChangeViewParams> {
-	return {
-		id: 'traces.changeView',
-		description:
-			'Switch the Traces Explorer between list, timeseries, table, and trace views',
-		parameters: {
-			type: 'object',
-			properties: {
-				view: {
-					type: 'string',
-					enum: ['list', 'timeseries', 'table', 'trace'],
-					description: 'The panel view to switch to',
-				},
-			},
-			required: ['view'],
-		},
-		execute: async ({ view }): Promise<ActionResult> => {
-			deps.onChangeView(view);
-			return { summary: `Switched to the "${view}" view.` };
-		},
-	};
-}
-
-/**
- * Save the current trace query as a named view (stub — wires to real API
- * when available).
- */
-export function tracesSaveViewAction(deps: {
-	onSaveView: (name: string) => Promise<void>;
-}): PageAction<SaveViewParams> {
-	return {
-		id: 'traces.saveView',
-		description: 'Save the current trace query as a named view',
-		parameters: {
-			type: 'object',
-			properties: {
-				name: { type: 'string', description: 'Name for the saved view' },
-			},
-			required: ['name'],
-		},
-		execute: async ({ name }): Promise<ActionResult> => {
-			await deps.onSaveView(name);
-			return { summary: `View "${name}" saved.` };
-		},
-	};
-}

frontend/src/container/LLMObservability/ToolbarActions/LeftToolbarActions.tsx

@@ -1,132 +0,0 @@
-import {
-	ArrowUpToLine,
-	Atom,
-	Filter,
-	SquareMousePointer,
-	Terminal,
-	Binoculars,
-} from '@signozhq/icons';
-import { Button, Tooltip } from 'antd';
-import cx from 'classnames';
-import { ExplorerViews } from 'pages/LogsExplorer/utils';
-
-import './ToolbarActions.styles.scss';
-
-interface LeftToolbarActionsProps {
-	items: any;
-	selectedView: string;
-	onChangeSelectedView: (view: ExplorerViews) => void;
-	showFilter: boolean;
-	handleFilterVisibilityChange: () => void;
-}
-
-const activeTab = 'active-tab';
-
-export default function LeftToolbarActions({
-	items,
-	selectedView,
-	onChangeSelectedView,
-	showFilter,
-	handleFilterVisibilityChange,
-}: LeftToolbarActionsProps): JSX.Element {
-	const { clickhouse, list, timeseries, table, trace } = items;
-
-	return (
-		<div className="left-toolbar">
-			{!showFilter && (
-				<Tooltip title="Show Filters">
-					<Button onClick={handleFilterVisibilityChange} className="filter-btn">
-						<Filter size={12} />
-						<ArrowUpToLine size={12} style={{ transform: 'rotate(90deg)' }} />
-					</Button>
-				</Tooltip>
-			)}
-			<div className="left-toolbar-query-actions">
-				{list?.show && (
-					<Tooltip title="List View">
-						<Button
-							disabled={list.disabled}
-							className={cx(
-								'list-view-tab',
-								'explorer-view-option',
-								selectedView === list.key ? activeTab : '',
-							)}
-							onClick={(): void => onChangeSelectedView(list.key)}
-						>
-							<SquareMousePointer size={14} data-testid="search-view" />
-							List View
-						</Button>
-					</Tooltip>
-				)}
-
-				{trace?.show && (
-					<Tooltip title="Trace View">
-						<Button
-							disabled={trace.disabled}
-							className={cx(
-								'trace-view-tab',
-								'explorer-view-option',
-								selectedView === trace.key ? activeTab : '',
-							)}
-							onClick={(): void => onChangeSelectedView(trace.key)}
-						>
-							<SquareMousePointer size={14} data-testid="trace-view" />
-							Trace View
-						</Button>
-					</Tooltip>
-				)}
-
-				{timeseries?.show && (
-					<Tooltip title="Time Series">
-						<Button
-							disabled={timeseries.disabled}
-							className={cx(
-								'timeseries-view-tab',
-								'explorer-view-option',
-								selectedView === timeseries.key ? activeTab : '',
-							)}
-							onClick={(): void => onChangeSelectedView(timeseries.key)}
-						>
-							<Atom size={14} data-testid="query-builder-view" />
-							Time Series
-						</Button>
-					</Tooltip>
-				)}
-
-				{clickhouse?.show && (
-					<Tooltip title="Clickhouse">
-						<Button
-							disabled={clickhouse.disabled}
-							className={cx(
-								'clickhouse-view-tab',
-								'explorer-view-option',
-								selectedView === clickhouse.key ? activeTab : '',
-							)}
-							onClick={(): void => onChangeSelectedView(clickhouse.key)}
-						>
-							<Terminal size={14} data-testid="clickhouse-view" />
-							Clickhouse
-						</Button>
-					</Tooltip>
-				)}
-
-				{table?.show && (
-					<Tooltip title="Table">
-						<Button
-							disabled={table.disabled}
-							className={cx(
-								'table-view-tab',
-								'explorer-view-option',
-								selectedView === table.key ? activeTab : '',
-							)}
-							onClick={(): void => onChangeSelectedView(table.key)}
-						>
-							<Binoculars size={14} data-testid="query-builder-view-v2" />
-							Table
-						</Button>
-					</Tooltip>
-				)}
-			</div>
-		</div>
-	);
-}

frontend/src/container/LLMObservability/ToolbarActions/ToolbarActions.styles.scss

@@ -1,125 +0,0 @@
-.left-toolbar {
-	display: flex;
-	align-items: center;
-
-	.filter-btn {
-		display: flex;
-		align-items: center;
-		justify-content: center;
-		box-shadow: none;
-		height: 32px;
-		margin-right: 12px;
-		border: 1px solid var(--l1-border);
-	}
-
-	.left-toolbar-query-actions {
-		display: flex;
-		border-radius: 2px;
-		border: 1px solid var(--l1-border);
-		background: var(--l1-background);
-		flex-direction: row;
-		border-bottom: none;
-		margin-bottom: -1px;
-
-		.prom-ql-icon {
-			height: 14px;
-			width: 14px;
-		}
-
-		.explorer-view-option {
-			display: flex;
-			align-items: center;
-			justify-content: center;
-			flex-direction: row;
-			border: none;
-			padding: 9px;
-			box-shadow: none;
-			border-radius: 0px;
-			border-left: 1px solid var(--l1-border);
-			border-bottom: 1px solid var(--l1-border);
-
-			gap: 8px;
-
-			&.active-tab {
-				background-color: var(--primary-background);
-				border-bottom: 1px solid var(--primary-background);
-				color: var(--primary-foreground);
-
-				&:hover {
-					background-color: var(--primary-background) !important;
-				}
-			}
-
-			&:disabled {
-				background-color: var(--l3-background);
-				opacity: 0.6;
-			}
-
-			&:first-child {
-				border-left: 1px solid transparent;
-			}
-
-			&:hover {
-				background-color: transparent !important;
-				border-left: 1px solid transparent !important;
-				color: var(--l1-foreground);
-			}
-		}
-	}
-
-	.frequency-chart-view-controller {
-		display: flex;
-		align-items: center;
-		padding-left: 8px;
-		gap: 8px;
-	}
-}
-
-.right-toolbar {
-	display: flex;
-	align-items: center;
-	background-color: var(--bg-robin-600);
-}
-
-.right-actions {
-	display: flex;
-	align-items: center;
-}
-
-.loading-container {
-	display: flex;
-	gap: 8px;
-	align-items: center;
-
-	.loading-btn {
-		display: flex;
-		width: 32px;
-		height: 33px;
-		padding: 4px 10px;
-		justify-content: center;
-		align-items: center;
-		gap: 6px;
-		flex-shrink: 0;
-		border-radius: 2px;
-		background: var(--l3-background);
-		box-shadow: none;
-		border: none;
-	}
-
-	.cancel-run {
-		display: flex;
-		height: 33px;
-		padding: 4px 10px;
-		justify-content: center;
-		align-items: center;
-		gap: 6px;
-		flex: 1 0 0;
-		border-radius: 2px;
-		background: var(--danger-background);
-		border: none;
-	}
-	.cancel-run:hover {
-		background-color: var(--bg-cherry-400) !important;
-		color: var(--l1-foreground) !important;
-	}
-}

frontend/src/container/MeterExplorer/Explorer/Explorer.tsx

@@ -6,11 +6,6 @@ import logEvent from 'api/common/logEvent';
 import cx from 'classnames';
 import { QueryBuilderV2 } from 'components/QueryBuilderV2/QueryBuilderV2';
 import QuickFilters from 'components/QuickFilters/QuickFilters';
-import {
-	TelemetrytypesSignalDTO,
-	TelemetrytypesSourceDTO,
-} from 'api/generated/services/sigNoz.schemas';
-import { useSignalFieldApis } from 'components/QuickFilters/hooks/useSignalFieldApis';
 import { QuickFiltersSource, SignalType } from 'components/QuickFilters/types';
 import { initialQueryMeterWithType, PANEL_TYPES } from 'constants/queryBuilder';
 import { REACT_QUERY_KEY } from 'constants/reactQueryKeys';
@@ -36,10 +31,6 @@ import { splitQueryIntoOneChartPerQuery } from './utils';
 import './Explorer.styles.scss';
 
 function Explorer(): JSX.Element {
-	const quickFilterFieldApis = useSignalFieldApis(
-		TelemetrytypesSignalDTO.metrics,
-		TelemetrytypesSourceDTO.meter,
-	);
 	const {
 		handleRunQuery,
 		stagedQuery,
@@ -146,14 +137,13 @@ function Explorer(): JSX.Element {
 				>
 					<QuickFilters
 						className="qf-meter-explorer"
-						pageSource={QuickFiltersSource.METER_EXPLORER}
-						quickFilterSignal={SignalType.METER_EXPLORER}
+						source={QuickFiltersSource.METER_EXPLORER}
+						signal={SignalType.METER_EXPLORER}
 						showFilterCollapse
 						showQueryName={false}
 						handleFilterVisibilityChange={(): void => {
 							setShowQuickFilters(!showQuickFilters);
 						}}
-						useFieldApis={quickFilterFieldApis}
 					/>
 				</div>
 

frontend/src/pages/AllErrors/index.tsx

@@ -8,8 +8,6 @@ import setLocalStorageApi from 'api/browser/localstorage/set';
 import cx from 'classnames';
 import HeaderRightSection from 'components/HeaderRightSection/HeaderRightSection';
 import QuickFilters from 'components/QuickFilters/QuickFilters';
-import { TelemetrytypesSignalDTO } from 'api/generated/services/sigNoz.schemas';
-import { useSignalFieldApis } from 'components/QuickFilters/hooks/useSignalFieldApis';
 import { QuickFiltersSource, SignalType } from 'components/QuickFilters/types';
 import RouteTab from 'components/RouteTab';
 import TypicalOverlayScrollbar from 'components/TypicalOverlayScrollbar/TypicalOverlayScrollbar';
@@ -57,20 +55,15 @@ function AllErrors(): JSX.Element {
 		setShowFilters((prev) => !prev);
 	};
 
-	const quickFilterFieldApis = useSignalFieldApis(
-		TelemetrytypesSignalDTO.traces,
-	);
-
 	return (
 		<div className={cx('all-errors-page', showFilters ? 'filter-visible' : '')}>
 			{showFilters && (
 				<section className={cx('all-errors-quick-filter-section')}>
 					<QuickFilters
 						className="qf-exceptions"
-						pageSource={QuickFiltersSource.EXCEPTIONS}
-						quickFilterSignal={SignalType.EXCEPTIONS}
+						source={QuickFiltersSource.EXCEPTIONS}
+						signal={SignalType.EXCEPTIONS}
 						handleFilterVisibilityChange={handleFilterVisibilityChange}
-						useFieldApis={quickFilterFieldApis}
 					/>
 				</section>
 			)}

frontend/src/pages/LogsExplorer/index.tsx

@@ -7,8 +7,6 @@ import cx from 'classnames';
 import ExplorerCard from 'components/ExplorerCard/ExplorerCard';
 import QueryCancelledPlaceholder from 'components/QueryCancelledPlaceholder';
 import QuickFilters from 'components/QuickFilters/QuickFilters';
-import { TelemetrytypesSignalDTO } from 'api/generated/services/sigNoz.schemas';
-import { useSignalFieldApis } from 'components/QuickFilters/hooks/useSignalFieldApis';
 import { QuickFiltersSource, SignalType } from 'components/QuickFilters/types';
 import WarningPopover from 'components/WarningPopover/WarningPopover';
 import { LOCALSTORAGE } from 'constants/localStorage';
@@ -76,8 +74,6 @@ function LogsExplorer(): JSX.Element {
 
 	const { handleExplorerTabChange } = useHandleExplorerTabChange();
 
-	const quickFilterFieldApis = useSignalFieldApis(TelemetrytypesSignalDTO.logs);
-
 	const isAIAssistantEnabled = useIsAIAssistantEnabled();
 
 	const listQueryKeyRef = useRef<any>();
@@ -233,10 +229,9 @@ function LogsExplorer(): JSX.Element {
 						<section className={cx('log-quick-filter-left-section')}>
 							<QuickFilters
 								className="qf-logs-explorer"
-								quickFilterSignal={SignalType.LOGS}
-								pageSource={QuickFiltersSource.LOGS_EXPLORER}
+								signal={SignalType.LOGS}
+								source={QuickFiltersSource.LOGS_EXPLORER}
 								handleFilterVisibilityChange={handleFilterVisibilityChange}
-								useFieldApis={quickFilterFieldApis}
 							/>
 						</section>
 					)}

frontend/src/pages/TracesExplorer/index.tsx

@@ -8,8 +8,6 @@ import cx from 'classnames';
 import ExplorerCard from 'components/ExplorerCard/ExplorerCard';
 import QueryCancelledPlaceholder from 'components/QueryCancelledPlaceholder';
 import QuickFilters from 'components/QuickFilters/QuickFilters';
-import { TelemetrytypesSignalDTO } from 'api/generated/services/sigNoz.schemas';
-import { useSignalFieldApis } from 'components/QuickFilters/hooks/useSignalFieldApis';
 import { QuickFiltersSource, SignalType } from 'components/QuickFilters/types';
 import WarningPopover from 'components/WarningPopover/WarningPopover';
 import { LOCALSTORAGE } from 'constants/localStorage';
@@ -130,10 +128,6 @@ function TracesExplorer(): JSX.Element {
 	);
 
 	const { handleExplorerTabChange } = useHandleExplorerTabChange();
-
-	const quickFilterFieldApis = useSignalFieldApis(
-		TelemetrytypesSignalDTO.traces,
-	);
 	const { safeNavigate } = useSafeNavigate();
 	const getExportToDashboardLink = useGetExportToDashboardLink();
 
@@ -268,12 +262,11 @@ function TracesExplorer(): JSX.Element {
 				<Card className="filter" hidden={!isOpen}>
 					<QuickFilters
 						className="qf-traces-explorer"
-						pageSource={QuickFiltersSource.TRACES_EXPLORER}
-						quickFilterSignal={SignalType.TRACES}
+						source={QuickFiltersSource.TRACES_EXPLORER}
+						signal={SignalType.TRACES}
 						handleFilterVisibilityChange={(): void => {
 							setOpen(!isOpen);
 						}}
-						useFieldApis={quickFilterFieldApis}
 					/>
 				</Card>
 				<div

go.mod

@@ -57,6 +57,7 @@ require (
 	github.com/segmentio/analytics-go/v3 v3.2.1
 	github.com/sethvargo/go-password v0.2.0
 	github.com/smartystreets/goconvey v1.8.1
+	github.com/soheilhy/cmux v0.1.5
 	github.com/spf13/cobra v1.10.2
 	github.com/stretchr/testify v1.11.1
 	github.com/swaggest/jsonschema-go v0.3.78

go.sum

@@ -1057,6 +1057,8 @@ github.com/smartystreets/assertions v0.0.0-20180927180507-b2de0cb4f26d/go.mod h1
 github.com/smartystreets/goconvey v1.6.4/go.mod h1:syvi0/a8iFYH4r/RixwvyeAJjdLS9QV7WQ/tjFTllLA=
 github.com/smartystreets/goconvey v1.8.1 h1:qGjIddxOk4grTu9JPOU31tVfq3cNdBlNa5sSznIX1xY=
 github.com/smartystreets/goconvey v1.8.1/go.mod h1:+/u4qLyY6x1jReYOp7GOM2FSt8aP9CzCZL03bI28W60=
+github.com/soheilhy/cmux v0.1.5 h1:jjzc5WVemNEDTLwv9tlmemhC73tI08BNOIGwBOo10Js=
+github.com/soheilhy/cmux v0.1.5/go.mod h1:T7TcVDs9LWfQgPlPsdngu6I6QIoyIFZDDC6sNE1GqG0=
 github.com/sourcegraph/conc v0.3.0 h1:OQTbbt6P72L20UqAkXXuLOj79LfEanQ+YQFNpLA9ySo=
 github.com/sourcegraph/conc v0.3.0/go.mod h1:Sdozi7LEKbFPqYX2/J+iBAM6HpqSLTASQIKqDmF7Mt0=
 github.com/spaolacci/murmur3 v0.0.0-20180118202830-f09979ecbc72/go.mod h1:JwIasOWyU6f++ZhiEuf87xNszmSA2myDM2Kzu9HwQUA=
@@ -1491,6 +1493,7 @@ golang.org/x/net v0.0.0-20200822124328-c89045814202/go.mod h1:/O7V0waA8r7cgGh81R
 golang.org/x/net v0.0.0-20201021035429-f5854403a974/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU=
 golang.org/x/net v0.0.0-20201031054903-ff519b6c9102/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU=
 golang.org/x/net v0.0.0-20201110031124-69a78807bb2b/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU=
+golang.org/x/net v0.0.0-20201202161906-c7110b5ffcbb/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU=
 golang.org/x/net v0.0.0-20201209123823-ac852fbbde11/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
 golang.org/x/net v0.0.0-20201224014010-6772e930b67b/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
 golang.org/x/net v0.0.0-20210119194325-5f4716e94777/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=

pkg/apiserver/apiserver.go

@@ -1,14 +1,10 @@
 package apiserver
 
 import (
-	"github.com/SigNoz/signoz/pkg/factory"
 	"github.com/gorilla/mux"
 )
 
 type APIServer interface {
-	// APIServer is a long running service serving the SigNoz API.
-	factory.ServiceWithHealthy
-
 	// Returns the mux router for the API server. Primarily used for collecting OpenAPI operations.
 	Router() *mux.Router
 

pkg/apiserver/config.go

@@ -3,16 +3,13 @@ package apiserver
 import (
 	"time"
 
-	"github.com/SigNoz/signoz/pkg/errors"
 	"github.com/SigNoz/signoz/pkg/factory"
-	httpserver "github.com/SigNoz/signoz/pkg/http/server"
 )
 
 // Config holds the configuration for config.
 type Config struct {
-	httpserver.Config `mapstructure:",squash" yaml:",squash"`
-	Timeout           Timeout `mapstructure:"timeout"`
-	Logging           Logging `mapstructure:"logging"`
+	Timeout Timeout `mapstructure:"timeout"`
+	Logging Logging `mapstructure:"logging"`
 }
 
 type Timeout struct {
@@ -35,10 +32,6 @@ func NewConfigFactory() factory.ConfigFactory {
 
 func newConfig() factory.Config {
 	return &Config{
-		Config: httpserver.Config{
-			Address:     "0.0.0.0:8080",
-			ReadTimeout: 60 * time.Second,
-		},
 		Timeout: Timeout{
 			Default: 60 * time.Second,
 			Max:     600 * time.Second,
@@ -59,9 +52,5 @@ func newConfig() factory.Config {
 }
 
 func (c Config) Validate() error {
-	if c.Address == "" {
-		return errors.NewInvalidInputf(errors.CodeInvalidInput, "apiserver.address is required")
-	}
-
 	return nil
 }

pkg/apiserver/config_test.go

@@ -8,14 +8,11 @@ import (
 	"github.com/SigNoz/signoz/pkg/config"
 	"github.com/SigNoz/signoz/pkg/config/envprovider"
 	"github.com/SigNoz/signoz/pkg/factory"
-	httpserver "github.com/SigNoz/signoz/pkg/http/server"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
 
 func TestNewWithEnvProvider(t *testing.T) {
-	t.Setenv("SIGNOZ_APISERVER_ADDRESS", "0.0.0.0:9090")
-	t.Setenv("SIGNOZ_APISERVER_READ__TIMEOUT", "80s")
 	t.Setenv("SIGNOZ_APISERVER_TIMEOUT_DEFAULT", "70s")
 	t.Setenv("SIGNOZ_APISERVER_TIMEOUT_MAX", "700s")
 	t.Setenv("SIGNOZ_APISERVER_TIMEOUT_EXCLUDED__ROUTES", "/excluded1,/excluded2")
@@ -41,10 +38,6 @@ func TestNewWithEnvProvider(t *testing.T) {
 	require.NoError(t, err)
 
 	expected := &Config{
-		Config: httpserver.Config{
-			Address:     "0.0.0.0:9090",
-			ReadTimeout: 80 * time.Second,
-		},
 		Timeout: Timeout{
 			Default: 70 * time.Second,
 			Max:     700 * time.Second,

pkg/apiserver/signozapiserver/provider.go

@@ -2,11 +2,9 @@ package signozapiserver
 
 import (
 	"context"
-	"net/http"
 
 	"github.com/SigNoz/signoz/pkg/alertmanager"
 	"github.com/SigNoz/signoz/pkg/apiserver"
-	"github.com/SigNoz/signoz/pkg/auditor"
 	"github.com/SigNoz/signoz/pkg/authz"
 	"github.com/SigNoz/signoz/pkg/factory"
 	"github.com/SigNoz/signoz/pkg/flagger"
@@ -14,8 +12,6 @@ import (
 	"github.com/SigNoz/signoz/pkg/global"
 	"github.com/SigNoz/signoz/pkg/http/handler"
 	"github.com/SigNoz/signoz/pkg/http/middleware"
-	httpserver "github.com/SigNoz/signoz/pkg/http/server"
-	"github.com/SigNoz/signoz/pkg/identn"
 	"github.com/SigNoz/signoz/pkg/licensing"
 	"github.com/SigNoz/signoz/pkg/modules/aiobservability"
 	"github.com/SigNoz/signoz/pkg/modules/authdomain"
@@ -41,22 +37,18 @@ import (
 	"github.com/SigNoz/signoz/pkg/prometheus"
 	"github.com/SigNoz/signoz/pkg/querier"
 	"github.com/SigNoz/signoz/pkg/ruler"
-	"github.com/SigNoz/signoz/pkg/sharder"
 	"github.com/SigNoz/signoz/pkg/statsreporter"
 	"github.com/SigNoz/signoz/pkg/subscription"
 	"github.com/SigNoz/signoz/pkg/types"
 	"github.com/SigNoz/signoz/pkg/types/authtypes"
-	"github.com/SigNoz/signoz/pkg/web"
 	"github.com/SigNoz/signoz/pkg/zeus"
 	"github.com/gorilla/mux"
 )
 
 type provider struct {
-	globalConfig               global.Config
-	web                        web.Web
+	config                     apiserver.Config
+	settings                   factory.ScopedProviderSettings
 	router                     *mux.Router
-	httpServer                 *httpserver.Server
-	healthyC                   chan struct{}
 	authzMiddleware            *middleware.AuthZ
 	authzService               authz.AuthZ
 	orgHandler                 organization.Handler
@@ -140,11 +132,6 @@ func NewFactory(
 	rulerHandler ruler.Handler,
 	statsHandler statsreporter.Handler,
 	savedViewHandler savedview.Handler,
-	globalConfig global.Config,
-	identNResolver identn.IdentNResolver,
-	sharder sharder.Sharder,
-	auditor auditor.Auditor,
-	web web.Web,
 	quickFilterModule quickfilter.Module,
 	quickFilterHandler quickfilter.Handler,
 ) factory.ProviderFactory[apiserver.APIServer, apiserver.Config] {
@@ -192,11 +179,6 @@ func NewFactory(
 			rulerHandler,
 			statsHandler,
 			savedViewHandler,
-			globalConfig,
-			identNResolver,
-			sharder,
-			auditor,
-			web,
 			quickFilterModule,
 			quickFilterHandler,
 		)
@@ -246,11 +228,6 @@ func newProvider(
 	rulerHandler ruler.Handler,
 	statsHandler statsreporter.Handler,
 	savedViewHandler savedview.Handler,
-	globalConfig global.Config,
-	identNResolver identn.IdentNResolver,
-	sharder sharder.Sharder,
-	auditor auditor.Auditor,
-	web web.Web,
 	quickFilterModule quickfilter.Module,
 	quickFilterHandler quickfilter.Handler,
 ) (apiserver.APIServer, error) {
@@ -258,10 +235,9 @@ func newProvider(
 	router := mux.NewRouter().UseEncodedPath()
 
 	provider := &provider{
-		globalConfig:               globalConfig,
-		web:                        web,
+		config:                     config,
+		settings:                   settings,
 		router:                     router,
-		healthyC:                   make(chan struct{}),
 		orgHandler:                 orgHandler,
 		userHandler:                userHandler,
 		authzService:               authzService,
@@ -306,68 +282,13 @@ func newProvider(
 
 	provider.authzMiddleware = middleware.NewAuthZ(settings.Logger(), orgGetter, authzService)
 
-	router.Use(middleware.NewRecovery(settings.Logger()).Wrap)
-	router.Use(middleware.NewOtel("apiserver", providerSettings.MeterProvider, providerSettings.TracerProvider).Wrap)
-	router.Use(middleware.NewIdentN(identNResolver, sharder, settings.Logger()).Wrap)
-	router.Use(middleware.NewTimeout(settings.Logger(),
-		config.Timeout.ExcludedRoutes,
-		config.Timeout.Default,
-		config.Timeout.Max,
-	).Wrap)
-	router.Use(middleware.NewResource(settings.Logger()).Wrap)
-	router.Use(middleware.NewAudit(settings.Logger(), config.Logging.ExcludedRoutes, auditor).Wrap)
-	router.Use(middleware.NewComment().Wrap)
-
 	if err := provider.AddToRouter(router); err != nil {
 		return nil, err
 	}
 
-	httpHandler := middleware.NewCors().Wrap(router)
-	httpHandler = middleware.NewCompress().Wrap(httpHandler)
-
-	routePrefix := globalConfig.ExternalPath()
-	if routePrefix != "" {
-		prefixed := http.StripPrefix(routePrefix, httpHandler)
-		httpHandler = http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
-			switch req.URL.Path {
-			case "/api/v1/health", "/api/v2/healthz", "/api/v2/readyz", "/api/v2/livez":
-				router.ServeHTTP(w, req)
-				return
-			}
-
-			prefixed.ServeHTTP(w, req)
-		})
-	}
-
-	httpServer, err := httpserver.New(settings.Logger(), config.Config, httpHandler)
-	if err != nil {
-		return nil, err
-	}
-	provider.httpServer = httpServer
-
 	return provider, nil
 }
 
-func (provider *provider) Start(ctx context.Context) error {
-	// Mount the web routes last so the catch-all prefix does not shadow API
-	// routes registered on the router after construction.
-	if err := provider.web.AddToRouter(provider.router); err != nil {
-		return err
-	}
-
-	close(provider.healthyC)
-
-	return provider.httpServer.Start(ctx)
-}
-
-func (provider *provider) Stop(ctx context.Context) error {
-	return provider.httpServer.Stop(ctx)
-}
-
-func (provider *provider) Healthy() <-chan struct{} {
-	return provider.healthyC
-}
-
 func (provider *provider) Router() *mux.Router {
 	return provider.router
 }

pkg/factory/registry.go

@@ -78,40 +78,6 @@ func NewRegistry(ctx context.Context, logger *slog.Logger, services ...NamedServ
 	}, nil
 }
 
-// Add registers additional services into the registry. It must be called before Start.
-func (registry *Registry) Add(ctx context.Context, services ...NamedService) error {
-	added := make([]*serviceWithState, 0, len(services))
-	for _, s := range services {
-		if _, ok := registry.servicesByName[s.Name()]; ok {
-			return errors.Newf(errors.TypeInvalidInput, ErrCodeInvalidRegistry, "cannot add service, duplicate service name %q", s.Name())
-		}
-		added = append(added, newServiceWithState(s))
-	}
-
-	for _, ss := range added {
-		registry.services = append(registry.services, ss)
-		registry.servicesByName[ss.service.Name()] = ss
-	}
-
-	for _, ss := range added {
-		for _, dep := range ss.service.DependsOn() {
-			if dep == ss.service.Name() {
-				registry.logger.ErrorContext(ctx, "ignoring self-dependency", slog.Any("service", ss.service.Name()))
-				continue
-			}
-
-			if _, ok := registry.servicesByName[dep]; !ok {
-				registry.logger.ErrorContext(ctx, "ignoring unknown dependency", slog.Any("service", ss.service.Name()), slog.Any("dependency", dep))
-				continue
-			}
-
-			ss.dependsOn = append(ss.dependsOn, dep)
-		}
-	}
-
-	return detectCyclicDeps(registry.services)
-}
-
 func (registry *Registry) Start(ctx context.Context) {
 	for _, ss := range registry.services {
 		go func(ss *serviceWithState) {

pkg/factory/registry_test.go

@@ -342,61 +342,3 @@ func TestDependsOnCycleReturnsError(t *testing.T) {
 	assert.Error(t, err)
 	assert.Contains(t, err.Error(), "dependency cycles detected")
 }
-
-func TestRegistryAdd(t *testing.T) {
-	s1 := newTestService(t)
-	s2 := newTestService(t)
-
-	registry, err := NewRegistry(context.Background(), slog.New(slog.DiscardHandler), NewNamedService(MustNewName("s1"), s1))
-	require.NoError(t, err)
-
-	require.NoError(t, registry.Add(context.Background(), NewNamedService(MustNewName("s2"), s2)))
-
-	ctx := context.Background()
-	registry.Start(ctx)
-
-	require.NoError(t, registry.AwaitHealthy(ctx))
-	byState := registry.ServicesByState()
-	assert.Len(t, byState[StateRunning], 2)
-	assert.True(t, registry.IsHealthy())
-
-	assert.NoError(t, registry.Stop(ctx))
-}
-
-func TestRegistryAddDuplicateReturnsError(t *testing.T) {
-	s1 := newTestService(t)
-
-	registry, err := NewRegistry(context.Background(), slog.New(slog.DiscardHandler), NewNamedService(MustNewName("s1"), s1))
-	require.NoError(t, err)
-
-	err = registry.Add(context.Background(), NewNamedService(MustNewName("s1"), newTestService(t)))
-	assert.Error(t, err)
-	assert.Contains(t, err.Error(), "duplicate service name")
-}
-
-func TestRegistryAddWithDependency(t *testing.T) {
-	s1 := newHealthyTestService(t)
-	s2 := newTestService(t)
-
-	registry, err := NewRegistry(context.Background(), slog.New(slog.DiscardHandler), NewNamedService(MustNewName("s1"), s1))
-	require.NoError(t, err)
-
-	// s2 depends on the already registered s1.
-	require.NoError(t, registry.Add(context.Background(), NewNamedService(MustNewName("s2"), s2, MustNewName("s1"))))
-
-	ctx := context.Background()
-	registry.Start(ctx)
-
-	// s2 stays in STARTING until s1 is healthy.
-	require.Eventually(t, func() bool {
-		byState := registry.ServicesByState()
-		return len(byState[StateStarting]) == 2
-	}, time.Second, time.Millisecond)
-
-	close(s1.healthyC)
-
-	require.NoError(t, registry.AwaitHealthy(ctx))
-	assert.True(t, registry.IsHealthy())
-
-	assert.NoError(t, registry.Stop(ctx))
-}

pkg/http/middleware/compress.go

@@ -1,17 +0,0 @@
-package middleware
-
-import (
-	"net/http"
-
-	gorillahandlers "github.com/gorilla/handlers"
-)
-
-type Compress struct{}
-
-func NewCompress() *Compress {
-	return &Compress{}
-}
-
-func (middleware *Compress) Wrap(next http.Handler) http.Handler {
-	return gorillahandlers.CompressHandler(next)
-}

pkg/http/middleware/cors.go

@@ -1,25 +0,0 @@
-package middleware
-
-import (
-	"net/http"
-
-	"github.com/rs/cors"
-)
-
-type Cors struct {
-	cors *cors.Cors
-}
-
-func NewCors() *Cors {
-	return &Cors{
-		cors: cors.New(cors.Options{
-			AllowedOrigins: []string{"*"},
-			AllowedMethods: []string{"GET", "DELETE", "POST", "PUT", "PATCH", "OPTIONS"},
-			AllowedHeaders: []string{"Accept", "Authorization", "Content-Type", "cache-control"},
-		}),
-	}
-}
-
-func (middleware *Cors) Wrap(next http.Handler) http.Handler {
-	return middleware.cors.Handler(next)
-}

pkg/http/middleware/otel.go

@@ -1,43 +0,0 @@
-package middleware
-
-import (
-	"net/http"
-	"slices"
-
-	"github.com/gorilla/mux"
-	"go.opentelemetry.io/contrib/instrumentation/github.com/gorilla/mux/otelmux"
-	"go.opentelemetry.io/otel/metric"
-	"go.opentelemetry.io/otel/propagation"
-	"go.opentelemetry.io/otel/trace"
-)
-
-// defaultExcludedRoutes are the health endpoints kept out of tracing/metrics to
-// avoid drowning telemetry in probe traffic.
-var defaultExcludedRoutes = []string{
-	"/api/v1/health",
-	"/api/v2/healthz",
-	"/api/v2/readyz",
-	"/api/v2/livez",
-}
-
-type Otel struct {
-	wrap mux.MiddlewareFunc
-}
-
-func NewOtel(service string, meterProvider metric.MeterProvider, tracerProvider trace.TracerProvider) *Otel {
-	return &Otel{
-		wrap: otelmux.Middleware(
-			service,
-			otelmux.WithMeterProvider(meterProvider),
-			otelmux.WithTracerProvider(tracerProvider),
-			otelmux.WithPropagators(propagation.NewCompositeTextMapPropagator(propagation.Baggage{}, propagation.TraceContext{})),
-			otelmux.WithFilter(func(r *http.Request) bool {
-				return !slices.Contains(defaultExcludedRoutes, r.URL.Path)
-			}),
-		),
-	}
-}
-
-func (middleware *Otel) Wrap(next http.Handler) http.Handler {
-	return middleware.wrap(next)
-}

pkg/http/server/config.go

@@ -1,18 +1,9 @@
 package server
 
-import "time"
-
 // Config holds the configuration for http.
 type Config struct {
 	//Address specifies the TCP address for the server to listen on, in the form "host:port".
 	// If empty, ":http" (port 80) is used. The service names are defined in RFC 6335 and assigned by IANA.
 	// See net.Dial for details of the address format.
 	Address string `mapstructure:"address"`
-
-	// ReadTimeout bounds reading an entire request, including the body. Zero means no timeout.
-	ReadTimeout time.Duration `mapstructure:"read_timeout"`
-
-	// WriteTimeout bounds writing the response. Zero means no timeout, required for
-	// streaming endpoints that hold the connection open.
-	WriteTimeout time.Duration `mapstructure:"write_timeout"`
 }

pkg/http/server/server.go

@@ -31,8 +31,8 @@ func New(logger *slog.Logger, cfg Config, handler http.Handler) (*Server, error)
 	srv := &http.Server{
 		Addr:           cfg.Address,
 		Handler:        handler,
-		ReadTimeout:    cfg.ReadTimeout,
-		WriteTimeout:   cfg.WriteTimeout,
+		ReadTimeout:    10 * time.Second,
+		WriteTimeout:   10 * time.Second,
 		MaxHeaderBytes: 1 << 20,
 	}
 

pkg/modules/fields/implfields/handler.go

@@ -82,7 +82,6 @@ func (handler *handler) GetFieldsValues(rw http.ResponseWriter, req *http.Reques
 
 	values := &telemetrytypes.TelemetryFieldValues{
 		StringValues:  allValues.StringValues,
-		BoolValues:    allValues.BoolValues,
 		NumberValues:  allValues.NumberValues,
 		RelatedValues: relatedValues,
 	}

pkg/modules/inframonitoring/implinframonitoring/helpers.go

@@ -446,14 +446,12 @@ func (m *module) buildFilterClause(ctx context.Context, orgID valuer.UUID, filte
 	}
 
 	opts := querybuilder.FilterExprVisitorOpts{
-		Context:          ctx,
-		Logger:           m.logger,
-		FieldMapper:      m.fieldMapper,
-		ConditionBuilder: m.condBuilder,
-		FullTextColumn:   &telemetrytypes.TelemetryFieldKey{Name: "metric_name", FieldContext: telemetrytypes.FieldContextMetric},
-		FieldKeys:        keys,
-		StartNs:          querybuilder.ToNanoSecs(uint64(startMillis)),
-		EndNs:            querybuilder.ToNanoSecs(uint64(endMillis)),
+		Context:        ctx,
+		Query:          querybuilder.NewQueryInfo(ctx, orgID, m.fl, telemetrytypes.SignalMetrics, nil, querybuilder.ToNanoSecs(uint64(startMillis)), querybuilder.ToNanoSecs(uint64(endMillis))),
+		Storage:        m.storage,
+		Logger:         m.logger,
+		FullTextColumn: &telemetrytypes.TelemetryFieldKey{Name: "metric_name", FieldContext: telemetrytypes.FieldContextMetric},
+		FieldKeys:      keys,
 	}
 
 	whereClause, err := querybuilder.PrepareWhereClause(expression, opts)

pkg/modules/inframonitoring/implinframonitoring/module.go

@@ -24,8 +24,7 @@ type module struct {
 	telemetryStore         telemetrystore.TelemetryStore
 	telemetryMetadataStore telemetrytypes.MetadataStore
 	querier                querier.Querier
-	fieldMapper            qbtypes.FieldMapper
-	condBuilder            qbtypes.ConditionBuilder
+	storage                qbtypes.Storage
 	logger                 *slog.Logger
 	config                 inframonitoring.Config
 	fl                     flagger.Flagger
@@ -40,14 +39,11 @@ func NewModule(
 	providerSettings factory.ProviderSettings,
 	cfg inframonitoring.Config,
 ) inframonitoring.Module {
-	fieldMapper := metricstelemetryschema.NewFieldMapper()
-	condBuilder := metricstelemetryschema.NewConditionBuilder(fieldMapper)
 	return &module{
 		telemetryStore:         telemetryStore,
 		telemetryMetadataStore: telemetryMetadataStore,
 		querier:                querier,
-		fieldMapper:            fieldMapper,
-		condBuilder:            condBuilder,
+		storage:                metricstelemetryschema.NewStorage(),
 		logger:                 providerSettings.Logger,
 		config:                 cfg,
 		fl:                     fl,

pkg/modules/metricsexplorer/implmetricsexplorer/module.go

@@ -37,8 +37,7 @@ import (
 type module struct {
 	telemetryStore         telemetrystore.TelemetryStore
 	telemetryMetadataStore telemetrytypes.MetadataStore
-	fieldMapper            qbtypes.FieldMapper
-	condBuilder            qbtypes.ConditionBuilder
+	storage                qbtypes.Storage
 	logger                 *slog.Logger
 	cache                  cache.Cache
 	ruleStore              ruletypes.RuleStore
@@ -49,12 +48,9 @@ type module struct {
 
 // NewModule constructs the metrics module with the provided dependencies.
 func NewModule(ts telemetrystore.TelemetryStore, telemetryMetadataStore telemetrytypes.MetadataStore, cache cache.Cache, ruleStore ruletypes.RuleStore, dashboardModule dashboard.Module, fl flagger.Flagger, providerSettings factory.ProviderSettings, cfg metricsexplorer.Config) metricsexplorer.Module {
-	fieldMapper := metricstelemetryschema.NewFieldMapper()
-	condBuilder := metricstelemetryschema.NewConditionBuilder(fieldMapper)
 	return &module{
 		telemetryStore:         ts,
-		fieldMapper:            fieldMapper,
-		condBuilder:            condBuilder,
+		storage:                metricstelemetryschema.NewStorage(),
 		logger:                 providerSettings.Logger,
 		telemetryMetadataStore: telemetryMetadataStore,
 		cache:                  cache,
@@ -975,14 +971,12 @@ func (m *module) buildFilterClause(ctx context.Context, orgID valuer.UUID, filte
 	}
 
 	opts := querybuilder.FilterExprVisitorOpts{
-		Context:          ctx,
-		Logger:           m.logger,
-		FieldMapper:      m.fieldMapper,
-		ConditionBuilder: m.condBuilder,
-		FullTextColumn:   &telemetrytypes.TelemetryFieldKey{Name: "metric_name", FieldContext: telemetrytypes.FieldContextMetric},
-		FieldKeys:        keys,
-		StartNs:          querybuilder.ToNanoSecs(uint64(startMillis)),
-		EndNs:            querybuilder.ToNanoSecs(uint64(endMillis)),
+		Context:        ctx,
+		Query:          querybuilder.NewQueryInfo(ctx, orgID, m.fl, telemetrytypes.SignalMetrics, nil, querybuilder.ToNanoSecs(uint64(startMillis)), querybuilder.ToNanoSecs(uint64(endMillis))),
+		Storage:        m.storage,
+		Logger:         m.logger,
+		FullTextColumn: &telemetrytypes.TelemetryFieldKey{Name: "metric_name", FieldContext: telemetrytypes.FieldContextMetric},
+		FieldKeys:      keys,
 	}
 
 	whereClause, err := querybuilder.PrepareWhereClause(expression, opts)

pkg/modules/rulestatehistory/implrulestatehistory/condition_builder.go

@@ -1,150 +0,0 @@
-package implrulestatehistory
-
-import (
-	"context"
-	"fmt"
-	"slices"
-
-	"github.com/SigNoz/signoz/pkg/errors"
-	"github.com/SigNoz/signoz/pkg/querybuilder"
-	qbtypes "github.com/SigNoz/signoz/pkg/types/querybuildertypes/querybuildertypesv5"
-	"github.com/SigNoz/signoz/pkg/types/telemetrytypes"
-	"github.com/SigNoz/signoz/pkg/valuer"
-	"github.com/huandu/go-sqlbuilder"
-)
-
-type conditionBuilder struct {
-	fm qbtypes.FieldMapper
-}
-
-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,
-	operator qbtypes.FilterOperator,
-	value any,
-	sb *sqlbuilder.SelectBuilder,
-) ([]string, []string, error) {
-
-	// has/hasAny/hasAll/hasToken/search are logs-only functions; reject for rule state history.
-	if err := querybuilder.NewFunctionUnsupportedError(operator); err != nil {
-		return nil, nil, err
-	}
-
-	// Rule state history fields have no family support, so every logical field
-	// is single-member and flattens losslessly to its physical key.
-	resolved, warning := querybuilder.ResolveLogicalFields(key, querybuilder.MatchingLogicalFields(ctx, orgID, nil, key, fieldKeys))
-	keys := querybuilder.SingleKeys(resolved)
-	var warnings []string
-	if warning != "" {
-		warnings = append(warnings, warning)
-	}
-	if len(keys) == 0 {
-		return nil, warnings, querybuilder.NewKeyNotFoundError(key.Name)
-	}
-
-	conds := make([]string, 0, len(keys))
-	for _, k := range keys {
-		cond, err := c.conditionForKey(ctx, orgID, startNs, endNs, k, operator, value, sb)
-		if err != nil {
-			return nil, nil, err
-		}
-		conds = append(conds, cond)
-	}
-	return conds, warnings, nil
-}
-
-func (c *conditionBuilder) conditionForKey(
-	ctx context.Context,
-	orgID valuer.UUID,
-	startNs uint64,
-	endNs uint64,
-	key *telemetrytypes.TelemetryFieldKey,
-	operator qbtypes.FilterOperator,
-	value any,
-	sb *sqlbuilder.SelectBuilder,
-) (string, error) {
-	if operator.IsStringSearchOperator() {
-		value = querybuilder.FormatValueForContains(value)
-	}
-
-	fieldName, err := c.fm.FieldFor(ctx, orgID, startNs, endNs, key)
-	if err != nil {
-		return "", err
-	}
-
-	switch operator {
-	case qbtypes.FilterOperatorEqual:
-		return sb.E(fieldName, value), nil
-	case qbtypes.FilterOperatorNotEqual:
-		return sb.NE(fieldName, value), nil
-	case qbtypes.FilterOperatorGreaterThan:
-		return sb.G(fieldName, value), nil
-	case qbtypes.FilterOperatorGreaterThanOrEq:
-		return sb.GE(fieldName, value), nil
-	case qbtypes.FilterOperatorLessThan:
-		return sb.LT(fieldName, value), nil
-	case qbtypes.FilterOperatorLessThanOrEq:
-		return sb.LE(fieldName, value), nil
-	case qbtypes.FilterOperatorLike:
-		return sb.Like(fieldName, value), nil
-	case qbtypes.FilterOperatorNotLike:
-		return sb.NotLike(fieldName, value), nil
-	case qbtypes.FilterOperatorILike:
-		return sb.ILike(fieldName, value), nil
-	case qbtypes.FilterOperatorNotILike:
-		return sb.NotILike(fieldName, value), nil
-	case qbtypes.FilterOperatorContains:
-		return sb.ILike(fieldName, fmt.Sprintf("%%%s%%", value)), nil
-	case qbtypes.FilterOperatorNotContains:
-		return sb.NotILike(fieldName, fmt.Sprintf("%%%s%%", value)), nil
-	case qbtypes.FilterOperatorRegexp:
-		return fmt.Sprintf(`match(%s, %s)`, sqlbuilder.Escape(fieldName), sb.Var(value)), nil
-	case qbtypes.FilterOperatorNotRegexp:
-		return fmt.Sprintf(`NOT match(%s, %s)`, sqlbuilder.Escape(fieldName), sb.Var(value)), nil
-	case qbtypes.FilterOperatorBetween:
-		values, ok := value.([]any)
-		if !ok || len(values) != 2 {
-			return "", qbtypes.ErrBetweenValues
-		}
-		return sb.Between(fieldName, values[0], values[1]), nil
-	case qbtypes.FilterOperatorNotBetween:
-		values, ok := value.([]any)
-		if !ok || len(values) != 2 {
-			return "", qbtypes.ErrBetweenValues
-		}
-		return sb.NotBetween(fieldName, values[0], values[1]), nil
-	case qbtypes.FilterOperatorIn:
-		values, ok := value.([]any)
-		if !ok {
-			return "", qbtypes.ErrInValues
-		}
-		return sb.In(fieldName, values), nil
-	case qbtypes.FilterOperatorNotIn:
-		values, ok := value.([]any)
-		if !ok {
-			return "", qbtypes.ErrInValues
-		}
-		return sb.NotIn(fieldName, values), nil
-	case qbtypes.FilterOperatorExists, qbtypes.FilterOperatorNotExists:
-		intrinsic := []string{"rule_id", "rule_name", "overall_state", "overall_state_changed", "state", "state_changed", "unix_milli", "fingerprint", "value"}
-		if slices.Contains(intrinsic, key.Name) {
-			return "true", nil
-		}
-		if operator == qbtypes.FilterOperatorExists {
-			return fmt.Sprintf("JSONHas(labels, %s)", sb.Var(key.Name)), nil
-		}
-		return fmt.Sprintf("not JSONHas(labels, %s)", sb.Var(key.Name)), nil
-	}
-
-	return "", errors.NewInvalidInputf(errors.CodeInvalidInput, "unsupported operator: %v", operator)
-}

pkg/modules/rulestatehistory/implrulestatehistory/field_mapper.go

@@ -9,7 +9,6 @@ import (
 	"github.com/SigNoz/signoz/pkg/querybuilder"
 	qbtypes "github.com/SigNoz/signoz/pkg/types/querybuildertypes/querybuildertypesv5"
 	"github.com/SigNoz/signoz/pkg/types/telemetrytypes"
-	"github.com/SigNoz/signoz/pkg/valuer"
 	"github.com/huandu/go-sqlbuilder"
 )
 
@@ -26,19 +25,15 @@ var ruleStateHistoryColumns = map[string]*schema.Column{
 	"value":                 {Name: "value", Type: schema.ColumnTypeFloat64},
 }
 
-type fieldMapper struct{}
+type storage struct{}
 
-func newFieldMapper() qbtypes.FieldMapper {
-	return &fieldMapper{}
+var _ qbtypes.Storage = (*storage)(nil)
+
+func newStorage() *storage {
+	return &storage{}
 }
 
-// CandidateKeys returns nil: rule-state history has no attribute-map fallback, so a
-// context-missing key stays unresolved and the caller errors.
-func (m *fieldMapper) CandidateKeys(_ context.Context, _ valuer.UUID, _ *telemetrytypes.TelemetryFieldKey, _ any, _ map[string][]*telemetrytypes.TelemetryFieldKey) []*telemetrytypes.TelemetryFieldKey {
-	return nil
-}
-
-func (m *fieldMapper) getColumn(_ context.Context, key *telemetrytypes.TelemetryFieldKey) (*schema.Column, error) { //nolint:unparam
+func (m *storage) getColumn(_ context.Context, key *telemetrytypes.TelemetryFieldKey) (*schema.Column, error) { //nolint:unparam
 	name := strings.TrimSpace(key.Name)
 	if col, ok := ruleStateHistoryColumns[name]; ok {
 		return col, nil
@@ -46,7 +41,7 @@ func (m *fieldMapper) getColumn(_ context.Context, key *telemetrytypes.Telemetry
 	return ruleStateHistoryColumns["labels"], nil
 }
 
-func (m *fieldMapper) FieldFor(ctx context.Context, _ valuer.UUID, _, _ uint64, key *telemetrytypes.TelemetryFieldKey) (string, error) {
+func (m *storage) read(ctx context.Context, _ qbtypes.QueryInfo, key *telemetrytypes.TelemetryFieldKey) (string, error) {
 	col, err := m.getColumn(ctx, key)
 	if err != nil {
 		return "", err
@@ -57,36 +52,41 @@ func (m *fieldMapper) FieldFor(ctx context.Context, _ valuer.UUID, _, _ uint64,
 	return col.Name, nil
 }
 
-func (m *fieldMapper) ColumnFor(ctx context.Context, _ valuer.UUID, _, _ uint64, key *telemetrytypes.TelemetryFieldKey) ([]*schema.Column, error) {
+// Read composes the bare read of one key with its membership test. A label
+// inside the JSON is checked with JSONHas; absent, it reads the empty string,
+// and that is the keyless contract here, so no query guards it. Every real
+// column is always present.
+func (m *storage) Read(ctx context.Context, q qbtypes.QueryInfo, key *telemetrytypes.TelemetryFieldKey) (qbtypes.Read, error) {
 	col, err := m.getColumn(ctx, key)
 	if err != nil {
-		return nil, err
+		return qbtypes.Read{}, err
 	}
-	return []*schema.Column{col}, nil
-}
-
-// ExistsFor implements the per-key existence primitive of qbtypes.FieldMapper.
-// A label inside the JSON gets a membership check, with the same condition
-// that FieldFor uses for extraction; every real column always exists.
-func (m *fieldMapper) ExistsFor(ctx context.Context, _ valuer.UUID, _, _ uint64, key *telemetrytypes.TelemetryFieldKey, exists bool) (string, error) {
-	col, err := m.getColumn(ctx, key)
+	sql, err := m.read(ctx, q, key)
 	if err != nil {
-		return "", err
+		return qbtypes.Read{}, err
 	}
 	if col.Name == "labels" && key.Name != "labels" {
-		pred := fmt.Sprintf("JSONHas(labels, %s)", querybuilder.ClickHouseStringLiteral(key.Name))
-		if exists {
-			return pred, nil
-		}
-		return "not " + pred, nil
+		presence := fmt.Sprintf("JSONHas(labels, %s)", querybuilder.ClickHouseStringLiteral(key.Name))
+		return qbtypes.Read{
+			SQL:        sql,
+			Presence:   presence,
+			Absence:    "not " + presence,
+			WhenAbsent: qbtypes.AbsentIsValue,
+		}, nil
 	}
-	return "true", nil
+	return qbtypes.Read{SQL: sql, Presence: "true", Absence: "false", WhenAbsent: qbtypes.AlwaysPresent}, nil
 }
 
-func (m *fieldMapper) ColumnExpressionFor(ctx context.Context, orgID valuer.UUID, tsStart, tsEnd uint64, field *telemetrytypes.TelemetryFieldKey, _ telemetrytypes.FieldDataType, _ map[string][]*telemetrytypes.TelemetryFieldKey) (string, error) {
-	colName, err := m.FieldFor(ctx, orgID, tsStart, tsEnd, field)
-	if err != nil {
-		return "", err
-	}
-	return fmt.Sprintf("%s AS `%s`", sqlbuilder.Escape(colName), field.Name), nil
+// Fallback returns nil: rule-state history has no attribute-map fallback, so
+// a key metadata does not hold stays unresolved and the caller errors.
+func (m *storage) Fallback(context.Context, qbtypes.QueryInfo, *telemetrytypes.TelemetryFieldKey, qbtypes.FilterOperator, any) ([]*telemetrytypes.LogicalField, error) {
+	return nil, nil
+}
+
+func (m *storage) Traits() qbtypes.Traits {
+	return qbtypes.Traits{}
+}
+
+func (m *storage) Compile(ctx context.Context, q qbtypes.QueryInfo, logical *telemetrytypes.LogicalField, operator qbtypes.FilterOperator, value any, sb *sqlbuilder.SelectBuilder) (qbtypes.Compiled, error) {
+	return querybuilder.SharedCondition(ctx, q, m, logical, operator, value, sb)
 }

pkg/modules/rulestatehistory/implrulestatehistory/store.go

@@ -25,18 +25,15 @@ const (
 type store struct {
 	telemetryStore         telemetrystore.TelemetryStore
 	telemetryMetadataStore telemetrytypes.MetadataStore
-	fieldMapper            qbtypes.FieldMapper
-	conditionBuilder       qbtypes.ConditionBuilder
+	storage                qbtypes.Storage
 	logger                 *slog.Logger
 }
 
 func NewStore(telemetryStore telemetrystore.TelemetryStore, telemetryMetadataStore telemetrytypes.MetadataStore, logger *slog.Logger) rulestatehistorytypes.Store {
-	fm := newFieldMapper()
 	return &store{
 		telemetryStore:         telemetryStore,
 		telemetryMetadataStore: telemetryMetadataStore,
-		fieldMapper:            fm,
-		conditionBuilder:       newConditionBuilder(fm),
+		storage:                newStorage(),
 		logger:                 logger,
 	}
 }
@@ -500,15 +497,13 @@ func (s *store) buildFilterClause(ctx context.Context, orgID valuer.UUID, filter
 	}
 
 	opts := querybuilder.FilterExprVisitorOpts{
-		Logger:           s.logger,
-		FieldMapper:      s.fieldMapper,
-		ConditionBuilder: s.conditionBuilder,
-		FieldKeys:        fieldKeys,
-		FullTextColumn:   &telemetrytypes.TelemetryFieldKey{Name: "labels", FieldContext: telemetrytypes.FieldContextAttribute},
+		Context:        ctx,
+		Query:          querybuilder.NewQueryInfo(ctx, orgID, nil, telemetrytypes.SignalUnspecified, nil, querybuilder.ToNanoSecs(uint64(startMillis)), querybuilder.ToNanoSecs(uint64(endMillis))),
+		Storage:        s.storage,
+		Logger:         s.logger,
+		FieldKeys:      fieldKeys,
+		FullTextColumn: &telemetrytypes.TelemetryFieldKey{Name: "labels", FieldContext: telemetrytypes.FieldContextAttribute},
 	}
-
-	opts.StartNs = querybuilder.ToNanoSecs(uint64(startMillis))
-	opts.EndNs = querybuilder.ToNanoSecs(uint64(endMillis))
 	prepared, err := querybuilder.PrepareWhereClause(expression, opts)
 	if err != nil {
 		return nil, err

pkg/pprof/httppprof/provider.go

@@ -6,7 +6,6 @@ import (
 	"net/http"
 	nethttppprof "net/http/pprof"
 	runtimepprof "runtime/pprof"
-	"time"
 
 	"github.com/SigNoz/signoz/pkg/factory"
 	httpserver "github.com/SigNoz/signoz/pkg/http/server"
@@ -24,7 +23,7 @@ func NewFactory() factory.ProviderFactory[pprof.PProf, pprof.Config] {
 func New(_ context.Context, settings factory.ProviderSettings, config pprof.Config) (pprof.PProf, error) {
 	server, err := httpserver.New(
 		settings.Logger.With(slog.String("pkg", "github.com/SigNoz/signoz/pkg/pprof/httppprof")),
-		httpserver.Config{Address: config.Address, ReadTimeout: 10 * time.Second, WriteTimeout: 10 * time.Second},
+		httpserver.Config{Address: config.Address},
 		newHandler(),
 	)
 	if err != nil {

pkg/query-service/app/http_handler.go

@@ -4070,20 +4070,20 @@ func (aH *APIHandler) RegisterTraceFunnelsRoutes(router *mux.Router, am *middlew
 		Methods(http.MethodPut)
 
 	// Analytics endpoints
-	traceFunnelsRouter.HandleFunc("/{funnel_id}/analytics/validate", am.ViewAccess(aH.handleValidateTraces)).Methods("POST")
-	traceFunnelsRouter.HandleFunc("/{funnel_id}/analytics/overview", am.ViewAccess(aH.handleFunnelAnalytics)).Methods("POST")
-	traceFunnelsRouter.HandleFunc("/{funnel_id}/analytics/steps", am.ViewAccess(aH.handleStepAnalytics)).Methods("POST")
-	traceFunnelsRouter.HandleFunc("/{funnel_id}/analytics/steps/overview", am.ViewAccess(aH.handleFunnelStepAnalytics)).Methods("POST")
-	traceFunnelsRouter.HandleFunc("/{funnel_id}/analytics/slow-traces", am.ViewAccess(aH.handleFunnelSlowTraces)).Methods("POST")
-	traceFunnelsRouter.HandleFunc("/{funnel_id}/analytics/error-traces", am.ViewAccess(aH.handleFunnelErrorTraces)).Methods("POST")
+	traceFunnelsRouter.HandleFunc("/{funnel_id}/analytics/validate", aH.handleValidateTraces).Methods("POST")
+	traceFunnelsRouter.HandleFunc("/{funnel_id}/analytics/overview", aH.handleFunnelAnalytics).Methods("POST")
+	traceFunnelsRouter.HandleFunc("/{funnel_id}/analytics/steps", aH.handleStepAnalytics).Methods("POST")
+	traceFunnelsRouter.HandleFunc("/{funnel_id}/analytics/steps/overview", aH.handleFunnelStepAnalytics).Methods("POST")
+	traceFunnelsRouter.HandleFunc("/{funnel_id}/analytics/slow-traces", aH.handleFunnelSlowTraces).Methods("POST")
+	traceFunnelsRouter.HandleFunc("/{funnel_id}/analytics/error-traces", aH.handleFunnelErrorTraces).Methods("POST")
 
 	// Analytics endpoints
-	traceFunnelsRouter.HandleFunc("/analytics/validate", am.ViewAccess(aH.handleValidateTracesWithPayload)).Methods("POST")
-	traceFunnelsRouter.HandleFunc("/analytics/overview", am.ViewAccess(aH.handleFunnelAnalyticsWithPayload)).Methods("POST")
-	traceFunnelsRouter.HandleFunc("/analytics/steps", am.ViewAccess(aH.handleStepAnalyticsWithPayload)).Methods("POST")
-	traceFunnelsRouter.HandleFunc("/analytics/steps/overview", am.ViewAccess(aH.handleFunnelStepAnalyticsWithPayload)).Methods("POST")
-	traceFunnelsRouter.HandleFunc("/analytics/slow-traces", am.ViewAccess(aH.handleFunnelSlowTracesWithPayload)).Methods("POST")
-	traceFunnelsRouter.HandleFunc("/analytics/error-traces", am.ViewAccess(aH.handleFunnelErrorTracesWithPayload)).Methods("POST")
+	traceFunnelsRouter.HandleFunc("/analytics/validate", aH.handleValidateTracesWithPayload).Methods("POST")
+	traceFunnelsRouter.HandleFunc("/analytics/overview", aH.handleFunnelAnalyticsWithPayload).Methods("POST")
+	traceFunnelsRouter.HandleFunc("/analytics/steps", aH.handleStepAnalyticsWithPayload).Methods("POST")
+	traceFunnelsRouter.HandleFunc("/analytics/steps/overview", aH.handleFunnelStepAnalyticsWithPayload).Methods("POST")
+	traceFunnelsRouter.HandleFunc("/analytics/slow-traces", aH.handleFunnelSlowTracesWithPayload).Methods("POST")
+	traceFunnelsRouter.HandleFunc("/analytics/error-traces", aH.handleFunnelErrorTracesWithPayload).Methods("POST")
 }
 
 func (aH *APIHandler) handleValidateTraces(w http.ResponseWriter, r *http.Request) {

pkg/query-service/app/server.go

@@ -2,9 +2,19 @@ package app
 
 import (
 	"context"
+	"fmt"
+	"net"
+	"net/http"
+	"slices"
 
+	"github.com/SigNoz/signoz/pkg/errors"
 	"github.com/SigNoz/signoz/pkg/queryparser"
 
+	"github.com/gorilla/handlers"
+
+	"github.com/rs/cors"
+	"github.com/soheilhy/cmux"
+
 	"github.com/SigNoz/signoz/pkg/http/middleware"
 	"github.com/SigNoz/signoz/pkg/query-service/agentConf"
 	"github.com/SigNoz/signoz/pkg/query-service/app/clickhouseReader"
@@ -13,15 +23,31 @@ import (
 	"github.com/SigNoz/signoz/pkg/query-service/app/opamp"
 	opAmpModel "github.com/SigNoz/signoz/pkg/query-service/app/opamp/model"
 	"github.com/SigNoz/signoz/pkg/signoz"
+	"github.com/SigNoz/signoz/pkg/web"
 
 	"log/slog"
 
+	"go.opentelemetry.io/contrib/instrumentation/github.com/gorilla/mux/otelmux"
+	"go.opentelemetry.io/otel/propagation"
+
 	"github.com/SigNoz/signoz/pkg/query-service/constants"
+	"github.com/SigNoz/signoz/pkg/query-service/healthcheck"
+	"github.com/SigNoz/signoz/pkg/query-service/utils"
 )
 
-// Server runs auxiliary servers (opamp) alongside the signoz apiserver
+// Server runs HTTP, Mux and a grpc server
 type Server struct {
+	config signoz.Config
+	signoz *signoz.SigNoz
+
+	// public http router
+	httpConn     net.Listener
+	httpServer   *http.Server
+	httpHostPort string
+
 	opampServer *opamp.Server
+
+	unavailableChannel chan healthcheck.Status
 }
 
 // NewServer creates and initializes Server
@@ -64,20 +90,20 @@ func NewServer(config signoz.Config, signoz *signoz.SigNoz) (*Server, error) {
 		return nil, err
 	}
 
-	// Register the legacy query-service routes on the apiserver router. The
-	// apiserver owns the HTTP server and applies the middleware chain at serve
-	// time, so these routes get the same treatment as the apiserver routes.
-	r := signoz.APIServer.Router()
-	am := middleware.NewAuthZ(signoz.Instrumentation.Logger(), signoz.Modules.OrgGetter, signoz.Authz)
+	s := &Server{
+		config:             config,
+		signoz:             signoz,
+		httpHostPort:       constants.HTTPHostPort,
+		unavailableChannel: make(chan healthcheck.Status),
+	}
 
-	apiHandler.RegisterRoutes(r, am)
-	apiHandler.RegisterLogsRoutes(r, am)
-	apiHandler.RegisterIntegrationRoutes(r, am)
-	apiHandler.RegisterQueryRangeV3Routes(r, am)
-	apiHandler.RegisterQueryRangeV4Routes(r, am)
-	apiHandler.RegisterMessagingQueuesRoutes(r, am)
-	apiHandler.RegisterThirdPartyApiRoutes(r, am)
-	apiHandler.RegisterTraceFunnelsRoutes(r, am)
+	httpServer, err := s.createPublicServer(apiHandler, signoz.Web)
+
+	if err != nil {
+		return nil, err
+	}
+
+	s.httpServer = httpServer
 
 	opAmpModel.Init(signoz.SQLStore, signoz.Instrumentation.Logger(), signoz.Modules.OrgGetter)
 
@@ -95,8 +121,6 @@ func NewServer(config signoz.Config, signoz *signoz.SigNoz) (*Server, error) {
 		return nil, err
 	}
 
-	s := &Server{}
-
 	s.opampServer = opamp.InitializeServer(
 		&opAmpModel.AllAgents,
 		agentConfMgr,
@@ -106,18 +130,146 @@ func NewServer(config signoz.Config, signoz *signoz.SigNoz) (*Server, error) {
 	return s, nil
 }
 
-// Start starts the opamp websocket server. The HTTP API server is started by
-// the signoz registry.
-func (s *Server) Start(ctx context.Context) error {
-	slog.Info("Starting OpAmp Websocket server", "addr", constants.OpAmpWsEndpoint)
-	if err := s.opampServer.Start(constants.OpAmpWsEndpoint); err != nil {
+// HealthCheckStatus returns health check status channel a client can subscribe to
+func (s Server) HealthCheckStatus() chan healthcheck.Status {
+	return s.unavailableChannel
+}
+
+func (s *Server) createPublicServer(api *APIHandler, web web.Web) (*http.Server, error) {
+	r := NewRouter()
+
+	r.Use(middleware.NewRecovery(s.signoz.Instrumentation.Logger()).Wrap)
+	r.Use(otelmux.Middleware(
+		"apiserver",
+		otelmux.WithMeterProvider(s.signoz.Instrumentation.MeterProvider()),
+		otelmux.WithTracerProvider(s.signoz.Instrumentation.TracerProvider()),
+		otelmux.WithPropagators(propagation.NewCompositeTextMapPropagator(propagation.Baggage{}, propagation.TraceContext{})),
+		otelmux.WithFilter(func(r *http.Request) bool {
+			return !slices.Contains([]string{"/api/v1/health"}, r.URL.Path)
+		}),
+	))
+	r.Use(middleware.NewIdentN(s.signoz.IdentNResolver, s.signoz.Sharder, s.signoz.Instrumentation.Logger()).Wrap)
+	r.Use(middleware.NewTimeout(s.signoz.Instrumentation.Logger(),
+		s.config.APIServer.Timeout.ExcludedRoutes,
+		s.config.APIServer.Timeout.Default,
+		s.config.APIServer.Timeout.Max,
+	).Wrap)
+	r.Use(middleware.NewResource(s.signoz.Instrumentation.Logger()).Wrap)
+	r.Use(middleware.NewAudit(s.signoz.Instrumentation.Logger(), s.config.APIServer.Logging.ExcludedRoutes, s.signoz.Auditor).Wrap)
+	r.Use(middleware.NewComment().Wrap)
+
+	am := middleware.NewAuthZ(s.signoz.Instrumentation.Logger(), s.signoz.Modules.OrgGetter, s.signoz.Authz)
+
+	api.RegisterRoutes(r, am)
+	api.RegisterLogsRoutes(r, am)
+	api.RegisterIntegrationRoutes(r, am)
+	api.RegisterQueryRangeV3Routes(r, am)
+	api.RegisterQueryRangeV4Routes(r, am)
+	api.RegisterMessagingQueuesRoutes(r, am)
+	api.RegisterThirdPartyApiRoutes(r, am)
+	api.RegisterTraceFunnelsRoutes(r, am)
+
+	err := s.signoz.APIServer.AddToRouter(r)
+	if err != nil {
+		return nil, err
+	}
+
+	c := cors.New(cors.Options{
+		AllowedOrigins: []string{"*"},
+		AllowedMethods: []string{"GET", "DELETE", "POST", "PUT", "PATCH", "OPTIONS"},
+		AllowedHeaders: []string{"Accept", "Authorization", "Content-Type", "cache-control"},
+	})
+
+	handler := c.Handler(r)
+
+	handler = handlers.CompressHandler(handler)
+
+	err = web.AddToRouter(r)
+	if err != nil {
+		return nil, err
+	}
+
+	routePrefix := s.config.Global.ExternalPath()
+	if routePrefix != "" {
+		prefixed := http.StripPrefix(routePrefix, handler)
+		handler = http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
+			switch req.URL.Path {
+			case "/api/v1/health", "/api/v2/healthz", "/api/v2/readyz", "/api/v2/livez":
+				r.ServeHTTP(w, req)
+				return
+			}
+
+			prefixed.ServeHTTP(w, req)
+		})
+	}
+
+	return &http.Server{
+		Handler: handler,
+	}, nil
+}
+
+// initListeners initialises listeners of the server
+func (s *Server) initListeners() error {
+	// listen on public port
+	var err error
+	publicHostPort := s.httpHostPort
+	if publicHostPort == "" {
+		return fmt.Errorf("constants.HTTPHostPort is required")
+	}
+
+	s.httpConn, err = net.Listen("tcp", publicHostPort)
+	if err != nil {
 		return err
 	}
 
+	slog.Info(fmt.Sprintf("Query server started listening on %s...", s.httpHostPort))
+
+	return nil
+}
+
+// Start listening on http and private http port concurrently
+func (s *Server) Start(ctx context.Context) error {
+	err := s.initListeners()
+	if err != nil {
+		return err
+	}
+
+	var httpPort int
+	if port, err := utils.GetPort(s.httpConn.Addr()); err == nil {
+		httpPort = port
+	}
+
+	go func() {
+		slog.Info("Starting HTTP server", "port", httpPort, "addr", s.httpHostPort)
+
+		switch err := s.httpServer.Serve(s.httpConn); err {
+		case nil, http.ErrServerClosed, cmux.ErrListenerClosed:
+			// normal exit, nothing to do
+		default:
+			slog.Error("Could not start HTTP server", errors.Attr(err))
+		}
+		s.unavailableChannel <- healthcheck.Unavailable
+	}()
+
+	go func() {
+		slog.Info("Starting OpAmp Websocket server", "addr", constants.OpAmpWsEndpoint)
+		err := s.opampServer.Start(constants.OpAmpWsEndpoint)
+		if err != nil {
+			slog.Error("opamp ws server failed to start", errors.Attr(err))
+			s.unavailableChannel <- healthcheck.Unavailable
+		}
+	}()
+
 	return nil
 }
 
 func (s *Server) Stop(ctx context.Context) error {
+	if s.httpServer != nil {
+		if err := s.httpServer.Shutdown(context.Background()); err != nil {
+			return err
+		}
+	}
+
 	s.opampServer.Stop()
 
 	return nil

pkg/query-service/constants/constants.go

@@ -10,7 +10,11 @@ import (
 	"github.com/SigNoz/signoz/pkg/valuer"
 )
 
-const OpAmpWsEndpoint = "0.0.0.0:4320" // address for opamp websocket
+const (
+	HTTPHostPort    = "0.0.0.0:8080" // Address to serve http (query service)
+	PrivateHostPort = "0.0.0.0:8085" // Address to server internal services like alert manager
+	OpAmpWsEndpoint = "0.0.0.0:4320" // address for opamp websocket
+)
 
 const MaxAllowedPointsInTimeSeries = 300
 

pkg/query-service/healthcheck/handler.go

@@ -0,0 +1,12 @@
+package healthcheck
+
+const (
+	// Unavailable indicates the service is not able to handle requests
+	Unavailable Status = iota
+	// Ready indicates the service is ready to handle requests
+	Ready
+	// Broken indicates that the healthcheck itself is broken, not serving HTTP
+	Broken
+)
+
+type Status int

pkg/querybuilder/agg_rewrite.go

@@ -17,11 +17,11 @@ import (
 )
 
 type aggExprRewriter struct {
-	logger           *slog.Logger
-	fullTextColumn   *telemetrytypes.TelemetryFieldKey
-	fieldMapper      qbtypes.FieldMapper
-	conditionBuilder qbtypes.ConditionBuilder
-	flagger          flagger.Flagger
+	logger         *slog.Logger
+	fullTextColumn *telemetrytypes.TelemetryFieldKey
+	storage        qbtypes.Storage
+	flagger        flagger.Flagger
+	signal         telemetrytypes.Signal
 }
 
 var _ qbtypes.AggExprRewriter = (*aggExprRewriter)(nil)
@@ -29,18 +29,18 @@ var _ qbtypes.AggExprRewriter = (*aggExprRewriter)(nil)
 func NewAggExprRewriter(
 	settings factory.ProviderSettings,
 	fullTextColumn *telemetrytypes.TelemetryFieldKey,
-	fieldMapper qbtypes.FieldMapper,
-	conditionBuilder qbtypes.ConditionBuilder,
+	storage qbtypes.Storage,
 	fl flagger.Flagger,
+	signal telemetrytypes.Signal,
 ) *aggExprRewriter {
 	set := factory.NewScopedProviderSettings(settings, "github.com/SigNoz/signoz/pkg/querybuilder/agg_rewrite")
 
 	return &aggExprRewriter{
-		logger:           set.Logger(),
-		fullTextColumn:   fullTextColumn,
-		fieldMapper:      fieldMapper,
-		conditionBuilder: conditionBuilder,
-		flagger:          fl,
+		logger:         set.Logger(),
+		fullTextColumn: fullTextColumn,
+		storage:        storage,
+		flagger:        fl,
+		signal:         signal,
 	}
 }
 
@@ -78,18 +78,14 @@ func (r *aggExprRewriter) Rewrite(
 		return "", nil, errors.NewInternalf(errors.CodeInternal, "no SELECT items for %q", expr)
 	}
 
-	visitor := newExprVisitor(
-		ctx,
-		orgID,
-		startNs,
-		endNs,
-		r.logger,
-		keys,
-		r.fullTextColumn,
-		r.fieldMapper,
-		r.conditionBuilder,
-		r.flagger,
-	)
+	visitor := &exprVisitor{
+		ctx:            ctx,
+		query:          NewQueryInfo(ctx, orgID, r.flagger, r.signal, nil, startNs, endNs),
+		logger:         r.logger,
+		fieldKeys:      keys,
+		fullTextColumn: r.fullTextColumn,
+		storage:        r.storage,
+	}
 	// Rewrite the first select item (our expression)
 	if err := sel.SelectItems[0].Accept(visitor); err != nil {
 		return "", nil, err
@@ -130,48 +126,19 @@ func (r *aggExprRewriter) RewriteMulti(
 	return out, chArgsList, nil
 }
 
-// exprVisitor walks FunctionExpr nodes and applies the mappers.
+// exprVisitor walks FunctionExpr nodes and resolves and renders their
+// arguments.
 type exprVisitor struct {
-	ctx     context.Context
-	orgID   valuer.UUID
-	startNs uint64
-	endNs   uint64
+	ctx   context.Context
+	query qbtypes.QueryInfo
 	chparser.DefaultASTVisitor
-	logger           *slog.Logger
-	fieldKeys        map[string][]*telemetrytypes.TelemetryFieldKey
-	fullTextColumn   *telemetrytypes.TelemetryFieldKey
-	fieldMapper      qbtypes.FieldMapper
-	conditionBuilder qbtypes.ConditionBuilder
-	flagger          flagger.Flagger
-	Modified         bool
-	chArgs           []any
-	isRate           bool
-}
-
-func newExprVisitor(
-	ctx context.Context,
-	orgID valuer.UUID,
-	startNs uint64,
-	endNs uint64,
-	logger *slog.Logger,
-	fieldKeys map[string][]*telemetrytypes.TelemetryFieldKey,
-	fullTextColumn *telemetrytypes.TelemetryFieldKey,
-	fieldMapper qbtypes.FieldMapper,
-	conditionBuilder qbtypes.ConditionBuilder,
-	fl flagger.Flagger,
-) *exprVisitor {
-	return &exprVisitor{
-		ctx:              ctx,
-		orgID:            orgID,
-		startNs:          startNs,
-		endNs:            endNs,
-		logger:           logger,
-		fieldKeys:        fieldKeys,
-		fullTextColumn:   fullTextColumn,
-		fieldMapper:      fieldMapper,
-		conditionBuilder: conditionBuilder,
-		flagger:          fl,
-	}
+	logger         *slog.Logger
+	fieldKeys      map[string][]*telemetrytypes.TelemetryFieldKey
+	fullTextColumn *telemetrytypes.TelemetryFieldKey
+	storage        qbtypes.Storage
+	Modified       bool
+	chArgs         []any
+	isRate         bool
 }
 
 // VisitFunctionExpr is invoked for each function call in the AST.
@@ -211,15 +178,12 @@ func (v *exprVisitor) VisitFunctionExpr(fn *chparser.FunctionExpr) error {
 		whereClause, err := PrepareWhereClause(
 			origPred,
 			FilterExprVisitorOpts{
-				Context:          v.ctx,
-				OrgID:            v.orgID,
-				Logger:           v.logger,
-				FieldKeys:        v.fieldKeys,
-				FieldMapper:      v.fieldMapper,
-				ConditionBuilder: v.conditionBuilder,
-				FullTextColumn:   v.fullTextColumn,
-				StartNs:          v.startNs,
-				EndNs:            v.endNs,
+				Context:        v.ctx,
+				Query:          v.query,
+				Storage:        v.storage,
+				Logger:         v.logger,
+				FieldKeys:      v.fieldKeys,
+				FullTextColumn: v.fullTextColumn,
 			},
 		)
 		if err != nil {
@@ -244,7 +208,7 @@ func (v *exprVisitor) VisitFunctionExpr(fn *chparser.FunctionExpr) error {
 		for i := 0; i < len(args)-1; i++ {
 			origVal := chparser.Format(args[i])
 			fieldKey := telemetrytypes.GetFieldKeyFromKeyText(origVal)
-			expr, err := v.fieldMapper.ColumnExpressionFor(v.ctx, v.orgID, v.startNs, v.endNs, &fieldKey, dataType, v.fieldKeys)
+			expr, err := ResolveColumn(v.ctx, v.query, v.storage, &fieldKey, dataType, v.fieldKeys)
 			if err != nil {
 				return errors.WrapInvalidInputf(err, errors.CodeInvalidInput, "failed to get table field name for %q", origVal)
 			}
@@ -261,7 +225,7 @@ func (v *exprVisitor) VisitFunctionExpr(fn *chparser.FunctionExpr) error {
 		for i, arg := range args {
 			orig := chparser.Format(arg)
 			fieldKey := telemetrytypes.GetFieldKeyFromKeyText(orig)
-			expr, err := v.fieldMapper.ColumnExpressionFor(v.ctx, v.orgID, v.startNs, v.endNs, &fieldKey, dataType, v.fieldKeys)
+			expr, err := ResolveColumn(v.ctx, v.query, v.storage, &fieldKey, dataType, v.fieldKeys)
 			if err != nil {
 				return err
 			}

pkg/querybuilder/column.go

@@ -0,0 +1,90 @@
+package querybuilder
+
+import (
+	"context"
+	"fmt"
+	"strings"
+
+	"github.com/SigNoz/signoz/pkg/errors"
+	qbtypes "github.com/SigNoz/signoz/pkg/types/querybuildertypes/querybuildertypesv5"
+	"github.com/SigNoz/signoz/pkg/types/telemetrytypes"
+)
+
+// Column renders a resolved key as one bare column expression; the caller
+// aliases. The coerced stages (group by, order, aggregation arguments) cast
+// every candidate to the target type. The guard follows Absent: a sentinel
+// read sits behind its presence test, so an absent row yields NULL; a column
+// every row has reads bare and ends the candidate list; a NULL-reading field
+// takes a presence branch only beside other candidates.
+func Column(
+	ctx context.Context,
+	q qbtypes.QueryInfo,
+	storage qbtypes.Storage,
+	resolved qbtypes.Resolved,
+	target telemetrytypes.FieldDataType,
+) (string, error) {
+	if len(resolved.Fields) == 0 {
+		return "", NewKeyNotFoundError(resolved.Key.Name, nil)
+	}
+
+	var targetValue any = ""
+	if target == telemetrytypes.FieldDataTypeFloat64 {
+		targetValue = 0.0
+	}
+	coerced := target != telemetrytypes.FieldDataTypeUnspecified
+	several := len(resolved.Fields) > 1
+
+	branches := make([]string, 0, len(resolved.Fields)*2)
+	filterOnly := false
+	for _, logical := range resolved.Fields {
+		read, err := LogicalRead(ctx, q, storage, logical)
+		if err != nil {
+			return "", err
+		}
+		if read.FilterOnly {
+			filterOnly = true
+			continue
+		}
+		// an array cannot sit inside Nullable or multiIf
+		if !several && bareRead(logical) {
+			return read.SQL, nil
+		}
+		expr := read.SQL
+		if coerced && !read.KeepType {
+			expr, _ = DataTypeCollisionHandledFieldName(logical.Single(), targetValue, expr, qbtypes.FilterOperatorUnknown)
+		}
+		// several native shapes share one multiIf, so every branch reads as text
+		branch := expr
+		if !coerced && several {
+			branch, _ = DataTypeCollisionHandledFieldName(logical.Single(), "", expr, qbtypes.FilterOperatorUnknown)
+		}
+		switch read.WhenAbsent {
+		case qbtypes.AlwaysPresent, qbtypes.AbsentIsValue:
+			if len(branches) == 0 {
+				return expr, nil
+			}
+			return fmt.Sprintf("multiIf(%s, %s)", strings.Join(branches, ", "), branch), nil
+		case qbtypes.AbsentIsNull:
+			if !several {
+				return expr, nil
+			}
+			branches = append(branches, read.Presence, branch)
+		default:
+			branches = append(branches, read.Presence, branch)
+		}
+	}
+	if len(branches) == 0 {
+		if filterOnly {
+			return "", errors.NewInvalidInputf(errors.CodeInvalidInput, "`%s` can be filtered but not selected or grouped", resolved.Key.Name)
+		}
+		return "", NewKeyNotFoundError(resolved.Key.Name, nil)
+	}
+	return fmt.Sprintf("multiIf(%s, NULL)", strings.Join(branches, ", ")), nil
+}
+
+func bareRead(logical *telemetrytypes.LogicalField) bool {
+	key := logical.Single()
+	return strings.Contains(key.Name, telemetrytypes.ArraySep) ||
+		strings.Contains(key.Name, telemetrytypes.ArrayAnyIndex) ||
+		key.FieldDataType.IsArray()
+}

pkg/querybuilder/condition.go

@@ -0,0 +1,121 @@
+package querybuilder
+
+import (
+	"context"
+
+	qbtypes "github.com/SigNoz/signoz/pkg/types/querybuildertypes/querybuildertypesv5"
+	"github.com/SigNoz/signoz/pkg/types/telemetrytypes"
+	"github.com/huandu/go-sqlbuilder"
+)
+
+// Condition compiles a resolved key into the conditions of one filter term:
+// the storage's part in the fingerprint split narrows the fields, and every
+// field compiles through the storage's Compile. It returns the per-field
+// warnings; the resolution carries its own.
+func Condition(
+	ctx context.Context,
+	q qbtypes.QueryInfo,
+	storage qbtypes.Storage,
+	resolved qbtypes.Resolved,
+	dropResourceFields bool,
+	operator qbtypes.FilterOperator,
+	value any,
+	sb *sqlbuilder.SelectBuilder,
+) ([]string, []string, error) {
+	if resolved.Skipped {
+		return nil, nil, nil
+	}
+	if operator.IsFunctionOperator() && operator != qbtypes.FilterOperatorSearch {
+		for _, logical := range resolved.Fields {
+			switch logical.FieldContext {
+			case telemetrytypes.FieldContextResource, telemetrytypes.FieldContextAttribute, telemetrytypes.FieldContextScope:
+				// a body function on a map-backed key is a user error; the split must not hide it
+				return nil, nil, NewFunctionUnsupportedError(operator)
+			}
+		}
+	}
+
+	fields := resolved.Fields
+	switch storage.Traits().Split {
+	case qbtypes.MainOfSplit:
+		// the sub-query cannot know fallback keys, so those stay
+		if dropResourceFields && !resolved.FromFallback {
+			filtered := make([]*telemetrytypes.LogicalField, 0, len(fields))
+			for _, logical := range fields {
+				if logical.FieldContext != telemetrytypes.FieldContextResource {
+					filtered = append(filtered, logical)
+				}
+			}
+			if len(filtered) == 0 {
+				return nil, nil, nil
+			}
+			fields = filtered
+		}
+	case qbtypes.FingerprintOfSplit:
+		filtered := make([]*telemetrytypes.LogicalField, 0, len(fields))
+		for _, logical := range fields {
+			if logical.FieldContext == telemetrytypes.FieldContextResource {
+				filtered = append(filtered, logical)
+			}
+		}
+		fields = filtered
+	}
+
+	conds := make([]string, 0, len(fields))
+	var warnings []string
+	for _, logical := range fields {
+		compiled, err := storage.Compile(ctx, q, logical, operator, value, sb)
+		if err != nil {
+			return nil, nil, err
+		}
+		if compiled.Condition != "" {
+			conds = append(conds, compiled.Condition)
+		}
+		warnings = append(warnings, compiled.Warnings...)
+	}
+	return conds, warnings, nil
+}
+
+// RejectsBodyFunction reports the error a storage without body functions
+// returns for one, before resolution; the fingerprint side of a split skips
+// the term instead, because the main query evaluates it.
+func RejectsBodyFunction(traits qbtypes.Traits, operator qbtypes.FilterOperator) (skip bool, err error) {
+	if !operator.IsFunctionOperator() && operator != qbtypes.FilterOperatorSearch {
+		return false, nil
+	}
+	if traits.SupportsBodyFunctions {
+		return false, nil
+	}
+	if traits.Split == qbtypes.FingerprintOfSplit {
+		return true, nil
+	}
+	return false, NewFunctionUnsupportedError(operator)
+}
+
+// Conditions resolves one key and compiles it: the condition builder for callers
+// that do not run the filter visitor. The warnings carry the resolution's
+// warnings first.
+func Conditions(
+	ctx context.Context,
+	q qbtypes.QueryInfo,
+	storage qbtypes.Storage,
+	key *telemetrytypes.TelemetryFieldKey,
+	operator qbtypes.FilterOperator,
+	value any,
+	fieldKeys map[string][]*telemetrytypes.TelemetryFieldKey,
+	dropResourceFields bool,
+	sb *sqlbuilder.SelectBuilder,
+) ([]string, []string, error) {
+	if _, err := RejectsBodyFunction(storage.Traits(), operator); err != nil {
+		return nil, nil, err
+	}
+	resolved, err := Resolve(ctx, q, storage, key, operator, value, fieldKeys)
+	if err != nil {
+		return nil, nil, err
+	}
+	conds, warnings, err := Condition(ctx, q, storage, resolved, dropResourceFields, operator, value, sb)
+	if err != nil {
+		return nil, nil, err
+	}
+	return conds, append(resolved.Warnings, warnings...), nil
+}

pkg/querybuilder/exists_expr.go

@@ -80,6 +80,11 @@ func ExistsExpression(columns []*schema.Column, key *telemetrytypes.TelemetryFie
 			return comparison("<>", "0"), nil
 		}
 		return comparison("=", "0"), nil
+	case schema.ColumnTypeEnumArray:
+		if exists {
+			return fmt.Sprintf("notEmpty(%s)", fieldExpression), nil
+		}
+		return fmt.Sprintf("empty(%s)", fieldExpression), nil
 	case schema.ColumnTypeEnumMap:
 		keyType := column.Type.(schema.MapColumnType).KeyType
 		if _, ok := keyType.(schema.LowCardinalityColumnType); !ok {

pkg/querybuilder/family_condition.go

@@ -0,0 +1,165 @@
+package querybuilder
+
+import (
+	"context"
+	"fmt"
+
+	qbtypes "github.com/SigNoz/signoz/pkg/types/querybuildertypes/querybuildertypesv5"
+	"github.com/SigNoz/signoz/pkg/types/telemetrytypes"
+	"github.com/huandu/go-sqlbuilder"
+)
+
+// SharedCondition is the Compile of every storage without its own condition
+// language: the field's read, the shared data-type collision cast, the
+// operator, then the guard rule. A sentinel-reading field takes the exists
+// guard on the operators that would otherwise match the sentinel.
+func SharedCondition(
+	ctx context.Context,
+	q qbtypes.QueryInfo,
+	storage qbtypes.Storage,
+	field *telemetrytypes.LogicalField,
+	operator qbtypes.FilterOperator,
+	value any,
+	sb *sqlbuilder.SelectBuilder,
+) (qbtypes.Compiled, error) {
+	condition, err := sharedOperator(ctx, q, storage, field, operator, value, sb)
+	if err != nil || condition == "" {
+		return qbtypes.Compiled{}, err
+	}
+	if !operator.AddDefaultExistsFilter() {
+		return qbtypes.Compiled{Condition: condition}, nil
+	}
+	read, err := LogicalRead(ctx, q, storage, field)
+	if err != nil {
+		return qbtypes.Compiled{}, err
+	}
+	if read.WhenAbsent != qbtypes.AbsentIsSentinel {
+		return qbtypes.Compiled{Condition: condition}, nil
+	}
+	return qbtypes.Compiled{Condition: sb.And(condition, sqlbuilder.Escape(read.Presence))}, nil
+}
+
+// sharedOperator expands a list per item, so each item takes its own cast,
+// and casts the read against the operand for everything else.
+func sharedOperator(
+	ctx context.Context,
+	q qbtypes.QueryInfo,
+	storage qbtypes.Storage,
+	field *telemetrytypes.LogicalField,
+	operator qbtypes.FilterOperator,
+	value any,
+	sb *sqlbuilder.SelectBuilder,
+) (string, error) {
+	switch operator {
+	case qbtypes.FilterOperatorIn, qbtypes.FilterOperatorNotIn:
+		values, ok := value.([]any)
+		if !ok {
+			return "", qbtypes.ErrInValues
+		}
+		itemOperator := qbtypes.FilterOperatorEqual
+		if operator == qbtypes.FilterOperatorNotIn {
+			itemOperator = qbtypes.FilterOperatorNotEqual
+		}
+		conditions := make([]string, 0, len(values))
+		for _, item := range values {
+			condition, err := sharedOperator(ctx, q, storage, field, itemOperator, item, sb)
+			if err != nil {
+				return "", err
+			}
+			conditions = append(conditions, condition)
+		}
+		// `=`+OR and `!=`+AND instead of IN and NOT IN, to make use of the index
+		if operator == qbtypes.FilterOperatorIn {
+			return sb.Or(conditions...), nil
+		}
+		return sb.And(conditions...), nil
+	}
+
+	if operator.IsStringSearchOperator() {
+		value = FormatValueForContains(value)
+	}
+	logicalRead, err := LogicalRead(ctx, q, storage, field)
+	if err != nil {
+		return "", err
+	}
+	// Coercion switches only on the data type, which every member shares, so
+	// the first member stands in for the field.
+	read, value := DataTypeCollisionHandledFieldName(field.Single(), value, logicalRead.SQL, operator)
+	return OperatorCondition(ctx, q, storage, field, read, operator, value, sb)
+}
+
+// OperatorCondition renders one operator over an already cast read. It is
+// the shared switch a storage with its own cast policy composes with. A list
+// operator is the caller's to expand, so each item takes its own cast.
+func OperatorCondition(
+	ctx context.Context,
+	q qbtypes.QueryInfo,
+	storage qbtypes.Storage,
+	field *telemetrytypes.LogicalField,
+	read string,
+	operator qbtypes.FilterOperator,
+	value any,
+	sb *sqlbuilder.SelectBuilder,
+) (string, error) {
+	switch operator {
+	case qbtypes.FilterOperatorEqual:
+		return sb.E(read, value), nil
+	case qbtypes.FilterOperatorNotEqual:
+		return sb.NE(read, value), nil
+	case qbtypes.FilterOperatorGreaterThan:
+		return sb.G(read, value), nil
+	case qbtypes.FilterOperatorGreaterThanOrEq:
+		return sb.GE(read, value), nil
+	case qbtypes.FilterOperatorLessThan:
+		return sb.LT(read, value), nil
+	case qbtypes.FilterOperatorLessThanOrEq:
+		return sb.LE(read, value), nil
+
+	case qbtypes.FilterOperatorLike:
+		return sb.Like(read, value), nil
+	case qbtypes.FilterOperatorNotLike:
+		return sb.NotLike(read, value), nil
+	case qbtypes.FilterOperatorILike:
+		return sb.ILike(read, value), nil
+	case qbtypes.FilterOperatorNotILike:
+		return sb.NotILike(read, value), nil
+
+	case qbtypes.FilterOperatorContains:
+		return sb.ILike(read, fmt.Sprintf("%%%s%%", value)), nil
+	case qbtypes.FilterOperatorNotContains:
+		return sb.NotILike(read, fmt.Sprintf("%%%s%%", value)), nil
+
+	case qbtypes.FilterOperatorRegexp:
+		// Note: Escape $$ to $$$$ to avoid sqlbuilder interpreting materialized $ signs
+		// Only needed because we are using sprintf instead of sb.Match (not implemented in sqlbuilder)
+		return fmt.Sprintf(`match(%s, %s)`, sqlbuilder.Escape(read), sb.Var(value)), nil
+	case qbtypes.FilterOperatorNotRegexp:
+		return fmt.Sprintf(`NOT match(%s, %s)`, sqlbuilder.Escape(read), sb.Var(value)), nil
+
+	case qbtypes.FilterOperatorBetween:
+		values, ok := value.([]any)
+		if !ok || len(values) != 2 {
+			return "", qbtypes.ErrBetweenValues
+		}
+		return sb.Between(read, values[0], values[1]), nil
+	case qbtypes.FilterOperatorNotBetween:
+		values, ok := value.([]any)
+		if !ok || len(values) != 2 {
+			return "", qbtypes.ErrBetweenValues
+		}
+		return sb.NotBetween(read, values[0], values[1]), nil
+
+	// exists and not exists are key membership checks, so the storage's
+	// presence test answers them
+	case qbtypes.FilterOperatorExists, qbtypes.FilterOperatorNotExists:
+		logicalRead, err := LogicalRead(ctx, q, storage, field)
+		if err != nil {
+			return "", err
+		}
+		if operator == qbtypes.FilterOperatorNotExists {
+			return sqlbuilder.Escape(logicalRead.Absence), nil
+		}
+		return sqlbuilder.Escape(logicalRead.Presence), nil
+	}
+	return "", qbtypes.ErrUnsupportedOperator
+}

pkg/querybuilder/key_resolution.go

@@ -4,6 +4,7 @@ import (
 	"encoding/json"
 	"fmt"
 
+	schema "github.com/SigNoz/signoz-otel-collector/cmd/signozschemamigrator/schema_migrator"
 	"github.com/SigNoz/signoz/pkg/errors"
 	qbtypes "github.com/SigNoz/signoz/pkg/types/querybuildertypes/querybuildertypesv5"
 	"github.com/SigNoz/signoz/pkg/types/telemetrytypes"
@@ -64,6 +65,28 @@ func ResolveLogicalFields(field *telemetrytypes.TelemetryFieldKey, logicalFields
 	return logicalFields, warning
 }
 
+// ColumnDataType is the field data type a table column reads as. A storage
+// stamps it on the column key its Fallback returns, so the intrinsic-column
+// step can drop a same-named metadata key of a contradicting type. A time
+// column has no field data type and matches none.
+func ColumnDataType(column *schema.Column) telemetrytypes.FieldDataType {
+	switch column.Type.GetType() {
+	case schema.ColumnTypeEnumBool:
+		return telemetrytypes.FieldDataTypeBool
+	case schema.ColumnTypeEnumInt8, schema.ColumnTypeEnumInt16, schema.ColumnTypeEnumInt32, schema.ColumnTypeEnumInt64,
+		schema.ColumnTypeEnumUInt8, schema.ColumnTypeEnumUInt16, schema.ColumnTypeEnumUInt32, schema.ColumnTypeEnumUInt64,
+		schema.ColumnTypeEnumFloat32, schema.ColumnTypeEnumFloat64:
+		return telemetrytypes.FieldDataTypeNumber
+	case schema.ColumnTypeEnumString, schema.ColumnTypeEnumFixedString:
+		return telemetrytypes.FieldDataTypeString
+	case schema.ColumnTypeEnumLowCardinality:
+		if lc, ok := column.Type.(schema.LowCardinalityColumnType); ok && lc.ElementType.GetType() == schema.ColumnTypeEnumString {
+			return telemetrytypes.FieldDataTypeString
+		}
+	}
+	return telemetrytypes.FieldDataTypeUnspecified
+}
+
 // WrapAsLogicalFields wraps physical keys (candidate or synthesized) as
 // single-member logical fields addressed by the requested spelling.
 func WrapAsLogicalFields(requestedName string, keys []*telemetrytypes.TelemetryFieldKey) []*telemetrytypes.LogicalField {
@@ -74,22 +97,14 @@ func WrapAsLogicalFields(requestedName string, keys []*telemetrytypes.TelemetryF
 	return fields
 }
 
-// SingleKeys flattens logical fields to their single members. It is the
-// adapter for signals whose fields are single-member by construction (every
-// signal without family support); their condition builders keep compiling per
-// physical key.
-func SingleKeys(fields []*telemetrytypes.LogicalField) []*telemetrytypes.TelemetryFieldKey {
-	keys := make([]*telemetrytypes.TelemetryFieldKey, 0, len(fields))
-	for _, field := range fields {
-		keys = append(keys, field.Single())
+// NewKeyNotFoundError builds the error for a key that neither metadata nor
+// the storage can serve, with the closest known names as suggestions.
+func NewKeyNotFoundError(name string, known []string) error {
+	err := errors.NewInvalidInputf(errors.CodeInvalidInput, "key `%s` not found", name).WithUrl(KeyNotFoundDocURL)
+	if len(known) == 0 {
+		return err
 	}
-	return keys
-}
-
-// NewKeyNotFoundError builds the error a condition builder returns when a filter term
-// references a key it has no matching field key for.
-func NewKeyNotFoundError(name string) error {
-	return errors.NewInvalidInputf(errors.CodeInvalidInput, "key `%s` not found", name).WithUrl(KeyNotFoundDocURL)
+	return err.WithSuggestions(errors.NewSuggestionsOnLevenshteinDistance(name, errors.NounKeys, known)...)
 }
 
 // NewKeyNotFoundWarning is the warning surfaced when a referenced key is absent from

pkg/querybuilder/logical_expr.go

@@ -7,90 +7,99 @@ import (
 
 	qbtypes "github.com/SigNoz/signoz/pkg/types/querybuildertypes/querybuildertypesv5"
 	"github.com/SigNoz/signoz/pkg/types/telemetrytypes"
-	"github.com/SigNoz/signoz/pkg/valuer"
 )
 
-// The two functions below are the only place family expressions are built.
-// They compose exclusively from the mapper's per-key primitives (FieldFor,
-// ExistsFor), so every member honors its own storage: materialized columns,
-// evolutions, and JSON plans ride the member keys, and a signal supports
-// families the moment its primitives are correct.
-
-// LogicalValueExpr returns the value expression for a resolved logical field:
-// the member's own expression for a single-member field, and a current-first
-// merge across the members' expressions for a family.
-func LogicalValueExpr(
-	ctx context.Context,
-	orgID valuer.UUID,
-	tsStart, tsEnd uint64,
-	fm qbtypes.FieldMapper,
-	logical *telemetrytypes.LogicalField,
-) (string, error) {
+// LogicalRead is the only place family expressions are built. It composes
+// exclusively from the storage's per-key Read, so every member honors its
+// own storage: materialized columns, evolutions, and JSON plans ride the
+// member keys, and a signal supports families the moment its reads are
+// correct.
+//
+// A single-member field reads through its member. A family merges the member
+// reads current-first, tests presence as any member present (and absence as
+// none present), and reads for a row without any member what the merge's tail
+// reads: the sentinel for a
+// string family, NULL for the others. A member with a value map reads in the
+// current vocabulary.
+func LogicalRead(ctx context.Context, q qbtypes.QueryInfo, storage qbtypes.Storage, logical *telemetrytypes.LogicalField) (qbtypes.Read, error) {
 	if !logical.IsFamily() {
-		return fm.FieldFor(ctx, orgID, tsStart, tsEnd, logical.Single())
+		return memberRead(ctx, q, storage, logical, 0)
+	}
+	reads := make([]qbtypes.Read, 0, len(logical.Members))
+	for i := range logical.Members {
+		read, err := memberRead(ctx, q, storage, logical, i)
+		if err != nil {
+			return qbtypes.Read{}, err
+		}
+		reads = append(reads, read)
 	}
 
-	memberExprs := make([]string, 0, len(logical.Members))
-	for _, member := range logical.Members {
-		expr, err := fm.FieldFor(ctx, orgID, tsStart, tsEnd, member)
-		if err != nil {
-			return "", err
-		}
-		memberExprs = append(memberExprs, expr)
+	merged := qbtypes.Read{WhenAbsent: familyAbsence(logical)}
+	guards := make([]string, 0, len(reads))
+	for _, read := range reads {
+		guards = append(guards, read.Presence)
+		merged.KeepType = merged.KeepType || read.KeepType
+	}
+	merged.Presence = "(" + strings.Join(guards, " OR ") + ")"
+	merged.Absence = "NOT " + merged.Presence
+	merged.FilterOnly = true
+	for _, read := range reads {
+		merged.FilterOnly = merged.FilterOnly && read.FilterOnly
 	}
 
 	if logical.FieldDataType == telemetrytypes.FieldDataTypeString {
 		// The trailing '' keeps single-key semantics for rows without any
 		// member: string maps read '' for an absent key, and negative
-		// operators must keep including such rows (see AddDefaultExistsFilter).
-		// A NULL tail would drop them: NULL != 'x' evaluates to NULL, and the
-		// row falls out of the result.
-		values := make([]string, 0, len(memberExprs))
-		for _, expr := range memberExprs {
-			values = append(values, fmt.Sprintf("NULLIF(%s, '')", expr))
+		// operators must keep including such rows. A NULL tail would drop
+		// them: NULL != 'x' evaluates to NULL, and the row falls out of the
+		// result.
+		values := make([]string, 0, len(reads))
+		for _, read := range reads {
+			values = append(values, fmt.Sprintf("NULLIF(%s, '')", read.SQL))
 		}
-		return "COALESCE(" + strings.Join(values, ", ") + ", '')", nil
+		merged.SQL = "COALESCE(" + strings.Join(values, ", ") + ", '')"
+		return merged, nil
 	}
-
 	// Numeric and boolean maps return zero for an absent key. If a family of
 	// either type is enabled, this tail must become zero too.
-	branches := make([]string, 0, len(logical.Members)*2)
-	for i, member := range logical.Members {
-		guard, err := fm.ExistsFor(ctx, orgID, tsStart, tsEnd, member, true)
-		if err != nil {
-			return "", err
-		}
-		branches = append(branches, guard, memberExprs[i])
+	branches := make([]string, 0, len(reads)*2)
+	for _, read := range reads {
+		branches = append(branches, read.Presence, read.SQL)
 	}
-	return "multiIf(" + strings.Join(branches, ", ") + ", NULL)", nil
+	merged.SQL = "multiIf(" + strings.Join(branches, ", ") + ", NULL)"
+	return merged, nil
 }
 
-// LogicalExistsExpr returns the existence predicate for a resolved logical
-// field: the member's own predicate for a single-member field, presence of
-// any member for a family.
-func LogicalExistsExpr(
-	ctx context.Context,
-	orgID valuer.UUID,
-	tsStart, tsEnd uint64,
-	fm qbtypes.FieldMapper,
-	logical *telemetrytypes.LogicalField,
-	exists bool,
-) (string, error) {
-	if !logical.IsFamily() {
-		return fm.ExistsFor(ctx, orgID, tsStart, tsEnd, logical.Single(), exists)
+func memberRead(ctx context.Context, q qbtypes.QueryInfo, storage qbtypes.Storage, logical *telemetrytypes.LogicalField, i int) (qbtypes.Read, error) {
+	read, err := storage.Read(ctx, q, logical.Members[i])
+	if err != nil {
+		return qbtypes.Read{}, err
 	}
-
-	guards := make([]string, 0, len(logical.Members))
-	for _, member := range logical.Members {
-		guard, err := fm.ExistsFor(ctx, orgID, tsStart, tsEnd, member, true)
-		if err != nil {
-			return "", err
-		}
-		guards = append(guards, guard)
+	if i < len(logical.ValueMaps) && logical.ValueMaps[i] != nil {
+		read.SQL = TransformRead(read.SQL, logical.ValueMaps[i])
 	}
-	combined := "(" + strings.Join(guards, " OR ") + ")"
-	if exists {
-		return combined, nil
-	}
-	return "NOT " + combined, nil
+	return read, nil
+}
+
+// TransformRead brings a member's read into the current vocabulary: a stored
+// value maps to its current value, any other value reads as it is.
+func TransformRead(read string, valueMap *telemetrytypes.ValueMap) string {
+	return fmt.Sprintf("transform(%s, %s, %s, %s)", read, clickHouseStringArray(valueMap.Stored), clickHouseStringArray(valueMap.Current), read)
+}
+
+func clickHouseStringArray(values []string) string {
+	items := make([]string, 0, len(values))
+	for _, value := range values {
+		items = append(items, ClickHouseStringLiteral(value))
+	}
+	return "[" + strings.Join(items, ", ") + "]"
+}
+
+// familyAbsence is what the merged read yields for a row without any
+// member: the sentinel tail of a string family, NULL for the others.
+func familyAbsence(logical *telemetrytypes.LogicalField) qbtypes.Absent {
+	if logical.FieldDataType == telemetrytypes.FieldDataTypeString {
+		return qbtypes.AbsentIsSentinel
+	}
+	return qbtypes.AbsentIsNull
 }

pkg/querybuilder/logical_expr_test.go

@@ -4,39 +4,30 @@ import (
 	"context"
 	"testing"
 
-	schema "github.com/SigNoz/signoz-otel-collector/cmd/signozschemamigrator/schema_migrator"
 	qbtypes "github.com/SigNoz/signoz/pkg/types/querybuildertypes/querybuildertypesv5"
 	"github.com/SigNoz/signoz/pkg/types/telemetrytypes"
-	"github.com/SigNoz/signoz/pkg/valuer"
+	"github.com/huandu/go-sqlbuilder"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
 
-// stubFieldMapper provides just the two per-key primitives the shared
-// composition builds on; the remaining FieldMapper methods are unused here.
-type stubFieldMapper struct{}
+// stubStorage provides the one read the shared composition builds on.
+type stubStorage struct{}
 
-func (stubFieldMapper) FieldFor(_ context.Context, _ valuer.UUID, _, _ uint64, key *telemetrytypes.TelemetryFieldKey) (string, error) {
-	return "value(" + key.Name + ")", nil
+func (stubStorage) Read(_ context.Context, _ qbtypes.QueryInfo, key *telemetrytypes.TelemetryFieldKey) (qbtypes.Read, error) {
+	return qbtypes.Read{SQL: "value(" + key.Name + ")", Presence: "has(" + key.Name + ")", Absence: "NOT has(" + key.Name + ")", WhenAbsent: qbtypes.AbsentIsSentinel}, nil
 }
 
-func (stubFieldMapper) ExistsFor(_ context.Context, _ valuer.UUID, _, _ uint64, key *telemetrytypes.TelemetryFieldKey, exists bool) (string, error) {
-	if exists {
-		return "has(" + key.Name + ")", nil
-	}
-	return "NOT has(" + key.Name + ")", nil
+func (stubStorage) Fallback(context.Context, qbtypes.QueryInfo, *telemetrytypes.TelemetryFieldKey, qbtypes.FilterOperator, any) ([]*telemetrytypes.LogicalField, error) {
+	return nil, nil
 }
 
-func (stubFieldMapper) ColumnFor(context.Context, valuer.UUID, uint64, uint64, *telemetrytypes.TelemetryFieldKey) ([]*schema.Column, error) {
-	return nil, qbtypes.ErrColumnNotFound
+func (stubStorage) Traits() qbtypes.Traits {
+	return qbtypes.Traits{}
 }
 
-func (stubFieldMapper) ColumnExpressionFor(context.Context, valuer.UUID, uint64, uint64, *telemetrytypes.TelemetryFieldKey, telemetrytypes.FieldDataType, map[string][]*telemetrytypes.TelemetryFieldKey) (string, error) {
-	return "", qbtypes.ErrColumnNotFound
-}
-
-func (stubFieldMapper) CandidateKeys(context.Context, valuer.UUID, *telemetrytypes.TelemetryFieldKey, any, map[string][]*telemetrytypes.TelemetryFieldKey) []*telemetrytypes.TelemetryFieldKey {
-	return nil
+func (s stubStorage) Compile(ctx context.Context, q qbtypes.QueryInfo, logical *telemetrytypes.LogicalField, operator qbtypes.FilterOperator, value any, sb *sqlbuilder.SelectBuilder) (qbtypes.Compiled, error) {
+	return SharedCondition(ctx, q, s, logical, operator, value, sb)
 }
 
 func stringFamily(names ...string) *telemetrytypes.LogicalField {
@@ -47,21 +38,21 @@ func stringFamily(names ...string) *telemetrytypes.LogicalField {
 	return &telemetrytypes.LogicalField{Name: names[0], FieldDataType: telemetrytypes.FieldDataTypeString, Members: members}
 }
 
-func TestLogicalValueExprSingleMemberDelegatesToFieldFor(t *testing.T) {
+func TestLogicalReadSingleMemberDelegatesToRead(t *testing.T) {
 	logical := telemetrytypes.SingleLogicalField("a", &telemetrytypes.TelemetryFieldKey{Name: "a"})
-	expr, err := LogicalValueExpr(context.Background(), valuer.UUID{}, 0, 0, stubFieldMapper{}, logical)
+	read, err := LogicalRead(context.Background(), qbtypes.QueryInfo{}, stubStorage{}, logical)
 	require.NoError(t, err)
-	assert.Equal(t, "value(a)", expr)
+	assert.Equal(t, "value(a)", read.SQL)
 }
 
-func TestLogicalValueExprStringFamilyMergesCurrentFirst(t *testing.T) {
-	expr, err := LogicalValueExpr(context.Background(), valuer.UUID{}, 0, 0, stubFieldMapper{}, stringFamily("current", "old"))
+func TestLogicalReadStringFamilyMergesCurrentFirst(t *testing.T) {
+	read, err := LogicalRead(context.Background(), qbtypes.QueryInfo{}, stubStorage{}, stringFamily("current", "old"))
 	require.NoError(t, err)
 	// The trailing '' preserves keyless-row semantics for negative operators.
-	assert.Equal(t, "COALESCE(NULLIF(value(current), ''), NULLIF(value(old), ''), '')", expr)
+	assert.Equal(t, "COALESCE(NULLIF(value(current), ''), NULLIF(value(old), ''), '')", read.SQL)
 }
 
-func TestLogicalValueExprNumericFamilyGuardsEveryMember(t *testing.T) {
+func TestLogicalReadNumericFamilyGuardsEveryMember(t *testing.T) {
 	logical := &telemetrytypes.LogicalField{
 		Name:          "current",
 		FieldDataType: telemetrytypes.FieldDataTypeNumber,
@@ -70,26 +61,24 @@ func TestLogicalValueExprNumericFamilyGuardsEveryMember(t *testing.T) {
 			{Name: "old", FieldDataType: telemetrytypes.FieldDataTypeNumber},
 		},
 	}
-	expr, err := LogicalValueExpr(context.Background(), valuer.UUID{}, 0, 0, stubFieldMapper{}, logical)
+	read, err := LogicalRead(context.Background(), qbtypes.QueryInfo{}, stubStorage{}, logical)
 	require.NoError(t, err)
-	assert.Equal(t, "multiIf(has(current), value(current), has(old), value(old), NULL)", expr)
+	assert.Equal(t, "multiIf(has(current), value(current), has(old), value(old), NULL)", read.SQL)
 }
 
-func TestLogicalExistsExprSingleMemberDelegatesToExistsFor(t *testing.T) {
+func TestLogicalReadSingleMemberDelegatesAbsence(t *testing.T) {
 	logical := telemetrytypes.SingleLogicalField("a", &telemetrytypes.TelemetryFieldKey{Name: "a"})
-	expr, err := LogicalExistsExpr(context.Background(), valuer.UUID{}, 0, 0, stubFieldMapper{}, logical, false)
+	read, err := LogicalRead(context.Background(), qbtypes.QueryInfo{}, stubStorage{}, logical)
 	require.NoError(t, err)
-	assert.Equal(t, "NOT has(a)", expr)
+	assert.Equal(t, "NOT has(a)", read.Absence)
 }
 
-func TestLogicalExistsExprFamilyIsAnyMemberPresence(t *testing.T) {
+func TestLogicalReadFamilyPresenceIsAnyMember(t *testing.T) {
 	family := stringFamily("current", "old")
 
-	expr, err := LogicalExistsExpr(context.Background(), valuer.UUID{}, 0, 0, stubFieldMapper{}, family, true)
+	read, err := LogicalRead(context.Background(), qbtypes.QueryInfo{}, stubStorage{}, family)
 	require.NoError(t, err)
-	assert.Equal(t, "(has(current) OR has(old))", expr)
+	assert.Equal(t, "(has(current) OR has(old))", read.Presence)
 
-	expr, err = LogicalExistsExpr(context.Background(), valuer.UUID{}, 0, 0, stubFieldMapper{}, family, false)
-	require.NoError(t, err)
-	assert.Equal(t, "NOT (has(current) OR has(old))", expr)
+	assert.Equal(t, "NOT (has(current) OR has(old))", read.Absence)
 }

pkg/querybuilder/logical_fields_test.go

@@ -48,7 +48,7 @@ func TestFamiliesOffByDefault(t *testing.T) {
 		}},
 	}
 
-	fields := MatchingLogicalFields(context.Background(), valuer.UUID{}, flaggertest.New(t), &telemetrytypes.TelemetryFieldKey{Name: "deployment.environment.name"}, fieldKeys)
+	fields := matchingLogicalFields(false, telemetrytypes.SignalUnspecified, &telemetrytypes.TelemetryFieldKey{Name: "deployment.environment.name"}, fieldKeys)
 	require.Len(t, fields, 1)
 	assert.False(t, fields[0].IsFamily())
 	assert.Equal(t, []string{"deployment.environment.name"}, memberNames(fields[0]))
@@ -76,7 +76,7 @@ func TestMatchingLogicalFieldsGroupsFamilyMembers(t *testing.T) {
 	}
 
 	for _, requested := range []string{"deployment.environment.name", "deployment.environment"} {
-		fields := MatchingLogicalFields(context.Background(), valuer.UUID{}, familiesOn(t), &telemetrytypes.TelemetryFieldKey{Name: requested}, fieldKeys)
+		fields := matchingLogicalFields(true, telemetrytypes.SignalUnspecified, &telemetrytypes.TelemetryFieldKey{Name: requested}, fieldKeys)
 		require.Len(t, fields, 1, "a family is one logical field, requested via %s", requested)
 		logical := fields[0]
 		assert.Equal(t, requested, logical.Name, "response identity is the requested spelling")
@@ -106,7 +106,7 @@ func TestMatchingLogicalFieldsOrdersMembersByFamilyRank(t *testing.T) {
 		}},
 	}
 
-	fields := MatchingLogicalFields(context.Background(), valuer.UUID{}, familiesOn(t), &telemetrytypes.TelemetryFieldKey{
+	fields := matchingLogicalFields(true, telemetrytypes.SignalUnspecified, &telemetrytypes.TelemetryFieldKey{
 		Name:         "deployment.environment.name",
 		FieldContext: telemetrytypes.FieldContextResource,
 	}, fieldKeys)
@@ -131,7 +131,7 @@ func TestMatchingLogicalFieldsKeepsLogsLiteral(t *testing.T) {
 		"deployment.environment":      {logsKey("deployment.environment")},
 	}
 
-	fields := MatchingLogicalFields(context.Background(), valuer.UUID{}, familiesOn(t), &telemetrytypes.TelemetryFieldKey{Name: "deployment.environment.name"}, fieldKeys)
+	fields := matchingLogicalFields(true, telemetrytypes.SignalUnspecified, &telemetrytypes.TelemetryFieldKey{Name: "deployment.environment.name"}, fieldKeys)
 	require.Len(t, fields, 1)
 	assert.False(t, fields[0].IsFamily())
 	assert.Equal(t, []string{"deployment.environment.name"}, memberNames(fields[0]))
@@ -165,7 +165,7 @@ func TestResolveLogicalFieldsKeepsFamilyThroughAmbiguity(t *testing.T) {
 	}
 
 	requested := &telemetrytypes.TelemetryFieldKey{Name: "deployment.environment.name"}
-	fields := MatchingLogicalFields(context.Background(), valuer.UUID{}, familiesOn(t), requested, fieldKeys)
+	fields := matchingLogicalFields(true, telemetrytypes.SignalUnspecified, requested, fieldKeys)
 	require.Len(t, fields, 2, "resource family + attribute collision")
 
 	resolved, warning := ResolveLogicalFields(requested, fields)
@@ -193,7 +193,7 @@ func TestMatchingLogicalFieldsNeverMergesAcrossDataTypes(t *testing.T) {
 		}},
 	}
 
-	fields := MatchingLogicalFields(context.Background(), valuer.UUID{}, familiesOn(t), &telemetrytypes.TelemetryFieldKey{Name: "deployment.environment.name"}, fieldKeys)
+	fields := matchingLogicalFields(true, telemetrytypes.SignalUnspecified, &telemetrytypes.TelemetryFieldKey{Name: "deployment.environment.name"}, fieldKeys)
 	require.Len(t, fields, 2)
 	for _, logical := range fields {
 		assert.False(t, logical.IsFamily())

pkg/querybuilder/resolve.go

@@ -0,0 +1,201 @@
+package querybuilder
+
+import (
+	"context"
+	"slices"
+
+	"github.com/SigNoz/signoz/pkg/flagger"
+	"github.com/SigNoz/signoz/pkg/types/featuretypes"
+	qbtypes "github.com/SigNoz/signoz/pkg/types/querybuildertypes/querybuildertypesv5"
+	"github.com/SigNoz/signoz/pkg/types/telemetrytypes"
+	"github.com/SigNoz/signoz/pkg/valuer"
+	"golang.org/x/exp/maps"
+)
+
+// NewQueryInfo binds the context of one query and evaluates the query-path
+// flags one time. A nil flagger keeps resolution literal and the log body in
+// its legacy column.
+func NewQueryInfo(ctx context.Context, orgID valuer.UUID, fl flagger.Flagger, signal telemetrytypes.Signal, metric *telemetrytypes.MetricContext, startNs, endNs uint64) qbtypes.QueryInfo {
+	q := qbtypes.QueryInfo{
+		StartNs:    startNs,
+		EndNs:      endNs,
+		Signal:     signal,
+		Metric:     metric,
+		FamiliesOn: semconvFamiliesEnabled(ctx, orgID, fl),
+	}
+	if fl != nil {
+		q.BodyJSONOn = fl.BooleanOrEmpty(ctx, flagger.FeatureUseJSONBody, featuretypes.NewFlaggerEvaluationContext(orgID))
+	}
+	return q
+}
+
+// Resolve turns one requested key into its meanings, one time per stage
+// entry. The order is the same for every storage and every stage:
+//
+//  1. matches: the metadata keys under the key's spellings, grouped into
+//     families when the flag is on; a key under one of the storage's own
+//     contexts matches its own context first, and only then as if it had
+//     none;
+//  2. ambiguity: in a filter, several interpretations settle by the
+//     resource-over-attribute policy, with a warning; a column stage keeps
+//     every interpretation in metadata order and folds them;
+//  3. intrinsic column first: for a bare key, a column every row has leads, whether
+//     metadata reports it or the storage's own tables do, and sentinel
+//     fields of a contradicting type drop;
+//  4. fallback: with no match, the storage's fallback keys; the not-found
+//     warning fires only when every one of them is a guess.
+func Resolve(
+	ctx context.Context,
+	q qbtypes.QueryInfo,
+	storage qbtypes.Storage,
+	key *telemetrytypes.TelemetryFieldKey,
+	operator qbtypes.FilterOperator,
+	value any,
+	fieldKeys map[string][]*telemetrytypes.TelemetryFieldKey,
+) (qbtypes.Resolved, error) {
+	traits := storage.Traits()
+
+	lookup := key
+	matches := matchingLogicalFields(q.FamiliesOn, q.Signal, key, fieldKeys)
+	if len(matches) == 0 && slices.Contains(traits.OwnContexts, key.FieldContext) {
+		bare := *key
+		bare.FieldContext = telemetrytypes.FieldContextUnspecified
+		lookup = &bare
+		matches = matchingLogicalFields(q.FamiliesOn, q.Signal, lookup, fieldKeys)
+	}
+
+	resolved := qbtypes.Resolved{Key: key, Ambiguous: len(matches) > 1}
+	fields := matches
+	if operator != qbtypes.FilterOperatorUnknown {
+		var warning string
+		fields, warning = ResolveLogicalFields(key, matches)
+		if warning != "" {
+			resolved.Warnings = append(resolved.Warnings, warning)
+		}
+	}
+	if lookup.FieldContext == telemetrytypes.FieldContextUnspecified && len(fields) > 0 {
+		fields = intrinsicColumnFirst(ctx, q, storage, key, operator, value, fields)
+	}
+	if len(fields) > 0 {
+		resolved.Fields = fields
+		return resolved, nil
+	}
+
+	fallback, err := storage.Fallback(ctx, q, key, operator, value)
+	if err != nil {
+		return qbtypes.Resolved{}, err
+	}
+	if len(fallback) == 0 {
+		if traits.UnknownKey == qbtypes.IgnoreUnknownKey {
+			resolved.Skipped = true
+			return resolved, nil
+		}
+		return qbtypes.Resolved{}, NewKeyNotFoundError(key.Name, maps.Keys(fieldKeys))
+	}
+	resolved.FromFallback = true
+	resolved.Fields = fallback
+	if fallbackIsGuess(ctx, q, storage, fallback) {
+		resolved.Warnings = append(resolved.Warnings, NewKeyNotFoundWarning(key.Name))
+	}
+	return resolved, nil
+}
+
+// ResolveColumn resolves one key for a column stage and renders it.
+func ResolveColumn(
+	ctx context.Context,
+	q qbtypes.QueryInfo,
+	storage qbtypes.Storage,
+	key *telemetrytypes.TelemetryFieldKey,
+	target telemetrytypes.FieldDataType,
+	fieldKeys map[string][]*telemetrytypes.TelemetryFieldKey,
+) (string, error) {
+	resolved, err := Resolve(ctx, q, storage, key, qbtypes.FilterOperatorUnknown, nil, fieldKeys)
+	if err != nil {
+		return "", err
+	}
+	return Column(ctx, q, storage, resolved, target)
+}
+
+// intrinsicColumnFirst puts a column every row has first for a bare key. The column comes from the
+// matches when metadata reports it, else from the storage's own fallback,
+// so a metadata gap degrades to the correct column and never to a corrupt
+// metadata key. A match of a contradicting data type drops.
+func intrinsicColumnFirst(
+	ctx context.Context,
+	q qbtypes.QueryInfo,
+	storage qbtypes.Storage,
+	key *telemetrytypes.TelemetryFieldKey,
+	operator qbtypes.FilterOperator,
+	value any,
+	fields []*telemetrytypes.LogicalField,
+) []*telemetrytypes.LogicalField {
+	column := alwaysPresent(ctx, q, storage, fields)
+	if column == nil {
+		// a fallback that cannot answer this term has no column for it; its
+		// error belongs to the no-match path
+		if fallback, err := storage.Fallback(ctx, q, key, operator, value); err == nil {
+			column = alwaysPresent(ctx, q, storage, fallback)
+		}
+	}
+	if column == nil {
+		return fields
+	}
+	out := make([]*telemetrytypes.LogicalField, 0, len(fields)+1)
+	out = append(out, column)
+	for _, logical := range fields {
+		if logical == column || sameFact(logical, column) {
+			continue
+		}
+		if dataTypesConsistent(column.FieldDataType, logical.FieldDataType) {
+			out = append(out, logical)
+		}
+	}
+	return out
+}
+
+// alwaysPresent returns the first field every row has. A field the storage
+// cannot test for presence is not that field.
+func alwaysPresent(ctx context.Context, q qbtypes.QueryInfo, storage qbtypes.Storage, fields []*telemetrytypes.LogicalField) *telemetrytypes.LogicalField {
+	for _, logical := range fields {
+		if logical.IsFamily() {
+			continue
+		}
+		read, err := storage.Read(ctx, q, logical.Single())
+		if err == nil && read.WhenAbsent == qbtypes.AlwaysPresent {
+			return logical
+		}
+	}
+	return nil
+}
+
+func sameFact(a, b *telemetrytypes.LogicalField) bool {
+	return !a.IsFamily() && !b.IsFamily() &&
+		a.FieldContext == b.FieldContext && a.Single().Name == b.Single().Name
+}
+
+// dataTypesConsistent reports whether a metadata key's data type can
+// describe the same stored value as the column's: an untyped metadata key
+// matches anything, a column without a field data type (a time column)
+// matches nothing, and the numeric kinds match each other.
+func dataTypesConsistent(column, entry telemetrytypes.FieldDataType) bool {
+	if entry == telemetrytypes.FieldDataTypeUnspecified {
+		return true
+	}
+	if column == telemetrytypes.FieldDataTypeUnspecified {
+		return false
+	}
+	if column == entry {
+		return true
+	}
+	return isNumber(column) && isNumber(entry)
+}
+
+func isNumber(dt telemetrytypes.FieldDataType) bool {
+	return dt == telemetrytypes.FieldDataTypeInt64 || dt == telemetrytypes.FieldDataTypeFloat64 || dt == telemetrytypes.FieldDataTypeNumber
+}
+
+// fallbackIsGuess reports whether every fallback key is a guess. A column
+// the storage knows is not one, and its presence means the key was found.
+func fallbackIsGuess(ctx context.Context, q qbtypes.QueryInfo, storage qbtypes.Storage, fields []*telemetrytypes.LogicalField) bool {
+	return alwaysPresent(ctx, q, storage, fields) == nil
+}

pkg/querybuilder/where_clause_visitor.go

@@ -9,12 +9,10 @@ import (
 	"strings"
 
 	"github.com/SigNoz/signoz/pkg/errors"
-	"github.com/SigNoz/signoz/pkg/flagger"
 	grammar "github.com/SigNoz/signoz/pkg/parser/filterquery/grammar"
 	"github.com/SigNoz/signoz/pkg/semconv"
 	qbtypes "github.com/SigNoz/signoz/pkg/types/querybuildertypes/querybuildertypesv5"
 	"github.com/SigNoz/signoz/pkg/types/telemetrytypes"
-	"github.com/SigNoz/signoz/pkg/valuer"
 	"github.com/antlr4-go/antlr/v4"
 
 	sqlbuilder "github.com/huandu/go-sqlbuilder"
@@ -28,10 +26,8 @@ const stringMatchingOperatorDocURL = "https://signoz.io/docs/userguide/operators
 // to convert the parsed filter expressions into ClickHouse WHERE clause.
 type filterExpressionVisitor struct {
 	context            context.Context
-	orgID              valuer.UUID
-	fl                 flagger.Flagger
-	fieldMapper        qbtypes.FieldMapper
-	conditionBuilder   qbtypes.ConditionBuilder
+	query              qbtypes.QueryInfo
+	storage            qbtypes.Storage
 	warnings           []string
 	mainWarnURL        string
 	fieldKeys          map[string][]*telemetrytypes.TelemetryFieldKey
@@ -44,39 +40,31 @@ type filterExpressionVisitor struct {
 	variables          map[string]qbtypes.VariableItem
 
 	keysWithWarnings map[string]bool
-	startNs          uint64
-	endNs            uint64
 
 	requiresCostGuard bool
 }
 
 type FilterExprVisitorOpts struct {
 	Context context.Context
-	OrgID   valuer.UUID
-	// Flagger evaluates the resolve_semconv_families flag during resolution.
-	// A nil Flagger keeps resolution literal.
-	Flagger            flagger.Flagger
+	// Query is the request's context with the query-path flags evaluated
+	// one time; Storage answers the signal's part of every term.
+	Query              qbtypes.QueryInfo
+	Storage            qbtypes.Storage
 	Logger             *slog.Logger
-	FieldMapper        qbtypes.FieldMapper
-	ConditionBuilder   qbtypes.ConditionBuilder
 	FieldKeys          map[string][]*telemetrytypes.TelemetryFieldKey
 	Builder            *sqlbuilder.SelectBuilder
 	FullTextColumn     *telemetrytypes.TelemetryFieldKey
 	SkipResourceFilter bool
 	SkipFullTextFilter bool
 	Variables          map[string]qbtypes.VariableItem
-	StartNs            uint64
-	EndNs              uint64
 }
 
 // newFilterExpressionVisitor creates a new filterExpressionVisitor.
 func newFilterExpressionVisitor(opts FilterExprVisitorOpts) *filterExpressionVisitor {
 	return &filterExpressionVisitor{
 		context:            opts.Context,
-		orgID:              opts.OrgID,
-		fl:                 opts.Flagger,
-		fieldMapper:        opts.FieldMapper,
-		conditionBuilder:   opts.ConditionBuilder,
+		query:              opts.Query,
+		storage:            opts.Storage,
 		fieldKeys:          opts.FieldKeys,
 		builder:            opts.Builder,
 		fullTextColumn:     opts.FullTextColumn,
@@ -84,8 +72,6 @@ func newFilterExpressionVisitor(opts FilterExprVisitorOpts) *filterExpressionVis
 		skipFullTextFilter: opts.SkipFullTextFilter,
 		variables:          opts.Variables,
 		keysWithWarnings:   make(map[string]bool),
-		startNs:            opts.StartNs,
-		endNs:              opts.EndNs,
 	}
 }
 
@@ -367,7 +353,7 @@ func (v *filterExpressionVisitor) VisitPrimary(ctx *grammar.PrimaryContext) any
 				return ErrorConditionLiteral
 			}
 		}
-		conds, ok := v.buildConditions(v.fullTextColumn, []*telemetrytypes.LogicalField{telemetrytypes.SingleLogicalField(v.fullTextColumn.Name, v.fullTextColumn)}, qbtypes.FilterOperatorRegexp, FormatFullTextSearch(searchText))
+		conds, ok := v.compile(storageKey(v.fullTextColumn), qbtypes.FilterOperatorRegexp, FormatFullTextSearch(searchText))
 		if !ok {
 			return ErrorConditionLiteral
 		}
@@ -386,7 +372,6 @@ func (v *filterExpressionVisitor) VisitPrimary(ctx *grammar.PrimaryContext) any
 // VisitComparison handles all comparison operators.
 func (v *filterExpressionVisitor) VisitComparison(ctx *grammar.ComparisonContext) any {
 	key := v.Visit(ctx.Key()).(*telemetrytypes.TelemetryFieldKey)
-	matching := MatchingLogicalFields(v.context, v.orgID, v.fl, key, v.fieldKeys)
 
 	// Handle EXISTS specially
 	if ctx.EXISTS() != nil {
@@ -395,7 +380,7 @@ func (v *filterExpressionVisitor) VisitComparison(ctx *grammar.ComparisonContext
 			op = qbtypes.FilterOperatorNotExists
 		}
 
-		conds, ok := v.buildConditions(key, matching, op, nil)
+		conds, ok := v.buildConditions(key, op, nil)
 		if !ok {
 			return ErrorConditionLiteral
 		}
@@ -468,7 +453,7 @@ func (v *filterExpressionVisitor) VisitComparison(ctx *grammar.ComparisonContext
 			op = qbtypes.FilterOperatorNotIn
 		}
 
-		conds, ok := v.buildConditions(key, matching, op, values)
+		conds, ok := v.buildConditions(key, op, values)
 		if !ok {
 			return ErrorConditionLiteral
 		}
@@ -516,7 +501,7 @@ func (v *filterExpressionVisitor) VisitComparison(ctx *grammar.ComparisonContext
 			return ErrorConditionLiteral
 		}
 
-		conds, ok := v.buildConditions(key, matching, op, []any{value1, value2})
+		conds, ok := v.buildConditions(key, op, []any{value1, value2})
 		if !ok {
 			return ErrorConditionLiteral
 		}
@@ -600,7 +585,7 @@ func (v *filterExpressionVisitor) VisitComparison(ctx *grammar.ComparisonContext
 			}
 		}
 
-		conds, ok := v.buildConditions(key, matching, op, value)
+		conds, ok := v.buildConditions(key, op, value)
 		if !ok {
 			return ErrorConditionLiteral
 		}
@@ -682,7 +667,7 @@ func (v *filterExpressionVisitor) VisitFullText(ctx *grammar.FullTextContext) an
 		v.errors = append(v.errors, "full text search is not supported")
 		return ErrorConditionLiteral
 	}
-	conds, ok := v.buildConditions(v.fullTextColumn, []*telemetrytypes.LogicalField{telemetrytypes.SingleLogicalField(v.fullTextColumn.Name, v.fullTextColumn)}, qbtypes.FilterOperatorRegexp, FormatFullTextSearch(text))
+	conds, ok := v.compile(storageKey(v.fullTextColumn), qbtypes.FilterOperatorRegexp, FormatFullTextSearch(text))
 	if !ok {
 		return ErrorConditionLiteral
 	}
@@ -737,7 +722,7 @@ func (v *filterExpressionVisitor) VisitFunctionCall(ctx *grammar.FunctionCallCon
 		return ErrorConditionLiteral
 	}
 
-	conds, ok := v.buildConditions(key, MatchingLogicalFields(v.context, v.orgID, v.fl, key, v.fieldKeys), operator, value)
+	conds, ok := v.buildConditions(key, operator, value)
 	if !ok {
 		return ErrorConditionLiteral
 	}
@@ -793,6 +778,12 @@ func normalizeFunctionValue(operator qbtypes.FilterOperator, functionName string
 // search term plus optional field-context scopes, ORing one FilterOperatorSearch per
 // scope (no scope = keyless, covering every field).
 func (v *filterExpressionVisitor) VisitSearchCall(ctx *grammar.SearchCallContext) any {
+	if skip, err := RejectsBodyFunction(v.storage.Traits(), qbtypes.FilterOperatorSearch); err != nil {
+		v.recordError(err)
+		return ErrorConditionLiteral
+	} else if skip {
+		return SkipConditionLiteral
+	}
 	// Flag scan-heavy so the statement builder attaches the cost guard.
 	v.requiresCostGuard = true
 
@@ -835,7 +826,7 @@ func (v *filterExpressionVisitor) VisitSearchCall(ctx *grammar.SearchCallContext
 	var conds []string
 	for _, fieldContext := range fieldContexts {
 		key := telemetrytypes.NewTelemetryFieldKey("", fieldContext, telemetrytypes.FieldDataTypeUnspecified)
-		scoped, cok := v.buildConditions(key, nil, qbtypes.FilterOperatorSearch, searchText)
+		scoped, cok := v.compile(storageKey(key), qbtypes.FilterOperatorSearch, searchText)
 		if !cok {
 			return ErrorConditionLiteral
 		}
@@ -927,20 +918,55 @@ func (v *filterExpressionVisitor) VisitKey(ctx *grammar.KeyContext) any {
 	return &fieldKey
 }
 
-// buildConditions invokes the condition builder for a filter term, folding its
-// warnings/errors into visitor state; returns false if an error was recorded.
-func (v *filterExpressionVisitor) buildConditions(key *telemetrytypes.TelemetryFieldKey, matching []*telemetrytypes.LogicalField, op qbtypes.FilterOperator, value any) ([]string, bool) {
-	conds, warns, err := v.conditionBuilder.ConditionFor(v.context, v.orgID, v.startNs, v.endNs, key, v.fieldKeys, qbtypes.ConditionBuilderOptions{SkipResourceFilter: v.skipResourceFilter}, op, value, v.builder)
+// buildConditions resolves and compiles one filter term, folding its
+// warnings and errors into the visitor state; ok is false when an error was
+// recorded.
+func (v *filterExpressionVisitor) buildConditions(key *telemetrytypes.TelemetryFieldKey, op qbtypes.FilterOperator, value any) ([]string, bool) {
+	if skip, err := RejectsBodyFunction(v.storage.Traits(), op); err != nil {
+		v.recordError(err)
+		return nil, false
+	} else if skip {
+		return nil, true
+	}
+	resolved, err := Resolve(v.context, v.query, v.storage, key, op, value, v.fieldKeys)
 	if err != nil {
-		_, _, _, _, errURL, _ := errors.Unwrapb(err)
-		assignIfEmpty(&v.mainErrorURL, errURL)
-		v.errors = append(v.errors, err.Error())
+		v.recordError(err)
 		return nil, false
 	}
-	v.addWarnings(warns, len(matching) > 1)
+	v.addWarnings(resolved.Warnings, resolved.Ambiguous)
+	return v.compile(resolved, op, value)
+}
+
+// compile turns a resolved term into its conditions, folding the storage's
+// warnings into the visitor state.
+func (v *filterExpressionVisitor) compile(resolved qbtypes.Resolved, op qbtypes.FilterOperator, value any) ([]string, bool) {
+	conds, warns, err := Condition(v.context, v.query, v.storage, resolved, v.skipResourceFilter, op, value, v.builder)
+	if err != nil {
+		v.recordError(err)
+		return nil, false
+	}
+	v.addWarnings(warns, resolved.Ambiguous)
 	return conds, true
 }
 
+func (v *filterExpressionVisitor) recordError(err error) {
+	_, _, _, _, errURL, _ := errors.Unwrapb(err)
+	assignIfEmpty(&v.mainErrorURL, errURL)
+	v.errors = append(v.errors, err.Error())
+}
+
+// storageKey is a key the storage knows without metadata, resolved as
+// itself: the full-text column, or a search() scope that names a set of
+// columns. It is a fallback key: the fingerprint sub-query cannot serve it,
+// so the main query keeps it when the split runs.
+func storageKey(key *telemetrytypes.TelemetryFieldKey) qbtypes.Resolved {
+	return qbtypes.Resolved{
+		Key:          key,
+		Fields:       []*telemetrytypes.LogicalField{telemetrytypes.SingleLogicalField(key.Name, key)},
+		FromFallback: true,
+	}
+}
+
 // addWarnings appends de-duplicated warnings to the visitor. ambiguous marks warnings
 // from a multi-match key so the field-context doc URL is attached.
 func (v *filterExpressionVisitor) addWarnings(warns []string, ambiguous bool) {
@@ -988,15 +1014,14 @@ func assignIfEmpty(s *string, value string) {
 
 // familyMemberNames returns the physical spellings to look up for the
 // referenced key: the semantic-convention family members (current-first) when
-// the resolve_semconv_families flag is on for the org and the key can resolve
-// to traces, else just the requested name. Only trace field mappers understand
-// families today; logs and metrics keep the requested spelling until theirs
-// land.
-func familyMemberNames(ctx context.Context, orgID valuer.UUID, fl flagger.Flagger, field *telemetrytypes.TelemetryFieldKey) []string {
-	if !semconvFamiliesEnabled(ctx, orgID, fl) {
+// families are on and the query can resolve to traces, else just the requested
+// name. Only trace field mappers understand families today; logs and metrics
+// keep the requested spelling until theirs land.
+func familyMemberNames(familiesOn bool, signal telemetrytypes.Signal, field *telemetrytypes.TelemetryFieldKey) []string {
+	if !familiesOn {
 		return []string{field.Name}
 	}
-	if field.Signal != telemetrytypes.SignalUnspecified && field.Signal != telemetrytypes.SignalTraces {
+	if signal != telemetrytypes.SignalUnspecified && signal != telemetrytypes.SignalTraces {
 		return []string{field.Name}
 	}
 	return semconv.Members(semconv.KindAttribute, telemetrytypes.FieldKeySelector{
@@ -1006,7 +1031,7 @@ func familyMemberNames(ctx context.Context, orgID valuer.UUID, fl flagger.Flagge
 	})
 }
 
-// MatchingLogicalFields resolves the referenced key against the metadata map
+// matchingLogicalFields resolves the referenced key against the metadata map
 // into logical fields, honoring any context/data type the user specified.
 //
 // Physical keys that are members of one semantic-convention family (traces
@@ -1014,16 +1039,15 @@ func familyMemberNames(ctx context.Context, orgID valuer.UUID, fl flagger.Flagge
 // identity, members ordered current-first. Every other matching key becomes
 // its own single-member logical field. Ambiguity is the length of the
 // returned slice: one family is one element and is never ambiguous with
-// itself, but the slice can hold several logical fields — including several
+// itself, but the slice can hold several logical fields, including several
 // family fields, one per identity, when the family exists under more than
 // one context or data type. Members alias the metadata map entries; nothing
 // is copied or mutated.
 //
-// Family grouping only happens when the resolve_semconv_families flag is on
-// for the org. A nil flagger means off: every match then stays a
-// single-member logical field.
-func MatchingLogicalFields(ctx context.Context, orgID valuer.UUID, fl flagger.Flagger, field *telemetrytypes.TelemetryFieldKey, fieldKeys map[string][]*telemetrytypes.TelemetryFieldKey) []*telemetrytypes.LogicalField {
-	members := familyMemberNames(ctx, orgID, fl, field)
+// Family grouping only happens when families are on for the query. Off,
+// every match stays a single-member logical field.
+func matchingLogicalFields(familiesOn bool, signal telemetrytypes.Signal, field *telemetrytypes.TelemetryFieldKey, fieldKeys map[string][]*telemetrytypes.TelemetryFieldKey) []*telemetrytypes.LogicalField {
+	members := familyMemberNames(familiesOn, signal, field)
 	matches := collectMemberMatches(field, members, fieldKeys)
 	return groupIntoLogicalFields(field.Name, len(members) > 1, matches)
 }

pkg/querybuilder/where_clause_visitor_test.go

@@ -10,7 +10,6 @@ import (
 	grammar "github.com/SigNoz/signoz/pkg/parser/filterquery/grammar"
 	qbtypes "github.com/SigNoz/signoz/pkg/types/querybuildertypes/querybuildertypesv5"
 	"github.com/SigNoz/signoz/pkg/types/telemetrytypes"
-	"github.com/SigNoz/signoz/pkg/valuer"
 	"github.com/antlr4-go/antlr/v4"
 	sqlbuilder "github.com/huandu/go-sqlbuilder"
 	"github.com/stretchr/testify/assert"
@@ -590,15 +589,18 @@ func TestVisitKey(t *testing.T) {
 			// and decides not-found handling. Replay that here against the generic
 			// builder behavior (error unless the key is ignored). The test maps carry
 			// no signal, so every logical field is single-member and flattens losslessly.
-			matching := MatchingLogicalFields(context.Background(), valuer.UUID{}, nil, key, tt.fieldKeys)
+			matching := matchingLogicalFields(false, telemetrytypes.SignalUnspecified, key, tt.fieldKeys)
 			resolved, warning := ResolveLogicalFields(key, matching)
-			keys := SingleKeys(resolved)
+			keys := make([]*telemetrytypes.TelemetryFieldKey, 0, len(resolved))
+			for _, logical := range resolved {
+				keys = append(keys, logical.Single())
+			}
 
 			var gotErrors []string
 			var gotMainErrURL, gotMainWrnURL string
 			var gotWarnings []string
 			if len(keys) == 0 && !tt.ignoreNotFoundKeys {
-				err := NewKeyNotFoundError(key.Name)
+				err := NewKeyNotFoundError(key.Name, nil)
 				gotErrors = append(gotErrors, err.Error())
 				_, _, _, _, gotMainErrURL, _ = errors.Unwrapb(err)
 			}
@@ -748,99 +750,51 @@ var visitTestKeys = map[string][]*telemetrytypes.TelemetryFieldKey{
 	"body": {{Name: "body", FieldContext: telemetrytypes.FieldContextLog, FieldDataType: telemetrytypes.FieldDataTypeString}},
 }
 
-type resourceConditionBuilder struct{}
+// resourceStorage mirrors the fingerprint storage: only resource keys
+// compile, and unknown keys and body functions are skipped.
+type resourceStorage struct{}
 
-func (b *resourceConditionBuilder) ConditionFor(
-	_ context.Context,
-	_ valuer.UUID,
-	_ uint64,
-	_ uint64,
-	key *telemetrytypes.TelemetryFieldKey,
-	fieldKeys map[string][]*telemetrytypes.TelemetryFieldKey,
-	_ qbtypes.ConditionBuilderOptions,
-	operator qbtypes.FilterOperator,
-	_ any,
-	_ *sqlbuilder.SelectBuilder,
-) ([]string, []string, error) {
-
-	// mirror the real resource builder: function operators never apply to resources
-	if operator.IsFunctionOperator() {
-		return nil, nil, nil
-	}
-
-	resolved, warning := ResolveLogicalFields(key, MatchingLogicalFields(context.Background(), valuer.UUID{}, nil, key, fieldKeys))
-	keys := SingleKeys(resolved)
-	var warnings []string
-	if warning != "" {
-		warnings = append(warnings, warning)
-	}
-
-	var conds []string
-	for _, k := range keys {
-		// only resource keys contribute; others (and unknown keys) are ignored
-		if k.FieldContext != telemetrytypes.FieldContextResource {
-			continue
-		}
-		conds = append(conds, fmt.Sprintf("%s_cond", k.Name))
-	}
-	return conds, warnings, nil
+func (resourceStorage) Read(_ context.Context, _ qbtypes.QueryInfo, key *telemetrytypes.TelemetryFieldKey) (qbtypes.Read, error) {
+	return qbtypes.Read{SQL: key.Name, Presence: "has(" + key.Name + ")", Absence: "NOT has(" + key.Name + ")", WhenAbsent: qbtypes.AbsentIsSentinel}, nil
 }
 
-type conditionBuilder struct{}
+func (resourceStorage) Fallback(context.Context, qbtypes.QueryInfo, *telemetrytypes.TelemetryFieldKey, qbtypes.FilterOperator, any) ([]*telemetrytypes.LogicalField, error) {
+	return nil, nil
+}
 
-func (b *conditionBuilder) ConditionFor(
-	_ context.Context,
-	_ valuer.UUID,
-	_ uint64,
-	_ uint64,
-	key *telemetrytypes.TelemetryFieldKey,
-	fieldKeys map[string][]*telemetrytypes.TelemetryFieldKey,
-	options qbtypes.ConditionBuilderOptions,
-	operator qbtypes.FilterOperator,
-	_ any,
-	_ *sqlbuilder.SelectBuilder,
-) ([]string, []string, error) {
+func (resourceStorage) Traits() qbtypes.Traits {
+	return qbtypes.Traits{Split: qbtypes.FingerprintOfSplit, UnknownKey: qbtypes.IgnoreUnknownKey}
+}
 
-	// has/hasAny/hasAll/hasToken only support body fields; mirror the real
-	// condition builder which now owns this validation and errors for non-body keys.
-	switch operator {
-	case qbtypes.FilterOperatorHas, qbtypes.FilterOperatorHasAny, qbtypes.FilterOperatorHasAll, qbtypes.FilterOperatorHasToken:
-		if key.FieldContext != telemetrytypes.FieldContextBody {
-			return nil, nil, errors.NewInvalidInputf(errors.CodeInvalidInput, "function supports only body JSON search")
-		}
-		return []string{fmt.Sprintf("%s_cond", key.Name)}, nil, nil
-	}
+func (resourceStorage) Compile(_ context.Context, _ qbtypes.QueryInfo, logical *telemetrytypes.LogicalField, _ qbtypes.FilterOperator, _ any, _ *sqlbuilder.SelectBuilder) (qbtypes.Compiled, error) {
+	return qbtypes.Compiled{Condition: fmt.Sprintf("%s_cond", logical.Single().Name)}, nil
+}
 
-	resolved, warning := ResolveLogicalFields(key, MatchingLogicalFields(context.Background(), valuer.UUID{}, nil, key, fieldKeys))
-	keys := SingleKeys(resolved)
-	var warnings []string
-	if warning != "" {
-		warnings = append(warnings, warning)
-	}
-	if len(keys) == 0 {
-		// errors on unknown keys (no IgnoreNotFoundKeys equivalent for this builder)
-		return nil, warnings, NewKeyNotFoundError(key.Name)
-	}
+// mainStorage mirrors a main-query storage: body functions apply to body keys
+// only, an unknown key errors, and a body path without metadata matches is
+// its own fallback.
+type mainStorage struct{}
 
-	// A resource sub-query already covers the term; drop resource keys from the main query.
-	if options.SkipResourceFilter {
-		filtered := make([]*telemetrytypes.TelemetryFieldKey, 0, len(keys))
-		for _, k := range keys {
-			if k.FieldContext != telemetrytypes.FieldContextResource {
-				filtered = append(filtered, k)
-			}
-		}
-		if len(filtered) == 0 {
-			return nil, warnings, nil
-		}
-		keys = filtered
-	}
+func (mainStorage) Read(_ context.Context, _ qbtypes.QueryInfo, key *telemetrytypes.TelemetryFieldKey) (qbtypes.Read, error) {
+	return qbtypes.Read{SQL: key.Name, Presence: "has(" + key.Name + ")", Absence: "NOT has(" + key.Name + ")", WhenAbsent: qbtypes.AbsentIsSentinel}, nil
+}
 
-	conds := make([]string, 0, len(keys))
-	for _, k := range keys {
-		conds = append(conds, fmt.Sprintf("%s_cond", k.Name))
+func (mainStorage) Fallback(_ context.Context, _ qbtypes.QueryInfo, key *telemetrytypes.TelemetryFieldKey, _ qbtypes.FilterOperator, _ any) ([]*telemetrytypes.LogicalField, error) {
+	if key.FieldContext != telemetrytypes.FieldContextBody {
+		return nil, nil
 	}
-	return conds, warnings, nil
+	return WrapAsLogicalFields(key.Name, []*telemetrytypes.TelemetryFieldKey{key}), nil
+}
+
+func (mainStorage) Traits() qbtypes.Traits {
+	return qbtypes.Traits{Split: qbtypes.MainOfSplit, SupportsBodyFunctions: true}
+}
+
+func (mainStorage) Compile(_ context.Context, _ qbtypes.QueryInfo, logical *telemetrytypes.LogicalField, operator qbtypes.FilterOperator, _ any, _ *sqlbuilder.SelectBuilder) (qbtypes.Compiled, error) {
+	if operator.IsFunctionOperator() && logical.FieldContext != telemetrytypes.FieldContextBody {
+		return qbtypes.Compiled{}, errors.NewInvalidInputf(errors.CodeInvalidInput, "function supports only body JSON search")
+	}
+	return qbtypes.Compiled{Condition: fmt.Sprintf("%s_cond", logical.Single().Name)}, nil
 }
 
 // visitComparisonCase is a single test case for the TestVisitComparison_* family.
@@ -879,7 +833,7 @@ func visitComparisonOpts(t *testing.T) (rsbOpts, sbOpts FilterExprVisitorOpts) {
 	rsbOpts = FilterExprVisitorOpts{
 		Context:            t.Context(),
 		FieldKeys:          visitTestKeys,
-		ConditionBuilder:   &resourceConditionBuilder{},
+		Storage:            &resourceStorage{},
 		Variables:          allVariable,
 		SkipResourceFilter: false,
 		SkipFullTextFilter: true,
@@ -887,7 +841,7 @@ func visitComparisonOpts(t *testing.T) (rsbOpts, sbOpts FilterExprVisitorOpts) {
 	sbOpts = FilterExprVisitorOpts{
 		Context:            t.Context(),
 		FieldKeys:          visitTestKeys,
-		ConditionBuilder:   &conditionBuilder{},
+		Storage:            &mainStorage{},
 		Variables:          allVariable,
 		SkipResourceFilter: true,
 		SkipFullTextFilter: false,
@@ -1630,6 +1584,8 @@ func TestVisitComparison_FunctionCalls(t *testing.T) {
 			wantErrSB: true,
 		},
 		{
+			// SB: a body function on a resource key is a user error, even when the
+			// resource sub-query would otherwise cover x.
 			name:      "has on resource key",
 			expr:      "has(x, 'hello')",
 			wantRSB:   "",

pkg/signoz/openapi.go

@@ -10,14 +10,12 @@ import (
 	"github.com/SigNoz/signoz/pkg/alertmanager"
 	"github.com/SigNoz/signoz/pkg/apiserver"
 	"github.com/SigNoz/signoz/pkg/apiserver/signozapiserver"
-	"github.com/SigNoz/signoz/pkg/auditor"
 	"github.com/SigNoz/signoz/pkg/authz"
 	"github.com/SigNoz/signoz/pkg/factory"
 	"github.com/SigNoz/signoz/pkg/flagger"
 	"github.com/SigNoz/signoz/pkg/gateway"
 	"github.com/SigNoz/signoz/pkg/global"
 	"github.com/SigNoz/signoz/pkg/http/handler"
-	"github.com/SigNoz/signoz/pkg/identn"
 	"github.com/SigNoz/signoz/pkg/instrumentation"
 	"github.com/SigNoz/signoz/pkg/licensing"
 	"github.com/SigNoz/signoz/pkg/modules/aiobservability"
@@ -44,11 +42,9 @@ import (
 	"github.com/SigNoz/signoz/pkg/prometheus"
 	"github.com/SigNoz/signoz/pkg/querier"
 	"github.com/SigNoz/signoz/pkg/ruler"
-	"github.com/SigNoz/signoz/pkg/sharder"
 	"github.com/SigNoz/signoz/pkg/statsreporter"
 	"github.com/SigNoz/signoz/pkg/subscription"
 	"github.com/SigNoz/signoz/pkg/types/authtypes"
-	"github.com/SigNoz/signoz/pkg/web"
 	"github.com/SigNoz/signoz/pkg/zeus"
 	"github.com/swaggest/jsonschema-go"
 	"github.com/swaggest/openapi-go"
@@ -105,11 +101,6 @@ func NewOpenAPI(ctx context.Context, instrumentation instrumentation.Instrumenta
 		struct{ ruler.Handler }{},
 		struct{ statsreporter.Handler }{},
 		struct{ savedview.Handler }{},
-		global.Config{},
-		struct{ identn.IdentNResolver }{},
-		struct{ sharder.Sharder }{},
-		struct{ auditor.Auditor }{},
-		struct{ web.Web }{},
 		struct{ quickfilter.Module }{},
 		struct{ quickfilter.Handler }{},
 	).New(ctx, instrumentation.ToProviderSettings(), apiserver.Config{})

pkg/signoz/provider.go

@@ -253,7 +253,6 @@ func NewSQLMigrationProviderFactories(
 		sqlmigration.NewAddQuickFilterTuplesFactory(sqlstore),
 		sqlmigration.NewAddIngestionTuplesFactory(sqlstore),
 		sqlmigration.NewAddSubscriptionTuplesFactory(sqlstore),
-		sqlmigration.NewNormalizeQuickFilterFieldsFactory(sqlstore),
 	)
 }
 
@@ -319,7 +318,7 @@ func NewQuerierProviderFactories(telemetryStore telemetrystore.TelemetryStore, p
 	)
 }
 
-func NewAPIServerProviderFactories(orgGetter organization.Getter, authz authz.AuthZ, modules Modules, handlers Handlers, globalConfig global.Config, gatewayService gateway.Gateway, identNResolver identn.IdentNResolver, sharder sharder.Sharder, auditor auditor.Auditor, web web.Web) factory.NamedMap[factory.ProviderFactory[apiserver.APIServer, apiserver.Config]] {
+func NewAPIServerProviderFactories(orgGetter organization.Getter, authz authz.AuthZ, modules Modules, handlers Handlers, globalConfig global.Config, gatewayService gateway.Gateway) factory.NamedMap[factory.ProviderFactory[apiserver.APIServer, apiserver.Config]] {
 	return factory.MustNewNamedMap(
 		signozapiserver.NewFactory(
 			orgGetter,
@@ -361,11 +360,6 @@ func NewAPIServerProviderFactories(orgGetter organization.Getter, authz authz.Au
 			handlers.RulerHandler,
 			handlers.StatsHandler,
 			handlers.SavedView,
-			globalConfig,
-			identNResolver,
-			sharder,
-			auditor,
-			web,
 			modules.QuickFilter,
 			handlers.QuickFilter,
 		),

pkg/signoz/provider_test.go

@@ -102,10 +102,6 @@ func TestNewProviderFactories(t *testing.T) {
 			Handlers{},
 			global.Config{},
 			nil,
-			nil,
-			nil,
-			nil,
-			nil,
 		)
 	})
 }