refactor: updating dashboard and integration config

* chore(docs): add authz guide

* chore(assets): clarify what withAuthZContent means

cmd/enterprise/meter.go

@@ -2,9 +2,9 @@ package main
 
 import (
 	"github.com/SigNoz/signoz/pkg/metercollector"
-	"github.com/SigNoz/signoz/pkg/telemetrylogs"
-	"github.com/SigNoz/signoz/pkg/telemetrymetrics"
-	"github.com/SigNoz/signoz/pkg/telemetrytraces"
+	"github.com/SigNoz/signoz/pkg/telemetryschema/logstelemetryschema"
+	"github.com/SigNoz/signoz/pkg/telemetryschema/metricstelemetryschema"
+	"github.com/SigNoz/signoz/pkg/telemetryschema/tracestelemetryschema"
 	"github.com/SigNoz/signoz/pkg/types/retentiontypes"
 	"github.com/SigNoz/signoz/pkg/types/zeustypes"
 )
@@ -25,8 +25,8 @@ var meterConfigs = []metercollector.Config{
 			Name:                 zeustypes.MeterLogSize,
 			Unit:                 zeustypes.MeterUnitBytes,
 			Aggregation:          zeustypes.MeterAggregationSum,
-			DBName:               telemetrylogs.DBName,
-			TableName:            telemetrylogs.LogsV2LocalTableName,
+			DBName:               logstelemetryschema.DBName,
+			TableName:            logstelemetryschema.LogsV2LocalTableName,
 			DefaultRetentionDays: retentiontypes.DefaultLogsRetentionDays,
 		},
 	},
@@ -36,8 +36,8 @@ var meterConfigs = []metercollector.Config{
 			Name:                 zeustypes.MeterSpanSize,
 			Unit:                 zeustypes.MeterUnitBytes,
 			Aggregation:          zeustypes.MeterAggregationSum,
-			DBName:               telemetrytraces.DBName,
-			TableName:            telemetrytraces.SpanIndexV3LocalTableName,
+			DBName:               tracestelemetryschema.DBName,
+			TableName:            tracestelemetryschema.SpanIndexV3LocalTableName,
 			DefaultRetentionDays: retentiontypes.DefaultTracesRetentionDays,
 		},
 	},
@@ -47,8 +47,8 @@ var meterConfigs = []metercollector.Config{
 			Name:                 zeustypes.MeterDatapointCount,
 			Unit:                 zeustypes.MeterUnitCount,
 			Aggregation:          zeustypes.MeterAggregationSum,
-			DBName:               telemetrymetrics.DBName,
-			TableName:            telemetrymetrics.SamplesV4LocalTableName,
+			DBName:               metricstelemetryschema.DBName,
+			TableName:            metricstelemetryschema.SamplesV4LocalTableName,
 			DefaultRetentionDays: retentiontypes.DefaultMetricsRetentionDays,
 		},
 	},

docs/api/openapi.yml

@@ -1496,6 +1496,9 @@ components:
       - redis
       - cloudsql_postgres
       - memorystore_redis
+      - computeengine
+      - gke
+      - cloudstorage
       type: string
     CloudintegrationtypesServiceMetadata:
       properties:
@@ -24695,149 +24698,6 @@ paths:
       summary: Replace variables
       tags:
       - querier
-  /prometheus/api/v1/query:
-    get:
-      deprecated: false
-      description: Evaluate a PromQL expression at a single instant. Request and
-        response follow the Prometheus HTTP API (https://prometheus.io/docs/prometheus/latest/querying/api/);
-        the /prometheus prefix distinguishes these PromQL-only endpoints from the
-        SigNoz query APIs. Also accepts POST with form-encoded parameters.
-      operationId: PrometheusInstantQuery
-      parameters:
-      - description: PromQL expression to evaluate
-        in: query
-        name: query
-        required: true
-        schema:
-          type: string
-      - description: 'Evaluation timestamp: float unix seconds or RFC3339. Defaults
-          to the server''s current time.'
-        in: query
-        name: time
-        schema:
-          type: string
-      - description: 'Evaluation timeout: float seconds or a Prometheus duration
-          string (e.g. 30s).'
-        in: query
-        name: timeout
-        schema:
-          type: string
-      - description: Set to any value to include query statistics in the response.
-        in: query
-        name: stats
-        schema:
-          type: string
-      responses:
-        "200":
-          content:
-            application/json:
-              schema:
-                properties:
-                  data:
-                    properties:
-                      result: {}
-                      resultType:
-                        enum:
-                        - matrix
-                        - vector
-                        - scalar
-                        - string
-                        type: string
-                      stats: {}
-                    type: object
-                  status:
-                    enum:
-                    - success
-                    type: string
-                type: object
-          description: Query evaluated successfully
-        "400":
-          description: Unparsable expression or parameters (errorType bad_data)
-        "422":
-          description: Expression failed to evaluate (errorType execution)
-        "503":
-          description: Query timed out or was canceled
-      summary: Prometheus instant query
-      tags:
-      - prometheus
-  /prometheus/api/v1/query_range:
-    get:
-      deprecated: false
-      description: Evaluate a PromQL expression over a range of time on a fixed
-        step grid. Request and response follow the Prometheus HTTP API
-        (https://prometheus.io/docs/prometheus/latest/querying/api/); the
-        /prometheus prefix distinguishes these PromQL-only endpoints from the
-        SigNoz query APIs. Grids are capped at 11,000 points per series. Also
-        accepts POST with form-encoded parameters.
-      operationId: PrometheusRangeQuery
-      parameters:
-      - description: PromQL expression to evaluate
-        in: query
-        name: query
-        required: true
-        schema:
-          type: string
-      - description: 'Start timestamp: float unix seconds or RFC3339.'
-        in: query
-        name: start
-        required: true
-        schema:
-          type: string
-      - description: 'End timestamp: float unix seconds or RFC3339.'
-        in: query
-        name: end
-        required: true
-        schema:
-          type: string
-      - description: 'Grid step: float seconds or a Prometheus duration string
-          (e.g. 30s). Must be positive.'
-        in: query
-        name: step
-        required: true
-        schema:
-          type: string
-      - description: 'Evaluation timeout: float seconds or a Prometheus duration
-          string (e.g. 30s).'
-        in: query
-        name: timeout
-        schema:
-          type: string
-      - description: Set to any value to include query statistics in the response.
-        in: query
-        name: stats
-        schema:
-          type: string
-      responses:
-        "200":
-          content:
-            application/json:
-              schema:
-                properties:
-                  data:
-                    properties:
-                      result: {}
-                      resultType:
-                        enum:
-                        - matrix
-                        type: string
-                      stats: {}
-                    type: object
-                  status:
-                    enum:
-                    - success
-                    type: string
-                type: object
-          description: Query evaluated successfully
-        "400":
-          description: Unparsable expression or parameters, or a grid past the 11,000-point
-            cap (errorType bad_data)
-        "422":
-          description: Expression failed to evaluate (errorType execution)
-        "503":
-          description: Query timed out or was canceled
-      summary: Prometheus range query
-      tags:
-      - prometheus
 servers:
 - description: The fully qualified URL to the SigNoz APIServer.
   url: https://{host}:{port}{base_path}

ee/metercollector/telemetrymetercollector/provider.go

@@ -16,7 +16,7 @@ import (
 	"github.com/SigNoz/signoz/pkg/factory"
 	"github.com/SigNoz/signoz/pkg/metercollector"
 	"github.com/SigNoz/signoz/pkg/modules/retention"
-	"github.com/SigNoz/signoz/pkg/telemetrymeter"
+	"github.com/SigNoz/signoz/pkg/telemetryschema/metertelemetryschema"
 	"github.com/SigNoz/signoz/pkg/telemetrystore"
 	"github.com/SigNoz/signoz/pkg/types/licensetypes"
 	"github.com/SigNoz/signoz/pkg/types/retentiontypes"
@@ -153,7 +153,7 @@ func (provider *Provider) Collect(
 func buildOriginQuery(meterName string) (string, []any) {
 	sb := sqlbuilder.NewSelectBuilder()
 	sb.Select("toInt64(ifNull(min(unix_milli), 0))")
-	sb.From(telemetrymeter.DBName + "." + telemetrymeter.SamplesTableName)
+	sb.From(metertelemetryschema.DBName + "." + metertelemetryschema.SamplesTableName)
 	sb.Where(sb.Equal("metric_name", meterName))
 	return sb.BuildWithFlavor(sqlbuilder.ClickHouse)
 }
@@ -171,7 +171,7 @@ func buildQuery(meterName string, segment *retentiontypes.RetentionPolicySegment
 
 	sb := sqlbuilder.NewSelectBuilder()
 	sb.Select(selects...)
-	sb.From(telemetrymeter.DBName + "." + telemetrymeter.SamplesTableName)
+	sb.From(metertelemetryschema.DBName + "." + metertelemetryschema.SamplesTableName)
 	sb.Where(
 		sb.Equal("metric_name", meterName),
 		sb.GTE("unix_milli", segment.StartMs),

ee/modules/metricreductionrule/implmetricreductionrule/clickhouse.go

@@ -8,16 +8,16 @@ import (
 	sqlbuilder "github.com/huandu/go-sqlbuilder"
 
 	"github.com/SigNoz/signoz/pkg/errors"
-	"github.com/SigNoz/signoz/pkg/telemetrymetrics"
+	"github.com/SigNoz/signoz/pkg/telemetryschema/metricstelemetryschema"
 	"github.com/SigNoz/signoz/pkg/telemetrystore"
 	"github.com/SigNoz/signoz/pkg/types/ctxtypes"
 	"github.com/SigNoz/signoz/pkg/types/metricreductionruletypes"
 )
 
 var (
-	reductionRulesTable = telemetrymetrics.DBName + "." + telemetrymetrics.ReductionRulesTableName
-	metadataTable       = telemetrymetrics.DBName + "." + telemetrymetrics.AttributesMetadataTableName
-	bufferSeriesTable   = telemetrymetrics.DBName + "." + telemetrymetrics.TimeseriesV4BufferTableName
+	reductionRulesTable = metricstelemetryschema.DBName + "." + metricstelemetryschema.ReductionRulesTableName
+	metadataTable       = metricstelemetryschema.DBName + "." + metricstelemetryschema.AttributesMetadataTableName
+	bufferSeriesTable   = metricstelemetryschema.DBName + "." + metricstelemetryschema.TimeseriesV4BufferTableName
 )
 
 const timeSeriesBucketMilli = int64(time.Hour / time.Millisecond)
@@ -192,7 +192,7 @@ func (c *clickhouse) ingestedSeriesCount(ctx context.Context, metricNames []stri
 
 	sb := sqlbuilder.NewSelectBuilder()
 	sb.Select("metric_name", "uniq(fingerprint)")
-	sb.From(telemetrymetrics.DBName + "." + telemetrymetrics.SamplesV4BufferTableName)
+	sb.From(metricstelemetryschema.DBName + "." + metricstelemetryschema.SamplesV4BufferTableName)
 	conds := []string{
 		sb.In("metric_name", names...),
 		sb.GE("unix_milli", startMs),
@@ -229,8 +229,8 @@ func (c *clickhouse) ingestedSeriesCount(ctx context.Context, metricNames []stri
 // reduced sample tables.
 func (c *clickhouse) reducedSeriesCount(ctx context.Context, metricNames []string, effectiveFrom map[string]int64, startMs, endMs int64) (map[string]uint64, error) {
 	out := make(map[string]uint64, len(metricNames))
-	for _, table := range []string{telemetrymetrics.SamplesV4ReducedLastTableName, telemetrymetrics.SamplesV4ReducedSumTableName} {
-		counts, err := c.reducedSeriesCountForTable(ctx, telemetrymetrics.DBName+"."+table, metricNames, effectiveFrom, startMs, endMs)
+	for _, table := range []string{metricstelemetryschema.SamplesV4ReducedLastTableName, metricstelemetryschema.SamplesV4ReducedSumTableName} {
+		counts, err := c.reducedSeriesCountForTable(ctx, metricstelemetryschema.DBName+"."+table, metricNames, effectiveFrom, startMs, endMs)
 		if err != nil {
 			return nil, err
 		}
@@ -300,9 +300,9 @@ func (c *clickhouse) RankByVolume(ctx context.Context, metricNames []string, eff
 		direction = "DESC"
 	}
 
-	ingestedTable := telemetrymetrics.DBName + "." + telemetrymetrics.SamplesV4BufferTableName
-	reducedLast := telemetrymetrics.DBName + "." + telemetrymetrics.SamplesV4ReducedLastTableName
-	reducedSum := telemetrymetrics.DBName + "." + telemetrymetrics.SamplesV4ReducedSumTableName
+	ingestedTable := metricstelemetryschema.DBName + "." + metricstelemetryschema.SamplesV4BufferTableName
+	reducedLast := metricstelemetryschema.DBName + "." + metricstelemetryschema.SamplesV4ReducedLastTableName
+	reducedSum := metricstelemetryschema.DBName + "." + metricstelemetryschema.SamplesV4ReducedSumTableName
 
 	sb := sqlbuilder.NewSelectBuilder()
 	sb.Select("base.metric_name AS metric_name", "ifNull(i.cnt, 0) AS ingested", "ifNull(d.cnt, 0) AS reduced")
@@ -352,16 +352,16 @@ func (c *clickhouse) SampleVolumeByMetric(ctx context.Context, metricNames []str
 	}
 	ctx = c.withThreads(ctx)
 
-	ingested, err := c.countSamplesByMetric(ctx, telemetrymetrics.DBName+"."+telemetrymetrics.SamplesV4BufferTableName, "count()", metricNames, effectiveFrom, startMs, endMs)
+	ingested, err := c.countSamplesByMetric(ctx, metricstelemetryschema.DBName+"."+metricstelemetryschema.SamplesV4BufferTableName, "count()", metricNames, effectiveFrom, startMs, endMs)
 	if err != nil {
 		return nil, err
 	}
 
-	last, err := c.countSamplesByMetric(ctx, telemetrymetrics.DBName+"."+telemetrymetrics.SamplesV4ReducedLastTableName, "uniq(reduced_fingerprint, unix_milli)", metricNames, effectiveFrom, startMs, endMs)
+	last, err := c.countSamplesByMetric(ctx, metricstelemetryschema.DBName+"."+metricstelemetryschema.SamplesV4ReducedLastTableName, "uniq(reduced_fingerprint, unix_milli)", metricNames, effectiveFrom, startMs, endMs)
 	if err != nil {
 		return nil, err
 	}
-	sum, err := c.countSamplesByMetric(ctx, telemetrymetrics.DBName+"."+telemetrymetrics.SamplesV4ReducedSumTableName, "uniq(reduced_fingerprint, unix_milli)", metricNames, effectiveFrom, startMs, endMs)
+	sum, err := c.countSamplesByMetric(ctx, metricstelemetryschema.DBName+"."+metricstelemetryschema.SamplesV4ReducedSumTableName, "uniq(reduced_fingerprint, unix_milli)", metricNames, effectiveFrom, startMs, endMs)
 	if err != nil {
 		return nil, err
 	}
@@ -419,7 +419,7 @@ func (c *clickhouse) TotalVolume(ctx context.Context, startMs, endMs int64) (uin
 
 	sb := sqlbuilder.NewSelectBuilder()
 	sb.Select("uniq(fingerprint)", "count()")
-	sb.From(telemetrymetrics.DBName + "." + telemetrymetrics.SamplesV4BufferTableName)
+	sb.From(metricstelemetryschema.DBName + "." + metricstelemetryschema.SamplesV4BufferTableName)
 	sb.Where(sb.GE("unix_milli", startMs), sb.LT("unix_milli", endMs))
 
 	query, args := sb.BuildWithFlavor(sqlbuilder.ClickHouse)
@@ -470,7 +470,7 @@ func (c *clickhouse) SampleTimeseries(ctx context.Context, ruledMetrics []string
 func (c *clickhouse) totalSamplesByBucket(ctx context.Context, startMs, endMs int64) (map[int64]uint64, error) {
 	sb := sqlbuilder.NewSelectBuilder()
 	sb.Select(sampleBucketExpr, "count()")
-	sb.From(telemetrymetrics.DBName + "." + telemetrymetrics.SamplesV4BufferTableName)
+	sb.From(metricstelemetryschema.DBName + "." + metricstelemetryschema.SamplesV4BufferTableName)
 	sb.Where(sb.GE("unix_milli", startMs), sb.LT("unix_milli", endMs))
 	sb.GroupBy("bucket")
 
@@ -485,7 +485,7 @@ func (c *clickhouse) ruledIngestedSamplesByBucket(ctx context.Context, metricNam
 
 	sb := sqlbuilder.NewSelectBuilder()
 	sb.Select(sampleBucketExpr, "count()")
-	sb.From(telemetrymetrics.DBName + "." + telemetrymetrics.SamplesV4BufferTableName)
+	sb.From(metricstelemetryschema.DBName + "." + metricstelemetryschema.SamplesV4BufferTableName)
 	conds := []string{sb.In("metric_name", names...), sb.GE("unix_milli", startMs), sb.LT("unix_milli", endMs)}
 	if len(effectiveFrom) > 0 {
 		conds = append(conds, strictEffectiveFrom(sb, metricNames, effectiveFrom))
@@ -499,7 +499,7 @@ func (c *clickhouse) ruledIngestedSamplesByBucket(ctx context.Context, metricNam
 // reduced 60s rows are versioned by computed_at, so count distinct buckets.
 func (c *clickhouse) ruledRetainedSamplesByBucket(ctx context.Context, metricNames []string, effectiveFrom map[string]int64, startMs, endMs int64) (map[int64]uint64, error) {
 	out := make(map[int64]uint64)
-	for _, table := range []string{telemetrymetrics.SamplesV4ReducedLastTableName, telemetrymetrics.SamplesV4ReducedSumTableName} {
+	for _, table := range []string{metricstelemetryschema.SamplesV4ReducedLastTableName, metricstelemetryschema.SamplesV4ReducedSumTableName} {
 		names := make([]any, len(metricNames))
 		for i, name := range metricNames {
 			names[i] = name
@@ -507,7 +507,7 @@ func (c *clickhouse) ruledRetainedSamplesByBucket(ctx context.Context, metricNam
 
 		sb := sqlbuilder.NewSelectBuilder()
 		sb.Select(sampleBucketExpr, "uniq(reduced_fingerprint, unix_milli)")
-		sb.From(telemetrymetrics.DBName + "." + table)
+		sb.From(metricstelemetryschema.DBName + "." + table)
 		conds := []string{sb.In("metric_name", names...), sb.GE("unix_milli", startMs), sb.LT("unix_milli", endMs)}
 		if len(effectiveFrom) > 0 {
 			conds = append(conds, strictEffectiveFrom(sb, metricNames, effectiveFrom))

frontend/docs/authz-guide.md

@@ -0,0 +1,136 @@
+# AuthZ Guide
+
+How to structure a page so it works with the permission system.
+
+We are migrating from the `ADMIN | EDITOR | VIEWER` roles to per-action checks. Instead of granting `VIEWER` and
+exposing everything, a user can now be granted access to a single resource, eg: `Logs` only.
+
+- [Prerequisites](#prerequisites)
+- [Core rules](#core-rules)
+- [Page patterns](#page-patterns)
+- [What "blocked" means](#what-blocked-means)
+- [Migration checklist](#migration-checklist)
+- [Testing](#testing)
+
+## Prerequisites
+
+Check whether the resource your page represents is supported: see
+[permissions.type.ts](../src/lib/authz/hooks/useAuthZ/permissions.type.ts) for the current resources and their allowed
+verbs.
+
+**If the resource is not listed there, skip authz for now**. The backend does not enforce it yet, so any frontend
+check would be decorative. Revisit once the resource is generated into that file (it is auto-generated from the
+backend).
+
+## Core rules
+
+These hold for every page. The per-pattern sections below only add to them.
+
+1. **A page is always reachable, regardless of permission.** The intended action must be known before permission can
+   be checked, so the route renders first and individual pieces are gated.
+2. **`update` requires both `read` and `update`.** A user who can write but cannot read the current value must not get
+   an edit affordance.
+3. **`delete` is independent of `read`.** Delete controls stay visible for a user who holds `delete` but not `read`.
+4. **Never gate per row.** If a user can `list`, render every row. Check `read` only when the row is opened (drawer or
+   detail route).
+5. **Gate the narrowest thing that works**, a button over a section, a section over a page.
+6. **A resource may be gated while a sub-resource is not.** A user without `read` on Service Accounts can still hold
+   `create` on API Keys, so blocking the outer container would hide work they are allowed to do.
+7. **Verbs not covered here** (`attach`, `detach`, `assignee`) behave like `delete`: gate the control that triggers
+   them, not the surrounding content.
+
+## Page patterns
+
+### List page
+
+![Visual rules for structuring a list page](./assets/list-example.svg)
+
+Without `list`, but with any of `read` / `create` / `update`, only the table is blocked:
+
+- Title, description, search filters and action buttons stay visible.
+- Filters and any control that drives the table are non-interactive.
+- The create button stays enabled if the user holds `create`.
+
+### Edit page
+
+![Visual rules for structuring an edit page](./assets/edit-example.svg)
+
+Without `read`:
+
+- Block the content with `withAuthZContent`, not the whole route.
+- Keep delete visible (rule 3).
+- Keep update blocked (rule 2).
+
+### Drawer
+
+![Visual rules for structuring a drawer](./assets/drawer-example.svg)
+
+Without `read`:
+
+- Block the drawer body, not the drawer itself.
+- Prefer routing that carries the resource ID in the URL, so delete stays reachable without `read`.
+- Keep update blocked (rule 2).
+- Watch for sub-resources the user may still be allowed to act on (rule 6).
+
+### Create
+
+Without `create`:
+
+| Entry point           | Gate with                                                     |
+| --------------------- | ------------------------------------------------------------- |
+| Button                | `AuthZButton`                                                 |
+| Dedicated create page | `withAuthZPage`                                               |
+| Create drawer opened directly (deep link) | `withAuthZContent` on the body + `AuthZButton` on footer actions |
+
+### Delete
+
+Gate the control with `AuthZButton`, or `AuthZTooltip` for a non-button trigger such as an icon or menu item.
+
+### Quick filters
+
+![Visual rules for structuring a page with quick filters](./assets/quick-filters-example.svg)
+
+## What "blocked" means
+
+Blocking is always a visible denial, never a silent removal. Use the components in
+[`lib/authz/components`](../src/lib/authz/components/README.md) rather than hand-rolling a check, they carry the
+denial message and the loading state.
+
+| Scope           | Component                                 | Denied state                                |
+| --------------- | ----------------------------------------- | ------------------------------------------- |
+| Button          | `AuthZButton`                             | Disabled + tooltip                          |
+| Any element      | `AuthZTooltip`                            | Disabled child + tooltip                    |
+| Section         | `withAuthZContent` / `AuthZGuardContent`  | Inline `PermissionDeniedCallout`            |
+| Page / route    | `withAuthZPage` / `AuthZGuardPage`        | `PermissionDeniedFullPage`                  |
+| Custom fallback | `withAuthZ` / `AuthZGuard`                | Whatever you pass as `fallback`             |
+
+Prefer the HOC (`withAuthZ*`); reach for the JSX guard (`AuthZGuard*`) when the gate depends on conditional rendering
+and an HOC cannot express it. The components README has the full decision tree and how to build the `checks` array.
+
+## Migration checklist
+
+Use the existing components. Create a new one only if none fit.
+
+- [ ] Can I apply a `withAuthZ*` variant directly, or must I extract the content into a component first?
+  - If extraction is needed, declare the new content component in the same file to keep the diff small, then move it
+    to its own file in a follow-up commit or PR.
+- [ ] Is the layout structured to respect the [core rules](#core-rules)?
+  - If not, raise it in the frontend Slack channel before reshaping the page.
+- [ ] Am I gating a shared component rather than a page or section?
+  - If so, it must stay functional with no permission. Example: the Query Builder works without field suggestions when
+    the user cannot read them.
+
+## Testing
+
+### Devtool
+
+Press `Cmd + K` (`Ctrl + K` on Windows/Linux) to open the shortcuts, search for `AuthZ`, and pick the first
+result. The devtool simulates granted and denied permissions across the UI.
+
+Available only in local development, it is stripped from production builds.
+
+### Unit tests
+
+[`lib/authz/utils/README.md`](../src/lib/authz/utils/README.md) covers the `*.authz.test.tsx` naming convention, the
+MSW handlers (`setupAuthzAdmin`, `setupAuthzDenyAll`, `setupAuthzDeny`, `setupAuthzAllow`,
+`setupAuthzGrantByPrefix`), and how to test the loading state.

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

@@ -2815,6 +2815,8 @@ export enum CloudintegrationtypesServiceIDDTO {
 	redis = 'redis',
 	cloudsql_postgres = 'cloudsql_postgres',
 	memorystore_redis = 'memorystore_redis',
+	computeengine = 'computeengine',
+	gke = 'gke',
 }
 export type CloudintegrationtypesCloudIntegrationServiceDTOAnyOf = {
 	/**

frontend/src/assets/Logos/gcp-cloud-storage.svg

@@ -1 +1 @@
-<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="1200" height="800" viewBox="-19.2 -28.483 166.401 170.898"><g transform="translate(0 -7.034)"><linearGradient id="a" x1="64" x2="64" y1="7.034" y2="120.789" gradientUnits="userSpaceOnUse"><stop offset="0" stop-color="#4387fd"/><stop offset="1" stop-color="#4683ea"/></linearGradient><path fill="url(#a)" d="M27.79 115.217 1.54 69.749a11.5 11.5 0 0 1 0-11.499l26.25-45.467a11.5 11.5 0 0 1 9.96-5.75h52.5a11.5 11.5 0 0 1 9.959 5.75l26.25 45.467a11.5 11.5 0 0 1 0 11.5l-26.25 45.466a11.5 11.5 0 0 1-9.959 5.75h-52.5a11.5 11.5 0 0 1-9.96-5.75z"/></g><g transform="translate(0 -7.034)"><defs><path id="b" d="M27.791 115.217 1.541 69.749a11.5 11.5 0 0 1 0-11.499l26.25-45.467a11.5 11.5 0 0 1 9.959-5.75h52.5a11.5 11.5 0 0 1 9.96 5.75l26.25 45.467a11.5 11.5 0 0 1 0 11.5l-26.25 45.466a11.5 11.5 0 0 1-9.96 5.75h-52.5a11.5 11.5 0 0 1-9.959-5.75z"/></defs><clipPath id="c"><use xlink:href="#b" width="100%" height="100%" overflow="visible"/></clipPath><path d="m49.313 53.875-7.01 6.99 5.957 5.958-5.898 10.476 44.635 44.636 10.816.002L118.936 84 85.489 50.55z" clip-path="url(#c)" opacity=".07"/></g><path fill="#fff" d="M84.7 43.236H43.264c-.667 0-1.212.546-1.212 1.214v8.566c0 .666.546 1.212 1.212 1.212H84.7c.667 0 1.213-.546 1.213-1.212v-8.568c0-.666-.545-1.213-1.212-1.213m-6.416 7.976a2.484 2.484 0 0 1-2.477-2.48 2.475 2.475 0 0 1 2.477-2.477c1.37 0 2.48 1.103 2.48 2.477a2.48 2.48 0 0 1-2.48 2.48m6.415 8.491-41.436.002c-.667 0-1.212.546-1.212 1.214v8.565c0 .666.546 1.213 1.212 1.213H84.7c.667 0 1.213-.547 1.213-1.213v-8.567c0-.666-.545-1.214-1.212-1.214m-6.416 7.976a2.483 2.483 0 0 1-2.477-2.48 2.475 2.475 0 0 1 2.477-2.477 2.48 2.48 0 1 1 0 4.956"/></svg>
+<svg xmlns="http://www.w3.org/2000/svg" width="24px" height="24px" viewBox="0 0 24 24"><defs><style>.cls-1{fill:#aecbfa;}.cls-2{fill:#669df6;}.cls-3{fill:#4285f4;}</style></defs><title>Icon_24px_CloudStorage_Color</title><g data-name="Product Icons"><path class="cls-1" d="M2,4.5H22a0,0,0,0,1,0,0v5a0,0,0,0,1,0,0H2a0,0,0,0,1,0,0v-5A0,0,0,0,1,2,4.5Z"/><path class="cls-2" d="M2,14.5H22a0,0,0,0,1,0,0v5a0,0,0,0,1,0,0H2a0,0,0,0,1,0,0v-5A0,0,0,0,1,2,14.5Z"/><rect class="cls-3" x="4.5" y="6.33" width="3.33" height="1.33"/><rect class="cls-3" x="4.5" y="16.33" width="3.33" height="1.33"/><circle class="cls-3" cx="18.5" cy="7" r="1"/><circle class="cls-3" cx="18.5" cy="17" r="1"/></g></svg>

frontend/src/assets/Logos/gcp-gke.svg

@@ -1 +1 @@
-<svg xmlns="http://www.w3.org/2000/svg" width="24" height="24"><path d="M19.73 6.56a1.73 1.73 0 0 0-1.68 1.68 1.83 1.83 0 0 0 .89 1.48v6.9l-5.16 3.06.8 1.28 5.55-3.25a.84.84 0 0 0 .4-.69v-7.3a1.64 1.64 0 0 0 .89-1.48 1.61 1.61 0 0 0-1.69-1.68" style="fill:#aecbfa"/><path d="m18 5.48-5.61-3.16a1.18 1.18 0 0 0-.79 0L5.25 6a1.72 1.72 0 0 0-2.68 1.35A1.73 1.73 0 0 0 4.26 9a1.73 1.73 0 0 0 1.68-1.65L12 3.9l5.15 3ZM11.2 18.5a1.57 1.57 0 0 0-.89.29l-5.16-3V9.92H3.56v6.31a.84.84 0 0 0 .4.69L9.52 20v.09a1.69 1.69 0 0 0 3.37 0 1.65 1.65 0 0 0-1.69-1.59" data-name="Path" style="fill:#aecbfa"/><path d="M16.96 8.63 12.1 5.78 7.13 8.63l4.97 2.77z" data-name="Path" style="fill:#669df6"/><path d="M12.1 12.38 6.84 9.32v2.47l5.26 2.96zM12.1 15.73l-5.26-3.05v2.07l5.26 3.06z" style="fill:#669df6"/><path d="M12.09 12.38v2.37l5.26-3.06V9.33Zm4.32-.94a.38.38 0 1 1 0-.76.38.38 0 0 1 0 .76M12.09 15.73v2.07l5.26-3.05v-2.07Zm4.32-1.07a.38.38 0 1 1 0-.76.38.38 0 0 1 0 .76" style="fill:#4285f4"/></svg>
+<svg xmlns="http://www.w3.org/2000/svg" width="24px" height="24px" viewBox="0 0 24 24"><defs><style>.cls-1{fill:#4285f4;}.cls-1,.cls-2,.cls-4{fill-rule:evenodd;}.cls-2{fill:#669df6;}.cls-3,.cls-4{fill:#aecbfa;}</style></defs><title>Icon_24px_K8Engine_Color</title><g data-name="Product Icons"><g ><polygon class="cls-1" points="14.68 13.06 19.23 15.69 19.23 16.68 14.29 13.83 14.68 13.06"/><polygon class="cls-2" points="9.98 13.65 4.77 16.66 4.45 15.86 9.53 12.92 9.98 13.65"/><rect class="cls-3" x="11.55" y="3.29" width="0.86" height="5.78"/><path class="cls-4" d="M3.25,7V17L12,22l8.74-5V7L12,2Zm15.63,8.89L12,19.78,5.12,15.89V8.11L12,4.22l6.87,3.89v7.78Z"/><polygon class="cls-4" points="11.98 11.5 15.96 9.21 11.98 6.91 8.01 9.21 11.98 11.5"/><polygon class="cls-2" points="11.52 12.3 7.66 10.01 7.66 14.6 11.52 16.89 11.52 12.3"/><polygon class="cls-1" points="12.48 12.3 12.48 16.89 16.34 14.6 16.34 10.01 12.48 12.3"/></g></g></svg>

frontend/vite.config.ts

@@ -143,6 +143,12 @@ export default defineConfig(({ mode }): UserConfig => {
 		plugins,
 		resolve: {
 			alias: {
+				// @grafana/data imports bare CJS `lodash`, whose UMD footer checks for an
+				// AMD loader before assigning module.exports. Any third-party script that
+				// defines window.define.amd first leaves the bundled namespace empty, so
+				// every lodash method reached through it is undefined at runtime. lodash-es
+				// is the same version, real ESM, and tree-shakes.
+				lodash: 'lodash-es',
 				'@': resolve(__dirname, './src'),
 				utils: resolve(__dirname, './src/utils'),
 				types: resolve(__dirname, './src/types'),

go.mod

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

go.sum

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

pkg/flagger/registry.go

@@ -14,8 +14,6 @@ var (
 	FeatureEnableAIObservability  = featuretypes.MustNewName("enable_ai_observability")
 	FeatureEnableMetricsReduction = featuretypes.MustNewName("enable_metrics_reduction")
 	FeatureUseInfraMonitoringV2   = featuretypes.MustNewName("use_infra_monitoring_v2")
-
-	FeatureUsePrometheusClickhouseV2 = featuretypes.MustNewName("use_prometheus_clickhouse_v2")
 )
 
 func MustNewRegistry() featuretypes.Registry {
@@ -108,14 +106,6 @@ func MustNewRegistry() featuretypes.Registry {
 			DefaultVariant: featuretypes.MustNewName("disabled"),
 			Variants:       featuretypes.NewBooleanVariants(),
 		},
-		&featuretypes.Feature{
-			Name:           FeatureUsePrometheusClickhouseV2,
-			Kind:           featuretypes.KindBoolean,
-			Stage:          featuretypes.StageExperimental,
-			Description:    "Runs PromQL queries on the clickhousev2 provider alongside the served engine result and logs any difference; serving is unaffected.",
-			DefaultVariant: featuretypes.MustNewName("disabled"),
-			Variants:       featuretypes.NewBooleanVariants(),
-		},
 	)
 	if err != nil {
 		panic(err)

pkg/modules/cloudintegration/implcloudintegration/fs/definitions/gcp/cloudstorage/assets/dashboards/overview.json

@@ -0,0 +1,956 @@
+{
+  "schemaVersion": "v6",
+  "image": "/assets/Logos/gcp-cloud-storage",
+  "name": "",
+  "generateName": true,
+  "tags": [
+    {
+      "key": "tag",
+      "value": "observability"
+    }
+  ],
+  "spec": {
+    "display": {
+      "name": "GCP Cloud Storage Overview",
+      "description": "Dashboard for GCP Cloud Storage overview"
+    },
+    "variables": [
+      {
+        "kind": "ListVariable",
+        "spec": {
+          "display": {
+            "name": "project_id",
+            "description": "GCP Project ID"
+          },
+          "allowAllValue": false,
+          "allowMultiple": false,
+          "customAllValue": "",
+          "capturingRegexp": "",
+          "sort": "none",
+          "plugin": {
+            "kind": "signoz/DynamicVariable",
+            "spec": {
+              "name": "project_id",
+              "signal": "metrics"
+            }
+          },
+          "name": "project_id"
+        }
+      },
+      {
+        "kind": "ListVariable",
+        "spec": {
+          "display": {
+            "name": "bucket_name",
+            "description": "GCS bucket name"
+          },
+          "allowAllValue": true,
+          "allowMultiple": true,
+          "customAllValue": "",
+          "capturingRegexp": "",
+          "sort": "none",
+          "plugin": {
+            "kind": "signoz/DynamicVariable",
+            "spec": {
+              "name": "bucket_name",
+              "signal": "metrics"
+            }
+          },
+          "name": "bucket_name"
+        }
+      }
+    ],
+    "panels": {
+      "1f0a4d5b-6c2e-4a71-8b3d-9e5c07a41d20": {
+        "kind": "Panel",
+        "spec": {
+          "display": {
+            "name": "Bucket size",
+            "description": "Total size of all objects in the bucket, grouped by storage class."
+          },
+          "plugin": {
+            "kind": "signoz/TablePanel",
+            "spec": {
+              "visualization": {
+                "timePreference": "global_time"
+              },
+              "formatting": {
+                "columnUnits": {
+                  "A": "By"
+                },
+                "decimalPrecision": "2"
+              },
+              "thresholds": null
+            }
+          },
+          "queries": [
+            {
+              "kind": "scalar",
+              "spec": {
+                "name": "A",
+                "plugin": {
+                  "kind": "signoz/BuilderQuery",
+                  "spec": {
+                    "name": "A",
+                    "signal": "metrics",
+                    "source": "",
+                    "aggregations": [
+                      {
+                        "metricName": "storage.googleapis.com/storage/v2/total_bytes",
+                        "temporality": "",
+                        "timeAggregation": "latest",
+                        "spaceAggregation": "sum",
+                        "reduceTo": "last"
+                      }
+                    ],
+                    "disabled": false,
+                    "filter": {
+                      "expression": "project_id = $project_id AND bucket_name in $bucket_name AND gcp.resource_type = 'gcs_bucket'"
+                    },
+                    "groupBy": [
+                      {
+                        "name": "bucket_name",
+                        "signal": "",
+                        "fieldContext": "attribute",
+                        "fieldDataType": "string"
+                      },
+                      {
+                        "name": "storage_class",
+                        "signal": "",
+                        "fieldContext": "attribute",
+                        "fieldDataType": "string"
+                      }
+                    ],
+                    "order": [],
+                    "having": {
+                      "expression": ""
+                    },
+                    "functions": [],
+                    "legend": "Size"
+                  }
+                }
+              }
+            }
+          ],
+          "links": []
+        }
+      },
+      "29ed9824-21db-44c3-9537-12be458f5c20": {
+        "kind": "Panel",
+        "spec": {
+          "display": {
+            "name": "Total object bytes",
+            "description": "Total size of all objects in the bucket, grouped by storage class and type."
+          },
+          "plugin": {
+            "kind": "signoz/TimeSeriesPanel",
+            "spec": {
+              "visualization": {
+                "timePreference": "global_time",
+                "fillSpans": false
+              },
+              "formatting": {
+                "unit": "By",
+                "decimalPrecision": "2"
+              },
+              "chartAppearance": {
+                "lineInterpolation": "spline",
+                "showPoints": false,
+                "lineStyle": "solid",
+                "fillMode": "none",
+                "spanGaps": {
+                  "fillOnlyBelow": false,
+                  "fillLessThan": ""
+                }
+              },
+              "axes": {
+                "softMin": 0,
+                "softMax": 0,
+                "isLogScale": false
+              },
+              "legend": {
+                "position": "right",
+                "mode": "list",
+                "customColors": null
+              },
+              "thresholds": null
+            }
+          },
+          "queries": [
+            {
+              "kind": "time_series",
+              "spec": {
+                "name": "A",
+                "plugin": {
+                  "kind": "signoz/BuilderQuery",
+                  "spec": {
+                    "name": "A",
+                    "signal": "metrics",
+                    "source": "",
+                    "aggregations": [
+                      {
+                        "metricName": "storage.googleapis.com/storage/v2/total_bytes",
+                        "temporality": "",
+                        "timeAggregation": "latest",
+                        "spaceAggregation": "sum",
+                        "reduceTo": "avg"
+                      }
+                    ],
+                    "disabled": false,
+                    "filter": {
+                      "expression": "project_id = $project_id AND bucket_name in $bucket_name AND gcp.resource_type = 'gcs_bucket'"
+                    },
+                    "groupBy": [
+                      {
+                        "name": "bucket_name",
+                        "signal": "",
+                        "fieldContext": "attribute",
+                        "fieldDataType": "string"
+                      },
+                      {
+                        "name": "storage_class",
+                        "signal": "",
+                        "fieldContext": "attribute",
+                        "fieldDataType": "string"
+                      },
+                      {
+                        "name": "type",
+                        "signal": "",
+                        "fieldContext": "attribute",
+                        "fieldDataType": "string"
+                      }
+                    ],
+                    "order": [],
+                    "having": {
+                      "expression": ""
+                    },
+                    "functions": [],
+                    "legend": "{{bucket_name}}/{{storage_class}}/{{type}}"
+                  }
+                }
+              }
+            }
+          ],
+          "links": []
+        }
+      },
+      "cbc53174-5527-4bce-b32d-317403849e48": {
+        "kind": "Panel",
+        "spec": {
+          "display": {
+            "name": "Total object count",
+            "description": "Total number of objects and multipart-uploads per bucket, grouped by storage class and type, where type can be live-object, noncurrent-object, soft-deleted-object or multipart-upload."
+          },
+          "plugin": {
+            "kind": "signoz/TimeSeriesPanel",
+            "spec": {
+              "visualization": {
+                "timePreference": "global_time",
+                "fillSpans": false
+              },
+              "formatting": {
+                "unit": "{count}",
+                "decimalPrecision": "2"
+              },
+              "chartAppearance": {
+                "lineInterpolation": "spline",
+                "showPoints": false,
+                "lineStyle": "solid",
+                "fillMode": "none",
+                "spanGaps": {
+                  "fillOnlyBelow": false,
+                  "fillLessThan": ""
+                }
+              },
+              "axes": {
+                "softMin": 0,
+                "softMax": 0,
+                "isLogScale": false
+              },
+              "legend": {
+                "position": "right",
+                "mode": "list",
+                "customColors": null
+              },
+              "thresholds": null
+            }
+          },
+          "queries": [
+            {
+              "kind": "time_series",
+              "spec": {
+                "name": "A",
+                "plugin": {
+                  "kind": "signoz/BuilderQuery",
+                  "spec": {
+                    "name": "A",
+                    "signal": "metrics",
+                    "source": "",
+                    "aggregations": [
+                      {
+                        "metricName": "storage.googleapis.com/storage/v2/total_count",
+                        "temporality": "",
+                        "timeAggregation": "latest",
+                        "spaceAggregation": "sum",
+                        "reduceTo": "avg"
+                      }
+                    ],
+                    "disabled": false,
+                    "filter": {
+                      "expression": "project_id = $project_id AND bucket_name in $bucket_name AND gcp.resource_type = 'gcs_bucket'"
+                    },
+                    "groupBy": [
+                      {
+                        "name": "bucket_name",
+                        "signal": "",
+                        "fieldContext": "attribute",
+                        "fieldDataType": "string"
+                      },
+                      {
+                        "name": "storage_class",
+                        "signal": "",
+                        "fieldContext": "attribute",
+                        "fieldDataType": "string"
+                      },
+                      {
+                        "name": "type",
+                        "signal": "",
+                        "fieldContext": "attribute",
+                        "fieldDataType": "string"
+                      }
+                    ],
+                    "order": [],
+                    "having": {
+                      "expression": ""
+                    },
+                    "functions": [],
+                    "legend": "{{bucket_name}}/{{storage_class}}/{{type}}"
+                  }
+                }
+              }
+            }
+          ],
+          "links": []
+        }
+      },
+      "76e70ce5-47e4-4b5b-9715-49fa21c58b0c": {
+        "kind": "Panel",
+        "spec": {
+          "display": {
+            "name": "Deleted bytes",
+            "description": "Rate of deleted bytes per bucket, grouped by storage class."
+          },
+          "plugin": {
+            "kind": "signoz/TimeSeriesPanel",
+            "spec": {
+              "visualization": {
+                "timePreference": "global_time",
+                "fillSpans": false
+              },
+              "formatting": {
+                "unit": "By/s",
+                "decimalPrecision": "2"
+              },
+              "chartAppearance": {
+                "lineInterpolation": "spline",
+                "showPoints": false,
+                "lineStyle": "solid",
+                "fillMode": "none",
+                "spanGaps": {
+                  "fillOnlyBelow": false,
+                  "fillLessThan": ""
+                }
+              },
+              "axes": {
+                "softMin": 0,
+                "softMax": 0,
+                "isLogScale": false
+              },
+              "legend": {
+                "position": "right",
+                "mode": "list",
+                "customColors": null
+              },
+              "thresholds": null
+            }
+          },
+          "queries": [
+            {
+              "kind": "time_series",
+              "spec": {
+                "name": "A",
+                "plugin": {
+                  "kind": "signoz/BuilderQuery",
+                  "spec": {
+                    "name": "A",
+                    "signal": "metrics",
+                    "source": "",
+                    "aggregations": [
+                      {
+                        "metricName": "storage.googleapis.com/storage/v2/deleted_bytes",
+                        "temporality": "",
+                        "timeAggregation": "rate",
+                        "spaceAggregation": "sum",
+                        "reduceTo": "sum"
+                      }
+                    ],
+                    "disabled": false,
+                    "filter": {
+                      "expression": "project_id = $project_id AND bucket_name in $bucket_name AND gcp.resource_type = 'gcs_bucket'"
+                    },
+                    "groupBy": [
+                      {
+                        "name": "bucket_name",
+                        "signal": "",
+                        "fieldContext": "attribute",
+                        "fieldDataType": "string"
+                      },
+                      {
+                        "name": "storage_class",
+                        "signal": "",
+                        "fieldContext": "attribute",
+                        "fieldDataType": "string"
+                      }
+                    ],
+                    "order": [],
+                    "having": {
+                      "expression": ""
+                    },
+                    "functions": [],
+                    "legend": "{{bucket_name}}/{{storage_class}}"
+                  }
+                }
+              }
+            }
+          ],
+          "links": []
+        }
+      },
+      "c5af2813-34ec-41a9-8d53-c9acd67f569f": {
+        "kind": "Panel",
+        "spec": {
+          "display": {
+            "name": "Request count",
+            "description": "Rate of API calls, grouped by the API method name and response code."
+          },
+          "plugin": {
+            "kind": "signoz/TimeSeriesPanel",
+            "spec": {
+              "visualization": {
+                "timePreference": "global_time",
+                "fillSpans": false
+              },
+              "formatting": {
+                "unit": "{count}/s",
+                "decimalPrecision": "2"
+              },
+              "chartAppearance": {
+                "lineInterpolation": "spline",
+                "showPoints": false,
+                "lineStyle": "solid",
+                "fillMode": "none",
+                "spanGaps": {
+                  "fillOnlyBelow": false,
+                  "fillLessThan": ""
+                }
+              },
+              "axes": {
+                "softMin": 0,
+                "softMax": 0,
+                "isLogScale": false
+              },
+              "legend": {
+                "position": "right",
+                "mode": "list",
+                "customColors": null
+              },
+              "thresholds": null
+            }
+          },
+          "queries": [
+            {
+              "kind": "time_series",
+              "spec": {
+                "name": "A",
+                "plugin": {
+                  "kind": "signoz/BuilderQuery",
+                  "spec": {
+                    "name": "A",
+                    "signal": "metrics",
+                    "source": "",
+                    "aggregations": [
+                      {
+                        "metricName": "storage.googleapis.com/api/request_count",
+                        "temporality": "",
+                        "timeAggregation": "rate",
+                        "spaceAggregation": "sum",
+                        "reduceTo": "sum"
+                      }
+                    ],
+                    "disabled": false,
+                    "filter": {
+                      "expression": "project_id = $project_id AND bucket_name in $bucket_name AND gcp.resource_type = 'gcs_bucket'"
+                    },
+                    "groupBy": [
+                      {
+                        "name": "bucket_name",
+                        "signal": "",
+                        "fieldContext": "attribute",
+                        "fieldDataType": "string"
+                      },
+                      {
+                        "name": "method",
+                        "signal": "",
+                        "fieldContext": "attribute",
+                        "fieldDataType": "string"
+                      },
+                      {
+                        "name": "response_code",
+                        "signal": "",
+                        "fieldContext": "attribute",
+                        "fieldDataType": "string"
+                      }
+                    ],
+                    "order": [],
+                    "having": {
+                      "expression": ""
+                    },
+                    "functions": [],
+                    "legend": "{{bucket_name}}/{{method}} - {{response_code}}"
+                  }
+                }
+              }
+            }
+          ],
+          "links": []
+        }
+      },
+      "70333210-68c3-4387-a6b7-afa2459d27dd": {
+        "kind": "Panel",
+        "spec": {
+          "display": {
+            "name": "Authentication count",
+            "description": "Rate of HMAC/RSA signed requests, grouped by authentication method, API method name and response code."
+          },
+          "plugin": {
+            "kind": "signoz/TimeSeriesPanel",
+            "spec": {
+              "visualization": {
+                "timePreference": "global_time",
+                "fillSpans": false
+              },
+              "formatting": {
+                "unit": "{count}/s",
+                "decimalPrecision": "2"
+              },
+              "chartAppearance": {
+                "lineInterpolation": "spline",
+                "showPoints": false,
+                "lineStyle": "solid",
+                "fillMode": "none",
+                "spanGaps": {
+                  "fillOnlyBelow": false,
+                  "fillLessThan": ""
+                }
+              },
+              "axes": {
+                "softMin": 0,
+                "softMax": 0,
+                "isLogScale": false
+              },
+              "legend": {
+                "position": "right",
+                "mode": "list",
+                "customColors": null
+              },
+              "thresholds": null
+            }
+          },
+          "queries": [
+            {
+              "kind": "time_series",
+              "spec": {
+                "name": "A",
+                "plugin": {
+                  "kind": "signoz/BuilderQuery",
+                  "spec": {
+                    "name": "A",
+                    "signal": "metrics",
+                    "source": "",
+                    "aggregations": [
+                      {
+                        "metricName": "storage.googleapis.com/authn/authentication_count",
+                        "temporality": "",
+                        "timeAggregation": "rate",
+                        "spaceAggregation": "sum",
+                        "reduceTo": "sum"
+                      }
+                    ],
+                    "disabled": false,
+                    "filter": {
+                      "expression": "project_id = $project_id AND bucket_name in $bucket_name AND gcp.resource_type = 'gcs_bucket'"
+                    },
+                    "groupBy": [
+                      {
+                        "name": "bucket_name",
+                        "signal": "",
+                        "fieldContext": "attribute",
+                        "fieldDataType": "string"
+                      },
+                      {
+                        "name": "authentication_method",
+                        "signal": "",
+                        "fieldContext": "attribute",
+                        "fieldDataType": "string"
+                      },
+                      {
+                        "name": "method",
+                        "signal": "",
+                        "fieldContext": "attribute",
+                        "fieldDataType": "string"
+                      },
+                      {
+                        "name": "response_code",
+                        "signal": "",
+                        "fieldContext": "attribute",
+                        "fieldDataType": "string"
+                      }
+                    ],
+                    "order": [],
+                    "having": {
+                      "expression": ""
+                    },
+                    "functions": [],
+                    "legend": "{{bucket_name}}/{{authentication_method}}/{{method}} - {{response_code}}"
+                  }
+                }
+              }
+            }
+          ],
+          "links": []
+        }
+      },
+      "7a98084c-2cd3-4146-a831-f5382162ffe5": {
+        "kind": "Panel",
+        "spec": {
+          "display": {
+            "name": "Received bytes",
+            "description": "Rate of bytes received over the network, grouped by the API method name and response code."
+          },
+          "plugin": {
+            "kind": "signoz/TimeSeriesPanel",
+            "spec": {
+              "visualization": {
+                "timePreference": "global_time",
+                "fillSpans": false
+              },
+              "formatting": {
+                "unit": "By/s",
+                "decimalPrecision": "2"
+              },
+              "chartAppearance": {
+                "lineInterpolation": "spline",
+                "showPoints": false,
+                "lineStyle": "solid",
+                "fillMode": "none",
+                "spanGaps": {
+                  "fillOnlyBelow": false,
+                  "fillLessThan": ""
+                }
+              },
+              "axes": {
+                "softMin": 0,
+                "softMax": 0,
+                "isLogScale": false
+              },
+              "legend": {
+                "position": "right",
+                "mode": "list",
+                "customColors": null
+              },
+              "thresholds": null
+            }
+          },
+          "queries": [
+            {
+              "kind": "time_series",
+              "spec": {
+                "name": "A",
+                "plugin": {
+                  "kind": "signoz/BuilderQuery",
+                  "spec": {
+                    "name": "A",
+                    "signal": "metrics",
+                    "source": "",
+                    "aggregations": [
+                      {
+                        "metricName": "storage.googleapis.com/network/received_bytes_count",
+                        "temporality": "",
+                        "timeAggregation": "rate",
+                        "spaceAggregation": "sum",
+                        "reduceTo": "sum"
+                      }
+                    ],
+                    "disabled": false,
+                    "filter": {
+                      "expression": "project_id = $project_id AND bucket_name in $bucket_name AND gcp.resource_type = 'gcs_bucket'"
+                    },
+                    "groupBy": [
+                      {
+                        "name": "bucket_name",
+                        "signal": "",
+                        "fieldContext": "attribute",
+                        "fieldDataType": "string"
+                      },
+                      {
+                        "name": "method",
+                        "signal": "",
+                        "fieldContext": "attribute",
+                        "fieldDataType": "string"
+                      },
+                      {
+                        "name": "response_code",
+                        "signal": "",
+                        "fieldContext": "attribute",
+                        "fieldDataType": "string"
+                      }
+                    ],
+                    "order": [],
+                    "having": {
+                      "expression": ""
+                    },
+                    "functions": [],
+                    "legend": "{{bucket_name}}/{{method}} - {{response_code}}"
+                  }
+                }
+              }
+            }
+          ],
+          "links": []
+        }
+      },
+      "7138bf98-b41a-46d8-90ef-8e7470819cdf": {
+        "kind": "Panel",
+        "spec": {
+          "display": {
+            "name": "Sent bytes",
+            "description": "Rate of bytes sent over the network, grouped by the API method name and response code."
+          },
+          "plugin": {
+            "kind": "signoz/TimeSeriesPanel",
+            "spec": {
+              "visualization": {
+                "timePreference": "global_time",
+                "fillSpans": false
+              },
+              "formatting": {
+                "unit": "By/s",
+                "decimalPrecision": "2"
+              },
+              "chartAppearance": {
+                "lineInterpolation": "spline",
+                "showPoints": false,
+                "lineStyle": "solid",
+                "fillMode": "none",
+                "spanGaps": {
+                  "fillOnlyBelow": false,
+                  "fillLessThan": ""
+                }
+              },
+              "axes": {
+                "softMin": 0,
+                "softMax": 0,
+                "isLogScale": false
+              },
+              "legend": {
+                "position": "right",
+                "mode": "list",
+                "customColors": null
+              },
+              "thresholds": null
+            }
+          },
+          "queries": [
+            {
+              "kind": "time_series",
+              "spec": {
+                "name": "A",
+                "plugin": {
+                  "kind": "signoz/BuilderQuery",
+                  "spec": {
+                    "name": "A",
+                    "signal": "metrics",
+                    "source": "",
+                    "aggregations": [
+                      {
+                        "metricName": "storage.googleapis.com/network/sent_bytes_count",
+                        "temporality": "",
+                        "timeAggregation": "rate",
+                        "spaceAggregation": "sum",
+                        "reduceTo": "sum"
+                      }
+                    ],
+                    "disabled": false,
+                    "filter": {
+                      "expression": "project_id = $project_id AND bucket_name in $bucket_name AND gcp.resource_type = 'gcs_bucket'"
+                    },
+                    "groupBy": [
+                      {
+                        "name": "bucket_name",
+                        "signal": "",
+                        "fieldContext": "attribute",
+                        "fieldDataType": "string"
+                      },
+                      {
+                        "name": "method",
+                        "signal": "",
+                        "fieldContext": "attribute",
+                        "fieldDataType": "string"
+                      },
+                      {
+                        "name": "response_code",
+                        "signal": "",
+                        "fieldContext": "attribute",
+                        "fieldDataType": "string"
+                      }
+                    ],
+                    "order": [],
+                    "having": {
+                      "expression": ""
+                    },
+                    "functions": [],
+                    "legend": "{{bucket_name}}/{{method}} - {{response_code}}"
+                  }
+                }
+              }
+            }
+          ],
+          "links": []
+        }
+      }
+    },
+    "layouts": [
+      {
+        "kind": "Grid",
+        "spec": {
+          "items": [
+            {
+              "x": 0,
+              "y": 0,
+              "width": 6,
+              "height": 6,
+              "content": {
+                "$ref": "#/spec/panels/1f0a4d5b-6c2e-4a71-8b3d-9e5c07a41d20"
+              }
+            }
+          ]
+        }
+      },
+      {
+        "kind": "Grid",
+        "spec": {
+          "display": {
+            "title": "Storage",
+            "collapse": {
+              "open": true
+            }
+          },
+          "items": [
+            {
+              "x": 0,
+              "y": 0,
+              "width": 6,
+              "height": 6,
+              "content": {
+                "$ref": "#/spec/panels/29ed9824-21db-44c3-9537-12be458f5c20"
+              }
+            },
+            {
+              "x": 6,
+              "y": 0,
+              "width": 6,
+              "height": 6,
+              "content": {
+                "$ref": "#/spec/panels/cbc53174-5527-4bce-b32d-317403849e48"
+              }
+            },
+            {
+              "x": 0,
+              "y": 6,
+              "width": 6,
+              "height": 6,
+              "content": {
+                "$ref": "#/spec/panels/76e70ce5-47e4-4b5b-9715-49fa21c58b0c"
+              }
+            }
+          ]
+        }
+      },
+      {
+        "kind": "Grid",
+        "spec": {
+          "display": {
+            "title": "API & Authentication",
+            "collapse": {
+              "open": true
+            }
+          },
+          "items": [
+            {
+              "x": 0,
+              "y": 0,
+              "width": 6,
+              "height": 6,
+              "content": {
+                "$ref": "#/spec/panels/c5af2813-34ec-41a9-8d53-c9acd67f569f"
+              }
+            },
+            {
+              "x": 6,
+              "y": 0,
+              "width": 6,
+              "height": 6,
+              "content": {
+                "$ref": "#/spec/panels/70333210-68c3-4387-a6b7-afa2459d27dd"
+              }
+            }
+          ]
+        }
+      },
+      {
+        "kind": "Grid",
+        "spec": {
+          "display": {
+            "title": "Network",
+            "collapse": {
+              "open": true
+            }
+          },
+          "items": [
+            {
+              "x": 0,
+              "y": 0,
+              "width": 6,
+              "height": 6,
+              "content": {
+                "$ref": "#/spec/panels/7a98084c-2cd3-4146-a831-f5382162ffe5"
+              }
+            },
+            {
+              "x": 6,
+              "y": 0,
+              "width": 6,
+              "height": 6,
+              "content": {
+                "$ref": "#/spec/panels/7138bf98-b41a-46d8-90ef-8e7470819cdf"
+              }
+            }
+          ]
+        }
+      }
+    ],
+    "duration": "",
+    "refreshInterval": "",
+    "links": []
+  }
+}

pkg/modules/cloudintegration/implcloudintegration/fs/definitions/gcp/cloudstorage/icon.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="24px" height="24px" viewBox="0 0 24 24"><defs><style>.cls-1{fill:#aecbfa;}.cls-2{fill:#669df6;}.cls-3{fill:#4285f4;}</style></defs><title>Icon_24px_CloudStorage_Color</title><g data-name="Product Icons"><path class="cls-1" d="M2,4.5H22a0,0,0,0,1,0,0v5a0,0,0,0,1,0,0H2a0,0,0,0,1,0,0v-5A0,0,0,0,1,2,4.5Z"/><path class="cls-2" d="M2,14.5H22a0,0,0,0,1,0,0v5a0,0,0,0,1,0,0H2a0,0,0,0,1,0,0v-5A0,0,0,0,1,2,14.5Z"/><rect class="cls-3" x="4.5" y="6.33" width="3.33" height="1.33"/><rect class="cls-3" x="4.5" y="16.33" width="3.33" height="1.33"/><circle class="cls-3" cx="18.5" cy="7" r="1"/><circle class="cls-3" cx="18.5" cy="17" r="1"/></g></svg>

pkg/modules/cloudintegration/implcloudintegration/fs/definitions/gcp/cloudstorage/integration.json

@@ -0,0 +1,70 @@
+{
+  "id": "cloudstorage",
+  "title": "GCP Cloud Storage",
+  "icon": "file://icon.svg",
+  "overview": "file://overview.md",
+  "supportedSignals": {
+    "metrics": true,
+    "logs": true
+  },
+  "dataCollected": {
+    "metrics": [
+      {
+        "name": "storage.googleapis.com/storage/v2/total_bytes",
+        "unit": "Bytes",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "storage.googleapis.com/storage/v2/total_count",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "storage.googleapis.com/storage/v2/deleted_bytes",
+        "unit": "Bytes",
+        "type": "Sum",
+        "description": ""
+      },
+      {
+        "name": "storage.googleapis.com/api/request_count",
+        "unit": "Count",
+        "type": "Sum",
+        "description": ""
+      },
+      {
+        "name": "storage.googleapis.com/network/received_bytes_count",
+        "unit": "Bytes",
+        "type": "Sum",
+        "description": ""
+      },
+      {
+        "name": "storage.googleapis.com/network/sent_bytes_count",
+        "unit": "Bytes",
+        "type": "Sum",
+        "description": ""
+      },
+      {
+        "name": "storage.googleapis.com/authn/authentication_count",
+        "unit": "Count",
+        "type": "Sum",
+        "description": ""
+      }
+    ],
+    "logs": []
+  },
+  "telemetryCollectionStrategy": {
+    "gcp": {}
+  },
+  "assets": {
+    "dashboards": [
+      {
+        "id": "overview",
+        "title": "GCP Cloud Storage Overview",
+        "description": "Overview of GCP Cloud Storage metrics",
+        "definition": "file://assets/dashboards/overview.json"
+      }
+    ]
+  }
+}

pkg/modules/cloudintegration/implcloudintegration/fs/definitions/gcp/cloudstorage/overview.md

@@ -0,0 +1,3 @@
+### Monitor GCP Cloud Storage with SigNoz
+
+Collect key GCP Cloud Storage metrics and view them with an out of the box dashboard.

pkg/modules/cloudintegration/implcloudintegration/fs/definitions/gcp/computeengine/icon.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="24px" height="24px" viewBox="0 0 24 24"><defs><style>.cls-1{fill:#aecbfa;}.cls-2{fill:#669df6;}.cls-3{fill:#4285f4;}</style></defs><title>Icon_24px_ComputeEngine_Color</title><g data-name="Product Icons"><rect class="cls-1" x="9" y="9" width="6" height="6"/><rect class="cls-2" x="11" y="2" width="2" height="4"/><rect class="cls-2" x="7" y="2" width="2" height="4"/><rect class="cls-2" x="15" y="2" width="2" height="4"/><rect class="cls-3" x="11" y="18" width="2" height="4"/><rect class="cls-3" x="7" y="18" width="2" height="4"/><rect class="cls-3" x="15" y="18" width="2" height="4"/><rect class="cls-3" x="19" y="10" width="2" height="4" transform="translate(8 32) rotate(-90)"/><rect class="cls-3" x="19" y="14" width="2" height="4" transform="translate(4 36) rotate(-90)"/><rect class="cls-3" x="19" y="6" width="2" height="4" transform="translate(12 28) rotate(-90)"/><rect class="cls-2" x="3" y="10" width="2" height="4" transform="translate(-8 16) rotate(-90)"/><rect class="cls-2" x="3" y="14" width="2" height="4" transform="translate(-12 20) rotate(-90)"/><rect class="cls-2" x="3" y="6" width="2" height="4" transform="translate(-4 12) rotate(-90)"/><path class="cls-1" d="M5,5V19H19V5ZM17,17H7V7H17Z"/><polygon class="cls-2" points="9 15 15 15 12 12 9 15"/><polygon class="cls-3" points="12 12 15 15 15 9 12 12"/></g></svg>

pkg/modules/cloudintegration/implcloudintegration/fs/definitions/gcp/computeengine/integration.json

@@ -0,0 +1,124 @@
+{
+  "id": "computeengine",
+  "title": "GCP Compute Engine",
+  "icon": "file://icon.svg",
+  "overview": "file://overview.md",
+  "supportedSignals": {
+    "metrics": true,
+    "logs": true
+  },
+  "dataCollected": {
+    "metrics": [
+      {
+        "name": "compute.googleapis.com/instance/uptime_total",
+        "unit": "Seconds",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "compute.googleapis.com/instance/cpu/utilization",
+        "unit": "Percent",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "compute.googleapis.com/guest/memory/bytes_used",
+        "unit": "Bytes",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "compute.googleapis.com/guest/memory/percent_used",
+        "unit": "Percent",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "agent.googleapis.com/memory/percent_used",
+        "unit": "Percent",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "compute.googleapis.com/instance/disk/average_io_latency",
+        "unit": "Microseconds",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "compute.googleapis.com/instance/disk/read_bytes_count",
+        "unit": "Bytes",
+        "type": "Sum",
+        "description": ""
+      },
+      {
+        "name": "compute.googleapis.com/instance/disk/write_bytes_count",
+        "unit": "Bytes",
+        "type": "Sum",
+        "description": ""
+      },
+      {
+        "name": "compute.googleapis.com/instance/disk/read_ops_count",
+        "unit": "Count",
+        "type": "Sum",
+        "description": ""
+      },
+      {
+        "name": "compute.googleapis.com/instance/disk/write_ops_count",
+        "unit": "Count",
+        "type": "Sum",
+        "description": ""
+      },
+      {
+        "name": "compute.googleapis.com/instance/disk/performance_status",
+        "unit": "None",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "compute.googleapis.com/instance/network/received_bytes_count",
+        "unit": "Bytes",
+        "type": "Sum",
+        "description": ""
+      },
+      {
+        "name": "compute.googleapis.com/instance/network/sent_bytes_count",
+        "unit": "Bytes",
+        "type": "Sum",
+        "description": ""
+      },
+      {
+        "name": "compute.googleapis.com/instance/network/received_packets_count",
+        "unit": "Count",
+        "type": "Sum",
+        "description": ""
+      },
+      {
+        "name": "compute.googleapis.com/instance/network/sent_packets_count",
+        "unit": "Count",
+        "type": "Sum",
+        "description": ""
+      },
+      {
+        "name": "compute.googleapis.com/firewall/dropped_packets_count",
+        "unit": "Count",
+        "type": "Sum",
+        "description": ""
+      }
+    ],
+    "logs": []
+  },
+  "telemetryCollectionStrategy": {
+    "gcp": {}
+  },
+  "assets": {
+    "dashboards": [
+      {
+        "id": "overview",
+        "title": "GCP Compute Engine Overview",
+        "description": "Overview of GCP Compute Engine metrics",
+        "definition": "file://assets/dashboards/overview.json"
+      }
+    ]
+  }
+}

pkg/modules/cloudintegration/implcloudintegration/fs/definitions/gcp/computeengine/overview.md

@@ -0,0 +1,3 @@
+### Monitor GCP Compute Engine with SigNoz
+
+Collect key GCP Compute Engine metrics and view them with an out of the box dashboard.

pkg/modules/cloudintegration/implcloudintegration/fs/definitions/gcp/gke/icon.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="24px" height="24px" viewBox="0 0 24 24"><defs><style>.cls-1{fill:#4285f4;}.cls-1,.cls-2,.cls-4{fill-rule:evenodd;}.cls-2{fill:#669df6;}.cls-3,.cls-4{fill:#aecbfa;}</style></defs><title>Icon_24px_K8Engine_Color</title><g data-name="Product Icons"><g ><polygon class="cls-1" points="14.68 13.06 19.23 15.69 19.23 16.68 14.29 13.83 14.68 13.06"/><polygon class="cls-2" points="9.98 13.65 4.77 16.66 4.45 15.86 9.53 12.92 9.98 13.65"/><rect class="cls-3" x="11.55" y="3.29" width="0.86" height="5.78"/><path class="cls-4" d="M3.25,7V17L12,22l8.74-5V7L12,2Zm15.63,8.89L12,19.78,5.12,15.89V8.11L12,4.22l6.87,3.89v7.78Z"/><polygon class="cls-4" points="11.98 11.5 15.96 9.21 11.98 6.91 8.01 9.21 11.98 11.5"/><polygon class="cls-2" points="11.52 12.3 7.66 10.01 7.66 14.6 11.52 16.89 11.52 12.3"/><polygon class="cls-1" points="12.48 12.3 12.48 16.89 16.34 14.6 16.34 10.01 12.48 12.3"/></g></g></svg>

pkg/modules/cloudintegration/implcloudintegration/fs/definitions/gcp/gke/integration.json

@@ -0,0 +1,124 @@
+{
+  "id": "gke",
+  "title": "GCP Kubernetes Engine",
+  "icon": "file://icon.svg",
+  "overview": "file://overview.md",
+  "supportedSignals": {
+    "metrics": true,
+    "logs": true
+  },
+  "dataCollected": {
+    "metrics": [
+      {
+        "name": "kubernetes.io/container/cpu/limit_utilization",
+        "unit": "None",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "kubernetes.io/container/cpu/request_utilization",
+        "unit": "None",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "kubernetes.io/container/memory/limit_utilization",
+        "unit": "None",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "kubernetes.io/container/memory/request_utilization",
+        "unit": "None",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "kubernetes.io/container/restart_count",
+        "unit": "Count",
+        "type": "Sum",
+        "description": ""
+      },
+      {
+        "name": "kubernetes.io/pod/latencies/pod_first_ready",
+        "unit": "Seconds",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "kubernetes.io/pod/network/received_bytes_count",
+        "unit": "Bytes",
+        "type": "Sum",
+        "description": ""
+      },
+      {
+        "name": "kubernetes.io/pod/network/sent_bytes_count",
+        "unit": "Bytes",
+        "type": "Sum",
+        "description": ""
+      },
+      {
+        "name": "kubernetes.io/pod/volume/utilization",
+        "unit": "None",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "kubernetes.io/node/cpu/allocatable_utilization",
+        "unit": "None",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "kubernetes.io/node/memory/allocatable_utilization",
+        "unit": "None",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "kubernetes.io/node/ephemeral_storage/used_bytes",
+        "unit": "Bytes",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "kubernetes.io/node/ephemeral_storage/allocatable_bytes",
+        "unit": "Bytes",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "kubernetes.io/node/network/received_bytes_count",
+        "unit": "Bytes",
+        "type": "Sum",
+        "description": ""
+      },
+      {
+        "name": "kubernetes.io/node/network/sent_bytes_count",
+        "unit": "Bytes",
+        "type": "Sum",
+        "description": ""
+      },
+      {
+        "name": "kubernetes.io/node/status_condition",
+        "unit": "None",
+        "type": "Gauge",
+        "description": ""
+      }
+    ],
+    "logs": []
+  },
+  "telemetryCollectionStrategy": {
+    "gcp": {}
+  },
+  "assets": {
+    "dashboards": [
+      {
+        "id": "overview",
+        "title": "GCP Kubernetes Engine Overview",
+        "description": "Overview of GCP Kubernetes Engine metrics",
+        "definition": "file://assets/dashboards/overview.json"
+      }
+    ]
+  }
+}

pkg/modules/cloudintegration/implcloudintegration/fs/definitions/gcp/gke/overview.md

@@ -0,0 +1,3 @@
+### Monitor GCP Kubernetes Engine with SigNoz
+
+Collect key GCP Kubernetes Engine metrics and view them with an out of the box dashboard.

pkg/modules/inframonitoring/implinframonitoring/collect.go

@@ -5,14 +5,14 @@ import (
 	"fmt"
 
 	"github.com/SigNoz/signoz/pkg/errors"
-	"github.com/SigNoz/signoz/pkg/telemetrymetrics"
+	"github.com/SigNoz/signoz/pkg/telemetryschema/metricstelemetryschema"
 	"github.com/SigNoz/signoz/pkg/valuer"
 )
 
 func (m *module) Collect(ctx context.Context, _ valuer.UUID) (map[string]any, error) {
 	stats := make(map[string]any)
 
-	metadataTable := fmt.Sprintf("%s.%s", telemetrymetrics.DBName, telemetrymetrics.AttributesMetadataTableName)
+	metadataTable := fmt.Sprintf("%s.%s", metricstelemetryschema.DBName, metricstelemetryschema.AttributesMetadataTableName)
 	var (
 		systemMetricCount uint64
 		k8sMetricCount    uint64

pkg/modules/inframonitoring/implinframonitoring/containers.go

@@ -7,7 +7,7 @@ import (
 	"strings"
 
 	"github.com/SigNoz/signoz/pkg/querybuilder"
-	"github.com/SigNoz/signoz/pkg/telemetrymetrics"
+	"github.com/SigNoz/signoz/pkg/telemetryschema/metricstelemetryschema"
 	"github.com/SigNoz/signoz/pkg/types/inframonitoringtypes"
 	qbtypes "github.com/SigNoz/signoz/pkg/types/querybuildertypes/querybuildertypesv5"
 	"github.com/SigNoz/signoz/pkg/valuer"
@@ -281,7 +281,7 @@ func (m *module) getPerGroupContainerStatusCounts(
 	mergedFilterExpr := mergeFilterExpressions(userFilterExpr, buildPageGroupsFilterExpr(pageGroups))
 
 	samplesStartMs, flooredEndMs, tsAdjustedStart, _, localTimeSeriesTable, distributedSamplesTable, _ := alignedMetricWindow(start, end)
-	valueCol := telemetrymetrics.ValueColumnForSamplesTable(distributedSamplesTable)
+	valueCol := metricstelemetryschema.ValueColumnForSamplesTable(distributedSamplesTable)
 
 	// Built once; identical across the two fps CTEs (buildFilterClause hits the
 	// metadata store + parses the expression). AddWhereClause only reads it.
@@ -310,7 +310,7 @@ func (m *module) getPerGroupContainerStatusCounts(
 		)
 	}
 	stateFps.Select(stateFpsCols...)
-	stateFps.From(fmt.Sprintf("%s.%s", telemetrymetrics.DBName, localTimeSeriesTable))
+	stateFps.From(fmt.Sprintf("%s.%s", metricstelemetryschema.DBName, localTimeSeriesTable))
 	stateFps.Where(
 		stateFps.E("metric_name", containerStatusStateMetricName),
 		stateFps.GE("unix_milli", tsAdjustedStart),
@@ -342,7 +342,7 @@ func (m *module) getPerGroupContainerStatusCounts(
 	containerState.Select(containerStateCols...)
 	containerState.From(fmt.Sprintf(
 		"%s.%s AS samples INNER JOIN state_fps AS fps ON samples.fingerprint = fps.fingerprint",
-		telemetrymetrics.DBName, distributedSamplesTable,
+		metricstelemetryschema.DBName, distributedSamplesTable,
 	))
 	containerState.Where(
 		containerState.E("samples.metric_name", containerStatusStateMetricName),
@@ -361,7 +361,7 @@ func (m *module) getPerGroupContainerStatusCounts(
 		fmt.Sprintf("JSONExtractString(labels, %s) AS container_name", reasonFps.Var(containerNameAttrKey)),
 		fmt.Sprintf("JSONExtractString(labels, %s) AS reason", reasonFps.Var(containerStatusReasonAttrKey)),
 	)
-	reasonFps.From(fmt.Sprintf("%s.%s", telemetrymetrics.DBName, localTimeSeriesTable))
+	reasonFps.From(fmt.Sprintf("%s.%s", metricstelemetryschema.DBName, localTimeSeriesTable))
 	reasonFps.Where(
 		reasonFps.E("metric_name", containerStatusReasonMetricName),
 		reasonFps.GE("unix_milli", tsAdjustedStart),
@@ -391,7 +391,7 @@ func (m *module) getPerGroupContainerStatusCounts(
 	)
 	reasonInner.From(fmt.Sprintf(
 		"%s.%s AS samples INNER JOIN reason_fps AS fps ON samples.fingerprint = fps.fingerprint",
-		telemetrymetrics.DBName, distributedSamplesTable,
+		metricstelemetryschema.DBName, distributedSamplesTable,
 	))
 	reasonInner.Where(
 		reasonInner.E("samples.metric_name", containerStatusReasonMetricName),
@@ -546,7 +546,7 @@ func (m *module) getPerGroupContainerRestartCounts(
 	mergedFilterExpr := mergeFilterExpressions(userFilterExpr, buildPageGroupsFilterExpr(pageGroups))
 
 	samplesStartMs, flooredEndMs, tsAdjustedStart, _, localTimeSeriesTable, distributedSamplesTable, _ := alignedMetricWindow(start, end)
-	valueCol := telemetrymetrics.ValueColumnForSamplesTable(distributedSamplesTable)
+	valueCol := metricstelemetryschema.ValueColumnForSamplesTable(distributedSamplesTable)
 
 	var (
 		filterClause *sqlbuilder.WhereClause
@@ -572,7 +572,7 @@ func (m *module) getPerGroupContainerRestartCounts(
 		)
 	}
 	restartFps.Select(restartFpsCols...)
-	restartFps.From(fmt.Sprintf("%s.%s", telemetrymetrics.DBName, localTimeSeriesTable))
+	restartFps.From(fmt.Sprintf("%s.%s", metricstelemetryschema.DBName, localTimeSeriesTable))
 	restartFps.Where(
 		restartFps.E("metric_name", containerRestartsMetricName),
 		restartFps.GE("unix_milli", tsAdjustedStart),
@@ -602,7 +602,7 @@ func (m *module) getPerGroupContainerRestartCounts(
 	containerRestarts.Select(containerRestartsCols...)
 	containerRestarts.From(fmt.Sprintf(
 		"%s.%s AS samples INNER JOIN restart_fps AS fps ON samples.fingerprint = fps.fingerprint",
-		telemetrymetrics.DBName, distributedSamplesTable,
+		metricstelemetryschema.DBName, distributedSamplesTable,
 	))
 	containerRestarts.Where(
 		containerRestarts.E("samples.metric_name", containerRestartsMetricName),
@@ -690,7 +690,7 @@ func (m *module) getPerGroupContainerReadyCounts(
 	mergedFilterExpr := mergeFilterExpressions(userFilterExpr, buildPageGroupsFilterExpr(pageGroups))
 
 	samplesStartMs, flooredEndMs, tsAdjustedStart, _, localTimeSeriesTable, distributedSamplesTable, _ := alignedMetricWindow(start, end)
-	valueCol := telemetrymetrics.ValueColumnForSamplesTable(distributedSamplesTable)
+	valueCol := metricstelemetryschema.ValueColumnForSamplesTable(distributedSamplesTable)
 
 	var (
 		filterClause *sqlbuilder.WhereClause
@@ -716,7 +716,7 @@ func (m *module) getPerGroupContainerReadyCounts(
 		)
 	}
 	readyFps.Select(readyFpsCols...)
-	readyFps.From(fmt.Sprintf("%s.%s", telemetrymetrics.DBName, localTimeSeriesTable))
+	readyFps.From(fmt.Sprintf("%s.%s", metricstelemetryschema.DBName, localTimeSeriesTable))
 	readyFps.Where(
 		readyFps.E("metric_name", containerReadyMetricName),
 		readyFps.GE("unix_milli", tsAdjustedStart),
@@ -746,7 +746,7 @@ func (m *module) getPerGroupContainerReadyCounts(
 	containerReady.Select(containerReadyCols...)
 	containerReady.From(fmt.Sprintf(
 		"%s.%s AS samples INNER JOIN ready_fps AS fps ON samples.fingerprint = fps.fingerprint",
-		telemetrymetrics.DBName, distributedSamplesTable,
+		metricstelemetryschema.DBName, distributedSamplesTable,
 	))
 	containerReady.Where(
 		containerReady.E("samples.metric_name", containerReadyMetricName),

pkg/modules/inframonitoring/implinframonitoring/helpers.go

@@ -9,7 +9,7 @@ import (
 	"github.com/SigNoz/signoz/pkg/errors"
 	"github.com/SigNoz/signoz/pkg/flagger"
 	"github.com/SigNoz/signoz/pkg/querybuilder"
-	"github.com/SigNoz/signoz/pkg/telemetrymetrics"
+	"github.com/SigNoz/signoz/pkg/telemetryschema/metricstelemetryschema"
 	"github.com/SigNoz/signoz/pkg/types/featuretypes"
 	"github.com/SigNoz/signoz/pkg/types/inframonitoringtypes"
 	"github.com/SigNoz/signoz/pkg/types/metrictypes"
@@ -344,11 +344,11 @@ func alignedMetricWindow(startMs, endMs int64) (
 		flooredEndMs = flooredEndMs - (flooredEndMs % (adjustStep * 1000))
 	}
 
-	tsAdjustedStartMs, _, distributedTSTable, localTSTable := telemetrymetrics.WhichTSTableToUse(
+	tsAdjustedStartMs, _, distributedTSTable, localTSTable := metricstelemetryschema.WhichTSTableToUse(
 		samplesAdjustedStartMs, flooredEndMs, false, nil,
 	)
 
-	distributedSamplesTable, localSamplesTable := telemetrymetrics.WhichSamplesTableToUse(
+	distributedSamplesTable, localSamplesTable := metricstelemetryschema.WhichSamplesTableToUse(
 		samplesAdjustedStartMs, flooredEndMs,
 		metrictypes.UnspecifiedType, metrictypes.TimeAggregationUnspecified, false, nil,
 	)
@@ -362,7 +362,7 @@ func alignedMetricWindow(startMs, endMs int64) (
 func (m *module) buildSamplesTblFingerprintSubQuery(metricNames []string, samplesTable string, flooredStart, flooredEnd uint64) *sqlbuilder.SelectBuilder {
 	fpSB := sqlbuilder.NewSelectBuilder()
 	fpSB.Select("DISTINCT fingerprint")
-	fpSB.From(fmt.Sprintf("%s.%s", telemetrymetrics.DBName, samplesTable))
+	fpSB.From(fmt.Sprintf("%s.%s", metricstelemetryschema.DBName, samplesTable))
 	fpSB.Where(
 		fpSB.In("metric_name", sqlbuilder.List(metricNames)),
 		fpSB.GE("unix_milli", flooredStart),
@@ -376,7 +376,7 @@ func (m *module) buildSamplesTblFingerprintSubQuery(metricNames []string, sample
 func (m *module) buildReducedSamplesTblFingerprintSubQuery(metricNames []string, flooredStart, flooredEnd uint64) *sqlbuilder.SelectBuilder {
 	lastSB := sqlbuilder.NewSelectBuilder()
 	lastSB.Select("reduced_fingerprint")
-	lastSB.From(fmt.Sprintf("%s.%s", telemetrymetrics.DBName, telemetrymetrics.SamplesV4ReducedLastTableName))
+	lastSB.From(fmt.Sprintf("%s.%s", metricstelemetryschema.DBName, metricstelemetryschema.SamplesV4ReducedLastTableName))
 	lastSB.Where(
 		lastSB.In("metric_name", sqlbuilder.List(metricNames)),
 		lastSB.GE("unix_milli", flooredStart),
@@ -385,7 +385,7 @@ func (m *module) buildReducedSamplesTblFingerprintSubQuery(metricNames []string,
 
 	sumSB := sqlbuilder.NewSelectBuilder()
 	sumSB.Select("reduced_fingerprint")
-	sumSB.From(fmt.Sprintf("%s.%s", telemetrymetrics.DBName, telemetrymetrics.SamplesV4ReducedSumTableName))
+	sumSB.From(fmt.Sprintf("%s.%s", metricstelemetryschema.DBName, metricstelemetryschema.SamplesV4ReducedSumTableName))
 	sumSB.Where(
 		sumSB.In("metric_name", sqlbuilder.List(metricNames)),
 		sumSB.GE("unix_milli", flooredStart),
@@ -478,7 +478,7 @@ func (m *module) getEarliestMetricTime(ctx context.Context, metricNames []string
 
 	sb := sqlbuilder.NewSelectBuilder()
 	sb.Select("min(first_reported_unix_milli) AS min_first_reported")
-	sb.From(fmt.Sprintf("%s.%s", telemetrymetrics.DBName, telemetrymetrics.AttributesMetadataTableName))
+	sb.From(fmt.Sprintf("%s.%s", metricstelemetryschema.DBName, metricstelemetryschema.AttributesMetadataTableName))
 	sb.Where(sb.In("metric_name", sqlbuilder.List(metricNames)))
 
 	query, args := sb.BuildWithFlavor(sqlbuilder.ClickHouse)
@@ -504,7 +504,7 @@ func (m *module) getMetricsExistence(ctx context.Context, metricNames []string)
 
 	sb := sqlbuilder.NewSelectBuilder()
 	sb.Select("metric_name", "count(*) AS cnt")
-	sb.From(fmt.Sprintf("%s.%s", telemetrymetrics.DBName, telemetrymetrics.AttributesMetadataTableName))
+	sb.From(fmt.Sprintf("%s.%s", metricstelemetryschema.DBName, metricstelemetryschema.AttributesMetadataTableName))
 	sb.Where(sb.In("metric_name", sqlbuilder.List(metricNames)))
 	sb.GroupBy("metric_name")
 
@@ -549,7 +549,7 @@ func (m *module) getAttributesExistence(ctx context.Context, metricNames, attrNa
 	}
 	sb := sqlbuilder.NewSelectBuilder()
 	sb.Select("attr_name", "count(*) AS cnt")
-	sb.From(fmt.Sprintf("%s.%s", telemetrymetrics.DBName, telemetrymetrics.AttributesMetadataTableName))
+	sb.From(fmt.Sprintf("%s.%s", metricstelemetryschema.DBName, metricstelemetryschema.AttributesMetadataTableName))
 	sb.Where(
 		sb.In("metric_name", sqlbuilder.List(metricNames)),
 		sb.In("attr_name", sqlbuilder.List(attrNames)),
@@ -656,7 +656,7 @@ func (m *module) getMetadata(
 
 		rawSrc := sqlbuilder.NewSelectBuilder()
 		rawSrc.Select("labels", "unix_milli")
-		rawSrc.From(fmt.Sprintf("%s.%s", telemetrymetrics.DBName, distributedTableName))
+		rawSrc.From(fmt.Sprintf("%s.%s", metricstelemetryschema.DBName, distributedTableName))
 		rawSrc.Where(
 			rawSrc.In("metric_name", sqlbuilder.List(metricNames)),
 			rawSrc.GE("unix_milli", tsAdjustedStartMs),
@@ -669,7 +669,7 @@ func (m *module) getMetadata(
 
 		reducedSrc := sqlbuilder.NewSelectBuilder()
 		reducedSrc.Select("labels", "unix_milli")
-		reducedSrc.From(fmt.Sprintf("%s.%s", telemetrymetrics.DBName, telemetrymetrics.TimeseriesV4ReducedTableName))
+		reducedSrc.From(fmt.Sprintf("%s.%s", metricstelemetryschema.DBName, metricstelemetryschema.TimeseriesV4ReducedTableName))
 		reducedSrc.Where(
 			reducedSrc.In("metric_name", sqlbuilder.List(metricNames)),
 			reducedSrc.GE("unix_milli", tsAdjustedStartMs),
@@ -683,7 +683,7 @@ func (m *module) getMetadata(
 		// Inner query reads over the union of raw + reduced series.
 		innerSB.From(innerSB.BuilderAs(sqlbuilder.UnionAll(rawSrc, reducedSrc), "series"))
 	} else {
-		innerSB.From(fmt.Sprintf("%s.%s", telemetrymetrics.DBName, distributedTableName))
+		innerSB.From(fmt.Sprintf("%s.%s", metricstelemetryschema.DBName, distributedTableName))
 		innerSB.Where(
 			innerSB.In("metric_name", sqlbuilder.List(metricNames)),
 			innerSB.GE("unix_milli", tsAdjustedStartMs),
@@ -870,7 +870,7 @@ func (m *module) getPerGroupDistinctCounts(
 
 		rawSrc := sqlbuilder.NewSelectBuilder()
 		rawSrc.Select("labels")
-		rawSrc.From(fmt.Sprintf("%s.%s", telemetrymetrics.DBName, distributedTimeSeriesTbl))
+		rawSrc.From(fmt.Sprintf("%s.%s", metricstelemetryschema.DBName, distributedTimeSeriesTbl))
 		rawSrc.Where(
 			rawSrc.In("metric_name", sqlbuilder.List(metricNames)),
 			rawSrc.GE("unix_milli", tsAdjustedStartMs),
@@ -883,7 +883,7 @@ func (m *module) getPerGroupDistinctCounts(
 
 		reducedSrc := sqlbuilder.NewSelectBuilder()
 		reducedSrc.Select("labels")
-		reducedSrc.From(fmt.Sprintf("%s.%s", telemetrymetrics.DBName, telemetrymetrics.TimeseriesV4ReducedTableName))
+		reducedSrc.From(fmt.Sprintf("%s.%s", metricstelemetryschema.DBName, metricstelemetryschema.TimeseriesV4ReducedTableName))
 		reducedSrc.Where(
 			reducedSrc.In("metric_name", sqlbuilder.List(metricNames)),
 			reducedSrc.GE("unix_milli", tsAdjustedStartMs),
@@ -896,7 +896,7 @@ func (m *module) getPerGroupDistinctCounts(
 
 		sb.From(sb.BuilderAs(sqlbuilder.UnionAll(rawSrc, reducedSrc), "series"))
 	} else {
-		sb.From(fmt.Sprintf("%s.%s", telemetrymetrics.DBName, distributedTimeSeriesTbl))
+		sb.From(fmt.Sprintf("%s.%s", metricstelemetryschema.DBName, distributedTimeSeriesTbl))
 		sb.Where(
 			sb.In("metric_name", sqlbuilder.List(metricNames)),
 			sb.GE("unix_milli", tsAdjustedStartMs),

pkg/modules/inframonitoring/implinframonitoring/hosts.go

@@ -7,7 +7,7 @@ import (
 	"strings"
 
 	"github.com/SigNoz/signoz/pkg/flagger"
-	"github.com/SigNoz/signoz/pkg/telemetrymetrics"
+	"github.com/SigNoz/signoz/pkg/telemetryschema/metricstelemetryschema"
 	"github.com/SigNoz/signoz/pkg/types/featuretypes"
 	"github.com/SigNoz/signoz/pkg/types/inframonitoringtypes"
 	qbtypes "github.com/SigNoz/signoz/pkg/types/querybuildertypes/querybuildertypesv5"
@@ -72,7 +72,7 @@ func (m *module) getPerGroupHostStatusCounts(
 
 		rawSrc := sqlbuilder.NewSelectBuilder()
 		rawSrc.Select("labels")
-		rawSrc.From(fmt.Sprintf("%s.%s", telemetrymetrics.DBName, distributedTimeSeriesTableName))
+		rawSrc.From(fmt.Sprintf("%s.%s", metricstelemetryschema.DBName, distributedTimeSeriesTableName))
 		rawSrc.Where(
 			rawSrc.In("metric_name", sqlbuilder.List(metricNames)),
 			rawSrc.GE("unix_milli", tsAdjustedStartMs),
@@ -85,7 +85,7 @@ func (m *module) getPerGroupHostStatusCounts(
 
 		reducedSrc := sqlbuilder.NewSelectBuilder()
 		reducedSrc.Select("labels")
-		reducedSrc.From(fmt.Sprintf("%s.%s", telemetrymetrics.DBName, telemetrymetrics.TimeseriesV4ReducedTableName))
+		reducedSrc.From(fmt.Sprintf("%s.%s", metricstelemetryschema.DBName, metricstelemetryschema.TimeseriesV4ReducedTableName))
 		reducedSrc.Where(
 			reducedSrc.In("metric_name", sqlbuilder.List(metricNames)),
 			reducedSrc.GE("unix_milli", tsAdjustedStartMs),
@@ -101,7 +101,7 @@ func (m *module) getPerGroupHostStatusCounts(
 
 		fpSB := m.buildSamplesTblFingerprintSubQuery(metricNames, localSamplesTable, samplesStartMs, flooredEndMs)
 
-		sb.From(fmt.Sprintf("%s.%s", telemetrymetrics.DBName, distributedTimeSeriesTableName))
+		sb.From(fmt.Sprintf("%s.%s", metricstelemetryschema.DBName, distributedTimeSeriesTableName))
 		sb.Where(
 			sb.In("metric_name", sqlbuilder.List(metricNames)),
 			sb.GE("unix_milli", tsAdjustedStartMs),
@@ -357,7 +357,7 @@ func (m *module) getActiveHostsQuery(metricNames []string, hostNameAttr string,
 	sb := sqlbuilder.NewSelectBuilder()
 	sb.Distinct()
 	sb.Select("attr_string_value")
-	sb.From(fmt.Sprintf("%s.%s", telemetrymetrics.DBName, telemetrymetrics.AttributesMetadataTableName))
+	sb.From(fmt.Sprintf("%s.%s", metricstelemetryschema.DBName, metricstelemetryschema.AttributesMetadataTableName))
 	sb.Where(
 		sb.In("metric_name", sqlbuilder.List(metricNames)),
 		sb.E("attr_name", hostNameAttr),

pkg/modules/inframonitoring/implinframonitoring/module.go

@@ -9,7 +9,7 @@ import (
 	"github.com/SigNoz/signoz/pkg/flagger"
 	"github.com/SigNoz/signoz/pkg/modules/inframonitoring"
 	"github.com/SigNoz/signoz/pkg/querier"
-	"github.com/SigNoz/signoz/pkg/telemetrymetrics"
+	"github.com/SigNoz/signoz/pkg/telemetryschema/metricstelemetryschema"
 	"github.com/SigNoz/signoz/pkg/telemetrystore"
 	"github.com/SigNoz/signoz/pkg/types/ctxtypes"
 	"github.com/SigNoz/signoz/pkg/types/inframonitoringtypes"
@@ -40,8 +40,8 @@ func NewModule(
 	providerSettings factory.ProviderSettings,
 	cfg inframonitoring.Config,
 ) inframonitoring.Module {
-	fieldMapper := telemetrymetrics.NewFieldMapper()
-	condBuilder := telemetrymetrics.NewConditionBuilder(fieldMapper)
+	fieldMapper := metricstelemetryschema.NewFieldMapper()
+	condBuilder := metricstelemetryschema.NewConditionBuilder(fieldMapper)
 	return &module{
 		telemetryStore:         telemetryStore,
 		telemetryMetadataStore: telemetryMetadataStore,

pkg/modules/inframonitoring/implinframonitoring/nodes.go

@@ -7,7 +7,7 @@ import (
 	"strings"
 
 	"github.com/SigNoz/signoz/pkg/querybuilder"
-	"github.com/SigNoz/signoz/pkg/telemetrymetrics"
+	"github.com/SigNoz/signoz/pkg/telemetryschema/metricstelemetryschema"
 	"github.com/SigNoz/signoz/pkg/types/inframonitoringtypes"
 	qbtypes "github.com/SigNoz/signoz/pkg/types/querybuildertypes/querybuildertypesv5"
 	"github.com/SigNoz/signoz/pkg/valuer"
@@ -186,7 +186,7 @@ func (m *module) getPerGroupNodeConditionCounts(
 
 	// Step-floor bounds + resolve tables in one shot to match QB v5 querier.
 	samplesStartMs, flooredEndMs, tsAdjustedStartMs, _, localTimeSeriesTable, distributedSamplesTable, _ := alignedMetricWindow(start, end)
-	valueCol := telemetrymetrics.ValueColumnForSamplesTable(distributedSamplesTable)
+	valueCol := metricstelemetryschema.ValueColumnForSamplesTable(distributedSamplesTable)
 
 	// ----- timeSeriesFPs -----
 	timeSeriesFPs := sqlbuilder.NewSelectBuilder()
@@ -200,7 +200,7 @@ func (m *module) getPerGroupNodeConditionCounts(
 		)
 	}
 	timeSeriesFPs.Select(timeSeriesFPsSelectCols...)
-	timeSeriesFPs.From(fmt.Sprintf("%s.%s", telemetrymetrics.DBName, localTimeSeriesTable))
+	timeSeriesFPs.From(fmt.Sprintf("%s.%s", metricstelemetryschema.DBName, localTimeSeriesTable))
 	timeSeriesFPs.Where(
 		timeSeriesFPs.E("metric_name", nodeConditionMetricName),
 		timeSeriesFPs.GE("unix_milli", tsAdjustedStartMs),
@@ -237,7 +237,7 @@ func (m *module) getPerGroupNodeConditionCounts(
 	latestConditionPerNode.Select(latestConditionPerNodeSelectCols...)
 	latestConditionPerNode.From(fmt.Sprintf(
 		"%s.%s AS samples INNER JOIN time_series_fps AS tsfp ON samples.fingerprint = tsfp.fingerprint",
-		telemetrymetrics.DBName, distributedSamplesTable,
+		metricstelemetryschema.DBName, distributedSamplesTable,
 	))
 	latestConditionPerNode.Where(
 		latestConditionPerNode.E("samples.metric_name", nodeConditionMetricName),

pkg/modules/inframonitoring/implinframonitoring/pods.go

@@ -8,7 +8,7 @@ import (
 	"time"
 
 	"github.com/SigNoz/signoz/pkg/querybuilder"
-	"github.com/SigNoz/signoz/pkg/telemetrymetrics"
+	"github.com/SigNoz/signoz/pkg/telemetryschema/metricstelemetryschema"
 	"github.com/SigNoz/signoz/pkg/types/inframonitoringtypes"
 	qbtypes "github.com/SigNoz/signoz/pkg/types/querybuildertypes/querybuildertypesv5"
 	"github.com/SigNoz/signoz/pkg/valuer"
@@ -284,7 +284,7 @@ func (m *module) getPerGroupPodStatusCounts(
 	mergedFilterExpr := mergeFilterExpressions(userFilterExpr, buildPageGroupsFilterExpr(pageGroups))
 
 	samplesStartMs, flooredEndMs, tsAdjustedStart, _, localTimeSeriesTable, distributedSamplesTable, _ := alignedMetricWindow(start, end)
-	valueCol := telemetrymetrics.ValueColumnForSamplesTable(distributedSamplesTable)
+	valueCol := metricstelemetryschema.ValueColumnForSamplesTable(distributedSamplesTable)
 
 	// Build the merged filter clause once; it's identical across the three fps
 	// CTEs, and buildFilterClause hits the metadata store + parses the
@@ -313,7 +313,7 @@ func (m *module) getPerGroupPodStatusCounts(
 		)
 	}
 	phaseFps.Select(phaseFpsCols...)
-	phaseFps.From(fmt.Sprintf("%s.%s", telemetrymetrics.DBName, localTimeSeriesTable))
+	phaseFps.From(fmt.Sprintf("%s.%s", metricstelemetryschema.DBName, localTimeSeriesTable))
 	phaseFps.Where(
 		phaseFps.E("metric_name", podPhaseMetricName),
 		phaseFps.GE("unix_milli", tsAdjustedStart),
@@ -340,7 +340,7 @@ func (m *module) getPerGroupPodStatusCounts(
 	phasePerPod.Select(phasePerPodCols...)
 	phasePerPod.From(fmt.Sprintf(
 		"%s.%s AS samples INNER JOIN phase_fps AS fps ON samples.fingerprint = fps.fingerprint",
-		telemetrymetrics.DBName, distributedSamplesTable,
+		metricstelemetryschema.DBName, distributedSamplesTable,
 	))
 	phasePerPod.Where(
 		phasePerPod.E("samples.metric_name", podPhaseMetricName),
@@ -357,7 +357,7 @@ func (m *module) getPerGroupPodStatusCounts(
 		"fingerprint",
 		fmt.Sprintf("JSONExtractString(labels, %s) AS pod_uid", podReasonFps.Var(podUIDAttrKey)),
 	)
-	podReasonFps.From(fmt.Sprintf("%s.%s", telemetrymetrics.DBName, localTimeSeriesTable))
+	podReasonFps.From(fmt.Sprintf("%s.%s", metricstelemetryschema.DBName, localTimeSeriesTable))
 	podReasonFps.Where(
 		podReasonFps.E("metric_name", podStatusReasonMetricName),
 		podReasonFps.GE("unix_milli", tsAdjustedStart),
@@ -377,7 +377,7 @@ func (m *module) getPerGroupPodStatusCounts(
 	)
 	podReasonPerPod.From(fmt.Sprintf(
 		"%s.%s AS samples INNER JOIN pod_reason_fps AS fps ON samples.fingerprint = fps.fingerprint",
-		telemetrymetrics.DBName, distributedSamplesTable,
+		metricstelemetryschema.DBName, distributedSamplesTable,
 	))
 	podReasonPerPod.Where(
 		podReasonPerPod.E("samples.metric_name", podStatusReasonMetricName),
@@ -396,7 +396,7 @@ func (m *module) getPerGroupPodStatusCounts(
 		fmt.Sprintf("JSONExtractString(labels, %s) AS container_name", containerReasonFps.Var(containerNameAttrKey)),
 		fmt.Sprintf("JSONExtractString(labels, %s) AS reason", containerReasonFps.Var(containerStatusReasonAttrKey)),
 	)
-	containerReasonFps.From(fmt.Sprintf("%s.%s", telemetrymetrics.DBName, localTimeSeriesTable))
+	containerReasonFps.From(fmt.Sprintf("%s.%s", metricstelemetryschema.DBName, localTimeSeriesTable))
 	containerReasonFps.Where(
 		containerReasonFps.E("metric_name", containerStatusReasonMetricName),
 		containerReasonFps.GE("unix_milli", tsAdjustedStart),
@@ -432,7 +432,7 @@ func (m *module) getPerGroupPodStatusCounts(
 	)
 	containerInner.From(fmt.Sprintf(
 		"%s.%s AS samples INNER JOIN container_reason_fps AS fps ON samples.fingerprint = fps.fingerprint",
-		telemetrymetrics.DBName, distributedSamplesTable,
+		metricstelemetryschema.DBName, distributedSamplesTable,
 	))
 	containerInner.Where(
 		containerInner.E("samples.metric_name", containerStatusReasonMetricName),
@@ -611,7 +611,7 @@ func (m *module) getPerGroupPodRestartCounts(
 	mergedFilterExpr := mergeFilterExpressions(userFilterExpr, buildPageGroupsFilterExpr(pageGroups))
 
 	samplesStartMs, flooredEndMs, tsAdjustedStart, _, localTimeSeriesTable, distributedSamplesTable, _ := alignedMetricWindow(start, end)
-	valueCol := telemetrymetrics.ValueColumnForSamplesTable(distributedSamplesTable)
+	valueCol := metricstelemetryschema.ValueColumnForSamplesTable(distributedSamplesTable)
 
 	var (
 		filterClause *sqlbuilder.WhereClause
@@ -637,7 +637,7 @@ func (m *module) getPerGroupPodRestartCounts(
 		)
 	}
 	restartFps.Select(restartFpsCols...)
-	restartFps.From(fmt.Sprintf("%s.%s", telemetrymetrics.DBName, localTimeSeriesTable))
+	restartFps.From(fmt.Sprintf("%s.%s", metricstelemetryschema.DBName, localTimeSeriesTable))
 	restartFps.Where(
 		restartFps.E("metric_name", containerRestartsMetricName),
 		restartFps.GE("unix_milli", tsAdjustedStart),
@@ -667,7 +667,7 @@ func (m *module) getPerGroupPodRestartCounts(
 	containerRestarts.Select(containerRestartsCols...)
 	containerRestarts.From(fmt.Sprintf(
 		"%s.%s AS samples INNER JOIN restart_fps AS fps ON samples.fingerprint = fps.fingerprint",
-		telemetrymetrics.DBName, distributedSamplesTable,
+		metricstelemetryschema.DBName, distributedSamplesTable,
 	))
 	containerRestarts.Where(
 		containerRestarts.E("samples.metric_name", containerRestartsMetricName),

pkg/modules/metricsexplorer/implmetricsexplorer/module.go

@@ -19,8 +19,8 @@ import (
 	"github.com/SigNoz/signoz/pkg/modules/dashboard"
 	"github.com/SigNoz/signoz/pkg/modules/metricsexplorer"
 	"github.com/SigNoz/signoz/pkg/querybuilder"
-	"github.com/SigNoz/signoz/pkg/telemetrymeter"
-	"github.com/SigNoz/signoz/pkg/telemetrymetrics"
+	"github.com/SigNoz/signoz/pkg/telemetryschema/metertelemetryschema"
+	"github.com/SigNoz/signoz/pkg/telemetryschema/metricstelemetryschema"
 	"github.com/SigNoz/signoz/pkg/telemetrystore"
 	"github.com/SigNoz/signoz/pkg/types/ctxtypes"
 	"github.com/SigNoz/signoz/pkg/types/dashboardtypes"
@@ -49,8 +49,8 @@ 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 := telemetrymetrics.NewFieldMapper()
-	condBuilder := telemetrymetrics.NewConditionBuilder(fieldMapper)
+	fieldMapper := metricstelemetryschema.NewFieldMapper()
+	condBuilder := metricstelemetryschema.NewConditionBuilder(fieldMapper)
 	return &module{
 		telemetryStore:         ts,
 		fieldMapper:            fieldMapper,
@@ -89,7 +89,7 @@ func (m *module) listMeterMetrics(ctx context.Context, params *metricsexplorerty
 		"argMax(temporality, unix_milli) AS temporality",
 		"argMax(is_monotonic, unix_milli) AS is_monotonic",
 	)
-	sb.From(fmt.Sprintf("%s.%s", telemetrymeter.DBName, telemetrymeter.SamplesTableName))
+	sb.From(fmt.Sprintf("%s.%s", metertelemetryschema.DBName, metertelemetryschema.SamplesTableName))
 
 	if params.Start != nil && params.End != nil {
 		sb.Where(sb.Between("unix_milli", *params.Start, *params.End))
@@ -160,11 +160,11 @@ func (m *module) listMetrics(ctx context.Context, orgID valuer.UUID, params *met
 	hasRange := params.Start != nil && params.End != nil
 	if hasRange {
 		var distributedTsTable string
-		rangeStart, rangeEnd, distributedTsTable, _ = telemetrymetrics.WhichTSTableToUse(uint64(*params.Start), uint64(*params.End), false, nil)
-		rawSB.From(fmt.Sprintf("%s.%s", telemetrymetrics.DBName, distributedTsTable))
+		rangeStart, rangeEnd, distributedTsTable, _ = metricstelemetryschema.WhichTSTableToUse(uint64(*params.Start), uint64(*params.End), false, nil)
+		rawSB.From(fmt.Sprintf("%s.%s", metricstelemetryschema.DBName, distributedTsTable))
 		rawSB.Where(rawSB.Between("unix_milli", rangeStart, rangeEnd))
 	} else {
-		rawSB.From(fmt.Sprintf("%s.%s", telemetrymetrics.DBName, telemetrymetrics.TimeseriesV41weekTableName))
+		rawSB.From(fmt.Sprintf("%s.%s", metricstelemetryschema.DBName, metricstelemetryschema.TimeseriesV41weekTableName))
 	}
 
 	applyListFilters(rawSB)
@@ -174,7 +174,7 @@ func (m *module) listMetrics(ctx context.Context, orgID valuer.UUID, params *met
 	if reductionEnabled {
 		reducedSB := sqlbuilder.NewSelectBuilder()
 		reducedSB.Select("DISTINCT metric_name")
-		reducedSB.From(fmt.Sprintf("%s.%s", telemetrymetrics.DBName, telemetrymetrics.TimeseriesV4ReducedTableName))
+		reducedSB.From(fmt.Sprintf("%s.%s", metricstelemetryschema.DBName, metricstelemetryschema.TimeseriesV4ReducedTableName))
 		if hasRange {
 			reducedSB.Where(reducedSB.Between("unix_milli", rangeStart, rangeEnd))
 		}
@@ -512,7 +512,7 @@ func (m *module) CheckMetricExists(ctx context.Context, orgID valuer.UUID, metri
 
 	sb := sqlbuilder.NewSelectBuilder()
 	sb.Select("count(*) > 0 as metricExists")
-	sb.From(fmt.Sprintf("%s.%s", telemetrymetrics.DBName, telemetrymetrics.AttributesMetadataTableName))
+	sb.From(fmt.Sprintf("%s.%s", metricstelemetryschema.DBName, metricstelemetryschema.AttributesMetadataTableName))
 	sb.Where(sb.E("metric_name", metricName))
 
 	query, args := sb.BuildWithFlavor(sqlbuilder.ClickHouse)
@@ -534,7 +534,7 @@ func (m *module) HasNonSigNozMetrics(ctx context.Context) (bool, error) {
 
 	sb := sqlbuilder.NewSelectBuilder()
 	sb.Select("count(*) > 0")
-	sb.From(fmt.Sprintf("%s.%s", telemetrymetrics.DBName, telemetrymetrics.TimeseriesV41weekTableName))
+	sb.From(fmt.Sprintf("%s.%s", metricstelemetryschema.DBName, metricstelemetryschema.TimeseriesV41weekTableName))
 	sb.Where("metric_name NOT LIKE 'signoz_%'")
 
 	query, args := sb.BuildWithFlavor(sqlbuilder.ClickHouse)
@@ -570,10 +570,10 @@ func (m *module) InspectMetrics(
 		return nil, err
 	}
 
-	tsStart, _, tsTable, _ := telemetrymetrics.WhichTSTableToUse(start, end, false, nil)
+	tsStart, _, tsTable, _ := metricstelemetryschema.WhichTSTableToUse(start, end, false, nil)
 	tsSb := sqlbuilder.NewSelectBuilder()
 	tsSb.Select("fingerprint", "labels")
-	tsSb.From(fmt.Sprintf("%s.%s", telemetrymetrics.DBName, tsTable))
+	tsSb.From(fmt.Sprintf("%s.%s", metricstelemetryschema.DBName, tsTable))
 	tsSb.Where(
 		tsSb.E("metric_name", req.MetricName),
 		tsSb.GE("unix_milli", tsStart),
@@ -625,7 +625,7 @@ func (m *module) InspectMetrics(
 
 	samplesSb := sqlbuilder.NewSelectBuilder()
 	samplesSb.Select("fingerprint", "unix_milli", "value")
-	samplesSb.From(fmt.Sprintf("%s.%s", telemetrymetrics.DBName, telemetrymetrics.SamplesV4TableName))
+	samplesSb.From(fmt.Sprintf("%s.%s", metricstelemetryschema.DBName, metricstelemetryschema.SamplesV4TableName))
 	samplesSb.Where(
 		samplesSb.In("fingerprint", fingerprints...),
 		samplesSb.E("metric_name", req.MetricName),
@@ -717,7 +717,7 @@ func (m *module) fetchUpdatedMetadata(ctx context.Context, orgID valuer.UUID, me
 		"argMax(temporality, created_at) AS temporality",
 		"argMax(is_monotonic, created_at) AS is_monotonic",
 	)
-	sb.From(fmt.Sprintf("%s.%s", telemetrymetrics.DBName, telemetrymetrics.UpdatedMetadataTableName))
+	sb.From(fmt.Sprintf("%s.%s", metricstelemetryschema.DBName, metricstelemetryschema.UpdatedMetadataTableName))
 	sb.Where(sb.In("metric_name", args...))
 	sb.GroupBy("metric_name")
 
@@ -777,7 +777,7 @@ func (m *module) fetchTimeseriesMetadata(ctx context.Context, orgID valuer.UUID,
 		"anyLast(temporality) AS temporality",
 		"argMax(is_monotonic, unix_milli) AS is_monotonic",
 	)
-	sb.From(fmt.Sprintf("%s.%s", telemetrymetrics.DBName, telemetrymetrics.TimeseriesV4TableName))
+	sb.From(fmt.Sprintf("%s.%s", metricstelemetryschema.DBName, metricstelemetryschema.TimeseriesV4TableName))
 	sb.Where(sb.In("metric_name", args...))
 	sb.GroupBy("metric_name")
 
@@ -891,7 +891,7 @@ func (m *module) checkForLabelInMetric(ctx context.Context, metricName string, l
 
 	sb := sqlbuilder.NewSelectBuilder()
 	sb.Select("count(*) > 0 AS has_label")
-	sb.From(fmt.Sprintf("%s.%s", telemetrymetrics.DBName, telemetrymetrics.AttributesMetadataTableName))
+	sb.From(fmt.Sprintf("%s.%s", metricstelemetryschema.DBName, metricstelemetryschema.AttributesMetadataTableName))
 	sb.Where(sb.E("metric_name", metricName))
 	sb.Where(sb.E("attr_name", label))
 	sb.Limit(1)
@@ -914,7 +914,7 @@ func (m *module) insertMetricsMetadata(ctx context.Context, orgID valuer.UUID, r
 	createdAt := time.Now().UnixMilli()
 
 	ib := sqlbuilder.NewInsertBuilder()
-	ib.InsertInto(fmt.Sprintf("%s.%s", telemetrymetrics.DBName, telemetrymetrics.UpdatedMetadataTableName))
+	ib.InsertInto(fmt.Sprintf("%s.%s", metricstelemetryschema.DBName, metricstelemetryschema.UpdatedMetadataTableName))
 	ib.Cols("metric_name", "temporality", "is_monotonic", "type", "description", "unit", "created_at")
 	ib.Values(
 		req.MetricName,
@@ -1016,9 +1016,9 @@ func (m *module) fetchMetricsStatsWithSamples(
 		}
 	}
 
-	start, end, distributedTsTable, localTsTable := telemetrymetrics.WhichTSTableToUse(uint64(req.Start), uint64(req.End), false, nil)
-	distributedSamplesTable, _ := telemetrymetrics.WhichSamplesTableToUse(uint64(req.Start), uint64(req.End), metrictypes.UnspecifiedType, metrictypes.TimeAggregationUnspecified, false, nil)
-	countExp := telemetrymetrics.CountExpressionForSamplesTable(distributedSamplesTable)
+	start, end, distributedTsTable, localTsTable := metricstelemetryschema.WhichTSTableToUse(uint64(req.Start), uint64(req.End), false, nil)
+	distributedSamplesTable, _ := metricstelemetryschema.WhichSamplesTableToUse(uint64(req.Start), uint64(req.End), metrictypes.UnspecifiedType, metrictypes.TimeAggregationUnspecified, false, nil)
+	countExp := metricstelemetryschema.CountExpressionForSamplesTable(distributedSamplesTable)
 
 	// Timeseries counts per metric
 	tsSB := sqlbuilder.NewSelectBuilder()
@@ -1026,7 +1026,7 @@ func (m *module) fetchMetricsStatsWithSamples(
 		"metric_name",
 		"uniq(fingerprint) AS timeseries",
 	)
-	tsSB.From(fmt.Sprintf("%s.%s", telemetrymetrics.DBName, distributedTsTable))
+	tsSB.From(fmt.Sprintf("%s.%s", metricstelemetryschema.DBName, distributedTsTable))
 	tsSB.Where(tsSB.Between("unix_milli", start, end))
 	tsSB.Where("NOT startsWith(metric_name, 'signoz')")
 	if filterWhereClause != nil {
@@ -1040,7 +1040,7 @@ func (m *module) fetchMetricsStatsWithSamples(
 		"metric_name",
 		fmt.Sprintf("%s AS samples", countExp),
 	)
-	samplesSB.From(fmt.Sprintf("%s.%s", telemetrymetrics.DBName, distributedSamplesTable))
+	samplesSB.From(fmt.Sprintf("%s.%s", metricstelemetryschema.DBName, distributedSamplesTable))
 	samplesSB.Where(samplesSB.Between("unix_milli", req.Start, req.End))
 	samplesSB.Where("NOT startsWith(metric_name, 'signoz')")
 
@@ -1053,7 +1053,7 @@ func (m *module) fetchMetricsStatsWithSamples(
 	if filterWhereClause != nil {
 		fingerprintSB := sqlbuilder.NewSelectBuilder()
 		fingerprintSB.Select("fingerprint")
-		fingerprintSB.From(fmt.Sprintf("%s.%s", telemetrymetrics.DBName, localTsTable))
+		fingerprintSB.From(fmt.Sprintf("%s.%s", metricstelemetryschema.DBName, localTsTable))
 		fingerprintSB.Where(fingerprintSB.Between("unix_milli", start, end))
 		fingerprintSB.Where("NOT startsWith(metric_name, 'signoz')")
 		fingerprintSB.AddWhereClause(sqlbuilder.CopyWhereClause(filterWhereClause))
@@ -1064,7 +1064,7 @@ func (m *module) fetchMetricsStatsWithSamples(
 	} else {
 		metricNamesSB := sqlbuilder.NewSelectBuilder()
 		metricNamesSB.Select("DISTINCT metric_name")
-		metricNamesSB.From(fmt.Sprintf("%s.%s", telemetrymetrics.DBName, localTsTable))
+		metricNamesSB.From(fmt.Sprintf("%s.%s", metricstelemetryschema.DBName, localTsTable))
 		metricNamesSB.Where(metricNamesSB.Between("unix_milli", start, end))
 		metricNamesSB.Where("NOT startsWith(metric_name, 'signoz')")
 
@@ -1090,18 +1090,18 @@ func (m *module) fetchMetricsStatsWithSamples(
 		// the data lands either of the _reduced_last/_reduced_sum tables
 		reducedLastSB := sqlbuilder.NewSelectBuilder()
 		reducedLastSB.Select("metric_name", "uniq(reduced_fingerprint, unix_milli) AS cnt")
-		reducedLastSB.From(fmt.Sprintf("%s.%s", telemetrymetrics.DBName, telemetrymetrics.SamplesV4ReducedLastTableName))
+		reducedLastSB.From(fmt.Sprintf("%s.%s", metricstelemetryschema.DBName, metricstelemetryschema.SamplesV4ReducedLastTableName))
 		reducedLastSB.Where(reducedLastSB.Between("unix_milli", req.Start, req.End))
 		reducedLastSB.Where("NOT startsWith(metric_name, 'signoz')")
 
 		reducedSumSB := sqlbuilder.NewSelectBuilder()
 		reducedSumSB.Select("metric_name", "uniq(reduced_fingerprint, unix_milli) AS cnt")
-		reducedSumSB.From(fmt.Sprintf("%s.%s", telemetrymetrics.DBName, telemetrymetrics.SamplesV4ReducedSumTableName))
+		reducedSumSB.From(fmt.Sprintf("%s.%s", metricstelemetryschema.DBName, metricstelemetryschema.SamplesV4ReducedSumTableName))
 		reducedSumSB.Where(reducedSumSB.Between("unix_milli", req.Start, req.End))
 		reducedSumSB.Where("NOT startsWith(metric_name, 'signoz')")
 
 		// separate query for reduced series counts
-		reducedTsSB.From(fmt.Sprintf("%s.%s", telemetrymetrics.DBName, telemetrymetrics.TimeseriesV4ReducedTableName))
+		reducedTsSB.From(fmt.Sprintf("%s.%s", metricstelemetryschema.DBName, metricstelemetryschema.TimeseriesV4ReducedTableName))
 		reducedTsSB.Where(reducedTsSB.Between("unix_milli", start, end))
 		reducedTsSB.Where("NOT startsWith(metric_name, 'signoz')")
 		reducedTsSB.GroupBy("metric_name")
@@ -1112,7 +1112,7 @@ func (m *module) fetchMetricsStatsWithSamples(
 			// samples uses a separate cte with local table
 			reducedFpSB := sqlbuilder.NewSelectBuilder()
 			reducedFpSB.Select("fingerprint")
-			reducedFpSB.From(fmt.Sprintf("%s.%s", telemetrymetrics.DBName, telemetrymetrics.TimeseriesV4ReducedLocalTableName))
+			reducedFpSB.From(fmt.Sprintf("%s.%s", metricstelemetryschema.DBName, metricstelemetryschema.TimeseriesV4ReducedLocalTableName))
 			reducedFpSB.Where(reducedFpSB.Between("unix_milli", start, end))
 			reducedFpSB.Where("NOT startsWith(metric_name, 'signoz')")
 			reducedFpSB.AddWhereClause(sqlbuilder.CopyWhereClause(filterWhereClause))
@@ -1220,11 +1220,11 @@ func (m *module) computeTimeseriesTreemap(ctx context.Context, orgID valuer.UUID
 		}
 	}
 
-	start, end, distributedTsTable, _ := telemetrymetrics.WhichTSTableToUse(uint64(req.Start), uint64(req.End), false, nil)
+	start, end, distributedTsTable, _ := metricstelemetryschema.WhichTSTableToUse(uint64(req.Start), uint64(req.End), false, nil)
 
 	totalTSBuilder := sqlbuilder.NewSelectBuilder()
 	totalTSBuilder.Select("uniq(fingerprint) AS total_time_series")
-	totalTSBuilder.From(fmt.Sprintf("%s.%s", telemetrymetrics.DBName, distributedTsTable))
+	totalTSBuilder.From(fmt.Sprintf("%s.%s", metricstelemetryschema.DBName, distributedTsTable))
 	totalTSBuilder.Where(totalTSBuilder.Between("unix_milli", start, end))
 
 	metricsSB := sqlbuilder.NewSelectBuilder()
@@ -1232,7 +1232,7 @@ func (m *module) computeTimeseriesTreemap(ctx context.Context, orgID valuer.UUID
 		"metric_name",
 		"uniq(fingerprint) AS total_value",
 	)
-	metricsSB.From(fmt.Sprintf("%s.%s", telemetrymetrics.DBName, distributedTsTable))
+	metricsSB.From(fmt.Sprintf("%s.%s", metricstelemetryschema.DBName, distributedTsTable))
 	metricsSB.Where(metricsSB.Between("unix_milli", start, end))
 	metricsSB.Where("NOT startsWith(metric_name, 'signoz')")
 	if filterWhereClause != nil {
@@ -1244,7 +1244,7 @@ func (m *module) computeTimeseriesTreemap(ctx context.Context, orgID valuer.UUID
 	if reductionEnabled {
 		reducedTotalTSBuilder := sqlbuilder.NewSelectBuilder()
 		reducedTotalTSBuilder.Select("uniq(fingerprint) AS total_time_series")
-		reducedTotalTSBuilder.From(fmt.Sprintf("%s.%s", telemetrymetrics.DBName, telemetrymetrics.TimeseriesV4ReducedTableName))
+		reducedTotalTSBuilder.From(fmt.Sprintf("%s.%s", metricstelemetryschema.DBName, metricstelemetryschema.TimeseriesV4ReducedTableName))
 		reducedTotalTSBuilder.Where(reducedTotalTSBuilder.Between("unix_milli", start, end))
 
 		reducedMetricsSB := sqlbuilder.NewSelectBuilder()
@@ -1252,7 +1252,7 @@ func (m *module) computeTimeseriesTreemap(ctx context.Context, orgID valuer.UUID
 			"metric_name",
 			"uniq(fingerprint) AS total_value",
 		)
-		reducedMetricsSB.From(fmt.Sprintf("%s.%s", telemetrymetrics.DBName, telemetrymetrics.TimeseriesV4ReducedTableName))
+		reducedMetricsSB.From(fmt.Sprintf("%s.%s", metricstelemetryschema.DBName, metricstelemetryschema.TimeseriesV4ReducedTableName))
 		reducedMetricsSB.Where(reducedMetricsSB.Between("unix_milli", start, end))
 		reducedMetricsSB.Where("NOT startsWith(metric_name, 'signoz')")
 		if filterWhereClause != nil {
@@ -1338,15 +1338,15 @@ func (m *module) computeSamplesTreemap(ctx context.Context, orgID valuer.UUID, r
 		}
 	}
 
-	start, end, distributedTsTable, localTsTable := telemetrymetrics.WhichTSTableToUse(uint64(req.Start), uint64(req.End), false, nil)
-	distributedSamplesTable, _ := telemetrymetrics.WhichSamplesTableToUse(uint64(req.Start), uint64(req.End), metrictypes.UnspecifiedType, metrictypes.TimeAggregationUnspecified, false, nil)
-	countExp := telemetrymetrics.CountExpressionForSamplesTable(distributedSamplesTable)
+	start, end, distributedTsTable, localTsTable := metricstelemetryschema.WhichTSTableToUse(uint64(req.Start), uint64(req.End), false, nil)
+	distributedSamplesTable, _ := metricstelemetryschema.WhichSamplesTableToUse(uint64(req.Start), uint64(req.End), metrictypes.UnspecifiedType, metrictypes.TimeAggregationUnspecified, false, nil)
+	countExp := metricstelemetryschema.CountExpressionForSamplesTable(distributedSamplesTable)
 
 	candidateLimit := req.Limit + 50
 
 	metricCandidatesSB := sqlbuilder.NewSelectBuilder()
 	metricCandidatesSB.Select("metric_name")
-	metricCandidatesSB.From(fmt.Sprintf("%s.%s", telemetrymetrics.DBName, distributedTsTable))
+	metricCandidatesSB.From(fmt.Sprintf("%s.%s", metricstelemetryschema.DBName, distributedTsTable))
 	metricCandidatesSB.Where("NOT startsWith(metric_name, 'signoz')")
 	metricCandidatesSB.Where(metricCandidatesSB.Between("unix_milli", start, end))
 	if filterWhereClause != nil {
@@ -1364,7 +1364,7 @@ func (m *module) computeSamplesTreemap(ctx context.Context, orgID valuer.UUID, r
 	if reductionEnabled {
 		reducedCandidatesSB = sqlbuilder.NewSelectBuilder()
 		reducedCandidatesSB.Select("metric_name")
-		reducedCandidatesSB.From(fmt.Sprintf("%s.%s", telemetrymetrics.DBName, telemetrymetrics.TimeseriesV4ReducedTableName))
+		reducedCandidatesSB.From(fmt.Sprintf("%s.%s", metricstelemetryschema.DBName, metricstelemetryschema.TimeseriesV4ReducedTableName))
 		reducedCandidatesSB.Where("NOT startsWith(metric_name, 'signoz')")
 		reducedCandidatesSB.Where(reducedCandidatesSB.Between("unix_milli", start, end))
 		if filterWhereClause != nil {
@@ -1379,7 +1379,7 @@ func (m *module) computeSamplesTreemap(ctx context.Context, orgID valuer.UUID, r
 
 	totalSamplesSB := sqlbuilder.NewSelectBuilder()
 	totalSamplesSB.Select(fmt.Sprintf("%s AS total_samples", countExp))
-	totalSamplesSB.From(fmt.Sprintf("%s.%s", telemetrymetrics.DBName, distributedSamplesTable))
+	totalSamplesSB.From(fmt.Sprintf("%s.%s", metricstelemetryschema.DBName, distributedSamplesTable))
 	totalSamplesSB.Where(totalSamplesSB.Between("unix_milli", req.Start, req.End))
 
 	sampleCountsSB := sqlbuilder.NewSelectBuilder()
@@ -1387,7 +1387,7 @@ func (m *module) computeSamplesTreemap(ctx context.Context, orgID valuer.UUID, r
 		"metric_name",
 		fmt.Sprintf("%s AS samples", countExp),
 	)
-	sampleCountsSB.From(fmt.Sprintf("%s.%s", telemetrymetrics.DBName, distributedSamplesTable))
+	sampleCountsSB.From(fmt.Sprintf("%s.%s", metricstelemetryschema.DBName, distributedSamplesTable))
 	sampleCountsSB.Where(sampleCountsSB.Between("unix_milli", req.Start, req.End))
 	sampleCountsSB.Where("metric_name GLOBAL IN (SELECT metric_name FROM __metric_candidates)")
 
@@ -1397,13 +1397,13 @@ func (m *module) computeSamplesTreemap(ctx context.Context, orgID valuer.UUID, r
 	if reductionEnabled {
 		reducedLastSB = sqlbuilder.NewSelectBuilder()
 		reducedLastSB.Select("metric_name", "uniq(reduced_fingerprint, unix_milli) AS cnt")
-		reducedLastSB.From(fmt.Sprintf("%s.%s", telemetrymetrics.DBName, telemetrymetrics.SamplesV4ReducedLastTableName))
+		reducedLastSB.From(fmt.Sprintf("%s.%s", metricstelemetryschema.DBName, metricstelemetryschema.SamplesV4ReducedLastTableName))
 		reducedLastSB.Where(reducedLastSB.Between("unix_milli", req.Start, req.End))
 		reducedLastSB.Where("metric_name GLOBAL IN (SELECT metric_name FROM __reduced_metric_candidates)")
 
 		reducedSumSB = sqlbuilder.NewSelectBuilder()
 		reducedSumSB.Select("metric_name", "uniq(reduced_fingerprint, unix_milli) AS cnt")
-		reducedSumSB.From(fmt.Sprintf("%s.%s", telemetrymetrics.DBName, telemetrymetrics.SamplesV4ReducedSumTableName))
+		reducedSumSB.From(fmt.Sprintf("%s.%s", metricstelemetryschema.DBName, metricstelemetryschema.SamplesV4ReducedSumTableName))
 		reducedSumSB.Where(reducedSumSB.Between("unix_milli", req.Start, req.End))
 		reducedSumSB.Where("metric_name GLOBAL IN (SELECT metric_name FROM __reduced_metric_candidates)")
 	}
@@ -1411,7 +1411,7 @@ func (m *module) computeSamplesTreemap(ctx context.Context, orgID valuer.UUID, r
 	if filterWhereClause != nil {
 		fingerprintSB := sqlbuilder.NewSelectBuilder()
 		fingerprintSB.Select("fingerprint")
-		fingerprintSB.From(fmt.Sprintf("%s.%s", telemetrymetrics.DBName, localTsTable))
+		fingerprintSB.From(fmt.Sprintf("%s.%s", metricstelemetryschema.DBName, localTsTable))
 		fingerprintSB.Where(fingerprintSB.Between("unix_milli", start, end))
 		fingerprintSB.Where("NOT startsWith(metric_name, 'signoz')")
 		fingerprintSB.AddWhereClause(sqlbuilder.CopyWhereClause(filterWhereClause))
@@ -1423,7 +1423,7 @@ func (m *module) computeSamplesTreemap(ctx context.Context, orgID valuer.UUID, r
 		if reductionEnabled {
 			reducedFingerprintSB := sqlbuilder.NewSelectBuilder()
 			reducedFingerprintSB.Select("fingerprint")
-			reducedFingerprintSB.From(fmt.Sprintf("%s.%s", telemetrymetrics.DBName, telemetrymetrics.TimeseriesV4ReducedLocalTableName))
+			reducedFingerprintSB.From(fmt.Sprintf("%s.%s", metricstelemetryschema.DBName, metricstelemetryschema.TimeseriesV4ReducedLocalTableName))
 			reducedFingerprintSB.Where(reducedFingerprintSB.Between("unix_milli", start, end))
 			reducedFingerprintSB.Where("NOT startsWith(metric_name, 'signoz')")
 			reducedFingerprintSB.AddWhereClause(sqlbuilder.CopyWhereClause(filterWhereClause))
@@ -1457,12 +1457,12 @@ func (m *module) computeSamplesTreemap(ctx context.Context, orgID valuer.UUID, r
 		// Grand total includes reduced sample volume so percentages stay consistent.
 		reducedTotalLastSB := sqlbuilder.NewSelectBuilder()
 		reducedTotalLastSB.Select("uniq(reduced_fingerprint, unix_milli) AS cnt")
-		reducedTotalLastSB.From(fmt.Sprintf("%s.%s", telemetrymetrics.DBName, telemetrymetrics.SamplesV4ReducedLastTableName))
+		reducedTotalLastSB.From(fmt.Sprintf("%s.%s", metricstelemetryschema.DBName, metricstelemetryschema.SamplesV4ReducedLastTableName))
 		reducedTotalLastSB.Where(reducedTotalLastSB.Between("unix_milli", req.Start, req.End))
 
 		reducedTotalSumSB := sqlbuilder.NewSelectBuilder()
 		reducedTotalSumSB.Select("uniq(reduced_fingerprint, unix_milli) AS cnt")
-		reducedTotalSumSB.From(fmt.Sprintf("%s.%s", telemetrymetrics.DBName, telemetrymetrics.SamplesV4ReducedSumTableName))
+		reducedTotalSumSB.From(fmt.Sprintf("%s.%s", metricstelemetryschema.DBName, metricstelemetryschema.SamplesV4ReducedSumTableName))
 		reducedTotalSumSB.Where(reducedTotalSumSB.Between("unix_milli", req.Start, req.End))
 
 		reducedTotalSamplesSB := sqlbuilder.NewSelectBuilder()
@@ -1552,7 +1552,7 @@ func (m *module) getMetricDataPoints(ctx context.Context, metricName string) (ui
 
 	sb := sqlbuilder.NewSelectBuilder()
 	sb.Select("sum(count) AS data_points")
-	sb.From(fmt.Sprintf("%s.%s", telemetrymetrics.DBName, telemetrymetrics.SamplesV4Agg30mTableName))
+	sb.From(fmt.Sprintf("%s.%s", metricstelemetryschema.DBName, metricstelemetryschema.SamplesV4Agg30mTableName))
 	sb.Where(sb.E("metric_name", metricName))
 
 	query, args := sb.BuildWithFlavor(sqlbuilder.ClickHouse)
@@ -1574,7 +1574,7 @@ func (m *module) getMetricLastReceived(ctx context.Context, metricName string) (
 
 	sb := sqlbuilder.NewSelectBuilder()
 	sb.Select("MAX(last_reported_unix_milli) AS last_received_time")
-	sb.From(fmt.Sprintf("%s.%s", telemetrymetrics.DBName, telemetrymetrics.AttributesMetadataTableName))
+	sb.From(fmt.Sprintf("%s.%s", metricstelemetryschema.DBName, metricstelemetryschema.AttributesMetadataTableName))
 	sb.Where(sb.E("metric_name", metricName))
 	query, args := sb.BuildWithFlavor(sqlbuilder.ClickHouse)
 
@@ -1599,7 +1599,7 @@ func (m *module) getTotalTimeSeriesForMetricName(ctx context.Context, metricName
 
 	sb := sqlbuilder.NewSelectBuilder()
 	sb.Select("uniq(fingerprint) AS time_series_count")
-	sb.From(fmt.Sprintf("%s.%s", telemetrymetrics.DBName, telemetrymetrics.TimeseriesV41weekTableName))
+	sb.From(fmt.Sprintf("%s.%s", metricstelemetryschema.DBName, metricstelemetryschema.TimeseriesV41weekTableName))
 	sb.Where(sb.E("metric_name", metricName))
 
 	query, args := sb.BuildWithFlavor(sqlbuilder.ClickHouse)
@@ -1623,7 +1623,7 @@ func (m *module) getActiveTimeSeriesForMetricName(ctx context.Context, metricNam
 
 	sb := sqlbuilder.NewSelectBuilder()
 	sb.Select("uniq(fingerprint) AS active_time_series")
-	sb.From(fmt.Sprintf("%s.%s", telemetrymetrics.DBName, telemetrymetrics.TimeseriesV4TableName))
+	sb.From(fmt.Sprintf("%s.%s", metricstelemetryschema.DBName, metricstelemetryschema.TimeseriesV4TableName))
 	sb.Where(sb.E("metric_name", metricName))
 	sb.Where(sb.GTE("unix_milli", milli))
 
@@ -1649,7 +1649,7 @@ func (m *module) fetchMetricAttributes(ctx context.Context, metricName string, s
 		"groupUniqArray(1000)(attr_string_value) AS values",
 		"uniq(attr_string_value) AS valueCount",
 	)
-	sb.From(fmt.Sprintf("%s.%s", telemetrymetrics.DBName, telemetrymetrics.AttributesMetadataTableName))
+	sb.From(fmt.Sprintf("%s.%s", metricstelemetryschema.DBName, metricstelemetryschema.AttributesMetadataTableName))
 	sb.Where(sb.E("metric_name", metricName))
 	sb.Where("NOT startsWith(attr_name, '__')")
 

pkg/modules/promote/implpromote/module.go

@@ -9,7 +9,7 @@ import (
 	schemamigrator "github.com/SigNoz/signoz-otel-collector/cmd/signozschemamigrator/schema_migrator"
 	"github.com/SigNoz/signoz/pkg/errors"
 	"github.com/SigNoz/signoz/pkg/modules/promote"
-	"github.com/SigNoz/signoz/pkg/telemetrylogs"
+	"github.com/SigNoz/signoz/pkg/telemetryschema/logstelemetryschema"
 	"github.com/SigNoz/signoz/pkg/telemetrystore"
 	"github.com/SigNoz/signoz/pkg/types/ctxtypes"
 	"github.com/SigNoz/signoz/pkg/types/instrumentationtypes"
@@ -52,7 +52,7 @@ func (m *module) ListPromotedAndIndexedPaths(ctx context.Context) ([]promotetype
 
 	response := []promotetypes.PromotePath{}
 	for _, path := range promotedPaths {
-		fullPath := telemetrylogs.BodyPromotedColumnPrefix + path
+		fullPath := logstelemetryschema.BodyPromotedColumnPrefix + path
 		path = telemetrytypes.BodyJSONStringSearchPrefix + path
 		item := promotetypes.PromotePath{
 			Path:    path,
@@ -68,7 +68,7 @@ func (m *module) ListPromotedAndIndexedPaths(ctx context.Context) ([]promotetype
 
 	// add the paths that are not promoted but have indexes
 	for path, indexes := range aggr {
-		path := strings.TrimPrefix(path, telemetrylogs.BodyV2ColumnPrefix)
+		path := strings.TrimPrefix(path, logstelemetryschema.BodyV2ColumnPrefix)
 		path = telemetrytypes.BodyJSONStringSearchPrefix + path
 		response = append(response, promotetypes.PromotePath{
 			Path:    path,
@@ -108,8 +108,8 @@ func (m *module) createIndexes(ctx context.Context, indexes []schemamigrator.Ind
 
 	for _, index := range indexes {
 		alterStmt := schemamigrator.AlterTableAddIndex{
-			Database: telemetrylogs.DBName,
-			Table:    telemetrylogs.LogsV2LocalTableName,
+			Database: logstelemetryschema.DBName,
+			Table:    logstelemetryschema.LogsV2LocalTableName,
 			Index:    index,
 		}
 		op := alterStmt.OnCluster(m.telemetryStore.Cluster())
@@ -153,10 +153,10 @@ func (m *module) PromoteAndIndexPaths(
 			}
 		}
 		if len(it.Indexes) > 0 {
-			parentColumn := telemetrylogs.LogsV2BodyV2Column
+			parentColumn := logstelemetryschema.LogsV2BodyV2Column
 			// if the path is already promoted or is being promoted, add it to the promoted column
 			if _, promoted := existingPromotedPaths[it.Path]; promoted || it.Promote {
-				parentColumn = telemetrylogs.LogsV2BodyPromotedColumn
+				parentColumn = logstelemetryschema.LogsV2BodyPromotedColumn
 			}
 
 			for _, index := range it.Indexes {

pkg/modules/services/implservices/module.go

@@ -11,8 +11,8 @@ import (
 	"github.com/SigNoz/signoz/pkg/errors"
 	"github.com/SigNoz/signoz/pkg/modules/services"
 	"github.com/SigNoz/signoz/pkg/querier"
+	"github.com/SigNoz/signoz/pkg/telemetryschema/tracestelemetryschema"
 	"github.com/SigNoz/signoz/pkg/telemetrystore"
-	"github.com/SigNoz/signoz/pkg/telemetrytraces"
 	"github.com/SigNoz/signoz/pkg/types/ctxtypes"
 	"github.com/SigNoz/signoz/pkg/types/instrumentationtypes"
 	qbtypes "github.com/SigNoz/signoz/pkg/types/querybuildertypes/querybuildertypesv5"
@@ -39,7 +39,7 @@ func (m *module) FetchTopLevelOperations(ctx context.Context, start time.Time, s
 	ctx = m.withServicesContext(ctx, "FetchTopLevelOperations")
 
 	db := m.TelemetryStore.ClickhouseDB()
-	query := fmt.Sprintf("SELECT name, serviceName, max(time) as ts FROM %s.%s WHERE time >= @start", telemetrytraces.DBName, telemetrytraces.TopLevelOperationsTableName)
+	query := fmt.Sprintf("SELECT name, serviceName, max(time) as ts FROM %s.%s WHERE time >= @start", tracestelemetryschema.DBName, tracestelemetryschema.TopLevelOperationsTableName)
 	args := []any{clickhouse.Named("start", start)}
 	if len(services) > 0 {
 		query += " AND serviceName IN @services"

pkg/prometheus/clickhouseprometheusv2/capture.go

@@ -1,85 +0,0 @@
-package clickhouseprometheusv2
-
-import (
-	"context"
-	"sync"
-
-	"github.com/SigNoz/signoz/pkg/prometheus"
-	"github.com/prometheus/prometheus/model/labels"
-	"github.com/prometheus/prometheus/storage"
-	"github.com/prometheus/prometheus/util/annotations"
-)
-
-// statementRecorder collects the statements a PromQL evaluation would run.
-// Safe for concurrent use: the engine may Select selectors concurrently.
-type statementRecorder struct {
-	mu         sync.Mutex
-	statements []prometheus.CapturedStatement
-}
-
-func (r *statementRecorder) record(query string, args []any) {
-	r.mu.Lock()
-	defer r.mu.Unlock()
-	r.statements = append(r.statements, prometheus.CapturedStatement{Query: query, Args: args})
-}
-
-func (r *statementRecorder) Statements() []prometheus.CapturedStatement {
-	r.mu.Lock()
-	defer r.mu.Unlock()
-	out := make([]prometheus.CapturedStatement, len(r.statements))
-	copy(out, r.statements)
-	return out
-}
-
-type captureQueryable struct {
-	client   *client
-	recorder *statementRecorder
-}
-
-func (c *captureQueryable) Querier(mint, maxt int64) (storage.Querier, error) {
-	return &captureQuerier{
-		querier:  querier{mint: mint, maxt: maxt, client: c.client},
-		recorder: c.recorder,
-	}, nil
-}
-
-// captureQuerier builds the same SQL as the live querier but records it and
-// returns no data. The fingerprint filter always takes the subquery form:
-// without executing the series lookup, the inline literal set is unknown.
-type captureQuerier struct {
-	querier
-	recorder *statementRecorder
-}
-
-func (c *captureQuerier) Select(ctx context.Context, _ bool, hints *storage.SelectHints, matchers ...*labels.Matcher) storage.SeriesSet {
-
-	start, end := c.window(hints)
-
-	samplesQuery, args, err := buildSamplesQuery(start, end, metricNamesFromMatchers(matchers), matchers, c.lastSamplePerStepFor(ctx, hints))
-	if err != nil {
-		return storage.ErrSeriesSet(err)
-	}
-	c.recorder.record(samplesQuery, args)
-
-	return storage.EmptySeriesSet()
-}
-
-func (c *captureQuerier) LabelValues(context.Context, string, *storage.LabelHints, ...*labels.Matcher) ([]string, annotations.Annotations, error) {
-	return nil, nil, nil
-}
-
-func (c *captureQuerier) LabelNames(context.Context, *storage.LabelHints, ...*labels.Matcher) ([]string, annotations.Annotations, error) {
-	return nil, nil, nil
-}
-
-// metricNamesFromMatchers extracts the statically known metric name, if any.
-// The live path derives names from the matched series; the capture path has
-// no execution results, so only a __name__ equality contributes.
-func metricNamesFromMatchers(matchers []*labels.Matcher) []string {
-	for _, m := range matchers {
-		if m.Name == metricNameLabel && m.Type == labels.MatchEqual && m.Value != "" {
-			return []string{m.Value}
-		}
-	}
-	return nil
-}

pkg/prometheus/clickhouseprometheusv2/classification_golden_test.go

@@ -1,119 +0,0 @@
-package clickhouseprometheusv2
-
-import (
-	"encoding/json"
-	"flag"
-	"os"
-	"path/filepath"
-	"sort"
-	"testing"
-
-	"github.com/prometheus/prometheus/promql/parser"
-	"github.com/stretchr/testify/require"
-)
-
-var updateGolden = flag.Bool("update", false, "rewrite the classification golden file")
-
-const goldenFile = "testdata/classification_golden.json"
-
-// corpusFile is the conformance corpus the integration suite replays; the
-// golden freezes how the classifier routes every one of its expressions.
-const corpusFile = "../../../tests/integration/testdata/promqltestcorpus/corpus.json"
-
-type goldenEntry struct {
-	Expr    string `json:"expr"`
-	StartMs int64  `json:"start_ms"`
-	EndMs   int64  `json:"end_ms"`
-	StepMs  int64  `json:"step_ms"`
-	// Plan is the routing decision: "full" (whole query in ClickHouse),
-	// "hybrid" (units substituted, engine on top), "fallback" (engine over
-	// the native querier).
-	Plan string `json:"plan"`
-	// Units is the substituted-unit count for hybrid plans.
-	Units int `json:"units,omitempty"`
-	// Reason is the coarse fallback bucket (fallbackShape).
-	Reason string `json:"reason,omitempty"`
-}
-
-// TestClassificationGolden freezes the classifier's routing decision for
-// every (expression, grid) of the conformance corpus. Routing is a
-// correctness surface of its own: a change that silently sends rate() to the
-// engine path costs the pushdown, and one that silently starts transpiling a
-// shape never proven equivalent risks wrong numbers — both must show up in
-// review as a diff of this file, with the corpus suite's clickhousev2 leg
-// judging whether the new routing still returns the reference answers.
-//
-// Regenerate after intentional classifier changes:
-//
-//	go test ./pkg/prometheus/clickhouseprometheusv2 -run TestClassificationGolden -update
-func TestClassificationGolden(t *testing.T) {
-	raw, err := os.ReadFile(corpusFile)
-	require.NoError(t, err)
-
-	var corpus struct {
-		Cases []struct {
-			Expr    string `json:"expr"`
-			StartMs int64  `json:"start_ms"`
-			EndMs   int64  `json:"end_ms"`
-			StepMs  int64  `json:"step_ms"`
-		} `json:"cases"`
-	}
-	require.NoError(t, json.Unmarshal(raw, &corpus))
-	require.NotEmpty(t, corpus.Cases)
-
-	promParser := parser.NewParser(parser.Options{})
-	seen := map[goldenEntry]bool{}
-	var entries []goldenEntry
-	for _, c := range corpus.Cases {
-		key := goldenEntry{Expr: c.Expr, StartMs: c.StartMs, EndMs: c.EndMs, StepMs: c.StepMs}
-		if seen[key] {
-			continue
-		}
-		seen[key] = true
-
-		expr, err := promParser.ParseExpr(c.Expr)
-		require.NoError(t, err, "corpus expression must parse: %q", c.Expr)
-
-		entry := key
-		plan, ok := classify(expr, gridContext{startMs: c.StartMs, endMs: c.EndMs, stepMs: c.StepMs})
-		switch {
-		case ok && plan.full:
-			entry.Plan = "full"
-		case ok:
-			entry.Plan = "hybrid"
-			entry.Units = len(plan.units)
-		default:
-			entry.Plan = "fallback"
-			entry.Reason = fallbackShape(expr)
-		}
-		entries = append(entries, entry)
-	}
-	sort.Slice(entries, func(i, j int) bool {
-		a, b := entries[i], entries[j]
-		if a.Expr != b.Expr {
-			return a.Expr < b.Expr
-		}
-		if a.StartMs != b.StartMs {
-			return a.StartMs < b.StartMs
-		}
-		if a.EndMs != b.EndMs {
-			return a.EndMs < b.EndMs
-		}
-		return a.StepMs < b.StepMs
-	})
-
-	got, err := json.MarshalIndent(entries, "", "  ")
-	require.NoError(t, err)
-	got = append(got, '\n')
-
-	if *updateGolden {
-		require.NoError(t, os.MkdirAll(filepath.Dir(goldenFile), 0o755))
-		require.NoError(t, os.WriteFile(goldenFile, got, 0o644))
-		return
-	}
-
-	want, err := os.ReadFile(goldenFile)
-	require.NoError(t, err, "golden missing — generate it with -update")
-	require.Equal(t, string(want), string(got),
-		"classification routing changed; if intentional, regenerate with -update and justify the diff in review")
-}

pkg/prometheus/clickhouseprometheusv2/client.go

@@ -1,180 +0,0 @@
-package clickhouseprometheusv2
-
-import (
-	"context"
-	"encoding/json"
-	"log/slog"
-	"math"
-	"slices"
-
-	"github.com/SigNoz/signoz/pkg/factory"
-	"github.com/SigNoz/signoz/pkg/prometheus"
-	"github.com/SigNoz/signoz/pkg/telemetrystore"
-	"github.com/SigNoz/signoz/pkg/types/ctxtypes"
-	"github.com/SigNoz/signoz/pkg/types/instrumentationtypes"
-	"github.com/SigNoz/signoz/pkg/types/telemetrytypes"
-	"github.com/prometheus/prometheus/model/labels"
-	promValue "github.com/prometheus/prometheus/model/value"
-)
-
-// seriesLookup holds a series lookup's result: matched fingerprints with
-// their labels, and the distinct metric names seen on them.
-type seriesLookup struct {
-	fingerprints map[uint64]labels.Labels
-	metricNames  []string
-}
-
-// client executes the series, samples and raw queries against ClickHouse.
-type client struct {
-	settings       factory.ScopedProviderSettings
-	telemetryStore telemetrystore.TelemetryStore
-	lookbackMs     int64
-}
-
-func newClient(settings factory.ScopedProviderSettings, telemetryStore telemetrystore.TelemetryStore, cfg prometheus.Config) *client {
-	lookback := cfg.LookbackDelta
-	if lookback <= 0 {
-		// Mirror the engine: promql defaults an unset lookback to 5m.
-		lookback = defaultLookbackDelta
-	}
-	return &client{
-		settings:       settings,
-		telemetryStore: telemetryStore,
-		lookbackMs:     lookback.Milliseconds(),
-	}
-}
-
-func (c *client) withContext(ctx context.Context, functionName string) context.Context {
-	return ctxtypes.NewContextWithCommentVals(ctx, map[string]string{
-		instrumentationtypes.TelemetrySignal:  telemetrytypes.SignalMetrics.StringValue(),
-		instrumentationtypes.CodeNamespace:    "clickhouse-prometheus-v2",
-		instrumentationtypes.CodeFunctionName: functionName,
-	})
-}
-
-func (c *client) selectSeries(ctx context.Context, query string, args []any) (*seriesLookup, error) {
-	ctx = c.withContext(ctx, "selectSeries")
-	rows, err := c.telemetryStore.ClickhouseDB().Query(ctx, query, args...)
-	if err != nil {
-		return nil, err
-	}
-	defer rows.Close()
-
-	lookup := &seriesLookup{fingerprints: make(map[uint64]labels.Labels)}
-	names := make(map[string]struct{})
-
-	var fingerprint uint64
-	var labelsJSON string
-	for rows.Next() {
-		if err := rows.Scan(&fingerprint, &labelsJSON); err != nil {
-			return nil, err
-		}
-		lset, err := unmarshalLabels(labelsJSON)
-		if err != nil {
-			return nil, err
-		}
-		lookup.fingerprints[fingerprint] = lset
-		if name := lset.Get(metricNameLabel); name != "" {
-			names[name] = struct{}{}
-		}
-	}
-	if err := rows.Err(); err != nil {
-		return nil, err
-	}
-
-	for name := range names {
-		lookup.metricNames = append(lookup.metricNames, name)
-	}
-	slices.Sort(lookup.metricNames)
-
-	return lookup, nil
-}
-
-// unmarshalLabels parses the labels JSON column, dropping empty-valued
-// labels: empty means "absent" in Prometheus, but stored attribute JSON can
-// carry them.
-func unmarshalLabels(s string) (labels.Labels, error) {
-	m := make(map[string]string)
-	if err := json.Unmarshal([]byte(s), &m); err != nil {
-		return labels.EmptyLabels(), err
-	}
-	builder := labels.NewScratchBuilder(len(m))
-	for k, v := range m {
-		if v == "" {
-			continue
-		}
-		builder.Add(k, v)
-	}
-	builder.Sort()
-	return builder.Labels(), nil
-}
-
-// selectSamples assembles per-series sample slices from a samples query (raw
-// or last-sample-per-step; same column shape), whose rows arrive ordered by
-// (fingerprint, unix_milli). Fingerprints missing from the lookup are skipped:
-// the samples query's semi-join re-runs the series predicates and can match
-// series registered after the lookup ran — the lookup is the read snapshot.
-// Stale flags map to the engine's StaleNaN. Duplicate
-// timestamps pass through: uniqueness is ingest's job, and v1 feeds them to
-// the engine as-is over the same dirty data.
-func (c *client) selectSamples(ctx context.Context, query string, args []any, lookup *seriesLookup) ([]*series, error) {
-	ctx = c.withContext(ctx, "selectSamples")
-	rows, err := c.telemetryStore.ClickhouseDB().Query(ctx, query, args...)
-	if err != nil {
-		return nil, err
-	}
-	defer rows.Close()
-
-	var (
-		result       []*series
-		current      *series
-		fingerprint  uint64
-		prevFp       uint64
-		timestampMs  int64
-		val          float64
-		flags        uint32
-		first        = true
-		haveCurrent  bool
-		staleMarker  = math.Float64frombits(promValue.StaleNaN)
-		unknownCount int
-	)
-
-	for rows.Next() {
-		if err := rows.Scan(&fingerprint, &timestampMs, &val, &flags); err != nil {
-			return nil, err
-		}
-
-		if first || fingerprint != prevFp {
-			first = false
-			prevFp = fingerprint
-			lset, ok := lookup.fingerprints[fingerprint]
-			if !ok {
-				unknownCount++
-				haveCurrent = false
-				continue
-			}
-			current = &series{lset: lset}
-			result = append(result, current)
-			haveCurrent = true
-		}
-		if !haveCurrent {
-			continue
-		}
-
-		if flags&1 == 1 {
-			val = staleMarker
-		}
-		current.ts = append(current.ts, timestampMs)
-		current.vs = append(current.vs, val)
-	}
-	if err := rows.Err(); err != nil {
-		return nil, err
-	}
-
-	if unknownCount > 0 {
-		c.settings.Logger().DebugContext(ctx, "skipped samples of fingerprints missing from series lookup",
-			slog.Int("unknown_fingerprints", unknownCount))
-	}
-
-	return result, nil
-}

pkg/prometheus/clickhouseprometheusv2/doc.go

@@ -1,337 +0,0 @@
-// Package clickhouseprometheusv2 is the second-generation ClickHouse-backed
-// Prometheus provider. It exists because the v1 provider fetches every raw
-// sample of a query's union window through the remote-read protobuf layer
-// and hands it to the engine — the cost is a function of ingested data, not
-// of the question asked, which is how a dashboard of PromQL panels takes an
-// instance down.
-//
-// Every query runs in one of two ways, decided per query:
-//
-//   - Transpiled: the query is evaluated entirely inside ClickHouse and only
-//     final (or near-final) per-group grid arrays come back, built on the
-//     timeSeries*ToGrid aggregate functions (the supported ClickHouse floor
-//     is >= 25.6, so they are assumed available).
-//   - Engine: the stock promql engine evaluates over this package's native
-//     storage.Querier. This is the path for everything not transpilable.
-//
-// Correctness is the constraint that shaped both paths: a PromQL result that
-// differs from upstream Prometheus is a lost user, so anything that cannot
-// reproduce engine semantics exactly falls back rather than approximate.
-// The rest of this comment is the PromQL -> SQL story, because that mapping
-// is where correctness is won or lost.
-//
-// # The evaluation model the SQL must reproduce
-//
-// A PromQL range query is an instant query evaluated at every grid point
-// t_i = start + i*step, i = 0..(end-start)/step. At each t_i:
-//
-//   - an instant selector resolves to the latest sample in the left-open
-//     lookback window (t_i - lookback, t_i], and to nothing when that latest
-//     sample is a stale marker — even if older real samples sit inside the
-//     window;
-//   - a range selector [r] collects every sample in (t_i - r, t_i], stale
-//     markers excluded;
-//   - offset d shifts both windows to (t_i - d - w, t_i - d].
-//
-// The transpilation invariant follows from this: every transpiled construct
-// produces, per output series, one array with exactly one slot per grid
-// point — slot i holds the value at t_i, NULL means absent. This is what
-// makes composition correct, not just convenient: the engine evaluates
-// these operators independently per t_i, so any representation that gets
-// every slot right gets the whole query right, and spatial aggregation over
-// arrays is sound because it combines values that belong to the same t_i by
-// construction. Slot index i maps back to t_i = start + i*step at scan time
-// (toMatrix). Everything below is about filling those slots with exactly
-// the numbers the engine would compute — and each equivalence was validated
-// against the vendored engine on live data before its shape entered the
-// allowlist; anything unproven stays on the engine path.
-//
-// # Classification: finding what a statement can answer
-//
-// classify walks the parsed AST looking for "core units" — maximal subtrees
-// of the shape
-//
-//	[agg by/without (...)] [fn(] selector[range] [offset d] [)] [op scalar]...
-//
-// classifyCore peels that chain from the outside in: an optional
-// sum/min/max/avg/count aggregation, then one of the allowlisted functions
-// or a bare instant selector, then the selector with its offset; on the way
-// out it accumulates number-literal arithmetic, comparisons (including
-// bool) and unary minus into a scalar-op pipeline. A node qualifies only if
-// its type, arguments and children are in the proven set — an allowlist, so
-// an overlooked construct becomes a fallback instead of a wrong number.
-//
-// Three unit kinds come out of this, each with its own SQL form:
-// unitRange (rate, irate, increase, delta, idelta over a range selector),
-// unitInstant (instant vector selection, bare or comparison-filtered) and
-// unitOverTime (avg/min/max/sum/count/last _over_time).
-//
-// If the entire tree is one unit, the plan is "full": the statement's rows
-// are the query result. Otherwise every maximal unit is cut out and replaced
-// in the expression with a synthetic selector __signoz_transpiled_N__, and
-// the rewritten expression runs in the engine over the units' materialized
-// results ("hybrid") — histogram_quantile, topk, or/and/unless and vector
-// matching keep exact engine semantics while their expensive inputs were
-// aggregated server-side.
-//
-// Classification refuses when exact semantics cannot be guaranteed
-// server-side: the @ modifier anywhere and default-resolution subqueries
-// (their resolution is a server runtime setting the transpiler cannot see);
-// duration expressions (offset step(), [range()], ...) anywhere — they are
-// resolved into the selector's static fields only at evaluation time, so at
-// classification time those fields still hold their zero values and
-// transpiling would silently use the wrong offset or range;
-// steps or ranges that are not whole seconds (the grid functions take
-// whole-second parameters); grouping by or matching on __name__ in hybrid
-// plans (the synthetic name would leak into results); name-keeping units —
-// bare/comparison instant selectors and last_over_time keep their real
-// __name__ (keepsName), which substitution would replace, so they transpile
-// only as full plans; and every function outside the allowlist (changes,
-// resets, quantile_over_time, absent, native-histogram functions, ...).
-//
-// Units inside a fixed-resolution subquery evaluate on the subquery's own
-// grid instead of the query grid: epoch-aligned multiples of the resolution
-// strictly after outerStart - offset - range, ending at outer end - offset —
-// the exact derivation the engine uses, because a grid shifted by one step
-// changes which samples every window sees.
-//
-// # From one unit to one statement
-//
-// buildUnitSQL renders each unit as a single statement. For
-// sum by (pod) (rate(m{job="api"}[5m])) the skeleton is:
-//
-//	SELECT gkey, sumForEach(grid) AS grid FROM (
-//	    SELECT series.gkey AS gkey,
-//	           timeSeriesRateToGrid(<start>, <end>, <step>, <range>)(fromUnixTimestamp64Milli(unix_milli), value) AS grid
-//	    FROM signoz_metrics.distributed_samples_v4 AS points
-//	    INNER JOIN (
-//	        SELECT fingerprint, <group key expr> AS gkey
-//	        FROM signoz_metrics.time_series_v4
-//	        WHERE <series predicates>
-//	        GROUP BY fingerprint, gkey
-//	    ) AS series ON points.fingerprint = series.fingerprint
-//	    WHERE metric_name = ? AND temporality IN ['Cumulative', 'Unspecified']
-//	      AND points.fingerprint IN (<matched fingerprints>)
-//	      AND unix_milli > <start - range> AND unix_milli <= <end>
-//	      AND bitAnd(flags, 1) = 0
-//	    GROUP BY points.fingerprint, series.gkey
-//	) GROUP BY gkey
-//	SETTINGS allow_experimental_ts_to_grid_aggregate_function = 1
-//
-// Reading it inside out:
-//
-// The time window is the selector's semantics verbatim: strict > on the
-// lower bound and <= on the upper is the left-open (t - w, t] rule, with the
-// whole window shifted by the offset. bitAnd(flags, 1) = 0 drops stale
-// markers, which PromQL excludes from range vectors.
-//
-// The inner GROUP BY computes one grid array per series.
-// timeSeriesRateToGrid(start, end, step, range) is a parametric aggregate:
-// fed (timestamp, value) pairs it produces Array(Nullable(Float64)) with one
-// slot per grid point. Correct because it implements the engine's
-// extrapolatedRate decision for decision — counter resets, the zero-point
-// clamp, the extrapolation thresholds, the >= 2 samples rule, the left-open
-// window — verified by feeding identical samples to both and comparing
-// slot for slot: the only difference ever observed is the last bit
-// (ClickHouse's C++ and Go round the same formula differently), which is
-// the floating-point floor, not a semantic gap. irate/delta/idelta map to
-// their own timeSeries*ToGrid functions with the same verification;
-// increase has no function of its own and is emitted as
-// arrayMap(x -> x * <range seconds>, <rate expr>), exact by definition —
-// extrapolatedRate computes the same extrapolated delta for both and
-// divides by the range only when isRate, so multiplying it back is the
-// identity, not an approximation. The grid parameters are rendered as
-// literals, not bound args — they are aggregate-function parameters — and
-// the experimental gate rides as a SETTINGS clause on the statement itself
-// so telemetrystore hooks cannot clobber it.
-//
-// The join annotates each series with its group key, in one of two forms.
-// by (...) extracts each listed label as a plain column
-// (JSONExtractString(labels, 'pod') AS g0) and groups on the columns
-// directly: the projection is a known short list and the label names live
-// in Go, so building, sorting and stringifying every label pair per row
-// would be waste. Correct because column-tuple equality is label-set
-// equality on the projection, and an extracted '' is the label being
-// absent — Prometheus semantics for by() over missing labels, and empties
-// are skipped when the columns turn back into labels. without and
-// no-aggregation project a label SET that varies per series, so they get
-// the canonical key: toJSONString of the sorted [label, value] pairs the
-// unit projects (without excludes the listed labels plus __name__; no
-// aggregation keeps everything, the name coming off in Go per the engine's
-// name-dropping rules). There the sort is load-bearing — stored JSON key
-// order is not canonical across fingerprints, and two orderings of the same
-// labels must land in one group — empty values are filtered for the same
-// absent-label reason, and the same string parses back into the output
-// label set (labelsFromGroupKey).
-//
-// The outer GROUP BY is the spatial aggregation: sum/min/max/avg/count
-// by/without become the -ForEach combinators. Element-wise aggregation over
-// grid arrays is the engine's per-t_i aggregation, because slot i of every
-// input array refers to the same t_i; the combinators skip NULLs, which is
-// the engine aggregating only the series present at t_i, and an index where
-// every series is absent stays NULL. Two edges need explicit handling:
-// countForEach wraps in a mapping of 0 back to NULL, because a count over
-// an all-absent index is an absent point, not 0; and a unit without
-// aggregation still passes through maxForEach — the identity for the common
-// one-fingerprint group, and a deterministic NULL-skipping merge when a
-// regex __name__ selector collapses distinct metrics onto one projected
-// label set. One caveat is inherent: summation order over series differs
-// from the engine's, so spatial aggregates can differ in the last ULP —
-// float addition is not associative; no ordering reproduces the engine's
-// bit-exactly from inside a GROUP BY.
-//
-// # Instant selectors: staleness needs two aggregates
-//
-// unitInstant uses window = lookback and must reproduce the shadowing rule:
-// the point is absent when the latest in-window sample is a stale marker.
-// timeSeriesLastToGrid alone cannot express that — skipping stale rows in
-// WHERE would resurrect the older real sample the marker was written to
-// bury. So stale rows stay in the scan for this kind only, and the grid
-// expression compares three aggregates per slot:
-//
-//	arrayMap((tall, tok, vok) -> if(tall IS NULL OR tok IS NULL OR tall != tok, NULL, vok),
-//	         timeSeriesLastToGrid(...)(ts, toFloat64(unix_milli)),                           -- last sample overall
-//	         timeSeriesLastToGridIf(...)(ts, toFloat64(unix_milli), bitAnd(flags, 1) = 0),   -- last non-stale, its timestamp
-//	         timeSeriesLastToGridIf(...)(ts, value, bitAnd(flags, 1) = 0))                   -- last non-stale, its value
-//
-// Correct by cases on a slot's window. No samples at all: both timestamp
-// aggregates are NULL, the slot is NULL — absent, as the engine says. Latest
-// sample non-stale: it is the latest overall and the latest non-stale, the
-// timestamps agree, the slot takes its value — the engine's pick. Latest
-// sample stale: the last-overall timestamp is the marker's, the
-// last-non-stale timestamp is older (or NULL when only markers are in
-// window), they disagree, the slot is NULL — the marker shadows, exactly
-// the engine's rule. Timestamps are unique per series (ingest dedups), so
-// timestamp equality identifies "the same sample" without ambiguity. The
-// -If combinator's applicability to these experimental aggregates was
-// probed before being trusted, not assumed.
-//
-// # Windowed *_over_time: whole buckets instead of a grid function
-//
-// avg/min/max/sum/count _over_time aggregate every raw sample in the window,
-// and no timeSeries*ToGrid function computes them. (last_over_time is the
-// exception: the last sample of a range vector — stale markers excluded from
-// range vectors by PromQL, excluded here in WHERE — is exactly
-// timeSeriesLastToGrid.) These transpile only when the range is a whole
-// multiple of the step, and then the window needs no per-sample fan-out at
-// all: with W = range/step, the window (t_k - range, t_k] is exactly the
-// union of W step buckets — both are left-open on the same boundaries — so
-// bucket membership fully determines window membership. Each sample lands
-// in exactly one bucket by a plain GROUP BY:
-//
-//	intDiv(unix_milli - <start> + <range> - 1, <step>) AS jj
-//
-// (ceil((ts - start)/step) shifted by W-1 so the earliest in-window sample
-// sits at 0; slot k's window is buckets jj in [k, k+W-1]). The alternative —
-// fanning each sample into all W windows that cover it — multiplies rows by
-// W, which for a long range over a short step is a row explosion measured
-// in billions; the bucketed form's row count is series x buckets, the size
-// of the output, regardless of W.
-//
-// The shard level aggregates per (series, group key, bucket): a bucket
-// count plus the function's value aggregate (sum for sum/avg, min, max).
-// The assembly level places the partials into dense arrays
-// (groupArrayInsertAt — positions are unique, one row per bucket; counts
-// and sums default to 0, which contributes nothing) and slides: slot k
-// combines its at-most-W bucket partials by direct aggregation, so window
-// sums are added the way the engine adds them — no prefix-sum differencing,
-// whose large-minus-large cancellation would drift past the shadow
-// tolerance on counter-sized values. Correct per slot because the bucket
-// union is the exact window multiset and avg/min/max/sum/count are
-// order-insensitive on a multiset (sum/avg up to summation order, the float
-// caveat above). A slot with zero window count is absent; min/max filter
-// their slices on the bucket counts, so an empty bucket's default can never
-// be mistaken for a value — a real sample can legitimately be +Inf.
-//
-// Ranges that don't divide the step, and windows wider than
-// maxWindowBuckets buckets (the slide costs W combines per slot), fall back
-// to the engine path, which is exact.
-//
-// # Scalar ops, full plans, hybrid plans
-//
-// The scalar-op pipeline applies in Go to the returned arrays
-// (applyScalarOps), slot by slot: arithmetic operators compute, comparisons
-// filter (the slot keeps the vector-side value or becomes NULL) or return
-// 0/1 under bool. Correct trivially: it is the same float64 operation the
-// engine would apply to the same slot value, in the same operator order the
-// AST dictates — running it in Go instead of another SQL layer changes
-// where, not what.
-//
-// A full plan's arrays map straight to the result matrix. A hybrid plan
-// materializes each unit's arrays as synthetic series under its
-// __signoz_transpiled_N__ name and evaluates the rewritten expression over
-// a storage that serves synthetic names from memory and everything else
-// live. Substitution is sound because a unit's output is a plain instant
-// vector to the engine — same values at same timestamps under a different
-// name, and the name cannot matter: plans that group by or match on
-// __name__ were refused at classification, and name-keeping units are never
-// substituted. One subtlety makes it exact: stale markers are written at
-// absent grid points, because the engine's lookback would otherwise
-// resurrect a point from up to lookback earlier — the marker encodes
-// "absent here" the way the engine itself encodes it. Units evaluate
-// concurrently; each is one series lookup plus one grid statement. A step
-// of 0 is an instant query: a single evaluation at end.
-//
-// # Series lookup
-//
-// Both paths resolve matchers the same way, once per selector
-// (selectSeries), against the series tables holding one row per
-// (fingerprint, bucket) at 1h/6h/1d/1w granularities; timeSeriesTableFor
-// picks the table whose bucket fits the window and rounds the window start
-// down to the bucket boundary. How matchers become SQL, and why regexes are
-// anchored, is documented at applySeriesConditions. Empty-valued labels come
-// off at this boundary: an empty value means "label absent" in Prometheus,
-// but stored attribute JSON can carry them.
-//
-// # The engine path
-//
-// Queries that do not transpile run in the stock engine over this package's
-// storage.Querier, which is still not the v1 path. Samples are fetched per
-// selector using the engine's per-selector hints, not the query-wide union
-// window, so foo / foo offset 1d reads two narrow windows instead of the
-// widest one twice. Instant selectors of subquery-free queries fetch only
-// the last sample per step bucket (lastSamplePerStep): buckets anchor at the
-// selector's first evaluation timestamp — recovered from the hints as
-// hints.Start + lookback - 1ms, the inverse of how the engine derives
-// hints.Start — so bucket boundaries coincide with evaluation timestamps and
-// a non-final sample of a bucket can never be the latest sample in
-// (t - lookback, t] for any grid t. Real timestamps are preserved, so the
-// engine's own lookback and staleness handling stay exact. Range selectors
-// always fetch raw — every sample feeds the range function — and the
-// subquery-free proof travels in the context as prometheus.QueryTraits,
-// because subquery selectors evaluate at the subquery's step while the
-// hints carry the top-level step. Row assembly maps stale flags to the
-// engine's StaleNaN and merges series with identical label sets
-// (sortAndMerge) — the engine assumes storages never emit duplicates.
-//
-// # Sharding
-//
-// samples_v4 and time_series_v4 (and all their rollups) shard on the same
-// key — cityHash64(env, temporality, metric_name, fingerprint) — so a
-// series' samples and catalog rows live on the same shard. The transpiled
-// statement above exploits that: the distributed samples table at the
-// top-level FROM makes ClickHouse rewrite the whole inner query per shard,
-// where the join against the shard-local series table and the per-series
-// grid aggregation run next to the data; the initiator only merges
-// aggregate states and applies the spatial -ForEach step. Same layout as
-// the telemetrymetrics statement builder. The group-key join alone
-// restricts the transpiled scan to the matched series; the engine path's
-// samples fetch restricts by the same predicates as a shard-local
-// semi-join, not a GLOBAL broadcast of the matched set. The temporality
-// filter on every
-// samples statement is a semantic no-op — the matched fingerprints already
-// come from those temporalities — that engages the leading samples
-// primary-key column. Delta-temporality series stay invisible to PromQL
-// here exactly as they are in v1: the rollout gate is parity with v1, and
-// making Delta visible is its own change with its own semantics to design —
-// a Delta stream fed to rate() as-if-cumulative would be wrong, not just
-// new.
-//
-// # Observability
-//
-// Every statement carries a log_comment with
-// code.namespace=clickhouse-prometheus-v2 and code.function.name naming the
-// call site (selectSeries, selectSamples, transpiledUnit, LabelValues,
-// LabelNames), so this provider's work is attributable in system.query_log
-// without guessing from query text.
-package clickhouseprometheusv2

pkg/prometheus/clickhouseprometheusv2/provider.go

@@ -1,84 +0,0 @@
-package clickhouseprometheusv2
-
-import (
-	"context"
-	"time"
-
-	"github.com/SigNoz/signoz/pkg/factory"
-	"github.com/SigNoz/signoz/pkg/prometheus"
-	"github.com/SigNoz/signoz/pkg/telemetrystore"
-	"github.com/prometheus/prometheus/promql"
-	"github.com/prometheus/prometheus/storage"
-)
-
-// Provider ties the package together: its own engine and parser, the
-// ClickHouse client behind the native storage.Querier, and the transpiler
-// executor. See the package documentation for what runs where and why. It is
-// exported as a concrete type — pkg/querier holds it directly for shadow
-// comparison and pinned serving, and an interface with a single
-// implementation would only hide that dependency.
-type Provider struct {
-	settings factory.ScopedProviderSettings
-	engine   *prometheus.Engine
-	parser   prometheus.Parser
-	client   *client
-	executor *executor
-}
-
-var (
-	_ prometheus.Prometheus        = (*Provider)(nil)
-	_ prometheus.StatementCapturer = (*Provider)(nil)
-)
-
-func NewFactory(telemetryStore telemetrystore.TelemetryStore) factory.ProviderFactory[prometheus.Prometheus, prometheus.Config] {
-	return factory.NewProviderFactory(factory.MustNewName("clickhousev2"), func(ctx context.Context, providerSettings factory.ProviderSettings, config prometheus.Config) (prometheus.Prometheus, error) {
-		return New(ctx, providerSettings, config, telemetryStore)
-	})
-}
-
-func New(_ context.Context, providerSettings factory.ProviderSettings, config prometheus.Config, telemetryStore telemetrystore.TelemetryStore) (*Provider, error) {
-	settings := factory.NewScopedProviderSettings(providerSettings, "github.com/SigNoz/signoz/pkg/prometheus/clickhouseprometheusv2")
-
-	engine := prometheus.NewEngine(settings.Logger(), config)
-	parser := prometheus.NewParser()
-	client := newClient(settings, telemetryStore, config)
-
-	return &Provider{
-		settings: settings,
-		engine:   engine,
-		parser:   parser,
-		client:   client,
-		executor: &executor{client: client, engine: engine, parser: parser},
-	}, nil
-}
-
-// TryExecuteRange evaluates transpilable query shapes directly in ClickHouse
-// (see transpiler.go). ok=false means the shape is not transpilable and the
-// caller should evaluate through Engine over Storage instead.
-func (p *Provider) TryExecuteRange(ctx context.Context, query string, start, end time.Time, step time.Duration) (promql.Matrix, bool, error) {
-	return p.executor.TryExecuteRange(ctx, query, start, end, step)
-}
-
-func (p *Provider) Engine() *prometheus.Engine {
-	return p.engine
-}
-
-func (p *Provider) Parser() prometheus.Parser {
-	return p.parser
-}
-
-func (p *Provider) Storage() storage.Queryable {
-	return p
-}
-
-func (p *Provider) Querier(mint, maxt int64) (storage.Querier, error) {
-	return &querier{mint: mint, maxt: maxt, client: p.client}, nil
-}
-
-// CapturingStorage implements prometheus.StatementCapturer: a storage that
-// records each selector's SQL without executing it, for the preview path.
-// A fresh recorder per call keeps concurrent dry-runs isolated.
-func (p *Provider) CapturingStorage() (storage.Queryable, prometheus.StatementRecorder) {
-	recorder := &statementRecorder{}
-	return &captureQueryable{client: p.client, recorder: recorder}, recorder
-}

pkg/prometheus/clickhouseprometheusv2/querier.go

@@ -1,170 +0,0 @@
-package clickhouseprometheusv2
-
-import (
-	"context"
-	"fmt"
-	"slices"
-	"time"
-
-	"github.com/SigNoz/signoz/pkg/prometheus"
-	"github.com/huandu/go-sqlbuilder"
-	"github.com/prometheus/prometheus/model/labels"
-	"github.com/prometheus/prometheus/storage"
-	"github.com/prometheus/prometheus/util/annotations"
-)
-
-// defaultLookbackDelta mirrors promql's default when the config leaves the
-// lookback unset; the engine and the storage must agree on it for
-// last-sample-per-step bucket anchoring.
-const defaultLookbackDelta = 5 * time.Minute
-
-// querier is a native storage.Querier over ClickHouse: Select builds SQL
-// directly from the matchers and hints, with no remote-read protobuf layer.
-type querier struct {
-	mint, maxt int64
-	client     *client
-}
-
-var _ storage.Querier = (*querier)(nil)
-
-func (q *querier) Select(ctx context.Context, sortSeries bool, hints *storage.SelectHints, matchers ...*labels.Matcher) storage.SeriesSet {
-	start, end := q.window(hints)
-
-	seriesQuery, seriesArgs, err := buildSeriesQuery(start, end, matchers)
-	if err != nil {
-		return storage.ErrSeriesSet(err)
-	}
-	lookup, err := q.client.selectSeries(ctx, seriesQuery, seriesArgs)
-	if err != nil {
-		return storage.ErrSeriesSet(err)
-	}
-	if len(lookup.fingerprints) == 0 {
-		return storage.EmptySeriesSet()
-	}
-
-	list, err := q.fetchSamples(ctx, start, end, matchers, lookup, q.lastSamplePerStepFor(ctx, hints))
-	if err != nil {
-		return storage.ErrSeriesSet(err)
-	}
-
-	// The engine assumes storages never emit duplicate label sets.
-	list = sortAndMerge(list)
-	return newSeriesSet(list)
-}
-
-func (q *querier) LabelValues(ctx context.Context, name string, hints *storage.LabelHints, matchers ...*labels.Matcher) ([]string, annotations.Annotations, error) {
-	sb := sqlbuilder.NewSelectBuilder()
-	if name == metricNameLabel {
-		sb.Select("DISTINCT metric_name AS value")
-	} else {
-		sb.Select(fmt.Sprintf("DISTINCT JSONExtractString(labels, %s) AS value", sb.Var(name)))
-	}
-	adjustedStart, table := timeSeriesTableFor(q.mint, q.maxt)
-	sb.From(fmt.Sprintf("%s.%s", databaseName, table))
-	if err := applySeriesConditions(sb, adjustedStart, q.maxt, matchers); err != nil {
-		return nil, nil, err
-	}
-	sb.Where("value != ''")
-	if hints != nil && hints.Limit > 0 {
-		sb.Limit(hints.Limit)
-	}
-
-	query, args := sb.BuildWithFlavor(sqlbuilder.ClickHouse)
-	values, err := q.selectStrings(ctx, "LabelValues", query, args)
-	if err != nil {
-		return nil, nil, err
-	}
-	slices.Sort(values)
-	return values, nil, nil
-}
-
-func (q *querier) LabelNames(ctx context.Context, hints *storage.LabelHints, matchers ...*labels.Matcher) ([]string, annotations.Annotations, error) {
-	sb := sqlbuilder.NewSelectBuilder()
-	sb.Select("DISTINCT arrayJoin(JSONExtractKeys(labels)) AS name")
-	adjustedStart, table := timeSeriesTableFor(q.mint, q.maxt)
-	sb.From(fmt.Sprintf("%s.%s", databaseName, table))
-	if err := applySeriesConditions(sb, adjustedStart, q.maxt, matchers); err != nil {
-		return nil, nil, err
-	}
-	if hints != nil && hints.Limit > 0 {
-		sb.Limit(hints.Limit)
-	}
-
-	query, args := sb.BuildWithFlavor(sqlbuilder.ClickHouse)
-	names, err := q.selectStrings(ctx, "LabelNames", query, args)
-	if err != nil {
-		return nil, nil, err
-	}
-	slices.Sort(names)
-	return names, nil, nil
-}
-
-func (q *querier) Close() error {
-	return nil
-}
-
-// window returns the per-selector fetch window from the hints (already
-// adjusted for offset, @, range and lookback); mint/maxt span the union of
-// all selectors and are the fallback.
-func (q *querier) window(hints *storage.SelectHints) (int64, int64) {
-	if hints != nil && hints.Start != 0 && hints.End != 0 && hints.Start <= hints.End {
-		return hints.Start, hints.End
-	}
-	return q.mint, q.maxt
-}
-
-// lastSamplePerStepFor decides whether the fetch can keep only the last
-// sample per step bucket (see lastSamplePerStep). Only instant selectors
-// (hints.Range == 0) of subquery-free queries qualify: range selectors need
-// every raw sample, and subquery selectors evaluate at the subquery's own
-// step while hints carry the top-level step — the subquery-free proof
-// arrives as QueryTraits in the context. The first evaluation timestamp is
-// recovered as hints.Start + lookback - 1ms, inverting how the engine
-// derives hints.Start.
-func (q *querier) lastSamplePerStepFor(ctx context.Context, hints *storage.SelectHints) *lastSamplePerStep {
-	if hints == nil || hints.Range != 0 || hints.Start <= 0 {
-		return nil
-	}
-	traits, ok := prometheus.QueryTraitsFromContext(ctx)
-	if !ok || !traits.SubqueryFree {
-		return nil
-	}
-	firstEval := hints.Start + q.client.lookbackMs - 1
-	if firstEval > hints.End {
-		// Defensive: never anchor a bucket past the window.
-		firstEval = hints.End
-	}
-	return &lastSamplePerStep{firstEvalMs: firstEval, stepMs: hints.Step}
-}
-
-// fetchSamples runs the samples query for the matched series (see
-// buildSamplesQuery).
-func (q *querier) fetchSamples(ctx context.Context, start, end int64, matchers []*labels.Matcher, lookup *seriesLookup, lastPerStep *lastSamplePerStep) ([]*series, error) {
-	query, args, err := buildSamplesQuery(start, end, lookup.metricNames, matchers, lastPerStep)
-	if err != nil {
-		return nil, err
-	}
-	return q.client.selectSamples(ctx, query, args, lookup)
-}
-
-func (q *querier) selectStrings(ctx context.Context, fn, query string, args []any) ([]string, error) {
-	ctx = q.client.withContext(ctx, fn)
-	rows, err := q.client.telemetryStore.ClickhouseDB().Query(ctx, query, args...)
-	if err != nil {
-		return nil, err
-	}
-	defer rows.Close()
-
-	var out []string
-	var v string
-	for rows.Next() {
-		if err := rows.Scan(&v); err != nil {
-			return nil, err
-		}
-		out = append(out, v)
-	}
-	if err := rows.Err(); err != nil {
-		return nil, err
-	}
-	return out, nil
-}

pkg/prometheus/clickhouseprometheusv2/seriesset.go

@@ -1,184 +0,0 @@
-package clickhouseprometheusv2
-
-import (
-	"sort"
-
-	"github.com/prometheus/prometheus/model/histogram"
-	"github.com/prometheus/prometheus/model/labels"
-	"github.com/prometheus/prometheus/storage"
-	"github.com/prometheus/prometheus/tsdb/chunkenc"
-	"github.com/prometheus/prometheus/util/annotations"
-)
-
-// series is one time series with samples as parallel slices ordered by
-// timestamp. Deliberately not storage.NewListSeries: that boxes every sample
-// as an interface value, a per-sample allocation this fetch path exists to
-// avoid.
-type series struct {
-	lset labels.Labels
-	ts   []int64
-	vs   []float64
-}
-
-var _ storage.Series = (*series)(nil)
-
-func (s *series) Labels() labels.Labels {
-	return s.lset
-}
-
-func (s *series) Iterator(it chunkenc.Iterator) chunkenc.Iterator {
-	if fit, ok := it.(*floatIterator); ok {
-		fit.reset(s)
-		return fit
-	}
-	fit := &floatIterator{}
-	fit.reset(s)
-	return fit
-}
-
-// floatIterator implements chunkenc.Iterator over a series' sample slices.
-type floatIterator struct {
-	s *series
-	i int
-}
-
-var _ chunkenc.Iterator = (*floatIterator)(nil)
-
-func (it *floatIterator) reset(s *series) {
-	it.s = s
-	it.i = -1
-}
-
-func (it *floatIterator) Next() chunkenc.ValueType {
-	it.i++
-	if it.i >= len(it.s.ts) {
-		return chunkenc.ValNone
-	}
-	return chunkenc.ValFloat
-}
-
-func (it *floatIterator) Seek(t int64) chunkenc.ValueType { //nolint:govet // stdmethods flags io.Seeker; this is chunkenc.Iterator's Seek
-	if it.i < 0 {
-		it.i = 0
-	}
-	if it.i >= len(it.s.ts) {
-		return chunkenc.ValNone
-	}
-	// The current position, once valid, must not move backwards.
-	if it.s.ts[it.i] >= t {
-		return chunkenc.ValFloat
-	}
-	it.i += sort.Search(len(it.s.ts)-it.i, func(j int) bool {
-		return it.s.ts[it.i+j] >= t
-	})
-	if it.i >= len(it.s.ts) {
-		return chunkenc.ValNone
-	}
-	return chunkenc.ValFloat
-}
-
-func (it *floatIterator) At() (int64, float64) {
-	return it.s.ts[it.i], it.s.vs[it.i]
-}
-
-func (it *floatIterator) AtHistogram(*histogram.Histogram) (int64, *histogram.Histogram) {
-	return 0, nil
-}
-
-func (it *floatIterator) AtFloatHistogram(*histogram.FloatHistogram) (int64, *histogram.FloatHistogram) {
-	return 0, nil
-}
-
-func (it *floatIterator) AtT() int64 {
-	return it.s.ts[it.i]
-}
-
-// AtST returns the current start timestamp; not tracked by this storage.
-func (it *floatIterator) AtST() int64 {
-	return 0
-}
-
-func (it *floatIterator) Err() error {
-	return nil
-}
-
-// seriesSet iterates a fully materialized, label-sorted list of series.
-type seriesSet struct {
-	series []*series
-	i      int
-}
-
-var _ storage.SeriesSet = (*seriesSet)(nil)
-
-func newSeriesSet(list []*series) *seriesSet {
-	return &seriesSet{series: list, i: -1}
-}
-
-func (s *seriesSet) Next() bool {
-	s.i++
-	return s.i < len(s.series)
-}
-
-func (s *seriesSet) At() storage.Series {
-	return s.series[s.i]
-}
-
-func (s *seriesSet) Err() error {
-	return nil
-}
-
-func (s *seriesSet) Warnings() annotations.Annotations {
-	return nil
-}
-
-// sortAndMerge orders series by label set and merges identical label sets
-// by timestamp (first sample wins ties): distinct fingerprints can carry
-// identical label sets, and the engine assumes storages never emit
-// duplicates.
-func sortAndMerge(list []*series) []*series {
-	if len(list) < 2 {
-		return list
-	}
-	sort.Slice(list, func(i, j int) bool {
-		return labels.Compare(list[i].lset, list[j].lset) < 0
-	})
-	out := list[:1]
-	for _, s := range list[1:] {
-		last := out[len(out)-1]
-		if labels.Compare(last.lset, s.lset) != 0 {
-			out = append(out, s)
-			continue
-		}
-		merged := mergeSamples(last, s)
-		out[len(out)-1] = merged
-	}
-	return out
-}
-
-func mergeSamples(a, b *series) *series {
-	ts := make([]int64, 0, len(a.ts)+len(b.ts))
-	vs := make([]float64, 0, len(a.ts)+len(b.ts))
-	i, j := 0, 0
-	for i < len(a.ts) && j < len(b.ts) {
-		switch {
-		case a.ts[i] < b.ts[j]:
-			ts = append(ts, a.ts[i])
-			vs = append(vs, a.vs[i])
-			i++
-		case a.ts[i] > b.ts[j]:
-			ts = append(ts, b.ts[j])
-			vs = append(vs, b.vs[j])
-			j++
-		default:
-			ts = append(ts, a.ts[i])
-			vs = append(vs, a.vs[i])
-			i++
-			j++
-		}
-	}
-	ts = append(ts, a.ts[i:]...)
-	vs = append(vs, a.vs[i:]...)
-	ts = append(ts, b.ts[j:]...)
-	vs = append(vs, b.vs[j:]...)
-	return &series{lset: a.lset, ts: ts, vs: vs}
-}

pkg/prometheus/clickhouseprometheusv2/sql.go

@@ -1,164 +0,0 @@
-package clickhouseprometheusv2
-
-import (
-	"fmt"
-
-	"github.com/SigNoz/signoz/pkg/errors"
-	"github.com/huandu/go-sqlbuilder"
-	"github.com/prometheus/prometheus/model/labels"
-)
-
-// buildSeriesQuery renders the series lookup: one row per matched fingerprint
-// with its labels.
-func buildSeriesQuery(start, end int64, matchers []*labels.Matcher) (string, []any, error) {
-	adjustedStart, table := timeSeriesTableFor(start, end)
-	sb := sqlbuilder.NewSelectBuilder()
-	sb.Select("fingerprint", "any(labels)")
-	sb.From(fmt.Sprintf("%s.%s", databaseName, table))
-	if err := applySeriesConditions(sb, adjustedStart, end, matchers); err != nil {
-		return "", nil, err
-	}
-	sb.GroupBy("fingerprint")
-	query, args := sb.BuildWithFlavor(sqlbuilder.ClickHouse)
-	return query, args, nil
-}
-
-// buildSamplesQuery renders the samples fetch for the matched series: a
-// semi-join re-runs the series predicates against the shard-local series
-// table (complete by fingerprint co-locality, see localTimeSeriesTable — a
-// GLOBAL broadcast would ship the matched set to every shard, and ClickHouse
-// materializes the subquery's set per shard before the scan, so it still
-// engages the fingerprint primary-key column). metricNames (observed on the
-// matched series when the selector had no __name__ equality) narrows the
-// primary-key scan. A non-nil lastPerStep groups to the last sample per
-// step bucket.
-func buildSamplesQuery(start, end int64, metricNames []string, matchers []*labels.Matcher, lastPerStep *lastSamplePerStep) (string, []any, error) {
-	sb := sqlbuilder.NewSelectBuilder()
-	if lastPerStep != nil {
-		// Aliases must not shadow source columns: ClickHouse resolves aliases
-		// in WHERE too, and "max(unix_milli) AS unix_milli" would put an
-		// aggregate into the WHERE clause (error 184).
-		sb.Select("fingerprint", "max(unix_milli) AS ts", "argMax(value, unix_milli) AS val", "argMax(flags, unix_milli) AS fl")
-	} else {
-		sb.Select("fingerprint", "unix_milli", "value", "flags")
-	}
-	sb.From(fmt.Sprintf("%s.%s", databaseName, distributedSamplesV4))
-
-	switch len(metricNames) {
-	case 0:
-		// No name constraint derivable; the primary-key prefix goes unused.
-	case 1:
-		sb.Where(sb.EQ("metric_name", metricNames[0]))
-	default:
-		sb.Where(sb.In("metric_name", sqlbuilder.List(metricNames)))
-	}
-	// Semantically redundant (the fingerprints already come from these
-	// temporalities) but engages the leading primary-key column.
-	sb.Where("temporality IN ['Cumulative', 'Unspecified']")
-	sub := sqlbuilder.NewSelectBuilder()
-	sub.Select("fingerprint")
-	adjustedStart, table := timeSeriesTableFor(start, end)
-	sub.From(fmt.Sprintf("%s.%s", databaseName, localTimeSeriesTable(table)))
-	if err := applySeriesConditions(sub, adjustedStart, end, matchers); err != nil {
-		return "", nil, err
-	}
-	sb.Where(sb.In("fingerprint", sub))
-	sb.Where(sb.GTE("unix_milli", start), sb.LTE("unix_milli", end))
-
-	if lastPerStep != nil {
-		sb.GroupBy("fingerprint")
-		if expr := lastPerStep.bucketExpr(); expr != "" {
-			sb.GroupBy(expr)
-		}
-		sb.OrderBy("fingerprint", "ts")
-	} else {
-		sb.OrderBy("fingerprint", "unix_milli")
-	}
-
-	query, args := sb.BuildWithFlavor(sqlbuilder.ClickHouse)
-	return query, args, nil
-}
-
-// applySeriesConditions adds the WHERE conditions of a series table scan:
-// __name__ matchers (all four types) translate to the metric_name column,
-// every other matcher to a JSONExtractString condition on the labels column.
-// An equality matcher against "" matches series without the label, mirroring
-// PromQL, because JSONExtractString returns "" for missing keys. Regexes are
-// anchored: PromQL matchers match the whole value, ClickHouse match()
-// searches for a substring.
-func applySeriesConditions(sb *sqlbuilder.SelectBuilder, start, end int64, matchers []*labels.Matcher) error {
-	for _, m := range matchers {
-		if m.Name != metricNameLabel {
-			continue
-		}
-		switch m.Type {
-		case labels.MatchEqual:
-			sb.Where(sb.EQ("metric_name", m.Value))
-		case labels.MatchNotEqual:
-			sb.Where(sb.NE("metric_name", m.Value))
-		case labels.MatchRegexp:
-			sb.Where(fmt.Sprintf("match(metric_name, %s)", sb.Var(anchorRegex(m.Value))))
-		case labels.MatchNotRegexp:
-			sb.Where(fmt.Sprintf("NOT match(metric_name, %s)", sb.Var(anchorRegex(m.Value))))
-		default:
-			return errors.NewInvalidInputf(errors.CodeInvalidInput, "unsupported matcher type %q for __name__", m.Type)
-		}
-	}
-
-	sb.Where("temporality IN ['Cumulative', 'Unspecified']")
-	// Inclusive upper bound: registration rows are hour-floored (and 6h/1d/1w
-	// for the rollup tables) by the exporter, so a series first registered in
-	// the bucket starting exactly at `end` would otherwise be invisible while
-	// its samples (<= end) are in range.
-	sb.Where(sb.GTE("unix_milli", start), sb.LTE("unix_milli", end))
-
-	for _, m := range matchers {
-		if m.Name == metricNameLabel {
-			continue
-		}
-		switch m.Type {
-		case labels.MatchEqual:
-			sb.Where(fmt.Sprintf("JSONExtractString(labels, %s) = %s", sb.Var(m.Name), sb.Var(m.Value)))
-		case labels.MatchNotEqual:
-			sb.Where(fmt.Sprintf("JSONExtractString(labels, %s) != %s", sb.Var(m.Name), sb.Var(m.Value)))
-		case labels.MatchRegexp:
-			sb.Where(fmt.Sprintf("match(JSONExtractString(labels, %s), %s)", sb.Var(m.Name), sb.Var(anchorRegex(m.Value))))
-		case labels.MatchNotRegexp:
-			sb.Where(fmt.Sprintf("NOT match(JSONExtractString(labels, %s), %s)", sb.Var(m.Name), sb.Var(anchorRegex(m.Value))))
-		default:
-			return errors.NewInvalidInputf(errors.CodeInvalidInput, "unsupported matcher type %q", m.Type)
-		}
-	}
-
-	return nil
-}
-
-// anchorRegex turns a PromQL regex into its fully-anchored form (see
-// applySeriesConditions).
-func anchorRegex(v string) string {
-	return "^(?:" + v + ")$"
-}
-
-// lastSamplePerStep reduces an instant-selector fetch to the last sample of
-// each step bucket: bucket 0 is (start, firstEval], bucket i is
-// (firstEval+(i-1)·step, firstEval+i·step]. Anchoring buckets at the first
-// evaluation timestamp makes every bucket boundary an evaluation timestamp,
-// so a non-final sample of a bucket can never be the latest sample in any
-// (t-lookback, t] the engine resolves — the reduction is lossless. Real
-// timestamps are preserved, so the engine's own lookback and staleness
-// handling remain exact.
-type lastSamplePerStep struct {
-	firstEvalMs int64
-	stepMs      int64
-}
-
-func (t *lastSamplePerStep) bucketExpr() string {
-	if t.stepMs <= 0 {
-		// Instant query: a single evaluation at firstEval; one bucket.
-		return ""
-	}
-	return fmt.Sprintf(
-		"if(unix_milli <= %d, 0, intDiv(unix_milli - %d - 1, %d) + 1)",
-		t.firstEvalMs, t.firstEvalMs, t.stepMs,
-	)
-}

pkg/prometheus/clickhouseprometheusv2/sql_test.go

@@ -1,139 +0,0 @@
-package clickhouseprometheusv2
-
-import (
-	"testing"
-	"time"
-
-	"github.com/prometheus/prometheus/model/labels"
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-)
-
-func mustMatcher(t *testing.T, mt labels.MatchType, name, value string) *labels.Matcher {
-	t.Helper()
-	m, err := labels.NewMatcher(mt, name, value)
-	require.NoError(t, err)
-	return m
-}
-
-func TestTimeSeriesTableFor(t *testing.T) {
-	base := time.Date(2026, 7, 10, 3, 27, 0, 0, time.UTC).UnixMilli()
-
-	tests := []struct {
-		name      string
-		span      time.Duration
-		wantTable string
-		roundTo   time.Duration
-	}{
-		{"under 6h uses hourly table", 2 * time.Hour, distributedTimeSeriesV4, time.Hour},
-		{"under 1d uses 6h table", 12 * time.Hour, distributedTimeSeriesV46hrs, 6 * time.Hour},
-		{"under 1w uses 1d table", 3 * 24 * time.Hour, distributedTimeSeriesV41day, 24 * time.Hour},
-		{"over 1w uses 1w table", 10 * 24 * time.Hour, distributedTimeSeriesV41week, 7 * 24 * time.Hour},
-	}
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			start, table := timeSeriesTableFor(base, base+tt.span.Milliseconds())
-			assert.Equal(t, tt.wantTable, table)
-			assert.Zero(t, start%tt.roundTo.Milliseconds())
-			assert.LessOrEqual(t, start, base)
-		})
-	}
-}
-
-func TestBuildSeriesQuery(t *testing.T) {
-	start := int64(1_700_000_000_000)
-	end := start + time.Hour.Milliseconds()
-	// The series table window rounds down to the table's bucket boundary.
-	adjustedStart := start - (start % time.Hour.Milliseconds())
-
-	t.Run("equality name and label matchers", func(t *testing.T) {
-		query, args, err := buildSeriesQuery(start, end, []*labels.Matcher{
-			mustMatcher(t, labels.MatchEqual, "__name__", "http_requests_total"),
-			mustMatcher(t, labels.MatchEqual, "job", "api"),
-		})
-		require.NoError(t, err)
-		assert.Equal(t,
-			"SELECT fingerprint, any(labels) FROM signoz_metrics.distributed_time_series_v4 WHERE metric_name = ? AND temporality IN ['Cumulative', 'Unspecified'] AND unix_milli >= ? AND unix_milli <= ? AND JSONExtractString(labels, ?) = ? GROUP BY fingerprint",
-			query,
-		)
-		assert.Equal(t, []any{"http_requests_total", adjustedStart, end, "job", "api"}, args)
-	})
-
-	t.Run("regex matchers are anchored", func(t *testing.T) {
-		_, args, err := buildSeriesQuery(start, end, []*labels.Matcher{
-			mustMatcher(t, labels.MatchEqual, "__name__", "up"),
-			mustMatcher(t, labels.MatchRegexp, "instance", "prod.*"),
-			mustMatcher(t, labels.MatchNotRegexp, "env", "dev|test"),
-		})
-		require.NoError(t, err)
-		assert.Equal(t, []any{"up", adjustedStart, end, "instance", "^(?:prod.*)$", "env", "^(?:dev|test)$"}, args)
-	})
-
-	t.Run("regex name matcher uses metric_name column", func(t *testing.T) {
-		query, args, err := buildSeriesQuery(start, end, []*labels.Matcher{
-			mustMatcher(t, labels.MatchRegexp, "__name__", "node_cpu.*|node_memory.*"),
-		})
-		require.NoError(t, err)
-		assert.Contains(t, query, "match(metric_name, ?)")
-		assert.NotContains(t, query, "JSONExtractString")
-		assert.Equal(t, []any{"^(?:node_cpu.*|node_memory.*)$", adjustedStart, end}, args)
-	})
-
-	t.Run("no name matcher omits metric_name condition", func(t *testing.T) {
-		query, _, err := buildSeriesQuery(start, end, []*labels.Matcher{
-			mustMatcher(t, labels.MatchEqual, "job", "api"),
-		})
-		require.NoError(t, err)
-		assert.NotContains(t, query, "metric_name")
-	})
-}
-
-func TestBuildSamplesQuery(t *testing.T) {
-	start := int64(1_700_000_000_000)
-	end := start + time.Hour.Milliseconds()
-	adjustedStart := start - (start % time.Hour.Milliseconds())
-	matchers := []*labels.Matcher{
-		mustMatcher(t, labels.MatchEqual, "__name__", "up"),
-		mustMatcher(t, labels.MatchEqual, "job", "api"),
-	}
-
-	t.Run("raw fetch filters by a shard-local semi-join", func(t *testing.T) {
-		query, args, err := buildSamplesQuery(start, end, []string{"up"}, matchers, nil)
-		require.NoError(t, err)
-		assert.Contains(t, query, "fingerprint IN (SELECT fingerprint FROM signoz_metrics.time_series_v4 WHERE ")
-		assert.NotContains(t, query, "GLOBAL IN")
-		assert.Contains(t, query, "ORDER BY fingerprint, unix_milli")
-		// Args follow placeholder order: samples metric name, the semi-join's
-		// series predicates, then the samples window bounds.
-		assert.Equal(t, []any{"up", "up", adjustedStart, end, "job", "api", start, end}, args)
-	})
-
-	t.Run("last-sample-per-step groups by step bucket anchored at first eval", func(t *testing.T) {
-		lastPerStep := &lastSamplePerStep{firstEvalMs: start + 299_999, stepMs: 60_000}
-		query, _, err := buildSamplesQuery(start, end, []string{"up"}, matchers, lastPerStep)
-		require.NoError(t, err)
-		assert.Contains(t, query, "argMax(value, unix_milli) AS val")
-		assert.Contains(t, query, "argMax(flags, unix_milli) AS fl")
-		assert.Contains(t, query, "GROUP BY fingerprint, if(unix_milli <= 1700000299999, 0, intDiv(unix_milli - 1700000299999 - 1, 60000) + 1)")
-		assert.Contains(t, query, "ORDER BY fingerprint, ts")
-		// Aliases must not shadow the source columns referenced in WHERE.
-		assert.NotContains(t, query, "AS unix_milli")
-		assert.NotContains(t, query, "AS value")
-		assert.NotContains(t, query, "AS flags")
-	})
-
-	t.Run("instant query keeps one bucket", func(t *testing.T) {
-		lastPerStep := &lastSamplePerStep{firstEvalMs: end, stepMs: 0}
-		query, _, err := buildSamplesQuery(start, end, []string{"up"}, matchers, lastPerStep)
-		require.NoError(t, err)
-		assert.Contains(t, query, "GROUP BY fingerprint ORDER BY fingerprint, ts")
-		assert.NotContains(t, query, "intDiv")
-	})
-
-	t.Run("multiple metric names from regex selector", func(t *testing.T) {
-		query, args, err := buildSamplesQuery(start, end, []string{"node_cpu", "node_memory"}, matchers, nil)
-		require.NoError(t, err)
-		assert.Contains(t, query, "metric_name IN (?, ?)")
-		assert.Equal(t, []any{"node_cpu", "node_memory", "up", adjustedStart, end, "job", "api", start, end}, args)
-	})
-}

pkg/prometheus/clickhouseprometheusv2/tables.go

@@ -1,70 +0,0 @@
-package clickhouseprometheusv2
-
-import "time"
-
-// TODO(srikanthccv): consolidate the metrics table names and the
-// window-to-table selection across the query builders (telemetrymetrics)
-// and the prometheus providers instead of each package carrying its own
-// copy.
-
-const (
-	// metricNameLabel is the reserved PromQL label holding the metric name.
-	metricNameLabel string = "__name__"
-
-	databaseName                 string = "signoz_metrics"
-	distributedTimeSeriesV4      string = "distributed_time_series_v4"
-	distributedTimeSeriesV46hrs  string = "distributed_time_series_v4_6hrs"
-	distributedTimeSeriesV41day  string = "distributed_time_series_v4_1day"
-	distributedTimeSeriesV41week string = "distributed_time_series_v4_1week"
-	distributedSamplesV4         string = "distributed_samples_v4"
-
-	localTimeSeriesV4      string = "time_series_v4"
-	localTimeSeriesV46hrs  string = "time_series_v4_6hrs"
-	localTimeSeriesV41day  string = "time_series_v4_1day"
-	localTimeSeriesV41week string = "time_series_v4_1week"
-)
-
-// localTimeSeriesTable maps a distributed time series table to its shard-local
-// table. Samples and time series shard on the same key
-// (cityHash64(env, temporality, metric_name, fingerprint)), so a query whose
-// top-level FROM is the distributed samples table can join or semi-join the
-// local time series table inside each shard: the shard rewrite runs the
-// subquery against the shard's own series rows, which are exactly the series
-// of the shard's samples. No broadcast, no initiator-side join.
-func localTimeSeriesTable(distributed string) string {
-	switch distributed {
-	case distributedTimeSeriesV46hrs:
-		return localTimeSeriesV46hrs
-	case distributedTimeSeriesV41day:
-		return localTimeSeriesV41day
-	case distributedTimeSeriesV41week:
-		return localTimeSeriesV41week
-	default:
-		return localTimeSeriesV4
-	}
-}
-
-var (
-	oneHourInMilliseconds  = time.Hour.Milliseconds()
-	sixHoursInMilliseconds = time.Hour.Milliseconds() * 6
-	oneDayInMilliseconds   = time.Hour.Milliseconds() * 24
-	oneWeekInMilliseconds  = time.Hour.Milliseconds() * 24 * 7
-)
-
-// timeSeriesTableFor returns the adjusted start and the time series table for
-// the window. Time series tables hold one row per (fingerprint, bucket), with
-// bucket granularities of 1h, 6h, 1d and 1w; the start is rounded down to the
-// bucket boundary so a window beginning mid-bucket still matches the bucket's
-// row.
-func timeSeriesTableFor(start, end int64) (int64, string) {
-	switch {
-	case end-start < sixHoursInMilliseconds:
-		return start - (start % oneHourInMilliseconds), distributedTimeSeriesV4
-	case end-start < oneDayInMilliseconds:
-		return start - (start % sixHoursInMilliseconds), distributedTimeSeriesV46hrs
-	case end-start < oneWeekInMilliseconds:
-		return start - (start % oneDayInMilliseconds), distributedTimeSeriesV41day
-	default:
-		return start - (start % oneWeekInMilliseconds), distributedTimeSeriesV41week
-	}
-}

pkg/prometheus/clickhouseprometheusv2/transpiler.go

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

pkg/prometheus/clickhouseprometheusv2/transpiler_corpus_test.go

@@ -1,161 +0,0 @@
-package clickhouseprometheusv2
-
-import (
-	"bufio"
-	"encoding/json"
-	"fmt"
-	"os"
-	"regexp"
-	"sort"
-	"strings"
-	"testing"
-
-	"github.com/prometheus/prometheus/promql/parser"
-	"github.com/stretchr/testify/require"
-)
-
-// TestClassifyCorpus measures real-workload compiler coverage: it classifies
-// every query of a JSON-lines corpus (one JSON-encoded PromQL string per
-// line) with the live classifier and reports full / hybrid / fallback
-// shares. Skipped unless PROMQL_CORPUS points to one or more files
-// (comma-separated). Dashboard template variables are substituted with
-// placeholder values before parsing, mirroring the production render step.
-//
-//	PROMQL_CORPUS=corpus-a.jsonl,corpus-b.jsonl go test -run TestClassifyCorpus -v
-func TestClassifyCorpus(t *testing.T) {
-	corpus := os.Getenv("PROMQL_CORPUS")
-	if corpus == "" {
-		t.Skip("PROMQL_CORPUS not set")
-	}
-
-	varRe := regexp.MustCompile(`\{\{\s*\.?[\w.]+\s*\}\}|\[\[\s*[\w.]+\s*\]\]|\$[\w.]+`)
-	promParser := parser.NewParser(parser.Options{})
-
-	for _, path := range strings.Split(corpus, ",") {
-		f, err := os.Open(path)
-		require.NoError(t, err)
-
-		var full, hybrid, fallbackInstant, fallbackOther, parseErrs int
-		fallbackReasons := map[string]int{}
-
-		scanner := bufio.NewScanner(f)
-		scanner.Buffer(make([]byte, 1024*1024), 1024*1024)
-		for scanner.Scan() {
-			var query string
-			require.NoError(t, json.Unmarshal(scanner.Bytes(), &query))
-			query = varRe.ReplaceAllString(query, "placeholder")
-
-			expr, err := promParser.ParseExpr(query)
-			if err != nil {
-				parseErrs++
-				continue
-			}
-
-			plan, ok := classify(expr, gridContext{startMs: 1_700_000_000_000, endMs: 1_700_007_200_000, stepMs: 60_000})
-			switch {
-			case ok && plan.full:
-				full++
-			case ok:
-				hybrid++
-			default:
-				reason := fallbackShape(expr)
-				fallbackReasons[reason]++
-				if reason == "instant-selector shape (last-sample-per-step engine path)" {
-					fallbackInstant++
-				} else {
-					fallbackOther++
-				}
-			}
-		}
-		require.NoError(t, scanner.Err())
-		_ = f.Close()
-
-		total := full + hybrid + fallbackInstant + fallbackOther
-		if total == 0 {
-			t.Logf("%s: no parseable queries (%d parse errors)", path, parseErrs)
-			continue
-		}
-		t.Logf("%s: %d queries — full=%d (%.0f%%) hybrid=%d (%.0f%%) fallback=%d (%.0f%%; instant-shape=%d) parse_errors=%d",
-			path, total,
-			full, 100*float64(full)/float64(total),
-			hybrid, 100*float64(hybrid)/float64(total),
-			fallbackInstant+fallbackOther, 100*float64(fallbackInstant+fallbackOther)/float64(total),
-			fallbackInstant, parseErrs)
-
-		reasons := make([]string, 0, len(fallbackReasons))
-		for r := range fallbackReasons {
-			reasons = append(reasons, r)
-		}
-		sort.Slice(reasons, func(i, j int) bool { return fallbackReasons[reasons[i]] > fallbackReasons[reasons[j]] })
-		for _, r := range reasons {
-			t.Logf("  fallback %4d  %s", fallbackReasons[r], r)
-		}
-	}
-}
-
-// fallbackShape buckets a non-transpilable query by why it stays on the engine
-// path, to separate "already served well" (instant selectors on the last-sample-per-step
-// path) from genuine compiler gaps.
-func fallbackShape(expr parser.Expr) string {
-	var hasMatrix, hasSubquery, hasAt, hasDurationExpr, overTime bool
-	rangeFns := map[string]bool{"rate": true, "increase": true, "delta": true, "irate": true, "idelta": true}
-	var unsupportedFns []string
-	parser.Inspect(expr, func(node parser.Node, _ []parser.Node) error {
-		switch n := node.(type) {
-		case *parser.MatrixSelector:
-			hasMatrix = true
-			if n.RangeExpr != nil {
-				hasDurationExpr = true
-			}
-		case *parser.SubqueryExpr:
-			hasSubquery = true
-			if n.RangeExpr != nil || n.StepExpr != nil || n.OriginalOffsetExpr != nil {
-				hasDurationExpr = true
-			}
-		case *parser.VectorSelector:
-			if n.Timestamp != nil || n.StartOrEnd != 0 {
-				hasAt = true
-			}
-			if n.OriginalOffsetExpr != nil {
-				hasDurationExpr = true
-			}
-		case *parser.Call:
-			if strings.HasSuffix(n.Func.Name, "_over_time") {
-				overTime = true
-			} else if !rangeFns[n.Func.Name] {
-				unsupportedFns = append(unsupportedFns, n.Func.Name)
-			}
-		}
-		return nil
-	})
-
-	switch {
-	case hasDurationExpr:
-		return "duration expression (resolved only at evaluation time)"
-	case hasSubquery:
-		return "subquery"
-	case hasAt:
-		return "@ modifier"
-	case overTime:
-		return "*_over_time range function"
-	case !hasMatrix:
-		return "instant-selector shape (last-sample-per-step engine path)"
-	case len(unsupportedFns) > 0:
-		return fmt.Sprintf("range shape with unsupported function(s): %s", strings.Join(dedupe(unsupportedFns), ",")) //nolint:makezero
-	default:
-		return "other range shape"
-	}
-}
-
-func dedupe(in []string) []string {
-	seen := map[string]bool{}
-	var out []string
-	for _, s := range in {
-		if !seen[s] {
-			seen[s] = true
-			out = append(out, s)
-		}
-	}
-	sort.Strings(out)
-	return out
-}

pkg/prometheus/clickhouseprometheusv2/transpiler_exec.go

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

pkg/prometheus/clickhouseprometheusv2/transpiler_sql.go

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

pkg/prometheus/clickhouseprometheusv2/transpiler_test.go

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

pkg/prometheus/config.go

@@ -24,10 +24,6 @@ type Config struct {
 
 	// Timeout is the maximum time a query is allowed to run before being aborted.
 	Timeout time.Duration `mapstructure:"timeout"`
-
-	// ProviderName selects the storage provider: "clickhouse" (default) or
-	// "clickhousev2".
-	ProviderName string `mapstructure:"provider"`
 }
 
 func NewConfigFactory() factory.ConfigFactory {
@@ -41,8 +37,7 @@ func newConfig() factory.Config {
 			Path:          "",
 			MaxConcurrent: 20,
 		},
-		Timeout:      2 * time.Minute,
-		ProviderName: "clickhouse",
+		Timeout: 2 * time.Minute,
 	}
 }
 
@@ -50,15 +45,9 @@ func (c Config) Validate() error {
 	if c.Timeout <= 0 {
 		return errors.Newf(errors.TypeInvalidInput, errors.CodeInvalidInput, "prometheus::timeout must be greater than 0")
 	}
-	if c.ProviderName != "" && c.ProviderName != "clickhouse" && c.ProviderName != "clickhousev2" {
-		return errors.Newf(errors.TypeInvalidInput, errors.CodeInvalidInput, "prometheus::provider must be one of [clickhouse, clickhousev2], got %q", c.ProviderName)
-	}
 	return nil
 }
 
 func (c Config) Provider() string {
-	if c.ProviderName == "" {
-		return "clickhouse"
-	}
-	return c.ProviderName
+	return "clickhouse"
 }

pkg/prometheus/promapi/handler.go

@@ -1,233 +0,0 @@
-// Package promapi serves the Prometheus HTTP query API over a
-// prometheus.Prometheus provider: /query and /query_range in the shape of
-// Prometheus' /api/v1 endpoints (https://prometheus.io/docs/prometheus/latest/querying/api/),
-// intended to be mounted under a distinguishing prefix (/prometheus/api/v1)
-// so PromQL-only endpoints are separate from the SigNoz query APIs. The
-// request and response contracts follow Prometheus: form-encoded GET/POST
-// params, {"status":"success","data":{resultType,result}} on success and
-// {"status":"error","errorType","error"} with Prometheus' status codes on
-// failure — so Prometheus-compatible clients can point at the prefix.
-package promapi
-
-import (
-	"context"
-	"encoding/json"
-	"log/slog"
-	"math"
-	"net/http"
-	"strconv"
-	"time"
-
-	promModel "github.com/prometheus/common/model"
-	"github.com/prometheus/prometheus/promql"
-	"github.com/prometheus/prometheus/promql/parser"
-	"github.com/prometheus/prometheus/util/stats"
-
-	"github.com/SigNoz/signoz/pkg/errors"
-	"github.com/SigNoz/signoz/pkg/prometheus"
-)
-
-// Handler serves the Prometheus query API over the configured provider.
-type Handler struct {
-	logger *slog.Logger
-	prom   prometheus.Prometheus
-}
-
-func NewHandler(logger *slog.Logger, prom prometheus.Prometheus) *Handler {
-	return &Handler{logger: logger, prom: prom}
-}
-
-type errorType string
-
-const (
-	errBadData  errorType = "bad_data"
-	errExec     errorType = "execution"
-	errCanceled errorType = "canceled"
-	errTimeout  errorType = "timeout"
-	errInternal errorType = "internal"
-)
-
-type queryData struct {
-	ResultType parser.ValueType  `json:"resultType"`
-	Result     parser.Value      `json:"result"`
-	Stats      stats.QueryStats  `json:"stats,omitempty"`
-}
-
-type response struct {
-	Status    string     `json:"status"`
-	Data      *queryData `json:"data,omitempty"`
-	ErrorType errorType  `json:"errorType,omitempty"`
-	Error     string     `json:"error,omitempty"`
-}
-
-// QueryRange evaluates an expression over a grid: query, start, end, step,
-// and optional timeout/stats params, all in Prometheus' formats.
-func (h *Handler) QueryRange(w http.ResponseWriter, r *http.Request) {
-	start, err := parseTime(r.FormValue("start"))
-	if err != nil {
-		h.respondError(r.Context(), w, errBadData, err)
-		return
-	}
-	end, err := parseTime(r.FormValue("end"))
-	if err != nil {
-		h.respondError(r.Context(), w, errBadData, err)
-		return
-	}
-	if end.Before(start) {
-		h.respondError(r.Context(), w, errBadData, errors.NewInvalidInputf(errors.CodeInvalidInput, "end timestamp must not be before start time"))
-		return
-	}
-	step, err := parseDuration(r.FormValue("step"))
-	if err != nil {
-		h.respondError(r.Context(), w, errBadData, err)
-		return
-	}
-	if step <= 0 {
-		h.respondError(r.Context(), w, errBadData, errors.NewInvalidInputf(errors.CodeInvalidInput, "zero or negative query resolution step widths are not accepted. Try a positive integer"))
-		return
-	}
-	// The engine materializes every point of every series; an unbounded
-	// grid is an unbounded allocation. 11,000 points covers 60s resolution
-	// for a week or 1h resolution for a year.
-	if end.Sub(start)/step > 11000 {
-		h.respondError(r.Context(), w, errBadData, errors.NewInvalidInputf(errors.CodeInvalidInput, "exceeded maximum resolution of 11,000 points per timeseries. Try decreasing the query resolution (?step=XX)"))
-		return
-	}
-
-	ctx, cancel, err := h.contextWithTimeout(r)
-	if err != nil {
-		h.respondError(r.Context(), w, errBadData, err)
-		return
-	}
-	defer cancel()
-
-	qry, err := h.prom.Engine().NewRangeQuery(ctx, h.prom.Storage(), nil, r.FormValue("query"), start, end, step)
-	if err != nil {
-		h.respondError(r.Context(), w, errBadData, err)
-		return
-	}
-	h.exec(ctx, w, r, qry)
-}
-
-// Query evaluates an expression at a single instant: query and optional
-// time/timeout/stats params. A missing time evaluates at the server's now,
-// as in Prometheus.
-func (h *Handler) Query(w http.ResponseWriter, r *http.Request) {
-	ts := time.Now()
-	if t := r.FormValue("time"); t != "" {
-		var err error
-		ts, err = parseTime(t)
-		if err != nil {
-			h.respondError(r.Context(), w, errBadData, err)
-			return
-		}
-	}
-
-	ctx, cancel, err := h.contextWithTimeout(r)
-	if err != nil {
-		h.respondError(r.Context(), w, errBadData, err)
-		return
-	}
-	defer cancel()
-
-	qry, err := h.prom.Engine().NewInstantQuery(ctx, h.prom.Storage(), nil, r.FormValue("query"), ts)
-	if err != nil {
-		h.respondError(r.Context(), w, errBadData, err)
-		return
-	}
-	h.exec(ctx, w, r, qry)
-}
-
-func (h *Handler) exec(ctx context.Context, w http.ResponseWriter, r *http.Request, qry promql.Query) {
-	defer qry.Close()
-	res := qry.Exec(ctx)
-	if res.Err != nil {
-		h.logger.ErrorContext(ctx, "error evaluating promql query", errors.Attr(res.Err))
-		switch res.Err.(type) {
-		case promql.ErrQueryCanceled:
-			h.respondError(ctx, w, errCanceled, res.Err)
-		case promql.ErrQueryTimeout:
-			h.respondError(ctx, w, errTimeout, res.Err)
-		case promql.ErrStorage:
-			h.respondError(ctx, w, errInternal, res.Err)
-		default:
-			h.respondError(ctx, w, errExec, res.Err)
-		}
-		return
-	}
-
-	data := &queryData{ResultType: res.Value.Type(), Result: res.Value}
-	if r.FormValue("stats") != "" {
-		data.Stats = stats.NewQueryStats(qry.Stats())
-	}
-	h.respond(ctx, w, data)
-}
-
-func (h *Handler) contextWithTimeout(r *http.Request) (context.Context, context.CancelFunc, error) {
-	ctx := r.Context()
-	if to := r.FormValue("timeout"); to != "" {
-		timeout, err := parseDuration(to)
-		if err != nil {
-			return nil, nil, err
-		}
-		ctx, cancel := context.WithTimeout(ctx, timeout)
-		return ctx, cancel, nil
-	}
-	ctx, cancel := context.WithCancel(ctx)
-	return ctx, cancel, nil
-}
-
-func (h *Handler) respond(ctx context.Context, w http.ResponseWriter, data *queryData) {
-	w.Header().Set("Content-Type", "application/json")
-	w.WriteHeader(http.StatusOK)
-	if err := json.NewEncoder(w).Encode(&response{Status: "success", Data: data}); err != nil {
-		h.logger.ErrorContext(ctx, "error writing prometheus api response", errors.Attr(err))
-	}
-}
-
-// respondError follows Prometheus' status-code mapping: bad_data 400,
-// execution 422, canceled/timeout 503, internal 500.
-func (h *Handler) respondError(ctx context.Context, w http.ResponseWriter, typ errorType, err error) {
-	code := http.StatusInternalServerError
-	switch typ {
-	case errBadData:
-		code = http.StatusBadRequest
-	case errExec:
-		code = http.StatusUnprocessableEntity
-	case errCanceled, errTimeout:
-		code = http.StatusServiceUnavailable
-	}
-	w.Header().Set("Content-Type", "application/json")
-	w.WriteHeader(code)
-	if encErr := json.NewEncoder(w).Encode(&response{Status: "error", ErrorType: typ, Error: err.Error()}); encErr != nil {
-		h.logger.ErrorContext(ctx, "error writing prometheus api error response", errors.Attr(encErr))
-	}
-}
-
-// parseTime accepts Prometheus' time formats: float unix seconds or RFC3339.
-func parseTime(s string) (time.Time, error) {
-	if t, err := strconv.ParseFloat(s, 64); err == nil {
-		sec, ns := math.Modf(t)
-		return time.Unix(int64(sec), int64(ns*float64(time.Second))), nil
-	}
-	if t, err := time.Parse(time.RFC3339Nano, s); err == nil {
-		return t, nil
-	}
-	return time.Time{}, errors.NewInvalidInputf(errors.CodeInvalidInput, "cannot parse %q to a valid timestamp", s)
-}
-
-// parseDuration accepts Prometheus' duration formats: float seconds or a
-// duration string like 5m.
-func parseDuration(s string) (time.Duration, error) {
-	if d, err := strconv.ParseFloat(s, 64); err == nil {
-		ts := d * float64(time.Second)
-		if ts > float64(math.MaxInt64) || ts < float64(math.MinInt64) {
-			return 0, errors.NewInvalidInputf(errors.CodeInvalidInput, "cannot parse %q to a valid duration. It overflows int64", s)
-		}
-		return time.Duration(ts), nil
-	}
-	if d, err := promModel.ParseDuration(s); err == nil {
-		return time.Duration(d), nil
-	}
-	return 0, errors.NewInvalidInputf(errors.CodeInvalidInput, "cannot parse %q to a valid duration", s)
-}

pkg/prometheus/prometheus.go

@@ -35,9 +35,3 @@ type StatementRecorder interface {
 type StatementCapturer interface {
 	CapturingStorage() (storage.Queryable, StatementRecorder)
 }
-
-// ProviderClickhouseV2 is the clickhousev2 provider name: the factory
-// registration, the prometheus::provider config value and the
-// X-SigNoz-PromQL-Provider request header all use it, so they cannot drift
-// apart.
-const ProviderClickhouseV2 = "clickhousev2"

pkg/prometheus/traits.go

@@ -1,49 +0,0 @@
-package prometheus
-
-import (
-	"context"
-
-	"github.com/prometheus/prometheus/promql/parser"
-)
-
-type queryTraitsKey struct{}
-
-// QueryTraits carries per-query facts a storage implementation cannot derive
-// from SelectHints alone. Call sites that parse the PromQL expression attach
-// traits to the context before handing it to the engine; storages treat a
-// missing traits value as "unknown" and stay conservative.
-type QueryTraits struct {
-	// SubqueryFree is true when the query contains no subquery expression.
-	// Subquery selectors are evaluated at the subquery's own step, but
-	// SelectHints.Step always carries the top-level step, so step-aligned
-	// storage optimizations (e.g. keeping only the last sample per step
-	// bucket) are safe only when this is true.
-	SubqueryFree bool
-}
-
-// DetectQueryTraits derives QueryTraits from a parsed PromQL expression.
-func DetectQueryTraits(expr parser.Expr) QueryTraits {
-	subqueryFree := true
-	parser.Inspect(expr, func(node parser.Node, _ []parser.Node) error {
-		if _, ok := node.(*parser.SubqueryExpr); ok {
-			subqueryFree = false
-		}
-		return nil
-	})
-	return QueryTraits{SubqueryFree: subqueryFree}
-}
-
-// NewContextWithQueryTraits returns a context carrying the given traits.
-func NewContextWithQueryTraits(ctx context.Context, traits QueryTraits) context.Context {
-	return context.WithValue(ctx, queryTraitsKey{}, traits)
-}
-
-// QueryTraitsFromContext returns the traits attached to ctx, if any.
-//
-// Context is used here, unlike for backend selection, because traits must
-// cross the promql engine to reach storage.Querier.Select, and the engine's
-// interfaces offer no other channel; the alternative is a Prometheus fork.
-func QueryTraitsFromContext(ctx context.Context) (QueryTraits, bool) {
-	traits, ok := ctx.Value(queryTraitsKey{}).(QueryTraits)
-	return traits, ok
-}

pkg/querier/api.go

@@ -22,6 +22,13 @@ import (
 	"github.com/SigNoz/signoz/pkg/variables"
 )
 
+type Handler interface {
+	QueryRange(rw http.ResponseWriter, req *http.Request)
+	QueryRangePreview(rw http.ResponseWriter, req *http.Request)
+	QueryRawStream(rw http.ResponseWriter, req *http.Request)
+	ReplaceVariables(rw http.ResponseWriter, req *http.Request)
+}
+
 type handler struct {
 	set       factory.ProviderSettings
 	analytics analytics.Analytics
@@ -50,7 +57,6 @@ func (handler *handler) QueryRange(rw http.ResponseWriter, req *http.Request) {
 		render.Error(rw, err)
 		return
 	}
-	queryRangeRequest.PromQLProvider = req.Header.Get("X-SigNoz-PromQL-Provider")
 
 	// Validate the query request
 	if err := queryRangeRequest.Validate(); err != nil {

pkg/querier/bucket_cache.go

@@ -15,6 +15,14 @@ import (
 	"github.com/SigNoz/signoz/pkg/valuer"
 )
 
+// BucketCache is the interface for bucket-based caching.
+type BucketCache interface {
+	// cached portion + list of gaps to fetch
+	GetMissRanges(ctx context.Context, orgID valuer.UUID, q qbtypes.Query, step qbtypes.Step) (cached *qbtypes.Result, missing []*qbtypes.TimeRange)
+	// store fresh buckets for future hits
+	Put(ctx context.Context, orgID valuer.UUID, q qbtypes.Query, step qbtypes.Step, fresh *qbtypes.Result)
+}
+
 // bucketCache implements the BucketCache interface.
 type bucketCache struct {
 	cache        cache.Cache

pkg/querier/builder_query.go

@@ -11,8 +11,8 @@ import (
 
 	"github.com/ClickHouse/clickhouse-go/v2"
 	"github.com/SigNoz/signoz/pkg/errors"
+	"github.com/SigNoz/signoz/pkg/telemetryschema/tracestelemetryschema"
 	"github.com/SigNoz/signoz/pkg/telemetrystore"
-	"github.com/SigNoz/signoz/pkg/telemetrytraces"
 	"github.com/SigNoz/signoz/pkg/types/ctxtypes"
 	"github.com/SigNoz/signoz/pkg/types/instrumentationtypes"
 	qbtypes "github.com/SigNoz/signoz/pkg/types/querybuildertypes/querybuildertypesv5"
@@ -277,12 +277,12 @@ func (q *builderQuery[T]) narrowWindowByTraceID(ctx context.Context, fromMS, toM
 		return fromMS, toMS, true, ""
 	}
 
-	traceIDs, found := telemetrytraces.ExtractTraceIDsFromFilter(q.spec.Filter.Expression)
+	traceIDs, found := tracestelemetryschema.ExtractTraceIDsFromFilter(q.spec.Filter.Expression)
 	if !found || len(traceIDs) == 0 {
 		return fromMS, toMS, true, ""
 	}
 
-	finder := telemetrytraces.NewTraceTimeRangeFinder(q.telemetryStore)
+	finder := tracestelemetryschema.NewTraceTimeRangeFinder(q.telemetryStore)
 	traceStart, traceEnd, exists, err := finder.GetTraceTimeRangeMulti(ctx, traceIDs)
 	if err != nil {
 		return fromMS, toMS, true, ""

pkg/querier/collect.go

@@ -6,18 +6,18 @@ import (
 	"time"
 
 	"github.com/SigNoz/signoz/pkg/errors"
-	"github.com/SigNoz/signoz/pkg/telemetrylogs"
-	"github.com/SigNoz/signoz/pkg/telemetrymetrics"
-	"github.com/SigNoz/signoz/pkg/telemetrytraces"
+	"github.com/SigNoz/signoz/pkg/telemetryschema/logstelemetryschema"
+	"github.com/SigNoz/signoz/pkg/telemetryschema/metricstelemetryschema"
+	"github.com/SigNoz/signoz/pkg/telemetryschema/tracestelemetryschema"
 	"github.com/SigNoz/signoz/pkg/valuer"
 )
 
 func (q *querier) Collect(ctx context.Context, _ valuer.UUID) (map[string]any, error) {
 	stats := make(map[string]any)
 
-	tracesTable := fmt.Sprintf("%s.%s", telemetrytraces.DBName, telemetrytraces.SpanIndexV3TableName)
-	logsTable := fmt.Sprintf("%s.%s", telemetrylogs.DBName, telemetrylogs.LogsV2TableName)
-	metricsTable := fmt.Sprintf("%s.%s", telemetrymetrics.DBName, telemetrymetrics.SamplesV4TableName)
+	tracesTable := fmt.Sprintf("%s.%s", tracestelemetryschema.DBName, tracestelemetryschema.SpanIndexV3TableName)
+	logsTable := fmt.Sprintf("%s.%s", logstelemetryschema.DBName, logstelemetryschema.LogsV2TableName)
+	metricsTable := fmt.Sprintf("%s.%s", metricstelemetryschema.DBName, metricstelemetryschema.SamplesV4TableName)
 
 	var (
 		traces           uint64

pkg/querier/config.go

@@ -9,12 +9,6 @@ import (
 
 const DefaultMaxConcurrentQueries = 8
 
-type SkipResourceFingerprint struct {
-	Enabled bool `yaml:"enabled" mapstructure:"enabled"`
-	// If count of fingerprint is above threshold, skip the fingerprint subquery and filter on main table instead.
-	Threshold uint64 `yaml:"threshold" mapstructure:"threshold"`
-}
-
 // Config represents the configuration for the querier.
 type Config struct {
 	// CacheTTL is the TTL for cached query results
@@ -23,8 +17,6 @@ type Config struct {
 	FluxInterval time.Duration `yaml:"flux_interval" mapstructure:"flux_interval"`
 	// MaxConcurrentQueries is the maximum number of concurrent queries for missing ranges
 	MaxConcurrentQueries int `yaml:"max_concurrent_queries" mapstructure:"max_concurrent_queries"`
-	// SkipResourceFingerprint configures when the resource fingerprint subquery is skipped in favor of main-table filtering.
-	SkipResourceFingerprint SkipResourceFingerprint `yaml:"skip_resource_fingerprint" mapstructure:"skip_resource_fingerprint"`
 	// LogTraceIDWindowPadding is the padding added to narrowed down timerange from trace summary to logs with trace_id filter.
 	LogTraceIDWindowPadding time.Duration `yaml:"log_trace_id_window_padding" mapstructure:"log_trace_id_window_padding"`
 }
@@ -39,11 +31,7 @@ func newConfig() factory.Config {
 		// Default values
 		CacheTTL:             168 * time.Hour,
 		FluxInterval:         5 * time.Minute,
-		MaxConcurrentQueries: DefaultMaxConcurrentQueries,
-		SkipResourceFingerprint: SkipResourceFingerprint{
-			Enabled:   false,
-			Threshold: 100000,
-		},
+		MaxConcurrentQueries:    DefaultMaxConcurrentQueries,
 		LogTraceIDWindowPadding: 5 * time.Minute,
 	}
 }
@@ -59,9 +47,6 @@ func (c Config) Validate() error {
 	if c.MaxConcurrentQueries <= 0 {
 		return errors.NewInvalidInputf(errors.CodeInvalidInput, "max_concurrent_queries must be positive, got %v", c.MaxConcurrentQueries)
 	}
-	if c.SkipResourceFingerprint.Enabled && c.SkipResourceFingerprint.Threshold == 0 {
-		return errors.NewInvalidInputf(errors.CodeInvalidInput, "skip_resource_fingerprint.threshold must be > 0 when enabled")
-	}
 	if c.LogTraceIDWindowPadding < 0 {
 		return errors.NewInvalidInputf(errors.CodeInvalidInput, "log_trace_id_window_padding must not be negative, got %v", c.LogTraceIDWindowPadding)
 	}

pkg/querier/interfaces.go

@@ -1,35 +0,0 @@
-package querier
-
-import (
-	"context"
-	"net/http"
-
-	"github.com/SigNoz/signoz/pkg/statsreporter"
-	qbtypes "github.com/SigNoz/signoz/pkg/types/querybuildertypes/querybuildertypesv5"
-	"github.com/SigNoz/signoz/pkg/valuer"
-)
-
-// Querier interface defines the contract for querying data.
-type Querier interface {
-	QueryRange(ctx context.Context, orgID valuer.UUID, req *qbtypes.QueryRangeRequest) (*qbtypes.QueryRangeResponse, error)
-	QueryRawStream(ctx context.Context, orgID valuer.UUID, req *qbtypes.QueryRangeRequest, client *qbtypes.RawStream)
-	statsreporter.StatsCollector
-	// QueryRangePreview validates and renders the queries without executing them.
-	QueryRangePreview(ctx context.Context, orgID valuer.UUID, req *qbtypes.QueryRangeRequest, opts qbtypes.QueryRangePreviewOptions) (*qbtypes.QueryRangePreviewResponse, error)
-}
-
-// BucketCache is the interface for bucket-based caching.
-type BucketCache interface {
-	// cached portion + list of gaps to fetch
-	GetMissRanges(ctx context.Context, orgID valuer.UUID, q qbtypes.Query, step qbtypes.Step) (cached *qbtypes.Result, missing []*qbtypes.TimeRange)
-	// store fresh buckets for future hits
-	Put(ctx context.Context, orgID valuer.UUID, q qbtypes.Query, step qbtypes.Step, fresh *qbtypes.Result)
-}
-
-type Handler interface {
-	QueryRange(rw http.ResponseWriter, req *http.Request)
-	// QueryRangePreview is the dry-run endpoint: validate and render without executing.
-	QueryRangePreview(rw http.ResponseWriter, req *http.Request)
-	QueryRawStream(rw http.ResponseWriter, req *http.Request)
-	ReplaceVariables(rw http.ResponseWriter, req *http.Request)
-}

pkg/querier/preview.go

@@ -231,7 +231,7 @@ func (q *querier) buildPreviewProviders(
 			sub.CompositeQuery = qbtypes.CompositeQuery{Queries: []qbtypes.QueryEnvelope{query}}
 		}
 
-		built, _, bErr := q.buildQueries(orgID, &sub, deps, missingMetricQuerySet, event, promqlOptions{})
+		built, _, bErr := q.buildQueries(orgID, &sub, deps, missingMetricQuerySet, event)
 		if bErr != nil {
 			errs[name] = bErr
 			continue

pkg/querier/promql_query.go

@@ -8,19 +8,15 @@ import (
 	"regexp"
 	"sort"
 	"strings"
-	"sync"
 	"text/template"
 	"time"
 
-	"github.com/ClickHouse/clickhouse-go/v2"
-
 	"github.com/prometheus/prometheus/model/labels"
 	"github.com/prometheus/prometheus/promql"
 	"github.com/prometheus/prometheus/promql/parser"
 
 	"github.com/SigNoz/signoz/pkg/errors"
 	"github.com/SigNoz/signoz/pkg/prometheus"
-	"github.com/SigNoz/signoz/pkg/prometheus/clickhouseprometheusv2"
 	"github.com/SigNoz/signoz/pkg/querybuilder"
 	"github.com/SigNoz/signoz/pkg/types/ctxtypes"
 	"github.com/SigNoz/signoz/pkg/types/instrumentationtypes"
@@ -102,24 +98,6 @@ type promqlQuery struct {
 	tr          qbv5.TimeRange
 	requestType qbv5.RequestType
 	vars        map[string]qbv5.VariableItem
-	opts        promqlOptions
-}
-
-// promqlOptions is how a PromQL query relates to the clickhousev2 provider
-// (see querier.promqlOptions for where the fields come from and why they are
-// flag-gated). Both providers are nil for a plain request, so a plain
-// request costs nothing extra.
-type promqlOptions struct {
-	// shadow, when set, runs the query on this provider after serving and
-	// logs any result difference; the response is never affected.
-	shadow *clickhouseprometheusv2.Provider
-	// shadowSlots is the querier-wide admission for shadow runs, shared by
-	// every query so the bound holds per process.
-	shadowSlots chan struct{}
-	// serve, when set, serves the response from this provider instead of the
-	// default path. Comparison callers fetch the default and the pinned
-	// result as two API calls and diff them.
-	serve *clickhouseprometheusv2.Provider
 }
 
 var _ qbv5.Query = (*promqlQuery)(nil)
@@ -132,7 +110,6 @@ func newPromqlQuery(
 	tr qbv5.TimeRange,
 	requestType qbv5.RequestType,
 	variables map[string]qbv5.VariableItem,
-	opts promqlOptions,
 ) *promqlQuery {
 	return &promqlQuery{
 		logger:      logger,
@@ -142,19 +119,10 @@ func newPromqlQuery(
 		tr:          tr,
 		requestType: requestType,
 		vars:        variables,
-		opts:        opts,
 	}
 }
 
 func (q *promqlQuery) Fingerprint() string {
-	// A pinned request must not share cache entries with default serving: a
-	// cached default result would satisfy the pin without running the pinned
-	// provider, and a pinned result would poison normal serving. No
-	// fingerprint means no caching at all — the pin exists to observe a
-	// provider, so a cache in front of it defeats the point.
-	if q.opts.serve != nil {
-		return ""
-	}
 	if q.requestType != qbv5.RequestTypeTimeSeries {
 		return ""
 	}
@@ -284,16 +252,7 @@ func (q *promqlQuery) PreviewStatements(ctx context.Context) ([]prometheus.Captu
 	start := int64(querybuilder.ToNanoSecs(q.tr.From))
 	end := int64(querybuilder.ToNanoSecs(q.tr.To))
 
-	// Attach the same query traits as Execute so the captured statements
-	// match what the live path would run.
-	if expr, parseErr := q.parser.ParseExpr(rendered); parseErr == nil {
-		ctx = prometheus.NewContextWithQueryTraits(ctx, prometheus.DetectQueryTraits(expr))
-	}
-
 	capStorage, recorder := storer.CapturingStorage()
-	if capStorage == nil {
-		return nil, nil
-	}
 	qry, err := q.promEngine.Engine().NewRangeQuery(
 		ctx,
 		capStorage,
@@ -337,58 +296,6 @@ func (q *promqlQuery) Execute(ctx context.Context) (*qbv5.Result, error) {
 		return nil, err
 	}
 
-	// Attach query traits so the storage can prove step-aligned optimizations
-	// safe (see prometheus.QueryTraits). A parse failure surfaces below via
-	// the engine with the enhanced error message.
-	if expr, parseErr := q.parser.ParseExpr(query); parseErr == nil {
-		ctx = prometheus.NewContextWithQueryTraits(ctx, prometheus.DetectQueryTraits(expr))
-	}
-
-	// Accumulate ClickHouse-side scan stats across every storage query this
-	// evaluation issues (engine selectors or the compiled executor): progress
-	// options propagate to each ClickHouse query through the context.
-	var statsMu sync.Mutex
-	var rowsScanned, bytesScanned uint64
-	ctx = clickhouse.Context(ctx, clickhouse.WithProgress(func(p *clickhouse.Progress) {
-		statsMu.Lock()
-		rowsScanned += p.Rows
-		bytesScanned += p.Bytes
-		statsMu.Unlock()
-	}))
-
-	began := time.Now()
-
-	// A pinned provider serves directly from it: comparison callers fetch
-	// the default result and the pinned result as two API calls and diff
-	// them.
-	if q.opts.serve != nil {
-		matrix, err := q.serveFromProvider(ctx, query, start, end)
-		if err != nil {
-			if enhanced := tryEnhancePromQLExecError(err); enhanced != nil {
-				return nil, enhanced
-			}
-			return nil, err
-		}
-		return q.toResult(matrix, nil, began, &statsMu, &rowsScanned, &bytesScanned), nil
-	}
-
-	// When the serving provider itself is clickhousev2
-	// (prometheus::provider: clickhousev2), serve the way the provider is
-	// designed to serve: transpiled when the shape allows. Without this the
-	// override would silently run the engine path only.
-	if prov, ok := q.promEngine.(*clickhouseprometheusv2.Provider); ok {
-		matrix, served, err := prov.TryExecuteRange(ctx, query, time.Unix(0, start), time.Unix(0, end), q.query.Step.Duration)
-		if err != nil {
-			if enhanced := tryEnhancePromQLExecError(err); enhanced != nil {
-				return nil, enhanced
-			}
-			return nil, err
-		}
-		if served {
-			return q.toResult(matrix, nil, began, &statsMu, &rowsScanned, &bytesScanned), nil
-		}
-	}
-
 	qry, err := q.promEngine.Engine().NewRangeQuery(
 		ctx,
 		q.promEngine.Storage(),
@@ -424,34 +331,6 @@ func (q *promqlQuery) Execute(ctx context.Context) (*qbv5.Result, error) {
 		return nil, errors.WrapInternalf(promErr, errors.CodeInternal, "error getting matrix from promql query %q", query)
 	}
 
-	if q.opts.shadow != nil {
-		// Shadows detach from the request, so without admission a dashboard
-		// burst would stack unbounded ClickHouse work for up to the shadow
-		// timeout — the concurrency pattern behind the original outages.
-		// Non-blocking: at the cap the comparison is skipped, not queued;
-		// a sampled shadow stream is exactly as useful for rollout evidence.
-		select {
-		case q.opts.shadowSlots <- struct{}{}:
-			// The engine pools the result's sample slices on Close; the
-			// shadow comparison needs a stable copy of what was served.
-			served := copyMatrix(matrix)
-			servedIn := time.Since(began)
-			go func() {
-				defer func() { <-q.opts.shadowSlots }()
-				q.runShadowCompare(context.WithoutCancel(ctx), query, start, end, served, servedIn)
-			}()
-		default:
-			q.logger.DebugContext(ctx, "promql shadow skipped: at concurrency cap", slog.String("query", query))
-		}
-	}
-
-	warnings, _ := res.Warnings.AsStrings(query, 10, 0)
-	return q.toResult(matrix, warnings, began, &statsMu, &rowsScanned, &bytesScanned), nil
-}
-
-// toResult converts an evaluated matrix into the v5 result shape, attaching
-// the ClickHouse scan stats accumulated during evaluation.
-func (q *promqlQuery) toResult(matrix promql.Matrix, warnings []string, began time.Time, statsMu *sync.Mutex, rowsScanned, bytesScanned *uint64) *qbv5.Result {
 	// Hide only known SigNoz storage keys: label names are user data and may
 	// legitimately start with "__" (e.g. __address__), so a blanket dunder
 	// strip mangles user labelsets. The __scope./__resource. prefixes cover
@@ -487,13 +366,7 @@ func (q *promqlQuery) toResult(matrix promql.Matrix, warnings []string, began ti
 		series = append(series, &s)
 	}
 
-	statsMu.Lock()
-	stats := qbv5.ExecStats{
-		RowsScanned:  *rowsScanned,
-		BytesScanned: *bytesScanned,
-		DurationMS:   uint64(time.Since(began).Milliseconds()),
-	}
-	statsMu.Unlock()
+	warnings, _ := res.Warnings.AsStrings(query, 10, 0)
 
 	tsData := &qbv5.TimeSeriesData{
 		QueryName: q.query.Name,
@@ -527,6 +400,6 @@ func (q *promqlQuery) toResult(matrix promql.Matrix, warnings []string, began ti
 		Type:     q.requestType,
 		Value:    payload,
 		Warnings: warnings,
-		Stats:    stats,
-	}
+		// TODO: map promql stats?
+	}, nil
 }

pkg/querier/promql_query_test.go

@@ -7,7 +7,6 @@ import (
 
 	"github.com/SigNoz/signoz/pkg/errors"
 	"github.com/SigNoz/signoz/pkg/prometheus"
-	"github.com/SigNoz/signoz/pkg/prometheus/clickhouseprometheusv2"
 	qbv5 "github.com/SigNoz/signoz/pkg/types/querybuildertypes/querybuildertypesv5"
 	"github.com/stretchr/testify/assert"
 )
@@ -441,15 +440,3 @@ func TestQuotedMetricOutsideBracesPattern(t *testing.T) {
 		})
 	}
 }
-
-// A pinned request must not share cache entries with default serving: a
-// cached default result would satisfy the pin without running the pinned
-// provider.
-func TestFingerprint_PinnedProviderBypassesCache(t *testing.T) {
-	q := &promqlQuery{
-		logger: slog.Default(),
-		query:  qbv5.PromQuery{Query: "up"},
-		opts:   promqlOptions{serve: &clickhouseprometheusv2.Provider{}},
-	}
-	assert.Empty(t, q.Fingerprint())
-}

pkg/querier/promql_shadow.go

@@ -1,186 +0,0 @@
-package querier
-
-import (
-	"context"
-	"fmt"
-	"log/slog"
-	"math"
-	"sort"
-	"time"
-
-	"github.com/ClickHouse/clickhouse-go/v2"
-	"github.com/SigNoz/signoz/pkg/prometheus"
-	"github.com/SigNoz/signoz/pkg/prometheus/clickhouseprometheusv2"
-	"github.com/prometheus/prometheus/model/labels"
-	"github.com/prometheus/prometheus/promql"
-)
-
-// shadowTimeout bounds a shadow evaluation; a shadow run must never outlive
-// the request by much or pile up.
-const shadowTimeout = 2 * time.Minute
-
-// runShadowCompare executes the query on the clickhousev2 provider exactly
-// as it would serve (transpiled when the shape allows, engine over the v2
-// querier otherwise), compares against the served result and logs the
-// outcome. Serving is never affected: this runs after the response, off the
-// request context, and only logs. The mismatch and failure logs are the
-// rollout evidence — serving cuts over to v2 only after they stay clean.
-func (q *promqlQuery) runShadowCompare(ctx context.Context, query string, startNs, endNs int64, served promql.Matrix, servedIn time.Duration) {
-	defer func() {
-		if r := recover(); r != nil {
-			q.logger.ErrorContext(ctx, "promql shadow comparison panicked", slog.Any("panic", r), slog.String("query", query))
-		}
-	}()
-
-	ctx, cancel := context.WithTimeout(ctx, shadowTimeout)
-	defer cancel()
-
-	// The request context carries the served response's scan-stats progress
-	// callback; without replacing it the shadow's ClickHouse progress would
-	// race into the served stats. The response itself was already sent.
-	ctx = clickhouse.Context(ctx, clickhouse.WithProgress(func(*clickhouse.Progress) {}))
-
-	if expr, parseErr := q.parser.ParseExpr(query); parseErr == nil {
-		ctx = prometheus.NewContextWithQueryTraits(ctx, prometheus.DetectQueryTraits(expr))
-	}
-
-	start, end := time.Unix(0, startNs), time.Unix(0, endNs)
-	began := time.Now()
-	shadow, transpiled, err := executeOnProvider(ctx, q.opts.shadow, query, start, end, q.query.Step.Duration)
-	shadowIn := time.Since(began)
-
-	logAttrs := []any{
-		slog.String("query", query),
-		slog.Int64("start_ms", startNs/int64(time.Millisecond)),
-		slog.Int64("end_ms", endNs/int64(time.Millisecond)),
-		slog.Duration("step", q.query.Step.Duration),
-		slog.Bool("transpiled", transpiled),
-		slog.Duration("served_in", servedIn),
-		slog.Duration("shadow_in", shadowIn),
-	}
-
-	if err != nil {
-		// A shadow failure would be a serving failure after rollout; surface
-		// it at the same level as a result mismatch.
-		q.logger.WarnContext(ctx, "promql shadow execution failed", append(logAttrs, slog.Any("error", err))...)
-		return
-	}
-
-	servedNorm := normalizeShadowMatrix(served)
-	shadowNorm := normalizeShadowMatrix(shadow)
-	if diff := diffShadowMatrices(servedNorm, shadowNorm); diff != "" {
-		q.logger.WarnContext(ctx, "promql shadow comparison mismatch", append(logAttrs,
-			slog.String("diff", diff),
-			slog.Int("served_series", len(servedNorm)),
-			slog.Int("shadow_series", len(shadowNorm)),
-		)...)
-		return
-	}
-	// Matches log the timings: served_in vs shadow_in across the fleet is
-	// the perf evidence for the cutover, gathered for free.
-	q.logger.DebugContext(ctx, "promql shadow comparison matched", logAttrs...)
-}
-
-// serveFromProvider evaluates the query the way the pinned provider would
-// serve it.
-func (q *promqlQuery) serveFromProvider(ctx context.Context, query string, startNs, endNs int64) (promql.Matrix, error) {
-	matrix, _, err := executeOnProvider(ctx, q.opts.serve, query, time.Unix(0, startNs), time.Unix(0, endNs), q.query.Step.Duration)
-	return matrix, err
-}
-
-// executeOnProvider evaluates the query the way the provider would serve it:
-// transpiled in ClickHouse when the shape allows, the engine over the
-// provider's storage otherwise. The returned matrix is an owned copy.
-func executeOnProvider(ctx context.Context, prov *clickhouseprometheusv2.Provider, query string, start, end time.Time, step time.Duration) (promql.Matrix, bool, error) {
-	matrix, ok, err := prov.TryExecuteRange(ctx, query, start, end, step)
-	if err != nil {
-		return nil, true, err
-	}
-	if ok {
-		return matrix, true, nil
-	}
-
-	qry, err := prov.Engine().NewRangeQuery(ctx, prov.Storage(), nil, query, start, end, step)
-	if err != nil {
-		return nil, false, err
-	}
-	defer qry.Close()
-
-	res := qry.Exec(ctx)
-	if res.Err != nil {
-		return nil, false, res.Err
-	}
-	matrix, err = res.Matrix()
-	if err != nil {
-		return nil, false, err
-	}
-	// Close returns the result's sample slices to the engine pool.
-	return copyMatrix(matrix), false, nil
-}
-
-func copyMatrix(matrix promql.Matrix) promql.Matrix {
-	out := make(promql.Matrix, 0, len(matrix))
-	for _, s := range matrix {
-		floats := make([]promql.FPoint, len(s.Floats))
-		copy(floats, s.Floats)
-		out = append(out, promql.Series{Metric: s.Metric.Copy(), Floats: floats})
-	}
-	return out
-}
-
-// normalizeShadowMatrix sorts by label set for order-independent
-// comparison. Both providers now resolve series identity the same way
-// (empty-valued labels dropped at read, no synthetic fingerprint label
-// since the v1 series-identity fix), so labels need no normalization.
-func normalizeShadowMatrix(matrix promql.Matrix) promql.Matrix {
-	out := make(promql.Matrix, 0, len(matrix))
-	out = append(out, matrix...)
-	sort.Slice(out, func(i, j int) bool { return labels.Compare(out[i].Metric, out[j].Metric) < 0 })
-	return out
-}
-
-// diffShadowMatrices returns a description of the first difference, or "".
-// Values compare with relative tolerance: spatial aggregations accumulate
-// floats in storage order, which differs between the providers in the last
-// ULP.
-func diffShadowMatrices(served, shadow promql.Matrix) string {
-	const relTol = 1e-9
-	if len(served) != len(shadow) {
-		return fmt.Sprintf("series count: served=%d shadow=%d", len(served), len(shadow))
-	}
-	for i := range served {
-		if labels.Compare(served[i].Metric, shadow[i].Metric) != 0 {
-			return fmt.Sprintf("series %d labels: served=%s shadow=%s", i, served[i].Metric, shadow[i].Metric)
-		}
-		if len(served[i].Floats) != len(shadow[i].Floats) {
-			return fmt.Sprintf("series %s points: served=%d shadow=%d", served[i].Metric, len(served[i].Floats), len(shadow[i].Floats))
-		}
-		for j := range served[i].Floats {
-			a, b := served[i].Floats[j], shadow[i].Floats[j]
-			if a.T != b.T {
-				return fmt.Sprintf("series %s point %d ts: served=%d shadow=%d", served[i].Metric, j, a.T, b.T)
-			}
-			// NaN and infinities first: NaN != NaN and Inf-Inf arithmetic
-			// would otherwise make one-sided NaN and Inf-vs-finite compare
-			// as equal (NaN > x and Inf > Inf are both false).
-			if math.IsNaN(a.F) || math.IsNaN(b.F) {
-				if math.IsNaN(a.F) != math.IsNaN(b.F) {
-					return fmt.Sprintf("series %s @%d value: served=%v shadow=%v", served[i].Metric, a.T, a.F, b.F)
-				}
-				continue
-			}
-			if math.IsInf(a.F, 0) || math.IsInf(b.F, 0) {
-				if a.F != b.F {
-					return fmt.Sprintf("series %s @%d value: served=%v shadow=%v", served[i].Metric, a.T, a.F, b.F)
-				}
-				continue
-			}
-			diff := math.Abs(a.F - b.F)
-			scale := math.Max(math.Abs(a.F), math.Abs(b.F))
-			if diff > relTol*math.Max(scale, 1e-300) && diff > 1e-12 {
-				return fmt.Sprintf("series %s @%d value: served=%v shadow=%v", served[i].Metric, a.T, a.F, b.F)
-			}
-		}
-	}
-	return ""
-}

pkg/querier/promql_shadow_test.go

@@ -1,67 +0,0 @@
-package querier
-
-import (
-	"math"
-	"testing"
-
-	"github.com/prometheus/prometheus/model/labels"
-	"github.com/prometheus/prometheus/promql"
-	"github.com/stretchr/testify/assert"
-)
-
-func TestNormalizeShadowMatrix(t *testing.T) {
-	matrix := promql.Matrix{
-		{
-			Metric: labels.FromStrings("__name__", "up", "job", "api"),
-			Floats: []promql.FPoint{{T: 1000, F: 1}},
-		},
-		{
-			Metric: labels.FromStrings("a", "1"),
-			Floats: []promql.FPoint{{T: 1000, F: 2}},
-		},
-	}
-	norm := normalizeShadowMatrix(matrix)
-	// sorted by label set; labels pass through untouched — both providers
-	// resolve series identity identically since the v1 series-identity fix
-	assert.Equal(t, labels.FromStrings("__name__", "up", "job", "api"), norm[0].Metric)
-	assert.Equal(t, labels.FromStrings("a", "1"), norm[1].Metric)
-}
-
-func TestDiffShadowMatrices(t *testing.T) {
-	series := func(v float64) promql.Matrix {
-		return promql.Matrix{{Metric: labels.FromStrings("a", "1"), Floats: []promql.FPoint{{T: 1000, F: v}}}}
-	}
-
-	assert.Empty(t, diffShadowMatrices(series(1.5), series(1.5)))
-	// last-ULP differences from storage-order float accumulation are expected
-	assert.Empty(t, diffShadowMatrices(series(0.08888888888888889), series(0.08888888888888888)))
-	assert.Empty(t, diffShadowMatrices(series(math.NaN()), series(math.NaN())))
-
-	assert.Contains(t, diffShadowMatrices(series(1.5), series(1.6)), "value")
-	assert.Contains(t, diffShadowMatrices(series(1.5), promql.Matrix{}), "series count")
-	assert.Contains(t, diffShadowMatrices(
-		series(1.5),
-		promql.Matrix{{Metric: labels.FromStrings("a", "2"), Floats: []promql.FPoint{{T: 1000, F: 1.5}}}},
-	), "labels")
-	assert.Contains(t, diffShadowMatrices(
-		series(1.5),
-		promql.Matrix{{Metric: labels.FromStrings("a", "1"), Floats: []promql.FPoint{{T: 2000, F: 1.5}}}},
-	), "ts")
-}
-
-// One-sided NaN makes every float comparison false, and Inf-Inf arithmetic
-// yields Inf > Inf == false; without explicit handling both divergences log
-// as matched — a shadow comparator that cannot see them would green-light a
-// broken rollout.
-func TestDiffShadowMatrices_SpecialFloats(t *testing.T) {
-	point := func(v float64) promql.Matrix {
-		return promql.Matrix{{Metric: labels.FromStrings("a", "1"), Floats: []promql.FPoint{{T: 1000, F: v}}}}
-	}
-
-	assert.NotEmpty(t, diffShadowMatrices(point(math.NaN()), point(1.5)), "one-sided NaN must diff")
-	assert.NotEmpty(t, diffShadowMatrices(point(1.5), point(math.NaN())), "one-sided NaN must diff either way")
-	assert.NotEmpty(t, diffShadowMatrices(point(math.Inf(1)), point(1.5)), "Inf vs finite must diff")
-	assert.NotEmpty(t, diffShadowMatrices(point(math.Inf(1)), point(math.Inf(-1))), "opposite infinities must diff")
-	assert.Empty(t, diffShadowMatrices(point(math.Inf(1)), point(math.Inf(1))), "equal infinities match")
-	assert.Empty(t, diffShadowMatrices(point(math.NaN()), point(math.NaN())), "both NaN match")
-}

pkg/querier/querier.go

@@ -19,12 +19,11 @@ import (
 	"github.com/SigNoz/signoz/pkg/factory"
 	"github.com/SigNoz/signoz/pkg/flagger"
 	"github.com/SigNoz/signoz/pkg/prometheus"
-	"github.com/SigNoz/signoz/pkg/prometheus/clickhouseprometheusv2"
 	"github.com/SigNoz/signoz/pkg/query-service/utils"
 	"github.com/SigNoz/signoz/pkg/querybuilder"
+	"github.com/SigNoz/signoz/pkg/statsreporter"
 	"github.com/SigNoz/signoz/pkg/telemetrystore"
 	"github.com/SigNoz/signoz/pkg/types/ctxtypes"
-	"github.com/SigNoz/signoz/pkg/types/featuretypes"
 	"github.com/SigNoz/signoz/pkg/types/instrumentationtypes"
 	"github.com/SigNoz/signoz/pkg/types/metrictypes"
 	"github.com/SigNoz/signoz/pkg/types/telemetrytypes"
@@ -37,20 +36,21 @@ var (
 	intervalWarn = "Query %s is requesting aggregation interval %v seconds, which is smaller than the minimum allowed interval of %v seconds for selected time range. Using the minimum instead"
 )
 
+// Querier interface defines the contract for querying data.
+type Querier interface {
+	QueryRange(ctx context.Context, orgID valuer.UUID, req *qbtypes.QueryRangeRequest) (*qbtypes.QueryRangeResponse, error)
+	QueryRawStream(ctx context.Context, orgID valuer.UUID, req *qbtypes.QueryRangeRequest, client *qbtypes.RawStream)
+	statsreporter.StatsCollector
+	// QueryRangePreview validates and renders the queries without executing them.
+	QueryRangePreview(ctx context.Context, orgID valuer.UUID, req *qbtypes.QueryRangeRequest, opts qbtypes.QueryRangePreviewOptions) (*qbtypes.QueryRangePreviewResponse, error)
+}
+
 type querier struct {
-	logger         *slog.Logger
-	fl             flagger.Flagger
-	telemetryStore telemetrystore.TelemetryStore
-	metadataStore  telemetrytypes.MetadataStore
-	promEngine     prometheus.Prometheus
-	// promV2 is the clickhousev2 prometheus provider, wired only when the
-	// serving provider is the default one (nil otherwise). It reads the same
-	// ClickHouse data through a different implementation; PromQL queries
-	// shadow-compare against it behind the use_prometheus_clickhouse_v2 flag
-	// and can be pinned to it for a response (see promqlOptions). It never
-	// serves by default — that cutover happens only after the shadow logs
-	// stay clean.
-	promV2                   *clickhouseprometheusv2.Provider
+	logger                   *slog.Logger
+	fl                       flagger.Flagger
+	telemetryStore           telemetrystore.TelemetryStore
+	metadataStore            telemetrytypes.MetadataStore
+	promEngine               prometheus.Prometheus
 	traceStmtBuilder         qbtypes.StatementBuilder[qbtypes.TraceAggregation]
 	logStmtBuilder           qbtypes.StatementBuilder[qbtypes.LogAggregation]
 	auditStmtBuilder         qbtypes.StatementBuilder[qbtypes.LogAggregation]
@@ -61,16 +61,8 @@ type querier struct {
 	liveDataRefresh          time.Duration
 	builderConfig            builderConfig
 	maxConcurrentQueries     int
-	// shadowSlots bounds concurrent shadow comparisons per process; shadows
-	// detach from their requests, so nothing else limits how many pile up.
-	shadowSlots chan struct{}
 }
 
-// maxConcurrentShadows is deliberately small: a shadow is a full extra
-// ClickHouse evaluation, and a sampled stream of comparisons is exactly as
-// useful for rollout evidence as an exhaustive one under load.
-const maxConcurrentShadows = 8
-
 var _ Querier = (*querier)(nil)
 
 func New(
@@ -78,7 +70,6 @@ func New(
 	telemetryStore telemetrystore.TelemetryStore,
 	metadataStore telemetrytypes.MetadataStore,
 	promEngine prometheus.Prometheus,
-	promV2 *clickhouseprometheusv2.Provider,
 	traceStmtBuilder qbtypes.StatementBuilder[qbtypes.TraceAggregation],
 	logStmtBuilder qbtypes.StatementBuilder[qbtypes.LogAggregation],
 	auditStmtBuilder qbtypes.StatementBuilder[qbtypes.LogAggregation],
@@ -100,7 +91,6 @@ func New(
 		telemetryStore:           telemetryStore,
 		metadataStore:            metadataStore,
 		promEngine:               promEngine,
-		promV2:                   promV2,
 		traceStmtBuilder:         traceStmtBuilder,
 		logStmtBuilder:           logStmtBuilder,
 		auditStmtBuilder:         auditStmtBuilder,
@@ -113,7 +103,6 @@ func New(
 			logTraceIDWindowPaddingMS: uint64(logTraceIDWindowPadding.Milliseconds()),
 		},
 		maxConcurrentQueries: maxConcurrentQueries,
-		shadowSlots:          make(chan struct{}, maxConcurrentShadows),
 	}
 }
 
@@ -153,11 +142,7 @@ func (q *querier) QueryRange(ctx context.Context, orgID valuer.UUID, req *qbtype
 		missingMetricQuerySet[name] = true
 	}
 
-	promqlOpts, err := q.promqlOptions(ctx, orgID, req)
-	if err != nil {
-		return nil, err
-	}
-	queries, steps, err := q.buildQueries(orgID, req, dependencyQueries, missingMetricQuerySet, event, promqlOpts)
+	queries, steps, err := q.buildQueries(orgID, req, dependencyQueries, missingMetricQuerySet, event)
 	if err != nil {
 		return nil, err
 	}
@@ -200,41 +185,12 @@ func (q *querier) QueryRange(ctx context.Context, orgID valuer.UUID, req *qbtype
 	return qbResp, qbErr
 }
 
-// promqlOptions derives the PromQL execution options for a request. With the
-// org's use_prometheus_clickhouse_v2 flag on, queries are shadow-compared
-// against the clickhousev2 provider (serving unaffected, diffs logged; see
-// promql_shadow.go). The X-SigNoz-PromQL-Provider header may instead pin the
-// response to that provider — integration tests and support fetch both
-// results for comparison — so it is deliberately flag-gated too: without the
-// gate the header would be an unaudited switch onto a provider still under
-// validation.
-func (q *querier) promqlOptions(ctx context.Context, orgID valuer.UUID, req *qbtypes.QueryRangeRequest) (promqlOptions, error) {
-	enabled := q.fl.BooleanOrEmpty(ctx, flagger.FeatureUsePrometheusClickhouseV2, featuretypes.NewFlaggerEvaluationContext(orgID))
-	if req.PromQLProvider == "" {
-		if enabled && q.promV2 != nil {
-			return promqlOptions{shadow: q.promV2, shadowSlots: q.shadowSlots}, nil
-		}
-		return promqlOptions{}, nil
-	}
-	if req.PromQLProvider != prometheus.ProviderClickhouseV2 {
-		return promqlOptions{}, errors.NewInvalidInputf(errors.CodeInvalidInput, "unknown promql provider %q", req.PromQLProvider)
-	}
-	if !enabled {
-		return promqlOptions{}, errors.NewInvalidInputf(errors.CodeInvalidInput, "promql provider %q requires the use_prometheus_clickhouse_v2 flag", req.PromQLProvider)
-	}
-	if q.promV2 == nil {
-		return promqlOptions{}, errors.NewInvalidInputf(errors.CodeInvalidInput, "promql provider %q is not available", req.PromQLProvider)
-	}
-	return promqlOptions{serve: q.promV2}, nil
-}
-
 func (q *querier) buildQueries(
 	orgID valuer.UUID,
 	req *qbtypes.QueryRangeRequest,
 	dependencyQueries map[string]bool,
 	missingMetricQuerySet map[string]bool,
 	event *qbtypes.QBEvent,
-	promqlOpts promqlOptions,
 ) (map[string]qbtypes.Query, map[string]qbtypes.Step, error) {
 
 	tmplVars := req.Variables
@@ -259,7 +215,7 @@ func (q *querier) buildQueries(
 			if !ok {
 				return nil, nil, errors.NewInvalidInputf(errors.CodeInvalidInput, "invalid promql query spec %T", query.Spec)
 			}
-			promqlQuery := newPromqlQuery(q.logger, q.promEngine, promQuery, qbtypes.TimeRange{From: req.Start, To: req.End}, req.RequestType, tmplVars, promqlOpts)
+			promqlQuery := newPromqlQuery(q.logger, q.promEngine, promQuery, qbtypes.TimeRange{From: req.Start, To: req.End}, req.RequestType, tmplVars)
 			queries[promQuery.Name] = promqlQuery
 			steps[promQuery.Name] = promQuery.Step
 		case qbtypes.QueryTypeClickHouseSQL:
@@ -902,7 +858,7 @@ func (q *querier) createRangedQuery(_ valuer.UUID, originalQuery qbtypes.Query,
 	switch qt := originalQuery.(type) {
 	case *promqlQuery:
 		queryCopy := qt.query.Copy()
-		return newPromqlQuery(q.logger, qt.promEngine, queryCopy, timeRange, qt.requestType, qt.vars, qt.opts)
+		return newPromqlQuery(q.logger, q.promEngine, queryCopy, timeRange, qt.requestType, qt.vars)
 
 	case *chSQLQuery:
 		queryCopy := qt.query.Copy()

pkg/querier/querier_test.go

@@ -48,7 +48,6 @@ func TestQueryRange_MetricTypeMissing(t *testing.T) {
 		nil, // telemetryStore
 		metadataStore,
 		nil,                // prometheus
-		nil,                // promV2
 		nil,                // traceStmtBuilder
 		nil,                // logStmtBuilder
 		nil,                // auditStmtBuilder
@@ -120,18 +119,17 @@ func TestQueryRange_MetricTypeFromStore(t *testing.T) {
 		providerSettings,
 		telemetryStore,
 		metadataStore,
-		nil,                      // prometheus
-		nil,                      // promV2
-		nil,                      // traceStmtBuilder
-		nil,                      // logStmtBuilder
-		nil,                      // auditStmtBuilder
-		&mockMetricStmtBuilder{}, // metricStmtBuilder
-		nil,                      // meterStmtBuilder
-		nil,                      // traceOperatorStmtBuilder
-		nil,                      // bucketCache
-		flaggertest.New(t),       // flagger
-		0,                        // logTraceIDWindowPadding
-		0,                        // maxConcurrentQueries
+		nil, // prometheus
+		nil, // traceStmtBuilder
+		nil, // logStmtBuilder
+		nil, // auditStmtBuilder
+		&mockMetricStmtBuilder{},
+		nil,                // meterStmtBuilder
+		nil,                // traceOperatorStmtBuilder
+		nil,                // bucketCache
+		flaggertest.New(t), // flagger
+		0,                  // logTraceIDWindowPadding
+		0,                  // maxConcurrentQueries
 	)
 
 	req := &qbtypes.QueryRangeRequest{

pkg/querier/queriertest/querier.go

@@ -0,0 +1,52 @@
+package queriertest
+
+import (
+	"context"
+
+	"github.com/SigNoz/signoz/pkg/querier"
+	qbtypes "github.com/SigNoz/signoz/pkg/types/querybuildertypes/querybuildertypesv5"
+	"github.com/SigNoz/signoz/pkg/valuer"
+)
+
+// MockQuerier implements querier.Querier for testing. Each behavior can be
+// overridden via a function field; unset fields return empty, non-error values.
+type MockQuerier struct {
+	QueryRangeFunc        func(ctx context.Context, orgID valuer.UUID, req *qbtypes.QueryRangeRequest) (*qbtypes.QueryRangeResponse, error)
+	QueryRawStreamFunc    func(ctx context.Context, orgID valuer.UUID, req *qbtypes.QueryRangeRequest, client *qbtypes.RawStream)
+	QueryRangePreviewFunc func(ctx context.Context, orgID valuer.UUID, req *qbtypes.QueryRangeRequest, opts qbtypes.QueryRangePreviewOptions) (*qbtypes.QueryRangePreviewResponse, error)
+	CollectFunc           func(ctx context.Context, orgID valuer.UUID) (map[string]any, error)
+}
+
+var _ querier.Querier = (*MockQuerier)(nil)
+
+// NewMockQuerier creates a new MockQuerier.
+func NewMockQuerier() *MockQuerier {
+	return &MockQuerier{}
+}
+
+func (m *MockQuerier) QueryRange(ctx context.Context, orgID valuer.UUID, req *qbtypes.QueryRangeRequest) (*qbtypes.QueryRangeResponse, error) {
+	if m.QueryRangeFunc != nil {
+		return m.QueryRangeFunc(ctx, orgID, req)
+	}
+	return &qbtypes.QueryRangeResponse{}, nil
+}
+
+func (m *MockQuerier) QueryRawStream(ctx context.Context, orgID valuer.UUID, req *qbtypes.QueryRangeRequest, client *qbtypes.RawStream) {
+	if m.QueryRawStreamFunc != nil {
+		m.QueryRawStreamFunc(ctx, orgID, req, client)
+	}
+}
+
+func (m *MockQuerier) QueryRangePreview(ctx context.Context, orgID valuer.UUID, req *qbtypes.QueryRangeRequest, opts qbtypes.QueryRangePreviewOptions) (*qbtypes.QueryRangePreviewResponse, error) {
+	if m.QueryRangePreviewFunc != nil {
+		return m.QueryRangePreviewFunc(ctx, orgID, req, opts)
+	}
+	return &qbtypes.QueryRangePreviewResponse{}, nil
+}
+
+func (m *MockQuerier) Collect(ctx context.Context, orgID valuer.UUID) (map[string]any, error) {
+	if m.CollectFunc != nil {
+		return m.CollectFunc(ctx, orgID)
+	}
+	return map[string]any{}, nil
+}

pkg/querier/signozquerier/provider.go

@@ -3,196 +3,54 @@ package signozquerier
 import (
 	"context"
 
-	"github.com/SigNoz/signoz/pkg/cache"
 	"github.com/SigNoz/signoz/pkg/factory"
 	"github.com/SigNoz/signoz/pkg/flagger"
 	"github.com/SigNoz/signoz/pkg/prometheus"
-	"github.com/SigNoz/signoz/pkg/prometheus/clickhouseprometheusv2"
 	"github.com/SigNoz/signoz/pkg/querier"
-	"github.com/SigNoz/signoz/pkg/querybuilder"
-	"github.com/SigNoz/signoz/pkg/telemetryaudit"
-	"github.com/SigNoz/signoz/pkg/telemetrylogs"
-	"github.com/SigNoz/signoz/pkg/telemetrymetadata"
-	"github.com/SigNoz/signoz/pkg/telemetrymeter"
-	"github.com/SigNoz/signoz/pkg/telemetrymetrics"
 	"github.com/SigNoz/signoz/pkg/telemetrystore"
-	"github.com/SigNoz/signoz/pkg/telemetrytraces"
+	qbtypes "github.com/SigNoz/signoz/pkg/types/querybuildertypes/querybuildertypesv5"
+	"github.com/SigNoz/signoz/pkg/types/telemetrytypes"
 )
 
-// NewFactory creates a new factory for the signoz querier provider.
+// NewFactory creates a new factory for the signoz querier provider. The query
+// stack (metadata store, statement builders, bucket cache) is assembled once in
+// signoz.go and injected here.
 func NewFactory(
 	telemetryStore telemetrystore.TelemetryStore,
 	prometheus prometheus.Prometheus,
-	promV2 *clickhouseprometheusv2.Provider,
-	cache cache.Cache,
+	metadataStore telemetrytypes.MetadataStore,
+	traceStmtBuilder qbtypes.StatementBuilder[qbtypes.TraceAggregation],
+	logStmtBuilder qbtypes.StatementBuilder[qbtypes.LogAggregation],
+	auditStmtBuilder qbtypes.StatementBuilder[qbtypes.LogAggregation],
+	metricStmtBuilder qbtypes.StatementBuilder[qbtypes.MetricAggregation],
+	meterStmtBuilder qbtypes.StatementBuilder[qbtypes.MetricAggregation],
+	traceOperatorStmtBuilder qbtypes.TraceOperatorStatementBuilder,
+	bucketCache querier.BucketCache,
 	flagger flagger.Flagger,
 ) factory.ProviderFactory[querier.Querier, querier.Config] {
 	return factory.NewProviderFactory(
 		factory.MustNewName("signoz"),
 		func(
-			ctx context.Context,
+			_ context.Context,
 			settings factory.ProviderSettings,
 			cfg querier.Config,
 		) (querier.Querier, error) {
-			return newProvider(ctx, settings, cfg, telemetryStore, prometheus, promV2, cache, flagger)
+			return querier.New(
+				settings,
+				telemetryStore,
+				metadataStore,
+				prometheus,
+				traceStmtBuilder,
+				logStmtBuilder,
+				auditStmtBuilder,
+				metricStmtBuilder,
+				meterStmtBuilder,
+				traceOperatorStmtBuilder,
+				bucketCache,
+				flagger,
+				cfg.LogTraceIDWindowPadding,
+				cfg.MaxConcurrentQueries,
+			), nil
 		},
 	)
 }
-
-func newProvider(
-	_ context.Context,
-	settings factory.ProviderSettings,
-	cfg querier.Config,
-	telemetryStore telemetrystore.TelemetryStore,
-	prometheus prometheus.Prometheus,
-	promV2 *clickhouseprometheusv2.Provider,
-	cache cache.Cache,
-	flagger flagger.Flagger,
-) (querier.Querier, error) {
-
-	// Create telemetry metadata store
-	telemetryMetadataStore := telemetrymetadata.NewTelemetryMetaStore(
-		settings,
-		telemetryStore,
-		telemetrytraces.DBName,
-		telemetrytraces.TagAttributesV2TableName,
-		telemetrytraces.SpanAttributesKeysTblName,
-		telemetrytraces.SpanIndexV3TableName,
-		telemetrymetrics.DBName,
-		telemetrymetrics.AttributesMetadataTableName,
-		telemetrymeter.DBName,
-		telemetrymeter.SamplesAgg1dTableName,
-		telemetrylogs.DBName,
-		telemetrylogs.LogsV2TableName,
-		telemetrylogs.TagAttributesV2TableName,
-		telemetrylogs.LogAttributeKeysTblName,
-		telemetrylogs.LogResourceKeysTblName,
-		telemetryaudit.DBName,
-		telemetryaudit.AuditLogsTableName,
-		telemetryaudit.TagAttributesTableName,
-		telemetryaudit.LogAttributeKeysTblName,
-		telemetryaudit.LogResourceKeysTblName,
-		telemetrymetadata.DBName,
-		telemetrymetadata.AttributesMetadataTableName,
-		telemetrymetadata.ColumnEvolutionMetadataTableName,
-		flagger,
-	)
-
-	// Create trace statement builder
-	traceFieldMapper := telemetrytraces.NewFieldMapper()
-	traceConditionBuilder := telemetrytraces.NewConditionBuilder(traceFieldMapper)
-
-	traceAggExprRewriter := querybuilder.NewAggExprRewriter(settings, nil, traceFieldMapper, traceConditionBuilder, flagger)
-	traceStmtBuilder := telemetrytraces.NewTraceQueryStatementBuilder(
-		settings,
-		telemetryMetadataStore,
-		traceFieldMapper,
-		traceConditionBuilder,
-		traceAggExprRewriter,
-		telemetryStore,
-		flagger,
-		cfg.SkipResourceFingerprint.Enabled,
-		cfg.SkipResourceFingerprint.Threshold,
-	)
-
-	// Create trace operator statement builder
-	traceOperatorStmtBuilder := telemetrytraces.NewTraceOperatorStatementBuilder(
-		settings,
-		telemetryMetadataStore,
-		traceFieldMapper,
-		traceConditionBuilder,
-		traceStmtBuilder,
-		traceAggExprRewriter,
-		flagger,
-	)
-
-	// Create log statement builder
-	logFieldMapper := telemetrylogs.NewFieldMapper(flagger)
-	logConditionBuilder := telemetrylogs.NewConditionBuilder(logFieldMapper, flagger)
-	logAggExprRewriter := querybuilder.NewAggExprRewriter(
-		settings,
-		telemetrylogs.DefaultFullTextColumn,
-		logFieldMapper,
-		logConditionBuilder,
-		flagger,
-	)
-	logStmtBuilder := telemetrylogs.NewLogQueryStatementBuilder(
-		settings,
-		telemetryMetadataStore,
-		logFieldMapper,
-		logConditionBuilder,
-		logAggExprRewriter,
-		telemetrylogs.DefaultFullTextColumn,
-		flagger,
-		telemetryStore,
-		cfg.SkipResourceFingerprint.Enabled,
-		cfg.SkipResourceFingerprint.Threshold,
-	)
-
-	// Create audit statement builder
-	auditFieldMapper := telemetryaudit.NewFieldMapper()
-	auditConditionBuilder := telemetryaudit.NewConditionBuilder(auditFieldMapper)
-	auditAggExprRewriter := querybuilder.NewAggExprRewriter(
-		settings,
-		telemetryaudit.DefaultFullTextColumn,
-		auditFieldMapper,
-		auditConditionBuilder,
-		flagger,
-	)
-	auditStmtBuilder := telemetryaudit.NewAuditQueryStatementBuilder(
-		settings,
-		telemetryMetadataStore,
-		auditFieldMapper,
-		auditConditionBuilder,
-		auditAggExprRewriter,
-		telemetryaudit.DefaultFullTextColumn,
-		flagger,
-	)
-
-	// Create metric statement builder
-	metricFieldMapper := telemetrymetrics.NewFieldMapper()
-	metricConditionBuilder := telemetrymetrics.NewConditionBuilder(metricFieldMapper)
-	metricStmtBuilder := telemetrymetrics.NewMetricQueryStatementBuilder(
-		settings,
-		telemetryMetadataStore,
-		metricFieldMapper,
-		metricConditionBuilder,
-		flagger,
-	)
-
-	// Create meter statement builder
-	meterStmtBuilder := telemetrymeter.NewMeterQueryStatementBuilder(
-		settings,
-		telemetryMetadataStore,
-		metricFieldMapper,
-		metricConditionBuilder,
-		metricStmtBuilder,
-	)
-
-	// Create bucket cache
-	bucketCache := querier.NewBucketCache(
-		settings,
-		cache,
-		cfg.CacheTTL,
-		cfg.FluxInterval,
-	)
-
-	// Create and return the querier
-	return querier.New(
-		settings,
-		telemetryStore,
-		telemetryMetadataStore,
-		prometheus,
-		promV2,
-		traceStmtBuilder,
-		logStmtBuilder,
-		auditStmtBuilder,
-		metricStmtBuilder,
-		meterStmtBuilder,
-		traceOperatorStmtBuilder,
-		bucketCache,
-		flagger,
-		cfg.LogTraceIDWindowPadding,
-		cfg.MaxConcurrentQueries,
-	), nil
-}

pkg/query-service/app/clickhouseReader/reader.go

@@ -232,6 +232,25 @@ func NewReader(
 	}
 }
 
+func (r *ClickHouseReader) GetInstantQueryMetricsResult(ctx context.Context, queryParams *model.InstantQueryMetricsParams) (*promql.Result, *stats.QueryStats, *model.ApiError) {
+	qry, err := r.prometheus.Engine().NewInstantQuery(ctx, r.prometheus.Storage(), nil, queryParams.Query, queryParams.Time)
+	if err != nil {
+		return nil, nil, &model.ApiError{Typ: model.ErrorBadData, Err: err}
+	}
+
+	res := qry.Exec(ctx)
+
+	// Optional stats field in response if parameter "stats" is not empty.
+	var qs stats.QueryStats
+	if queryParams.Stats != "" {
+		qs = stats.NewQueryStats(qry.Stats())
+	}
+
+	qry.Close()
+	return res, &qs, nil
+
+}
+
 func (r *ClickHouseReader) GetQueryRangeResult(ctx context.Context, query *model.QueryRangeParams) (*promql.Result, *stats.QueryStats, *model.ApiError) {
 	qry, err := r.prometheus.Engine().NewRangeQuery(ctx, r.prometheus.Storage(), nil, query.Query, query.Start, query.End, query.Step)
 

pkg/query-service/app/http_handler.go

@@ -26,10 +26,11 @@ import (
 	"text/template"
 	"time"
 
+	"github.com/prometheus/prometheus/promql"
+
 	"github.com/SigNoz/signoz/pkg/http/middleware"
 	"github.com/SigNoz/signoz/pkg/http/render"
 	"github.com/SigNoz/signoz/pkg/licensing"
-	"github.com/SigNoz/signoz/pkg/prometheus/promapi"
 	"github.com/SigNoz/signoz/pkg/query-service/app/integrations"
 	"github.com/SigNoz/signoz/pkg/signoz"
 	"github.com/SigNoz/signoz/pkg/types/retentiontypes"
@@ -482,12 +483,8 @@ func (aH *APIHandler) Respond(w http.ResponseWriter, data interface{}) {
 
 // RegisterRoutes registers routes for this handler on the given router
 func (aH *APIHandler) RegisterRoutes(router *mux.Router, am *middleware.AuthZ) {
-	// PromQL-only endpoints, in Prometheus' own API shape, live under a
-	// /prometheus prefix so they are distinguishable from the SigNoz query
-	// APIs; Prometheus-compatible clients can be pointed at the prefix.
-	promAPI := promapi.NewHandler(aH.logger, aH.Signoz.Prometheus)
-	router.HandleFunc("/prometheus/api/v1/query_range", am.ViewAccess(promAPI.QueryRange)).Methods(http.MethodGet, http.MethodPost)
-	router.HandleFunc("/prometheus/api/v1/query", am.ViewAccess(promAPI.Query)).Methods(http.MethodGet, http.MethodPost)
+	router.HandleFunc("/api/v1/query_range", am.ViewAccess(aH.queryRangeMetrics)).Methods(http.MethodGet)
+	router.HandleFunc("/api/v1/query", am.ViewAccess(aH.queryMetrics)).Methods(http.MethodGet)
 	router.HandleFunc("/api/v1/rules", am.ViewAccess(aH.listRules)).Methods(http.MethodGet)
 	router.HandleFunc("/api/v1/rules/{id}", am.ViewAccess(aH.getRule)).Methods(http.MethodGet)
 	router.HandleFunc("/api/v1/rules", am.EditAccess(aH.createRule)).Methods(http.MethodPost)
@@ -1106,6 +1103,115 @@ func (aH *APIHandler) queryDashboardVarsV2(w http.ResponseWriter, r *http.Reques
 	aH.Respond(w, dashboardVars)
 }
 
+func (aH *APIHandler) queryRangeMetrics(w http.ResponseWriter, r *http.Request) {
+
+	query, apiErrorObj := parseQueryRangeRequest(r)
+
+	if apiErrorObj != nil {
+		RespondError(w, apiErrorObj, nil)
+		return
+	}
+
+	// TODO: add structured logging for query and apiError if needed
+
+	ctx := r.Context()
+	if to := r.FormValue("timeout"); to != "" {
+		var cancel context.CancelFunc
+		timeout, err := parseMetricsDuration(to)
+		if aH.HandleError(w, err, http.StatusBadRequest) {
+			return
+		}
+
+		ctx, cancel = context.WithTimeout(ctx, timeout)
+		defer cancel()
+	}
+
+	res, qs, apiError := aH.reader.GetQueryRangeResult(ctx, query)
+
+	if apiError != nil {
+		RespondError(w, apiError, nil)
+		return
+	}
+
+	if res.Err != nil {
+		aH.logger.ErrorContext(r.Context(), "error in query range metrics", errors.Attr(res.Err))
+	}
+
+	if res.Err != nil {
+		switch res.Err.(type) {
+		case promql.ErrQueryCanceled:
+			RespondError(w, &model.ApiError{Typ: model.ErrorCanceled, Err: res.Err}, nil)
+		case promql.ErrQueryTimeout:
+			RespondError(w, &model.ApiError{Typ: model.ErrorTimeout, Err: res.Err}, nil)
+		}
+		RespondError(w, &model.ApiError{Typ: model.ErrorExec, Err: res.Err}, nil)
+		return
+	}
+
+	response_data := &model.QueryData{
+		ResultType: res.Value.Type(),
+		Result:     res.Value,
+		Stats:      qs,
+	}
+
+	aH.Respond(w, response_data)
+
+}
+
+func (aH *APIHandler) queryMetrics(w http.ResponseWriter, r *http.Request) {
+
+	queryParams, apiErrorObj := parseInstantQueryMetricsRequest(r)
+
+	if apiErrorObj != nil {
+		RespondError(w, apiErrorObj, nil)
+		return
+	}
+
+	// TODO: add structured logging for query and apiError if needed
+
+	ctx := r.Context()
+	if to := r.FormValue("timeout"); to != "" {
+		var cancel context.CancelFunc
+		timeout, err := parseMetricsDuration(to)
+		if aH.HandleError(w, err, http.StatusBadRequest) {
+			return
+		}
+
+		ctx, cancel = context.WithTimeout(ctx, timeout)
+		defer cancel()
+	}
+
+	res, qs, apiError := aH.reader.GetInstantQueryMetricsResult(ctx, queryParams)
+
+	if apiError != nil {
+		RespondError(w, apiError, nil)
+		return
+	}
+
+	if res.Err != nil {
+		aH.logger.ErrorContext(r.Context(), "error in query range metrics", errors.Attr(res.Err))
+	}
+
+	if res.Err != nil {
+		switch res.Err.(type) {
+		case promql.ErrQueryCanceled:
+			RespondError(w, &model.ApiError{Typ: model.ErrorCanceled, Err: res.Err}, nil)
+		case promql.ErrQueryTimeout:
+			RespondError(w, &model.ApiError{Typ: model.ErrorTimeout, Err: res.Err}, nil)
+		}
+		RespondError(w, &model.ApiError{Typ: model.ErrorExec, Err: res.Err}, nil)
+	}
+
+	responseData := &model.QueryData{
+		ResultType: res.Value.Type(),
+		Result:     res.Value,
+		Stats:      qs,
+	}
+
+	aH.Respond(w, responseData)
+
+}
+
 func (aH *APIHandler) registerEvent(w http.ResponseWriter, r *http.Request) {
 	request, err := parseRegisterEventRequest(r)
 	if aH.HandleError(w, err, http.StatusBadRequest) {

pkg/query-service/app/parser.go

@@ -27,6 +27,7 @@ import (
 	queues2 "github.com/SigNoz/signoz/pkg/query-service/app/integrations/messagingQueues/queues"
 
 	"github.com/gorilla/mux"
+	promModel "github.com/prometheus/common/model"
 	"go.uber.org/multierr"
 
 	errorsV2 "github.com/SigNoz/signoz/pkg/errors"
@@ -87,6 +88,95 @@ func parseRegisterEventRequest(r *http.Request) (*model.RegisterEventParams, err
 	return postData, nil
 }
 
+func parseMetricsTime(s string) (time.Time, error) {
+	if t, err := strconv.ParseFloat(s, 64); err == nil {
+		s, ns := math.Modf(t)
+		return time.Unix(int64(s), int64(ns*float64(time.Second))), nil
+		// return time.Unix(0, t), nil
+	}
+	if t, err := time.Parse(time.RFC3339Nano, s); err == nil {
+		return t, nil
+	}
+	return time.Time{}, fmt.Errorf("cannot parse %q to a valid timestamp", s)
+}
+
+func parseMetricsDuration(s string) (time.Duration, error) {
+	if d, err := strconv.ParseFloat(s, 64); err == nil {
+		ts := d * float64(time.Second)
+		if ts > float64(math.MaxInt64) || ts < float64(math.MinInt64) {
+			return 0, fmt.Errorf("cannot parse %q to a valid duration. It overflows int64", s)
+		}
+		return time.Duration(ts), nil
+	}
+	if d, err := promModel.ParseDuration(s); err == nil {
+		return time.Duration(d), nil
+	}
+	return 0, fmt.Errorf("cannot parse %q to a valid duration", s)
+}
+
+func parseInstantQueryMetricsRequest(r *http.Request) (*model.InstantQueryMetricsParams, *model.ApiError) {
+	var ts time.Time
+	if t := r.FormValue("time"); t != "" {
+		var err error
+		ts, err = parseMetricsTime(t)
+		if err != nil {
+			return nil, &model.ApiError{Typ: model.ErrorBadData, Err: err}
+		}
+	} else {
+		ts = time.Now()
+	}
+
+	return &model.InstantQueryMetricsParams{
+		Time:  ts,
+		Query: r.FormValue("query"),
+		Stats: r.FormValue("stats"),
+	}, nil
+
+}
+
+func parseQueryRangeRequest(r *http.Request) (*model.QueryRangeParams, *model.ApiError) {
+
+	start, err := parseMetricsTime(r.FormValue("start"))
+	if err != nil {
+		return nil, &model.ApiError{Typ: model.ErrorBadData, Err: err}
+	}
+	end, err := parseMetricsTime(r.FormValue("end"))
+	if err != nil {
+		return nil, &model.ApiError{Typ: model.ErrorBadData, Err: err}
+	}
+	if end.Before(start) {
+		err := errors.New("end timestamp must not be before start time")
+		return nil, &model.ApiError{Typ: model.ErrorBadData, Err: err}
+	}
+
+	step, err := parseMetricsDuration(r.FormValue("step"))
+	if err != nil {
+		return nil, &model.ApiError{Typ: model.ErrorBadData, Err: err}
+	}
+
+	if step <= 0 {
+		err := errors.New("zero or negative query resolution step widths are not accepted. Try a positive integer")
+		return nil, &model.ApiError{Typ: model.ErrorBadData, Err: err}
+	}
+
+	// For safety, limit the number of returned points per timeseries.
+	// This is sufficient for 60s resolution for a week or 1h resolution for a year.
+	if end.Sub(start)/step > 11000 {
+		err := errors.New("exceeded maximum resolution of 11,000 points per timeseries. Try decreasing the query resolution (?step=XX)")
+		return nil, &model.ApiError{Typ: model.ErrorBadData, Err: err}
+	}
+
+	queryRangeParams := model.QueryRangeParams{
+		Start: start,
+		End:   end,
+		Step:  step,
+		Query: r.FormValue("query"),
+		Stats: r.FormValue("stats"),
+	}
+
+	return &queryRangeParams, nil
+}
+
 func parseGetUsageRequest(r *http.Request) (*model.GetUsageParams, error) {
 	startTime, err := parseTime("start", r)
 	if err != nil {

pkg/query-service/interfaces/interface.go

@@ -14,6 +14,7 @@ import (
 )
 
 type Reader interface {
+	GetInstantQueryMetricsResult(ctx context.Context, query *model.InstantQueryMetricsParams) (*promql.Result, *stats.QueryStats, *model.ApiError)
 	GetQueryRangeResult(ctx context.Context, query *model.QueryRangeParams) (*promql.Result, *stats.QueryStats, *model.ApiError)
 	GetTopLevelOperations(ctx context.Context, start, end time.Time, services []string) (*map[string][]string, *model.ApiError)
 	GetEntryPointOperations(ctx context.Context, query *model.GetTopOperationsParams) (*[]model.TopOperationsItem, error)

pkg/query-service/model/queryParams.go

@@ -4,6 +4,12 @@ import (
 	"time"
 )
 
+type InstantQueryMetricsParams struct {
+	Time  time.Time
+	Query string
+	Stats string
+}
+
 type QueryRangeParams struct {
 	Start time.Time
 	End   time.Time

pkg/query-service/rules/managertestfactory.go

@@ -18,6 +18,13 @@ import (
 	"github.com/SigNoz/signoz/pkg/querier/signozquerier"
 	"github.com/SigNoz/signoz/pkg/sqlstore"
 	"github.com/SigNoz/signoz/pkg/sqlstore/sqlstoretest"
+	"github.com/SigNoz/signoz/pkg/statementbuilder"
+	"github.com/SigNoz/signoz/pkg/statementbuilder/auditstatementbuilder"
+	"github.com/SigNoz/signoz/pkg/statementbuilder/logsstatementbuilder"
+	"github.com/SigNoz/signoz/pkg/statementbuilder/meterstatementbuilder"
+	"github.com/SigNoz/signoz/pkg/statementbuilder/metricsstatementbuilder"
+	"github.com/SigNoz/signoz/pkg/statementbuilder/tracesstatementbuilder"
+	"github.com/SigNoz/signoz/pkg/telemetrymetadata"
 	"github.com/SigNoz/signoz/pkg/telemetrystore"
 	"github.com/SigNoz/signoz/pkg/telemetrystore/telemetrystoretest"
 	"github.com/stretchr/testify/require"
@@ -105,7 +112,23 @@ func NewTestManager(t *testing.T, testOpts *TestManagerOptions) *Manager {
 	}
 
 	// Create querier with test values
-	providerFactory := signozquerier.NewFactory(telemetryStore, prometheus, nil, cache, flagger)
+	metadataStore := telemetrymetadata.NewTelemetryMetaStore(providerSettings, telemetryStore, flagger)
+	cfg := statementbuilder.Config{}
+	ctx := context.Background()
+	traceStmtBuilder, err := tracesstatementbuilder.NewFactory(telemetryStore, metadataStore, flagger).New(ctx, providerSettings, cfg)
+	require.NoError(t, err)
+	traceOperatorStmtBuilder, err := tracesstatementbuilder.NewOperatorFactory(telemetryStore, metadataStore, flagger).New(ctx, providerSettings, cfg)
+	require.NoError(t, err)
+	logStmtBuilder, err := logsstatementbuilder.NewFactory(telemetryStore, metadataStore, flagger).New(ctx, providerSettings, cfg)
+	require.NoError(t, err)
+	auditStmtBuilder, err := auditstatementbuilder.NewFactory(metadataStore, flagger).New(ctx, providerSettings, cfg)
+	require.NoError(t, err)
+	metricStmtBuilder, err := metricsstatementbuilder.NewFactory(metadataStore, flagger).New(ctx, providerSettings, cfg)
+	require.NoError(t, err)
+	meterStmtBuilder, err := meterstatementbuilder.NewFactory(metadataStore, flagger).New(ctx, providerSettings, cfg)
+	require.NoError(t, err)
+	bucketCache := querier.NewBucketCache(providerSettings, cache, 0, 0)
+	providerFactory := signozquerier.NewFactory(telemetryStore, prometheus, metadataStore, traceStmtBuilder, logStmtBuilder, auditStmtBuilder, metricStmtBuilder, meterStmtBuilder, traceOperatorStmtBuilder, bucketCache, flagger)
 	mockQuerier, err := providerFactory.New(context.Background(), providerSettings, querier.Config{})
 	require.NoError(t, err)
 

pkg/query-service/rules/setups_test.go

@@ -8,11 +8,11 @@ import (
 	"github.com/SigNoz/signoz/pkg/flagger"
 	"github.com/SigNoz/signoz/pkg/instrumentation/instrumentationtest"
 	"github.com/SigNoz/signoz/pkg/querier"
-	"github.com/SigNoz/signoz/pkg/querybuilder"
-	"github.com/SigNoz/signoz/pkg/telemetrylogs"
-	"github.com/SigNoz/signoz/pkg/telemetrymetrics"
+	"github.com/SigNoz/signoz/pkg/statementbuilder"
+	"github.com/SigNoz/signoz/pkg/statementbuilder/logsstatementbuilder"
+	"github.com/SigNoz/signoz/pkg/statementbuilder/metricsstatementbuilder"
+	"github.com/SigNoz/signoz/pkg/statementbuilder/tracesstatementbuilder"
 	"github.com/SigNoz/signoz/pkg/telemetrystore"
-	"github.com/SigNoz/signoz/pkg/telemetrytraces"
 	"github.com/SigNoz/signoz/pkg/types/telemetrytypes"
 	"github.com/SigNoz/signoz/pkg/types/telemetrytypes/telemetrytypestest"
 	"github.com/stretchr/testify/require"
@@ -24,7 +24,7 @@ func prepareQuerierForMetrics(t *testing.T, telemetryStore telemetrystore.Teleme
 	providerSettings := instrumentationtest.New().ToProviderSettings()
 	metadataStore := telemetrytypestest.NewMockMetadataStore()
 
-	flagger, err := flagger.New(
+	fl, err := flagger.New(
 		context.Background(),
 		instrumentationtest.New().ToProviderSettings(),
 		flagger.Config{},
@@ -32,22 +32,14 @@ func prepareQuerierForMetrics(t *testing.T, telemetryStore telemetrystore.Teleme
 	)
 	require.NoError(t, err)
 
-	metricFieldMapper := telemetrymetrics.NewFieldMapper()
-	metricConditionBuilder := telemetrymetrics.NewConditionBuilder(metricFieldMapper)
-	metricStmtBuilder := telemetrymetrics.NewMetricQueryStatementBuilder(
-		providerSettings,
-		metadataStore,
-		metricFieldMapper,
-		metricConditionBuilder,
-		flagger,
-	)
+	metricStmtBuilder, err := metricsstatementbuilder.NewFactory(metadataStore, fl).New(context.Background(), providerSettings, statementbuilder.Config{})
+	require.NoError(t, err)
 
 	return querier.New(
 		providerSettings,
 		telemetryStore,
 		metadataStore,
 		nil, // prometheus
-		nil, // promV2
 		nil, // traceStmtBuilder
 		nil, // logStmtBuilder
 		nil, // auditStmtBuilder
@@ -55,7 +47,7 @@ func prepareQuerierForMetrics(t *testing.T, telemetryStore telemetrystore.Teleme
 		nil, // meterStmtBuilder
 		nil, // traceOperatorStmtBuilder
 		nil, // bucketCache
-		flagger,
+		fl,
 		0,
 		0, // maxConcurrentQueries (0 means default)
 	), metadataStore
@@ -74,41 +66,21 @@ func prepareQuerierForLogs(t *testing.T, telemetryStore telemetrystore.Telemetry
 	metadataStore.KeysMap = keysMap
 
 	fl := flaggertest.New(t)
-	logFieldMapper := telemetrylogs.NewFieldMapper(fl)
-	logConditionBuilder := telemetrylogs.NewConditionBuilder(logFieldMapper, fl)
-	logAggExprRewriter := querybuilder.NewAggExprRewriter(
-		providerSettings,
-		telemetrylogs.DefaultFullTextColumn,
-		logFieldMapper,
-		logConditionBuilder,
-		fl,
-	)
-	logStmtBuilder := telemetrylogs.NewLogQueryStatementBuilder(
-		providerSettings,
-		metadataStore,
-		logFieldMapper,
-		logConditionBuilder,
-		logAggExprRewriter,
-		telemetrylogs.DefaultFullTextColumn,
-		fl,
-		nil,
-		false,
-		100000,
-	)
+	logStmtBuilder, err := logsstatementbuilder.NewFactory(nil, metadataStore, fl).New(context.Background(), providerSettings, statementbuilder.Config{})
+	require.NoError(t, err)
 
 	return querier.New(
 		providerSettings,
 		telemetryStore,
 		metadataStore,
-		nil,            // prometheus
-		nil,            // promV2
-		nil,            // traceStmtBuilder
-		logStmtBuilder, // logStmtBuilder
-		nil,            // auditStmtBuilder
-		nil,            // metricStmtBuilder
-		nil,            // meterStmtBuilder
-		nil,            // traceOperatorStmtBuilder
-		nil,            // bucketCache
+		nil, // prometheus
+		nil, // traceStmtBuilder
+		logStmtBuilder,
+		nil, // auditStmtBuilder
+		nil, // metricStmtBuilder
+		nil, // meterStmtBuilder
+		nil, // traceOperatorStmtBuilder
+		nil, // bucketCache
 		fl,
 		5*time.Minute, // logTraceIDWindowPadding
 		0,             // maxConcurrentQueries (0 means default)
@@ -128,37 +100,22 @@ func prepareQuerierForTraces(t *testing.T, telemetryStore telemetrystore.Telemet
 	}
 	metadataStore.KeysMap = keysMap
 
-	// Create trace statement builder
-	traceFieldMapper := telemetrytraces.NewFieldMapper()
-	traceConditionBuilder := telemetrytraces.NewConditionBuilder(traceFieldMapper)
-
 	fl := flaggertest.New(t)
-	traceAggExprRewriter := querybuilder.NewAggExprRewriter(providerSettings, nil, traceFieldMapper, traceConditionBuilder, fl)
-	traceStmtBuilder := telemetrytraces.NewTraceQueryStatementBuilder(
-		providerSettings,
-		metadataStore,
-		traceFieldMapper,
-		traceConditionBuilder,
-		traceAggExprRewriter,
-		telemetryStore,
-		fl,
-		false,
-		100000,
-	)
+	traceStmtBuilder, err := tracesstatementbuilder.NewFactory(telemetryStore, metadataStore, fl).New(context.Background(), providerSettings, statementbuilder.Config{})
+	require.NoError(t, err)
 
 	return querier.New(
 		providerSettings,
 		telemetryStore,
 		metadataStore,
-		nil,              // prometheus
-		nil,              // promV2
-		traceStmtBuilder, // traceStmtBuilder
-		nil,              // logStmtBuilder
-		nil,              // auditStmtBuilder
-		nil,              // metricStmtBuilder
-		nil,              // meterStmtBuilder
-		nil,              // traceOperatorStmtBuilder
-		nil,              // bucketCache
+		nil, // prometheus
+		traceStmtBuilder,
+		nil, // logStmtBuilder
+		nil, // auditStmtBuilder
+		nil, // metricStmtBuilder
+		nil, // meterStmtBuilder
+		nil, // traceOperatorStmtBuilder
+		nil, // bucketCache
 		fl,
 		0,
 		0, // maxConcurrentQueries (0 means default)

pkg/querybuilder/clickhouse_sql.go

@@ -9,6 +9,16 @@ import (
 	"github.com/SigNoz/signoz/pkg/errors"
 )
 
+var (
+	CodeClickHouseSQLParserPanic        = errors.MustNewCode("clickhouse_sql_parser_panic")
+	CodeClickHouseSQLUnparseable        = errors.MustNewCode("clickhouse_sql_unparseable")
+	CodeClickHouseSQLNotSingleStatement = errors.MustNewCode("clickhouse_sql_not_single_statement")
+	CodeClickHouseSQLNotSelect          = errors.MustNewCode("clickhouse_sql_not_select")
+	CodeClickHouseSQLTableFunction      = errors.MustNewCode("clickhouse_sql_table_function")
+	CodeClickHouseSQLInternalDatabase   = errors.MustNewCode("clickhouse_sql_internal_database")
+	CodeClickHouseSQLReadonlyOverride   = errors.MustNewCode("clickhouse_sql_readonly_override")
+)
+
 // internalDatabases hold server metadata, credentials and grants rather than telemetry.
 var internalDatabases = map[string]struct{}{
 	"system":             {},
@@ -20,30 +30,30 @@ func ErrIfStatementIsNotValid(query string) (err error) {
 	defer func() {
 		// The parser has a history of panicking on malformed input rather than returning an error.
 		if recovered := recover(); recovered != nil {
-			err = errors.NewInvalidInputf(errors.CodeInvalidInput, "invalid ClickHouse SQL (recovered): %v", recovered)
+			err = errors.NewInvalidInputf(CodeClickHouseSQLParserPanic, "invalid ClickHouse SQL (recovered): %v", recovered)
 		}
 	}()
 
 	stmts, parseErr := chparser.NewParser(query).ParseStmts()
 	if parseErr != nil {
 		// Wrapped rather than formatted in, so that callers can recover the parser's *ParseError and read the position off it.
-		return errors.WrapInvalidInputf(parseErr, errors.CodeInvalidInput, "invalid ClickHouse SQL: %s", parseErr.Error())
+		return errors.WrapInvalidInputf(parseErr, CodeClickHouseSQLUnparseable, "invalid ClickHouse SQL: %s", parseErr.Error())
 	}
 
 	if len(stmts) != 1 {
-		return errors.NewInvalidInputf(errors.CodeInvalidInput, "ClickHouse SQL must contain exactly one statement, found %d statements", len(stmts))
+		return errors.NewInvalidInputf(CodeClickHouseSQLNotSingleStatement, "ClickHouse SQL must contain exactly one statement, found %d statements", len(stmts))
 	}
 
 	selectQuery, ok := stmts[0].(*chparser.SelectQuery)
 	if !ok {
-		return errors.NewInvalidInputf(errors.CodeInvalidInput, "only SELECT statements are allowed in ClickHouse SQL queries")
+		return errors.NewInvalidInputf(CodeClickHouseSQLNotSelect, "only SELECT statements are allowed in ClickHouse SQL queries")
 	}
 
 	visitor := &chparser.DefaultASTVisitor{Visit: func(node chparser.Expr) error {
 		switch expr := node.(type) {
 		case *chparser.TableFunctionExpr:
 			// Source table functions remain usable in ClickHouse read-only mode.
-			return errors.NewInvalidInputf(errors.CodeInvalidInput, "ClickHouse table functions are not allowed in SQL queries: %s", chparser.Format(expr.Name))
+			return errors.NewInvalidInputf(CodeClickHouseSQLTableFunction, "ClickHouse table functions are not allowed in SQL queries: %s", chparser.Format(expr.Name))
 
 		case *chparser.TableIdentifier:
 			// Reading these is unaffected by ClickHouse read-only mode.
@@ -52,13 +62,13 @@ func ErrIfStatementIsNotValid(query string) (err error) {
 			}
 
 			if _, ok := internalDatabases[strings.ToLower(expr.Database.Name)]; ok {
-				return errors.NewInvalidInputf(errors.CodeInvalidInput, "the ClickHouse %s database is not allowed in SQL queries", expr.Database.Name)
+				return errors.NewInvalidInputf(CodeClickHouseSQLInternalDatabase, "the ClickHouse %s database is not allowed in SQL queries", expr.Database.Name)
 			}
 
 		case *chparser.SettingExpr:
 			// A query-level setting takes precedence over the context setting.
 			if strings.EqualFold(expr.Name.Name, "readonly") {
-				return errors.NewInvalidInputf(errors.CodeInvalidInput, "the ClickHouse readonly setting cannot be overridden")
+				return errors.NewInvalidInputf(CodeClickHouseSQLReadonlyOverride, "the ClickHouse readonly setting cannot be overridden")
 			}
 		}
 

pkg/querybuilder/clickhouse_sql_test.go

@@ -3,6 +3,8 @@ package querybuilder
 import (
 	"testing"
 
+	"github.com/SigNoz/signoz/pkg/errors"
+
 	chparser "github.com/AfterShip/clickhouse-sql-parser/parser"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
@@ -30,10 +32,15 @@ func TestErrIfStatementIsNotValid_Pass(t *testing.T) {
 		{"TrailingUnterminatedBlockComment", "SELECT count() FROM t /* unterminated"},
 		// The rule keys on the database, not on the table name.
 		{"TableNamedSystemInTelemetryDatabase", "SELECT * FROM signoz_logs.system"},
-		{"SignedLiteralAfterClosingParen", "SELECT (toUnixTimestamp(now()) - 3600)*1000000000"},
+		{"SignedLiteralAfterClosingParenSpaced", "SELECT (toUnixTimestamp(now()) - 3600)*1000000000"},
 		// order by interval
 		{"OrderByInterval", "SELECT toStartOfInterval(timestamp, INTERVAL 1 MINUTE) AS interval ORDER BY interval"},
 		{"OrderByIntervalAndDirection", "SELECT toStartOfInterval(timestamp, INTERVAL 1 MINUTE) AS `interval` ORDER BY `interval` ASC"},
+		// Unspaced, so rejected until the parser stopped lexing a signed literal after a
+		// closing bracket. The spaced form above no longer needs to be spaced.
+		// https://github.com/AfterShip/clickhouse-sql-parser/issues/286
+		{"SignedLiteralAfterClosingParenUnspaced", "SELECT now() AS ts, toFloat64(count()) AS value FROM ( SELECT attributes_string['TableName'] AS T, attributes_string['MissingId'] AS M, max(fromUnixTimestamp64Nano(timestamp)) AS last_seen, dateDiff('minute', min(fromUnixTimestamp64Nano(timestamp)), max(fromUnixTimestamp64Nano(timestamp))) AS age_min FROM signoz_logs.distributed_logs_v2 WHERE body='missing_map_record' AND timestamp >= (toUnixTimestamp(now())-3600)*1000000000 GROUP BY T, M ) WHERE age_min >= 20 AND last_seen >= now() - toIntervalMinute(8)"},
+		{"SignedLiteralAfterClosingParenMinimal", "SELECT (1)-1"},
 		{"TrimFunction", "SELECT trimBoth('/api/endpoint/', '/');"},
 	}
 
@@ -47,49 +54,52 @@ func TestErrIfStatementIsNotValid_Pass(t *testing.T) {
 
 func TestErrIfStatementIsNotValid_Fail(t *testing.T) {
 	testCases := []struct {
-		name  string
-		query string
+		name         string
+		query        string
+		expectedCode errors.Code
 	}{
 		// Not a single statement, or not a statement at all.
-		{"Empty", ""},
-		{"UnterminatedBlockCommentOnly", "/* x"},
-		{"Unparseable", "SELECT FROM WHERE"},
-		{"MultipleStatements", "SELECT 1; DROP TABLE signoz_logs.logs_v2"},
+		{"Empty", "", CodeClickHouseSQLNotSingleStatement},
+		{"UnterminatedBlockCommentOnly", "/* x", CodeClickHouseSQLUnparseable},
+		{"Unparseable", "SELECT FROM WHERE", CodeClickHouseSQLUnparseable},
+		{"MultipleStatements", "SELECT 1; DROP TABLE signoz_logs.logs_v2", CodeClickHouseSQLNotSingleStatement},
 		// Parses, but is not a SELECT.
-		{"Drop", "DROP TABLE signoz_logs.logs_v2"},
-		{"Insert", "INSERT INTO signoz_logs.logs_v2 SELECT * FROM signoz_logs.logs_v2"},
-		{"AlterDelete", "ALTER TABLE signoz_logs.logs_v2 DELETE WHERE 1 = 1"},
-		{"CreateTable", "CREATE TABLE evil (a Int) ENGINE = Memory"},
-		{"Grant", "GRANT ALL ON *.* TO admin"},
-		{"Set", "SET readonly = 0"},
+		{"Drop", "DROP TABLE signoz_logs.logs_v2", CodeClickHouseSQLNotSelect},
+		{"Insert", "INSERT INTO signoz_logs.logs_v2 SELECT * FROM signoz_logs.logs_v2", CodeClickHouseSQLNotSelect},
+		{"AlterDelete", "ALTER TABLE signoz_logs.logs_v2 DELETE WHERE 1 = 1", CodeClickHouseSQLNotSelect},
+		{"CreateTable", "CREATE TABLE evil (a Int) ENGINE = Memory", CodeClickHouseSQLNotSelect},
+		{"Grant", "GRANT ALL ON *.* TO admin", CodeClickHouseSQLNotSelect},
+		{"Set", "SET readonly = 0", CodeClickHouseSQLNotSelect},
 		// These the parser rejects outright rather than classifying.
-		{"ShowGrants", "SHOW GRANTS"},
-		{"IntoOutfile", "SELECT * FROM t INTO OUTFILE '/tmp/x.csv'"},
+		{"ShowGrants", "SHOW GRANTS", CodeClickHouseSQLUnparseable},
+		{"IntoOutfile", "SELECT * FROM t INTO OUTFILE '/tmp/x.csv'", CodeClickHouseSQLUnparseable},
 		// Table functions, which read through something other than a telemetry table.
-		{"UrlTableFunction", "SELECT * FROM url('http://attacker.example/x', CSV, 'a String')"},
-		{"FileTableFunction", "SELECT * FROM file('/etc/passwd', CSV, 'a String')"},
-		{"ExecutableTableFunction", "SELECT * FROM executable('script.sh', CSV, 'a String')"},
-		{"TableFunctionInJoin", "SELECT * FROM t1 JOIN url('http://x', CSV, 'a String') u ON 1 = 1"},
-		{"TableFunctionInCommonTableExpression", "WITH c AS (SELECT * FROM url('http://x', CSV, 'a String')) SELECT * FROM c"},
-		{"TableFunctionInWhereSubquery", "SELECT * FROM t WHERE a IN (SELECT * FROM file('/etc/passwd', CSV, 'a String'))"},
-		{"TableFunctionInUnion", "SELECT * FROM t UNION ALL SELECT * FROM url('http://x', CSV, 'a String')"},
+		{"UrlTableFunction", "SELECT * FROM url('http://attacker.example/x', CSV, 'a String')", CodeClickHouseSQLTableFunction},
+		{"FileTableFunction", "SELECT * FROM file('/etc/passwd', CSV, 'a String')", CodeClickHouseSQLTableFunction},
+		{"ExecutableTableFunction", "SELECT * FROM executable('script.sh', CSV, 'a String')", CodeClickHouseSQLTableFunction},
+		{"TableFunctionInJoin", "SELECT * FROM t1 JOIN url('http://x', CSV, 'a String') u ON 1 = 1", CodeClickHouseSQLTableFunction},
+		{"TableFunctionInCommonTableExpression", "WITH c AS (SELECT * FROM url('http://x', CSV, 'a String')) SELECT * FROM c", CodeClickHouseSQLTableFunction},
+		{"TableFunctionInWhereSubquery", "SELECT * FROM t WHERE a IN (SELECT * FROM file('/etc/passwd', CSV, 'a String'))", CodeClickHouseSQLTableFunction},
+		{"TableFunctionInUnion", "SELECT * FROM t UNION ALL SELECT * FROM url('http://x', CSV, 'a String')", CodeClickHouseSQLTableFunction},
 		// Internal databases, which hold grants and server metadata rather than telemetry.
-		{"SystemUsers", "SELECT * FROM system.users"},
-		{"SystemUppercase", "SELECT * FROM SYSTEM.USERS"},
-		{"SystemQuoted", "SELECT count() FROM `system`.`tables`"},
-		{"SystemInSubquery", "SELECT * FROM (SELECT name FROM system.parts)"},
-		{"SystemInJoin", "SELECT * FROM signoz_logs.distributed_logs_v2 AS l JOIN system.users AS u ON 1 = 1"},
-		{"SystemInIntersect", "SELECT * FROM t INTERSECT SELECT * FROM system.users"},
-		{"InformationSchema", "SELECT * FROM information_schema.tables"},
+		{"SystemUsers", "SELECT * FROM system.users", CodeClickHouseSQLInternalDatabase},
+		{"SystemUppercase", "SELECT * FROM SYSTEM.USERS", CodeClickHouseSQLInternalDatabase},
+		{"SystemQuoted", "SELECT count() FROM `system`.`tables`", CodeClickHouseSQLInternalDatabase},
+		{"SystemInSubquery", "SELECT * FROM (SELECT name FROM system.parts)", CodeClickHouseSQLInternalDatabase},
+		{"SystemInJoin", "SELECT * FROM signoz_logs.distributed_logs_v2 AS l JOIN system.users AS u ON 1 = 1", CodeClickHouseSQLInternalDatabase},
+		{"SystemInIntersect", "SELECT * FROM t INTERSECT SELECT * FROM system.users", CodeClickHouseSQLInternalDatabase},
+		{"InformationSchema", "SELECT * FROM information_schema.tables", CodeClickHouseSQLInternalDatabase},
 		// A query-level setting takes precedence over the one the caller applies.
-		{"ReadonlySettingOverride", "SELECT * FROM t SETTINGS readonly = 0"},
-		{"ReadonlySettingOverrideAmongOthers", "SELECT * FROM t SETTINGS max_threads = 4, readonly = 0"},
+		{"ReadonlySettingOverride", "SELECT * FROM t SETTINGS readonly = 0", CodeClickHouseSQLReadonlyOverride},
+		{"ReadonlySettingOverrideAmongOthers", "SELECT * FROM t SETTINGS max_threads = 4, readonly = 0", CodeClickHouseSQLReadonlyOverride},
 	}
 
 	for _, testCase := range testCases {
 		t.Run(testCase.name, func(t *testing.T) {
 			err := ErrIfStatementIsNotValid(testCase.query)
+
 			assert.Error(t, err)
+			assert.True(t, errors.Asc(err, testCase.expectedCode), "expected code %s, got %v", testCase.expectedCode, err)
 		})
 	}
 }
@@ -122,18 +132,6 @@ func TestErrIfStatementIsNotValid_ShouldPassButFails(t *testing.T) {
 			expectedStopsAfter: "trim(BOTH '",
 			fix:                "SELECT trimBoth(replaceOne( JSONExtractString(body, 'Action'), 'health_status: ', '' ), ' ')",
 		},
-		{
-			name:               "SignedLiteralAfterClosingParen",
-			query:              "SELECT now() AS ts, toFloat64(count()) AS value FROM ( SELECT attributes_string['TableName'] AS T, attributes_string['MissingId'] AS M, max(fromUnixTimestamp64Nano(timestamp)) AS last_seen, dateDiff('minute', min(fromUnixTimestamp64Nano(timestamp)), max(fromUnixTimestamp64Nano(timestamp))) AS age_min FROM signoz_logs.distributed_logs_v2 WHERE body='missing_map_record' AND timestamp >= (toUnixTimestamp(now())-3600)*1000000000 GROUP BY T, M ) WHERE age_min >= 20 AND last_seen >= now() - toIntervalMinute(8)",
-			expectedStopsAfter: "(toUnixTimestamp(now())",
-			fix:                "SELECT (toUnixTimestamp(now()) - 3600) * 1000000000",
-		},
-		{
-			name:               "SignedLiteralAfterClosingParenMinimal",
-			query:              "SELECT (1)-1",
-			expectedStopsAfter: "(1)",
-			fix:                "SELECT (1) - 1",
-		},
 	}
 
 	for _, testCase := range testCases {

pkg/signoz/config.go

@@ -39,6 +39,7 @@ import (
 	"github.com/SigNoz/signoz/pkg/sqlmigrator"
 	"github.com/SigNoz/signoz/pkg/sqlschema"
 	"github.com/SigNoz/signoz/pkg/sqlstore"
+	"github.com/SigNoz/signoz/pkg/statementbuilder"
 	"github.com/SigNoz/signoz/pkg/statsreporter"
 	"github.com/SigNoz/signoz/pkg/telemetrystore"
 	"github.com/SigNoz/signoz/pkg/tokenizer"
@@ -97,6 +98,9 @@ type Config struct {
 	// Querier config
 	Querier querier.Config `mapstructure:"querier"`
 
+	// StatementBuilder config
+	StatementBuilder statementbuilder.Config `mapstructure:"statementbuilder"`
+
 	// Ruler config
 	Ruler ruler.Config `mapstructure:"ruler"`
 
@@ -166,6 +170,7 @@ func NewConfig(ctx context.Context, logger *slog.Logger, resolverConfig config.R
 		prometheus.NewConfigFactory(),
 		alertmanager.NewConfigFactory(),
 		querier.NewConfigFactory(),
+		statementbuilder.NewConfigFactory(),
 		ruler.NewConfigFactory(),
 		emailing.NewConfigFactory(),
 		sharder.NewConfigFactory(),

pkg/signoz/provider.go

@@ -45,7 +45,6 @@ import (
 	"github.com/SigNoz/signoz/pkg/pprof/nooppprof"
 	"github.com/SigNoz/signoz/pkg/prometheus"
 	"github.com/SigNoz/signoz/pkg/prometheus/clickhouseprometheus"
-	"github.com/SigNoz/signoz/pkg/prometheus/clickhouseprometheusv2"
 	"github.com/SigNoz/signoz/pkg/querier"
 	"github.com/SigNoz/signoz/pkg/querier/signozquerier"
 	"github.com/SigNoz/signoz/pkg/sharder"
@@ -70,6 +69,8 @@ import (
 	"github.com/SigNoz/signoz/pkg/types/alertmanagertypes"
 	"github.com/SigNoz/signoz/pkg/types/dashboardtypes"
 	"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/version"
 	"github.com/SigNoz/signoz/pkg/web"
 	"github.com/SigNoz/signoz/pkg/web/noopweb"
@@ -228,6 +229,7 @@ func NewSQLMigrationProviderFactories(
 		sqlmigration.NewAddTelemetryTuplesFactory(sqlstore),
 		sqlmigration.NewAddTagRelationRankFactory(sqlstore, sqlschema),
 		sqlmigration.NewMigrateDashboardsV1ToV2Factory(sqlstore, sqlschema, dashboardStore, tagModule),
+		sqlmigration.NewFillDashboardMeterSourceFactory(sqlstore, dashboardStore),
 	)
 }
 
@@ -245,7 +247,6 @@ func NewTelemetryStoreProviderFactories() factory.NamedMap[factory.ProviderFacto
 func NewPrometheusProviderFactories(telemetryStore telemetrystore.TelemetryStore) factory.NamedMap[factory.ProviderFactory[prometheus.Prometheus, prometheus.Config]] {
 	return factory.MustNewNamedMap(
 		clickhouseprometheus.NewFactory(telemetryStore),
-		clickhouseprometheusv2.NewFactory(telemetryStore),
 	)
 }
 
@@ -287,9 +288,9 @@ func NewStatsReporterProviderFactories(aggregator statsreporter.Aggregator, orgG
 	)
 }
 
-func NewQuerierProviderFactories(telemetryStore telemetrystore.TelemetryStore, prometheus prometheus.Prometheus, promV2 *clickhouseprometheusv2.Provider, cache cache.Cache, flagger flagger.Flagger) factory.NamedMap[factory.ProviderFactory[querier.Querier, querier.Config]] {
+func NewQuerierProviderFactories(telemetryStore telemetrystore.TelemetryStore, prometheus prometheus.Prometheus, metadataStore telemetrytypes.MetadataStore, traceStmtBuilder qbtypes.StatementBuilder[qbtypes.TraceAggregation], logStmtBuilder qbtypes.StatementBuilder[qbtypes.LogAggregation], auditStmtBuilder qbtypes.StatementBuilder[qbtypes.LogAggregation], metricStmtBuilder qbtypes.StatementBuilder[qbtypes.MetricAggregation], meterStmtBuilder qbtypes.StatementBuilder[qbtypes.MetricAggregation], traceOperatorStmtBuilder qbtypes.TraceOperatorStatementBuilder, bucketCache querier.BucketCache, flagger flagger.Flagger) factory.NamedMap[factory.ProviderFactory[querier.Querier, querier.Config]] {
 	return factory.MustNewNamedMap(
-		signozquerier.NewFactory(telemetryStore, prometheus, promV2, cache, flagger),
+		signozquerier.NewFactory(telemetryStore, prometheus, metadataStore, traceStmtBuilder, logStmtBuilder, auditStmtBuilder, metricStmtBuilder, meterStmtBuilder, traceOperatorStmtBuilder, bucketCache, flagger),
 	)
 }
 

pkg/signoz/signoz.go

@@ -40,7 +40,6 @@ import (
 	"github.com/SigNoz/signoz/pkg/modules/tag/impltag"
 	"github.com/SigNoz/signoz/pkg/modules/user/impluser"
 	"github.com/SigNoz/signoz/pkg/prometheus"
-	"github.com/SigNoz/signoz/pkg/prometheus/clickhouseprometheusv2"
 	"github.com/SigNoz/signoz/pkg/querier"
 	"github.com/SigNoz/signoz/pkg/queryparser"
 	"github.com/SigNoz/signoz/pkg/ruler"
@@ -49,16 +48,17 @@ import (
 	"github.com/SigNoz/signoz/pkg/sqlmigrator"
 	"github.com/SigNoz/signoz/pkg/sqlschema"
 	"github.com/SigNoz/signoz/pkg/sqlstore"
+	"github.com/SigNoz/signoz/pkg/statementbuilder/auditstatementbuilder"
+	"github.com/SigNoz/signoz/pkg/statementbuilder/logsstatementbuilder"
+	"github.com/SigNoz/signoz/pkg/statementbuilder/meterstatementbuilder"
+	"github.com/SigNoz/signoz/pkg/statementbuilder/metricsstatementbuilder"
+	"github.com/SigNoz/signoz/pkg/statementbuilder/tracesstatementbuilder"
 	"github.com/SigNoz/signoz/pkg/statsreporter"
-	"github.com/SigNoz/signoz/pkg/telemetryaudit"
-	"github.com/SigNoz/signoz/pkg/telemetrylogs"
 	"github.com/SigNoz/signoz/pkg/telemetrymetadata"
-	"github.com/SigNoz/signoz/pkg/telemetrymeter"
-	"github.com/SigNoz/signoz/pkg/telemetrymetrics"
 	"github.com/SigNoz/signoz/pkg/telemetrystore"
-	"github.com/SigNoz/signoz/pkg/telemetrytraces"
 	pkgtokenizer "github.com/SigNoz/signoz/pkg/tokenizer"
 	"github.com/SigNoz/signoz/pkg/types/authtypes"
+	qbtypes "github.com/SigNoz/signoz/pkg/types/querybuildertypes/querybuildertypesv5"
 	"github.com/SigNoz/signoz/pkg/types/telemetrytypes"
 	"github.com/SigNoz/signoz/pkg/version"
 	"github.com/SigNoz/signoz/pkg/zeus"
@@ -97,6 +97,62 @@ type SigNoz struct {
 	MeterReporter          meterreporter.Reporter
 }
 
+// newQueryStack assembles the query stack once and returns, in order: the shared
+// telemetry metadata store (reused elsewhere in signoz.New), the per-signal
+// statement builders (trace, log, audit, metric, meter, trace-operator), and the
+// bucket cache. It is the only place that imports the concrete statement-builder
+// sub-packages.
+func newQueryStack(
+	ctx context.Context,
+	settings factory.ProviderSettings,
+	config Config,
+	telemetryStore telemetrystore.TelemetryStore,
+	cache cache.Cache,
+	fl flagger.Flagger,
+) (
+	telemetrytypes.MetadataStore,
+	qbtypes.StatementBuilder[qbtypes.TraceAggregation],
+	qbtypes.StatementBuilder[qbtypes.LogAggregation],
+	qbtypes.StatementBuilder[qbtypes.LogAggregation],
+	qbtypes.StatementBuilder[qbtypes.MetricAggregation],
+	qbtypes.StatementBuilder[qbtypes.MetricAggregation],
+	qbtypes.TraceOperatorStatementBuilder,
+	querier.BucketCache,
+	error,
+) {
+	metadataStore := telemetrymetadata.NewTelemetryMetaStore(settings, telemetryStore, fl)
+
+	cfg := config.StatementBuilder
+	traceStmtBuilder, err := tracesstatementbuilder.NewFactory(telemetryStore, metadataStore, fl).New(ctx, settings, cfg)
+	if err != nil {
+		return nil, nil, nil, nil, nil, nil, nil, nil, err
+	}
+	traceOperatorStmtBuilder, err := tracesstatementbuilder.NewOperatorFactory(telemetryStore, metadataStore, fl).New(ctx, settings, cfg)
+	if err != nil {
+		return nil, nil, nil, nil, nil, nil, nil, nil, err
+	}
+	logStmtBuilder, err := logsstatementbuilder.NewFactory(telemetryStore, metadataStore, fl).New(ctx, settings, cfg)
+	if err != nil {
+		return nil, nil, nil, nil, nil, nil, nil, nil, err
+	}
+	auditStmtBuilder, err := auditstatementbuilder.NewFactory(metadataStore, fl).New(ctx, settings, cfg)
+	if err != nil {
+		return nil, nil, nil, nil, nil, nil, nil, nil, err
+	}
+	metricStmtBuilder, err := metricsstatementbuilder.NewFactory(metadataStore, fl).New(ctx, settings, cfg)
+	if err != nil {
+		return nil, nil, nil, nil, nil, nil, nil, nil, err
+	}
+	meterStmtBuilder, err := meterstatementbuilder.NewFactory(metadataStore, fl).New(ctx, settings, cfg)
+	if err != nil {
+		return nil, nil, nil, nil, nil, nil, nil, nil, err
+	}
+
+	bucketCache := querier.NewBucketCache(settings, cache, config.Querier.CacheTTL, config.Querier.FluxInterval)
+
+	return metadataStore, traceStmtBuilder, logStmtBuilder, auditStmtBuilder, metricStmtBuilder, meterStmtBuilder, traceOperatorStmtBuilder, bucketCache, nil
+}
+
 func New(
 	ctx context.Context,
 	config Config,
@@ -243,11 +299,6 @@ func New(
 
 	retentionGetter := implretention.NewGetter(implretention.NewStore(sqlstore))
 
-	// promV2 is the clickhousev2 provider handed to the querier for shadow
-	// comparison and pinned serving (declared before the serving provider,
-	// whose variable shadows the package name below).
-	var promV2 *clickhouseprometheusv2.Provider
-
 	// Initialize prometheus from the available prometheus provider factories
 	prometheus, err := factory.NewProviderFromNamedMap(
 		ctx,
@@ -260,21 +311,11 @@ func New(
 		return nil, err
 	}
 
-	// With the default provider, also stand up the clickhousev2 provider for
-	// the querier: PromQL queries shadow-compare against it behind the
-	// use_prometheus_clickhouse_v2 flag (see pkg/querier/promql_shadow.go).
-	// It never serves by default. An explicit
-	// prometheus::provider: clickhousev2 makes v2 the serving provider
-	// outright, so there is nothing to compare against.
-	if config.Prometheus.Provider() == "clickhouse" {
-		v2Config := config.Prometheus
-		// The v2 engine only evaluates shadow and pinned queries; disable its
-		// active query tracker so two trackers never share a file.
-		v2Config.ActiveQueryTrackerConfig.Enabled = false
-		promV2, err = clickhouseprometheusv2.New(ctx, providerSettings, v2Config, telemetrystore)
-		if err != nil {
-			return nil, err
-		}
+	// Assemble the query stack (metadata store, statement builders, bucket cache) once,
+	// and reuse the single metadata store everywhere downstream.
+	telemetryMetadataStore, traceStmtBuilder, logStmtBuilder, auditStmtBuilder, metricStmtBuilder, meterStmtBuilder, traceOperatorStmtBuilder, bucketCache, err := newQueryStack(ctx, providerSettings, config, telemetrystore, cache, flagger)
+	if err != nil {
+		return nil, err
 	}
 
 	// Initialize querier from the available querier provider factories
@@ -282,7 +323,7 @@ func New(
 		ctx,
 		providerSettings,
 		config.Querier,
-		NewQuerierProviderFactories(telemetrystore, prometheus, promV2, cache, flagger),
+		NewQuerierProviderFactories(telemetrystore, prometheus, telemetryMetadataStore, traceStmtBuilder, logStmtBuilder, auditStmtBuilder, metricStmtBuilder, meterStmtBuilder, traceOperatorStmtBuilder, bucketCache, flagger),
 		config.Querier.Provider(),
 	)
 	if err != nil {
@@ -450,35 +491,6 @@ func New(
 		return nil, err
 	}
 
-	// Initialize telemetry metadata store
-	// TODO: consolidate other telemetrymetadata.NewTelemetryMetaStore initializations to reuse this instance instead.
-	telemetryMetadataStore := telemetrymetadata.NewTelemetryMetaStore(
-		providerSettings,
-		telemetrystore,
-		telemetrytraces.DBName,
-		telemetrytraces.TagAttributesV2TableName,
-		telemetrytraces.SpanAttributesKeysTblName,
-		telemetrytraces.SpanIndexV3TableName,
-		telemetrymetrics.DBName,
-		telemetrymetrics.AttributesMetadataTableName,
-		telemetrymeter.DBName,
-		telemetrymeter.SamplesAgg1dTableName,
-		telemetrylogs.DBName,
-		telemetrylogs.LogsV2TableName,
-		telemetrylogs.TagAttributesV2TableName,
-		telemetrylogs.LogAttributeKeysTblName,
-		telemetrylogs.LogResourceKeysTblName,
-		telemetryaudit.DBName,
-		telemetryaudit.AuditLogsTableName,
-		telemetryaudit.TagAttributesTableName,
-		telemetryaudit.LogAttributeKeysTblName,
-		telemetryaudit.LogResourceKeysTblName,
-		telemetrymetadata.DBName,
-		telemetrymetadata.AttributesMetadataTableName,
-		telemetrymetadata.ColumnEvolutionMetadataTableName,
-		flagger,
-	)
-
 	global, err := factory.NewProviderFromNamedMap(
 		ctx,
 		providerSettings,

pkg/sqlmigration/104_fill_dashboard_meter_source.go

@@ -0,0 +1,159 @@
+package sqlmigration
+
+import (
+	"context"
+	"log/slog"
+
+	"github.com/SigNoz/signoz/pkg/factory"
+	"github.com/SigNoz/signoz/pkg/sqlstore"
+	"github.com/SigNoz/signoz/pkg/types"
+	"github.com/SigNoz/signoz/pkg/types/dashboardtypes"
+	qb "github.com/SigNoz/signoz/pkg/types/querybuildertypes/querybuildertypesv5"
+	"github.com/SigNoz/signoz/pkg/types/telemetrytypes"
+	"github.com/SigNoz/signoz/pkg/valuer"
+	"github.com/uptrace/bun"
+	"github.com/uptrace/bun/migrate"
+)
+
+// meterMetricNames are the SigNoz meter metrics; a metrics query aggregating one is a
+// meter query.
+var meterMetricNames = map[string]bool{
+	"signoz.meter.log.count":              true,
+	"signoz.meter.log.size":               true,
+	"signoz.meter.span.count":             true,
+	"signoz.meter.span.size":              true,
+	"signoz.meter.metric.datapoint.count": true,
+	"signoz.meter.platform.active":        true,
+}
+
+type fillDashboardMeterSource struct {
+	sqlstore       sqlstore.SQLStore
+	dashboardStore dashboardtypes.Store
+	settings       factory.ProviderSettings
+}
+
+func NewFillDashboardMeterSourceFactory(sqlstore sqlstore.SQLStore, dashboardStore dashboardtypes.Store) factory.ProviderFactory[SQLMigration, Config] {
+	return factory.NewProviderFactory(
+		factory.MustNewName("fill_dashboard_meter_source"),
+		func(ctx context.Context, ps factory.ProviderSettings, c Config) (SQLMigration, error) {
+			return &fillDashboardMeterSource{sqlstore: sqlstore, dashboardStore: dashboardStore, settings: ps}, nil
+		},
+	)
+}
+
+func (migration *fillDashboardMeterSource) Register(migrations *migrate.Migrations) error {
+	return migrations.Register(migration.Up, migration.Down)
+}
+
+// Up resets the meter source that 103 dropped when converting v1 meter queries to v2:
+// every metrics query aggregating a meter metric is set back to source "meter". One
+// transaction; v1 (unparseable-as-v2) dashboards are skipped.
+func (migration *fillDashboardMeterSource) Up(ctx context.Context, _ *bun.DB) error {
+	return migration.sqlstore.RunInTxCtx(ctx, nil, func(ctx context.Context) error {
+		var orgIDs []string
+		if err := migration.sqlstore.BunDBCtx(ctx).NewSelect().Model((*types.Organization)(nil)).Column("id").Scan(ctx, &orgIDs); err != nil {
+			return err
+		}
+
+		for _, id := range orgIDs {
+			orgID, err := valuer.NewUUID(id)
+			if err != nil {
+				return err
+			}
+			if err := migration.fillOrg(ctx, orgID); err != nil {
+				return err
+			}
+		}
+
+		return nil
+	})
+}
+
+// fillOrg fills the meter source on every v2 dashboard in the org that needs it. Runs
+// inside the caller's transaction.
+func (migration *fillDashboardMeterSource) fillOrg(ctx context.Context, orgID valuer.UUID) error {
+	// List, not ListV2: ListV2 paginates and excludes system dashboards; a migration needs every row.
+	storables, err := migration.dashboardStore.List(ctx, orgID)
+	if err != nil {
+		return err
+	}
+
+	logger := migration.settings.Logger
+	var stillInV1, skippedNoMeter, wouldMigrateButErrored, migrated int
+	for _, storable := range storables {
+		// ToDashboardV2 rejects non-v2 data, so v1 dashboards fall through untouched.
+		dashboard, err := storable.ToDashboardV2(nil)
+		if err != nil {
+			stillInV1++
+			continue
+		}
+		if !fillMeterSource(&dashboard.Spec) {
+			skippedNoMeter++
+			continue
+		}
+		restorable, err := dashboard.ToStorableDashboard()
+		if err != nil {
+			wouldMigrateButErrored++
+			logger.WarnContext(ctx, "failed to re-serialize dashboard after filling meter source", slog.String("org_id", orgID.String()), slog.String("dashboard_id", storable.ID.String()), slog.Any("error", err))
+			continue
+		}
+		if err := migration.dashboardStore.Update(ctx, orgID, restorable); err != nil {
+			return err
+		}
+		migrated++
+	}
+
+	logger.InfoContext(ctx, "filled meter source on v2 dashboards",
+		slog.String("org_id", orgID.String()),
+		slog.Int("total", len(storables)),
+		slog.Int("still_in_v1", stillInV1),
+		slog.Int("skipped_no_meter", skippedNoMeter),
+		slog.Int("would_migrate_but_errored", wouldMigrateButErrored),
+		slog.Int("migrated", migrated),
+	)
+	return nil
+}
+
+// fillMeterSource sets Source=meter on every metrics builder query in the spec whose
+// aggregation targets a meter metric, reporting whether anything changed.
+func fillMeterSource(spec *dashboardtypes.DashboardSpec) bool {
+	changed := false
+	for _, panel := range spec.Panels {
+		if panel == nil {
+			continue
+		}
+		for _, query := range panel.Spec.Queries {
+			switch plugin := query.Spec.Plugin.Spec.(type) {
+			case *qb.CompositeQuery:
+				for i := range plugin.Queries {
+					changed = setMeterSource(&plugin.Queries[i].Spec) || changed
+				}
+			case *dashboardtypes.BuilderQuerySpec:
+				changed = setMeterSource(&plugin.Spec) || changed
+			}
+		}
+	}
+	return changed
+}
+
+// setMeterSource sets source "meter" on a metrics query aggregating a meter metric. The
+// type assertion doubles as the metrics-signal check; the already-meter guard keeps it
+// idempotent. Written back through the pointer, as an interface value isn't addressable.
+func setMeterSource(spec *any) bool {
+	query, ok := (*spec).(qb.QueryBuilderQuery[qb.MetricAggregation])
+	if !ok || query.Source == telemetrytypes.SourceMeter {
+		return false
+	}
+	for _, aggregation := range query.Aggregations {
+		if meterMetricNames[aggregation.MetricName] {
+			query.Source = telemetrytypes.SourceMeter
+			*spec = query
+			return true
+		}
+	}
+	return false
+}
+
+func (migration *fillDashboardMeterSource) Down(context.Context, *bun.DB) error {
+	return nil
+}

pkg/statementbuilder/auditstatementbuilder/statement_builder.go

@@ -1,4 +1,4 @@
-package telemetryaudit
+package auditstatementbuilder
 
 import (
 	"context"
@@ -10,7 +10,9 @@ import (
 	"github.com/SigNoz/signoz/pkg/factory"
 	"github.com/SigNoz/signoz/pkg/flagger"
 	"github.com/SigNoz/signoz/pkg/querybuilder"
-	"github.com/SigNoz/signoz/pkg/telemetryresourcefilter"
+	"github.com/SigNoz/signoz/pkg/statementbuilder"
+	"github.com/SigNoz/signoz/pkg/statementbuilder/resourcefilter"
+	"github.com/SigNoz/signoz/pkg/telemetryschema/audittelemetryschema"
 	qbtypes "github.com/SigNoz/signoz/pkg/types/querybuildertypes/querybuildertypesv5"
 	"github.com/SigNoz/signoz/pkg/types/telemetrytypes"
 	"github.com/SigNoz/signoz/pkg/valuer"
@@ -29,6 +31,25 @@ type auditQueryStatementBuilder struct {
 
 var _ qbtypes.StatementBuilder[qbtypes.LogAggregation] = (*auditQueryStatementBuilder)(nil)
 
+// NewFactory returns a provider factory for the audit statement builder. Its New
+// internalizes the FieldMapper, ConditionBuilder, and AggExprRewriter.
+func NewFactory(
+	metadataStore telemetrytypes.MetadataStore,
+	fl flagger.Flagger,
+) factory.ProviderFactory[qbtypes.StatementBuilder[qbtypes.LogAggregation], statementbuilder.Config] {
+	return factory.NewProviderFactory(
+		factory.MustNewName("audit"),
+		func(_ context.Context, settings factory.ProviderSettings, _ statementbuilder.Config) (qbtypes.StatementBuilder[qbtypes.LogAggregation], error) {
+			fm := audittelemetryschema.NewFieldMapper()
+			cb := audittelemetryschema.NewConditionBuilder(fm)
+			aggExprRewriter := querybuilder.NewAggExprRewriter(settings, audittelemetryschema.DefaultFullTextColumn, fm, cb, fl)
+			return NewAuditQueryStatementBuilder(
+				settings, metadataStore, fm, cb, aggExprRewriter, audittelemetryschema.DefaultFullTextColumn, fl,
+			), nil
+		},
+	)
+}
+
 func NewAuditQueryStatementBuilder(
 	settings factory.ProviderSettings,
 	metadataStore telemetrytypes.MetadataStore,
@@ -38,12 +59,12 @@ func NewAuditQueryStatementBuilder(
 	fullTextColumn *telemetrytypes.TelemetryFieldKey,
 	flagger flagger.Flagger,
 ) *auditQueryStatementBuilder {
-	auditSettings := factory.NewScopedProviderSettings(settings, "github.com/SigNoz/signoz/pkg/telemetryaudit")
+	auditSettings := factory.NewScopedProviderSettings(settings, "github.com/SigNoz/signoz/pkg/telemetryschema/audittelemetryschema")
 
-	resourceFilterStmtBuilder := telemetryresourcefilter.New[qbtypes.LogAggregation](
+	resourceFilterStmtBuilder := resourcefilter.New[qbtypes.LogAggregation](
 		settings,
-		DBName,
-		LogsResourceTableName,
+		audittelemetryschema.DBName,
+		audittelemetryschema.LogsResourceTableName,
 		telemetrytypes.SignalLogs,
 		telemetrytypes.SourceAudit,
 		metadataStore,
@@ -184,15 +205,15 @@ func (b *auditQueryStatementBuilder) adjustKeys(ctx context.Context, keys map[st
 	}
 
 	for _, action := range actions {
-		b.logger.InfoContext(ctx, "key adjustment action", slog.String("action", action))
+		b.logger.DebugContext(ctx, "key adjustment action", slog.String("action", action))
 	}
 
 	return query
 }
 
 func (b *auditQueryStatementBuilder) adjustKey(key *telemetrytypes.TelemetryFieldKey, keys map[string][]*telemetrytypes.TelemetryFieldKey) []string {
-	if _, ok := IntrinsicFields[key.Name]; ok {
-		intrinsicField := IntrinsicFields[key.Name]
+	if _, ok := audittelemetryschema.IntrinsicFields[key.Name]; ok {
+		intrinsicField := audittelemetryschema.IntrinsicFields[key.Name]
 		return querybuilder.AdjustKey(key, keys, &intrinsicField)
 	}
 	return querybuilder.AdjustKey(key, keys, nil)
@@ -219,26 +240,26 @@ func (b *auditQueryStatementBuilder) buildListQuery(
 		cteArgs = append(cteArgs, args)
 	}
 
-	sb.Select(TimestampColumn)
-	sb.SelectMore(IDColumn)
+	sb.Select(audittelemetryschema.TimestampColumn)
+	sb.SelectMore(audittelemetryschema.IDColumn)
 	if len(query.SelectFields) == 0 {
-		sb.SelectMore(TraceIDColumn)
-		sb.SelectMore(SpanIDColumn)
-		sb.SelectMore(TraceFlagsColumn)
-		sb.SelectMore(SeverityTextColumn)
-		sb.SelectMore(SeverityNumberColumn)
-		sb.SelectMore(ScopeNameColumn)
-		sb.SelectMore(ScopeVersionColumn)
-		sb.SelectMore(BodyColumn)
-		sb.SelectMore(EventNameColumn)
-		sb.SelectMore(AttributesStringColumn)
-		sb.SelectMore(AttributesNumberColumn)
-		sb.SelectMore(AttributesBoolColumn)
-		sb.SelectMore(ResourceColumn)
-		sb.SelectMore(ScopeStringColumn)
+		sb.SelectMore(audittelemetryschema.TraceIDColumn)
+		sb.SelectMore(audittelemetryschema.SpanIDColumn)
+		sb.SelectMore(audittelemetryschema.TraceFlagsColumn)
+		sb.SelectMore(audittelemetryschema.SeverityTextColumn)
+		sb.SelectMore(audittelemetryschema.SeverityNumberColumn)
+		sb.SelectMore(audittelemetryschema.ScopeNameColumn)
+		sb.SelectMore(audittelemetryschema.ScopeVersionColumn)
+		sb.SelectMore(audittelemetryschema.BodyColumn)
+		sb.SelectMore(audittelemetryschema.EventNameColumn)
+		sb.SelectMore(audittelemetryschema.AttributesStringColumn)
+		sb.SelectMore(audittelemetryschema.AttributesNumberColumn)
+		sb.SelectMore(audittelemetryschema.AttributesBoolColumn)
+		sb.SelectMore(audittelemetryschema.ResourceColumn)
+		sb.SelectMore(audittelemetryschema.ScopeStringColumn)
 	} else {
 		for index := range query.SelectFields {
-			if query.SelectFields[index].Name == TimestampColumn || query.SelectFields[index].Name == IDColumn {
+			if query.SelectFields[index].Name == audittelemetryschema.TimestampColumn || query.SelectFields[index].Name == audittelemetryschema.IDColumn {
 				continue
 			}
 
@@ -250,7 +271,7 @@ func (b *auditQueryStatementBuilder) buildListQuery(
 		}
 	}
 
-	sb.From(fmt.Sprintf("%s.%s", DBName, AuditLogsTableName))
+	sb.From(fmt.Sprintf("%s.%s", audittelemetryschema.DBName, audittelemetryschema.AuditLogsTableName))
 
 	preparedWhereClause, err := b.addFilterCondition(ctx, orgID, sb, start, end, query, keys, variables)
 	if err != nil {
@@ -340,7 +361,7 @@ func (b *auditQueryStatementBuilder) buildTimeSeriesQuery(
 		sb.SelectMore(fmt.Sprintf("%s AS __result_%d", rewritten, i))
 	}
 
-	sb.From(fmt.Sprintf("%s.%s", DBName, AuditLogsTableName))
+	sb.From(fmt.Sprintf("%s.%s", audittelemetryschema.DBName, audittelemetryschema.AuditLogsTableName))
 
 	preparedWhereClause, err := b.addFilterCondition(ctx, orgID, sb, start, end, query, keys, variables)
 	if err != nil {
@@ -478,7 +499,7 @@ func (b *auditQueryStatementBuilder) buildScalarQuery(
 		}
 	}
 
-	sb.From(fmt.Sprintf("%s.%s", DBName, AuditLogsTableName))
+	sb.From(fmt.Sprintf("%s.%s", audittelemetryschema.DBName, audittelemetryschema.AuditLogsTableName))
 
 	preparedWhereClause, err := b.addFilterCondition(ctx, orgID, sb, start, end, query, keys, variables)
 	if err != nil {

pkg/statementbuilder/auditstatementbuilder/statement_builder_test.go

@@ -1,4 +1,4 @@
-package telemetryaudit
+package auditstatementbuilder
 
 import (
 	"context"
@@ -8,6 +8,7 @@ import (
 	"github.com/SigNoz/signoz/pkg/flagger/flaggertest"
 	"github.com/SigNoz/signoz/pkg/instrumentation/instrumentationtest"
 	"github.com/SigNoz/signoz/pkg/querybuilder"
+	"github.com/SigNoz/signoz/pkg/telemetryschema/audittelemetryschema"
 	qbtypes "github.com/SigNoz/signoz/pkg/types/querybuildertypes/querybuildertypesv5"
 	"github.com/SigNoz/signoz/pkg/types/telemetrytypes"
 	"github.com/SigNoz/signoz/pkg/types/telemetrytypes/telemetrytypestest"
@@ -54,8 +55,8 @@ func newTestAuditStatementBuilder(t *testing.T) *auditQueryStatementBuilder {
 	mockMetadataStore := telemetrytypestest.NewMockMetadataStore()
 	mockMetadataStore.KeysMap = auditFieldKeyMap()
 
-	fm := NewFieldMapper()
-	cb := NewConditionBuilder(fm)
+	fm := audittelemetryschema.NewFieldMapper()
+	cb := audittelemetryschema.NewConditionBuilder(fm)
 	aggExprRewriter := querybuilder.NewAggExprRewriter(instrumentationtest.New().ToProviderSettings(), nil, fm, cb, fl)
 
 	return NewAuditQueryStatementBuilder(
@@ -64,7 +65,7 @@ func newTestAuditStatementBuilder(t *testing.T) *auditQueryStatementBuilder {
 		fm,
 		cb,
 		aggExprRewriter,
-		DefaultFullTextColumn,
+		audittelemetryschema.DefaultFullTextColumn,
 		fl,
 	)
 }

pkg/statementbuilder/config.go

@@ -0,0 +1,41 @@
+package statementbuilder
+
+import (
+	"github.com/SigNoz/signoz/pkg/errors"
+	"github.com/SigNoz/signoz/pkg/factory"
+)
+
+// SkipResourceFingerprint configures when the resource fingerprint subquery is skipped in favor of main-table filtering.
+type SkipResourceFingerprint struct {
+	Enabled bool `yaml:"enabled" mapstructure:"enabled"`
+	// If count of fingerprint is above threshold, skip the fingerprint subquery and filter on main table instead.
+	Threshold uint64 `yaml:"threshold" mapstructure:"threshold"`
+}
+
+// Config represents the configuration for the statement builders.
+type Config struct {
+	// SkipResourceFingerprint configures when the resource fingerprint subquery is skipped in favor of main-table filtering.
+	SkipResourceFingerprint SkipResourceFingerprint `yaml:"skip_resource_fingerprint" mapstructure:"skip_resource_fingerprint"`
+}
+
+// NewConfigFactory creates a new config factory for the statement builders.
+func NewConfigFactory() factory.ConfigFactory {
+	return factory.NewConfigFactory(factory.MustNewName("statementbuilder"), newConfig)
+}
+
+func newConfig() factory.Config {
+	return Config{
+		SkipResourceFingerprint: SkipResourceFingerprint{
+			Enabled:   false,
+			Threshold: 100000,
+		},
+	}
+}
+
+// Validate validates the configuration.
+func (c Config) Validate() error {
+	if c.SkipResourceFingerprint.Enabled && c.SkipResourceFingerprint.Threshold == 0 {
+		return errors.NewInvalidInputf(errors.CodeInvalidInput, "skip_resource_fingerprint.threshold must be > 0 when enabled")
+	}
+	return nil
+}

pkg/statementbuilder/logsstatementbuilder/groupby_unknown_key_test.go

@@ -1,4 +1,4 @@
-package telemetrylogs
+package logsstatementbuilder
 
 import (
 	"context"
@@ -8,6 +8,7 @@ import (
 	"github.com/SigNoz/signoz/pkg/flagger/flaggertest"
 	"github.com/SigNoz/signoz/pkg/instrumentation/instrumentationtest"
 	"github.com/SigNoz/signoz/pkg/querybuilder"
+	"github.com/SigNoz/signoz/pkg/telemetryschema/logstelemetryschema"
 	qbtypes "github.com/SigNoz/signoz/pkg/types/querybuildertypes/querybuildertypesv5"
 	"github.com/SigNoz/signoz/pkg/types/telemetrytypes"
 	"github.com/SigNoz/signoz/pkg/types/telemetrytypes/telemetrytypestest"
@@ -43,14 +44,14 @@ func TestStatementBuilderGroupByUnknownKey(t *testing.T) {
 		t.Run(c.name, func(t *testing.T) {
 			fl := flaggertest.WithUseJSONBody(t, c.useJSONBody)
 			mockMetadataStore := telemetrytypestest.NewMockMetadataStore()
-			mockMetadataStore.KeysMap = buildCompleteFieldKeyMap(releaseTime)
-			fm := NewFieldMapper(fl)
-			cb := NewConditionBuilder(fm, fl)
+			mockMetadataStore.KeysMap = logstelemetryschema.BuildCompleteFieldKeyMap(releaseTime)
+			fm := logstelemetryschema.NewFieldMapper(fl)
+			cb := logstelemetryschema.NewConditionBuilder(fm, fl)
 			aggExprRewriter := querybuilder.NewAggExprRewriter(instrumentationtest.New().ToProviderSettings(), nil, fm, cb, fl)
 			statementBuilder := NewLogQueryStatementBuilder(
 				instrumentationtest.New().ToProviderSettings(),
 				mockMetadataStore, fm, cb, aggExprRewriter,
-				DefaultFullTextColumn, fl, nil, false, 100000,
+				logstelemetryschema.DefaultFullTextColumn, fl, nil, false, 100000,
 			)
 
 			query := qbtypes.QueryBuilderQuery[qbtypes.LogAggregation]{

pkg/statementbuilder/logsstatementbuilder/json_stmt_builder_test.go

@@ -1,4 +1,4 @@
-package telemetrylogs
+package logsstatementbuilder
 
 import (
 	"context"
@@ -11,6 +11,7 @@ import (
 	"github.com/SigNoz/signoz/pkg/flagger/flaggertest"
 	"github.com/SigNoz/signoz/pkg/instrumentation/instrumentationtest"
 	"github.com/SigNoz/signoz/pkg/querybuilder"
+	"github.com/SigNoz/signoz/pkg/telemetryschema/logstelemetryschema"
 	qbtypes "github.com/SigNoz/signoz/pkg/types/querybuildertypes/querybuildertypesv5"
 	"github.com/SigNoz/signoz/pkg/types/telemetrytypes"
 	"github.com/SigNoz/signoz/pkg/types/telemetrytypes/telemetrytypestest"
@@ -1225,7 +1226,7 @@ func TestJSONStmtBuilder_OrderBy(t *testing.T) {
 func TestResourceAggrAndGroupBy_WithJSONEnabled(t *testing.T) {
 	statementBuilder, metadataStore := buildJSONTestStatementBuilder(t, false)
 	releaseTime := time.Date(2024, 1, 15, 10, 0, 0, 0, time.UTC)
-	keysMap := buildCompleteFieldKeyMap(releaseTime)
+	keysMap := logstelemetryschema.BuildCompleteFieldKeyMap(releaseTime)
 	for _, keys := range keysMap {
 		for _, key := range keys {
 			metadataStore.SetKey(key)
@@ -1287,7 +1288,7 @@ func TestResourceAggrAndGroupBy_WithJSONEnabled(t *testing.T) {
 
 func buildTestTelemetryMetadataStore(t *testing.T, addIndexes bool) *telemetrytypestest.MockMetadataStore {
 	mockMetadataStore := telemetrytypestest.NewMockMetadataStore()
-	mockMetadataStore.SetStaticFields(IntrinsicFields)
+	mockMetadataStore.SetStaticFields(logstelemetryschema.IntrinsicFields)
 	types, _ := telemetrytypes.TestJSONTypeSet()
 	for path, fieldDataTypes := range types {
 		for _, fdt := range fieldDataTypes {
@@ -1307,15 +1308,15 @@ func buildTestTelemetryMetadataStore(t *testing.T, addIndexes bool) *telemetryty
 						Name:            path,
 						FieldContext:    telemetrytypes.FieldContextBody,
 						FieldDataType:   fdt,
-						BaseColumn:      LogsV2BodyV2Column,
-						IndexExpression: schemamigrator.JSONSubColumnIndexExpr(LogsV2BodyV2Column, path, jsonType.StringValue()),
+						BaseColumn:      logstelemetryschema.LogsV2BodyV2Column,
+						IndexExpression: schemamigrator.JSONSubColumnIndexExpr(logstelemetryschema.LogsV2BodyV2Column, path, jsonType.StringValue()),
 					})
 				}
 			}
 
 			err := key.SetJSONAccessPlan(telemetrytypes.JSONColumnMetadata{
-				BaseColumn:     LogsV2BodyV2Column,
-				PromotedColumn: LogsV2BodyPromotedColumn,
+				BaseColumn:     logstelemetryschema.LogsV2BodyV2Column,
+				PromotedColumn: logstelemetryschema.LogsV2BodyPromotedColumn,
 			}, types)
 			require.NoError(t, err)
 
@@ -1331,8 +1332,8 @@ func buildJSONTestStatementBuilder(t *testing.T, addIndexes bool) (*logQueryStat
 
 	mockMetadataStore := buildTestTelemetryMetadataStore(t, addIndexes)
 	fl := flaggertest.WithUseJSONBody(t, true)
-	fm := NewFieldMapper(fl)
-	cb := NewConditionBuilder(fm, fl)
+	fm := logstelemetryschema.NewFieldMapper(fl)
+	cb := logstelemetryschema.NewConditionBuilder(fm, fl)
 
 	aggExprRewriter := querybuilder.NewAggExprRewriter(instrumentationtest.New().ToProviderSettings(), nil, fm, cb, fl)
 
@@ -1342,7 +1343,7 @@ func buildJSONTestStatementBuilder(t *testing.T, addIndexes bool) (*logQueryStat
 		fm,
 		cb,
 		aggExprRewriter,
-		DefaultFullTextColumn,
+		logstelemetryschema.DefaultFullTextColumn,
 		fl,
 		nil,
 		false,

pkg/statementbuilder/logsstatementbuilder/statement_builder.go

@@ -1,4 +1,4 @@
-package telemetrylogs
+package logsstatementbuilder
 
 import (
 	"context"
@@ -10,7 +10,9 @@ import (
 	"github.com/SigNoz/signoz/pkg/factory"
 	"github.com/SigNoz/signoz/pkg/flagger"
 	"github.com/SigNoz/signoz/pkg/querybuilder"
-	"github.com/SigNoz/signoz/pkg/telemetryresourcefilter"
+	"github.com/SigNoz/signoz/pkg/statementbuilder"
+	"github.com/SigNoz/signoz/pkg/statementbuilder/resourcefilter"
+	"github.com/SigNoz/signoz/pkg/telemetryschema/logstelemetryschema"
 	"github.com/SigNoz/signoz/pkg/telemetrystore"
 	"github.com/SigNoz/signoz/pkg/types/featuretypes"
 	qbtypes "github.com/SigNoz/signoz/pkg/types/querybuildertypes/querybuildertypesv5"
@@ -19,12 +21,22 @@ import (
 	"github.com/huandu/go-sqlbuilder"
 )
 
+const bodySearchDefaultWarning = "body searches default to `body.message:string`. Use `body.<key>` to search a different field inside body"
+
+func bodyAliasExpression(bodyJSONEnabled bool) string {
+	if !bodyJSONEnabled {
+		return logstelemetryschema.LogsV2BodyColumn
+	}
+
+	return fmt.Sprintf("%s as body", logstelemetryschema.LogsV2BodyV2Column)
+}
+
 type logQueryStatementBuilder struct {
 	logger                         *slog.Logger
 	metadataStore                  telemetrytypes.MetadataStore
 	fm                             qbtypes.FieldMapper
 	cb                             qbtypes.ConditionBuilder
-	resourceFilterResolver         *telemetryresourcefilter.ResourceFingerprintResolver[qbtypes.LogAggregation]
+	resourceFilterResolver         *resourcefilter.ResourceFingerprintResolver[qbtypes.LogAggregation]
 	aggExprRewriter                qbtypes.AggExprRewriter
 	fl                             flagger.Flagger
 	skipResourceFingerprintEnabled bool
@@ -34,6 +46,28 @@ type logQueryStatementBuilder struct {
 
 var _ qbtypes.StatementBuilder[qbtypes.LogAggregation] = (*logQueryStatementBuilder)(nil)
 
+// NewFactory returns a provider factory for the logs statement builder. Its New
+// internalizes the FieldMapper, ConditionBuilder, and AggExprRewriter, and reads
+// SkipResourceFingerprint from the config.
+func NewFactory(
+	telemetryStore telemetrystore.TelemetryStore,
+	metadataStore telemetrytypes.MetadataStore,
+	fl flagger.Flagger,
+) factory.ProviderFactory[qbtypes.StatementBuilder[qbtypes.LogAggregation], statementbuilder.Config] {
+	return factory.NewProviderFactory(
+		factory.MustNewName("logs"),
+		func(_ context.Context, settings factory.ProviderSettings, cfg statementbuilder.Config) (qbtypes.StatementBuilder[qbtypes.LogAggregation], error) {
+			fm := logstelemetryschema.NewFieldMapper(fl)
+			cb := logstelemetryschema.NewConditionBuilder(fm, fl)
+			aggExprRewriter := querybuilder.NewAggExprRewriter(settings, logstelemetryschema.DefaultFullTextColumn, fm, cb, fl)
+			return NewLogQueryStatementBuilder(
+				settings, metadataStore, fm, cb, aggExprRewriter, logstelemetryschema.DefaultFullTextColumn,
+				fl, telemetryStore, cfg.SkipResourceFingerprint.Enabled, cfg.SkipResourceFingerprint.Threshold,
+			), nil
+		},
+	)
+}
+
 func NewLogQueryStatementBuilder(
 	settings factory.ProviderSettings,
 	metadataStore telemetrytypes.MetadataStore,
@@ -46,12 +80,12 @@ func NewLogQueryStatementBuilder(
 	skipResourceFingerprintEnable bool,
 	skipResourceFingerprintThreshold uint64,
 ) *logQueryStatementBuilder {
-	logsSettings := factory.NewScopedProviderSettings(settings, "github.com/SigNoz/signoz/pkg/telemetrylogs")
+	logsSettings := factory.NewScopedProviderSettings(settings, "github.com/SigNoz/signoz/pkg/telemetryschema/logstelemetryschema")
 
-	resourceFilterResolver := telemetryresourcefilter.NewResolver[qbtypes.LogAggregation](
+	resourceFilterResolver := resourcefilter.NewResolver[qbtypes.LogAggregation](
 		settings,
-		DBName,
-		LogsResourceV2TableName,
+		logstelemetryschema.DBName,
+		logstelemetryschema.LogsResourceV2TableName,
 		telemetrytypes.SignalLogs,
 		telemetrytypes.SourceUnspecified,
 		metadataStore,
@@ -174,7 +208,7 @@ func getKeySelectors(query qbtypes.QueryBuilderQuery[qbtypes.LogAggregation], bo
 	// TODO(Piyush): Setup better for coming FTS support.
 	if bodyJSONEnabled {
 		for _, sel := range keySelectors {
-			if sel.Name == LogsV2BodyColumn {
+			if sel.Name == logstelemetryschema.LogsV2BodyColumn {
 				warnings = append(warnings, bodySearchDefaultWarning)
 				break
 			}
@@ -240,8 +274,7 @@ func (b *logQueryStatementBuilder) adjustKeys(ctx context.Context, keys map[stri
 	}
 
 	for _, action := range actions {
-		// TODO: change to debug level once we are confident about the behavior
-		b.logger.InfoContext(ctx, "key adjustment action", slog.String("action", action))
+		b.logger.DebugContext(ctx, "key adjustment action", slog.String("action", action))
 	}
 
 	return query
@@ -250,8 +283,8 @@ func (b *logQueryStatementBuilder) adjustKeys(ctx context.Context, keys map[stri
 func (b *logQueryStatementBuilder) adjustKey(key *telemetrytypes.TelemetryFieldKey, keys map[string][]*telemetrytypes.TelemetryFieldKey) []string {
 	// First check if it matches with any intrinsic fields
 	var intrinsicOrCalculatedField telemetrytypes.TelemetryFieldKey
-	if _, ok := IntrinsicFields[key.Name]; ok {
-		intrinsicOrCalculatedField = IntrinsicFields[key.Name]
+	if _, ok := logstelemetryschema.IntrinsicFields[key.Name]; ok {
+		intrinsicOrCalculatedField = logstelemetryschema.IntrinsicFields[key.Name]
 		return querybuilder.AdjustKey(key, keys, &intrinsicOrCalculatedField)
 	}
 
@@ -284,28 +317,28 @@ func (b *logQueryStatementBuilder) buildListQuery(
 	}
 
 	// Select timestamp and id by default
-	sb.Select(LogsV2TimestampColumn)
-	sb.SelectMore(LogsV2IDColumn)
+	sb.Select(logstelemetryschema.LogsV2TimestampColumn)
+	sb.SelectMore(logstelemetryschema.LogsV2IDColumn)
 	if len(query.SelectFields) == 0 {
 		// Select all default columns
-		sb.SelectMore(LogsV2TraceIDColumn)
-		sb.SelectMore(LogsV2SpanIDColumn)
-		sb.SelectMore(LogsV2TraceFlagsColumn)
-		sb.SelectMore(LogsV2SeverityTextColumn)
-		sb.SelectMore(LogsV2SeverityNumberColumn)
-		sb.SelectMore(LogsV2ScopeNameColumn)
-		sb.SelectMore(LogsV2ScopeVersionColumn)
+		sb.SelectMore(logstelemetryschema.LogsV2TraceIDColumn)
+		sb.SelectMore(logstelemetryschema.LogsV2SpanIDColumn)
+		sb.SelectMore(logstelemetryschema.LogsV2TraceFlagsColumn)
+		sb.SelectMore(logstelemetryschema.LogsV2SeverityTextColumn)
+		sb.SelectMore(logstelemetryschema.LogsV2SeverityNumberColumn)
+		sb.SelectMore(logstelemetryschema.LogsV2ScopeNameColumn)
+		sb.SelectMore(logstelemetryschema.LogsV2ScopeVersionColumn)
 		sb.SelectMore(bodyAliasExpression(b.fl.BooleanOrEmpty(ctx, flagger.FeatureUseJSONBody, featuretypes.NewFlaggerEvaluationContext(orgID))))
-		sb.SelectMore(LogsV2AttributesStringColumn)
-		sb.SelectMore(LogsV2AttributesNumberColumn)
-		sb.SelectMore(LogsV2AttributesBoolColumn)
-		sb.SelectMore(LogsV2ResourcesStringColumn)
-		sb.SelectMore(LogsV2ScopeStringColumn)
+		sb.SelectMore(logstelemetryschema.LogsV2AttributesStringColumn)
+		sb.SelectMore(logstelemetryschema.LogsV2AttributesNumberColumn)
+		sb.SelectMore(logstelemetryschema.LogsV2AttributesBoolColumn)
+		sb.SelectMore(logstelemetryschema.LogsV2ResourcesStringColumn)
+		sb.SelectMore(logstelemetryschema.LogsV2ScopeStringColumn)
 
 	} else {
 		// Select specified columns
 		for index := range query.SelectFields {
-			if query.SelectFields[index].Name == LogsV2TimestampColumn || query.SelectFields[index].Name == LogsV2IDColumn {
+			if query.SelectFields[index].Name == logstelemetryschema.LogsV2TimestampColumn || query.SelectFields[index].Name == logstelemetryschema.LogsV2IDColumn {
 				continue
 			}
 
@@ -318,7 +351,7 @@ func (b *logQueryStatementBuilder) buildListQuery(
 		}
 	}
 
-	sb.From(fmt.Sprintf("%s.%s", DBName, LogsV2TableName))
+	sb.From(fmt.Sprintf("%s.%s", logstelemetryschema.DBName, logstelemetryschema.LogsV2TableName))
 	// Add filter conditions
 	preparedWhereClause, err := b.addFilterCondition(ctx, orgID, sb, start, end, query, keys, variables, skipResourceFilter)
 
@@ -424,7 +457,7 @@ func (b *logQueryStatementBuilder) buildTimeSeriesQuery(
 	}
 
 	// Add FROM clause
-	sb.From(fmt.Sprintf("%s.%s", DBName, LogsV2TableName))
+	sb.From(fmt.Sprintf("%s.%s", logstelemetryschema.DBName, logstelemetryschema.LogsV2TableName))
 
 	preparedWhereClause, err := b.addFilterCondition(ctx, orgID, sb, start, end, query, keys, variables, skipResourceFilter)
 
@@ -592,7 +625,7 @@ func (b *logQueryStatementBuilder) buildScalarQuery(
 		}
 	}
 
-	sb.From(fmt.Sprintf("%s.%s", DBName, LogsV2TableName))
+	sb.From(fmt.Sprintf("%s.%s", logstelemetryschema.DBName, logstelemetryschema.LogsV2TableName))
 
 	// Add filter conditions
 	preparedWhereClause, err := b.addFilterCondition(ctx, orgID, sb, start, end, query, keys, variables, skipResourceFilter)

pkg/statementbuilder/logsstatementbuilder/stmt_builder_test.go

@@ -1,4 +1,4 @@
-package telemetrylogs
+package logsstatementbuilder
 
 import (
 	"context"
@@ -11,6 +11,7 @@ import (
 	"github.com/SigNoz/signoz/pkg/flagger/flaggertest"
 	"github.com/SigNoz/signoz/pkg/instrumentation/instrumentationtest"
 	"github.com/SigNoz/signoz/pkg/querybuilder"
+	"github.com/SigNoz/signoz/pkg/telemetryschema/logstelemetryschema"
 	"github.com/SigNoz/signoz/pkg/telemetrystore"
 	"github.com/SigNoz/signoz/pkg/telemetrystore/telemetrystoretest"
 	qbtypes "github.com/SigNoz/signoz/pkg/types/querybuildertypes/querybuildertypesv5"
@@ -212,12 +213,12 @@ func TestStatementBuilderTimeSeries(t *testing.T) {
 	fl := flaggertest.New(t)
 
 	mockMetadataStore := telemetrytypestest.NewMockMetadataStore()
-	keysMap := buildCompleteFieldKeyMap(releaseTime)
+	keysMap := logstelemetryschema.BuildCompleteFieldKeyMap(releaseTime)
 
 	mockMetadataStore.KeysMap = keysMap
 
-	fm := NewFieldMapper(fl)
-	cb := NewConditionBuilder(fm, fl)
+	fm := logstelemetryschema.NewFieldMapper(fl)
+	cb := logstelemetryschema.NewConditionBuilder(fm, fl)
 
 	aggExprRewriter := querybuilder.NewAggExprRewriter(instrumentationtest.New().ToProviderSettings(), nil, fm, cb, fl)
 
@@ -227,7 +228,7 @@ func TestStatementBuilderTimeSeries(t *testing.T) {
 		fm,
 		cb,
 		aggExprRewriter,
-		DefaultFullTextColumn,
+		logstelemetryschema.DefaultFullTextColumn,
 		fl,
 		nil,
 		false,
@@ -355,12 +356,12 @@ func TestStatementBuilderListQuery(t *testing.T) {
 	ctx := context.Background()
 	fl := flaggertest.New(t)
 	mockMetadataStore := telemetrytypestest.NewMockMetadataStore()
-	fm := NewFieldMapper(fl)
+	fm := logstelemetryschema.NewFieldMapper(fl)
 
 	// Create a test release time
 	releaseTime := time.Date(2024, 1, 15, 10, 0, 0, 0, time.UTC)
-	mockMetadataStore.KeysMap = buildCompleteFieldKeyMap(releaseTime)
-	cb := NewConditionBuilder(fm, fl)
+	mockMetadataStore.KeysMap = logstelemetryschema.BuildCompleteFieldKeyMap(releaseTime)
+	cb := logstelemetryschema.NewConditionBuilder(fm, fl)
 
 	aggExprRewriter := querybuilder.NewAggExprRewriter(instrumentationtest.New().ToProviderSettings(), nil, fm, cb, fl)
 
@@ -370,7 +371,7 @@ func TestStatementBuilderListQuery(t *testing.T) {
 		fm,
 		cb,
 		aggExprRewriter,
-		DefaultFullTextColumn,
+		logstelemetryschema.DefaultFullTextColumn,
 		fl,
 		nil,
 		false,
@@ -507,11 +508,11 @@ func TestStatementBuilderListQueryResourceTests(t *testing.T) {
 	ctx := context.Background()
 	fl := flaggertest.New(t)
 	mockMetadataStore := telemetrytypestest.NewMockMetadataStore()
-	fm := NewFieldMapper(fl)
+	fm := logstelemetryschema.NewFieldMapper(fl)
 	// Create a test release time
 	releaseTime := time.Date(2024, 1, 15, 10, 0, 0, 0, time.UTC)
-	mockMetadataStore.KeysMap = buildCompleteFieldKeyMap(releaseTime)
-	cb := NewConditionBuilder(fm, fl)
+	mockMetadataStore.KeysMap = logstelemetryschema.BuildCompleteFieldKeyMap(releaseTime)
+	cb := logstelemetryschema.NewConditionBuilder(fm, fl)
 
 	aggExprRewriter := querybuilder.NewAggExprRewriter(instrumentationtest.New().ToProviderSettings(), nil, fm, cb, fl)
 
@@ -521,7 +522,7 @@ func TestStatementBuilderListQueryResourceTests(t *testing.T) {
 		fm,
 		cb,
 		aggExprRewriter,
-		DefaultFullTextColumn,
+		logstelemetryschema.DefaultFullTextColumn,
 		fl,
 		nil,
 		false,
@@ -585,11 +586,11 @@ func TestStatementBuilderTimeSeriesBodyGroupBy(t *testing.T) {
 	ctx := context.Background()
 	fl := flaggertest.New(t)
 	mockMetadataStore := telemetrytypestest.NewMockMetadataStore()
-	fm := NewFieldMapper(fl)
+	fm := logstelemetryschema.NewFieldMapper(fl)
 	// Create a test release time
 	releaseTime := time.Date(2024, 1, 15, 10, 0, 0, 0, time.UTC)
-	mockMetadataStore.KeysMap = buildCompleteFieldKeyMap(releaseTime)
-	cb := NewConditionBuilder(fm, fl)
+	mockMetadataStore.KeysMap = logstelemetryschema.BuildCompleteFieldKeyMap(releaseTime)
+	cb := logstelemetryschema.NewConditionBuilder(fm, fl)
 
 	aggExprRewriter := querybuilder.NewAggExprRewriter(instrumentationtest.New().ToProviderSettings(), nil, fm, cb, fl)
 
@@ -599,7 +600,7 @@ func TestStatementBuilderTimeSeriesBodyGroupBy(t *testing.T) {
 		fm,
 		cb,
 		aggExprRewriter,
-		DefaultFullTextColumn,
+		logstelemetryschema.DefaultFullTextColumn,
 		fl,
 		nil,
 		false,
@@ -684,9 +685,9 @@ func TestStatementBuilderListQueryServiceCollision(t *testing.T) {
 	ctx := context.Background()
 	mockMetadataStore := telemetrytypestest.NewMockMetadataStore()
 	fl := flaggertest.New(t)
-	fm := NewFieldMapper(fl)
-	mockMetadataStore.KeysMap = buildCompleteFieldKeyMapCollision()
-	cb := NewConditionBuilder(fm, fl)
+	fm := logstelemetryschema.NewFieldMapper(fl)
+	mockMetadataStore.KeysMap = logstelemetryschema.BuildCompleteFieldKeyMapCollision()
+	cb := logstelemetryschema.NewConditionBuilder(fm, fl)
 
 	aggExprRewriter := querybuilder.NewAggExprRewriter(instrumentationtest.New().ToProviderSettings(), nil, fm, cb, fl)
 
@@ -696,7 +697,7 @@ func TestStatementBuilderListQueryServiceCollision(t *testing.T) {
 		fm,
 		cb,
 		aggExprRewriter,
-		DefaultFullTextColumn,
+		logstelemetryschema.DefaultFullTextColumn,
 		fl,
 		nil,
 		false,
@@ -740,8 +741,8 @@ func TestAdjustKey(t *testing.T) {
 				FieldContext:  telemetrytypes.FieldContextUnspecified,
 				FieldDataType: telemetrytypes.FieldDataTypeUnspecified,
 			},
-			keysMap:     buildCompleteFieldKeyMap(releaseTime),
-			expectedKey: IntrinsicFields["severity_text"],
+			keysMap:     logstelemetryschema.BuildCompleteFieldKeyMap(releaseTime),
+			expectedKey: logstelemetryschema.IntrinsicFields["severity_text"],
 		},
 		{
 			name: "intrinsic field with other key match - no override",
@@ -777,7 +778,7 @@ func TestAdjustKey(t *testing.T) {
 				FieldContext:  telemetrytypes.FieldContextBody,
 				FieldDataType: telemetrytypes.FieldDataTypeUnspecified,
 			},
-			keysMap: buildCompleteFieldKeyMap(releaseTime),
+			keysMap: logstelemetryschema.BuildCompleteFieldKeyMap(releaseTime),
 			expectedKey: telemetrytypes.TelemetryFieldKey{
 				Name:          "severity_number",
 				FieldContext:  telemetrytypes.FieldContextBody,
@@ -791,8 +792,8 @@ func TestAdjustKey(t *testing.T) {
 				FieldContext:  telemetrytypes.FieldContextUnspecified,
 				FieldDataType: telemetrytypes.FieldDataTypeUnspecified,
 			},
-			keysMap:     buildCompleteFieldKeyMap(releaseTime),
-			expectedKey: *buildCompleteFieldKeyMap(releaseTime)["service.name"][0],
+			keysMap:     logstelemetryschema.BuildCompleteFieldKeyMap(releaseTime),
+			expectedKey: *logstelemetryschema.BuildCompleteFieldKeyMap(releaseTime)["service.name"][0],
 		},
 		{
 			name: "single matching key with incorrect context specified - no override",
@@ -801,7 +802,7 @@ func TestAdjustKey(t *testing.T) {
 				FieldContext:  telemetrytypes.FieldContextAttribute,
 				FieldDataType: telemetrytypes.FieldDataTypeUnspecified,
 			},
-			keysMap: buildCompleteFieldKeyMap(releaseTime),
+			keysMap: logstelemetryschema.BuildCompleteFieldKeyMap(releaseTime),
 			expectedKey: telemetrytypes.TelemetryFieldKey{
 				Name:          "service.name",
 				FieldContext:  telemetrytypes.FieldContextAttribute,
@@ -815,8 +816,8 @@ func TestAdjustKey(t *testing.T) {
 				FieldContext:  telemetrytypes.FieldContextUnspecified,
 				FieldDataType: telemetrytypes.FieldDataTypeUnspecified,
 			},
-			keysMap:     buildCompleteFieldKeyMap(releaseTime),
-			expectedKey: *buildCompleteFieldKeyMap(releaseTime)["service.name"][0],
+			keysMap:     logstelemetryschema.BuildCompleteFieldKeyMap(releaseTime),
+			expectedKey: *logstelemetryschema.BuildCompleteFieldKeyMap(releaseTime)["service.name"][0],
 		},
 		{
 			name: "multiple matching keys - all materialized",
@@ -825,7 +826,7 @@ func TestAdjustKey(t *testing.T) {
 				FieldContext:  telemetrytypes.FieldContextUnspecified,
 				FieldDataType: telemetrytypes.FieldDataTypeUnspecified,
 			},
-			keysMap: buildCompleteFieldKeyMap(releaseTime),
+			keysMap: logstelemetryschema.BuildCompleteFieldKeyMap(releaseTime),
 			expectedKey: telemetrytypes.TelemetryFieldKey{
 				Name:          "multi.mat.key",
 				FieldDataType: telemetrytypes.FieldDataTypeString,
@@ -839,7 +840,7 @@ func TestAdjustKey(t *testing.T) {
 				FieldContext:  telemetrytypes.FieldContextUnspecified,
 				FieldDataType: telemetrytypes.FieldDataTypeUnspecified,
 			},
-			keysMap: buildCompleteFieldKeyMap(releaseTime),
+			keysMap: logstelemetryschema.BuildCompleteFieldKeyMap(releaseTime),
 			expectedKey: telemetrytypes.TelemetryFieldKey{
 				Name:          "mixed.materialization.key",
 				FieldDataType: telemetrytypes.FieldDataTypeString,
@@ -853,8 +854,8 @@ func TestAdjustKey(t *testing.T) {
 				FieldContext:  telemetrytypes.FieldContextAttribute,
 				FieldDataType: telemetrytypes.FieldDataTypeUnspecified,
 			},
-			keysMap:     buildCompleteFieldKeyMap(releaseTime),
-			expectedKey: *buildCompleteFieldKeyMap(releaseTime)["mixed.materialization.key"][0],
+			keysMap:     logstelemetryschema.BuildCompleteFieldKeyMap(releaseTime),
+			expectedKey: *logstelemetryschema.BuildCompleteFieldKeyMap(releaseTime)["mixed.materialization.key"][0],
 		},
 		{
 			name: "no matching keys - unknown field",
@@ -863,7 +864,7 @@ func TestAdjustKey(t *testing.T) {
 				FieldContext:  telemetrytypes.FieldContextUnspecified,
 				FieldDataType: telemetrytypes.FieldDataTypeUnspecified,
 			},
-			keysMap: buildCompleteFieldKeyMap(releaseTime),
+			keysMap: logstelemetryschema.BuildCompleteFieldKeyMap(releaseTime),
 			expectedKey: telemetrytypes.TelemetryFieldKey{
 				Name:          "unknown.field",
 				FieldContext:  telemetrytypes.FieldContextUnspecified,
@@ -878,7 +879,7 @@ func TestAdjustKey(t *testing.T) {
 				FieldContext:  telemetrytypes.FieldContextAttribute,
 				FieldDataType: telemetrytypes.FieldDataTypeUnspecified,
 			},
-			keysMap: buildCompleteFieldKeyMap(releaseTime),
+			keysMap: logstelemetryschema.BuildCompleteFieldKeyMap(releaseTime),
 			expectedKey: telemetrytypes.TelemetryFieldKey{
 				Name:          "unknown.field",
 				FieldContext:  telemetrytypes.FieldContextAttribute,
@@ -893,8 +894,8 @@ func TestAdjustKey(t *testing.T) {
 				FieldContext:  telemetrytypes.FieldContextUnspecified,
 				FieldDataType: telemetrytypes.FieldDataTypeUnspecified,
 			},
-			keysMap:     buildCompleteFieldKeyMap(releaseTime),
-			expectedKey: *buildCompleteFieldKeyMap(releaseTime)["mat.key"][0],
+			keysMap:     logstelemetryschema.BuildCompleteFieldKeyMap(releaseTime),
+			expectedKey: *logstelemetryschema.BuildCompleteFieldKeyMap(releaseTime)["mat.key"][0],
 		},
 		{
 			name: "non-materialized field",
@@ -903,16 +904,16 @@ func TestAdjustKey(t *testing.T) {
 				FieldContext:  telemetrytypes.FieldContextUnspecified,
 				FieldDataType: telemetrytypes.FieldDataTypeUnspecified,
 			},
-			keysMap:     buildCompleteFieldKeyMap(releaseTime),
-			expectedKey: *buildCompleteFieldKeyMap(releaseTime)["user.id"][0],
+			keysMap:     logstelemetryschema.BuildCompleteFieldKeyMap(releaseTime),
+			expectedKey: *logstelemetryschema.BuildCompleteFieldKeyMap(releaseTime)["user.id"][0],
 		},
 	}
 
 	fl := flaggertest.New(t)
-	fm := NewFieldMapper(fl)
+	fm := logstelemetryschema.NewFieldMapper(fl)
 	mockMetadataStore := telemetrytypestest.NewMockMetadataStore()
-	mockMetadataStore.KeysMap = buildCompleteFieldKeyMapCollision()
-	cb := NewConditionBuilder(fm, fl)
+	mockMetadataStore.KeysMap = logstelemetryschema.BuildCompleteFieldKeyMapCollision()
+	cb := logstelemetryschema.NewConditionBuilder(fm, fl)
 
 	aggExprRewriter := querybuilder.NewAggExprRewriter(instrumentationtest.New().ToProviderSettings(), nil, fm, cb, fl)
 
@@ -922,7 +923,7 @@ func TestAdjustKey(t *testing.T) {
 		fm,
 		cb,
 		aggExprRewriter,
-		DefaultFullTextColumn,
+		logstelemetryschema.DefaultFullTextColumn,
 		fl,
 		nil,
 		false,
@@ -1054,11 +1055,11 @@ func TestStmtBuilderBodyField(t *testing.T) {
 	for _, c := range cases {
 		t.Run(c.name, func(t *testing.T) {
 			fl := flaggertest.WithUseJSONBody(t, c.enableUseJSONBody)
-			fm := NewFieldMapper(fl)
-			cb := NewConditionBuilder(fm, fl)
+			fm := logstelemetryschema.NewFieldMapper(fl)
+			cb := logstelemetryschema.NewConditionBuilder(fm, fl)
 			// build the key map
 			mockMetadataStore := telemetrytypestest.NewMockMetadataStore()
-			for _, field := range IntrinsicFields {
+			for _, field := range logstelemetryschema.IntrinsicFields {
 				f := field
 				mockMetadataStore.KeysMap[field.Name] = append(mockMetadataStore.KeysMap[field.Name], &f)
 			}
@@ -1069,7 +1070,7 @@ func TestStmtBuilderBodyField(t *testing.T) {
 				fm,
 				cb,
 				aggExprRewriter,
-				DefaultFullTextColumn,
+				logstelemetryschema.DefaultFullTextColumn,
 				fl,
 				nil,
 				false,
@@ -1155,11 +1156,11 @@ func TestStmtBuilderBodyFullTextSearch(t *testing.T) {
 	for _, c := range cases {
 		t.Run(c.name, func(t *testing.T) {
 			fl := flaggertest.WithUseJSONBody(t, c.enableUseJSONBody)
-			fm := NewFieldMapper(fl)
-			cb := NewConditionBuilder(fm, fl)
+			fm := logstelemetryschema.NewFieldMapper(fl)
+			cb := logstelemetryschema.NewConditionBuilder(fm, fl)
 			// build the key map
 			mockMetadataStore := telemetrytypestest.NewMockMetadataStore()
-			for _, field := range IntrinsicFields {
+			for _, field := range logstelemetryschema.IntrinsicFields {
 				f := field
 				mockMetadataStore.KeysMap[field.Name] = append(mockMetadataStore.KeysMap[field.Name], &f)
 			}
@@ -1170,7 +1171,7 @@ func TestStmtBuilderBodyFullTextSearch(t *testing.T) {
 				fm,
 				cb,
 				aggExprRewriter,
-				DefaultFullTextColumn,
+				logstelemetryschema.DefaultFullTextColumn,
 				fl,
 				nil,
 				false,
@@ -1273,14 +1274,14 @@ func newSkipResourceFingerprintLogsBuilder(
 	t.Helper()
 
 	fl := flaggertest.New(t)
-	fm := NewFieldMapper(fl)
-	cb := NewConditionBuilder(fm, fl)
+	fm := logstelemetryschema.NewFieldMapper(fl)
+	cb := logstelemetryschema.NewConditionBuilder(fm, fl)
 	mockMetadataStore := telemetrytypestest.NewMockMetadataStore()
-	mockMetadataStore.KeysMap = buildCompleteFieldKeyMap(time.Date(2024, 1, 15, 10, 0, 0, 0, time.UTC))
+	mockMetadataStore.KeysMap = logstelemetryschema.BuildCompleteFieldKeyMap(time.Date(2024, 1, 15, 10, 0, 0, 0, time.UTC))
 
 	aggExprRewriter := querybuilder.NewAggExprRewriter(
 		instrumentationtest.New().ToProviderSettings(),
-		DefaultFullTextColumn,
+		logstelemetryschema.DefaultFullTextColumn,
 		fm,
 		cb,
 		fl,
@@ -1292,7 +1293,7 @@ func newSkipResourceFingerprintLogsBuilder(
 		fm,
 		cb,
 		aggExprRewriter,
-		DefaultFullTextColumn,
+		logstelemetryschema.DefaultFullTextColumn,
 		fl,
 		telemetryStore,
 		skipEnable,

pkg/statementbuilder/meterstatementbuilder/statement_builder.go

@@ -1,4 +1,4 @@
-package telemetrymeter
+package meterstatementbuilder
 
 import (
 	"context"
@@ -7,8 +7,12 @@ import (
 
 	"github.com/SigNoz/signoz/pkg/errors"
 	"github.com/SigNoz/signoz/pkg/factory"
+	"github.com/SigNoz/signoz/pkg/flagger"
 	"github.com/SigNoz/signoz/pkg/querybuilder"
-	"github.com/SigNoz/signoz/pkg/telemetrymetrics"
+	"github.com/SigNoz/signoz/pkg/statementbuilder"
+	"github.com/SigNoz/signoz/pkg/statementbuilder/metricsstatementbuilder"
+	"github.com/SigNoz/signoz/pkg/telemetryschema/metertelemetryschema"
+	"github.com/SigNoz/signoz/pkg/telemetryschema/metricstelemetryschema"
 	"github.com/SigNoz/signoz/pkg/types/metrictypes"
 	qbtypes "github.com/SigNoz/signoz/pkg/types/querybuildertypes/querybuildertypesv5"
 	"github.com/SigNoz/signoz/pkg/types/telemetrytypes"
@@ -21,19 +25,40 @@ type meterQueryStatementBuilder struct {
 	metadataStore           telemetrytypes.MetadataStore
 	fm                      qbtypes.FieldMapper
 	cb                      qbtypes.ConditionBuilder
-	metricsStatementBuilder *telemetrymetrics.MetricQueryStatementBuilder
+	metricsStatementBuilder *metricsstatementbuilder.StatementBuilder
 }
 
 var _ qbtypes.StatementBuilder[qbtypes.MetricAggregation] = (*meterQueryStatementBuilder)(nil)
 
+// NewFactory returns a provider factory for the meter statement builder. Its New
+// reuses the metrics FieldMapper/ConditionBuilder and delegates the final SELECT
+// to a metrics statement builder built via the metrics factory.
+func NewFactory(
+	metadataStore telemetrytypes.MetadataStore,
+	fl flagger.Flagger,
+) factory.ProviderFactory[qbtypes.StatementBuilder[qbtypes.MetricAggregation], statementbuilder.Config] {
+	return factory.NewProviderFactory(
+		factory.MustNewName("meter"),
+		func(ctx context.Context, settings factory.ProviderSettings, cfg statementbuilder.Config) (qbtypes.StatementBuilder[qbtypes.MetricAggregation], error) {
+			metricsStatementBuilder, err := metricsstatementbuilder.NewFactory(metadataStore, fl).New(ctx, settings, cfg)
+			if err != nil {
+				return nil, err
+			}
+			fm := metricstelemetryschema.NewFieldMapper()
+			cb := metricstelemetryschema.NewConditionBuilder(fm)
+			return NewMeterQueryStatementBuilder(settings, metadataStore, fm, cb, metricsStatementBuilder), nil
+		},
+	)
+}
+
 func NewMeterQueryStatementBuilder(
 	settings factory.ProviderSettings,
 	metadataStore telemetrytypes.MetadataStore,
 	fieldMapper qbtypes.FieldMapper,
 	conditionBuilder qbtypes.ConditionBuilder,
-	metricsStatementBuilder *telemetrymetrics.MetricQueryStatementBuilder,
+	metricsStatementBuilder *metricsstatementbuilder.StatementBuilder,
 ) *meterQueryStatementBuilder {
-	metricsSettings := factory.NewScopedProviderSettings(settings, "github.com/SigNoz/signoz/pkg/telemetrymeter")
+	metricsSettings := factory.NewScopedProviderSettings(settings, "github.com/SigNoz/signoz/pkg/telemetryschema/metertelemetryschema")
 
 	return &meterQueryStatementBuilder{
 		logger:                  metricsSettings.Logger(),
@@ -53,7 +78,7 @@ func (b *meterQueryStatementBuilder) Build(
 	query qbtypes.QueryBuilderQuery[qbtypes.MetricAggregation],
 	variables map[string]qbtypes.VariableItem,
 ) (*qbtypes.Statement, error) {
-	keySelectors := telemetrymetrics.GetKeySelectors(query)
+	keySelectors := metricsstatementbuilder.GetKeySelectors(query)
 	keys, _, err := b.metadataStore.GetKeysMulti(ctx, orgID, keySelectors)
 	if err != nil {
 		return nil, err
@@ -133,8 +158,8 @@ func (b *meterQueryStatementBuilder) buildTemporalAggDeltaFastPath(
 		sb.SelectMore(col)
 	}
 
-	tbl := WhichSamplesTableToUse(start, end, query.Aggregations[0].Type, query.Aggregations[0].TimeAggregation, query.Aggregations[0].TableHints)
-	aggCol, err := AggregationColumnForSamplesTable(start, end, query.Aggregations[0].Type, query.Aggregations[0].Temporality, query.Aggregations[0].TimeAggregation, query.Aggregations[0].TableHints)
+	tbl := metertelemetryschema.WhichSamplesTableToUse(start, end, query.Aggregations[0].Type, query.Aggregations[0].TimeAggregation, query.Aggregations[0].TableHints)
+	aggCol, err := metertelemetryschema.AggregationColumnForSamplesTable(start, end, query.Aggregations[0].Type, query.Aggregations[0].Temporality, query.Aggregations[0].TimeAggregation, query.Aggregations[0].TableHints)
 	if err != nil {
 		return "", nil, err
 	}
@@ -143,7 +168,7 @@ func (b *meterQueryStatementBuilder) buildTemporalAggDeltaFastPath(
 	}
 
 	sb.SelectMore(fmt.Sprintf("%s AS value", aggCol))
-	sb.From(fmt.Sprintf("%s.%s AS points", DBName, tbl))
+	sb.From(fmt.Sprintf("%s.%s AS points", metertelemetryschema.DBName, tbl))
 	sb.Where(
 		sb.In("metric_name", query.Aggregations[0].MetricName),
 		sb.GTE("unix_milli", start),
@@ -222,8 +247,8 @@ func (b *meterQueryStatementBuilder) buildTemporalAggDelta(
 		sb.SelectMore(col)
 	}
 
-	tbl := WhichSamplesTableToUse(start, end, query.Aggregations[0].Type, query.Aggregations[0].TimeAggregation, query.Aggregations[0].TableHints)
-	aggCol, err := AggregationColumnForSamplesTable(start, end, query.Aggregations[0].Type, query.Aggregations[0].Temporality,
+	tbl := metertelemetryschema.WhichSamplesTableToUse(start, end, query.Aggregations[0].Type, query.Aggregations[0].TimeAggregation, query.Aggregations[0].TableHints)
+	aggCol, err := metertelemetryschema.AggregationColumnForSamplesTable(start, end, query.Aggregations[0].Type, query.Aggregations[0].Temporality,
 		query.Aggregations[0].TimeAggregation, query.Aggregations[0].TableHints)
 	if err != nil {
 		return "", nil, err
@@ -234,7 +259,7 @@ func (b *meterQueryStatementBuilder) buildTemporalAggDelta(
 
 	sb.SelectMore(fmt.Sprintf("%s AS per_series_value", aggCol))
 
-	sb.From(fmt.Sprintf("%s.%s AS points", DBName, tbl))
+	sb.From(fmt.Sprintf("%s.%s AS points", metertelemetryschema.DBName, tbl))
 	sb.Where(
 		sb.In("metric_name", query.Aggregations[0].MetricName),
 		sb.GTE("unix_milli", start),
@@ -300,14 +325,14 @@ func (b *meterQueryStatementBuilder) buildTemporalAggCumulativeOrUnspecified(
 		baseSb.SelectMore(col)
 	}
 
-	tbl := WhichSamplesTableToUse(start, end, query.Aggregations[0].Type, query.Aggregations[0].TimeAggregation, query.Aggregations[0].TableHints)
-	aggCol, err := AggregationColumnForSamplesTable(start, end, query.Aggregations[0].Type, query.Aggregations[0].Temporality, query.Aggregations[0].TimeAggregation, query.Aggregations[0].TableHints)
+	tbl := metertelemetryschema.WhichSamplesTableToUse(start, end, query.Aggregations[0].Type, query.Aggregations[0].TimeAggregation, query.Aggregations[0].TableHints)
+	aggCol, err := metertelemetryschema.AggregationColumnForSamplesTable(start, end, query.Aggregations[0].Type, query.Aggregations[0].Temporality, query.Aggregations[0].TimeAggregation, query.Aggregations[0].TableHints)
 	if err != nil {
 		return "", nil, err
 	}
 	baseSb.SelectMore(fmt.Sprintf("%s AS per_series_value", aggCol))
 
-	baseSb.From(fmt.Sprintf("%s.%s AS points", DBName, tbl))
+	baseSb.From(fmt.Sprintf("%s.%s AS points", metertelemetryschema.DBName, tbl))
 	baseSb.Where(
 		baseSb.In("metric_name", query.Aggregations[0].MetricName),
 		baseSb.GTE("unix_milli", start),
@@ -350,7 +375,7 @@ func (b *meterQueryStatementBuilder) buildTemporalAggCumulativeOrUnspecified(
 		for _, g := range query.GroupBy {
 			wrapped.SelectMore(fmt.Sprintf("`%s`", g.Name))
 		}
-		wrapped.SelectMore(fmt.Sprintf("%s AS per_series_value", telemetrymetrics.RateTmpl))
+		wrapped.SelectMore(fmt.Sprintf("%s AS per_series_value", metricsstatementbuilder.RateTmpl))
 		wrapped.From(fmt.Sprintf("(%s) WINDOW rate_window AS (PARTITION BY fingerprint ORDER BY fingerprint, ts)", innerQuery))
 		q, args := wrapped.BuildWithFlavor(sqlbuilder.ClickHouse, innerArgs...)
 		return fmt.Sprintf("__temporal_aggregation_cte AS (%s)", q), args, nil
@@ -361,7 +386,7 @@ func (b *meterQueryStatementBuilder) buildTemporalAggCumulativeOrUnspecified(
 		for _, g := range query.GroupBy {
 			wrapped.SelectMore(fmt.Sprintf("`%s`", g.Name))
 		}
-		wrapped.SelectMore(fmt.Sprintf("%s AS per_series_value", telemetrymetrics.IncreaseTmpl))
+		wrapped.SelectMore(fmt.Sprintf("%s AS per_series_value", metricsstatementbuilder.IncreaseTmpl))
 		wrapped.From(fmt.Sprintf("(%s) WINDOW rate_window AS (PARTITION BY fingerprint ORDER BY fingerprint, ts)", innerQuery))
 		q, args := wrapped.BuildWithFlavor(sqlbuilder.ClickHouse, innerArgs...)
 		return fmt.Sprintf("__temporal_aggregation_cte AS (%s)", q), args, nil

pkg/statementbuilder/meterstatementbuilder/stmt_builder_test.go

@@ -1,4 +1,4 @@
-package telemetrymeter
+package meterstatementbuilder
 
 import (
 	"context"
@@ -7,7 +7,8 @@ import (
 
 	"github.com/SigNoz/signoz/pkg/flagger/flaggertest"
 	"github.com/SigNoz/signoz/pkg/instrumentation/instrumentationtest"
-	"github.com/SigNoz/signoz/pkg/telemetrymetrics"
+	"github.com/SigNoz/signoz/pkg/statementbuilder/metricsstatementbuilder"
+	"github.com/SigNoz/signoz/pkg/telemetryschema/metricstelemetryschema"
 	"github.com/SigNoz/signoz/pkg/types/metrictypes"
 	qbtypes "github.com/SigNoz/signoz/pkg/types/querybuildertypes/querybuildertypesv5"
 	"github.com/SigNoz/signoz/pkg/types/telemetrytypes"
@@ -158,8 +159,8 @@ func TestStatementBuilder(t *testing.T) {
 		},
 	}
 
-	fm := telemetrymetrics.NewFieldMapper()
-	cb := telemetrymetrics.NewConditionBuilder(fm)
+	fm := metricstelemetryschema.NewFieldMapper()
+	cb := metricstelemetryschema.NewConditionBuilder(fm)
 	mockMetadataStore := telemetrytypestest.NewMockMetadataStore()
 	keys, err := telemetrytypestest.LoadFieldKeysFromJSON("testdata/keys_map.json")
 	if err != nil {
@@ -169,7 +170,7 @@ func TestStatementBuilder(t *testing.T) {
 
 	flagger := flaggertest.New(t)
 
-	metricStmtBuilder := telemetrymetrics.NewMetricQueryStatementBuilder(instrumentationtest.New().ToProviderSettings(), mockMetadataStore, fm, cb, flagger)
+	metricStmtBuilder := metricsstatementbuilder.NewMetricQueryStatementBuilder(instrumentationtest.New().ToProviderSettings(), mockMetadataStore, fm, cb, flagger)
 
 	statementBuilder := NewMeterQueryStatementBuilder(
 		instrumentationtest.New().ToProviderSettings(),

pkg/statementbuilder/metricsstatementbuilder/reduced_test.go

@@ -1,4 +1,4 @@
-package telemetrymetrics
+package metricsstatementbuilder
 
 import (
 	"context"
@@ -7,6 +7,7 @@ import (
 
 	"github.com/SigNoz/signoz/pkg/flagger"
 	"github.com/SigNoz/signoz/pkg/instrumentation/instrumentationtest"
+	"github.com/SigNoz/signoz/pkg/telemetryschema/metricstelemetryschema"
 	"github.com/SigNoz/signoz/pkg/types/metrictypes"
 	qbtypes "github.com/SigNoz/signoz/pkg/types/querybuildertypes/querybuildertypesv5"
 	"github.com/SigNoz/signoz/pkg/types/telemetrytypes"
@@ -118,8 +119,8 @@ func TestReducedStatementBuilder(t *testing.T) {
 		},
 	}
 
-	fm := NewFieldMapper()
-	cb := NewConditionBuilder(fm)
+	fm := metricstelemetryschema.NewFieldMapper()
+	cb := metricstelemetryschema.NewConditionBuilder(fm)
 	fl, err := flagger.New(context.Background(), instrumentationtest.New().ToProviderSettings(), flagger.Config{}, flagger.MustNewRegistry())
 	require.NoError(t, err)
 	sb := NewMetricQueryStatementBuilder(instrumentationtest.New().ToProviderSettings(), telemetrytypestest.NewMockMetadataStore(), fm, cb, fl)

pkg/statementbuilder/metricsstatementbuilder/statement_builder.go

@@ -1,4 +1,4 @@
-package telemetrymetrics
+package metricsstatementbuilder
 
 import (
 	"context"
@@ -9,6 +9,8 @@ import (
 	"github.com/SigNoz/signoz/pkg/factory"
 	"github.com/SigNoz/signoz/pkg/flagger"
 	"github.com/SigNoz/signoz/pkg/querybuilder"
+	"github.com/SigNoz/signoz/pkg/statementbuilder"
+	"github.com/SigNoz/signoz/pkg/telemetryschema/metricstelemetryschema"
 	"github.com/SigNoz/signoz/pkg/types/metrictypes"
 	qbtypes "github.com/SigNoz/signoz/pkg/types/querybuildertypes/querybuildertypesv5"
 	"github.com/SigNoz/signoz/pkg/types/telemetrytypes"
@@ -29,7 +31,7 @@ const (
 	OthersMultiTemporality = `IF(LOWER(temporality) LIKE LOWER('delta'), %s, %s) AS per_series_value`
 )
 
-type MetricQueryStatementBuilder struct {
+type StatementBuilder struct {
 	logger        *slog.Logger
 	metadataStore telemetrytypes.MetadataStore
 	fm            qbtypes.FieldMapper
@@ -37,7 +39,24 @@ type MetricQueryStatementBuilder struct {
 	flagger       flagger.Flagger
 }
 
-var _ qbtypes.StatementBuilder[qbtypes.MetricAggregation] = (*MetricQueryStatementBuilder)(nil)
+var _ qbtypes.StatementBuilder[qbtypes.MetricAggregation] = (*StatementBuilder)(nil)
+
+// NewFactory returns a provider factory for the metrics statement builder. Its
+// New internalizes the FieldMapper and ConditionBuilder and yields the concrete
+// *StatementBuilder so the meter builder can reuse it.
+func NewFactory(
+	metadataStore telemetrytypes.MetadataStore,
+	fl flagger.Flagger,
+) factory.ProviderFactory[*StatementBuilder, statementbuilder.Config] {
+	return factory.NewProviderFactory(
+		factory.MustNewName("metrics"),
+		func(_ context.Context, settings factory.ProviderSettings, _ statementbuilder.Config) (*StatementBuilder, error) {
+			fm := metricstelemetryschema.NewFieldMapper()
+			cb := metricstelemetryschema.NewConditionBuilder(fm)
+			return NewMetricQueryStatementBuilder(settings, metadataStore, fm, cb, fl), nil
+		},
+	)
+}
 
 func NewMetricQueryStatementBuilder(
 	settings factory.ProviderSettings,
@@ -45,9 +64,9 @@ func NewMetricQueryStatementBuilder(
 	fieldMapper qbtypes.FieldMapper,
 	conditionBuilder qbtypes.ConditionBuilder,
 	flagger flagger.Flagger,
-) *MetricQueryStatementBuilder {
-	metricsSettings := factory.NewScopedProviderSettings(settings, "github.com/SigNoz/signoz/pkg/telemetrymetrics")
-	return &MetricQueryStatementBuilder{
+) *StatementBuilder {
+	metricsSettings := factory.NewScopedProviderSettings(settings, "github.com/SigNoz/signoz/pkg/telemetryschema/metricstelemetryschema")
+	return &StatementBuilder{
 		logger:        metricsSettings.Logger(),
 		metadataStore: metadataStore,
 		fm:            fieldMapper,
@@ -89,7 +108,7 @@ func GetKeySelectors(query qbtypes.QueryBuilderQuery[qbtypes.MetricAggregation])
 	return keySelectors
 }
 
-func (b *MetricQueryStatementBuilder) Build(
+func (b *StatementBuilder) Build(
 	ctx context.Context,
 	orgID valuer.UUID,
 	start uint64,
@@ -126,7 +145,7 @@ func (b *MetricQueryStatementBuilder) Build(
 	return b.buildPipelineStatement(ctx, orgID, start, end, query, keys, variables)
 }
 
-func (b *MetricQueryStatementBuilder) buildPipelineStatement(
+func (b *StatementBuilder) buildPipelineStatement(
 	ctx context.Context,
 	orgID valuer.UUID,
 	start, end uint64,
@@ -188,11 +207,11 @@ func (b *MetricQueryStatementBuilder) buildPipelineStatement(
 	// shaped exactly like samples_v4 / time_series_v4, so once the table names are
 	// chosen the rest of the pipeline is unchanged.
 	useBuffer := agg.Reduced &&
-		end-start < oneDayInMilliseconds &&
-		start >= uint64(time.Now().UnixMilli())-oneDayInMilliseconds
+		end-start < metricstelemetryschema.OneDayInMilliseconds &&
+		start >= uint64(time.Now().UnixMilli())-metricstelemetryschema.OneDayInMilliseconds
 
-	samplesTable, _ := WhichSamplesTableToUse(start, end, agg.Type, agg.TimeAggregation, useBuffer, agg.TableHints)
-	tsStart, tsEnd, _, tsTable := WhichTSTableToUse(start, end, useBuffer, agg.TableHints)
+	samplesTable, _ := metricstelemetryschema.WhichSamplesTableToUse(start, end, agg.Type, agg.TimeAggregation, useBuffer, agg.TableHints)
+	tsStart, tsEnd, _, tsTable := metricstelemetryschema.WhichTSTableToUse(start, end, useBuffer, agg.TableHints)
 
 	var timeSeriesCTE string
 	var timeSeriesCTEArgs []any
@@ -232,7 +251,7 @@ func (b *MetricQueryStatementBuilder) buildPipelineStatement(
 		var tsCTE string
 		var tsArgs []any
 		// time series rows are written on hour boundaries
-		tsStart := start - (start % oneHourInMilliseconds)
+		tsStart := start - (start % metricstelemetryschema.OneHourInMilliseconds)
 		if tsCTE, tsArgs, err = b.buildReducedTimeSeriesCTE(ctx, orgID, tsStart, end, query, keys, variables); err != nil {
 			return nil, err
 		}
@@ -282,7 +301,7 @@ func unionStatements(main, reduced *qbtypes.Statement, query qbtypes.QueryBuilde
 	return &qbtypes.Statement{Query: q, Args: args, Warnings: warnings}, nil
 }
 
-func (b *MetricQueryStatementBuilder) buildReducedTimeSeriesCTE(
+func (b *StatementBuilder) buildReducedTimeSeriesCTE(
 	ctx context.Context,
 	orgID valuer.UUID,
 	start, end uint64,
@@ -312,7 +331,7 @@ func (b *MetricQueryStatementBuilder) buildReducedTimeSeriesCTE(
 		}
 	}
 
-	sb.From(fmt.Sprintf("%s.%s", DBName, TimeseriesV4ReducedLocalTableName))
+	sb.From(fmt.Sprintf("%s.%s", metricstelemetryschema.DBName, metricstelemetryschema.TimeseriesV4ReducedLocalTableName))
 	sb.Select("fingerprint")
 	for _, g := range query.GroupBy {
 		col, err := b.fm.ColumnExpressionFor(ctx, orgID, start, end, &g.TelemetryFieldKey, telemetrytypes.FieldDataTypeString, keys)
@@ -343,7 +362,7 @@ func (b *MetricQueryStatementBuilder) buildReducedTimeSeriesCTE(
 // spatial_aggregation_cte in one level with no per-series grouping, so shards
 // send one state per (step, group) instead of per (series, step, group).
 // FINAL still dedups recomputed 60s buckets at scan time.
-func (b *MetricQueryStatementBuilder) buildReducedSpatialAggFastPath(
+func (b *StatementBuilder) buildReducedSpatialAggFastPath(
 	start, end uint64,
 	query qbtypes.QueryBuilderQuery[qbtypes.MetricAggregation],
 	timeSeriesCTE string,
@@ -352,7 +371,7 @@ func (b *MetricQueryStatementBuilder) buildReducedSpatialAggFastPath(
 	agg := query.Aggregations[0]
 	stepSec := int64(query.StepInterval.Seconds())
 
-	value, _, ok := ReducedValueColumn(agg.Type, agg.SpaceAggregation)
+	value, _, ok := metricstelemetryschema.ReducedValueColumn(agg.Type, agg.SpaceAggregation)
 	if !ok {
 		return "", nil, false
 	}
@@ -362,8 +381,8 @@ func (b *MetricQueryStatementBuilder) buildReducedSpatialAggFastPath(
 	for _, g := range query.GroupBy {
 		sb.SelectMore(fmt.Sprintf("`%s`", g.Name))
 	}
-	sb.SelectMore(fmt.Sprintf("%s AS value", ReducedTimeAggregationColumn(agg.TimeAggregation, stepSec, value)))
-	sb.From(fmt.Sprintf("%s.%s AS points FINAL", DBName, WhichReducedSamplesTableToUse(agg.Type)))
+	sb.SelectMore(fmt.Sprintf("%s AS value", metricstelemetryschema.ReducedTimeAggregationColumn(agg.TimeAggregation, stepSec, value)))
+	sb.From(fmt.Sprintf("%s.%s AS points FINAL", metricstelemetryschema.DBName, metricstelemetryschema.WhichReducedSamplesTableToUse(agg.Type)))
 	sb.JoinWithOption(sqlbuilder.InnerJoin, timeSeriesCTE, "points.reduced_fingerprint = filtered_time_series.fingerprint")
 	sb.Where(
 		sb.In("metric_name", agg.MetricName),
@@ -377,7 +396,7 @@ func (b *MetricQueryStatementBuilder) buildReducedSpatialAggFastPath(
 	return fmt.Sprintf("__spatial_aggregation_cte AS (%s)", q), args, true
 }
 
-func (b *MetricQueryStatementBuilder) buildReducedTemporalAggregationCTE(
+func (b *StatementBuilder) buildReducedTemporalAggregationCTE(
 	start, end uint64,
 	query qbtypes.QueryBuilderQuery[qbtypes.MetricAggregation],
 	timeSeriesCTE string,
@@ -386,7 +405,7 @@ func (b *MetricQueryStatementBuilder) buildReducedTemporalAggregationCTE(
 	agg := query.Aggregations[0]
 	stepSec := int64(query.StepInterval.Seconds())
 
-	value, weight, ok := ReducedValueColumn(agg.Type, agg.SpaceAggregation)
+	value, weight, ok := metricstelemetryschema.ReducedValueColumn(agg.Type, agg.SpaceAggregation)
 	if !ok {
 		return "", nil, false
 	}
@@ -399,13 +418,13 @@ func (b *MetricQueryStatementBuilder) buildReducedTemporalAggregationCTE(
 	for _, g := range query.GroupBy {
 		sb.SelectMore(fmt.Sprintf("`%s`", g.Name))
 	}
-	sb.SelectMore(fmt.Sprintf("%s AS per_series_value", ReducedTimeAggregationColumn(agg.TimeAggregation, stepSec, value)))
+	sb.SelectMore(fmt.Sprintf("%s AS per_series_value", metricstelemetryschema.ReducedTimeAggregationColumn(agg.TimeAggregation, stepSec, value)))
 	if weight != "" {
 		// count_series is a series count, not additive over time, so the avg
 		// denominator is reduced with avg
 		sb.SelectMore(fmt.Sprintf("avg(%s) AS per_series_weight", weight))
 	}
-	sb.From(fmt.Sprintf("%s.%s AS points FINAL", DBName, WhichReducedSamplesTableToUse(agg.Type)))
+	sb.From(fmt.Sprintf("%s.%s AS points FINAL", metricstelemetryschema.DBName, metricstelemetryschema.WhichReducedSamplesTableToUse(agg.Type)))
 	sb.JoinWithOption(sqlbuilder.InnerJoin, timeSeriesCTE, "points.reduced_fingerprint = filtered_time_series.fingerprint")
 	sb.Where(
 		sb.In("metric_name", agg.MetricName),
@@ -419,7 +438,7 @@ func (b *MetricQueryStatementBuilder) buildReducedTemporalAggregationCTE(
 	return fmt.Sprintf("__temporal_aggregation_cte AS (%s)", q), args, true
 }
 
-func (b *MetricQueryStatementBuilder) buildReducedSpatialAggregationCTE(
+func (b *StatementBuilder) buildReducedSpatialAggregationCTE(
 	query qbtypes.QueryBuilderQuery[qbtypes.MetricAggregation],
 ) (string, []any) {
 	spatial := "sum(per_series_value)"
@@ -446,7 +465,7 @@ func (b *MetricQueryStatementBuilder) buildReducedSpatialAggregationCTE(
 	return fmt.Sprintf("__spatial_aggregation_cte AS (%s)", q), args
 }
 
-func (b *MetricQueryStatementBuilder) buildTemporalAggDeltaFastPath(
+func (b *StatementBuilder) buildTemporalAggDeltaFastPath(
 	start, end uint64,
 	query qbtypes.QueryBuilderQuery[qbtypes.MetricAggregation],
 	samplesTable string,
@@ -465,7 +484,7 @@ func (b *MetricQueryStatementBuilder) buildTemporalAggDeltaFastPath(
 		sb.SelectMore(fmt.Sprintf("`%s`", g.Name))
 	}
 
-	aggCol, err := AggregationColumnForSamplesTable(
+	aggCol, err := metricstelemetryschema.AggregationColumnForSamplesTable(
 		samplesTable, query.Aggregations[0].Temporality, query.Aggregations[0].TimeAggregation,
 	)
 	if err != nil {
@@ -483,7 +502,7 @@ func (b *MetricQueryStatementBuilder) buildTemporalAggDeltaFastPath(
 
 	sb.SelectMore(fmt.Sprintf("%s AS value", aggCol))
 
-	sb.From(fmt.Sprintf("%s.%s AS points", DBName, samplesTable))
+	sb.From(fmt.Sprintf("%s.%s AS points", metricstelemetryschema.DBName, samplesTable))
 	sb.JoinWithOption(sqlbuilder.InnerJoin, timeSeriesCTE, "points.fingerprint = filtered_time_series.fingerprint")
 	sb.Where(
 		sb.In("metric_name", query.Aggregations[0].MetricName),
@@ -497,7 +516,7 @@ func (b *MetricQueryStatementBuilder) buildTemporalAggDeltaFastPath(
 	return fmt.Sprintf("__spatial_aggregation_cte AS (%s)", q), args, nil
 }
 
-func (b *MetricQueryStatementBuilder) buildTimeSeriesCTE(
+func (b *StatementBuilder) buildTimeSeriesCTE(
 	ctx context.Context,
 	orgID valuer.UUID,
 	start, end uint64,
@@ -529,7 +548,7 @@ func (b *MetricQueryStatementBuilder) buildTimeSeriesCTE(
 		}
 	}
 
-	sb.From(fmt.Sprintf("%s.%s", DBName, tsTable))
+	sb.From(fmt.Sprintf("%s.%s", metricstelemetryschema.DBName, tsTable))
 
 	sb.Select("fingerprint")
 	for _, g := range query.GroupBy {
@@ -552,7 +571,7 @@ func (b *MetricQueryStatementBuilder) buildTimeSeriesCTE(
 
 	// the buffer holds both raw rows and the reduced catalog rows; the raw read
 	// only wants the original series
-	if tsTable == TimeseriesV4BufferLocalTableName {
+	if tsTable == metricstelemetryschema.TimeseriesV4BufferLocalTableName {
 		sb.Where(sb.EQ("is_reduced", false))
 	}
 
@@ -567,7 +586,7 @@ func (b *MetricQueryStatementBuilder) buildTimeSeriesCTE(
 	return fmt.Sprintf("(%s) AS filtered_time_series", q), args, nil
 }
 
-func (b *MetricQueryStatementBuilder) buildTemporalAggregationCTE(
+func (b *StatementBuilder) buildTemporalAggregationCTE(
 	ctx context.Context,
 	start, end uint64,
 	query qbtypes.QueryBuilderQuery[qbtypes.MetricAggregation],
@@ -584,7 +603,7 @@ func (b *MetricQueryStatementBuilder) buildTemporalAggregationCTE(
 	return b.buildTemporalAggForMultipleTemporalities(ctx, start, end, query, samplesTable, timeSeriesCTE, timeSeriesCTEArgs)
 }
 
-func (b *MetricQueryStatementBuilder) buildTemporalAggDelta(
+func (b *StatementBuilder) buildTemporalAggDelta(
 	_ context.Context,
 	start, end uint64,
 	query qbtypes.QueryBuilderQuery[qbtypes.MetricAggregation],
@@ -605,7 +624,7 @@ func (b *MetricQueryStatementBuilder) buildTemporalAggDelta(
 		sb.SelectMore(fmt.Sprintf("`%s`", g.Name))
 	}
 
-	aggCol, err := AggregationColumnForSamplesTable(samplesTable, query.Aggregations[0].Temporality, query.Aggregations[0].TimeAggregation)
+	aggCol, err := metricstelemetryschema.AggregationColumnForSamplesTable(samplesTable, query.Aggregations[0].Temporality, query.Aggregations[0].TimeAggregation)
 	if err != nil {
 		return "", nil, err
 	}
@@ -616,7 +635,7 @@ func (b *MetricQueryStatementBuilder) buildTemporalAggDelta(
 
 	sb.SelectMore(fmt.Sprintf("%s AS per_series_value", aggCol))
 
-	sb.From(fmt.Sprintf("%s.%s AS points", DBName, samplesTable))
+	sb.From(fmt.Sprintf("%s.%s AS points", metricstelemetryschema.DBName, samplesTable))
 	sb.JoinWithOption(sqlbuilder.InnerJoin, timeSeriesCTE, "points.fingerprint = filtered_time_series.fingerprint")
 	sb.Where(
 		sb.In("metric_name", query.Aggregations[0].MetricName),
@@ -631,7 +650,7 @@ func (b *MetricQueryStatementBuilder) buildTemporalAggDelta(
 	return fmt.Sprintf("__temporal_aggregation_cte AS (%s)", q), args, nil
 }
 
-func (b *MetricQueryStatementBuilder) buildTemporalAggCumulativeOrUnspecified(
+func (b *StatementBuilder) buildTemporalAggCumulativeOrUnspecified(
 	_ context.Context,
 	start, end uint64,
 	query qbtypes.QueryBuilderQuery[qbtypes.MetricAggregation],
@@ -651,13 +670,13 @@ func (b *MetricQueryStatementBuilder) buildTemporalAggCumulativeOrUnspecified(
 		baseSb.SelectMore(fmt.Sprintf("`%s`", g.Name))
 	}
 
-	aggCol, err := AggregationColumnForSamplesTable(samplesTable, query.Aggregations[0].Temporality, query.Aggregations[0].TimeAggregation)
+	aggCol, err := metricstelemetryschema.AggregationColumnForSamplesTable(samplesTable, query.Aggregations[0].Temporality, query.Aggregations[0].TimeAggregation)
 	if err != nil {
 		return "", nil, err
 	}
 	baseSb.SelectMore(fmt.Sprintf("%s AS per_series_value", aggCol))
 
-	baseSb.From(fmt.Sprintf("%s.%s AS points", DBName, samplesTable))
+	baseSb.From(fmt.Sprintf("%s.%s AS points", metricstelemetryschema.DBName, samplesTable))
 	baseSb.JoinWithOption(sqlbuilder.InnerJoin, timeSeriesCTE, "points.fingerprint = filtered_time_series.fingerprint")
 	baseSb.Where(
 		baseSb.In("metric_name", query.Aggregations[0].MetricName),
@@ -697,7 +716,7 @@ func (b *MetricQueryStatementBuilder) buildTemporalAggCumulativeOrUnspecified(
 	}
 }
 
-func (b *MetricQueryStatementBuilder) buildTemporalAggForMultipleTemporalities(
+func (b *StatementBuilder) buildTemporalAggForMultipleTemporalities(
 	_ context.Context,
 	start, end uint64,
 	query qbtypes.QueryBuilderQuery[qbtypes.MetricAggregation],
@@ -716,11 +735,11 @@ func (b *MetricQueryStatementBuilder) buildTemporalAggForMultipleTemporalities(
 		sb.SelectMore(fmt.Sprintf("`%s`", g.Name))
 	}
 
-	aggForDeltaTemporality, err := AggregationColumnForSamplesTable(samplesTable, metrictypes.Delta, query.Aggregations[0].TimeAggregation)
+	aggForDeltaTemporality, err := metricstelemetryschema.AggregationColumnForSamplesTable(samplesTable, metrictypes.Delta, query.Aggregations[0].TimeAggregation)
 	if err != nil {
 		return "", nil, err
 	}
-	aggForCumulativeTemporality, err := AggregationColumnForSamplesTable(samplesTable, metrictypes.Cumulative, query.Aggregations[0].TimeAggregation)
+	aggForCumulativeTemporality, err := metricstelemetryschema.AggregationColumnForSamplesTable(samplesTable, metrictypes.Cumulative, query.Aggregations[0].TimeAggregation)
 	if err != nil {
 		return "", nil, err
 	}
@@ -748,7 +767,7 @@ func (b *MetricQueryStatementBuilder) buildTemporalAggForMultipleTemporalities(
 		sb.SelectMore(expr)
 	}
 
-	sb.From(fmt.Sprintf("%s.%s AS points", DBName, samplesTable))
+	sb.From(fmt.Sprintf("%s.%s AS points", metricstelemetryschema.DBName, samplesTable))
 	sb.JoinWithOption(sqlbuilder.InnerJoin, timeSeriesCTE, "points.fingerprint = filtered_time_series.fingerprint")
 	sb.Where(
 		sb.In("metric_name", query.Aggregations[0].MetricName),
@@ -762,7 +781,7 @@ func (b *MetricQueryStatementBuilder) buildTemporalAggForMultipleTemporalities(
 	return fmt.Sprintf("__temporal_aggregation_cte AS (%s)", queryWithWindowAndOrder), args, nil
 }
 
-func (b *MetricQueryStatementBuilder) buildSpatialAggregationCTE(
+func (b *StatementBuilder) buildSpatialAggregationCTE(
 	_ context.Context,
 	_ uint64,
 	_ uint64,
@@ -788,7 +807,7 @@ func (b *MetricQueryStatementBuilder) buildSpatialAggregationCTE(
 	return fmt.Sprintf("__spatial_aggregation_cte AS (%s)", q), args
 }
 
-func (b *MetricQueryStatementBuilder) BuildFinalSelect(
+func (b *StatementBuilder) BuildFinalSelect(
 	cteFragments []string,
 	cteArgs [][]any,
 	query qbtypes.QueryBuilderQuery[qbtypes.MetricAggregation],
@@ -833,7 +852,7 @@ func (b *MetricQueryStatementBuilder) BuildFinalSelect(
 			sb.SelectMore(fmt.Sprintf("`%s`", g.Name))
 		}
 
-		aggQuery, err := AggregationQueryForHistogramCountWithParams(query.Aggregations[0].ComparisonSpaceAggregationParam)
+		aggQuery, err := metricstelemetryschema.AggregationQueryForHistogramCountWithParams(query.Aggregations[0].ComparisonSpaceAggregationParam)
 		if err != nil {
 			return nil, err
 		}

pkg/statementbuilder/metricsstatementbuilder/stmt_builder_test.go

@@ -1,4 +1,4 @@
-package telemetrymetrics
+package metricsstatementbuilder
 
 import (
 	"context"
@@ -7,6 +7,7 @@ import (
 
 	"github.com/SigNoz/signoz/pkg/flagger"
 	"github.com/SigNoz/signoz/pkg/instrumentation/instrumentationtest"
+	"github.com/SigNoz/signoz/pkg/telemetryschema/metricstelemetryschema"
 	"github.com/SigNoz/signoz/pkg/types/metrictypes"
 	qbtypes "github.com/SigNoz/signoz/pkg/types/querybuildertypes/querybuildertypesv5"
 	"github.com/SigNoz/signoz/pkg/types/telemetrytypes"
@@ -252,8 +253,8 @@ func TestStatementBuilder(t *testing.T) {
 		},
 	}
 
-	fm := NewFieldMapper()
-	cb := NewConditionBuilder(fm)
+	fm := metricstelemetryschema.NewFieldMapper()
+	cb := metricstelemetryschema.NewConditionBuilder(fm)
 	mockMetadataStore := telemetrytypestest.NewMockMetadataStore()
 	keys, err := telemetrytypestest.LoadFieldKeysFromJSON("testdata/keys_map.json")
 	if err != nil {